oraclecloud 1.0.0

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/lib/oraclecloud.rb

@@ -0,0 +1,36 @@
+#
+# Author:: Chef Partner Engineering (<partnereng@chef.io>)
+# Copyright:: Copyright (c) 2015 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'oraclecloud/asset'
+require 'oraclecloud/assets'
+require 'oraclecloud/client'
+require 'oraclecloud/exceptions'
+require 'oraclecloud/imagelist'
+require 'oraclecloud/imagelists'
+require 'oraclecloud/instance'
+require 'oraclecloud/instances'
+require 'oraclecloud/instance_request'
+require 'oraclecloud/ip_association'
+require 'oraclecloud/ip_associations'
+require 'oraclecloud/orchestration'
+require 'oraclecloud/orchestrations'
+require 'oraclecloud/shape'
+require 'oraclecloud/shapes'
+require 'oraclecloud/sshkey'
+require 'oraclecloud/sshkeys'
+require 'oraclecloud/version'

data/lib/oraclecloud/asset.rb

@@ -0,0 +1,65 @@
+#
+# Author:: Chef Partner Engineering (<partnereng@chef.io>)
+# Copyright:: Copyright (c) 2015 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module OracleCloud
+  class Asset
+    attr_reader :asset_data, :asset_type, :client, :container, :path
+
+    def initialize(client, path)
+      @client     = client
+      @asset_data = nil
+      @path       = path
+      @container  = path.split('/').first
+
+      local_init
+      validate!
+
+      fetch
+    end
+
+    def local_init
+      # this should be redefined in each Assets subclass with things like
+      # the @asset_type to use in API calls
+    end
+
+    def validate!
+      raise "#{self.class} did not define an asset_type variable" if asset_type.nil?
+    end
+
+    def fetch
+      @asset_data = client.single_item(asset_type, path)
+    end
+    alias_method :refresh, :fetch
+
+    def id
+      asset_data['name'].split('/').last
+    end
+    alias_method :name, :id
+
+    def name_with_container
+      "#{container}/#{id}"
+    end
+
+    def full_name
+      "/Compute-#{client.identity_domain}/#{name_with_container}"
+    end
+
+    def strip_identity_domain(name)
+      name.gsub("/Compute-#{client.identity_domain}/", '')
+    end
+  end
+end

data/lib/oraclecloud/assets.rb

@@ -0,0 +1,99 @@
+#
+# Author:: Chef Partner Engineering (<partnereng@chef.io>)
+# Copyright:: Copyright (c) 2015 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+module OracleCloud
+  class Assets
+    attr_reader :asset_klass, :asset_type, :client
+    attr_accessor :create_opts
+
+    def initialize(client)
+      @client = client
+      @create_opts = {}
+
+      local_init
+      validate!
+    end
+
+    def local_init
+      # this should be redefined in each Assets subclass with things like
+      # the @asset_type to use in API calls
+    end
+
+    def validate!
+      raise "#{self.class} did not define an asset_type variable" if asset_type.nil?
+      raise "#{self.class} did not define an asset_klass variable" if asset_klass.nil?
+    end
+
+    def all
+      all_asset_ids_by_container.each_with_object([]) do |(container, asset_names), memo|
+        asset_names.each do |asset_name|
+          memo << @asset_klass.new(client, "#{container}/#{asset_name}")
+        end
+      end
+    end
+
+    def containers
+      directory('')
+    end
+
+    def ids_from_results(results)
+      results['result'].map { |x| x.split('/').last }
+    end
+
+    def all_asset_ids_by_container
+      containers.each_with_object({}) do |container, memo|
+        memo[container] = asset_ids_for_container(container)
+      end
+    end
+
+    def asset_ids_for_container(container)
+      directory(container)
+    end
+
+    def by_name(name)
+      @asset_klass.new(client, strip_identity_domain(name))
+    end
+
+    def directory(path)
+      ids_from_results(client.directory(asset_type, path))
+    end
+
+    def create(opts)
+      @create_opts = opts
+
+      validate_create_options!
+      response = client.http_post("/#{asset_type}/", create_request_payload.to_json)
+      name     = strip_identity_domain(response['name'])
+      @asset_klass.new(client, name)
+    end
+
+    def create_request_payload
+      # this should be defined in each Assets subclass with a formatted
+      # payload used to create the Asset
+      raise NoMethodError, "#{self.class} does not define create_request_payload"
+    end
+
+    def validate_create_options!
+      # this should be redefined in each Assets subclass with any validation
+      # of creation options that should be done prior to creation
+    end
+
+    def strip_identity_domain(name)
+      name.gsub("/Compute-#{client.identity_domain}/", '')
+    end
+  end
+end

data/lib/oraclecloud/client.rb

@@ -0,0 +1,250 @@
+#
+# Author:: Chef Partner Engineering (<partnereng@chef.io>)
+# Copyright:: Copyright (c) 2015 Chef Software, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'ffi_yajl'
+require 'rest-client'
+
+module OracleCloud
+  class Client # rubocop:disable Metrics/ClassLength
+    attr_reader :identity_domain, :password, :username
+
+    def initialize(opts)
+      @api_url         = opts[:api_url]
+      @identity_domain = opts[:identity_domain]
+      @username        = opts[:username]
+      @password        = opts[:password]
+      @verify_ssl      = opts.fetch(:verify_ssl, true)
+      @cookie          = nil
+
+      validate_client_options!
+    end
+
+    #################################
+    #
+    # methods to other API objects
+    #
+
+    def imagelists
+      OracleCloud::ImageLists.new(self)
+    end
+
+    def instance_request(*args)
+      OracleCloud::InstanceRequest.new(self, *args)
+    end
+
+    def instances
+      OracleCloud::Instances.new(self)
+    end
+
+    def ip_associations
+      OracleCloud::IPAssociations.new(self)
+    end
+
+    def orchestrations
+      OracleCloud::Orchestrations.new(self)
+    end
+
+    def shapes
+      OracleCloud::Shapes.new(self)
+    end
+
+    def sshkeys
+      OracleCloud::SSHKeys.new(self)
+    end
+
+    #################################
+    #
+    # client methods
+    #
+
+    def validate_client_options!
+      raise ArgumentError, 'Username, password and identity_domain are required' if
+        @username.nil? || @password.nil? || @identity_domain.nil?
+      raise ArgumentError, 'An API URL is required' if @api_url.nil?
+      raise ArgumentError, "API URL #{@api_url} is not a valid URI." unless valid_uri?(@api_url)
+    end
+
+    def valid_uri?(uri)
+      uri = URI.parse(uri)
+      uri.is_a?(URI::HTTP)
+    rescue URI::InvalidURIError
+      false
+    end
+
+    def username_with_domain
+      "#{compute_identity_domain}/#{@username}"
+    end
+
+    def compute_identity_domain
+      "Compute-#{@identity_domain}"
+    end
+
+    def authenticate!
+      path = '/authenticate/'
+      response = RestClient::Request.execute(method: :post,
+                                             url: full_url(path),
+                                             headers: request_headers,
+                                             payload: authenticate_payload.to_json,
+                                             verify_ssl: @verify_ssl)
+
+    rescue => e
+      raise_http_exception(e, path)
+    else
+      @cookie = process_auth_cookies(response.headers[:set_cookie])
+    end
+
+    def authenticated?
+      ! @cookie.nil?
+    end
+
+    def request_headers(opts = {})
+      headers = { 'Content-Type' => 'application/oracle-compute-v3+json' }
+
+      if opts[:type] == :directory
+        headers['Accept'] = 'application/oracle-compute-v3+directory+json'
+      else
+        headers['Accept'] = 'application/oracle-compute-v3+json'
+      end
+
+      headers['Cookie'] = @cookie if @cookie
+      headers
+    end
+
+    def authenticate_payload
+      {
+        'user'     => username_with_domain,
+        'password' => @password
+      }
+    end
+
+    def full_url(path)
+      @api_url + path
+    end
+
+    def process_auth_cookies(cookies)
+      cookie = cookies.find { |c| c.start_with?('nimbula=') }
+      raise 'No nimbula auth cookie received in authentication request' if cookie.nil?
+
+      cookie.gsub!(/ Path=.* Max-Age=.*$/, '')
+      cookie
+    end
+
+    def asset_get(request_type, asset_type, path)
+      url = url_with_identity_domain(asset_type, path)
+      http_get(request_type, url)
+    end
+
+    def asset_put(asset_type, path, payload = nil)
+      url = url_with_identity_domain(asset_type, path)
+      http_put(url, payload)
+    end
+
+    def asset_delete(asset_type, path)
+      url = url_with_identity_domain(asset_type, path)
+      http_delete(url)
+    end
+
+    def single_item(asset_type, path)
+      asset_get(:single, asset_type, path)
+    end
+
+    def directory(asset_type, path)
+      asset_get(:directory, asset_type, path)
+    end
+
+    def url_with_identity_domain(type, path = '')
+      "/#{type}/#{compute_identity_domain}/#{path}"
+    end
+
+    def http_get(request_type, url)
+      authenticate! unless authenticated?
+
+      response = RestClient::Request.execute(method: :get,
+                                             url: full_url(url),
+                                             headers: request_headers(type: request_type),
+                                             verify_ssl: @verify_ssl)
+    rescue => e
+      raise_http_exception(e, url)
+    else
+      FFI_Yajl::Parser.parse(response)
+    end
+
+    def http_post(path, payload)
+      authenticate! unless authenticated?
+      response = RestClient::Request.execute(method: :post,
+                                             url: full_url(path),
+                                             headers: request_headers,
+                                             payload: payload,
+                                             verify_ssl: @verify_ssl)
+    rescue => e
+      raise_http_exception(e, path)
+    else
+      FFI_Yajl::Parser.parse(response)
+    end
+
+    def http_put(path, payload = nil)
+      authenticate! unless authenticated?
+      response = RestClient::Request.execute(method: :put,
+                                             url: full_url(path),
+                                             headers: request_headers,
+                                             payload: payload,
+                                             verify_ssl: @verify_ssl)
+    rescue => e
+      raise_http_exception(e, path)
+    else
+      FFI_Yajl::Parser.parse(response)
+    end
+
+    def http_delete(path)
+      authenticate! unless authenticated?
+      response = RestClient::Request.execute(method: :delete,
+                                             url: full_url(path),
+                                             headers: request_headers,
+                                             verify_ssl: @verify_ssl)
+    rescue => e
+      raise_http_exception(e, path)
+    else
+      FFI_Yajl::Parser.parse(response)
+    end
+
+    def raise_http_exception(caught_exception, path)
+      raise unless caught_exception.respond_to?(:http_code)
+
+      if caught_exception.http_code == 404
+        klass = OracleCloud::Exception::HTTPNotFound
+      else
+        klass = OracleCloud::Exception::HTTPError
+      end
+
+      begin
+        error_body = FFI_Yajl::Parser.parse(caught_exception.response)
+      rescue
+        error_body = { 'message' => caught_exception.response }
+      end
+
+      exception = klass.new(code: caught_exception.http_code,
+                            body: caught_exception.response,
+                            klass: caught_exception.class,
+                            error: error_body['message'].to_s,
+                            path: path)
+
+      message = exception.error.empty? ? caught_exception.message : exception.error
+      raise exception, message
+    end
+  end
+end