stellar_core_commander 0.0.8 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2d1cd8f2aeaf80f4c957fa062d63449ff0d36dfd
-  data.tar.gz: 257c977e5fa0b37615448040ebcb42fd77cae408
+  metadata.gz: 6ec23f9e827ebf793af1412a68847a9f37ff9278
+  data.tar.gz: 9e2d0a36edb3093e4384067225d95c03341cca8f
 SHA512:
-  metadata.gz: 690851008b629b2ece84d06e27cac23a4f794b66383686335983491858e35f3d1634f60f25452dc4a50a483ceba2f14ca7206db291c3ca890013362cefec53e5
-  data.tar.gz: 8321aaa93507ce629edc802adbbc203a5b69248b610fe223144910a267c6edc12db9c5c2d373acb24e9d02928223ab56d76ffd8554c42d9f4a7dca0d53de078e
+  metadata.gz: 2cd2365fb8291e0307c29b5283eb0537950e6bab08ed69999cb4fc9c5f66c14b17d0758aabf37b5467eef99778afb3b8915e0bb6bcef533e6611ca376cdf78ab
+  data.tar.gz: f1c4810b80c622b188c7f936a45dc2db4ecd98e2a1e71103f6cd525293720144481ef49198bda1c0ebe42a3f6f5152d6784960c0a22558d1a5d11b4015ccd0c4

data/bin/scc

@@ -6,41 +6,33 @@ require 'slop'
 def run
   $opts = Slop.parse do
     banner 'Usage: scc -r RECIPE'
-    
-    on 'stellar-core-bin', 'a path to a stellar-core executable (default to `which stellar-core`)', argument: true
+
+    on 'stellar-core-bin', 'a path to a stellar-core executable (defaults to `which stellar-core`)', argument: true
+
     on 'r', 'recipe', 'a recipe file', argument: true #, required: true
+    on 'p', 'process', 'method for running stellar-core', argument: true, default: 'local'
   end
 
   recipe    = load_recipe
   commander = make_commander
-  process   = commander.make_process
 
   #run recipe
-  transactor = StellarCoreCommander::Transactor.new(process)
-  process.run
-  process.wait_for_ready
+  transactor = StellarCoreCommander::Transactor.new(commander)
+
+
   transactor.run_recipe recipe
   transactor.close_ledger
 
-  output_results(process)
+  output_results(transactor.get_process(:process))
 end
 
 
 def make_commander
-  stellar_core_bin = $opts[:"stellar-core-bin"]
+  opts = {
+    stellar_core_bin: $opts[:"stellar-core-bin"],
+  }
 
-  if stellar_core_bin.blank?
-    search = `which stellar-core`.strip
-
-    if $?.success?
-      stellar_core_bin = search
-    else
-      $stderr.puts "Could not find a `stellar-core` binary, please use --stellar-core-bin to specify"
-      exit 1
-    end
-  end
-
-  StellarCoreCommander::Commander.new(stellar_core_bin).tap do |c|
+  StellarCoreCommander::Commander.new($opts[:"process"], opts).tap do |c|
     c.cleanup_at_exit!
   end
 end
@@ -66,5 +58,3 @@ def output_results(process)
 end
 
 run
-
- 

data/examples/allow_trust.rb

@@ -2,9 +2,9 @@ account :usd_gateway
 account :scott
 account :andrew
 
-payment :master, :usd_gateway, [:native, 1000_000000]
-payment :master, :scott, [:native, 1000_000000]
-payment :master, :andrew, [:native, 1000_000000]
+payment :master, :usd_gateway, [:native, 1000 * Stellar::ONE]
+payment :master, :scott, [:native, 1000 * Stellar::ONE]
+payment :master, :andrew, [:native, 1000 * Stellar::ONE]
 
 close_ledger
 
@@ -18,7 +18,3 @@ trust :andrew, :usd_gateway, "USD"
 close_ledger
 
 allow_trust :usd_gateway, :scott, "USD"
-
-# close_ledger
-
-# payment :usd_gateway, :scott,  ["USD", :usd_gateway, 1000_000000]

data/examples/non_native_payment.rb

@@ -13,8 +13,8 @@ trust :andrew, :usd_gateway, "USD"
 
 close_ledger
 
-payment :usd_gateway, :scott,  ["USD", :usd_gateway, 1000_000000]
+payment :usd_gateway, :scott,  ["USD", :usd_gateway, 1000 * Stellar::ONE]
 
 close_ledger
 
-payment :scott, :andrew, ["USD", :usd_gateway, 500_000000]
+payment :scott, :andrew, ["USD", :usd_gateway, 500 * Stellar::ONE]

data/examples/pathed_payment.rb

@@ -1,17 +1,14 @@
-# DOES NOT YET WORK WITH LATEST TRANSACTION TYPES
-
 account :usd_gateway
 account :eur_gateway
 account :scott
 account :bartek
 account :andrew
 
-payment :master, :usd_gateway, [:native, 1000_000000]
-payment :master, :eur_gateway, [:native, 1000_000000]
-
-payment :master, :scott, [:native, 1000_000000]
-payment :master, :bartek, [:native, 1000_000000]
-payment :master, :andrew, [:native, 1000_000000]
+create_account :usd_gateway, :master
+create_account :eur_gateway, :master
+create_account :scott, :master
+create_account :bartek, :master
+create_account :andrew, :master
 
 close_ledger
 
@@ -22,15 +19,15 @@ trust :andrew, :eur_gateway, "EUR"
 
 close_ledger
 
-payment :usd_gateway, :scott,  ["USD", :usd_gateway, 1000_000000]
-payment :usd_gateway, :andrew, ["USD", :usd_gateway, 200_000000]
-payment :eur_gateway, :andrew, ["EUR", :eur_gateway, 200_000000]
-payment :eur_gateway, :bartek, ["EUR", :eur_gateway, 1000_000000]
+payment :usd_gateway, :scott,  ["USD", :usd_gateway, 1000 * Stellar::ONE]
+payment :usd_gateway, :andrew, ["USD", :usd_gateway, 200 * Stellar::ONE]
+payment :eur_gateway, :andrew, ["EUR", :eur_gateway, 200 * Stellar::ONE]
+payment :eur_gateway, :bartek, ["EUR", :eur_gateway, 1000 * Stellar::ONE]
 
 close_ledger
 
-offer :andrew, {buy:["USD", :usd_gateway], with:["EUR", :eur_gateway]}, 200_000000, 1.0
+offer :andrew, {buy:["USD", :usd_gateway], with:["EUR", :eur_gateway]}, 200 * Stellar::ONE, 1.0
 
 close_ledger
 
-payment :scott, :bartek, ["EUR", :eur_gateway, 10], path: [["USD", :usd_gateway]]
+payment :scott, :bartek, ["EUR", :eur_gateway, 10], with: ["USD", :usd_gateway, 10], path: []

data/examples/simple_payment.rb

@@ -2,6 +2,6 @@ account :scott
 
 create_account :scott, :master
 
-close_ledger 
+close_ledger
 
-payment :master, :scott, [:native, 1000_000000]
+payment :master, :scott, [:native, 1000 * Stellar::ONE]

data/examples/trade.rb

@@ -3,10 +3,10 @@ account :eur_gateway
 account :scott
 account :bartek
 
-create_account :usd_gateway, :master, 1000_000000
-create_account :eur_gateway, :master, 1000_000000
-create_account :scott,       :master, 1000_000000
-create_account :bartek,      :master, 1000_000000
+create_account :usd_gateway, :master, 1000 * Stellar::ONE
+create_account :eur_gateway, :master, 1000 * Stellar::ONE
+create_account :scott,       :master, 1000 * Stellar::ONE
+create_account :bartek,      :master, 1000 * Stellar::ONE
 
 close_ledger
 
@@ -17,15 +17,15 @@ trust :bartek, :eur_gateway, "EUR"
 
 close_ledger
 
-payment :usd_gateway, :scott,  ["USD", :usd_gateway, 1000_000000]
-payment :eur_gateway, :bartek, ["EUR", :eur_gateway, 1000_000000]
+payment :usd_gateway, :scott,  ["USD", :usd_gateway, 1000 * Stellar::ONE]
+payment :eur_gateway, :bartek, ["EUR", :eur_gateway, 1000 * Stellar::ONE]
 
 close_ledger
 
-offer :bartek, {buy:["USD", :usd_gateway], with:["EUR", :eur_gateway]}, 1000_000000, 1.0
+offer :bartek, {buy:["USD", :usd_gateway], with:["EUR", :eur_gateway]}, 1000 * Stellar::ONE, 1.0
 
 close_ledger
 
-offer :scott, {sell:["USD", :usd_gateway], for:["EUR", :eur_gateway]}, 500_000000, 1.0
+offer :scott, {sell:["USD", :usd_gateway], for:["EUR", :eur_gateway]}, 500 * Stellar::ONE, 1.0
 
-offer :scott, {sell:["USD", :usd_gateway], for: :native}, 500_000000, 1.0
+offer :scott, {sell:["USD", :usd_gateway], for: :native}, 500 * Stellar::ONE, 1.0

data/lib/stellar_core_commander.rb

@@ -13,7 +13,11 @@ module StellarCoreCommander
   extend ActiveSupport::Autoload
 
   autoload :Commander
+
   autoload :Process
+  autoload :LocalProcess
+  autoload :DockerProcess
+
   autoload :Transactor
   autoload :OperationBuilder
 

data/lib/stellar_core_commander/commander.rb

@@ -1,28 +1,43 @@
 require 'fileutils'
 module StellarCoreCommander
+
+  #
+  # Commander is the object that manages running stellar-core processes.  It is
+  # responsible for creating and cleaning Process objects
+  #
   class Commander
     include Contracts
 
-    # 
+    #
     # Creates a new core commander
-    # 
-    Contract String => Any
-    def initialize(stellar_core_bin)
-      @stellar_core_bin = stellar_core_bin
-      raise "no file at #{stellar_core_bin}" unless File.exist?(stellar_core_bin)
-
+    #
+    Contract Or["local", "docker"], Hash => Any
+    def initialize(process_type, process_options={})
+      @process_type = process_type
+      @process_options = process_options
       @processes = []
     end
 
     Contract None => Process
+    #
+    # make_process returns a new, unlaunched Process object, bound to a new
+    # tmpdir and 
     def make_process
       tmpdir = Dir.mktmpdir("scc")
 
       identity      = Stellar::KeyPair.random
-      base_port     = 39132 + (@processes.length * 2)
-
-      FileUtils.cp(@stellar_core_bin, "#{tmpdir}/stellar-core")
-      Process.new(tmpdir, base_port, identity).tap do |p|
+      base_port     = 39132 + @processes.map(&:required_ports).sum
+
+      process_class = case @process_type
+                        when 'local'
+                          LocalProcess
+                        when 'docker'
+                          DockerProcess
+                        else
+                          raise "Unknown process type: #{@process_type}"
+                      end
+
+      process_class.new(tmpdir, base_port, identity, @process_options).tap do |p|
         p.setup
         @processes << p
       end
@@ -40,4 +55,4 @@ module StellarCoreCommander
     end
 
   end
-end
+end

data/lib/stellar_core_commander/docker_process.rb

@@ -0,0 +1,161 @@
+require 'uri'
+require 'securerandom'
+
+module StellarCoreCommander
+
+  class DockerProcess < Process
+    include Contracts
+
+    Contract None => Num
+    def required_ports
+      3
+    end
+
+    Contract None => Any
+    def launch_state_container
+      run_cmd "docker", %W(run --name #{state_container_name} -p #{postgres_port}:5432 --env-file stellar-core.env -d stellar/stellar-core-state)
+      raise "Could not create state container" unless $?.success?
+    end
+
+    Contract None => Any
+    def shutdown_state_container
+      run_cmd "docker", %W(rm -f -v #{state_container_name})
+      raise "Could not drop db: #{database_name}" unless $?.success?
+    end
+
+    Contract None => Any
+    def write_config
+      IO.write("#{working_dir}/.pgpass", "#{docker_host}:#{postgres_port}:*:#{database_user}:#{database_password}")
+      FileUtils.chmod(0600, "#{working_dir}/.pgpass")
+      IO.write("#{working_dir}/stellar-core.env", config)
+    end
+
+    Contract None => Any
+    def setup
+      write_config
+      launch_state_container
+    end
+
+    Contract None => nil
+    def run
+      raise "already running!" if running?
+      launch_stellar_core
+    end
+
+    Contract None => Bool
+    def running?
+      run_cmd "docker", %W(inspect #{container_name})
+      $?.success?
+    end
+
+    Contract None => Any
+    def shutdown
+      return true unless running?
+      run_cmd "docker", %W(rm -f #{container_name})
+    end
+
+    Contract None => Any
+    def cleanup
+      database.disconnect
+      shutdown
+      shutdown_state_container
+      rm_working_dir
+    end
+
+    Contract None => Any
+    def dump_database
+      Dir.chdir(working_dir) do
+        `docker 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)
+    end
+
+    Contract None => String
+    def database_name
+      "stellar"
+    end
+
+    Contract None => String
+    def database_user
+      "postgres"
+    end
+
+    Contract None => String
+    def database_password
+      @database_password ||= SecureRandom.hex
+    end
+
+    Contract None => Num
+    def postgres_port
+      base_port + 2
+    end
+
+    Contract None => String
+    def container_name
+      "c#{base_port}"
+    end
+
+    Contract None => String
+    def state_container_name
+      "db#{container_name}"
+    end
+
+    Contract None => String
+    def docker_host
+      docker_uri = URI.parse(ENV['DOCKER_HOST'])
+      if docker_uri.scheme == "tcp"
+        docker_uri.host
+      else
+        "127.0.0.1"
+      end
+    end
+
+    Contract None => String
+    def http_host
+      docker_host
+    end
+
+    private
+    def launch_stellar_core
+      run_cmd "docker", %W(run
+                           --name #{container_name}
+                           --net host
+                           --volumes-from #{state_container_name}
+                           --env-file stellar-core.env
+                           -d stellar/stellar-core
+                           /run main fresh 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}
+
+        MANUAL_CLOSE=true
+
+        QUORUM_THRESHOLD=1
+
+        PREFERRED_PEERS=["127.0.0.1:#{peer_port}"]
+        QUORUM_SET=["#{identity.address}"]
+
+        HISTORY_PEERS=["main"]
+
+        HISTORY_GET=cp history/%s/{0} {1}
+        HISTORY_PUT=cp {0} history/%s/{1}
+        HISTORY_MKDIR=mkdir -p history/%s/{0}
+      EOS
+    end
+  end
+end

data/lib/stellar_core_commander/local_process.rb

@@ -0,0 +1,170 @@
+module StellarCoreCommander
+
+  class LocalProcess < Process
+    include Contracts
+
+    attr_reader :pid
+    attr_reader :wait
+
+    def initialize(working_dir, base_port, identity, opts)
+      stellar_core_bin = opts[:stellar_core_bin]
+      if stellar_core_bin.blank?
+        search = `which stellar-core`.strip
+
+        if $?.success?
+          stellar_core_bin = search
+        else
+          $stderr.puts "Could not find a `stellar-core` binary, please use --stellar-core-bin to specify"
+          exit 1
+        end
+      end
+
+      FileUtils.cp(stellar_core_bin, "#{working_dir}/stellar-core")
+      super
+    end
+
+    Contract None => Any
+    def forcescp
+      run_cmd "./stellar-core", ["--forcescp"]
+      raise "Could not set --forcescp" unless $?.success?
+    end
+
+    Contract None => Any
+    def initialize_history
+      run_cmd "./stellar-core", ["--newhist", "main"]
+      raise "Could not initialize history" unless $?.success?
+    end
+
+    Contract None => Any
+    def initialize_database
+      run_cmd "./stellar-core", ["--newdb"]
+      raise "Could not initialize db" unless $?.success?
+    end
+
+    Contract None => Any
+    def create_database
+      run_cmd "createdb", [database_name]
+      raise "Could not create db: #{database_name}" unless $?.success?
+    end
+
+    Contract None => Any
+    def drop_database
+      run_cmd "dropdb", [database_name]
+      raise "Could not drop db: #{database_name}" unless $?.success?
+    end
+
+    Contract None => Any
+    def write_config
+      IO.write("#{@working_dir}/stellar-core.cfg", config)
+    end
+
+    Contract None => Any
+    def setup
+      write_config
+      create_database
+      initialize_history
+      initialize_database
+    end
+
+    Contract None => Num
+    def run
+      raise "already running!" if running?
+
+      forcescp
+      launch_stellar_core
+    end
+
+
+    Contract None => Bool
+    def running?
+      return false unless @pid
+      ::Process.kill 0, @pid
+      true
+    rescue Errno::ESRCH
+      false
+    end
+
+    Contract Bool => Bool
+    def shutdown(graceful=true)
+      return true if !running?
+
+      if graceful
+        ::Process.kill "INT", @pid
+      else
+        ::Process.kill "KILL", @pid
+      end
+
+      @wait.value.success?
+    end
+
+    Contract None => Any
+    def cleanup
+      database.disconnect
+      shutdown
+      drop_database
+      rm_working_dir
+    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)
+    end
+
+    Contract None => String
+    def database_name
+      "stellar_core_tmp_#{basename}"
+    end
+
+    Contract None => String
+    def dsn
+      "postgresql://dbname=#{database_name}"
+    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
+      end
+    end
+
+    Contract None => String
+    def config
+      <<-EOS.strip_heredoc
+        MANUAL_CLOSE=true
+        PEER_PORT=#{peer_port}
+        RUN_STANDALONE=false
+        HTTP_PORT=#{http_port}
+        PUBLIC_HTTP_PORT=false
+        PEER_SEED="#{@identity.seed}"
+        VALIDATION_SEED="#{@identity.seed}"
+
+        DATABASE="#{dsn}"
+
+        [QUORUM_SET]
+        THRESHOLD=1
+        VALIDATORS=["#{@identity.address}"]
+
+        [HISTORY.main]
+        get="cp history/main/{0} {1}"
+        put="cp {0} history/main/{1}"
+        mkdir="mkdir -p history/main/{0}"
+      EOS
+    end
+
+  end
+end

data/lib/stellar_core_commander/operation_builder.rb

@@ -5,9 +5,12 @@ module StellarCoreCommander
 
     Currency = Or[
       [String, Symbol],
-      :native
+      :native,
+    ]
+    Amount = Or[
+      [String, Symbol, Num],
+      [:native, Num],
     ]
-    Amount = Any #TODO
 
     OfferCurrencies = Or[
       {sell:Currency, for: Currency},
@@ -19,30 +22,27 @@ module StellarCoreCommander
       @transactor = transactor
     end
 
-    Contract Symbol, Symbol, Amount, Or[{}, {path: Any}] => Any
+    Contract Symbol, Symbol, Amount, Or[{}, {path: ArrayOf[Currency], with:Amount}] => Any
     def payment(from, to, amount, options={})
       from = get_account from
       to   = get_account to
 
-      if amount.first != :native
-        amount    = [:iso4217] + amount
-        amount[2] = get_account(amount[2])
-        amount[1] = amount[1].ljust(4, "\x00")
-      end
-
       attrs = {
         account:     from,
         destination: to,
         sequence:    next_sequence(from),
-        amount:      amount,
+        amount:      normalize_amount(amount),
       }
 
-      # TODO: Fix pathed payments
-      # if options[:path]
-      #   attrs[:path] = options[:path].map{|p| make_currency p}
-      # end
+      tx =  if options[:with]
+              attrs[:with] = normalize_amount(options[:with])
+              attrs[:path] = options[:path].map{|p| make_currency p}
+              Stellar::Transaction.path_payment(attrs)
+            else
+              Stellar::Transaction.payment(attrs)
+            end
 
-      Stellar::Transaction.payment(attrs).to_envelope(from)
+      tx.to_envelope(from)
     end
 
     Contract Symbol, Symbol, Num => Any
@@ -146,10 +146,9 @@ module StellarCoreCommander
       end
 
       code, issuer = *input
-      code = code.ljust(4, "\x00")
       issuer = get_account issuer
 
-      [:iso4217, code, issuer]
+      [:alphanum, code, issuer]
     end
 
     def make_account_flags(flags=nil)
@@ -157,5 +156,15 @@ module StellarCoreCommander
       flags.map{|f| Stellar::AccountFlags.send(f)}
     end
 
+    Contract Amount => Any
+    def normalize_amount(amount)
+      return amount if amount.first == :native
+
+      amount = [:alphanum] + amount
+      amount[2] = get_account(amount[2]) # translate issuer to account
+
+      amount
+    end
+
   end
 end

data/lib/stellar_core_commander/process.rb

@@ -6,82 +6,34 @@ module StellarCoreCommander
     attr_reader :working_dir
     attr_reader :base_port
     attr_reader :identity
-    attr_reader :pid
-    attr_reader :wait
+    attr_reader :server
 
-    def initialize(working_dir, base_port, identity)
+    def initialize(working_dir, base_port, identity, opts)
       @working_dir = working_dir
       @base_port   = base_port
       @identity    = identity
 
-      @server = Faraday.new(url: "http://127.0.0.1:#{http_port}") do |conn|
+      @server = Faraday.new(url: "http://#{http_host}:#{http_port}") do |conn|
         conn.request :url_encoded
         conn.adapter Faraday.default_adapter
       end
     end
 
-    Contract None => Any
-    def forcescp
-      run_cmd "./stellar-core", ["--forcescp"]
-      raise "Could not set --forcescp" unless $?.success?
-    end
-
-    Contract None => Any
-    def initialize_history
-      run_cmd "./stellar-core", ["--newhist", "main"]
-      raise "Could not initialize history" unless $?.success?
-    end
-
-    Contract None => Any
-    def initialize_database
-      run_cmd "./stellar-core", ["--newdb"]
-      raise "Could not initialize db" unless $?.success?
-    end
-
-    Contract None => Any
-    def create_database
-      run_cmd "createdb", [database_name]
-      raise "Could not create db: #{database_name}" unless $?.success?
-    end
-
-    Contract None => Any
-    def drop_database
-      run_cmd "dropdb", [database_name]
-      raise "Could not drop db: #{database_name}" unless $?.success?
-    end
-
-    Contract None => Any
-    def write_config
-      IO.write("#{@working_dir}/stellar-core.cfg", config)
+    Contract None => Num
+    def required_ports
+      2
     end
 
     Contract None => Any
     def rm_working_dir
-      FileUtils.rm_rf @working_dir
-    end
-
-    Contract None => Any
-    def setup
-      write_config
-      create_database
-      initialize_history
-      initialize_database
+      FileUtils.rm_rf working_dir
     end
 
-    Contract None => Num
-    def run
-      raise "already running!" if running?
-
-      forcescp
-      launch_stellar_core
-    end
-
-
     Contract None => Any
     def wait_for_ready
       loop do
 
-        response = @server.get("/info") rescue false
+        response = server.get("/info") rescue false
 
         if response
           body = ActiveSupport::JSON.decode(response.body)
@@ -94,36 +46,14 @@ module StellarCoreCommander
       end
     end
 
-    Contract None => Bool
-    def running?
-      return false unless @pid
-      ::Process.kill 0, @pid
-      true
-    rescue Errno::ESRCH
-      false
-    end
-
-    Contract Bool => Bool
-    def shutdown(graceful=true)
-      return true if !running?
-
-      if graceful
-        ::Process.kill "INT", @pid
-      else
-        ::Process.kill "KILL", @pid
-      end
-
-      @wait.value.success?
-    end
-
     Contract None => Bool
     def close_ledger
       prev_ledger = latest_ledger
       next_ledger = prev_ledger + 1
 
-      @server.get("manualclose")
+      server.get("manualclose")
 
-      Timeout.timeout(5.0) do 
+      Timeout.timeout(close_timeout) do
         loop do
           current_ledger = latest_ledger
 
@@ -142,9 +72,19 @@ module StellarCoreCommander
       true
     end
 
+    Contract None => Num
+    def http_port
+      base_port
+    end
+
+    Contract None => Num
+    def peer_port
+      base_port + 1
+    end
+
     Contract String => Any
     def submit_transaction(envelope_hex)
-      response = @server.get("tx", blob: envelope_hex)
+      response = server.get("tx", blob: envelope_hex)
       body = ActiveSupport::JSON.decode(response.body)
 
       if body["status"] == "ERROR"
@@ -153,14 +93,12 @@ module StellarCoreCommander
 
     end
 
-
     Contract Stellar::KeyPair => Num
     def sequence_for(account)
       row = database[:accounts].where(:accountid => account.address).first
       row[:seqnum]
     end
 
-
     Contract None => Num
     def latest_ledger
       database[:ledgerheaders].max(:ledgerseq)
@@ -172,98 +110,33 @@ module StellarCoreCommander
       row[:txresult]
     end
 
-    Contract None => Any
-    def cleanup
-      database.disconnect
-      shutdown
-      drop_database
-      rm_working_dir
-    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)
-    end
-
     Contract None => String
-    def database_name
-      "stellar_core_tmp_#{basename}"
-    end
-
-    Contract None => String
-    def dsn
-      "postgresql://dbname=#{database_name}"
+    def http_host
+      "127.0.0.1"
     end
 
     Contract None => Num
-    def http_port
-      @base_port
-    end
-
-    Contract None => Num
-    def peer_port
-      @base_port + 1
+    def close_timeout
+      5.0
     end
 
     private
     Contract None => String
     def basename
-      File.basename(@working_dir)
+      File.basename(working_dir)
     end
 
     Contract String, ArrayOf[String] => Maybe[Bool]
     def run_cmd(cmd, args)
       args += [{
-          out: "stellar-core.log", 
+          out: "stellar-core.log",
           err: "stellar-core.log",
         }]
 
-      Dir.chdir @working_dir do
+      Dir.chdir working_dir do
         system(cmd, *args)
       end
     end
 
-    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
-      end
-    end
-
-    Contract None => String
-    def config
-      <<-EOS.strip_heredoc
-        MANUAL_CLOSE=true
-        PEER_PORT=#{peer_port}
-        RUN_STANDALONE=false
-        HTTP_PORT=#{http_port}
-        PUBLIC_HTTP_PORT=false
-        PEER_SEED="#{@identity.seed}"
-        VALIDATION_SEED="#{@identity.seed}"
-        QUORUM_THRESHOLD=1
-        QUORUM_SET=["#{@identity.address}"]
-        DATABASE="#{dsn}"
-
-        [HISTORY.main]
-        get="cp history/main/{0} {1}"
-        put="cp {0} history/main/{1}"
-        mkdir="mkdir -p history/main/{0}"
-      EOS
-    end
-
   end
 end

data/lib/stellar_core_commander/transactor.rb

@@ -2,32 +2,37 @@ require 'fileutils'
 module StellarCoreCommander
 
 
-  # 
+  #
   # A transactor plays transactions against a stellar-core test node.
-  # 
-  # 
+  #
+  #
   class Transactor
     include Contracts
 
     class FailedTransaction < StandardError ; end
 
-    Contract Process => Any
-    def initialize(process)
-      @process    = process
-      @named      = {}.with_indifferent_access
-      @unverified = []
+    Contract Commander => Any
+    def initialize(commander)
+      @commander         = commander
+      @named             = {}.with_indifferent_access
+      @unverified        = []
       @operation_builder = OperationBuilder.new(self)
+
       account :master, Stellar::KeyPair.from_raw_seed("allmylifemyhearthasbeensearching")
     end
 
     Contract String => Any
-    # 
+    #
     # Runs the provided recipe against the process identified by @process
-    # 
+    #
     # @param recipe_path [String] path to the recipe file
-    # 
+    #
     def run_recipe(recipe_path)
-      raise "stellar-core not running" unless @process.running? 
+      @process = @commander.make_process
+      @process.run
+      @process.wait_for_ready
+
+      add_named :process, @process
 
       recipe_content = IO.read(recipe_path)
       instance_eval recipe_content
@@ -35,13 +40,13 @@ module StellarCoreCommander
 
 
     Contract Symbol, Stellar::KeyPair => Any
-    # 
+    #
     # Registered an account for this scenario.  Future calls may refer to
     # the name provided.
-    # 
+    #
     # @param name [Symbol] the name to register the keypair at
     # @param keypair=Stellar::KeyPair.random [Stellar::KeyPair] the keypair to use for this account
-    # 
+    #
     def account(name, keypair=Stellar::KeyPair.random)
       unless keypair.is_a?(Stellar::KeyPair)
         raise ArgumentError, "`#{keypair.class.name}` is not `Stellar::KeyPair`"
@@ -51,71 +56,71 @@ module StellarCoreCommander
     end
 
 
-    # 
+    #
     # @see StellarCoreCommander::OperationBuilder#payment
     def payment(*args)
       envelope = @operation_builder.payment(*args)
 
       submit_transaction envelope do |result|
-        payment_result = result.result.results!.first.tr!.payment_result!
+        payment_result = result.result.results!.first.tr!.value
         raise FailedTransaction unless payment_result.code.value >= 0
       end
     end
 
-    # 
+    #
     # @see StellarCoreCommander::OperationBuilder#create_account
     def create_account(*args)
       envelope = @operation_builder.create_account(*args)
       submit_transaction envelope
-    end 
+    end
 
-    # 
+    #
     # @see StellarCoreCommander::OperationBuilder#trust
     def trust(*args)
       envelope = @operation_builder.trust(*args)
       submit_transaction envelope
-    end  
+    end
 
-    # 
+    #
     # @see StellarCoreCommander::OperationBuilder#change_trust
     def change_trust(*args)
       envelope = @operation_builder.change_trust(*args)
       submit_transaction envelope
     end
 
-    # 
+    #
     # @see StellarCoreCommander::OperationBuilder#offer
     def offer(*args)
       envelope = @operation_builder.offer(*args)
       submit_transaction envelope
     end
 
-    # 
+    #
     # @see StellarCoreCommander::OperationBuilder#require_trust_auth
     def require_trust_auth(*args)
       envelope = @operation_builder.require_trust_auth(*args)
       submit_transaction envelope
-    end 
+    end
 
-    # 
+    #
     # @see StellarCoreCommander::OperationBuilder#set_flags
     def set_flags(*args)
       envelope = @operation_builder.set_flags(*args)
       submit_transaction envelope
     end
-    
-    # 
+
+    #
     # @see StellarCoreCommander::OperationBuilder#allow_trust
     def allow_trust(*args)
       envelope = @operation_builder.allow_trust(*args)
       submit_transaction envelope
-    end 
+    end
 
     Contract None => Any
-    # 
+    #
     # Triggers a ledger close.  Any unvalidated transaction will
     # be validated, which will trigger an error if any fail to be validated
-    # 
+    #
     def close_ledger
       @process.close_ledger
 
@@ -131,7 +136,6 @@ module StellarCoreCommander
         end
       end
 
-      # TODO: validate in-flight transactions
       @unverified.clear
     end
 
@@ -144,6 +148,15 @@ module StellarCoreCommander
       end
     end
 
+    Contract Symbol => Process
+    def get_process(name)
+      @named[name].tap do |found|
+        unless found.is_a?(Process)
+          raise ArgumentError, "#{name.inspect} is not process"
+        end
+      end
+    end
+
     Contract Stellar::KeyPair => Num
     def next_sequence(account)
       base_sequence  = @process.sequence_for(account)
@@ -177,9 +190,9 @@ module StellarCoreCommander
       hex_hash = Convert.to_hex(raw_hash)
 
       base64_result = @process.transaction_result(hex_hash)
-      
+
       raise "couldn't find result for #{hex_hash}" if base64_result.blank?
-      
+
       raw_result = Convert.from_base64(base64_result)
 
       pair = Stellar::TransactionResultPair.from_xdr(raw_result)
@@ -194,4 +207,4 @@ module StellarCoreCommander
     end
 
   end
-end
+end

data/lib/stellar_core_commander/version.rb

@@ -1,3 +1,3 @@
 module StellarCoreCommander
-  VERSION = "0.0.8"
+  VERSION = "0.0.9"
 end

data/stellar_core_commander.gemspec

@@ -17,11 +17,11 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "stellar-base", "= 0.0.9"
+  spec.add_dependency "stellar-base", "= 0.0.10"
   spec.add_dependency "slop", "~> 3.6.0"
   spec.add_dependency "faraday", "~> 0.9.1"
   spec.add_dependency "faraday_middleware", "~> 0.9.1"
-  spec.add_dependency "pg", "~> 0.18.1"   
+  spec.add_dependency "pg", "~> 0.18.1"
   spec.add_dependency "sequel", "~> 4.21.0"
   spec.add_dependency "activesupport", ">= 4.0.0"
   spec.add_dependency "contracts", "~> 0.9"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: stellar_core_commander
 version: !ruby/object:Gem::Version
-  version: 0.0.8
+  version: 0.0.9
 platform: ruby
 authors:
 - Scott Fleckenstein
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-05-21 00:00:00.000000000 Z
+date: 2015-06-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: stellar-base
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.9
+        version: 0.0.10
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.0.9
+        version: 0.0.10
 - !ruby/object:Gem::Dependency
   name: slop
   requirement: !ruby/object:Gem::Requirement
@@ -186,6 +186,8 @@ files:
 - lib/stellar_core_commander.rb
 - lib/stellar_core_commander/commander.rb
 - lib/stellar_core_commander/convert.rb
+- lib/stellar_core_commander/docker_process.rb
+- lib/stellar_core_commander/local_process.rb
 - lib/stellar_core_commander/operation_builder.rb
 - lib/stellar_core_commander/process.rb
 - lib/stellar_core_commander/transactor.rb