worochi 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2ca726002689f7fe66fe07d7ff2af93a5fc6b2e4
+  data.tar.gz: 27f7cfdcd912eeb33d9103969c59b192a79d47ab
+SHA512:
+  metadata.gz: 57fbb09d74618b9544fe5e2c8651637b1393cd97a76dec396474286393c6552ed8bfc6a568a57f60986f38665f1498352d87e0cb893e7a341d2e1034b3f39bf0
+  data.tar.gz: c0519b4338dbeabc4365776293935c6a6e6156c4ded75ed86756ab4d4d8c9c17807a27c013b640c33a0a4de359d44dc9c8d579871fd52e181b99518d54514639

data/README.md

@@ -0,0 +1,5 @@
+Worochi
+===============================================================================
+
+Worochi provides a standard way to interface with Ruby API wrappers provided
+by various cloud storage services such as Dropbox and Google Drive.

data/lib/worochi/agent/dropbox.rb

@@ -0,0 +1,82 @@
+require 'dropbox_sdk'
+
+class Worochi
+  # The {Agent} for Dropbox API. This wraps around the `dropbox-sdk` gem.
+  # @see https://www.dropbox.com/developers/core/start/ruby
+  class Agent::Dropbox < Agent
+    # @return [Hash] default options for Dropbox
+    def default_options
+      {
+        chunk_size: 2*1024*1024,
+        overwrite: true,
+        dir: '/'
+      }
+    end
+
+    # Initializes Dropbox SDK client. Refer to
+    # {https://www.dropbox.com/developers/core/start/ruby
+    # official Dropbox documentation}.
+    #
+    # @return [DropboxClient]
+    def init_client
+      @client = DropboxClient.new(options[:token])
+    end
+
+    # Push a single {Item} to Dropbox.
+    #
+    # @param [Item]
+    # @return [nil]
+    def push_item(item)
+      Worochi::Log.debug "Uploading #{item.path} (#{item.size} bytes) to Dropbox..."
+      if item.size > options[:chunk_size]
+        push_item_chunked(item)
+      else
+        @client.put_file(full_path(item), item.content, options[:overwrite])
+      end
+      Worochi::Log.debug "Uploaded"
+      nil
+    end
+
+    # Returns a list of files and subdirectories at the remote path specified
+    # by `options[:dir]`.
+    #
+    # @return [Array<Hash>] list of files and subdirectories
+    def list
+      remote_path = options[:dir]
+      begin
+        response = @client.metadata(remote_path)
+      rescue DropboxError
+        raise Error, 'Invalid Dropbox folder specified'
+      end
+
+      response['contents'].map do |elem|
+        {
+          name: elem['path'].split('/').last,
+          path: elem['path'],
+          type: elem['is_dir'] ? 'folder' : 'file'
+        }
+      end
+    end
+
+    # Uses the `/chunked_upload` endpoint to push large files to Dropbox.
+    # Refer to {https://www.dropbox.com/developers/core/docs#chunked-upload
+    # API documentation}.
+    #
+    # @param [Item]
+    # @return [nil]
+    def push_item_chunked(item)
+      Worochi::Log.debug "Using chunk uploader..."
+      uploader = @client.get_chunked_uploader(item.content, item.size)
+      while uploader.offset < uploader.total_size
+          begin
+              uploader.upload(options[:chunk_size])
+          rescue DropboxError
+              raise Error, 'Dropbox chunk upload failed'
+          end
+          Worochi::Log.debug "Uploaded #{uploader.offset} bytes"
+      end
+      uploader.finish(full_path(item), options[:overwrite])
+      nil
+    end
+  end
+end

data/lib/worochi/agent/github.rb

@@ -0,0 +1,199 @@
+require 'octokit'
+require 'base64'
+require 'worochi/helper/github'
+
+class Worochi
+  # The {Agent} for GitHub API. This wraps around the `octokit` gem.
+  # @see https://github.com/octokit/octokit.rb
+  class Agent::Github < Agent
+
+    # @return [Hash] default options for GitHub
+    def default_options
+      {
+        source: 'master',
+        target: 'worochi',
+        repo: 'darkmirage/test',
+        block_size: Worochi::Helper::Github::BLOCK_SIZE,
+        commit_msg: 'Empty commit message',
+        dir: '/'
+      }
+    end
+
+    # Initializes Octokit client. Refer to
+    # {https://github.com/octokit/octokit.rb
+    # octokit.rb documentation}.
+    #
+    # @return [Octokit::Client]
+    def init_client
+      @client = Octokit::Client.new(login: 'me', oauth_token: options[:token])
+    end
+
+    # Pushes a list of {Item} to GitHub.
+    #
+    # @param [Array<Item>]
+    # @return [nil]
+    # @see Agent#push_items
+    def push_all(items)
+      source_sha = source_branch
+      items.each { |item| source_sha = tree_append(source_sha, item) }
+      commit = @client.create_commit(repo, options[:commit_msg], source_sha,
+                                     target_branch)
+      @client.update_ref(repo, "heads/#{options[:target]}", commit.sha)
+      nil
+    end
+
+    # Pushes a single {Item} to GitHub. This means making a new commit for each
+    # file. Not recommended and should just use {#push_all} instead.
+    #
+    # @param [Item]
+    # @return [nil]
+    def push_item(item)
+      Worochi::Log.warn 'push_item should not be used for GitHub'
+      push_all([item])
+    end
+
+    # Returns a list of files and subdirectories at the remote path specified
+    # by `options[:dir]`.
+    #
+    # @return [Array<Hash>] list of files and subdirectories
+    def list
+      remote_path = options[:dir].sub(/^\//, '').sub(/\/$/, '')
+
+      result = @client.tree(repo, source_branch, recursive: true).tree
+      result.sort! do |x, y|
+        x.path.split('/').size <=> y.path.split('/').size
+      end
+
+      # Checks that folders are at the requested path and not at a lower or
+      # higher level
+      result.reject! do |elem|
+        !elem.path.match(remote_path + '($|\/.+)') ||
+        (File.join(remote_path,
+            elem.path.split('/').last).sub(/^\//, '') != elem.path)
+      end
+
+      result.map do |elem|
+        {
+          name: elem.path.split('/').last,
+          path: elem.path,
+          type: elem.type == 'tree' ? 'folder' : 'file',
+          sha: elem.sha
+        }
+      end
+    end
+
+    # Returns a list of repositories for the remote branch specified by
+    # `options[:source]`. If `opts[:push]` is `true`, then only repos with
+    # push access are returned. If `opts[:details]` is `true`, returns hashes
+    # containing more information about each repo.
+    #
+    # @param opts [Hash]
+    # @return [Array<String>, Array<Hash>] a list of repositories    
+    def repos(opts={ push: false, details: false, orgs: true })
+      repos = @client.repositories.map {|repo| parse_repo repo}
+      @client.organizations.each do |org|
+        repos += @client.organization_repositories(org.login).map {|repo| parse_repo repo}
+      end
+      repos.reject! {|repo| !repo[:push]} if opts[:push]
+      repos.map { |repo| repo[:full_name] } unless opts[:details]
+    end
+
+  private
+    # Appends an item to the existing tree.
+    #
+    # @param tree_sha [String] SHA1 checksum of the root tree
+    # @param item [Item] the item to append
+    # @return [String] SHA1 checksum of the resulting tree
+    def tree_append(tree_sha, item)
+      child = {
+        path: full_path(item).gsub(/^\//, ''),
+        sha: push_blob(item),
+        type: 'blob',
+        mode: '100644'
+      }
+      new_tree = @client.create_tree(repo, [child], base_tree: tree_sha)
+      new_tree.sha
+    end
+
+    # Pushes a single item to GitHub and returns the blob SHA1 checksum.
+    #
+    # @param item [Item]
+    # @return [String] SHA1 checksum of the created blob
+    def push_blob(item)
+      Worochi::Log.debug "Uploading #{item.path} (#{item.size} bytes) to GitHub..."
+      if item.size > options[:block_size]
+        sha = stream_blob(item)
+      else
+        sha = @client.create_blob(repo, Base64.strict_encode64(item.read), 'base64')
+      end
+      Worochi::Log.debug "Uploaded [#{sha}]"
+      sha
+    end
+
+    # Pushes a single item to GitHub using JSON streaming and returns the SHA1
+    # checksum
+    #
+    # @param item [Item]
+    # @return [String] SHA1 checksum of the created blob
+    def stream_blob(item)
+      Worochi::Log.debug "Using JSON streaming..."
+      post_stream = Worochi::Helper::Github::StreamIO.new(item)
+
+      uri = URI("https://api.github.com/repos/#{repo}/git/blobs")
+      request = Net::HTTP::Post.new(uri.path)
+      request.content_length = post_stream.size
+      request.content_type = 'application/x-www-form-urlencoded'
+      request.add_field('Authorization', "token #{options[:token]}")
+      request.body_stream = post_stream
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == 'https')
+      http.request request do |response|
+        return JSON.parse(response.body)['sha']
+      end
+
+      raise Error, 'Failed to upload file to GitHub'
+    end
+
+    # @return [Hash] repo information
+    def parse_repo(repo)
+      {
+        name: repo.name,
+        full_name: repo.full_name,
+        owner: repo.owner.login,
+        description: repo.description,
+        url: repo.url,
+        push: repo.permissions.push,
+        pull: repo.permissions.pull
+      }
+    end
+
+    # Returns the SHA1 checksum of the source branch.
+    #
+    # @return [String] SHA1 checksum
+    def source_branch
+      @client.branch(repo, options[:source]).commit.sha
+    end
+
+    # Returns the SHA1 checksum of the target branch. Clones source branch if
+    # target branch does not exist
+    #
+    # @return [String] SHA1 checksum
+    def target_branch
+      begin
+        sha = @client.branch(repo, options[:target]).commit.sha
+      rescue
+        ref = @client.create_ref(repo, "heads/#{options[:target]}", source_branch)
+        sha = ref.object.sha
+      end
+      sha
+    end
+
+    # An alias for `options[:repo]`
+    #
+    # @return [String] full repo name
+    def repo
+      options[:repo]
+    end
+  end
+end

data/lib/worochi/agent/sample.rb

@@ -0,0 +1,64 @@
+class Worochi
+  # The {Agent} for a sample API.
+  # This is a sample of methods that should be implemented by a service agent.
+  class Agent::Sample < Agent
+
+    # @return [Hash] default options for sample API
+    # @see Agent#set_options
+    def default_options
+      {
+        dir: '/'
+      }
+    end
+
+    # This is where the service-specific API client should be initialized.
+    #
+    # @return [ApiClient]
+    # @see Agent#initialize
+    def init_client
+      @client = nil
+    end
+
+    # Defined for services that need to push all the items together as a
+    # batch. For example, GitHub needs to make one commit for all the files.
+    # Usually a service-specific implementation should only need one of either
+    # {#push_item} or {#push_all}.
+    #
+    # @return [nil]
+    # @see Agent#push_items
+    def push_all(items)
+      items.each { |item| @client.push(item.content, item.path) }
+    end
+
+    # Pushes an individual item to the service. Usually a service-specific
+    # implementation should only need one of either {#push_item} or
+    # {#push_all}.
+    #
+    # @return [nil]
+    # @see Agent#push_items
+    def push_item(item)
+      @client.push(item.content, item.path)
+    end
+
+    # Returns a list of files and subdirectories at the remote path specified
+    # by `options[:dir]`. Each file entry is a hash that should contain at
+    # least the keys `:name`, `:path`, and `:type`, but can also contain other
+    # service-specific meta information.
+    #
+    # @return [Array<Hash>] list of files and subdirectories
+    # @see Agent#folders
+    # @see Agent#files
+    def list
+      result = @client.get_file_list
+      result.map do |elem|
+        {
+          name: elem.name,
+          path: elem.path,
+          type: elem.type
+        }
+      end
+    end
+
+    # Service specific methods
+  end
+end

data/lib/worochi/agent.rb

@@ -0,0 +1,143 @@
+class Worochi
+  # The parent class for all service agents.
+  class Agent
+    # Service name.
+    # @return [Symbol]
+    attr_reader :type
+    # Service options.
+    # @return [Hash]
+    attr_accessor :options
+
+    # @param opts [Hash] service options
+    def initialize(opts={})
+      set_options(opts)
+      @type = options[:service]
+      init_client
+    end
+
+    # Push list of files to the service. Refer to {Item.open} for how to
+    # format the file list. An optional `opts` hash can be used to update the
+    # agent options before pushing.
+    #
+    # @example
+    #     agent = Worochi.create(:github, 'sfsFj41na89cx')
+    #     agent.push({ source: 'http://a.com/file.jpg', path: 'folder/file.jpg' })
+    #
+    # @param origin [Array<Hash>, Array<String>, Hash, String]
+    # @param opts [Hash] update agent options before pushing
+    # @return [nil]
+    # @see Item.open
+    def push(origin, opts=nil)
+      set_options(opts) unless opts.nil?
+      items = Item.open(origin)
+      push_items(items)
+      nil
+    end
+
+    # Push a list of {Item} to the service. Usually called by {#push}.
+    #
+    # @param items [Array<Item>]
+    # @return [nil]
+    def push_items(items)
+      items.each { |item| item.content.rewind }
+      Worochi::Log.info "Pushing #{items.size} items to #{type}"
+      if respond_to?(:push_all)
+        push_all(items)
+      else
+        items.each { |item| push_item(item) }
+      end
+      Worochi::Log.info "Push to #{type} completed"
+      nil
+    end
+
+    # Remove the agent from the list of active agents responding to calls to
+    # {Worochi.push}.
+    #
+    # @return [nil]
+    def remove
+      Worochi.remove(self)
+      nil
+    end
+
+    # Returns a list of subdirectories at the remote path specified by
+    # `options[:dir]`. Relies on the service-specific implementation of
+    # `#list`.
+    #
+    # @return [Array<Hash>] list of subdirectories
+    def folders(details=false)
+      result = list.reject { |elem| elem[:type] != 'folder' }
+      result.map { |elem| elem[:name] } unless details
+    end
+
+    # Returns a list of files at the remote path specified by `options[:dir]`.
+    # Relies on the service-specific implementation of `#list`.
+    #
+    # @return [Array<Hash>] list of files
+    def files(details=false)
+      result = list.reject { |elem| elem[:type] != 'file' }
+      result.map { |elem| elem[:name] } unless details
+    end
+
+    # Updates {.options} using `opts`.
+    #
+    # @param opts [Hash] new options
+    # @return [Hash] the updated options
+    def set_options(opts={})
+      self.options ||= default_options
+      options.merge!(opts)
+    end
+
+    # Sets the remote target directory path. This is the same as modifying
+    # `options[:dir]`.
+    #
+    # @param path [String] the new path
+    # @return [Hash] the updated options
+    def set_dir(path)
+      options[:dir] = path
+      options
+    end
+
+  private
+    # @return [String] full path combining remote directory and item path
+    def full_path(item)
+      File.join(options[:dir], item.path)
+    end
+
+    # @return [Hash] default options for agents that do not override this
+    def default_options
+      { dir: '/' }
+    end
+
+    class << self
+    public
+      # Creates a new service-specific {Agent} based on `:service`.
+      #
+      # @example
+      #     Worochi::Agent.new({ service: :github, token:'6st46setsybhd64' })
+      #
+      # @param opts [Hash] service options; must contain `:service` key.
+      # @return [Agent]
+      def new(opts={})
+        service = opts[:service]
+        if self.name == 'Worochi::Agent'
+          raise Error, 'Invalid service' unless Config.services.include?(service)
+          Agent.const_get(class_name(service)).new(opts)
+        else
+          super
+        end
+      end
+
+    private
+      # Returns the class name for the {Agent} given a service name
+      #
+      # @return [String]
+      def class_name(service)
+        service.to_s.split('_').map{|e| e.capitalize}.join
+      end
+    end
+  end
+end
+
+Worochi::Config.services.each do |service|
+  require "worochi/agent/#{service}"
+end

data/lib/worochi/config.rb

@@ -0,0 +1,23 @@
+class Worochi
+  # Configurations for Worochi.
+  module Config
+    @services = [:github, :dropbox]
+    @s3_bucket = 'data-pixelapse'
+    @s3_prefix = 's3'
+
+    class << self
+      # Array of service names. 
+      # @return [Array<Symbol>]
+      attr_reader :services
+
+      # Name of S3 bucket.
+      # @return [String]
+      attr_reader :s3_bucket
+
+      # Prefix for S3 resource paths.
+      # @return [String]
+      attr_reader :s3_prefix
+    end
+  end
+end
+

data/lib/worochi/error.rb

@@ -0,0 +1,2 @@
+class Worochi::Error < StandardError
+end

data/lib/worochi/helper/github.rb

@@ -0,0 +1,99 @@
+require 'base64'
+
+class Worochi
+  # Helper classes for GitHub JSON streaming.
+  module Helper::Github
+
+    BLOCK_SIZE = 12288
+
+    # This is a wrapper that produces a JSON stream that works with
+    # {Net::HTTP::Post#body_stream}.
+    class StreamIO
+
+      def initialize(item)
+        item.content.rewind
+        @parts = [
+          StringIO.new('{"content":"'),
+          Base64IO.new(item.content),
+          StringIO.new('","encoding":"base64"}')
+        ]
+        @part_no = 0
+        @size = @parts.inject(0) {|sum, p| sum + p.size}
+      end
+
+      # @return [Integer] size of the JSON
+      def size
+        @size
+      end
+
+      # Rewind each component of the stream.
+      #
+      # @return [nil]
+      def rewind
+        @parts.each { |part| part.rewind }
+        @part_no = 0
+        nil
+      end
+
+      # @param length [Integer]
+      # @param outbuf [IO]
+      # @return [String]
+      def read(length=nil, outbuf=nil)
+        return length.nil? ? '' : nil if @part_no >= @parts.size
+        
+        length = length || size
+        output = @parts[@part_no].read(length).to_s
+
+        if output.nil?
+          return nil if @part_no >= @parts.size
+          output = ''
+        end
+
+        while output.length < length
+          @part_no += 1
+          break if @part_no == @parts.size
+          output += @parts[@part_no].read(length - output.length).to_s
+        end
+        if not outbuf.nil?
+          outbuf.clear
+          outbuf.insert(0, output)
+        end
+
+        output
+      end  
+    end
+
+    # This is a wrapper around the file content that streams the file as a
+    # Base64 encoded string.
+    class Base64IO
+      def initialize(file)
+        file.rewind
+        @file = file
+        @encoded_size = (@file.size / 3.0).ceil * 4
+        @buffer = ''
+      end
+
+      # @return [Integer] size of the JSON
+      def size
+        @encoded_size
+      end
+
+      # Rewind the stream.
+      def rewind
+        @file.rewind
+        @buffer = ''
+        nil
+      end
+
+      # @param length [Integer]
+      # @param outbuf [IO]
+      # @return [String]
+      def read(length=size, outbuf=nil)
+        while @buffer.length < length and not @file.eof?
+          @buffer += Base64.strict_encode64 @file.read(BLOCK_SIZE)
+        end
+        @buffer.empty? ? nil : @buffer.slice!(0, length)
+      end
+    end
+  end
+end

data/lib/worochi/helper.rb

@@ -0,0 +1,34 @@
+require 'aws-sdk' unless Worochi::Config.s3_bucket.nil?
+
+class Worochi
+  module Helper
+    class << self
+      # A regex generated from {Config.s3_prefix} for determining if a given
+      # String is an S3 path.
+      #
+      # @return [Regexp]
+      def s3_prefix_re
+        /^#{Config.s3_prefix}\:/
+      end
+
+      # Given an S3 path, return the full URL for the corresponding object
+      # determined using the AWS SDK.
+      #
+      # @param path [String]
+      # @return [URI::HTTP]
+      def s3_url(path)
+        raise Error, 'S3 bucket name is not defined' if Config.s3_bucket.nil?
+        path = path.sub(s3_prefix_re, '')
+        AWS::S3.new.buckets[Config.s3_bucket].objects[path].url_for(:read)
+      end
+
+      # Check if a given path is an S3 path.
+      #
+      # @param path [String]
+      # @return [Boolean]
+      def is_s3_path?(path)
+        !s3_prefix_re.match(path).nil?
+      end
+    end
+  end
+end

data/lib/worochi/item.rb

@@ -0,0 +1,139 @@
+require 'tempfile'
+
+class Worochi
+  # This represents a single file that is being pushed. The {#content}
+  # attribute holds an IO object that is read by the push agent and the
+  # {#path} attribute is the relative path to the remote target directory that
+  # the file will be pushed to.
+  class Item
+    # The relative path of the object from the target root directory. If
+    # the {Item} was initialized without a `:path` option, this attribute
+    # defaults to the file name.
+    # @return [String]
+    attr_accessor :path
+
+    # An IO object containing the content of the file being pushed.
+    # @return [IO]
+    attr_accessor :content
+    def initialize(opts={})
+      @path = opts[:path]
+      raise Error, 'Missing Item content' if !opts[:content]
+      @content = opts[:content]
+      @content.rewind
+    end
+
+    # The total size of the content in bytes.
+    #
+    # @return [Integer]
+    def size
+      content.size
+    end
+
+    # Read from the content. This is just a wrapper for the `#read` method on
+    # {#content} and any arguments will be passed on to the IO object. 
+    #
+    # @return [String]
+    def read(*args)
+      content.read(args)
+    end
+
+    class << self
+      # Takes in either a single file entry or a list of file entries and
+      # parses them into a list of {Item} objects. Each entry can be either a
+      # String specifying the source location of the file, or a Hash
+      # specifying both the `:source` location and the remote `:path` to push
+      # the file to.
+      #
+      # @example Single file
+      #     Item.open('folder/file.txt')
+      # @example Multiple files
+      #     Item.open(['folder/file1.txt', 'folder/file2.txt'])
+      # @example Remote path
+      #     Item.open({
+      #       source: 'http://a.com/file.jpg',
+      #       path: 'folder/file.jpg'
+      #     })
+      # @example Remote path with mixed origins
+      #     a = { source: 'http://a.com/file.jpg', path: 'folder/file1.jpg' }
+      #     b = { source: 'folder/file.jpg', path: 'folder/file2.jpg' }
+      #     c = { source: 's3:folder/file.jpg', path: 'folder/file3.jpg' }
+      #     Item.open([a, b, c])
+      #     # c is an example of retrieving files using an AWS S3 path
+      #
+      # @param origin [Array<Hash>, Array<String>, Hash, String]
+      # @return [Array<Item>]
+      def open(origin)
+        file_list = origin.kind_of?(Array) ? origin : [origin]
+        file_list.map { |entry| open_single(entry) }
+      end
+
+      # Takes in a single entry from {.open} and creates an {Item}.
+      #
+      # @param entry [Hash, String] the file metadata
+      # @return [Item] the file item
+      def open_single(entry)
+        if entry.kind_of?(Hash)
+          source = entry[:source]
+          path = entry[:path]
+        else
+          source = entry
+        end
+
+        Item.new({
+          path: path || File.basename(source),
+          content: retrieve(source)
+        })
+      end
+
+      # Retrieves the file content from `source`.
+      #
+      # @param source [String] local or remote location of the file content
+      # @return [File]
+      def retrieve(source)
+        if File.file?(source)
+          retrieve_local(source)
+        else
+          url = Helper.is_s3_path?(source) ? Helper.s3_url(source) : source
+          retrieve_remote(url)
+        end        
+      end
+
+      # Retrieves the local file.
+      #
+      # @param local_path [String] local path to the file
+      # @return [File]
+      def retrieve_local(local_path)
+        Worochi::Log.debug 'OPEN: ' + local_path
+        file = File.open(local_path)
+        Worochi::Log.debug "#{file.size} bytes"
+        file
+      end
+
+      # Downloads a remote file using {HTTP::Get}.
+      #
+      # @param file_url [String, URI] the URL of the file
+      # @return [Tempfile] the downloaded file
+      def retrieve_remote(file_url)
+        Worochi::Log.debug file_url.class
+        uri = URI(file_url)
+        Worochi::Log.debug 'GET: ' + uri.to_s
+
+        file = Tempfile.new('worochi_tmp_')
+        file.binmode
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = (uri.scheme == 'https')
+        request = Net::HTTP::Get.new uri
+
+        http.request request do |response|
+          response.read_body do |segment|
+            file.write segment
+          end
+        end
+        Worochi::Log.debug "Downloaded #{file.size} bytes"
+        file.rewind
+        file
+      end
+    end
+  end
+end

data/lib/worochi/log.rb

@@ -0,0 +1,41 @@
+require 'logger'
+
+class Worochi
+  class Log
+    SEVERITY_COLOR = {
+      'DEBUG' => 37,
+      'INFO' => 32,
+      'WARN' => 33,
+      'ERROR' => 31,
+      'FATAL' => 31
+    }
+    class << self
+      def init_log
+        @logger = Logger.new(STDOUT)
+        @logger.formatter = proc do |severity, datetime, progname, msg|
+          "[\033[#{SEVERITY_COLOR[severity]}m#{severity}\033[0m]: #{msg}\n"
+        end
+      end
+
+      def debug(message)
+        init_log if @logger.nil?
+        @logger.debug message
+      end
+
+      def warn(message)
+        init_log if @logger.nil?
+        @logger.warn message
+      end
+
+      def info(message)
+        init_log if @logger.nil?
+        @logger.info message
+      end
+
+      def error(message)
+        init_log if @logger.nil?
+        @logger.error message
+      end
+    end
+  end
+end

data/lib/worochi.rb

@@ -0,0 +1,114 @@
+require 'worochi/config'
+require 'worochi/error'
+require 'worochi/log'
+require 'worochi/helper'
+require 'worochi/item'
+require 'worochi/agent'
+
+class Worochi
+  @agents = []
+
+  class << self
+    # List of {Worochi::Agent} waiting for {Worochi.push}.
+    #
+    # @return [Array]
+    attr_reader :agents
+
+    # Creates a new {Worochi::Agent} and adds it to the list of agents
+    # listening to {Worochi.push} requests.
+    #
+    # @example
+    #     Worochi.create(:dropbox, 'as89h38nFBUSHFfuh99f', { dir: '/folder' })
+    # @example
+    #     opts = {
+    #       repo: 'darkmirage/worochi',
+    #       source: 'master',
+    #       target: 'temp',
+    #       commit_msg: 'Hello'
+    #     }
+    #     Worochi.create(:github, '6st46setsytgbhd64', opts)
+    #
+    # @param service [Symbol] service name as defined in {Config.services}
+    # @param token [String] authorization token for the service API
+    # @param opts [Hash] additional service-specific options
+    # @return [Worochi::Agent]
+    # @see Agent.new
+    def create(service, token, opts={})
+      opts[:service] = service
+      opts[:token] = token
+      agent = Agent.new(opts)
+      @agents << agent
+      agent
+    end
+
+    # Adds an exist {Worochi::Agent} to the list of agents listening to
+    # {Worochi.push} requests.
+    #
+    # @param agent [Worochi::Agent]
+    # @return [nil]
+    def add(agent)
+      @agents << agent
+      nil
+    end
+
+    # Remove a specific {Worochi::Agent} from the list of agents listening to
+    # {Worochi.push} requests.
+    #
+    # @param agent [Worochi::Agent]
+    # @return [nil]
+    def remove(agent)
+      @agents.delete(agent)
+      nil
+    end
+
+    # Remove all agents belonging to a given service from the list. Removes
+    # all agents if service is not specified. (See {.reset}).
+    #
+    # @example
+    #     Worochi.remove(:dropbox)
+    #
+    # @param service [Symbol] service name as defined in {Config.services}
+    # @return [nil]
+    def remove_service(service=nil)
+      if service.nil?
+        reset
+      else
+        @agents.reject! { |a| a.type == service }
+      end
+      nil
+    end
+
+    # Removes all agents from the list
+    #
+    # @return [nil]
+    def reset
+      @agents.clear
+    end
+
+    # List the active agents.
+    #
+    # @return [Array<String>]
+    def list
+      @agents.map { |a| a.to_s }
+    end
+
+    # @return [Integer] number of active agents.
+    def size
+      @agents.size
+    end
+
+    # Push list of files using the active agents in {.agents}. Refer to
+    # {Item.open} for how to format the file list.
+    #
+    # @param origin [Array<Hash>, Array<String>, Hash, String]
+    # @param opts [Hash] update agent options before pushing
+    # @return [Boolean] success
+    # @see Item.open
+    # @see Agent#push
+    def push(origin, opts={})
+      Log.warn 'No push targets specified' and return false if @agents.empty?
+      @agents.each { |agent| agent.push(origin, opts) }
+      true
+    end
+  end
+end

data/worochi.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name = 'worochi'
+  s.version = '0.0.0'
+  s.date = '2013-08-02'
+  s.summary = 'Worochi'
+  s.description = 'Provides a standard way to interface with Ruby API wrappers provided by various cloud storage services such as Dropbox and Google Drive.'
+  s.authors = ['Raven Jiang']
+  s.email = ['raven@cs.stanford.edu']
+  s.files = %w(README.md worochi.gemspec)
+  s.files += Dir.glob('lib/**/*.rb')
+  s.require_paths = ["lib"]
+  s.homepage = 'http://rubygems.org/gems/worochi'
+  s.license = 'MIT'
+end

metadata

@@ -0,0 +1,59 @@
+--- !ruby/object:Gem::Specification
+name: worochi
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Raven Jiang
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-08-02 00:00:00.000000000 Z
+dependencies: []
+description: Provides a standard way to interface with Ruby API wrappers provided
+  by various cloud storage services such as Dropbox and Google Drive.
+email:
+- raven@cs.stanford.edu
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- worochi.gemspec
+- lib/worochi/error.rb
+- lib/worochi/log.rb
+- lib/worochi/agent.rb
+- lib/worochi/helper/github.rb
+- lib/worochi/config.rb
+- lib/worochi/agent/sample.rb
+- lib/worochi/agent/github.rb
+- lib/worochi/agent/dropbox.rb
+- lib/worochi/helper.rb
+- lib/worochi/item.rb
+- lib/worochi.rb
+homepage: http://rubygems.org/gems/worochi
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.6
+signing_key: 
+specification_version: 4
+summary: Worochi
+test_files: []
+has_rdoc: