fog-oneandone 1.0

data/lib/oneandone/requests/compute/create_server.rb

@@ -0,0 +1,139 @@
+module Fog
+  module Compute
+    class OneAndOne
+
+      class Real
+
+        ##
+        # Creates a new server
+        # URL: [https://cloudpanel-api.1and1.com/documentation/1and1/v1/en/documentation.html#servers_post]
+        ##
+        def create_server(name: nil, description: nil, rsa_key: nil,
+          fixed_instance_id: nil, vcore: nil, cores_per_processor: nil,
+          ram: nil, appliance_id: nil, datacenter_id: nil, hdds: nil,
+          password: nil, power_on: nil, firewall_id: nil, ip_id: nil,
+          load_balancer_id: nil, monitoring_policy_id: nil)
+          
+          # Build hardware hash
+          hardware_params = {
+            'fixed_instance_size_id' => fixed_instance_id,
+            'vcore' => vcore,
+            'cores_per_processor' => cores_per_processor,
+            'ram' => ram,
+            'hdds' => hdds
+          }
+
+          # Clean out null values from hardware hash
+          hardware = clean_hash(hardware_params)
+
+          # Build POST body
+          new_server = {
+            'name' => name,
+            'description' => description,
+            'rsa_key' => rsa_key,
+            'hardware' => hardware,
+            'appliance_id' => appliance_id,
+            'datacenter_id' => datacenter_id,
+            'password' => password,
+            'power_on' => power_on,
+            'firewall_policy_id' => firewall_id,
+            'ip_id' => ip_id,
+            'load_balancer_id' => load_balancer_id,
+            'monitoring_policy_id' => monitoring_policy_id
+          }
+
+          # Clean out null values from POST body
+          body = clean_hash(new_server)
+
+          # Stringify the POST body
+          string_body = Fog::JSON.encode(body)
+
+          # Request
+          params = {
+            'method' => :post,
+            'endpoint' => '/servers',
+            'body' => string_body
+          }
+
+          request(params)
+
+        end
+
+      end # Real
+
+      
+      class Mock
+
+        def create_server(name: nil, description: nil, rsa_key: nil,
+          fixed_instance_id: nil, vcore: nil, cores_per_processor: nil,
+          ram: nil, appliance_id: nil, datacenter_id: nil, hdds: nil,
+          password: nil, power_on: nil, firewall_id: nil, ip_id: nil,
+          load_balancer_id: nil, monitoring_policy_id: nil)
+          
+          # Add UUID to hdds being passed in
+          if hdds
+            hdds.each do |hdd|
+              hdd['id'] = Fog::UUID.uuid
+            end
+          end
+
+          # Create mock server hash
+          mock_server = {
+            "id" => Fog::UUID.uuid,
+            "cloudpanel_id" => "FE7ED7D",
+            "name" => name,
+            "description" => description,
+            "datacenter" => {
+              "id" => datacenter_id,
+              "location" => "USA",
+              "country_code" => "US"
+            },
+            "creation_date" => "2015-05-07T08:25:37+00:00",
+            "first_password" => "Nm4gP97xSw",
+            "status" => {
+              "state" => "POWERED_ON",
+              "percent" => nil
+            },
+            "hardware" => {
+              "fixed_instance_size_id" => fixed_instance_id,
+              "vcore" => vcore,
+              "cores_per_processor" => cores_per_processor,
+              "ram" => ram,
+              "hdds" => hdds
+            },
+            "image" => {
+              "id" => appliance_id,
+              "name" => nil
+            },
+            "dvd" => nil,
+            "snapshot" => {},
+            "ips" => [
+              {
+                'id' => Fog::UUID.uuid,
+                'type' => 'IPV4',
+                'firewall_policy' => {},
+                'load_balancers' => []
+              }
+            ],
+            "alerts" => [],
+            "monitoring_policy" => nil,
+            "private_networks" => []
+          }
+
+          # Save mock server to servers list
+          self.data[:servers] << mock_server
+
+          # Return mock response to user
+          response = Excon::Response.new
+          response.status = 202
+          response.body = mock_server
+            
+          response
+
+        end
+
+      end # Mock
+
+    end # OneAndOne
+  end # Compute
+end # Fog

data/lib/oneandone/requests/compute/create_shared_storage.rb

@@ -0,0 +1,83 @@
+module Fog
+  module Compute
+    class OneAndOne
+
+      class Real
+
+        ##
+        # Creates a new shared storage
+        # URL: [https://cloudpanel-api.1and1.com/documentation/1and1/v1/en/documentation.html#shared_storages_post]
+        ##
+        def create_shared_storage(name: nil, description: nil,
+          size: nil, datacenter_id: nil)
+
+          # Build POST body
+          new_shared_storage = {
+            'name' => name,
+            'description' => description,
+            'size' => size,
+            'datacenter_id' => datacenter_id
+          }
+
+          # Clean out null values from POST body
+          body = clean_hash(new_shared_storage)
+
+          # Stringify the POST body
+          string_body = Fog::JSON.encode(body)
+
+          # Request
+          params = {
+            'method' => :post,
+            'endpoint' => '/shared_storages',
+            'body' => string_body
+          }
+
+          request(params)
+
+        end
+
+      end # Real
+
+      
+      class Mock
+
+        def create_shared_storage(name: nil, description: nil,
+          size: nil, datacenter_id: nil)
+          
+          # Create mock shared storage hash
+          mock_shared_storage = {
+            "id" => Fog::UUID.uuid,
+            "size" => size,
+            "state" => "ACTIVE",
+            "description" => description,
+            "datacenter" => {
+              "id" => datacenter_id,
+              "location" => "USA",
+              "country_code" => "US"
+            },
+            "cloudpanel_id" => "vid35780",
+            "size_used" => "0.00",
+            "cifs_path" => "\\vid50995.nas1.lan\vid50995",
+            "nfs_path" => "vid50995.nas1.lan/:vid50995",
+            "name" => name,
+            "creation_date" => "2015-05-06T08:33:25+00:00",
+            "servers" => []
+          }
+
+          # Save mock shared storage to list
+          self.data[:shared_storages] << mock_shared_storage
+
+          # Return mock response to user
+          response = Excon::Response.new
+          response.status = 202
+          response.body = mock_shared_storage
+            
+          response
+
+        end
+
+      end # Mock
+
+    end # OneAndOne
+  end # Compute
+end # Fog

data/lib/oneandone/requests/compute/create_snapshot.rb

@@ -0,0 +1,51 @@
+module Fog
+  module Compute
+    class OneAndOne
+
+      class Real
+
+        ##
+        # Create a server snapshot
+        # URL: [https://cloudpanel-api.1and1.com/documentation/1and1/v1/en/documentation.html#servers__server_id__snapshots_post]
+        ##
+        def create_snapshot(server_id)
+          
+          params = {
+            'method' => :post,
+            'endpoint' => "/servers/#{server_id}/snapshots"
+          }
+
+          request(params)
+
+        end
+
+      end # Real
+
+      
+      class Mock
+
+        def create_snapshot(server_id)
+          
+          # Search for server
+          if server = self.data[:servers].find {
+            |hash| hash['id'] == server_id
+          }
+            server['snapshot']['id'] = Fog::UUID.uuid
+          else
+            raise Fog::Errors::NotFound.new('The requested resource could
+              not be found.')
+          end
+
+          # Return Response Object to User
+          response = Excon::Response.new
+          response.status = 202
+          response.body = server
+          response
+
+        end
+
+      end # Mock
+
+    end # OneAndOne
+  end # Compute
+end # Fog

data/lib/oneandone/requests/compute/create_vpn.rb

@@ -0,0 +1,80 @@
+module Fog
+  module Compute
+    class OneAndOne
+
+      class Real
+
+        ##
+        # Creates a new VPN
+        # URL: [https://cloudpanel-api.1and1.com/documentation/1and1/v1/en/documentation.html#vpns_post]
+        ##
+        def create_vpn(name: nil, description: nil, datacenter_id: nil)
+
+          # Build POST body
+          new_vpn = {
+            'name' => name,
+            'description' => description,
+            'datacenter_id' => datacenter_id
+          }
+
+          # Clean out null values from POST body
+          body = clean_hash(new_vpn)
+
+          # Stringify the POST body
+          string_body = Fog::JSON.encode(body)
+
+          # Request
+          params = {
+            'method' => :post,
+            'endpoint' => '/vpns',
+            'body' => string_body
+          }
+
+          request(params)
+
+        end
+
+      end # Real
+
+      
+      class Mock
+
+        def create_vpn(name: nil, description: nil, datacenter_id: nil)
+          
+          # Create mock vpn hash
+          mock_vpn = {
+            "id" => Fog::UUID.uuid,
+            "name" => name,
+            "description" => description,
+            "state" => "ACTIVE",
+            "datacenter" => {
+              "id" => datacenter_id,
+              "location" => "Spain",
+              "country_code" => "ES"
+            },
+            "type" => "SSL",
+            "ips" => [
+              "10.131.1.45",
+              "10.131.0.45"
+            ],
+            "cloudpanel_id" => "FW99AA4_8",
+            "creation_date" => "30-06-2015T 14:52:35+00.00"
+          }
+
+          # Save mock vpn to vpns list
+          self.data[:vpns] << mock_vpn
+
+          # Return mock response to user
+          response = Excon::Response.new
+          response.status = 202
+          response.body = mock_vpn
+            
+          response
+
+        end
+
+      end # Mock
+
+    end # OneAndOne
+  end # Compute
+end # Fog

data/lib/oneandone/requests/compute/delete_firewall.rb

@@ -0,0 +1,51 @@
+module Fog
+  module Compute
+    class OneAndOne
+
+      class Real
+
+        ##
+        # Delete a firewall policy
+        # URL: [https://cloudpanel-api.1and1.com/documentation/1and1/v1/en/documentation.html#firewall_policies__firewall_id__delete]
+        ##
+        def delete_firewall(firewall_id)
+          
+          params = {
+            'method' => :delete,
+            'endpoint' => "/firewall_policies/#{firewall_id}"
+          }
+
+          request(params)
+
+        end
+
+      end # Real
+
+      
+      class Mock
+
+        def delete_firewall(firewall_id)
+          
+          # Search for firewall to destroy
+          if firewall = self.data[:firewalls].find {
+            |hash| hash['id'] == firewall_id
+          }
+            self.data[:firewalls].delete(firewall)
+          else
+            raise Fog::Errors::NotFound.new('The requested resource could
+              not be found.')
+          end
+
+          # Return Response Object to User
+          response = Excon::Response.new
+          response.status = 202
+          response.body = 'The requested firewall has been deleted.'
+          response
+
+        end
+
+      end # Mock
+
+    end # OneAndOne
+  end # Compute
+end # Fog

data/lib/oneandone/requests/compute/delete_firewall_rule.rb

@@ -0,0 +1,60 @@
+module Fog
+  module Compute
+    class OneAndOne
+
+      class Real
+
+        ##
+        # Delete a firewall policy's rule
+        # URL: [https://cloudpanel-api.1and1.com/documentation/1and1/v1/en/documentation.html#firewall_policies__firewall_id__rules__rule_id__delete]
+        ##
+        def delete_firewall_rule(firewall_id: nil, rule_id: nil)
+          
+          params = {
+            'method' => :delete,
+            'endpoint' => "/firewall_policies/#{firewall_id}/rules/#{rule_id}"
+          }
+
+          request(params)
+
+        end
+
+      end # Real
+
+      
+      class Mock
+
+        def delete_firewall_rule(firewall_id: nil, rule_id: nil)
+          
+          # Search for firewall
+          if firewall = self.data[:firewalls].find {
+            |hash| hash['id'] == firewall_id
+          }
+          else
+            raise Fog::Errors::NotFound.new('The requested resource could
+              not be found.')
+          end
+
+          # Search for rule to destroy
+          if rule = firewall['rules'].find {
+            |index| index['id'] == rule_id
+          }
+            firewall['rules'].delete(rule)
+          else
+            raise Fog::Errors::NotFound.new('The requested rule could
+            not be found.')
+          end
+
+          # Return Response Object to User
+          response = Excon::Response.new
+          response.status = 202
+          response.body = firewall
+          response
+
+        end
+
+      end # Mock
+
+    end # OneAndOne
+  end # Compute
+end # Fog

data/lib/oneandone/requests/compute/delete_hdd.rb

@@ -0,0 +1,61 @@
+module Fog
+  module Compute
+    class OneAndOne
+
+      class Real
+
+        ##
+        # Delete a server's HDD
+        # URL: [https://cloudpanel-api.1and1.com/documentation/1and1/v1/en/documentation.html#servers__server_id__hardware_hdds__hdd_id__delete]
+        ##
+        def delete_hdd(server_id: nil, hdd_id: nil)
+
+          # Request
+          params = {
+            'method' => :delete,
+            'endpoint' => "/servers/#{server_id}/hardware/hdds/#{hdd_id}"
+          }
+
+          request(params)
+
+        end
+
+      end # Real
+
+      
+      class Mock
+
+        def delete_hdd(server_id: nil, hdd_id: nil)
+          
+          # Search for server
+          if server = self.data[:servers].find {
+            |hash| hash['id'] == server_id
+          }
+          else
+            raise Fog::Errors::NotFound.new('The requested resource could
+              not be found.')
+          end
+
+          # Search for hdd to return
+          if hdd = server['hardware']['hdds'].find {
+            |index| index['id'] == hdd_id
+          }
+            server['hardware']['hdds'].delete(hdd)
+          else
+            raise Fog::Errors::NotFound.new('The requested HDD could
+            not be found.')
+          end
+
+          # Return Response Object to User
+          response = Excon::Response.new
+          response.status = 202
+          response.body = server
+          response
+
+        end
+
+      end # Mock
+
+    end # OneAndOne
+  end # Compute
+end # Fog

data/lib/oneandone/requests/compute/delete_image.rb

@@ -0,0 +1,51 @@
+module Fog
+  module Compute
+    class OneAndOne
+
+      class Real
+
+        ##
+        # Delete an image
+        # URL: [https://cloudpanel-api.1and1.com/documentation/1and1/v1/en/documentation.html#images__image_id__delete]
+        ##
+        def delete_image(image_id)
+          
+          params = {
+            'method' => :delete,
+            'endpoint' => "/images/#{image_id}"
+          }
+
+          request(params)
+
+        end
+
+      end # Real
+
+      
+      class Mock
+
+        def delete_image(image_id)
+          
+          # Search for image to delete
+          if image = self.data[:images].find {
+            |hash| hash['id'] == image_id
+          }
+            self.data[:images].delete(image)
+          else
+            raise Fog::Errors::NotFound.new('The requested resource could
+              not be found.')
+          end
+
+          # Return Response Object to User
+          response = Excon::Response.new
+          response.status = 202
+          response.body = 'The requested image has been deleted.'
+          response
+
+        end
+
+      end # Mock
+
+    end # OneAndOne
+  end # Compute
+end # Fog

data/lib/oneandone/requests/compute/delete_load_balancer.rb

@@ -0,0 +1,51 @@
+module Fog
+  module Compute
+    class OneAndOne
+
+      class Real
+
+        ##
+        # Deletes a load balancer
+        # URL: [https://cloudpanel-api.1and1.com/documentation/1and1/v1/en/documentation.html#load_balancers__load_balancer_id__delete]
+        ##
+        def delete_load_balancer(load_balancer_id)
+          
+          params = {
+            'method' => :delete,
+            'endpoint' => "/load_balancers/#{load_balancer_id}"
+          }
+
+          request(params)
+
+        end
+
+      end # Real
+
+      
+      class Mock
+
+        def delete_load_balancer(load_balancer_id)
+          
+          # Search for load balancer to destroy
+          if load_balancer = self.data[:load_balancers].find {
+            |hash| hash['id'] == load_balancer_id
+          }
+            self.data[:load_balancers].delete(load_balancer)
+          else
+            raise Fog::Errors::NotFound.new('The requested resource could
+              not be found.')
+          end
+
+          # Return Response Object to User
+          response = Excon::Response.new
+          response.status = 202
+          response.body = 'The requested load balancer has been deleted.'
+          response
+
+        end
+
+      end # Mock
+
+    end # OneAndOne
+  end # Compute
+end # Fog

data/lib/oneandone/requests/compute/delete_load_balancer_rule.rb

@@ -0,0 +1,60 @@
+module Fog
+  module Compute
+    class OneAndOne
+
+      class Real
+
+        ##
+        # Delete a load balancer's rule
+        # URL: [https://cloudpanel-api.1and1.com/documentation/1and1/v1/en/documentation.html#load_balancers__load_balancer_id__rules__rule_id__delete]
+        ##
+        def delete_load_balancer_rule(load_balancer_id: nil, rule_id: nil)
+          
+          params = {
+            'method' => :delete,
+            'endpoint' => "/load_balancers/#{load_balancer_id}/rules/#{rule_id}"
+          }
+
+          request(params)
+
+        end
+
+      end # Real
+
+      
+      class Mock
+
+        def delete_load_balancer_rule(load_balancer_id: nil, rule_id: nil)
+          
+          # Search for load balancer
+          if load_balancer = self.data[:load_balancers].find {
+            |hash| hash['id'] == load_balancer_id
+          }
+          else
+            raise Fog::Errors::NotFound.new('The requested resource could
+              not be found.')
+          end
+
+          # Search for rule to destroy
+          if rule = load_balancer['rules'].find {
+            |index| index['id'] == rule_id
+          }
+            load_balancer['rules'].delete(rule)
+          else
+            raise Fog::Errors::NotFound.new('The requested rule could
+            not be found.')
+          end
+
+          # Return Response Object to User
+          response = Excon::Response.new
+          response.status = 202
+          response.body = load_balancer
+          response
+
+        end
+
+      end # Mock
+
+    end # OneAndOne
+  end # Compute
+end # Fog