682 lines
18 KiB
Bash
Executable File
682 lines
18 KiB
Bash
Executable File
#!/bin/bash
|
|
|
|
set -e
|
|
|
|
if ! docker > /dev/null 2>&1 ; then
|
|
echo "Docker does not seem to be installed."
|
|
exit 1
|
|
fi
|
|
|
|
docker_version="$(docker version -f "{{ .Server.Version }}")"
|
|
docker_major="$(echo "$docker_version" | cut -d . -f 1)"
|
|
docker_minor="$(echo "$docker_version" | cut -d . -f 2)"
|
|
|
|
if ([ "$docker_major" -gt 1 ] ||
|
|
( [ "$docker_major" -eq 1 ] && [ "$docker_minor" -ge 13 ] )) ; then
|
|
docker_1_13=true
|
|
else
|
|
docker_1_13=false
|
|
fi
|
|
|
|
src_dir="$(cd "$(dirname "$0")" && echo "$(pwd -P)/")"
|
|
cd "$src_dir"
|
|
|
|
default_port=9732
|
|
port="$default_port"
|
|
|
|
docker_image=docker.io/tezos/tezos:alphanet
|
|
docker_volume=tezos-alphanet-data$suffix
|
|
suffix=
|
|
|
|
data_dir="$HOME/.tezos-alphanet$suffix"
|
|
docker_container="tezos-alphanet$suffix"
|
|
|
|
if [ $ALPHANET_EMACS ]; then
|
|
interactive_flags="-t"
|
|
else
|
|
interactive_flags="-it"
|
|
fi
|
|
|
|
|
|
## Saving state ############################################################
|
|
|
|
save_identity() {
|
|
if [ ! -f "$data_dir/identity.json" ]; then
|
|
echo "Saving the generated identity into '$data_dir/identity.json'..."
|
|
mkdir -p "$data_dir/"
|
|
fi
|
|
docker cp "$docker_container:var/run/tezos/node/identity.json" \
|
|
"$data_dir/"
|
|
}
|
|
|
|
|
|
may_restore_identity() {
|
|
if [ -f "$data_dir/identity.json" ]; then
|
|
echo "Restoring the peer identity from '$data_dir/identity.json'..."
|
|
docker exec "$docker_container" mkdir -p /var/run/tezos/node/
|
|
docker cp "$data_dir/identity.json" \
|
|
"$docker_container:var/run/tezos/node/"
|
|
docker exec "$docker_container" \
|
|
sudo chown tezos "/var/run/tezos/node/identity.json"
|
|
fi
|
|
}
|
|
|
|
may_save_client_file() {
|
|
if docker exec "$docker_container" \
|
|
test -f "/var/run/tezos/client/$1" ; then
|
|
docker cp "$docker_container:var/run/tezos/client/$1" \
|
|
"$data_dir/$1"
|
|
elif [ -f "$data_dir/$1" ] ; then
|
|
mv "$data_dir/$1" "$data_dir/$1.bak"
|
|
fi
|
|
}
|
|
|
|
may_restore_client_file() {
|
|
if [ -f "$data_dir/$1" ]; then
|
|
docker cp "$data_dir/$1" \
|
|
"$docker_container:var/run/tezos/client/"
|
|
docker exec "$docker_container" \
|
|
sudo chown tezos "/var/run/tezos/client/$1"
|
|
fi
|
|
}
|
|
|
|
save_accounts() {
|
|
if ! docker exec "$docker_container" \
|
|
test -f "/var/run/tezos/client/secret keys" ; then
|
|
return
|
|
fi
|
|
if [ ! -f "$data_dir/secret keys" ]; then
|
|
echo "Saving the secrets into '$data_dir/secret keys'..."
|
|
echo
|
|
echo "\033[33mWARNING: THE SECRET KEYS FILE IS UNENCRYPTED!!!\033[0m"
|
|
echo
|
|
mkdir -p "$data_dir/"
|
|
fi
|
|
docker cp "$docker_container:var/run/tezos/client/secret keys" \
|
|
"$data_dir/"
|
|
may_save_client_file "public key hashs"
|
|
may_save_client_file "public keys"
|
|
may_save_client_file "contracts"
|
|
}
|
|
|
|
may_restore_accounts() {
|
|
docker exec "$docker_container" mkdir -p /var/run/tezos/client/
|
|
if [ -f "$data_dir/secret keys" ]; then
|
|
echo "Restoring the secret keys from '$data_dir/secret keys'..."
|
|
may_restore_client_file "secret keys"
|
|
fi
|
|
may_restore_client_file "public key hashs"
|
|
may_restore_client_file "public keys"
|
|
may_restore_client_file "contracts"
|
|
}
|
|
|
|
|
|
## Container ###############################################################
|
|
|
|
pull_image() {
|
|
if [ "$TEZOS_ALPHANET_DO_NOT_PULL" = "yes" ] || [ "$ALPHANET_EMACS" ] ; then
|
|
return ;
|
|
fi
|
|
docker pull "$docker_image"
|
|
}
|
|
|
|
check_container() {
|
|
res=$(docker inspect \
|
|
--format="{{ .State.Running }}" \
|
|
--type=container "$docker_container" 2>/dev/null \
|
|
|| echo false)
|
|
[ "$res" = true ]
|
|
}
|
|
|
|
check_volume() {
|
|
docker volume inspect "$docker_volume" > /dev/null 2>&1
|
|
}
|
|
|
|
clear_volume() {
|
|
if check_volume ; then
|
|
docker volume rm "$docker_volume" > /dev/null
|
|
echo "\033[32mThe blockchain data has been removed from the disk.\033[0m"
|
|
else
|
|
echo "\033[32mNo remaining data to be removed from the disk.\033[0m"
|
|
fi
|
|
}
|
|
|
|
uptodate_container() {
|
|
running_image=$(docker inspect \
|
|
--format="{{ .Image }}" \
|
|
--type=container "$docker_container")
|
|
latest_image=$(docker inspect \
|
|
--format="{{ .Id }}" \
|
|
--type=image "$docker_image")
|
|
[ "$latest_image" = "$running_image" ]
|
|
}
|
|
|
|
assert_container_uptodate() {
|
|
pull_image > /dev/null
|
|
if ! uptodate_container; then
|
|
echo "The current container is not the latest available."
|
|
echo "Please restart."
|
|
exit 1
|
|
fi
|
|
}
|
|
|
|
assert_container() {
|
|
if ! check_container; then
|
|
echo "\033[31mNo container currently running!\033[0m"
|
|
exit 1
|
|
fi
|
|
}
|
|
|
|
start_container() {
|
|
if [ "$#" -ge 2 ] && [ "$1" = "--rpc-port" ] ; then
|
|
docker_export_rpc="-p $2:8732"
|
|
fi
|
|
if check_container; then
|
|
assert_container_uptodate
|
|
else
|
|
if ! check_volume; then
|
|
docker volume create $docker_volume
|
|
fi
|
|
docker rm "$docker_container" || true > /dev/null 2>&1
|
|
echo "Launching the docker container..."
|
|
docker run --rm -dit -p "$port:$port" $docker_export_rpc \
|
|
-v "$docker_volume:/var/run/tezos" \
|
|
--entrypoint /bin/sh \
|
|
--name "$docker_container" \
|
|
"$docker_image" > /dev/null
|
|
may_restore_identity
|
|
may_restore_accounts
|
|
fi
|
|
}
|
|
|
|
stop_container() {
|
|
if ! check_container; then
|
|
echo "\033[31mNo container to kill!\033[0m"
|
|
exit 1
|
|
fi
|
|
save_identity ## Saving again, just in case...
|
|
save_accounts
|
|
printf "Stopping the container... "
|
|
docker stop "$docker_container" >/dev/null
|
|
echo " done"
|
|
}
|
|
|
|
|
|
## Node ####################################################################
|
|
|
|
init_node() {
|
|
docker exec "$docker_container" tezos init \
|
|
"$@" --net-addr "[::]:$port"
|
|
save_identity
|
|
}
|
|
|
|
check_node() {
|
|
check_container && docker exec "$interactive_flags" "$docker_container" tezos check_node
|
|
}
|
|
|
|
assert_node() {
|
|
if ! check_node; then
|
|
echo "\033[31mNode is not running!\033[0m"
|
|
exit 0
|
|
fi
|
|
}
|
|
|
|
status_node() {
|
|
if check_node; then
|
|
echo "\033[32mNode is running\033[0m"
|
|
else
|
|
echo "\033[33mNode is not running\033[0m"
|
|
fi
|
|
}
|
|
|
|
start_node() {
|
|
if check_node; then
|
|
echo "\033[31mCannot run two nodes in the same container!\033[0m"
|
|
exit 1
|
|
fi
|
|
if $docker_1_13; then
|
|
tezos_log_env="-eTEZOS_LOG=${TEZOS_LOG:=* -> info}"
|
|
fi
|
|
docker exec -d "${tezos_log_env}" \
|
|
"$docker_container" tezos run_node
|
|
sleep 1
|
|
docker exec "$docker_container" tezos wait_node
|
|
echo "\033[32mThe node is now running.\033[0m"
|
|
}
|
|
|
|
log_node() {
|
|
docker exec "$interactive_flags" "$docker_container" tezos log_node
|
|
}
|
|
|
|
stop_node() {
|
|
docker exec "$docker_container" tezos stop_node
|
|
}
|
|
|
|
|
|
## Baker ###################################################################
|
|
|
|
check_baker() {
|
|
check_node && docker exec "$interactive_flags" "$docker_container" tezos check_baker
|
|
}
|
|
|
|
assert_baker() {
|
|
if ! check_baker; then
|
|
echo "\033[31mBaker is not running!\033[0m"
|
|
exit 0
|
|
fi
|
|
}
|
|
|
|
status_baker() {
|
|
if check_baker; then
|
|
echo "\033[32mBaker is running\033[0m"
|
|
else
|
|
echo "\033[33mBaker is not running\033[0m"
|
|
fi
|
|
}
|
|
|
|
start_baker() {
|
|
if check_baker; then
|
|
echo "\033[31mCannot run two bakers in the same container!\033[0m"
|
|
exit 1
|
|
fi
|
|
TEZOS_LOG="${TEZOS_LOG:=* -> info}"
|
|
docker exec -d "$docker_container" tezos run_baker
|
|
echo "\033[32mThe baker is now running.\033[0m"
|
|
}
|
|
|
|
log_baker() {
|
|
docker exec "$interactive_flags" "$docker_container" tezos log_baker
|
|
}
|
|
|
|
stop_baker() {
|
|
docker exec "$docker_container" tezos stop_baker
|
|
}
|
|
|
|
## Baker ###################################################################
|
|
|
|
check_endorser() {
|
|
check_node && docker exec "$interactive_flags" "$docker_container" tezos check_endorser
|
|
}
|
|
|
|
assert_endorser() {
|
|
if ! check_baker; then
|
|
echo "\033[31mEndorser is not running!\033[0m"
|
|
exit 0
|
|
fi
|
|
}
|
|
|
|
status_endorser() {
|
|
if check_endorser; then
|
|
echo "\033[32mEndorser is running\033[0m"
|
|
else
|
|
echo "\033[33mEndorser is not running\033[0m"
|
|
fi
|
|
}
|
|
|
|
start_endorser() {
|
|
if check_endorser; then
|
|
echo "\033[31mCannot run two endorsers in the same container!\033[0m"
|
|
exit 1
|
|
fi
|
|
TEZOS_LOG="${TEZOS_LOG:=* -> info}"
|
|
docker exec -d "$docker_container" tezos run_endorser
|
|
echo "\033[32mThe endorser is now running.\033[0m"
|
|
}
|
|
|
|
log_endorser() {
|
|
docker exec "$interactive_flags" "$docker_container" tezos log_endorser
|
|
}
|
|
|
|
stop_endorser() {
|
|
docker exec "$docker_container" tezos stop_endorser
|
|
}
|
|
|
|
## Misc ####################################################################
|
|
|
|
|
|
run_client() {
|
|
declare -a container_args=();
|
|
for arg in "$@"; do
|
|
if [[ "$arg" == 'container:'* ]]; then
|
|
local_path=${arg#container:}
|
|
docker exec "$docker_container" mkdir -p -m 777 /tmp/copied/
|
|
file_name=$(basename "${local_path}")
|
|
docker_path="/tmp/copied/$file_name"
|
|
docker cp "${local_path}" "$docker_container:${docker_path}"
|
|
docker exec "$docker_container" sudo chmod 644 "${docker_path}"
|
|
container_args+=($docker_path);
|
|
else
|
|
container_args+=(${arg});
|
|
fi
|
|
done
|
|
docker exec "$interactive_flags" "$docker_container" tezos client "${container_args[@]}"
|
|
docker exec "$docker_container" rm -rf /tmp/copied # Remove copied files
|
|
save_accounts
|
|
}
|
|
|
|
run_shell() {
|
|
if [ $# -eq 0 ]; then
|
|
docker exec -it "$docker_container" bash
|
|
else
|
|
docker exec -it "$docker_container" bash -c "$@"
|
|
fi
|
|
save_accounts
|
|
}
|
|
|
|
display_head() {
|
|
docker exec "$interactive_flags" "$docker_container" tezos \
|
|
client rpc call /blocks/head with '{}'
|
|
docker exec "$interactive_flags" "$docker_container" tezos \
|
|
client rpc call /blocks/head/proto/context/level with '{}'
|
|
}
|
|
|
|
## Main ####################################################################
|
|
|
|
start() {
|
|
pull_image
|
|
start_container "$@"
|
|
init_node "$@"
|
|
start_node
|
|
start_baker
|
|
start_endorser
|
|
save_accounts
|
|
warn_script_uptodate
|
|
}
|
|
|
|
go_alpha_go() {
|
|
docker exec "$interactive_flags" "$docker_container" tezos client \
|
|
activate \
|
|
protocol ProtoALphaALphaALphaALphaALphaALphaALphaALphaDdp3zK \
|
|
with fitness 1 \
|
|
and key dictator
|
|
}
|
|
|
|
stop() {
|
|
stop_node || true
|
|
stop_container
|
|
}
|
|
|
|
status() {
|
|
pull_image
|
|
if ! uptodate_container; then
|
|
echo "\033[31mThe container is running but not the latest available.\033[0m"
|
|
exit 1
|
|
fi
|
|
echo "\033[32mThe container is running and up to date.\033[0m"
|
|
warn_script_uptodate verbose
|
|
status_node
|
|
status_baker
|
|
status_endorser
|
|
}
|
|
|
|
warn_script_uptodate() {
|
|
if [[ $ALPHANET_EMACS ]]; then
|
|
return
|
|
fi
|
|
docker cp "$docker_container:home/tezos/scripts/alphanet.sh" \
|
|
".alphanet.sh.new"
|
|
if ! diff .alphanet.sh.new "$0" >/dev/null 2>&1 ; then
|
|
echo "\033[33mWarning: the container contains a new version of 'alphanet.sh'.\033[0m"
|
|
echo "\033[33mYou might run '$0 update_script' to synchronize.\033[0m"
|
|
elif [ "$1" = "verbose" ] ; then
|
|
echo "\033[32mThe script is up to date.\033[0m"
|
|
fi
|
|
rm .alphanet.sh.new
|
|
}
|
|
|
|
assert_uptodate() {
|
|
assert_container
|
|
assert_container_uptodate
|
|
warn_script_uptodate
|
|
}
|
|
|
|
update_script() {
|
|
pull_image
|
|
tmp="$(docker run --rm -dit --entrypoint /bin/sleep "$docker_image" 20)"
|
|
docker cp "$tmp:home/tezos/scripts/alphanet.sh" ".alphanet.sh.new"
|
|
docker stop "$tmp" > /dev/null
|
|
if ! diff .alphanet.sh.new "$0" >/dev/null 2>&1 ; then
|
|
mv .alphanet.sh.new "$0"
|
|
echo "\033[32mThe script has been updated.\033[0m"
|
|
else
|
|
rm .alphanet.sh.new
|
|
echo "\033[32mThe script is up to date.\033[0m"
|
|
fi
|
|
}
|
|
|
|
usage() {
|
|
echo "Usage: $0 [GLOBAL_OPTIONS] <command> [OPTIONS]"
|
|
echo " Main commands:"
|
|
echo " $0 start [--rpc-port <int>] [OPTIONS]"
|
|
echo " Launch a full Tezos alphanet node in a docker container"
|
|
echo " automatically generating a new network identity."
|
|
echo " An account 'my_account' for a manager 'my_identity' is also"
|
|
echo " created to be used via the client."
|
|
echo " OPTIONS (others than --rpc-port) are directly passed to the"
|
|
echo " Tezos node, see '$0 shell tezos-node config --help'"
|
|
echo " for more details."
|
|
echo " By default, the RPC port is not exported outside the docker"
|
|
echo " container. WARNING: when exported some RPCs could be harmful"
|
|
echo " (e.g. 'inject_block', 'force_validation', ...), it is"
|
|
echo " advised not to export them publicly."
|
|
echo " $0 <stop|kill>"
|
|
echo " Friendly or brutally stop the node."
|
|
echo " $0 restart"
|
|
echo " Friendly stop the node, fetch the latest docker image and "
|
|
echo " update this script, then start the node again."
|
|
echo " The blockchain data are preserved."
|
|
echo " $0 clear"
|
|
echo " Remove all the blockchain data from the disk (except"
|
|
echo " for secret keys and other configuration backup)."
|
|
echo " $0 status"
|
|
echo " Check that the running node is running and up to date."
|
|
echo " Upgrade is automatically done by the start command."
|
|
echo " $0 head"
|
|
echo " Display info about the current head of the blockchain."
|
|
echo " $0 client <COMMAND>"
|
|
echo " Pass a command to the tezos client."
|
|
echo " $0 update_script"
|
|
echo " Replace 'alphanet.sh' with the one found in the docker image."
|
|
echo " Advanced commands:"
|
|
echo " $0 container <start|stop|status>"
|
|
echo " $0 node <start|stop|status|log>"
|
|
echo " $0 baker <start|stop|status|log>"
|
|
echo " $0 endorser <start|stop|status|log>"
|
|
echo " $0 shell"
|
|
echo "Node configuration backup directory: $data_dir"
|
|
echo "Global options are currently limited to:"
|
|
echo " --port <int>"
|
|
echo " change public the port Tezos node"
|
|
echo "Container prefix:"
|
|
echo " container:<FILE>"
|
|
echo " can be used anywhere 'file:<FILE>' is permitted in client commands."
|
|
echo " It will cause the referenced file to be copied into the docker conainer."
|
|
echo " Files will be renamed, which may make errors difficult to read"
|
|
}
|
|
|
|
## Dispatch ################################################################
|
|
|
|
if [ "$#" -ge 2 ] && [ "$1" = "--port" ] ; then
|
|
port="$2"
|
|
suffix=".$port"
|
|
shift 2
|
|
fi
|
|
|
|
command="$1"
|
|
if [ "$#" -eq 0 ] ; then usage ; exit 1; else shift ; fi
|
|
|
|
|
|
case "$command" in
|
|
|
|
## Main
|
|
|
|
start)
|
|
start "$@"
|
|
;;
|
|
restart)
|
|
if check_container; then
|
|
stop_container
|
|
fi
|
|
update_script
|
|
export TEZOS_ALPHANET_DO_NOT_PULL=yes
|
|
exec "$0" start "$@"
|
|
;;
|
|
clear)
|
|
if check_container; then
|
|
echo "\033[31mCannot clear data while the container is running.\033[0m"
|
|
exit 1
|
|
fi
|
|
clear_volume
|
|
;;
|
|
status)
|
|
assert_container
|
|
status
|
|
;;
|
|
stop)
|
|
assert_container
|
|
stop
|
|
;;
|
|
kill)
|
|
stop_container
|
|
;;
|
|
|
|
## Container
|
|
|
|
container)
|
|
subcommand="$1"
|
|
if [ "$#" -eq 0 ] ; then usage ; exit 1 ; else shift ; fi
|
|
case "$subcommand" in
|
|
start)
|
|
start_container "$@"
|
|
warn_script_uptodate
|
|
;;
|
|
status)
|
|
if check_container; then
|
|
echo "\033[32mContainer is running\033[0m"
|
|
else
|
|
echo "\033[33mContainer is not running\033[0m"
|
|
fi
|
|
;;
|
|
stop)
|
|
stop_container
|
|
;;
|
|
*)
|
|
usage
|
|
exit 1
|
|
esac ;;
|
|
|
|
## Node
|
|
|
|
node)
|
|
subcommand="$1"
|
|
if [ "$#" -eq 0 ] ; then usage ; exit 1; else shift ; fi
|
|
case "$subcommand" in
|
|
start)
|
|
assert_uptodate
|
|
start_node
|
|
;;
|
|
status)
|
|
assert_uptodate
|
|
status_node
|
|
;;
|
|
log)
|
|
assert_uptodate
|
|
log_node
|
|
;;
|
|
stop)
|
|
assert_uptodate
|
|
stop_node
|
|
;;
|
|
*)
|
|
usage
|
|
exit 1
|
|
esac ;;
|
|
## Baker
|
|
|
|
baker)
|
|
subcommand="$1"
|
|
if [ "$#" -eq 0 ] ; then usage ; exit 1; else shift ; fi
|
|
case "$subcommand" in
|
|
status)
|
|
assert_uptodate
|
|
status_baker
|
|
;;
|
|
start)
|
|
assert_uptodate
|
|
assert_node
|
|
start_baker
|
|
;;
|
|
log)
|
|
assert_uptodate
|
|
log_baker
|
|
;;
|
|
stop)
|
|
assert_uptodate
|
|
stop_baker
|
|
;;
|
|
*)
|
|
usage
|
|
exit 1
|
|
esac ;;
|
|
|
|
## Endorser
|
|
|
|
endorser)
|
|
subcommand="$1"
|
|
if [ "$#" -eq 0 ] ; then usage ; exit 1; else shift ; fi
|
|
case "$subcommand" in
|
|
status)
|
|
assert_uptodate
|
|
status_endorser
|
|
;;
|
|
start)
|
|
assert_uptodate
|
|
assert_node
|
|
start_endorser
|
|
;;
|
|
log)
|
|
assert_uptodate
|
|
log_endorser
|
|
;;
|
|
stop)
|
|
assert_uptodate
|
|
stop_endorser
|
|
;;
|
|
*)
|
|
usage
|
|
exit 1
|
|
esac ;;
|
|
|
|
## Misc.
|
|
|
|
head)
|
|
assert_uptodate
|
|
assert_node
|
|
display_head
|
|
;;
|
|
go_alpha_go)
|
|
assert_uptodate
|
|
assert_node
|
|
go_alpha_go
|
|
;;
|
|
shell)
|
|
assert_uptodate
|
|
run_shell "$@"
|
|
;;
|
|
client)
|
|
assert_uptodate
|
|
assert_node
|
|
run_client "$@"
|
|
;;
|
|
check_script)
|
|
assert_uptodate
|
|
;;
|
|
update_script)
|
|
update_script
|
|
;;
|
|
*)
|
|
usage
|
|
exit 1
|
|
;;
|
|
esac
|