fog 1.8.0 → 1.9.0

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

@@ -6,6 +6,28 @@ module Fog
         basic_request :get_public_ips
       end
 
+      class Mock
+        def get_public_ips(uri)
+
+          environment_id = id_from_uri(uri)
+          environment    = self.data[:environments][environment_id]
+
+          public_ips  = self.data[:public_ips].values.select{|cp| cp[:environment_id] == environment_id}
+
+          public_ips = public_ips.map{|pi| Fog::Ecloud.slice(pi, :id, :environment_id)}
+
+          public_ip_response = {:PublicIp => (public_ips.size > 1 ? public_ips : public_ips.first)} # GAH
+          body = {
+            :href  => uri,
+            :type  => "application/vnd.tmrk.cloud.publicIp; type=collection",
+            :Links => {
+              :Link => environment,
+            }
+          }.merge(public_ip_response)
+
+          response(:body => body)
+        end
+      end
     end
   end
 end

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

@@ -1,11 +1,18 @@
 module Fog
   module Compute
     class Ecloud
-
       class Real
         basic_request :get_row
       end
 
+      class Mock
+        def get_row(uri)
+          row_id = id_from_uri(uri)
+          row = self.data[:rows][row_id]
+
+          response(:body =>  row)
+        end
+      end
     end
   end
 end

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

@@ -1,11 +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

@@ -6,6 +6,17 @@ module Fog
         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 response(:status => 404) # ?
+          end
+        end
+      end
     end
   end
 end

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

@@ -1,11 +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

@@ -6,6 +6,17 @@ module Fog
         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

@@ -6,6 +6,26 @@ module Fog
         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_task.rb

@@ -1,11 +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_template.rb

@@ -6,6 +6,17 @@ module Fog
         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

@@ -6,6 +6,44 @@ module Fog
         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_virtual_machine_assigned_ips.rb

@@ -0,0 +1,44 @@
+module Fog
+  module Compute
+    class Ecloud
+
+      class Real
+        def get_virtual_machine_assigned_ips(virtual_machine_id)
+          request(
+            :uri => "/cloudapi/ecloud/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_delete.rb

@@ -1,11 +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/internet_service_create.rb

@@ -62,6 +62,41 @@ module Fog
           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          
+end

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

@@ -6,6 +6,29 @@ module Fog
         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

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

@@ -40,6 +40,54 @@ module Fog
           end
         end
       end
+
+      class Mock
+        def node_service_create(service_data)
+          validate_node_service_data(service_data)
+
+          internet_service_id = service_data[:uri].match(/(\d+)/)[1]
+          internet_service    = self.data[:internet_services][internet_service_id.to_i].dup
+          network_id, ip_address_name     = service_data[:ip_address].match(/\/(\d+)\/(.*)$/).captures
+          network = self.data[:networks][network_id.to_i]
+          ip_addresses = network[:IpAddresses][:IpAddress]
+          ip_addresses = ip_addresses.is_a?(Array) ? ip_addresses : [ip_addresses]
+          ip_address = ip_addresses.detect { |ip| ip[:name] == ip_address_name }
+
+          service_id   = Fog::Mock.random_numbers(6).to_i
+          service = {
+            :href => "/cloudapi/ecloud/nodeservices/#{service_id}",
+            :name => service_data[:name],
+            :type => "application/vnd.tmrk.cloud.nodeService",
+            :Links => {
+              :Link => [
+                Fog::Ecloud.keep(internet_service, :href, :name, :type),
+              ],
+            },
+            :Protocol    => service_data[:protocol],
+            :Port        => service_data[:port],
+            :Enabled     => service_data[:enabled],
+            :Description => service_data[:description],
+            :IpAddress   => {
+              :href => ip_address[:href],
+              :name => ip_address[:name],
+              :type => ip_address[:type],
+              :Network => {
+                :href => network[:href],
+                :name => network[:name],
+                :type => network[:type],
+              },
+            },
+          }
+
+          node_service_response = response(:body => service)
+
+          service.merge!(:internet_service => internet_service)
+
+          self.data[:node_services][service_id] = service
+
+          node_service_response
+        end
+      end
     end
   end
-end          
+end