fog 1.25.0 → 1.26.0

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,58 +0,0 @@
-module Fog
-  module Compute
-    class Ecloud
-      module Shared
-        def validate_edit_internet_service_options(options)
-          required_opts = [:name, :enabled, :persistence]
-          unless required_opts.all? { |opt| options.key?(opt) }
-            raise ArgumentError.new("Required data missing: #{(required_opts - options.keys).map(&:inspect).join(", ")}")
-          end
-          raise ArgumentError.new("Required data missing: #{:persistence[:type]}") unless options[:persistence][:type]
-        end
-
-        def build_node_service_body_edit(options)
-          xml = Builder::XmlMarkup.new
-          xml.InternetService(:name => options[:name]) do
-            xml.Enabled options[:enabled]
-            if options[:description]
-              xml.Description options[:description]
-            end
-            xml.Persistence do
-              xml.Type options[:persistence][:type]
-              if options[:persistence][:timeout]
-                xml.Timeout options[:persistence][:timeout]
-              end
-            end
-            if options[:redirect_url]
-              xml.RedirectUrl options[:redirect_url]
-            end
-            if options[:trusted_network_group]
-              xml.TrustedNetworkGroup(:href => options[:trusted_network_group][:href], :name => service_data[:trusted_network_group][:name], :type => 'application/vnd.tmrk.cloud.trustedNetworkGroup')
-            end
-            if options[:backup_internet_service]
-              xml.BackupInternetService(:href => options[:backup_internet_service][:href], :name => service_data[:backup_internet_service][:name], :type => 'application/vnd.tmrk.cloud.backupInternetService')
-            end
-            if options[:load_balancing_method]
-              xml.LoadBalancingMethod options[:load_balancing_method]
-            end
-          end
-        end
-      end
-
-      class Real
-        def node_service_edit(options)
-          validate_edit_node_service_options(options)
-          body = build_node_service_body_edit(options)
-          request(
-            :expects => 202,
-            :method => 'PUT',
-            :headers => {},
-            :body => body,
-            :uri => options[:uri],
-            :parse => true
-          )
-        end
-      end
-    end
-  end
-end