clouddrive 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 8d64073347f2f8b488312ea58fad514dba3c1cb6
+  data.tar.gz: 8395374122e477a41de9987861a7f1fc4b013329
+SHA512:
+  metadata.gz: 8781961a4a644e9839084f17e6f234326ab00548864c3fb7dc67c824f49f069c6bc570fd82bc20350e15b2847e8add9f23b70f6095688a219bfa6cee48b04ba7
+  data.tar.gz: 3ea157a6089a9abf9310addd4d027343e00ab7bbf000fcc0e415301fadaf4705074386b6574fa90af4c824fe44741009a3f0f7ce4c1f5e57b49188e931a6f697

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.idea/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.2.1

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,13 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, we pledge to respect all people who contribute through reporting issues, posting feature requests, updating documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free experience for everyone, regardless of level of experience, gender, gender identity and expression, sexual orientation, disability, personal appearance, body size, race, age, or religion.
+
+Examples of unacceptable behavior by participants include the use of sexual language or imagery, derogatory comments or personal attacks, trolling, public or private harassment, insults, or other unprofessional conduct.
+
+Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct. Project maintainers who do not follow the Code of Conduct may be removed from the project team.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by opening an issue or contacting one or more of the project maintainers.
+
+This Code of Conduct is adapted from the [Contributor Covenant](http:contributor-covenant.org), version 1.0.0, available at [http://contributor-covenant.org/version/1/0/0/](http://contributor-covenant.org/version/1/0/0/)

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in clouddrive.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 TODO: Write your name
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,73 @@
+# CloudDrive SDK and CLI
+
+This i a Ruby project built to interact with Amazon's CloudDrive API. It works as both an SDK and a CLI in the sense that I've built the code to easily be implemented in your own projects but it also includes an executable to run many common processes right from the command line.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'clouddrive'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install clouddrive
+
+## CLI Usage
+
+The CLI is used by running `clouddrive` with one of the following commands followed by any necessary arguments (use `help` argument before any of the following commands for more information).
+
+```bash
+init        Initialize the CLI with your Amazon email and CloudDrive API credentials
+sync        Sync the local cache with Amazon CloudDrive
+clearcache  Clear the local cache
+metadata    Output JSON-formatted metadata related to the remote file give its remote path
+```
+
+## SDK Usage
+
+### Account
+
+#### Initialization
+
+The CloudDrive SDK first needs have an authenticated `Account` object which can then be passed into the different classes for API calls.
+
+The `Account` class is created by passing in the `email`, `client_id`, and `client_secret` into the constructor and calling the `authorize` method. This will handle authorizing and (if necessary) renewing authorization.
+
+The initial `authorize` method call will return false with an `auth_url` key in its `data`. This URL can then be passed into a second `authorize` call which will parse out the `code` parameter and complete the initial OAuth process.
+
+```ruby
+account = CloudDrive::Account.new("me@example.com", "my-client-id", "clientsecret")
+account.authorize
+...
+account.authorize(auth_url)
+```
+
+The `authorize` method call will still need to be called periodically to renew its authorization as the OAuth token expires every 60 minutes.
+
+####  Local Cache
+
+By default, the SDK stores all necessary information (OAuth token information, local account caches, etc) into `~/.clouddrive`. Each account (email), has its own cache file and local cache database of its remote filesystem. Once authenticated, the local cache is initially synced with the remote CloudDrive by calling the `sync` method.
+
+```ruby
+account.sync
+```
+
+Every time `sync` is called, it will update the local cache with all changes since the last `sync` call. The local cache can be cleared out and reset by calling `clear_cache`.
+
+```ruby
+account.clear_cache
+```
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/clouddrive/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/clouddrive

@@ -0,0 +1,151 @@
+require 'thor'
+require 'clouddrive'
+require 'yaml'
+require 'json'
+
+module CloudDrive
+  class CLI < Thor
+
+    def initialize(*args)
+      super
+      @config_path = File.expand_path('~/.clouddrive') + "/"
+    end
+
+    desc "init", "Initialize app with Amazon e-mail and CloudDrive credentials"
+    option :email, :aliases => :e
+    option :client_id, :aliases => :i
+    option :client_secret, :aliases => :s
+    option :auth_url, :aliases => :u
+    def init
+      email = options[:email]
+      client_id = options[:client_id]
+      client_secret = options[:client_secret]
+
+      config = read_config
+
+      if email != nil
+        config[:email] = email
+      end
+
+      if client_id != nil
+        config[:client_id] = client_id
+      end
+
+      if client_secret != nil
+        config[:client_secret] = client_secret
+      end
+
+      if config[:email] == nil
+        puts "Email is required for authorization"
+        exit
+      end
+
+      if config[:client_id] == nil || config[:client_secret] == nil
+        puts "Amazon CloudDrive API credentials required"
+        exit
+      end
+
+      save_config(config)
+
+      account = CloudDrive::Account.new(config[:email], config[:client_id], config[:client_secret])
+      result = account.authorize
+      if result[:success] === false
+        if result[:data]["message"] == "Initial authorization required."
+          puts "Initiali authorization required. Navigate to the following URL and paste in the redirect URL here."
+          url = ask(result[:data]["auth_url"] + "\n")
+          result = account.authorize(url)
+          if result[:success]
+            puts "Successfully authenticated with Amazon CloudDrive"
+          else
+            puts "Failed to authenticate with Amazon CloudDrive: #{result[:data].to_json}"
+          end
+        end
+      else
+        puts "Already authenticated with Amazon CloudDrive"
+      end
+    end
+
+    desc "sync", "Sync local cache with Amazon CloudDrive"
+    long_desc <<'LONGDESC'
+    Syncing the nodes from Amazon CloudDrive to a local database allows for quicker
+    API calls as well as the ability for some operations to be performed 'offline'.
+    Before running any commands that alter data remotely, the local cache should
+    always be synced up.
+LONGDESC
+    def sync
+      setup
+      @account.authorize
+      @account.sync
+    end
+
+    desc "clearcache", "Clear local nodes cache"
+    def clearcache
+      setup
+      @account.authorize
+      @account.clear_cache
+    end
+
+    desc 'metadata REMOTE_PATH', 'Retrieve the node\'s metadata given its remote path'
+    def metadata(path)
+      setup
+      @account.authorize
+      api = CloudDrive::Node.new(@account)
+
+      if (node = api.find_by_path(path)) != nil
+        puts node.to_json
+      else
+        puts "File does not exist."
+      end
+    end
+
+    desc "mkdir REMOTE_PATH", "Create (recursively) a new remote directory"
+    def mkdir(path)
+      setup
+      @account.authorize
+      node = CloudDrive::Node.new(@account)
+
+      result = node.create_directory_path(path)
+      if result[:success]
+        puts "Successfully created new directory path: #{result[:data].to_json}"
+      else
+        puts "Failed to create new directory path: #{result[:data].to_json}"
+      end
+    end
+
+    private
+
+    def setup
+      config = read_config
+      @account = CloudDrive::Account.new(config[:email], config[:client_id], config[:client_secret])
+    end
+
+    def read_config
+      if File.exists?("#{@config_path}config.yaml")
+        return YAML.load_file("#{@config_path}config.yaml")
+      else
+        if !File.exists?(@config_path)
+          Dir.mkdir(@config_path)
+        end
+      end
+
+      {
+          :email => nil,
+          :client_id => nil,
+          :client_secret => nil
+      }
+    end
+
+    def save_config config
+      if !File.exists?(@config_path)
+        Dir.mkdir(@config_path)
+      end
+
+      File.open("#{@config_path}config.yaml", 'w') do |file|
+        file.write(config.to_yaml)
+      end
+    end
+
+  end
+end
+
+CloudDrive::CLI.start( ARGV )

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "clouddrive"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/clouddrive.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'clouddrive/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "clouddrive"
+  spec.version       = CloudDrive::VERSION
+  spec.authors       = ["Alex Phillips"]
+  spec.email         = ["exonintrendo@gmail.com"]
+
+  spec.summary       = %q{CloudDrive for Ruby}
+  spec.description   = %q{Ruby SDK and command line application for Amazon's CloudDrive}
+  spec.homepage      = "https://github.com/exonintrendo/clouddrive"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  # if spec.respond_to?(:metadata)
+  #   spec.metadata['allowed_push_host'] = "TODO: Set to 'http://mygemserver.com'"
+  # else
+  #   raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
+  # end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) } + Dir['lib/**/*.rb']
+  spec.bindir        = "bin"
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+
+  spec.add_runtime_dependency "rest-client", "~> 1.8"
+  spec.add_runtime_dependency "thor", "~> 0.19"
+  spec.add_runtime_dependency "sqlite3", "~>1.3"
+end

data/lib/clouddrive.rb

@@ -0,0 +1,7 @@
+require "clouddrive/version"
+require "clouddrive/account"
+require "clouddrive/node"
+
+module CloudDrive
+  # Your code goes here...
+end

data/lib/clouddrive/account.rb

@@ -0,0 +1,307 @@
+require 'json'
+require 'cgi'
+require 'rest-client'
+require 'sqlite3'
+
+module CloudDrive
+
+  class Account
+
+    attr_reader :access_token, :metadata_url, :content_url, :email, :token_store, :db
+
+    def initialize(email, client_id, client_secret)
+      @email = email
+      @cache_file = File.expand_path("~/.clouddrive/#{email}.cache")
+      @client_id = client_id
+      @client_secret = client_secret
+
+      @db = SQLite3::Database.new(File.expand_path("~/.clouddrive/#{@email}.db"))
+      if @db.execute("SELECT name FROM sqlite_master WHERE type='table' AND name='nodes';").empty?
+        @db.execute <<-SQL
+         CREATE TABLE nodes(
+            id VARCHAR PRIMARY KEY NOT NULL,
+            name VARCHAR NOT NULL,
+            kind VARCHAR NOT NULL,
+            md5 VARCHAR,
+            created DATETIME NOT NULL,
+            modified DATETIME NOT NULL,
+            raw_data TEXT NOT NULL
+         );
+        SQL
+      end
+    end
+
+    def authorize(auth_url = nil)
+      retval = {
+        :success => true,
+        :data => {}
+      }
+
+      @token_store = {
+          "checkpoint" => nil,
+          "nodes" => {}
+      }
+
+      if File.exists?(@cache_file)
+        @token_store = JSON.parse(File.read(@cache_file))
+      end
+
+      if !@token_store.has_key?("access_token")
+        if auth_url.nil?
+          retval = {
+            :success => false,
+            :data => {
+              "message" => "Initial authorization required",
+              "auth_url" => "https://www.amazon.com/ap/oa?client_id=#{@client_id}&scope=clouddrive%3Aread%20clouddrive%3Awrite&response_type=code&redirect_uri=http://localhost"
+            }
+          }
+
+          return retval
+        else
+          data = request_authorization(auth_url)
+        end
+
+        if data[:success] === true
+          @token_store = data[:data]
+        else
+          return data
+        end
+
+        save_token_store
+      elsif (Time.new.to_i - @token_store["last_authorized"]) > 60
+        data = renew_authorization
+        if data[:success] === false
+          return data
+        end
+      end
+
+      @access_token = @token_store["access_token"]
+
+      if !@token_store.has_key?("metadataUrl") || !@token_store.has_key?("contentUrl")
+        result = get_endpoint
+        if result[:success] === true
+          @metadata_url = result[:data]["metadataUrl"]
+          @content_url = result[:data]["contentUrl"]
+          @token_store["contentUrl"] = @content_url
+          @token_store["metadataUrl"] = @metadata_url
+
+          save_token_store
+        end
+      end
+
+      @metadata_url = @token_store["metadataUrl"]
+      @content_url = @token_store["contentUrl"]
+
+      retval
+    end
+
+    def clear_cache
+      @token_store["nodes"] = {}
+      @token_store["checkpoint"] = nil
+      save_token_store
+    end
+
+    def get_endpoint
+      retval = {
+          :success => false,
+          :data => {}
+      }
+      RestClient.get("https://cdws.us-east-1.amazonaws.com/drive/v1/account/endpoint", {:Authorization => "Bearer #{@access_token}"}) do |response, request, result|
+        retval[:data] = JSON.parse(response.body)
+        if response.code === 200
+          retval[:success] = true
+        end
+      end
+
+      retval
+    end
+
+    def get_quota
+      retval = {
+          :success => false,
+          :data => {}
+      }
+
+      RestClient.get("#{@metadata_url}account/quota", {:Authorization => "Bearer #{@access_token}"}) do |response, request, result|
+        retval[:data] = JSON.parse(response.body)
+        if response.code === 200
+          retval[:success] = true
+        end
+      end
+
+      retval
+    end
+
+    def get_usage
+      retval = {
+          :success => false,
+          :data => {}
+      }
+
+      RestClient.get("#{@metadata_url}account/usage", {:Authorization => "Bearer #{@access_token}"}) do |response, request, result|
+        retval[:data] = JSON.parse(response.body)
+        if response.code === 200
+          retval[:success] = true
+        end
+      end
+
+      retval
+    end
+
+    def nodes
+      @token_store["nodes"]
+    end
+
+    def request_authorization(auth_url)
+      retval = {
+          :success => false,
+          :data => {}
+      }
+
+      params = CGI.parse(URI.parse(auth_url).query)
+      if !params.has_key?('code')
+        retval[:data]["message"] = "No authorization code exists in the callback URL: #{params}"
+
+        return retval
+      end
+
+      code = params["code"]
+
+      # Get token
+      #
+      # @TODO: why do I need to do this with code? (i.e., code[0])
+      body = {
+          'grant_type' => "authorization_code",
+          'code' => code[0],
+          'client_id' => @client_id,
+          'client_secret' => @client_secret,
+          'redirect_uri' => "http://localhost"
+      }
+
+      RestClient.post("https://api.amazon.com/auth/o2/token", body, :content_type => 'application/x-www-form-urlencoded') do |response, request, result|
+        retval[:data] = JSON.parse(response.body)
+        if response.code === 200
+          retval[:success] = true
+          retval[:data]["last_authorized"] = Time.new.to_i
+        end
+      end
+
+      retval
+    end
+
+    def renew_authorization
+      retval = {
+          :success => false,
+          :data => {}
+      }
+
+      body = {
+          'grant_type' => "refresh_token",
+          'refresh_token' => @token_store["refresh_token"],
+          'client_id' => @client_id,
+          'client_secret' => @client_secret,
+          'redirect_uri' => "http://localhost"
+      }
+      RestClient.post("https://api.amazon.com/auth/o2/token", body, :content_type => 'application/x-www-form-urlencoded') do |response, request, result|
+        retval[:data] = JSON.parse(response.body)
+        if response.code === 200
+          retval[:success] = true
+
+          @token_store["last_authorized"] = Time.new.to_i
+          @token_store["refresh_token"] = retval[:data]["refresh_token"]
+          @token_store["access_token"] = retval[:data]["access_token"]
+
+          @access_token = @token_store["access_token"]
+          @refresh_token = @token_store["refresh_token"]
+
+          save_token_store
+        end
+      end
+
+      retval
+    end
+
+    def save_token_store
+      File.open(@cache_file, 'w') do |file|
+        file.write(@token_store.to_json)
+      end
+    end
+
+    def sync
+      if !@token_store.has_key?("checkpoint")
+        @token_store["checkpoint"] = nil
+      end
+
+      body = {
+          :includePurged => "true"
+      }
+
+      loop do
+        if @token_store["checkpoint"] != nil
+          body[:checkpoint] = @token_store["checkpoint"]
+        end
+
+        loop = true
+        RestClient.post(@metadata_url + "changes", body.to_json, :Authorization => "Bearer #{@access_token}") do |response, request, result|
+          if response.code === 200
+            data = response.body.split("\n")
+            data.each do |xary|
+              xary = JSON.parse(xary)
+              if xary.has_key?("reset") && xary["reset"] == true
+                @db.execute("DELETE FROM nodes WHERE 1=1")
+              end
+
+              if xary.has_key?("end") && xary["end"] == true
+                loop = false
+              elsif xary.has_key?("nodes")
+                @token_store["checkpoint"] = xary["checkpoint"]
+                xary["nodes"].each do |node|
+                  if node["status"] == "PURGED"
+                    delete_node_by_id(node["id"])
+                  else
+                    save_node(node)
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        break if loop === false
+      end
+
+      save_token_store
+    end
+
+    def delete_node_by_id(id)
+      begin
+        @db.execute("DELETE FROM nodes WHERE id = ?", id)
+      rescue SQLite3::Exception => e
+        puts "Exception deleting node with ID #{id}: #{e}"
+      end
+    end
+
+    def save_node(node)
+      md5 = nil
+      if node["contentProperties"] != nil && node["contentProperties"]["md5"] != nil
+        md5 = node["contentProperties"]["md5"]
+      end
+
+      if node["name"] == nil && node["isRoot"] != nil && node["isRoot"] == true
+        node["name"] = "root"
+      end
+
+      begin
+        result = db.execute("INSERT OR REPLACE INTO nodes (id, name, kind, md5, created, modified, raw_data)
+          VALUES (?, ?, ?, ?, ?, ?, ?);", [node["id"], node["name"], node["kind"], md5, node["createdDate"], node["modifiedDate"], node.to_json])
+      rescue SQLite3::Exception => e
+        if node["name"] == nil
+          puts "Exception saving node: #{e}"
+          puts node.to_json
+        end
+      end
+    end
+
+  end
+
+end

data/lib/clouddrive/node.rb

@@ -0,0 +1,329 @@
+require 'rest-client'
+require 'pathname'
+require 'find'
+require 'digest/md5'
+require 'json'
+
+module CloudDrive
+
+  class Node
+
+    def initialize(account)
+      @account = account
+    end
+
+    def build_node_path(node)
+      path = []
+      loop do
+        path.push node["name"]
+
+        break if node.has_key?('isRoot') && node['isRoot'] == true
+
+        results = find_by_id(node["parents"][0])
+        if results[:success] == false
+          raise "No parent node found with ID #{node["parents"][0]}"
+        end
+
+        node = results[:data]
+
+        break if node.has_key?('isRoot') && node['isRoot'] === true
+      end
+
+      path = path.reverse
+      path.join('/')
+    end
+
+    def create_new_folder(name, parent_id = nil)
+      if parent_id == nil
+        parent_id = get_root['id']
+      end
+
+      body = {
+          :name => name,
+          :parents => [
+              parent_id
+          ],
+          :kind => "FOLDER"
+      }
+
+      retval = {
+          :success => false,
+          :data => []
+      }
+
+      RestClient.post(
+          "#{@account.metadata_url}nodes",
+          body.to_json,
+          :Authorization => "Bearer #{@account.access_token}"
+      ) do |response, request, result|
+        data = JSON.parse(response.body)
+        retval[:data] = data
+        if response.code === 201
+          retval[:success] = true
+          @account.save_node(data)
+        end
+      end
+
+      retval
+    end
+
+    def create_directory_path(path)
+      retval = {
+        :success => true,
+        :data => {}
+      }
+
+      path = get_path_array(path)
+      previous_node = get_root
+
+      match = nil
+      path.each_with_index do |folder, index|
+        xary = path.slice(0, index + 1)
+        if (match = find_by_path(xary.join('/'))) === nil
+          result = create_new_folder(folder, previous_node["id"])
+          if result[:success] === false
+            return result
+          end
+
+          match = result[:data]
+        end
+
+        previous_node = match
+      end
+
+      if match == nil
+        retval[:data] = previous_node
+      else
+        retval[:data] = match
+      end
+
+      retval
+    end
+
+    # If given a local file, the MD5 will be compared as well
+    def exists?(remote_file, local_file = nil)
+      if (file = find_by_path(remote_file)) == nil
+        if local_file != nil
+          if (file = find_by_md5(Digest::MD5.file(local_file).to_s)) != nil
+            path = build_node_path(file)
+            return {
+                :success => true,
+                :data => {
+                    "message" => "File with same MD5 exists at #{path}: #{file.to_json}"
+                }
+            }
+          end
+        end
+        return {
+            :success => false,
+            :data => {
+                "message" => "File #{remote_file} does not exist"
+            }
+        }
+      end
+
+      retval = {
+          :success => true,
+          :data => {
+              "message" => "File #{remote_file} exists"
+          }
+      }
+
+      if local_file != nil
+        if file["contentProperties"] != nil && file["contentProperties"]["md5"] != nil
+          if Digest::MD5.file(local_file).to_s != file["contentProperties"]["md5"]
+            retval[:data]["message"] = "File #{remote_file} exists butuum doesn't match"
+          else
+            retval[:data]["message"] = "File #{remote_file} exists and is identical"
+          end
+        else
+          retval[:data]["message"] = "File #{remote_file} exists, but no checksum is available"
+        end
+      end
+
+      retval
+    end
+
+    def find_by_id(id)
+      retval = {
+          :success => false,
+          :data => {}
+      }
+
+      results = @account.db.execute("SELECT raw_data FROM nodes WHERE id = ?;", id)
+      if results.empty?
+        return retval
+      end
+
+      if results.count > 1
+        raise "Multiple nodes with same ID found: #{results[:data].to_json}"
+      end
+
+      {
+          :success => true,
+          :data => JSON.parse(results[0][0])
+      }
+    end
+
+    def find_by_md5(hash)
+
+      results = @account.db.execute("SELECT raw_data FROM nodes WHERE md5 = ?;", hash)
+      if results.empty?
+        return nil
+      end
+
+      if results.count > 1
+        raise "Multiple nodes with same MD5: #{results.to_json}"
+      end
+
+      JSON.parse(results[0][0])
+    end
+
+    def find_by_name(name)
+      retval = []
+      results = @account.db.execute("SELECT raw_data FROM nodes WHERE name = ?;", name)
+      if results.empty?
+        return retval
+      end
+
+      results.each do |result|
+          retval.push(JSON.parse(result[0]))
+      end
+
+      retval
+    end
+
+    def find_by_path(path)
+      path = path.gsub(/\A\//, '')
+      path = path.gsub(/\/$/, '')
+      path_info = Pathname.new(path)
+
+      found_nodes = find_by_name(path_info.basename.to_s)
+      if found_nodes.empty?
+        return nil
+      end
+
+      match = nil
+      found_nodes.each do |node|
+        if build_node_path(node) == path
+          match = node
+        end
+      end
+
+      match
+    end
+
+    def get_path_array(path)
+      return path if path.kind_of?(Array)
+
+      path = path.split('/')
+      path.reject! do |value|
+        value.empty?
+      end
+
+      path
+    end
+
+    def get_path_string(path)
+      path = path.join '/' if path.kind_of?(Array)
+
+      path.chomp
+    end
+
+    def get_root
+      results = find_by_name('root')
+      if results.empty?
+        raise "No node by the name of 'root' found in database"
+      end
+
+      results.each do |node|
+        if node.has_key?('isRoot') && node['isRoot'] === true
+          return node
+        end
+      end
+
+      nil
+    end
+
+    def upload_dir(src_path, dest_root, show_progress = false)
+      src_path = File.expand_path(src_path)
+
+      dest_root = get_path_array(dest_root)
+      dest_root.push(get_path_array(src_path).last)
+      dest_root = get_path_string(dest_root)
+
+      retval = []
+      Find.find(src_path) do |file|
+        # Skip root directory, no need to make it
+        next if file == src_path || File.directory?(file)
+
+        path_info = Pathname.new(file)
+        remote_dest = path_info.dirname.sub(src_path, dest_root).to_s
+
+        result = upload_file(file, remote_dest)
+        if show_progress == true
+          if result[:success] == true
+            puts "Successfully uploaded file #{file}: #{result[:data].to_json}"
+          else
+            puts "Failed to uploaded file #{file}: #{result[:data].to_json}"
+          end
+        end
+
+        retval.push(result)
+
+        # Since uploading a directory can take a while (depending on number/size of files)
+        # we will check if we need to renew our authorization after each file upload to
+        # make sure our authentication doesn't expire.
+        if (Time.new.to_i - @account.token_store["last_authorized"]) > 60
+          result = @account.renew_authorization
+          if result[:success] === false
+            raise "Failed to renew authorization: #{result[:data].to_json}"
+          end
+        end
+      end
+
+      retval
+    end
+
+    def upload_file(src_path, dest_path)
+      retval = {
+          :success => false,
+          :data => []
+      }
+
+      path_info = Pathname.new(src_path)
+      dest_path = get_path_string(get_path_array(dest_path))
+      dest_folder = create_directory_path(dest_path)
+
+      result = exists?("#{dest_path}/#{path_info.basename}", src_path)
+      if result[:success] == true
+        retval[:data] = result[:data]
+
+        return retval
+      end
+
+      body = {
+          :metadata => {
+              :kind => 'FILE',
+              :name => path_info.basename,
+              :parents => [
+                  dest_folder["id"]
+              ]
+          }.to_json,
+          :content => File.new(File.expand_path(src_path), 'rb')
+      }
+
+      RestClient.post("#{@account.content_url}nodes", body, :Authorization => "Bearer #{@account.access_token}") do |response, request, result|
+        retval[:data] = JSON.parse(response.body)
+        if response.code === 201
+          retval[:success] = true
+          @account.save_node(retval[:data])
+        end
+      end
+
+      retval
+    end
+
+  end
+
+end

data/lib/clouddrive/version.rb

@@ -0,0 +1,3 @@
+module CloudDrive
+  VERSION = "0.0.1"
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: clouddrive
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Alex Phillips
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rest-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.19'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+description: Ruby SDK and command line application for Amazon's CloudDrive
+email:
+- exonintrendo@gmail.com
+executables:
+- clouddrive
+- console
+- setup
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/clouddrive
+- bin/console
+- bin/setup
+- clouddrive.gemspec
+- lib/clouddrive.rb
+- lib/clouddrive/account.rb
+- lib/clouddrive/node.rb
+- lib/clouddrive/version.rb
+homepage: https://github.com/exonintrendo/clouddrive
+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.4.7
+signing_key: 
+specification_version: 4
+summary: CloudDrive for Ruby
+test_files: []