fog-openstack 0.1.0

data/lib/fog/openstack/models/baremetal/nodes.rb

@@ -0,0 +1,44 @@
+require 'fog/openstack/models/collection'
+require 'fog/openstack/models/baremetal/node'
+
+module Fog
+  module Baremetal
+    class OpenStack
+      class Nodes < Fog::OpenStack::Collection
+        model Fog::Baremetal::OpenStack::Node
+
+        def all(options = {})
+          load_response(service.list_nodes_detailed(options), 'nodes')
+        end
+
+        def summary(options = {})
+          load_response(service.list_nodes(options), 'nodes')
+        end
+
+        def details(options = {})
+          Fog::Logger.deprecation("Calling OpenStack[:baremetal].nodes.details will be removed, "\
+                                  " call .nodes.all for detailed list.")
+          load(service.list_nodes_detailed(options).body['nodes'])
+        end
+
+        def find_by_uuid(uuid)
+          new(service.get_node(uuid).body)
+        end
+        alias_method :get, :find_by_uuid
+
+        def destroy(uuid)
+          node = self.find_by_uuid(uuid)
+          node.destroy
+        end
+
+        def method_missing(method_sym, *arguments, &block)
+          if method_sym.to_s =~ /^find_by_(.*)$/
+            load(service.list_nodes_detailed({$1 => arguments.first}).body['nodes'])
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/openstack/models/baremetal/port.rb

@@ -0,0 +1,50 @@
+require 'fog/openstack/models/model'
+
+module Fog
+  module Baremetal
+    class OpenStack
+      class Port < Fog::OpenStack::Model
+        identity :uuid
+
+        attribute :address
+        attribute :uuid
+
+        #detailed
+        attribute :created_at
+        attribute :updated_at
+        attribute :extra
+        attribute :node_uuid
+
+        def create
+          requires :address, :node_uuid
+          merge_attributes(service.create_port(self.attributes).body)
+          self
+        end
+
+        def update(patch=nil)
+          requires :uuid, :address, :node_uuid
+          if patch
+            merge_attributes(service.patch_port(uuid, patch).body)
+          else
+            # TODO implement update_node method using PUT method and self.attributes
+            # once it is supported by Ironic
+            raise ArgumentError, ('You need to provide patch attribute. Ironic does '
+                                  'not support update by hash yet, only by jsonpatch.')
+          end
+          self
+        end
+
+        def destroy
+          requires :uuid
+          service.delete_port(self.uuid)
+          true
+        end
+
+        def metadata
+          requires :uuid
+          service.get_port(self.uuid).headers
+        end
+      end
+    end
+  end
+end

data/lib/fog/openstack/models/baremetal/ports.rb

@@ -0,0 +1,44 @@
+require 'fog/openstack/models/collection'
+require 'fog/openstack/models/baremetal/port'
+
+module Fog
+  module Baremetal
+    class OpenStack
+      class Ports < Fog::OpenStack::Collection
+        model Fog::Baremetal::OpenStack::Port
+
+        def all(options = {})
+          load_response(service.list_ports_detailed(options), 'ports')
+        end
+
+        def summary(options = {})
+          load_response(service.list_ports(options), 'ports')
+        end
+
+        def details(options = {})
+          Fog::Logger.deprecation("Calling OpenStack[:baremetal].ports.details will be removed, "\
+                                  " call .ports.all for detailed list.")
+          load(service.list_ports_detailed(options).body['ports'])
+        end
+
+        def find_by_uuid(uuid)
+          new(service.get_port(uuid).body)
+        end
+        alias_method :get, :find_by_uuid
+
+        def destroy(uuid)
+          port = self.find_by_id(uuid)
+          port.destroy
+        end
+
+        def method_missing(method_sym, *arguments, &block)
+          if method_sym.to_s =~ /^find_by_(.*)$/
+            load(service.list_ports_detailed({$1 => arguments.first}).body['ports'])
+          else
+            super
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,45 @@
+require 'fog/core/collection'
+
+module Fog
+  module OpenStack
+    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 load_response(response, index = nil)
+        # Delete it index if it's there, so we don't store response with data twice, but we store only metadata
+        objects = index ? response.body.delete(index) : response.body
+
+        clear && objects.each { |object| self << new(object) }
+        self.response = response
+        self
+      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::OpenStack::Errors::InterfaceNotImplemented.new('Method :all is not implemented')
+      end
+
+      # Returns non detailed list of records, usually just subset of attributes, which makes this call more effective.
+      # Not all openstack services support non detailed list, so it delegates to :all by default.
+      def summary(options = {})
+        all(options)
+      end
+
+      # Gets record given record's UUID
+      def get(uuid)
+        raise Fog::OpenStack::Errors::InterfaceNotImplemented.new('Method :get is not implemented')
+      end
+      alias_method :find_by_id, :get
+
+      # Destroys record given record's UUID
+      def destroy(uuid)
+        raise Fog::OpenStack::Errors::InterfaceNotImplemented.new('Method :destroy is not implemented')
+      end
+    end
+  end
+end

data/lib/fog/openstack/models/compute/address.rb

@@ -0,0 +1,67 @@
+require 'fog/openstack/models/model'
+
+module Fog
+  module Compute
+    class OpenStack
+      class Address < Fog::OpenStack::Model
+        identity  :id
+
+        attribute :ip
+        attribute :pool
+        attribute :fixed_ip
+        attribute :instance_id
+
+        def initialize(attributes = {})
+          # assign server first to prevent race condition with persisted?
+          self.server = attributes.delete(:server)
+          super
+        end
+
+        def destroy
+          requires :id
+          service.release_address(id)
+          true
+        end
+
+        def server=(new_server)
+          if new_server
+            associate(new_server)
+          else
+            disassociate
+          end
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
+          data = service.allocate_address(pool).body['floating_ip']
+          new_attributes = data.reject {|key,value| !['id', 'instance_id', 'ip', 'fixed_ip'].include?(key)}
+          merge_attributes(new_attributes)
+          if @server
+            self.server = @server
+          end
+          true
+        end
+
+        private
+
+        def associate(new_server)
+          unless persisted?
+            @server = new_server
+          else
+            @server = nil
+            self.instance_id = new_server.id
+            service.associate_address(instance_id, ip)
+          end
+        end
+
+        def disassociate
+          @server = nil
+          if persisted?
+            service.disassociate_address(instance_id, ip)
+          end
+          self.instance_id = nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/openstack/models/compute/addresses.rb

@@ -0,0 +1,28 @@
+require 'fog/openstack/models/collection'
+require 'fog/openstack/models/compute/address'
+
+module Fog
+  module Compute
+    class OpenStack
+      class Addresses < Fog::OpenStack::Collection
+        model Fog::Compute::OpenStack::Address
+
+        def all(options = {})
+          load_response(service.list_all_addresses(options), 'floating_ips')
+        end
+
+        def get(address_id)
+          if address = service.get_address(address_id).body['floating_ip']
+            new(address)
+          end
+        rescue Fog::Compute::OpenStack::NotFound
+          nil
+        end
+
+        def get_address_pools
+          service.list_address_pools.body['floating_ip_pools']
+        end
+      end
+    end
+  end
+end

data/lib/fog/openstack/models/compute/aggregate.rb

@@ -0,0 +1,58 @@
+require 'fog/openstack/models/model'
+
+module Fog
+  module Compute
+    class OpenStack
+      class Aggregate < Fog::OpenStack::Model
+        identity :id
+
+        attribute :availability_zone
+        attribute :name
+        attribute :metadata
+        attribute :deleted
+        attribute :deleted_at
+        attribute :updated_at
+        attribute :created_at
+
+        # Detailed
+        attribute :hosts
+
+        def save
+          requires :name
+          identity ? update : create
+        end
+
+        def create
+          requires :name
+          merge_attributes(service.create_aggregate(self.name, self.attributes).body['aggregate'])
+          self
+        end
+
+        def update
+          merge_attributes(service.update_aggregate(self.id, self.attributes).body['aggregate'])
+          self
+        end
+
+        def add_host(host_uuid)
+          requires :id,
+          service.add_aggregate_host(self.id, host_uuid)
+        end
+
+        def remove_host(host_uuid)
+          requires :id,
+          service.remove_aggregate_host(self.id, host_uuid)
+        end
+
+        def update_metadata(metadata)
+          service.update_aggregate_metadata(self.id, metadata)
+        end
+
+        def destroy
+          requires :id
+          service.delete_aggregate(self.id)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/openstack/models/compute/aggregates.rb

@@ -0,0 +1,26 @@
+require 'fog/openstack/models/collection'
+require 'fog/openstack/models/compute/aggregate'
+
+module Fog
+  module Compute
+    class OpenStack
+      class Aggregates < Fog::OpenStack::Collection
+        model Fog::Compute::OpenStack::Aggregate
+
+        def all(options = {})
+          load_response(service.list_aggregates(options), 'aggregates')
+        end
+
+        def find_by_id(id)
+          new(service.get_aggregate(id).body['aggregate'])
+        end
+        alias_method :get, :find_by_id
+
+        def destroy(id)
+          aggregate = self.find_by_id(id)
+          aggregate.destroy
+        end
+      end
+    end
+  end
+end

data/lib/fog/openstack/models/compute/availability_zone.rb

@@ -0,0 +1,14 @@
+require 'fog/openstack/models/model'
+
+module Fog
+  module Compute
+    class OpenStack
+      class AvailabilityZone < Fog::OpenStack::Model
+        identity :zoneName
+
+        attribute :hosts
+        attribute :zoneState
+      end
+    end
+  end
+end

data/lib/fog/openstack/models/compute/availability_zones.rb

@@ -0,0 +1,22 @@
+require 'fog/openstack/models/collection'
+require 'fog/openstack/models/compute/availability_zone'
+
+module Fog
+  module Compute
+    class OpenStack
+      class AvailabilityZones < Fog::OpenStack::Collection
+        model Fog::Compute::OpenStack::AvailabilityZone
+
+        def all(options = {})
+          data = service.list_zones_detailed(options)
+          load_response(data, 'availabilityZoneInfo')
+        end
+
+        def summary(options = {})
+          data = service.list_zones(options)
+          load_response(data, 'availabilityZoneInfo')
+        end
+      end
+    end
+  end
+end

data/lib/fog/openstack/models/compute/flavor.rb

@@ -0,0 +1,52 @@
+require 'fog/openstack/models/model'
+
+module Fog
+  module Compute
+    class OpenStack
+      class Flavor < Fog::OpenStack::Model
+        identity :id
+
+        attribute :name
+        attribute :ram
+        attribute :disk
+        attribute :vcpus
+        attribute :links
+        attribute :swap
+        attribute :rxtx_factor
+        attribute :metadata
+        attribute :ephemeral, :aliases => 'OS-FLV-EXT-DATA:ephemeral'
+        attribute :is_public, :aliases => 'os-flavor-access:is_public'
+        attribute :disabled, :aliases => 'OS-FLV-DISABLED:disabled'
+
+        def save
+          requires :name, :ram, :vcpus, :disk
+          attributes[:ephemeral] = self.ephemeral || 0
+          attributes[:is_public] = self.is_public || false
+          attributes[:disabled] = self.disabled || false
+          attributes[:swap] = self.swap || 0
+          attributes[:rxtx_factor] = self.rxtx_factor || 1.0
+          merge_attributes(service.create_flavor(self.attributes).body['flavor'])
+          self
+        end
+
+        def destroy
+          requires :id
+          service.delete_flavor(self.id)
+          true
+        end
+
+        def metadata
+          service.get_flavor_metadata(self.id).body['extra_specs']
+        rescue Fog::Compute::OpenStack::NotFound
+          nil
+        end
+
+        def create_metadata(metadata)
+          service.create_flavor_metadata(self.id, metadata)
+        rescue Fog::Compute::OpenStack::NotFound
+          nil
+        end
+      end
+    end
+  end
+end