fog 1.3.1 → 1.4.0

data/lib/fog/bin/slicehost.rb

@@ -1,36 +0,0 @@
-class Slicehost < Fog::Bin
-  class << self
-
-    def class_for(key)
-      case key
-      when :compute
-        Fog::Compute::Slicehost
-      when :dns
-        Fog::DNS::Slicehost
-      else 
-        raise ArgumentError, "Unrecognized service: #{key}"
-      end
-    end
-
-    def [](service)
-      @@connections ||= Hash.new do |hash, key|
-        hash[key] = case key
-        when :compute
-          Fog::Logger.warning("Slicehost[:compute] is not recommended, use Compute[:slicehost] for portability")
-          Fog::Compute.new(:provider => 'Slicehost')
-        when :dns
-          Fog::Logger.warning("Slicehost[:dns] is deprecated, use Storage[:slicehost] instead")
-          Fog::DNS.new(:provider => 'Slicehost')
-        else
-          raise ArgumentError, "Unrecognized service: #{key.inspect}"
-        end
-      end
-      @@connections[service]
-    end
-
-    def services
-      Fog::Slicehost.services
-    end
-
-  end
-end

data/lib/fog/brightbox/requests/compute/resize_server.rb

@@ -1,19 +0,0 @@
-module Fog
-  module Compute
-    class Brightbox
-      class Real
-
-        def resize_server(identifier, options = {})
-          request(
-            :expects  => [202],
-            :method   => 'POST',
-            :path     => "/1.0/servers/#{identifier}/resize",
-            :headers  => {"Content-Type" => "application/json"},
-            :body     => MultiJson.encode(options)
-          )
-        end
-
-      end
-    end
-  end
-end

data/lib/fog/ecloud/models/compute/ip.rb

@@ -1,49 +0,0 @@
-module Fog
-  module Compute
-    class Ecloud
-      class Ip < Fog::Ecloud::Model
-
-        ignore_attributes :xmlns_i, :xmlns
-
-        identity :href, :aliases => :Href
-
-        attribute :name, :aliases => :Name
-        attribute :status, :aliases => :Status
-        attribute :server, :aliases => :Server
-        attribute :rnat, :aliases => :RnatAddress
-        attribute :id, :aliases => :Id, :type => :integer
-
-        def rnat=(new_rnat)
-          attributes[:rnat] = new_rnat
-          @changed = true
-        end
-
-        def save
-          if @changed
-            connection.configure_network_ip( href, _compose_network_ip_data )
-          end
-          true
-        end
-
-        def reload
-          super
-          @changed = false
-          self
-        end
-
-        private
-        def _compose_network_ip_data
-          {
-            :id => id,
-            :href => href,
-            :name => name,
-            :status => status,
-            :server => server,
-            :rnat => rnat
-          }
-        end
-
-      end
-    end
-  end
-end

data/lib/fog/ecloud/models/compute/ips.rb

@@ -1,32 +0,0 @@
-require 'fog/ecloud/models/compute/ip'
-
-module Fog
-  module Compute
-    class Ecloud
-      class Ips < Fog::Ecloud::Collection
-
-        model Fog::Compute::Ecloud::Ip
-
-        undef_method :create
-
-        attribute :href
-
-        def all
-          check_href!( :messages => "Ips href of a Network you want to enumerate" )
-          if data = connection.get_network_ips(href).body[:IpAddress]
-            load(data)
-          end
-        end
-
-        def get(uri)
-          if data = connection.get_network_ip(uri).body
-            new(data)
-          end
-        rescue Fog::Errors::NotFound
-          nil
-        end
-
-      end
-    end
-  end
-end

data/lib/fog/ecloud/models/compute/vdc.rb

@@ -1,81 +0,0 @@
-module Fog
-  module Compute
-    class Ecloud
-      class Vdc < Fog::Ecloud::Model
-
-        identity :href
-
-        ignore_attributes :xmlns, :xmlns_xsi, :xmlns_xsd
-
-        attribute :name
-        attribute :type
-        attribute :description, :aliases => :Description
-        attribute :other_links, :aliases => :Link
-        attribute :compute_capacity, :aliases => :ComputeCapacity
-        attribute :storage_capacity, :aliases => :StorageCapacity
-        attribute :available_networks, :aliases => :AvailableNetworks, :squash => :Network
-        attribute :resource_entities, :aliases => :ResourceEntities, :squash => :ResourceEntity
-        attribute :deployed_vm_quota
-        attribute :instantiated_vm_quota
-
-        def public_ips
-          @public_ips ||= collection_based_on_type("application/vnd.tmrk.ecloud.publicIpsList+xml")
-        end
-
-        def internet_services
-          @internet_services ||= collection_based_on_type("application/vnd.tmrk.ecloud.internetServicesList+xml")
-        end
-
-        def backup_internet_services
-          @backup_internet_services ||= collection_based_on_type("application/vnd.tmrk.ecloud.internetServicesList+xml", BackupInternetServices)
-        end
-
-        def networks
-          @networks ||= Fog::Compute::Ecloud::Networks.
-            new( :connection => connection,
-                 :href => href )
-        end
-
-        def servers
-          @servers ||= Fog::Compute::Ecloud::Servers.
-            new( :connection => connection,
-                 :href => href )
-        end
-
-        def tasks
-          @tasks ||= Fog::Compute::Ecloud::Tasks.
-            new( :connection => connection,
-                 :href => href + "/tasksList" )
-        end
-
-        def catalog
-          @catalog ||= collection_based_on_type("application/vnd.vmware.vcloud.catalog+xml")
-        end
-
-        def firewall_acls
-          @firewall_acls ||= collection_based_on_type("application/vnd.tmrk.ecloud.firewallAclsList+xml")
-        end
-
-        private
-
-        def collection_based_on_type(type, klass = nil)
-          load_unless_loaded!
-          if link = other_links.detect { |link| link[:type] == type }
-            case type
-            when "application/vnd.tmrk.ecloud.publicIpsList+xml"
-              Fog::Compute::Ecloud::PublicIps
-            when "application/vnd.tmrk.ecloud.internetServicesList+xml"
-              klass || Fog::Compute::Ecloud::InternetServices
-            when "application/vnd.vmware.vcloud.catalog+xml"
-              Fog::Compute::Ecloud::Catalog
-            when "application/vnd.tmrk.ecloud.firewallAclsList+xml"
-              Fog::Compute::Ecloud::FirewallAcls
-            end.new( :connection => connection, :href => link[:href] )
-          else
-            [ ]
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/ecloud/models/compute/vdcs.rb

@@ -1,40 +0,0 @@
-require 'fog/ecloud/models/compute/vdc'
-
-module Fog
-  module Compute
-    class Ecloud
-
-      class Vdcs < Collection
-
-        model Fog::Compute::Ecloud::Vdc
-
-        undef_method :create
-
-        def all
-          data = connection.get_organization(organization_uri).body[:Link].select { |link| link[:type] == "application/vnd.vmware.vcloud.vdc+xml" }
-          data.each { |link| link.delete_if { |key, value| [:rel].include?(key) } }
-          load(data)
-        end
-
-        def get(uri)
-          if data = connection.get_vdc(uri)
-            new(data.body)
-          end
-        rescue Fog::Errors::NotFound
-          nil
-        end
-
-        def organization_uri
-          @organizatio_uri ||= connection.default_organization_uri
-        end
-
-        private
-
-        def organization_uri=(new_organization_uri)
-          @organization_uri = new_organization_uri
-        end
-
-      end
-    end
-  end
-end

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

@@ -1,109 +0,0 @@
-module Fog
-  module Compute
-    class Ecloud
-      module Shared
-        def validate_backup_internet_service_data(service_data, configure=false)
-          required_opts = [:name, :protocol, :description, :enabled]
-          if configure
-            required_opts + [ :id, :href, :timeout ]
-          end
-          unless required_opts.all? { |opt| service_data.has_key?(opt) }
-            raise ArgumentError.new("Required Backup Internet Service data missing: #{(required_opts - service_data.keys).map(&:inspect).join(", ")}")
-          end
-        end
-      end
-
-      class Real
-        include Shared
-
-        def add_backup_internet_service(internet_services_uri, service_data)
-          validate_backup_internet_service_data(service_data)
-          if monitor = service_data[:monitor]
-            validate_internet_service_monitor(monitor)
-            ensure_monitor_defaults!(monitor)
-          end
-
-          request(
-            :body     => generate_backup_internet_service_request(service_data),
-            :expects  => 200,
-            :headers  => {'Content-Type' => 'application/xml'},
-            :method   => 'POST',
-            :uri      => internet_services_uri,
-            :parse    => true
-          )
-        end
-
-        private
-
-        def generate_backup_internet_service_request(service_data)
-          builder = Builder::XmlMarkup.new
-          builder.CreateBackupInternetServiceRequest("xmlns" => "urn:tmrk:eCloudExtensions-2.5") {
-            builder.Name(service_data[:name])
-            builder.Protocol(service_data[:protocol])
-            builder.Enabled(service_data[:enabled])
-            builder.Description(service_data[:description])
-            builder.RedirectURL(service_data[:redirect_url])
-            if monitor = service_data[:monitor]
-              generate_monitor_section(builder,monitor)
-            end
-          }
-        end
-      end
-
-      class Mock
-        include Shared
-
-        #
-        # Based on
-        # http://support.theenterprisecloud.com/kb/default.asp?id=729&Lang=1&SID=
-        # and many tears shed.
-        #
-
-        def add_backup_internet_service(internet_services_uri, service_data)
-          validate_backup_internet_service_data(service_data)
-
-          internet_services_uri = ensure_unparsed(internet_services_uri)
-
-          if vdc_internet_service_collection = mock_data.vdc_internet_service_collection_from_href(internet_services_uri)
-            new_backup_internet_service = MockBackupInternetService.new(service_data, vdc_internet_service_collection.backup_internet_services)
-            vdc_internet_service_collection.backup_internet_services << new_backup_internet_service
-            xml = generate_backup_internet_service_added_response(new_backup_internet_service)
-
-            mock_it 200, xml, {'Content-Type' => 'application/vnd.tmrk.ecloud.internetService+xml'}
-          else
-            mock_error 200, "401 Unauthorized"
-          end
-        end
-
-        private
-
-        def generate_backup_internet_service_added_response(new_backup_internet_service)
-          builder = Builder::XmlMarkup.new
-          builder.InternetService("xmlns" => "urn:tmrk:eCloudExtensions-2.5", "xmlns:i" => "http://www.w3.org/2001/XMLSchema-instance") {
-            builder.Id new_backup_internet_service.object_id
-            builder.Href new_backup_internet_service.href
-            builder.Name new_backup_internet_service.name
-            # so broken
-            builder.PublicIpAddress do
-              builder.Id -2147483648
-              builder.Id "http://totally.invalid/1234"
-              builder.Name
-            end
-            builder.Port new_backup_internet_service.port
-            builder.Protocol new_backup_internet_service.protocol
-            builder.Enabled new_backup_internet_service.enabled
-            builder.Timeout new_backup_internet_service.timeout
-            builder.Description new_backup_internet_service.description
-            builder.RedirectURL new_backup_internet_service.redirect_url
-            builder.Monitor "i:nil" => true
-            # so broken
-            builder.IsBackupService false
-            builder.BackupService "i:nil" => true
-            builder.BackupOf "i:nil" => true
-          }
-        end
-      end
-    end
-  end
-end
-

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

@@ -1,149 +0,0 @@
-module Fog
-  module Compute
-    class Ecloud
-      module Shared
-        def validate_internet_service_monitor(monitor)
-          #FIXME: Refactor this type of function into something generic
-          unless ['Disabled','HTTP','ECV'].include?(monitor[:type])
-            raise ArgumentError.new("Supported monitor types are: ECV & HTTP")
-          end
-
-          required_opts = case monitor[:type]
-                          when "Disabled"
-                            [:type, :is_enabled]
-                          else
-                            [:type, :url_send_string, :http_headers, :receive_string, :is_enabled]
-                          end
-
-          unless required_opts.all? { |opt| monitor.has_key?(opt) && monitor[opt] }
-            raise ArgumentError.new("Required Monitor data missing: #{(required_opts - monitor.keys).map(&:inspect).join(", ")}")
-          end
-
-          case monitor[:type]
-            when "HTTP", "ECV"
-              unless monitor[:http_headers].is_a?(Array) || monitor[:http_headers].is_a?(String)
-                raise ArgumentError.new("Monitor :http_headers must be a String or Array")
-              end
-          end
-
-          unless [true, false, "true", "false"].include?(monitor[:is_enabled])
-            raise ArgumentError.new("Monitor :is_enabled must be true or false")
-          end
-        end
-
-        def validate_internet_service_data(service_data, configure=false)
-          required_opts = [:name, :protocol, :port, :description, :enabled]
-          if configure
-            required_opts + [ :id, :href, :timeout ]
-          end
-          unless required_opts.all? { |opt| service_data.has_key?(opt) }
-            raise ArgumentError.new("Required Internet Service data missing: #{(required_opts - service_data.keys).map(&:inspect).join(", ")}")
-          end
-        end
-
-        def ensure_monitor_defaults!(monitor)
-          if monitor[:http_headers].is_a?(String)
-            monitor[:http_headers] = [ monitor[:http_headers] ]
-          end
-
-          unless monitor[:retries]
-            monitor[:retries] = 3
-          end
-
-          unless monitor[:response_timeout]
-            monitor[:response_timeout] = 2
-          end
-
-          unless monitor[:down_time]
-            monitor[:down_time] = 30
-          end
-
-          unless monitor[:interval]
-            monitor[:interval] = 5
-          end
-        end
-      end
-
-      class Real
-        include Shared
-
-        def add_internet_service(internet_services_uri, service_data)
-          validate_internet_service_data(service_data)
-          if monitor = service_data[:monitor]
-            validate_internet_service_monitor(monitor)
-            ensure_monitor_defaults!(monitor)
-          end
-
-          request(
-            :body     => generate_internet_service_request(service_data),
-            :expects  => 200,
-            :headers  => {'Content-Type' => 'application/vnd.tmrk.ecloud.internetService+xml'},
-            :method   => 'POST',
-            :uri      => internet_services_uri,
-            :parse    => true
-          )
-        end
-
-        private
-
-        def generate_internet_service_request(service_data)
-          builder = Builder::XmlMarkup.new
-          builder.CreateInternetServiceRequest(ecloud_xmlns) {
-            builder.Name(service_data[:name])
-            builder.Protocol(service_data[:protocol])
-            builder.Port(service_data[:port])
-            builder.Enabled(service_data[:enabled])
-            builder.Description(service_data[:description])
-            builder.RedirectURL(service_data[:redirect_url])
-            if monitor = service_data[:monitor]
-              generate_monitor_section(builder,monitor)
-            end
-          }
-        end
-
-        def generate_monitor_section(builder, monitor)
-          builder.Monitor {
-            builder.MonitorType(monitor[:type])
-            case monitor[:type]
-            when "ECV","HTTP"
-              builder.UrlSendString(monitor[:url_send_string])
-              builder.HttpHeader(monitor[:http_headers].join("\n"))
-              builder.ReceiveString(monitor[:receive_string])
-              builder.Interval(monitor[:interval])
-              builder.ResponseTimeOut(monitor[:response_timeout])
-              builder.DownTime(monitor[:downtime])
-              builder.Retries(monitor[:retries])
-            end
-            builder.IsEnabled(monitor[:is_enabled])
-          }
-        end
-
-      end
-
-      class Mock
-        include Shared
-
-        #
-        # Based on
-        # http://support.theenterprisecloud.com/kb/default.asp?id=561&Lang=1&SID=
-        #
-
-        def add_internet_service(internet_services_uri, service_data)
-          validate_internet_service_data(service_data)
-
-          internet_services_uri = ensure_unparsed(internet_services_uri)
-
-          if public_ip_internet_service_collection = mock_data.public_ip_internet_service_collection_from_href(internet_services_uri)
-            new_public_ip_internet_service = MockPublicIpInternetService.new(service_data, public_ip_internet_service_collection)
-            public_ip_internet_service_collection.items << new_public_ip_internet_service
-            xml = generate_internet_service(Builder::XmlMarkup.new, new_public_ip_internet_service, true)
-
-            mock_it 200, xml, {'Content-Type' => 'application/vnd.tmrk.ecloud.internetService+xml'}
-          else
-            mock_error 200, "401 Unauthorized"
-          end
-        end
-      end
-    end
-  end
-end