cardano-up 0.1.1 → 0.1.2

data/lib/cardano-up/{start.rb → launcher.rb}

@@ -2,7 +2,7 @@
 
 module CardanoUp
   ##
-  # Start cardano-node and cardano-wallet on your system.
+  # Start/stop 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.
@@ -18,26 +18,29 @@ module CardanoUp
   # @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' }
+  module Launcher
+    # Create common set of variables for getting node and wallet up
+    # @param env [Hash] provide env and wallet_port,
+    #  e.g. { env: 'mainnet', wallet_port: '8090', session_name: '0' }
     # @raise CardanoUp::EnvNotSupportedError
     # @raise CardanoUp::WalletPortError
-    def self.prepare_configuration(opt = { env: 'mainnet', wallet_port: '8090' })
+    def self.setup(opt = { env: 'mainnet', wallet_port: '8090', session_name: '0' })
       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?
 
+      session_name = opt[:session_name] || '0'
+
       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)
+      bin_dir = configs[:bin_dir]
+      config_dir = File.join(configs[:config_dir], env)
+      log_dir = File.join(configs[:log_dir], session_name, env)
+      state_dir = File.join(configs[:state_dir], session_name, 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|
@@ -45,11 +48,11 @@ module CardanoUp
       end
 
       node_socket = if CardanoUp::Utils.win?
-                      "\\\\.\\pipe\\cardano-node-#{env}"
+                      "\\\\.\\pipe\\cardano-node-#{env}-#{session_name}"
                     else
                       File.join(state_dir, 'node.socket')
                     end
-      network = env == 'mainnet' ? '--mainnet' : "--testnet #{config_dir}/byron-genesis.json"
+      network = env == 'mainnet' ? '--mainnet' : "--testnet #{File.join(config_dir, 'byron-genesis.json')}"
 
       {
         env: env,
@@ -62,50 +65,73 @@ module CardanoUp
         wallet_db_dir: wallet_db_dir,
         node_db_dir: node_db_dir,
         node_socket: node_socket,
-        network: network
+        network: network,
+        session_name: session_name
       }
     end
 
-    # @param configuration [Hash] output of prepare_configuration
-    def self.start_node(configuration)
+    # @param configuration [Hash] output of setup
+    # @raise CardanoUp::SessionHasNodeError
+    # @raise CardanoUp::SessionHasWalletError
+    def self.node_up(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]
+      session_name = configuration[:session_name]
 
       exe = CardanoUp::Utils.win? ? '.exe' : ''
-      version = CardanoUp::Utils.cmd "#{bin_dir}/cardano-node#{exe} version"
-
+      cardano_node = "#{File.join(bin_dir, 'cardano-node')}#{exe}"
+      version = CardanoUp::Utils.cmd "#{cardano_node} version"
+      node_cmd = ["#{cardano_node} run",
+                  "--config #{File.join(config_dir, 'config.json')}",
+                  "--topology #{File.join(config_dir, 'topology.json')}",
+                  "--database-path #{node_db_dir}",
+                  "--socket-path #{node_socket}"].join(' ')
+      node_service = if CardanoUp::Utils.win?
+                       "cardano-node-#{env}-#{session_name}"
+                     else
+                       "NODE_#{env}_#{session_name}"
+                     end
+      logfile = File.join(log_dir, 'node.log')
+      service_details = {
+        network: env,
+        node: {
+          service: node_service,
+          version: version,
+          log: logfile,
+          db_dir: node_db_dir,
+          socket_path: node_socket,
+          protocol_magic: get_protocol_magic(config_dir),
+          bin: node_cmd.split.first,
+          cmd: node_cmd
+        }
+      }
+      CardanoUp::Session.create_or_update(session_name, service_details)
       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)
+        config_win = CardanoUp::Utils.from_json("#{config_dir}/config.json")
+        config_win[:EnableP2P] = false
+        CardanoUp::Utils.to_json("#{config_dir}/config.json", config_win)
+        topology = {
+          Producers: [
+            {
+              addr: "#{env}-node.world.dev.cardano.org",
+              port: 30_002,
+              valency: 2
+            }
+          ]
+        }
+        CardanoUp::Utils.to_json("#{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"
+        log_stdout_node = "nssm set #{node_service} AppStdout #{logfile}"
+        log_stderr_node = "nssm set #{node_service} AppStderr #{logfile}"
         start_node = "nssm start #{node_service}"
 
         CardanoUp::Utils.cmd install_node
@@ -113,32 +139,18 @@ module CardanoUp
         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}"
+        screen_cmd = "screen -dmS #{node_service} -L -Logfile #{logfile} #{node_cmd}"
+        CardanoUp::Utils.cmd screen_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
-        }
-      }
+      service_details
     end
 
-    # @param configuration [Hash] output of prepare_configuration
-    def self.start_wallet(configuration)
+    # @param configuration [Hash] output of setup
+    def self.wallet_up(configuration)
+      if CardanoUp::Utils.port_used?(configuration[:wallet_port].to_i)
+        raise CardanoUp::WalletPortUsedError, configuration[:wallet_port]
+      end
+
       env = configuration[:env]
       wallet_port = configuration[:wallet_port]
       token_metadata_server = configuration[:token_metadata_server]
@@ -147,24 +159,44 @@ module CardanoUp
       wallet_db_dir = configuration[:wallet_db_dir]
       node_socket = configuration[:node_socket]
       network = configuration[:network]
+      session_name = configuration[:session_name]
 
       exe = CardanoUp::Utils.win? ? '.exe' : ''
+      cardano_wallet = "#{File.join(bin_dir, 'cardano-wallet')}#{exe}"
+      wallet_cmd = ["#{cardano_wallet} serve",
+                    "--port #{wallet_port}",
+                    "--node-socket #{node_socket}",
+                    network.to_s,
+                    "--database #{wallet_db_dir}",
+                    "--token-metadata-server #{token_metadata_server}"].join(' ')
       version = CardanoUp::Utils.cmd "#{bin_dir}/cardano-wallet#{exe} version"
+      wallet_service = if CardanoUp::Utils.win?
+                         "cardano-wallet-#{env}-#{session_name}"
+                       else
+                         "WALLET_#{env}_#{session_name}"
+                       end
+      logfile = File.join(log_dir, 'wallet.log')
+      service_details = {
+        network: env,
+        wallet: {
+          service: wallet_service,
+          version: version,
+          log: logfile,
+          db_dir: wallet_db_dir,
+          port: wallet_port.to_i,
+          url: "http://localhost:#{wallet_port}/v2",
+          bin: wallet_cmd.split.first,
+          cmd: wallet_cmd
+        }
+      }
 
+      CardanoUp::Session.create_or_update(session_name, service_details)
       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"
+        log_stdout_wallet = "nssm set #{wallet_service} AppStdout #{logfile}"
+        log_stderr_wallet = "nssm set #{wallet_service} AppStderr #{logfile}"
         start_wallet = "nssm start #{wallet_service}"
 
         CardanoUp::Utils.cmd install_wallet
@@ -172,75 +204,45 @@ module CardanoUp
         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}"
+        CardanoUp::Utils.cmd "screen -dmS #{wallet_service} -L -Logfile #{logfile} #{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)
+      service_details
     end
 
     # @raise CardanoUp::EnvNotSupportedError
-    def self.stop_node(env)
+    def self.node_down(env, session_name = '0')
       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"
+        CardanoUp::Utils.cmd "nssm stop cardano-node-#{env}-#{session_name}"
+        CardanoUp::Utils.cmd "nssm remove cardano-node-#{env}-#{session_name} confirm"
       else
-        CardanoUp::Utils.cmd "screen -S NODE_#{env} -X at '0' stuff '^C'"
-        CardanoUp::Utils.cmd "screen -XS NODE_#{env} quit"
+        CardanoUp::Utils.cmd "screen -S NODE_#{env}_#{session_name} -X at '0' stuff '^C'"
+        CardanoUp::Utils.cmd "screen -XS NODE_#{env}_#{session_name} quit"
       end
+      CardanoUp::Session.remove(session_name, { network: env, service: 'node' })
     end
 
     # @raise CardanoUp::EnvNotSupportedError
-    def self.stop_wallet(env)
+    def self.wallet_down(env, session_name = '0')
       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"
+        CardanoUp::Utils.cmd "nssm stop cardano-wallet-#{env}-#{session_name}"
+        CardanoUp::Utils.cmd "nssm remove cardano-wallet-#{env}-#{session_name} confirm"
       else
-        CardanoUp::Utils.cmd "screen -S WALLET_#{env} -X at '0' stuff '^C'"
-        CardanoUp::Utils.cmd "screen -XS WALLET_#{env} quit"
+        CardanoUp::Utils.cmd "screen -S WALLET_#{env}_#{session_name} -X at '0' stuff '^C'"
+        CardanoUp::Utils.cmd "screen -XS WALLET_#{env}_#{session_name} quit"
       end
-    end
-
-    # @raise CardanoUp::EnvNotSupportedError
-    def self.stop_node_and_wallet(env)
-      stop_wallet(env)
-      stop_node(env)
+      CardanoUp::Session.remove(session_name, { network: env, service: 'wallet' })
     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
+      byron_genesis = CardanoUp::Utils.from_json(File.join(config, 'byron-genesis.json'))
+      byron_genesis[:protocolConsts][:protocolMagic].to_i
     end
     module_function :get_protocol_magic
     private_class_method :get_protocol_magic

data/lib/cardano-up/ping.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module CardanoUp
+  # Check status (ping) of running node and wallet services
+  module Ping
+    # @param session_name [String]
+    # @param env [String]
+    # @raise CardanoUp::EnvNotSupportedError
+    # @raise CardanoUp::SessionNotExistsError
+    # @raise CardanoUp::SessionServiceNotUpError
+    # @raise CardanoUp::SessionEnvNotUpError
+    def self.wallet(session_name, env)
+      CardanoUp::Configs.exist?(env)
+      CardanoUp::Session.network_or_raise?(session_name, env.to_sym)
+      CardanoUp::Session.wallet_or_raise?(session_name, env.to_sym)
+      session = CardanoUp::Session.get(session_name)
+
+      url = session[env.to_sym][:wallet][:url]
+      r = HTTParty.get("#{url}/network/information")
+      [r.parsed_response, r.code]
+    end
+
+    # @param session_name [String]
+    # @param env [String]
+    # @raise CardanoUp::EnvNotSupportedError
+    # @raise CardanoUp::SessionNotExistsError
+    # @raise CardanoUp::SessionServiceNotUpError
+    # @raise CardanoUp::SessionEnvNotUpError
+    def self.node(session_name, env)
+      CardanoUp::Configs.exist?(env)
+      CardanoUp::Session.network_or_raise?(session_name, env.to_sym)
+      CardanoUp::Session.node_or_raise?(session_name, env.to_sym)
+      session = CardanoUp::Session.get(session_name)
+      bin_dir = CardanoUp.config[:bin_dir]
+
+      ENV['CARDANO_NODE_SOCKET_PATH'] = session[env.to_sym][:node][:socket_path]
+      protocol_magic = session[env.to_sym][:node][:protocol_magic]
+      network_arg = env == 'mainnet' ? '--mainnet' : "--testnet-magic #{protocol_magic}"
+      exe = CardanoUp::Utils.win? ? '.exe' : ''
+      cmd = "#{File.join(bin_dir, 'cardano-cli')}#{exe} query tip #{network_arg}"
+      res = CardanoUp::Utils.cmd cmd
+      begin
+        r = JSON.parse(res)
+        c = 200
+      rescue JSON::ParserError
+        r = 'Not responding.'
+        c = 404
+      end
+      [r, c]
+    end
+  end
+end

data/lib/cardano-up/session.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module CardanoUp
+  # Basic sessions management
+  module Session
+    # Check session file exists
+    def self.exists?(session_name)
+      CardanoUp.configure_default unless CardanoUp.configured?
+      File.exist?(session_file_path(session_name))
+    end
+
+    # get session contents
+    def self.get(session_name)
+      raise CardanoUp::SessionNotExistsError, session_name unless exists?(session_name)
+
+      CardanoUp.configure_default unless CardanoUp.configured?
+      session = session_file_path(session_name)
+      CardanoUp::Utils.from_json(session)
+    end
+
+    def self.destroy!(session_name)
+      path = session_file_path(session_name)
+      FileUtils.rm_f(path)
+    end
+
+    def self.destroy_all!
+      list_all.each do |path|
+        FileUtils.rm_f(path)
+      end
+    end
+
+    def self.list_all
+      Dir[File.join(CardanoUp.base_dir, '.session*')]
+    end
+
+    # create or update session with details of launched service
+    # @param session_name [String] session name
+    # @param service_details [Hash] service details
+    # @raise ArgumentError
+    # @raise CardanoUp::SessionHasNodeError
+    # @raise CardanoUp::SessionHasWalletError
+    def self.create_or_update(session_name, service_details)
+      raise ArgumentError, 'service_details should be Hash' unless service_details.is_a?(Hash)
+      raise ArgumentError, 'service_details shoud have :network' if service_details[:network].nil?
+
+      service_network = service_details[:network].to_sym || :unknown
+
+      if !exists?(session_name) || empty?(session_name)
+        # if session is not set then just create new with just service_details
+        content = { service_network => service_details }
+        put_content(session_name, content)
+      elsif !network?(session_name, service_network)
+        # if session exists but has no network, add new network
+        existing_services = get(session_name)
+        new_service = { service_network => service_details }
+        put_content(session_name, existing_services.merge(new_service))
+      else
+        # if session has network and node already, you can add only wallet
+        if service_details.key?(:node) && node?(session_name, service_network)
+          raise CardanoUp::SessionHasNodeError.new(session_name, service_network)
+        end
+
+        # if session has network and wallet already, you can add only node
+        if service_details.key?(:wallet) && wallet?(session_name, service_network)
+          raise CardanoUp::SessionHasWalletError.new(session_name,
+                                                     service_network)
+        end
+
+        existing_services = get(session_name)
+        updated_network = existing_services[service_network].merge(service_details)
+        existing_services[service_network] = updated_network
+        put_content(session_name, existing_services)
+      end
+    end
+
+    def self.node_or_raise?(session_name, env)
+      raise CardanoUp::SessionServiceNotUpError.new(session_name, env, :node) unless node?(session_name, env)
+
+      true
+    end
+
+    def self.wallet_or_raise?(session_name, env)
+      raise CardanoUp::SessionServiceNotUpError.new(session_name, env, :wallet) unless wallet?(session_name, env)
+
+      true
+    end
+
+    def self.network_or_raise?(session_name, env)
+      raise CardanoUp::SessionEnvNotUpError.new(session_name, env) unless network?(session_name, env)
+
+      true
+    end
+
+    # remove entry from session
+    # @param session_name [String] session name
+    # @param service_details [Hash] service details ({ network: 'preprod', service: 'wallet' })
+    def self.remove(session_name, service_details)
+      existing_services = get(session_name)
+      service = service_details[:service].to_sym
+      network = service_details[:network].to_sym
+      if existing_services && existing_services[network]
+        existing_services[network].delete(service)
+
+        unless existing_services[network].key?(:node) || existing_services[network].key?(:wallet)
+          existing_services.delete(network)
+        end
+        put_content(session_name, existing_services)
+      end
+
+      destroy!(session_name) if empty?(session_name)
+    end
+
+    def session_file_path(session_name)
+      File.join(CardanoUp.base_dir, ".session-#{session_name}.json")
+    end
+    module_function :session_file_path
+    private_class_method :session_file_path
+
+    def put_content(session_name, contents)
+      raise ArgumentError, 'contents should be Hash' unless contents.is_a?(Hash)
+
+      path = session_file_path(session_name)
+      File.write(path, JSON.pretty_generate(contents))
+      path
+    end
+    module_function :put_content
+    private_class_method :put_content
+
+    def empty?(session_name)
+      get(session_name) == {}
+    end
+    module_function :empty?
+    private_class_method :empty?
+
+    def network?(session_name, env)
+      get(session_name).key?(env.to_sym)
+    end
+    module_function :network?
+    private_class_method :network?
+
+    def node?(session_name, env)
+      get(session_name)[env.to_sym].key?(:node)
+    end
+    module_function :node?
+    private_class_method :node?
+
+    def wallet?(session_name, env)
+      get(session_name)[env.to_sym].key?(:wallet)
+    end
+    module_function :wallet?
+    private_class_method :wallet?
+  end
+end

data/lib/cardano-up/utils.rb

@@ -8,7 +8,7 @@ module CardanoUp
       res = `#{cmd}`
       puts cmd if display_result
       puts res if display_result
-      res.gsub("\n", '')
+      res.gsub("\n", ' ').strip
     end
 
     def self.wget(url, file = nil)
@@ -17,6 +17,31 @@ module CardanoUp
       File.binwrite(file, resp.body)
     end
 
+    # Check if port is already used
+    def self.port_used?(port)
+      begin
+        Timeout.timeout(1) do
+          s = TCPSocket.new('localhost', port)
+          s.close
+          return true
+        rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH
+          return false
+        end
+      rescue Timeout::Error
+        # do nothing
+      end
+
+      false
+    end
+
+    def self.from_json(file)
+      JSON.parse(File.read(file), { symbolize_names: true })
+    end
+
+    def self.to_json(file, hash)
+      File.write(file, JSON.pretty_generate(hash))
+    end
+
     def self.win?
       RUBY_PLATFORM =~ /cygwin|mswin|mingw|bccwin|wince|emx/
     end

data/lib/cardano-up/version.rb

@@ -2,5 +2,5 @@
 
 # Version
 module CardanoUp
-  VERSION ||= '0.1.1'
+  VERSION ||= '0.1.2'
 end

data/lib/cardano-up.rb

@@ -8,13 +8,18 @@ require 'file-tail'
 require 'json'
 require 'zlib'
 require 'zip'
+require 'socket'
+require 'timeout'
 
 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/bins'
+require 'cardano-up/configs'
+require 'cardano-up/launcher'
+require 'cardano-up/session'
+require 'cardano-up/ping'
 require 'cardano-up/tail'
 
 # Cardano Up!
@@ -74,24 +79,24 @@ module CardanoUp
     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') }
+          { 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))
+    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
+    CardanoUp::Utils.to_json(@cardano_up_config, c)
+    CardanoUp::Utils.from_json(@cardano_up_config)
   end
 
   # Get config values
   def self.config
     raise CardanoUp::ConfigNotSetError unless configured?
 
-    JSON.parse(File.read(@cardano_up_config))
+    CardanoUp::Utils.from_json(@cardano_up_config)
   end
 
   # Remove configuration file