cardano-up 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 630dda3bb909a92e0fa63562f5aff0f90afa817c8f5170f7567bcf059a962f2e
+  data.tar.gz: c37378163253bb7945188c3a8794d6e01d638a0a4a053e887347b9aef5046a48
+SHA512:
+  metadata.gz: 7e84594cee7e1fe4716f78c58f1deb39676f0d3ff3d7a721af055d13b6e627e96085dbceabda516665036f0137393121a29176df07bef07c9120872d680013b5
+  data.tar.gz: 602b2379f4fd6a2dad86f2f4234ca4c3e7492cb194f73a95e60675f40d502e9dcaef2e3dc37532ae5ccd8b19a48eeddc96d1bd93f1197cceeda64451dd49f10d

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2022 Piotr Stachyra
+
+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.

data/README.md

@@ -0,0 +1,75 @@
+# Cardano Up!
+<a href="https://badge.fury.io/rb/cardano-up">
+  <img src="https://badge.fury.io/rb/cardano-up.svg" alt="Gem Version">
+</a>
+<a href="https://github.com/piotr-iohk/cardano-up/releases">
+  <img src="https://img.shields.io/github/release/piotr-iohk/cardano-up.svg" />
+</a>
+<a href="https://github.com/piotr-iohk/cardano-up/actions?query=workflow%3ATests">
+  <img src="https://github.com/piotr-iohk/cardano-up/workflows/Tests/badge.svg" />
+</a>
+<a href="https://github.com/piotr-iohk/cardano-up/actions?query=workflow%3ADocs">
+  <img src="https://github.com/piotr-iohk/cardano-up/workflows/Docs/badge.svg" />
+</a>
+<a href="https://github.com/piotr-iohk/cardano-up/actions?query=workflow%3ARubocop">
+  <img src="https://github.com/piotr-iohk/cardano-up/workflows/Rubocop/badge.svg" />
+</a>
+
+## Overview
+
+This Ruby gem provides easy way for:
+ - getting `cardano-node`, `cardano-cli`, `cardano-wallet`, `cardano-addresses` and `bech32` tools onto your system (Linux, MacOS or Windows).
+ - getting configuration for any Cardano public environment.
+ - starting, managing and monitoring cardano-node and cardano-wallet services.
+
+<img src="cardano-up.gif" />
+
+## Installation
+
+    $ gem install cardano-up
+
+## Usage
+
+It only takes a single command to start node and wallet on your system. Say, on `mainnet`?
+
+    $ cardano-up mainnet node-wallet up
+
+That's it! 🎉
+
+If any configs are missing cardano-up will download them. If any binaries are missing cardano-up will get ones from latest release.
+
+Call `$ cardano-up --help` to explore more options.
+
+## Documentation
+
+| Link | Description  |
+|--|--|
+|  [Ruby API (edge)](https://piotr-iohk.github.io/cardano-up/master/) | cardano-up API doc |
+
+## How it works
+
+**Configurations** for the networks are downloaded from [Cardano Book](https://book.world.dev.cardano.org/environments.html).
+
+**Binaries** come from [cardano-wallet](https://github.com/input-output-hk/cardano-wallet) which actually provides `cardano-node`, `cardano-cli`, `cardano-wallet`, `cardano-addresses` and `bech32` tools in each of its release bundles. This ensures that all components are compatible and work smoothly together. You can get any public release of the cardano-wallet bundle as well as `master` version and even any of the PRs that are currently being worked on.
+
+**Starting** `cardano-node` and `cardano-wallet`,  cardano-up attempts to launch separate [`screen`](https://www.gnu.org/software/screen/) sessions for wallet and node respectively. If screen is not present on your system you can install it using package manager, e.g.:
+
+MacOS:
+
+    $ brew install screen
+
+Linux:
+
+    $ sudo apt-get install screen
+
+In case of Windows it will attempt to install cardano-node and cardano-wallet as Windows services using [`nssm`](https://nssm.cc/) tool. Nssm can be installed via choco package manager:
+
+    $ choco install nssm
+
+> :warning: nssm requires administrator permissions to register Windows services, therefore you need to start your cmd as an administrator.
+
+By default cardano-up keeps all files at `$HOME/.cardano-up/` however this can be configured by editing `$HOME/.cardano-up/.cardano-up.json` directly or via `config` sub-command. One can check the contents of this internal config file by calling `$ cardano-up config`.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/bin/cardano-up

@@ -0,0 +1,236 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'cardano-up'
+require 'docopt'
+
+doc = <<~DOCOPT
+  Cardano Up!
+  Lightweight manager for Cardano binaries and configs.
+
+  Usage:
+    #{File.basename(__FILE__)} install [<release>]
+    #{File.basename(__FILE__)} get-configs <env>
+    #{File.basename(__FILE__)} <env> (node|wallet|node-wallet) up [--port <port>]
+    #{File.basename(__FILE__)} <env> (node|wallet|node-wallet) down
+    #{File.basename(__FILE__)} <env> (node|wallet) tail
+    #{File.basename(__FILE__)} config [--set-default] [--bindir <path>] [--configdir <path>] [--logdir <path>] [--statedir <path>]
+    #{File.basename(__FILE__)} -v | --version
+    #{File.basename(__FILE__)} -h | --help
+
+  Options:
+    install                 Install cardano-node, cardano-cli, cardano-wallet, cardano-addresses and bech32.
+    <release>               latest | release tag | master | pr num [default: latest]
+    get-configs             Get configs for particular Cardano environment.
+    <env>                   mainnet | preview | preprod etc.
+    up                      Start particular service. If any configs are missing #{File.basename(__FILE__)}
+                            will download them. If any binaries are missing #{File.basename(__FILE__)} will get
+                            ones from latest release.
+    down                    Stop particular service.
+    tail                    Follow logs for particular service.
+    --port <port>           Specify wallet port. [default: 8090]
+
+    config                  Internal config for #{File.basename(__FILE__)}
+    --set-default           Overwrite config with default values.
+    --bindir <path>         Set bin dir.
+    --configdir <path>      Set config dir.
+    --logdir <path>         Set log dir.
+    --statedir <path>       Set state dir.
+
+    -v --version            Check #{File.basename(__FILE__)} version and versions of
+                            installed binaries if available.
+    -h --help               This help.
+DOCOPT
+
+def pretty_json(c)
+  puts JSON.pretty_generate(c)
+end
+
+def ok
+  warn 'Ok.'
+end
+
+begin
+  CardanoUp.configure_default unless CardanoUp.configured?
+  o = Docopt.docopt(doc)
+
+  # VERSION
+  if o['--version'] == true
+    warn "#{File.basename(__FILE__)}: #{CardanoUp::VERSION}"
+    $stderr.puts
+    begin
+      pretty_json CardanoUp::Install.return_versions
+    rescue StandardError => e
+      warn 'Nothing installed? To fix run:'
+      warn " $ #{File.basename(__FILE__)} install"
+      warn e
+    end
+    exit 1
+  end
+
+  # CONFIG
+  if o['config'] == true
+    c = CardanoUp.config
+    if o['--set-default'] == true
+      c = CardanoUp.configure_default
+      warn 'Configs set to default!'
+    end
+    if o['--bindir']
+      bindir = o['--bindir']
+      c = CardanoUp.configure(bindir, nil, nil, nil)
+      warn 'Installdir updated!'
+    end
+    if o['--statedir']
+      statedir = o['--statedir']
+      c = CardanoUp.configure(nil, statedir, nil, nil)
+      warn 'Statedir updated!'
+    end
+    if o['--logdir']
+      logdir = o['--logdir']
+      c = CardanoUp.configure(nil, nil, logdir, nil)
+      warn 'Logdir updated!'
+    end
+    if o['--configdir']
+      configdir = o['--configdir']
+      c = CardanoUp.configure(nil, nil, nil, configdir)
+      warn 'Configdir updated!'
+    end
+
+    warn "Your config file is #{CardanoUp.adrestia_bundler_config}:"
+    $stderr.puts
+    pretty_json(c)
+    exit
+  end
+
+  # INSTALL
+  if o['install'] == true
+    release = o['<release>']
+    begin
+      $stderr.print "Installing '#{release}'... "
+      versions = CardanoUp::Install.install_bins(release)
+      ok
+    rescue CardanoUp::VersionNotSupportedError => e
+      warn(e.message)
+      exit 1
+    end
+    warn "Install dir: #{CardanoUp.config['bin_dir']}"
+    $stderr.puts
+    pretty_json(versions)
+    exit
+  end
+
+  # INSTALL CONFIGS
+  if o['get-configs'] == true
+    env = o['<env>']
+    begin
+      configs = CardanoUp::Install.install_configs(env)
+    rescue CardanoUp::EnvNotSupportedError => e
+      warn(e.message)
+      exit 1
+    end
+    warn "Downloaded configs for '#{env}' environment."
+    warn "Config dir: #{File.join(CardanoUp.config['config_dir'], env)}"
+    $stderr.puts
+    pretty_json(configs)
+    exit
+  end
+
+  # UP
+  if o['up'] == true
+    env = o['<env>']
+    port = o['--port']
+
+    begin
+      $stderr.print 'Configs: '
+      unless CardanoUp::Install.configs_exist?(env)
+        $stderr.print "installing configs for #{env}... "
+        CardanoUp::Install.install_configs(env)
+      end
+      ok
+
+      $stderr.print 'Binaries: '
+      begin
+        CardanoUp::Install.return_versions
+        ok
+      rescue StandardError
+        $stderr.print 'installing latest release binaries... '
+        CardanoUp::Install.install_bins('latest')
+        ok
+      end
+
+      $stderr.puts
+      warn 'Starting...'
+      $stderr.puts
+      c = CardanoUp::Start.prepare_configuration({ env: env, wallet_port: port })
+    rescue CardanoUp::EnvNotSupportedError => e
+      warn(e.message)
+      exit 1
+    end
+    begin
+      if o['node']
+        pretty_json CardanoUp::Start.start_node(c)
+        $stderr.puts
+        warn "Congratulations! You've just started cardano-node!"
+      elsif o['wallet']
+        pretty_json CardanoUp::Start.start_wallet(c)
+        $stderr.puts
+        warn "Congratulations! You've just started cardano-wallet!"
+      elsif o['node-wallet']
+        pretty_json CardanoUp::Start.start_node_and_wallet(c)
+        $stderr.puts
+        warn "Congratulations! You've just started cardano-node and cardano-wallet!"
+      end
+    rescue StandardError => e
+      warn 'Either you miss configs or binaries... To fix that try running:'
+      warn " $ #{File.basename(__FILE__)} get-configs #{env}"
+      warn " $ #{File.basename(__FILE__)} install"
+      warn e
+      exit 1
+    end
+  end
+
+  # STOP
+  if o['down'] == true
+    env = o['<env>']
+
+    begin
+      if o['node']
+        CardanoUp::Start.stop_node(env)
+      elsif o['wallet']
+        CardanoUp::Start.stop_wallet(env)
+      elsif o['node-wallet']
+        CardanoUp::Start.stop_node_and_wallet(env)
+      end
+      warn 'Stopped.'
+    rescue CardanoUp::EnvNotSupportedError => e
+      warn(e.message)
+      exit 1
+    end
+  end
+
+  # TAIL
+  if o['tail'] == true
+    env = o['<env>']
+    begin
+      log_dir = File.join(CardanoUp.config['log_dir'], env)
+      if o['node']
+        log_file = File.join(log_dir, 'node.log')
+        CardanoUp::Tail.tail(log_file)
+      elsif o['wallet']
+        log_file = File.join(log_dir, 'wallet.log')
+        CardanoUp::Tail.tail(log_file)
+      end
+    rescue CardanoUp::EnvNotSupportedError => e
+      warn(e.message)
+      exit 1
+    rescue StandardError => e
+      warn "Log file does not seem to exist: #{log_file}"
+      warn(e.message)
+      exit 1
+    rescue Interrupt
+      exit
+    end
+  end
+rescue Docopt::Exit => e
+  puts e.message
+end

data/bin/console

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'bundler/setup'
+require 'cardano-up'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/rebuild

@@ -0,0 +1,3 @@
+#!/usr/bin/env bash
+gem build *.gemspec -o cardano-up.gem
+gem install cardano-up.gem

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/lib/cardano-up/err.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module CardanoUp
+  # Thrown when env is not supported
+  class EnvNotSupportedError < StandardError
+    def initialize(env)
+      super("Environment '#{env}' not supported. Supported are: #{ENVS}")
+    end
+  end
+
+  # Thrown when cardano_up internal config does not exists
+  class ConfigNotSetError < StandardError
+    def initialize
+      super("Config not exists at '#{CardanoUp.cardano_up_config}'!")
+    end
+  end
+
+  # Thrown when wallet port is not set
+  class WalletPortError < StandardError
+    def initialize
+      super('Wallet port is not set!')
+    end
+  end
+
+  # Thrown when version of bundle to download is not supported
+  class VersionNotSupportedError < StandardError
+    def initialize(ver)
+      super(["Not supported version: #{ver}. Supported are: 'latest', 'master',",
+             "tag (e.g. 'v2022-08-16') or pr number ('3045')"].join(' '))
+    end
+  end
+end

data/lib/cardano-up/install.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+module CardanoUp
+  # Installing configs for Cardano environments and binaries
+  module Install
+    # Check all necessary config files for particular environment exist.
+    # @param env [String] - one of {ENVS}
+    # @raise CardanoUp::EnvNotSupportedError
+    def self.configs_exist?(env)
+      CardanoUp.configure_default unless CardanoUp.configured?
+      raise CardanoUp::EnvNotSupportedError, env unless CardanoUp::ENVS.include?(env)
+
+      configs = CardanoUp.config
+      config_dir_env = FileUtils.mkdir_p(File.join(configs['config_dir'], env))
+      config_files = CardanoUp::CONFIG_FILES
+      not_existing = []
+      config_files.each do |file|
+        conf_file_path = File.join(config_dir_env, file)
+        not_existing << conf_file_path unless File.exist?(conf_file_path)
+      end
+      not_existing.empty?
+    end
+
+    # Get all necessary config files for particular environment.
+    # @param env [String] - one of {ENVS}
+    # @raise CardanoUp::EnvNotSupportedError
+    def self.install_configs(env)
+      CardanoUp.configure_default unless CardanoUp.configured?
+      raise CardanoUp::EnvNotSupportedError, env unless CardanoUp::ENVS.include?(env)
+
+      configs = CardanoUp.config
+      config_urls = CardanoUp::Utils.config_urls(env)
+      config_dir_env = FileUtils.mkdir_p(File.join(configs['config_dir'], env))
+      config_urls.each do |url|
+        CardanoUp::Utils.wget(url, File.join(config_dir_env, File.basename(url)))
+      end
+    end
+
+    # Get cardano-wallet bundle binaries to your computer.
+    # @param release [String] - 'latest' | /^v20.{2}-.{2}-.{2}/ | 'master' | '3341'
+    # @raise CardanoUp::VersionNotSupportedError
+    def self.install_bins(release)
+      CardanoUp.configure_default unless CardanoUp.configured?
+      configs = CardanoUp.config
+      url = CardanoUp::Utils.get_binary_url(release)
+      bin_dir_env = FileUtils.mkdir_p(configs['bin_dir']).first
+      file_to_unpack = File.join(bin_dir_env, 'binary-dist')
+      CardanoUp::Utils.wget(url, file_to_unpack)
+
+      unpack_binary(file_to_unpack, bin_dir_env)
+      return_versions(bin_dir_env)
+    end
+
+    def unpack_binary(file_path, destination)
+      if CardanoUp::Utils.win?
+        CardanoUp::Tar.unzip(file_path, destination)
+      else
+        gio = CardanoUp::Tar.ungzip(File.open(file_path, 'rb'))
+        CardanoUp::Tar.untar(gio, destination)
+        cw_dir = Dir[File.join(destination, '/cardano-wallet-*')].first
+        FileUtils.cp_r(Dir[File.join(cw_dir, '/*')], destination)
+        FileUtils.rm_rf(file_path)
+        FileUtils.rm_rf(cw_dir)
+        executables = Dir[File.join(destination, '/cardano-*')] << File.join(destination, '/bech32')
+        executables.each { |e| FileUtils.chmod('u+x', e) }
+        executables
+      end
+    end
+    module_function :unpack_binary
+    private_class_method :unpack_binary
+
+    # Return versions of installed components
+    # @raise CardanoUp::ConfigNotSetError
+    def self.return_versions(bin_dir = nil)
+      bindir = bin_dir.nil? ? CardanoUp.config['bin_dir'] : bin_dir
+      exe = CardanoUp::Utils.win? ? '.exe' : ''
+      cn = CardanoUp::Utils.cmd "#{bindir}/cardano-node#{exe} version"
+      cli = CardanoUp::Utils.cmd "#{bindir}/cardano-cli#{exe} version"
+      cw = CardanoUp::Utils.cmd "#{bindir}/cardano-wallet#{exe} version"
+      ca = CardanoUp::Utils.cmd "#{bindir}/cardano-address#{exe} version"
+      b32 = CardanoUp::Utils.cmd "#{bindir}/bech32#{exe} --version"
+      { 'cardano-node' => cn,
+        'cardano-cli' => cli,
+        'cardano-wallet' => cw,
+        'cardano-address' => ca,
+        'bech32' => b32 }
+    end
+  end
+end

data/lib/cardano-up/start.rb

@@ -0,0 +1,248 @@
+# frozen_string_literal: true
+
+module CardanoUp
+  ##
+  # Start cardano-node and cardano-wallet on your system.
+  #
+  # For Linux and MacOS it will attempt to start separate screen sessions for
+  # wallet and node respectively, therefore 'screen' tool is required on your system.
+  # @see https://www.gnu.org/software/screen/
+  # If screen is not present you can install it using your package manager for instance:
+  #  # MacOS:
+  #  brew install screen
+  #  # Linux:
+  #  sudo apt-get install screen
+  #
+  # For Windows it will attepmt to install cardano-node and cardano-wallet as Windows services
+  # using 'nssm' tool.
+  # @see https://nssm.cc/
+  # Nssm can be installed via choco package manager:
+  #  choco install nssm
+  module Start
+    # Prepare configuration for wallet and node to be started
+    # @param env [Hash] provide env and wallet_port, e.g. { env: 'mainnet', wallet_port: '8090' }
+    # @raise CardanoUp::EnvNotSupportedError
+    # @raise CardanoUp::WalletPortError
+    def self.prepare_configuration(opt = { env: 'mainnet', wallet_port: '8090' })
+      env = opt[:env]
+      raise CardanoUp::EnvNotSupportedError, env unless CardanoUp::ENVS.include? env
+
+      wallet_port = opt[:wallet_port]
+      raise CardanoUp::WalletPortError if wallet_port.nil? || wallet_port.empty?
+
+      token_metadata_server = env == 'mainnet' ? CardanoUp::MAINNET_TOKEN_SERVER : CardanoUp::TESTNET_TOKEN_SERVER
+
+      CardanoUp.configure_default unless CardanoUp.configured?
+      configs = CardanoUp.config
+      bin_dir = configs['bin_dir']
+      config_dir = File.join(configs['config_dir'], env)
+      log_dir = File.join(configs['log_dir'], env)
+      state_dir = File.join(configs['state_dir'], env)
+      wallet_db_dir = File.join(state_dir, 'wallet-db')
+      node_db_dir = File.join(state_dir, 'node-db')
+      [bin_dir, config_dir, log_dir, state_dir, wallet_db_dir, node_db_dir].each do |dir|
+        FileUtils.mkdir_p(dir)
+      end
+
+      node_socket = if CardanoUp::Utils.win?
+                      "\\\\.\\pipe\\cardano-node-#{env}"
+                    else
+                      File.join(state_dir, 'node.socket')
+                    end
+      network = env == 'mainnet' ? '--mainnet' : "--testnet #{config_dir}/byron-genesis.json"
+
+      {
+        env: env,
+        wallet_port: wallet_port,
+        token_metadata_server: token_metadata_server,
+        bin_dir: bin_dir,
+        config_dir: config_dir,
+        log_dir: log_dir,
+        state_dir: state_dir,
+        wallet_db_dir: wallet_db_dir,
+        node_db_dir: node_db_dir,
+        node_socket: node_socket,
+        network: network
+      }
+    end
+
+    # @param configuration [Hash] output of prepare_configuration
+    def self.start_node(configuration)
+      env = configuration[:env]
+      bin_dir = configuration[:bin_dir]
+      config_dir = configuration[:config_dir]
+      log_dir = configuration[:log_dir]
+      node_db_dir = configuration[:node_db_dir]
+      node_socket = configuration[:node_socket]
+
+      exe = CardanoUp::Utils.win? ? '.exe' : ''
+      version = CardanoUp::Utils.cmd "#{bin_dir}/cardano-node#{exe} version"
+
+      if CardanoUp::Utils.win?
+        # Turn off p2p for Windows
+        # TODO: remove after https://github.com/input-output-hk/ouroboros-network/issues/3968 released
+        config_win = JSON.parse(File.read("#{config_dir}/config.json"))
+        config_win['EnableP2P'] = false
+        File.write("#{config_dir}/config.json", JSON.pretty_generate(config_win))
+        topology = %({
+              "Producers": [
+                {
+                  "addr": "#{env}-node.world.dev.cardano.org",
+                  "port": 30002,
+                  "valency": 2
+                }
+              ]
+            })
+        File.write("#{config_dir}/topology.json", topology)
+
+        # create cardano-node.bat file
+        node_cmd = ["#{bin_dir}/cardano-node.exe run",
+                    "--config #{config_dir}/config.json",
+                    "--topology #{config_dir}/topology.json",
+                    "--database-path #{node_db_dir}",
+                    "--socket-path #{node_socket}"].join(' ')
+        File.write("#{bin_dir}/cardano-node.bat", node_cmd)
+        node_service = "cardano-node-#{env}"
+        install_node = "nssm install #{node_service} #{bin_dir}/cardano-node.bat"
+        log_stdout_node = "nssm set #{node_service} AppStdout #{log_dir}/node.log"
+        log_stderr_node = "nssm set #{node_service} AppStderr #{log_dir}/node.log"
+        start_node = "nssm start #{node_service}"
+
+        CardanoUp::Utils.cmd install_node
+        CardanoUp::Utils.cmd log_stdout_node
+        CardanoUp::Utils.cmd log_stderr_node
+        CardanoUp::Utils.cmd start_node
+      else
+        node_cmd = ["#{bin_dir}/cardano-node run",
+                    "--config #{config_dir}/config.json",
+                    "--topology #{config_dir}/topology.json",
+                    "--database-path #{node_db_dir}",
+                    "--socket-path #{node_socket}"].join(' ')
+        node_service = "NODE_#{env}"
+        CardanoUp::Utils.cmd "screen -dmS #{node_service} -L -Logfile #{log_dir}/node.log #{node_cmd}"
+      end
+
+      {
+        node: {
+          service: node_service,
+          network: env,
+          version: version,
+          log: "#{log_dir}/node.log",
+          db_dir: node_db_dir,
+          socket_path: node_socket,
+          protocol_magic: get_protocol_magic(config_dir),
+          bin: node_cmd.split.first,
+          cmd: node_cmd
+        }
+      }
+    end
+
+    # @param configuration [Hash] output of prepare_configuration
+    def self.start_wallet(configuration)
+      env = configuration[:env]
+      wallet_port = configuration[:wallet_port]
+      token_metadata_server = configuration[:token_metadata_server]
+      bin_dir = configuration[:bin_dir]
+      log_dir = configuration[:log_dir]
+      wallet_db_dir = configuration[:wallet_db_dir]
+      node_socket = configuration[:node_socket]
+      network = configuration[:network]
+
+      exe = CardanoUp::Utils.win? ? '.exe' : ''
+      version = CardanoUp::Utils.cmd "#{bin_dir}/cardano-wallet#{exe} version"
+
+      if CardanoUp::Utils.win?
+
+        # create cardano-wallet.bat file
+        wallet_cmd = ["#{bin_dir}/cardano-wallet.exe serve",
+                      "--port #{wallet_port}",
+                      "--node-socket #{node_socket}",
+                      network.to_s,
+                      "--database #{wallet_db_dir}",
+                      "--token-metadata-server #{token_metadata_server}"].join(' ')
+        File.write("#{bin_dir}/cardano-wallet.bat", wallet_cmd)
+        wallet_service = "cardano-wallet-#{env}"
+        install_wallet = "nssm install #{wallet_service} #{bin_dir}/cardano-wallet.bat"
+        log_stdout_wallet = "nssm set #{wallet_service} AppStdout #{log_dir}/wallet.log"
+        log_stderr_wallet = "nssm set #{wallet_service} AppStderr #{log_dir}/wallet.log"
+        start_wallet = "nssm start #{wallet_service}"
+
+        CardanoUp::Utils.cmd install_wallet
+        CardanoUp::Utils.cmd log_stdout_wallet
+        CardanoUp::Utils.cmd log_stderr_wallet
+        CardanoUp::Utils.cmd start_wallet
+      else
+        wallet_cmd = ["#{bin_dir}/cardano-wallet serve",
+                      "--port #{wallet_port}",
+                      "--node-socket #{node_socket}",
+                      network.to_s,
+                      "--database #{wallet_db_dir}",
+                      "--token-metadata-server #{token_metadata_server}"].join(' ')
+        wallet_service = "WALLET_#{env}"
+        CardanoUp::Utils.cmd "screen -dmS #{wallet_service} -L -Logfile #{log_dir}/wallet.log #{wallet_cmd}"
+      end
+
+      {
+        wallet: {
+          service: wallet_service,
+          network: env,
+          version: version,
+          log: "#{log_dir}/wallet.log",
+          db_dir: wallet_db_dir,
+          port: wallet_port.to_i,
+          host: "http://localhost:#{wallet_port}/v2",
+          bin: wallet_cmd.split.first,
+          cmd: wallet_cmd
+        }
+      }
+    end
+
+    # @param configuration [Hash] output of prepare_configuration
+    def self.start_node_and_wallet(configuration)
+      cn = start_node(configuration)
+      cw = start_wallet(configuration)
+      cn.merge(cw)
+    end
+
+    # @raise CardanoUp::EnvNotSupportedError
+    def self.stop_node(env)
+      raise CardanoUp::EnvNotSupportedError, env unless CardanoUp::ENVS.include? env
+
+      if CardanoUp::Utils.win?
+        CardanoUp::Utils.cmd "nssm stop cardano-node-#{env}"
+        CardanoUp::Utils.cmd "nssm remove cardano-node-#{env} confirm"
+      else
+        CardanoUp::Utils.cmd "screen -S NODE_#{env} -X at '0' stuff '^C'"
+        CardanoUp::Utils.cmd "screen -XS NODE_#{env} quit"
+      end
+    end
+
+    # @raise CardanoUp::EnvNotSupportedError
+    def self.stop_wallet(env)
+      raise CardanoUp::EnvNotSupportedError, env unless CardanoUp::ENVS.include? env
+
+      if CardanoUp::Utils.win?
+        CardanoUp::Utils.cmd "nssm stop cardano-wallet-#{env}"
+        CardanoUp::Utils.cmd "nssm remove cardano-wallet-#{env} confirm"
+      else
+        CardanoUp::Utils.cmd "screen -S WALLET_#{env} -X at '0' stuff '^C'"
+        CardanoUp::Utils.cmd "screen -XS WALLET_#{env} quit"
+      end
+    end
+
+    # @raise CardanoUp::EnvNotSupportedError
+    def self.stop_node_and_wallet(env)
+      stop_wallet(env)
+      stop_node(env)
+    end
+
+    ##
+    # Get protocol magic from config's byron-genesis.json
+    def get_protocol_magic(config)
+      byron_genesis = JSON.parse(File.read(File.join(config, 'byron-genesis.json')))
+      byron_genesis['protocolConsts']['protocolMagic'].to_i
+    end
+    module_function :get_protocol_magic
+    private_class_method :get_protocol_magic
+  end
+end

data/lib/cardano-up/tail.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module CardanoUp
+  # Tail log file
+  module Tail
+    def self.tail(file_path)
+      File.open(file_path) do |log|
+        log.extend(File::Tail)
+        log.interval
+        log.backward(10)
+        log.tail { |line| warn line }
+      end
+    end
+  end
+end

data/lib/cardano-up/tar.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module CardanoUp
+  # unpacking archives
+  module Tar
+    # unzip file to destination directory
+    def self.unzip(file, destination)
+      FileUtils.mkdir_p(destination)
+      Zip::File.open(file) do |zip_file|
+        zip_file.each do |f|
+          fpath = File.join(destination, f.name)
+          zip_file.extract(f, fpath)
+        end
+      end
+    end
+
+    # un-gzips the given IO, returning the
+    # decompressed version as a StringIO
+    def self.ungzip(tarfile)
+      z = Zlib::GzipReader.new(tarfile)
+      unzipped = StringIO.new(z.read)
+      z.close
+      unzipped
+    end
+
+    # untars the given IO into the specified
+    # directory
+    def self.untar(io, destination)
+      Gem::Package::TarReader.new io do |tar|
+        tar.each do |tarfile|
+          destination_file = File.join destination, tarfile.full_name
+
+          if tarfile.directory?
+            FileUtils.mkdir_p destination_file
+          else
+            destination_directory = File.dirname(destination_file)
+            FileUtils.mkdir_p destination_directory unless File.directory?(destination_directory)
+            File.open destination_file, 'wb' do |f|
+              f.print tarfile.read
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cardano-up/utils.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module CardanoUp
+  # Utility methods
+  module Utils
+    def self.cmd(cmd, display_result: false)
+      cmd.gsub(/\s+/, ' ')
+      res = `#{cmd}`
+      puts cmd if display_result
+      puts res if display_result
+      res.gsub("\n", '')
+    end
+
+    def self.wget(url, file = nil)
+      file ||= File.basename(url)
+      resp = HTTParty.get(url)
+      File.binwrite(file, resp.body)
+    end
+
+    def self.win?
+      RUBY_PLATFORM =~ /cygwin|mswin|mingw|bccwin|wince|emx/
+    end
+
+    def self.linux?
+      RUBY_PLATFORM =~ /linux/
+    end
+
+    def self.mac?
+      RUBY_PLATFORM =~ /darwin/
+    end
+
+    def self.latest_tag
+      HTTParty.get("#{CardanoUp::BINS_BASE_URL}/releases/latest",
+                   headers: { 'Accept' => 'application/json' })['tag_name']
+    end
+
+    ##
+    # Latest binary url for latest release or particular tag, from master or pr num.
+    # @param release [String] - 'latest' | /^v20.{2}-.{2}-.{2}/ | 'master' | '3341'
+    # @raise CardanoUp::VersionNotSupportedError
+    def self.get_binary_url(release = 'latest')
+      unless release == 'master' || release == 'latest' || release =~ /^v20.{2}-.{2}-.{2}/ || release =~ /^\d+$/
+        raise CardanoUp::VersionNotSupportedError, release
+      end
+
+      url = ''
+      if release == 'latest' || release =~ /^v20.{2}-.{2}-.{2}/
+        tag = release == 'latest' ? latest_tag : release
+        if linux?
+          file = "cardano-wallet-#{tag}-linux64.tar.gz"
+        elsif mac?
+          file = "cardano-wallet-#{tag}-macos-intel.tar.gz"
+        elsif win?
+          file = "cardano-wallet-#{tag}-win64.zip"
+        end
+        url = "#{CardanoUp::BINS_BASE_URL}/releases/download/#{tag}/#{file}"
+      else
+        if linux?
+          os = 'linux.musl.cardano-wallet-linux64'
+        elsif mac?
+          os = 'macos.intel.cardano-wallet-macos-intel'
+        elsif win?
+          os = 'linux.windows.cardano-wallet-win64'
+        end
+
+        url = if release == 'master'
+                "#{CardanoUp::HYDRA_BASE_URL}/#{os}/latest/download-by-type/file/binary-dist"
+              else
+                "#{CardanoUp::HYDRA_BASE_URL}-pr-#{release}/#{os}/latest/download-by-type/file/binary-dist"
+              end
+      end
+      url
+    end
+
+    ##
+    # Latest Cardano configs
+    # @raise CardanoUp::EnvNotSupportedError
+    def self.configs_base_url(env)
+      raise CardanoUp::EnvNotSupportedError, env unless CardanoUp::ENVS.include?(env)
+
+      "#{CardanoUp::CONFIGS_BASE_URL}/#{env}/"
+    end
+
+    # @raise CardanoUp::EnvNotSupportedError
+    def self.config_urls(env)
+      raise CardanoUp::EnvNotSupportedError, env unless CardanoUp::ENVS.include?(env)
+
+      base_url = configs_base_url(env)
+      configs = []
+      CardanoUp::CONFIG_FILES.each do |file|
+        configs << "#{base_url}#{file}"
+      end
+      configs
+    end
+  end
+end

data/lib/cardano-up/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+# Version
+module CardanoUp
+  VERSION ||= '0.1.0'
+end

data/lib/cardano-up.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'rubygems'
+require 'rubygems/package'
+require 'httparty'
+require 'fileutils'
+require 'file-tail'
+require 'json'
+require 'zlib'
+require 'zip'
+
+require 'cardano-up/version'
+require 'cardano-up/err'
+require 'cardano-up/utils'
+require 'cardano-up/tar'
+require 'cardano-up/install'
+require 'cardano-up/start'
+require 'cardano-up/tail'
+
+# Cardano Up!
+# Lightweight manager for Cardano binaries and configs.
+module CardanoUp
+  CONFIGS_BASE_URL = 'https://book.world.dev.cardano.org/environments'
+  BINS_BASE_URL = 'https://github.com/input-output-hk/cardano-wallet'
+  HYDRA_BASE_URL = 'https://hydra.iohk.io/job/Cardano/cardano-wallet'
+  ENVS = %w[mainnet preview preprod shelley-qa
+            staging vasil-qa vasil-dev mixed testnet].freeze
+  CONFIG_FILES = ['alonzo-genesis.json', 'byron-genesis.json', 'shelley-genesis.json',
+                  'config.json', 'topology.json'].freeze
+  MAINNET_TOKEN_SERVER = 'https://tokens.cardano.org'
+  TESTNET_TOKEN_SERVER = 'https://metadata.cardano-testnet.iohkdev.io'
+  # It is recommended to use default value for {base_dir},
+  # however it is possible to modify it with {base_dir=}.
+  @base_dir = File.join(Dir.home, '.cardano-up')
+
+  # It is recommended to use default value for {cardano_up_config},
+  # however it is possible to modify it with {cardano_up_config=}.
+  @cardano_up_config = File.join(@base_dir, '.cardano-up.json')
+
+  def self.base_dir
+    @base_dir
+  end
+
+  def self.base_dir=(value)
+    @base_dir = value
+    @cardano_up_config = File.join(@base_dir, 'config.json')
+    @base_dir
+  end
+
+  def self.cardano_up_config
+    @cardano_up_config
+  end
+
+  def self.cardano_up_config=(value)
+    @cardano_up_config = value
+  end
+
+  # Check if CardanoUp config exists
+  def self.configured?
+    File.exist?(@cardano_up_config)
+  end
+
+  # Set default config for CardanoUp
+  def self.configure_default
+    configure(File.join(@base_dir, 'bins'),
+              File.join(@base_dir, 'state'),
+              File.join(@base_dir, 'logs'),
+              File.join(@base_dir, 'configs'))
+  end
+
+  # Set custom config for CardanoUp
+  def self.configure(bin_dir, state_dir, logs_dir, config_dir)
+    FileUtils.mkdir_p(@base_dir)
+    c = if configured?
+          CardanoUp.config
+        else
+          { 'bin_dir' => File.join(@base_dir, 'bins'),
+            'state_dir' => File.join(@base_dir, 'state'),
+            'log_dir' => File.join(@base_dir, 'state'),
+            'config_dir' => File.join(@base_dir, 'configs') }
+        end
+    c['bin_dir'] = bin_dir if bin_dir
+    c['state_dir'] = state_dir if state_dir
+    c['log_dir'] = logs_dir if logs_dir
+    c['config_dir'] = config_dir if config_dir
+    File.write(@cardano_up_config, JSON.pretty_generate(c))
+    JSON.parse(File.read(@cardano_up_config))
+  end
+
+  # Get config values
+  def self.config
+    raise CardanoUp::ConfigNotSetError unless configured?
+
+    JSON.parse(File.read(@cardano_up_config))
+  end
+
+  # Remove configuration file
+  def self.remove_cardano_up_config
+    FileUtils.rm_f(@cardano_up_config)
+  end
+
+  # dir [String] config dir
+  def self.clean_config_dir(dir)
+    FileUtils.rm_f(config[dir])
+  end
+end

metadata

@@ -0,0 +1,166 @@
+--- !ruby/object:Gem::Specification
+name: cardano-up
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Piotr Stachyra
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2022-10-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: docopt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.6.1
+- !ruby/object:Gem::Dependency
+  name: file-tail
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+- !ruby/object:Gem::Dependency
+  name: httparty
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.20.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.20.0
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 2.3.2
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.11'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.36'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.36'
+description: |-
+  Cardano Up lets you get all essential Cardano
+                          tools on your system: cardano-node, cardano-cli, cardano-wallet,
+                          cardano-addresses and bech32. Then easily manage configuration
+                          for different environments and launch node and wallet services.
+email:
+- piotr.stachyra@gmail.com
+executables:
+- cardano-up
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE.txt
+- README.md
+- bin/cardano-up
+- bin/console
+- bin/rebuild
+- bin/setup
+- lib/cardano-up.rb
+- lib/cardano-up/err.rb
+- lib/cardano-up/install.rb
+- lib/cardano-up/start.rb
+- lib/cardano-up/tail.rb
+- lib/cardano-up/tar.rb
+- lib/cardano-up/utils.rb
+- lib/cardano-up/version.rb
+homepage: https://github.com/piotr-iohk/cardano-up
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org/
+  homepage_uri: https://github.com/piotr-iohk/cardano-up
+  source_code_uri: https://github.com/piotr-iohk/cardano-up
+  changelog_uri: https://github.com/piotr-iohk/cardano-up
+  rubygems_mfa_required: 'true'
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- bin
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.7.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3.1
+signing_key: 
+specification_version: 4
+summary: Lightweight manager for Cardano binaries and configs.
+test_files: []