fog-openstack 0.1.10 → 0.1.11

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

@@ -1,22 +0,0 @@
-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/flavors.rb

@@ -1,29 +0,0 @@
-require 'fog/openstack/models/collection'
-require 'fog/openstack/models/compute/flavor'
-
-module Fog
-  module Compute
-    class OpenStack
-      class Flavors < Fog::OpenStack::Collection
-        model Fog::Compute::OpenStack::Flavor
-
-        def all(options = {})
-          data = service.list_flavors_detail(options)
-          load_response(data, 'flavors')
-        end
-
-        def summary(options = {})
-          data = service.list_flavors(options)
-          load_response(data, 'flavors')
-        end
-
-        def get(flavor_id)
-          data = service.get_flavor_details(flavor_id).body['flavor']
-          new(data)
-        rescue Fog::Compute::OpenStack::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-require 'fog/compute/models/server'
-require 'fog/openstack/models/compute/metadata'
-
-module Fog
-  module Compute
-    class OpenStack
-      class Host < Fog::OpenStack::Model
-        attribute :host_name
-        attribute :service_name
-        attribute :details
-        attribute :zone
-
-        def initialize(attributes)
-          attributes["service_name"] = attributes.delete "service"
-          # Old 'connection' is renamed as service and should be used instead
-          prepare_service_value(attributes)
-          super
-        end
-
-        def details
-          service.get_host_details(self.host_name).body['host']
-        rescue Fog::Compute::OpenStack::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-require 'fog/openstack/models/collection'
-require 'fog/openstack/models/compute/host'
-
-module Fog
-  module Compute
-    class OpenStack
-      class Hosts < Fog::OpenStack::Collection
-        model Fog::Compute::OpenStack::Host
-
-        def all(options = {})
-          data = service.list_hosts(options)
-          load_response(data, 'hosts')
-        end
-
-        def get(host_name)
-          if host = service.get_host_details(host_name).body['host']
-            new({
-              'host_name' => host_name,
-              'details' => host}
-            )
-          end
-        rescue Fog::Compute::OpenStack::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-require 'fog/openstack/models/model'
-require 'fog/openstack/models/compute/metadata'
-
-module Fog
-  module Compute
-    class OpenStack
-      class Image < Fog::OpenStack::Model
-        identity :id
-
-        attribute :name
-        attribute :created_at,  :aliases => 'created'
-        attribute :updated_at,  :aliases => 'updated'
-        attribute :progress
-        attribute :status
-        attribute :minDisk
-        attribute :minRam
-        attribute :server,   :aliases => 'server'
-        attribute :metadata
-        attribute :links
-
-        def metadata
-          @metadata ||= begin
-            Fog::Compute::OpenStack::Metadata.new({
-              :service => service,
-              :parent => self
-            })
-          end
-        end
-
-        def metadata=(new_metadata={})
-          metas = []
-          new_metadata.each_pair {|k,v| metas << {"key" => k, "value" => v} }
-          metadata.load(metas)
-        end
-
-        def destroy
-          requires :id
-          service.delete_image(id)
-          true
-        end
-
-        def ready?
-          status == 'ACTIVE'
-        end
-      end
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-require 'fog/openstack/models/collection'
-require 'fog/openstack/models/compute/image'
-
-module Fog
-  module Compute
-    class OpenStack
-      class Images < Fog::OpenStack::Collection
-        attribute :filters
-
-        model Fog::Compute::OpenStack::Image
-
-        attribute :server
-
-        def initialize(attributes)
-          self.filters ||= {}
-          super
-        end
-
-        def all(filters_arg = filters)
-          filters = filters_arg
-          data = service.list_images_detail(filters)
-          images = load_response(data, 'images')
-          if server
-            self.replace(self.select {|image| image.server_id == server.id})
-          end
-          images
-        end
-
-        def get(image_id)
-          data = service.get_image_details(image_id).body['image']
-          new(data)
-        rescue Fog::Compute::OpenStack::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-require 'fog/openstack/models/model'
-
-module Fog
-  module Compute
-    class OpenStack
-      class KeyPair < Fog::OpenStack::Model
-        identity  :name
-
-        attribute :fingerprint
-        attribute :public_key
-        attribute :private_key
-        attribute :user_id
-        attribute :id
-
-        attr_accessor :public_key
-
-        def destroy
-          requires :name
-
-          service.delete_key_pair(name)
-          true
-        end
-
-        def save
-          requires :name
-
-          data = if public_key
-            service.create_key_pair(name, public_key).body['keypair']
-          else
-            service.create_key_pair(name).body['keypair']
-          end
-          new_attributes = data.reject {|key,value| !['fingerprint', 'public_key', 'name', 'private_key', 'user_id'].include?(key)}
-          merge_attributes(new_attributes)
-          true
-        end
-
-        def write(path="#{ENV['HOME']}/.ssh/fog_#{Fog.credential.to_s}_#{name}.pem")
-          if writable?
-            split_private_key = private_key.split(/\n/)
-            File.open(path, "w") do |f|
-              split_private_key.each {|line| f.puts line}
-              f.chmod 0600
-            end
-            "Key file built: #{path}"
-          else
-            "Invalid private key"
-          end
-        end
-
-        def writable?
-          !!(private_key && ENV.key?('HOME'))
-        end
-      end
-    end
-  end
-end

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

@@ -1,29 +0,0 @@
-require 'fog/openstack/models/collection'
-require 'fog/openstack/models/compute/key_pair'
-
-module Fog
-  module Compute
-    class OpenStack
-      class KeyPairs < Fog::OpenStack::Collection
-        model Fog::Compute::OpenStack::KeyPair
-
-        def all(options = {})
-          items = Array.new
-          service.list_key_pairs(options).body['keypairs'].each do |kp|
-            items = items + kp.values
-          end
-          # TODO convert to load_response?
-          load(items)
-        end
-
-        def get(key_pair_name)
-          if key_pair_name
-            self.all.select {|kp| kp.name == key_pair_name}.first
-          end
-        rescue Fog::Compute::OpenStack::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,65 +0,0 @@
-require 'fog/openstack/models/collection'
-require 'fog/openstack/models/meta_parent'
-require 'fog/openstack/models/compute/metadatum'
-require 'fog/openstack/models/compute/image'
-require 'fog/openstack/models/compute/server'
-
-module Fog
-  module Compute
-    class OpenStack
-      class Metadata < Fog::OpenStack::Collection
-        model Fog::Compute::OpenStack::Metadatum
-
-        include Fog::Compute::OpenStack::MetaParent
-
-        def all
-          requires :parent
-          metadata = service.list_metadata(collection_name, @parent.id).body['metadata']
-          metas = []
-          metadata.each_pair {|k,v| metas << {"key" => k, "value" => v} } unless metadata.nil?
-          # TODO convert to load_response?
-          load(metas)
-        end
-
-        def get(key)
-          requires :parent
-          data = service.get_metadata(collection_name, @parent.id, key).body["meta"]
-          metas = []
-          data.each_pair {|k,v| metas << {"key" => k, "value" => v} }
-          new(metas[0])
-        rescue Fog::Compute::OpenStack::NotFound
-          nil
-        end
-
-        def update(data=nil)
-          requires :parent
-          service.update_metadata(collection_name, @parent.id, to_hash(data))
-        end
-
-        def set(data=nil)
-          requires :parent
-          service.set_metadata(collection_name, @parent.id, to_hash(data))
-        end
-
-        def new(attributes = {})
-          requires :parent
-          super({ :parent => @parent }.merge!(attributes))
-        end
-
-        def to_hash(data=nil)
-          if data.nil?
-            data={}
-            self.each do |meta|
-              if meta.is_a?(Fog::Compute::OpenStack::Metadatum) then
-                data.store(meta.key, meta.value)
-              else
-                data.store(meta["key"], meta["value"])
-              end
-            end
-          end
-          data
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-require 'fog/openstack/models/collection'
-require 'fog/openstack/models/compute/network'
-
-module Fog
-  module Compute
-    class OpenStack
-      class Networks < Fog::OpenStack::Collection
-        model Fog::Compute::OpenStack::Network
-
-        attribute :server
-
-        def all
-          requires :server
-
-          networks = Array.new
-          server.addresses.each_with_index do |address, index|
-            networks << {
-              :id   => index + 1,
-              :name => address[0],
-              :addresses => address[1].map {|a| a['addr'] }
-            }
-          end
-
-          # TODO convert to load_response?
-          load(networks)
-        end
-      end # class Networks
-    end # class OpenStack
-  end # module Compute
-end # module Fog

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

@@ -1,21 +0,0 @@
-require 'fog/openstack/models/collection'
-require 'fog/openstack/models/compute/security_group_rule'
-
-module Fog
-  module Compute
-    class OpenStack
-      class SecurityGroupRules < Fog::OpenStack::Collection
-        model Fog::Compute::OpenStack::SecurityGroupRule
-
-        def get(security_group_rule_id)
-          if security_group_rule_id
-            body = service.get_security_group_rule(security_group_rule_id).body
-            new(body['security_group_rule'])
-          end
-        rescue Fog::Compute::OpenStack::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-require 'fog/openstack/models/collection'
-require 'fog/openstack/models/compute/security_group'
-
-module Fog
-  module Compute
-    class OpenStack
-      class SecurityGroups < Fog::OpenStack::Collection
-        model Fog::Compute::OpenStack::SecurityGroup
-
-        def all(options = {})
-          load_response(service.list_security_groups(options), 'security_groups')
-        end
-
-        def get(security_group_id)
-          if security_group_id
-            new(service.get_security_group(security_group_id).body['security_group'])
-          end
-        rescue Fog::Compute::OpenStack::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,397 +0,0 @@
-require 'fog/compute/models/server'
-require 'fog/openstack/models/compute/metadata'
-
-module Fog
-  module Compute
-    class OpenStack
-      class Server < Fog::Compute::Server
-        identity :id
-        attribute :instance_name, :aliases => 'OS-EXT-SRV-ATTR:instance_name'
-
-        attribute :addresses
-        attribute :flavor
-        attribute :host_id, :aliases => 'hostId'
-        attribute :image
-        attribute :metadata
-        attribute :links
-        attribute :name
-
-        # @!attribute [rw] personality
-        # @note This attribute is only used for server creation. This field will be nil on subsequent retrievals.
-        # @return [Hash] Hash containing data to inject into the file system of the cloud server instance during
-        #                server creation.
-        # @example To inject fog.txt into file system
-        #   :personality => [{ :path => '/root/fog.txt',
-        #                      :contents => Base64.encode64('Fog was here!')
-        #                   }]
-        # @see #create
-        # @see http://docs.openstack.org/api/openstack-compute/2/content/Server_Personality-d1e2543.html
-        attribute :personality
-        attribute :progress
-        attribute :accessIPv4
-        attribute :accessIPv6
-        attribute :availability_zone, :aliases => 'OS-EXT-AZ:availability_zone'
-        attribute :user_data_encoded
-        attribute :state,       :aliases => 'status'
-        attribute :created,     :type => :time
-        attribute :updated,     :type => :time
-
-        attribute :tenant_id
-        attribute :user_id
-        attribute :key_name
-        attribute :fault
-        attribute :config_drive
-        attribute :os_dcf_disk_config, :aliases => 'OS-DCF:diskConfig'
-        attribute :os_ext_srv_attr_host, :aliases => 'OS-EXT-SRV-ATTR:host'
-        attribute :os_ext_srv_attr_hypervisor_hostname, :aliases => 'OS-EXT-SRV-ATTR:hypervisor_hostname'
-        attribute :os_ext_srv_attr_instance_name, :aliases => 'OS-EXT-SRV-ATTR:instance_name'
-        attribute :os_ext_sts_power_state, :aliases => 'OS-EXT-STS:power_state'
-        attribute :os_ext_sts_task_state, :aliases => 'OS-EXT-STS:task_state'
-        attribute :os_ext_sts_vm_state, :aliases => 'OS-EXT-STS:vm_state'
-
-        attr_reader :password
-        attr_writer :image_ref, :flavor_ref, :nics, :os_scheduler_hints
-        attr_accessor :block_device_mapping, :block_device_mapping_v2
-
-        # In some cases it's handy to be able to store the project for the record, e.g. swift doesn't contain project
-        # info in the result, so we can track it in this attribute based on what project was used in the request
-        attr_accessor :project
-
-        def initialize(attributes = {})
-          # Old 'connection' is renamed as service and should be used instead
-          prepare_service_value(attributes)
-
-          self.security_groups = attributes.delete(:security_groups)
-          self.min_count = attributes.delete(:min_count)
-          self.max_count = attributes.delete(:max_count)
-          self.nics = attributes.delete(:nics)
-          self.os_scheduler_hints = attributes.delete(:os_scheduler_hints)
-          self.block_device_mapping = attributes.delete(:block_device_mapping)
-          self.block_device_mapping_v2 = attributes.delete(:block_device_mapping_v2)
-
-          super
-        end
-
-        def metadata
-          @metadata ||= begin
-            Fog::Compute::OpenStack::Metadata.new(:service => service,
-                                                  :parent  => self)
-          end
-        end
-
-        def metadata=(new_metadata = {})
-          return unless new_metadata
-          metas = []
-          new_metadata.each_pair { |k, v| metas << {"key" => k, "value" => v} }
-          @metadata = metadata.load(metas)
-        end
-
-        def user_data=(ascii_userdata)
-          self.user_data_encoded = [ascii_userdata].pack('m') if ascii_userdata
-        end
-
-        def destroy
-          requires :id
-          service.delete_server(id)
-          true
-        end
-
-        def images
-          requires :id
-          service.images(:server => self)
-        end
-
-        def all_addresses
-          # currently openstack API does not tell us what is a floating ip vs a fixed ip for the vm listing,
-          # we fall back to get all addresses and filter sadly.
-          # Only includes manually-assigned addresses, not auto-assigned
-          @all_addresses ||= service.list_all_addresses.body["floating_ips"].select { |data| data['instance_id'] == id }
-        end
-
-        def reload
-          @all_addresses = nil
-          super
-        end
-
-        # returns all ip_addresses for a given instance
-        # this includes both the fixed ip(s) and the floating ip(s)
-        def ip_addresses
-          addresses ? addresses.values.flatten.collect { |x| x['addr'] } : []
-        end
-
-        def floating_ip_addresses
-          all_floating = if addresses
-                           flattened_values = addresses.values.flatten
-                           flattened_values.select { |d| d["OS-EXT-IPS:type"] == "floating" }.collect { |a| a["addr"] }
-                         else
-                           []
-                         end
-
-          # Return them all, leading with manually assigned addresses
-          manual = all_addresses.collect { |addr| addr["ip"] }
-
-          all_floating.sort do |a, b|
-            a_manual = manual.include? a
-            b_manual = manual.include? b
-
-            if a_manual && !b_manual
-              -1
-            elsif !a_manual && b_manual
-              1
-            else
-              0
-            end
-          end
-          all_floating.empty? ? manual : all_floating
-        end
-
-        def public_ip_addresses
-          if floating_ip_addresses.empty?
-            addresses.select { |s| s[0] =~ /public/i }.collect { |a| a[1][0]['addr'] }
-          else
-            floating_ip_addresses
-          end
-        end
-
-        def floating_ip_address
-          floating_ip_addresses.first
-        end
-
-        def public_ip_address
-          public_ip_addresses.first
-        end
-
-        def private_ip_addresses
-          rfc1918_regexp = /(^10\.|^172\.1[6-9]\.|^172\.2[0-9]\.|^172.3[0-1]\.|^192\.168\.)/
-          almost_private = ip_addresses - public_ip_addresses - floating_ip_addresses
-          almost_private.select { |ip| rfc1918_regexp.match ip }
-        end
-
-        def private_ip_address
-          private_ip_addresses.first
-        end
-
-        attr_reader :image_ref
-
-        attr_writer :image_ref
-
-        attr_reader :flavor_ref
-
-        attr_writer :flavor_ref
-
-        def ready?
-          state == 'ACTIVE'
-        end
-
-        def failed?
-          state == 'ERROR'
-        end
-
-        def change_password(admin_password)
-          requires :id
-          service.change_server_password(id, admin_password)
-          true
-        end
-
-        def rebuild(image_ref, name, admin_pass = nil, metadata = nil, personality = nil)
-          requires :id
-          service.rebuild_server(id, image_ref, name, admin_pass, metadata, personality)
-          true
-        end
-
-        def resize(flavor_ref)
-          requires :id
-          service.resize_server(id, flavor_ref)
-          true
-        end
-
-        def revert_resize
-          requires :id
-          service.revert_resize_server(id)
-          true
-        end
-
-        def confirm_resize
-          requires :id
-          service.confirm_resize_server(id)
-          true
-        end
-
-        def security_groups
-          requires :id
-
-          groups = service.list_security_groups(:server_id => id).body['security_groups']
-
-          groups.map do |group|
-            Fog::Compute::OpenStack::SecurityGroup.new group.merge(:service => service)
-          end
-        end
-
-        attr_writer :security_groups
-
-        def reboot(type = 'SOFT')
-          requires :id
-          service.reboot_server(id, type)
-          true
-        end
-
-        def stop
-          requires :id
-          service.stop_server(id)
-        end
-
-        def pause
-          requires :id
-          service.pause_server(id)
-        end
-
-        def suspend
-          requires :id
-          service.suspend_server(id)
-        end
-
-        def start
-          requires :id
-
-          case state.downcase
-          when 'paused'
-            service.unpause_server(id)
-          when 'suspended'
-            service.resume_server(id)
-          else
-            service.start_server(id)
-          end
-        end
-
-        def shelve
-          requires :id
-          service.shelve_server(id)
-        end
-
-        def unshelve
-          requires :id
-          service.unshelve_server(id)
-        end
-
-        def shelve_offload
-          requires :id
-          service.shelve_offload_server(id)
-        end
-
-        def create_image(name, metadata = {})
-          requires :id
-          service.create_image(id, name, metadata)
-        end
-
-        def console(log_length = nil)
-          requires :id
-          service.get_console_output(id, log_length)
-        end
-
-        def migrate
-          requires :id
-          service.migrate_server(id)
-        end
-
-        def live_migrate(host, block_migration, disk_over_commit)
-          requires :id
-          service.live_migrate_server(id, host, block_migration, disk_over_commit)
-        end
-
-        def evacuate(host = nil, on_shared_storage = nil, admin_password = nil)
-          requires :id
-          service.evacuate_server(id, host, on_shared_storage, admin_password)
-        end
-
-        def associate_address(floating_ip)
-          requires :id
-          service.associate_address id, floating_ip
-        end
-
-        def disassociate_address(floating_ip)
-          requires :id
-          service.disassociate_address id, floating_ip
-        end
-
-        def reset_vm_state(vm_state)
-          requires :id
-          service.reset_server_state id, vm_state
-        end
-
-        attr_writer :min_count
-
-        attr_writer :max_count
-
-        def networks
-          service.networks(:server => self)
-        end
-
-        def volumes
-          requires :id
-          service.volumes.select do |vol|
-            vol.attachments.find { |attachment| attachment["serverId"] == id }
-          end
-        end
-
-        def volume_attachments
-          requires :id
-          service.get_server_volumes(id).body['volumeAttachments']
-        end
-
-        def attach_volume(volume_id, device_name)
-          requires :id
-          service.attach_volume(volume_id, id, device_name)
-          true
-        end
-
-        def detach_volume(volume_id)
-          requires :id
-          service.detach_volume(id, volume_id)
-          true
-        end
-
-        def save
-          raise Fog::Errors::Error, 'Resaving an existing object may create a duplicate' if persisted?
-          requires :flavor_ref, :name
-          requires_one :image_ref, :block_device_mapping, :block_device_mapping_v2
-          options = {
-            'personality'             => personality,
-            'accessIPv4'              => accessIPv4,
-            'accessIPv6'              => accessIPv6,
-            'availability_zone'       => availability_zone,
-            'user_data'               => user_data_encoded,
-            'key_name'                => key_name,
-            'config_drive'            => config_drive,
-            'security_groups'         => @security_groups,
-            'min_count'               => @min_count,
-            'max_count'               => @max_count,
-            'nics'                    => @nics,
-            'os:scheduler_hints'      => @os_scheduler_hints,
-            'block_device_mapping'    => @block_device_mapping,
-            'block_device_mapping_v2' => @block_device_mapping_v2,
-          }
-          options['metadata'] = metadata.to_hash unless @metadata.nil?
-          options = options.reject { |_key, value| value.nil? }
-          data = service.create_server(name, image_ref, flavor_ref, options)
-          merge_attributes(data.body['server'])
-          true
-        end
-
-        def setup(credentials = {})
-          requires :ssh_ip_address, :identity, :public_key, :username
-          ssh = Fog::SSH.new(ssh_ip_address, username, credentials)
-          ssh.run([
-                    %(mkdir .ssh),
-                    %(echo "#{public_key}" >> ~/.ssh/authorized_keys),
-                    %(passwd -l #{username}),
-                    %(echo "#{Fog::JSON.encode(attributes)}" >> ~/attributes.json),
-                    %(echo "#{Fog::JSON.encode(metadata)}" >> ~/metadata.json)
-                  ])
-        rescue Errno::ECONNREFUSED
-          sleep(1)
-          retry
-        end
-      end
-    end
-  end
-end