fog-profitbricks 0.0.1

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

@@ -0,0 +1,98 @@
+module Fog
+    module Compute
+        class ProfitBricks
+            class Real
+                require 'fog/profitbricks/parsers/compute/create_storage'
+
+                # Create new virtual storage
+                #
+                # ==== Parameters
+                # * dataCenterId<~String> - Required, UUID of virtual data center
+                # * size<~Integer> - Required, size of virtual storage
+                # * options<~Hash>:
+                #   * storageName<~String> - Optional, name of the new virtual storage
+                #   * mountImageId<~String> - Optional, UUID of image
+                #   * profitBricksImagePassword<~String> - Optional, 
+                #
+                # ==== Returns
+                # * response<~Excon::Response>:
+                #   * body<~Hash>:
+                #     * createStorageResponse<~Hash>:
+                #       * requestId<~String> - ID of request
+                #       * dataCenterId<~String> - UUID of virtual data center
+                #       * dataCenterVersion<~Integer> - Version of the virtual data center
+                #       * storageId<~String> - UUID of the new virtual storage
+                #
+                # {ProfitBricks API Documentation}[http://www.profitbricks.com/apidoc/CreateStorage.html]
+                def create_storage(data_center_id, size, options={})
+                    soap_envelope = Fog::ProfitBricks.construct_envelope {
+                      |xml| xml[:ws].createStorage {
+                        xml.request {
+                          xml.dataCenterId(data_center_id)
+                          xml.size(size)
+                          options.each { |key, value| xml.send(key, value) }
+                        }
+                      }
+                    }
+
+                    request(
+                        :expects => [200],
+                        :method  => 'POST',
+                        :body    => soap_envelope.to_xml,
+                        :parser  => 
+                          Fog::Parsers::Compute::ProfitBricks::CreateStorage.new
+                    )
+                end
+            end
+
+            class Mock
+                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
+                    }
+                        data_center['dataCenterVersion'] += 1
+                    else
+                        raise Fog::Errors::NotFound.new('Data center resource could not be found')
+                    end
+
+                    if image = self.data[:images].find {
+                        |attrib| attrib['imageId'] == options['mountImageId']
+                    }
+                        mount_image = {
+                            'imageId'   => options['mountImageId'],
+                            'imageName' => image['imageName']
+                        }
+                    end
+
+                    storage_id = Fog::UUID.uuid
+                    storage = {
+                        'dataCenterId'         => data_center_id,
+                        'dataCenterVersion'    => data_center['dataCenterVersion'],
+                        'storageId'            => storage_id,
+                        'size'                 => size,
+                        'storageName'          => options['storageName'] || '',
+                        'mountImage'           => mount_image || {},
+                        'provisioningState'    => 'AVAILABLE',
+                        'creationTime'         => Time.now,
+                        'lastModificationTime' => Time.now,
+                        'profitBricksImagePassword' => options['profitBricksImagePassword'] || ''
+                    }
+                    
+                    self.data[:volumes] << storage
+                    response.body = {
+                      'createStorageResponse' => {
+                        'requestId'         => Fog::Mock::random_numbers(7),
+                        'dataCenterId'      => Fog::UUID.uuid,
+                        'dataCenterVersion' => 1,
+                        'storageId'         => storage_id
+                      }
+                    }
+                    response
+                end
+            end
+        end
+    end
+end

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

@@ -0,0 +1,62 @@
+module Fog
+    module Compute
+        class ProfitBricks
+            class Real
+                require 'fog/profitbricks/parsers/compute/delete_data_center'
+
+                # Delete virtual data center
+                #
+                # ==== Parameters
+                # * dataCenterId<~String> - UUID of the virtual data center
+                #
+                # ==== Returns
+                # * response<~Excon::Response>:
+                #   * body<~Hash>:
+                #     * deleteDataCenterResponse<~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/DeleteDataCenter.html]
+                def delete_data_center(data_center_id)
+                    soap_envelope = Fog::ProfitBricks.construct_envelope {
+                      |xml| xml[:ws].deleteDataCenter {
+                        xml.dataCenterId(data_center_id)
+                      }
+                    }
+
+                    request(
+                        :expects => [200],
+                        :method  => 'POST',
+                        :body    => soap_envelope.to_xml,
+                        :parser  => 
+                          Fog::Parsers::Compute::ProfitBricks::DeleteDataCenter.new
+                    )
+                rescue Excon::Errors::InternalServerError => error
+                    Fog::Errors::NotFound.new(error)
+                end
+            end
+
+            class Mock
+                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
+                    }
+                        self.data[:datacenters].delete(data_center)
+                    else
+                        raise Fog::Errors::NotFound.new('The requested resource could not be found')
+                    end
+
+                    response.body = { 'deleteDataCenterResponse' => {
+                        'requestId' => data_center['requestId']
+                        }
+                    }
+                    response
+                end
+            end
+        end
+    end
+end

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

@@ -0,0 +1,66 @@
+module Fog
+    module Compute
+        class ProfitBricks
+            class Real
+                require 'fog/profitbricks/parsers/compute/delete_nic'
+
+                # Delete virtual network interface
+                #
+                # ==== Parameters
+                # * nicId<~String> - UUID of the virtual network interface
+                #
+                # ==== Returns
+                # * response<~Excon::Response>:
+                #   * body<~Hash>:
+                #     * deleteNicResponse<~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/DeleteNic.html]
+                def delete_nic(nic_id)
+                    soap_envelope = Fog::ProfitBricks.construct_envelope {
+                      |xml| xml[:ws].deleteNic {
+                        xml.nicId(nic_id)
+                      }
+                    }
+
+                    request(
+                        :expects => [200],
+                        :method  => 'POST',
+                        :body    => soap_envelope.to_xml,
+                        :parser  => 
+                          Fog::Parsers::Compute::ProfitBricks::DeleteNic.new
+                    )
+                rescue Excon::Errors::InternalServerError => error
+                    Fog::Errors::NotFound.new(error)
+                end
+            end
+
+            class Mock
+                def delete_nic(nic_id)
+                    response = Excon::Response.new
+                    response.status = 200
+                    
+                    if nic = self.data[:interfaces].find {
+                      |attrib| attrib['nicId'] == nic_id
+                    }
+                        self.data[:interfaces].delete(nic)
+                    else
+                        raise Fog::Errors::NotFound.new(
+                          'The requested NIC could not be found'
+                        )
+                    end
+
+                    response.body = { 'deleteNicResponse' => {
+                        'requestId'         => Fog::Mock::random_numbers(7),
+                        'dataCenterId'      => Fog::UUID.uuid,
+                        'dataCenterVersion' => 1,
+                        }
+                    }
+                    response
+                end
+            end
+        end
+    end
+end

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

@@ -0,0 +1,66 @@
+module Fog
+    module Compute
+        class ProfitBricks
+            class Real
+                require 'fog/profitbricks/parsers/compute/delete_server'
+
+                # Delete virtual server
+                #
+                # ==== Parameters
+                # * serverId<~String> - UUID of the virtual server
+                #
+                # ==== Returns
+                # * response<~Excon::Response>:
+                #   * body<~Hash>:
+                #     * deleteServerResponse<~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/DeleteServer.html]
+                def delete_server(server_id)
+                    soap_envelope = Fog::ProfitBricks.construct_envelope {
+                      |xml| xml[:ws].deleteServer {
+                        xml.serverId(server_id)
+                      }
+                    }
+
+                    request(
+                        :expects => [200],
+                        :method  => 'POST',
+                        :body    => soap_envelope.to_xml,
+                        :parser  => 
+                          Fog::Parsers::Compute::ProfitBricks::DeleteServer.new
+                    )
+                rescue Excon::Errors::InternalServerError => error
+                    Fog::Errors::NotFound.new(error)
+                end
+            end
+
+            class Mock
+                def delete_server(server_id)
+
+                    if server = self.data[:servers].find {
+                      |attrib| attrib['serverId'] == server_id
+                    }
+                        self.data[:servers].delete(server)
+                    else
+                        raise Fog::Errors::NotFound.new(
+                          'The requested server resource could not be found'
+                        )
+                    end
+
+                    response        = Excon::Response.new
+                    response.status = 200
+                    response.body   = { 'deleteServerResponse' => {
+                        'requestId'         => Fog::Mock::random_numbers(7),
+                        'dataCenterId'      => Fog::UUID.uuid,
+                        'dataCenterVersion' => 1,
+                        }
+                    }
+                    response
+                end
+            end
+        end
+    end
+end

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

@@ -0,0 +1,66 @@
+module Fog
+    module Compute
+        class ProfitBricks
+            class Real
+                require 'fog/profitbricks/parsers/compute/delete_storage'
+
+                # Delete a virtual storage
+                #
+                # ==== Parameters
+                # * storageId<~String> - 
+                #
+                # ==== Returns
+                # * response<~Excon::Response>:
+                #   * body<~Hash>:
+                #     * deleteStorageResponse<~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/DeleteStorage.html]
+                def delete_storage(storage_id)
+                    soap_envelope = Fog::ProfitBricks.construct_envelope {
+                      |xml| xml[:ws].deleteStorage {
+                        xml.storageId(storage_id)
+                      }
+                    }
+
+                    request(
+                        :expects => [200],
+                        :method  => 'POST',
+                        :body    => soap_envelope.to_xml,
+                        :parser  => 
+                          Fog::Parsers::Compute::ProfitBricks::DeleteStorage.new
+                    )
+                rescue Excon::Errors::InternalServerError => error
+                    Fog::Errors::NotFound.new(error)
+                end
+            end
+
+            class Mock
+                def delete_storage(storage_id)
+                    response = Excon::Response.new
+                    response.status = 200
+
+                    if storage = self.data[:volumes].find {
+                      |attrib| attrib['storageId'] == storage_id
+                    }
+                        self.data[:volumes].delete(storage)
+                    else
+                        raise Fog::Errors::NotFound.new(
+                          'The requested resource could not be found'
+                        )
+                    end
+
+                    response.body = { 'deleteStorageResponse' => {
+                        'requestId'         => Fog::Mock::random_numbers(7),
+                        'dataCenterId'      => Fog::UUID.uuid,
+                        'dataCenterVersion' => 3
+                        }
+                    }
+                    response
+                end
+            end
+        end
+    end
+end

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

@@ -0,0 +1,78 @@
+module Fog
+    module Compute
+        class ProfitBricks
+            class Real
+                require 'fog/profitbricks/parsers/compute/disconnect_storage_from_server'
+
+                # 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

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

@@ -0,0 +1,32 @@
+module Fog
+  module Compute
+    class ProfitBricks
+      class Real
+        require "fog/profitbricks/parsers/compute/get_all_data_centers"
+        def get_all_data_centers
+          soap_envelope = Fog::ProfitBricks.construct_envelope do |xml|
+            xml[:ws].getAllDataCenters
+          end
+
+          request(
+            :expects => [200],
+            :method  => "POST",
+            :body    => soap_envelope.to_xml,
+            :parser  => Fog::Parsers::Compute::ProfitBricks::GetAllDataCenters.new
+          )
+        end
+      end
+
+      class Mock
+        def get_all_data_centers
+          response        = Excon::Response.new
+          response.status = 200
+          response.body   = {
+            "getAllDataCentersResponse" => self.data[:datacenters]
+          }
+          response
+        end
+      end
+    end
+  end
+end