fog 1.41.0 → 2.1.0

data/lib/fog/ovirt/requests/compute/remove_from_affinity_group.rb

@@ -1,21 +0,0 @@
-module Fog
-  module Compute
-    class Ovirt
-     class Real
-        def remove_from_affinity_group(id, options = {})
-          raise ArgumentError, "instance id is a required parameter" unless id
-          raise ArgumentError, "affinity group id is a required parameter for remove-from-affinity-group" unless options.key? :id
-          client.delete_vm_from_affinity_group(options[:id], id)
-        end
-      end
-
-      class Mock
-        def remove_from_affinity_group(id, options = {})
-          raise ArgumentError, "instance id is a required parameter" unless id
-          raise ArgumentError, "affinity group id is a required parameter for remove-from-affinity-group" unless options.key? :id
-          true
-        end
-      end
-    end
-  end
-end

data/lib/fog/ovirt/requests/compute/storage_domains.rb

@@ -1,20 +0,0 @@
-module Fog
-  module Compute
-    class Ovirt
-      class Real
-        def storage_domains filter={}
-          client.storagedomains(filter)
-        end
-      end
-
-      class Mock
-        def storage_domains(filters = {})
-          xml = read_xml 'storage_domains.xml'
-          Nokogiri::XML(xml).xpath('/storage_domains/storage_domain').map do |sd|
-            OVIRT::StorageDomain::new(self, sd)
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/ovirt/requests/compute/update_interface.rb

@@ -1,35 +0,0 @@
-module Fog
-  module Compute
-    class Ovirt
-
-      module Shared
-        def check_arguments(id, options)
-          raise ArgumentError, "instance id is a required parameter" unless id
-          raise ArgumentError, "interface id is a required parameter for update-interface" unless options.key? :id
-        end
-      end
-
-      class Real
-        extend ::Fog::Compute::Ovirt::Shared
-
-        def update_interface(id, options)
-          check_arguments(id, options)
-
-          interface_id = options[:id]
-          options.delete(:id)
-
-          client.update_interface(id, interface_id, options)
-        end
-      end
-
-      class Mock
-        extend ::Fog::Compute::Ovirt::Shared
-
-        def update_interface(id, options)
-          check_arguments(id, options)
-          true
-        end
-      end
-    end
-  end
-end

data/lib/fog/ovirt/requests/compute/update_vm.rb

@@ -1,18 +0,0 @@
-module Fog
-  module Compute
-    class Ovirt
-      class Real
-        def update_vm(attrs)
-          client.update_vm(attrs)
-        end
-      end
-
-      class Mock
-        def update_vm(attrs)
-          xml = read_xml('vm.xml')
-          OVIRT::VM::new(self, Nokogiri::XML(xml).root)
-        end
-      end
-    end
-  end
-end

data/lib/fog/ovirt/requests/compute/update_volume.rb

@@ -1,39 +0,0 @@
-module Fog
-  module Compute
-    class Ovirt
-
-      module Shared
-        def check_arguments(id, options)
-          raise ArgumentError, "instance id is a required parameter" unless id
-          raise ArgumentError, "disk id is a required parameter for update-volume" unless options.has_key? :id
-        end
-      end
-
-
-      class Real
-        extend ::Fog::Compute::Ovirt::Shared
-
-        def update_volume(id, options)
-          check_arguments(id, options)
-
-          disk_id = options[:id]
-          options.delete(:id)
-
-          client.update_volume(id, disk_id, options)
-          true # If we come here, expect success and return true
-        end
-
-      end
-
-      class Mock
-        extend ::Fog::Compute::Ovirt::Shared
-
-        def update_volume(id, options)
-          check_arguments(id, options)
-          true
-        end
-      end
-
-    end
-  end
-end

data/lib/fog/ovirt/requests/compute/vm_action.rb

@@ -1,22 +0,0 @@
-module Fog
-  module Compute
-    class Ovirt
-      class Real
-        def vm_action(options = {})
-          raise ArgumentError, "instance id is a required parameter" unless options.key? :id
-          raise ArgumentError, "action is a required parameter" unless options.key? :action
-
-          client.vm_action options[:id], options[:action]
-        end
-      end
-
-      class Mock
-        def vm_action(options = {})
-          raise ArgumentError, "id is a required parameter" unless options.key? :id
-          raise ArgumentError, "action is a required parameter" unless options.key? :action
-          true
-        end
-      end
-    end
-  end
-end

data/lib/fog/ovirt/requests/compute/vm_start_with_cloudinit.rb

@@ -1,19 +0,0 @@
-module Fog
-  module Compute
-    class Ovirt
-      class Real
-        def vm_start_with_cloudinit(options = {})
-          raise ArgumentError, "instance id is a required parameter" unless options.key? :id
-          client.vm_start_with_cloudinit(options[:id], options[:user_data])
-        end
-      end
-
-      class Mock
-        def vm_start_with_cloudinit(options = {})
-          raise ArgumentError, "instance id is a required parameter" unless options.key? :id
-          true
-        end
-      end
-    end
-  end
-end

data/lib/fog/ovirt/requests/compute/vm_ticket.rb

@@ -1,17 +0,0 @@
-module Fog
-  module Compute
-    class Ovirt
-      class Real
-        def vm_ticket(id, options = {})
-          client.set_ticket(id, options)
-        end
-      end
-
-      class Mock
-        def vm_ticket(id, options = {})
-          "Secret"
-        end
-      end
-    end
-  end
-end

data/lib/fog/ovirt.rb

@@ -1 +0,0 @@
-require 'fog/ovirt/compute'

data/lib/fog/zerigo/core.rb

@@ -1,10 +0,0 @@
-require 'fog/core'
-require 'fog/xml'
-
-module Fog
-  module Zerigo
-    extend Fog::Provider
-
-    service(:dns, 'DNS')
-  end
-end

data/lib/fog/zerigo/dns.rb

@@ -1,114 +0,0 @@
-require 'fog/zerigo/core'
-
-module Fog
-  module DNS
-    class Zerigo < Fog::Service
-      requires :zerigo_email, :zerigo_token
-      recognizes :host, :persistent, :port, :scheme, :timeout
-
-      model_path 'fog/zerigo/models/dns'
-      model       :record
-      collection  :records
-      model       :zone
-      collection  :zones
-
-      request_path 'fog/zerigo/requests/dns'
-      request :count_hosts
-      request :count_zones
-      request :create_host
-      request :create_zone
-      request :delete_host
-      request :delete_zone
-      request :find_hosts
-      request :get_host
-      request :get_zone
-      request :get_zone_stats
-      request :list_zones
-      request :list_hosts
-      request :update_host
-      request :update_zone
-
-      class Mock
-        def self.data
-          @data ||= Hash.new do |hash, key|
-            hash[key] = key == :zones ? [] : {}
-          end
-        end
-
-        def self.reset
-          @data = nil
-        end
-
-        def initialize(options={})
-          @zerigo_email = options[:zerigo_email]
-          @zerigo_token = options[:zerigo_token]
-        end
-
-        def data
-          self.class.data
-        end
-
-        def reset_data
-          self.class.reset
-        end
-
-        def find_by_zone_id(zone_id)
-          self.data[:zones].find { |z| z['id'] == zone_id }
-        end
-
-        def find_by_domain(domain)
-          self.data[:zones].find { |z| z['domain'] == domain }
-        end
-
-        def find_host(host_id)
-          self.data[:zones].map { |z| z['hosts'].find { |h| h['id'] == host_id } }.compact.first
-        end
-      end
-
-      class Real
-        def initialize(options={})
-
-          @zerigo_email  = options[:zerigo_email]
-          @zerigo_token  = options[:zerigo_token]
-          @connection_options = options[:connection_options] || {}
-          @host       = options[:host]        || "ns.zerigo.com"
-          @persistent = options[:persistent]  || false
-          @port       = options[:port]        || 80
-          @scheme     = options[:scheme]      || 'http'
-          @connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
-        end
-
-        def reload
-          @connection.reset
-        end
-
-        def request(params)
-          params[:headers] ||= {}
-          key= "#{@zerigo_email}:#{@zerigo_token}"
-          params[:headers].merge!({
-            'Authorization' => "Basic #{Base64.encode64(key).delete("\r\n")}"
-          })
-          case params[:method]
-          when 'DELETE', 'GET', 'HEAD'
-            params[:headers]['Accept'] = 'application/xml'
-          when 'POST', 'PUT'
-            params[:headers]['Content-Type'] = 'application/xml'
-          end
-
-          begin
-            response = @connection.request(params)
-          rescue Excon::Errors::HTTPStatusError => error
-            raise case error
-            when Excon::Errors::NotFound
-              Fog::DNS::Zerigo::NotFound.slurp(error)
-            else
-              error
-            end
-          end
-
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/zerigo/models/dns/record.rb

@@ -1,66 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module DNS
-    class Zerigo
-      class Record < Fog::Model
-        extend Fog::Deprecation
-        deprecate :ip, :value
-        deprecate :ip=, :value=
-
-        identity :id
-
-        attribute :created_at,  :aliases => 'created-at'
-        attribute :value,       :aliases => 'data'
-        attribute :domain,      :aliases => 'fqdn'
-        attribute :name,        :aliases => 'hostname'
-        attribute :description, :aliases => 'notes'
-        attribute :priority
-        attribute :ttl
-        attribute :type,        :aliases => 'host-type'
-        attribute :updated_at,  :aliases => 'updated-at'
-        attribute :zone_id,     :aliases => 'zone-id'
-
-        def initialize(attributes={})
-          super
-        end
-
-        def destroy
-          requires :identity
-          service.delete_host(identity)
-          true
-        end
-
-        def zone
-          @zone
-        end
-
-        def save
-          requires :zone, :type, :value
-          options = {}
-          options[:hostname]  = name if name
-          options[:notes]     = description if description
-          options[:priority]  = priority if priority
-          options[:ttl]       = ttl if ttl
-
-          if persisted?
-            options[:host_type] = type
-            options[:data]      = value
-            service.update_host(identity, options)
-          else
-            data = service.create_host(@zone.id, type, value, options)
-            merge_attributes(data.body)
-          end
-
-          true
-        end
-
-        private
-
-        def zone=(new_zone)
-          @zone = new_zone
-        end
-      end
-    end
-  end
-end

data/lib/fog/zerigo/models/dns/records.rb

@@ -1,45 +0,0 @@
-require 'fog/core/collection'
-require 'fog/zerigo/models/dns/record'
-
-module Fog
-  module DNS
-    class Zerigo
-      class Records < Fog::Collection
-        attribute :zone
-
-        model Fog::DNS::Zerigo::Record
-
-        # List all domains
-        # @param [Hash] options Options to pass to the underlying API call
-        # @option options [String] :fqdn search for the given fqdn
-        def all(options = {})
-          requires :zone
-          if options[:fqdn]
-            hosts = service.find_hosts(options[:fqdn], zone.id).body['hosts']
-            load(hosts)
-          else
-            parent = zone.collection.get(zone.identity)
-            if parent
-              merge_attributes(parent.records.attributes)
-              load(parent.records.map {|record| record.attributes})
-            else
-              nil
-            end
-          end
-        end
-
-        def get(record_id)
-          data = service.get_host(record_id).body
-          new(data)
-        rescue Fog::Service::NotFound
-          nil
-        end
-
-        def new(attributes = {})
-          requires :zone
-          super({ :zone => zone }.merge!(attributes))
-        end
-      end
-    end
-  end
-end

data/lib/fog/zerigo/models/dns/zone.rb

@@ -1,84 +0,0 @@
-require 'fog/core/model'
-require 'fog/zerigo/models/dns/records'
-
-module Fog
-  module DNS
-    class Zerigo
-      class Zone < Fog::Model
-        identity :id
-
-        attribute :created_at,  :aliases => 'created-at'
-        attribute :domain
-        attribute :ttl,         :aliases => 'default-ttl'
-        attribute :type,        :aliases => 'ns-type'
-        attribute :updated_at,  :aliases => 'updated-at'
-
-        # <custom-nameservers>ns1.example.com,ns2.example.com</custom-nameservers>
-        # <custom-ns type="boolean">true</custom-ns>
-        # <hostmaster>dnsadmin@example.com</hostmaster>
-        # <notes nil="true"/>
-        # <ns1 nil="true"/>
-        # <nx-ttl nil="true"></nx-ttl>
-        # <slave-nameservers nil="true"/>
-        # <tag-list>one two</tag-list>
-        # <hosts-count>1</hosts-count>
-
-        def initialize(attributes={})
-          self.type ||= 'pri_sec'
-          super
-        end
-
-        def destroy
-          requires :identity
-          service.delete_zone(identity)
-          true
-        end
-
-        def records
-          @records ||= begin
-            Fog::DNS::Zerigo::Records.new(
-              :zone       => self,
-              :service => service
-            )
-          end
-        end
-
-        def nameservers
-          [
-            'a.ns.zerigo.net',
-            'b.ns.zerigo.net',
-            'c.ns.zerigo.net',
-            'd.ns.zerigo.net',
-            'e.ns.zerigo.net'
-          ]
-        end
-
-        def save
-          self.ttl ||= 3600
-          requires :domain, :type, :ttl
-          options = {}
-          # * options<~Hash> - optional paramaters
-          #   * ns1<~String> - required if ns_type == sec
-          #   * nx_ttl<~Integer> -
-          #   * slave_nameservers<~String> - required if ns_type == pri
-          #   * axfr_ips<~String> - comma-separated list of IPs or IP blocks allowed to perform AXFRs
-          #   * custom_nameservers<~String> - comma-separated list of custom nameservers
-          #   * custom_ns<~String> - indicates if vanity (custom) nameservers are enabled for this domain
-          #   * hostmaster<~String> - email of the DNS administrator or hostmaster
-          #   * notes<~String> - notes about the domain
-          #   * restrict_axfr<~String> - indicates if AXFR transfers should be restricted to IPs in axfr-ips
-          #   * tag_list<~String> - List of all tags associated with this domain
-          data = unless identity
-            service.create_zone(domain, ttl, type, options)
-          else
-            options[:default_ttl] = ttl
-            options[:ns_type]     = type
-            service.update_zone(identity, options)
-          end
-          merge_attributes(data.body)
-          true
-        end
-      end
-    end
-  end
-end

data/lib/fog/zerigo/models/dns/zones.rb

@@ -1,26 +0,0 @@
-require 'fog/core/collection'
-require 'fog/zerigo/models/dns/zone'
-
-module Fog
-  module DNS
-    class Zerigo
-      class Zones < Fog::Collection
-        model Fog::DNS::Zerigo::Zone
-
-        def all(options = {})
-          data = service.list_zones(options).body['zones']
-          load(data)
-        end
-
-        def get(zone_id_or_domain)
-          data = service.get_zone(zone_id_or_domain).body
-          zone = new(data)
-          zone.records.load(data['hosts'])
-          zone
-        rescue Fog::Service::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/fog/zerigo/parsers/dns/count_hosts.rb

@@ -1,20 +0,0 @@
-module Fog
-  module Parsers
-    module DNS
-      module Zerigo
-        class CountHosts < Fog::Parsers::Base
-          def reset
-            @response = {}
-          end
-
-          def end_element(name)
-            case name
-            when 'count'
-              @response[name] = value.to_i
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/zerigo/parsers/dns/count_zones.rb

@@ -1,20 +0,0 @@
-module Fog
-  module Parsers
-    module DNS
-      module Zerigo
-        class CountZones < Fog::Parsers::Base
-          def reset
-            @response = {}
-          end
-
-          def end_element(name)
-            case name
-            when 'count'
-              @response[name] = value.to_i
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/zerigo/parsers/dns/create_host.rb

@@ -1,24 +0,0 @@
-module Fog
-  module Parsers
-    module DNS
-      module Zerigo
-        class CreateHost < Fog::Parsers::Base
-          def reset
-            @response = {}
-          end
-
-          def end_element(name)
-            case name
-            when 'id', 'zone-id'
-              @response[name] = value.to_i
-            when 'priority', 'ttl'
-              @response[name] = value.to_i if value
-            when 'data', 'fqdn', 'host-type', 'hostname', 'notes', 'zone-id', 'created-at', 'updated-at'
-              @response[name] = value
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/zerigo/parsers/dns/create_zone.rb

@@ -1,22 +0,0 @@
-module Fog
-  module Parsers
-    module DNS
-      module Zerigo
-        class CreateZone < Fog::Parsers::Base
-          def reset
-            @response = {}
-          end
-
-          def end_element(name)
-            case name
-            when 'default-ttl', 'id', 'nx-ttl', 'hosts-count'
-              @response[name] = value.to_i
-            when 'created-at', 'custom-nameservers', 'custom-ns', 'domain', 'hostmaster', 'notes', 'ns1', 'ns-type', 'slave-nameservers', 'tag-list', 'updated-at', 'hosts', 'axfr-ips', 'restrict-axfr'
-              @response[name] = value
-            end
-          end
-        end
-      end
-    end
-  end
-end

data/lib/fog/zerigo/parsers/dns/find_hosts.rb

@@ -1,28 +0,0 @@
-module Fog
-  module Parsers
-    module DNS
-      module Zerigo
-        class FindHosts < Fog::Parsers::Base
-          def reset
-            @host = {}
-            @response = { 'hosts' => [] }
-          end
-
-          def end_element(name)
-            case name
-            when 'id', 'zone-id'
-              @host[name] = value.to_i
-            when 'priority', 'ttl'
-              @host[name] = value.to_i if value
-            when 'data', 'fqdn', 'host-type', 'hostname', 'notes', 'zone-id', 'created-at', 'updated-at'
-              @host[name] = value
-            when 'host'
-              @response['hosts'] << @host
-              @host = {}
-            end
-          end
-        end
-      end
-    end
-  end
-end