fog-profitbricks 0.0.1

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

@@ -0,0 +1,61 @@
+module Fog
+    module Compute
+        class ProfitBricks
+            class Real
+                require 'fog/profitbricks/parsers/compute/set_internet_access'
+
+                # Connect an existing NIC to a public LAN to get internet access
+                #
+                # ==== Parameters
+                # * dataCenterId<~String> -
+                # * lanId<~Integer> -
+                # * internetAccess<~Boolean> - 
+                #
+                # ==== Returns
+                # * response<~Excon::Response>:
+                #   * body<~Hash>:
+                #     * setInternetAccessResponse<~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/SetInternetAccess.html]
+                def set_internet_access(data_center_id, lan_id, internet_access)
+                    soap_envelope = Fog::ProfitBricks.construct_envelope {
+                      |xml| xml[:ws].setInternetAccess {
+                        xml.dataCenterId(data_center_id)
+                        xml.lanId(lan_id)
+                        xml.internetAccess(internet_access)
+                      }
+                    }
+
+                    request(
+                        :expects => [200],
+                        :method  => 'POST',
+                        :body    => soap_envelope.to_xml,
+                        :parser  =>
+                          Fog::Parsers::Compute::ProfitBricks::SetInternetAccess.new
+                    )
+                rescue Excon::Errors::InternalServerError => error
+                    Fog::Errors::NotFound.new(error)
+                end
+            end
+
+            class Mock
+                def set_internet_access(data_center_id, lan_id, internet_access)
+                    response        = Excon::Response.new
+                    response.status = 200
+                    response.body   = {
+                      'setInternetAccessResponse' =>
+                      {
+                        'requestId'         => Fog::Mock::random_numbers(7),
+                        'dataCenterId'      => Fog::UUID.uuid,
+                        'dataCenterVersion' => 1
+                      }
+                    }
+                    response
+                end
+            end
+        end
+    end
+end

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

@@ -0,0 +1,59 @@
+module Fog
+  module Compute
+    class ProfitBricks
+      class Real
+
+        # Start specified virtual server
+        #
+        # ==== Parameters
+        # * serverId<~String> - UUID of a virtual server
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #   * startServerResponse<~Hash>:
+        #     * requestId<~String> - ID of request
+        #
+        # {ProfitBricks API Documentation}[http://www.profitbricks.com/apidoc/StartServer.html]
+        def start_server(server_id)
+          soap_envelope = Fog::ProfitBricks.construct_envelope do |xml|
+            xml[:ws].startServer {
+              xml.serverId(server_id)
+            }
+          end
+
+          request(
+            :expects => [200],
+            :method  => "POST",
+            :body    => soap_envelope.to_xml
+          )
+        rescue Excon::Errors::InternalServerError => error
+          Fog::Errors::NotFound.new(error)
+        end
+      end
+
+      class Mock
+        def start_server(server_id)
+
+          if server = self.data[:servers].find {
+            |attrib| attrib["serverId"] == server_id
+          }
+            server["machine_state"] = "RUNNING"
+            server["provisioning_state"] = "AVAILABLE"
+          else
+            raise Fog::Errors::NotFound.new("The requested server resource could not be found")
+          end
+
+          response        = Excon::Response.new
+          response.status = 200
+          response.body   = {
+            "startServerResponse" => {
+              "requestId" => Fog::Mock::random_numbers(7)
+            }
+          }
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+module Fog
+  module Compute
+    class ProfitBricks
+      class Real
+
+        # Stop specified virtual server
+        #
+        # ==== Parameters
+        # * serverId<~String> - UUID of a virtual server
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #   * stopServerResponse<~Hash>:
+        #     * requestId<~String> - ID of request
+        #
+        # {ProfitBricks API Documentation}[http://www.profitbricks.com/apidoc/StopServer.html]
+        def stop_server(server_id)
+          soap_envelope = Fog::ProfitBricks.construct_envelope do |xml|
+            xml[:ws].stopServer {
+              xml.serverId(server_id)
+            }
+          end
+
+          request(
+            :expects => [200],
+            :method  => "POST",
+            :body    => soap_envelope.to_xml
+          )
+        rescue Excon::Errors::InternalServerError => error
+          Fog::Errors::NotFound.new(error)
+        end
+      end
+
+      class Mock
+        def stop_server(server_id)
+
+          if server = self.data[:servers].find {
+            |attrib| attrib["serverId"] == server_id
+          }
+            server["machine_state"] = "SHUTOFF"
+            server["provisioning_state"] = "INACTIVE"
+          else
+            raise Fog::Errors::NotFound.new("The requested server resource could not be found")
+          end
+
+          response        = Excon::Response.new
+          response.status = 200
+          response.body   = {
+            "stopServerResponse" => {
+              "requestId" => Fog::Mock::random_numbers(7)
+            }
+          }
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+module Fog
+    module Compute
+        class ProfitBricks
+            class Real
+                require 'fog/profitbricks/parsers/compute/update_data_center'
+                def update_data_center(data_center_id, options={})
+                    soap_envelope = Fog::ProfitBricks.construct_envelope {
+                      |xml| xml[:ws].updateDataCenter {
+                        xml.request { 
+                          xml.dataCenterId(data_center_id)
+                          options.each { |key, value| xml.send(key, value) }
+                        }
+                      }
+                    }
+
+                    request(
+                        :expects => [200],
+                        :method  => 'POST',
+                        :body    => soap_envelope.to_xml,
+                        :parser  => 
+                          Fog::Parsers::Compute::ProfitBricks::UpdateDataCenter.new
+                    )
+                rescue Excon::Errors::InternalServerError => error
+                    Fog::Errors::NotFound.new(error)
+                end
+            end
+
+            class Mock
+                def update_data_center(data_center_id, options={})
+
+                    if data_center = self.data[:datacenters].find {
+                      |attrib| attrib['dataCenterId'] == data_center_id
+                    }
+                        data_center['dataCenterName'] = options['dataCenterName']
+                        data_center['dataCenterVersion'] += 1
+                    else
+                        raise Fog::Errors::NotFound.new('The requested resource could not be found')
+                    end
+
+                    response        = Excon::Response.new
+                    response.status = 200
+                    response.body   = {
+                        'updateDataCenterResponse' =>
+                        {
+                            'requestId'         => Fog::Mock::random_numbers(7),
+                            'dataCenterId'      => Fog::UUID.uuid,
+                            'dataCenterVersion' => 1
+                        }
+                    }
+                    response
+                end
+            end
+        end
+    end
+end

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

@@ -0,0 +1,76 @@
+module Fog
+    module Compute
+        class ProfitBricks
+            class Real
+                require 'fog/profitbricks/parsers/compute/update_nic'
+
+                # Update a virtual NIC
+                #
+                # ==== Parameters
+                # * nicId<~String> - Required, 
+                # * options<~Hash>:
+                #   * lanId<~Integer> - Optional, 
+                #   * nicName<~String> - Optional, name of the new virtual network interface
+                #   * ip<~String> - Optional, 
+                #   * dhcpActive<~Boolean> - Optional, 
+                #
+                # ==== Returns
+                # * response<~Excon::Response>:
+                #   * body<~Hash>:
+                #     * updateNicResponse<~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/UpdateNIC.html]
+                def update_nic(nic_id, options={})
+                    soap_envelope = Fog::ProfitBricks.construct_envelope {
+                      |xml| xml[:ws].updateNic {
+                        xml.request { 
+                          xml.nicId(nic_id)
+                          options.each { |key, value| xml.send(key, value) }
+                        }
+                      }
+                    }
+
+                    request(
+                        :expects => [200],
+                        :method  => 'POST',
+                        :body    => soap_envelope.to_xml,
+                        :parser  =>
+                          Fog::Parsers::Compute::ProfitBricks::UpdateNic.new
+                    )
+                rescue Excon::Errors::InternalServerError => error
+                    Fog::Errors::NotFound.new(error)
+                end
+            end
+
+            class Mock
+                def update_nic(nic_id, options={})
+
+                    if nic = self.data[:interfaces].find {
+                      |attrib| attrib['nicId'] == nic_id
+                    }
+                        options.each do |key, value|
+                            nic[key] = value
+                        end
+                    else
+                        raise Fog::Errors::NotFound.new('The requested NIC could not be found')
+                    end
+                    
+                    response        = Excon::Response.new
+                    response.status = 200
+                    response.body   = {
+                      'updateNicResponse' =>
+                      {
+                        'requestId'         => Fog::Mock::random_numbers(7),
+                        'dataCenterId'      => Fog::UUID.uuid,
+                        'dataCenterVersion' => 1
+                      }
+                    }
+                    response
+                end
+            end
+        end
+    end
+end

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

@@ -0,0 +1,81 @@
+module Fog
+    module Compute
+        class ProfitBricks
+            class Real
+                require 'fog/profitbricks/parsers/compute/update_server'
+
+                # Update a virtual server
+                #
+                # ==== Parameters
+                # * serverId<~String> - Required, UUID of virtual server
+                # * options<~Hash>:
+                #   * serverName<~String> - Optional, 
+                #   * cores<~Integer> - Optional,
+                #   * ram<~Integer> Optional, Memory in MB
+                #   * bootFromStorageId<~String> - Optional, UUID of boot storage
+                #   * bootFromImageId<~String> -
+                #   * osType<~String> - Optional, UNKNOWN, WINDOWS, LINUX, OTHER
+                #   * availabilityZone<~String> - Optional, AUTO, ZONE_1, ZONE_2
+                #
+                # ==== Returns
+                # * response<~Excon::Response>:
+                #   * body<~Hash>:
+                #     * updateServerResponse<~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/UpdateServer.html]
+                def update_server(server_id, options={})
+                    soap_envelope = Fog::ProfitBricks.construct_envelope {
+                      |xml| xml[:ws].updateServer {
+                        xml.request { 
+                          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::UpdateServer.new
+                    )
+                rescue Excon::Errors::InternalServerError => error
+                    Fog::Errors::NotFound.new(error)
+                end
+            end
+
+            class Mock
+                def update_server(server_id, options={})
+
+                    if server = self.data[:servers].find {
+                      |attrib| attrib['serverId'] == server_id
+                    }
+                        options.each do |key, value|
+                            server[key] = value
+                        end
+                    else
+                        raise Fog::Errors::NotFound.new(
+                            'The requested server resource could not be found'
+                        )
+                    end
+
+                    response        = Excon::Response.new
+                    response.status = 200
+                    response.body   = {
+                      'updateServerResponse' =>
+                      {
+                        'requestId'         => Fog::Mock::random_numbers(7),
+                        'dataCenterId'      => Fog::UUID.uuid,
+                        'dataCenterVersion' => 1
+                      }
+                    }
+                    response
+                end
+            end
+        end
+    end
+end

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

@@ -0,0 +1,75 @@
+module Fog
+    module Compute
+        class ProfitBricks
+            class Real
+                require 'fog/profitbricks/parsers/compute/update_storage'
+
+                # Update a virtual storage
+                #
+                # ==== Parameters
+                # * storageId<~String> - Required, UUID of the virtual storage
+                # * options<~Hash>:
+                #   * size<~Integer> - Optional, size of virtual storage in GB
+                #   * storageName<~String> - Optional, 
+                #   * mountImageId<~String> - Optional, 
+                #
+                # ==== Returns
+                # * response<~Excon::Response>:
+                #   * body<~Hash>:
+                #     * updateStorageResponse<~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/UpdateStorage.html]
+                def update_storage(storage_id, options={})
+                    soap_envelope = Fog::ProfitBricks.construct_envelope {
+                      |xml| xml[:ws].updateStorage {
+                        xml.request { 
+                          xml.storageId(storage_id)
+                          options.each { |key, value| xml.send(key, value) }
+                        }
+                      }
+                    }
+
+                    request(
+                        :expects => [200],
+                        :method  => 'POST',
+                        :body    => soap_envelope.to_xml,
+                        :parser  =>
+                          Fog::Parsers::Compute::ProfitBricks::UpdateStorage.new
+                    )
+                rescue Excon::Errors::InternalServerError => error
+                    Fog::Errors::NotFound.new(error)
+                end
+            end
+
+            class Mock
+                def update_storage(storage_id, options={})
+
+                    if storage = self.data[:volumes].find {
+                      |attrib| attrib['storageId'] == storage_id
+                    }
+                        options.each do |key, value|
+                            storage[key] = value
+                        end
+                    else
+                        raise Fog::Errors::NotFound.new('The requested resource could not be found')
+                    end
+
+                    response        = Excon::Response.new
+                    response.status = 200
+                    response.body   = {
+                      'updateStorageResponse' =>
+                      {
+                        'requestId'         => Fog::Mock::random_numbers(7),
+                        'dataCenterId'      => Fog::UUID.uuid,
+                        'dataCenterVersion' => 1
+                      }
+                    }
+                    response
+                end
+            end
+        end
+    end
+end