cardano-up 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ffd6230a971acea78415e9789e6b605ad493dee667afe4acd5f123759df90867
-  data.tar.gz: 20af817f4b0918d29b5b75dc6bea54d59fc3e5e6ee61d974888a69ffd8dce357
+  metadata.gz: 7dc6e5153ea10a283c8076a763034d89334e0ec285265ce8fa47cb7d41dddbaa
+  data.tar.gz: fc58a1646113ff3c52faaadb6807f1147029a4716d06b750f07783041eac4149
 SHA512:
-  metadata.gz: 46d6f2e0f2398aa1416ab61e1f49684aa5b07389efce583f00ab973b46f5c91246aea9a71f27bb03717ed0101ef27cff9547adf366469650d9b03d25ff7dd8b9
-  data.tar.gz: bcc306a1b9ac5a7debee61df90fe659bfc3df4f4cc309317ba334193c6cf421c9810a88c5100639994bc9e5494c678fc171cf9fd308cd7c3937e4e658b516270
+  metadata.gz: e098510d7c479a9d1570c1f9ba803875908b509365b556045c8530f1548e13356593592c3985c30d6711c84c2afd077b54cd417bf5eba0505590bb9b1b6fb30d
+  data.tar.gz: 54d8a545a3f1ebdea7cca06829672c337de7eac3403469d6ed33033869e7e08431b86dd495be49def0359063d004c0a363fdba397a8cd69ef4852d852582aa92

data/README.md

@@ -29,21 +29,26 @@ This Ruby gem provides easy way for:
 
 It only takes a single command to start node and wallet on your system. Say, on `mainnet`?
 
-    $ cardano-up mainnet node-wallet up
+    $ cardano-up mainnet 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.
+To explore more options call:
+
+		$ cardano-up --help
+		$ cardano-up --examples
 
 ## Documentation
 
 | Link | Description  |
 |--|--|
+|  [Usage examples](https://github.com/piotr-iohk/cardano-up/wiki/Usage-Examples) | Also available in `$ cardano-up --examples` |
 |  [Ruby API (edge)](https://piotr-iohk.github.io/cardano-up/master/) | cardano-up API doc |
 
 ## How it works
+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`.
 
 **Configurations** for the networks are downloaded from [Cardano Book](https://book.world.dev.cardano.org/environments.html).
 
@@ -65,8 +70,8 @@ In case of Windows it will attempt to install cardano-node and cardano-wallet as
 
 > :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`.
+There is also basic **session management** in cardano-up. In a single session you can have at most 1 node and 1 wallet for particular network. Because of the sessions you can quickly check details of your running components (like where are the log or database files or what ports are used) and you have some basic tools to monitor them (via `tail` and `ping` subcommands).
 
 ## License
 
-The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).
+The gem is available as open source under the terms of the [MIT License](https://github.com/piotr-iohk/cardano-up/blob/master/LICENSE.txt).

data/bin/cardano-up

@@ -11,16 +11,17 @@ doc = <<~DOCOPT
   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__)} ls
     #{File.basename(__FILE__)} config [--set-default] [--bindir <path>] [--configdir <path>] [--logdir <path>] [--statedir <path>]
+    #{File.basename(__FILE__)} <env> [(node|wallet)] [(up|down|ping)] [--port <port>] [--session <name>]
+    #{File.basename(__FILE__)} <env> (node|wallet) tail [--session <name>]
     #{File.basename(__FILE__)} -v | --version
+    #{File.basename(__FILE__)} -e | --examples
     #{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]
+    <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__)}
@@ -28,7 +29,11 @@ doc = <<~DOCOPT
                             ones from latest release.
     down                    Stop particular service.
     tail                    Follow logs for particular service.
-    --port <port>           Specify wallet port. [default: 8090]
+    ping                    Ping service to check its status.
+    ls                      List sessions.
+    -p --port <port>        Specify wallet port. [default: 8090]
+    -s --session <name>     Set session name. In single session you can have
+                            at most 1 node and 1 wallet for particular <env>. [default: 0]
 
     config                  Internal config for #{File.basename(__FILE__)}
     --set-default           Overwrite config with default values.
@@ -39,31 +44,105 @@ doc = <<~DOCOPT
 
     -v --version            Check #{File.basename(__FILE__)} version and versions of
                             installed binaries if available.
+    -e --examples           Show some usage examples.
     -h --help               This help.
 DOCOPT
 
 def pretty_json(c)
-  puts JSON.pretty_generate(c)
+  if c.is_a?(Hash)
+    puts JSON.pretty_generate(c)
+  else
+    warn c
+  end
 end
 
 def ok
   warn 'Ok.'
 end
 
+def not_ok
+  warn '⚠️   Not ok.'
+end
+
 begin
   CardanoUp.configure_default unless CardanoUp.configured?
   o = Docopt.docopt(doc)
+  # pretty_json o
+
+  # EXAMPLES
+  if o['--examples'] == true
+    warn %(INTERNAL CONFIG:
+------------------------------
+Check internal config file contents:
+
+    $ #{File.basename(__FILE__)} config
+
+BINARIES AND NETWORK CONFIGS:
+------------------------------
+Get latest release binaries and verify versions:
+
+    $ #{File.basename(__FILE__)} install latest
+    $ #{File.basename(__FILE__)} -v
+
+Get configuration for 'preview' network:
+
+    $ #{File.basename(__FILE__)} get-configs preview
+
+SERVICE MANAGEMENT:
+------------------------------
+> Note: If you have no configs for particular env 'up'
+        subcommand will download them on the fly. If no binaries,
+        latest release will be installed, otherwise it will use
+        what is in the 'bin_dir'.
+
+Start node and wallet on mainnet:
+
+    $ #{File.basename(__FILE__)} mainnet up
+
+Start node on preprod:
+
+    $ #{File.basename(__FILE__)} preprod node up
+
+Check active sessions:
+
+    $ #{File.basename(__FILE__)} ls
+
+Check details of what is running on mainnet and preprod or details of given component:
+
+    $ #{File.basename(__FILE__)} mainnet
+    $ #{File.basename(__FILE__)} preprod
+    $ #{File.basename(__FILE__)} mainnet wallet
+    $ #{File.basename(__FILE__)} preprod node
+
+Check health of node and wallet on mainnet:
+
+    $ #{File.basename(__FILE__)} mainnet node ping
+    $ #{File.basename(__FILE__)} mainnet wallet ping
 
+Monitor mainnet wallet and node logs (Ctrl + c to stop):
+
+    $ #{File.basename(__FILE__)} mainnet node tail
+    $ #{File.basename(__FILE__)} mainnet wallet tail
+
+Stop preprod node:
+
+    $ #{File.basename(__FILE__)} preprod node down
+
+Stop mainnet node and wallet:
+
+    $ #{File.basename(__FILE__)} mainnet down
+    )
+  end
   # VERSION
   if o['--version'] == true
     warn "#{File.basename(__FILE__)}: #{CardanoUp::VERSION}"
     $stderr.puts
     begin
-      pretty_json CardanoUp::Install.return_versions
+      pretty_json CardanoUp::Bins.return_versions
     rescue StandardError => e
       warn 'Nothing installed? To fix run:'
       warn " $ #{File.basename(__FILE__)} install"
-      warn e
+      warn "⚠️   #{e}"
     end
   end
 
@@ -103,16 +182,20 @@ begin
 
   # INSTALL
   if o['install'] == true
-    release = o['<release>']
+    release = o['<release>'] || 'latest'
     begin
       $stderr.print "Installing '#{release}'... "
-      versions = CardanoUp::Install.install_bins(release)
+      versions = CardanoUp::Bins.install(release)
       ok
     rescue CardanoUp::VersionNotSupportedError => e
       warn(e.message)
       exit 1
+    rescue Errno::ETXTBSY => e
+      warn("Couldn't unpack binaries, perhaps some file is in use?")
+      warn(e.message)
+      exit 1
     end
-    warn "Install dir: #{CardanoUp.config['bin_dir']}"
+    warn "Install dir: #{CardanoUp.config[:bin_dir]}"
     $stderr.puts
     pretty_json(versions)
     exit
@@ -122,13 +205,13 @@ begin
   if o['get-configs'] == true
     env = o['<env>']
     begin
-      configs = CardanoUp::Install.install_configs(env)
+      configs = CardanoUp::Configs.get(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)}"
+    warn "Config dir: #{File.join(CardanoUp.config[:config_dir], env)}"
     $stderr.puts
     pretty_json(configs)
     exit
@@ -138,80 +221,103 @@ begin
   if o['up'] == true
     env = o['<env>']
     port = o['--port']
+    session_name = o['--session']
 
     begin
       $stderr.print 'Configs: '
-      unless CardanoUp::Install.configs_exist?(env)
+      unless CardanoUp::Configs.exist?(env)
         $stderr.print "installing configs for #{env}... "
-        CardanoUp::Install.install_configs(env)
+        CardanoUp::Configs.get(env)
       end
       ok
 
       $stderr.print 'Binaries: '
       begin
-        CardanoUp::Install.return_versions
+        CardanoUp::Bins.return_versions
         ok
       rescue StandardError
         $stderr.print 'installing latest release binaries... '
-        CardanoUp::Install.install_bins('latest')
+        CardanoUp::Bins.install('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
+      c = CardanoUp::Launcher.setup({ env: env, wallet_port: port, session_name: session_name })
+
       if o['node']
-        pretty_json CardanoUp::Start.start_node(c)
+        pretty_json CardanoUp::Launcher.node_up(c)
         $stderr.puts
         warn "Congratulations! You've just started cardano-node!"
       elsif o['wallet']
-        pretty_json CardanoUp::Start.start_wallet(c)
+        pretty_json CardanoUp::Launcher.wallet_up(c)
         $stderr.puts
         warn "Congratulations! You've just started cardano-wallet!"
-      elsif o['node-wallet']
-        pretty_json CardanoUp::Start.start_node_and_wallet(c)
+      else
+        n = CardanoUp::Launcher.node_up(c)
+        w = CardanoUp::Launcher.wallet_up(c)
+        pretty_json(n.merge(w))
         $stderr.puts
         warn "Congratulations! You've just started cardano-node and cardano-wallet!"
       end
+    rescue CardanoUp::EnvNotSupportedError => e
+      warn "⚠️   #{e}"
+      exit 1
+    rescue CardanoUp::SessionHasNodeError => e
+      warn "⚠️   #{e}"
+      $stderr.puts
+      warn "If you'd like to start another node instance after all:"
+      warn " $ #{File.basename(__FILE__)} #{env} node up -s <some_name>"
+      exit 1
+    rescue CardanoUp::SessionHasWalletError, CardanoUp::WalletPortUsedError => e
+      warn "⚠️   #{e}"
+      $stderr.puts
+      warn "If you'd like to start another wallet instance after all:"
+      warn " $ #{File.basename(__FILE__)} #{env} wallet up -s <some_name> --port <different_port>"
+      exit 1
     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
+      warn "⚠️   #{e}"
       exit 1
     end
-  end
 
-  # STOP
-  if o['down'] == true
+  # DOWN
+  elsif o['down'] == true
     env = o['<env>']
-
+    session_name = o['--session']
+    warn "Stopping service on '#{env}' in session '#{session_name}'..."
     begin
       if o['node']
-        CardanoUp::Start.stop_node(env)
+        CardanoUp::Launcher.node_down(env, session_name)
+        warn 'Node stopped.'
       elsif o['wallet']
-        CardanoUp::Start.stop_wallet(env)
-      elsif o['node-wallet']
-        CardanoUp::Start.stop_node_and_wallet(env)
+        CardanoUp::Launcher.wallet_down(env, session_name)
+        warn 'Wallet stopped.'
+      else
+        CardanoUp::Launcher.node_down(env, session_name)
+        warn 'Node stopped.'
+        begin
+          CardanoUp::Launcher.wallet_down(env, session_name)
+        rescue CardanoUp::SessionNotExistsError
+          # in case node_down kills session (i.e. it was the last service killed)
+          exit
+        end
+        warn 'Wallet stopped.'
       end
-      warn 'Stopped.'
-    rescue CardanoUp::EnvNotSupportedError => e
-      warn(e.message)
+    rescue CardanoUp::EnvNotSupportedError, CardanoUp::SessionNotExistsError => e
+      warn "⚠️   #{e}"
       exit 1
     end
-  end
 
   # TAIL
-  if o['tail'] == true
+  elsif o['tail'] == true
     env = o['<env>']
+    session_name = o['--session']
     begin
-      log_dir = File.join(CardanoUp.config['log_dir'], env)
+      log_dir = File.join(CardanoUp.config[:log_dir], session_name, env)
       if o['node']
         log_file = File.join(log_dir, 'node.log')
         CardanoUp::Tail.tail(log_file)
@@ -227,8 +333,123 @@ begin
       warn(e.message)
       exit 1
     rescue Interrupt
+      # on ctrl + c don't show stack trace
+      $stderr.puts
+    end
+
+  # PING
+  elsif o['ping']
+    begin
+      session_name = o['--session']
+      env = o['<env>']
+      CardanoUp::Configs.exist?(env)
+      sessions = CardanoUp::Session.get(session_name)
+      CardanoUp::Session.network_or_raise?(session_name, env.to_sym)
+      warn "Ping {env: #{env}, session: #{session_name}}:"
+
+      if o['node']
+        CardanoUp::Session.node_or_raise?(session_name, env.to_sym)
+        $stderr.print 'Node ping... '
+        r, c = CardanoUp::Ping.node(session_name, env)
+        c == 200 ? ok : not_ok
+        pretty_json r
+      elsif o['wallet']
+        CardanoUp::Session.wallet_or_raise?(session_name, env.to_sym)
+        url = sessions[env.to_sym][:wallet][:url]
+        $stderr.print "Wallet ping (url: #{url})... "
+        r, c = CardanoUp::Ping.wallet(session_name, env)
+        c == 200 ? ok : not_ok
+        pretty_json r
+      else
+        warn 'Use: '
+        warn "  $ #{File.basename(__FILE__)} #{env} node ping -s #{session_name}"
+        warn "  $ #{File.basename(__FILE__)} #{env} wallet ping -s #{session_name}"
+      end
+    rescue Errno::ECONNREFUSED,
+           CardanoUp::EnvNotSupportedError => e
+      warn "⚠️   #{e}"
+      exit 1
+    rescue CardanoUp::SessionNotExistsError,
+           CardanoUp::SessionEnvNotUpError,
+           CardanoUp::SessionServiceNotUpError => e
+      warn "⚠️   #{e}"
+      warn 'To list active sessions call: '
+      warn "  $ #{File.basename(__FILE__)} ls"
+      exit 1
+    rescue Interrupt
+      # on ctrl + c don't show stack trace
+      $stderr.puts
       exit
     end
+
+  # Session STATUS
+  elsif o['<env>']
+    session_name = o['--session']
+    env = o['<env>']
+    begin
+      CardanoUp::Configs.exist?(env)
+      sessions = CardanoUp::Session.get(session_name)
+      CardanoUp::Session.network_or_raise?(session_name, env.to_sym)
+
+      if o['node']
+        CardanoUp::Session.node_or_raise?(session_name, env.to_sym)
+        warn "Node details {env: #{env}, session: #{session_name}}:"
+        warn "For health-check: $ #{File.basename(__FILE__)} #{env} node ping -s #{session_name}"
+        $stderr.puts
+        node = sessions[env.to_sym][:node]
+        pretty_json node
+      elsif o['wallet']
+        CardanoUp::Session.wallet_or_raise?(session_name, env.to_sym)
+        warn "Wallet details {env: #{env}, session: #{session_name}}:"
+        warn "For health-check: $ #{File.basename(__FILE__)} #{env} wallet ping -s #{session_name}"
+        $stderr.puts
+        wallet = sessions[env.to_sym][:wallet]
+        pretty_json wallet
+      else
+        warn "Details {env: #{env}, session: #{session_name}}:"
+        $stderr.puts
+        pretty_json sessions[env.to_sym]
+      end
+    rescue CardanoUp::EnvNotSupportedError => e
+      warn "⚠️   #{e}"
+      exit 1
+    rescue CardanoUp::SessionNotExistsError,
+           CardanoUp::SessionEnvNotUpError,
+           CardanoUp::SessionServiceNotUpError => e
+      warn "⚠️   #{e}"
+      warn 'To list active sessions call: '
+      warn "  $ #{File.basename(__FILE__)} ls"
+      exit 1
+    end
+  end
+
+  # LS
+  if o['ls']
+    sessions = CardanoUp::Session.list_all
+
+    def list_extended(sessions)
+      sessions.map do |s|
+        session_name = File.basename(s)[/.session-(.+).json/, 1]
+        s_det = CardanoUp::Session.get(session_name)
+        warn "  #{session_name}:"
+        s_det.each_key do |env|
+          warn "    #{env}:"
+          s_det[env].each_key do |service|
+            warn "       #{service} (#{s_det[env][service][:service]})" if service == :node
+            if service == :wallet
+              warn "       #{service} (#{s_det[env][service][:service]}, port: #{s_det[env][service][:port]})"
+            end
+          end
+        end
+      end
+    end
+
+    if sessions.empty?
+      warn 'No active sessions.'
+    else
+      warn 'Sessions:'
+      list_extended(sessions)
+    end
   end
 rescue Docopt::Exit => e
   puts e.message

data/lib/cardano-up/{install.rb → bins.rb}

@@ -1,49 +1,16 @@
 # 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
-
+  # Installing binaries for Cardano
+  module Bins
     # 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)
+    def self.install(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
+      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)
 
@@ -51,6 +18,23 @@ module CardanoUp
       return_versions(bin_dir_env)
     end
 
+    # 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
+
     def unpack_binary(file_path, destination)
       if CardanoUp::Utils.win?
         CardanoUp::Tar.unzip(file_path, destination)
@@ -68,22 +52,5 @@ module CardanoUp
     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/configs.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module CardanoUp
+  # Installing configs Cardano environments
+  module Configs
+    # Check all necessary config files for particular environment exist.
+    # @param env [String] - one of {ENVS}
+    # @raise CardanoUp::EnvNotSupportedError
+    def self.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.get(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
+  end
+end

data/lib/cardano-up/err.rb

@@ -1,6 +1,41 @@
 # frozen_string_literal: true
 
 module CardanoUp
+  # Thrown when service not exists in session
+  class SessionServiceNotUpError < StandardError
+    def initialize(session_name, env, service)
+      super("Service '#{service}' is not running on '#{env}' in session '#{session_name}'!")
+    end
+  end
+
+  # Thrown when env not exists in session
+  class SessionEnvNotUpError < StandardError
+    def initialize(session_name, env)
+      super("Nothing is running on '#{env}' in session '#{session_name}'!")
+    end
+  end
+
+  # Thrown when session not exists
+  class SessionNotExistsError < StandardError
+    def initialize(session_name)
+      super("Session '#{session_name}' does not exist!")
+    end
+  end
+
+  # Thrown when there is already a node running in the session
+  class SessionHasNodeError < StandardError
+    def initialize(session_name, network)
+      super("Session '#{session_name}' already has node running on '#{network}'!")
+    end
+  end
+
+  # Thrown when there is already a wallet running in the session
+  class SessionHasWalletError < StandardError
+    def initialize(session_name, network)
+      super("Session '#{session_name}' already has wallet running on '#{network}'!")
+    end
+  end
+
   # Thrown when env is not supported
   class EnvNotSupportedError < StandardError
     def initialize(env)
@@ -22,6 +57,13 @@ module CardanoUp
     end
   end
 
+  # Thrown when wallet port is not set
+  class WalletPortUsedError < StandardError
+    def initialize(port)
+      super("The port #{port} is already in use!")
+    end
+  end
+
   # Thrown when version of bundle to download is not supported
   class VersionNotSupportedError < StandardError
     def initialize(ver)