fog-joyent 0.0.1

data/lib/fog/joyent/compute.rb

@@ -0,0 +1,272 @@
+require 'fog/joyent/core'
+require 'fog/joyent/errors'
+
+module Fog
+  module Compute
+    class Joyent < Fog::Service
+      requires :joyent_username
+
+      recognizes :joyent_url
+
+      recognizes :joyent_keyname
+      recognizes :joyent_keyfile
+      recognizes :joyent_keydata
+      recognizes :joyent_keyphrase
+      recognizes :joyent_version
+
+      secrets :joyent_keydata, :joyent_keyphrase
+
+      model_path 'fog/joyent/models/compute'
+      request_path 'fog/joyent/requests/compute'
+
+      request :list_datacenters
+      # request :get_datacenter
+
+      # Datacenters
+      collection :datacenters
+      model :datacenter
+
+      # Keys
+      collection :keys
+      model :key
+
+      request :list_keys
+      request :get_key
+      request :create_key
+      request :delete_key
+
+      # Images
+      collection :images
+      model :image
+      request :list_datasets
+      request :get_dataset
+      request :list_images
+      request :get_image
+
+      # Flavors
+      collection :flavors
+      model :flavor
+      request :list_packages
+      request :get_package
+
+      # Servers
+      collection :servers
+      model :server
+      request :list_machines
+      request :get_machine
+      request :create_machine
+      request :start_machine
+      request :stop_machine
+      request :reboot_machine
+      request :resize_machine
+      request :delete_machine
+
+      # Snapshots
+      collection :snapshots
+      model :snapshot
+      request :create_machine_snapshot
+      request :start_machine_from_snapshot
+      request :list_machine_snapshots
+      request :get_machine_snapshot
+      request :delete_machine_snapshot
+      request :update_machine_metadata
+      request :get_machine_metadata
+      request :delete_machine_metadata
+      request :delete_all_machine_metadata
+
+      # MachineTags
+      request :add_machine_tags
+      request :list_machine_tags
+      request :get_machine_tag
+      request :delete_machine_tag
+      request :delete_all_machine_tags
+
+      # Networks
+      collection :networks
+      model :network
+      request :list_networks
+
+      class Mock
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {}
+          end
+        end
+
+        def data
+          self.class.data
+        end
+
+        def initialize(options = {})
+          @joyent_username = options[:joyent_username]
+        end
+
+        def request(opts)
+          raise "Not Implemented"
+        end
+      end # Mock
+
+      class Real
+        attr_accessor :joyent_version
+        attr_accessor :joyent_url
+
+        def initialize(options = {})
+          @connection_options = options[:connection_options] || {}
+          @persistent = options[:persistent] || false
+
+          @joyent_url = options[:joyent_url] || 'https://us-sw-1.api.joyentcloud.com'
+          @joyent_version = options[:joyent_version] || '~7'
+          @joyent_username = options[:joyent_username]
+
+          unless @joyent_username
+            raise ArgumentError, "options[:joyent_username] required"
+          end
+
+          if options[:joyent_keyname]
+            begin
+              require "net/ssh"
+            rescue LoadError
+              Fog::Logger.warning("'net/ssh' missing, please install and try again.")
+              exit(1)
+            end
+            @joyent_keyname = options[:joyent_keyname]
+            @joyent_keyphrase = options[:joyent_keyphrase]
+            @key_manager = Net::SSH::Authentication::KeyManager.new(nil, {
+                :keys_only => true,
+                :passphrase => @joyent_keyphrase
+            })
+
+            if options[:joyent_keyfile]
+              if File.exist?(options[:joyent_keyfile])
+                @joyent_keyfile = options[:joyent_keyfile]
+                @key_manager.add(@joyent_keyfile)
+              else
+                raise ArgumentError, "options[:joyent_keyfile] provided does not exist."
+              end
+            elsif options[:joyent_keydata]
+              if options[:joyent_keydata].to_s.empty?
+                raise ArgumentError, 'options[:joyent_keydata] must not be blank'
+              else
+                @joyent_keydata = options[:joyent_keydata]
+                @key_manager.add_key_data(@joyent_keydata)
+              end
+            end
+          else
+            raise ArgumentError, "Must provide a joyent_keyname and joyent_keyfile pair"
+          end
+
+          @connection = Fog::XML::Connection.new(
+            @joyent_url,
+            @persistent,
+            @connection_options
+          )
+        end
+
+        def request(opts = {})
+          opts[:headers] = {
+            "X-Api-Version" => @joyent_version,
+            "Content-Type" => "application/json",
+            "Accept" => "application/json"
+          }.merge(opts[:headers] || {}).merge(header_for_signature_auth)
+
+          if opts[:body]
+            opts[:body] = Fog::JSON.encode(opts[:body])
+          end
+
+          response = @connection.request(opts)
+          if response.headers["Content-Type"] == "application/json"
+            response.body = json_decode(response.body)
+          end
+
+          response
+        rescue Excon::Errors::HTTPStatusError => e
+          if e.response.headers["Content-Type"] == "application/json"
+            e.response.body = json_decode(e.response.body)
+          end
+          raise_if_error!(e.request, e.response)
+        end
+
+        private
+
+        def json_decode(body)
+          parsed = Fog::JSON.decode(body)
+          decode_time_attrs(parsed)
+        end
+
+        def header_for_signature_auth
+          date = Time.now.utc.httpdate
+
+          # Force KeyManager to load the key(s)
+          @key_manager.each_identity {}
+
+          key = @key_manager.known_identities.keys.first
+
+          sig = if key.kind_of? OpenSSL::PKey::RSA
+            @key_manager.sign(key, date)[15..-1]
+          else
+            key = OpenSSL::PKey::DSA.new(File.read(@joyent_keyfile), @joyent_keyphrase)
+            key.sign('sha1', date)
+          end
+
+          key_id = "/#{@joyent_username}/keys/#{@joyent_keyname}"
+          key_type = key.class.to_s.split('::').last.downcase.to_sym
+
+          unless [:rsa, :dsa].include? key_type
+            raise Joyent::Errors::Unauthorized.new('Invalid key type -- only rsa or dsa key is supported')
+          end
+
+          signature = Base64.encode64(sig).delete("\r\n")
+
+          {
+            "Date" => date,
+            "Authorization" => "Signature keyId=\"#{key_id}\",algorithm=\"#{key_type}-sha1\" #{signature}"
+          }
+        rescue Net::SSH::Authentication::KeyManagerError => e
+          raise Joyent::Errors::Unauthorized.new('SSH Signing Error: :#{e.message}', e)
+        end
+
+        def decode_time_attrs(obj)
+          if obj.kind_of?(Hash)
+            obj["created"] = Time.parse(obj["created"]) unless obj["created"].nil? or obj["created"] == ''
+            obj["updated"] = Time.parse(obj["updated"]) unless obj["updated"].nil? or obj["updated"] == ''
+          elsif obj.kind_of?(Array)
+            obj.map do |o|
+              decode_time_attrs(o)
+            end
+          end
+
+          obj
+        end
+
+        def raise_if_error!(request, response)
+          case response.status
+          when 400 then
+            raise Joyent::Errors::BadRequest.new('Bad Request', request, response)
+          when 401 then
+            raise Joyent::Errors::Unauthorized.new('Invalid credentials were used', request, response)
+          when 403 then
+            raise Joyent::Errors::Forbidden.new('No permissions to the specified resource', request, response)
+          when 404 then
+            raise Joyent::Errors::NotFound.new('Requested resource was not found', request, response)
+          when 405 then
+            raise Joyent::Errors::MethodNotAllowed.new('Method not supported for the given resource', request, response)
+          when 406 then
+            raise Joyent::Errors::NotAcceptable.new('Try sending a different Accept header', request, response)
+          when 409 then
+            raise Joyent::Errors::Conflict.new('Most likely invalid or missing parameters', request, response)
+          when 414 then
+            raise Joyent::Errors::RequestEntityTooLarge.new('You sent too much data', request, response)
+          when 415 then
+            raise Joyent::Errors::UnsupportedMediaType.new('You encoded your request in a format we don\'t understand', request, response)
+          when 420 then
+            raise Joyent::Errors::PolicyNotForfilled.new('You are sending too many requests', request, response)
+          when 449 then
+            raise Joyent::Errors::RetryWith.new('Invalid API Version requested; try with a different API Version', request, response)
+          when 503 then
+            raise Joyent::Errors::ServiceUnavailable.new('Either there\'s no capacity in this datacenter, or we\'re in a maintenance window', request, response)
+          end
+        end
+      end # Real
+    end
+  end
+end

data/lib/fog/joyent/core.rb

@@ -0,0 +1,10 @@
+require 'fog/core'
+require 'fog/json'
+
+module Fog
+  module Joyent
+    extend Fog::Provider
+
+    service(:compute, 'Compute')
+  end
+end

data/lib/fog/joyent/errors.rb

@@ -0,0 +1,91 @@
+require 'fog/joyent/core'
+
+module Fog
+  module Compute
+    class Joyent < Fog::Service
+      class Errors
+        module MessageParserMixin
+          def message
+            if response.body["code"] && response.body["message"]
+              "[ERROR #{response.body['code']}] : #{response.body['message']}"
+            else
+              ''
+            end
+          end
+
+          def to_s
+            message
+          end
+        end
+
+        # https://us-west-1.api.joyentcloud.com/docs#cloudapi-http-responses
+        #
+        # HTTP Status Codes
+        #
+        # Your client should check for each of the following status codes from any API request:
+        #
+        # Response  Code  Description
+
+        # 400 Bad Request Invalid HTTP Request
+        class BadRequest < Excon::Errors::BadRequest
+          include MessageParserMixin
+        end
+
+        # 401 Unauthorized  Either no Authorization header was sent, or invalid credentials were used
+        class Unauthorized < Excon::Errors::Unauthorized
+          include MessageParserMixin
+        end
+
+        # 403 Forbidden No permissions to the specified resource
+        class Forbidden < Excon::Errors::Forbidden
+          include MessageParserMixin
+        end
+
+        # 404 Not Found Something you requested was not found
+        class NotFound < Excon::Errors::NotFound
+          include MessageParserMixin
+        end
+
+        # 405 Method Not Allowed  Method not supported for the given resource
+        class MethodNotAllowed < Excon::Errors::MethodNotAllowed
+          include MessageParserMixin
+        end
+
+        # 406 Not Acceptable  Try sending a different Accept header
+        class NotAcceptable < Excon::Errors::NotAcceptable
+          include MessageParserMixin
+        end
+
+        # 409 Conflict  Most likely invalid or missing parameters
+        class Conflict < Excon::Errors::Conflict
+          include MessageParserMixin
+        end
+
+        # 413 Request Entity Too Large  You sent too much data
+        class RequestEntityTooLarge < Excon::Errors::RequestEntityTooLarge
+          include MessageParserMixin
+        end
+
+        # 415 Unsupported Media Type  You encoded your request in a format we don't understand
+        class UnsupportedMediaType < Excon::Errors::UnsupportedMediaType
+          include MessageParserMixin
+        end
+
+        # 420 Slow Down You're sending too many requests
+        class PolicyNotForfilled < Excon::Errors::HTTPStatusError
+          include MessageParserMixin
+        end
+
+        # 449 Retry With  Invalid Version header; try with a different X-Api-Version string
+        class RetryWith < Excon::Errors::HTTPStatusError
+          include MessageParserMixin
+        end
+
+        # 503 Service Unavailable Either there's no capacity in this datacenter, or we're in a maintenance window
+        class ServiceUnavailable < Excon::Errors::ServiceUnavailable
+          include MessageParserMixin
+        end
+      end
+    end
+  end
+end

data/lib/fog/joyent/models/analytics/field.rb

@@ -0,0 +1,13 @@
+require 'fog/core/model'
+
+module Fog
+  module Joyent
+    class Analytics
+      class Field < Fog::Model
+        attribute :name
+        attribute :label
+        attribute :type
+      end
+    end
+  end
+end

data/lib/fog/joyent/models/analytics/fields.rb

@@ -0,0 +1,24 @@
+require 'fog/joyent/models/analytics/field'
+
+module Fog
+  module Joyent
+    class Analytics
+      class Fields < Fog::Collection
+        model Fog::Joyent::Analytics::Field
+
+        def all
+          data = service.describe_analytics.body['fields']
+          load(data)
+        end
+
+        # Joyent returns an odd data structure like this:
+        # { 'apache' => {'label' => 'Apache'}}
+        # where the key is the name of the module
+        def new(attributes = {})
+          name, other_attributes = attributes
+          super(other_attributes.merge('name' => name))
+        end
+      end
+    end
+  end
+end

data/lib/fog/joyent/models/analytics/instrumentation.rb

@@ -0,0 +1,82 @@
+require 'fog/core/model'
+
+module Fog
+  module Joyent
+    class Analytics
+      class Instrumentation < Fog::Model
+        identity :id
+        attribute :joyent_module, :aliases => 'module'
+        attribute :stat
+        attribute :predicate
+        attribute :decomposition, :type => :array
+        attribute :value_dimension, :aliases => 'value-dimension', :type => :integer
+        attribute :value_arity, :aliases => 'value-arity'
+        attribute :retention_time, :aliases => 'retention-time', :type => :integer
+        attribute :granularity, :type => :integer
+        attribute :idle_max, :aliases => 'idle-max', :type => :integer
+        attribute :transformations, :type => :array
+        attribute :persist_data, :aliases => 'persist-data', :type => :boolean
+        attribute :crtime
+        attribute :value_scope, :aliases => 'value-scope'
+        attribute :uris, :type => :array
+
+        def initialize(attributes={})
+          self.decomposition = []
+          self.value_arity = 'scalar'
+          self.retention_time = 600
+          self.idle_max = 3600
+          self.persist_data = false
+          self.value_scope = 'interval'
+          super
+        end
+
+        def crtime=(new_crtime)
+          attributes[:crtime] = Time.at(new_crtime.to_i / 1000)
+        end
+
+        def decomposition=(value)
+          attributes[:decomposition] = value
+          self.value_dimension = self.decomposition.size + 1
+          self.decomposition
+        end
+
+        def save
+          requires :joyent_module, :stat
+          munged_attributes = self.attributes.dup
+          remap_attributes(munged_attributes, {
+              :joyent_module => 'module',
+              :value_dimension => 'value-dimension',
+              :value_arity => 'value-arity',
+              :retention_time => 'retention-time',
+              :idle_max => 'idle-max',
+              :persist_data => 'persist-data',
+              :value_scope => 'value-scope'
+          })
+
+          data = service.create_instrumentation(munged_attributes)
+          merge_attributes(data.body)
+          true
+        end
+
+        def destroy
+          requires :id
+          service.delete_instrumentation(self.identity)
+          true
+        end
+
+        # Get a set of datapoints back for an instrumentation
+        # use start_time and ndatapoints so we can get back a range of datapoints
+        # the interval between datapoints should correspond to the granularity of the instrumentation
+        # @param [Time] start_time
+        # @param [Integer] ndatapoints
+        def values(start_time, ndatapoints)
+          requires :id, :granularity
+          data = service.get_instrumentation_value(self.uris.find {|uri| uri['name'] == 'value_raw'}['uri'], start_time, ndatapoints, self.granularity).body
+          data.map do |datum|
+            Fog::Joyent::Analytics::Value.new(datum)
+          end
+        end
+      end
+    end
+  end
+end