c3d 0.3.5 → 0.4.2

data/lib/c3d/connect_torrent.rb

@@ -1,147 +0,0 @@
-#!/usr/bin/env ruby
-# This is based off of work by fguillen for the transmission_api gem here: https://github.com/fguillen/TransmissionApi
-
-class TorrentAPI
-  include Celluloid
-  attr_accessor :session_id, :url, :basic_auth, :fields, :debug_mode
-
-  TORRENT_FIELDS = [
-    "id",
-    "name",
-    "totalSize",
-    "isFinished",
-    "percentDone",
-  ]
-
-  def initialize opts
-    @url = opts[:url]
-    @fields = opts[:fields] || TORRENT_FIELDS
-    @basic_auth = { :username => opts[:username], :password => opts[:password] } if opts[:username]
-    @debug_mode = opts[:debug_mode] || false
-    # todo - connect to client, get, and save session_id
-    @session_id = "NOT-INITIALIZED"
-  end
-
-  def all
-    log ("[C3D-EPM::#{Time.now.strftime( "%F %T" )}] Getting All Torrents"), true
-
-    response =
-      post(
-        :method => "torrent-get",
-        :arguments => {
-          :fields => fields
-        }
-      )
-
-    response["arguments"]["torrent-added"]
-  end
-
-  def find id
-    log ("[C3D-EPM::#{Time.now.strftime( "%F %T" )}] Getting Torrent ID >> "+ "#{id}"), true
-
-    response =
-      post(
-        :method => "torrent-get",
-        :arguments => {
-          :fields => fields,
-          :ids => [id]
-        }
-      )
-
-    response["arguments"]["torrents"].first
-  end
-
-  def create filename
-    log ("[C3D-EPM::#{Time.now.strftime( "%F %T" )}] Adding Blob >> \t"+ "#{filename}"), true
-
-    response =
-      post(
-        :method => "torrent-add",
-        :arguments => {
-          :filename => filename,
-          :'download-dir' => ENV['BLOBS_DIR'],
-          :'peer-limit' => 99
-        }
-      )
-
-    response["arguments"]
-  end
-
-  def destroy(id)
-    log ("[C3D-EPM::#{Time.now.strftime( "%F %T" )}] Remove Torrent ID >> "+ "#{id}"), true
-
-    response =
-      post(
-        :method => "torrent-remove",
-        :arguments => {
-          :ids => [id],
-          :"delete-local-data" => true
-        }
-      )
-
-    response
-  end
-
-  private
-    def post(opts)
-      JSON::parse( http_post(opts).body )
-    end
-
-    def http_post(opts)
-      post_options = {
-        :body => opts.to_json,
-        :headers => { "x-transmission-session-id" => session_id }
-      }
-      post_options.merge!( :basic_auth => basic_auth ) if basic_auth
-
-      log "url: #{url}"
-      log "post_body:"
-      log JSON.parse(post_options[:body]).to_yaml
-      log "------------------"
-
-      response = HTTParty.post( url, post_options )
-
-      log_response response
-
-      # retry connection if session_id incorrect
-      if( response.code == 409 )
-        log "changing session_id"
-        @session_id = response.headers["x-transmission-session-id"]
-        response = http_post(opts)
-      end
-
-      response
-    end
-
-    def log(message, override = false)
-      if debug_mode || override
-        puts "#{message}"
-      end
-    end
-
-    def log_response(response)
-      body = nil
-      begin
-        body = JSON.parse(response.body).to_yaml
-      rescue
-        body = response.body
-      end
-
-      headers = response.headers.to_yaml
-
-      log "response.code: #{response.code}"
-      log "response.message: #{response.message}"
-
-      log "response.body_raw:"
-      log response.body
-      log "-----------------"
-
-      log "response.body:"
-      log body
-      log "-----------------"
-
-      log "response.headers:"
-      log headers
-      log "------------------"
-    end
-end

data/lib/c3d/connect_ui.rb

@@ -1,102 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'json'
-require 'celluloid/zmq'
-
-# commands - sent over ZMQ but using a standard JSONRPC structure.
-#   * `makeBlob`:      make blob
-#                      params: filename: "FILENAME" || filecontents: "CONTENTS"
-#                      returns success: BLOB_ID or error
-#   * `destroyBlob`:   destroy blob
-#                      params: blob: "BLOB_ID"
-#                      returns success: true or error
-#   * `addBlobToG`:    add blob to group
-#                      params: blob: "BLOB_ID", contract: "CONTRACT_ADDRESS", group: "GROUP_ID"
-#                      returns success: true or error
-#   * `rmBlobFromG`:   remove blob from contract
-#                      params: blob: "BLOB_ID", contract: "CONTRACT_ADDRESS", group: "GROUP_ID"
-#                      returns success: true or error
-#   * `subscribeK`:    add a contract's blobs to the subscribed list
-#                      params: contract: "CONTRACT_ADDRESS"
-#                      returns success: true or error
-#   * `subscribeG`:    add a group's blobs to the subscribed list
-#                      params: contract: "CONTRACT_ADDRESS", group: "GROUP_ID"
-#                      returns success: true or error
-#   * `unsubscribeK`   remove a contract's blobs from the subscribed list
-#                      params: contract: "CONTRACT_ADDRESS"
-#                      returns success: true or error
-#   * `unsubscribeG`   remove a group's blobs from the subscribed list
-#                      params: contract: "CONTRACT_ADDRESS", group: "GROUP_ID"
-#                      returns success: true or error
-#   * `ignoreG`        add a group to the ignore list
-#                      params: contract: "CONTRACT_ADDRESS", group: "GROUP_ID"
-#                      returns success: true or error
-#   * `publish`:       sugar for make blob + add to g
-#                      params: filename: "FILENAME" || filecontents: "CONTENTS",
-#                              contract: "CONTRACT_ADDRESS", [group]: ["GROUP1_ID", "GROUP2_ID", ...]
-#                      returns success: BLOB_ID or error)
-#   * `get`:           add a magnet link to the cache
-#                      params: id: "BLOB_ID"
-#                      returns success: true or error
-
-Celluloid::ZMQ.init
-
-class ConnectUI
-  include Celluloid::ZMQ
-
-  def initialize
-    @answer_socket = RepSocket.new
-
-    begin
-      @answer_socket.bind ENV['UI_ADDRESS']
-    rescue IOError
-      @answer_socket.close
-      raise
-    end
-
-    puts "[C3D-EPM::#{Time.now.strftime( "%F %T" )}] c3D<-ui on port >>\t#{ENV['UI_ADDRESS'].split(':').last}"
-  end
-
-  def run
-    loop { async.handle_message @answer_socket.read }
-    self.terminate
-  end
-
-  def handle_message message
-    message = JSON.load message
-    puts "[C3D-EPM::#{Time.now.strftime( "%F %T" )}] Received Question >>\tcommand:#{message['command']}\tparams:#{message['params']}"
-    case message['command']
-    when 'get'
-      # todo
-    when 'makeBlob'
-      blob         = message['params'][0]
-      PublishBlob.new blob, nil
-    when 'destroyBlob'
-      #todo
-    when 'addBlobToG'
-      sending_addr = message['params'][0]
-      contract_id  = message['params'][1]
-      group_id     = message['params'][2]
-      PublishBlob.new nil, sending_addr, contract_id, group_id
-    when 'rmBlobFromG'
-      #todo
-    when 'subscribeK'
-      #todo
-    when 'subscribeG'
-      #todo
-    when 'unsubscribeK'
-      #todo
-    when 'unsubscribeG'
-      #todo
-    when 'ignoreG'
-      #todo
-    when 'publish'
-      sending_addr = message['params'][0]
-      contract_id  = message['params'][1]
-      group_id     = message['params'][2]
-      blob         = message['params'][3]
-      PublishBlob.new blob, sending_addr, contract_id, group_id
-    end
-    @answer_socket.send JSON.dump message
-  end
-end

data/lib/c3d/processes.rb

@@ -1,44 +0,0 @@
-#!/usr/bin/env ruby
-
-class TransmissionRunner
-  def start_transmission
-    unless is_trans_running?
-      pid = spawn "transmission-daemon -f --no-incomplete-dir -o -C -p #{ENV['TORRENT_RPC'].split(':').last[0..3]} -w #{ENV['BLOBS_DIR']} -g #{File.join(ENV['HOME'], '.epm')}"
-      at_exit { Process.kill("INT", pid) }
-    end
-  end
-
-  def is_trans_running?
-    a = `ps ux`.split("\n").select{|e| e[/transmission-daemon/]}
-    return (! a.empty?)
-  end
-end
-
-class EthZmqRunner
-  def start_ethereum_zmq_bridge
-    unless is_bridge_running?
-      c3d_node = File.join(File.dirname(__FILE__), '..', '..', 'node_modules', 'c3d', 'connect_aleth.js')
-      pid = spawn "node #{c3d_node}"
-      at_exit { Process.kill("INT", pid) }
-    end
-  end
-
-  def is_bridge_running?
-    a = `ps ux`.split("\n").select{|e| e[/node.*connect_aleth.js$/]}
-    return (! a.empty?)
-  end
-end
-
-class EthRunner
-  def start_ethereum
-    unless is_eth_running?
-      pid = spawn #{todo}""
-      at_exit { Process.kill("INT", pid) }
-    end
-  end
-
-  def is_eth_running?
-    a = `ps ux`.split("\n").select{|e| e[/eth/]} #todo cleanup
-    return (! a.empty?)
-  end
-end

data/lib/c3d/publish.rb

@@ -1,101 +0,0 @@
-#!/usr/bin/env ruby
-# based off of work by @mukaibot here: https://github.com/mukaibot/mktorrent/blob/master/lib/mktorrent.rb
-# and work by @Burgestrand here: https://gist.github.com/Burgestrand/1733611
-
-class Publish
-  include Celluloid
-  attr_accessor :tor_file, :blob_file, :sha1_trun
-
-  def initialize puller, eth, blob, sending_addr, contract_id='', group_id=''
-    @swarm_puller = puller
-    @eth = eth
-    @piecelength = 32 * 1024
-
-    unless blob == nil
-      prepare blob
-      build
-      write_torrent
-      publish_torrent
-    end
-    unless sending_addr == nil
-      publish_ethereum sending_addr, contract_id, group_id
-    end
-  end
-
-  private
-    def prepare blob
-      sha1_full = Digest::SHA1.hexdigest blob
-      @sha1_trun = sha1_full[0..23]
-      @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
-
-    def build
-      @info = { :'created by' => "OWIG3",
-                :'creation date' => DateTime.now.strftime("%s").to_i,
-                encoding: "UTF-8",
-                info: {  name: @files.first[:path].last,
-                         :'piece length' => @piecelength,
-                         length: @files.first[:length],
-                         :private => 0, #1 is private
-                      }
-              }
-      @info[:info][:pieces] = ""
-      i = 0
-      read_pieces(@files.first[:path], @piecelength) do |piece|
-        @info[:info][:pieces] += Digest::SHA1.digest(piece)
-        i += 1
-      end
-    end
-
-    def read_pieces file, length
-      buffer = ""
-      puts "[C3D-EPM::#{Time.now.strftime( "%F %T" )}] Hashing Blob >> \t" + "#{file.join("/")}"
-      File.open(file.join("/")) do |fh|
-        begin
-          read = fh.read(length - buffer.length)
-          if (buffer.length + read.length) == length
-            yield(buffer + read)
-            buffer = ""
-          else
-            buffer += read
-          end
-        end until fh.eof?
-      end
-      yield buffer
-    end
-
-    def write_torrent
-      File.open(@tor_file, 'w') do |torrentfile|
-        torrentfile.write @info.bencode
-      end
-      puts "[C3D-EPM::#{Time.now.strftime( "%F %T" )}] Torrent Link >> \t" + "#{@tor_file}"
-    end
-
-    def publish_torrent
-      p "#{@swarm_puller}"
-      torrent  = @swarm_puller.create @tor_file
-      begin
-        @btih     = torrent["torrent-added"]['hashString']
-      rescue
-        @btih     = torrent["torrent-duplicate"]['hashString']
-      end
-      mag_link = "magnet:?xt=urn:btih:" + @btih + "&dn=" + @sha1_trun
-      puts "[C3D-EPM::#{Time.now.strftime( "%F %T" )}] Magnet Link >> \t" + mag_link
-    end
-
-    def publish_ethereum sending_addr, contract_id, group_id
-      message = {}
-      post_id = "0x#{@btih}#{@sha1_trun}"
-      data  = [
-        '3',             #data_slots
-        'newp',          #....data
-        group_id,
-        post_id
-      ]
-      @eth.transact contract_id, sending_addr, data
-    end
-end
-

data/lib/c3d/setup.rb

@@ -1,105 +0,0 @@
-#!/usr/bin/env ruby
-require 'celluloid/autostart'
-require 'fileutils'
-
-class SetupC3D
-  include Celluloid
-
-  def initialize
-    set_deps
-    config = get_config
-    set_the_env config
-    set_trans_config config
-    set_c3d_config config
-  end
-
-  def set_deps
-    dep_exist? 'transmission-daemon', 'sudo apt-get install transmission-daemon'
-    dep_exist? 'node', 'sudo apt-get install nodejs'
-    unless File.directory? File.join(File.dirname(__FILE__), '..', '..', 'node_modules', 'c3d')
-      `cd #{File.join(File.dirname(__FILE__), '..', '..')} && npm install c3d`
-    end
-  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
-      FileUtils.cp config_example, config_file
-    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_ADDRESS']   = config['ui_address']
-    ENV['ETH_ZMQ_ADDR'] = config['eth_zmq_addr']
-    ENV['ETH_HOST']     = config['eth_host']
-    ENV['ETH_PORT']     = config['eth_port']
-  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
-
-  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 dir_exist? directry
-    unless File.directory? directry
-      Dir.mkdir directry
-    end
-  end
-
-  def file_exist? fil
-    unless File.exists? fil
-      File.open(fil, "w") {}
-    end
-  end
-
-  def dep_exist? dependency, fixer
-    unless which dependency
-      `#{fixer}`
-    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
-      }
-    end
-    return nil
-  end
-end
-
-if __FILE__==$0
-  require 'json'
-  SetupC3D.new
-end

data/lib/c3d/subscribe.rb

@@ -1,138 +0,0 @@
-#!/usr/bin/env ruby
-
-# Queries:
-#   * `subscribe-k`:    add a contract's blobs to the subscribed list (params: contract: "CONTRACT_ADDRESS") (returns success: true or error)
-#   * `subscribe-g`:    add a group's blobs to the subscribed list (params: contract: "CONTRACT_ADDRESS", group: "GROUP_ID") (returns success: true or error)
-#   * `unsubscribe-k`   remove a contract's blobs from the subscribed list (params: contract: "CONTRACT_ADDRESS") (returns success: true or error)
-#   * `unsubscribe-g`   remove a group's blobs from the subscribed list (params: contract: "CONTRACT_ADDRESS", group: "GROUP_ID") (returns success: true or error)
-#   * `ignore-g`        add a group to the ignore list (params: contract: "CONTRACT_ADDRESS", group: "GROUP_ID") (returns success: true or error)
-
-require 'json'
-require 'celluloid/autostart'
-require 'base64'
-
-class Subscribe
-  include Celluloid
-  attr_accessor :tor_file, :blob_file, :sha1_trun
-
-  def initialize action, eth
-    @eth = eth
-    case action
-    when 'subscribeK'
-      subscribe_k
-    when 'subscribeG'
-      subscribe_g
-    when 'unsubscribeK'
-      unsubscribe_k
-    when 'unsubscribeG'
-      unsubscribe_g
-    when 'ignoreG'
-      ignore_g
-    when 'assembleQueries'
-      assemble_queries
-    end
-  end
-
-  def assemble_queries
-    # watched, ignored = load_library
-    # watched[contract] = [group1,group2] || watched[contract]=[] <=all
-    watched = {"97d1f086800920e8fd2344be52fb22d7bf6036d2" => []}
-    watched.each_key do |contract|
-      # todo - build
-      latest_group = send_query contract, '0x18'
-      latest_group_author = send_query contract, latest_group
-      step = iterate latest_group
-      prev_group = send_query contract, step      # prev_group == '0x16' => first_group
-      step = iterate step
-      next_group = send_query contract, step      # next_group == '0x' => last_group
-      step = iterate step
-      title1 = send_query contract, step
-      step = iterate step
-      title2 = send_query contract, step
-      title = eth_strings title1
-      title << eth_strings(title2) unless title2 == '0x'
-      step = iterate step
-      posts_in_group = (send_query contract, step).to_i(16)
-      step = iterate step
-      latest_blob = send_query contract, step
-      p latest_group
-      p latest_group_author
-      p next_group
-      p prev_group
-      p title
-      p posts_in_group
-      p latest_blob
-      next_blob = ''
-      until next_blob == '0x'
-        next_blob          = send_query contract, latest_blob
-        latest_blob_author = send_query contract, latest_blob.next
-        blob_id            = send_query contract, latest_blob.next.next
-        p next_blob
-        p latest_blob_author
-        get_the_blob blob_id unless do_i_have_it? blob_id
-        latest_blob = next_blob
-      end
-    end
-    #read watcher file && build hash
-    #read igored file && delete from hash
-    #for each watched contract
-      # for each watched group
-        #first subquery is to group_id + 5 - contains the number of blobs -> compare to stored val in the JSON
-        #if that number is has not changed, check group_id + 6 - contains the newest post -> compare to stored val in the JSON
-          #if that number is the same, do nothing
-          #if that number has changed, check blob_id + 1 - contains next in linked list -> compare to stored val in the JSON
-        #if that number has changed, loop through the posts and check that each
-  end
-
-  private
-
-    def load_library
-      watched = JSON.load File.read ENV['WATCH_FILE']
-      ignored = JSON.load File.read ENV['IGNORE_FILE']
-      [watched, ignored]
-    end
-
-    def send_query contract, storage
-      @eth.get_storage_at contract, storage
-    end
-
-    def eth_strings input
-      input.scan(/../).map{|x| x.hex }.reject{|c| c == 0}.pack('c*')
-    end
-
-    def iterate input
-      last_place = input[-1]
-      input[-1] = last_place.next
-      input
-    end
-
-    def do_i_have_it? blob
-      dn   = blob[42..-1]
-      p 'dont have this'
-      File.exists?(File.join(ENV['BLOBS_DIR'], dn))
-    end
-
-    def get_the_blob blob
-      btih = blob[2..41]
-      dn   = blob[42..-1]
-      link = "magnet:?xt=urn:btih:" + btih + "&dn=" + dn
-      p 'getting_link'
-      torrent  = @@swarm_puller.create link
-      p torrent
-    end
-end
-
-if __FILE__==$0
-  require './connect_ethereum.rb'
-  require './connect_torrent'
-  require 'yaml'
-  require 'httparty'
-  @@swarm_puller = TorrentAPI.new(
-    username:   ENV['TORRENT_USER'],
-    password:   ENV['TORRENT_PASS'],
-    url:        ENV['TORRENT_RPC'],
-    debug_mode: true
-  )
-  questions_for_eth = ConnectEth.new :zmq, :cpp
-  Subscribe.new 'assembleQueries', questions_for_eth
-end

data/lib/c3d/util.rb

@@ -1,22 +0,0 @@
-#!/usr/bin/env ruby
-# based off of work by @mukaibot here: https://github.com/mukaibot/mktorrent/blob/master/lib/mktorrent.rb
-# and work by @Burgestrand here: https://gist.github.com/Burgestrand/1733611
-# note `rhash` dependency
-
-module Utility
-  def self.add_group_to_ethereum sending_addr, contract_id, title, eth
-    message = {}
-    message['command'] = 'transact'
-    message['params']  = [
-      sending_addr,    #sender_addr
-      '',              #value
-      contract_id,     #recipient_addr
-      '10000',         #gas
-      '2',             #data_slots
-      'newt',          #....data
-      title
-    ]
-    eth.write JSON.dump message
-    ### somehow this is not currently working.
-  end
-end