fog-ecloud 0.0.1

data/lib/fog/ecloud/requests/compute/get_rows.rb

@@ -0,0 +1,12 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :get_rows
+      end
+
+      class Mock
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/get_server.rb

@@ -0,0 +1,21 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :get_server
+      end
+
+      class Mock
+        def get_server(uri)
+          server_id = uri.match(/(\d+)/)
+          server_id = server_id.nil? ? nil : server_id[1].to_i
+          server = self.data[:servers][server_id]
+          if server
+            response(:body => Fog::Ecloud.slice(server, :id, :compute_pool_id))
+          else raise Fog::Errors::NotFound
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/get_server_configuration_option.rb

@@ -0,0 +1,9 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :get_server_configuration_option
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/get_server_configuration_options.rb

@@ -0,0 +1,9 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :get_server_configuration_options
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/get_servers.rb

@@ -0,0 +1,42 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :get_servers
+      end
+      class Mock
+        def get_servers(uri)
+          if uri =~ /layoutgroups/i
+            group_id        = id_from_uri(uri)
+            group           = self.data[:groups][group_id]
+            servers         = group[:VirtualMachines][:VirtualMachine]
+            compute_pool_id = servers.first[:compute_pool_id] unless servers.empty?
+            compute_pool    = self.data[:compute_pools][compute_pool_id] unless compute_pool_id.nil?
+          elsif uri =~ /computepool/i
+            compute_pool_id = id_from_uri(uri)
+            compute_pool    = self.data[:compute_pools][compute_pool_id]
+            servers = self.data[:servers].values.select{|cp| cp[:compute_pool_id] == compute_pool_id}
+            servers = servers.map{|server| Fog::Ecloud.slice(server, :id, :compute_pool_id)}
+          end
+
+          links = if compute_pool.nil?
+                    []
+                  else
+                    [Fog::Ecloud.keep(compute_pool, :name, :href, :type),]
+                  end
+
+          server_response = {:VirtualMachine => (servers.size > 1 ? servers : servers.first)} # GAH
+          body = {
+            :href  => uri,
+            :type  => "application/vnd.tmrk.cloud.virtualMachine; type=collection",
+            :Links => {
+              :Link => links
+            }
+          }.merge(server_response)
+
+          response(:body => body)
+        end
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/get_ssh_key.rb

@@ -0,0 +1,21 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :get_ssh_key
+      end
+
+      class Mock
+        def get_ssh_key(uri)
+          ssh_key_id = id_from_uri(uri).to_i
+          ssh_key    = self.data[:ssh_keys][ssh_key_id.to_i]
+
+          if ssh_key
+            response(:body => Fog::Ecloud.slice(ssh_key, :id, :admin_organization))
+          else response(:status => 404) # ?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/get_ssh_keys.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :get_ssh_keys
+      end
+
+      class Mock
+        def get_ssh_keys(uri)
+          organization_id = id_from_uri(uri)
+          organization    = self.data[:organizations][organization_id]
+
+          ssh_keys = self.data[:ssh_keys].values.select{|key| key[:admin_organization_id] == organization_id}
+          ssh_keys = ssh_keys.map{|key| Fog::Ecloud.slice(key, :id, :admin_organization)}
+
+          ssh_key_response = {:SshKey => (ssh_keys.size > 1 ? ssh_keys : ssh_keys.first)} # GAH
+          body = {
+            :href  => "/cloudapi/ecloud/admin/organizations/#{organization_id}/sshKeys",
+            :type  => "application/vnd.tmrk.cloud.sshKey; type=collection",
+            :Links => {
+              :Link => organization,
+            },
+          }.merge(ssh_key_response)
+
+          response(:body => body)
+        end
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/get_storage_usage_detail.rb

@@ -0,0 +1,9 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :get_storage_usage_detail
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/get_storage_usage_detail_summary.rb

@@ -0,0 +1,9 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :get_storage_usage_detail_summary
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/get_support_ticket.rb

@@ -0,0 +1,9 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :get_support_ticket
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/get_support_tickets.rb

@@ -0,0 +1,9 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :get_support_tickets
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/get_tag.rb

@@ -0,0 +1,9 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :get_tag
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/get_tags.rb

@@ -0,0 +1,9 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :get_tags
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/get_task.rb

@@ -0,0 +1,13 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :get_task
+      end
+      class Mock
+        def get_task(uri)
+        end
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/get_tasks.rb

@@ -0,0 +1,9 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :get_tasks
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/get_template.rb

@@ -0,0 +1,21 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :get_template
+      end
+
+      class Mock
+        def get_template(uri)
+          template_id, compute_pool_id = uri.match(/(\d+).*\/(\d+)$/).captures
+          template    = self.data[:templates][template_id.to_i]
+
+          if template
+            response(:body => Fog::Ecloud.slice(template, :id, :environment))
+          else response(:status => 404) # ?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/get_templates.rb

@@ -0,0 +1,48 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :get_templates
+      end
+
+      class Mock
+        def get_templates(uri) # /cloudapi/ecloud/computepools/compute_pools/534
+          compute_pool_id = id_from_uri(uri)
+          compute_pool    = self.data[:compute_pools][compute_pool_id]
+
+          templates = self.data[:templates].values.select{|template| template[:compute_pool_id] == compute_pool_id}
+          templates = templates.map{|template| Fog::Ecloud.slice(template, :id, :compute_pool)}
+
+          template_response = {:Template => (templates.size > 1 ? templates : templates.first)} # GAH
+          body = {
+            :href  => uri,
+            :type  => "application/vnd.tmrk.cloud.template; type=collection",
+            :Links => {
+              :Link => compute_pool,
+            },
+            :Families => {
+              :Family => {
+                :Name => "Standard Templates",
+                :Categories => {
+                  :Category => [
+                    {
+                      :Name => "OS Only",
+                      :OperatingSystems => {
+                        :OperatingSystem => {
+                          :Name => "Linux",
+                          :Templates => template_response,
+                        }
+                      }
+                    }
+                  ]
+                }
+              }
+            }
+          }
+
+          response(:body => body)
+        end
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/get_trusted_network_group.rb

@@ -0,0 +1,9 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :get_trusted_network_group
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/get_trusted_network_groups.rb

@@ -0,0 +1,9 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :get_trusted_network_groups
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/get_user.rb

@@ -0,0 +1,9 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :get_user
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/get_users.rb

@@ -0,0 +1,9 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :get_users
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/get_virtual_machine_assigned_ips.rb

@@ -0,0 +1,42 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        def get_virtual_machine_assigned_ips(virtual_machine_id)
+          request(
+            :uri => "#{base_path}/virtualmachines/#{virtual_machine_id}/assignedips",
+            :parse   => true
+          )
+        end
+      end
+
+      class Mock
+        def get_virtual_machine_assigned_ips(virtual_machine_id)
+          server         = self.data[:servers][virtual_machine_id.to_i]
+          compute_pool   = self.data[:compute_pools][server[:compute_pool_id]]
+          environment_id = compute_pool[:environment_id]
+          environment    = self.data[:environments][environment_id]
+
+          networks = self.data[:networks].values.select{|n| n[:environment_id] == environment_id}
+          networks = networks.map{|n| deep_copy(Fog::Ecloud.slice(n, :environment, :id))}
+
+          networks.each do |network|
+            address = network[:IpAddresses][:IpAddress].map{|ia| ia[:name]}
+            network[:IpAddresses][:IpAddress] = address.first
+          end
+
+          body = {
+            :href  => "/cloudapi/ecloud/virtualMachines/#{virtual_machine_id}/assignedIps",
+            :type  => "application/vnd.tmrk.cloud.network",
+            :Links => {
+              :Link => Fog::Ecloud.keep(environment, :name, :href, :type)
+            },
+            :Networks => {:Network => (networks.size > 1 ? networks : networks.first)},
+          }
+
+          response(:body =>  body)
+        end
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/groups_create.rb

@@ -0,0 +1,31 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        include Shared
+
+        def groups_create(data)
+          validate_data([:name], data)
+
+          request(
+            :body => generate_groups_create_request(data),
+            :expects => 201,
+            :method => "POST",
+            :headers => {},
+            :uri => data[:uri],
+            :parse => true
+          )
+        end
+
+        private
+
+        def generate_groups_create_request(data)
+          xml = Builder::XmlMarkup.new
+          xml.CreateLayoutGroup(:name => data[:name]) do
+            xml.Row(:href => data[:href], :name => data[:row_name], :type => "application/vnd.tmrk.cloud.layoutRow")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/groups_delete.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :groups_delete, 204, 'DELETE'
+      end
+
+      class Mock
+        def groups_delete(uri)
+          group_id = id_from_uri(uri)
+          self.data[:groups].delete(group_id)
+          self.data[:rows].values.each do |row|
+            row[:Groups][:Group].delete_if { |g| g[:id] == group_id }
+          end
+          self.data[:layouts].values.each do |layout|
+            layout[:Rows][:Row].each do |row|
+              row[:Groups][:Group].delete_if { |g| g[:id] == group_id }
+            end
+          end
+
+          response(:body =>  nil, :status => 204)
+        end
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/groups_edit.rb

@@ -0,0 +1,29 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        include Shared
+
+        def groups_edit(data)
+          validate_data([:name], data)
+
+          request(
+            :body => generate_groups_edit_request(data),
+            :expects => 204,
+            :method => "PUT",
+            :headers => {},
+            :uri => data[:uri],
+            :parse => false
+          )
+        end
+
+        private
+
+        def generate_groups_edit_request(data)
+          xml = Builder::XmlMarkup.new
+          xml.LayoutGroup(:name => data[:name])
+        end
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/groups_movedown.rb

@@ -0,0 +1,9 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :groups_movedown, 204, 'POST'
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/groups_moveup.rb

@@ -0,0 +1,9 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :groups_moveup, 204, 'POST'
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/internet_service_create.rb

@@ -0,0 +1,102 @@
+module Fog
+  module Compute
+    class Ecloud
+      module Shared
+        def validate_internet_service_data(service_data)
+          required_opts = [:name, :protocol, :port, :description, :enabled, :persistence]
+          unless required_opts.all? { |opt| service_data.key?(opt) }
+            raise ArgumentError.new("Required Internet Service data missing: #{(required_opts - service_data.keys).map(&:inspect).join(", ")}")
+          end
+          if service_data[:trusted_network_group]
+            raise ArgumentError.new("Required Trusted Network Group data missing: #{([:name, :href] - service_data[:trusted_network_group].keys).map(&:inspect).join(", ")}")
+          end
+          if service_data[:backup_internet_service]
+            raise ArgumentError.new("Required Backup Internet Service data missing: #{([:name, :href] - service_data[:backup_internet_service].keys).map(&:inspect).join(", ")}")
+          end
+        end
+      end
+
+      class Real
+        include Shared
+
+        def internet_service_create(service_data)
+          validate_internet_service_data(service_data)
+
+          request(
+            :body => generate_internet_service_request(service_data),
+            :expects => 201,
+            :method => "POST",
+            :headers => {},
+            :uri => service_data[:uri],
+            :parse => true
+          )
+        end
+
+        private
+
+        def generate_internet_service_request(service_data)
+          xml = Builder::XmlMarkup.new
+          xml.CreateInternetService(:name => service_data[:name]) do
+            xml.Protocol service_data[:protocol]
+            xml.Port service_data[:port]
+            xml.Enabled service_data[:enabled]
+            xml.Description service_data[:description]
+            xml.Persistence do
+              xml.Type service_data[:persistence][:type]
+              if service_data[:persistence][:timeout]
+                xml.Timeout service_data[:persistence][:timeout]
+              end
+            end
+            if service_data[:redirect_url]
+              xml.RedirectUrl service_data[:redirect_url]
+            end
+            if service_data[:trusted_network_group]
+              xml.TrustedNetworkGroup(:href => service_data[:trusted_network_group][:href], :name => service_data[:trusted_network_group][:name], :type => 'application/vnd.tmrk.cloud.trustedNetworkGroup')
+            end
+            if service_data[:backup_internet_service]
+              xml.BackupInternetService(:href => service_data[:backup_internet_service][:href], :name => service_data[:backup_internet_service][:name], :type => 'application/vnd.tmrk.cloud.backupInternetService')
+            end
+            if service_data[:load_balancing_method]
+              xml.LoadBalancingMethod service_data[:load_balancing_method]
+            end
+          end
+        end
+      end
+
+      class Mock
+        def internet_service_create(service_data)
+          validate_internet_service_data(service_data)
+          public_ip_id = service_data[:uri].match(/(\d+)/)[1]
+          public_ip    = self.data[:public_ips][public_ip_id.to_i].dup
+          service_id   = Fog::Mock.random_numbers(6).to_i
+          service = {
+            :href => "/cloudapi/ecloud/internetServices/#{service_id}",
+            :name => service_data[:name],
+            :type => "application/vnd.tmrk.cloud.internetService",
+            :Links => {
+              :Link => [
+                Fog::Ecloud.keep(public_ip, :href, :name, :type),
+              ],
+            },
+            :Protocol    => service_data[:protocol],
+            :Port        => service_data[:port],
+            :Enabled     => service_data[:enabled],
+            :Description => service_data[:description],
+            :PublicIp    => Fog::Ecloud.keep(public_ip, :href, :name, :type),
+            :Persistence => {
+              :Type => service_data[:persistence][:type],
+            },
+          }
+
+          internet_service_response = response(:body => service)
+
+          service.merge!(:public_ip => public_ip)
+
+          self.data[:internet_services][service_id] = service
+
+          internet_service_response
+        end
+      end
+    end
+  end
+end

data/lib/fog/ecloud/requests/compute/internet_service_delete.rb

@@ -0,0 +1,33 @@
+module Fog
+  module Compute
+    class Ecloud
+      class Real
+        basic_request :internet_service_delete, 202, 'DELETE'
+      end
+
+      class Mock
+        def internet_service_delete(uri)
+          service_id = id_from_uri(uri)
+
+          service = self.data[:internet_services][service_id].dup
+          self.data[:internet_services].delete(service_id)
+
+          task_id = Fog::Mock.random_numbers(10).to_i
+          task = {
+            :id            => task_id,
+            :href          => "/cloudapi/ecloud/tasks/#{task_id}",
+            :type          => "application/vnd.tmrk.cloud.task",
+            :Operation     => "Delete Service",
+            :Status        => "Complete",
+            :ImpactedItem  => Fog::Ecloud.keep(service, :name, :href, :type),
+            :StartTime     => Time.now.iso8601,
+            :CompletedTime => Time.now.iso8601,
+            :InitiatedBy   => {},
+          }
+          self.data[:tasks][task_id] = task
+          response(:body => task)
+        end
+      end
+    end
+  end
+end