xplenty-api 0.0.1

data/.gitignore

@@ -0,0 +1,20 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/
+
+/.idea

data/.travis.yml

@@ -0,0 +1,11 @@
+language: ruby
+
+notifications:
+  email: false
+
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+
+script: bundle exec rake

data/Gemfile

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

data/Gemfile.lock

@@ -0,0 +1,20 @@
+PATH
+  remote: .
+  specs:
+    xplenty-api (0.0.1)
+      excon (~> 0.20.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    excon (0.20.1)
+    minitest (4.7.4)
+    rake (10.0.4)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  minitest
+  rake
+  xplenty-api!

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License
+
+Copyright (c) 2012-2013 Xplenty, Ltd. http://www.xplenty.com
+
+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,139 @@
+## Xplenty Ruby Wrapper
+
+[![Build Status](https://travis-ci.org/xplenty/xplenty.rb.png)](https://travis-ci.org/xplenty/xplenty.rb)
+
+The Xplenty rb is a Ruby artifact that provides a simple wrapper for the [Xplenty REST Api](https://github.com/xplenty/xplenty-api-doc). 
+To use it, create an TODO:OBJECT-NAME object and call its methods to access the Xplenty API.
+This page describes the available XplentyAPI methods.
+
+### Create an XplentyAPI Object
+
+Pass your account ID and API key to the XplentyAPI constructor.
+```ruby
+@xplenty = Xplenty::API.new(:api_key => 'your_api_key', :account_id => 'your_account_id')
+```
+If you want to supply custom values for the version, scheme or host that the Xplenty::API object will use,
+you can use Xplenty::API builder methods to customize these properties.
+```ruby
+@xplenty = Xplenty::API.new(:api_key => 'your_api_key', :account_id => 'your_account_id', :scheme => 'https', :host => 'api.xplenty.com')
+@xplenty = Xplenty::API.new(:api_key => 'your_api_key', :account_id => 'your_account_id', :headers => { 'User-Agent' => 'your user agent' })
+TODO:INSERT-CODE
+```
+### List the Cluster Plans
+
+A cluster plan is a definition of a cluster type, which includes the number of nodes in the cluster and its pricing. Cluster plan details can be viewed in the Xplenty web application.
+After you've determined which cluster plan is appropriate for your needs, use this method to retrieve the cluster plan ID. The cluster plan ID can then be used when creating a new cluster.
+```ruby
+@xplenty.cluster_plans
+```
+### Create a Cluster
+
+This method creates a new cluster. A cluster is a group of machines ("nodes") allocated to your account. The number of nodes in the cluster is determined by the "plan_id" value that you supply to the call. While the cluster is active, only your account's users can run jobs on the cluster.
+You will need to provide an active cluster when starting a new job. Save the cluster ID value returned in the response "id" field. You will use the value to refer to this cluster in subsequent API calls.
+```ruby
+@xplenty.create_cluster(:nodes => 1, :type => "sandbox")
+```
+### List All Clusters
+
+This method returns the list of clusters that were created by users in your account.
+You can use this information to monitor and display your clusters and their statuses.
+
+```ruby
+@xplenty.clusters # return all clusters
+```
+XplentyAPI.listClusters() is shorthand for XplentyAPI.listClusters(new Properties()), which returns all clusters with no filtering.
+You can also pass property parameters which filter the clusters according to their status, and determine the order in which they'll be sorted.
+Only clusters which have the status passed in the PARAMETER_STATUS property will be returned, sorted according to the field passed in PARAMETER_SORT,
+in ascending or descending order according to the PARAMETER_DIRECTION property.
+
+```ruby
+@xplenty.clusters(:status => 'terminated')
+@xplenty.clusters(:sort => 'created', :direction => 'desc')
+```
+### Get Cluster Information
+
+This method returns the details of the cluster with the given ID.
+```ruby
+@xplenty.get_cluster_info(1792)
+```
+### Terminate a Cluster
+
+This method deactivates the given cluster, releasing its resources and terminating its runtime period. Use this method when all of the cluster's jobs are completed and it's no longer needed. The method returns the given cluster's details, including a status of "pending_terminate".
+```ruby
+@xplenty.terminate_cluster(1792)
+```
+### Run a Job
+
+This method creates a new job and triggers it to run. The job performs the series of data processing tasks that are defined in the job's package. Unless the job encounters an error or is terminated by the user, it will run until it completes its tasks on all of the input data. Save the job ID value returned in the response "id" field. You will use the value to refer to this job in subsequent API calls.
+```ruby
+@xplenty.run_job(1792, 902, {:first_arg => 'Argument 1'})
+```
+### List All Jobs
+
+This method returns information for all the jobs that have been created under your account.
+```ruby
+@xplenty.jobs
+```
+XplentyAPI.listJobs() is shorthand for XplentyAPI.listJobs(new Properties()), which returns all jobs with no filtering.
+You can also pass property parameters which filter the jobs according to their status, and determine the order in which they'll be sorted.
+Only jobs which have the status passed in the PARAMETER_STATUS property will be returned, sorted according to the field passed in PARAMETER_SORT,
+in ascending or descending order according to the PARAMETER_DIRECTION property.
+```ruby
+@xplenty.jobs(:status => 'idle')
+@xplenty.jobs(:status => 'completed', :sort => 'created_at', :direction => 'asc')
+```
+
+### Get Job Information
+
+This method retrieves information for a job, according to the given job ID.
+```ruby
+@xplenty.get_job_info(9032)
+```
+### Terminate a Job
+
+This method terminates an active job. Usually it's unnecessary to request to terminate a job, because normally the job will end when its tasks are completed. You may want to actively terminate a job if you need its cluster resources for a more urgent job, or if the job is taking too long to complete.
+```ruby
+@xplenty.terminate_job(9032)
+```
+### Watch Cluster
+
+You can watch a cluster that you or others have created. If you'r watching a cluster, you'll receive notifications (email messages or web notifications) on important updates.
+
+This method adds the calling user as a watcher of the specifeid cluster.
+```ruby
+@xplenty.watch_cluster(1792)
+```
+### Stop Watching Cluster
+
+This method removes the calling user from the watcher list of the specified cluster.
+```ruby
+@xplenty.stop_watching_cluster(1792)
+```
+### Get Cluster Watchers
+
+This call retrieves the list of users watching the specified cluster.
+```ruby
+@xplenty.cluster_watchers(1792)
+```
+### Watch Job
+
+You can watch a job that you or others have executed. If you'r watching a job, you'll receive notifications (email messages or web notifications) on important updates.
+
+This method adds the calling user as a watcher of the specifeid job.
+```ruby
+@xplenty.watch_job(9032)
+```
+### Stop Watching Job
+
+This method removes the calling user from the watcher list of the specified job.
+```ruby
+@xplenty.stop_watching_job(9032)
+```
+### Get Job Watchers
+
+This call retrieves the list of users watching the specified job.
+```ruby
+@xplenty.job_watchers(9032)
+```
+## License
+Released under the [MIT license](http://www.opensource.org/licenses/mit-license.php).

data/Rakefile

@@ -0,0 +1,29 @@
+require "bundler/gem_tasks"
+
+require 'rake/testtask'
+
+task :default => :test
+
+Rake::TestTask.new do |task|
+  task.name = :test
+  task.test_files = FileList['test/test*.rb']
+end
+
+task :cache, [:account_id, :api_key] do |task, args|
+  unless args.api_key && args.account_id
+    puts('cache requires an account id and api key, please call as `cache[account_id api_key]`')
+  else
+    require "#{File.dirname(__FILE__)}/lib/xplenty/api"
+    xplenty = Xplenty::API.new(:api_key => args.api_key, :account_id => args.account_id)
+
+    clusters = Xplenty::API::OkJson.encode(xplenty.clusters.body)
+    File.open("#{File.dirname(__FILE__)}/lib/xplenty/api/mock/cache/clusters.json", 'w') do |file|
+      file.write(clusters)
+    end
+
+    jobs = Xplenty::API::OkJson.encode(xplenty.jobs.body)
+    File.open("#{File.dirname(__FILE__)}/lib/xplenty/api/mock/cache/jobs.json", 'w') do |file|
+      file.write(jobs)
+    end
+  end
+end

data/lib/xplenty-api.rb

@@ -0,0 +1,3 @@
+$:.unshift File.dirname(__FILE__)
+
+require(File.join(File.dirname(__FILE__), "xplenty", "api"))

data/lib/xplenty/api.rb

@@ -0,0 +1,107 @@
+require "base64"
+require "excon"
+require "securerandom"
+require "uri"
+require "zlib"
+
+__LIB_DIR__ = File.expand_path(File.join(File.dirname(__FILE__), ".."))
+unless $LOAD_PATH.include?(__LIB_DIR__)
+  $LOAD_PATH.unshift(__LIB_DIR__)
+end
+
+require "xplenty/api/vendor/okjson"
+
+require "xplenty/api/errors"
+require "xplenty/api/mock"
+require "xplenty/api/version"
+
+require "xplenty/api/jobs"
+require "xplenty/api/cluster_plans"
+require "xplenty/api/clusters"
+require "xplenty/api/watchers"
+
+srand
+
+module Xplenty
+  class API
+
+    HEADERS = {
+      'Accept' => 'application/vnd.xplenty+json'
+    }
+
+    OPTIONS = {
+      :headers  => {},
+      :host     => 'api.xplenty.com',
+      :nonblock => false,
+      :scheme   => 'https'
+    }
+
+    def initialize(options={})
+      options = OPTIONS.merge(options)
+
+      @api_key = options.delete(:api_key) || ENV['XPLENTY_API_KEY']
+      @account_id = options.delete(:account_id) || ENV['XPLENTY_ACCOUNT_ID']
+			@version = options.delete(:version)
+			@mime_type = "application/vnd.xplenty+json"
+			if @version && @version.is_a?(Fixnum)
+				@mime_type = @mime_type << "; version=#{@version}"
+			end
+      user_name = "#{@api_key}"
+      options[:headers] = HEADERS.merge({
+        'Authorization' => "Basic #{Base64.encode64(user_name).gsub("\n", '')}",
+				'Accept'        => @mime_type
+      }).merge(options[:headers])
+
+      @connection = Excon.new("#{options[:scheme]}://#{options[:host]}", options)
+    end
+
+    def request(params, &block)
+      begin
+        response = @connection.request(params, &block)
+      rescue Excon::Errors::HTTPStatusError => error
+        klass = case error.response.status
+          when 400 then Xplenty::API::Errors::BadRequest
+          when 401 then Xplenty::API::Errors::Unauthorized
+          when 402 then Xplenty::API::Errors::PaymentRequired
+          when 403 then Xplenty::API::Errors::Forbidden
+          when 404 then Xplenty::API::Errors::NotFound
+          when 406 then Xplenty::API::Errors::NotAcceptable
+          when 415 then Xplenty::API::Errors::UnsupportedMediaType
+          when 422 then Xplenty::API::Errors::UnprocessableEntity
+          when 429 then Xplenty::API::Errors::TooManyRequests
+          when 500 then Xplenty::API::Errors::RequestFailed
+          when 502 then Xplenty::API::Errors::BadGateway
+          when 503 then Xplenty::API::Errors::ServiceUnavailable
+          else Xplenty::API::Errors::ErrorWithResponse
+        end
+
+        reerror = klass.new(error.message, error.response)
+        reerror.set_backtrace(error.backtrace)
+        raise(reerror)
+      end
+
+      if response.body && !response.body.empty?
+        if response.headers['Content-Encoding'] == 'gzip'
+          response.body = Zlib::GzipReader.new(StringIO.new(response.body)).read
+        end
+        begin
+          response.body = Xplenty::API::OkJson.decode(response.body)
+        #rescue
+          # leave non-JSON body as is
+        end
+      end
+
+      # reset (non-persistent) connection
+      @connection.reset
+
+      response
+    end
+
+    private
+
+    def account_id
+      @account_id
+    end
+
+  end
+end

data/lib/xplenty/api/cluster_plans.rb

@@ -0,0 +1,12 @@
+module Xplenty
+  class API
+    # GET /<accountID>/api/cluster_plans
+    def cluster_plans
+      request(
+        :expects => 200,
+        :method => :get,
+        :path => "/#{account_id}/api/cluster_plans"
+      )
+    end
+  end
+end

data/lib/xplenty/api/clusters.rb

@@ -0,0 +1,46 @@
+module Xplenty
+  class API
+    # POST /<accountID>/api/clusters
+    def create_cluster(cluster_info)
+      cluster_info = cluster_info.inject({}) { |v, hv|
+        v.merge({"cluster[#{hv.first}]" => hv.last})
+      }
+
+      request(
+        :expects => 201,
+        :method => :post,
+        :path => "/#{account_id}/api/clusters",
+        :query => cluster_info
+      )
+    end
+
+    # GET /<accountID>/api/clusters/<clusterID>
+    def get_cluster_info(clusterID)
+      request(
+        :expects => 200,
+        :method => :get,
+        :path => "/#{account_id}/api/clusters/#{clusterID}"
+      )
+    end
+
+    # GET /<accountID>/api/clusters
+    def clusters(options={})
+      request(
+        :expects => 200,
+        :method => :get,
+        :path => "/#{account_id}/api/clusters",
+        :query => options
+      )
+    end
+
+    # DELETE /<accountID>/api/clusters/<clusterID>
+    def terminate_cluster(clusterID)
+      request(
+        :expects => 200,
+        :method => :delete,
+        :path => "/#{account_id}/api/clusters/#{clusterID}"
+      )
+    end
+
+  end
+end

data/lib/xplenty/api/errors.rb

@@ -0,0 +1,32 @@
+module Xplenty
+  class API
+    module Errors
+      class Error < StandardError; end
+
+      class ErrorWithResponse < Error
+        attr_reader :response
+
+        def initialize(message, response)
+          super message
+          @response = response
+        end
+      end
+
+      class RequestFailed < ErrorWithResponse; end
+      class NotModified < ErrorWithResponse; end
+      class BadRequest < ErrorWithResponse; end
+      class Unauthorized < ErrorWithResponse; end
+      class PaymentRequired < ErrorWithResponse; end
+      class Forbidden < ErrorWithResponse; end
+      class NotFound < ErrorWithResponse; end
+      class NotAcceptable < ErrorWithResponse; end
+      class UnsupportedMediaType < ErrorWithResponse; end
+      class UnprocessableEntity < ErrorWithResponse; end
+      class TooManyRequests < ErrorWithResponse; end
+      class InternalServerError < ErrorWithResponse; end
+      class BadGateway < ErrorWithResponse; end
+      class ServiceUnavailable < ErrorWithResponse; end
+
+    end
+  end
+end