everbox_client 0.0.9

data/CHANGELOG.rdoc

@@ -0,0 +1,26 @@
+== 0.0.9 (2011-04-22)
+* now works under ruby 1.9.
+* now works under Windows.
+* everbox cat use stream download (0.0.8 will print it to stdout after all data
+  downloaded).
+
+== 0.0.8 (2011-04-22)
+
+* everbox help and everbox cat works.
+
+== 0.0.7 (2011-01-21)
+
+* everbox prepare_put works
+
+== 0.0.6 (2011-01-06)
+
+* everbox ls support argument as path
+* everbox config (print config or set config)
+
+== 0.0.5 (2010-12-02)
+
+* OAuth login: "everbox login --oauth"
+* show user info and space info: "everbox info"
+* only get download url (do not download it): "everbox get -u FILENAME"
+* gemspec no longer depends on git
+

data/README.rdoc

@@ -0,0 +1,38 @@
+= everbox_client - EverBox 命令行及调试工具
+
+== 安装
+
+    $ gem install everbox_client-0.0.8.gem
+
+== 使用方法
+
+=== 列出全部可用命令
+    $ everbox
+    Usage: everbox [options] <command>
+
+    Available commands:
+       cat            cat file
+       cd             change dir
+       config         set config
+       get            download file
+       help           print help info
+       info           show user info
+       login          login
+       ls             list files and directories
+       lsdir          list directories
+       mirror         download dir
+       mkdir          make directory
+       prepare_put    prepare put
+       put            upload file
+       pwd            print working dir
+       rm             delete file or directory
+
+=== 显示单个命令的帮助
+    $ everbox help login
+    Usage:
+
+      everbox login [username [password]]
+      登录 everbox, 登录完成后的 token 保存在 $HOME/.everbox_client/config
+
+      everbox login --oauth
+      以 OAuth 方式登录

data/bin/everbox

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require "everbox_client/cli"
+
+EverboxClient::CLI.execute(STDOUT, STDIN, STDERR, ARGV)

data/lib/everbox_client.rb

@@ -0,0 +1,11 @@
+require 'logger'
+
+module EverboxClient
+  autoload :PathEntry, 'everbox_client/models/path_entry'
+  autoload :User, 'everbox_client/models/user'
+  autoload :Account, 'everbox_client/models/account'
+
+  def self.logger
+    @logger ||= Logger.new(STDERR)
+  end
+end

data/lib/everbox_client/cli.rb

@@ -0,0 +1,129 @@
+require 'pp'
+
+require 'everbox_client/runner'
+
+module EverboxClient
+  class CLI
+    SUPPORTED_COMMANDS = {
+      "login"     => "login",
+      "ls"        => "list files and directories",
+      "lsdir"     => "list directories",
+      "get"       => "download file",
+      "put"       => "upload file",
+      "prepare_put" => "prepare put",
+      "cd"        => "change dir",
+      "pwd"       => "print working dir",
+      "mkdir"     => "make directory",
+      "rm"        => "delete file or directory",
+      "mirror"    => "download dir",
+      "info"      => "show user info",
+      "config"       => "set config",
+      "cat"       => "cat file",
+      "help"       => "print help info",
+      "thumbnail" => "get thumbnail url"
+    }
+
+    attr_reader :command
+    attr_reader :options
+    attr_reader :stdout, :stdin
+
+    def self.execute(stdout, stdin, stderr, arguments = [])
+      self.new.execute(stdout, stdin, stderr, arguments)
+    end
+
+    def initialize
+      @options = {}
+
+      # don't dump a backtrace on a ^C
+      trap(:INT) {
+        exit
+      }
+    end
+
+    def execute(stdout, stdin, stderr, arguments = [])
+      @stdout = stdout
+      @stdin  = stdin
+      @stderr = stderr
+      extract_command_and_parse_options(arguments)
+
+      if valid_command?
+        begin
+          runner = EverboxClient::Runner.new @opts
+          runner.send @command, *@args
+          runner.dump_config
+        rescue => e
+          raise e
+          STDERR.write "Error: #{e.message}\n"
+          exit 1
+        end
+      else
+        usage
+      end
+    end
+  protected
+
+
+    def extract_command_and_parse_options(arguments)
+      parse_options(arguments)
+      @command, *@args = ARGV
+    end
+    def option_parser(arguments = "")
+      option_parser = OptionParser.new do |opts|
+        opts.banner = "Usage: #{File.basename($0)} [options] <command>"
+
+        ## Common Options
+
+
+        #opts.on("--scope SCOPE", "Specifies the scope (Google-specific).") do |v|
+        #  options[:scope] = v
+        #end
+      end
+    end
+
+    def parse_options(arguments)
+      option_parser(arguments).order!(arguments)
+    end
+
+    def prepare_parameters
+      escaped_pairs = options[:params].collect do |pair|
+        if pair =~ /:/
+          Hash[*pair.split(":", 2)].collect do |k,v|
+            [CGI.escape(k.strip), CGI.escape(v.strip)] * "="
+          end
+        else
+          pair
+        end
+      end
+
+      querystring = escaped_pairs * "&"
+      cli_params = CGI.parse(querystring)
+
+      {
+        "oauth_consumer_key"     => options[:oauth_consumer_key],
+        "oauth_nonce"            => options[:oauth_nonce],
+        "oauth_timestamp"        => options[:oauth_timestamp],
+        "oauth_token"            => options[:oauth_token],
+        "oauth_signature_method" => options[:oauth_signature_method],
+        "oauth_version"          => options[:oauth_version]
+      }.reject { |k,v| v.nil? || v == "" }.merge(cli_params)
+    end
+
+    def usage
+      stdout.puts option_parser.help
+      stdout.puts
+      stdout.puts "Available commands:"
+      SUPPORTED_COMMANDS.keys.sort.each do |command|
+        desc = SUPPORTED_COMMANDS[command]
+        puts "   #{command.ljust(15)}#{desc}"
+      end
+    end
+
+    def valid_command?
+      SUPPORTED_COMMANDS.keys.include?(command)
+    end
+
+    def verbose?
+      options[:verbose]
+    end
+  end
+end

data/lib/everbox_client/exceptions.rb

@@ -0,0 +1,9 @@
+module EverboxClient
+  class Exception < RuntimeError; end
+
+  class UnknownResponseException < Exception
+    def initialize(response)
+      super("unknown response code: #{response.code}\n#{response.body}")
+    end
+  end
+end

data/lib/everbox_client/models/account.rb

@@ -0,0 +1,25 @@
+module EverboxClient
+  class Account
+    def initialize(data)
+      @data = data
+    end
+
+    def google?
+      @data["type"] == 'google'
+    end
+
+    def sdo?
+      @data["type"] == 'sdo'
+    end
+
+    def to_s
+      if google?
+        "Google Account: #{@data["email"]}"
+      elsif sdo?
+        "SDO Account: #{@data["name"]}"
+      else
+        "Unknown Account Type: #{@data["type"]}"
+      end
+    end
+  end
+end

data/lib/everbox_client/models/path_entry.rb

@@ -0,0 +1,47 @@
+module EverboxClient
+  class PathEntry
+    MASK_FILE = 0x1
+    MASK_DIR = 0x2
+    MASK_DELETED = 0x8000
+
+    def initialize(data)
+      @data = data
+    end
+
+    def basename
+      @data["path"].split('/')[-1]
+    end
+
+    def file?
+      (@data["type"] & MASK_FILE) != 0
+    end
+
+    def dir?
+      (@data["type"] & MASK_DIR) != 0
+    end
+
+    def deleted?
+      (@data["type"] & MASK_DELETED) != 0
+    end
+
+    def entries
+      @entries ||= 
+        begin
+          if @data["entries"].nil?
+            []
+          else
+            @data["entries"].map {|x| PathEntry.new(x)}
+          end
+        end
+    end
+
+    def path
+      @data["path"]
+    end
+
+    def to_line
+      suffix = dir? ? '/' : ''
+      "#{"%10d" % @data["fileSize"]}\t#{basename}#{suffix}\n"
+    end
+  end
+end

data/lib/everbox_client/models/user.rb

@@ -0,0 +1,23 @@
+require 'everbox_client'
+
+module EverboxClient
+  class User
+    def initialize(data)
+      @data = data
+    end
+
+    def to_s
+      res = ""
+      res << "username: #{@data["username"]}\n"
+      res << "email: #{@data["email"]}\n"
+      res << "\n"
+      unless @data["accounts"].empty?
+        res << "Accounts:\n"
+        @data["accounts"].each do |account|
+          res << "  " << Account.new(account).to_s << "\n"
+        end
+      end
+      res
+    end
+  end
+end

data/lib/everbox_client/runner.rb

@@ -0,0 +1,658 @@
+# encoding: utf-8
+require 'fileutils'
+require 'yaml'
+require 'digest/sha1'
+require 'pp'
+
+require 'oauth'
+require 'json'
+require 'highline/import'
+require 'restclient'
+require 'launchy'
+
+require 'everbox_client'
+require 'everbox_client/exceptions'
+
+
+class ResponseError < RuntimeError
+  attr_accessor :response
+  def initialize(response)
+    @response = response
+  end
+
+  def to_s
+    "code=#{response.code}|body=#{response.body}"
+  end
+end
+
+class File
+  # expan_path in unix style
+  def self.expand_path_unix(*args)
+    res = self.expand_path(*args)
+    if res[0] != '/'
+      res = res[res.index("/"), res.size]
+    end
+    res
+  end
+end
+
+module EverboxClient
+  class Runner
+    DEFAULT_OPTIONS = {
+      :pwd => '/home',
+      :config_file => '~/.everbox_client/config',
+      :consumer_key => 'TFshQutcGMifMPCtcUFWsMtTIqBg8bAqB55XJO8P',
+      :consumer_secret => '9tego848novn68kboENkhW3gTy9rE2woHWpRwAwQ',
+      :oauth_site => 'http://account.everbox.com',
+      :fs_site => 'http://fs.everbox.com',
+      :chunk_size => 1024*1024*4
+
+    }
+
+    def initialize(opts={})
+      opts ||= {}
+      config_file = opts[:config_file] || DEFAULT_OPTIONS[:config_file]
+      @options = DEFAULT_OPTIONS.merge(load_config(config_file)).merge(opts)
+    end
+
+    def help(arg = nil)
+      case arg
+      when nil
+        puts "Usage: everbox help COMMAND"
+      when 'cat'
+        puts "Usage: everbox cat [PATH]..."
+      when 'cd'
+        puts <<DOC
+Usage: everbox cd [newpath]
+切换工作目录, newpath 可以是相对路径或者绝对路径, 没有 newpath 会切换目录到 "/home"
+注意: cd 并不会检查服务器上该目录是否真的存在
+DOC
+      when 'config'
+        puts <<DOC
+Usage:
+  everbox config
+  显示当前的配置
+
+  everbox config KEY VALUE
+  设置配置
+DOC
+      when 'get'
+        puts <<DOC
+Usage: everbox get [-u] FILENAME
+下载文件, 注意可能会覆盖本地的同名文件, 如果指定 "-u", 则只打印下载 url
+DOC
+      when 'info'
+        puts <<DOC
+Usage: everbox info
+显示用户信息
+DOC
+      when 'login'
+        puts <<DOC
+Usage:
+
+  everbox login [username [password]]
+  登录 everbox, 登录完成后的 token 保存在 $HOME/.everbox_client/config
+
+  everbox login --oauth
+  以 OAuth 方式登录
+DOC
+      when 'ls'
+        puts <<DOC
+Usage: everbox ls [path]
+显示当前目录下的文件和目录
+DOC
+      when 'lsdir'
+        puts <<DOC
+Usage: everbox lsdir
+显示当前目录下的目录
+DOC
+
+      when 'mirror'
+        puts <<DOC
+Usage:
+  everbox mirror DIRNAME
+  下载目录到本地
+
+  everbox mirror -R DIRNAME
+  上传目录到服务器
+DOC
+      when 'mkdir'
+        puts <<DOC
+Usage: everbox mkdir DIRNAME
+创建目录
+DOC
+      when 'prepare_put'
+        puts <<DOC
+Usage: everbox prepare_put FILENAME
+只运行 prepare_put 部分
+DOC
+      when 'put'
+        puts <<DOC
+Usage: everbox put FILENAME [FILENAME]...
+上传文件
+DOC
+      when 'pwd'
+        puts <<DOC
+Usage: everbox pwd
+显示当前目录
+DOC
+      when 'rm'
+        puts <<DOC
+Usage: everbox rm DIRNAME [DIRNAME]...
+删除文件或目录
+DOC
+      else
+        puts "Not Documented"
+      end
+    end
+
+    def config(*args)
+      if args.size == 0
+        @options.each do |k, v|
+          puts "#{k}\t#{v}"
+        end
+      elsif args.size == 2
+        @options[args[0].to_sym] = args[1]
+      else
+        raise "Usage: everbox config [KEY VALUE]"
+      end
+    end
+
+
+    def login(*args)
+      if args[0] == '-o' or args[0] == '--oauth'
+        return login_oauth
+      end
+
+      @username = args.shift
+      @password = args.shift
+
+      raise "too many arguments" unless args.empty?
+
+      if @username.nil?
+        @username = ask("Enter your username:  ") { |q| q.echo = true }
+      end
+      if @password.nil?
+        @password = ask("Enter your password:  ") { |q| q.echo = "*" }
+      end
+
+      response = consumer.request(:post, "/oauth/quick_token?login=#{CGI.escape @username}&password=#{CGI.escape @password}")
+      if response.code.to_i != 200
+        raise "login failed: #{response.body}"
+      end
+
+      d = CGI.parse(response.body).inject({}) do |h,(k,v)|
+        h[k.strip.to_sym] = v.first
+        h[k.strip]        = v.first
+        h
+      end
+
+      access_token = OAuth::AccessToken.from_hash(self, d)
+      @options[:access_token] = access_token.token
+      @options[:access_secret] = access_token.secret
+      puts @options.inspect
+    end
+
+    def ls(path = '.')
+      data = {:path => File.expand_path_unix(path, @options[:pwd])}
+      response = access_token.post(fs(:get), JSON.dump(data), {'Content-Type' => 'text/plain' })
+      fail response.inspect if response.code != "200"
+      info = JSON.parse(response.body)
+      info["entries"].each do |entry|
+        entry = PathEntry.new(entry)
+        puts entry.to_line
+      end
+    end
+
+    def lsdir
+      data = {:path => @options[:pwd]}
+      info = JSON.parse(access_token.post(fs(:get), JSON.dump(data), {'Content-Type' => 'text/plain' }).body)
+      info["entries"].each do |entry|
+        entry = PathEntry.new(entry)
+        puts entry.to_line if entry.dir?
+      end
+    end
+
+    def mkdir(path)
+      path = File.expand_path_unix(path, @options[:pwd])
+      make_remote_path(path)
+    end
+
+    def make_remote_path(path, opts = {})
+      data = {
+        :path => path,
+        :editTime => edit_time
+      }
+      response = access_token.post(fs(:mkdir), data.to_json, {'Content-Type' => 'text/plain'})
+      case response.code
+      when "200"
+        #
+      when "409"
+        unless opts[:ignore_conflict]
+          raise Exception, "directory already exist: `#{path}'"
+        end
+      end
+    end
+
+    def rm(*pathes)
+      fail "at least one path required" if pathes.empty?
+      pathes = pathes.map {|path| File.expand_path_unix(path, @options[:pwd])}
+
+      data = {
+        :paths => pathes,
+      }
+      response = access_token.post(fs(:delete), data.to_json, {'Content-Type' => 'text/plain'})
+      case response.code
+      when "200"
+        #
+      when "409"
+        raise Exception, "directory already exist: `#{path}'"
+      else
+        raise UnknownResponseException, response
+      end
+    end
+
+
+    def get(*args)
+      filename = args.shift
+      url_only = false
+      if filename == '-u'
+        url_only = true
+        filename = args.shift
+      end
+
+      raise ArgumentError, "filename is required" if filename.nil?
+
+      path = File.expand_path_unix(filename, @options[:pwd])
+      download_file(path, File.expand_path_unix('.'), :url_only => url_only)
+    end
+
+    def cat(*args)
+      args.each do |filename|
+        path = File.expand_path_unix(filename, @options[:pwd])
+        data = {:path => path}
+        response = access_token.post(fs(:get), JSON.dump(data), {'Content-Type' => 'text/plain' })
+        fail response.inspect if response.code != "200"
+        url = JSON.parse(response.body)["dataurl"]
+        Net::HTTP.get_response(URI.parse(url)) do |response|
+          fail response.inspect if response.code != "200"
+          response.read_body do |seg|
+            STDOUT.write(seg)
+            STDOUT.flush
+          end
+        end
+      end
+    end
+
+    def thumbnail(*args)
+      args.each do |filename|
+        path = File.expand_path_unix(filename, @options[:pwd])
+        if ['.flv', '.mp4', '.3gp'].include? File.extname(path).downcase
+          aimType = '0x20000'
+        else
+          aimType = '0'
+        end
+        data = {:path => path, :aimType => aimType}
+        response = access_token.post(fs('/2/thumbnail'), JSON.dump(data), {'Content-Type' => 'text/plain' })
+        fail response.inspect if response.code != "200"
+        puts JSON.parse(response.body)["url"]
+      end
+    end
+
+    def download_file(path, local_path, opts = {})
+      data = {:path => path}
+      info = JSON.parse(access_token.post(fs(:get), JSON.dump(data), {'Content-Type' => 'text/plain' }).body)
+      if opts[:url_only]
+        puts info["dataurl"]
+      else
+        puts "Downloading `#{File.basename(path)}' with curl"
+        ofname = File.expand_path_unix(File.basename(path), local_path)
+        system('curl', '-o', ofname, info["dataurl"])
+      end
+    end
+
+    def put(*filenames)
+      fail "at lease one FILE required" if filenames.empty?
+      filenames.each do |filename|
+        puts "uploading #{filename}"
+        upload_file(filename, @options[:pwd])
+        puts
+      end
+    end
+
+    def prepare_put(filename)
+      _get_upload_urls(filename, @options[:pwd])["required"].each do |x|
+        puts "#{x["index"]}\t#{x["url"]}"
+      end
+    end
+
+
+    def _get_upload_urls(filename, remote_path)
+      basename = File.basename(filename)
+      target_path = File.expand_path_unix(basename, remote_path)
+      keys = calc_digests(filename)
+      params = {
+        :path      => target_path,
+        :keys      => keys,
+        :chunkSize => @options[:chunk_size],
+        :fileSize  => File.open(filename).stat.size,
+        :base      => ''
+      }
+      JSON.parse(access_token.post(fs(:prepare_put), JSON.dump(params), {'Content-Type' => 'text/plain' }).body)
+    end
+
+    def upload_file(filename, remote_path)
+      basename = File.basename(filename)
+      target_path = "#{remote_path}/#{basename}"
+      keys = calc_digests(filename)
+      params = {
+        :path      => target_path,
+        :keys      => keys,
+        :chunkSize => @options[:chunk_size],
+        :fileSize  => File.open(filename).stat.size,
+        :base      => ''
+      }
+      begin
+        response = access_token.post(fs(:prepare_put), JSON.dump(params), {'Content-Type' => 'text/plain' })
+        raise ResponseError.new(response) if response.code != '200'
+      rescue ResponseError => e
+        if e.response.code != '409'
+          puts "[PREPARE_PUT] meet #{e.message}, retry"
+          retry
+        else
+          raise
+        end
+      end
+      info = JSON.parse(response.body)
+      raise "bad response: #{info}" if info["required"].nil?
+      File.open(filename) do |f|
+        info["required"].each do |x|
+          begin
+            puts "upload block ##{x["index"]}"
+            f.seek(x["index"] * @options[:chunk_size])
+            code, response = http_request x['url'], f.read(@options[:chunk_size]), :method => :put
+            if code != 200
+              raise code.to_s
+            end
+          rescue => e
+            puts "[UPLOAD_BLOCK] meet #{e.class}: #{e.message}, retry"
+            retry
+          end
+        end
+      end
+
+
+      ftime = (Time.now.to_i * 1000 * 1000 * 10).to_s
+      params = params.merge :editTime => ftime, :mimeType => 'application/octet-stream'
+      code, response = access_token.post(fs(:commit_put), params.to_json, {'Content-Type' => 'text/plain'})
+      pp code, response
+    rescue ResponseError
+      raise
+    rescue => e
+      puts "[UPLOAD_FILE] meet #{e.class}: #{e.message}, retry"
+      retry
+    end
+
+
+    def dump_config
+      config = {}
+      [:access_token, :access_secret, :pwd, :consumer_key, :consumer_secret, :oauth_site, :fs_site].each do |k|
+        config[k] = @options[k] unless @options[k].nil?
+      end
+      save_config(@options[:config_file], config)
+    end
+
+    def pwd
+      puts @options[:pwd]
+    end
+
+    def cd(newpath = nil)
+      newpath ||= "/home"
+      @options[:pwd] = File.expand_path_unix(newpath, @options[:pwd])
+      @options[:pwd] = "/home" unless @options[:pwd].start_with? "/home"
+      puts "current dir: #{@options[:pwd]}"
+    end
+
+    def mirror(*args)
+      raise Exception, "everbox mirror [-R] pathname" if args.empty?
+
+      upload = false
+      if args[0] == '-R'
+        upload = true
+        args.shift
+      end
+
+      path = args.shift
+      if path == '--'
+        path = args.shift
+      end
+
+      if path.nil? or ! args.empty?
+        raise Exception, "everbox mirror [-R] pathname"
+      end
+
+      if upload
+        upload_path(path)
+      else
+        download_path(path)
+      end
+    end
+
+    def upload_path(path)
+      local_path = File.expand_path_unix(path)
+      remote_path = @options[:pwd]
+
+      jobs = []
+      jobs << [remote_path, local_path]
+      until jobs.empty?
+        remote_path, local_path = jobs.pop
+        if File.directory? local_path
+          puts "upload dir: #{local_path}"
+          new_remote_path = File.expand_path_unix(File.basename(local_path), remote_path)
+          begin
+            make_remote_path(new_remote_path, :ignore_conflict=>true)
+          rescue => e
+            puts "[MAKE_REMOTE_PATH] meet #{e.class}: #{e}, retry"
+            retry
+          end
+
+          remote_filenames = []
+          data = {:path => new_remote_path}
+          response = access_token.post(fs(:get), JSON.dump(data), {'Content-Type' => 'text/plain' })
+          fail response.inspect if response.code != "200"
+          info = JSON.parse(response.body)
+          info["entries"].each do |entry|
+            entry = PathEntry.new(entry)
+            remote_filenames << entry.basename if entry.file?
+          end
+
+          Dir.entries(local_path).each do |filename|
+            next if ['.', '..'].include? filename
+            if remote_filenames.include? filename
+              puts "file already exist, ignored: #{filename}"
+              next
+            end
+            x = "#{local_path}/#{filename}"
+            if ! File.symlink? x and (File.directory? x or File.file? x)
+              jobs << [new_remote_path, x]
+            end
+          end
+        elsif File.file? local_path and ! File.symlink? local_path
+          puts "uploading #{local_path}"
+          begin
+            upload_file(local_path, remote_path)
+          rescue ResponseError => e
+            if e.response.code == "409"
+              puts "file already exist, ignored"
+            else
+              raise e
+            end
+          end
+        end
+      end
+    end
+
+    def download_path(path)
+      local_path = File.expand_path_unix('.')
+      remote_path = File.expand_path_unix(path, @options[:pwd])
+
+      jobs = []
+      jobs << [remote_path, local_path]
+
+      until jobs.empty?
+        remote_path, local_path = jobs.pop
+        entry = path_info(remote_path)
+        if entry.nil? or entry.deleted?
+          next
+        end
+
+        if entry.dir?
+          new_local_path = File.expand_path_unix(entry.basename, local_path)
+          FileUtils.makedirs(new_local_path)
+          entry.entries.each do |x|
+            jobs << [x.path, new_local_path]
+          end
+        else
+          download_file(remote_path, local_path)
+        end
+      end
+    end
+
+    # 显示用户信息
+    def info
+      user_info
+      puts
+      fs_info
+    end
+
+    def user_info
+      response = access_token.get '/api/1/user_info'
+      if response.code == '200'
+        res = JSON.parse(response.body)
+        if res["code"] == 0
+          user = User.new(res["user"])
+          puts user
+          return
+        end
+      end
+      puts "fetch user info failed"
+      puts "  code: #{response.code}"
+      puts "  body: #{response.body}"
+    end
+
+    def fs_info
+      response = access_token.get fs :info
+      data = JSON.parse(response.body)
+      puts "Disk Space Info"
+      puts "  used: #{data["used"]}"
+      puts "  total: #{data["total"]}"
+    end
+  protected
+
+    def fs(path)
+      path = path.to_s
+      path = '/' + path unless path.start_with? '/'
+      @options[:fs_site] + path
+    end
+
+    def login_oauth
+      request_token = consumer.get_request_token
+      url = request_token.authorize_url
+      puts "open url in your browser: #{url}"
+      Launchy.open(url)
+      STDOUT.write "please input the verification code: "
+      STDOUT.flush
+      verification_code = STDIN.readline.strip
+      access_token = request_token.get_access_token :oauth_verifier => verification_code
+      @options[:access_token] = access_token.token
+      @options[:access_secret] = access_token.secret
+      puts @options.inspect
+    end
+
+    def path_info(path)
+      data = {:path => path}
+      info = JSON.parse(access_token.post(fs(:get), JSON.dump(data), {'Content-Type' => 'text/plain' }).body)
+      PathEntry.new(info)
+    end
+
+    def consumer
+      OAuth::Consumer.new @options[:consumer_key], @options[:consumer_secret], {
+        :site => @options[:oauth_site]
+      }
+    end
+
+    def access_token
+      raise "please login first" if @options[:access_token].nil? or @options[:access_secret].nil?
+      OAuth::AccessToken.new(consumer, @options[:access_token], @options[:access_secret])
+    end
+
+    def load_config(config_file)
+      YAML.load_file(File.expand_path_unix(config_file))
+    rescue Errno::ENOENT
+      {}
+    rescue => e
+      EverboxClient.logger.info("load config file #{config_file} failed: #{e.class}")
+      {}
+    end
+
+    def save_config(config_file, config)
+      config_file = File.expand_path_unix(config_file)
+      FileUtils.makedirs(File.dirname(config_file))
+      File.open(config_file, 'w') do |ofile|
+        YAML.dump(config, ofile)
+      end
+    end
+
+    def calc_digests(fname)
+      res = []
+      File.open(fname) do |ifile|
+        while (data = ifile.read(@options[:chunk_size])) do
+          res << urlsafe_base64(Digest::SHA1.digest(data))
+        end
+      end
+      res
+    end
+
+    def urlsafe_base64(content)
+      Base64.encode64(content).strip.gsub('+', '-').gsub('/','_')
+    end
+
+    def http_request url, data = nil, options = {}
+      begin
+        options[:method] = :post unless options[:method]
+        case options[:method]
+        when :get
+          response = RestClient.get url, data, :content_type => options[:content_type]
+        when :post
+          response = RestClient.post url, data, :content_type => options[:content_type]
+        when :put
+          response = RestClient.put url, data
+        end
+        body = response.body
+        data = nil
+        data = JSON.parse body unless body.empty?
+        [response.code.to_i, data]
+      rescue => e
+        EverboxClient.logger.error e
+        code = 0
+        data = nil
+        body = nil
+        res = e.response if e.respond_to? :response
+        begin
+          code = res.code if res.respond_to? :code
+          body = res.body if res.respond_to? :body
+          data = JSON.parse body unless body.empty?
+        rescue
+          data = body
+        end
+        [code, data]
+      end
+    end
+
+    def edit_time(time = nil)
+      time ||= Time.now
+      (time.to_i * 1000 * 1000 * 10).to_s
+    end
+
+  end
+end

data/lib/everbox_client/version.rb

@@ -0,0 +1,3 @@
+module EverboxClient
+  VERSION = "0.0.9"
+end

data/spec/everbox_client/models/path_entry_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+require 'json'
+
+require 'everbox_client'
+
+module EverboxClient
+  describe PathEntry do
+    context "path" do
+      ENTRY_1 = %Q[{"editTime":"12898149764580000","ver":"MDAwMDAwMDAwMDAwMDAwOQ==","type":2,"path":"/home/foo","fileSize":"1932891"}]
+
+      it "should works" do
+        entry = PathEntry.new(JSON.parse(ENTRY_1))
+        entry.file?.should == false
+        entry.dir?.should == true
+        entry.deleted?.should == false
+        entry.basename.should == "foo"
+        entry.to_line.should == "1932891\tfoo/\n"
+      end
+    end
+
+    context "file" do
+      ENTRY_1 = %Q[{"editTime":"12898149764580000","ver":"MDAwMDAwMDAwMDAwMDAwOQ==","type":1,"path":"/home/foo","fileSize":"1932891"}]
+
+      it "should works" do
+        entry = PathEntry.new(JSON.parse(ENTRY_1))
+        entry.file?.should == true
+        entry.dir?.should == false
+        entry.deleted?.should == false
+        entry.basename.should == "foo"
+        entry.to_line.should == "1932891\tfoo\n"
+      end
+    end
+  end
+end

data/spec/everbox_client/runner_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+require 'everbox_client/runner'
+
+module EverboxClient
+  describe Runner do
+    it "should works" do
+      Runner.new.ls
+    end
+  end
+end

data/spec/everbox_client_spec.rb

@@ -0,0 +1,7 @@
+require 'everbox_client'
+
+describe EverboxClient do
+  it "autoload should works" do
+    EverboxClient::PathEntry.should be_a(Class)
+  end
+end

metadata

@@ -0,0 +1,151 @@
+--- !ruby/object:Gem::Specification 
+name: everbox_client
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 0.0.9
+platform: ruby
+authors: 
+- LI Daobing
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-12-13 00:00:00 +08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: oauth
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: highline
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: json_pure
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rest-client
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: launchy
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :runtime
+  version_requirements: *id005
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id006 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id006
+- !ruby/object:Gem::Dependency 
+  name: rdoc
+  prerelease: false
+  requirement: &id007 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+  type: :development
+  version_requirements: *id007
+description: EverBox Command Tool
+email: 
+- lidaobing@gmail.com
+executables: 
+- everbox
+extensions: []
+
+extra_rdoc_files: 
+- README.rdoc
+- CHANGELOG.rdoc
+files: 
+- bin/everbox
+- lib/everbox_client.rb
+- lib/everbox_client/version.rb
+- lib/everbox_client/models/path_entry.rb
+- lib/everbox_client/models/account.rb
+- lib/everbox_client/models/user.rb
+- lib/everbox_client/runner.rb
+- lib/everbox_client/cli.rb
+- lib/everbox_client/exceptions.rb
+- spec/everbox_client_spec.rb
+- spec/spec_helper.rb
+- spec/everbox_client/models/path_entry_spec.rb
+- spec/everbox_client/runner_spec.rb
+- README.rdoc
+- CHANGELOG.rdoc
+has_rdoc: true
+homepage: http://www.everbox.com/
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.5.3
+signing_key: 
+specification_version: 3
+summary: EverBox Command Tool
+test_files: 
+- spec/everbox_client_spec.rb
+- spec/spec_helper.rb
+- spec/everbox_client/models/path_entry_spec.rb
+- spec/everbox_client/runner_spec.rb