diff --git a/src/adapter/src/catalog.rs b/src/adapter/src/catalog.rs index 318ae707f6957..52cc3a9ef9142 100644 --- a/src/adapter/src/catalog.rs +++ b/src/adapter/src/catalog.rs @@ -1078,6 +1078,10 @@ impl Catalog { self.state.get_network_policy(&network_policy_id) } + pub fn get_network_by_name(&self, name: &str) -> Option<&NetworkPolicy> { + self.state.try_get_network_policy_by_name(name) + } + pub fn clusters(&self) -> impl Iterator { self.state.clusters_by_id.values() } diff --git a/src/adapter/src/coord.rs b/src/adapter/src/coord.rs index 9257a07c886aa..228fa9c9cd53b 100644 --- a/src/adapter/src/coord.rs +++ b/src/adapter/src/coord.rs @@ -97,7 +97,7 @@ use mz_catalog::config::{AwsPrincipalContext, BuiltinItemMigrationConfig, Cluste use mz_catalog::durable::OpenableDurableCatalogState; use mz_catalog::memory::objects::{ CatalogEntry, CatalogItem, ClusterReplicaProcessStatus, ClusterVariantManaged, Connection, - DataSourceDesc, TableDataSource, + DataSourceDesc, NetworkPolicy, TableDataSource, }; use mz_cloud_resources::{CloudResourceController, VpcEndpointConfig, VpcEndpointEvent}; use mz_compute_client::as_of_selection; @@ -4097,24 +4097,15 @@ pub enum NetworkPolicyError { MissingIp, } -// TODO @jubrad this will be moved to a catalog resource in v1 -// of network policies. -/// Represents a basic network policy. -#[derive(Debug, Clone)] -pub struct NetworkPolicy { - allow_list: Vec, -} - -impl NetworkPolicy { - pub fn new(allow_list: Vec) -> Self { - NetworkPolicy { allow_list } - } - - /// Validate the provided IP is allowed by the network policy. - pub fn validate(&self, ip: &IpAddr) -> Result<(), NetworkPolicyError> { - match self.allow_list.iter().any(|net| net.contains(ip)) { - true => Ok(()), - false => Err(NetworkPolicyError::AddressDenied(ip.clone())), - } +pub(crate) fn validate_network_with_policy( + ip: &IpAddr, + policy: &NetworkPolicy, +) -> Result<(), NetworkPolicyError> { + // At the moment we're not handling action or direction + // as those are only able to be "allow" and "ingress" respectively + if policy.rules.iter().any(|r| r.address.0.contains(ip)) { + Ok(()) + } else { + Err(NetworkPolicyError::AddressDenied(ip.clone())) } } diff --git a/src/adapter/src/coord/command_handler.rs b/src/adapter/src/coord/command_handler.rs index 7bc580b0d5615..81ed9882f1070 100644 --- a/src/adapter/src/coord/command_handler.rs +++ b/src/adapter/src/coord/command_handler.rs @@ -62,8 +62,8 @@ use crate::command::{ }; use crate::coord::appends::{Deferred, PendingWriteTxn}; use crate::coord::{ - ConnMeta, Coordinator, DeferredPlanStatement, Message, NetworkPolicy, PendingTxn, - PlanStatement, PlanValidity, PurifiedStatementReady, + validate_network_with_policy, ConnMeta, Coordinator, DeferredPlanStatement, Message, + PendingTxn, PlanStatement, PlanValidity, PurifiedStatementReady, }; use crate::error::AdapterError; use crate::notice::AdapterNotice; @@ -355,9 +355,26 @@ impl Coordinator { // ensure these internal interfaces are well secured. let system_config = self.catalog().state().system_config(); if !user.is_internal() { - let default_policy = NetworkPolicy::new(system_config.default_network_policy()); + let Some(network_policy) = self + .catalog() + .get_network_by_name(&system_config.default_network_policy_name()) + else { + tracing::error!("Network_policy system var is not pointing to a existing network policy. All user traffic will be blocked"); + match client_ip { + Some(ip) => { + return Err(AdapterError::NetworkPolicyDenied( + super::NetworkPolicyError::AddressDenied(ip.clone()), + )); + } + None => { + return Err(AdapterError::NetworkPolicyDenied( + super::NetworkPolicyError::MissingIp, + )); + } + } + }; if let Some(ip) = client_ip { - match default_policy.validate(ip) { + match validate_network_with_policy(ip, network_policy) { Ok(_) => {} Err(e) => return Err(AdapterError::NetworkPolicyDenied(e)), } diff --git a/src/adapter/src/coord/sequencer/inner.rs b/src/adapter/src/coord/sequencer/inner.rs index d42fc4631d755..91c9eeb2fab3e 100644 --- a/src/adapter/src/coord/sequencer/inner.rs +++ b/src/adapter/src/coord/sequencer/inner.rs @@ -70,8 +70,8 @@ use mz_sql::plan::{ use mz_sql::session::metadata::SessionMetadata; use mz_sql::session::user::UserKind; use mz_sql::session::vars::{ - self, IsolationLevel, OwnedVarInput, SessionVars, Var, VarInput, SCHEMA_ALIAS, - TRANSACTION_ISOLATION_VAR_NAME, + self, IsolationLevel, OwnedVarInput, SessionVars, Var, VarError, VarInput, NETWORK_POLICY, + SCHEMA_ALIAS, TRANSACTION_ISOLATION_VAR_NAME, }; use mz_sql::{plan, rbac}; use mz_sql_parser::ast::display::AstDisplay; @@ -4001,6 +4001,25 @@ impl Coordinator { plan::AlterSystemSetPlan { name, value }: plan::AlterSystemSetPlan, ) -> Result { self.is_user_allowed_to_alter_system(session, Some(&name))?; + if NETWORK_POLICY.name.to_string().to_lowercase() == name.clone().to_lowercase() { + let values = match value { + plan::VariableValue::Default => None, + plan::VariableValue::Values(ref values) => Some(values), + }; + if let Some(_policy) = values + .map(|v| self.catalog.get_network_by_name(&v[0])) + .flatten() + { + } else { + return Err(AdapterError::PlanError(plan::PlanError::VarError( + VarError::InvalidParameterValue { + name: NETWORK_POLICY.name(), + invalid_values: values.expect("Must have provided value.").to_owned(), + reason: "No network policy with such name exists!".to_string(), + }, + ))); + } + } let op = match value { plan::VariableValue::Values(values) => catalog::Op::UpdateSystemConfiguration { name: name.clone(), diff --git a/src/buf.yaml b/src/buf.yaml index a1147b73755d2..fae9cbdf83ff2 100644 --- a/src/buf.yaml +++ b/src/buf.yaml @@ -24,6 +24,8 @@ breaking: # reason: does currently not require backward-compatibility - catalog/protos/objects_v69.proto # reason: does currently not require backward-compatibility + - catalog/protos/objects_v70.proto + # reason: does currently not require backward-compatibility - cluster-client/src/client.proto # reason: does currently not require backward-compatibility - compute-client/src/logging.proto diff --git a/src/catalog/protos/hashes.json b/src/catalog/protos/hashes.json index 5a17d54058293..40ba39acdf6de 100644 --- a/src/catalog/protos/hashes.json +++ b/src/catalog/protos/hashes.json @@ -14,5 +14,9 @@ { "name": "objects_v69.proto", "md5": "638e206754da134b10a0712d63bdd8dc" + }, + { + "name": "objects_v70.proto", + "md5": "2f8c95db7075f523a7e28af319279bcd" } ] diff --git a/src/catalog/protos/objects_v70.proto b/src/catalog/protos/objects_v70.proto new file mode 100644 index 0000000000000..610e3733a2bbe --- /dev/null +++ b/src/catalog/protos/objects_v70.proto @@ -0,0 +1,1023 @@ +// Copyright Materialize, Inc. and contributors. All rights reserved. +// +// Use of this software is governed by the Business Source License +// included in the LICENSE file. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0. + +// This protobuf file defines the types we store in the Stash. +// +// Before and after modifying this file, make sure you have a snapshot of the before version, +// e.g. a copy of this file named 'objects_v{CATALOG_VERSION}.proto', and a snapshot of the file +// after your modifications, e.g. 'objects_v{CATALOG_VERSION + 1}.proto'. Then you can write a +// migration using these two files, and no matter how the types change in the future, we'll always +// have these snapshots to facilitate the migration. + +// buf breaking: ignore (does currently not require backward-compatibility) + +syntax = "proto3"; + +package objects_v70; + +message ConfigKey { + string key = 1; +} + +message ConfigValue { + uint64 value = 1; +} + +message SettingKey { + string name = 1; +} + +message SettingValue { + string value = 1; +} + +message IdAllocKey { + string name = 1; +} + +message IdAllocValue { + uint64 next_id = 1; +} + +message GidMappingKey { + string schema_name = 1; + CatalogItemType object_type = 2; + string object_name = 3; +} + +message GidMappingValue { + // TODO(parkmycar): Ideally this is a SystemCatalogItemId but making this change panics 0dt + // upgrades if there were new builtin objects added since the older version of Materialize + // doesn't know how to read the new SystemCatalogItemId type. + uint64 id = 1; + string fingerprint = 2; + SystemGlobalId global_id = 3; +} + +message ClusterKey { + ClusterId id = 1; +} + +message ClusterValue { + reserved 2; + string name = 1; + RoleId owner_id = 3; + repeated MzAclItem privileges = 4; + ClusterConfig config = 5; +} + +message ClusterIntrospectionSourceIndexKey { + ClusterId cluster_id = 1; + string name = 2; +} + +message ClusterIntrospectionSourceIndexValue { + // TODO(parkmycar): Ideally this is a SystemCatalogItemId but making this change panics 0dt + // upgrades if there were new builtin objects added since the older version of Materialize + // doesn't know how to read the new SystemCatalogItemId type. + uint64 index_id = 1; + uint32 oid = 2; + SystemGlobalId global_id = 3; +} + +message ClusterReplicaKey { + ReplicaId id = 1; +} + +message ClusterReplicaValue { + ClusterId cluster_id = 1; + string name = 2; + ReplicaConfig config = 3; + RoleId owner_id = 4; +} + +message DatabaseKey { + DatabaseId id = 1; +} + +message DatabaseValue { + string name = 1; + RoleId owner_id = 2; + repeated MzAclItem privileges = 3; + uint32 oid = 4; +} + +message SchemaKey { + SchemaId id = 1; +} + +message SchemaValue { + DatabaseId database_id = 1; + string name = 2; + RoleId owner_id = 3; + repeated MzAclItem privileges = 4; + uint32 oid = 5; +} + +message ItemKey { + CatalogItemId gid = 1; +} + +message ItemValue { + SchemaId schema_id = 1; + string name = 2; + CatalogItem definition = 3; + RoleId owner_id = 4; + repeated MzAclItem privileges = 5; + uint32 oid = 6; + GlobalId global_id = 7; + repeated ItemVersion extra_versions = 8; +} + +message ItemVersion { + GlobalId global_id = 1; + Version version = 2; +} + +message RoleKey { + RoleId id = 1; +} + +message RoleValue { + string name = 1; + RoleAttributes attributes = 2; + RoleMembership membership = 3; + RoleVars vars = 4; + uint32 oid = 5; +} + +message NetworkPolicyKey { + NetworkPolicyId id = 1; +} + +message NetworkPolicyValue { + string name = 1; + repeated NetworkPolicyRule rules = 2; + RoleId owner_id = 3; + repeated MzAclItem privileges = 4; + uint32 oid = 5; +} + +message ServerConfigurationKey { + string name = 1; +} + +message ServerConfigurationValue { + string value = 1; +} + +message AuditLogKey { + oneof event { + AuditLogEventV1 v1 = 1; + } +} + +message CommentKey { + oneof object { + CatalogItemId table = 1; + CatalogItemId view = 2; + CatalogItemId materialized_view = 4; + CatalogItemId source = 5; + CatalogItemId sink = 6; + CatalogItemId index = 7; + CatalogItemId func = 8; + CatalogItemId connection = 9; + CatalogItemId type = 10; + CatalogItemId secret = 11; + CatalogItemId continual_task = 17; + RoleId role = 12; + DatabaseId database = 13; + ResolvedSchema schema = 14; + ClusterId cluster = 15; + ClusterReplicaId cluster_replica = 16; + NetworkPolicyId network_policy = 18; + } + oneof sub_component { + uint64 column_pos = 3; + } +} + +message CommentValue { + string comment = 1; +} + +message SourceReferencesKey { + CatalogItemId source = 1; +} + +message SourceReferencesValue { + repeated SourceReference references = 1; + EpochMillis updated_at = 2; +} + +message SourceReference { + string name = 1; + optional string namespace = 2; + repeated string columns = 3; +} + +message StorageCollectionMetadataKey { + GlobalId id = 1; +} + +// This value is stored transparently, however, it should only ever be +// manipulated by the storage controller. +message StorageCollectionMetadataValue { + string shard = 1; +} + +// This value is stored transparently, however, it should only ever be +// manipulated by the storage controller. +message UnfinalizedShardKey { + string shard = 1; +} + +// This value is stored transparently, however, it should only ever be +// manipulated by the storage controller. +message TxnWalShardValue { + string shard = 1; +} + +// ---- Common Types +// +// Note: Normally types like this would go in some sort of `common.proto` file, but we want to keep +// our proto definitions in a single file to make snapshotting easier, hence them living here. + +message Empty { + /* purposefully empty */ +} + +// In protobuf a "None" string is the same thing as an empty string. To get the same semantics of +// an `Option` from Rust, we need to wrap a string in a message. +message StringWrapper { + string inner = 1; +} + +message Duration { + uint64 secs = 1; + uint32 nanos = 2; +} + +message EpochMillis { + uint64 millis = 1; +} + +// Opaque timestamp type that is specific to Materialize. +message Timestamp { + uint64 internal = 1; +} + +message Version { + uint64 value = 2; +} + +enum CatalogItemType { + CATALOG_ITEM_TYPE_UNKNOWN = 0; + CATALOG_ITEM_TYPE_TABLE = 1; + CATALOG_ITEM_TYPE_SOURCE = 2; + CATALOG_ITEM_TYPE_SINK = 3; + CATALOG_ITEM_TYPE_VIEW = 4; + CATALOG_ITEM_TYPE_MATERIALIZED_VIEW = 5; + CATALOG_ITEM_TYPE_INDEX = 6; + CATALOG_ITEM_TYPE_TYPE = 7; + CATALOG_ITEM_TYPE_FUNC = 8; + CATALOG_ITEM_TYPE_SECRET = 9; + CATALOG_ITEM_TYPE_CONNECTION = 10; + CATALOG_ITEM_TYPE_CONTINUAL_TASK = 11; +} + +message CatalogItem { + message V1 { + string create_sql = 1; + } + + oneof value { + V1 v1 = 1; + } +} + +message CatalogItemId { + oneof value { + uint64 system = 1; + uint64 user = 2; + uint64 transient = 3; + } +} + +/// A newtype wrapper for a `CatalogItemId` that is always in the "system" namespace. +message SystemCatalogItemId { + uint64 value = 1; +} + +message GlobalId { + oneof value { + uint64 system = 1; + uint64 user = 2; + uint64 transient = 3; + Empty explain = 4; + } +} + +/// A newtype wrapper for a `GlobalId` that is always in the "system" namespace. +message SystemGlobalId { + uint64 value = 1; +} + +message ClusterId { + oneof value { + uint64 system = 1; + uint64 user = 2; + } +} + +message DatabaseId { + oneof value { + uint64 system = 1; + uint64 user = 2; + } +} + +message ResolvedDatabaseSpecifier { + oneof spec { + Empty ambient = 1; + DatabaseId id = 2; + } +} + +message SchemaId { + oneof value { + uint64 system = 1; + uint64 user = 2; + } +} + +message SchemaSpecifier { + oneof spec { + Empty temporary = 1; + SchemaId id = 2; + } +} + +message ResolvedSchema { + ResolvedDatabaseSpecifier database = 1; + SchemaSpecifier schema = 2; +} + +message ReplicaId { + oneof value { + uint64 system = 1; + uint64 user = 2; + } +} + +message ClusterReplicaId { + ClusterId cluster_id = 1; + ReplicaId replica_id = 2; +} + +message NetworkPolicyId { + oneof value { + uint64 system = 1; + uint64 user = 2; + } +} + +message ReplicaLogging { + bool log_logging = 1; + Duration interval = 2; +} + +message OptimizerFeatureOverride { + string name = 1; + string value = 2; +} + +message ClusterScheduleRefreshOptions { + Duration rehydration_time_estimate = 1; +} + +message ClusterSchedule { + oneof value { + Empty manual = 1; + ClusterScheduleRefreshOptions refresh = 2; + } +} + +message ClusterConfig { + message ManagedCluster { + string size = 1; + uint32 replication_factor = 2; + repeated string availability_zones = 3; + ReplicaLogging logging = 4; + bool disk = 6; + repeated OptimizerFeatureOverride optimizer_feature_overrides = 7; + ClusterSchedule schedule = 8; + } + + oneof variant { + Empty unmanaged = 1; + ManagedCluster managed = 2; + } + optional string workload_class = 3; +} + +message ReplicaConfig { + message UnmanagedLocation { + repeated string storagectl_addrs = 1; + repeated string storage_addrs = 2; + repeated string computectl_addrs = 3; + repeated string compute_addrs = 4; + uint64 workers = 5; + } + + message ManagedLocation { + string size = 1; + optional string availability_zone = 2; + bool disk = 4; + bool internal = 5; + optional string billed_as = 6; + bool pending = 7; + } + + oneof location { + UnmanagedLocation unmanaged = 1; + ManagedLocation managed = 2; + } + ReplicaLogging logging = 3; +} + +message RoleId { + oneof value { + uint64 system = 1; + uint64 user = 2; + Empty public = 3; + uint64 predefined = 4; + } +} + +message RoleAttributes { + bool inherit = 1; +} + +message RoleMembership { + message Entry { + RoleId key = 1; + RoleId value = 2; + } + + repeated Entry map = 1; +} + +message RoleVars { + message SqlSet { + repeated string entries = 1; + } + + message Entry { + string key = 1; + oneof val { + string flat = 2; + SqlSet sql_set = 3; + } + } + + repeated Entry entries = 1; +} + +message NetworkPolicyRule { + string name = 1; + oneof action { + Empty allow = 2; + } + oneof direction { + Empty ingress = 3; + } + string address = 4; +} + +message AclMode { + // A bit flag representing all the privileges that can be granted to a role. + uint64 bitflags = 1; +} + +message MzAclItem { + RoleId grantee = 1; + RoleId grantor = 2; + AclMode acl_mode = 3; +} + +enum ObjectType { + OBJECT_TYPE_UNKNOWN = 0; + OBJECT_TYPE_TABLE = 1; + OBJECT_TYPE_VIEW = 2; + OBJECT_TYPE_MATERIALIZED_VIEW = 3; + OBJECT_TYPE_SOURCE = 4; + OBJECT_TYPE_SINK = 5; + OBJECT_TYPE_INDEX = 6; + OBJECT_TYPE_TYPE = 7; + OBJECT_TYPE_ROLE = 8; + OBJECT_TYPE_CLUSTER = 9; + OBJECT_TYPE_CLUSTER_REPLICA = 10; + OBJECT_TYPE_SECRET = 11; + OBJECT_TYPE_CONNECTION = 12; + OBJECT_TYPE_DATABASE = 13; + OBJECT_TYPE_SCHEMA = 14; + OBJECT_TYPE_FUNC = 15; + OBJECT_TYPE_CONTINUAL_TASK = 16; + OBJECT_TYPE_NETWORK_POLICY = 17; +} + +message DefaultPrivilegesKey { + RoleId role_id = 1; + DatabaseId database_id = 2; + SchemaId schema_id = 3; + ObjectType object_type = 4; + RoleId grantee = 5; +} + +message DefaultPrivilegesValue { + AclMode privileges = 1; +} + +message SystemPrivilegesKey { + RoleId grantee = 1; + RoleId grantor = 2; +} + +message SystemPrivilegesValue { + AclMode acl_mode = 1; +} + +message AuditLogEventV1 { + enum EventType { + EVENT_TYPE_UNKNOWN = 0; + EVENT_TYPE_CREATE = 1; + EVENT_TYPE_DROP = 2; + EVENT_TYPE_ALTER = 3; + EVENT_TYPE_GRANT = 4; + EVENT_TYPE_REVOKE = 5; + EVENT_TYPE_COMMENT = 6; + } + + enum ObjectType { + OBJECT_TYPE_UNKNOWN = 0; + OBJECT_TYPE_CLUSTER = 1; + OBJECT_TYPE_CLUSTER_REPLICA = 2; + OBJECT_TYPE_CONNECTION = 3; + OBJECT_TYPE_DATABASE = 4; + OBJECT_TYPE_FUNC = 5; + OBJECT_TYPE_INDEX = 6; + OBJECT_TYPE_MATERIALIZED_VIEW = 7; + OBJECT_TYPE_ROLE = 8; + OBJECT_TYPE_SECRET = 9; + OBJECT_TYPE_SCHEMA = 10; + OBJECT_TYPE_SINK = 11; + OBJECT_TYPE_SOURCE = 12; + OBJECT_TYPE_TABLE = 13; + OBJECT_TYPE_TYPE = 14; + OBJECT_TYPE_VIEW = 15; + OBJECT_TYPE_SYSTEM = 16; + OBJECT_TYPE_CONTINUAL_TASK = 17; + OBJECT_TYPE_NETWORK_POLICY = 18; + } + + message IdFullNameV1 { + string id = 1; + FullNameV1 name = 2; + } + + message FullNameV1 { + string database = 1; + string schema = 2; + string item = 3; + } + + message IdNameV1 { + string id = 1; + string name = 2; + } + + message RenameClusterV1 { + string id = 1; + string old_name = 2; + string new_name = 3; + } + + message RenameClusterReplicaV1 { + string cluster_id = 1; + string replica_id = 2; + string old_name = 3; + string new_name = 4; + } + + message RenameItemV1 { + string id = 1; + FullNameV1 old_name = 2; + FullNameV1 new_name = 3; + } + + message CreateClusterReplicaV1 { + string cluster_id = 1; + string cluster_name = 2; + StringWrapper replica_id = 3; + string replica_name = 4; + string logical_size = 5; + bool disk = 6; + optional string billed_as = 7; + bool internal = 8; + } + + message CreateClusterReplicaV2 { + string cluster_id = 1; + string cluster_name = 2; + StringWrapper replica_id = 3; + string replica_name = 4; + string logical_size = 5; + bool disk = 6; + optional string billed_as = 7; + bool internal = 8; + CreateOrDropClusterReplicaReasonV1 reason = 9; + SchedulingDecisionsWithReasonsV1 scheduling_policies = 10; + } + + message DropClusterReplicaV1 { + string cluster_id = 1; + string cluster_name = 2; + StringWrapper replica_id = 3; + string replica_name = 4; + } + + message DropClusterReplicaV2 { + string cluster_id = 1; + string cluster_name = 2; + StringWrapper replica_id = 3; + string replica_name = 4; + CreateOrDropClusterReplicaReasonV1 reason = 5; + SchedulingDecisionsWithReasonsV1 scheduling_policies = 6; + } + + message CreateOrDropClusterReplicaReasonV1 { + oneof reason { + Empty Manual = 1; + Empty Schedule = 2; + Empty System = 3; + } + } + + message SchedulingDecisionsWithReasonsV1 { + RefreshDecisionWithReasonV1 on_refresh = 1; + } + + message RefreshDecisionWithReasonV1 { + oneof decision { + Empty On = 1; + Empty Off = 2; + } + repeated string objects_needing_refresh = 3; + string rehydration_time_estimate = 4; + } + + message CreateSourceSinkV1 { + string id = 1; + FullNameV1 name = 2; + StringWrapper size = 3; + } + + message CreateSourceSinkV2 { + string id = 1; + FullNameV1 name = 2; + StringWrapper size = 3; + string external_type = 4; + } + + message CreateSourceSinkV3 { + string id = 1; + FullNameV1 name = 2; + string external_type = 3; + } + + message CreateSourceSinkV4 { + string id = 1; + StringWrapper cluster_id = 2; + FullNameV1 name = 3; + string external_type = 4; + } + + message CreateIndexV1 { + string id = 1; + string cluster_id = 2; + FullNameV1 name = 3; + } + + message CreateMaterializedViewV1 { + string id = 1; + string cluster_id = 2; + FullNameV1 name = 3; + } + + message AlterSourceSinkV1 { + string id = 1; + FullNameV1 name = 2; + StringWrapper old_size = 3; + StringWrapper new_size = 4; + } + + message AlterSetClusterV1 { + string id = 1; + FullNameV1 name = 2; + StringWrapper old_cluster = 3; + StringWrapper new_cluster = 4; + } + + message GrantRoleV1 { + string role_id = 1; + string member_id = 2; + string grantor_id = 3; + } + + message GrantRoleV2 { + string role_id = 1; + string member_id = 2; + string grantor_id = 3; + string executed_by = 4; + } + + message RevokeRoleV1 { + string role_id = 1; + string member_id = 2; + } + + message RevokeRoleV2 { + string role_id = 1; + string member_id = 2; + string grantor_id = 3; + string executed_by = 4; + } + + message UpdatePrivilegeV1 { + string object_id = 1; + string grantee_id = 2; + string grantor_id = 3; + string privileges = 4; + } + + message AlterDefaultPrivilegeV1 { + string role_id = 1; + StringWrapper database_id = 2; + StringWrapper schema_id = 3; + string grantee_id = 4; + string privileges = 5; + } + + message UpdateOwnerV1 { + string object_id = 1; + string old_owner_id = 2; + string new_owner_id = 3; + } + + message SchemaV1 { + string id = 1; + string name = 2; + string database_name = 3; + } + + message SchemaV2 { + string id = 1; + string name = 2; + StringWrapper database_name = 3; + } + + message RenameSchemaV1 { + string id = 1; + optional string database_name = 2; + string old_name = 3; + string new_name = 4; + } + + message UpdateItemV1 { + string id = 1; + FullNameV1 name = 2; + } + + message AlterRetainHistoryV1 { + string id = 1; + optional string old_history = 2; + optional string new_history = 3; + } + + message ToNewIdV1 { + string id = 1; + string new_id = 2; + } + + message FromPreviousIdV1 { + string id = 1; + string previous_id = 2; + } + + message SetV1 { + string name = 1; + optional string value = 2; + } + + message RotateKeysV1 { + string id = 1; + string name = 2; + } + + uint64 id = 1; + EventType event_type = 2; + ObjectType object_type = 3; + StringWrapper user = 4; + EpochMillis occurred_at = 5; + + // next-id: 40 + oneof details { + CreateClusterReplicaV1 create_cluster_replica_v1 = 6; + CreateClusterReplicaV2 create_cluster_replica_v2 = 33; + DropClusterReplicaV1 drop_cluster_replica_v1 = 7; + DropClusterReplicaV2 drop_cluster_replica_v2 = 34; + CreateSourceSinkV1 create_source_sink_v1 = 8; + CreateSourceSinkV2 create_source_sink_v2 = 9; + AlterSourceSinkV1 alter_source_sink_v1 = 10; + AlterSetClusterV1 alter_set_cluster_v1 = 25; + GrantRoleV1 grant_role_v1 = 11; + GrantRoleV2 grant_role_v2 = 12; + RevokeRoleV1 revoke_role_v1 = 13; + RevokeRoleV2 revoke_role_v2 = 14; + UpdatePrivilegeV1 update_privilege_v1 = 22; + AlterDefaultPrivilegeV1 alter_default_privilege_v1 = 23; + UpdateOwnerV1 update_owner_v1 = 24; + IdFullNameV1 id_full_name_v1 = 15; + RenameClusterV1 rename_cluster_v1 = 20; + RenameClusterReplicaV1 rename_cluster_replica_v1 = 21; + RenameItemV1 rename_item_v1 = 16; + IdNameV1 id_name_v1 = 17; + SchemaV1 schema_v1 = 18; + SchemaV2 schema_v2 = 19; + RenameSchemaV1 rename_schema_v1 = 27; + UpdateItemV1 update_item_v1 = 26; + CreateSourceSinkV3 create_source_sink_v3 = 29; + AlterRetainHistoryV1 alter_retain_history_v1 = 30; + ToNewIdV1 to_new_id_v1 = 31; + FromPreviousIdV1 from_previous_id_v1 = 32; + SetV1 set_v1 = 35; + Empty reset_all_v1 = 36; + RotateKeysV1 rotate_keys_v1 = 37; + CreateSourceSinkV4 create_source_sink_v4 = 38; + CreateIndexV1 create_index_v1 = 39; + CreateMaterializedViewV1 create_materialized_view_v1 = 40; + } +} + +// Wrapper of key-values used by the persist implementation to serialize the catalog. +message StateUpdateKind { + reserved "Epoch"; + + message AuditLog { + AuditLogKey key = 1; + } + + message Cluster { + ClusterKey key = 1; + ClusterValue value = 2; + } + + message ClusterReplica { + ClusterReplicaKey key = 1; + ClusterReplicaValue value = 2; + } + + message Comment { + CommentKey key = 1; + CommentValue value = 2; + } + + message Config { + ConfigKey key = 1; + ConfigValue value = 2; + } + + message Database { + DatabaseKey key = 1; + DatabaseValue value = 2; + } + + message DefaultPrivileges { + DefaultPrivilegesKey key = 1; + DefaultPrivilegesValue value = 2; + } + + message FenceToken { + uint64 deploy_generation = 1; + int64 epoch = 2; + } + + message IdAlloc { + IdAllocKey key = 1; + IdAllocValue value = 2; + } + + message ClusterIntrospectionSourceIndex { + ClusterIntrospectionSourceIndexKey key = 1; + ClusterIntrospectionSourceIndexValue value = 2; + } + + message Item { + ItemKey key = 1; + ItemValue value = 2; + } + + message Role { + RoleKey key = 1; + RoleValue value = 2; + } + + message NetworkPolicy { + NetworkPolicyKey key = 1; + NetworkPolicyValue value = 2; + } + + message Schema { + SchemaKey key = 1; + SchemaValue value = 2; + } + + message Setting { + SettingKey key = 1; + SettingValue value = 2; + } + + message ServerConfiguration { + ServerConfigurationKey key = 1; + ServerConfigurationValue value = 2; + } + + message SourceReferences { + SourceReferencesKey key = 1; + SourceReferencesValue value = 2; + } + + message GidMapping { + GidMappingKey key = 1; + GidMappingValue value = 2; + } + + message SystemPrivileges { + SystemPrivilegesKey key = 1; + SystemPrivilegesValue value = 2; + } + + message StorageCollectionMetadata { + StorageCollectionMetadataKey key = 1; + StorageCollectionMetadataValue value = 2; + } + + message UnfinalizedShard { + UnfinalizedShardKey key = 1; + } + + message TxnWalShard { + TxnWalShardValue value = 1; + } + + reserved 15; + reserved "storage_usage"; + reserved 19; + reserved "timestamp"; + reserved 22; + reserved "persist_txn_shard"; + reserved 8; + reserved "epoch"; + + oneof kind { + AuditLog audit_log = 1; + Cluster cluster = 2; + ClusterReplica cluster_replica = 3; + Comment comment = 4; + Config config = 5; + Database database = 6; + DefaultPrivileges default_privileges = 7; + IdAlloc id_alloc = 9; + ClusterIntrospectionSourceIndex cluster_introspection_source_index = 10; + Item item = 11; + Role role = 12; + Schema schema = 13; + Setting setting = 14; + ServerConfiguration server_configuration = 16; + GidMapping gid_mapping = 17; + SystemPrivileges system_privileges = 18; + StorageCollectionMetadata storage_collection_metadata = 20; + UnfinalizedShard unfinalized_shard = 21; + TxnWalShard txn_wal_shard = 23; + SourceReferences source_references = 24; + FenceToken fence_token = 25; + NetworkPolicy network_policy = 26; + } +} diff --git a/src/catalog/src/durable/initialize.rs b/src/catalog/src/durable/initialize.rs index 155b119e3ae2a..99e1bca9097e9 100644 --- a/src/catalog/src/durable/initialize.rs +++ b/src/catalog/src/durable/initialize.rs @@ -9,9 +9,11 @@ use std::collections::BTreeMap; use std::iter; +use std::str::FromStr; use std::sync::LazyLock; use std::time::Duration; +use ipnet::IpNet; use itertools::max; use mz_audit_log::{CreateOrDropClusterReplicaReasonV1, EventV1, VersionedEvent}; use mz_controller::clusters::ReplicaLogging; @@ -19,11 +21,13 @@ use mz_controller_types::{is_cluster_size_v2, ClusterId, ReplicaId}; use mz_ore::collections::HashSet; use mz_ore::now::EpochMillis; use mz_pgrepr::oid::{ - FIRST_USER_OID, ROLE_PUBLIC_OID, SCHEMA_INFORMATION_SCHEMA_OID, SCHEMA_MZ_CATALOG_OID, - SCHEMA_MZ_CATALOG_UNSTABLE_OID, SCHEMA_MZ_INTERNAL_OID, SCHEMA_MZ_INTROSPECTION_OID, - SCHEMA_MZ_UNSAFE_OID, SCHEMA_PG_CATALOG_OID, + FIRST_USER_OID, NETWORK_POLICIES_DEFAULT_POLICY_OID, ROLE_PUBLIC_OID, + SCHEMA_INFORMATION_SCHEMA_OID, SCHEMA_MZ_CATALOG_OID, SCHEMA_MZ_CATALOG_UNSTABLE_OID, + SCHEMA_MZ_INTERNAL_OID, SCHEMA_MZ_INTROSPECTION_OID, SCHEMA_MZ_UNSAFE_OID, + SCHEMA_PG_CATALOG_OID, }; use mz_repr::adt::mz_acl_item::{AclMode, MzAclItem}; +use mz_repr::network_policy_id::NetworkPolicyId; use mz_repr::role_id::RoleId; use mz_sql::catalog::{ DefaultPrivilegeAclItem, DefaultPrivilegeObject, ObjectType, RoleAttributes, RoleMembership, @@ -32,6 +36,7 @@ use mz_sql::catalog::{ use mz_sql::names::{ DatabaseId, ObjectId, ResolvedDatabaseSpecifier, SchemaId, SchemaSpecifier, PUBLIC_ROLE_NAME, }; +use mz_sql::plan::{NetworkPolicyRule, PolicyAddress}; use mz_sql::rbac; use mz_sql::session::user::{MZ_SUPPORT_ROLE_ID, MZ_SYSTEM_ROLE_ID}; @@ -96,6 +101,31 @@ pub const MZ_INTROSPECTION_SCHEMA_ID: u64 = 8; const DEFAULT_ALLOCATOR_ID: u64 = 1; +pub const DEFAULT_USER_NETWORK_POLICY_ID: NetworkPolicyId = NetworkPolicyId::User(1); +pub const DEFAULT_USER_NETWORK_POLICY_NAME: &str = "default"; +pub const DEFAULT_USER_NETWORK_POLICY_RULES: LazyLock< + Vec<( + &str, + mz_sql::plan::NetworkPolicyRuleAction, + mz_sql::plan::NetworkPolicyRuleDirection, + &str, + )>, +> = LazyLock::new(|| { + vec![( + "open_ingress", + mz_sql::plan::NetworkPolicyRuleAction::Allow, + mz_sql::plan::NetworkPolicyRuleDirection::Ingress, + "0.0.0.0/0", + )] +}); + +static DEFAULT_USER_NETWORK_POLICY_PRIVILEGES: LazyLock> = LazyLock::new(|| { + vec![rbac::owner_privilege( + ObjectType::NetworkPolicy, + MZ_SYSTEM_ROLE_ID, + )] +}); + static SYSTEM_SCHEMA_PRIVILEGES: LazyLock> = LazyLock::new(|| { vec![ rbac::default_builtin_object_privilege(mz_sql::catalog::ObjectType::Schema), @@ -549,6 +579,40 @@ pub(crate) async fn initialize( }); }; + tx.insert_network_policy( + DEFAULT_USER_NETWORK_POLICY_ID, + DEFAULT_USER_NETWORK_POLICY_NAME.to_string(), + DEFAULT_USER_NETWORK_POLICY_RULES + .clone() + .into_iter() + .map(|(name, action, direction, ip_str)| NetworkPolicyRule { + name: name.to_string(), + action: action.clone(), + direction: direction.clone(), + address: PolicyAddress( + IpNet::from_str(ip_str).expect("default policy must provide valid ip"), + ), + }) + .collect::>(), + DEFAULT_USER_NETWORK_POLICY_PRIVILEGES.clone(), + MZ_SYSTEM_ROLE_ID, + NETWORK_POLICIES_DEFAULT_POLICY_OID, + )?; + // We created a network policy with a prefined ID user(1) and OID. We need + // to increment the id alloc key. It should be safe to assume that there's + // no user(1), as a sanity check, we'll assert this is the case. + let id = tx.get_and_increment_id(USER_NETWORK_POLICY_ID_ALLOC_KEY.to_string())?; + assert!(DEFAULT_USER_NETWORK_POLICY_ID == NetworkPolicyId::User(id)); + + audit_events.extend([( + mz_audit_log::EventType::Create, + mz_audit_log::ObjectType::NetworkPolicy, + mz_audit_log::EventDetails::IdNameV1(mz_audit_log::IdNameV1 { + id: DEFAULT_USER_NETWORK_POLICY_ID.to_string(), + name: DEFAULT_USER_NETWORK_POLICY_NAME.to_string(), + }), + )]); + tx.insert_user_cluster( DEFAULT_USER_CLUSTER_ID, DEFAULT_USER_CLUSTER_NAME, @@ -578,6 +642,7 @@ pub(crate) async fn initialize( }), ), ]); + // Optionally add a privilege for the bootstrap role. if let Some(role) = &bootstrap_role { let role_id: RoleId = role.id.clone(); diff --git a/src/catalog/src/durable/upgrade.rs b/src/catalog/src/durable/upgrade.rs index 8ea6ce3849f11..8d6220abf1e9c 100644 --- a/src/catalog/src/durable/upgrade.rs +++ b/src/catalog/src/durable/upgrade.rs @@ -181,14 +181,14 @@ macro_rules! objects { } } -objects!(v67, v68, v69); +objects!(v67, v68, v69, v70); /// The current version of the `Catalog`. /// /// We will initialize new `Catalog`es with this version, and migrate existing `Catalog`es to this /// version. Whenever the `Catalog` changes, e.g. the protobufs we serialize in the `Catalog` /// change, we need to bump this version. -pub const CATALOG_VERSION: u64 = 69; +pub const CATALOG_VERSION: u64 = 70; /// The minimum `Catalog` version number that we support migrating from. /// @@ -202,6 +202,7 @@ const FUTURE_VERSION: u64 = CATALOG_VERSION + 1; mod v67_to_v68; mod v68_to_v69; +mod v69_to_v70; /// Describes a single action to take during a migration from `V1` to `V2`. #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)] @@ -282,6 +283,7 @@ async fn run_upgrade( 67 => run_versioned_upgrade(unopened_catalog_state, version, v67_to_v68::upgrade).await, 68 => run_versioned_upgrade(unopened_catalog_state, version, v68_to_v69::upgrade).await, + 69 => run_versioned_upgrade(unopened_catalog_state, version, v69_to_v70::upgrade).await, // Up-to-date, no migration needed! CATALOG_VERSION => Ok(CATALOG_VERSION), diff --git a/src/catalog/src/durable/upgrade/snapshots/objects_v70.txt b/src/catalog/src/durable/upgrade/snapshots/objects_v70.txt new file mode 100644 index 0000000000000..4075e5733207e --- /dev/null +++ b/src/catalog/src/durable/upgrade/snapshots/objects_v70.txt @@ -0,0 +1,100 @@ +CnAKbroBawoVCgRraW5kEg1CC1R4bldhbFNoYXJkClIKBXZhbHVlEkm6AUYKRAoFc2hhcmQSO0I5XEN28JGKjWDwn4W8LkbgtIbigIngsrPOhsOIezoqbiJm4LqEIuGAqOCzoyfwnqSa8JG/gHjwnoS7 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 +ClwKWroBVwolChFkZXBsb3lfZ2VuZXJhdGlvbhIQwgENCgsBCEIxIZNgdpYBbAoYCgVlcG9jaBIPwgEMCgqFmYgTlSIEYEONChQKBGtpbmQSDEIKRmVuY2VUb2tlbg== +CnEKb7oBbAoUCgNrZXkSDboBCgoICgJpZBICCAQKIwoEa2luZBIbQhlTdG9yYWdlQ29sbGVjdGlvbk1ldGFkYXRhCi8KBXZhbHVlEia6ASMKIQoFc2hhcmQSGEIW6qyG8LGrpGd24bWpwqXDiuCpmickcA== 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 +CswnCsknugHFJwoUCgNrZXkSDboBCgoICgJpZBICCAQKEAoEa2luZBIIQgZTY2hlbWEKmicKBXZhbHVlEpAnugGMJwofCgtkYXRhYmFzZV9pZBIQugENCgsKBXZhbHVlEgIIBAoTCgRuYW1lEgtCCfCWq4JXyLo9IgoSCgNvaWQSC8IBCAoGBBhzRJKcCg4KCG93bmVyX2lkEgIIBAqvJgoKcHJpdmlsZWdlcxKgJrIBnCYKP7oBPAoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAoNCgdncmFudG9yEgIIBApeugFbCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAVOUiEcGKBF0ZGwKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAoNCgdncmFudG9yEgIIBApQugFNCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAVCEJVRmVxlTM3wKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKP7oBPAoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAoNCgdncmFudG9yEgIIBApQugFNCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAWY4aEUVACmXdDwKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKaLoBZQo3CghhY2xfbW9kZRIrugEoCiYKCGJpdGZsYWdzEhrCARcKChWIGWUVQJEABWwQ////////////AQobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECg0KB2dyYW50b3ISAggECk+6AUwKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECisKB2dyYW50b3ISILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEACqEBugGdAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCoZIBmNJAyQCNmwKNgoHZ3JhbnRlZRIrugEoCiYKBXZhbHVlEh26ARoKGAoEVXNlchIQwgENCgsBZHYGNyKXICR5bAo1CgdncmFudG9yEiq6AScKJQoFdmFsdWUSHLoBGQoXCgRVc2VyEg/CAQwKCmJSAzggcTmUCSwKT7oBTAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCoZRGFFYWCI5hzwKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKWboBVgoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKNQoHZ3JhbnRvchIqugEnCiUKBXZhbHVlEhy6ARkKFwoEVXNlchIPwgEMCgp0EmEpKRcikmkcCjG6AS4KDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECmS6AWEKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECkAKB2dyYW50b3ISNboBMgowCgV2YWx1ZRInugEkCiIKBFVzZXISGsIBFwoKB1lVIVNxBDRDfBD///////////8BCmq6AWcKDgoIYWNsX21vZGUSAggECkYKB2dyYW50ZWUSO7oBOAo2CgV2YWx1ZRItugEqCigKClByZWRlZmluZWQSGsIBFwoKA3UieYVZiAaVLBD///////////8BCg0KB2dyYW50b3ISAggECo0BugGJAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCkgFmBJichGHQXwKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAo8CgdncmFudG9yEjG6AS4KLAoFdmFsdWUSI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwFCmYElWDYJN2ZMCl+6AVwKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECjsKB2dyYW50b3ISMLoBLQorCgV2YWx1ZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKeSeIJ2UzgoiXbAo/ugE8Cg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECly6AVkKDgoIYWNsX21vZGUSAggECjgKB2dyYW50ZWUSLboBKgooCgV2YWx1ZRIfugEcChoKBlN5c3RlbRIQwgENCgsBKAhlkHlAV5CVjAoNCgdncmFudG9yEgIIBAoxugEuCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAoxugEuCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAoxugEuCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAo/ugE8Cg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECk+6AUwKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgqBQ0MWJHdWIwM8Cg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECnq6AXcKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBOGBJBSNSRVIxjAoNCgdncmFudGVlEgIIBAo3CgdncmFudG9yEiy6ASkKJwoFdmFsdWUSHroBGwoZCgZTeXN0ZW0SD8IBDAoKeYcmmXOCRBASTAprugFoCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKOBdHcgiImTEDjAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKfroBewotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFWFGI5FwF2mHCMCjsKB2dyYW50ZWUSMLoBLQorCgV2YWx1ZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKQ2F2IhhhZylSXAoNCgdncmFudG9yEgIIBApOugFLCisKCGFjbF9tb2RlEh+6ARwKGgoIYml0ZmxhZ3MSDsIBCwoJCXBZJ5N2UXQcCg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECjG6AS4KDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECl66AVsKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBMzVDlhESJUA1bAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECg0KB2dyYW50b3ISAggEClu6AVgKDgoIYWNsX21vZGUSAggECjcKB2dyYW50ZWUSLLoBKQonCgV2YWx1ZRIeugEbChkKBlN5c3RlbRIPwgEMCgpRUFEVNhgheQccCg0KB2dyYW50b3ISAggECk+6AUwKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgoiB4Nyl3GHiSRMCg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECj+6ATwKDgoIYWNsX21vZGUSAggEChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKDQoHZ3JhbnRvchICCAQKeroBdwotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEjWHNmEAlzVwGcCjcKB2dyYW50ZWUSLLoBKQonCgV2YWx1ZRIeugEbChkKBlN5c3RlbRIPwgEMCgpmIBhVJDSSgJJsCg0KB2dyYW50b3ISAggECl26AVoKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgqZWGOQdpeACYc8Cg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKa7oBaAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKClMUEJOGiDJXGWwKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECjG6AS4KDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggEClq6AVcKNwoIYWNsX21vZGUSK7oBKAomCghiaXRmbGFncxIawgEXCgoXKJGGlhdEVYN8EP///////////wEKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKYLoBXQoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKPAoHZ3JhbnRvchIxugEuCiwKBXZhbHVlEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBZhMXFUVIgHBobApdugFaCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKh5diYplDE3V3jAoNCgdncmFudGVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECmi6AWUKNwoIYWNsX21vZGUSK7oBKAomCghiaXRmbGFncxIawgEXCgoDgQcRkncxKIlsEP///////////wEKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAoNCgdncmFudG9yEgIIBApdugFaCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKk5IpSImIEGREPAoNCgdncmFudGVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECjG6AS4KDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECly6AVkKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECjgKB2dyYW50b3ISLboBKgooCgV2YWx1ZRIfugEcChoKBlN5c3RlbRIQwgENCgsBYBNmZzVYhGFyPApPugFMCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKMzkQYnk2lChibAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBApdugFaCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKAyJTgWIVRwQ5LAoNCgdncmFudGVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECk+6AUwKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECisKB2dyYW50b3ISILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEACocBugGDAQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFnKYEzB4gyIIGcChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKNQoHZ3JhbnRvchIqugEnCiUKBXZhbHVlEhy6ARkKFwoEVXNlchIPwgEMCgoWI1AFMTV4QJRsCny6AXkKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBOXAQIDgIcHFHbAorCgdncmFudGVlEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggEClC6AU0KLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBeFR5Z3cwY2WFXAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBApdugFaCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKZoIXSVYTh4KCPAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECg0KB2dyYW50b3ISAggECjG6AS4KDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECjG6AS4KDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECl26AVoKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgqWV0U3UWJhASacChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKDQoHZ3JhbnRvchICCAQKMboBLgoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKiAG6AYQBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAYEEUycVN5dZFRwKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAo2CgdncmFudG9yEiu6ASgKJgoFdmFsdWUSHboBGgoYCgRVc2VyEhDCAQ0KCwFChSKVIVcGKIFMCl+6AVwKDgoIYWNsX21vZGUSAggECjsKB2dyYW50ZWUSMLoBLQorCgV2YWx1ZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKcZgwhydmOZESnAoNCgdncmFudG9yEgIIBA== +ClsKWboBVgoiCgNrZXkSG7oBGAoWCgJpZBIQugENCgsKBXZhbHVlEgIIBAojCgRraW5kEhtCGVN0b3JhZ2VDb2xsZWN0aW9uTWV0YWRhdGEKCwoFdmFsdWUSAggE +Cm0Ka7oBaAo/CgNrZXkSOLoBNQozCgJpZBItugEqCigKBXZhbHVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwFiQWZkR0gVEoicChgKBGtpbmQSEEIOQ2x1c3RlclJlcGxpY2EKCwoFdmFsdWUSAggE +CvEBCu4BugHqAQqCAQoDa2V5Enu6AXgKPAoLb2JqZWN0X25hbWUSLUIrXO+svvCav73hv7PwkKeD0ajhiqcxVSpSL8i6OisqWix0JUzvv70lPW0gRAoZCgtvYmplY3RfdHlwZRIKwgEHCgVTOAFjbAodCgtzY2hlbWFfbmFtZRIOQgzgqLU/8JCWjToqYEAKFAoEa2luZBIMQgpHaWRNYXBwaW5nCk0KBXZhbHVlEkS6AUEKFgoLZmluZ2VycHJpbnQSB0IFJ/CQhI4KDwoJZ2xvYmFsX2lkEgIIBAoWCgJpZBIQwgENCgsBBBCZkDdUYYdYHA== +CjEKL7oBLAoJCgNrZXkSAggEChIKBGtpbmQSCkIIRGF0YWJhc2UKCwoFdmFsdWUSAggE +CmIKYLoBXQo+CgNrZXkSN7oBNAoyCgNnaWQSK7oBKAomCgV2YWx1ZRIdugEaChgKBFVzZXISEMIBDQoLAUNgdgF3FSMVZSwKDgoEa2luZBIGQgRJdGVtCgsKBXZhbHVlEgIIBA== +CsMBCsABugG8AQqlAQoDa2V5Ep0BugGZAQqWAQoFZXZlbnQSjAG6AYgBCoUBCgJWMRJ/ugF8Cg0KB2RldGFpbHMSAggEChkKCmV2ZW50X3R5cGUSC8IBCAoGAXV1WChNChYKAmlkEhDCAQ0KCwEpWTMlQkBHl4ZcChkKC29iamVjdF90eXBlEgrCAQcKBVYIlBQdChEKC29jY3VycmVkX2F0EgIIBAoKCgR1c2VyEgIIBAoSCgRraW5kEgpCCEF1ZGl0TG9n +CnoKeLoBdQo5CgNrZXkSMroBLwotCgNrZXkSJkIkwqVZP+CnsNGo8J+VtOCviOC1sfCehLHwnrm8WPCfl60/4LOVChAKBGtpbmQSCEIGQ29uZmlnCiYKBXZhbHVlEh26ARoKGAoFdmFsdWUSD8IBDAoKRQR4gUJJN3AnLA== +CjMKMboBLgoJCgNrZXkSAggEChQKBGtpbmQSDEIKR2lkTWFwcGluZwoLCgV2YWx1ZRICCAQ= +CiQKIroBHwoJCgNrZXkSAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= +CnkKd7oBdAoJCgNrZXkSAggECh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgpICgV2YWx1ZRI/ugE8CjoKBXZhbHVlEjFCLyrwlq2syLrwkYyzw4E/aeGJmHnwkLqsJDw8YHAq8J2QvvCegKPwkbS6yLrwnZKi +CjYKNLoBMQoJCgNrZXkSAggEChcKBGtpbmQSD0INTmV0d29ya1BvbGljeQoLCgV2YWx1ZRICCAQ= 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 +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHU2V0dGluZwoLCgV2YWx1ZRICCAQ= +CikKJ7oBJAoVCgRraW5kEg1CC1R4bldhbFNoYXJkCgsKBXZhbHVlEgIIBA== +CmcKZboBYgpDCgNrZXkSPLoBOQo3CgNnaWQSMLoBLQorCgV2YWx1ZRIiugEfCh0KCVRyYW5zaWVudBIQwgENCgsBNUBgEiJhZIUWXAoOCgRraW5kEgZCBEl0ZW0KCwoFdmFsdWUSAggE +Ci8KLboBKgoJCgNrZXkSAggEChAKBGtpbmQSCEIGQ29uZmlnCgsKBXZhbHVlEgIIBA== +Ck4KTLoBSQoJCgNrZXkSAggEChEKBGtpbmQSCUIHSWRBbGxvYwopCgV2YWx1ZRIgugEdChsKB25leHRfaWQSEMIBDQoLAVWYWER4aUMIYBw= +CiwKKroBJwoJCgNrZXkSAggEChoKBGtpbmQSEkIQVW5maW5hbGl6ZWRTaGFyZA== +CrQBCrEBugGtAQpNCgNrZXkSRroBQwpBCgRuYW1lEjlCNyU74rWwJfCRqr/wm7KYIiLCvyHwlryOQnclwqXhv7PwnruxLiZfyLon8J2fg+C3rifIukvgto4KEQoEa2luZBIJQgdTZXR0aW5nCkkKBXZhbHVlEkC6AT0KOwoFdmFsdWUSMkIww4jvv70nUuqbiCbwkYq5ZPCeuZ3CpfCRprzDl+CsgVdSKuCgvjrCpdGoUPCfn6Ni +CjEKL7oBLAoJCgNrZXkSAggEChIKBGtpbmQSCkIIRGF0YWJhc2UKCwoFdmFsdWUSAggE +CjcKNboBMgoJCgNrZXkSAggEChgKBGtpbmQSEEIOQ2x1c3RlclJlcGxpY2EKCwoFdmFsdWUSAggE +CjoKOLoBNQoUCgNrZXkSDboBCgoICgJpZBICCAQKEAoEa2luZBIIQgZTY2hlbWEKCwoFdmFsdWUSAggE +CnMKcboBbgotCgNrZXkSJroBIwoMCgZvYmplY3QSAggEChMKDXN1Yl9jb21wb25lbnQSAggEChEKBGtpbmQSCUIHQ29tbWVudAoqCgV2YWx1ZRIhugEeChwKB2NvbW1lbnQSEUIP4rCA8J6jjz9eKu+/vWwl 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 +CjEKL7oBLAoJCgNrZXkSAggEChIKBGtpbmQSCkIIRGF0YWJhc2UKCwoFdmFsdWUSAggE +CkYKRLoBQQoiCgNrZXkSG7oBGAoWCgJpZBIQugENCgsKBXZhbHVlEgIIBAoOCgRraW5kEgZCBFJvbGUKCwoFdmFsdWUSAggE +CjEKL7oBLAoJCgNrZXkSAggEChIKBGtpbmQSCkIIRGF0YWJhc2UKCwoFdmFsdWUSAggE +ClQKUroBTwotCgNrZXkSJroBIwoMCgZvYmplY3QSAggEChMKDXN1Yl9jb21wb25lbnQSAggEChEKBGtpbmQSCUIHQ29tbWVudAoLCgV2YWx1ZRICCAQ= +ClwKWroBVwolChFkZXBsb3lfZ2VuZXJhdGlvbhIQwgENCgsBMmQCEDR0VxVRfAoYCgVlcG9jaBIPwgEMCgqENjSTaVcwEGA9ChQKBGtpbmQSDEIKRmVuY2VUb2tlbg== +ClsKWboBVgoXCgNrZXkSELoBDQoLCgRuYW1lEgNCATwKEQoEa2luZBIJQgdJZEFsbG9jCigKBXZhbHVlEh+6ARwKGgoHbmV4dF9pZBIPwgEMCgqECTAwIwY0hyks +CiQKIroBHwoJCgNrZXkSAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= +Cm8KbboBagoJCgNrZXkSAggECh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgo+CgV2YWx1ZRI1ugEyCjAKBXZhbHVlEidCJV9O8J2StT/zoIeGJ2xePyY46qyu77+9wqXwkbah8J2VhiXIui8= +CmsKaboBZgpFCgNrZXkSProBOwo5CgNrZXkSMkIwYOGdoTBC4Z+xaF8/45iYfmVw8J6khm468JGwvzvCpVphdDQjwrE8PT/wlr2W1o4jChAKBGtpbmQSCEIGQ29uZmlnCgsKBXZhbHVlEgIIBA== +Ck0KS7oBSAoJCgNrZXkSAggEChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKHgoFdmFsdWUSFboBEgoQCgpwcml2aWxlZ2VzEgIIBA== +ClYKVLoBUQozCgNrZXkSLLoBKQonCgVzaGFyZBIeQhwlLiThiovwm4SyM+C8iD5+Kj/gv4TvtpPwkaSJChoKBGtpbmQSEkIQVW5maW5hbGl6ZWRTaGFyZA== +CjIKMLoBLQoXCgNrZXkSELoBDQoLCgVldmVudBICCAQKEgoEa2luZBIKQghBdWRpdExvZw== +CmYKZLoBYQo2CgNrZXkSL7oBLAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECg0KB2dyYW50b3ISAggEChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwoLCgV2YWx1ZRICCAQ= +Cn8KfboBegpYCgNrZXkSUboBTgpMCgRuYW1lEkRCQuGdsiFtI8O64KyC8JarqWfvuao577+9SvCeuJrCti/gqKrvv70uLTTwkbyB4pGKyLp18JC5tz46IvCRnIbwkbKpJgoRCgRraW5kEglCB1NldHRpbmcKCwoFdmFsdWUSAggE +CmoKaLoBZQomCgNrZXkSH7oBHAoaCgRuYW1lEhJCEFzwkKuXUUQuw5Mk77+9wq8KEQoEa2luZBIJQgdJZEFsbG9jCigKBXZhbHVlEh+6ARwKGgoHbmV4dF9pZBIPwgEMCgozUpcwUAYmlomc +CkoKSLoBRQoJCgNrZXkSAggEChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwocCgV2YWx1ZRITugEQCg4KCGFjbF9tb2RlEgIIBA== +CsABCr0BugG5AQpxCgNrZXkSaroBZwpQCgZvYmplY3QSRroBQwpBCgZTZWNyZXQSN7oBNAoyCgV2YWx1ZRIpugEmCiQKBlN5c3RlbRIawgEXCgoBE2VykGQ0lWhcEP7//////////wEKEwoNc3ViX2NvbXBvbmVudBICCAQKEQoEa2luZBIJQgdDb21tZW50CjEKBXZhbHVlEii6ASUKIwoHY29tbWVudBIYQhZTwqRkLzzwkKCb8JuFpjw68JCgvGwq +CkIKQLoBPQoUCgNrZXkSDboBCgoICgJpZBICCAQKGAoEa2luZBIQQg5DbHVzdGVyUmVwbGljYQoLCgV2YWx1ZRICCAQ= +CnYKdLoBcQpJCgNrZXkSQroBPwo9CgJpZBI3ugE0CjIKBXZhbHVlEim6ASYKJAoGU3lzdGVtEhrCARcKChMwQohnV5eWZkwQ////////////AQoXCgRraW5kEg9CDU5ldHdvcmtQb2xpY3kKCwoFdmFsdWUSAggE +CmwKaroBZwoVCgRraW5kEg1CC1R4bldhbFNoYXJkCk4KBXZhbHVlEkW6AUIKQAoFc2hhcmQSN0I18JG1qD4lTm0i8JGjnirwkYy2wqXgqoN4KvCego/wmr+1ceCxmNGoe/CbgYzgqofwkJmw0ag= +CikKJ7oBJAoVCgRraW5kEg1CC1R4bldhbFNoYXJkCgsKBXZhbHVlEgIIBA== +CjMKMboBLgoJCgNrZXkSAggEChQKBGtpbmQSDEIKR2lkTWFwcGluZwoLCgV2YWx1ZRICCAQ= +CiQKIroBHwoJCgNrZXkSAggEChIKBGtpbmQSCkIIQXVkaXRMb2c= +Ci8KLboBKgoJCgNrZXkSAggEChAKBGtpbmQSCEIGU2NoZW1hCgsKBXZhbHVlEgIIBA== +CrIBCq8BugGrAQoJCgNrZXkSAggEChQKBGtpbmQSDEIKR2lkTWFwcGluZwqHAQoFdmFsdWUSfroBeworCgtmaW5nZXJwcmludBIcQhrwkK6GJGBu0ajvv73grLJaUPCRmZHhiZFOPAoqCglnbG9iYWxfaWQSHboBGgoYCgV2YWx1ZRIPwgEMCgqJSBk0EIR4kWB8CiAKAmlkEhrCARcKChARZiV5WVQDiUwQ////////////AQ== +CjwKOroBNwoJCgNrZXkSAggECh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgoLCgV2YWx1ZRICCAQ= +Ci0KK7oBKAoJCgNrZXkSAggECg4KBGtpbmQSBkIEUm9sZQoLCgV2YWx1ZRICCAQ= +ClsKWboBVgoiCgNrZXkSG7oBGAoWCgJpZBIQugENCgsKBXZhbHVlEgIIBAojCgRraW5kEhtCGVN0b3JhZ2VDb2xsZWN0aW9uTWV0YWRhdGEKCwoFdmFsdWUSAggE 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 +CngKdroBcwoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ29tbWVudApTCgV2YWx1ZRJKugFHCkUKB2NvbW1lbnQSOkI4MPCQurFzJ+Cos9GoOsOLOcOuYCXGg/CegJRcXCXwkbK0POGKtV924Zq0We+5qiJ7P/CRjZ7CqC4= +CnYKdLoBcQoJCgNrZXkSAggEChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKRwoFdmFsdWUSProBOwo5Cgpwcml2aWxlZ2VzEiu6ASgKJgoIYml0ZmxhZ3MSGsIBFwoKBEdQFwFBVpkIHBD///////////8B +CnEKb7oBbAoVCgRraW5kEg1CC1R4bldhbFNoYXJkClMKBXZhbHVlEkq6AUcKRQoFc2hhcmQSPEI6JfCfq6fwkKiOZz5gZ9GoIuCvqWBlwq/gqK8qfV/DkvCdhY3wnoKPL++/vSfhvZt74oKaPTY6JuC3rw== +CkIKQLoBPQoUCgNrZXkSDboBCgoICgJpZBICCAQKGAoEa2luZBIQQg5DbHVzdGVyUmVwbGljYQoLCgV2YWx1ZRICCAQ= +CjkKN7oBNAoJCgNrZXkSAggEChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwoLCgV2YWx1ZRICCAQ= +CokBCoYBugGCAQpGCgNrZXkSP7oBPAorCgdncmFudGVlEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAAoNCgdncmFudG9yEgIIBAoaCgRraW5kEhJCEFN5c3RlbVByaXZpbGVnZXMKHAoFdmFsdWUSE7oBEAoOCghhY2xfbW9kZRICCAQ= +CnAKbroBawoJCgNrZXkSAggECiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQo5CgV2YWx1ZRIwugEtCisKBXNoYXJkEiJCINGoMyTvv71K8KynpighVPCdqq9oYGPitbDwkYyv4Luc +CrwFCrkFugG1BQoUCgNrZXkSDboBCgoICgJpZBICCAQKEAoEa2luZBIIQgZTY2hlbWEKigUKBXZhbHVlEoAFugH8BAoRCgtkYXRhYmFzZV9pZBICCAQKCgoEbmFtZRICQgAKEgoDb2lkEgvCAQgKBgF1kiEEfAocCghvd25lcl9pZBIQugENCgsKBXZhbHVlEgIIBAqoBAoKcHJpdmlsZWdlcxKZBLIBlQQKiQG6AYUBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAWFUWSJllSQySWwKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAo3CgdncmFudG9yEiy6ASkKJwoFdmFsdWUSHroBGwoZCgZTeXN0ZW0SD8IBDAoKEyUUIxUYODUVbAo/ugE8Cg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECl66AVsKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBQWdCN3IgEGIyjAoNCgdncmFudGVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECne6AXQKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpiBTWVmWhWMxNcCjUKB2dyYW50ZWUSKroBJwolCgV2YWx1ZRIcugEZChcKBFVzZXISD8IBDAoKlJknISc4ZTNpTAoNCgdncmFudG9yEgIIBAptugFqCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKEDAmR3dTR1BgfAoNCgdncmFudGVlEgIIBAorCgdncmFudG9yEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAA== +CkoKSLoBRQoJCgNrZXkSAggEChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwocCgV2YWx1ZRITugEQCg4KCGFjbF9tb2RlEgIIBA== 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 +CkIKQLoBPQoUCgNrZXkSDboBCgoICgJpZBICCAQKGAoEa2luZBIQQg5DbHVzdGVyUmVwbGljYQoLCgV2YWx1ZRICCAQ= +CmgKZroBYwoJCgNrZXkSAggEChoKBGtpbmQSEkIQU3lzdGVtUHJpdmlsZWdlcwo6CgV2YWx1ZRIxugEuCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKBUiShWmIcymCLA== +Cq8BCqwBugGoAQoJCgNrZXkSAggEChQKBGtpbmQSDEIKR2lkTWFwcGluZwqEAQoFdmFsdWUSe7oBeApDCgtmaW5nZXJwcmludBI0QjI/TXtN4aeCPS5AQjzIusKlIlxW4KuL8J+VtD/Iumvwnp+72rfwkJOJ340877+9W+CzngoPCglnbG9iYWxfaWQSAggECiAKAmlkEhrCARcKCgFwlxIihyEzd2wQ////////////AQ== +CmwKaroBZwoJCgNrZXkSAggEChsKBGtpbmQSE0IRRGVmYXVsdFByaXZpbGVnZXMKPQoFdmFsdWUSNLoBMQovCgpwcml2aWxlZ2VzEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAXkyhYRxhWYRNUw= +CrUBCrIBugGuAQqIAQoDa2V5EoABugF9ChQKC29iamVjdF9uYW1lEgVCA826KwoZCgtvYmplY3RfdHlwZRIKwgEHCgVJB3RSXApKCgtzY2hlbWFfbmFtZRI7Qjlge+qpn+ODh/CRsILwkYyM4LC98J+dvfCQvb15LuCimMKq4LOHUCJ7PD3wn6+2Kjp48JCTsSfgtYsKFAoEa2luZBIMQgpHaWRNYXBwaW5nCgsKBXZhbHVlEgIIBA== +Co0BCooBugGGAQpHCgNrZXkSQLoBPQo7CgRuYW1lEjNCMfCeuqbwkYO3TTzitKc1YiVvXNGoYPCRg7nIuuCzjfCRo79s8JKRkPCfq7IuQ3JcyLoKEQoEa2luZBIJQgdJZEFsbG9jCigKBXZhbHVlEh+6ARwKGgoHbmV4dF9pZBIPwgEMCgoZaJeHczdYNkYc +CnsKeboBdgpCCgNrZXkSO7oBOAo2CgJpZBIwugEtCisKBXZhbHVlEiK6AR8KHQoJVHJhbnNpZW50EhDCAQ0KCwECiIUEB3MnMQcsCiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQoLCgV2YWx1ZRICCAQ= +Cm8KbboBagoJCgNrZXkSAggEChEKBGtpbmQSCUIHQ29tbWVudApKCgV2YWx1ZRJBugE+CjwKB2NvbW1lbnQSMUIv8JCNkyQ5JCfgsZ3wkLya8J6KmvCQnrjDosOF8JGwgzPhiZg98J6Am/CegIouO3s= +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHU2V0dGluZwoLCgV2YWx1ZRICCAQ= +Ci0KK7oBKAoJCgNrZXkSAggECg4KBGtpbmQSBkIESXRlbQoLCgV2YWx1ZRICCAQ= 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 +CkIKQLoBPQoJCgNrZXkSAggECiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQoLCgV2YWx1ZRICCAQ= +CnMKcboBbgoJCgNrZXkSAggECh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgpCCgV2YWx1ZRI5ugE2CjQKBXZhbHVlEitCKeGds8OYJS4uJvCfgIBcwqXwnp+877+jPC9KPyXIuiDwm7KYePCehYkk +CjMKMboBLgoJCgNrZXkSAggEChQKBGtpbmQSDEIKR2lkTWFwcGluZwoLCgV2YWx1ZRICCAQ= +CjAKLroBKwoJCgNrZXkSAggEChEKBGtpbmQSCUIHU2V0dGluZwoLCgV2YWx1ZRICCAQ= +Cvt0Cvh0ugH0dAoJCgNrZXkSAggEChcKBGtpbmQSD0INTmV0d29ya1BvbGljeQrNdAoFdmFsdWUSw3S6Ab90CjEKBG5hbWUSKUIn8JCKmvCdk7p38J60vWhYV8K3aibwnrmJPD/hqa5zM1zCpUfwkaWUChEKA29pZBIKwgEHCgUBdChHLAocCghvd25lcl9pZBIQugENCgsKBXZhbHVlEgIIBAqpLgoKcHJpdmlsZWdlcxKaLrIBli4KhwG6AYMBCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAYAWZHFVKJdYCVwKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAo1CgdncmFudG9yEiq6AScKJQoFdmFsdWUSHLoBGQoXCgRVc2VyEg/CAQwKCpAAUGQXIJMJmXwKfLoBeQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwEDWBcUQXhDZZZ8CisKB2dyYW50ZWUSILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEAChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKeLoBdQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCpUzVyRQEwlmiJwKDQoHZ3JhbnRlZRICCAQKNgoHZ3JhbnRvchIrugEoCiYKBXZhbHVlEh26ARoKGAoEVXNlchIQwgENCgsBFiJFBgVVE3lXnAoxugEuCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAp9ugF6CiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKVDI5QiUyklV4bAo7CgdncmFudGVlEjC6AS0KKwoFdmFsdWUSIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCnR5dGl4QHA1YDwKDQoHZ3JhbnRvchICCAQKXLoBWQoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKOAoHZ3JhbnRvchItugEqCigKBXZhbHVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwF0l0lmREVWNZI8Cj+6ATwKDgoIYWNsX21vZGUSAggEChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKDQoHZ3JhbnRvchICCAQKfLoBeQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFHmHVlaQFZmQNsCisKB2dyYW50ZWUSILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEAChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKMboBLgoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKjAG6AYgBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKiXBFRTiEkHSVjAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECjsKB2dyYW50b3ISMLoBLQorCgV2YWx1ZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKU2dZUYGTkIIzbApougFlCjcKCGFjbF9tb2RlEiu6ASgKJgoIYml0ZmxhZ3MSGsIBFwoKFHSRYocDUYlHXBD///////////8BCg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKP7oBPAoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAoNCgdncmFudG9yEgIIBAo/ugE8Cg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECjG6AS4KDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECj+6ATwKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKMboBLgoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKP7oBPAoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBAqJAboBhQEKLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgpVUFgIeJeWQSKcChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKOAoHZ3JhbnRvchItugEqCigKBXZhbHVlEh+6ARwKGgoGU3lzdGVtEhDCAQ0KCwFDgpaSU2FRUAUsCl+6AVwKDgoIYWNsX21vZGUSAggECjsKB2dyYW50ZWUSMLoBLQorCgV2YWx1ZRIiugEfCh0KClByZWRlZmluZWQSD8IBDAoKKQUTUSIEMgcxjAoNCgdncmFudG9yEgIIBApbugFYCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAo3CgdncmFudG9yEiy6ASkKJwoFdmFsdWUSHroBGwoZCgZTeXN0ZW0SD8IBDAoKOIV0cig2VZKXXApPugFMCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAorCgdncmFudG9yEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAApPugFMCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKcImVZleSYJBnHAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAq1AboBsQEKLQoIYWNsX21vZGUSIboBHgocCghiaXRmbGFncxIQwgENCgsBdWRoQZUzFwEgHApCCgdncmFudGVlEje6ATQKMgoFdmFsdWUSKboBJgokCgZTeXN0ZW0SGsIBFwoKEWGIJSGXCQIkbBD///////////8BCjwKB2dyYW50b3ISMboBLgosCgV2YWx1ZRIjugEgCh4KClByZWRlZmluZWQSEMIBDQoLAVQiOHBIJxEUZDwKT7oBTAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCnNgJ5MpiRk1CBwKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKjAG6AYgBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKNJNgKXYGRGWHbAo7CgdncmFudGVlEjC6AS0KKwoFdmFsdWUSIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKCjhUc4RhRgEDRUwKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBAp3ugF0CiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKMhRklwR3JBY4jAo1CgdncmFudGVlEiq6AScKJQoFdmFsdWUSHLoBGQoXCgRVc2VyEg/CAQwKCneUgmNZBheJhywKDQoHZ3JhbnRvchICCAQKP7oBPAoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBAp7ugF4CiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKeDJSlkAHJ2OFXAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECisKB2dyYW50b3ISILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEACj+6ATwKDgoIYWNsX21vZGUSAggECg0KB2dyYW50ZWUSAggEChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKbroBawoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAo8CgdncmFudG9yEjG6AS4KLAoFdmFsdWUSI7oBIAoeCgpQcmVkZWZpbmVkEhDCAQ0KCwEQA0BHBGaGkQdsCl26AVoKDgoIYWNsX21vZGUSAggECisKB2dyYW50ZWUSILoBHQobCgV2YWx1ZRISugEPCg0KBlB1YmxpYxIDugEAChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKhgG6AYIBCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKiUmGYhWGckIlLAobCgdncmFudGVlEhC6AQ0KCwoFdmFsdWUSAggECjUKB2dyYW50b3ISKroBJwolCgV2YWx1ZRIcugEZChcKBFVzZXISD8IBDAoKY5YlR2KQVDUlTApuugFrCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLASg5E3kXJBdoNnwKKwoHZ3JhbnRlZRIgugEdChsKBXZhbHVlEhK6AQ8KDQoGUHVibGljEgO6AQAKDQoHZ3JhbnRvchICCAQKeboBdgotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwF0ZwhmhSFYdlI8Cg0KB2dyYW50ZWUSAggECjYKB2dyYW50b3ISK7oBKAomCgV2YWx1ZRIdugEaChgKBFVzZXISEMIBDQoLAVhBYBJQNBU4lCwKT7oBTAosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCliSaJWQkldpgXwKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKaboBZgoOCghhY2xfbW9kZRICCAQKGwoHZ3JhbnRlZRIQugENCgsKBXZhbHVlEgIIBAo3CgdncmFudG9yEiy6ASkKJwoFdmFsdWUSHroBGwoZCgZTeXN0ZW0SD8IBDAoKVEkzhziVhWIyPAoxugEuCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAoxugEuCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAp5ugF2Cg4KCGFjbF9tb2RlEgIIBAorCgdncmFudGVlEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAAo3CgdncmFudG9yEiy6ASkKJwoFdmFsdWUSHroBGwoZCgZTeXN0ZW0SD8IBDAoKYVYWUmcldCFgfAoxugEuCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBApcugFZCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAo4CgdncmFudG9yEi26ASoKKAoFdmFsdWUSH7oBHAoaCgZTeXN0ZW0SEMIBDQoLATlIlVQmgENzJXwKeLoBdQoOCghhY2xfbW9kZRICCAQKNgoHZ3JhbnRlZRIrugEoCiYKBXZhbHVlEh26ARoKGAoEVXNlchIQwgENCgsBGEWTAESDAFVVjAorCgdncmFudG9yEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAApPugFMCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKIlJTcwOSOEmCnAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBApougFlCg4KCGFjbF9tb2RlEgIIBAo2CgdncmFudGVlEiu6ASgKJgoFdmFsdWUSHboBGgoYCgRVc2VyEhDCAQ0KCwFylGFydgJBADBMChsKB2dyYW50b3ISELoBDQoLCgV2YWx1ZRICCAQKP7oBPAoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBAp/ugF8Ci0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAUVoJ2kpJUZnB0wKDQoHZ3JhbnRlZRICCAQKPAoHZ3JhbnRvchIxugEuCiwKBXZhbHVlEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBOZknAkQ1SDkFHApQugFNCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLAXcHUBVlSZMWiRwKDQoHZ3JhbnRlZRICCAQKDQoHZ3JhbnRvchICCAQKP7oBPAoOCghhY2xfbW9kZRICCAQKDQoHZ3JhbnRlZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBApdugFaCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKlUFDAiIjg0E1TAoNCgdncmFudGVlEgIIBAobCgdncmFudG9yEhC6AQ0KCwoFdmFsdWUSAggECoYBugGCAQoOCghhY2xfbW9kZRICCAQKNwoHZ3JhbnRlZRIsugEpCicKBXZhbHVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCnGGWSE0kFFiaXwKNwoHZ3JhbnRvchIsugEpCicKBXZhbHVlEh66ARsKGQoGU3lzdGVtEg/CAQwKCjBoJwAWV2RZJHwKULoBTQotCghhY2xfbW9kZRIhugEeChwKCGJpdGZsYWdzEhDCAQ0KCwFxEDNYRUQDdRGMCg0KB2dyYW50ZWUSAggECg0KB2dyYW50b3ISAggECp0BugGZAQosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKCkaUh0OXN5IwcRwKPAoHZ3JhbnRlZRIxugEuCiwKBXZhbHVlEiO6ASAKHgoKUHJlZGVmaW5lZBIQwgENCgsBFlaWMwkWcGhoHAorCgdncmFudG9yEiC6AR0KGwoFdmFsdWUSEroBDwoNCgZQdWJsaWMSA7oBAApPugFMCiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKZTcFBAhVYSmVLAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBApbugFYCg4KCGFjbF9tb2RlEgIIBAo3CgdncmFudGVlEiy6ASkKJwoFdmFsdWUSHroBGwoZCgZTeXN0ZW0SD8IBDAoKcVWXWFEQeIAZfAoNCgdncmFudG9yEgIIBApZugFWCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAo1CgdncmFudG9yEiq6AScKJQoFdmFsdWUSHLoBGQoXCgRVc2VyEg/CAQwKCoeVMpWHRnmCFDwKbboBagosCghhY2xfbW9kZRIgugEdChsKCGJpdGZsYWdzEg/CAQwKChFWk2RUgpk4cJwKDQoHZ3JhbnRlZRICCAQKKwoHZ3JhbnRvchIgugEdChsKBXZhbHVlEhK6AQ8KDQoGUHVibGljEgO6AQAKggG6AX8KLAoIYWNsX21vZGUSILoBHQobCghiaXRmbGFncxIPwgEMCgopmGGGUkgygGksCkAKB2dyYW50ZWUSNboBMgowCgV2YWx1ZRInugEkCiIKBFVzZXISGsIBFwoKGCQCMEkGeCCUTBD///////////8BCg0KB2dyYW50b3ISAggECk26AUoKDgoIYWNsX21vZGUSAggEChsKB2dyYW50ZWUSELoBDQoLCgV2YWx1ZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBApeugFbCi0KCGFjbF9tb2RlEiG6AR4KHAoIYml0ZmxhZ3MSEMIBDQoLASETaZhgZ5GFJlwKDQoHZ3JhbnRlZRICCAQKGwoHZ3JhbnRvchIQugENCgsKBXZhbHVlEgIIBAoxugEuCg4KCGFjbF9tb2RlEgIIBAoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAp9ugF6CiwKCGFjbF9tb2RlEiC6AR0KGwoIYml0ZmxhZ3MSD8IBDAoKmJGEcwNzNRk5LAo7CgdncmFudGVlEjC6AS0KKwoFdmFsdWUSIroBHwodCgpQcmVkZWZpbmVkEg/CAQwKChkoFnZFcIAlODwKDQoHZ3JhbnRvchICCAQKrEUKBXJ1bGVzEqJFsgGeRQqXAboBkwEKDAoGYWN0aW9uEgIIBApDCgdhZGRyZXNzEjhCNi/wkKSJ8J65rkzwnrmp4oGwIvCSk4TgvoLhirPwkbCVWD9WPTXwkbC74LK576y+4LaDyLrDhAoPCglkaXJlY3Rpb24SAggECi0KBG5hbWUSJUIjZNGo8J6koOCqsuCnl+CrvfCWqqBc8J6fojrwkZCcJvCQqLgKnAG6AZgBChsKBmFjdGlvbhIRugEOCgwKBUFsbG93EgO6AQAKPQoHYWRkcmVzcxIyQjDwkZuHZ/CvpIJgJH0zfiVL77+b8JCdpXsnIiYtN8i6KvCeuLvqqZHvv70iJPCQvIAKIAoJZGlyZWN0aW9uEhO6ARAKDgoHSW5ncmVzcxIDugEAChgKBG5hbWUSEEIOYOGzgl8v8JGcvfCflbQKiwG6AYcBCgwKBmFjdGlvbhICCAQKLwoHYWRkcmVzcxIkQiIlP+G8nCXhn6fgsrY84aCZ4b6HMCZ84L6xw4Thv5rRqEdgCg8KCWRpcmVjdGlvbhICCAQKNQoEbmFtZRItQivIujfCpTou8J64g+Cori3CrOGqh3Pqr4gn8JCsktGoOmAq8JGxo/CRpLg/CnO6AXAKDAoGYWN0aW9uEgIIBAofCgdhZGRyZXNzEhRCEtGoSTw+WFwl8J2qnOKiuy03OwoPCglkaXJlY3Rpb24SAggECi4KBG5hbWUSJkIk77+9OuGvs++/veCxi8Kl8J65pO+/mj8/MXk/dC8u4b+ZIjp6CrQBugGwAQobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEACkEKB2FkZHJlc3MSNkI08J2Ss0hg8JGyoDwr8JCWlV3gq6PwkIOX4Ki/dC7vv5JiYCQv4L+T0ag48J2SouCxgU/CpQogCglkaXJlY3Rpb24SE7oBEAoOCgdJbmdyZXNzEgO6AQAKLAoEbmFtZRIkQiLXgnvDgvCeubfDuiXIuvCRtpfCpeCogiox8JCKgvCSvqskCrQBugGwAQoMCgZhY3Rpb24SAggECj4KB2FkZHJlc3MSM0IxUuqsoVohcOCwj0/Dq/CRnLrCsD9YMSVzXFNCdPCQrZs/Slzvv710JXvvvYPwlJO2JgogCglkaXJlY3Rpb24SE7oBEAoOCgdJbmdyZXNzEgO6AQAKPgoEbmFtZRI2QjTwkISh762BL8KlZvCeubY6OsOc4K6DPSoj4b2T8J6fpFXwnrqlYGZ2RXfhj7nwkK6qJWJ4Cne6AXQKGwoGYWN0aW9uEhG6AQ4KDAoFQWxsb3cSA7oBAAonCgdhZGRyZXNzEhxCGngiYFwqwqviuKXhpKbXmCrgrp7gtp7OhcKwCiAKCWRpcmVjdGlvbhITugEQCg4KB0luZ3Jlc3MSA7oBAAoKCgRuYW1lEgJCAAquAboBqgEKGwoGYWN0aW9uEhG6AQ4KDAoFQWxsb3cSA7oBAApJCgdhZGRyZXNzEj5CPE7RqNGo8Ja8rSZc8JCMiTty4KytP+Gnmj0k0ajRqELgrqMv8J64p1TwkICB4K6HUPCdkqpz4ZyRXMKlJgoPCglkaXJlY3Rpb24SAggECi8KBG5hbWUSJ0Il4K+XVe+thiRdPPCfgaLhv5rhorDwn5W0YC5xzozwn5W0NSrGjAp6ugF3ChsKBmFjdGlvbhIRugEOCgwKBUFsbG93EgO6AQAKKQoHYWRkcmVzcxIeQhwnSnw3eyclSnNz4bC8Ki/hv5LcmTzvv73wkLqrCiAKCWRpcmVjdGlvbhITugEQCg4KB0luZ3Jlc3MSA7oBAAoLCgRuYW1lEgNCAVwKe7oBeAoMCgZhY3Rpb24SAggEChMKB2FkZHJlc3MSCEIGdSLwkJaYCiAKCWRpcmVjdGlvbhITugEQCg4KB0luZ3Jlc3MSA7oBAAoxCgRuYW1lEilCJz3RqE7wkIC98JCol++/vXFZM0x14r+0wqUiQCcmJ+KvmiLwkJOOUwqtAboBqQEKGwoGYWN0aW9uEhG6AQ4KDAoFQWxsb3cSA7oBAApTCgdhZGRyZXNzEkhCRuCysjBY8J6fsO+/vPCeuYviv7bIuvCflbQ9wrbgrohxLNGoOnvRqPCfiZDwnriDWVFOOsKqYG3wkKiV762BNvCdlL3grqMKDwoJZGlyZWN0aW9uEgIIBAokCgRuYW1lEhxCGuqin82+77+98JGFn/Cdg5fhoIU/4YC2InslCmK6AV8KGwoGYWN0aW9uEhG6AQ4KDAoFQWxsb3cSA7oBAAoQCgdhZGRyZXNzEgVCAyZTSQogCglkaXJlY3Rpb24SE7oBEAoOCgdJbmdyZXNzEgO6AQAKDAoEbmFtZRIEQgLDpAqRAboBjQEKGwoGYWN0aW9uEhG6AQ4KDAoFQWxsb3cSA7oBAAo5CgdhZGRyZXNzEi5CLHvvv719IuChueGJpyp24LWIIFxoP/CQj5Twn5W0IuGptfCeuYvwnaqdUcONCg8KCWRpcmVjdGlvbhICCAQKIgoEbmFtZRIaQhhHOi7IuvCQq69W8JGck+Gxhkov8J+bpC4KgQG6AX4KGwoGYWN0aW9uEhG6AQ4KDAoFQWxsb3cSA7oBAAo3CgdhZGRyZXNzEixCKvCRl4Qu8J2IjHx7YPCRmafhqaHRqOCxiCbwkIGLItGo8Kq9mvCQj45LPwoPCglkaXJlY3Rpb24SAggEChUKBG5hbWUSDUILIl3wkK6Ka/CfoIYKdboBcgobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEACjYKB2FkZHJlc3MSK0IpLHsqMOGdpSEvXE06Ii/wn5W0dvCfrqzwkLmrTibwkaSVdWJRKCXvrIIKDwoJZGlyZWN0aW9uEgIIBAoKCgRuYW1lEgJCAAqsAboBqAEKDAoGYWN0aW9uEgIIBAo3CgdhZGRyZXNzEixCKmfwkZyJwqVFfNGo8JKAquGPuFluPDoqZzzCoiXwkYK3J1BkP+Css+KOkgogCglkaXJlY3Rpb24SE7oBEAoOCgdJbmdyZXNzEgO6AQAKPQoEbmFtZRI1QjMqPiPhp5o68JCNuci64KaqPCVeReC9v2YvOi4hw7kvwqXwn5W08JCjsE0uJfCRg7bDkD0KgAG6AX0KGwoGYWN0aW9uEhG6AQ4KDAoFQWxsb3cSA7oBAAogCgdhZGRyZXNzEhVCE3vwn5W0PeC0g0dwJOGdrnt5S1oKDwoJZGlyZWN0aW9uEgIIBAorCgRuYW1lEiNCIe+/vSYvwqIm4bGJ8J2Sq/CRjLLwkaSB4b2nQ1zgsaJ0QwqZAboBlQEKDAoGYWN0aW9uEgIIBAofCgdhZGRyZXNzEhRCEvCflbR08J+CvmDwkJKm4KiDKgogCglkaXJlY3Rpb24SE7oBEAoOCgdJbmdyZXNzEgO6AQAKQgoEbmFtZRI6Qjgue/Cen6nwnrmL8J66hEomw6TwkIGL8J2qnOCohvCQkYzDn2o/PO+/vS09JOCstuG/qPCQoLgnYAqQAboBjAEKGwoGYWN0aW9uEhG6AQ4KDAoFQWxsb3cSA7oBAAocCgdhZGRyZXNzEhFCD/CRv6zgoZ4mMeG8m+CrjAoPCglkaXJlY3Rpb24SAggECj4KBG5hbWUSNkI0PPCbsaXwn5W0ZiJ58JGMs/CdlL0uLy48NuGPuvCRsJbhvoEi8J64uci64LOGJy5l8JGaswpjugFgCgwKBmFjdGlvbhICCAQKGgoHYWRkcmVzcxIPQg1I4bGx8J+VtGfgr5AiCiAKCWRpcmVjdGlvbhITugEQCg4KB0luZ3Jlc3MSA7oBAAoSCgRuYW1lEgpCCC5B77+9Jjw6CqEBugGdAQoMCgZhY3Rpb24SAggECjcKB2FkZHJlc3MSLEIq8JGymjzqpYFe77+9LmBdPDxaT+GgjeCwjzpV4La90ajIuvCav7vhj7pZCg8KCWRpcmVjdGlvbhICCAQKQwoEbmFtZRI7QjngrYvvrJZedPCflbQvJiVU0ag18JCUiSfwn6q/4oCGJyPIuvCfq4Lwn5W0RD3IujMlLjrwkKmsJ00KqgG6AaYBChsKBmFjdGlvbhIRugEOCgwKBUFsbG93EgO6AQAKKwoHYWRkcmVzcxIgQh7grZ1gfPCRhbTjhK3wkJW6cy/jhq4geyo6ReCovl4KIAoJZGlyZWN0aW9uEhO6ARAKDgoHSW5ncmVzcxIDugEACjgKBG5hbWUSMEIu8JGRnSo8YFTjhpXwnrmN8J+vgfCQlYFe4Zym4LGdOi8lyLpg8Juyh+Cug0BQPAqyAboBrgEKGwoGYWN0aW9uEhG6AQ4KDAoFQWxsb3cSA7oBAAo1CgdhZGRyZXNzEipCKPCRho/gsa55YPCRiqDqqaUzLfCQs64o8J65m+CyvMOEJk4xJ/CRtbkKDwoJZGlyZWN0aW9uEgIIBApHCgRuYW1lEj9CPfCRjYs98JCLqeCsjy49WjbRqC5ULOC0gz/hj7LhioHgqIN2wqUq77+9ffCRjYtlYPCRm4ngurpjRMODeSQKlwG6AZMBChsKBmFjdGlvbhIRugEOCgwKBUFsbG93EgO6AQAKLAoHYWRkcmVzcxIhQh/wnoSM8JGMgWxgQ/CRtIjwkLyJLiVq8JuFpi9ew7JyCiAKCWRpcmVjdGlvbhITugEQCg4KB0luZ3Jlc3MSA7oBAAokCgRuYW1lEhxCGtGoLHwv8JGKpCZcWPCRtpFJJmPwlq2Y4K+QCowBugGIAQoMCgZhY3Rpb24SAggECjMKB2FkZHJlc3MSKEIm8JGNpkRjJj8zal17KmHwlq2977+9JjzwnqWeUeC2nFBg8JGGhEMKIAoJZGlyZWN0aW9uEhO6ARAKDgoHSW5ncmVzcxIDugEACiEKBG5hbWUSGUIXbvCRtIU98JGEmjolYci6JVY88JCBi1UKb7oBbAoMCgZhY3Rpb24SAggEChQKB2FkZHJlc3MSCUIH8JCAvSdHYAogCglkaXJlY3Rpb24SE7oBEAoOCgdJbmdyZXNzEgO6AQAKJAoEbmFtZRIcQho/J9Go77+oLiTgtJDCpSciMSLhoJTvrKIiegqvAboBqwEKDAoGYWN0aW9uEgIIBAo1CgdhZGRyZXNzEipCKHVvauCtnUcmJChAe1x777+98JSXoVPhi5IiKm06XO+/g+CmkGjgvJIKIAoJZGlyZWN0aW9uEhO6ARAKDgoHSW5ncmVzcxIDugEACkIKBG5hbWUSOkI48JKRtPCdnpnho5XCpTHIuvCflbTwkYyG8J+rsSQv4LKf8JuyklzgoZ5PJFVIIm0uZeC0hPCfq5UKTLoBSQoMCgZhY3Rpb24SAggEChcKB2FkZHJlc3MSDEIKJvCQkapcwqUjNgoPCglkaXJlY3Rpb24SAggECg8KBG5hbWUSB0IFRnfRqFEKuAG6AbQBCgwKBmFjdGlvbhICCAQKMgoHYWRkcmVzcxInQiU/0agv4K2MYNGoPHvDi8KlLWDvv70qfvCRjZfRqOCpkSjqrIUpCiAKCWRpcmVjdGlvbhITugEQCg4KB0luZ3Jlc3MSA7oBAApOCgRuYW1lEkZCRCR+8JGykk0/XMOQP/CRvYTCpfCeuZvgo4/wkbS6cPCcvotq8J+VtCB78JC6rdGo8JuJtibwkJa5yLrhj7rwnaqsdlw6CmK6AV8KDAoGYWN0aW9uEgIIBAoWCgdhZGRyZXNzEgtCCfCWvpRI8J+VtAoPCglkaXJlY3Rpb24SAggECiYKBG5hbWUSHkIcJfCwnbBbXPCUmJpp8JCUmiTwnrmLw7Pwn5W0PAqvAboBqwEKDAoGYWN0aW9uEgIIBAorCgdhZGRyZXNzEiBCHm7wkYiGe2A8KjEuS0HwkbyB1r/hiZhC4LCWXOC3lgogCglkaXJlY3Rpb24SE7oBEAoOCgdJbmdyZXNzEgO6AQAKTAoEbmFtZRJEQkLCoC8v8J6LtfCflbR4JHzwnrqr8JGMsicgJOOAs/CQpp/wnZ69PyXwkKKGSOqslOGKsiYmw43wr6KZeu+/vVUu374KXboBWgobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEAChIKB2FkZHJlc3MSB0IFO+GctW0KDwoJZGlyZWN0aW9uEgIIBAoWCgRuYW1lEg5CDHtmwqVsbjBtwqJxKgpnugFkCgwKBmFjdGlvbhICCAQKJAoHYWRkcmVzcxIZQhfwk5GB6qmFWmgiJPCdjawk8JGLsOG/ogoPCglkaXJlY3Rpb24SAggECh0KBG5hbWUSFUIT8JGMnOC2vX1j8J6yoOChoeGJkQp4ugF1ChsKBmFjdGlvbhIRugEOCgwKBUFsbG93EgO6AQAKHwoHYWRkcmVzcxIUQhLvuIo3K1Lhr5Iv8JG/sOG9ki4KDwoJZGlyZWN0aW9uEgIIBAokCgRuYW1lEhxCGvCeuKcvKMi6J/CdkrLwkKCAe2TwkK2xwqVzCpQBugGQAQobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEACiUKB2FkZHJlc3MSGkIY8JGnnkEk8J65gidDw4ttQCRgOiTwn5W0Cg8KCWRpcmVjdGlvbhICCAQKOQoEbmFtZRIxQi9V8Jy8s2PhnaBfNPCRgIAmVizgs50/4K6O4Kmb8JGkiSfvubDDhdiW4LqlUz86Ogq4AboBtAEKDAoGYWN0aW9uEgIIBApFCgdhZGRyZXNzEjpCOOC0jvCfiJ3vv70q4KatNTQk8JGEh++/veqtlEfDly9lMy890ajjhJzihK5YIlwn8JCAsOKOgMKlCg8KCWRpcmVjdGlvbhICCAQKTAoEbmFtZRJEQkLIuiPgtq7wkZicYSdrci7igIpH8JGMvOqpkyps8J65n+KynSrwlqyiR3fqp48q8Jatk+K3neGDjcOr8JC0t1HitJkKvQG6AbkBCgwKBmFjdGlvbhICCAQKPwoHYWRkcmVzcxI0QjLwkYO3JUrvv70ve2zIuiTIuiXwmr+4PEov1qjgsq1j8JGBmi4k8JCrs8Kl8JGMnuCptgogCglkaXJlY3Rpb24SE7oBEAoOCgdJbmdyZXNzEgO6AQAKRgoEbmFtZRI+Qjzwn4e5K/CRq5NNyLonKu+/vXHwlqyb8JGwo9GoQFnwkK2a8JCLtuqYpCVz4La14aqDUPCRjLV02JXit4sKlgG6AZIBChsKBmFjdGlvbhIRugEOCgwKBUFsbG93EgO6AQAKJwoHYWRkcmVzcxIcQhp7feqvse+/vSYu8JG1qOKCsi9kPeqroci6TQogCglkaXJlY3Rpb24SE7oBEAoOCgdJbmdyZXNzEgO6AQAKKAoEbmFtZRIgQh5BO0TwkLCXLi7CpTMkyLolIvCeupRPJSJVYDzhsLwKVLoBUQoMCgZhY3Rpb24SAggEChYKB2FkZHJlc3MSC0IJ4oGxXCbwnbypCg8KCWRpcmVjdGlvbhICCAQKGAoEbmFtZRIQQg7vuZDvv73zoIWiM1gnIgqfAboBmwEKGwoGYWN0aW9uEhG6AQ4KDAoFQWxsb3cSA7oBAAovCgdhZGRyZXNzEiRCIvCrjYnwlr+wJNGo8JG+sCpAJOCpgUrqn5Zr8JGyr8K2XFUKIAoJZGlyZWN0aW9uEhO6ARAKDgoHSW5ncmVzcxIDugEACikKBG5hbWUSIUIf8JGDkyIi4pGC8JGKgGJ777+M8J6ftFki8J+VtOC1uApbugFYCgwKBmFjdGlvbhICCAQKFgoHYWRkcmVzcxILQgk84reZcmDhjrkKIAoJZGlyZWN0aW9uEhO6ARAKDgoHSW5ncmVzcxIDugEACg4KBG5hbWUSBkIESOCroQpyugFvCgwKBmFjdGlvbhICCAQKIQoHYWRkcmVzcxIWQhR7J+GkmVzgr4bgs6jhpaY+8JCRkgogCglkaXJlY3Rpb24SE7oBEAoOCgdJbmdyZXNzEgO6AQAKGgoEbmFtZRISQhAvKfCRsL3graBj4q6K0ahgCooBugGGAQoMCgZhY3Rpb24SAggECigKB2FkZHJlc3MSHUIbRzpWOlzwlqmmXiLvv70gUz09Z1/gqZt7IiRVCiAKCWRpcmVjdGlvbhITugEQCg4KB0luZ3Jlc3MSA7oBAAoqCgRuYW1lEiJCID8i8JGMt+Gjr3vwkZeI8JCCoU/hpbNqe/CflbRoL8i6CrsBugG3AQobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEACkEKB2FkZHJlc3MSNkI08J65pOC1mvCeuKLwm7KC4amcU/CflbQlJ+CunuGtl/CeuogvKiE64bK/YntgIvCtlpUiIwoPCglkaXJlY3Rpb24SAggECkQKBG5hbWUSPEI6ayXwnbynwqXgsYfgrqpJNvCWv7Hwlr6VJeChnmUkPdGoYsOk4L2J4YmY6qGD8JG0iT7wkYqN8J28pQqKAboBhgEKGwoGYWN0aW9uEhG6AQ4KDAoFQWxsb3cSA7oBAAobCgdhZGRyZXNzEhBCDuK2h/CQhqA4POqahci6CiAKCWRpcmVjdGlvbhITugEQCg4KB0luZ3Jlc3MSA7oBAAooCgRuYW1lEiBCHuCsiiIvTi/wn5uwKuCrjS4uP+qvm+K/lNGo8J2QkQqFAboBgQEKDAoGYWN0aW9uEgIIBAocCgdhZGRyZXNzEhFCD+CmsvCRlqXgoZ7wkZaJYgogCglkaXJlY3Rpb24SE7oBEAoOCgdJbmdyZXNzEgO6AQAKMQoEbmFtZRIpQiciJtGoOiY88JCAlGXIuvCflbQ8Z/CRsq0nPHzgqIo94LaCe9GoICIKxwG6AcMBChsKBmFjdGlvbhIRugEOCgwKBUFsbG93EgO6AQAKOwoHYWRkcmVzcxIwQi5Z4rWv4aCEJF1gPDrRqOChhSbgqYdgKvCfoZLwnaqe15vwkbWnX/Cdkqvhi4RYCiAKCWRpcmVjdGlvbhITugEQCg4KB0luZ3Jlc3MSA7oBAApFCgRuYW1lEj1COy/wn5ue4K6qJ+CzrPCYoqTCpfCbhZBQbPCRtafqr7k8ZiIu8J65gsKhK/CeubA6ZW5NOvCfnJNIW01YCqIBugGeAQoMCgZhY3Rpb24SAggECicKB2FkZHJlc3MSHEIa3LUt4rqS8JC5p++/vV8xJPCRgIrhuKYmyLoKIAoJZGlyZWN0aW9uEhO6ARAKDgoHSW5ncmVzcxIDugEACkMKBG5hbWUSO0I5d3PwnYWCaiDgvJTgpLPwkbCFQ+KOo++/vTpj8JCBkeCunMKge0tGJvCQsKxy8J2QqcKlS/CflbRECmG6AV4KGwoGYWN0aW9uEhG6AQ4KDAoFQWxsb3cSA7oBAAoVCgdhZGRyZXNzEgpCCOCrjCLwnaqeCg8KCWRpcmVjdGlvbhICCAQKFwoEbmFtZRIPQg1QdPCRqb5o8JGll2hkCkm6AUYKDAoGYWN0aW9uEgIIBAoRCgdhZGRyZXNzEgZCBCUoXU4KDwoJZGlyZWN0aW9uEgIIBAoSCgRuYW1lEgpCCOCrvCUk4b2bCp0BugGZAQobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEAChUKB2FkZHJlc3MSCkIIPOGkhXzhpbQKIAoJZGlyZWN0aW9uEhO6ARAKDgoHSW5ncmVzcxIDugEACkEKBG5hbWUSOUI3LSZP0ajwnZu+WcOAOXJi8JG1pz3vrLtx8J65qSoq8JCdknTwnZKAL/CQlLXCpXBRb21B8J6BmwpyugFvCgwKBmFjdGlvbhICCAQKEgoHYWRkcmVzcxIHQgVjw5MiQgogCglkaXJlY3Rpb24SE7oBEAoOCgdJbmdyZXNzEgO6AQAKKQoEbmFtZRIhQh/hvrfgqZvwrbe4YeG8vFHgqLx74Kis8J+JoeGxuWAkCrEBugGtAQobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEACjEKB2FkZHJlc3MSJkIk8J28iC/iu6TDgvCfh77wkI2AwqUn8JGNl+qtgU0lJnsm4byZCiAKCWRpcmVjdGlvbhITugEQCg4KB0luZ3Jlc3MSA7oBAAo5CgRuYW1lEjFCL0Uqw74lXsOO8JCPkPCfq5LgqZol4KmL15pbKibwkKCb4LqC8JGkifCeoJzwkbKvCsYBugHCAQobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEACjsKB2FkZHJlc3MSMEIuaPCQsozgrqlcyLokUid77Z65Ksi68J65ny5cP+GgsS/wmr+3JS5GP1MnIsKnKgogCglkaXJlY3Rpb24SE7oBEAoOCgdJbmdyZXNzEgO6AQAKRAoEbmFtZRI8Qjrwn4Cn8JG0mXM/8JCWoDrvv71UeTpgZsOQ8JGkliJc4rasWEAnRSTDij3qqoTwkYuV8JCtmUrwn6GBCsUBugHBAQobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEAClAKB2FkZHJlc3MSRUJD8JGRgjzwkbKl4LuG4bGIe/CWvYhS4reIdTPDq1d977+S4KiG8J+VtPCflbRXX+KRiWDgqZ4v77+94LuG4K648JCMkQoPCglkaXJlY3Rpb24SAggECj8KBG5hbWUSN0I18KaFoMKlL/CQrZ3wn6Kw8JaplCfjh48uJPCQjpPIul/CssKi4aOs4YqMW0R7KjrgqZ5gfCgKkAG6AYwBChsKBmFjdGlvbhIRugEOCgwKBUFsbG93EgO6AQAKQgoHYWRkcmVzcxI3QjU8XCfDnPCQo7XgrIg94raqe9aoQuGkkvCdlLZe8JCVuVQlLyrwnrinLeGftlAv8J65sTLRqAoPCglkaXJlY3Rpb24SAggEChgKBG5hbWUSEEIO4q6G0ag64bmMe+qnt3kKrAG6AagBCgwKBmFjdGlvbhICCAQKNQoHYWRkcmVzcxIqQig9UCUkYPCflbTwkbWn4Z2zwqXwkKC38J+JkVw04LaHJCfgtbbwnZWCCiAKCWRpcmVjdGlvbhITugEQCg4KB0luZ3Jlc3MSA7oBAAo/CgRuYW1lEjdCNcKwPDHgprIl8JuLmiJnIuOHmj/DqSrqqqjvvqUuPybwn5W0eC13VG/wkJOv8JGmuT/grrE6CrgBugG0AQobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEACjAKB2FkZHJlc3MSJUIj8JGFhHfvtpUm8J60iCdG8JapoHRi8JChh8KlPOK9mPCen6QKIAoJZGlyZWN0aW9uEhO6ARAKDgoHSW5ncmVzcxIDugEACkEKBG5hbWUSOUI3QCRge3PwkJ2KJTFLS+qlrDfjg6/RqPCQlrzIuvCRq5EiJEDqnrct77+98J+IoCd74ra8SCV7JApsugFpCgwKBmFjdGlvbhICCAQKFgoHYWRkcmVzcxILQgngs5Y8ZD9NYkQKIAoJZGlyZWN0aW9uEhO6ARAKDgoHSW5ncmVzcxIDugEACh8KBG5hbWUSF0IV8J65iUBLJXfRqCXgvYM6UFTwnZKsCoQBugGAAQobCgZhY3Rpb24SEboBDgoMCgVBbGxvdxIDugEACjMKB2FkZHJlc3MSKEIm8J2SomDwm7KB8J+psywue+CxnSbwn5W0ay/wnqWHLz84fvCcvqQKIAoJZGlyZWN0aW9uEhO6ARAKDgoHSW5ncmVzcxIDugEACgoKBG5hbWUSAkIACne6AXQKGwoGYWN0aW9uEhG6AQ4KDAoFQWxsb3cSA7oBAAofCgdhZGRyZXNzEhRCEntv8J+VtHThiorwkY2I4K+wLAoPCglkaXJlY3Rpb24SAggECiMKBG5hbWUSG0IZ77+98J+iqPCRgqZlLmTwkKS/4aCU8J65kQ== +Ck0KS7oBSAoUCgNrZXkSDboBCgoICgJpZBICCAQKIwoEa2luZBIbQhlTdG9yYWdlQ29sbGVjdGlvbk1ldGFkYXRhCgsKBXZhbHVlEgIIBA== +ClYKVLoBUQoyCgNrZXkSK7oBKAomCgJpZBIgugEdChsKBXZhbHVlEhK6AQ8KDQoGUHVibGljEgO6AQAKDgoEa2luZBIGQgRSb2xlCgsKBXZhbHVlEgIIBA== +CnIKcLoBbQoJCgNrZXkSAggEChQKBGtpbmQSDEIKR2lkTWFwcGluZwpKCgV2YWx1ZRJBugE+ChQKC2ZpbmdlcnByaW50EgVCA+GnhAoPCglnbG9iYWxfaWQSAggEChUKAmlkEg/CAQwKCkVIRVNmN1V0dxw= +CiwKKroBJwoJCgNrZXkSAggEChoKBGtpbmQSEkIQVW5maW5hbGl6ZWRTaGFyZA== +ClEKT7oBTAoJCgNrZXkSAggECh0KBGtpbmQSFUITU2VydmVyQ29uZmlndXJhdGlvbgogCgV2YWx1ZRIXugEUChIKBXZhbHVlEglCB0jvv73gtr0= +Cj4KPLoBOQoXCgNrZXkSELoBDQoLCgRuYW1lEgNCAWsKEQoEa2luZBIJQgdJZEFsbG9jCgsKBXZhbHVlEgIIBA== +Ci8KLboBKgoJCgNrZXkSAggEChAKBGtpbmQSCEIGQ29uZmlnCgsKBXZhbHVlEgIIBA== +Cn8KfboBegoJCgNrZXkSAggEChEKBGtpbmQSCUIHU2V0dGluZwpaCgV2YWx1ZRJRugFOCkwKBXZhbHVlEkNCQXvwl76Ew5tlP1zCr+GiqDo6JfCQrZEqJ3M88J+Aji/wn5W0Z3XwlqmgSEp7a/CQoI/wm7Gw4K2W8J+giPCQqIYo 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 +ClgKVroBUwooCgNrZXkSIboBHgoNCgdncmFudGVlEgIIBAoNCgdncmFudG9yEgIIBAoaCgRraW5kEhJCEFN5c3RlbVByaXZpbGVnZXMKCwoFdmFsdWUSAggE +CiwKKroBJwoJCgNrZXkSAggEChoKBGtpbmQSEkIQVW5maW5hbGl6ZWRTaGFyZA== +CrcBCrQBugGwAQp2CgNrZXkSb7oBbAo5CgpjbHVzdGVyX2lkEiu6ASgKJgoFdmFsdWUSHboBGgoYCgRVc2VyEhDCAQ0KCwF1MiJ2ckSBiXlsCi8KBG5hbWUSJ0Il8J+VtOC1oi7gr5dcwqXgtr3gsIZifXd5P1PgqoElTyTwkKa+JQopCgRraW5kEiFCH0NsdXN0ZXJJbnRyb3NwZWN0aW9uU291cmNlSW5kZXgKCwoFdmFsdWUSAggE +CjIKMLoBLQoXCgNrZXkSELoBDQoLCgVldmVudBICCAQKEgoEa2luZBIKQghBdWRpdExvZw== +CkIKQLoBPQoJCgNrZXkSAggECiMKBGtpbmQSG0IZU3RvcmFnZUNvbGxlY3Rpb25NZXRhZGF0YQoLCgV2YWx1ZRICCAQ= +CkgKRroBQwoJCgNrZXkSAggECikKBGtpbmQSIUIfQ2x1c3RlckludHJvc3BlY3Rpb25Tb3VyY2VJbmRleAoLCgV2YWx1ZRICCAQ= diff --git a/src/catalog/src/durable/upgrade/v68_to_v69.rs b/src/catalog/src/durable/upgrade/v68_to_v69.rs index 7e544541350eb..fdb586d5a2234 100644 --- a/src/catalog/src/durable/upgrade/v68_to_v69.rs +++ b/src/catalog/src/durable/upgrade/v68_to_v69.rs @@ -14,5 +14,5 @@ use crate::durable::upgrade::{objects_v68 as v68, objects_v69 as v69}; pub fn upgrade( _snapshot: Vec, ) -> Vec> { - Vec::new() + vec![] } diff --git a/src/catalog/src/durable/upgrade/v69_to_v70.rs b/src/catalog/src/durable/upgrade/v69_to_v70.rs new file mode 100644 index 0000000000000..581cfeb3b838e --- /dev/null +++ b/src/catalog/src/durable/upgrade/v69_to_v70.rs @@ -0,0 +1,122 @@ +// Copyright Materialize, Inc. and contributors. All rights reserved. +// +// Use of this software is governed by the Business Source License +// included in the LICENSE file. +// +// As of the Change Date specified in that file, in accordance with +// the Business Source License, use of this software will be governed +// by the Apache License, Version 2.0. + +use std::sync::LazyLock; + +use mz_pgrepr::oid::NETWORK_POLICIES_DEFAULT_POLICY_OID; +use mz_sql::plan::{NetworkPolicyRuleAction, NetworkPolicyRuleDirection}; + +use crate::durable::upgrade::objects_v70::Empty; + +use crate::durable::upgrade::MigrationAction; +use crate::durable::upgrade::{objects_v69 as v69, objects_v70 as v70}; + +const DEFAULT_USER_NETWORK_POLICY_NAME: &str = "default"; +const DEFAULT_USER_NETWORK_POLICY_RULES: LazyLock< + Vec<( + &str, + mz_sql::plan::NetworkPolicyRuleAction, + mz_sql::plan::NetworkPolicyRuleDirection, + &str, + )>, +> = LazyLock::new(|| { + vec![( + "open_ingress", + mz_sql::plan::NetworkPolicyRuleAction::Allow, + mz_sql::plan::NetworkPolicyRuleDirection::Ingress, + "0.0.0.0/0", + )] +}); + +const MZ_SYSTEM_ROLE_ID: u64 = 1; +const MZ_SUPPORT_ROLE_ID: u64 = 2; + +/// In v69, we add the Network Policy resources. +pub fn upgrade( + _snapshot: Vec, +) -> Vec> { + let policy = v70::state_update_kind::NetworkPolicy { + key: Some(v70::NetworkPolicyKey { + id: Some(v70::NetworkPolicyId { + value: Some(v70::network_policy_id::Value::User(1)), + }), + }), + value: Some(v70::NetworkPolicyValue { + name: DEFAULT_USER_NETWORK_POLICY_NAME.to_string(), + rules: DEFAULT_USER_NETWORK_POLICY_RULES + .clone() + .into_iter() + .map(|(name, action, direction, ip_str)| v70::NetworkPolicyRule { + name: name.to_string(), + action: Some(action.into()), + direction: Some(direction.into()), + address: ip_str.to_string(), + }) + .collect::>(), + owner_id: Some(v70::RoleId { + value: Some(v70::role_id::Value::System(MZ_SYSTEM_ROLE_ID)), + }), + privileges: vec![ + v70::MzAclItem { + grantee: Some(v70::RoleId { + value: Some(v70::role_id::Value::Public(Empty {})), + }), + grantor: Some(v70::RoleId { + value: Some(v70::role_id::Value::System(MZ_SYSTEM_ROLE_ID)), + }), + // usage + acl_mode: Some(v70::AclMode { bitflags: 256 }), + }, + v70::MzAclItem { + grantee: Some(v70::RoleId { + value: Some(v70::role_id::Value::System(MZ_SUPPORT_ROLE_ID)), + }), + grantor: Some(v70::RoleId { + value: Some(v70::role_id::Value::System(MZ_SYSTEM_ROLE_ID)), + }), + // usage + acl_mode: Some(v70::AclMode { bitflags: 256 }), + }, + v70::MzAclItem { + grantee: Some(v70::RoleId { + value: Some(v70::role_id::Value::System(MZ_SYSTEM_ROLE_ID)), + }), + grantor: Some(v70::RoleId { + value: Some(v70::role_id::Value::System(MZ_SYSTEM_ROLE_ID)), + }), + // usage_create + acl_mode: Some(v70::AclMode { bitflags: 768 }), + }, + ], + oid: NETWORK_POLICIES_DEFAULT_POLICY_OID, + }), + }; + + vec![MigrationAction::Insert(v70::StateUpdateKind { + kind: Some(v70::state_update_kind::Kind::NetworkPolicy(policy)), + })] +} + +impl From for v70::network_policy_rule::Action { + fn from(action: NetworkPolicyRuleAction) -> Self { + match action { + NetworkPolicyRuleAction::Allow => v70::network_policy_rule::Action::Allow(Empty {}), + } + } +} + +impl From for v70::network_policy_rule::Direction { + fn from(direction: NetworkPolicyRuleDirection) -> Self { + match direction { + NetworkPolicyRuleDirection::Ingress => { + v70::network_policy_rule::Direction::Ingress(Empty {}) + } + } + } +} diff --git a/src/catalog/tests/snapshots/debug__opened_trace.snap b/src/catalog/tests/snapshots/debug__opened_trace.snap index 626f1a76c38de..b88a9bec0efa3 100644 --- a/src/catalog/tests/snapshots/debug__opened_trace.snap +++ b/src/catalog/tests/snapshots/debug__opened_trace.snap @@ -256,6 +256,38 @@ Trace { AuditLogEventV1 { id: 8, event_type: Create, + object_type: NetworkPolicy, + user: None, + occurred_at: Some( + EpochMillis { + millis: 0, + }, + ), + details: Some( + IdNameV1( + IdNameV1 { + id: "u1", + name: "default", + }, + ), + ), + }, + ), + ), + }, + (), + ), + 2, + 1, + ), + ( + ( + AuditLogKey { + event: Some( + V1( + AuditLogEventV1 { + id: 9, + event_type: Create, object_type: Cluster, user: None, occurred_at: Some( @@ -286,7 +318,7 @@ Trace { event: Some( V1( AuditLogEventV1 { - id: 9, + id: 10, event_type: Grant, object_type: Cluster, user: None, @@ -320,7 +352,7 @@ Trace { event: Some( V1( AuditLogEventV1 { - id: 10, + id: 11, event_type: Create, object_type: ClusterReplica, user: None, @@ -372,7 +404,7 @@ Trace { event: Some( V1( AuditLogEventV1 { - id: 11, + id: 12, event_type: Grant, object_type: System, user: None, @@ -906,7 +938,7 @@ Trace { name: "auditlog", }, IdAllocValue { - next_id: 12, + next_id: 13, }, ), 2, @@ -1038,7 +1070,7 @@ Trace { name: "user_network_policy", }, IdAllocValue { - next_id: 1, + next_id: 2, }, ), 2, @@ -1062,7 +1094,81 @@ Trace { values: [], }, network_policies: CollectionTrace { - values: [], + values: [ + ( + ( + NetworkPolicyKey { + id: Some( + NetworkPolicyId { + value: Some( + User( + 1, + ), + ), + }, + ), + }, + NetworkPolicyValue { + name: "default", + rules: [ + NetworkPolicyRule { + name: "open_ingress", + address: "0.0.0.0/0", + action: Some( + Allow( + Empty, + ), + ), + direction: Some( + Ingress( + Empty, + ), + ), + }, + ], + owner_id: Some( + RoleId { + value: Some( + System( + 1, + ), + ), + }, + ), + privileges: [ + MzAclItem { + grantee: Some( + RoleId { + value: Some( + System( + 1, + ), + ), + }, + ), + grantor: Some( + RoleId { + value: Some( + System( + 1, + ), + ), + }, + ), + acl_mode: Some( + AclMode { + bitflags: 256, + }, + ), + }, + ], + oid: 17044, + }, + ), + 2, + 1, + ), + ], }, roles: CollectionTrace { values: [ diff --git a/src/catalog/tests/snapshots/open__initial_audit_log.snap b/src/catalog/tests/snapshots/open__initial_audit_log.snap index a7ce419f6c8ed..6a8a0cf500b89 100644 --- a/src/catalog/tests/snapshots/open__initial_audit_log.snap +++ b/src/catalog/tests/snapshots/open__initial_audit_log.snap @@ -1,6 +1,5 @@ --- source: src/catalog/tests/open.rs -assertion_line: 444 expression: audit_log --- [ @@ -130,6 +129,21 @@ expression: audit_log EventV1 { id: 8, event_type: Create, + object_type: NetworkPolicy, + details: IdNameV1( + IdNameV1 { + id: "u1", + name: "default", + }, + ), + user: None, + occurred_at: 0, + }, + ), + V1( + EventV1 { + id: 9, + event_type: Create, object_type: Cluster, details: IdNameV1( IdNameV1 { @@ -143,7 +157,7 @@ expression: audit_log ), V1( EventV1 { - id: 9, + id: 10, event_type: Grant, object_type: Cluster, details: UpdatePrivilegeV1( @@ -160,7 +174,7 @@ expression: audit_log ), V1( EventV1 { - id: 10, + id: 11, event_type: Create, object_type: ClusterReplica, details: CreateClusterReplicaV2( @@ -185,7 +199,7 @@ expression: audit_log ), V1( EventV1 { - id: 11, + id: 12, event_type: Grant, object_type: System, details: UpdatePrivilegeV1( diff --git a/src/catalog/tests/snapshots/open__initial_snapshot.snap b/src/catalog/tests/snapshots/open__initial_snapshot.snap index f20a54b6bc8d0..be07407c40229 100644 --- a/src/catalog/tests/snapshots/open__initial_snapshot.snap +++ b/src/catalog/tests/snapshots/open__initial_snapshot.snap @@ -1238,7 +1238,74 @@ Snapshot { ), }, }, - network_policies: {}, + network_policies: { + NetworkPolicyKey { + id: Some( + NetworkPolicyId { + value: Some( + User( + 1, + ), + ), + }, + ), + }: NetworkPolicyValue { + name: "default", + rules: [ + NetworkPolicyRule { + name: "open_ingress", + address: "0.0.0.0/0", + action: Some( + Allow( + Empty, + ), + ), + direction: Some( + Ingress( + Empty, + ), + ), + }, + ], + owner_id: Some( + RoleId { + value: Some( + System( + 1, + ), + ), + }, + ), + privileges: [ + MzAclItem { + grantee: Some( + RoleId { + value: Some( + System( + 1, + ), + ), + }, + ), + grantor: Some( + RoleId { + value: Some( + System( + 1, + ), + ), + }, + ), + acl_mode: Some( + AclMode { + bitflags: 256, + }, + ), + }, + ], + oid: 17044, + }, + }, cluster_replicas: { ClusterReplicaKey { id: Some( @@ -1304,7 +1371,7 @@ Snapshot { IdAllocKey { name: "auditlog", }: IdAllocValue { - next_id: 12, + next_id: 13, }, IdAllocKey { name: "database", @@ -1359,7 +1426,7 @@ Snapshot { IdAllocKey { name: "user_network_policy", }: IdAllocValue { - next_id: 1, + next_id: 2, }, IdAllocKey { name: "user_role", diff --git a/src/pgrepr-consts/src/oid.rs b/src/pgrepr-consts/src/oid.rs index 872b1b42f7246..7cdf107fae30e 100644 --- a/src/pgrepr-consts/src/oid.rs +++ b/src/pgrepr-consts/src/oid.rs @@ -763,3 +763,4 @@ pub const TABLE_MZ_NETWORK_POLICIES_OID: u32 = 17040; pub const TABLE_MZ_NETWORK_POLICY_RULES_OID: u32 = 17041; pub const VIEW_MZ_INDEX_ADVICE_OID: u32 = 17042; pub const VIEW_MZ_SHOW_NETWORK_POLICIES_OID: u32 = 17043; +pub const NETWORK_POLICIES_DEFAULT_POLICY_OID: u32 = 17044; diff --git a/src/sql/src/session/vars.rs b/src/sql/src/session/vars.rs index fd44c4ac3c6ab..7fd8a178781c1 100644 --- a/src/sql/src/session/vars.rs +++ b/src/sql/src/session/vars.rs @@ -75,7 +75,6 @@ use std::time::Duration; use chrono::{DateTime, Utc}; use im::OrdMap; -use ipnet::IpNet; use mz_build_info::BuildInfo; use mz_dyncfg::{ConfigSet, ConfigType, ConfigUpdates, ConfigVal}; use mz_ore::cast::CastFrom; @@ -1251,7 +1250,7 @@ impl SystemVars { &KAFKA_DEFAULT_METADATA_FETCH_INTERVAL, &ENABLE_LAUNCHDARKLY, &MAX_CONNECTIONS, - &DEFAULT_NETWORK_POLICY_ALLOW_LIST, + &NETWORK_POLICY, &SUPERUSER_RESERVED_CONNECTIONS, &KEEP_N_SOURCE_STATUS_HISTORY_ENTRIES, &KEEP_N_SINK_STATUS_HISTORY_ENTRIES, @@ -1429,7 +1428,9 @@ impl SystemVars { /// Returns whether or not this parameter can be modified by a superuser. pub fn user_modifiable(&self, name: &str) -> bool { - Self::SESSION_VARS.contains_key(UncasedStr::new(name)) || name == ENABLE_RBAC_CHECKS.name() + Self::SESSION_VARS.contains_key(UncasedStr::new(name)) + || name == ENABLE_RBAC_CHECKS.name() + || name == NETWORK_POLICY.name() } /// Returns a [`Var`] representing the configuration parameter with the @@ -2046,9 +2047,8 @@ impl SystemVars { *self.expect_value(&MAX_CONNECTIONS) } - pub fn default_network_policy(&self) -> Vec { - self.expect_value::>(&DEFAULT_NETWORK_POLICY_ALLOW_LIST) - .clone() + pub fn default_network_policy_name(&self) -> String { + self.expect_value::(&NETWORK_POLICY).clone() } /// Returns the `superuser_reserved_connections` configuration parameter. diff --git a/src/sql/src/session/vars/definitions.rs b/src/sql/src/session/vars/definitions.rs index de3198253b861..33df01e7358a1 100644 --- a/src/sql/src/session/vars/definitions.rs +++ b/src/sql/src/session/vars/definitions.rs @@ -15,7 +15,6 @@ use std::time::Duration; use chrono::{DateTime, Utc}; use derivative::Derivative; -use ipnet::IpNet; use mz_adapter_types::timestamp_oracle::{ DEFAULT_PG_TIMESTAMP_ORACLE_CONNPOOL_MAX_SIZE, DEFAULT_PG_TIMESTAMP_ORACLE_CONNPOOL_MAX_WAIT, DEFAULT_PG_TIMESTAMP_ORACLE_CONNPOOL_TTL, DEFAULT_PG_TIMESTAMP_ORACLE_CONNPOOL_TTL_STAGGER, @@ -1503,10 +1502,10 @@ pub static USER_STORAGE_MANAGED_COLLECTIONS_BATCH_DURATION: VarDefinition = VarD false, ); -pub static DEFAULT_NETWORK_POLICY_ALLOW_LIST: VarDefinition = VarDefinition::new_lazy( - "default_network_policy_allow_list", - lazy_value!(Vec; || vec![IpNet::from_str("0.0.0.0/0").expect("this is a valid IpNet")]), - "Network policy allow list that external user connections will be validated against.", +pub static NETWORK_POLICY: VarDefinition = VarDefinition::new_lazy( + "network_policy", + lazy_value!(String; || "default".to_string()), + "Sets the fallback network policy applied to all users without an explicit policy.", true, ); diff --git a/test/restart/mzcompose.py b/test/restart/mzcompose.py index 9f94578765d3c..99f5a6d0c4ad6 100644 --- a/test/restart/mzcompose.py +++ b/test/restart/mzcompose.py @@ -455,71 +455,84 @@ def workflow_network_policies(c: Composition) -> None: c.up("materialized") http_port = c.port("materialized", 6876) - # Ensure new user sessions are allowed. + # ensure default network policy + def assert_can_connect(): + assert c.sql_query("SELECT 1") == [(1,)] + assert requests.post( + f"http://localhost:{http_port}/api/sql", json={"query": "select 1"} + ).json()["results"][0]["rows"] == [["1"]] + + def assert_new_connection_fails(): + # New SQL and HTTP user sessions should now fail. + try: + c.sql_query("SELECT 1") + except OperationalError as e: + # assert e.pgcode == "MZ010" # Not exposed by psycopg + assert "session denied" in str(e) + assert "DETAIL: Access denied for address" in e.args[0], e.args + + res = requests.post( + f"http://localhost:{http_port}/api/sql", json={"query": "select 1"} + ) + assert res.status_code == 403 + assert res.json()["message"] == "session denied" + assert res.json()["code"] == "MZ011" + assert "Access denied for address" in res.json()["detail"] + + # ensure default network policy + assert c.sql_query("show network_policy") == [("default",)] + assert_can_connect() + # enable network policy management c.sql( - "ALTER SYSTEM SET allow_user_sessions = true", + "ALTER SYSTEM SET enable_network_policies = true", port=6877, user="mz_system", ) + + # close network policies c.sql( - "ALTER SYSTEM SET default_network_policy_allow_list = '0.0.0.0/0'", + "CREATE NETWORK POLICY closed (RULES ())", port=6877, user="mz_system", ) + c.sql( + "ALTER SYSTEM SET network_policy='closed'", + port=6877, + user="mz_system", + ) + assert_new_connection_fails() - # SQL and HTTP user sessions should work. - assert c.sql_query("SELECT 1") == [(1,)] - assert requests.post( - f"http://localhost:{http_port}/api/sql", json={"query": "select 1"} - ).json()["results"][0]["rows"] == [["1"]] - - # Save a cursor for later. + # open the closed network policy + c.sql( + "ALTER NETWORK POLICY closed SET (RULES (open (ACTION='allow', DIRECTION='ingress', ADDRESS='0.0.0.0/0')))", + port=6877, + user="mz_system", + ) + assert_can_connect() cursor = c.sql_cursor() - # Block external user session by ip. + # shut down the closed network policy c.sql( - "ALTER SYSTEM SET default_network_policy_allow_list = '0.0.0.0/32'", + "ALTER NETWORK POLICY closed SET (RULES (closed (ACTION='allow', DIRECTION='ingress', ADDRESS='0.0.0.0/32')))", port=6877, user="mz_system", ) + assert_new_connection_fails() - # New SQL and HTTP user sessions should now fail. - try: - c.sql_query("SELECT 1") - except OperationalError as e: - # assert e.pgcode == "MZ010" # Not exposed by psycopg - assert "session denied" in str(e) - assert "DETAIL: Access denied for address" in e.args[0], e.args + # validate that the cursor from the beginning of the test still works. + assert cursor.execute("SELECT 1").fetchall() == [(1,)] - res = requests.post( - f"http://localhost:{http_port}/api/sql", json={"query": "select 1"} + c.sql( + "ALTER SYSTEM SET network_policy='default'", + port=6877, + user="mz_system", ) - assert res.status_code == 403 - assert res.json()["message"] == "session denied" - assert res.json()["code"] == "MZ011" - assert "Access denied for address" in res.json()["detail"] - - # The cursor from the beginning of the test should still work. - cursor.execute("SELECT 1") - assert cursor.fetchall() == [(1,)] - - # Re-allow new user sessions. c.sql( - "ALTER SYSTEM SET default_network_policy_allow_list = '0.0.0.0/0'", + "DROP NETWORK POLICY closed", port=6877, user="mz_system", ) - # SQL and HTTP user sessions should work again. - assert c.sql_query("SELECT 1") == [(1,)] - assert requests.post( - f"http://localhost:{http_port}/api/sql", json={"query": "select 1"} - ).json()["results"][0]["rows"] == [["1"]] - - # The cursor from the beginning of the test should still work. - cursor.execute("SELECT 1") - assert cursor.fetchall() == [(1,)] - def workflow_drop_materialize_database(c: Composition) -> None: c.up("materialized") diff --git a/test/sqllogictest/audit_log.slt b/test/sqllogictest/audit_log.slt index dc9bf0e7e201a..fdd613a3ffc86 100644 --- a/test/sqllogictest/audit_log.slt +++ b/test/sqllogictest/audit_log.slt @@ -147,61 +147,62 @@ SELECT id, event_type, object_type, details, user FROM mz_audit_events ORDER BY 8 grant database {"grantee_id":"u1","grantor_id":"s1","object_id":"Du1","privileges":"UC"} NULL 9 create schema {"database_name":"materialize","id":"3","name":"public"} NULL 10 grant schema {"grantee_id":"u1","grantor_id":"s1","object_id":"Su1.u3","privileges":"UC"} NULL -11 create cluster {"id":"u1","name":"quickstart"} NULL -12 grant cluster {"grantee_id":"p","grantor_id":"s1","object_id":"Cu1","privileges":"U"} NULL -13 grant cluster {"grantee_id":"u1","grantor_id":"s1","object_id":"Cu1","privileges":"UC"} NULL -14 create cluster-replica {"billed_as":null,"cluster_id":"u1","cluster_name":"quickstart","disk":false,"internal":false,"logical_size":"2","reason":"system","replica_id":"u1","replica_name":"r1"} NULL -15 grant system {"grantee_id":"s1","grantor_id":"s1","object_id":"SYSTEM","privileges":"RBNP"} NULL -16 grant system {"grantee_id":"u1","grantor_id":"s1","object_id":"SYSTEM","privileges":"RBNP"} NULL -17 alter system {"name":"enable_reduce_mfp_fusion","value":"on"} mz_system -18 alter system {"name":"enable_unsafe_functions","value":"on"} mz_system -19 create database {"id":"u2","name":"test"} materialize -20 create schema {"database_name":"test","id":"u9","name":"public"} materialize -21 create schema {"database_name":"test","id":"u10","name":"sc1"} materialize -22 create schema {"database_name":"test","id":"u11","name":"sc2"} materialize -23 drop schema {"database_name":"test","id":"u10","name":"sc1"} materialize -24 drop schema {"database_name":"test","id":"u9","name":"public"} materialize -25 drop schema {"database_name":"test","id":"u11","name":"sc2"} materialize -26 drop database {"id":"u2","name":"test"} materialize -27 create role {"id":"u2","name":"foo"} materialize -28 drop role {"id":"u2","name":"foo"} materialize -29 create cluster {"id":"u2","name":"foo"} materialize -30 create cluster-replica {"billed_as":null,"cluster_id":"u2","cluster_name":"foo","disk":true,"internal":false,"logical_size":"1","reason":"manual","replica_id":"u2","replica_name":"r"} materialize -31 create materialized-view {"cluster_id":"u1","database":"materialize","id":"u1","item":"v2","schema":"public"} materialize -32 create view {"database":"materialize","id":"u2","item":"unmat","schema":"public"} materialize -33 create table {"database":"materialize","id":"u3","item":"t","schema":"public"} materialize -34 create index {"cluster_id":"u1","database":"materialize","id":"u4","item":"t_primary_idx","schema":"public"} materialize -35 alter view {"id":"u2","new_name":{"database":"materialize","item":"renamed","schema":"public"},"old_name":{"database":"materialize","item":"unmat","schema":"public"}} materialize -36 drop materialized-view {"database":"materialize","id":"u1","item":"v2","schema":"public"} materialize -37 create materialized-view {"cluster_id":"u1","database":"materialize","id":"u5","item":"v2","schema":"public"} materialize -38 create index {"cluster_id":"u1","database":"materialize","id":"u6","item":"renamed_primary_idx","schema":"public"} materialize -39 drop index {"database":"materialize","id":"u6","item":"renamed_primary_idx","schema":"public"} materialize -40 drop view {"database":"materialize","id":"u2","item":"renamed","schema":"public"} materialize -41 create source {"cluster_id":null,"database":"materialize","id":"u7","item":"s_progress","schema":"public","type":"progress"} materialize -42 create source {"cluster_id":"u1","database":"materialize","id":"u8","item":"s","schema":"public","type":"load-generator"} materialize -43 drop source {"database":"materialize","id":"u8","item":"s","schema":"public"} materialize -44 drop source {"database":"materialize","id":"u7","item":"s_progress","schema":"public"} materialize -45 create source {"cluster_id":null,"database":"materialize","id":"u9","item":"multiplex_progress","schema":"public","type":"progress"} materialize -46 create source {"cluster_id":"u1","database":"materialize","id":"u10","item":"multiplex","schema":"public","type":"load-generator"} materialize -47 create table {"database":"materialize","id":"u11","item":"accounts","schema":"public"} materialize -48 create table {"database":"materialize","id":"u12","item":"auctions","schema":"public"} materialize -49 create table {"database":"materialize","id":"u13","item":"bids","schema":"public"} materialize -50 create table {"database":"materialize","id":"u14","item":"organizations","schema":"public"} materialize -51 create table {"database":"materialize","id":"u15","item":"users","schema":"public"} materialize -52 alter cluster-replica {"cluster_id":"u2","new_name":"s","old_name":"r","replica_id":"u2"} materialize -53 comment cluster {"id":"Cluster(User(2))","name":"foo"} materialize +11 create network-policy {"id":"u1","name":"default"} NULL +12 create cluster {"id":"u1","name":"quickstart"} NULL +13 grant cluster {"grantee_id":"p","grantor_id":"s1","object_id":"Cu1","privileges":"U"} NULL +14 grant cluster {"grantee_id":"u1","grantor_id":"s1","object_id":"Cu1","privileges":"UC"} NULL +15 create cluster-replica {"billed_as":null,"cluster_id":"u1","cluster_name":"quickstart","disk":false,"internal":false,"logical_size":"2","reason":"system","replica_id":"u1","replica_name":"r1"} NULL +16 grant system {"grantee_id":"s1","grantor_id":"s1","object_id":"SYSTEM","privileges":"RBNP"} NULL +17 grant system {"grantee_id":"u1","grantor_id":"s1","object_id":"SYSTEM","privileges":"RBNP"} NULL +18 alter system {"name":"enable_reduce_mfp_fusion","value":"on"} mz_system +19 alter system {"name":"enable_unsafe_functions","value":"on"} mz_system +20 create database {"id":"u2","name":"test"} materialize +21 create schema {"database_name":"test","id":"u9","name":"public"} materialize +22 create schema {"database_name":"test","id":"u10","name":"sc1"} materialize +23 create schema {"database_name":"test","id":"u11","name":"sc2"} materialize +24 drop schema {"database_name":"test","id":"u10","name":"sc1"} materialize +25 drop schema {"database_name":"test","id":"u9","name":"public"} materialize +26 drop schema {"database_name":"test","id":"u11","name":"sc2"} materialize +27 drop database {"id":"u2","name":"test"} materialize +28 create role {"id":"u2","name":"foo"} materialize +29 drop role {"id":"u2","name":"foo"} materialize +30 create cluster {"id":"u2","name":"foo"} materialize +31 create cluster-replica {"billed_as":null,"cluster_id":"u2","cluster_name":"foo","disk":true,"internal":false,"logical_size":"1","reason":"manual","replica_id":"u2","replica_name":"r"} materialize +32 create materialized-view {"cluster_id":"u1","database":"materialize","id":"u1","item":"v2","schema":"public"} materialize +33 create view {"database":"materialize","id":"u2","item":"unmat","schema":"public"} materialize +34 create table {"database":"materialize","id":"u3","item":"t","schema":"public"} materialize +35 create index {"cluster_id":"u1","database":"materialize","id":"u4","item":"t_primary_idx","schema":"public"} materialize +36 alter view {"id":"u2","new_name":{"database":"materialize","item":"renamed","schema":"public"},"old_name":{"database":"materialize","item":"unmat","schema":"public"}} materialize +37 drop materialized-view {"database":"materialize","id":"u1","item":"v2","schema":"public"} materialize +38 create materialized-view {"cluster_id":"u1","database":"materialize","id":"u5","item":"v2","schema":"public"} materialize +39 create index {"cluster_id":"u1","database":"materialize","id":"u6","item":"renamed_primary_idx","schema":"public"} materialize +40 drop index {"database":"materialize","id":"u6","item":"renamed_primary_idx","schema":"public"} materialize +41 drop view {"database":"materialize","id":"u2","item":"renamed","schema":"public"} materialize +42 create source {"cluster_id":null,"database":"materialize","id":"u7","item":"s_progress","schema":"public","type":"progress"} materialize +43 create source {"cluster_id":"u1","database":"materialize","id":"u8","item":"s","schema":"public","type":"load-generator"} materialize +44 drop source {"database":"materialize","id":"u8","item":"s","schema":"public"} materialize +45 drop source {"database":"materialize","id":"u7","item":"s_progress","schema":"public"} materialize +46 create source {"cluster_id":null,"database":"materialize","id":"u9","item":"multiplex_progress","schema":"public","type":"progress"} materialize +47 create source {"cluster_id":"u1","database":"materialize","id":"u10","item":"multiplex","schema":"public","type":"load-generator"} materialize +48 create table {"database":"materialize","id":"u11","item":"accounts","schema":"public"} materialize +49 create table {"database":"materialize","id":"u12","item":"auctions","schema":"public"} materialize +50 create table {"database":"materialize","id":"u13","item":"bids","schema":"public"} materialize +51 create table {"database":"materialize","id":"u14","item":"organizations","schema":"public"} materialize +52 create table {"database":"materialize","id":"u15","item":"users","schema":"public"} materialize +53 alter cluster-replica {"cluster_id":"u2","new_name":"s","old_name":"r","replica_id":"u2"} materialize 54 comment cluster {"id":"Cluster(User(2))","name":"foo"} materialize -55 alter cluster {"id":"u2","new_name":"bar","old_name":"foo"} materialize -56 drop cluster-replica {"cluster_id":"u2","cluster_name":"bar","reason":"manual","replica_id":"u2","replica_name":"s"} materialize -57 drop cluster {"id":"u2","name":"bar"} materialize -58 alter materialized-view {"id":"u5","new_history":"'5m'","old_history":null} materialize -59 alter materialized-view {"id":"u5","new_history":null,"old_history":"FOR␠'5m'"} materialize -60 comment materialized-view {"id":"MaterializedView(User(5))","name":"materialize.public.v2"} materialize -61 create connection {"database":"materialize","id":"u16","item":"conn","schema":"public"} materialize -62 alter connection {"database":"materialize","id":"u16","item":"conn","schema":"public"} materialize -63 alter system {"name":"max_aws_privatelink_connections","value":"10"} mz_system -64 alter system {"name":"max_aws_privatelink_connections","value":null} mz_system -65 alter system null mz_system +55 comment cluster {"id":"Cluster(User(2))","name":"foo"} materialize +56 alter cluster {"id":"u2","new_name":"bar","old_name":"foo"} materialize +57 drop cluster-replica {"cluster_id":"u2","cluster_name":"bar","reason":"manual","replica_id":"u2","replica_name":"s"} materialize +58 drop cluster {"id":"u2","name":"bar"} materialize +59 alter materialized-view {"id":"u5","new_history":"'5m'","old_history":null} materialize +60 alter materialized-view {"id":"u5","new_history":null,"old_history":"FOR␠'5m'"} materialize +61 comment materialized-view {"id":"MaterializedView(User(5))","name":"materialize.public.v2"} materialize +62 create connection {"database":"materialize","id":"u16","item":"conn","schema":"public"} materialize +63 alter connection {"database":"materialize","id":"u16","item":"conn","schema":"public"} materialize +64 alter system {"name":"max_aws_privatelink_connections","value":"10"} mz_system +65 alter system {"name":"max_aws_privatelink_connections","value":null} mz_system +66 alter system null mz_system simple conn=mz_system,user=mz_system ALTER SYSTEM SET unsafe_mock_audit_event_timestamp = 666 @@ -214,7 +215,7 @@ CREATE TABLE tt () query ITTTTT SELECT id, event_type, object_type, details, user, occurred_at FROM mz_audit_events ORDER BY id DESC LIMIT 1 ---- -67 create table {"database":"materialize","id":"u17","item":"tt","schema":"public"} materialize 1970-01-01␠00:00:00.666+00 +68 create table {"database":"materialize","id":"u17","item":"tt","schema":"public"} materialize 1970-01-01␠00:00:00.666+00 simple conn=mz_system,user=mz_system ALTER SYSTEM RESET unsafe_mock_audit_event_timestamp @@ -248,7 +249,7 @@ COMPLETE 0 query ITTTT SELECT id, event_type, object_type, details, user FROM mz_audit_events ORDER BY id DESC LIMIT 1 ---- -71 grant table {"grantee_id":"u3","grantor_id":"u1","object_id":"Iu3","privileges":"r"} mz_system +72 grant table {"grantee_id":"u3","grantor_id":"u1","object_id":"Iu3","privileges":"r"} mz_system simple conn=mz_system,user=mz_system REVOKE SELECT ON t FROM r1; @@ -258,7 +259,7 @@ COMPLETE 0 query ITTTT SELECT id, event_type, object_type, details, user FROM mz_audit_events ORDER BY id DESC LIMIT 1 ---- -72 revoke table {"grantee_id":"u3","grantor_id":"u1","object_id":"Iu3","privileges":"r"} mz_system +73 revoke table {"grantee_id":"u3","grantor_id":"u1","object_id":"Iu3","privileges":"r"} mz_system simple conn=mz_system,user=mz_system ALTER DEFAULT PRIVILEGES FOR ROLE r1 IN SCHEMA public GRANT SELECT ON TABLES to PUBLIC; @@ -268,7 +269,7 @@ COMPLETE 0 query ITTTT SELECT id, event_type, object_type, details, user FROM mz_audit_events ORDER BY id DESC LIMIT 1 ---- -73 grant table {"database_id":"u1","grantee_id":"p","privileges":"r","role_id":"u3","schema_id":"u3"} mz_system +74 grant table {"database_id":"u1","grantee_id":"p","privileges":"r","role_id":"u3","schema_id":"u3"} mz_system simple conn=mz_system,user=mz_system ALTER DEFAULT PRIVILEGES FOR ROLE r1 IN SCHEMA public REVOKE SELECT ON TABLES FROM PUBLIC; @@ -278,7 +279,7 @@ COMPLETE 0 query ITTTT SELECT id, event_type, object_type, details, user FROM mz_audit_events ORDER BY id DESC LIMIT 1 ---- -74 revoke table {"database_id":"u1","grantee_id":"p","privileges":"r","role_id":"u3","schema_id":"u3"} mz_system +75 revoke table {"database_id":"u1","grantee_id":"p","privileges":"r","role_id":"u3","schema_id":"u3"} mz_system statement ok CREATE TABLE t1 (a INT); @@ -291,7 +292,7 @@ COMPLETE 0 query ITTTT SELECT id, event_type, object_type, details, user FROM mz_audit_events ORDER BY id DESC LIMIT 1 ---- -76 alter table {"new_owner_id":"u3","object_id":"Iu18","old_owner_id":"u1"} mz_system +77 alter table {"new_owner_id":"u3","object_id":"Iu18","old_owner_id":"u1"} mz_system # Test events for auto-created users, which have the username only in the event details, but not the user column. simple conn=c,user=new_user @@ -303,4 +304,4 @@ COMPLETE 1 query ITTTT SELECT id, event_type, object_type, details, user FROM mz_audit_events ORDER BY id DESC LIMIT 1 ---- -77 create role {"id":"u4","name":"new_user"} NULL +78 create role {"id":"u4","name":"new_user"} NULL diff --git a/test/sqllogictest/network_policy.slt b/test/sqllogictest/network_policy.slt index 6b8adefa498bc..a10e79eaa0c55 100644 --- a/test/sqllogictest/network_policy.slt +++ b/test/sqllogictest/network_policy.slt @@ -34,6 +34,8 @@ COMPLETE 0 query TTT rowsort SELECT * FROM (SHOW NETWORK POLICIES) ---- +default +(empty) np r1,r2 (empty) @@ -41,10 +43,14 @@ r1,r2 query TTTT SELECT id, name, owner_id, oid FROM mz_internal.mz_network_policies ---- -u1 +u2 np s1 20177 +u1 +default +s1 +17044 query TTTTT colnames @@ -52,15 +58,20 @@ SELECT * FROM mz_internal.mz_network_policy_rules ---- name policy_id action address direction r1 -u1 +u2 allow 0.0.0.0/32 ingress r2 -u1 +u2 allow 0.0.0.1/32 ingress +open_ingress +u1 +allow +0.0.0.0/0 +ingress simple conn=mz_system,user=mz_system @@ -73,10 +84,15 @@ SELECT * FROM mz_internal.mz_network_policy_rules ---- name policy_id action address direction r1 -u1 +u2 allow 1.1.1.1/32 ingress +open_ingress +u1 +allow +0.0.0.0/0 +ingress simple conn=mz_system,user=mz_system DROP NETWORK POLICY np; @@ -86,3 +102,5 @@ COMPLETE 0 query TT rowsort select * from (SHOW NETWORK POLICIES) ---- +default +(empty) diff --git a/test/testdrive/session.td b/test/testdrive/session.td index 93ae34f1fdd47..a6b078bf6acb3 100644 --- a/test/testdrive/session.td +++ b/test/testdrive/session.td @@ -26,7 +26,6 @@ cluster_replica "" "Sets a target clust current_object_missing_warnings on "Whether to emit warnings when the current database, schema, or cluster is missing (Materialize)." database materialize "Sets the current database (CockroachDB)." DateStyle "ISO, MDY" "Sets the display format for date and time values (PostgreSQL)." -default_network_policy_allow_list "0.0.0.0/0" "Network policy allow list that external user connections will be validated against." emit_introspection_query_notice on "Whether to print a notice when querying per-replica introspection sources." emit_plan_insights_notice off "Boolean flag indicating whether to send a NOTICE with JSON-formatted plan insights before executing a SELECT statement (Materialize)." emit_timestamp_notice off "Boolean flag indicating whether to send a NOTICE with timestamp explanations of queries (Materialize)." @@ -63,6 +62,7 @@ max_secrets 100 "The maximum number max_sinks 25 "The maximum number of sinks in the region, across all schemas (Materialize)." max_sources 25 "The maximum number of sources in the region, across all schemas (Materialize)." max_tables 25 "The maximum number of tables in the region, across all schemas (Materialize)." +network_policy default "Sets the fallback network policy applied to all users without an explicit policy." mz_version "Shows the Materialize server version (Materialize)." real_time_recency off "Feature flag indicating whether real time recency is enabled (Materialize)." real_time_recency_timeout "10 s" "Sets the maximum allowed duration of SELECTs that actively use real-time recency, i.e. reach out to an external system to determine their most recencly exposed data (Materialize)."