fog-oneandone 1.0

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

@@ -0,0 +1,67 @@
+module Fog
+  module Compute
+    class OneAndOne
+
+      class Real
+
+        ##
+        # Clone a server
+        # URL: [https://cloudpanel-api.1and1.com/documentation/1and1/v1/en/documentation.html#servers__server_id__clone_post]
+        ##
+        def clone_server(server_id: nil, name: nil, datacenter_id: nil)
+          
+          # Build PUT body
+          clone_specs = {
+            'name' => name,
+            'datacenter_id' => datacenter_id
+          }
+
+          # Stringify the PUT body
+          string_body = Fog::JSON.encode(clone_specs)
+
+          # Request
+          params = {
+            'method' => :post,
+            'endpoint' => "/servers/#{server_id}/clone",
+            'body' => string_body
+          }
+
+          request(params)
+
+        end
+
+      end # Real
+
+      
+      class Mock
+
+        def clone_server(server_id: nil, name: nil, datacenter_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
+
+          # Clone server and save to servers list
+          clone = server.dup
+          clone['id'] = Fog::UUID.uuid
+          clone['name'] = name
+          self.data[:servers] << clone
+
+          # Return Response Object to User
+          response = Excon::Response.new
+          response.status = 202
+          response.body = clone
+          response
+
+        end
+
+      end # Mock
+
+    end # OneAndOne
+  end # Compute
+end # Fog

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

@@ -0,0 +1,78 @@
+module Fog
+  module Compute
+    class OneAndOne
+
+      class Real
+
+        ##
+        # Creates a new firewall policy
+        # URL: [https://cloudpanel-api.1and1.com/documentation/1and1/v1/en/documentation.html#firewall_policies_post]
+        ##
+        def create_firewall(name: nil, description: nil, rules: nil)
+
+          # Build POST body
+          new_firewall = {
+            'name' => name,
+            'description' => description,
+            'rules' => rules
+          }
+
+          # Clean out null values from POST body
+          body = clean_hash(new_firewall)
+
+          # Stringify the POST body
+          string_body = Fog::JSON.encode(body)
+
+          # Request
+          params = {
+            'method' => :post,
+            'endpoint' => '/firewall_policies',
+            'body' => string_body
+          }
+
+          request(params)
+
+        end
+
+      end # Real
+
+      
+      class Mock
+
+        def create_firewall(name: nil, description: nil, rules: nil)
+          
+          # Add UUID to rules being passed in
+          rules.each do |rule|
+            rule['id'] = Fog::UUID.uuid
+          end
+
+          # Create mock firewall hash
+          mock_firewall = {
+            "id" => Fog::UUID.uuid,
+            "name" => name,
+            "description" => description,
+            "state" => "ACTIVE",
+            "creation_date" => "2015-04-29T10:43:11+00:00",
+            "default" => 0,
+            "rules" => rules,
+            "server_ips" => [],
+            "cloudpanel_id" => "FW99AA4_7"
+          }
+
+          # Save mock firewall to list
+          self.data[:firewalls] << mock_firewall
+
+          # Return mock response to user
+          response = Excon::Response.new
+          response.status = 202
+          response.body = mock_firewall
+            
+          response
+
+        end
+
+      end # Mock
+
+    end # OneAndOne
+  end # Compute
+end # Fog

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

@@ -0,0 +1,101 @@
+module Fog
+  module Compute
+    class OneAndOne
+
+      class Real
+
+        ##
+        # Creates a new image
+        # URL: [https://cloudpanel-api.1and1.com/documentation/1and1/v1/en/documentation.html#images_post]
+        ##
+        def create_image(server_id: nil, name: nil, description: nil,
+          frequency: nil, num_images: nil)
+
+          # Build POST body
+          new_image = {
+            'server_id' => server_id,
+            'name' => name,
+            'description' => description,
+            'frequency' => frequency,
+            'num_images' => num_images
+          }
+
+          # Clean out null values from POST body
+          body = clean_hash(new_image)
+
+          # Stringify the POST body
+          string_body = Fog::JSON.encode(body)
+
+          # Request
+          params = {
+            'method' => :post,
+            'endpoint' => '/images',
+            'body' => string_body
+          }
+
+          request(params)
+
+        end
+
+      end # Real
+
+      
+      class Mock
+
+        def create_image(server_id: nil, name: nil, description: nil,
+          frequency: nil, num_images: nil)
+          
+          # Create mock image hash
+          mock_image = {
+            "id" => Fog::UUID.uuid,
+            "name" => name,
+            "datacenter" => {
+              "id" => "D0F6D8C8ED29D3036F94C27BBB7BAD36",
+              "location" => "USA",
+              "country_code" => "US"
+            },
+            "os_family" => "Windows",
+            "os" => "WindowsDatacenter",
+            "os_version" => "Windows2012R2",
+            "architecture" => 64,
+            "os_image_type" => "Personal",
+            "type" => "MY_IMAGE",
+            "min_hdd_size" => 40,
+            "licenses" => [
+            {
+              "name" => "Windows 2012 Standard"
+            }
+            ],
+            "cloudpanel_id" => "ap8962D_253",
+            "state" => "ENABLED",
+            "description" => description,
+            "hdds" => [
+            {
+              "id" => "D0289C1FDF48628FE53335470EEC05DB",
+              "size" => 40,
+              "is_main" => true
+            }
+            ],
+            "server_id" => server_id,
+            "frequency" => frequency,
+            "num_images" => num_images,
+            "creation_date" => "2015-05-06T08:04:41+00:00"
+          }
+
+          # Save mock image to images list
+          self.data[:images] << mock_image
+
+          # Return mock response to user
+          response = Excon::Response.new
+          response.status = 202
+          response.body = mock_image
+            
+          response
+
+        end
+
+      end # Mock
+
+    end # OneAndOne
+  end # Compute
+end # Fog

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

@@ -0,0 +1,104 @@
+module Fog
+  module Compute
+    class OneAndOne
+
+      class Real
+
+        ##
+        # Create a new load balancer
+        # URL: [https://cloudpanel-api.1and1.com/documentation/1and1/v1/en/documentation.html#load_balancers_post]
+        ##
+        def create_load_balancer(name: nil, description: nil,
+          health_check_test: nil, health_check_interval: nil, persistence: nil,
+          persistence_time: nil, method: nil, rules: nil,
+          health_check_path: nil, health_check_parse: nil, datacenter_id: nil)
+
+          # Build POST body
+          new_load_balancer = {
+            'name' => name,
+            'description' => description,
+            'health_check_test' => health_check_test,
+            'health_check_interval' => health_check_interval,
+            'persistence' => persistence,
+            'persistence_time' => persistence_time,
+            'method' => method,
+            'rules' => rules,
+            'health_check_path' => health_check_path,
+            'health_check_parse' => health_check_parse,
+            'datacenter_id' => datacenter_id
+          }
+
+          # Clean out null keys in POST body
+          body = clean_hash(new_load_balancer)
+
+          # Stringify the POST body
+          string_body = Fog::JSON.encode(body)
+
+          # Request
+          params = {
+            'method' => :post,
+            'endpoint' => '/load_balancers',
+            'body' => string_body
+          }
+
+          request(params)
+
+        end
+
+      end # Real
+
+      
+      class Mock
+
+        def create_load_balancer(name: nil, description: nil,
+          health_check_test: nil, health_check_interval: nil, persistence: nil,
+          persistence_time: nil, method: nil, rules: nil,
+          health_check_path: nil, health_check_parse: nil, datacenter_id: nil)
+          
+          # Add UUID to rules being passed in
+          rules.each do |rule|
+            rule['id'] = Fog::UUID.uuid
+          end
+
+          # Create mock load balancer hash
+          mock_load_balancer = {
+            "id" => Fog::UUID.uuid,
+            "name" => name,
+            "state" => "ACTIVE",
+            "creation_date" => "2015-05-04T07:26:24+00:00",
+            "description" => description,
+            "ip" => nil,
+            "health_check_test" => health_check_test,
+            "health_check_interval" => health_check_interval,
+            "health_check_path" => health_check_path,
+            "health_check_path_parser" => health_check_parse,
+            "persistence" => persistence,
+            "persistence_time" => persistence_time,
+            "method" => method,
+            "datacenter" => {
+              "id" => datacenter_id,
+              "location" => "USA",
+              "country_code" => "US"
+            },
+            "rules" => rules,
+            "server_ips" => [],
+            "cloudpanel_id" => "LB99AA4_1"
+          }
+
+          # Save mock load balancer to list
+          self.data[:load_balancers] << mock_load_balancer
+
+          # Return mock response to user
+          response = Excon::Response.new
+          response.status = 202
+          response.body = mock_load_balancer
+            
+          response
+
+        end
+
+      end # Mock
+
+    end # OneAndOne
+  end # Compute
+end # Fog

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

@@ -0,0 +1,93 @@
+module Fog
+  module Compute
+    class OneAndOne
+
+      class Real
+
+        ##
+        # Creates a new monitoring policy
+        # URL: [https://cloudpanel-api.1and1.com/documentation/1and1/v1/en/documentation.html#monitoring_policies_post]
+        ##
+        def create_monitoring_policy(name: nil, description: nil, email: nil,
+          agent: nil, thresholds: nil, ports: nil, processes: nil)
+
+          # Build POST body
+          new_monitoring_policy = {
+            'name' => name,
+            'description' => description,
+            'email' => email,
+            'agent' => agent,
+            'thresholds' => thresholds,
+            'ports' => ports,
+            'processes' => processes
+          }
+
+          # Clean out null keys in POST body
+          body = clean_hash(new_monitoring_policy)
+
+          # Stringify the POST body
+          string_body = Fog::JSON.encode(body)
+
+          # Request
+          params = {
+            'method' => :post,
+            'endpoint' => '/monitoring_policies',
+            'body' => string_body
+          }
+
+          request(params)
+
+        end
+
+      end # Real
+
+      
+      class Mock
+
+        def create_monitoring_policy(name: nil, description: nil, email: nil,
+          agent: nil, thresholds: nil, ports: nil, processes: nil)
+          
+          # Add UUID to ports being passed in
+          ports.each do |port|
+            port['id'] = Fog::UUID.uuid
+          end
+
+          # Add UUID to processes being passed in
+          processes.each do |process|
+            process['id'] = Fog::UUID.uuid
+          end
+
+          # Create mock monitoring policy hash
+          mock_monitoring_policy = {
+            "id" => Fog::UUID.uuid,
+            "name" => name,
+            "description" => description,
+            "default" => 0,
+            "state" => "ACTIVE",
+            "creation_date" => "2015-05-07T07:34:41+00:00",
+            "email" => email,
+            "agent" => agent,
+            "servers" => [],
+            "thresholds" => thresholds,
+            "ports" => ports,
+            "processes" => processes,
+            "cloudpanel_id" => "mo8962D_3"
+          }
+
+          # Save mock monitoring policy to list
+          self.data[:monitoring_policies] << mock_monitoring_policy
+
+          # Return mock response to user
+          response = Excon::Response.new
+          response.status = 202
+          response.body = mock_monitoring_policy
+            
+          response
+
+        end
+
+      end # Mock
+
+    end # OneAndOne
+  end # Compute
+end # Fog

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

@@ -0,0 +1,82 @@
+module Fog
+  module Compute
+    class OneAndOne
+
+      class Real
+
+        ##
+        # Create a new private network
+        # URL: [https://cloudpanel-api.1and1.com/documentation/1and1/v1/en/documentation.html#private_networks_post]
+        ##
+        def create_private_network(name: nil, description: nil,
+          network_address: nil, subnet_mask: nil, datacenter_id: nil)
+          
+          # Build POST body
+          new_private_network = {
+            'name' => name,
+            'description' => description,
+            'network_address' => network_address,
+            'subnet_mask' => subnet_mask,
+            'datacenter_id' => datacenter_id
+          }
+
+          # Clean out null keys in POST body
+          body = clean_hash(new_private_network)
+
+          # Stringify the POST body
+          string_body = Fog::JSON.encode(body)
+
+          # Request
+          params = {
+            'method' => :post,
+            'endpoint' => '/private_networks',
+            'body' => string_body
+          }
+
+          request(params)
+
+        end
+
+      end # Real
+
+      
+      class Mock
+
+        def create_private_network(name: nil, description: nil,
+          network_address: nil, subnet_mask: nil, datacenter_id: nil)
+          
+          # Create mock private network hash
+          mock_private_network = {
+            "id" => Fog::UUID.uuid,
+            "name" => name,
+            "description" => description,
+            "datacenter" => {
+              "id" => datacenter_id,
+              "location" => "USA",
+              "country_code" => "US"
+            },
+            "network_address" => network_address,
+            "subnet_mask" => subnet_mask,
+            "state" => "ACTIVE",
+            "creation_date" => "2015-05-04T08:35:12+00:00",
+            "servers" => [],
+            "cloudpanel_id" => "pn99AA4_2"
+          }
+
+          # Save mock private network to list
+          self.data[:private_networks] << mock_private_network
+
+          # Return mock response to user
+          response = Excon::Response.new
+          response.status = 202
+          response.body = mock_private_network
+            
+          response
+
+        end
+
+      end # Mock
+
+    end # OneAndOne
+  end # Compute
+end # Fog

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

@@ -0,0 +1,77 @@
+module Fog
+  module Compute
+    class OneAndOne
+
+      class Real
+
+        ##
+        # Create a new public IP
+        # URL: [https://cloudpanel-api.1and1.com/documentation/1and1/v1/en/documentation.html#public_ips_post]
+        ##
+        def create_public_ip(reverse_dns: nil, type: nil, datacenter_id: nil)
+          
+          # Build POST body
+          new_ip = {
+            'reverse_dns' => reverse_dns,
+            'type' => type,
+            'datacenter_id' => datacenter_id
+          }
+
+          # Clean out null keys in POST body
+          body = clean_hash(new_ip)
+
+          # Stringify the POST body
+          string_body = Fog::JSON.encode(body)
+
+          # Request
+          params = {
+            'method' => :post,
+            'endpoint' => '/public_ips',
+            'body' => string_body
+          }
+
+          request(params)
+
+        end
+
+      end # Real
+
+      
+      class Mock
+
+        def create_public_ip(reverse_dns: nil, type: nil, datacenter_id: nil)
+          
+          # Create mock public ip hash
+          mock_public_ip = {
+            "id" => Fog::UUID.uuid,
+            "ip" => "10.4.140.155",
+            "type" => type,
+            "datacenter" => {
+              "id" => datacenter_id,
+              "location" => "USA",
+              "country_code" => "US"
+            },
+            "assigned_to" => nil,
+            "reverse_dns" => reverse_dns,
+            "is_dhcp" => false,
+            "state" => "ACTIVE",
+            "creation_date" => "2015-05-06T08:17:33+00:00"
+          }
+
+          # Save mock public ip to list
+          self.data[:public_ips] << mock_public_ip
+
+          # Return mock response to user
+          response = Excon::Response.new
+          response.status = 202
+          response.body = mock_public_ip
+            
+          response
+
+        end
+
+      end # Mock
+
+    end # OneAndOne
+  end # Compute
+end # Fog