fog-profitbricks 0.0.1

data/lib/fog/profitbricks/parsers/compute/update_storage.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Parsers
+    module Compute
+      module ProfitBricks
+        class UpdateStorage < Fog::Parsers::ProfitBricks::Base
+          def reset
+            @response = { 'updateStorageResponse' => {} }
+          end
+
+          def end_element(name)
+            case name
+            when 'requestId', 'dataCenterId'
+              @response['updateStorageResponse'][name] = value
+            when 'dataCenterVersion'
+              @response['updateStorageResponse'][name] = value.to_i
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/profitbricks/requests/compute/clear_data_center.rb

@@ -0,0 +1,53 @@
+module Fog
+  module Compute
+    class ProfitBricks
+      class Real
+        require "fog/profitbricks/parsers/compute/clear_data_center"
+
+        # Clear all objects within a virtual data center
+        #
+        # ==== Parameters
+        # * dataCenterId<~String> - Required, UUID of virtual data center
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #   * clearDataCenterResponse<~Hash>:
+        #     * requestId<~String> - ID of request
+        #     * dataCenterId<~String> - UUID of virtual data center
+        #     * dataCenterVersion<~Integer> - Version of the virtual data center
+        #
+        # {ProfitBricks API Documentation}[http://www.profitbricks.com/apidoc/ClearDataCenter.html]
+        def clear_data_center(data_center_id)
+          soap_envelope = Fog::ProfitBricks.construct_envelope {
+            |xml| xml[:ws].clearDataCenter {
+              xml.dataCenterId(data_center_id)
+            }
+          }
+
+          request(
+            :expects => [200],
+            :method  => "POST",
+            :body    => soap_envelope.to_xml,
+            :parser  => Fog::Parsers::Compute::ProfitBricks::ClearDataCenter.new
+          )
+        end
+      end
+
+      class Mock
+        def clear_data_center(data_center_id)
+          response        = Excon::Response.new
+          response.status = 200
+          response.body   = {
+            "clearDataCenterResponse" => {
+              "requestId"         => Fog::Mock::random_numbers(7),
+              "dataCenterId"      => Fog::UUID.uuid,
+              "dataCenterVersion" => 1,
+            }
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/profitbricks/requests/compute/connect_storage_to_server.rb

@@ -0,0 +1,85 @@
+module Fog
+    module Compute
+        class ProfitBricks
+            class Real
+                require 'fog/profitbricks/parsers/compute/connect_storage_to_server'
+
+                # Connect virtual storage
+                #
+                # ==== Parameters
+                # * storageId<~String> - Required, UUID of virtual storage
+                # * serverId<~String> - Required, 
+                # * options<~Hash>:
+                #   * busType<~String> - Optional, VIRTIO, IDE 
+                #   * deviceNumber<~Integer> - Optional, 
+                #
+                # ==== Returns
+                # * response<~Excon::Response>:
+                #   * body<~Hash>:
+                #     * connectStorageToServerResponse<~Hash>:
+                #       * requestId<~String> - ID of request
+                #       * dataCenterId<~String> - UUID of virtual data center
+                #       * dataCenterVersion<~Integer> - Version of the virtual data center
+                #
+                # {ProfitBricks API Documentation}[http://www.profitbricks.com/apidoc/ConnectStorage.html]
+                def connect_storage_to_server(storage_id, server_id, options={})
+                    soap_envelope = Fog::ProfitBricks.construct_envelope {
+                      |xml| xml[:ws].connectStorageToServer {
+                        xml.request { 
+                          xml.storageId(storage_id)
+                          xml.serverId(server_id)
+                          options.each { |key, value| xml.send(key, value) }
+                        }
+                      }
+                    }
+
+                    request(
+                        :expects => [200],
+                        :method  => 'POST',
+                        :body    => soap_envelope.to_xml,
+                        :parser  => 
+                          Fog::Parsers::Compute::ProfitBricks::ConnectStorageToServer.new
+                    )
+                rescue Excon::Errors::InternalServerError => error
+                    Fog::Errors::NotFound.new(error)
+                end
+            end
+
+            class Mock
+                def connect_storage_to_server(storage_id, server_id, options={})
+
+                    if storage = self.data[:volumes].find {
+                        |attrib| attrib['storageId'] == storage_id
+                    }
+                    else
+                        raise Fog::Errors::NotFound.new(
+                            'The requested volume could not be found'
+                        )
+                    end
+
+                    if server = self.data[:servers].find {
+                        |attrib| attrib['serverId'] == server_id
+                    }
+                        server['connectedStorages'] << storage
+                    else
+                        raise Fog::Errors::NotFound.new(
+                            'The requested server could not be found'
+                        )
+                    end
+
+                    response = Excon::Response.new
+                    response.status = 200
+                    response.body =
+                    { 'connectStorageToServerResponse' =>
+                      {
+                        'requestId' => Fog::Mock::random_numbers(7),
+                        'dataCenterId' => Fog::UUID.uuid,
+                        'dataCenterVersion' => 1
+                      }
+                    }
+                    response
+                end
+            end
+        end
+    end
+end

data/lib/fog/profitbricks/requests/compute/create_data_center.rb

@@ -0,0 +1,64 @@
+module Fog
+    module Compute
+        class ProfitBricks
+            class Real
+                require 'fog/profitbricks/parsers/compute/create_data_center'
+
+                # Create a new virtual data center
+                #
+                # ==== Parameters
+                #   dataCenterName<~String> - Name of the new virtual data center
+                #   location<~String> - Location to create the new data center ("de/fkb", "de/fra", or "us/las")
+                #
+                # ==== Returns
+                # * response<~Excon::Response>:
+                #   * body<~Hash>:
+                #     * createDataCenterResponse<~Hash>:
+                #       * requestId<~String> - ID of request
+                #       * dataCenterId<~String> - UUID of virtual data center
+                #       * dataCenterVersion<~Integer> - Version of the virtual data center
+                #       * location<~String> - Location of virtual data center
+                #
+                # {ProfitBricks API Documentation}[http://www.profitbricks.com/apidoc/CreateDataCenter.html]
+                def create_data_center(data_center_name='', location='')
+                    soap_envelope = Fog::ProfitBricks.construct_envelope {
+                        |xml| xml[:ws].createDataCenter {
+                        xml.request {
+                            xml.dataCenterName(data_center_name)
+                            xml.location(location)
+                        }
+                    }
+                }
+
+                    request(
+                        :expects => [200],
+                        :method  => 'POST',
+                        :body    => soap_envelope.to_xml,
+                        :parser  => 
+                            Fog::Parsers::Compute::ProfitBricks::CreateDataCenter.new
+                    )
+                end
+            end
+
+            class Mock
+                def create_data_center(data_center_name='', location='')
+
+                    data_center = {
+                        'requestId'         => Fog::Mock::random_numbers(7),
+                        'dataCenterId'      => Fog::UUID.uuid,
+                        'dataCenterName'    => data_center_name || '',
+                        'location'          => location || '',
+                        'dataCenterVersion' => 1,
+                        'provisioningState' => 'AVAILABLE'
+                    }
+
+                    self.data[:datacenters] << data_center
+                    response        = Excon::Response.new
+                    response.status = 200
+                    response.body   = { 'createDataCenterResponse' => data_center }
+                    response
+                end
+            end
+        end
+    end
+end

data/lib/fog/profitbricks/requests/compute/create_flavor.rb

@@ -0,0 +1,40 @@
+module Fog
+    module Compute
+        class ProfitBricks
+            class Real
+                # Not a real API method; will only return flavor object.
+                def create_flavor(flavor_name, cores, ram)
+                    response        = Excon::Response.new
+                    response.status = 200
+                    response.body   = {
+                      'createFlavorResponse' => {
+                          'id'    => Fog::UUID.uuid,
+                          'name'  => flavor_name,
+                          'cores' => cores,
+                          'ram'   => ram,
+                      }
+                    }
+                    response
+                end
+            end
+
+            class Mock
+                def create_flavor(flavor_name, ram, cores)
+                    response = Excon::Response.new
+                    response.status = 200
+                    
+                    flavor = {
+                      'id'    => Fog::UUID.uuid,
+                      'name'  => flavor_name,
+                      'ram'   => ram,
+                      'cores' => cores
+                    }
+                    
+                    self.data[:flavors] << flavor
+                    response.body = { 'createFlavorResponse' => flavor }
+                    response
+                end
+            end
+        end
+    end
+end

data/lib/fog/profitbricks/requests/compute/create_nic.rb

@@ -0,0 +1,81 @@
+module Fog
+    module Compute
+        class ProfitBricks
+            class Real
+                require 'fog/profitbricks/parsers/compute/create_nic'
+
+                # Create new virtual network interface
+                #
+                # ==== Parameters
+                # * serverId<~String> - Required, 
+                # * lanId - Required,
+                # * options<~Hash>:
+                #   * nicName<~String> - Optional, name of the new virtual network interface
+                #   * ip<~String> - Optional, 
+                #   * dhcpActive<~String> - Optional, 
+                #
+                # ==== Returns
+                # * response<~Excon::Response>:
+                #   * body<~Hash>:
+                #     * createNicResponse<~Hash>:
+                #       * requestId<~String> - ID of request
+                #       * dataCenterId<~String> - UUID of virtual data center
+                #       * dataCenterVersion<~Integer> - Version of the virtual data center
+                #       * nicId<~String> - UUID of the new virtual network interface
+                #
+                # {ProfitBricks API Documentation}[http://www.profitbricks.com/apidoc/CreateNIC.html]
+                def create_nic(server_id, lan_id, options={})
+                    soap_envelope = Fog::ProfitBricks.construct_envelope {
+                      |xml| xml[:ws].createNic {
+                        xml.request {
+                          xml.serverId(server_id)
+                          xml.lanId(lan_id)
+                          options.each { |key, value| xml.send(key, value) }
+                        }
+                      }
+                    }
+
+                    request(
+                        :expects => [200],
+                        :method  => 'POST',
+                        :body    => soap_envelope.to_xml,
+                        :parser  => 
+                          Fog::Parsers::Compute::ProfitBricks::CreateNic.new
+                    )
+                end
+            end
+
+            class Mock
+                def create_nic(server_id, lan_id, options={})
+                    response = Excon::Response.new
+                    response.status = 200
+                    
+                    nic_id = Fog::UUID.uuid
+                    nic = {
+                        'nicId'             => nic_id,
+                        'lanId'             => lan_id,
+                        'nicName'           => options['nicName'] || '',
+                        'internetAccess'    => options['internetAccess'] || 'false',
+                        'ip'                => options['ip'] || nil,
+                        'macAddress'        => Fog::Mock::random_hex(12),
+                        'firewall'          => {},
+                        'dhcpActive'        => options['dhcpActive'] || 'false',
+                        'provisioningState' => 'AVAILABLE'
+                    }
+                    
+                    self.data[:interfaces] << nic
+                    response.body = {
+                      'createNicResponse' => 
+                      {
+                        'requestId'         => Fog::Mock::random_numbers(7),
+                        'dataCenterId'      => Fog::UUID.uuid,
+                        'dataCenterVersion' => 1,
+                        'nicId'             => nic_id
+                      }
+                    }
+                    response
+                end
+            end
+        end
+    end
+end

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

@@ -0,0 +1,107 @@
+module Fog
+    module Compute
+        class ProfitBricks
+            class Real
+                require 'fog/profitbricks/parsers/compute/create_server'
+
+                # Create new virtual server
+                #
+                # ==== Parameters
+                # * dataCenterId<~String> - Required, UUID of virtual data center
+                # * cores<~Integer> - Required, number of CPU cores allocated to virtual server
+                # * ram<~Integer> - Required, amount of memory in GB allocated to virtual server
+                # * options<~Hash>:
+                #   * serverName<~String> - Optional, name of the new virtual network interface
+                #   * bootFromStorageId<~String> - Optional, defines an existing storage device ID to be set as boot device of the server
+                #   * bootFromImageId<~<String> - Optional, defines an existing CD-ROM/DVD image ID to be set as boot device of the server
+                #   * internetAccess<~Boolean> - Optional, set to TRUE to connect the server to the Internet via the specified LAN ID
+                #   * lanId<~String> - Optional, connects the server to the specified LAN ID
+                #   * osType<~String> - Optional, UNKNOWN, WINDOWS, LINUX, OTHER
+                #   * availabilityZone<~String> - Optional, AUTO, ZONE_1, ZONE_2
+                #   * cpuHotPlug<~Boolean> - Optional, set the server CPU Hot-Plug capability 
+                #   * ramHotPlug<~Boolean> - Optional, set the server RAM Hot-Plug capability
+                #   * nicHotPlug<~Boolean> - Optional, set the server NIC Hot-Plug capability
+                #   * nicHotUnPlug<~Boolean> - Optional, set the server NIC Hot-UnPlug capability
+                #   * discVirtioHotPlug<~Boolean> - Optional, set the server capabilities to hotplug storages which are connected through VirtIO bustypeSet 
+                #   * discVirtioHotUnPlug<~Boolean> - Optional, set the server capabilities to hotUnplug storages which are connected through VirtIO bustypeSet
+                #
+                # ==== Returns
+                # * response<~Excon::Response>:
+                #   * body<~Hash>:
+                #     * createServerResponse<~Hash>:
+                #       * requestId<~String> - ID of request
+                #       * dataCenterId<~String> - UUID of virtual data center
+                #       * dataCenterVersion<~Integer> - Version of the virtual data center
+                #       * serverId<~String> - UUID of the new virtual server
+                #
+                # {ProfitBricks API Documentation}[http://www.profitbricks.com/apidoc/CreateServer.html]
+                def create_server(data_center_id, cores, ram, options={})
+                    soap_envelope = Fog::ProfitBricks.construct_envelope {
+                      |xml| xml[:ws].createServer {
+                        xml.request {
+                          xml.dataCenterId(data_center_id)
+                          xml.cores(cores)
+                          xml.ram(ram)
+                          options.each { |key, value| xml.send(key, value) }
+                        }
+                      }
+                    }
+
+                    request(
+                        :expects => [200],
+                        :method  => 'POST',
+                        :body    => soap_envelope.to_xml,
+                        :parser  => 
+                          Fog::Parsers::Compute::ProfitBricks::CreateServer.new
+                    )
+                end
+            end
+
+            class Mock
+                def create_server(data_center_id, cores, ram, options={})
+                    server_id = Fog::UUID.uuid
+
+                    server = {
+                        'serverId'             => server_id,
+                        'cores'                => cores,
+                        'ram'                  => ram,
+                        'serverName'           => options['serverName'],
+                        'internetAccess'       => options['internetAccess'] || 'false',
+                        #'ips'                  => options['ips'] || '',
+                        'connectedStorages'    => options['connectedStorages'] || [],
+                        'romDrives'            => options['romDrives'] || [],
+                        'nics'                 => options['nics'] || [],
+                        'provisioningState'    => 'AVAILABLE',
+                        'virtualMachineState'  => 'RUNNING',
+                        'creationTime'         => Time.now,
+                        'lastModificationTime' => Time.now,
+                        'osType'               => options['osType'] || 'UNKNOWN',
+                        'availabilityZone'     => options['availabilityZone'] || 'AUTO',
+                        'dataCenterId'         => Fog::UUID.uuid,
+                        'dataCenterVersion'    => 1
+                        ##'cpuHotPlug'           => 'true',
+                        ##'ramHotPlug'           => 'true',
+                        ##'nicHotPlug'           => 'true',
+                        ##'nicHotUnPlug'         => 'true',
+                        ##'discVirtioHotPlug'    => 'true',
+                        ##'discVirtioHotUnPlug'  => 'true'
+                    }
+                    
+                    self.data[:servers] << server
+
+                    response = Excon::Response.new
+                    response.status = 200
+                    response.body = {
+                      'createServerResponse' => {
+                        'requestId'         => Fog::Mock::random_numbers(7),
+                        'dataCenterId'      => Fog::UUID.uuid,
+                        'dataCenterVersion' => 1,
+                        'serverId'          => server_id
+                      }
+                    }
+                    response
+                end
+            end
+        end
+    end
+end