Skip to content

Instantly share code, notes, and snippets.

@d4hines

d4hines/granadanet.sh

Created October 20, 2021 12:42
Show Gist options
  • Save d4hines/56f63936862b4f35b7937db7eb6976c0 to your computer and use it in GitHub Desktop.
Save d4hines/56f63936862b4f35b7937db7eb6976c0 to your computer and use it in GitHub Desktop.
Download ZIP
Patched version of tezos-docker-manager.sh and script for setting up a node
Raw
granadanet.sh
#! /usr/bin/env bash
set -e
if ! which docker > /dev/null 2>&1 ; then
echo "Docker does not seem to be installed."
exit 1
fi
if ! which docker-compose > /dev/null 2>&1 ; then
echo "Docker-compose 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
current_dir="$(pwd -P)"
src_dir="$(cd "$(dirname "$0")" && echo "$current_dir/")"
cd "$src_dir"
update_compose_file() {
update_active_protocol_version
if [ "$#" -ge 4 ] && [ "$1" = "--rpc-port" ] ; then
export_rpc="
- \"$2:8732\""
shift 2
fi
cat > "$docker_compose_yml" <<EOF
version: "2"
volumes:
node_data:
client_data:
services:
node:
image: $docker_image
hostname: node
command: tezos-node --net-addr :$port $@
ports:
- "$port:$port"$export_rpc
expose:
- "8732"
volumes:
- node_data:/var/run/tezos/node
- client_data:/var/run/tezos/client
restart: on-failure
upgrader:
image: $docker_image
hostname: node
command: tezos-upgrade-storage
volumes:
- node_data:/var/run/tezos/node
- client_data:/var/run/tezos/client
restart: on-failure
depends_on:
- "node"
EOF
if [ -n "$local_snapshot_path" ]; then
cat >> "$docker_compose_yml" <<EOF
importer:
image: $docker_image
hostname: node
command: tezos-snapshot-import $@
volumes:
- node_data:/var/run/tezos/node
- client_data:/var/run/tezos/client
- $local_snapshot_path:/snapshot
restart: on-failure
depends_on:
- "node"
EOF
fi
for proto in $(cat "$active_protocol_versions") ; do
cat >> "$docker_compose_yml" <<EOF
baker-$proto:
image: $docker_image
hostname: baker-$proto
environment:
- PROTOCOL=$proto
command: tezos-baker --max-priority 128
links:
- node
volumes:
- node_data:/var/run/tezos/node:ro
- client_data:/var/run/tezos/client
restart: on-failure
endorser-$proto:
image: $docker_image
hostname: endorser-$proto
environment:
- PROTOCOL=$proto
command: tezos-endorser
links:
- node
volumes:
- client_data:/var/run/tezos/client
restart: on-failure
accuser-$proto:
image: $docker_image
hostname: accuser-$proto
environment:
- PROTOCOL=$proto
command: tezos-accuser
links:
- node
volumes:
- client_data:/var/run/tezos/client
restart: on-failure
baker-$proto-test:
image: $docker_image
hostname: baker-$proto-test
environment:
- PROTOCOL=$proto
command: tezos-baker-test --max-priority 128
links:
- node
volumes:
- node_data:/var/run/tezos/node:ro
- client_data:/var/run/tezos/client
restart: on-failure
endorser-$proto-test:
image: $docker_image
hostname: endorser-$proto-test
environment:
- PROTOCOL=$proto
command: tezos-endorser-test
links:
- node
volumes:
- client_data:/var/run/tezos/client
restart: on-failure
accuser-$proto-test:
image: $docker_image
hostname: accuser-$proto-test
environment:
- PROTOCOL=$proto
command: tezos-accuser-test
links:
- node
volumes:
- client_data:/var/run/tezos/client
restart: on-failure
EOF
done
}
call_docker_compose() {
docker-compose -f "$docker_compose_yml" -p "$docker_compose_name" "$@"
}
exec_docker() {
if [ -t 0 ] && [ -t 1 ] && [ -t 2 ] && [ -z "$ALPHANET_EMACS" ]; then
local interactive_flags="-it"
else
local interactive_flags="-t"
fi
local node_container="$(container_name "$docker_node_container")"
declare -a container_args=();
tmpdir="/tmp"
for arg in "$@"; do
if [[ "$arg" == 'container:'* ]]; then
local_path="${arg#container:}"
if [[ "$local_path" != '/'* ]]; then
local_path="$current_dir/$local_path"
fi
file_name=$(basename "${local_path}")
docker_path="$tmpdir/$file_name"
docker cp "${local_path}" "$node_container:${docker_path}"
docker exec "$interactive_flags" "$node_container" sudo chown tezos "${docker_path}"
container_args+=("file:$docker_path");
else
container_args+=("${arg}");
fi
done
docker exec "$interactive_flags" -e 'TEZOS_CLIENT_UNSAFE_DISABLE_DISCLAIMER' "$node_container" "${container_args[@]}"
}
## Container ###############################################################
update_active_protocol_version() {
docker run --entrypoint /bin/cat "$docker_image" \
/usr/local/share/tezos/active_protocol_versions > "$active_protocol_versions"
}
may_update_active_protocol_version() {
if [ ! -f "$active_protocol_versions" ] ; then
update_active_protocol_version
fi
}
pull_image() {
if [ "$TEZOS_ALPHANET_DO_NOT_PULL" = "yes" ] \
|| [ "$ALPHANET_EMACS" ] \
|| [ "$docker_image" = "$(echo $docker_image | tr -d '/')" ] ; then
return ;
fi
docker pull "$docker_image"
update_active_protocol_version
date "+%s" > "$docker_pull_timestamp"
}
may_pull_image() {
if [ ! -f "$docker_pull_timestamp" ] \
|| [ 3600 -le $(($(date "+%s") - $(cat $docker_pull_timestamp))) ]; then
pull_image
fi
}
uptodate_container() {
running_image=$(docker inspect \
--format="{{ .Image }}" \
--type=container "$(container_name "$1")")
latest_image=$(docker inspect \
--format="{{ .Id }}" \
--type=image "$docker_image")
[ "$latest_image" = "$running_image" ]
}
uptodate_containers() {
container=$1
if [ ! -z "$container" ]; then
shift 1
uptodate_container $container && uptodate_containers $@
fi
}
assert_container() {
call_docker_compose up --no-start
}
container_name() {
local name="$(docker ps --filter "name=$1" --format "{{.Names}}")"
if [ -n "$name" ]; then echo "$name"; else echo "$1"; fi
}
## Node ####################################################################
check_node_volume() {
docker volume inspect "$docker_node_volume" > /dev/null 2>&1
}
clear_node_volume() {
if check_node; then
echo -e "\033[31mCannot clear data while the node is running.\033[0m"
exit 1
fi
if check_node_volume ; then
docker volume rm "$docker_node_volume" > /dev/null
echo -e "\033[32mThe chain data has been removed from the disk.\033[0m"
else
echo -e "\033[32mNo remaining data to be removed from the disk.\033[0m"
fi
}
check_node() {
res=$(docker inspect \
--format="{{ .State.Running }}" \
--type=container "$(container_name "$docker_node_container")" 2>/dev/null || echo false)
[ "$res" = "true" ]
}
assert_node() {
if ! check_node; then
echo -e "\033[31mNode is not running!\033[0m"
exit 0
fi
}
warn_node_uptodate() {
if ! uptodate_container "$docker_node_container"; then
echo -e "\033[33mThe current node is not the latest available.\033[0m"
fi
}
assert_node_uptodate() {
may_pull_image
assert_node
if ! uptodate_container "$docker_node_container"; then
echo -e "\033[33mThe current node is not the latest available.\033[0m"
exit 1
fi
}
status_node() {
may_pull_image
if check_node; then
echo -e "\033[32mNode is running\033[0m"
warn_node_uptodate
else
echo -e "\033[33mNode is not running\033[0m"
fi
}
start_node() {
pull_image
if check_node; then
echo -e "\033[31mNode is already running\033[0m"
exit 1
fi
update_compose_file "$@"
call_docker_compose up --no-start
call_docker_compose start node
echo -e "\033[32mThe node is now running.\033[0m"
}
log_node() {
may_pull_image
assert_node_uptodate
call_docker_compose logs -f node
}
stop_node() {
if ! check_node; then
echo -e "\033[31mNo node to kill!\033[0m"
exit 1
fi
echo -e "\033[32mStopping the node...\033[0m"
call_docker_compose stop node
}
## Baker ###################################################################
check_baker() {
update_active_protocol_version
bakers="$(sed "s/^\(.*\)$/baker-\1 baker-\1-test/g" "$active_protocol_versions")"
docker_baker_containers="$(sed "s/^\(.*\)$/${docker_compose_name}-baker-\1-1 ${docker_compose_name}-baker-\1-test-1/g" "$active_protocol_versions")"
for docker_baker_container in $docker_baker_containers; do
res=$(docker inspect \
--format="{{ .State.Running }}" \
--type=container "$(container_name "$docker_baker_container")" 2>/dev/null || echo false)
if ! [ "$res" = "true" ]; then return 1; fi
done
}
assert_baker() {
if ! check_baker; then
echo -e "\033[31mBaker is not running!\033[0m"
exit 0
fi
}
assert_baker_uptodate() {
assert_baker
if ! uptodate_containers $docker_baker_containers; then
echo -e "\033[33mThe current baker is not the latest available.\033[0m"
exit 1
fi
}
status_baker() {
if check_baker; then
echo -e "\033[32mBaker is running\033[0m"
may_pull_image
if ! uptodate_containers $docker_baker_containers; then
echo -e "\033[33mThe current baker is not the latest available.\033[0m"
fi
else
echo -e "\033[33mBaker is not running\033[0m"
fi
}
start_baker() {
if check_baker; then
echo -e "\033[31mBaker is already running\033[0m"
exit 1
fi
pull_image
assert_node_uptodate
call_docker_compose start $bakers
echo -e "\033[32mThe baker is now running.\033[0m"
}
log_baker() {
may_pull_image
assert_baker_uptodate
call_docker_compose logs -f $bakers
}
stop_baker() {
if ! check_baker; then
echo -e "\033[31mNo baker to kill!\033[0m"
exit 1
fi
echo -e "\033[32mStopping the baker...\033[0m"
call_docker_compose stop $bakers
}
## Endorser ###################################################################
check_endorser() {
update_active_protocol_version
endorsers="$(sed "s/^\(.*\)$/endorser-\1 endorser-\1-test/g" "$active_protocol_versions")"
docker_endorser_containers="$(sed "s/^\(.*\)$/${docker_compose_name}-endorser-\1-1 ${docker_compose_name}-endorser-\1-test-1/g" "$active_protocol_versions")"
for docker_endorser_container in $docker_endorser_containers; do
res=$(docker inspect \
--format="{{ .State.Running }}" \
--type=container "$(container_name "$docker_endorser_container")" 2>/dev/null || echo false)
if ! [ "$res" = "true" ]; then return 1; fi
done
}
assert_endorser() {
if ! check_endorser; then
echo -e "\033[31mEndorser is not running!\033[0m"
exit 0
fi
}
assert_endorser_uptodate() {
assert_endorser
if ! uptodate_containers $docker_endorser_containers; then
echo -e "\033[33mThe current endorser is not the latest available.\033[0m"
exit 1
fi
}
status_endorser() {
if check_endorser; then
echo -e "\033[32mEndorser is running\033[0m"
may_pull_image
if ! uptodate_containers $docker_endorser_containers; then
echo -e "\033[33mThe current endorser is not the latest available.\033[0m"
fi
else
echo -e "\033[33mEndorser is not running\033[0m"
fi
}
start_endorser() {
if check_endorser; then
echo -e "\033[31mEndorser is already running\033[0m"
exit 1
fi
pull_image
assert_node_uptodate
call_docker_compose start $endorsers
echo -e "\033[32mThe endorser is now running.\033[0m"
}
log_endorser() {
may_pull_image
assert_endorser_uptodate
call_docker_compose logs -f $endorsers
}
stop_endorser() {
if ! check_endorser; then
echo -e "\033[31mNo endorser to kill!\033[0m"
exit 1
fi
echo -e "\033[32mStopping the endorser...\033[0m"
call_docker_compose stop $endorsers
}
## Accuser ###################################################################
check_accuser() {
update_active_protocol_version
accusers="$(sed "s/^\(.*\)$/accuser-\1 accuser-\1-test/g" "$active_protocol_versions")"
docker_accuser_containers="$(sed "s/^\(.*\)$/${docker_compose_name}_accuser-\1_1 ${docker_compose_name}_accuser-\1-test_1/g" "$active_protocol_versions")"
for docker_accuser_container in $docker_accuser_containers; do
res=$(docker inspect \
--format="{{ .State.Running }}" \
--type=container "$(container_name "$docker_accuser_container")" 2>/dev/null || echo false)
if ! [ "$res" = "true" ]; then return 1; fi
done
}
assert_accuser() {
if ! check_accuser; then
echo -e "\033[31mAccuser is not running!\033[0m"
exit 0
fi
}
assert_accuser_uptodate() {
assert_accuser
if ! uptodate_containers $docker_accuser_containers; then
echo -e "\033[33mThe current accuser is not the latest available.\033[0m"
exit 1
fi
}
status_accuser() {
if check_accuser; then
echo -e "\033[32mAccuser is running\033[0m"
may_pull_image
if ! uptodate_containers $docker_accuser_containers; then
echo -e "\033[33mThe current accuser is not the latest available.\033[0m"
fi
else
echo -e "\033[33mAccuser is not running\033[0m"
fi
}
start_accuser() {
if check_accuser; then
echo -e "\033[31mAccuser is already running\033[0m"
exit 1
fi
pull_image
assert_node_uptodate
call_docker_compose start $accusers
echo -e "\033[32mThe accuser is now running.\033[0m"
}
log_accuser() {
may_pull_image
assert_accuser_uptodate
call_docker_compose logs -f $accusers
}
stop_accuser() {
if ! check_accuser; then
echo -e "\033[31mNo accuser to kill!\033[0m"
exit 1
fi
echo -e "\033[32mStopping the accuser...\033[0m"
call_docker_compose stop $accusers
}
## Misc ####################################################################
run_client() {
assert_node_uptodate
exec_docker "tezos-client" "$@"
}
run_admin_client() {
assert_node_uptodate
exec_docker "tezos-admin-client" "$@"
}
run_shell() {
assert_node_uptodate
if [ $# -eq 0 ]; then
exec_docker /bin/sh
else
exec_docker /bin/sh -c "$@"
fi
}
display_head() {
assert_node_uptodate
exec_docker tezos-client rpc get /chains/main/blocks/head/header
}
## Main ####################################################################
start() {
pull_image
update_compose_file "$@"
call_docker_compose up -d --remove-orphans
warn_script_uptodate
}
stop() {
call_docker_compose down
}
kill_() {
call_docker_compose kill
stop
}
status() {
status_node
status_baker
status_endorser
warn_script_uptodate verbose
}
snapshot_import() {
pull_image
local_snapshot_path="$1"
shift
update_compose_file "$@"
call_docker_compose up importer
warn_script_uptodate
}
warn_script_uptodate() {
if [[ $ALPHANET_EMACS ]]; then
return
fi
docker run --entrypoint /bin/cat "$docker_image" \
"/usr/local/share/tezos/tezos-docker-manager.sh" > ".tezos-docker-manager.sh.new"
if ! diff .tezos-docker-manager.sh.new "$0" >/dev/null 2>&1 ; then
echo -e "\033[33mWarning: the container contains a new version of 'tezos-docker-manager.sh'.\033[0m"
echo -e "\033[33mYou might run '$0 update_script' to synchronize.\033[0m"
elif [ "$1" = "verbose" ] ; then
echo -e "\033[32mThe script is up to date.\033[0m"
fi
rm .tezos-docker-manager.sh.new
}
update_script() {
docker run --entrypoint /bin/cat "$docker_image" \
"/usr/local/share/tezos/tezos-docker-manager.sh" > ".tezos-docker-manager.sh.new"
if ! diff .tezos-docker-manager.sh.new "$0" >/dev/null 2>&1 ; then
mv .tezos-docker-manager.sh.new "$0"
echo -e "\033[32mThe script has been updated.\033[0m"
else
rm .tezos-docker-manager.sh.new
echo -e "\033[32mThe script is up to date.\033[0m"
fi
}
upgrade_node_storage() {
pull_image
local_snapshot_path="$1"
update_compose_file
call_docker_compose up upgrader
warn_script_uptodate
}
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 " 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 'tezos-docker-manager.sh' with the one found in the docker image."
echo " Advanced commands:"
echo " $0 node <start|stop|status|log>"
echo " $0 node upgrade"
echo " $0 snapshot import <snapshot_file>"
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 container."
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 $(basename "$0") in
granadanet.sh)
docker_base_dir="$HOME/.tezos-granadanet"
docker_image=tezos/tezos:master
docker_compose_base_name=granadanet
default_port=9732
network=granadanet
;;
hangzhounet.sh)
docker_base_dir="$HOME/.tezos-hangzhounet"
docker_image=tezos/tezos:master
docker_compose_base_name=hangzhounet
default_port=9732
network=hangzhounet
;;
*)
docker_base_dir="$HOME/.tezos-mainnet"
docker_image=tezos/tezos:master
docker_compose_base_name="mainnet"
default_port=9732
network=mainnet
;;
esac
if [ -n "$suffix" ] ; then
mkdir -p "$docker_base_dir"
echo "$port" > "$docker_base_dir/default_port"
elif [ -f "$docker_base_dir/default_port" ]; then
port=$(cat "$docker_base_dir/default_port")
suffix="$port"
else
port=$default_port
fi
docker_dir="$docker_base_dir$suffix"
docker_compose_yml="$docker_dir/docker-compose.yml"
docker_pull_timestamp="$docker_dir/docker_pull.timestamp"
active_protocol_versions="$docker_dir/active_protocol_versions"
docker_compose_name="$docker_compose_base_name$suffix"
docker_node_container=${docker_compose_name}-node-1
docker_node_volume=${docker_compose_name}_node_data
docker_client_volume=${docker_compose_name}_client_data
mkdir -p "$docker_dir"
case "$command" in
## Main
start)
start "$@" --network $network
;;
restart)
stop
update_script
export TEZOS_ALPHANET_DO_NOT_PULL=yes
exec "$0" start "$@"
;;
clear)
clear_node_volume
;;
status)
status
;;
stop)
stop
;;
kill)
kill_
;;
## Node
node)
subcommand="$1"
if [ "$#" -eq 0 ] ; then usage ; exit 1; else shift ; fi
case "$subcommand" in
start)
start_node "$@" --network $network
;;
status)
status_node
;;
log)
log_node
;;
upgrade)
upgrade_node_storage
;;
stop)
stop_node
;;
*)
usage
exit 1
esac ;;
## Snapshot import
snapshot)
subcommand="$1"
if [ "$#" -ne 2 ] ; then usage ; exit 1; else shift ; fi
snapshot_file="$1"
case "$subcommand" in
import)
snapshot_import "$snapshot_file" --network $network
;;
*)
usage
exit 1
esac ;;
## Baker
baker)
subcommand="$1"
if [ "$#" -eq 0 ] ; then usage ; exit 1; else shift ; fi
case "$subcommand" in
status)
status_baker
;;
start)
start_baker
;;
log)
log_baker
;;
stop)
stop_baker
;;
*)
usage
exit 1
esac ;;
## Endorser
endorser)
subcommand="$1"
if [ "$#" -eq 0 ] ; then usage ; exit 1; else shift ; fi
case "$subcommand" in
status)
status_endorser
;;
start)
start_endorser
;;
log)
log_endorser
;;
stop)
stop_endorser
;;
*)
usage
exit 1
esac ;;
## Accuser
accuser)
subcommand="$1"
if [ "$#" -eq 0 ] ; then usage ; exit 1; else shift ; fi
case "$subcommand" in
status)
status_accuser
;;
start)
start_accuser
;;
log)
log_accuser
;;
stop)
stop_accuser
;;
*)
usage
exit 1
esac ;;
## Misc.
head)
display_head
;;
shell)
run_shell "$@"
;;
client)
run_client "$@"
;;
admin-client)
run_admin_client "$@"
;;
check_script)
warn_script_uptodate verbose
;;
update_script)
update_script
;;
*)
usage
exit 1
;;
esac
Raw
node.sh
network=granadanet
command="./$network.sh"
# Stop any previously running containers
$command stop
# Delete any leftover data
docker rm -vf $(docker ps -aq) && docker volume prune -f
rm -rf ~/.tezos-$network
rm -rf tezos-snapshot.rolling
# Get the snapshot
wget "https://${network}.xtz-shots.io/rolling" -O tezos-snapshot.rolling
echo "============= Snapshot Import =============="
$command snapshot import "$PWD/tezos-snapshot.rolling"
echo "============= Starting Node =============="
$command start --rpc-addr localhost --allow-all-rpc localhost:8732 --rpc-addr node --allow-all-rpc node:8732
echo "============= Generating Keys =============="
sleep 20 # For some reason waiting seems to be necesssary. Not sure how long though.
$command client gen keys "myFirstKey"
echo "============== Copying data ================"
docker cp faucet.json "${network}-node-1:/home/tezos/"
docker exec "${network}-node-1" sudo chown tezos:nogroup /home/tezos/faucet.json
echo "============== Activating Wallet ==========="
$command client activate account faucetWallet with "container:faucet.json"
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment