fog-profitbricks 0.0.3 → 0.0.4

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

@@ -0,0 +1,83 @@
+module Fog
+  module Compute
+    class ProfitBricks
+      class Real
+        # 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 → compute/profit_bricks/requests}/create_data_center.rb

@@ -2,8 +2,6 @@ module Fog
     module Compute
         class ProfitBricks
             class Real
-                require 'fog/profitbricks/parsers/compute/create_data_center'
-
                 # Create a new virtual data center
                 #
                 # ==== Parameters
@@ -34,7 +32,7 @@ module Fog
                         :expects => [200],
                         :method  => 'POST',
                         :body    => soap_envelope.to_xml,
-                        :parser  => 
+                        :parser  =>
                             Fog::Parsers::Compute::ProfitBricks::CreateDataCenter.new
                     )
                 end

data/lib/fog/{profitbricks/requests/compute → compute/profit_bricks/requests}/create_flavor.rb

@@ -22,14 +22,14 @@ module Fog
                 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

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

@@ -0,0 +1,79 @@
+module Fog
+  module Compute
+    class ProfitBricks
+      class Real
+        # 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/compute/profit_bricks/requests/create_server.rb

@@ -0,0 +1,105 @@
+module Fog
+  module Compute
+    class ProfitBricks
+      class Real
+        # 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

data/lib/fog/{profitbricks/requests/compute → compute/profit_bricks/requests}/create_storage.rb

@@ -2,8 +2,6 @@ module Fog
     module Compute
         class ProfitBricks
             class Real
-                require 'fog/profitbricks/parsers/compute/create_storage'
-
                 # Create new virtual storage
                 #
                 # ==== Parameters
@@ -39,8 +37,8 @@ module Fog
                         :expects => [200],
                         :method  => 'POST',
                         :body    => soap_envelope.to_xml,
-                        :parser  => 
-                          Fog::Parsers::Compute::ProfitBricks::CreateStorage.new
+                        :parser  =>
+                            Fog::Parsers::Compute::ProfitBricks::CreateStorage.new
                     )
                 end
             end
@@ -49,7 +47,7 @@ module Fog
                 def create_storage(data_center_id, size, options={})
                     response = Excon::Response.new
                     response.status = 200
-                    
+
                     if data_center = self.data[:datacenters].find {
                         |attrib| attrib['dataCenterId'] == data_center_id
                     }
@@ -80,7 +78,7 @@ module Fog
                         'lastModificationTime' => Time.now,
                         'profitBricksImagePassword' => options['profitBricksImagePassword'] || ''
                     }
-                    
+
                     self.data[:volumes] << storage
                     response.body = {
                       'createStorageResponse' => {

data/lib/fog/{profitbricks/requests/compute → compute/profit_bricks/requests}/delete_data_center.rb

@@ -2,8 +2,6 @@ module Fog
     module Compute
         class ProfitBricks
             class Real
-                require 'fog/profitbricks/parsers/compute/delete_data_center'
-
                 # Delete virtual data center
                 #
                 # ==== Parameters
@@ -29,8 +27,8 @@ module Fog
                         :expects => [200],
                         :method  => 'POST',
                         :body    => soap_envelope.to_xml,
-                        :parser  => 
-                          Fog::Parsers::Compute::ProfitBricks::DeleteDataCenter.new
+                        :parser  =>
+                            Fog::Parsers::Compute::ProfitBricks::DeleteDataCenter.new
                     )
                 rescue Excon::Errors::InternalServerError => error
                     Fog::Errors::NotFound.new(error)
@@ -41,7 +39,7 @@ module Fog
                 def delete_data_center(data_center_id)
                     response = Excon::Response.new
                     response.status = 200
-                    
+
                     if data_center = self.data[:datacenters].find {
                       |attrib| attrib['dataCenterId'] == data_center_id
                     }

data/lib/fog/{profitbricks/requests/compute → compute/profit_bricks/requests}/delete_nic.rb

@@ -2,8 +2,6 @@ module Fog
     module Compute
         class ProfitBricks
             class Real
-                require 'fog/profitbricks/parsers/compute/delete_nic'
-
                 # Delete virtual network interface
                 #
                 # ==== Parameters
@@ -29,8 +27,8 @@ module Fog
                         :expects => [200],
                         :method  => 'POST',
                         :body    => soap_envelope.to_xml,
-                        :parser  => 
-                          Fog::Parsers::Compute::ProfitBricks::DeleteNic.new
+                        :parser  =>
+                            Fog::Parsers::Compute::ProfitBricks::DeleteNic.new
                     )
                 rescue Excon::Errors::InternalServerError => error
                     Fog::Errors::NotFound.new(error)
@@ -41,7 +39,7 @@ module Fog
                 def delete_nic(nic_id)
                     response = Excon::Response.new
                     response.status = 200
-                    
+
                     if nic = self.data[:interfaces].find {
                       |attrib| attrib['nicId'] == nic_id
                     }

data/lib/fog/{profitbricks/requests/compute → compute/profit_bricks/requests}/delete_server.rb

@@ -2,8 +2,6 @@ module Fog
     module Compute
         class ProfitBricks
             class Real
-                require 'fog/profitbricks/parsers/compute/delete_server'
-
                 # Delete virtual server
                 #
                 # ==== Parameters
@@ -29,8 +27,8 @@ module Fog
                         :expects => [200],
                         :method  => 'POST',
                         :body    => soap_envelope.to_xml,
-                        :parser  => 
-                          Fog::Parsers::Compute::ProfitBricks::DeleteServer.new
+                        :parser  =>
+                            Fog::Parsers::Compute::ProfitBricks::DeleteServer.new
                     )
                 rescue Excon::Errors::InternalServerError => error
                     Fog::Errors::NotFound.new(error)

data/lib/fog/{profitbricks/requests/compute → compute/profit_bricks/requests}/delete_storage.rb

@@ -2,8 +2,6 @@ module Fog
     module Compute
         class ProfitBricks
             class Real
-                require 'fog/profitbricks/parsers/compute/delete_storage'
-
                 # Delete a virtual storage
                 #
                 # ==== Parameters
@@ -29,8 +27,8 @@ module Fog
                         :expects => [200],
                         :method  => 'POST',
                         :body    => soap_envelope.to_xml,
-                        :parser  => 
-                          Fog::Parsers::Compute::ProfitBricks::DeleteStorage.new
+                        :parser  =>
+                            Fog::Parsers::Compute::ProfitBricks::DeleteStorage.new
                     )
                 rescue Excon::Errors::InternalServerError => error
                     Fog::Errors::NotFound.new(error)

data/lib/fog/compute/profit_bricks/requests/disconnect_storage_from_server.rb

@@ -0,0 +1,76 @@
+module Fog
+  module Compute
+    class ProfitBricks
+      class Real
+        # Disconnect virtual storage
+        #
+        # ==== Parameters
+        # * serverId<~String> - UUID of virtual server
+        # * storageId<~String> - UUID of virtual storage
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * disconnectStorageToServerResponse<~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/DisconnectStorage.html]
+        def disconnect_storage_from_server(storage_id, server_id)
+          soap_envelope = Fog::ProfitBricks.construct_envelope {
+              |xml| xml[:ws].disconnectStorageFromServer {
+              xml.serverId(server_id)
+              xml.storageId(storage_id)
+            }
+          }
+
+          request(
+              :expects => [200],
+              :method  => 'POST',
+              :body    => soap_envelope.to_xml,
+              :parser  =>
+                  Fog::Parsers::Compute::ProfitBricks::DisconnectStorageFromServer.new
+          )
+        rescue Excon::Errors::InternalServerError => error
+          Fog::Errors::NotFound.new(error)
+        end
+      end
+
+      class Mock
+        def disconnect_storage_from_server(storage_id, server_id)
+
+          if storage = self.data[:volumes].find {
+              |attrib| attrib['storageId'] == storage_id
+          }
+          else
+            raise Fog::Errors::NotFound.new(
+                      'The requested storage resource could not be found'
+                  )
+          end
+
+          if server = self.data[:servers].find {
+              |attrib| attrib['serverId'] == server_id
+          }['connectedStorages'].delete(storage)
+          else
+            raise Fog::Errors::NotFound.new(
+                      'The requested server resource could not be found'
+                  )
+          end
+
+          response        = Excon::Response.new
+          response.status = 200
+          response.body   =
+              { 'disconnectStorageFromServerResponse' =>
+                    {
+                        'requestId' => Fog::Mock::random_numbers(7),
+                        'dataCenterId' => Fog::UUID.uuid,
+                        'dataCenterVersion' => 1
+                    }
+              }
+          response
+        end
+      end
+    end
+  end
+end