c3d 0.5.6 → 0.5.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b89df29d2eb9708a3bc8bfd6328619f09e65da3a
-  data.tar.gz: 5a8305b77f94b65aacf5bbe43ea2038fd527c535
+  metadata.gz: a643edac24f6736a334862867e8f2068be43dd2e
+  data.tar.gz: 9da1d9ae7f3327201a5c05ad7b20b9ec11270ae6
 SHA512:
-  metadata.gz: 6a1bb4aeb6f2e899c246df60d17b9c378f8b9c9d4733e96d9bcd5a191e3c4ebc8945420e7ae2a78dcd291e5fae1f105b8f7b3025bf1ab998d91faf9eb2c27fb6
-  data.tar.gz: 619b5b056688678c1110168d889f7948142c9a4bf3923b889a00e93fa7050b56824d828a00194a5211ac626f350f51048a329d606c58efa9bcc58631a49f5865
+  metadata.gz: d686d7973f19720a5f4ab4a9740192c022880359a64ec8d11b7f7d0261ca08ca0c61ccd416502db3109946d9c2dfa02f14c476832a684b73fb0eb8d1b998b896
+  data.tar.gz: ad0ba837624f36a9fc58295120d15c5f1a21522751b05becd8516ee563bc1acb230288cacbe7bd65097ebad6921582df2806a49acf1dfc069088cce9ebd356e0

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    c3d (0.5.2)
+    c3d (0.5.6)
       bencode (~> 0.8)
       celluloid (~> 0.15)
       commander (~> 4.1)
@@ -17,7 +17,7 @@ GEM
     commander (4.1.6)
       highline (~> 1.6.11)
     diff-lcs (1.2.5)
-    epm (0.3.8)
+    epm (0.3.14)
       commander (~> 4.1.6)
     highline (1.6.21)
     httparty (0.13.1)
@@ -29,14 +29,14 @@ GEM
       rspec-core (~> 3.0.0)
       rspec-expectations (~> 3.0.0)
       rspec-mocks (~> 3.0.0)
-    rspec-core (3.0.1)
+    rspec-core (3.0.2)
       rspec-support (~> 3.0.0)
-    rspec-expectations (3.0.1)
+    rspec-expectations (3.0.2)
       diff-lcs (>= 1.2.0, < 2.0)
       rspec-support (~> 3.0.0)
-    rspec-mocks (3.0.1)
+    rspec-mocks (3.0.2)
       rspec-support (~> 3.0.0)
-    rspec-support (3.0.0)
+    rspec-support (3.0.2)
     timers (1.1.0)
 
 PLATFORMS

data/LICENSE.md

@@ -1,4 +1,4 @@
-Copyright (c) [2014] [Watershed Legal Services, PLLC]
+Copyright (c) [2014] Project Douglas Limited
 
 Any person who (1) obtains a copy of this software and associated documentation
 files (the "Software") and (2) agrees to the terms of this license agreement may

data/lib/c3d/connectors/connect_ethereum.rb

@@ -120,8 +120,12 @@ module C3D
     private
 
       def guard_addresses address
-        unless address[0..1] == "0x"
-          address = "0x" + address
+        if address.class == String
+          unless address[0..1] == "0x"
+            address = "0x" + address
+          end
+        else
+          address = '0x'
         end
         address
       end
@@ -148,7 +152,17 @@ module C3D
       def send_command request
         @request.body = request.to_json
         puts "[C3D::#{Time.now.strftime( "%F %T" )}] Sending Question >>\t#{@request.body}"
-        handle_response JSON.parse(@question_socket.request(@request).body)
+        begin
+          handle_response JSON.parse(@question_socket.request(@request).body)
+        rescue
+          sleep 2
+          begin
+            handle_response JSON.parse(@question_socket.request(@request).body)
+          rescue
+            response = {}
+            handle_response response['error'] = 'Cannot Connect to Ethereum Client.'
+          end
+        end
       end
 
       def handle_response response
@@ -156,7 +170,7 @@ module C3D
           puts "[C3D::#{Time.now.strftime( "%F %T" )}] Received Answer >>\tanswer:#{response['result']}"
           return response["result"]
         else
-          puts "[C3D::#{Time.now.strftime( "%F %T" )}] Received Answer >>\tERROR!"
+          puts "[C3D::#{Time.now.strftime( "%F %T" )}] Received Answer >>\tERROR!: #{response['error']}"
           return nil
         end
       end

data/lib/c3d/util/blobber.rb

@@ -3,10 +3,22 @@
 # and work by @Burgestrand here: https://gist.github.com/Burgestrand/1733611
 
 module C3D
+
+  ## The Blobber class takes reads from either an input buffer or from a raw file.
+  #    It first takes the SHA1 checksum of the contents of the file and truncates
+  #    those down to 24 characters. Then it calculates the information necessary
+  #    to formulate a torrent file without trackers. That torrent file is then
+  #    saved into the publisher's torrent file directory as stated in the c3d
+  #    settings. Lastly, the determined torrent file is submitted to the transmission
+  #    client for seeding.
   class Blobber
     include Celluloid
-    attr_accessor :tor_file, :blob_file, :sha1_trun, :btih, :mag_link
+    attr_reader :tor_file, :blob_file, :sha1_trun, :btih, :mag_link
 
+    # Blobber.new accepts one argument: the blob which is to be torrented and
+    #   submitted to transmission for seeding. After ensuring that the blob is sent
+    #   the function will run that blob through the torrenting process by the sequence
+    #   of function calls to the private functions of the class.
     def initialize blob
       @piecelength = 32 * 1024
       if blob
@@ -19,6 +31,14 @@ module C3D
 
     private
 
+      # prepare accepts a blob as its only argument. First the function checks if the
+      #   blob is a file which currently exists. If it is a file, it will read the contents
+      #   of the file into memory for the remainder of the functionality. If the blob is
+      #   a raw piece of content it will already be in memory and need not be read.
+      #   After the blob is in memory, the function will take the SHA1 checksum of the blob
+      #   and then will establish the display name (dn) of the blob as well as its torrent
+      #   file as instance variables of the class. Finally, it will write the contents of the
+      #   blob into the @blob_file in the blob directory (which is taken from the c3d settings)
       def prepare blob
         if File.exists? blob
           blob = File.read blob
@@ -28,10 +48,14 @@ module C3D
         @tor_file  = File.join(ENV['TORRENTS_DIR'], "#{sha1_trun}.torrent")
         @blob_file = File.join(ENV['BLOBS_DIR'], sha1_trun)
         File.open(@blob_file, 'w'){|f| f.write(blob)}
-        @files = [{ path: @blob_file.split('/'), length: File::open(@blob_file).size }]
       end
 
+      # the build command builds the information required to forumlate the torrent file.
+      #   first it adds the files to the file instance variable, then it adds the various
+      #   information pieces needed. Finally, it runs the read_pieces function to develop
+      #   the hash that the torrent file needs to ensure it has all the pieces of a torrent.
       def build
+        @files = [{ path: @blob_file.split('/'), length: File::open(@blob_file).size }]
         @info = { :'created by' => "OWIG3",
                   :'creation date' => DateTime.now.strftime("%s").to_i,
                   encoding: "UTF-8",
@@ -42,30 +66,31 @@ module C3D
                         }
                 }
         @info[:info][:pieces] = ""
-        i = 0
-        read_pieces(@files.first[:path], @piecelength) do |piece|
+        read_pieces do |piece|
           @info[:info][:pieces] += Digest::SHA1.digest(piece)
-          i += 1
         end
       end
 
-      def read_pieces file, length
+      # read_pieces accepts file and length arguments and it hashes the blob file to
+      #   make sure that it has all of the pieces. it uses ruby's buffer functionality.
+      def read_pieces
+        puts "[C3D-EPM::#{Time.now.strftime( "%F %T" )}] Hashing Blob >>\t\t" + "#{@files.first[:path].join("/")}"
         buffer = ""
-        puts "[C3D-EPM::#{Time.now.strftime( "%F %T" )}] Hashing Blob >>\t\t" + "#{file.join("/")}"
-        File.open(file.join("/")) do |fh|
+        File.open(@files.first[:path].join("/")) do |file|
           begin
-            read = fh.read(length - buffer.length)
-            if (buffer.length + read.length) == length
+            read = file.read(@piecelength - buffer.length)
+            if (buffer.length + read.length) == @piecelength
               yield(buffer + read)
               buffer = ""
             else
               buffer += read
             end
-          end until fh.eof?
+          end until file.eof?
         end
         yield buffer
       end
 
+      # write torrent byteencodes the torrent information hash into the torrent file.
       def write_torrent
         File.open(@tor_file, 'w') do |torrentfile|
           torrentfile.write @info.bencode
@@ -73,6 +98,12 @@ module C3D
         puts "[C3D-EPM::#{Time.now.strftime( "%F %T" )}] Torrent Link >>\t\t" + "#{@tor_file}"
       end
 
+      # publish torrent uses the torrent connector object from the Celluloid actor registry
+      #  and sends that to the torrent client via RPC. After it sends that it queries the
+      #  return to understand the btih of the torrent file, which together with the truncated
+      #  SHA1 checksum of the contents (the display name, or dn) formulates the magnet link
+      #  and also these pieces are then sent to the ethereum layer for submission to the blockchain
+      #  via a different class.
       def publish_torrent
         torrent  = Celluloid::Actor[:puller].create @tor_file
         begin

data/lib/c3d/util/encrypt.rb

@@ -0,0 +1,177 @@
+#!/usr/bin/env ruby
+
+module C3D
+
+  ## The Encryptor class is used to sign and encrypt file blobs using
+  #    gpg (for now) on a user's computer. The object class is instantiated
+  #    using any of gpg's options and the instance methods can then be used
+  #    and will rely upon the instatiated options. The encryptor class
+  #    will not blob files, and as such it should be called prior to and
+  #    in conjunction with the Blobber class for users to share encrypted
+  #    files via the torrent layer c3d utilizes.
+  class Encryptor
+    include Celluloid
+    attr_accessor :opts
+    attr_reader :opts_addendum
+
+    # Encryptor.new can be instantiated using any gpg options available to the
+    #   user. Each of the options should be sent as the key to the hash with
+    #   the value of the hash being the value of the option send to the gpg
+    #   cli. The instantiated class will then use these options whenever any
+    #   of the instance methods are called.
+    def initialize opts={}
+      @opts = '--quiet --yes '
+      @opts << build_opts(opts)
+    end
+
+    # clearsign will call gpg's clearsign function on a blob. A blob can be passed
+    #   in the form of raw file contents already read into memory, or as a filepath
+    #   as is the case with the Blobber class. clearsign will return the raw contents
+    #   of the clearsigned file to the caller, by clearsigning to a tmp file and reading
+    #   that tempfile into memory (this will avoid any gpg errors being passed back to
+    #   the caller). the clearsign function would typically be called in conjunction with
+    #   the verify function. typically, clearsign will utilize the default gpg keys
+    #   for the user.
+    def clearsign blob
+      clear_addendum
+      blob = file_or_contents blob
+      outf = add_output_path_to_opts
+      cmd  = build_command '--clearsign', blob
+      system "#{cmd}"
+      return outf
+    end
+
+    # verify will call gpg's verify function on a blob file. the function will only
+    #   accept a file path and does not accept raw file contents. the function will return
+    #   true or false depending on whether the clearsigned file was valid or not. Verify
+    #   is not used with encrypted files (for simplicity in c3d's case) but only with
+    #   clearsigned files. This is a design decision for convenience.
+    def verify blob_file
+      clear_addendum
+      cmd    = build_command '--verify', blob_file
+      result = `#{cmd} 2>&1`
+      p "REAS: " + result
+      result = parse_gpg_output result
+      return result
+    end
+
+    # encrypt will call gpg's sign and encrypt function on a blob. by default encrypt will
+    #   sign and encrypt via the user's default keys. this function is opinionated and
+    #   has not been built to provide abstracted gpg encryption functionality. as such,
+    #   it will utilized gpg's built in rsa encryption functionality rather than using
+    #   elliptical curve functionality. over time, Project Douglas intends to expand the
+    #   scope of blob encryption options. the blob argument passed to the encrypt function
+    #   can be either a file path or raw file contents as with the Blobber class as well as
+    #   the clearsign function. in addition, the function accepts an array of recipient email
+    #   addresses or gpg keys which can be used to restrict decryption functionality to the
+    #   intended recipients of the file blob only.
+    def encrypt blob, recipients=[]
+      clear_addendum
+      blob = file_or_contents blob
+      outf = add_output_path_to_opts
+      add_recipients_to_opts recipients unless recipients.empty?
+      cmd  = build_command '--sign --encrypt', blob
+      system "#{cmd}"
+      return outf
+    end
+
+    # decrypt will call gpg's decrypt function on a blob. the function will only accept
+    #   a file path and does not accept raw file contents (roughly mirroring the verify
+    #   function). the function will return an array containing: [0] -- true or false flag
+    #   which signals whether the signature of the file was correct and verified by gpg as
+    #   well as [1] -- the path to the decrypted file.
+    def decrypt blob_file
+      clear_addendum
+      outf   = add_output_path_to_opts
+      cmd    = build_command '--decrypt', blob_file
+      result = `#{cmd} 2>&1`
+      result = parse_gpg_output result
+      result = [outf, result]
+      return result
+    end
+
+    private
+
+      # build_opts accepts a hash of options from the instantiating function of the class
+      #   and builds the command line options which will be passed prior to the gpg command.
+      #   the keys of the hash must match with gpg options exactly as the function is designed
+      #   to be relatively dumb. it will simply loop through the keys and change those from
+      #   symbols to strings while adding the correct cli switcher notation.
+      def build_opts opts
+        return opts.inject('') do |cmd, key, val|
+          cmd << '--'
+          cmd << key.to_s
+          cmd << ' '
+          cmd << val.to_s
+          cmd << ' '
+          cmd
+        end
+      end
+
+      # build_command syncronizes all the pieces of the command structure into a unified
+      #   cli command which is then sent to gpg via the command line for parsing by the
+      #   post command functions. this command does not send the command to gpg via a cli
+      #   interface but simply builds the string.
+      def build_command task, blob_or_file
+        cmd = 'gpg '
+        cmd << @opts
+        cmd << ' '
+        cmd << @opts_addendum
+        cmd << task
+        cmd << ' '
+        cmd << blob_or_file
+        return cmd
+      end
+
+      # separates the options passed to gpg by individual commands from the global ones
+      #   which are established in the @opts instance variable. Because the class will
+      #   be called multiple times, we need to clear this instance variable prior to any
+      #   of the functional commands.
+      def clear_addendum
+        @opts_addendum = ' '
+      end
+
+      # file_or_contents identifies whether the blob sent to the invoking command was a
+      #   file or the raw contents of a file. if the later then it will create a temp
+      #   file and write the raw contents of the file to that tmp file so that gpg can
+      #   operate on the file contents. gpg does not work well in signing and encrypting
+      #   from stdin, so we are forced to use tempfiles for this process.
+      def file_or_contents blob
+        unless File.exists? blob
+          blob = Tempfile.new 'c3d-encrypted'
+          File.open(blob.path, 'w'){|f| f.write(blob)}
+          return blob.path
+        end
+        return blob
+      end
+
+      # add_recipients_to_opts is invoked by the encrypt function which has an optional
+      #   array of recipients that may be passed as its second argument. this command
+      #   loops through those recipients and adds each to the @opts string.
+      def add_recipients_to_opts recipients
+        @opts_addendum << '--recipients '
+        recipients.each do |recip|
+          @opts_addendum << ( recip + ' ' )
+        end
+      end
+
+      # add_output_path_to_opts is invoked by all of the functions.
+      def add_output_path_to_opts
+        output_file = Tempfile.new 'c3d-output'
+        @opts_addendum << '--output '
+        @opts_addendum << ( output_file.path + ' ' )
+        return output_file.path
+      end
+
+      # parse_gpg_output performs a regex query on the output string from the gpg
+      #   verify and decrypt strings to check if the signature of a particular file
+      #   was valid
+      def parse_gpg_output output
+        output = output.split("\n")
+        p output
+        output = output.select{|line| line[/gpg: Good signature/]}
+        p output
+        return ( ! output.empty? )
+      end
+  end
+end

data/lib/c3d/util/processes.rb

@@ -29,6 +29,20 @@ module C3D
       end
       return (! a.empty?)
     end
+
+    def set_trans_config config
+      trans_file = File.join(ENV['HOME'], '.epm', 'settings.json')
+      trans_example = File.join(File.dirname(__FILE__), '..', '..', '..', 'settings', 'transmission.json')
+      unless File.exists? trans_file
+        FileUtils.cp trans_example, trans_file
+      end
+      trans_config = JSON.load(File.read(trans_file))
+      trans_config["incomplete-dir"]        = config['download_dir']
+      trans_config["download-queue-size"]   = config['download-queue-size'].to_i
+      trans_config["queue-stalled-minutes"] = config['queue-stalled-minutes'].to_i
+      trans_config["seed-queue-size"]       = config['seed-queue-size'].to_i
+      File.open(trans_file, 'w'){|f| f.write(JSON.pretty_generate(trans_config))}
+    end
   end
 
   module EthRunner
@@ -66,8 +80,17 @@ module C3D
 
 
     def is_eth_running?
-      a = `ps ux`.split("\n").select{|e| e[/eth --json-rpc-port/]}
+      a = `ps ux`.split("\n").select{|e| e[/eth .*--json-rpc-port/]}
       return (! a.empty?)
     end
+
+    def eth_process
+      if is_eth_running?
+        a = `ps ux`.split("\n").select{|e| e[/eth .*--json-rpc-port/]}[0].split(" ")[1]
+        return a
+      else
+        return false
+      end
+    end
   end
 end

data/lib/c3d/util/setup.rb

@@ -6,119 +6,56 @@ module C3D
 
     def initialize cli=false
       set_deps
-      #todo - pull these from utility module rather than use here.
-      config = get_config
-      set_the_env config
-      set_trans_config config
+      config = C3D::Utility.get_config
+      C3D::Utility.set_the_env config
       set_c3d_config config
-      start_processes config, cli
+      C3D::TransmissionRunner.set_trans_config config
+      C3D::TransmissionRunner.start_transmission cli
+      C3D::EthRunner.start_ethereum config
     end
 
     private
 
-    def set_deps
-      dep_exist? 'transmission-daemon', 'sudo apt-get install transmission-daemon && sudo service transmission-daemon stop && sudo update-rc.d -f transmission-daemon remove'
-    end
-
-    def get_config
-      dir_exist? File.join(ENV['HOME'], '.epm')
-      config_file  = File.join(ENV['HOME'], '.epm', 'c3d-config.json')
-      config_example = File.join(File.dirname(__FILE__), '..', '..', '..', 'settings', 'c3d-config.json')
-      unless File.exists? config_file
-        tmp = File.read config_example
-        until ! tmp[/(\{\{USERHOME\}\})/]
-          tmp.gsub!("{{USERHOME}}", ENV["HOME"])
-        end
-        print "Before we begin, I need to ask you two personal questions:\n"
-        print "What is your primary account which I should be using to send transactions?\n\n"
-        account = STDIN.gets.chomp
-        print "Thanks. #{account} is what I will use.\n"
-        print "Thanks. Now what is the private key for that account which I should be using?\n\n"
-        secret = STDIN.gets.chomp
-        print "Thanks. #{secret} is what I will use.\n"
-        account = "0x#{account}" if account[0..1] != '0x'
-        secret = "0x#{secret}" if secret[0..1] != '0x'
-        tmp.gsub!("{{0xACCT}}", account)
-        tmp.gsub!("{{0xSEC}}", secret)
-        File.open(config_file, 'w'){|f| f.write(tmp)}
+      def set_deps
+        dep_exist? 'transmission-daemon', 'sudo apt-get install transmission-daemon && sudo service transmission-daemon stop && sudo update-rc.d -f transmission-daemon remove'
       end
-      return JSON.load(File.read(config_file))
-    end
 
-    def set_the_env config
-      ENV['SWARM_DIR']     = config['swarm_dir']
-      ENV['TORRENTS_DIR']  = config['torrents_dir']
-      ENV['BLOBS_DIR']     = config['blobs_dir']
-      ENV['WATCH_FILE']    = config['watch_file']
-      ENV['IGNORE_FILE']   = config['ignore_file']
-      ENV['TORRENT_RPC']   = config['torrent_rpc']
-      ENV['TORRENT_USER']  = config['torrent_user']
-      ENV['TORRENT_PASS']  = config['torrent_pass']
-      ENV['UI_RESPOND']    = config['ui_respond']
-      ENV['UI_ANNOUNCE']   = config['ui_announce']
-      ENV['ETH_CONNECTOR'] = config['eth_connector']
-      ENV['ETH_ZMQ_ADDR']  = config['eth_zmq_addr']
-      ENV['ETH_HOST']      = config['eth_rpc_host']
-      ENV['ETH_PORT']      = config['eth_rpc_port']
-      ENV['ETH_KEY']       ||= config['primary_account_key']
-      ENV['GAS_PRICE']     = config['gas_price'] || '100000000000000'
-    end
-
-    def set_trans_config config
-      trans_file = File.join(ENV['HOME'], '.epm', 'settings.json')
-      trans_example = File.join(File.dirname(__FILE__), '..', '..', '..', 'settings', 'transmission.json')
-      unless File.exists? trans_file
-        FileUtils.cp trans_example, trans_file
+      def set_c3d_config config
+        dir_exist?  ENV['SWARM_DIR']
+        dir_exist?  ENV['TORRENTS_DIR']
+        dir_exist?  ENV['BLOBS_DIR']
+        dir_exist?  ENV['TORRENT_DOWN_DIR']
+        file_exist? ENV['WATCH_FILE']
+        file_exist? ENV['IGNORE_FILE']
       end
-      trans_config = JSON.load(File.read(trans_file))
-      trans_config["incomplete-dir"]        = config['download_dir']
-      trans_config["download-queue-size"]   = config['download-queue-size'].to_i
-      trans_config["queue-stalled-minutes"] = config['queue-stalled-minutes'].to_i
-      trans_config["seed-queue-size"]       = config['seed-queue-size'].to_i
-      File.open(trans_file, 'w'){|f| f.write(JSON.pretty_generate(trans_config))}
-    end
 
-    def set_c3d_config config
-      dir_exist?  ENV['SWARM_DIR']
-      dir_exist?  ENV['TORRENTS_DIR']
-      dir_exist?  ENV['BLOBS_DIR']
-      dir_exist?  config['download_dir']
-      file_exist? ENV['WATCH_FILE']
-      file_exist? ENV['IGNORE_FILE']
-    end
-
-    def start_processes config, cli
-      C3D::TransmissionRunner.start_transmission cli
-      C3D::EthRunner.start_ethereum config
-    end
-
-    def dir_exist? directry
-      unless File.directory? directry
-        FileUtils.mkdir_p directry
+      def dir_exist? directry
+        unless File.directory? directry
+          FileUtils.mkdir_p directry
+        end
       end
-    end
 
-    def file_exist? fil
-      unless File.exists? fil
-        File.open(fil, "w") {}
+      def file_exist? fil
+        unless File.exists? fil
+          File.open(fil, "w") {}
+        end
       end
-    end
 
-    def dep_exist? dependency, fixer
-      unless which dependency
-        `#{fixer}`
+      def dep_exist? dependency, fixer
+        unless which dependency
+          `#{fixer}`
+        end
       end
-    end
 
-    def which cmd
-      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
-      ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
-        exts.each { |ext|
-          exe = File.join(path, "#{cmd}#{ext}")
-          return exe if File.executable? exe
-        }
+      def which cmd
+        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+          exts.each { |ext|
+            exe = File.join(path, "#{cmd}#{ext}")
+            return exe if File.executable? exe
+          }
+        end
+        return nil
       end
-      return nil
-    end
   end
 end

data/lib/c3d/util/util.rb

@@ -53,22 +53,37 @@ module C3D
     end
 
     def set_the_env config
-      ENV['SWARM_DIR']     = config['swarm_dir']
-      ENV['TORRENTS_DIR']  = config['torrents_dir']
-      ENV['BLOBS_DIR']     = config['blobs_dir']
-      ENV['WATCH_FILE']    = config['watch_file']
-      ENV['IGNORE_FILE']   = config['ignore_file']
-      ENV['TORRENT_RPC']   = config['torrent_rpc']
-      ENV['TORRENT_USER']  = config['torrent_user']
-      ENV['TORRENT_PASS']  = config['torrent_pass']
-      ENV['UI_RESPOND']    = config['ui_respond']
-      ENV['UI_ANNOUNCE']   = config['ui_announce']
-      ENV['ETH_CONNECTOR'] = config['eth_connector']
-      ENV['ETH_ZMQ_ADDR']  = config['eth_zmq_addr']
-      ENV['ETH_HOST']      = config['eth_rpc_host']
-      ENV['ETH_PORT']      = config['eth_rpc_port']
-      ENV['ETH_KEY']       ||= config['primary_account_key']
-      ENV['GAS_PRICE']     = config['gas_price'] || '100000000000000'
+      ENV['SWARM_DIR']        = config['swarm_dir']
+      ENV['TORRENTS_DIR']     = config['torrents_dir']
+      ENV['BLOBS_DIR']        = config['blobs_dir']
+      ENV['WATCH_FILE']       = config['watch_file']
+      ENV['IGNORE_FILE']      = config['ignore_file']
+      ENV['TORRENT_RPC']      = config['torrent_rpc']
+      ENV['TORRENT_USER']     = config['torrent_user']
+      ENV['TORRENT_PASS']     = config['torrent_pass']
+      ENV['TORRENT_DOWN_DIR'] = config['download_dir']
+      ENV['ETH_HOST']         = config['eth_rpc_host']
+      ENV['ETH_PORT']         = config['eth_rpc_port']
+      ENV['ETH_REMOTE']       = config["eth_remote"]
+      ENV['ETH_KEY']        ||= config['primary_account_key']
+      ENV['BLOCKCHAIN_DIR']   = config["blockchain_dir"]
+      ENV['GAS_PRICE']        = config['gas_price'] || '100000000000000'
+    end
+
+    def get_latest_doug
+      log_file = File.join(ENV['HOME'], '.epm', 'deployed-log.csv')
+      begin
+        log  = File.read log_file
+        doug = log.split("\n").map{|l| l.split(',')}.select{|l| l[0] == ("Doug" || "DOUG" || "doug")}[-1][-1]
+      rescue
+        doug = '0x'
+      end
+      doug_check = Celluloid::Actor[:eth].get_storage_at doug, '0x10'
+      if doug_check != '0x'
+        return doug
+      else
+        return nil
+      end
     end
 
     def dir_exist? directry

data/lib/c3d/version.rb

@@ -1 +1 @@
-VERSION ||= "0.5.6"
+VERSION ||= "0.5.7"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: c3d
 version: !ruby/object:Gem::Version
-  version: 0.5.6
+  version: 0.5.7
 platform: ruby
 authors:
 - Casey Kuhlman
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-06-26 00:00:00.000000000 Z
+date: 2014-07-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: httparty
@@ -135,6 +135,7 @@ files:
 - lib/c3d/connectors/connect_ethereum.rb
 - lib/c3d/connectors/connect_torrent.rb
 - lib/c3d/util/blobber.rb
+- lib/c3d/util/encrypt.rb
 - lib/c3d/util/processes.rb
 - lib/c3d/util/purger.rb
 - lib/c3d/util/setup.rb