From 57e4e0364abc6ecad058de003f399aaac1215d73 Mon Sep 17 00:00:00 2001 From: Helena Li Date: Thu, 2 Feb 2023 17:51:12 -0800 Subject: [PATCH] code not yet compiling, all nodes in network are now stored as maps and not lists, also genesis keys are in maps --- src/app/test_executive/payments_test.ml | 49 +- src/app/test_executive/snark_test.ml | 73 ++- .../{snark_test..mli => snark_test.mli} | 0 .../kubernetes_network.ml | 62 +-- .../mina_automation.ml | 449 +++++++++++------- src/lib/integration_test_lib/intf.ml | 8 +- src/lib/integration_test_lib/test_config.ml | 62 ++- 7 files changed, 455 insertions(+), 248 deletions(-) rename src/app/test_executive/{snark_test..mli => snark_test.mli} (100%) diff --git a/src/app/test_executive/payments_test.ml b/src/app/test_executive/payments_test.ml index 8aa93234039..4826c722ebd 100644 --- a/src/app/test_executive/payments_test.ml +++ b/src/app/test_executive/payments_test.ml @@ -22,7 +22,7 @@ module Make (Inputs : Intf.Test.Inputs_intf) = struct (* TODO: test snark work *) let config = let open Test_config in - let open Test_config.Wallet in + (* let open Test_config.Wallet in *) let make_timing ~min_balance ~cliff_time ~cliff_amount ~vesting_period ~vesting_increment : Mina_base.Account_timing.t = let open Currency in @@ -36,24 +36,51 @@ module Make (Inputs : Intf.Test.Inputs_intf) = struct in { default with requires_graphql = true - ; block_producers = - [ { balance = "400000"; timing = Untimed } (* 400_000_000_000_000 *) - ; { balance = "300000"; timing = Untimed } (* 300_000_000_000_000 *) - ; { balance = "30000" + ; genesis_ledger = + [ { account_name = "block-producer1-key" + ; balance = "400000" + ; timing = Untimed + } + ; { account_name = "block-producer2-key" + ; balance = "300000" + ; timing = Untimed + } + ; { account_name = "block-producer3-key" + ; balance = "30000" ; timing = make_timing ~min_balance:10_000_000_000_000 ~cliff_time:8 ~cliff_amount:0 ~vesting_period:4 ~vesting_increment:5_000_000_000_000 } - (* 30_000_000_000_000 mina is the total. initially, the balance will be 10k mina. after 8 global slots, the cliff is hit, although the cliff amount is 0. 4 slots after that, 5_000_000_000_000 mina will vest, and 4 slots after that another 5_000_000_000_000 will vest, and then twice again, for a total of 30k mina all fully liquid and unlocked at the end of the schedule*) + ; { account_name = "snark-node-key" + ; balance = "1000" + ; timing = Untimed + } + ; { account_name = "extra1"; balance = "1000"; timing = Untimed } + ; { account_name = "extra2"; balance = "1000"; timing = Untimed } ] - ; extra_genesis_accounts = - [ { balance = "1000"; timing = Untimed } - ; { balance = "1000"; timing = Untimed } + ; block_producers = + [ { node_name = "block-producer1" + ; account_name = "block-producer1-key" + } + (* 400_000_000_000_000 *) + ; { node_name = "block-producer2" + ; account_name = "block-producer2-key" + } + (* 300_000_000_000_000 *) + ; { node_name = "block-producer3" + ; account_name = "block-producer3-key" + } + (* 30_000_000_000_000 mina is the total. initially, the balance will be 10k mina. after 8 global slots, the cliff is hit, although the cliff amount is 0. 4 slots after that, 5_000_000_000_000 mina will vest, and 4 slots after that another 5_000_000_000_000 will vest, and then twice again, for a total of 30k mina all fully liquid and unlocked at the end of the schedule*) ] - ; num_archive_nodes = 1 - ; num_snark_workers = 4 + ; snark_worker = + Some + { node_name = "snark-node" + ; account_name = "snark-node-key" + ; replicas = 4 + } ; snark_worker_fee = "0.0001" + ; num_archive_nodes = 1 ; proof_config = { proof_config_default with work_delay = Some 1 diff --git a/src/app/test_executive/snark_test.ml b/src/app/test_executive/snark_test.ml index ea0ae9c215e..ab49d9e2a84 100644 --- a/src/app/test_executive/snark_test.ml +++ b/src/app/test_executive/snark_test.ml @@ -42,6 +42,39 @@ module Make (Inputs : Intf.Test.Inputs_intf) = struct } } + (* + TODO, new config format should look like + + let config = + let open Test_config in + let open Test_config.Wallet in + { default with + requires_graphql = true + ; genesis_ledger = [ + { key_name = "bp1_key"; balance = "400000"; timing = Untimed } + ; { key_name = "bp2_key"; balance = "300000"; timing = Untimed } + ; { key_name = "extra1_key"; balance = "1000"; timing = Untimed } + ; { key_name = "extra2_key"; balance = "1000"; timing = Untimed } + ; { key_name = "snark_worker1_key"; balance = "10"; timing = Untimed } + ] + ; block_producers = + [ { node_name = "bp1"; node_key_name = "bp1_key" } + ; { node_name = "bp2"; node_key_name = "bp2_key" } + ] + ; num_archive_nodes = 0 + ; snark_workers = [ + { node_name = "snark_worker"; node_key_name = "snark_worker1_key"; replicas = 4 } + ] + ; snark_worker_fee = "0.0001" + ; proof_config = + { proof_config_default with + work_delay = Some 1 + ; transaction_capacity = + Some Runtime_config.Proof_keys.Transaction_capacity.small + } + } + *) + let run network t = let open Malleable_error.Let_syntax in let logger = Logger.create () in @@ -67,7 +100,7 @@ module Make (Inputs : Intf.Test.Inputs_intf) = struct let sender_pub_key = sender_kp.public_key |> Signature_lib.Public_key.compress in - + (* let snark_worker_pk = Test_config.default.snark_worker_public_key in *) let%bind () = section_hard "send out a bunch more txns to fill up the snark ledger, then wait for \ @@ -96,25 +129,25 @@ module Make (Inputs : Intf.Test.Inputs_intf) = struct wait_for t (Wait_condition.ledger_proofs_emitted_since_genesis ~num_proofs:1) ) in - let%bind () = - section_hard "check snark worker's account balance" - (let%bind { total_balance = snark_worker_balance; _ } = - Network.Node.must_get_account_data ~logger untimed_node_b - ~public_key:Test_config.default.snark_worker_public_key - in - if - Currency.Amount.( >= ) - (Currency.Balance.to_amount snark_worker_balance) - snark_worker_expected - then Malleable_error.return () - else - Malleable_error.soft_error_format ~value:() - "Error with snark_worker_balance. snark_worker_balance is %d and \ - should be %d. snark fee is %d" - (Currency.Balance.to_int snark_worker_balance) - (Currency.Amount.to_int snark_worker_expected) - (Currency.Fee.to_int fee) ) - in + (* let%bind () = + section_hard "check snark worker's account balance" + (let%bind { total_balance = snark_worker_balance; _ } = + Network.Node.must_get_account_data ~logger untimed_node_b + ~public_key:snark_worker_pk + in + if + Currency.Amount.( >= ) + (Currency.Balance.to_amount snark_worker_balance) + snark_worker_expected + then Malleable_error.return () + else + Malleable_error.soft_error_format ~value:() + "Error with snark_worker_balance. snark_worker_balance is %d and \ + should be %d. snark fee is %d" + (Currency.Balance.to_int snark_worker_balance) + (Currency.Amount.to_int snark_worker_expected) + (Currency.Fee.to_int fee) ) + in *) section_hard "dfasdfdasf" (let%bind hash = let%map { hash; _ } = diff --git a/src/app/test_executive/snark_test..mli b/src/app/test_executive/snark_test.mli similarity index 100% rename from src/app/test_executive/snark_test..mli rename to src/app/test_executive/snark_test.mli diff --git a/src/lib/integration_test_cloud_engine/kubernetes_network.ml b/src/lib/integration_test_cloud_engine/kubernetes_network.ml index 9d0502a7695..f5c941d47c4 100644 --- a/src/lib/integration_test_cloud_engine/kubernetes_network.ml +++ b/src/lib/integration_test_cloud_engine/kubernetes_network.ml @@ -834,15 +834,14 @@ end type t = { namespace : string ; constants : Test_config.constants - ; seeds : Node.t list - ; block_producers : Node.t list - ; snark_coordinators : Node.t list - ; snark_workers : Node.t list - ; archive_nodes : Node.t list - ; testnet_log_filter : string (* ; keypairs : Signature_lib.Keypair.t list *) - ; block_producer_keypairs : Signature_lib.Keypair.t list - ; extra_genesis_keypairs : Signature_lib.Keypair.t list - ; nodes_by_pod_id : Node.t String.Map.t + ; seeds : Node.t Core.String.Map.t + ; block_producers : Node.t Core.String.Map.t + ; snark_coordinators : Node.t Core.String.Map.t + ; snark_workers : Node.t Core.String.Map.t + ; archive_nodes : Node.t Core.String.Map.t + ; nodes_by_pod_id : Node.t Core.String.Map.t + ; testnet_log_filter : string + ; genesis_keypairs : Network_keypair.t Core.String.Map.t } let constants { constants; _ } = constants @@ -863,34 +862,37 @@ let archive_nodes { archive_nodes; _ } = archive_nodes (* all_nodes returns all *actual* mina nodes; note that a snark_worker is a pod within the network but not technically a mina node, therefore not included here. snark coordinators on the other hand ARE mina nodes *) let all_nodes { seeds; block_producers; snark_coordinators; archive_nodes; _ } = - List.concat [ seeds; block_producers; snark_coordinators; archive_nodes ] + List.concat + [ Core.String.Map.to_alist seeds + ; Core.String.Map.to_alist block_producers + ; Core.String.Map.to_alist snark_coordinators + ; Core.String.Map.to_alist archive_nodes + ] + |> Core.String.Map.of_alist_exn (* all_pods returns everything in the network. remember that snark_workers will never initialize and will never sync, and aren't supposed to *) -let all_pods - { seeds - ; block_producers - ; snark_coordinators - ; snark_workers - ; archive_nodes - ; _ - } = - List.concat - [ seeds; block_producers; snark_coordinators; snark_workers; archive_nodes ] +(* TODO snark workers and snark coordinators have the same key name, but different workload ids*) +let all_pods { nodes_by_pod_id; _ } = Core.String.Map.data nodes_by_pod_id (* all_non_seed_pods returns everything in the network except seed nodes *) -let all_non_seed_pods - { block_producers; snark_coordinators; snark_workers; archive_nodes; _ } = - List.concat - [ block_producers; snark_coordinators; snark_workers; archive_nodes ] +let all_non_seed_pods { nodes_by_pod_id; seeds; _ } = + let seedlist = Core.String.Map.keys seeds in + let rec remove_all_keys_in_list mp lst = + match lst with + | [] -> + mp + | hd :: tl -> + remove_all_keys_in_list (Core.String.Map.remove mp hd) tl + in + Core.String.Map.data (remove_all_keys_in_list nodes_by_pod_id seedlist) -let all_keypairs { block_producer_keypairs; extra_genesis_keypairs; _ } = - block_producer_keypairs @ extra_genesis_keypairs +let genesis_keypairs { genesis_keypairs; _ } = genesis_keypairs -let block_producer_keypairs { block_producer_keypairs; _ } = - block_producer_keypairs +(* let block_producer_keypairs { block_producer_keypairs; _ } = + block_producer_keypairs -let extra_genesis_keypairs { extra_genesis_keypairs; _ } = - extra_genesis_keypairs + let extra_genesis_keypairs { extra_genesis_keypairs; _ } = + extra_genesis_keypairs *) let lookup_node_by_pod_id t = Map.find t.nodes_by_pod_id diff --git a/src/lib/integration_test_cloud_engine/mina_automation.ml b/src/lib/integration_test_cloud_engine/mina_automation.ml index 7dfdf212b00..2952950e155 100644 --- a/src/lib/integration_test_cloud_engine/mina_automation.ml +++ b/src/lib/integration_test_cloud_engine/mina_automation.ml @@ -23,8 +23,7 @@ module Network_config = struct module Cli_inputs = Cli_inputs type block_producer_config = - { name : string - ; id : string + { name : string (* ; id : string *) ; keypair : Network_keypair.t ; public_key : string ; private_key : string @@ -33,6 +32,18 @@ module Network_config = struct } [@@deriving to_yojson] + type snark_worker_config = + { name : string + (* ; id : string *) + (* ; keypair : Network_keypair.t *) + ; public_key : string + (* ; private_key : string *) + (* ; keypair_secret : string *) + (* ; libp2p_secret : string *) + ; replicas : int + } + [@@deriving to_yojson] + type terraform_config = { k8s_context : string ; cluster_name : string @@ -53,9 +64,8 @@ module Network_config = struct ; archive_node_count : int ; mina_archive_schema : string ; mina_archive_schema_aux_files : string list - ; snark_worker_replicas : int - ; snark_worker_fee : string - ; snark_worker_public_key : string + ; snark_worker_config : snark_worker_config option + ; snark_worker_fee : string (* ; snark_worker_public_key : string *) ; cpu_request : int ; mem_request : string ; worker_cpu_request : int @@ -69,8 +79,17 @@ module Network_config = struct ; check_capacity : bool ; check_capacity_delay : int ; check_capacity_retries : int - ; block_producer_keypairs : Network_keypair.t list - ; extra_genesis_keypairs : Network_keypair.t list + (* ; block_producer_keypairs : Network_keypair.t list + ; extra_genesis_keypairs : Network_keypair.t list *) + ; genesis_keypairs : + (Network_keypair.t Core.String.Map.t + [@to_yojson + fun map -> + `Assoc + (Core.Map.fold_right ~init:[] + ~f:(fun ~key:k ~data:v accum -> + (k, Network_keypair.to_yojson v) :: accum ) + map )] ) ; constants : Test_config.constants ; terraform : terraform_config } @@ -85,20 +104,19 @@ module Network_config = struct let expand ~logger ~test_name ~(cli_inputs : Cli_inputs.t) ~(debug : bool) ~(test_config : Test_config.t) ~(images : Test_config.Container_images.t) = - let { Test_config.k + let { requires_graphql + ; genesis_ledger + ; block_producers + ; snark_worker + ; snark_worker_fee + ; num_archive_nodes + ; log_precomputed_blocks (* ; num_plain_nodes *) + ; proof_config + ; Test_config.k ; delta ; slots_per_epoch ; slots_per_sub_window ; txpool_max_size - ; requires_graphql - ; block_producers - ; extra_genesis_accounts - ; num_snark_workers - ; num_archive_nodes - ; log_precomputed_blocks - ; snark_worker_fee - ; snark_worker_public_key - ; proof_config } = test_config in @@ -111,56 +129,44 @@ module Network_config = struct let git_commit = Mina_version.commit_id_short in (* see ./src/app/test_executive/README.md for information regarding the namespace name format and length restrictions *) let testnet_name = "it-" ^ user ^ "-" ^ git_commit ^ "-" ^ test_name in + (* GENERATE ACCOUNTS AND KEYPAIRS *) - let num_block_producers = List.length block_producers in - let bp_keypairs, extra_keypairs = - List.split_n + (* let num_block_producers = List.length block_producers in *) + let keypairs = + List.take (* the first keypair is the genesis winner and is assumed to be untimed. Therefore dropping it, and not assigning it to any block producer *) (List.drop (Array.to_list (Lazy.force Sample_keypairs.keypairs)) 1) - num_block_producers - in - if List.length bp_keypairs < num_block_producers then - failwith - "not enough sample keypairs for specified number of block producers" ; - assert (List.length bp_keypairs >= num_block_producers) ; - if List.length bp_keypairs < num_block_producers then - failwith - "not enough sample keypairs for specified number of extra keypairs" ; - assert (List.length extra_keypairs >= List.length extra_genesis_accounts) ; - let extra_keypairs_cut = - List.take extra_keypairs (List.length extra_genesis_accounts) - in - let extra_accounts = - List.map (List.zip_exn extra_genesis_accounts extra_keypairs_cut) - ~f:(fun ({ Test_config.Wallet.balance; timing }, (pk, sk)) -> - let timing = - match timing with - | Account.Timing.Untimed -> - None - | Timed t -> - Some - { Runtime_config.Accounts.Single.Timed.initial_minimum_balance = - t.initial_minimum_balance - ; cliff_time = t.cliff_time - ; cliff_amount = t.cliff_amount - ; vesting_period = t.vesting_period - ; vesting_increment = t.vesting_increment - } + (List.length genesis_ledger) + in + (* let module Labeled_accounts = Map.Make(String) + in *) + let labeled_accounts : + ( Runtime_config.Accounts.single + * (Public_key.Compressed.t * Private_key.t) ) + String.Map.t = + String.Map.empty + in + + (* if List.length bp_keypairs < num_block_producers then + failwith + "not enough sample keypairs for specified number of block producers" ; + assert (List.length bp_keypairs >= num_block_producers) ; + if List.length bp_keypairs < num_block_producers then + failwith + "not enough sample keypairs for specified number of extra keypairs" ; + assert (List.length extra_keypairs >= List.length extra_genesis_accounts) ; + let extra_keypairs_cut = + List.take extra_keypairs (List.length extra_genesis_accounts) + in *) + let rec add_accounts mp zip = + match zip with + | [] -> + mp + | hd :: tl -> + let ( { Test_config.Test_Account.balance; account_name; timing } + , (pk, sk) ) = + hd in - let default = Runtime_config.Accounts.Single.default in - { default with - pk = Some (Public_key.Compressed.to_string pk) - ; sk = Some (Private_key.to_base58_check sk) - ; balance = - Balance.of_formatted_string balance - (* delegation currently unsupported *) - ; delegate = None - ; timing - } ) - in - let bp_accounts = - List.map (List.zip_exn block_producers bp_keypairs) - ~f:(fun ({ Test_config.Wallet.balance; timing }, (pk, _)) -> let timing = match timing with | Account.Timing.Untimed -> @@ -176,16 +182,52 @@ module Network_config = struct } in let default = Runtime_config.Accounts.Single.default in - { default with - pk = Some (Public_key.Compressed.to_string pk) - ; sk = None - ; balance = - Balance.of_formatted_string balance - (* delegation currently unsupported *) - ; delegate = None - ; timing - } ) - in + let acct = + { default with + pk = Some (Public_key.Compressed.to_string pk) + ; sk = Some (Private_key.to_base58_check sk) + ; balance = + Balance.of_formatted_string balance + (* delegation currently unsupported *) + ; delegate = None + ; timing + } + in + add_accounts + (String.Map.add_exn mp ~key:account_name ~data:(acct, (pk, sk))) + tl + in + let genesis_ledger_accounts = + add_accounts labeled_accounts (List.zip_exn genesis_ledger keypairs) + in + (* let bp_accounts = + List.map (List.zip_exn block_producers bp_keypairs) + ~f:(fun ({ Test_config.Wallet.balance; timing }, (pk, _)) -> + let timing = + match timing with + | Account.Timing.Untimed -> + None + | Timed t -> + Some + { Runtime_config.Accounts.Single.Timed.initial_minimum_balance = + t.initial_minimum_balance + ; cliff_time = t.cliff_time + ; cliff_amount = t.cliff_amount + ; vesting_period = t.vesting_period + ; vesting_increment = t.vesting_increment + } + in + let default = Runtime_config.Accounts.Single.default in + { default with + pk = Some (Public_key.Compressed.to_string pk) + ; sk = None + ; balance = + Balance.of_formatted_string balance + (* delegation currently unsupported *) + ; delegate = None + ; timing + } ) + in *) (* DAEMON CONFIG *) let constraint_constants = Genesis_ledger_helper.make_constraint_constants @@ -206,7 +248,12 @@ module Network_config = struct ; proof = Some proof_config (* TODO: prebake ledger and only set hash *) ; ledger = Some - { base = Accounts (bp_accounts @ extra_accounts) + { base = + Accounts + (let tuplist = String.Map.data genesis_ledger_accounts in + List.map tuplist ~f:(fun tup -> + let acct, _ = tup in + acct ) ) ; add_genesis_winner = None ; num_accounts = None ; balances = [] @@ -225,9 +272,14 @@ module Network_config = struct { constraints = constraint_constants; genesis = genesis_constants } in (* BLOCK PRODUCER CONFIG *) - let block_producer_config index keypair = - { name = "test-block-producer-" ^ Int.to_string (index + 1) - ; id = Int.to_string index + let mk_net_keypair secret_name (pk, sk) = + let keypair = + { Keypair.public_key = Public_key.decompress_exn pk; private_key = sk } + in + Network_keypair.create_network_keypair ~keypair ~secret_name + in + let block_producer_config name keypair = + { name (* ; id = Int.to_string index *) ; keypair ; keypair_secret = keypair.secret_name ; public_key = keypair.public_key_file @@ -235,6 +287,14 @@ module Network_config = struct ; libp2p_secret = "" } in + let block_producer_configs = + List.map block_producers ~f:(fun node -> + let _, key_tup = + String.Map.find_exn genesis_ledger_accounts node.account_name + in + block_producer_config node.node_name + (mk_net_keypair node.account_name key_tup) ) + in let mina_archive_schema = "create_schema.sql" in let mina_archive_base_url = "https://raw.githubusercontent.com/MinaProtocol/mina/" @@ -243,25 +303,41 @@ module Network_config = struct let mina_archive_schema_aux_files = [ mina_archive_base_url ^ "create_schema.sql" ] in - let mk_net_keypair index (pk, sk) = - let secret_name = "test-keypair-" ^ Int.to_string index in - let keypair = - { Keypair.public_key = Public_key.decompress_exn pk; private_key = sk } - in - Network_keypair.create_network_keypair ~keypair ~secret_name - in - let extra_genesis_net_keypairs = - List.mapi extra_keypairs_cut ~f:mk_net_keypair + let genesis_keypairs = + String.Map.of_alist_exn + (List.map (String.Map.to_alist genesis_ledger_accounts) + ~f:(fun element -> + let kp_name, (_, (pk, sk)) = element in + (kp_name, mk_net_keypair kp_name (pk, sk)) ) ) + in + let snark_worker_config = + match snark_worker with + | None -> + None + | Some conf -> + let network_kp = + String.Map.find_exn genesis_keypairs conf.account_name + in + Some + { name = conf.node_name + ; public_key = network_kp.public_key_file + ; replicas = conf.replicas + } in - let bp_net_keypairs = List.mapi bp_keypairs ~f:mk_net_keypair in + + (* let extra_genesis_net_keypairs = + List.mapi extra_keypairs_cut ~f:mk_net_keypair + in + let bp_net_keypairs = List.mapi bp_keypairs ~f:mk_net_keypair in *) (* NETWORK CONFIG *) { mina_automation_location = cli_inputs.mina_automation_location ; debug_arg = debug ; check_capacity = cli_inputs.check_capacity ; check_capacity_delay = cli_inputs.check_capacity_delay ; check_capacity_retries = cli_inputs.check_capacity_retries - ; block_producer_keypairs = bp_net_keypairs - ; extra_genesis_keypairs = extra_genesis_net_keypairs + ; genesis_keypairs + (* ; block_producer_keypairs = bp_net_keypairs + ; extra_genesis_keypairs = extra_genesis_net_keypairs *) ; constants ; terraform = { cluster_name @@ -275,14 +351,12 @@ module Network_config = struct ; mina_points_image = images.points ; mina_archive_image = images.archive_node ; runtime_config = Runtime_config.to_yojson runtime_config - ; block_producer_configs = - List.mapi bp_net_keypairs ~f:block_producer_config + ; block_producer_configs ; log_precomputed_blocks ; archive_node_count = num_archive_nodes ; mina_archive_schema ; mina_archive_schema_aux_files - ; snark_worker_replicas = num_snark_workers - ; snark_worker_public_key + ; snark_worker_config (* ; snark_worker_public_key *) ; snark_worker_fee ; aws_route53_zone_id ; cpu_request = 6 @@ -340,15 +414,21 @@ module Network_manager = struct ; testnet_dir : string ; testnet_log_filter : string ; constants : Test_config.constants - ; seed_workloads : Kubernetes_network.Workload_to_deploy.t list - ; block_producer_workloads : Kubernetes_network.Workload_to_deploy.t list - ; snark_coordinator_workloads : Kubernetes_network.Workload_to_deploy.t list - ; snark_worker_workloads : Kubernetes_network.Workload_to_deploy.t list - ; archive_workloads : Kubernetes_network.Workload_to_deploy.t list - ; workloads_by_id : Kubernetes_network.Workload_to_deploy.t String.Map.t - ; mutable deployed : bool (* ; keypairs : Keypair.t list *) - ; block_producer_keypairs : Keypair.t list - ; extra_genesis_keypairs : Keypair.t list + ; seed_workloads : Kubernetes_network.Workload_to_deploy.t Core.String.Map.t + ; block_producer_workloads : + Kubernetes_network.Workload_to_deploy.t Core.String.Map.t + ; snark_coordinator_workloads : + Kubernetes_network.Workload_to_deploy.t Core.String.Map.t + ; snark_worker_workloads : + Kubernetes_network.Workload_to_deploy.t Core.String.Map.t + ; archive_workloads : + Kubernetes_network.Workload_to_deploy.t Core.String.Map.t + ; workloads_by_id : + Kubernetes_network.Workload_to_deploy.t Core.String.Map.t + ; mutable deployed : bool + ; genesis_keypairs : Network_keypair.t Core.String.Map.t + (* ; block_producer_keypairs : Keypair.t list + ; extra_genesis_keypairs : Keypair.t list *) } let run_cmd t prog args = Util.run_cmd t.testnet_dir prog args @@ -410,9 +490,9 @@ module Network_manager = struct let nodes_available = max_nodes - num_kube_nodes in let cpus_needed_estimate = 6 - * ( List.length t.seed_workloads - + List.length t.block_producer_keypairs - + List.length t.snark_coordinator_workloads ) + * ( Core.Map.length t.seed_workloads + + Core.Map.length t.block_producer_workloads + + Core.Map.length t.snark_coordinator_workloads ) (* as of 2022/07, the seed, bps, and the snark coordinator use 6 cpus. this is just a rough heuristic so we're not bothering to calculate memory needed *) in let cluster_nodes_needed = @@ -500,58 +580,106 @@ module Network_manager = struct *) let testnet_log_filter = Network_config.testnet_log_filter network_config in (* we currently only deploy 1 seed and coordinator per deploy (will be configurable later) *) + (* seed node keyname and workload name hardcoded as "seed" *) let seed_workloads = - [ Kubernetes_network.Workload_to_deploy.construct_workload "seed" - [ Kubernetes_network.Workload_to_deploy.cons_pod_info "mina" ] - ] - in - let snark_coordinator_id = - String.lowercase - (String.sub network_config.terraform.snark_worker_public_key - ~pos: - (String.length network_config.terraform.snark_worker_public_key - 6) - ~len:6 ) - in - let snark_coordinator_workloads = - if network_config.terraform.snark_worker_replicas > 0 then - [ Kubernetes_network.Workload_to_deploy.construct_workload - ("snark-coordinator-" ^ snark_coordinator_id) - [ Kubernetes_network.Workload_to_deploy.cons_pod_info "mina" ] - ] - else [] - in - let snark_worker_workloads = - if network_config.terraform.snark_worker_replicas > 0 then - [ Kubernetes_network.Workload_to_deploy.construct_workload - ("snark-worker-" ^ snark_coordinator_id) - (List.init network_config.terraform.snark_worker_replicas - ~f:(fun _i -> - Kubernetes_network.Workload_to_deploy.cons_pod_info "worker" ) - ) - ] - else [] + Core.String.Map.add_exn Core.String.Map.empty ~key:"seed" + ~data: + (Kubernetes_network.Workload_to_deploy.construct_workload "seed" + [ Kubernetes_network.Workload_to_deploy.cons_pod_info "mina" ] ) in + + let snark_coordinator_workloads, snark_worker_workloads = + match network_config.terraform.snark_worker_config with + | Some config -> + let snark_coordinator_id = + String.lowercase + (String.sub config.public_key + ~pos:(String.length config.public_key - 6) + ~len:6 ) + in + let snark_coordinator_workloads = + if config.replicas > 0 then + Core.String.Map.of_alist_exn + [ ( config.name ^ "-coordinator-" ^ snark_coordinator_id + , Kubernetes_network.Workload_to_deploy.construct_workload + (config.name ^ "-coordinator-" ^ snark_coordinator_id) + [ Kubernetes_network.Workload_to_deploy.cons_pod_info + "mina" + ] ) + ] + else Core.String.Map.of_alist_exn [] + in + let snark_worker_workloads = + if config.replicas > 0 then + Core.String.Map.of_alist_exn + [ ( config.name ^ "-worker-" ^ snark_coordinator_id + , Kubernetes_network.Workload_to_deploy.construct_workload + (config.name ^ "-worker-" ^ snark_coordinator_id) + (List.init config.replicas ~f:(fun _i -> + Kubernetes_network.Workload_to_deploy.cons_pod_info + "worker" ) ) ) + ] + else Core.String.Map.of_alist_exn [] + in + (snark_coordinator_workloads, snark_worker_workloads) + | None -> + (Core.String.Map.of_alist_exn [], Core.String.Map.of_alist_exn []) + in + (* + let snark_coordinator_id = + String.lowercase + (String.sub network_config.terraform.snark_worker_public_key + ~pos: + (String.length network_config.terraform.snark_worker_public_key - 6) + ~len:6 ) + in + let snark_coordinator_workloads = + if network_config.terraform.snark_worker_replicas > 0 then + [ Kubernetes_network.Workload_to_deploy.construct_workload + ("snark-coordinator-" ^ snark_coordinator_id) + [ Kubernetes_network.Workload_to_deploy.cons_pod_info "mina" ] + ] + else [] + in + let snark_worker_workloads = + if network_config.terraform.snark_worker_replicas > 0 then + [ Kubernetes_network.Workload_to_deploy.construct_workload + ("snark-worker-" ^ snark_coordinator_id) + (List.init network_config.terraform.snark_worker_replicas + ~f:(fun _i -> + Kubernetes_network.Workload_to_deploy.cons_pod_info "worker" ) + ) + ] + else [] + in *) let block_producer_workloads = List.map network_config.terraform.block_producer_configs ~f:(fun bp_config -> - Kubernetes_network.Workload_to_deploy.construct_workload - bp_config.name - [ Kubernetes_network.Workload_to_deploy.cons_pod_info - ~network_keypair:bp_config.keypair "mina" - ] ) + ( bp_config.name + , Kubernetes_network.Workload_to_deploy.construct_workload + bp_config.name + [ Kubernetes_network.Workload_to_deploy.cons_pod_info + ~network_keypair:bp_config.keypair "mina" + ] ) ) + |> Core.String.Map.of_alist_exn in let archive_workloads = List.init network_config.terraform.archive_node_count ~f:(fun i -> - Kubernetes_network.Workload_to_deploy.construct_workload - (sprintf "archive-%d" (i + 1)) - [ Kubernetes_network.Workload_to_deploy.cons_pod_info - ~has_archive_container:true "mina" - ] ) + ( sprintf "archive-%d" (i + 1) + , Kubernetes_network.Workload_to_deploy.construct_workload + (sprintf "archive-%d" (i + 1)) + [ Kubernetes_network.Workload_to_deploy.cons_pod_info + ~has_archive_container:true "mina" + ] ) ) + |> Core.String.Map.of_alist_exn in let workloads_by_id = let all_workloads = - seed_workloads @ snark_coordinator_workloads @ snark_worker_workloads - @ block_producer_workloads @ archive_workloads + Core.String.Map.data seed_workloads + @ Core.String.Map.data snark_coordinator_workloads + @ Core.String.Map.data snark_worker_workloads + @ Core.String.Map.data block_producer_workloads + @ Core.String.Map.data archive_workloads in all_workloads |> List.map ~f:(fun w -> (w.workload_id, w)) @@ -577,12 +705,14 @@ module Network_manager = struct ; archive_workloads ; workloads_by_id ; deployed = false - ; block_producer_keypairs = - List.map network_config.block_producer_keypairs - ~f:(fun { keypair; _ } -> keypair) - ; extra_genesis_keypairs = - List.map network_config.extra_genesis_keypairs - ~f:(fun { keypair; _ } -> keypair) + ; genesis_keypairs = + network_config.genesis_keypairs + (* ; block_producer_keypairs = + List.map network_config.block_producer_keypairs + ~f:(fun { keypair; _ } -> keypair) + ; extra_genesis_keypairs = + List.map network_config.extra_genesis_keypairs + ~f:(fun { keypair; _ } -> keypair) *) } in (* check capacity *) @@ -666,7 +796,7 @@ module Network_manager = struct |> List.map ~f:(fun node -> (node.pod_id, node)) |> String.Map.of_alist_exn in - let result = + let network = { Kubernetes_network.namespace = t.namespace ; constants = t.constants ; seeds @@ -676,8 +806,7 @@ module Network_manager = struct ; archive_nodes ; nodes_by_pod_id ; testnet_log_filter = t.testnet_log_filter - ; block_producer_keypairs = t.block_producer_keypairs - ; extra_genesis_keypairs = t.extra_genesis_keypairs + ; genesis_keypairs = t.genesis_keypairs } in let nodes_to_string = @@ -687,11 +816,11 @@ module Network_manager = struct [%log info] "Network deployed" ; [%log info] "testnet namespace: %s" t.namespace ; [%log info] "snark coordinators: %s" - (nodes_to_string result.snark_coordinators) ; - [%log info] "snark workers: %s" (nodes_to_string result.snark_workers) ; - [%log info] "block producers: %s" (nodes_to_string result.block_producers) ; - [%log info] "archive nodes: %s" (nodes_to_string result.archive_nodes) ; - result + (nodes_to_string network.snark_coordinators) ; + [%log info] "snark workers: %s" (nodes_to_string network.snark_workers) ; + [%log info] "block producers: %s" (nodes_to_string network.block_producers) ; + [%log info] "archive nodes: %s" (nodes_to_string network.archive_nodes) ; + network let destroy t = [%log' info t.logger] "Destroying network" ; diff --git a/src/lib/integration_test_lib/intf.ml b/src/lib/integration_test_lib/intf.ml index b9c5ecf068c..2d6614127c2 100644 --- a/src/lib/integration_test_lib/intf.ml +++ b/src/lib/integration_test_lib/intf.ml @@ -176,6 +176,8 @@ module Engine = struct type t + (* val labeled_keypairs : ( Signature_lib.Public_key.Compressed.t * Signature_lib.Private_key.t ) String.Map.t *) + val constants : t -> Test_config.constants val constraint_constants : t -> Genesis_constants.Constraint_constants.t @@ -194,11 +196,7 @@ module Engine = struct val all_nodes : t -> Node.t list - val all_keypairs : t -> Signature_lib.Keypair.t list - - val block_producer_keypairs : t -> Signature_lib.Keypair.t list - - val extra_genesis_keypairs : t -> Signature_lib.Keypair.t list + val genesis_keypairs : t -> Network_keypair.t Core.String.Map.t val initialize_infra : logger:Logger.t -> t -> unit Malleable_error.t end diff --git a/src/lib/integration_test_lib/test_config.ml b/src/lib/integration_test_lib/test_config.ml index b6842dbbb13..a1f1d38f58b 100644 --- a/src/lib/integration_test_lib/test_config.ml +++ b/src/lib/integration_test_lib/test_config.ml @@ -8,8 +8,23 @@ module Container_images = struct } end -module Wallet = struct - type t = { balance : string; timing : Mina_base.Account_timing.t } +(* module Labeled_keypair = Map.Make(String) *) + +module Test_Account = struct + type t = + { account_name : string + ; balance : string + ; timing : Mina_base.Account_timing.t + } +end + +module Block_producer_node = struct + type t = { node_name : string; account_name : string } +end + +module Snark_worker_node = struct + type t = { node_name : string; account_name : string; replicas : int } + [@@deriving to_yojson] end type constants = @@ -19,21 +34,23 @@ type constants = [@@deriving to_yojson] type t = - { (* temporary flag to enable/disable graphql ingress deployments *) - requires_graphql : bool + { requires_graphql : bool + (* temporary flag to enable/disable graphql ingress deployments *) + (* testnet topography *) + ; genesis_ledger : Test_Account.t list + ; block_producers : Block_producer_node.t list + ; snark_worker : Snark_worker_node.t option + ; snark_worker_fee : string + ; num_archive_nodes : int + ; log_precomputed_blocks : bool + (* ; num_plain_nodes : int *) + (* blockchain constants *) + ; proof_config : Runtime_config.Proof_keys.t ; k : int ; delta : int ; slots_per_epoch : int ; slots_per_sub_window : int ; txpool_max_size : int - ; block_producers : Wallet.t list - ; extra_genesis_accounts : Wallet.t list - ; num_snark_workers : int - ; num_archive_nodes : int - ; log_precomputed_blocks : bool - ; snark_worker_fee : string - ; snark_worker_public_key : string - ; proof_config : Runtime_config.Proof_keys.t } let proof_config_default : Runtime_config.Proof_keys.t = @@ -51,19 +68,20 @@ let proof_config_default : Runtime_config.Proof_keys.t = let default = { requires_graphql = false + ; genesis_ledger = [] + ; block_producers = [] + ; snark_worker = None + ; snark_worker_fee = + "0.025" + (* ; snark_worker_public_key = + (let pk, _ = (Lazy.force Mina_base.Sample_keypairs.keypairs).(0) in + Signature_lib.Public_key.Compressed.to_string pk ) *) + ; num_archive_nodes = 0 + ; log_precomputed_blocks = false (* ; num_plain_nodes = 0 *) + ; proof_config = proof_config_default ; k = 20 ; slots_per_epoch = 3 * 8 * 20 ; slots_per_sub_window = 2 ; delta = 0 ; txpool_max_size = 3000 - ; block_producers = [] - ; extra_genesis_accounts = [] - ; num_snark_workers = 0 - ; num_archive_nodes = 0 - ; log_precomputed_blocks = false - ; snark_worker_fee = "0.025" - ; snark_worker_public_key = - (let pk, _ = (Lazy.force Mina_base.Sample_keypairs.keypairs).(0) in - Signature_lib.Public_key.Compressed.to_string pk ) - ; proof_config = proof_config_default }