Mirror of https://github.com/roostorg/osprey
github.com/roostorg/osprey
remove label service proto and smite ref in coordinator (#61)
+37
-276
-5
osprey_coordinator/build.rs
-5
osprey_coordinator/build.rs
-2
osprey_coordinator/src/discovery/mod.rs
-2
osprey_coordinator/src/discovery/mod.rs
-2
osprey_coordinator/src/discovery/watcher.rs
-2
osprey_coordinator/src/discovery/watcher.rs
···
1
-
use crate::backoff_utils::{AsyncBackoff, Config as BackoffConfig};
2
1
use crate::discovery::error::DiscoveryError;
3
2
use crate::discovery::ring::{Config as RingConfig, Ring, DEFAULT_NUM_REPLICAS};
4
3
use crate::discovery::service::ServiceRegistration;
5
4
use crate::etcd::{Action, Client, Node, WatchEvent, Watcher};
6
-
use crate::tokio_utils::{AbortOnDrop, UnboundedReceiverChunker};
7
5
use anyhow::Result;
8
6
use arc_swap::ArcSwap;
9
7
use indexmap::IndexMap;
-1
osprey_coordinator/src/etcd_config/mod.rs
-1
osprey_coordinator/src/etcd_config/mod.rs
+1
-2
osprey_coordinator/src/etcd_watcherd/mod.rs
+1
-2
osprey_coordinator/src/etcd_watcherd/mod.rs
···
7
7
pub mod rpc;
8
8
mod stats;
9
9
10
-
pub use self::api::{WatchHandle, Watcher, WatcherEvents};
11
-
pub use self::metrics::{WatcherMetrics, WatcherMetricsGuard};
10
+
pub use self::api::{WatchHandle, Watcher};
12
11
pub use self::watcher_impl::{
13
12
key_watcher::KeyWatchEvents, recursive_key_watcher::RecursiveKeyWatchEvents,
14
13
};
-6
osprey_coordinator/src/etcd_watcherd/rpc/mod.rs
-6
osprey_coordinator/src/etcd_watcherd/rpc/mod.rs
+1
-1
osprey_coordinator/src/gcloud/kms.rs
+1
-1
osprey_coordinator/src/gcloud/kms.rs
-75
osprey_coordinator/src/label_service_client.rs
-75
osprey_coordinator/src/label_service_client.rs
···
1
-
use crate::pigeon::grpc_client::GrpcClient;
2
-
use crate::pigeon::Connector;
3
-
4
-
use crate::round_robin;
5
-
use anyhow::Result;
6
-
use tonic::transport::{Channel, Endpoint, Error as TonicError};
7
-
8
-
use crate::proto::label_service_client::LabelServiceClient as LabelServiceClientProto;
9
-
use crate::proto::{Entity, EntityKey, GetEntityRequest, GetEntityResponse};
10
-
11
-
use futures::future::try_join_all;
12
-
use futures::future::{BoxFuture, FutureExt};
13
-
14
-
pub struct LabelServiceClient {
15
-
rpc_client: GrpcClient<LabelServiceClientProto<Channel>>,
16
-
}
17
-
18
-
impl LabelServiceClient {
19
-
pub async fn new() -> Result<LabelServiceClient> {
20
-
let rpc_client = GrpcClient::<LabelServiceClientProto<Channel>>::new(
21
-
"label_service_client".into(),
22
-
"discord_smite_labels".into(),
23
-
2,
24
-
Some("smite_coordinator"),
25
-
)
26
-
.await?;
27
-
Ok(LabelServiceClient { rpc_client })
28
-
}
29
-
30
-
pub async fn get_entities(&self, entities: Vec<EntityKey>) -> Result<Vec<Entity>> {
31
-
let requests: Vec<_> = entities
32
-
.into_iter()
33
-
.map(|entity_key| GetEntityRequest {
34
-
// the routing key is only important client-side ^^
35
-
routing_key: "meow".to_string(),
36
-
key: Some(entity_key),
37
-
})
38
-
.collect();
39
-
40
-
let mut futures: Vec<BoxFuture<Result<GetEntityResponse, tonic::Status>>> =
41
-
Vec::with_capacity(8);
42
-
43
-
for request in requests {
44
-
let future: BoxFuture<Result<GetEntityResponse, tonic::Status>> =
45
-
round_robin!(self.rpc_client, get_entity, request).boxed();
46
-
futures.push(future);
47
-
}
48
-
49
-
let get_entity_results: Vec<GetEntityResponse> = try_join_all(futures).await?;
50
-
51
-
Ok(get_entity_results
52
-
.into_iter()
53
-
.filter_map(|get_entity_response| get_entity_response.entity)
54
-
.collect())
55
-
}
56
-
}
57
-
58
-
#[tonic::async_trait]
59
-
impl Connector for LabelServiceClientProto<Channel> {
60
-
async fn connect(dst: Endpoint) -> Result<Self, TonicError> {
61
-
let svc = Self::connect(dst)
62
-
.await?
63
-
.max_decoding_message_size(20 * 1024 * 1024)
64
-
.max_encoding_message_size(20 * 1024 * 1024);
65
-
66
-
Ok(svc)
67
-
}
68
-
fn connect_lazy(dst: Endpoint) -> Self {
69
-
let channel = dst.connect_lazy();
70
-
71
-
Self::new(channel)
72
-
.max_decoding_message_size(20 * 1024 * 1024)
73
-
.max_encoding_message_size(20 * 1024 * 1024)
74
-
}
75
-
}
+10
-17
osprey_coordinator/src/main.rs
+10
-17
osprey_coordinator/src/main.rs
···
8
8
mod future_utils;
9
9
mod gcloud;
10
10
mod hashring;
11
-
mod label_service_client;
12
11
mod metrics;
13
12
mod osprey_bidirectional_stream;
14
13
mod pigeon;
···
29
28
use std::sync::Arc;
30
29
use std::time::Duration;
31
30
31
+
use crate::coordinator_metrics::OspreyCoordinatorMetrics;
32
32
use crate::snowflake_client::SnowflakeClient;
33
-
use crate::{
34
-
coordinator_metrics::OspreyCoordinatorMetrics, label_service_client::LabelServiceClient,
35
-
};
36
33
37
34
use crate::metrics::emit_worker::SpawnEmitWorker;
38
35
use crate::metrics::new_client;
···
50
47
short,
51
48
long,
52
49
default_value = "19950",
53
-
env = "SMITE_COORDINATOR_BIDI_STREAM_PORT"
50
+
env = "OSPREY_COORDINATOR_BIDI_STREAM_PORT"
54
51
)]
55
52
bidi_stream_port: u16,
56
53
#[arg(
57
54
long,
58
55
default_value = "19951",
59
-
env = "SMITE_COORDINATOR_SYNC_ACTION_PORT"
56
+
env = "OSPREY_COORDINATOR_SYNC_ACTION_PORT"
60
57
)]
61
58
sync_action_port: u16,
62
59
#[arg(
···
82
79
tracing::info!("starting grpc metrics worker");
83
80
let _worker_guard = metrics
84
81
.clone()
85
-
.spawn_emit_worker(new_client("smite_coordinator").unwrap());
82
+
.spawn_emit_worker(new_client("osprey_coordinator").unwrap());
86
83
87
-
let smite_coordinator_grpc_bidi_stream_service =
84
+
let osprey_coordinator_grpc_bidi_stream_service =
88
85
OspreyCoordinatorServiceServer::new(OspreyCoordinatorServer::new(
89
86
priority_queue_sender.clone(),
90
87
priority_queue_receiver.clone(),
91
88
metrics.clone(),
92
89
));
93
90
94
-
tracing::info!("starting label service client");
95
-
let label_service_client = LabelServiceClient::new().await?;
96
-
97
-
let smite_coordinator_sync_action_service =
91
+
let osprey_coordinator_sync_action_service =
98
92
OspreyCoordinatorSyncActionServiceServer::new(sync_action_rpc::SyncActionServer::new(
99
93
snowflake_client.clone(),
100
94
priority_queue_sender.clone(),
101
95
metrics.clone(),
102
-
label_service_client,
103
96
));
104
97
105
98
let pubsub_fut = start_pubsub_subscriber(
···
108
101
metrics.clone(),
109
102
);
110
103
let grpc_bidi_stream_service_fut = pigeon::serve(
111
-
smite_coordinator_grpc_bidi_stream_service,
112
-
"smite_coordinator",
104
+
osprey_coordinator_grpc_bidi_stream_service,
105
+
"osprey_coordinator",
113
106
opts.bidi_stream_port,
114
107
Duration::from_secs(30),
115
108
);
116
109
let sync_action_service_fut = pigeon::serve(
117
-
smite_coordinator_sync_action_service,
118
-
"smite_coordinator_sync_action",
110
+
osprey_coordinator_sync_action_service,
111
+
"osprey_coordinator_sync_action",
119
112
opts.sync_action_port,
120
113
Duration::from_secs(60),
121
114
);
-1
osprey_coordinator/src/metrics/counters/mod.rs
-1
osprey_coordinator/src/metrics/counters/mod.rs
-1
osprey_coordinator/src/metrics/gauges/mod.rs
-1
osprey_coordinator/src/metrics/gauges/mod.rs
+1
-1
osprey_coordinator/src/osprey_bidirectional_stream.rs
+1
-1
osprey_coordinator/src/osprey_bidirectional_stream.rs
···
311
311
let metrics = OspreyCoordinatorMetrics::new();
312
312
let _worker_guard = metrics
313
313
.clone()
314
-
.spawn_emit_worker(new_client("smite_coordinator").unwrap());
314
+
.spawn_emit_worker(new_client("osprey_coordinator").unwrap());
315
315
316
316
let ackable_action = proto::OspreyCoordinatorAction {
317
317
ack_id: 1,
-1
osprey_coordinator/src/pigeon/mod.rs
-1
osprey_coordinator/src/pigeon/mod.rs
-7
osprey_coordinator/src/proto/mod.rs
-7
osprey_coordinator/src/proto/mod.rs
···
13
13
}
14
14
}
15
15
16
-
pub mod labels {
17
-
pub mod v1 {
18
-
include!(concat!(env!("OUT_DIR"), "/osprey.rpc.labels.v1.rs"));
19
-
}
20
-
}
21
-
22
16
pub mod osprey_coordinator {
23
17
pub mod bidirectional_stream {
24
18
pub mod v1 {
···
43
37
44
38
pub use osprey::rpc::actions::v1::*;
45
39
pub use osprey::rpc::common::v1::*;
46
-
pub use osprey::rpc::labels::v1::*;
47
40
pub use osprey::rpc::osprey_coordinator::bidirectional_stream::v1::*;
48
41
pub use osprey::rpc::osprey_coordinator::sync_action::v1 as osprey_coordinator_sync_action;
49
42
pub const PB_DESCRIPTOR_BYTES: &[u8] = include_bytes!(concat!(env!("OUT_DIR"), "/descriptor.bin"));
+9
-9
osprey_coordinator/src/pubsub.rs
+9
-9
osprey_coordinator/src/pubsub.rs
···
30
30
use tokio::time::{timeout, Duration as TokioDuration, Instant};
31
31
use tonic::{codegen::InterceptedService, transport::Channel};
32
32
33
-
use crate::proto::Action as SmiteProtoAction;
33
+
use crate::proto::Action as OspreyProtoAction;
34
34
use crate::signals::exit_signal;
35
35
use crate::snowflake_client::SnowflakeClient;
36
36
use convert_case::{Case, Casing};
···
43
43
snowflake_client: &SnowflakeClient,
44
44
metrics: &OspreyCoordinatorMetrics,
45
45
) -> Result<proto::OspreyCoordinatorAction> {
46
-
let smite_proto_action = SmiteProtoAction::decode(message_data).unwrap();
47
-
let action_id = if smite_proto_action.id == 0 {
46
+
let osprey_proto_action = OspreyProtoAction::decode(message_data).unwrap();
47
+
let action_id = if osprey_proto_action.id == 0 {
48
48
metrics.action_id_snowflake_generation_proto.incr();
49
49
snowflake_client.generate_id().await?
50
50
} else {
51
-
smite_proto_action.id
51
+
osprey_proto_action.id
52
52
};
53
-
let action_name = smite_proto_action
53
+
let action_name = osprey_proto_action
54
54
.data
55
55
.unwrap()
56
56
.to_string()
···
185
185
} else {
186
186
tracing::info!("Creating subscription client to real pubsub");
187
187
let service_account =
188
-
std::env::var("SMITE_COORDINATOR_SERVICE_ACCOUNT").unwrap_or("default".to_string());
188
+
std::env::var("OSPREY_COORDINATOR_SERVICE_ACCOUNT").unwrap_or("default".to_string());
189
189
let client = GCPMetadataClient::new(service_account).unwrap();
190
190
Connection::from_metadata_client(
191
191
client,
···
211
211
let project_id = std::env::var("PUBSUB_SUBSCRIPTION_PROJECT_ID")
212
212
.unwrap_or("discord-anti-abuse-prd".to_string());
213
213
214
-
let subscription_id =
215
-
std::env::var("PUBSUB_SUBSCRIPTION_ID").unwrap_or("smite-coordinator-test".to_string());
214
+
let subscription_id = std::env::var("PUBSUB_SUBSCRIPTION_ID")
215
+
.unwrap_or("osprey-coordinator-test".to_string());
216
216
217
217
PubSubSubscription::new(project_id, subscription_id)
218
218
};
···
334
334
}
335
335
}
336
336
}),
337
-
MetricsClientBuilder::new("smite_coordinator.pull"),
337
+
MetricsClientBuilder::new("osprey_coordinator.pull"),
338
338
)
339
339
.gracefully_stop_on_signal(exit_signal(), Duration::from_secs(30))
340
340
.await;
+9
-32
osprey_coordinator/src/sync_action_rpc.rs
+9
-32
osprey_coordinator/src/sync_action_rpc.rs
···
3
3
use crate::snowflake_client::SnowflakeClient;
4
4
use crate::{
5
5
coordinator_metrics::OspreyCoordinatorMetrics,
6
-
label_service_client::LabelServiceClient,
7
6
priority_queue::AckableAction,
8
7
priority_queue::{AckOrNack, PriorityQueueSender},
9
8
proto::{self, osprey_coordinator_sync_action},
···
20
19
snowflake_client: Arc<SnowflakeClient>,
21
20
priority_queue_sender: PriorityQueueSender,
22
21
metrics: Arc<OspreyCoordinatorMetrics>,
23
-
label_service_client: LabelServiceClient,
24
22
}
25
23
26
24
impl SyncActionServer {
···
28
26
snowflake_client: Arc<SnowflakeClient>,
29
27
priority_queue_sender: PriorityQueueSender,
30
28
metrics: Arc<OspreyCoordinatorMetrics>,
31
-
label_service_client: LabelServiceClient,
32
29
) -> SyncActionServer {
33
30
SyncActionServer {
34
31
snowflake_client,
35
32
priority_queue_sender,
36
33
metrics,
37
-
label_service_client,
38
34
}
39
35
}
40
36
}
41
37
42
-
async fn create_smite_coordinator_action(
38
+
async fn create_osprey_coordinator_action(
43
39
ack_id: u64,
44
40
action_request: &osprey_coordinator_sync_action::ProcessActionRequest,
45
41
snowflake_client: &SnowflakeClient,
46
-
) -> Result<(proto::OspreyCoordinatorAction, Vec<crate::proto::EntityKey>)> {
42
+
) -> Result<proto::OspreyCoordinatorAction> {
47
43
// generate snowflake if one is not provided, to match the behaviour in pubsub.rs
48
44
let action_id = match action_request.action_id {
49
45
Some(id) => match id {
···
56
52
if action_request.action_name.is_empty() {
57
53
return Err(anyhow!("`action_name` must not be empty"));
58
54
}
59
-
let smite_coordinator_action = proto::OspreyCoordinatorAction {
55
+
let osprey_coordinator_action = proto::OspreyCoordinatorAction {
60
56
ack_id,
61
57
action_id,
62
58
action_name: action_request.action_name.clone(),
···
75
71
),
76
72
};
77
73
78
-
Ok((
79
-
smite_coordinator_action,
80
-
action_request.requested_entities.clone(),
81
-
))
74
+
Ok(osprey_coordinator_action)
82
75
}
83
76
84
77
impl SyncActionServer {
···
90
83
{
91
84
let unvalidated_action_id = action_request.action_id;
92
85
93
-
let (smite_coordinator_action, requested_entities) = match create_smite_coordinator_action(
86
+
let osprey_coordinator_action = match create_osprey_coordinator_action(
94
87
ack_id,
95
88
action_request,
96
89
self.snowflake_client.as_ref(),
···
107
100
}
108
101
};
109
102
110
-
let action_id = smite_coordinator_action.action_id;
103
+
let action_id = osprey_coordinator_action.action_id;
111
104
112
-
let (ackable_action, acking_receiver) = AckableAction::new(smite_coordinator_action);
105
+
let (ackable_action, acking_receiver) = AckableAction::new(osprey_coordinator_action);
113
106
114
107
let send_start_time = Instant::now();
115
108
match self.priority_queue_sender.send_sync(ackable_action).await {
···
132
125
Ok(ack_or_nack) => match ack_or_nack {
133
126
AckOrNack::Ack(verdicts) => {
134
127
tracing::debug!({action_id=%action_id, ack_id=ack_id},"[rpc] acking message");
135
-
let entities = match self
136
-
.label_service_client
137
-
.get_entities(requested_entities)
138
-
.await
139
-
{
140
-
Ok(entities) => entities,
141
-
Err(error) => {
142
-
tracing::error!({error=%error},"label service call failed");
143
-
self.metrics
144
-
.sync_classification_failure_label_service
145
-
.incr();
146
-
return Err(tonic::Status::aborted("label service call failed"));
147
-
}
148
-
};
149
128
150
-
let response = osprey_coordinator_sync_action::ProcessActionResponse {
151
-
entities,
152
-
verdicts,
153
-
};
129
+
let response =
130
+
osprey_coordinator_sync_action::ProcessActionResponse { verdicts };
154
131
155
132
self.metrics.sync_classification_result_ack.incr();
156
133
self.metrics
-4
osprey_coordinator/src/tokio_utils/mod.rs
-4
osprey_coordinator/src/tokio_utils/mod.rs
···
8
8
9
9
mod unbounded_receiver_chunker;
10
10
11
-
pub use unbounded_receiver_chunker::{
12
-
ChunkSizeConfig as UnboundedReceiverChunkSizeConfig, UnboundedReceiverChunker,
13
-
};
14
-
15
11
/// A helper struct that will invoke [`JoinHandle::abort`] when dropped.
16
12
#[derive(Debug)]
17
13
pub struct AbortOnDrop<T = ()> {
-12
proto/etcd_watcherd/v1/BUILD
-12
proto/etcd_watcherd/v1/BUILD
···
1
-
load("@rules_proto//proto:defs.bzl", "proto_library")
2
-
3
-
package(default_visibility = ["//visibility:public"])
4
-
5
-
proto_library(
6
-
name = "etcd_watcherd_proto",
7
-
srcs = ["etcd_watcherd.proto"],
8
-
strip_import_prefix = "/proto/",
9
-
deps = [
10
-
"//proto/google:com_google_protobuf",
11
-
],
12
-
)
-49
proto/etcd_watcherd/v1/etcd_watcherd.proto
-49
proto/etcd_watcherd/v1/etcd_watcherd.proto
···
1
-
syntax = "proto3";
2
-
3
-
package discord_common.etcd_watcherd.v1;
4
-
5
-
import "google/protobuf/wrappers.proto";
6
-
7
-
service EtcdWatcherdService
8
-
{
9
-
rpc WatchKey(WatchKeyRequest) returns (stream WatchKeyResponse);
10
-
rpc WatchKeyRecursive(WatchKeyRecursiveRequest) returns (stream WatchKeyRecursiveResponse);
11
-
}
12
-
13
-
message WatchKeyRequest
14
-
{
15
-
string key = 1;
16
-
}
17
-
18
-
message WatchKeyResponse
19
-
{
20
-
google.protobuf.StringValue value = 1;
21
-
}
22
-
message WatchKeyRecursiveRequest
23
-
{
24
-
string key = 1;
25
-
}
26
-
27
-
message WatchKeyRecursiveResponse
28
-
{
29
-
message FullSync { map<string, string> items = 1; }
30
-
31
-
message SyncOne
32
-
{
33
-
string key = 1;
34
-
string value = 2;
35
-
}
36
-
37
-
message DeleteOne
38
-
{
39
-
string key = 1;
40
-
string prev_value = 2;
41
-
}
42
-
43
-
oneof event
44
-
{
45
-
FullSync full_sync = 1;
46
-
SyncOne sync_one = 2;
47
-
DeleteOne delete_one = 3;
48
-
}
49
-
}
+5
-5
proto/osprey/rpc/actions/v1/action.proto
+5
-5
proto/osprey/rpc/actions/v1/action.proto
···
13
13
fixed64 id = 1;
14
14
15
15
// This oneof denotes the type of action this message is.
16
-
// Each field name in this this oneof should match the name of an action that Smite expects.
16
+
// Each field name in this this oneof should match the name of an action that Osprey expects.
17
17
oneof data {
18
18
AuthSessionCreated auth_session_created = 2;
19
19
AuthSessionModified auth_session_modified = 3;
···
23
23
UserBatchMLScore user_batch_ml_score = 7;
24
24
UserBlocked user_blocked = 8;
25
25
GuildJoined guild_joined = 9;
26
-
SmiteAutoClusteringUser smite_auto_clustering_user = 10;
27
-
SmiteAutoClusteringKey smite_auto_clustering_key = 11;
26
+
OspreyAutoClusteringUser osprey_auto_clustering_user = 10;
27
+
OspreyAutoClusteringKey osprey_auto_clustering_key = 11;
28
28
HashMatcherIconMatched hash_matcher_icon_matched = 12;
29
29
SafetyVisualPrediction safety_visual_prediction = 13;
30
30
}
···
76
76
BatchMLSourceEvent source_event = 8;
77
77
}
78
78
79
-
message SmiteAutoClusteringUser {
79
+
message OspreyAutoClusteringUser {
80
80
google.protobuf.Timestamp timestamp = 1;
81
81
uint64 user_id = 2;
82
82
string pipeline_name = 3;
83
83
string cluster_id = 4;
84
84
}
85
85
86
-
message SmiteAutoClusteringKey {
86
+
message OspreyAutoClusteringKey {
87
87
google.protobuf.Timestamp timestamp = 1;
88
88
string key = 2;
89
89
string value = 3;
+1
-1
proto/osprey/rpc/actions/v1/guild.proto
+1
-1
proto/osprey/rpc/actions/v1/guild.proto
-36
proto/osprey/rpc/labels/v1/service.proto
-36
proto/osprey/rpc/labels/v1/service.proto
···
1
-
syntax = "proto3";
2
-
3
-
package osprey.rpc.labels.v1;
4
-
5
-
// Mock proto file for deprecated labels functionality
6
-
// These are marked as DEPRECATED in sync_action service
7
-
// and will be removed once labels are replaced with verdicts
8
-
9
-
message EntityKey {
10
-
string entity_type = 1;
11
-
string entity_id = 2;
12
-
}
13
-
14
-
message Label {
15
-
string name = 1;
16
-
int64 version = 2;
17
-
int64 expires_at = 3;
18
-
}
19
-
20
-
message Entity {
21
-
EntityKey key = 1;
22
-
repeated Label labels = 2;
23
-
}
24
-
25
-
message GetEntityRequest {
26
-
string routing_key = 1;
27
-
EntityKey key = 2;
28
-
}
29
-
30
-
message GetEntityResponse {
31
-
Entity entity = 1;
32
-
}
33
-
34
-
service LabelService {
35
-
rpc GetEntity(GetEntityRequest) returns (GetEntityResponse);
36
-
}
-6
proto/osprey/rpc/osprey_coordinator/sync_action/v1/service.proto
-6
proto/osprey/rpc/osprey_coordinator/sync_action/v1/service.proto
···
2
2
package osprey.rpc.osprey_coordinator.sync_action.v1;
3
3
4
4
import "osprey/rpc/common/v1/verdicts.proto";
5
-
import "osprey/rpc/labels/v1/service.proto";
6
5
7
6
import "google/protobuf/timestamp.proto";
8
7
import "google/protobuf/wrappers.proto";
···
11
10
google.protobuf.UInt64Value action_id = 1;
12
11
string action_name = 2;
13
12
string action_data_json = 3;
14
-
// DEPRECATED: to be removed once labels are replaced with verdicts
15
-
repeated osprey.rpc.labels.v1.EntityKey requested_entities = 4;
16
13
google.protobuf.Timestamp timestamp = 5;
17
14
}
18
15
19
16
message ProcessActionResponse {
20
-
// DEPRECATED: to be removed once labels are replaced with verdicts
21
-
repeated osprey.rpc.labels.v1.Entity entities = 1;
22
-
//
23
17
osprey.rpc.common.v1.Verdicts verdicts = 2;
24
18
}
25
19