fog-rackspace 0.1.0

data/lib/fog/rackspace/requests/compute_v2/create_image.rb

@@ -0,0 +1,97 @@
+module Fog
+  module Compute
+    class RackspaceV2
+      class Real
+        # Create an image from a running server
+        #
+        # @param [String] server_id Id of server to create image from
+        # @param [String] name name for created image
+        # @param [Hash] options
+        # @option options [Hash] :metadata - key value pairs of image metadata
+        # @return [Excon::Response] response
+        # @raise [Fog::Compute::RackspaceV2::NotFound] - HTTP 404
+        # @raise [Fog::Compute::RackspaceV2::BadRequest] - HTTP 400
+        # @raise [Fog::Compute::RackspaceV2::InternalServerError] - HTTP 500
+        # @raise [Fog::Compute::RackspaceV2::ServiceError]
+        # @see http://docs.rackspace.com/servers/api/v2/cs-devguide/content/Create_Image-d1e4655.html
+        #
+        # * State Transition:
+        #   * SAVING -> ACTIVE
+        #   * SAVING  -> ERROR (on error)
+        def create_image(server_id, name, options = {})
+          data = {
+            'createImage' => {
+              'name' => name
+            }
+          }
+          data['createImage'].merge!(options)
+          request(
+            :body     => Fog::JSON.encode(data),
+            :expects  => 202,
+            :method   => 'POST',
+            :path     => "servers/#{server_id}/action"
+          )
+        end
+      end
+
+      class Mock
+        def create_image(server_id, name, options = {})
+          image_id = Fog::Rackspace::MockData.uuid
+          image = {
+            "OS-DCF:diskConfig" => "AUTO",
+            "created"           => "2012-02-28T19:38:57Z",
+            "id"                => image_id,
+            "links"             => [
+              {
+                "href"              => "https://dfw.servers.api.rackspacecloud.com/v2/010101/images/#{image_id}",
+                "rel"               => "self"
+              },
+              {
+                "href"              => "https://dfw.servers.api.rackspacecloud.com/010101/images/#{image_id}",
+                "rel"               => "bookmark"
+              },
+              {
+                "href"              => "https://dfw.servers.api.rackspacecloud.com/010101/images/#{image_id}",
+                "rel"               => "alternate",
+                "type"              => "application/vnd.openstack.image"
+              }
+            ],
+            "metadata"                              => {
+              "arch"                                  => "x86-64",
+              "auto_disk_config"                      => "True",
+              "com.rackspace__1__build_core"          => "1",
+              "com.rackspace__1__build_managed"       => "0",
+              "com.rackspace__1__build_rackconnect"   => "0",
+              "com.rackspace__1__options"             => "0",
+              "com.rackspace__1__visible_core"        => "1",
+              "com.rackspace__1__visible_managed"     => "0",
+              "com.rackspace__1__visible_rackconnect" => "0",
+              "image_type"                            => "base",
+              "org.openstack__1__architecture"        => "x64",
+              "org.openstack__1__os_distro"           => "org.ubuntu",
+              "org.openstack__1__os_version"          => "11.10",
+              "os_distro"                             => "ubuntu",
+              "os_type"                               => "linux",
+              "os_version"                            => "11.10",
+              "rax_managed"                           => "false",
+              "rax_options"                           => "0"
+            },
+            "minDisk"  => 10,
+            "minRam"   => 256,
+            "name"     => "Ubuntu 11.10",
+            "progress" => 100,
+            "status"   => "SAVING",
+            "updated"  => "2012-02-28T19:39:05Z"
+          }
+
+          self.data[:images][image_id] = image
+
+          response(
+            :status => 202,
+            :headers => {"Location" => "/#{image_id}"}
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/compute_v2/create_keypair.rb

@@ -0,0 +1,62 @@
+module Fog
+  module Compute
+    class RackspaceV2
+      class Real
+        # Request a new keypair to be created
+        # @param [String] key_name: unique name of the keypair to create
+        # @return  [Excon::Response] response :
+        #   * body [Hash]: -
+        #     * 'keypair' [Hash]: -
+        #       * 'fingerprint' [String]: unique fingerprint of the keypair
+        #       * 'name' [String]: unique name of the keypair
+        #       * 'private_key' [String]: the private key of the keypair (only available here, at creation time)
+        #       * 'public_key' [String]: the public key of the keypair
+        #       * 'user_id' [String]: the user id
+        # @raise [Fog::Compute::RackspaceV2::NotFound]
+        # @raise [Fog::Compute::RackspaceV2::BadRequest]
+        # @raise [Fog::Compute::RackspaceV2::InternalServerError]
+        # @raise [Fog::Compute::RackspaceV2::ServiceError]
+        # @see   http://docs.rackspace.com/servers/api/v2/cs-devguide/content/CreateKeyPair.html
+        def create_keypair(key_name, attributes = nil)
+          key_data = { 'name' => key_name }
+
+          if attributes.is_a?(String)
+            Fog::Logger.deprecation "Passing the public key as the 2nd arg is deprecated, please pass a hash of attributes."
+            key_data.merge!("public_key" => attributes)
+          end
+
+          key_data.merge!(attributes) if attributes.is_a?(Hash)
+
+          data = {
+            'keypair' => key_data
+          }
+
+          request(
+            :method   => 'POST',
+            :expects  => 200,
+            :path     => '/os-keypairs',
+            :body     => Fog::JSON.encode(data)
+          )
+        end
+      end
+
+      class Mock
+        def create_keypair(key_name, attributes = nil)
+            # 409 response when already existing
+            raise Fog::Compute::RackspaceV2::ServiceError if not self.data[:keypairs].select { |k| key_name.include? k['keypair']['name'] }.first.nil?
+
+            if attributes.is_a?(String)
+              Fog::Logger.deprecation "Passing the public key as the 2nd arg is deprecated, please pass a hash of attributes."
+            end
+
+            k = self.data[:keypair]
+            k['name'] = key_name
+            self.data[:keypairs] << { 'keypair' => k }
+
+            response( :status => 200,
+                      :body   => { 'keypair' => k } )
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/compute_v2/create_network.rb

@@ -0,0 +1,36 @@
+module Fog
+  module Compute
+    class RackspaceV2
+      class Real
+        def create_network(label, cidr)
+          data = {
+            'network' => {
+              'label' => label,
+              'cidr' => cidr
+            }
+          }
+
+          request(
+            :method => 'POST',
+            :body => Fog::JSON.encode(data),
+            :path => "os-networksv2",
+            :expects => 200
+          )
+        end
+      end
+
+      class Mock
+        def create_network(label, cidr)
+          network_id = Fog::Rackspace::MockData.uuid
+
+          self.data[:networks][network_id] = {
+            'id' => network_id,
+            'label' => label,
+            'cidr' => cidr
+          }
+          response(:body => { 'network' => self.data[:networks][network_id] })
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/compute_v2/create_server.rb

@@ -0,0 +1,243 @@
+module Fog
+  module Compute
+    class RackspaceV2
+      class Real
+        # Create server
+        # @param [String] name name of server
+        # @param [String] image_id of the image used to create server
+        # @param [String] flavor_id id of the flavor of the image
+        # @param [String] min_count
+        # @param [String] max_count
+        # @param [Hash] options
+        # @option options [Hash] metadata key value pairs of server metadata
+        # @option options [String] OS-DCF:diskConfig The disk configuration value. (AUTO or MANUAL)
+        # @option options [Hash] personality Hash containing data to inject into the file system of the cloud server instance during server creation.
+        # @option options [Boolean] config_drive whether to attach a read-only configuration drive
+        # @option options [String] keypair  Name of the kay-pair to associate with this server.
+        # @option options [Array<Hash>] block_device_mapping A manually specified block device mapping to fully control the creation and
+        #   attachment of volumes to this server. Mutually exclusive with :volume_id or :volume_image_id. If provided, leave image_id
+        #   as "". See http://developer.openstack.org/api-ref-compute-v2-ext.html#ext-os-block-device-mapping-v2-boot for details.
+        # @option options [String] boot_volume_id Id of a pre-created bootable volume to use for this server. If provided, leave image_id as "".
+        # @option options [Integer] boot_volume_size Size of the bootable volume to be created expressed in GB. (defaults to 100)
+        # @option options [String] boot_image_id Id of an image to create a bootable volume from and attach to this server. If provided,
+        #   leave image_id as "".
+        # @return [Excon::Response] response:
+        #   * body [Hash]:
+        #     * server [Hash]:
+        #       * name [String] - name of server
+        #       * imageRef [String] - id of image used to create server
+        #       * flavorRef [String] - id of flavor used to create server
+        #       * OS-DCF:diskConfig [String] - The disk configuration value.
+        #       * name [String] - name of server
+        #       * metadata [Hash] - Metadata key and value pairs.
+        #       * personality [Array]:
+        #         * [Hash]:
+        #           * path - path of the file created
+        #           * contents - Base 64 encoded file contents
+        #       * networks [Array]:
+        #         * [Hash]:
+        #           * uuid [String] - uuid of attached network
+        #       * config_drive [Boolean]: Wether to use a config drive or not
+        #       * user_data [String]: User data for cloud init
+        # @raise [Fog::Compute::RackspaceV2::NotFound] - HTTP 404
+        # @raise [Fog::Compute::RackspaceV2::BadRequest] - HTTP 400
+        # @raise [Fog::Compute::RackspaceV2::InternalServerError] - HTTP 500
+        # @raise [Fog::Compute::RackspaceV2::ServiceError]
+        # @see http://docs.rackspace.com/servers/api/v2/cs-devguide/content/CreateServers.html
+        # @see http://docs.rackspace.com/servers/api/v2/cs-devguide/content/Server_Metadata-d1e2529.html
+        # @see http://docs.rackspace.com/servers/api/v2/cs-devguide/content/Server_Personality-d1e2543.html
+        # @see http://docs.rackspace.com/servers/api/v2/cs-devguide/content/ch_extensions.html#diskconfig_attribute
+        # @see http://developer.openstack.org/api-ref-compute-v2-ext.html#ext-os-block-device-mapping-v2-boot
+        #
+        # * State Transitions
+        #   * BUILD -> ACTIVE
+        #   * BUILD -> ERROR (on error)
+        def create_server(name, image_id, flavor_id, min_count, max_count, options = {})
+          data = {
+            'server' => {
+              'name'      => name,
+              'imageRef'  => image_id,
+              'flavorRef' => flavor_id,
+              'minCount'  => min_count,
+              'maxCount'  => max_count
+            }
+          }
+
+          data['server']['adminPass'] = options[:password] unless options[:password].nil?
+          data['server']['OS-DCF:diskConfig'] = options[:disk_config] unless options[:disk_config].nil?
+          data['server']['metadata'] = options[:metadata] unless options[:metadata].nil?
+          data['server']['personality'] = options[:personality] unless options[:personality].nil?
+          data['server']['config_drive'] = options[:config_drive] unless options[:config_drive].nil?
+          data['server']['user_data'] = options[:user_data] unless options[:user_data].nil?
+          data['server']['networks'] = options[:networks] || [
+            { :uuid => '00000000-0000-0000-0000-000000000000' },
+            { :uuid => '11111111-1111-1111-1111-111111111111' }
+          ]
+
+          if options[:keypair]
+            Fog::Logger.deprecation(":keypair has been depreciated. Please use :key_name instead.")
+            options[:key_name] = options[:keypair]
+          end
+
+          data['server']['key_name'] = options[:key_name] unless options[:key_name].nil?
+
+          if options[:block_device_mapping]
+            if options[:boot_volume_id]
+              Fog::Logger.warning("Manual :block_device_mapping overrides :boot_volume_id in #create_server!")
+            end
+
+            if options[:boot_image_id]
+              Fog::Logger.warning("Manual :block_device_mapping overrides :boot_image_id in #create_server!")
+            end
+
+            data['server']['block_device_mapping_v2'] = options[:block_device_mapping]
+          else
+            if options[:boot_volume_id]
+              if options[:boot_image_id]
+                Fog::Logger.warning(":boot_volume_id overrides :boot_image_id!")
+              end
+
+              if options[:boot_volume_size]
+                Fog::Logger.warning("Boot volume size: " + options[:boot_volume_size] + "GB")
+              end
+
+              data['server']['block_device_mapping_v2'] = [{
+                'boot_index' => '0',
+                'uuid' => options[:boot_volume_id],
+                'source_type' => 'volume',
+                'destination_type' => 'volume',
+                'volume_size' => options[:boot_volume_size] ? options[:boot_volume_size] : 100
+              }]
+            end
+
+            if options[:boot_image_id]
+              data['server']['block_device_mapping_v2'] = [{
+                'boot_index' => '0',
+                'uuid' => options[:boot_image_id],
+                'source_type' => 'image',
+                'destination_type' => 'volume',
+                'volume_size' => options[:boot_volume_size] ? options[:boot_volume_size] : 100
+              }]
+            end
+        end
+
+          request(
+            :body    => Fog::JSON.encode(data),
+            :expects => [202],
+            :method  => 'POST',
+            :path    => "servers"
+          )
+        end
+      end
+
+      class Mock
+        def create_server(name, image_id, flavor_id, min_count, max_count, options={})
+          server_id   = Fog::Rackspace::MockData.uuid
+          public_ip4  = Fog::Rackspace::MockData.ipv4_address
+          public_ip6  = Fog::Rackspace::MockData.ipv6_address
+          private_ip4 = Fog::Rackspace::MockData.ipv4_address
+          private_ip6 = Fog::Rackspace::MockData.ipv6_address
+          admin_pass  = Fog::Mock.random_letters(12)
+
+          flavor = self.data[:flavors][flavor_id]
+          image  = self.data[:images][image_id]
+
+          server = {
+            "OS-DCF:diskConfig"      => "AUTO",
+            "OS-EXT-STS:power_state" => 1,
+            "OS-EXT-STS:task_state"  => nil,
+            "OS-EXT-STS:vm_state"    => "active",
+            "accessIPv4" => public_ip4,
+            "accessIPv6" => public_ip6,
+            "addresses" => {
+              "private" => [
+                {
+                  "addr" => private_ip4,
+                  "version" => 4
+                }
+              ],
+                "public" => [
+                  {
+                    "addr" => public_ip4,
+                    "version" => 4
+                  },
+                  {
+                    "addr" => public_ip6,
+                    "version" => 6
+                  }
+              ]
+            },
+            "created" => "2012-07-28T15:32:25Z",
+            "flavor" => Fog::Rackspace::MockData.keep(flavor, "id", "links"),
+            "hostId" => Fog::Mock.random_hex(56),
+            "id" => server_id,
+            "image"  => Fog::Rackspace::MockData.keep(image, "id", "links"),
+            "links" => [
+              {
+                "href" => "https://dfw.servers.api.rackspacecloud.com/v2/010101/servers/#{server_id}",
+                "rel" => "self",
+              },
+              {
+                "href" => "https://dfw.servers.api.rackspacecloud.com/010101/servers/#{server_id}",
+                "rel" => "bookmark",
+              }
+            ],
+            "metadata" => {},
+            "name" => name,
+            "progress" => 100,
+            "rax-bandwidth:bandwidth" => [
+              {
+                "audit_period_end"   => "2012-08-16T14:12:00Z",
+                "audit_period_start" => "2012-08-16T06:00:00Z",
+                "bandwidth_inbound"  => 39147845,
+                "bandwidth_outbound" => 13390651,
+                "interface"          => "public",
+              },
+              {
+                "audit_period_end"   => "2012-08-16T14:12:00Z",
+                "audit_period_start" => "2012-08-16T06:00:00Z",
+                "bandwidth_inbound"  => 24229191,
+                "bandwidth_outbound" => 84,
+                "interface"          => "private",
+              }
+            ],
+            "status"             => "ACTIVE",
+            "tenant_id"          => "010101",
+            "updated"            => "2012-07-28T15:37:09Z",
+            "user_id"            => "170454",
+            :volume_ids          => [],
+          }
+
+          #  add in additional networks
+          if options[:networks]
+            options[:networks].each do |network|
+              net_label = self.data[:networks][network[:uuid]]["label"]
+              server["addresses"] = { net_label => []}
+            end
+          end
+          self.data[:servers][server_id] = server
+
+          response = {
+            "server" => {
+              "OS-DCF:diskConfig" => "AUTO",
+              "adminPass" => admin_pass,
+              "id" => server_id,
+              "links" => [
+                {
+                  "href" => "https://dfw.servers.api.rackspacecloud.com/v2/010101/servers/#{server_id}",
+                  "rel"  => "self"
+                  },
+                  {
+                  "href" => "https://dfw.servers.api.rackspacecloud.com/010101/servers/#{server_id}",
+                  "rel"  => "bookmark"
+                }
+              ]
+            }
+          }
+
+          response(:body => response)
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/compute_v2/create_virtual_interface.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Compute
+    class RackspaceV2
+      class Real
+        # Creates virtual interface for a server
+        # @param [String] server_id The server id to create the virtual interface on
+        # @param [String] network_id The network id to attach the virtual interface to
+        # @raise [Fog::Compute::RackspaceV2::NotFound] - HTTP 404
+        # @raise [Fog::Compute::RackspaceV2::BadRequest] - HTTP 400
+        # @raise [Fog::Compute::RackspaceV2::InternalServerError] - HTTP 500
+        # @raise [Fog::Compute::RackspaceV2::ServiceError]
+        # @see http://docs.rackspace.com/servers/api/v2/cn-devguide/content/api_create_virtual_interface.html
+        def create_virtual_interface(server_id, network_id)
+          data = {
+            :virtual_interface => {
+              :network_id => network_id
+            }
+          }
+
+          request(
+            :expects => [200],
+            :method => 'POST',
+            :path => "servers/#{server_id}/os-virtual-interfacesv2",
+            :body => Fog::JSON.encode(data)
+          )
+        end
+      end
+    end
+  end
+end