gobbler 0.0.1 → 0.1.1

data/README.md

@@ -1,9 +1,6 @@
 # Gobbler
 
-Access to Gobbler API
-
-_PLEASE NOTE_: This should only be used for testing for now. It's only
-an experiement and could rapidly change and break as we work on it.
+Access to Gobbler API via Ruby
 
 ## Installation
 
@@ -19,14 +16,35 @@ Or install it yourself as:
 
     $ gem install gobbler
 
-## Usage
+## Documentation
+
+Documentation is available at [rdoc.info](http://rdoc.info/gems/gobbler/frames)
+
+## Exmaple Usage
+
+    require 'gobbler'
+
+    ## Set up authentication and sign in
+    Gobbler.config(email: "...", password: "...")
+
+    ## Get the high-level metrics for your account
+    puts Gobbler::Dashboard.list
+
+    ## Get a list of all project names
+    puts Gobbler.projects.collect(&:name)
+
+    ## Get a list of all files in a project
+    project = Gobbler.projects.first
+    checkpoint = project.last_checkpoint
 
-TODO: Write usage instructions here
+    checkpoint.assets.each do |asset|
+      puts asset["relative_path"]
+    end
 
-## Contributing
+    ## Get a list of all machines that you have signed into gobbler with
+    puts Gobbler.machines
 
-1. Fork it
-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 new Pull Request
+    ## Get a list of the cities that each of your drives was last seen in
+    Gobbler.volumes.each do |volume|
+      puts "#{volume.volume_name} : #{volume.city}"
+    end

data/gobbler.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |gem|
   gem.email         = ["dan@gobbler.com"]
   gem.description   = %q{Access to the Gobbler API}
   gem.summary       = %q{Access to the Gobbler API}
-  gem.homepage      = ""
+  gem.homepage      = "https://github.com/gobbler/gobbler"
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }

data/lib/gobbler.rb

@@ -1,5 +1,114 @@
-require "gobbler/version"
+require 'json'
+require 'net/http'
+require 'uri'
+require 'base64'
+
 
 module Gobbler
-  # Your code goes here...
+
+  require 'gobbler/base'
+  require 'gobbler/mappable'
+
+  require 'gobbler/checkpoint'
+  require 'gobbler/client_version'
+  require 'gobbler/dashboard'
+  require 'gobbler/folder'
+  require 'gobbler/machine'
+  require 'gobbler/volume'
+  require 'gobbler/project'
+  require 'gobbler/quota'
+  require 'gobbler/referral'
+
+  class << self
+
+    @@api_server = "api.gobbler.com"
+    @@client_version = "dev"
+    @@machine_serial = "api"
+    @@config = {}
+    @@keys = {}
+
+    # Set the configuration
+    # 
+    # Options are passed as a Hash of symbols
+    # @option opts [String] :email Email of Gobbler account
+    # @option opts [String] :password Password of Gobbler account
+    def config(opts)
+      opts.each {|k,v| opts[k.to_sym] ||= opts[k]}
+      @@config = opts
+      @@api_server = opts[:api_server] if opts[:api_server]
+      @@client_version = opts[:client_version] if opts[:client_version]
+      @@machine_serial = opts[:machine_serial] if opts[:machine_serial]
+      login! if opts[:email] && opts[:password]
+    end
+
+    # @return [Boolean] Login successful, will raise an error if it was not
+    def login!
+      raise "No credentials" if @@config[:email].nil? || @@config[:password].nil?
+
+      authentication = {
+        machine_info: { serial: @@machine_serial },
+        authentication: {
+          provider: "gobbler",
+          credentials: {
+            email: @@config[:email],
+            password: @@config[:password] 
+          }
+        }
+      }
+
+      response = request("client_user/login", authentication)
+      @@keys[:cookie] = response[:http_response]["Set-Cookie"].split('; ')[0]
+      @@keys[:client_key] = response["client_key"]
+
+      raise "Can't Login" if @@keys[:client_key].nil?
+
+      return true
+    end
+
+    # @return [Hash] Hash from the JSON API server response
+    def request(uri, body = nil)
+      uri = URI.parse("https://#{api_server}/#{uri}")
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+
+      if body
+        request = Net::HTTP::Post.new(uri.request_uri)
+        request.body = body.to_json unless body.nil?
+      else
+        request = Net::HTTP::Get.new(uri.request_uri)
+      end
+
+      request["Content-type"] = "application/json"
+      request["Cookie"] = cookie
+      request["x-mam-client-version"] = client_version
+      request["x-mam-client-key"] = client_key
+
+      response = http.request(request)
+      raise unless response.code == "200"
+      JSON.parse(response.body).merge(http_response: response)
+    end
+
+    # @return [Hash] The unpacked JSON string
+    def unpack(str)
+      return [] if str.nil? || str == ""
+      decoded = Base64.decode64(str)
+      unzipped = Zlib::GzipReader.new(StringIO.new(decoded)).read
+      JSON.parse(unzipped)
+    end
+
+    # @return [Boolean] If you are currently signed into the Gobbler API
+    def signed_in?
+      !client_key.nil? && client_key != ""
+    end
+
+    private
+
+    def api_server; @@api_server; end
+    def client_key; @@keys[:client_key]; end
+    def client_version; @@client_version; end
+    def cookie; @@keys[:cookie]; end
+    def machine_serial; @@machine_serial; end
+  end
+
 end

data/lib/gobbler/base.rb

@@ -0,0 +1,29 @@
+module Gobbler
+  class Base
+    attr_accessor :json
+
+    def self.get(guid)
+      list.find {|p| p.guid == guid}
+    end
+
+    def initialize(json)
+      @json = json
+    end
+
+    def base_attr; json; end
+
+    private
+
+    def method_missing(method, *args, &block)
+      if base_attr.keys.include?(method.to_s) || method == :assets
+        if method == :assets && base_attr.keys.include?("assets_packed")
+          ::Gobbler.unpack(base_attr["assets_packed"])
+        else
+          base_attr[method.to_s]
+        end
+      else
+        super(method, *args, &block)
+      end
+    end
+  end
+end

data/lib/gobbler/checkpoint.rb

@@ -0,0 +1,31 @@
+module Gobbler
+  class Checkpoint < Base
+
+    # Gets the checkpoint for a project
+    #
+    # @option opts [String] :project_id The id of the project to get
+    # @option opts [Integer] :checkpoint The number of the checkpoint
+    # @return [Checkpoint] the checkpoint
+    def self.get(opts)
+      raise unless opts[:project_id] && opts[:checkpoint]
+      new(::Gobbler.request("v1/projects/#{opts[:project_id]}/checkpoints/#{opts[:checkpoint]}"))
+    end
+
+    # @return [Project] The {Project} that this is a checkpoint for
+    def project
+      ::Gobbler::Project.get(json["project"])
+    end
+
+    # Email this version of the project to a list of recipieints
+    # @param recipieints [String] A comma-separated list of email addresses
+    # @return [Hash] The sevrer response
+    def email_to(recipients, opts = {})
+      opts[:checkpoint] = num
+      project.email_to(recipients, opts)
+    end
+
+    private
+
+    def base_attr; json["checkpoint"]; end
+  end
+end

data/lib/gobbler/client_version.rb

@@ -0,0 +1,9 @@
+module Gobbler
+  class ClientVersion < Base
+
+    # @return [ClientVersion] The information about the latest client
+    def self.latest
+      ::Gobbler.request("client_user/get_version_info")["data"]
+    end
+  end
+end

data/lib/gobbler/dashboard.rb

@@ -0,0 +1,14 @@
+module Gobbler
+
+  # Alias for {Gobbler::Dashboard.get}
+  # @return [Dashboard] Metrics for your account
+  def self.dashboard; Dashboard.get; end
+
+  class Dashboard < Base
+
+    # @return [Dashboard] Metrics for your account
+    def self.get
+      new(::Gobbler.request "account/dashboard.json")
+    end
+  end
+end

data/lib/gobbler/folder.rb

@@ -0,0 +1,35 @@
+module Gobbler
+ 
+  # Alias for {Folder.get}
+  # @param guid [String] The guid of the folder
+  # @return [Folder]
+  def self.folder(guid); Folder.get(guid); end
+
+  # Alias for {Folder.list}
+  # @return [Array<Folder>] An array of Folders
+  def self.folders(opts = {}); Folder.list(opts); end
+
+  class Folder < Base
+
+    # @return [Array<Folder>] An array of Folders
+    def self.list(opts = {})
+      opts[:offset] ||= 0
+      ::Gobbler.request("client_catalog/sync_ask_folder", options: opts)["updates"].map {|folder| new(folder)}
+    end
+
+    # @return [String] The guid for the folder
+    def guid
+      user_data_guid
+    end
+
+    # @return [Volume] The volume that this folder is on
+    def volume
+      ::Gobbler::Volume.get(volume_guid)
+    end
+
+    # @return [Hash] The assets for this folder
+    def assets
+      ::Gobbler.unpack json["dir"]["assets_packed"]
+    end
+  end
+end

data/lib/gobbler/machine.rb

@@ -0,0 +1,22 @@
+module Gobbler
+
+  # Alias for {Gobbler::Machine.get}
+  # @param guid [String] The guid of the machine
+  # @return [Machine]
+  def self.machine(guid); Machine.get(guid); end
+
+  # Alias for {Gobbler::Machine.list}
+  # @return [Array<Machine>] An array of Folders
+  def self.machines(opts = {}); Machine.list(opts); end
+
+  class Machine < Base
+    include Mappable
+
+    # @return [Array<Machine>] Machines that have been connected to your account
+    def self.list(opts = {})
+      opts[:offset] ||= 0
+      ::Gobbler.request("client_machine/sync_ask", options: opts)["updates"].map {|machine| new(machine)}
+    end
+
+  end
+end

data/lib/gobbler/mappable.rb

@@ -0,0 +1,29 @@
+module Gobbler
+  module Mappable
+    def self.included(base)
+      base.extend(Gobbler::Mappable::ClassMethods)
+    end
+
+    def city; last_location["city"] unless last_location.nil?; end
+    def lat; last_location["lat"]   unless last_location.nil?; end
+    def lng; last_location["lng"]   unless last_location.nil?; end
+    def coordinates; [lat, lng]; end
+    def zip; last_location["zip"]   unless last_location.nil?; end
+
+    module ClassMethods
+      def valid_locations; list.collect(&:coordinates).reject {|c| c == [nil,nil] || c == [0.0,0.0]}; end
+
+      def google_maps_url(opts = {})
+        opts[:size] ||= "1500x1200"
+        opts[:sensor] ||= "true"
+        url = "http://maps.googleapis.com/maps/api/staticmap?size=#{opts[:size]}"
+        url += "&" + valid_locations.map {|c| "markers=color:green%7Clabel:X%7C#{c[0]},#{c[1]}"}.join("&")
+        url += "&sensor=#{opts[:sensor]}"
+      end
+
+      def open_map!(opts = {})
+        system "open '#{google_maps_url(opts)}'"
+      end
+    end
+  end
+end

data/lib/gobbler/project.rb

@@ -0,0 +1,42 @@
+module Gobbler
+  
+  # Alias for {Gobbler::Project.get}
+  # @param guid [String] The guid of the project
+  # @return [Project]
+  def self.project(guid); Project.get(guid); end
+
+  # Alias for {Gobbler::Project.list}
+  # @return [Array<Project>] An array of Backed up projects
+  def self.projects(opts = {}); Project.list(opts); end
+
+  # Projects that you have backed up with Gobbler
+  class Project < Base
+
+    # @return [Array<Project>] an array of Gobbler Projects
+    def self.list(opts = {})
+      opts[:offset] ||= 0
+      ::Gobbler.request("client_project/sync_ask", options: opts)["updates"].map {|project| new(project)}
+    end
+
+    # Get the last checkpoint for a project
+    # @return [Checkpoint]
+    def last_checkpoint
+      ::Gobbler::Checkpoint.get(project_id: guid, checkpoint: current_checkpoint["num"])
+    end
+
+    # @return [Array<Checkpoint>] an array of Checkpoints for this project
+    def checkpoints
+      (1..current_checkpoint["num"]).map do |checkpoint_num|
+       ::Gobbler::Checkpoint.get(project_id: guid, checkpoint: checkpoint_num)
+      end
+    end
+
+    # @return [Hash] The information about the email sent
+    def email_to(recipients, opts = {})
+      params = {guid: guid, recipients: recipients}
+      params[:is_public] = opts[:public] if opts[:public] == true
+      params[:checkpoint] = opts[:checkpoint] if opts[:checkpoint]
+      ::Gobbler.request("client_mailbox/send_project", params)
+    end
+  end
+end

data/lib/gobbler/quota.rb

@@ -0,0 +1,28 @@
+module Gobbler
+
+  # Alias for {Quota.get}
+  def self.quota; Quota.get; end
+
+  class Quota < Base
+
+    # @return [Quota] The transfer and storage quota for your account
+    def self.get
+      new(::Gobbler.request("v1/quotas"))
+    end
+
+    # @return [Integer] The total bytes you can sending (note -1 represents unlimted)
+    def transfer
+      quotas["limits"]["transfer"]
+    end
+
+    # @return [Boolean] If your account has unlimited sending
+    def unlimited_transfer?
+      transfer == -1
+    end
+
+    # @return [Integer] The total bytes you can backup (note -1 represents unlimted)
+    def storage
+      quotas["limits"]["storage"]
+    end
+  end
+end

data/lib/gobbler/referral.rb

@@ -0,0 +1,14 @@
+module Gobbler
+
+  # Alias for {Referral.list}
+  # @return [Array<Referral>] All referrals
+  def self.referrals; Referral.list; end
+
+  class Referral < Base
+
+    # @return [Array<Referrals>] All referrals
+    def self.list
+      ::Gobbler.request("account/referrals.json")["referrals"].map {|ref| new(ref)}
+    end
+  end
+end

data/lib/gobbler/version.rb

@@ -1,3 +1,3 @@
 module Gobbler
-  VERSION = "0.0.1"
+  VERSION = "0.1.1"
 end

data/lib/gobbler/volume.rb

@@ -0,0 +1,29 @@
+module Gobbler
+
+  # Alias for {Volume.get}
+  # @param guid [String] The guid of the volume
+  # @return [Volume]
+  def self.volume(guid); Volume.get(guid); end
+
+  # Alias for {Volume.list}
+  # @return [Array<Volume>] An array of Volumes
+  def self.volumes(opts = {}); Volume.list(opts); end
+
+  class Volume < Base
+    include Mappable
+
+    # @option opts [Integer] :limit The number of records to return
+    # @option opts [Integer] :offset The number of records to offset the
+    #   results (useful for paging)
+    # @return [Array<Volume>] an array of volumes
+    def self.list(opts = {})
+      opts[:offset] ||= 0
+      ::Gobbler.request("client_volume/sync_ask", options: opts)["updates"].map {|volume| new(volume)}
+    end
+
+    # @return [Boolean] If the volume is currently connected to a machine
+    def connected?
+      currently_connected
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gobbler
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-05 00:00:00.000000000 Z
+date: 2013-08-08 00:00:00.000000000 Z
 dependencies: []
 description: Access to the Gobbler API
 email:
@@ -25,8 +25,19 @@ files:
 - Rakefile
 - gobbler.gemspec
 - lib/gobbler.rb
+- lib/gobbler/base.rb
+- lib/gobbler/checkpoint.rb
+- lib/gobbler/client_version.rb
+- lib/gobbler/dashboard.rb
+- lib/gobbler/folder.rb
+- lib/gobbler/machine.rb
+- lib/gobbler/mappable.rb
+- lib/gobbler/project.rb
+- lib/gobbler/quota.rb
+- lib/gobbler/referral.rb
 - lib/gobbler/version.rb
-homepage: ''
+- lib/gobbler/volume.rb
+homepage: https://github.com/gobbler/gobbler
 licenses: []
 post_install_message: 
 rdoc_options: []