stellar_core_commander 0.0.11 → 0.0.12

data/lib/stellar_core_commander/convert.rb

@@ -21,10 +21,6 @@ module StellarCoreCommander
       Base64.strict_decode64(base64_string)
     end
 
-    def base58
-      Stellar::Util::Base58.stellar
-    end
-
     extend self
   end
-end
+end

data/lib/stellar_core_commander/docker_process.rb

@@ -1,4 +1,5 @@
 require 'uri'
+require 'set'
 require 'securerandom'
 
 module StellarCoreCommander
@@ -6,15 +7,41 @@ module StellarCoreCommander
   class DockerProcess < Process
     include Contracts
 
+    attr_reader :docker_core_image
+    attr_reader :docker_state_image
+
+    Contract({
+      docker_state_image: String,
+      docker_core_image:  String,
+      docker_pull: Bool
+    } => Any)
+    def initialize(params)
+      @docker_state_image = params[:docker_state_image]
+      @docker_core_image  = params[:docker_core_image]
+      @docker_pull  = params[:docker_pull]
+      super
+    end
+
     Contract None => Num
     def required_ports
       3
     end
 
+    Contract None => Any
+    def launch_heka_container
+      $stderr.puts "launching heka container #{heka_container_name}"
+      docker %W(run
+        --name #{heka_container_name}
+        --net container:#{container_name}
+        --volumes-from #{container_name}
+        -d stellar/heka
+      )
+    end
+
     Contract None => Any
     def launch_state_container
-      $stderr.puts "launching state container #{state_container_name}"
-      docker %W(run --name #{state_container_name} -p #{postgres_port}:5432 --env-file stellar-core.env -d stellar/stellar-core-state)
+      $stderr.puts "launching state container #{state_container_name} from image #{docker_state_image}"
+      docker %W(run --name #{state_container_name} -p #{postgres_port}:5432 --env-file stellar-core.env -d #{docker_state_image})
       raise "Could not create state container" unless $?.success?
     end
 
@@ -25,6 +52,13 @@ module StellarCoreCommander
       raise "Could not drop db: #{database_name}" unless $?.success?
     end
 
+    Contract None => Any
+    def shutdown_heka_container
+      return true unless heka_container_running?
+      docker %W(rm -f -v #{heka_container_name})
+      raise "Could not stop heka container: #{heka_container_name}" unless $?.success?
+    end
+
     Contract None => Any
     def write_config
       IO.write("#{working_dir}/stellar-core.env", config)
@@ -35,66 +69,75 @@ module StellarCoreCommander
       write_config
     end
 
-    Contract None => nil
-    def run
-      raise "already running!" if running?
-      setup
+    Contract None => Any
+    def launch_process
       launch_state_container
       launch_stellar_core
+      launch_heka_container if atlas
     end
 
     Contract None => Bool
     def running?
-      docker %W(inspect #{container_name})
-      $?.success?
+      container_running? container_name
+    end
+
+    Contract None => Bool
+    def heka_container_running?
+      container_running? heka_container_name
     end
 
     Contract None => Bool
     def state_container_running?
-      docker %W(inspect #{state_container_name})
-      $?.success?
+      container_running? state_container_name
     end
 
     Contract None => Any
     def shutdown
       return true unless running?
+      docker %W(stop #{container_name})
+      docker %W(exec #{container_name} rm -rf /history)
       docker %W(rm -f #{container_name})
     end
 
     Contract None => Any
     def cleanup
       database.disconnect
+      dump_database
+      dump_logs
+      dump_cores
+      dump_scp_state
+      dump_info
+      dump_metrics
       shutdown
       shutdown_state_container
-      rm_working_dir
+      shutdown_heka_container if atlas
     end
 
     Contract None => Any
-    def dump_database
-      Dir.chdir(working_dir) do
-        host_args = "-H tcp://#{docker_host}:#{docker_port}" if host
-        `docker #{host_args} exec #{state_container_name} pg_dump -U #{database_user} --clean --no-owner #{database_name}`
-      end
-    end
-
-    Contract None => Sequel::Database
-    def database
-      @database ||= Sequel.postgres(database_name, host: docker_host, port: postgres_port, user: database_user, password: database_password)
+    def dump_logs
+      docker ["logs", container_name]
     end
 
-    Contract None => String
-    def database_name
-      "stellar"
+    Contract None => Any
+    def dump_cores
+      docker %W(run --volumes-from #{container_name} --rm -e MODE=local #{docker_core_image} /utils/core_file_processor.py)
+      docker %W(cp #{container_name}:/cores .)
     end
 
-    Contract None => String
-    def database_user
-      "postgres"
+    Contract None => Any
+    def dump_database
+      fname = "#{working_dir}/database-#{Time.now.to_i}-#{rand 100000}.sql"
+      $stderr.puts "dumping database to #{fname}"
+      host_args = "-H tcp://#{docker_host}:#{docker_port}" if host
+      sql = `docker #{host_args} exec #{state_container_name} pg_dump -U #{database_user} --clean --no-owner --no-privileges #{database_name}`
+      File.open(fname, 'w') {|f| f.write(sql) }
+      fname
     end
 
     Contract None => String
-    def database_password
+    def default_database_url
       @database_password ||= SecureRandom.hex
+      "postgres://postgres:#{@database_password}@#{docker_host}:#{postgres_port}/stellar"
     end
 
     Contract None => Num
@@ -112,6 +155,11 @@ module StellarCoreCommander
       "scc-state-#{idname}"
     end
 
+    Contract None => String
+    def heka_container_name
+      "scc-heka-#{idname}"
+    end
+
     Contract None => String
     def docker_host
       return host if host
@@ -124,44 +172,167 @@ module StellarCoreCommander
       docker_host
     end
 
+    Contract None => Bool
+    def docker_pull?
+      @docker_pull
+    end
+
+    Contract None => ArrayOf[String]
+    def aws_credentials_volume
+      if use_s3 and File.exists?("#{ENV['HOME']}/.aws")
+        ["-v", "#{ENV['HOME']}/.aws:/root/.aws:ro"]
+      else
+        []
+      end
+    end
+
+    Contract None => Bool
+    def use_s3
+      if @use_s3
+        true
+      else
+        if host and (@quorum.size > 1)
+          $stderr.puts "WARNING: multi-peer with remote docker host, but no s3; history will not be shared"
+        end
+        false
+      end
+    end
+
+    Contract None => ArrayOf[String]
+    def shared_history_volume
+      if use_s3
+        []
+      else
+        dir = File.expand_path("#{working_dir}/../history-archives")
+        Dir.mkdir(dir) unless File.exists?(dir)
+        ["-v", "#{dir}:/history"]
+      end
+    end
+
+    Contract None => String
+    def history_get_command
+      cmds = Set.new
+      localget = "cp /history/%s/{0} {1}"
+      s3get = "aws s3 --region #{@s3_history_region} cp #{@s3_history_prefix}/%s/{0} {1}"
+      @quorum.each do |q|
+        if q == @name
+          next
+        end
+        if SPECIAL_PEERS.has_key? q
+          cmds.add SPECIAL_PEERS[q][:get]
+        elsif use_s3
+          cmds.add s3get
+        else
+          cmds.add localget
+        end
+      end
+
+      if cmds.size == 0
+        if use_s3
+          cmds.add s3get
+        else
+          cmds.add localget
+        end
+      end
+
+      if cmds.size != 1
+        raise "Conflicting get commands: #{cmds.to_a.inspect}"
+      end
+      <<-EOS.strip_heredoc
+        HISTORY_GET=#{cmds.to_a.first}
+      EOS
+    end
+
+    Contract None => String
+    def history_put_commands
+      if has_special_peers?
+        ""
+      else
+        if use_s3
+          <<-EOS.strip_heredoc
+            HISTORY_PUT=aws s3 --region #{@s3_history_region} cp {0} #{@s3_history_prefix}/%s/{1}
+          EOS
+        else
+          <<-EOS.strip_heredoc
+            HISTORY_PUT=cp {0} /history/%s/{1}
+            HISTORY_MKDIR=mkdir -p /history/%s/{0}
+          EOS
+        end
+      end
+    end
+
+    def prepare
+      $stderr.puts "preparing #{idname} (dir:#{working_dir})"
+      return unless docker_pull?
+      docker %W(pull #{docker_state_image})
+      docker %W(pull #{docker_core_image})
+      docker %W(pull stellar/heka)
+    end
+
+    def crash
+      docker %W(exec #{container_name} pkill -ABRT stellar-core)
+    end
+
     private
     def launch_stellar_core
       $stderr.puts "launching stellar-core container #{container_name}"
-      docker %W(run
+      docker (%W(run
                            --name #{container_name}
                            --net host
                            --volumes-from #{state_container_name}
+               ) + aws_credentials_volume + shared_history_volume + %W(
                            --env-file stellar-core.env
-                           -d stellar/stellar-core
-                           /run main fresh forcescp
-                        )
+                           -d #{docker_core_image}
+                           /start #{@name} fresh #{"forcescp" if @forcescp}
+               ))
       raise "Could not create stellar-core container" unless $?.success?
     end
 
     Contract None => String
     def config
+      (
       <<-EOS.strip_heredoc
         POSTGRES_PASSWORD=#{database_password}
 
-        main_POSTGRES_PORT=#{postgres_port}
-        main_PEER_PORT=#{peer_port}
-        main_HTTP_PORT=#{http_port}
-        main_PEER_SEED=#{identity.seed}
-        main_VALIDATION_SEED=#{identity.seed}
+        ENVIRONMENT=scc
+        CLUSTER_NAME=#{recipe_name}
+        HOSTNAME=#{idname}
+
+        #{@name}_POSTGRES_PORT=#{postgres_port}
+        #{@name}_PEER_PORT=#{peer_port}
+        #{@name}_HTTP_PORT=#{http_port}
+        #{@name}_PEER_SEED=#{identity.seed}
+        #{"#{@name}_VALIDATION_SEED=#{identity.seed}" if @validate}
 
         #{"MANUAL_CLOSE=true" if manual_close?}
 
-        QUORUM_THRESHOLD=#{threshold}
+        ARTIFICIALLY_GENERATE_LOAD_FOR_TESTING=true
+        #{"ARTIFICIALLY_ACCELERATE_TIME_FOR_TESTING=true" if @accelerate_time}
+        #{"CATCHUP_COMPLETE=true" if @catchup_complete}
 
-        PREFERRED_PEERS=#{peers}
-        QUORUM_SET=#{quorum}
+        #{"ATLAS_ADDRESS=" + atlas if atlas}
 
-        HISTORY_PEERS=["main"]
+        METRICS_INTERVAL=#{atlas_interval}
 
-        HISTORY_GET=cp history/%s/{0} {1}
-        HISTORY_PUT=cp {0} history/%s/{1}
-        HISTORY_MKDIR=mkdir -p history/%s/{0}
+        #{"COMMANDS=[\"ll?level=debug\"]" if @debug}
+
+        FAILURE_SAFETY=0
+        UNSAFE_QUORUM=true
+
+        PREFERRED_PEERS=#{peer_connections}
+        VALIDATORS=#{quorum}
+
+        HISTORY_PEERS=#{peer_names}
+
+        NETWORK_PASSPHRASE="#{network_passphrase}"
       EOS
+      ) + history_get_command + history_put_commands
+    end
+
+    def recipe_name
+      File.basename($opts[:recipe], '.rb')
+    rescue TypeError
+      'recipe_name_not_found'
     end
 
     def docker_port
@@ -183,5 +354,10 @@ module StellarCoreCommander
     def docker(args)
       run_cmd "docker", docker_args + args
     end
+
+    def container_running?(name)
+      docker ['inspect', '-f', '{{.Name}} running: {{.State.Running}}', name]
+      $?.success?
+    end
   end
 end

data/lib/stellar_core_commander/local_process.rb

@@ -4,12 +4,15 @@ module StellarCoreCommander
     include Contracts
 
     attr_reader :pid
-    attr_reader :wait
 
     def initialize(params)
+      raise "`host` param is unsupported on LocalProcess, please use `-p docker` for this recipe." if params[:host]
+      $stderr.puts "Warning: Ignoring `atlas` param since LocalProcess doesn't support this." if params[:atlas]
+
       super
       @stellar_core_bin = params[:stellar_core_bin]
-      raise "`host` param is unsupported on LocalProcess, please use `-p docker` for this recipe." if params[:host]
+      @database_url     = params[:database].try(:strip)
+
       setup_working_dir
     end
 
@@ -21,7 +24,8 @@ module StellarCoreCommander
 
     Contract None => Any
     def initialize_history
-      run_cmd "./stellar-core", ["--newhist", "main"]
+      Dir.mkdir(history_dir) unless File.exists?(history_dir)
+      run_cmd "./stellar-core", ["--newhist", @name.to_s]
       raise "Could not initialize history" unless $?.success?
     end
 
@@ -48,19 +52,22 @@ module StellarCoreCommander
       IO.write("#{@working_dir}/stellar-core.cfg", config)
     end
 
+    Contract None => String
+    def history_dir
+      File.expand_path("#{working_dir}/../history-archives")
+    end
+
     Contract None => Any
     def setup
       write_config
-      create_database
+      create_database unless @keep_database
       initialize_history
       initialize_database
     end
 
     Contract None => Num
-    def run
-      raise "already running!" if running?
-      setup
-      forcescp
+    def launch_process
+      forcescp if @forcescp
       launch_stellar_core
     end
 
@@ -84,52 +91,50 @@ module StellarCoreCommander
         ::Process.kill "KILL", @pid
       end
 
-      @wait.value.success?
+      @wait_value == 0
     end
 
     Contract None => Any
     def cleanup
       database.disconnect
+      dump_database
+      dump_scp_state
+      dump_info
+      dump_metrics
       shutdown
-      drop_database
-      rm_working_dir
+      drop_database unless @keep_database
     end
 
     Contract None => Any
     def dump_database
-      Dir.chdir(@working_dir) do
-        `pg_dump #{database_name} --clean --no-owner`
-      end
-    end
-
-
-    Contract None => Sequel::Database
-    def database
-      @database ||= Sequel.postgres(database_name)
+      fname = "#{working_dir}/database-#{Time.now.to_i}-#{rand 100000}.sql"
+      $stderr.puts "dumping database to #{fname}"
+      sql = `pg_dump #{database_name} --clean --no-owner --no-privileges`
+      File.open(fname, 'w') {|f| f.write(sql) }
+      fname
     end
 
     Contract None => String
-    def database_name
-      "stellar_core_tmp_#{idname}"
+    def default_database_url
+      "postgres:///#{idname}"
     end
 
-    Contract None => String
-    def dsn
-      "postgresql://dbname=#{database_name}"
+    def crash
+      `kill -ABRT #{@pid}`
     end
 
     private
     def launch_stellar_core
       Dir.chdir @working_dir do
-        sin, sout, serr, wait = Open3.popen3("./stellar-core")
-
-        # throwaway stdout, stderr (the logs will record any output)
-        Thread.new{ until (line = sout.gets).nil? ; end }
-        Thread.new{ until (line = serr.gets).nil? ; end }
-
-        @wait = wait
-        @pid = wait.pid
+        @pid = ::Process.spawn("./stellar-core",
+                               :out => "stdout.txt",
+                               :err => "stderr.txt")
+        @wait = Thread.new {
+          @wait_value = ::Process.wait(@pid);
+          $stderr.puts "stellar-core process exited: #{@wait_value}"
+        }
       end
+      @pid
     end
 
     Contract None => String
@@ -139,25 +144,61 @@ module StellarCoreCommander
         RUN_STANDALONE=false
         HTTP_PORT=#{http_port}
         PUBLIC_HTTP_PORT=false
-        PEER_SEED="#{@identity.seed}"
-        VALIDATION_SEED="#{@identity.seed}"
+        NODE_SEED="#{@identity.seed}"
+        #{"NODE_IS_VALIDATOR=true" if @validate}
+
+        ARTIFICIALLY_GENERATE_LOAD_FOR_TESTING=true
+        #{"ARTIFICIALLY_ACCELERATE_TIME_FOR_TESTING=true" if @accelerate_time}
+        #{"CATCHUP_COMPLETE=true" if @catchup_complete}
 
         DATABASE="#{dsn}"
-        PREFERRED_PEERS=#{peers}
+        PREFERRED_PEERS=#{peer_connections}
 
         #{"MANUAL_CLOSE=true" if manual_close?}
+        #{"COMMANDS=[\"ll?level=debug\"]" if @debug}
+
+        FAILURE_SAFETY=0
+        UNSAFE_QUORUM=true
+
+        NETWORK_PASSPHRASE="#{network_passphrase}"
 
         [QUORUM_SET]
-        THRESHOLD=#{threshold}
         VALIDATORS=#{quorum}
 
-        [HISTORY.main]
-        get="cp history/main/{0} {1}"
-        put="cp {0} history/main/{1}"
-        mkdir="mkdir -p history/main/{0}"
+        #{history_sources}
       EOS
     end
 
+    Contract Symbol => String
+    def one_history_source(n)
+      dir = "#{history_dir}/#{n}"
+      if n == @name
+        <<-EOS.strip_heredoc
+          [HISTORY.#{n}]
+          get="cp #{dir}/{0} {1}"
+          put="cp {0} #{dir}/{1}"
+          mkdir="mkdir -p #{dir}/{0}"
+        EOS
+      else
+        name = n.to_s
+        get = "cp #{history_dir}/%s/{0} {1}"
+        if SPECIAL_PEERS.has_key? n
+          name = SPECIAL_PEERS[n][:name]
+          get = SPECIAL_PEERS[n][:get]
+        end
+        get.sub!('%s', name)
+        <<-EOS.strip_heredoc
+          [HISTORY.#{name}]
+          get="#{get}"
+        EOS
+      end
+    end
+
+    Contract None => String
+    def history_sources
+      @quorum.map {|n| one_history_source n}.join("\n")
+    end
+
     def setup_working_dir
       if @stellar_core_bin.blank?
         search = `which stellar-core`.strip