fog-oracle 0.1.0

data/lib/fog/oracle/core.rb

@@ -0,0 +1,92 @@
+require 'fog/core'
+require 'fog/json'
+require 'fog/xml'
+
+module Fog
+  module Oracle
+    extend Fog::Provider
+
+    module Errors
+      class ServiceError < Fog::Errors::Error; end
+      class ServiceUnavailable < ServiceError; end
+      class BadRequest < ServiceError; end
+      class InterfaceNotImplemented < Fog::Errors::Error; end
+    end
+
+    service(:compute, 'Compute')
+
+    module JsonUtils
+      def json_encode(body)
+        encoded = Fog::JSON.encode(body)
+        encoded
+      end
+
+      def json_decode(body)
+        parsed = Fog::JSON.decode(body)
+        snakecase_hash_keys(parsed)
+        # decode_time_attrs(parsed)
+        parsed
+      end
+
+      def snakecase_hash_keys(value)
+        case value
+        when Hash
+          value.keys.each do |key|
+            new_key = key.underscore
+            value[new_key] = value.delete(key)
+            snakecase_hash_keys(value[new_key])
+          end
+        when Array
+          value.each do |it|
+            snakecase_hash_keys(it)
+          end
+        end
+      end
+    end
+
+    module Core
+      include JsonUtils
+
+      def core_initialize(options)
+        @api_url                  = options[:oracle_url]
+        @username                 = options[:oracle_username]
+        @password                 = options[:oracle_password]
+        @connection_options       = options[:connection_options] || {}
+        @persistent               = options[:persistent] || false
+        @connection = Fog::XML::Connection.new(@api_url, @persistent, @connection_options)
+      end
+
+      def escape(str)
+        str.gsub(/([^a-zA-Z0-9_.-]+)/) do
+          '%' + $1.unpack('H2' * $1.bytesize).join('%').upcase
+        end
+      end
+
+      def request(opts)
+        opts[:path] = '/ovm/core/wsapi/rest/' + opts[:path]
+
+        hash = Base64.encode64(@username + ":" + @password).delete("\r\n")
+
+        opts[:headers] = {
+          "Accept" => "application/json",
+          'Authorization' => "Basic #{hash}"
+        }.merge(opts[:headers] || {})
+
+        if opts[:body]
+          opts[:headers]["Content-Type"] = "application/json"
+          opts[:body] = json_encode(opts[:body])
+        end
+
+        response = @connection.request(opts)
+
+        if response.headers["Content-Type"] == "application/json"
+          response.body = json_decode(response.body)
+        end
+
+        # puts @api_url, opts, response
+
+        response
+      end
+    end
+  end
+end

data/lib/fog/oracle/models/associations.rb

@@ -0,0 +1,89 @@
+module Fog
+  module Associations
+    class OracleDefault < Default
+      def create_setter
+        model.class_eval <<-EOS, __FILE__, __LINE__
+          def #{name}=(new_#{name})
+            associations[:#{name}] = new_#{name}
+          end
+        EOS
+      end
+
+      def create_getter
+        model.class_eval <<-EOS, __FILE__, __LINE__
+          def #{name}
+            associations[:#{name}]
+          end
+        EOS
+      end
+    end
+
+    class OracleOneModel < OracleDefault
+      def create_setter
+        model.class_eval <<-EOS, __FILE__, __LINE__
+          def #{name}=(new_#{name})
+            return if new_#{name}.nil?
+            associations[:#{name}] = service.send(self.class.associations[:#{name}]).new(new_#{name})
+          end
+        EOS
+      end
+    end
+
+    class OracleManyModels < OracleDefault
+      def create_setter
+        model.class_eval <<-EOS, __FILE__, __LINE__
+          def #{name}=(new_#{name})
+            return if new_#{name}.nil?
+            collection = service.send(self.class.associations[:#{name}])
+            associations[:#{name}] = Array(new_#{name}).map do |association|
+              collection.new(association)
+            end
+          end
+        EOS
+      end
+    end
+
+    class OracleOneIdentity < OracleDefault
+      attr_reader :details_name
+
+      def initialize(model, name, collection_name, options)
+        @details_name = options[:details_name]
+        super(model, name, collection_name, options)
+      end
+
+      def create_getter
+        super
+
+        model.class_eval <<-EOS, __FILE__, __LINE__
+          def #{details_name}
+            return nil if associations[:#{name}].nil?
+            service.send(self.class.associations[:#{name}]).get(associations[:#{name}])
+          end
+        EOS
+      end
+    end
+
+    class OracleManyIdentities < OracleDefault
+      attr_reader :all_name
+
+      def initialize(model, name, collection_name, options)
+        @all_name = options[:all_name]
+        super(model, name, collection_name, options)
+      end
+
+      def create_getter
+        super
+
+        model.class_eval <<-EOS, __FILE__, __LINE__
+          def #{all_name}
+            return [] if associations[:#{name}].nil?
+            data = Array(associations[:#{name}]).map do |association|
+              service.send(self.class.associations[:#{name}]).get(association)
+            end
+            #{association_class}.new(data)
+          end
+        EOS
+      end
+    end
+  end
+end

data/lib/fog/oracle/models/collection.rb

@@ -0,0 +1,47 @@
+require 'fog/core/collection'
+
+module Fog
+  module Oracle
+    class Collection < Fog::Collection
+      # It's important to store the whole response, it contains e.g. important info about whether there is another
+      # page of data.
+      attr_accessor :response
+
+      def id_value(id)
+        if id.is_a?(Hash)
+          id["value"]
+        else
+          id
+        end
+      end
+
+      def load_response(response)
+        objects = response.body
+
+        clear && objects.each { |object| self << new(object) }
+        self.response = response
+        self
+      end
+
+      def new_from_response(response)
+        obj = new(response.body)
+        obj.response = response
+        obj
+      end
+
+      ##################################################################################################################
+      # Abstract base class methods, please keep the consistent naming in all subclasses of the Collection class
+
+      # Returns detailed list of records
+      def all(options = {})
+        raise Fog::Oracle::Errors::InterfaceNotImplemented.new('Method :all is not implemented')
+      end
+
+      # Gets record given record's id
+      def get(id)
+        raise Fog::Oracle::Errors::InterfaceNotImplemented.new('Method :get is not implemented')
+      end
+      alias_method :find_by_id, :get
+    end
+  end
+end

data/lib/fog/oracle/models/compute/access_group.rb

@@ -0,0 +1,18 @@
+require 'fog/oracle/models/compute/base_object'
+
+module Fog
+  module Compute
+    class Oracle
+      class AccessGroup < BaseObject
+        attribute :name_on_array, :type => :string
+        attribute :type, :type => :string # AccessGroupType
+        has_many_identities :file_system_ids, :file_systems, :all_name => :file_systems
+        has_many_identities :server_ids, :servers, :all_name => :servers
+        has_many_identities :storage_element_ids, :storage_elements, :all_name => :storage_elements
+        has_many_identities :storage_initiator_ids, :storage_initiators, :all_name => :storage_initiators
+        has_one_identity :file_server_id, :file_servers, :details_name => :file_server
+        has_one_identity :storage_array_id, :storage_arrays, :details_name => :storage_array
+      end
+    end
+  end
+end

data/lib/fog/oracle/models/compute/access_group_type.rb

@@ -0,0 +1,8 @@
+module Fog
+  module Oracle
+    module AccessGroupType
+      FILE_SYSTEM = 'FILE_SYSTEM'
+      STORAGE_ELEMENT = 'STORAGE_ELEMENT'
+    end
+  end
+end

data/lib/fog/oracle/models/compute/access_groups.rb

@@ -0,0 +1,22 @@
+require 'fog/oracle/models/collection'
+require 'fog/oracle/models/compute/access_group'
+
+module Fog
+  module Compute
+    class Oracle
+      class AccessGroups < Fog::Oracle::Collection
+        model Fog::Compute::Oracle::AccessGroup
+
+        def all()
+          data = service.list_access_groups()
+          load_response(data)
+        end
+
+        def get(id)
+          data = service.get_access_group(id_value(id))
+          new_from_response(data)
+        end
+      end
+    end
+  end
+end

data/lib/fog/oracle/models/compute/access_host.rb

@@ -0,0 +1,14 @@
+require 'fog/oracle/models/model'
+
+module Fog
+  module Compute
+    class Oracle
+      class AccessHost < Fog::Oracle::Model
+        attribute :hostname, :type => :string
+        attribute :password, :type => :string
+        attribute :port, :type => :integer
+        attribute :username, :type => :string
+      end
+    end
+  end
+end

data/lib/fog/oracle/models/compute/access_hosts.rb

@@ -0,0 +1,22 @@
+require 'fog/oracle/models/collection'
+require 'fog/oracle/models/compute/access_host'
+
+module Fog
+  module Compute
+    class Oracle
+      class AccessHosts < Fog::Oracle::Collection
+        model Fog::Compute::Oracle::AccessHost
+
+        def all()
+          data = service.list_access_hosts()
+          load_response(data)
+        end
+
+        def get(id)
+          data = service.get_access_host(id_value(id))
+          new_from_response(data)
+        end
+      end
+    end
+  end
+end

data/lib/fog/oracle/models/compute/affinity_group.rb

@@ -0,0 +1,15 @@
+require 'fog/oracle/models/compute/base_object'
+
+module Fog
+  module Compute
+    class Oracle
+      class AffinityGroup < BaseObject
+        attribute :server_affinity_type, :type => :string # AffinityType
+        attribute :vm_affinity_type, :type => :string # AffinityType
+        has_many_identities :server_ids, :servers, :all_name => :servers
+        has_many_identities :vm_ids, :vms, :all_name => :vms
+        has_one_identity :server_pool_id, :server_pools, :details_name => :server_pool
+      end
+    end
+  end
+end

data/lib/fog/oracle/models/compute/affinity_groups.rb

@@ -0,0 +1,22 @@
+require 'fog/oracle/models/collection'
+require 'fog/oracle/models/compute/affinity_group'
+
+module Fog
+  module Compute
+    class Oracle
+      class AffinityGroups < Fog::Oracle::Collection
+        model Fog::Compute::Oracle::AffinityGroup
+
+        def all()
+          data = service.list_affinity_groups()
+          load_response(data)
+        end
+
+        def get(id)
+          data = service.get_affinity_group(id_value(id))
+          new_from_response(data)
+        end
+      end
+    end
+  end
+end

data/lib/fog/oracle/models/compute/affinity_type.rb

@@ -0,0 +1,9 @@
+module Fog
+  module Oracle
+    module AffinityType
+      AFFINITY = 'AFFINITY'
+      ANTI_AFFINITY = 'ANTI_AFFINITY'
+      NO_AFFINITY = 'NO_AFFINITY'
+    end
+  end
+end

data/lib/fog/oracle/models/compute/archive_management_attributes.rb

@@ -0,0 +1,16 @@
+require 'fog/oracle/models/model'
+
+module Fog
+  module Compute
+    class Oracle
+      class ArchiveManagementAttributes < Fog::Oracle::Model
+        attribute :archive_events_max_age, :type => :integer
+        attribute :archive_jobs_max_age, :type => :integer
+        attribute :constructing_jobs_max_age, :type => :integer
+        attribute :interval, :type => :integer
+        attribute :live_events_max_age, :type => :integer
+        attribute :live_jobs_max_age, :type => :integer
+      end
+    end
+  end
+end

data/lib/fog/oracle/models/compute/archive_management_attributeses.rb

@@ -0,0 +1,22 @@
+require 'fog/oracle/models/collection'
+require 'fog/oracle/models/compute/archive_management_attributes'
+
+module Fog
+  module Compute
+    class Oracle
+      class ArchiveManagementAttributeses < Fog::Oracle::Collection
+        model Fog::Compute::Oracle::ArchiveManagementAttributes
+
+        def all()
+          data = service.list_archive_management_attributeses()
+          load_response(data)
+        end
+
+        def get(id)
+          data = service.get_archive_management_attributes(id_value(id))
+          new_from_response(data)
+        end
+      end
+    end
+  end
+end

data/lib/fog/oracle/models/compute/assemblies.rb

@@ -0,0 +1,22 @@
+require 'fog/oracle/models/collection'
+require 'fog/oracle/models/compute/assembly'
+
+module Fog
+  module Compute
+    class Oracle
+      class Assemblies < Fog::Oracle::Collection
+        model Fog::Compute::Oracle::Assembly
+
+        def all()
+          data = service.list_assemblies()
+          load_response(data)
+        end
+
+        def get(id)
+          data = service.get_assembly(id_value(id))
+          new_from_response(data)
+        end
+      end
+    end
+  end
+end

data/lib/fog/oracle/models/compute/assembly.rb

@@ -0,0 +1,15 @@
+require 'fog/oracle/models/compute/base_object'
+
+module Fog
+  module Compute
+    class Oracle
+      class Assembly < BaseObject
+        attribute :locales, :type => :array # of :string
+        attribute :origin, :type => :string
+        has_many_identities :assembly_virtual_disk_ids, :assembly_virtual_disks, :all_name => :assembly_virtual_disks
+        has_many_identities :assembly_vm_ids, :assembly_vms, :all_name => :assembly_vms
+        has_one_identity :repository_id, :repositories, :details_name => :repository
+      end
+    end
+  end
+end