fog-openstack 0.1.0

data/lib/fog/openstack/requests/compute/create_security_group_rule.rb

@@ -0,0 +1,57 @@
+module Fog
+  module Compute
+    class OpenStack
+      class Real
+        def create_security_group_rule(parent_group_id, ip_protocol, from_port, to_port, cidr, group_id=nil)
+          data = {
+            'security_group_rule' => {
+              'parent_group_id' => parent_group_id,
+              'ip_protocol'     => ip_protocol,
+              'from_port'       => from_port,
+              'to_port'         => to_port,
+              'cidr'            => cidr,
+              'group_id'        => group_id
+            }
+          }
+
+          request(
+            :expects  => 200,
+            :method   => 'POST',
+            :body     => Fog::JSON.encode(data),
+            :path     => 'os-security-group-rules.json'
+          )
+        end
+      end
+
+      class Mock
+        def create_security_group_rule(parent_group_id, ip_protocol, from_port, to_port, cidr, group_id=nil)
+          parent_group_id = parent_group_id.to_i
+          response = Excon::Response.new
+          response.status = 200
+          response.headers = {
+            'X-Compute-Request-Id' => "req-#{Fog::Mock.random_hex(32)}",
+            'Content-Type'   => 'application/json',
+            'Content-Length' => Fog::Mock.random_numbers(3).to_s,
+            'Date' => Date.new
+          }
+          rule = {
+            'id' => Fog::Mock.random_numbers(2).to_i,
+            'from_port'   => from_port,
+            'group'       => group_id || {},
+            'ip_protocol' => ip_protocol,
+            'to_port'     => to_port,
+            'parent_group_id' => parent_group_id,
+            'ip_range' => {
+              'cidr'   => cidr
+            }
+          }
+          self.data[:security_groups][parent_group_id.to_s]['rules'].push(rule)
+          response.body = {
+            'security_group_rule' => rule
+          }
+          response
+        end
+      end # mock
+    end # openstack
+  end # compute
+end # fog

data/lib/fog/openstack/requests/compute/create_server.rb

@@ -0,0 +1,185 @@
+module Fog
+  module Compute
+    class OpenStack
+      class Real
+        def create_server(name, image_ref, flavor_ref, options = {})
+          data = {
+            'server' => {
+              'flavorRef'  => flavor_ref,
+              'imageRef'   => image_ref,
+              'name'       => name
+            }
+          }
+
+          vanilla_options = ['metadata', 'accessIPv4', 'accessIPv6',
+                             'availability_zone', 'user_data', 'key_name',
+                             'adminPass', 'config_drive', 'min_count', 'max_count',
+                             'return_reservation_id'
+                            ]
+          vanilla_options.select{|o| options[o]}.each do |key|
+            data['server'][key] = options[key]
+          end
+
+          if options['security_groups']
+            # security names requires a hash with a name prefix
+            data['server']['security_groups'] =
+              Array(options['security_groups']).map do |sg|
+              name = if sg.is_a?(Fog::Compute::OpenStack::SecurityGroup) then
+                       sg.name
+                     else
+                       sg
+                     end
+              { :name => name }
+            end
+          end
+
+          if options['personality']
+            data['server']['personality'] = []
+            for file in options['personality']
+              data['server']['personality'] << {
+                'contents'  => Base64.encode64(file['contents'] || file[:contents]),
+                'path'      => file['path'] || file[:path]
+              }
+            end
+          end
+
+          if options['nics']
+            data['server']['networks'] =
+            Array(options['nics']).map do |nic|
+              neti = { 'uuid' => (nic['net_id'] || nic[:net_id]) }
+              neti['fixed_ip'] = (nic['v4_fixed_ip'] || nic[:v4_fixed_ip]) unless (nic['v4_fixed_ip'] || nic[:v4_fixed_ip]).nil?
+              neti['port'] = (nic['port_id'] || nic[:port_id]) unless (nic['port_id'] || nic[:port_id]).nil?
+              neti
+            end
+          end
+
+          if options['os:scheduler_hints']
+            data['os:scheduler_hints'] = options['os:scheduler_hints']
+          end
+
+          if (block_device_mapping = options['block_device_mapping_v2'])
+            data['server']['block_device_mapping_v2'] = [block_device_mapping].flatten.collect do |mapping|
+              {
+                'boot_index'            => mapping[:boot_index],
+                'delete_on_termination' => mapping[:delete_on_termination],
+                'destination_type'      => mapping[:destination_type],
+                'device_name'           => mapping[:device_name],
+                'source_type'           => mapping[:source_type],
+                'uuid'                  => mapping[:uuid],
+                'volume_size'           => mapping[:volume_size],
+              }
+            end
+          elsif (block_device_mapping = options['block_device_mapping'])
+            data['server']['block_device_mapping'] = [block_device_mapping].flatten.collect do |mapping|
+              {
+                'delete_on_termination' => mapping[:delete_on_termination],
+                'device_name'           => mapping[:device_name],
+                'volume_id'             => mapping[:volume_id],
+                'volume_size'           => mapping[:volume_size],
+              }
+            end
+          end
+
+          path = block_device_mapping ? 'os-volumes_boot.json' : 'servers.json'
+
+          request(
+            :body     => Fog::JSON.encode(data),
+            :expects  => [200, 202],
+            :method   => 'POST',
+            :path     => path
+          )
+        end
+      end
+
+      class Mock
+        def create_server(name, image_ref, flavor_ref, options = {})
+          response = Excon::Response.new
+          response.status = 202
+
+          server_id = Fog::Mock.random_numbers(6).to_s
+          identity = Fog::Identity::OpenStack.new :openstack_auth_url => credentials[:openstack_auth_url]
+          user = identity.users.find { |u|
+            u.name == @openstack_username
+          }
+
+          user_id = if user then
+                      user.id
+                    else
+                       response = identity.create_user(@openstack_username,
+                         'password',
+                         "#{@openstack_username}@example.com")
+                       response.body["user"]["id"]
+                    end
+
+          mock_data = {
+            'addresses'    => {"Private" => [{"addr" => Fog::Mock.random_ip }]},
+            'flavor'       => {"id" => flavor_ref, "links"=>[{"href"=>"http://nova1:8774/admin/flavors/1", "rel"=>"bookmark"}]},
+            'id'           => server_id,
+            'image'        => {"id" => image_ref, "links"=>[{"href"=>"http://nova1:8774/admin/images/#{image_ref}", "rel"=>"bookmark"}]},
+            'links'        => [{"href"=>"http://nova1:8774/v1.1/admin/servers/5", "rel"=>"self"}, {"href"=>"http://nova1:8774/admin/servers/5", "rel"=>"bookmark"}],
+            'hostId'       => "123456789ABCDEF01234567890ABCDEF",
+            'metadata'     => options['metadata'] || {},
+            'name'         => name || "server_#{rand(999)}",
+            'accessIPv4'   => options['accessIPv4'] || "",
+            'accessIPv6'   => options['accessIPv6'] || "",
+            'progress'     => 0,
+            'status'       => 'BUILD',
+            'created'      => '2012-09-27T00:04:18Z',
+            'updated'      => '2012-09-27T00:04:27Z',
+            'user_id'      => @openstack_username,
+            'config_drive' => options['config_drive'] || '',
+          }
+
+          if nics = options['nics']
+            nics.each do |nic|
+              mock_data["addresses"].merge!(
+                "Public" => [{ 'addr' => Fog::Mock.random_ip }]
+              )
+            end
+          end
+
+          response_data = {}
+          if options['return_reservation_id'] == 'True' then
+            response_data = { 'reservation_id' => "r-#{Fog::Mock.random_numbers(6).to_s}" }
+          else
+            response_data = {
+              'adminPass'       => 'password',
+              'id'              => server_id,
+              'links'           => mock_data['links'],
+            }
+          end
+
+          if block_devices = options["block_device_mapping_v2"]
+            block_devices.each { |bd| compute.volumes.get(bd[:uuid]).attach(server_id, bd[:device_name]) }
+          elsif block_device = options["block_device_mapping"]
+            compute.volumes.get(block_device[:volume_id]).attach(server_id, block_device[:device_name])
+          end
+
+          self.data[:last_modified][:servers][server_id] = Time.now
+          self.data[:servers][server_id] = mock_data
+          if security_groups = options['security_groups'] then
+            groups = Array(options['security_groups']).map do |sg|
+              if sg.is_a?(Fog::Compute::OpenStack::SecurityGroup) then
+                sg.name
+              else
+                sg
+              end
+            end
+
+            self.data[:server_security_group_map][server_id] = groups
+            response_data['security_groups'] = groups
+          end
+
+          self.data[:last_modified][:servers][server_id] = Time.now
+          self.data[:servers][server_id] = mock_data
+          if options['return_reservation_id'] == 'True' then
+            response.body = response_data
+          else
+            response.body = { 'server' => response_data }
+          end
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/openstack/requests/compute/create_volume.rb

@@ -0,0 +1,51 @@
+module Fog
+  module Compute
+    class OpenStack
+      class Real
+        def create_volume(name, description, size, options={})
+          data = {
+            'volume' => {
+              'display_name'        => name,
+              'display_description' => description,
+              'size'                => size
+            }
+          }
+
+          vanilla_options = [:snapshot_id, :availability_zone]
+          vanilla_options.select{|o| options[o]}.each do |key|
+            data['volume'][key] = options[key]
+          end
+          request(
+            :body     => Fog::JSON.encode(data),
+            :expects  => [200, 202],
+            :method   => 'POST',
+            :path     => "os-volumes"
+          )
+        end
+      end
+
+      class Mock
+        def create_volume(name, description, size, options={})
+          response = Excon::Response.new
+          response.status = 202
+          data = {
+            'id'                  => Fog::Mock.random_numbers(2),
+            'displayName'         => name,
+            'displayDescription'  => description,
+            'size'                => size,
+            'status'              => 'creating',
+            'snapshotId'          => options[:snapshot_id],
+            'volumeType'          => 'None',
+            'availabilityZone'    => options[:availability_zone] || 'nova',
+            'createdAt'           => Time.now.strftime('%FT%T.%6N'),
+            'attachments'         => [],
+            'metadata'            => {}
+          }
+          self.data[:volumes][data['id']] = data
+          response.body = { 'volume' => data }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/openstack/requests/compute/create_volume_snapshot.rb

@@ -0,0 +1,51 @@
+module Fog
+  module Compute
+    class OpenStack
+      class Real
+        def create_volume_snapshot(volume_id, name, description, force=false)
+          data = {
+            'snapshot' => {
+              'volume_id'           => volume_id,
+              'display_name'        => name,
+              'display_description' => description,
+              'force'               => force
+            }
+          }
+
+          request(
+            :body     => Fog::JSON.encode(data),
+            :expects  => [200, 202],
+            :method   => 'POST',
+            :path     => "os-snapshots"
+          )
+        end
+      end
+
+      class Mock
+        def create_volume_snapshot(volume_id, name, description, force=false)
+          volume_response = get_volume_details(volume_id)
+          volume = volume_response.data[:body]['volume']
+          unless volume.nil?
+            response = Excon::Response.new
+            data = {
+              "status" => "availble",
+              "name" => name,
+              "created_at" => Time.now,
+              "description" => description,
+              "volume_id" => volume_id,
+              "id" => Fog::Mock.random_numbers(2),
+              "size" => volume['size']
+            }
+
+            self.data[:snapshots][data['id']] = data
+            response.body = { "snapshot" => data }
+            response.status = 202
+            response
+          else
+            raise Fog::Compute::OpenStack::NotFound
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/openstack/requests/compute/delete_aggregate.rb

@@ -0,0 +1,28 @@
+module Fog
+  module Compute
+    class OpenStack
+      class Real
+        def delete_aggregate(uuid)
+          request(
+            :expects => [200, 202, 204],
+            :method  => 'DELETE',
+            :path    => "os-aggregates/#{uuid}"
+          )
+        end
+      end
+
+      class Mock
+        def delete_aggregate(uuid)
+          response = Excon::Response.new
+          response.status = 200
+          response.headers = {
+            "Content-Type" => "text/html; charset=UTF-8",
+            "Content-Length" => "0",
+            "Date" => Date.new
+          }
+          response
+        end
+      end # mock
+    end # openstack
+  end # compute
+end # fog

data/lib/fog/openstack/requests/compute/delete_flavor.rb

@@ -0,0 +1,28 @@
+module Fog
+  module Compute
+    class OpenStack
+      class Real
+        def delete_flavor(flavor_id)
+          request(
+            :expects  => 202,
+            :method   => 'DELETE',
+            :path     => "flavors/#{flavor_id}"
+          )
+        end
+      end
+
+      class Mock
+        def delete_flavor(flavor_id)
+          response = Excon::Response.new
+          response.status = 202
+          response.headers = {
+            "Content-Type" => "text/html; charset=UTF-8",
+            "Content-Length" => "0",
+            "Date" => Date.new
+          }
+          response
+        end
+      end # mock
+    end # openstack
+  end # compute
+end # fog

data/lib/fog/openstack/requests/compute/delete_image.rb

@@ -0,0 +1,35 @@
+module Fog
+  module Compute
+    class OpenStack
+      class Real
+        def delete_image(image_id)
+          request(
+            :expects  => 204,
+            :method   => 'DELETE',
+            :path     => "images/#{image_id}"
+          )
+        end
+      end
+
+      class Mock
+        def delete_image(image_id)
+          response = Excon::Response.new
+          if image = list_images_detail.body['images'].find {|_| _['id'] == image_id}
+            if image['status'] == 'SAVING'
+              response.status = 409
+              raise(Excon::Errors.status_error({:expects => 202}, response))
+            else
+              self.data[:last_modified][:images].delete(image_id)
+              self.data[:images].delete(image_id)
+              response.status = 202
+            end
+            response
+          else
+            response.status = 400
+            raise(Excon::Errors.status_error({:expects => 202}, response))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/openstack/requests/compute/delete_key_pair.rb

@@ -0,0 +1,29 @@
+module Fog
+  module Compute
+    class OpenStack
+      class Real
+        def delete_key_pair(key_name)
+          request(
+            :expects  => 202,
+            :method   => 'DELETE',
+            :path     => "os-keypairs/#{key_name}"
+          )
+        end
+      end
+
+      class Mock
+        def delete_key_pair(key_name)
+          response = Excon::Response.new
+          response.status = 202
+          response.headers = {
+            "Content-Type" => "text/html; charset=UTF-8",
+            "Content-Length" => "0",
+            "Date" => Date.new
+          }
+          response.body = {}
+          response
+        end
+      end # mock
+    end # openstack
+  end # compute
+end # fog