https://gitlab.com/tezos/tezos
Tip revision: 040af5c8affd25febc1cf77cd0b2673714b0019e authored by Ding Xiang Fei on 14 June 2022, 10:42:58 UTC
Proto: propose gas model
Proto: propose gas model
Tip revision: 040af5c
client_config.ml
(*****************************************************************************)
(* *)
(* Open Source License *)
(* Copyright (c) 2018 Dynamic Ledger Solutions, Inc. <contact@tezos.com> *)
(* Copyright (c) 2018-2020 Nomadic Labs, <contact@nomadic-labs.com> *)
(* *)
(* Permission is hereby granted, free of charge, to any person obtaining a *)
(* copy of this software and associated documentation files (the "Software"),*)
(* to deal in the Software without restriction, including without limitation *)
(* the rights to use, copy, modify, merge, publish, distribute, sublicense, *)
(* and/or sell copies of the Software, and to permit persons to whom the *)
(* Software is furnished to do so, subject to the following conditions: *)
(* *)
(* The above copyright notice and this permission notice shall be included *)
(* in all copies or substantial portions of the Software. *)
(* *)
(* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR*)
(* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *)
(* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *)
(* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER*)
(* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *)
(* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *)
(* DEALINGS IN THE SOFTWARE. *)
(* *)
(*****************************************************************************)
(* Tezos Command line interface - Configuration and Arguments Parsing *)
type cli_args = {
chain : Chain_services.chain;
block : Shell_services.block;
confirmations : int option;
sources : Tezos_proxy.Light.sources_config option;
password_filename : string option;
protocol : Protocol_hash.t option;
print_timings : bool;
log_requests : bool;
better_errors : bool;
client_mode : client_mode;
}
and client_mode = [`Mode_client | `Mode_light | `Mode_mockup | `Mode_proxy]
let all_modes = [`Mode_client; `Mode_light; `Mode_mockup; `Mode_proxy]
let client_mode_to_string = function
| `Mode_client -> "client"
| `Mode_light -> "light"
| `Mode_mockup -> "mockup"
| `Mode_proxy -> "proxy"
type error += Invalid_endpoint_arg of string
type error += Invalid_media_type_arg of string
type error += Suppressed_arg of {args : string list; by : string}
type error += Invalid_chain_argument of string
type error += Invalid_block_argument of string
type error += Invalid_protocol_argument of string
type error += Invalid_port_arg of string
type error += Invalid_remote_signer_argument of string
type error += Invalid_wait_arg of string
type error += Invalid_mode_arg of string
let () =
register_error_kind
`Branch
~id:"badMediaTypeArgument"
~title:"Bad Media Type Argument"
~description:"Media type argument could not be parsed"
~pp:(fun ppf s ->
Format.fprintf
ppf
"media_type parameter must be 'json', 'binary' or 'any'. Got: %s"
s)
Data_encoding.(obj1 (req "value" string))
(function Invalid_media_type_arg s -> Some s | _ -> None)
(fun s -> Invalid_media_type_arg s) ;
register_error_kind
`Branch
~id:"badEndpointArgument"
~title:"Bad Endpoint Argument"
~description:"Endpoint argument could not be parsed"
~pp:(fun ppf s -> Format.pp_print_string ppf s)
Data_encoding.(obj1 (req "value" string))
(function Invalid_endpoint_arg s -> Some s | _ -> None)
(fun s -> Invalid_endpoint_arg s) ;
register_error_kind
`Branch
~id:"suppressedArgument"
~title:"Suppressed Argument"
~description:"Certain arguments are conflicting with some other"
~pp:(fun ppf (args, by) ->
Format.fprintf
ppf
(if List.length args == 1 then "Option %s is in conflict with %s"
else "Options %s are in conflict with %s")
(String.concat " and " args)
by)
Data_encoding.(obj2 (req "suppressed" (list string)) (req "by" string))
(function Suppressed_arg e -> Some (e.args, e.by) | _ -> None)
(fun (args, by) -> Suppressed_arg {args; by}) ;
register_error_kind
`Branch
~id:"badChainArgument"
~title:"Bad Chain Argument"
~description:"Chain argument could not be parsed"
~pp:(fun ppf s ->
Format.fprintf ppf "Value %s is not a value chain reference." s)
Data_encoding.(obj1 (req "value" string))
(function Invalid_chain_argument s -> Some s | _ -> None)
(fun s -> Invalid_chain_argument s) ;
register_error_kind
`Branch
~id:"badBlockArgument"
~title:"Bad Block Argument"
~description:"Block argument could not be parsed"
~pp:(fun ppf s ->
Format.fprintf ppf "Value %s is not a value block reference." s)
Data_encoding.(obj1 (req "value" string))
(function Invalid_block_argument s -> Some s | _ -> None)
(fun s -> Invalid_block_argument s) ;
register_error_kind
`Branch
~id:"badProtocolArgument"
~title:"Bad Protocol Argument"
~description:"Protocol argument could not be parsed"
~pp:(fun ppf s ->
Format.fprintf ppf "Value %s does not correspond to any known protocol." s)
Data_encoding.(obj1 (req "value" string))
(function Invalid_protocol_argument s -> Some s | _ -> None)
(fun s -> Invalid_protocol_argument s) ;
register_error_kind
`Branch
~id:"invalidPortArgument"
~title:"Bad Port Argument"
~description:"Port argument could not be parsed"
~pp:(fun ppf s -> Format.fprintf ppf "Value %s is not a valid TCP port." s)
Data_encoding.(obj1 (req "value" string))
(function Invalid_port_arg s -> Some s | _ -> None)
(fun s -> Invalid_port_arg s) ;
register_error_kind
`Branch
~id:"invalid_remote_signer_argument"
~title:"Unexpected URI of remote signer"
~description:"The remote signer argument could not be parsed"
~pp:(fun ppf s -> Format.fprintf ppf "Value '%s' is not a valid URI." s)
Data_encoding.(obj1 (req "value" string))
(function Invalid_remote_signer_argument s -> Some s | _ -> None)
(fun s -> Invalid_remote_signer_argument s) ;
register_error_kind
`Branch
~id:"invalidWaitArgument"
~title:"Bad Wait Argument"
~description:"Wait argument could not be parsed"
~pp:(fun ppf s ->
Format.fprintf
ppf
"Value %s is not a valid number of confirmation, nor 'none'."
s)
Data_encoding.(obj1 (req "value" string))
(function Invalid_wait_arg s -> Some s | _ -> None)
(fun s -> Invalid_wait_arg s) ;
register_error_kind
`Branch
~id:"invalidModeArgument"
~title:"Invalid Mode Argument"
~description:"Mode argument could not be parsed"
~pp:(fun ppf s ->
let enclose s = "\"" ^ s ^ "\"" in
let pp_mode s = enclose @@ client_mode_to_string s in
let mode_strings = List.map pp_mode all_modes in
Format.fprintf
ppf
"Value \"%s\" is invalid. It should be one of: %s"
s
(String.concat " or " mode_strings))
Data_encoding.(obj1 (req "value" string))
(function Invalid_mode_arg s -> Some s | _ -> None)
(fun s -> Invalid_mode_arg s)
let home = try Sys.getenv "HOME" with Not_found -> "/root"
let base_dir_env_name = "TEZOS_CLIENT_DIR"
let default_base_dir =
try Sys.getenv base_dir_env_name
with Not_found -> Filename.concat home ".tezos-client"
let default_chain = `Main
let default_block = `Head 0
let default_endpoint = Uri.of_string "http://localhost:8732"
let default_media_type = Media_type.Command_line.Any
open Filename.Infix
module Cfg_file = struct
(* the fields [node_addr], [node_port], and [tls] are deprecated by
* and should not coexist with [endpoint].
* see [parse_config_args] for the exact handling *)
type t = {
base_dir : string;
node_addr : string option;
node_port : int option;
tls : bool option;
media_type : Media_type.Command_line.t option;
endpoint : Uri.t option;
web_port : int;
remote_signer : Uri.t option;
confirmations : int option;
password_filename : string option;
}
let default =
{
base_dir = default_base_dir;
media_type = None;
endpoint = None;
node_addr = None;
node_port = None;
tls = None;
web_port = 8080;
remote_signer = None;
confirmations = Some 0;
password_filename = None;
}
open Data_encoding
let encoding =
conv
(fun {
base_dir;
node_addr;
node_port;
tls;
media_type;
endpoint;
web_port;
remote_signer;
confirmations;
password_filename;
} ->
( base_dir,
node_addr,
node_port,
tls,
media_type,
endpoint,
Some web_port,
remote_signer,
confirmations,
password_filename ))
(fun ( base_dir,
node_addr,
node_port,
tls,
media_type,
endpoint,
web_port,
remote_signer,
confirmations,
password_filename ) ->
let web_port = Option.value ~default:default.web_port web_port in
{
base_dir;
node_addr;
node_port;
tls;
media_type;
endpoint;
web_port;
remote_signer;
confirmations;
password_filename;
})
(obj10
(req "base_dir" string)
(opt "node_addr" string)
(opt "node_port" uint16)
(opt "tls" bool)
(opt "media_type" Media_type.Command_line.encoding)
(opt "endpoint" RPC_encoding.uri_encoding)
(opt "web_port" uint16)
(opt "remote_signer" RPC_encoding.uri_encoding)
(opt "confirmations" int8)
(opt "password_filename" string))
let from_json json = Data_encoding.Json.destruct encoding json
let read fp =
let open Lwt_result_syntax in
let* json = Lwt_utils_unix.Json.read_file fp in
return (from_json json)
let write out cfg =
Lwt_utils_unix.Json.write_file
out
(Data_encoding.Json.construct encoding cfg)
end
let default_cli_args =
{
chain = default_chain;
block = default_block;
confirmations = Some 0;
sources = None;
password_filename = None;
protocol = None;
print_timings = false;
log_requests = false;
better_errors = false;
client_mode = `Mode_client;
}
open Clic
let string_parameter () : (string, #Client_context.full) parameter =
parameter (fun _ x -> Lwt.return_ok x)
let media_type_parameter () :
(Media_type.Command_line.t, #Client_context.full) parameter =
let open Lwt_result_syntax in
parameter (fun _ x ->
match Media_type.Command_line.parse_cli_parameter x with
| Some v -> return v
| None -> tzfail (Invalid_media_type_arg x))
let endpoint_parameter () =
let open Lwt_result_syntax in
parameter (fun _ x ->
let parsed = Uri.of_string x in
let* _ =
match Uri.scheme parsed with
| Some "http" | Some "https" -> return ()
| _ ->
tzfail
(Invalid_endpoint_arg
("only http and https endpoints are supported: " ^ x))
in
match (Uri.query parsed, Uri.fragment parsed) with
| [], None -> return parsed
| _ ->
tzfail
(Invalid_endpoint_arg
("endpoint uri should not have query string or fragment: " ^ x)))
let sources_parameter () =
let open Lwt_result_syntax in
parameter (fun _ path ->
let*! r = Lwt_utils_unix.Json.read_file path in
match r with
| Error errs ->
failwith
"Can't parse the file specified by --sources as JSON: %s@,%a"
path
pp_print_trace
errs
| Ok json -> (
try
match Tezos_proxy.Light.destruct_sources_config json with
| Ok sources_cfg -> return sources_cfg
| Error msg -> failwith "%s" msg
with exn ->
failwith
"Can't parse the file specified by --sources: %s@,%a"
path
(fun ppf exn -> Json_encoding.print_error ppf exn)
exn))
let chain_parameter () =
parameter (fun _ chain ->
let open Lwt_result_syntax in
match Chain_services.parse_chain chain with
| Error _ -> tzfail (Invalid_chain_argument chain)
| Ok chain -> return chain)
let block_parameter () =
parameter (fun _ block ->
let open Lwt_result_syntax in
match Block_services.parse_block block with
| Error _ -> tzfail (Invalid_block_argument block)
| Ok block -> return block)
let wait_parameter () =
parameter (fun _ wait ->
let open Lwt_result_syntax in
match wait with
| "no" | "none" -> return_none
| _ -> (
match int_of_string_opt wait with
| Some w when 0 <= w -> return_some w
| None | Some _ -> tzfail (Invalid_wait_arg wait)))
let protocol_parameter () =
parameter (fun _ arg ->
let open Lwt_result_syntax in
match
Seq.filter
(fun (hash, _commands) ->
String.has_prefix ~prefix:arg (Protocol_hash.to_b58check hash))
(Client_commands.get_versions ())
@@ ()
with
| Cons ((hash, _commands), _) -> return_some hash
| Nil -> tzfail (Invalid_protocol_argument arg))
(* Command-line only args (not in config file) *)
let base_dir_arg () =
arg
~long:"base-dir"
~short:'d'
~placeholder:"path"
~doc:
(Format.asprintf
"@[<v>@[<2>client data directory (absent: %s env)@,\
The directory where the Tezos client will store all its data.@,\
If absent, its value is the value of the %s@,\
environment variable. If %s is itself not specified,@,\
defaults to %s@]@]@."
base_dir_env_name
base_dir_env_name
base_dir_env_name
default_base_dir)
(string_parameter ())
let config_file_arg () =
arg
~long:"config-file"
~short:'c'
~placeholder:"path"
~doc:"configuration file"
(string_parameter ())
let timings_switch () =
switch ~long:"timings" ~short:'t' ~doc:"show RPC request times" ()
let chain_arg () =
default_arg
~long:"chain"
~placeholder:"hash|tag"
~doc:
"chain on which to apply contextual commands (commands dependent on the \
context associated with the specified chain). Possible tags are 'main' \
and 'test'."
~default:(Chain_services.to_string default_cli_args.chain)
(chain_parameter ())
let block_arg () =
default_arg
~long:"block"
~short:'b'
~placeholder:"hash|level|tag"
~doc:
"block on which to apply contextual commands (commands dependent on the \
context associated with the specified block). Possible tags include \
'head' and 'genesis' +/- an optional offset (e.g. \"tezos-client -b \
head-1 get timestamp\"). Note that block queried must exist in node's \
storage."
~default:(Block_services.to_string default_cli_args.block)
(block_parameter ())
let wait_arg () =
arg
~long:"wait"
~short:'w'
~placeholder:"none|<int>"
~doc:
"how many confirmation blocks are needed before an operation is \
considered included"
(wait_parameter ())
let protocol_arg () =
arg
~long:"protocol"
~short:'p'
~placeholder:"hash"
~doc:"use commands of a specific protocol"
(protocol_parameter ())
let log_requests_switch () =
switch ~long:"log-requests" ~short:'l' ~doc:"log all requests to the node" ()
let better_errors () =
switch
~long:"better-errors"
~doc:
"Error reporting is more detailed. Can be used if a call to an RPC fails \
or if you don't know the input accepted by the RPC. It may happen that \
the RPC calls take more time however."
()
(* Command-line args which can be set in config file as well *)
let addr_confdesc = "-A/--addr ('node_addr' in config file)"
let addr_arg () =
arg
~long:"addr"
~short:'A'
~placeholder:"IP addr|host"
~doc:"[DEPRECATED: use --endpoint instead] IP address of the node"
(string_parameter ())
let port_confdesc = "-P/--port ('node_port' in config file)"
let port_arg () =
arg
~long:"port"
~short:'P'
~placeholder:"number"
~doc:"[DEPRECATED: use --endpoint instead] RPC port of the node"
(parameter (fun _ x ->
let open Lwt_result_syntax in
match int_of_string_opt x with
| Some i -> return i
| None -> tzfail (Invalid_port_arg x)))
let tls_confdesc = "-S/--tls ('tls' in config file)"
let tls_switch () =
switch
~long:"tls"
~short:'S'
~doc:"[DEPRECATED: use --endpoint instead] use TLS to connect to node."
()
let media_type_confdesc = "-m/--media-type"
let media_type_arg () =
arg
~long:"media-type"
~short:'m'
~placeholder:"json, binary, any or default"
~doc:
"Sets the \"media-type\" value for the \"accept\" header for RPC \
requests to the node. The media accept header indicates to the node \
which format of data serialisation is supported. Use the value \"json\" \
for serialisation to the JSON format.\n\
\ Use the value \"binary\" for faster but less human-readable \
binary serialisation format."
(media_type_parameter ())
let endpoint_confdesc = "-E/--endpoint ('endpoint' in config file)"
let endpoint_arg () =
arg
~long:"endpoint"
~short:'E'
~placeholder:"uri"
~doc:
"HTTP(S) endpoint of the node RPC interface; e.g. 'http://localhost:8732'"
(endpoint_parameter ())
let sources_arg () =
arg
~long:"sources"
~short:'s'
~placeholder:"path"
~doc:
("path to JSON file containing sources for --mode light. Example file \
content: " ^ Tezos_proxy.Light.example_sources)
(sources_parameter ())
let remote_signer_arg () =
arg
~long:"remote-signer"
~short:'R'
~placeholder:"uri"
~doc:"URI of the remote signer"
(parameter (fun _ x -> Tezos_signer_backends_unix.Remote.parse_base_uri x))
let password_filename_arg () =
arg
~long:"password-filename"
~short:'f'
~placeholder:"filename"
~doc:"path to the password filename"
(string_parameter ())
let client_mode_arg () =
let mode_strings = List.map client_mode_to_string all_modes in
let parse_client_mode (str : string) : client_mode tzresult =
let open Result_syntax in
let* modes_and_strings =
List.combine
~when_different_lengths:(TzTrace.make @@ Exn (Failure __LOC__))
mode_strings
all_modes
in
match List.assoc_opt ~equal:String.equal str modes_and_strings with
| None -> tzfail (Invalid_mode_arg str)
| Some mode -> return mode
in
default_arg
~short:'M'
~long:"mode"
~placeholder:(String.concat "|" mode_strings)
~doc:"how to interact with the node"
~default:(client_mode_to_string `Mode_client)
(parameter
~autocomplete:(fun _ -> Lwt.return_ok mode_strings)
(fun _ param -> Lwt.return (parse_client_mode param)))
let read_config_file config_file =
let open Lwt_result_syntax in
let*! r = Lwt_utils_unix.Json.read_file config_file in
match r with
| Error errs ->
failwith
"Can't parse the configuration file as a JSON: %s@,%a"
config_file
pp_print_trace
errs
| Ok cfg_json -> (
try return @@ Cfg_file.from_json cfg_json
with exn ->
failwith
"Can't parse the configuration file: %s@,%a"
config_file
(fun ppf exn -> Json_encoding.print_error ppf exn)
exn)
let fail_on_non_mockup_dir (cctxt : #Client_context.full) =
let open Lwt_result_syntax in
let base_dir = cctxt#get_base_dir in
let open Tezos_mockup.Persistence in
let* b = classify_base_dir base_dir in
match b with
| Base_dir_does_not_exist | Base_dir_is_file | Base_dir_is_nonempty
| Base_dir_is_empty ->
failwith
"base directory at %s should be a mockup directory for this operation \
to be allowed (it may contain sensitive data otherwise). What you \
likely want is calling `tezos-client --mode mockup --base-dir \
/some/dir create mockup` where `/some/dir` is **fresh** and **empty** \
and redo this operation, specifying `--base-dir /some/dir` this time."
base_dir
| Base_dir_is_mockup -> return_unit
let default_config_file_name = "config"
let mockup_bootstrap_accounts = "bootstrap-accounts"
let mockup_protocol_constants = "protocol-constants"
(* The implementation of ["config"; "show"] when --mode is "client" *)
let config_show_client (cctxt : #Client_context.full) (config_file : string) cfg
=
let open Lwt_syntax in
let* () =
if not @@ Sys.file_exists config_file then
cctxt#warning
"@[<v 2>Warning: no config file at %s,@,\
displaying the default configuration.@]"
config_file
else Lwt.return_unit
in
let* () =
cctxt#message
"%a@,"
Data_encoding.Json.pp
(Data_encoding.Json.construct Cfg_file.encoding cfg)
in
return_ok_unit
(* The implementation of ["config"; "show"] when --mode is "mockup" *)
let config_show_mockup (cctxt : #Client_context.full)
(protocol_hash_opt : Protocol_hash.t option) (base_dir : string) =
let open Lwt_result_syntax in
let* () = fail_on_non_mockup_dir cctxt in
let* mockup, _ =
Tezos_mockup.Persistence.get_mockup_context_from_disk
~base_dir
~protocol_hash:protocol_hash_opt
cctxt
in
let (module Mockup) = mockup in
let json_pp encoding ppf value =
Data_encoding.Json.pp ppf (Data_encoding.Json.construct encoding value)
in
let* bootstrap_accounts_string = Mockup.default_bootstrap_accounts cctxt in
let*! () =
cctxt#message
"@[<v>Default value of --%s:@,%s@]"
mockup_bootstrap_accounts
bootstrap_accounts_string
in
let* protocol_constants = Mockup.default_protocol_constants cctxt in
let*! () =
cctxt#message
"@[<v>Default value of --%s:@,%a@]"
mockup_protocol_constants
(json_pp Mockup.protocol_constants_encoding)
protocol_constants
in
return_unit
(* The implementation of ["config"; "init"] when --mode is "client" *)
let config_init_client config_file cfg =
if not (Sys.file_exists config_file) then Cfg_file.(write config_file cfg)
(* Should be default or command would have failed *)
else failwith "Config file already exists at location: %s" config_file
(* The implementation of ["config"; "init"] when --mode is "mockup" *)
let config_init_mockup cctxt protocol_hash_opt bootstrap_accounts_file
protocol_constants_file base_dir =
let open Lwt_result_syntax in
let* () = fail_on_non_mockup_dir cctxt in
let* () =
fail_when
(Sys.file_exists bootstrap_accounts_file)
(error_of_fmt
"Config file to write value of --%s exists already: %s"
mockup_bootstrap_accounts
bootstrap_accounts_file)
in
let* () =
fail_when
(Sys.file_exists protocol_constants_file)
(error_of_fmt
"Config file to write value of --%s exists already: %s"
mockup_protocol_constants
protocol_constants_file)
in
let* mockup, _ =
Tezos_mockup.Persistence.get_mockup_context_from_disk
~base_dir
~protocol_hash:protocol_hash_opt
cctxt
in
let (module Mockup) = mockup in
let* string_to_write = Mockup.default_bootstrap_accounts cctxt in
let*! _ =
Lwt_utils_unix.create_file bootstrap_accounts_file string_to_write
in
let*! () =
cctxt#message
"Written default --%s file: %s"
mockup_bootstrap_accounts
bootstrap_accounts_file
in
let* protocol_constants = Mockup.default_protocol_constants cctxt in
let string_to_write =
Data_encoding.Json.construct
Mockup.protocol_constants_encoding
protocol_constants
in
let* () =
Lwt_utils_unix.Json.write_file protocol_constants_file string_to_write
in
let*! () =
cctxt#message
"Written default --%s file: %s"
mockup_protocol_constants
protocol_constants_file
in
return_unit
let commands config_file cfg (client_mode : client_mode)
(protocol_hash_opt : Protocol_hash.t option) (base_dir : string) =
let open Clic in
let group =
{
Clic.name = "config";
title = "Commands for editing and viewing the client's config file";
}
in
[
command
~group
~desc:
"Show the current config (config file content + command line \
arguments) or the mockup config files if `--mode mockup` is \
specified."
no_options
(fixed ["config"; "show"])
(fun () (cctxt : #Client_context.full) ->
match client_mode with
| `Mode_client | `Mode_light | `Mode_proxy ->
config_show_client cctxt config_file cfg
| `Mode_mockup -> config_show_mockup cctxt protocol_hash_opt base_dir);
command
~group
~desc:"Reset the config file to the factory defaults."
no_options
(fixed ["config"; "reset"])
(fun () _cctxt -> Cfg_file.(write config_file default));
command
~group
~desc:
"Update the config based on the current cli values.\n\
Loads the current configuration (default or as specified with \
`-config-file`), applies alterations from other command line \
arguments (such as the node's address, etc.), and overwrites the \
updated configuration file."
no_options
(fixed ["config"; "update"])
(fun () _cctxt -> Cfg_file.(write config_file cfg));
command
~group
~desc:
"Create config file(s) based on the current CLI values.\n\
If the `-file` option is not passed, this will initialize the default \
config file, based on default parameters, altered by other command \
line options (such as the node's address, etc.).\n\
Otherwise, it will create a new config file, based on the default \
parameters (or the the ones specified with `-config-file`), altered \
by other command line options.\n\n\
If `-mode mockup` is specified, this will initialize the mockup's \
default files instead of the config file. Use `-bootstrap-accounts` \
and `-protocol-constants` to specify custom paths.\n\n\
The command will always fail if file(s) to create exist already"
(args3
(default_arg
~long:"output"
~short:'o'
~placeholder:"path"
~doc:"path at which to create the file"
~default:(cfg.base_dir // default_config_file_name)
(parameter (fun _ctx str -> Lwt.return_ok str)))
(default_arg
~long:mockup_bootstrap_accounts
~placeholder:"path"
~doc:"path at which to create the file"
~default:((cfg.base_dir // mockup_bootstrap_accounts) ^ ".json")
(parameter (fun _ctx str -> Lwt.return_ok str)))
(default_arg
~long:mockup_protocol_constants
~placeholder:"path"
~doc:"path at which to create the file"
~default:((cfg.base_dir // mockup_protocol_constants) ^ ".json")
(parameter (fun _ctx str -> Lwt.return_ok str))))
(fixed ["config"; "init"])
(fun (config_file, bootstrap_accounts_file, protocol_constants_file) cctxt ->
match client_mode with
| `Mode_client | `Mode_light | `Mode_proxy ->
config_init_client config_file cfg
| `Mode_mockup ->
config_init_mockup
cctxt
protocol_hash_opt
bootstrap_accounts_file
protocol_constants_file
base_dir);
]
let global_options () =
args18
(base_dir_arg ())
(config_file_arg ())
(timings_switch ())
(chain_arg ())
(block_arg ())
(wait_arg ())
(protocol_arg ())
(log_requests_switch ())
(better_errors ())
(addr_arg ())
(port_arg ())
(tls_switch ())
(media_type_arg ())
(endpoint_arg ())
(sources_arg ())
(remote_signer_arg ())
(password_filename_arg ())
(client_mode_arg ())
type parsed_config_args = {
parsed_config_file : Cfg_file.t option;
parsed_args : cli_args option;
config_commands : Client_context.full command list;
base_dir : string option;
require_auth : bool;
}
let default_parsed_config_args =
{
parsed_config_file = None;
parsed_args = None;
config_commands = [];
base_dir = None;
require_auth = false;
}
(* Check that the base directory is actually in the right configuration for
* the mode used by the client.
*
* Depending on the criticality of the compatibility issue, this function fails
* (when all/most commands will fail) or emits a warning (some commands may
* fail).
*)
let check_base_dir_for_mode (ctx : #Client_context.full) client_mode base_dir =
let open Lwt_result_syntax in
let open Tezos_mockup.Persistence in
let* base_dir_class = classify_base_dir base_dir in
match client_mode with
| `Mode_client | `Mode_light | `Mode_proxy -> (
match base_dir_class with
| Base_dir_is_mockup ->
failwith
"Base directory %s is in mockup mode while operation is in %s mode"
base_dir
@@ client_mode_to_string client_mode
(* You might be creating a mockup directory here *)
| Base_dir_is_empty -> return_unit
| Base_dir_is_file | Base_dir_does_not_exist ->
(* This case is checked in by the caller so that it should not happen *)
failwith
"Error for base-dir %s should not have happened (this is due to %a)"
base_dir
pp_base_dir_class
base_dir_class
| _ -> return_unit)
| `Mode_mockup -> (
let warn_might_not_work explain =
let*! () =
ctx#warning
"@[<hv>Base directory %s %a@ Some commands (e.g., transfer) might \
not work correctly.@]"
base_dir
explain
()
in
return_unit
in
let show_cmd ppf () =
Format.fprintf
ppf
"./tezos-client --mode mockup --base-dir %s create mockup"
base_dir
in
match base_dir_class with
| Base_dir_is_empty ->
warn_might_not_work (fun ppf () ->
Format.fprintf
ppf
"is empty.@ Move directory %s away and create it anew with:@ \
%a@ or use another directory name."
base_dir
show_cmd
())
| Base_dir_does_not_exist ->
warn_might_not_work (fun ppf () ->
Format.fprintf
ppf
"does not exist.@ Create it with:@ %a"
show_cmd
())
| Base_dir_is_nonempty ->
warn_might_not_work (fun ppf () ->
Format.fprintf
ppf
"is non empty.@ Move directory %s away and create it anew \
with:@ %a@ or use another directory name."
base_dir
show_cmd
())
| Base_dir_is_file ->
warn_might_not_work (fun ppf () ->
Format.fprintf
ppf
"is a file.@ This is expected to be a directory.@ It can be \
created with:@ %a"
show_cmd
())
| Base_dir_is_mockup -> return_unit)
let build_endpoint addr port tls =
let updatecomp updatef ov uri =
match ov with Some x -> updatef uri (Some x) | None -> uri
in
let scheme = Option.map (function true -> "https" | false -> "http") tls in
let url = default_endpoint in
url
|> updatecomp Uri.with_host addr
|> updatecomp Uri.with_port port
|> updatecomp Uri.with_scheme scheme
let light_mode_checks mode endpoint sources =
let open Lwt_result_syntax in
match (mode, sources) with
| `Mode_client, None | `Mode_mockup, None | `Mode_proxy, None ->
(* No --mode light, no --sources; good *)
return_unit
| `Mode_client, Some _ | `Mode_mockup, Some _ | `Mode_proxy, Some _ ->
(* --sources without the light mode: wrong *)
failwith
"--sources is specified whereas mode is %s. --sources should only be \
used with --mode light."
@@ client_mode_to_string mode
| `Mode_light, None ->
(* --mode light without --sources: wrong *)
failwith
"--mode light requires passing --sources. Example --sources file: %s"
Tezos_proxy.Light.example_sources
| `Mode_light, Some sources ->
let sources_uris = Tezos_proxy.Light.sources_config_to_uris sources in
if List.mem ~equal:Uri.equal endpoint sources_uris then return_unit
else
let uri_to_json_string uri =
Uri.to_string uri |> Printf.sprintf "\"%s\""
in
failwith
"Value of --endpoint is %a. Therefore, this URI MUST be in field \
'uris' of --sources (whose value is: [%s]). If you did not specify \
--endpoint, it is being defaulted; you may hereby specify \
--endpoint %a to fix this error."
Uri.pp
endpoint
(String.concat ", " @@ List.map uri_to_json_string sources_uris)
(* By the check done in Light.mk_sources_config, [sources_uris]
cannot be empty, but we don't rely on this here, by using
pp_print_option. *)
(Format.pp_print_option Uri.pp)
(List.hd sources_uris)
let parse_config_args (ctx : #Client_context.full) argv =
let open Lwt_result_syntax in
let* ( ( base_dir,
config_file,
timings,
chain,
block,
confirmations,
protocol,
log_requests,
better_errors,
node_addr,
node_port,
tls,
media_type,
endpoint,
sources,
remote_signer,
password_filename,
client_mode ),
remaining ) =
parse_global_options (global_options ()) ctx argv
in
let* base_dir =
match base_dir with
| None ->
let base_dir = default_base_dir in
let* () =
unless
(* Mockup mode will create the base directory on need *)
(client_mode = `Mode_mockup || Sys.file_exists base_dir)
(fun () ->
let*! () = Lwt_utils_unix.create_dir base_dir in
return_unit)
in
return base_dir
| Some dir -> (
match client_mode with
| `Mode_client | `Mode_light | `Mode_proxy ->
if not (Sys.file_exists dir) then
failwith
"Specified --base-dir does not exist. Please create the \
directory and try again."
else if Sys.is_directory dir then return dir
else failwith "Specified --base-dir must be a directory"
| `Mode_mockup ->
(* In mockup mode base dir may be created automatically. *)
return dir)
in
let* () = check_base_dir_for_mode ctx client_mode base_dir in
let* () =
when_
(Option.is_some sources && client_mode <> `Mode_light)
(fun () ->
failwith
"--sources is specific to --mode light, please do not specify it \
with --mode %s."
@@ client_mode_to_string client_mode)
in
let* config_file =
match config_file with
| None -> return @@ (base_dir // default_config_file_name)
| Some config_file ->
if Sys.file_exists config_file then return config_file
else
failwith
"Config file specified in option does not exist. Use `client \
config init` to create one."
in
let config_dir = Filename.dirname config_file in
let protocol = match protocol with None -> None | Some p -> p in
let* cfg =
if not (Sys.file_exists config_file) then
return {Cfg_file.default with base_dir}
else read_config_file config_file
in
(* endpoint logic:
* 1) when --endpoint provided as argument,
* use it but check no presence of --addr, --port, or --tls
* 2) otherwise, merge --addr, --port, and --tls with config file; then
* 2a) --endpoint exists in config file,
* use it but check no presence of merged --addr, --port, or --tls
* 2b) synthesize --endpoint from --addr, --port, and --tls *)
let check_absence addr port tls =
let checkabs argdesc = function
| None -> fun x -> x
| _ -> fun x -> x @ [argdesc]
in
let superr =
[]
|> checkabs addr_confdesc addr
|> checkabs port_confdesc port
|> checkabs tls_confdesc tls
in
if superr <> [] then
tzfail (Suppressed_arg {args = superr; by = endpoint_confdesc})
else return ()
in
let tls = if tls then Some true else None in
let* endpoint =
match endpoint with
| Some endpt ->
let* _ = check_absence node_addr node_port tls in
return endpt
| None -> (
let node_addr = Option.either node_addr cfg.node_addr in
let node_port = Option.either node_port cfg.node_port in
let tls = Option.either tls cfg.tls in
match cfg.endpoint with
| Some endpt ->
let* _ = check_absence node_addr node_port tls in
return endpt
| None -> return (build_endpoint node_addr node_port tls))
in
(* give a kind warning when any of -A -P -S exists *)
(let got = function Some _ -> true | None -> false in
let gotany =
got node_addr || got node_port || got tls || got cfg.node_addr
|| got cfg.node_port || got cfg.tls
in
if gotany then (
Format.(
eprintf
"@{<warning>Warning:@} the --addr --port --tls options are now \
deprecated; use --endpoint instead\n" ;
pp_print_flush err_formatter ()))) ;
let* () = light_mode_checks client_mode endpoint sources in
let* remote_signer_env =
Tezos_signer_backends_unix.Remote.read_base_uri_from_env ()
in
let remote_signer =
Option.either remote_signer
@@ Option.either remote_signer_env cfg.remote_signer
in
let confirmations = Option.value ~default:cfg.confirmations confirmations in
(* --password-filename has precedence over --config-file's
"password-filename" json field *)
let password_filename =
Option.either password_filename cfg.password_filename
in
let media_type = Option.either media_type cfg.media_type in
let cfg =
{
cfg with
node_addr = None;
node_port = None;
tls = None;
media_type;
endpoint = Some endpoint;
remote_signer;
confirmations;
password_filename;
}
in
if Sys.file_exists base_dir && not (Sys.is_directory base_dir) then (
Format.eprintf "%s is not a directory.@." base_dir ;
exit 1) ;
if Sys.file_exists config_dir && not (Sys.is_directory config_dir) then (
Format.eprintf "%s is not a directory.@." config_dir ;
exit 1) ;
let* () =
unless (client_mode = `Mode_mockup) (fun () ->
let*! () = Lwt_utils_unix.create_dir config_dir in
return_unit)
in
let parsed_args =
{
chain;
block;
confirmations;
sources;
print_timings = timings;
log_requests;
better_errors;
password_filename;
protocol;
client_mode;
}
in
return
( {
default_parsed_config_args with
parsed_config_file = Some cfg;
parsed_args = Some parsed_args;
config_commands =
commands config_file cfg client_mode parsed_args.protocol base_dir;
},
remaining )
type t =
string option
* string option
* bool
* Shell_services.chain
* Shell_services.block
* int option option
* Protocol_hash.t option option
* bool
* bool
* string option
* int option
* bool
* Media_type.Command_line.t option
* Uri.t option
* Tezos_proxy.Light.sources_config option
* Uri.t option
* string option
* client_mode
module type Remote_params = sig
val authenticate :
Signature.public_key_hash list -> Bytes.t -> Signature.t tzresult Lwt.t
val logger : Tezos_rpc_http_client_unix.RPC_client_unix.logger
end
let other_registrations : (_ -> (module Remote_params) -> _) option =
Some
(fun parsed_config_file (module Remote_params) ->
parsed_config_file.Cfg_file.remote_signer
|> Option.iter (fun signer ->
Client_keys.register_signer
(module Tezos_signer_backends_unix.Remote.Make
(Tezos_rpc_http_client_unix.RPC_client_unix)
(struct
let default = signer
include Remote_params
end))))
let clic_commands ~base_dir:_ ~config_commands ~builtin_commands ~other_commands
~require_auth:_ =
config_commands @ builtin_commands @ other_commands
let logger = None