class Fog::Compute::OneAndOne::Mock

Public Class Methods

data() click to toggle source
# File lib/oneandone/compute.rb, line 307
def self.data
  
  @data ||= Hash.new do |hash, key|
    hash[key] = {
      :servers  => [],
      :images  => [],
      :shared_storages  => [],
      :firewalls  => [],
      :load_balancers  => [],
      :public_ips  => [],
      :private_networks  => [],
      :monitoring_policies  => [],
      :vpns => [],
      :ssh_keys => [],
      :block_storages => [],
      :baremetal_models  => [
        {
          "name" => "baremetal_1_name",
          "id" => "8C626C1A7005D0D1F527143C413D461E",
          "hardware" => {
            "cores" => 1,
            "cores_per_processor" => 4,
            "ram" => 16,
            "unit" => "GB",
            "hdds" => [
              {
                "size" => 480,
                "unit" => "GB",
                "is_main" => true
              }
            ]
          }
        },
        {
          "name" => "baremetal_2_name",
          "id" => "8C626C1A7005D0D1F5271434563D461A",
          "hardware" => {
            "cores" => 1,
            "cores_per_processor" => 4,
            "ram" => 64,
            "unit" => "GB",
            "hdds" => [
              {
                "size" => 800,
                "unit" => "GB",
                "is_main" => true
              }
            ]
          }
        }
      ],
      :datacenters => [
        {
          "id" => "81DEF28500FBC2A973FC0C620DF5B721",
          "location" => "Spain",
          "country_code" => "ES"
        },
        {
          "id" => "908DC2072407C94C8054610AD5A53B8C",
          "location" => "United States of America",
          "country_code" => "US"
        },
        {
          "id" => "4EFAD5836CE43ACA502FD5B99BEE44EF",
          "location" => "Germany",
          "country_code" => "DE"
        },
        {
          "id" => "5091F6D8CBFEF9C26ACE957C652D5D49",
          "location" => "United Kingdom of Great Britain and Northern Ireland",
          "country_code" => "GB"
        }
      ],
      :fixed_servers => [
        {
          "name" => "M",
          "id" => "8C626C1A7005D0D1F527143C413D461E",
          "hardware" => {
            "vcore" => 1,
            "cores_per_processor" => 1,
            "ram" => 1,
            "unit" => "GB",
            "hdds" => [
            {
              "size" => 40,
              "unit" => "GB",
              "is_main" => true
            }
            ]
          }
        },
        {
          "name" => "L",
          "id" => "8C626C1A7005D0D1F527143C413D461F",
          "hardware" => {
            "vcore" => 2,
            "cores_per_processor" => 1,
            "ram" => 2,
            "unit" => "GB",
            "hdds" => [
            {
              "size" => 80,
              "unit" => "GiB",
              "is_main" => true
            }
            ]
          }
        },
        {
          "name" => "XL",
          "id" => "8C626C1A7005D0D1F527143C413D4620",
          "hardware" => {
            "vcore" => 2,
            "cores_per_processor" => 1,
            "ram" => 4,
            "unit" => "GB",
            "hdds" => [
            {
              "size" => 120,
              "unit" => "GB",
              "is_main" => true
            }
            ]
          }
        },
        {
          "name" => "XXL",
          "id" => "8C626C1A7005D0D1F527143C413D4621",
          "hardware" => {
            "vcore" => 4,
            "cores_per_processor" => 1,
            "ram" => 8,
            "unit" => "GB",
            "hdds" => [
            {
              "size" => 160,
              "unit" => "GiB",
              "is_main" => true
            }
            ]
          }
        }
      ],
      :logs => [
        {
          "id" => "E485755233541090E369E957EA2499D7",
          "start_date" => "2015-04-06T23:46:38Z",
          "end_date" => "2015-04-06T23:48:52Z",
          "duration" => 72,
          "status" => {
            "state" => "COMPLETED",
            "percent" => 100
          },
          "action" => "DELETE",
          "type" => "MONITORINGPOLICY",
          "resource" => {
            "id" => "E485755233541090E6546957EA2499D7",
            "name" => "My Monitoring Policy 1"
          },
          "details" => {
            
          },
          "user" => {
            "id" => "7C88E50FBC500A3D9D7F94E414255D6B",
            "name" => "034b011e.user"
          },
          "cloudpanel_id" => "ap99AA4_1"
        },
        {
          "id" => "E485755233541090E369E957EA2499D8",
          "start_date" => "2015-04-06T23:51:00Z",
          "end_date" => "2015-04-06T23:51:29Z",
          "duration" => 29,
          "status" => {
            "state" => "COMPLETED",
            "percent" => 100
          },
          "action" => "CREATE",
          "type" => "MONITORINGPOLICY",
          "resource" => {
            "id" => "E485755233541090E6546957EA2499D7",
            "name" => "My Monitoring Policy test"
          },
          "details" => {
            
          },
          "user" => {
            "id" => "7C88E50FBC500A3D9D7F94E414255D6B",
            "name" => "034b011e.user"
          }
        }
      ],
      :server_appliances => [
        {
          "id" => "55726DEDA20C99CF6F2AF8F18CAC9963",
          "name" => "w2012r2datacenter64iso",
          "available_datacenters" => [
          "DA41201B4A006EDE6DA62A5A62A658E7",
          "47FA5A2D251AE57935E30F9D5AB4F817",
          "7C5FA1D21B98DE39D7516333AAB7DA54"
          ],
          "os_installation_base" => "ISO_OS",
          "os_family" => "Windows",
          "os" => "WindowsDatacenter",
          "os_version" => "Windows2012R2",
          "min_hdd_size" => 40,
          "os_architecture" => 64,
          "licenses" => nil,
          "type" => "ISO",
          "version" => nil,
          "categories" => [],
          "eula_url" => nil
        },
        {
          "id" => "81504C620D98BCEBAA5202D145203B4C",
          "name" => "Windows 2008R2 - 64 bits (Standard) + SQL Server 2012 (Standard)",
          "available_datacenters" => [
          "DA41201B4A006EDE6DA62A5A62A658E7",
          "47FA5A2D251AE57935E30F9D5AB4F817",
          "7C5FA1D21B98DE39D7516333AAB7DA54"
          ],
          "os_installation_base" => "Standard",
          "os_family" => "Windows",
          "os" => "Windows",
          "os_version" => "Windows 2008R2",
          "min_hdd_size" => 40,
          "os_architecture" => 64,
          "licenses" =>[
          "Windows",
          "SQL Server"
          ],
          "type" => "IMAGE", 
          "version" => nil,
          "categories" => [],
          "eula_url" => nil
        }
      ],
      :dvd_isos => [
        {
          "id" => "55726DEDA20C99CF6F2AF8F18CAC9963",
          "name" => "w2012r2datacenter64iso",
          "available_datacenters" => [
          "DA41201B4A006EDE6DA62A5A62A658E7",
          "47FA5A2D251AE57935E30F9D5AB4F817",
          "7C5FA1D21B98DE39D7516333AAB7DA54"
          ],
          "os_family" => "Windows",
          "os" => "WindowsDatacenter",
          "os_version" => "Windows2012R2",
          "os_architecture" => 64,
          "type" => "OS"
        },
        {
          "id" => "B675B070A3BB5C8D71B2129952F04BC8",
          "name" => "ubuntu1404-64iso",
          "available_datacenters" => [
          "DA41201B4A006EDE6DA62A5A62A658E7",
          "47FA5A2D251AE57935E30F9D5AB4F817",
          "7C5FA1D21B98DE39D7516333AAB7DA54"
          ],
          "os_family" => "Linux",
          "os" => "Ubuntu",
          "os_version" => "Ubuntu14.04",
          "os_architecture" => 64,
          "type" => "OS"
        },
        {
          "id" => "F9DCFAF16B4929D9F9AE6B24B125EC17",
          "name" => "centos6-32iso",
          "available_datacenters" => [
          "DA41201B4A006EDE6DA62A5A62A658E7",
          "47FA5A2D251AE57935E30F9D5AB4F817",
          "7C5FA1D21B98DE39D7516333AAB7DA54"
          ],
          "os_family" => "Linux",
          "os" => "Centos",
          "os_version" => "Centos6",
          "os_architecture" => 32,
          "type" => "OS"
        },
        {
          "id" => "3E04654E0DA19EE6A3699272D4114AFA",
          "name" => "centos6-64iso",
          "available_datacenters" => [
          "DA41201B4A006EDE6DA62A5A62A658E7",
          "47FA5A2D251AE57935E30F9D5AB4F817",
          "7C5FA1D21B98DE39D7516333AAB7DA54"
          ],
          "os_family" => "Linux",
          "os" => "Centos",
          "os_version" => "Centos6",
          "os_architecture" => 64,
          "type" => "OS"
        },
        {
          "id" => "8F8CBE2DAB9FF6F0F9A4D846E82DD651",
          "name" => "rhel6-64iso",
          "available_datacenters" => [
          "DA41201B4A006EDE6DA62A5A62A658E7",
          "47FA5A2D251AE57935E30F9D5AB4F817",
          "7C5FA1D21B98DE39D7516333AAB7DA54"
          ],
          "os_family" => "Linux",
          "os" => "RedHat",
          "os_version" => "RedHat6",
          "os_architecture" => 64,
          "type" => "OS"
        },
        {
          "id" => "B62716F09C314B46D6782EA385E27206",
          "name" => "centos7-64iso",
          "available_datacenters" => [
          "DA41201B4A006EDE6DA62A5A62A658E7",
          "47FA5A2D251AE57935E30F9D5AB4F817",
          "7C5FA1D21B98DE39D7516333AAB7DA54"
          ],
          "os_family" => "Linux",
          "os" => "Centos",
          "os_version" => "Centos7",
          "os_architecture" => 64,
          "type" => "OS"
        },
        {
          "id" => "AE54D0EE48B1F6E59021FAA63988274B",
          "name" => "debian6-64iso",
          "available_datacenters" => [
          "DA41201B4A006EDE6DA62A5A62A658E7",
          "47FA5A2D251AE57935E30F9D5AB4F817",
          "7C5FA1D21B98DE39D7516333AAB7DA54"
          ],
          "os_family" => "Linux",
          "os" => "Debian",
          "os_version" => "Debian6",
          "os_architecture" => 64,
          "type" => "OS"
        },
        {
          "id" => "AA70C76B77BC6132117DCA202D34A5A4",
          "name" => "debian6-32iso",
          "available_datacenters" => [
          "DA41201B4A006EDE6DA62A5A62A658E7",
          "47FA5A2D251AE57935E30F9D5AB4F817",
          "7C5FA1D21B98DE39D7516333AAB7DA54"
          ],
          "os_family" => "Linux",
          "os" => "Debian",
          "os_version" => "Debian6",
          "os_architecture" => 32,
          "type" => "OS"
        },
        {
          "id" => "4001EE28F2E195BD4D2D44844FAC9591",
          "name" => "debian7-64iso",
          "available_datacenters" => [
          "DA41201B4A006EDE6DA62A5A62A658E7",
          "47FA5A2D251AE57935E30F9D5AB4F817",
          "7C5FA1D21B98DE39D7516333AAB7DA54"
          ],
          "os_family" => "Linux",
          "os" => "Debian",
          "os_version" => "Debian7",
          "os_architecture" => 64,
          "type" => "OS"
        },
        {
          "id" => "B1A2D93BE081873BF127C9B9200849D8",
          "name" => "debian7-32iso",
          "available_datacenters" => [
          "DA41201B4A006EDE6DA62A5A62A658E7",
          "47FA5A2D251AE57935E30F9D5AB4F817",
          "7C5FA1D21B98DE39D7516333AAB7DA54"
          ],
          "os_family" => "Linux",
          "os" => "Debian",
          "os_version" => "Debian7",
          "os_architecture" => 32,
          "type" => "OS"
        },
        {
          "id" => "DC0886301FA0BFDD8BA21F3E9FDFC012",
          "name" => "freebsd10-64iso",
          "available_datacenters" => [
          "DA41201B4A006EDE6DA62A5A62A658E7",
          "47FA5A2D251AE57935E30F9D5AB4F817",
          "7C5FA1D21B98DE39D7516333AAB7DA54"
          ],
          "os_family" => "Linux",
          "os" => "FreeBSD",
          "os_version" => "FreeBSD10",
          "os_architecture" => 64,
          "type" => "OS"
        },
        {
          "id" => "369A148192AAD04C83FEC050F9072C76",
          "name" => "freebsd10-32iso",
          "available_datacenters" => [
          "DA41201B4A006EDE6DA62A5A62A658E7",
          "47FA5A2D251AE57935E30F9D5AB4F817",
          "7C5FA1D21B98DE39D7516333AAB7DA54"
          ],
          "os_family" => "Linux",
          "os" => "FreeBSD",
          "os_version" => "FreeBSD10",
          "os_architecture" => 32,
          "type" => "OS"
        },
        {
          "id" => "9F3A97E35D7C182EE7B871B7FBFEBBDC",
          "name" => "rhel7-64iso",
          "available_datacenters" => [
          "DA41201B4A006EDE6DA62A5A62A658E7",
          "47FA5A2D251AE57935E30F9D5AB4F817",
          "7C5FA1D21B98DE39D7516333AAB7DA54"
          ],
          "os_family" => "Linux",
          "os" => "RedHat",
          "os_version" => "RedHat7",
          "os_architecture" => 64,
          "type" => "OS"
        },
        {
          "id" => "FEF6DB2420612426911F2F9CA9E25755",
          "name" => "w2008r2datacenter64iso",
          "available_datacenters" => [
          "DA41201B4A006EDE6DA62A5A62A658E7",
          "47FA5A2D251AE57935E30F9D5AB4F817",
          "7C5FA1D21B98DE39D7516333AAB7DA54"
          ],
          "os_family" => "Windows",
          "os" => "WindowsDatacenter",
          "os_version" => "Windows2008R2",
          "os_architecture" => 64,
          "type" => "OS"
        }
      ],
      :recovery_appliances => [
        {
          "id" => "81504C620D98BCEBAA5202D145203B4B",
          "name" => "Recovery image name",
          "available_datacenters" => [
            "DA41201B4A006EDE6DA62A5A62A658E7",
            "47FA5A2D251AE57935E30F9D5AB4F817",
            "7C5FA1D21B98DE39D7516333AAB7DA54"
          ],
          "os_family" => "Linux",
          "os" => "CentOS",
          "os_version" => "CentOS 7",
          "architecture" => 64
        },
        {
          "id" => "81504C620D98BCEB5646987545203B42",
          "name" => "Recovery image name",
          "available_datacenters" => [
            "DA41201B4A006EDE6DA62A5A62A658E7",
            "47FA5A2D251AE57935E30F9D5AB4F817",
            "7C5FA1D21B98DE39D7516333AAB7DA54"
          ],
          "os_family" => "Windows",
          "os" => "Windows",
          "os_version" => "Windows 2012",
          "architecture" => 64
        }
      ]
    }
  end

end
new(options={}) click to toggle source
# File lib/oneandone/compute.rb, line 776
def initialize(options={})
  
  @oneandone_api_key = options[:oneandone_api_key]

end

Public Instance Methods

access() click to toggle source
# File lib/oneandone/requests/compute/access.rb, line 27
def access
  Fog::Mock.not_implemented
end
add_block_storage_server(block_storage_id: nil, server_id: nil) click to toggle source
# File lib/oneandone/requests/compute/add_block_storage_server.rb, line 37
def add_block_storage_server(block_storage_id: nil, server_id: nil)
  
  # Search for block storage to return
  if block_storage = self.data[:block_storages].find {
    |hash| hash['id'] == block_storage_id
  }
    block_storage['server'] << {"id" => server_id}
  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 = block_storage
  response

end
add_firewall(server_id: nil, ip_id: nil, firewall_id: nil) click to toggle source
# File lib/oneandone/requests/compute/add_firewall.rb, line 37
def add_firewall(server_id: nil, ip_id: nil, firewall_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 IP to return
  if ip = server['ips'].find {
    |index| index['id'] == ip_id
  }
    ip['firewall_policy']['id'] = firewall_id
  else
    raise Fog::Errors::NotFound.new('The requested server IP could
    not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 202
  response.body = server
  response

end
add_firewall_ips(firewall_id: nil, ips: nil) click to toggle source
# File lib/oneandone/requests/compute/add_firewall_ips.rb, line 40
def add_firewall_ips(firewall_id: nil, ips: nil)
  
  # Search for firewall to return
  if firewall = self.data[:firewalls].find {
    |hash| hash['id'] == firewall_id
  }
    # Add server IPs
    ips.each do |ip|
      firewall['server_ips'] << ip
    end
  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 = firewall
  response

end
add_firewall_rules(firewall_id: nil, rules: nil) click to toggle source
# File lib/oneandone/requests/compute/add_firewall_rules.rb, line 40
def add_firewall_rules(firewall_id: nil, rules: nil)
  
  # Search for firewall to return
  if firewall = self.data[:firewalls].find {
    |hash| hash['id'] == firewall_id
  }
    # Add rules
    rules.each do |rule|
      rule['id'] = Fog::UUID.uuid
      firewall['rules'] << rule
    end
  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 = firewall
  response

end
add_hdds(server_id: nil, hdds: nil) click to toggle source
# File lib/oneandone/requests/compute/add_hdds.rb, line 37
def add_hdds(server_id: nil, hdds: nil)
  
  # Search for server to return
  if server = self.data[:servers].find {
    |hash| hash['id'] == server_id
  }
    # Add hdds
    hdds.each do |hdd|
      hdd['id'] = Fog::UUID.uuid
      server['hardware']['hdds'] << hdd
    end
  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
add_load_balancer(server_id: nil, ip_id: nil, load_balancer_id: nil) click to toggle source
# File lib/oneandone/requests/compute/add_load_balancer.rb, line 38
def add_load_balancer(server_id: nil, ip_id: nil,
  load_balancer_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 IP to return
  if ip = server['ips'].find {
    |index| index['id'] == ip_id
  }
    load_balancer = {
      'id' => load_balancer_id
    }

    ip['load_balancers'] << load_balancer
  else
    raise Fog::Errors::NotFound.new('The requested server IP could
    not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 202
  response.body = server
  response

end
add_load_balancer_ips(load_balancer_id: nil, ips: nil) click to toggle source
# File lib/oneandone/requests/compute/add_load_balancer_ips.rb, line 40
def add_load_balancer_ips(load_balancer_id: nil, ips: nil)
  
  # Search for load balancer to return
  if load_balancer = self.data[:load_balancers].find {
    |hash| hash['id'] == load_balancer_id
  }
    # Add server IPs
    ips.each do |ip|
      load_balancer['server_ips'] << ip
    end
  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 = load_balancer
  response

end
add_load_balancer_rules(load_balancer_id: nil, rules: nil) click to toggle source
# File lib/oneandone/requests/compute/add_load_balancer_rules.rb, line 40
def add_load_balancer_rules(load_balancer_id: nil, rules: nil)
  
  # Search for load balancer to return
  if load_balancer = self.data[:load_balancers].find {
    |hash| hash['id'] == load_balancer_id
  }
    # Add rules
    rules.each do |rule|
      rule['id'] = Fog::UUID.uuid
      load_balancer['rules'] << rule
    end
  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 = load_balancer
  response

end
add_mp_servers(monitoring_policy_id: nil, servers: nil) click to toggle source
# File lib/oneandone/requests/compute/add_mp_servers.rb, line 37
def add_mp_servers(monitoring_policy_id: nil, servers: nil)
  
  # Search for MP to return
  if monitoring_policy = self.data[:monitoring_policies].find {
    |hash| hash['id'] == monitoring_policy_id
  }
    # Add servers
    servers.each do |server|
      monitoring_policy['servers'] << server
    end
  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 = monitoring_policy
  response

end
add_ports(monitoring_policy_id: nil, ports: nil) click to toggle source
# File lib/oneandone/requests/compute/add_ports.rb, line 37
def add_ports(monitoring_policy_id: nil, ports: nil)
  
  # Search for MP to return
  if monitoring_policy = self.data[:monitoring_policies].find {
    |hash| hash['id'] == monitoring_policy_id
  }
    # Add ports
    ports.each do |port|
      port['id'] = Fog::UUID.uuid
      monitoring_policy['ports'] << port
    end
  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 = monitoring_policy
  response

end
add_private_network(server_id: nil, private_network_id: nil) click to toggle source
# File lib/oneandone/requests/compute/add_private_network.rb, line 37
def add_private_network(server_id: nil, private_network_id: nil)
  
  # Search for server
  if server = self.data[:servers].find {
    |hash| hash['id'] == server_id
  }
    private_network = {
      'id' => private_network_id
    }

    server['private_networks'] << private_network
  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
add_private_network_servers(private_network_id: nil, servers: nil) click to toggle source
# File lib/oneandone/requests/compute/add_private_network_servers.rb, line 40
def add_private_network_servers(private_network_id: nil, servers: nil)
  
  # Search for private network to return
  if private_network = self.data[:private_networks].find {
    |hash| hash['id'] == private_network_id
  }
    # Add servers
    servers.each do |server|
      private_network['servers'] << server
    end
  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 = private_network
  response

end
add_processes(monitoring_policy_id: nil, processes: nil) click to toggle source
# File lib/oneandone/requests/compute/add_processes.rb, line 37
def add_processes(monitoring_policy_id: nil, processes: nil)
  
  # Search for MP to return
  if monitoring_policy = self.data[:monitoring_policies].find {
    |hash| hash['id'] == monitoring_policy_id
  }
    # Add processes
    processes.each do |process|
      process['id'] = Fog::UUID.uuid
      monitoring_policy['processes'] << process
    end
  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 = monitoring_policy
  response

end
add_server_ip(server_id: nil, type: nil) click to toggle source
# File lib/oneandone/requests/compute/add_server_ip.rb, line 40
def add_server_ip(server_id: nil, type: nil)
  
  # Search for server to return
  if server = self.data[:servers].find {
    |hash| hash['id'] == server_id
  }
    # Add IP
    new_ip = {
      'id' => Fog::UUID.uuid,
      'type' => type,
      'firewall_policy' => {},
      'load_balancers' => []
    }

    server['ips'] << new_ip
  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
add_shared_storage_servers(shared_storage_id: nil, servers: nil) click to toggle source
# File lib/oneandone/requests/compute/add_shared_storage_servers.rb, line 37
def add_shared_storage_servers(shared_storage_id: nil, servers: nil)
  
  # Search for shared storage to return
  if shared_storage = self.data[:shared_storages].find {
    |hash| hash['id'] == shared_storage_id
  }
    # Add servers
    servers.each do |server|
      shared_storage['servers'] << server
    end
  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 = shared_storage
  response

end
change_password(password) click to toggle source
# File lib/oneandone/requests/compute/change_password.rb, line 37
def change_password(password)
  Fog::Mock.not_implemented
end
change_status(server_id: nil, action: nil, method: nil) click to toggle source
# File lib/oneandone/requests/compute/change_status.rb, line 38
def change_status(server_id: nil, action: nil, method: nil)
  
  # Search for server
  if server = self.data[:servers].find {
    |hash| hash['id'] == server_id
  }
    if action == 'POWER_ON'
      server['status']['state'] = 'POWERED_ON'
    elsif action == 'POWER_OFF'
      server['status']['state'] = 'POWERED_OFF'
    elsif action == 'REBOOT'
      sleep 3
      server['status']['state'] = 'POWERED_ON'
    end
  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
clone_server(server_id: nil, name: nil, datacenter_id: nil) click to toggle source
# File lib/oneandone/requests/compute/clone_server.rb, line 38
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
create_block_storage(name: nil, description: nil, size: nil, datacenter_id: nil, server_id: nil) click to toggle source
# File lib/oneandone/requests/compute/create_block_storage.rb, line 45
def create_block_storage(name: nil, description: nil,
  size: nil, datacenter_id: nil, server_id: nil)
  
  # Create mock block storage hash
  mock_block_storage = {
    "id" => Fog::UUID.uuid,
    "size" => size,
    "state" => "ACTIVE",
    "description" => description,
    "datacenter" => {
      "id" => datacenter_id,
      "location" => "USA",
      "country_code" => "US"
    },
    "name" => name,
    "creation_date" => "2018-01-06T08:33:25+00:00",
    "server" => server_id
  }

  # Save mock block storage to list
  self.data[:block_storages] << mock_block_storage

  # Return mock response to user
  response = Excon::Response.new
  response.status = 202
  response.body = mock_block_storage
    
  response

end
create_firewall(name: nil, description: nil, rules: nil) click to toggle source
# File lib/oneandone/requests/compute/create_firewall.rb, line 42
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
create_image(server_id: nil, name: nil, description: nil, frequency: nil, num_images: nil, source: nil, url: nil, os_id: nil, type: nil) click to toggle source
# File lib/oneandone/requests/compute/create_image.rb, line 50
def create_image(server_id: nil, name: nil, description: nil,
  frequency: nil, num_images: nil, source: nil, url: nil,
  os_id: nil, type: 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
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) click to toggle source
# File lib/oneandone/requests/compute/create_load_balancer.rb, line 53
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
create_monitoring_policy(name: nil, description: nil, email: nil, agent: nil, thresholds: nil, ports: nil, processes: nil) click to toggle source
# File lib/oneandone/requests/compute/create_monitoring_policy.rb, line 47
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
create_private_network(name: nil, description: nil, network_address: nil, subnet_mask: nil, datacenter_id: nil) click to toggle source
# File lib/oneandone/requests/compute/create_private_network.rb, line 45
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
create_public_ip(reverse_dns: nil, type: nil, datacenter_id: nil) click to toggle source
# File lib/oneandone/requests/compute/create_public_ip.rb, line 42
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
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, public_key: nil, server_type: nil, baremetal_model_id: nil) click to toggle source
# File lib/oneandone/requests/compute/create_server.rb, line 72
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, public_key: nil,
  server_type: nil, baremetal_model_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
create_shared_storage(name: nil, description: nil, size: nil, datacenter_id: nil) click to toggle source
# File lib/oneandone/requests/compute/create_shared_storage.rb, line 44
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
create_snapshot(server_id) click to toggle source
# File lib/oneandone/requests/compute/create_snapshot.rb, line 27
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
create_ssh_key(name: nil, description: nil, public_key: nil) click to toggle source
# File lib/oneandone/requests/compute/create_ssh_key.rb, line 43
def create_ssh_key(name: nil, description: nil,
  public_key: nil)
  
  # Create mock ssh key hash
  mock_ssh_key = {
    "id" => Fog::UUID.uuid,
    "name" => name,
    "description" => description,
    "state" => "ACTIVE",
    "servers" => [],
    "md5" => "5df9f63916ebf8528697b629022993e8",
    "creation_date" => "2018-01-06T08:33:25+00:00",
    "public_key" => public_key
  }

  # Save mock ssh key to list
  self.data[:ssh_keys] << mock_ssh_key

  # Return mock response to user
  response = Excon::Response.new
  response.status = 202
  response.body = mock_ssh_key
    
  response

end
create_vpn(name: nil, description: nil, datacenter_id: nil) click to toggle source
# File lib/oneandone/requests/compute/create_vpn.rb, line 42
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
data() click to toggle source
# File lib/oneandone/compute.rb, line 783
def data

  self.class.data[@oneandone_api_key]

end
delete_block_storage(block_storage_id) click to toggle source
# File lib/oneandone/requests/compute/delete_block_storage.rb, line 27
def delete_block_storage(block_storage_id)
  
  # Search for block storage to delete
  if block_storage = self.data[:block_storages].find {
    |hash| hash['id'] == block_storage_id
  }
    self.data[:block_storages].delete(block_storage)
  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 = []
  response

end
delete_firewall(firewall_id) click to toggle source
# File lib/oneandone/requests/compute/delete_firewall.rb, line 27
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
delete_firewall_rule(firewall_id: nil, rule_id: nil) click to toggle source
# File lib/oneandone/requests/compute/delete_firewall_rule.rb, line 27
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
delete_hdd(server_id: nil, hdd_id: nil) click to toggle source
# File lib/oneandone/requests/compute/delete_hdd.rb, line 28
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
delete_image(image_id) click to toggle source
# File lib/oneandone/requests/compute/delete_image.rb, line 27
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
delete_load_balancer(load_balancer_id) click to toggle source
# File lib/oneandone/requests/compute/delete_load_balancer.rb, line 27
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
delete_load_balancer_rule(load_balancer_id: nil, rule_id: nil) click to toggle source
# File lib/oneandone/requests/compute/delete_load_balancer_rule.rb, line 27
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
delete_monitoring_policy(monitoring_policy_id) click to toggle source
# File lib/oneandone/requests/compute/delete_monitoring_policy.rb, line 27
def delete_monitoring_policy(monitoring_policy_id)
  
  # Search for MP to delete
  if monitoring_policy = self.data[:monitoring_policies].find {
    |hash| hash['id'] == monitoring_policy_id
  }
    self.data[:monitoring_policies].delete(monitoring_policy)
  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 monitoring policy has been deleted.'
  response

end
delete_port(monitoring_policy_id: nil, port_id: nil) click to toggle source
# File lib/oneandone/requests/compute/delete_port.rb, line 27
def delete_port(monitoring_policy_id: nil, port_id: nil)
  
  # Search for MP
  if monitoring_policy = self.data[:monitoring_policies].find {
    |hash| hash['id'] == monitoring_policy_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested resource could
      not be found.')
  end

  # Search for port to destroy
  if port = monitoring_policy['ports'].find {
    |index| index['id'] == port_id
  }
    monitoring_policy['ports'].delete(port)
  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 = monitoring_policy
  response

end
delete_private_network(private_network_id) click to toggle source
# File lib/oneandone/requests/compute/delete_private_network.rb, line 27
def delete_private_network(private_network_id)
  
  # Search for private network to destroy
  if private_network = self.data[:private_networks].find {
    |hash| hash['id'] == private_network_id
  }
    self.data[:private_networks].delete(private_network)
  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 private network has been deleted.'
  response

end
delete_process(monitoring_policy_id: nil, process_id: nil) click to toggle source
# File lib/oneandone/requests/compute/delete_process.rb, line 27
def delete_process(monitoring_policy_id: nil, process_id: nil)
  
  # Search for MP
  if monitoring_policy = self.data[:monitoring_policies].find {
    |hash| hash['id'] == monitoring_policy_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested resource could
      not be found.')
  end

  # Search for process to destroy
  if process = monitoring_policy['processes'].find {
    |index| index['id'] == process_id
  }
    monitoring_policy['processes'].delete(process)
  else
    raise Fog::Errors::NotFound.new('The requested process could
    not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 202
  response.body = monitoring_policy
  response

end
delete_public_ip(ip_id) click to toggle source
# File lib/oneandone/requests/compute/delete_public_ip.rb, line 27
def delete_public_ip(ip_id)
  
  # Search for public IP to destroy
  if ip = self.data[:public_ips].find {
    |hash| hash['id'] == ip_id
  }
    self.data[:public_ips].delete(ip)
  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 public IP has been deleted.'
  response

end
delete_server(server_id) click to toggle source
# File lib/oneandone/requests/compute/delete_server.rb, line 27
def delete_server(server_id)
  
  # Search for server to delete
  if server = self.data[:servers].find {
    |hash| hash['id'] == server_id
  }
    self.data[:servers].delete(server)
  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 server has been deleted.'
  response

end
delete_server_ip(server_id: nil, ip_id: nil) click to toggle source
# File lib/oneandone/requests/compute/delete_server_ip.rb, line 27
def delete_server_ip(server_id: nil, ip_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 IP to return
  if ip = server['ips'].find {
    |index| index['id'] == ip_id
  }
    server['ips'].delete(ip)
  else
    raise Fog::Errors::NotFound.new('The requested server IP could
    not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 200
  response.body = server
  response

end
delete_shared_storage(shared_storage_id) click to toggle source
# File lib/oneandone/requests/compute/delete_shared_storage.rb, line 27
def delete_shared_storage(shared_storage_id)
  
  # Search for shared storage to delete
  if shared_storage = self.data[:shared_storages].find {
    |hash| hash['id'] == shared_storage_id
  }
    self.data[:shared_storages].delete(shared_storage)
  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 shared storage has been deleted.'
  response

end
delete_snapshot(server_id: nil, snapshot_id: nil) click to toggle source
# File lib/oneandone/requests/compute/delete_snapshot.rb, line 27
def delete_snapshot(server_id: nil, snapshot_id: nil)
  
  # Search for server
  if server = self.data[:servers].find {
    |hash| hash['id'] == server_id
  }
    server['snapshot'] = {}
  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
delete_ssh_key(ssh_key_id) click to toggle source
# File lib/oneandone/requests/compute/delete_ssh_key.rb, line 27
def delete_ssh_key(ssh_key_id)
  
  # Search for ssh key to delete
  if ssh_key = self.data[:ssh_keys].find {
    |hash| hash['id'] == ssh_key_id
  }
    self.data[:ssh_keys].delete(ssh_key)
  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 = []
  response

end
delete_vpn(vpn_id) click to toggle source
# File lib/oneandone/requests/compute/delete_vpn.rb, line 27
def delete_vpn(vpn_id)
  
  # Search for VPN to delete
  if vpn = self.data[:vpns].find {
    |hash| hash['id'] == vpn_id
  }
    self.data[:vpns].delete(vpn)
  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 VPN has been deleted.'
  response

end
eject_dvd(server_id) click to toggle source
# File lib/oneandone/requests/compute/eject_dvd.rb, line 27
def eject_dvd(server_id)
  
  # Search for server
  if server = self.data[:servers].find {
    |hash| hash['id'] == server_id
  }
    server['dvd'] = {}
  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 = 200
  response.body = server
  response

end
get_baremetal_model(id) click to toggle source
# File lib/oneandone/requests/compute/get_baremetal_model.rb, line 22
def get_baremetal_model(id)
  
  # Search for baremetal model to return
  if baremetal_model = self.data[:baremetal_models].find {
    |hash| hash['id'] == id
  }
  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 = 200
  response.body = baremetal_model
  response
end
get_block_storage(block_storage_id) click to toggle source
# File lib/oneandone/requests/compute/get_block_storage.rb, line 27
def get_block_storage(block_storage_id)
  
  # Search for block storage to return
  if block_storage = self.data[:block_storages].find {
    |hash| hash['id'] == block_storage_id
  }
  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 = block_storage
  response

end
get_block_storage_server(block_storage_id: nil) click to toggle source
# File lib/oneandone/requests/compute/get_block_storage_server.rb, line 27
def get_block_storage_server(block_storage_id: nil)
  
  # Search for block storage
  if block_storage = self.data[:block_storages].find {
    |hash| hash['id'] == block_storage_id
  }
  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 = block_storage['server']
  response

end
get_datacenter(datacenter_id) click to toggle source
# File lib/oneandone/requests/compute/get_datacenter.rb, line 27
def get_datacenter(datacenter_id)
  
  # Search for image to return
  if datacenter = self.data[:datacenters].find {
    |hash| hash['id'] == datacenter_id
  }
  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 = 200
  response.body = datacenter
  response

end
get_dvd(server_id) click to toggle source
# File lib/oneandone/requests/compute/get_dvd.rb, line 27
def get_dvd(server_id)
  
  # 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

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 200
  response.body = server['dvd']
  response

end
get_dvd_iso(dvd_id) click to toggle source
# File lib/oneandone/requests/compute/get_dvd_iso.rb, line 27
def get_dvd_iso(dvd_id)
  
  # Search for dvd to return
  if dvd = self.data[:dvd_isos].find {
    |hash| hash['id'] == dvd_id
  }
  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 = 200
  response.body = dvd
  response

end
get_firewall(firewall_id) click to toggle source
# File lib/oneandone/requests/compute/get_firewall.rb, line 27
def get_firewall(firewall_id)
  
  # Search for firewall to return
  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

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 202
  response.body = firewall
  response

end
get_firewall_ip(firewall_id: nil, ip_id: nil) click to toggle source
# File lib/oneandone/requests/compute/get_firewall_ip.rb, line 27
def get_firewall_ip(firewall_id: nil, ip_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 server IP to return
  if ip = firewall['server_ips'].find {
    |string| string == ip_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested server could
    not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 200
  response.body = ip
  response

end
get_firewall_rule(firewall_id: nil, rule_id: nil) click to toggle source
# File lib/oneandone/requests/compute/get_firewall_rule.rb, line 27
def get_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 return
  if rule = firewall['rules'].find {
    |index| index['id'] == rule_id
  }
  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 = 200
  response.body = rule
  response

end
get_fixed_server(fixed_instance_id) click to toggle source
# File lib/oneandone/requests/compute/get_fixed_server.rb, line 27
def get_fixed_server(fixed_instance_id)
  
  # Search for fixed server to return
  if fixed_server = self.data[:fixed_servers].find {
    |hash| hash['id'] == fixed_instance_id
  }
  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 = fixed_server
  response

end
get_hardware(server_id) click to toggle source
# File lib/oneandone/requests/compute/get_hardware.rb, line 27
def get_hardware(server_id)
  
  # 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

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 200
  response.body = server['hardware']
  response

end
get_hdd(server_id: nil, hdd_id: nil) click to toggle source
# File lib/oneandone/requests/compute/get_hdd.rb, line 28
def get_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
  }
  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 = 200
  response.body = hdd
  response

end
get_hdds(server_id) click to toggle source
# File lib/oneandone/requests/compute/get_hdds.rb, line 27
def get_hdds(server_id)
  
  # 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

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 200
  response.body = server['hardware']['hdds']
  response

end
get_image(image_id) click to toggle source
# File lib/oneandone/requests/compute/get_image.rb, line 27
def get_image(image_id)
  
  # Search for image to return
  if image = self.data[:images].find {
    |hash| hash['id'] == image_id
  }
  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 = 200
  response.body = image
  response

end
get_load_balancer(load_balancer_id) click to toggle source
# File lib/oneandone/requests/compute/get_load_balancer.rb, line 27
def get_load_balancer(load_balancer_id)
  
  # Search for load balancer to return
  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

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 200
  response.body = load_balancer
  response

end
get_load_balancer_ip(load_balancer_id: nil, ip_id: nil) click to toggle source
# File lib/oneandone/requests/compute/get_load_balancer_ip.rb, line 27
def get_load_balancer_ip(load_balancer_id: nil, ip_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 server IP to return
  if ip = load_balancer['server_ips'].find {
    |string| string == ip_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested server IP could
    not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 200
  response.body = ip
  response

end
get_load_balancer_rule(load_balancer_id: nil, rule_id: nil) click to toggle source
# File lib/oneandone/requests/compute/get_load_balancer_rule.rb, line 27
def get_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 return
  if rule = load_balancer['rules'].find {
    |index| index['id'] == rule_id
  }
  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 = 200
  response.body = rule
  response

end
get_log(log_id) click to toggle source
# File lib/oneandone/requests/compute/get_log.rb, line 28
def get_log(log_id)
  
  # Search for log to return
  if log = self.data[:logs].find {
    |hash| hash['id'] == log_id
  }
  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 = 200
  response.body = log
  response

end
get_monitored_server(server_id: nil, period: 'LAST24H', start_date: nil, end_date: nil) click to toggle source
# File lib/oneandone/requests/compute/get_monitored_server.rb, line 40
def get_monitored_server(server_id: nil, period: 'LAST24H',
  start_date: nil, end_date: nil)
  Fog::Mock.not_implemented
end
get_monitoring_policy(monitoring_policy_id) click to toggle source
# File lib/oneandone/requests/compute/get_monitoring_policy.rb, line 27
def get_monitoring_policy(monitoring_policy_id)
  
  # Search for MP to return
  if monitoring_policy = self.data[:monitoring_policies].find {
    |hash| hash['id'] == monitoring_policy_id
  }
  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 = 200
  response.body = monitoring_policy
  response

end
get_mp_server(monitoring_policy_id: nil, server_id: nil) click to toggle source
# File lib/oneandone/requests/compute/get_mp_server.rb, line 27
def get_mp_server(monitoring_policy_id: nil, server_id: nil)
  
  # Search for MP
  if monitoring_policy = self.data[:monitoring_policies].find {
    |hash| hash['id'] == monitoring_policy_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested resource could
      not be found.')
  end

  # Search for server to return
  if server = monitoring_policy['servers'].find {
    |index| index == server_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested server could
    not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 200
  response.body = server
  response

end
get_port(monitoring_policy_id: nil, port_id: nil) click to toggle source
# File lib/oneandone/requests/compute/get_port.rb, line 27
def get_port(monitoring_policy_id: nil, port_id: nil)
  
  # Search for MP
  if monitoring_policy = self.data[:monitoring_policies].find {
    |hash| hash['id'] == monitoring_policy_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested resource could
      not be found.')
  end

  # Search for port to return
  if port = monitoring_policy['ports'].find {
    |index| index['id'] == port_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested port could
    not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 200
  response.body = port
  response

end
get_private_network(private_network_id) click to toggle source
# File lib/oneandone/requests/compute/get_private_network.rb, line 27
def get_private_network(private_network_id)
  
  # Search for private network to return
  if private_network = self.data[:private_networks].find {
    |hash| hash['id'] == private_network_id
  }
  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 = 200
  response.body = private_network
  response

end
get_private_network_server(private_network_id: nil, server_id: nil) click to toggle source
# File lib/oneandone/requests/compute/get_private_network_server.rb, line 27
def get_private_network_server(private_network_id: nil, server_id: nil)
  
  # Search for private network
  if private_network = self.data[:private_networks].find {
    |hash| hash['id'] == private_network_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested resource could
      not be found.')
  end

  # Search for server to return
  if server = private_network['servers'].find {
    |index| index == server_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested server could
    not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 202
  response.body = server
  response

end
get_process(monitoring_policy_id: nil, process_id: nil) click to toggle source
# File lib/oneandone/requests/compute/get_process.rb, line 27
def get_process(monitoring_policy_id: nil, process_id: nil)
  
  # Search for MP
  if monitoring_policy = self.data[:monitoring_policies].find {
    |hash| hash['id'] == monitoring_policy_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested resource could
      not be found.')
  end

  # Search for process to return
  if process = monitoring_policy['processes'].find {
    |index| index['id'] == process_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested port could
    not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 200
  response.body = process
  response

end
get_public_ip(ip_id) click to toggle source
# File lib/oneandone/requests/compute/get_public_ip.rb, line 27
def get_public_ip(ip_id)
  
  # Search for IP to return
  if public_ip = self.data[:public_ips].find {
    |hash| hash['id'] == ip_id
  }
  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 = 200
  response.body = public_ip
  response

end
get_recovery_appliance(appliance_id) click to toggle source
# File lib/oneandone/requests/compute/get_recovery_appliance.rb, line 22
def get_recovery_appliance(appliance_id)
  # Search for server appliance to return
  if server_appliance = self.data[:recovery_appliances].find {
    |hash| hash['id'] == appliance_id
  }
  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 = 200
  response.body = server_appliance
  response
end
get_server(server_id) click to toggle source
# File lib/oneandone/requests/compute/get_server.rb, line 27
def get_server(server_id)
  
  # Search for server to return
  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

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 200
  response.body = server
  response

end
get_server_appliance(appliance_id) click to toggle source
# File lib/oneandone/requests/compute/get_server_appliance.rb, line 27
def get_server_appliance(appliance_id)
  
  # Search for server appliance to return
  if server_appliance = self.data[:server_appliances].find {
    |hash| hash['id'] == appliance_id
  }
  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 = 200
  response.body = server_appliance
  response

end
get_server_image(server_id) click to toggle source
# File lib/oneandone/requests/compute/get_server_image.rb, line 27
def get_server_image(server_id)
  
  # 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

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 200
  response.body = server['image']
  response

end
get_server_ip(server_id: nil, ip_id: nil) click to toggle source
# File lib/oneandone/requests/compute/get_server_ip.rb, line 27
def get_server_ip(server_id: nil, ip_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 IP to return
  if ip = server['ips'].find {
    |index| index['id'] == ip_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested server IP could
    not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 200
  response.body = ip
  response

end
get_server_private_network(server_id: nil, private_network_id: nil) click to toggle source
# File lib/oneandone/requests/compute/get_server_private_network.rb, line 27
def get_server_private_network(server_id: nil, private_network_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 private network
  if private_network = server['private_networks'].find {
    |hash| hash['id'] == private_network_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested private network could
      not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 200
  response.body = private_network
  response

end
get_shared_storage(shared_storage_id) click to toggle source
# File lib/oneandone/requests/compute/get_shared_storage.rb, line 27
def get_shared_storage(shared_storage_id)
  
  # Search for shared storage to return
  if shared_storage = self.data[:shared_storages].find {
    |hash| hash['id'] == shared_storage_id
  }
  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 = shared_storage
  response

end
get_shared_storage_server(shared_storage_id: nil, server_id: nil) click to toggle source
# File lib/oneandone/requests/compute/get_shared_storage_server.rb, line 27
def get_shared_storage_server(shared_storage_id: nil, server_id: nil)
  
  # Search for shared storage
  if shared_storage = self.data[:shared_storages].find {
    |hash| hash['id'] == shared_storage_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested resource could
      not be found.')
  end

  # Search for server to return
  if server = shared_storage['servers'].find {
    |index| index['id'] == server_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested server could
    not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 202
  response.body = server
  response

end
get_snapshot(server_id) click to toggle source
# File lib/oneandone/requests/compute/get_snapshot.rb, line 27
def get_snapshot(server_id)
  
  # 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

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 200
  response.body = server['snapshot']
  response

end
get_ssh_key(ssh_key_id) click to toggle source
# File lib/oneandone/requests/compute/get_ssh_key.rb, line 27
def get_ssh_key(ssh_key_id)
  
  # Search for ssh key to return
  if ssh_key = self.data[:ssh_keys].find {
    |hash| hash['id'] == ssh_key_id
  }
  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 = ssh_key
  response

end
get_vpn(vpn_id) click to toggle source
# File lib/oneandone/requests/compute/get_vpn.rb, line 27
def get_vpn(vpn_id)
  
  # Search for VPN to return
  if vpn = self.data[:vpns].find {
    |hash| hash['id'] == vpn_id
  }
  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 = 200
  response.body = vpn
  response

end
install_server_image(server_id: nil, image_id: nil, password: nil, firewall_id: nil) click to toggle source
# File lib/oneandone/requests/compute/install_server_image.rb, line 45
def install_server_image(server_id: nil, image_id: nil, password: nil,
  firewall_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

  # Update image info
  server['image']['id'] = image_id

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 202
  response.body = server
  response

end
list_baremetal_models(page: nil, per_page: nil, sort: nil, q: nil, fields: nil) click to toggle source
# File lib/oneandone/requests/compute/list_baremetal_models.rb, line 37
def list_baremetal_models(page: nil, per_page: nil, sort: nil, q: nil,
  fields: nil)
  
  response = Excon::Response.new
  response.status = 200
  response.body = self.data[:baremetal_models]
  response
end
list_block_storages(page: nil, per_page: nil, sort: nil, q: nil, fields: nil) click to toggle source
# File lib/oneandone/requests/compute/list_block_storages.rb, line 42
def list_block_storages(page: nil, per_page: nil, sort: nil, q: nil,
  fields: nil)
  
  response = Excon::Response.new
  response.status = 200
  response.body = self.data[:block_storages]
  response

end
list_datacenters(page: nil, per_page: nil, sort: nil, q: nil, fields: nil) click to toggle source
# File lib/oneandone/requests/compute/list_datacenters.rb, line 42
def list_datacenters(page: nil, per_page: nil, sort: nil, q: nil,
  fields: nil)
  
  response = Excon::Response.new
  response.status = 200
  response.body = self.data[:datacenters]
  response

end
list_dvds(page: nil, per_page: nil, sort: nil, q: nil, fields: nil) click to toggle source
# File lib/oneandone/requests/compute/list_dvds.rb, line 42
def list_dvds(page: nil, per_page: nil, sort: nil, q: nil,
  fields: nil)
  
  response = Excon::Response.new
  response.status = 200
  response.body = self.data[:dvd_isos]
  response

end
list_firewall_ips(firewall_id) click to toggle source
# File lib/oneandone/requests/compute/list_firewall_ips.rb, line 27
def list_firewall_ips(firewall_id)

  # Search for firewall to return
  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

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 202
  response.body = firewall['server_ips']
  response

end
list_firewall_rules(firewall_id) click to toggle source
# File lib/oneandone/requests/compute/list_firewall_rules.rb, line 27
def list_firewall_rules(firewall_id)
  
  # Search for firewall to return
  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

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 202
  response.body = firewall['rules']
  response

end
list_firewalls(page: nil, per_page: nil, sort: nil, q: nil, fields: nil) click to toggle source
# File lib/oneandone/requests/compute/list_firewalls.rb, line 42
def list_firewalls(page: nil, per_page: nil, sort: nil, q: nil,
  fields: nil)
  
  response = Excon::Response.new
  response.status = 200
  response.body = self.data[:firewalls]
  response

end
list_fixed_servers() click to toggle source
# File lib/oneandone/requests/compute/list_fixed_servers.rb, line 27
def list_fixed_servers
  
  response = Excon::Response.new
  response.status = 200
  response.body = self.data[:fixed_servers]
  response

end
list_images(page: nil, per_page: nil, sort: nil, q: nil, fields: nil) click to toggle source
# File lib/oneandone/requests/compute/list_images.rb, line 42
def list_images(page: nil, per_page: nil, sort: nil, q: nil,
  fields: nil)
  
  response = Excon::Response.new
  response.status = 200
  response.body = self.data[:images]
  response

end
list_ip_firewalls(server_id: nil, ip_id: nil) click to toggle source
# File lib/oneandone/requests/compute/list_ip_firewalls.rb, line 27
def list_ip_firewalls(server_id: nil, ip_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 IP to return
  if ip = server['ips'].find {
    |index| index['id'] == ip_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested server IP could
    not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 200
  response.body = ip['firewall_policy']
  response

end
list_ip_load_balancers(server_id: nil, ip_id: nil) click to toggle source
# File lib/oneandone/requests/compute/list_ip_load_balancers.rb, line 27
def list_ip_load_balancers(server_id: nil, ip_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 IP to return
  if ip = server['ips'].find {
    |index| index['id'] == ip_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested server IP could
    not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 200
  response.body = ip['load_balancers']
  response

end
list_load_balancer_ips(load_balancer_id) click to toggle source
# File lib/oneandone/requests/compute/list_load_balancer_ips.rb, line 27
def list_load_balancer_ips(load_balancer_id)
  
  # Search for load balancer to return
  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

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 202
  response.body = load_balancer['server_ips']
  response

end
list_load_balancer_rules(load_balancer_id) click to toggle source
# File lib/oneandone/requests/compute/list_load_balancer_rules.rb, line 27
def list_load_balancer_rules(load_balancer_id)
  
  # Search for load balancer to return
  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

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 202
  response.body = load_balancer['rules']
  response

end
list_load_balancers(page: nil, per_page: nil, sort: nil, q: nil, fields: nil) click to toggle source
# File lib/oneandone/requests/compute/list_load_balancers.rb, line 42
def list_load_balancers(page: nil, per_page: nil, sort: nil, q: nil,
  fields: nil)
  
  response = Excon::Response.new
  response.status = 200
  response.body = self.data[:load_balancers]
  response

end
list_logs(page: nil, per_page: nil, sort: nil, q: nil, fields: nil, period: 'LAST_24H', start_date: nil, end_date: nil) click to toggle source
# File lib/oneandone/requests/compute/list_logs.rb, line 45
def list_logs(page: nil, per_page: nil, sort: nil, q: nil, fields: nil,
  period: 'LAST_24H', start_date: nil, end_date: nil)
  
  response = Excon::Response.new
  response.status = 200
  response.body = self.data[:logs]
  response

end
list_monitored_servers(page: nil, per_page: nil, sort: nil, q: nil, fields: nil) click to toggle source
# File lib/oneandone/requests/compute/list_monitored_servers.rb, line 42
def list_monitored_servers(page: nil, per_page: nil, sort: nil, q: nil,
  fields: nil)
  Fog::Mock.not_implemented
end
list_monitoring_policies(page: nil, per_page: nil, sort: nil, q: nil, fields: nil) click to toggle source
# File lib/oneandone/requests/compute/list_monitoring_policies.rb, line 42
def list_monitoring_policies(page: nil, per_page: nil, sort: nil, q: nil,
  fields: nil)
  
  response = Excon::Response.new
  response.status = 200
  response.body = self.data[:monitoring_policies]
  response

end
list_mp_servers(monitoring_policy_id) click to toggle source
# File lib/oneandone/requests/compute/list_mp_servers.rb, line 27
def list_mp_servers(monitoring_policy_id)
  
  # Search for MP
  if monitoring_policy = self.data[:monitoring_policies].find {
    |hash| hash['id'] == monitoring_policy_id
  }
  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 = 200
  response.body = monitoring_policy['servers']
  response

end
list_ports(monitoring_policy_id) click to toggle source
# File lib/oneandone/requests/compute/list_ports.rb, line 28
def list_ports(monitoring_policy_id)
  
  # Search for MP
  if monitoring_policy = self.data[:monitoring_policies].find {
    |hash| hash['id'] == monitoring_policy_id
  }
  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 = 200
  response.body = monitoring_policy['ports']
  response

end
list_private_network_servers(private_network_id) click to toggle source
# File lib/oneandone/requests/compute/list_private_network_servers.rb, line 27
def list_private_network_servers(private_network_id)
  
  # Search for private network to return
  if private_network = self.data[:private_networks].find {
    |hash| hash['id'] == private_network_id
  }
  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 = private_network['servers']
  response

end
list_private_networks(page: nil, per_page: nil, sort: nil, q: nil, fields: nil) click to toggle source
# File lib/oneandone/requests/compute/list_private_networks.rb, line 42
def list_private_networks(page: nil, per_page: nil, sort: nil, q: nil,
  fields: nil)
  
  response = Excon::Response.new
  response.status = 200
  response.body = self.data[:private_networks]
  response

end
list_processes(monitoring_policy_id) click to toggle source
# File lib/oneandone/requests/compute/list_processes.rb, line 28
def list_processes(monitoring_policy_id)
  
  # Search for MP
  if monitoring_policy = self.data[:monitoring_policies].find {
    |hash| hash['id'] == monitoring_policy_id
  }
  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 = 200
  response.body = monitoring_policy['processes']
  response

end
list_public_ips(page: nil, per_page: nil, sort: nil, q: nil, fields: nil) click to toggle source
# File lib/oneandone/requests/compute/list_public_ips.rb, line 42
def list_public_ips(page: nil, per_page: nil, sort: nil, q: nil,
  fields: nil)
  
  response = Excon::Response.new
  response.status = 200
  response.body = self.data[:public_ips]
  response

end
list_recovery_appliances(page: nil, per_page: nil, sort: nil, q: nil, fields: nil) click to toggle source
# File lib/oneandone/requests/compute/list_recovery_appliances.rb, line 36
def list_recovery_appliances(page: nil, per_page: nil, sort: nil, q: nil,
  fields: nil)
  
  response = Excon::Response.new
  response.status = 200
  response.body = self.data[:recovery_appliances]
  response
end
list_server_appliances(page: nil, per_page: nil, sort: nil, q: nil, fields: nil) click to toggle source
# File lib/oneandone/requests/compute/list_server_appliances.rb, line 42
def list_server_appliances(page: nil, per_page: nil, sort: nil, q: nil,
  fields: nil)
  
  response = Excon::Response.new
  response.status = 200
  response.body = self.data[:server_appliances]
  response

end
list_server_ips(server_id) click to toggle source
# File lib/oneandone/requests/compute/list_server_ips.rb, line 27
def list_server_ips(server_id)
  
  # 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

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 200
  response.body = server['ips']
  response

end
list_server_private_networks(server_id) click to toggle source
# File lib/oneandone/requests/compute/list_server_private_networks.rb, line 27
def list_server_private_networks(server_id)
  
  # 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

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 200
  response.body = server['private_networks']
  response

end
list_servers(page: nil, per_page: nil, sort: nil, q: nil, fields: nil) click to toggle source
# File lib/oneandone/requests/compute/list_servers.rb, line 42
def list_servers(page: nil, per_page: nil, sort: nil, q: nil,
  fields: nil)
  
  response = Excon::Response.new
  response.status = 200
  response.body = self.data[:servers]
  response

end
list_shared_storage_servers(shared_storage_id) click to toggle source
# File lib/oneandone/requests/compute/list_shared_storage_servers.rb, line 27
def list_shared_storage_servers(shared_storage_id)
  
  # Search for shared storage to return
  if shared_storage = self.data[:shared_storages].find {
    |hash| hash['id'] == shared_storage_id
  }
  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 = shared_storage['servers']
  response

end
list_shared_storages(page: nil, per_page: nil, sort: nil, q: nil, fields: nil) click to toggle source
# File lib/oneandone/requests/compute/list_shared_storages.rb, line 42
def list_shared_storages(page: nil, per_page: nil, sort: nil, q: nil,
  fields: nil)
  
  response = Excon::Response.new
  response.status = 200
  response.body = self.data[:shared_storages]
  response

end
list_ssh_keys(page: nil, per_page: nil, sort: nil, q: nil, fields: nil) click to toggle source
# File lib/oneandone/requests/compute/list_ssh_keys.rb, line 42
def list_ssh_keys(page: nil, per_page: nil, sort: nil, q: nil,
  fields: nil)
  
  response = Excon::Response.new
  response.status = 200
  response.body = self.data[:ssh_keys]
  response

end
list_usages(page: nil, per_page: nil, sort: nil, q: nil, fields: nil, period: 'LAST_24H', start_date: nil, end_date: nil) click to toggle source
# File lib/oneandone/requests/compute/list_usages.rb, line 45
def list_usages(page: nil, per_page: nil, sort: nil, q: nil, fields: nil,
  period: 'LAST_24H', start_date: nil, end_date: nil)
  Fog::Mock.not_implemented
end
list_vpns(page: nil, per_page: nil, sort: nil, q: nil, fields: nil) click to toggle source
# File lib/oneandone/requests/compute/list_vpns.rb, line 42
def list_vpns(page: nil, per_page: nil, sort: nil, q: nil,
  fields: nil)
  
  response = Excon::Response.new
  response.status = 200
  response.body = self.data[:vpns]
  response

end
load_dvd(server_id: nil, dvd_id: nil) click to toggle source
# File lib/oneandone/requests/compute/load_dvd.rb, line 37
def load_dvd(server_id: nil, dvd_id: nil)
  
  # Search for server
  if server = self.data[:servers].find {
    |hash| hash['id'] == server_id
  }
    dvd = {
      'id' => dvd_id
    }

    server['dvd'] = dvd
  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 = 200
  response.body = server
  response

end
ping() click to toggle source
# File lib/oneandone/requests/compute/ping.rb, line 28
def ping
  
  Fog::Mock.not_implemented

end
ping_auth() click to toggle source
# File lib/oneandone/requests/compute/ping_auth.rb, line 28
def ping_auth
  
  Fog::Mock.not_implemented

end
remove_block_storage_server(block_storage_id: nil) click to toggle source
# File lib/oneandone/requests/compute/remove_block_storage_server.rb, line 27
def remove_block_storage_server(block_storage_id: nil)
  
  # Search for block storage
  if block_storage = self.data[:block_storages].find {
    |hash| hash['id'] == block_storage_id
  }
  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 = block_storage
  response

end
remove_firewall(server_id: nil, ip_id: nil) click to toggle source
# File lib/oneandone/requests/compute/remove_firewall.rb, line 27
def remove_firewall(server_id: nil, ip_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 IP to remove firewall from
  if ip = server['ips'].find {
    |index| index['id'] == ip_id
  }
    ip['firewall_policy'] = {}
  else
    raise Fog::Errors::NotFound.new('The requested server IP could
    not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 202
  response.body = server
  response

end
remove_load_balancer(server_id: nil, ip_id: nil, load_balancer_id: nil) click to toggle source
# File lib/oneandone/requests/compute/remove_load_balancer.rb, line 28
def remove_load_balancer(server_id: nil, ip_id: nil,
  load_balancer_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 IP
  if ip = server['ips'].find {
    |index| index['id'] == ip_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested server IP could
    not be found.')
  end

  # Search for load balancer to destroy
  if load_balancer = ip['load_balancers'].find {
    |index| index['id'] == load_balancer_id
  }
    ip['load_balancers'].delete(load_balancer)
  else
    raise Fog::Errors::NotFound.new('The requested load balancer could
    not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 202
  response.body = server
  response

end
remove_load_balancer_ip(load_balancer_id: nil, ip_id: nil) click to toggle source
# File lib/oneandone/requests/compute/remove_load_balancer_ip.rb, line 27
def remove_load_balancer_ip(load_balancer_id: nil, ip_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 server IP to destroy
  if ip = load_balancer['server_ips'].find {
    |index| index == ip_id
  }
    load_balancer['server_ips'].delete(ip)
  else
    raise Fog::Errors::NotFound.new('The requested server IP could
    not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 202
  response.body = load_balancer
  response

end
remove_mp_server(monitoring_policy_id: nil, server_id: nil) click to toggle source
# File lib/oneandone/requests/compute/remove_mp_server.rb, line 27
def remove_mp_server(monitoring_policy_id: nil, server_id: nil)
  
  # Search for MP
  if monitoring_policy = self.data[:monitoring_policies].find {
    |hash| hash['id'] == monitoring_policy_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested resource could
      not be found.')
  end

  # Search for server to remove
  if server = monitoring_policy['servers'].find {
    |index| index == server_id
  }
    monitoring_policy['servers'].delete(server)
  else
    raise Fog::Errors::NotFound.new('The requested server could
    not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 202
  response.body = monitoring_policy
  response

end
remove_private_network(server_id: nil, private_network_id: nil) click to toggle source
# File lib/oneandone/requests/compute/remove_private_network.rb, line 27
def remove_private_network(server_id: nil, private_network_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 private network
  if private_network = server['private_networks'].find {
    |hash| hash['id'] == private_network_id
  }
    server['private_networks'].delete(private_network)
  else
    raise Fog::Errors::NotFound.new('The requested private network could
      not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 202
  response.body = server
  response

end
remove_private_network_server(private_network_id: nil, server_id: nil) click to toggle source
# File lib/oneandone/requests/compute/remove_private_network_server.rb, line 27
def remove_private_network_server(private_network_id: nil, server_id: nil)
  
  # Search for private network
  if private_network = self.data[:private_networks].find {
    |hash| hash['id'] == private_network_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested resource could
      not be found.')
  end

  # Search for server to destroy
  if server = private_network['servers'].find {
    |index| index == server_id
  }
    private_network['servers'].delete(server)
  else
    raise Fog::Errors::NotFound.new('The requested server could
    not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 202
  response.body = private_network
  response

end
remove_shared_storage_server(shared_storage_id: nil, server_id: nil) click to toggle source
# File lib/oneandone/requests/compute/remove_shared_storage_server.rb, line 27
def remove_shared_storage_server(shared_storage_id: nil, server_id: nil)
  
  # Search for shared storage
  if shared_storage = self.data[:shared_storages].find {
    |hash| hash['id'] == shared_storage_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested resource could
      not be found.')
  end

  # Search for server to destroy
  if server = shared_storage['servers'].find {
    |index| index['id'] == server_id
  }
    shared_storage['servers'].delete(server)
  else
    raise Fog::Errors::NotFound.new('The requested server could
    not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 202
  response.body = shared_storage
  response

end
reset_data() click to toggle source
# File lib/oneandone/compute.rb, line 790
def reset_data

  self.class.data.delete(@oneandone_api_key)

end
restore_snapshot(server_id: nil, snapshot_id: nil) click to toggle source
# File lib/oneandone/requests/compute/restore_snapshot.rb, line 27
def restore_snapshot(server_id: nil, snapshot_id: nil)
  Fog::Mock.not_implemented
end
status(server_id) click to toggle source
# File lib/oneandone/requests/compute/status.rb, line 27
def status(server_id)
  
  # 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

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 200
  response.body = server['status']
  response

end
update_block_storage(block_storage_id: nil, name: nil, description: nil, size: nil) click to toggle source
# File lib/oneandone/requests/compute/update_block_storage.rb, line 43
def update_block_storage(block_storage_id: nil, name: nil,
  description: nil, size: nil)
  
  # Search for block storage to update
  if block_storage = self.data[:block_storages].find {
    |hash| hash['id'] == block_storage_id
  }
    # Create parameter hash
    params = {
      'name' => name,
      'description' => description,
      'size' => size
    }
    
    # Update the block storage we found with new values
    params.each do |key, value|
      if value
        block_storage[key] = value
      end
    end
  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 = block_storage
  response

end
update_firewall(firewall_id: nil, name: nil, description: nil) click to toggle source
# File lib/oneandone/requests/compute/update_firewall.rb, line 41
def update_firewall(firewall_id: nil, name: nil, description: nil)
  
  # Search for firewall to update
  if firewall = self.data[:firewalls].find {
    |hash| hash['id'] == firewall_id
  }
    # Create parameter hash
    params = {
      'name' => name,
      'description' => description
    }
    
    # Update the firewall we found with new values
    params.each do |key, value|
      if value
        firewall[key] = value
      end
    end
  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 = firewall
  response

end
update_hardware(server_id: nil, fixed_instance_id: nil, vcore: nil, cores_per_processor: nil, ram: nil) click to toggle source
# File lib/oneandone/requests/compute/update_hardware.rb, line 44
def update_hardware(server_id: nil, fixed_instance_id: nil, vcore: nil,
  cores_per_processor: nil, ram: nil)
  
  # Search for server to update
  if server = self.data[:servers].find {
    |hash| hash['id'] == server_id
  }
    # Create parameter hash
    params = {
      'fixed_instance_id' => fixed_instance_id,
      'vcore' => vcore,
      'cores_per_processor' => cores_per_processor,
      'ram' => ram
    }
    
    # Update the server hardware with new values
    params.each do |key, value|
      if value
        server['hardware'][key] = value
      end
    end
  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
update_hdd(server_id: nil, hdd_id: nil, size: nil) click to toggle source
# File lib/oneandone/requests/compute/update_hdd.rb, line 37
def update_hdd(server_id: nil, hdd_id: nil, size: nil)
  
  # Search for server to update
  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 server's hdd to update
  if hdd = server['hardware']['hdds'].find {
    |hash| hash['id'] == hdd_id
  }
    # Update the server hdd with new values
    hdd['size'] = size
  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
update_image(image_id: nil, name: nil, description: nil, frequency: nil) click to toggle source
# File lib/oneandone/requests/compute/update_image.rb, line 43
def update_image(image_id: nil, name: nil, description: nil,
  frequency: nil)
  
  # Search for image to update
  if image = self.data[:images].find {
    |hash| hash['id'] == image_id
  }
    # Create parameter hash
    params = {
      'name' => name,
      'description' => description,
      'frequency' => frequency
    }
    
    # Update the image we found with new values
    params.each do |key, value|
      if value
        image[key] = value
      end
    end
  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 = image
  response

end
update_load_balancer(load_balancer_id: nil, name: nil, description: nil, health_check_test: nil, health_check_interval: nil, persistence: nil, persistence_time: nil, method: nil, health_check_path: nil, health_check_parse: nil) click to toggle source
# File lib/oneandone/requests/compute/update_load_balancer.rb, line 51
def update_load_balancer(load_balancer_id: nil, name: nil,
  description: nil, health_check_test: nil, health_check_interval: nil,
  persistence: nil, persistence_time: nil, method: nil,
  health_check_path: nil, health_check_parse: nil)
  
  # Search for load balancer to update
  if load_balancer = self.data[:load_balancers].find {
    |hash| hash['id'] == load_balancer_id
  }
    # Create parameter hash
    params = {
      'name' => name,
      'description' => description,
      'health_check_test' => health_check_test,
      'health_check_interval' => health_check_interval,
      'persistence' => persistence,
      'persistence_time' => persistence_time,
      'method' => method,
      'health_check_path' => health_check_path,
      'health_check_parse' => health_check_parse
    }
    
    # Update the load balancer we found with new values
    params.each do |key, value|
      if value
        load_balancer[key] = value
      end
    end
  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 = load_balancer
  response

end
update_monitoring_policy(monitoring_policy_id: nil, name: nil, description: nil, email: nil, thresholds: nil) click to toggle source
# File lib/oneandone/requests/compute/update_monitoring_policy.rb, line 44
def update_monitoring_policy(monitoring_policy_id: nil, name: nil,
  description: nil, email: nil, thresholds: nil)
  
  # Search for MP to update
  if monitoring_policy = self.data[:monitoring_policies].find {
    |hash| hash['id'] == monitoring_policy_id
  }
    # Create parameter hash
    params = {
      'name' => name,
      'description' => description,
      'email' => email,
      'thresholds' => thresholds
    }
    
    # Update the MP we found with new values
    params.each do |key, value|
      if value
        monitoring_policy[key] = value
      end
    end
  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 = monitoring_policy
  response

end
update_port(monitoring_policy_id: nil, port_id: nil, new_port: nil) click to toggle source
# File lib/oneandone/requests/compute/update_port.rb, line 37
def update_port(monitoring_policy_id: nil, port_id: nil, new_port: nil)
  
  # Search for MP
  if monitoring_policy = self.data[:monitoring_policies].find {
    |hash| hash['id'] == monitoring_policy_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested resource could
      not be found.')
  end

  # Search for port to update
  if port = monitoring_policy['ports'].find {
    |index| index['id'] == port_id
  }

    # Update the port with new values
    new_port.each do |key, value|
      port[key] = value
    end
  else
    raise Fog::Errors::NotFound.new('The requested port could
    not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 202
  response.body = monitoring_policy
  response

end
update_private_network(private_network_id: nil, name: nil, description: nil, network_address: nil, subnet_mask: nil) click to toggle source
# File lib/oneandone/requests/compute/update_private_network.rb, line 44
def update_private_network(private_network_id: nil, name: nil,
  description: nil, network_address: nil, subnet_mask: nil)
  
  # Search for private network to update
  if private_network = self.data[:private_networks].find {
    |hash| hash['id'] == private_network_id
  }
    # Create parameter hash
    params = {
      'name' => name,
      'description' => description,
      'network_address' => network_address,
      'subnet_mask' => subnet_mask,
    }
    
    # Update the private network we found with new values
    params.each do |key, value|
      if value
        private_network[key] = value
      end
    end
  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 = private_network
  response

end
update_process(monitoring_policy_id: nil, process_id: nil, new_process: nil) click to toggle source
# File lib/oneandone/requests/compute/update_process.rb, line 38
def update_process(monitoring_policy_id: nil, process_id: nil,
  new_process: nil)
  
  # Search for MP
  if monitoring_policy = self.data[:monitoring_policies].find {
    |hash| hash['id'] == monitoring_policy_id
  }
  else
    raise Fog::Errors::NotFound.new('The requested resource could
      not be found.')
  end

  # Search for process to update
  if process = monitoring_policy['processes'].find {
    |index| index['id'] == process_id
  }

    # Update the process with new values
    new_process.each do |key, value|
      process[key] = value
    end
  else
    raise Fog::Errors::NotFound.new('The requested process could
    not be found.')
  end

  # Return Response Object to User
  response = Excon::Response.new
  response.status = 202
  response.body = monitoring_policy
  response

end
update_public_ip(ip_id: nil, reverse_dns: nil) click to toggle source
# File lib/oneandone/requests/compute/update_public_ip.rb, line 37
def update_public_ip(ip_id: nil, reverse_dns: nil)
  
  # Search for IP to update
  if ip = self.data[:public_ips].find {
    |hash| hash['id'] == ip_id
  }
    # Create parameter hash
    params = {
      'reverse_dns' => reverse_dns
    }
    
    # Update the IP we found with new values
    params.each do |key, value|
      if value
        ip[key] = value
      end
    end
  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 = ip
  response

end
update_server(server_id: nil, name: nil, description: nil) click to toggle source
# File lib/oneandone/requests/compute/update_server.rb, line 41
def update_server(server_id: nil, name: nil, description: nil)
  
  # Search for server to update
  if server = self.data[:servers].find {
    |hash| hash['id'] == server_id
  }
    # Create parameter hash
    params = {
      'name' => name,
      'description' => description
    }
    
    # Update the server we found with new values
    params.each do |key, value|
      if value
        server[key] = value
      end
    end
  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
update_shared_storage(shared_storage_id: nil, name: nil, description: nil, size: nil) click to toggle source
# File lib/oneandone/requests/compute/update_shared_storage.rb, line 43
def update_shared_storage(shared_storage_id: nil, name: nil,
  description: nil, size: nil)
  
  # Search for shared storage to update
  if shared_storage = self.data[:shared_storages].find {
    |hash| hash['id'] == shared_storage_id
  }
    # Create parameter hash
    params = {
      'name' => name,
      'description' => description,
      'size' => size
    }
    
    # Update the shared storage we found with new values
    params.each do |key, value|
      if value
        shared_storage[key] = value
      end
    end
  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 = shared_storage
  response

end
update_ssh_key(ssh_key_id: nil, name: nil, description: nil) click to toggle source
# File lib/oneandone/requests/compute/update_ssh_key.rb, line 42
def update_ssh_key(ssh_key_id: nil, name: nil,
  description: nil)
  
  # Search for ssh key to update
  if ssh_key = self.data[:ssh_keys].find {
    |hash| hash['id'] == ssh_key_id
  }
    # Create parameter hash
    params = {
      'name' => name,
      'description' => description
    }
    
    # Update the ssh key we found with new values
    params.each do |key, value|
      if value
        ssh_key[key] = value
      end
    end
  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 = ssh_key
  response

end
update_vpn(vpn_id: nil, name: nil, description: nil) click to toggle source
# File lib/oneandone/requests/compute/update_vpn.rb, line 41
def update_vpn(vpn_id: nil, name: nil, description: nil)
  
  # Search for VPN to update
  if vpn = self.data[:vpns].find {
    |hash| hash['id'] == vpn_id
  }
    # Create parameter hash
    params = {
      'name' => name,
      'description' => description
    }
    
    # Update the VPN we found with new values
    params.each do |key, value|
      if value
        vpn[key] = value
      end
    end
  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 = vpn
  response

end