phpfog-fog 0.4.1

data/lib/fog/dns/linode.rb

@@ -0,0 +1,99 @@
+module Fog
+  module Linode
+    class DNS < Fog::Service
+
+      requires :linode_api_key
+      recognizes :port, :scheme, :persistent
+      recognizes :provider # remove post deprecation
+
+      model_path 'fog/dns/models/linode'
+      model       :record
+      collection  :records
+      model       :zone
+      collection  :zones
+
+      request_path 'fog/dns/requests/linode'
+      request :domain_create
+      request :domain_delete
+      request :domain_list
+      request :domain_update
+      request :domain_resource_create
+      request :domain_resource_delete
+      request :domain_resource_list
+      request :domain_resource_update
+
+      class Mock
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {}
+          end
+        end
+
+        def self.reset_data(keys=data.keys)
+          for key in [*keys]
+            data.delete(key)
+          end
+        end
+
+        def initialize(options={})
+          unless options.delete(:provider)
+            location = caller.first
+            warning = "[yellow][WARN] Fog::Linode::DNS.new is deprecated, use Fog::DNS.new(:provider => 'Linode') instead[/]"
+            warning << " [light_black](" << location << ")[/] "
+            Formatador.display_line(warning)
+          end
+
+          @linode_api_key = options[:linode_api_key]
+          @data = self.class.data[@linode_api_key]
+        end
+
+      end
+
+      class Real
+
+        def initialize(options={})
+          unless options.delete(:provider)
+            location = caller.first
+            warning = "[yellow][WARN] Fog::Linode::DNS.new is deprecated, use Fog::DNS.new(:provider => 'Linode') instead[/]"
+            warning << " [light_black](" << location << ")[/] "
+            Formatador.display_line(warning)
+          end
+
+          require 'json'
+          @linode_api_key = options[:linode_api_key]
+          @host   = options[:host]    || "api.linode.com"
+          @port   = options[:port]    || 443
+          @scheme = options[:scheme]  || 'https'
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", options[:persistent])
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def request(params)
+          params[:query] ||= {}
+          params[:query].merge!(:api_key => @linode_api_key)
+
+          response = @connection.request(params.merge!({:host => @host}))
+
+          unless response.body.empty?
+            response.body = JSON.parse(response.body)
+            if data = response.body['ERRORARRAY'].first
+              error = case data['ERRORCODE']
+              when 5
+                Fog::Linode::DNS::NotFound
+              else
+                Fog::Linode::DNS::Error
+              end
+              raise error.new(data['ERRORMESSAGE'])
+            end
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class DNS
+
+      class Record < Fog::Model
+
+        identity :id,           :aliases => ['Id']
+
+        attribute :ip,          :aliases => ['ResourceRecords']
+        attribute :name,        :aliases => ['Name']
+        attribute :ttl,         :aliases => ['TTL']
+        attribute :type,        :aliases => ['Type']
+        attribute :status,      :aliases => ['Status']
+        attribute :created_at,  :aliases => ['SubmittedAt']
+
+        def initialize(attributes={})
+          self.ttl    ||= 3600
+          super
+        end
+
+        def destroy
+          requires :ip, :name, :ttl, :type, :zone
+          options = {
+            :action           => 'DELETE',
+            :name             => name,
+            :resource_records => [*ip],
+            :ttl              => ttl,
+            :type             => type
+          }
+          connection.change_resource_record_sets(zone.id, [options])
+          true
+        end
+
+        def zone
+          @zone
+        end
+
+        def save
+          requires :ip, :name, :ttl, :type, :zone
+          options = {
+            :action           => 'CREATE',
+            :name             => name,
+            :resource_records => [*ip],
+            :ttl              => ttl,
+            :type             => type
+          }
+          data = connection.change_resource_record_sets(zone.id, [options]).body
+          merge_attributes(data)
+          true
+        end
+
+        private
+
+        def zone=(new_zone)
+          @zone = new_zone
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require 'fog/core/collection'
+require 'fog/dns/models/aws/record'
+
+module Fog
+  module AWS
+    class DNS
+
+      class Records < Fog::Collection
+
+        attribute :is_truncated,      :aliases => ['IsTruncated']
+        attribute :max_items,         :aliases => ['MaxItems']
+        attribute :name
+        attribute :next_record_name,  :aliases => ['NextRecordName']
+        attribute :next_record_type,  :aliases => ['NextRecordType']
+        attribute :type
+
+        attribute :zone
+
+        model Fog::AWS::DNS::Record
+
+        def all(options = {})
+          requires :zone
+          options['MaxItems'] ||= max_items
+          options['Name']     ||= name
+          options['Type']     ||= type
+          data = connection.list_resource_record_sets(zone.id, options).body
+          merge_attributes(data.reject {|key, value| !['IsTruncated', 'MaxItems', 'NextRecordName', 'NextRecordType'].include?(key)})
+          # leave out the default, read only records
+          data = data['ResourceRecordSets'].reject {|record| ['NS', 'SOA'].include?(record['Type'])}
+          load(data)
+        end
+
+        def get(record_id)
+          data = connection.get_change(record_id).body
+          new(data)
+        rescue Excon::Errors::BadRequest
+          nil
+        end
+
+        def new(attributes = {})
+          requires :zone
+          super({ :zone => zone }.merge!(attributes))
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,53 @@
+require 'fog/core/model'
+# require 'fog/dns/models/aws/records'
+
+module Fog
+  module AWS
+    class DNS
+
+      class Zone < Fog::Model
+
+        identity :id,                 :aliases => 'Id'
+
+        attribute :caller_reference,  :aliases => 'CallerReference'
+        attribute :change_info,       :aliases => 'ChangeInfo'
+        attribute :description,       :aliases => 'Comment'
+        attribute :domain,            :aliases => 'Name'
+        attribute :nameservers,       :aliases => 'NameServers'
+
+        def destroy
+          requires :identity
+          connection.delete_hosted_zone(identity)
+          true
+        end
+
+        def records
+          @records ||= begin
+            Fog::AWS::DNS::Records.new(
+              :zone       => self,
+              :connection => connection
+            )
+          end
+        end
+
+        def save
+          requires :domain
+          options = {}
+          options[:caller_ref]  = caller_reference if caller_reference
+          options[:comment]     = description if description
+          data = connection.create_hosted_zone(domain, options).body
+          merge_attributes(data)
+          true
+        end
+
+        private
+
+        define_method(:HostedZone=) do |new_hosted_zone|
+          merge_attributes(new_hosted_zone)
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'fog/core/collection'
+require 'fog/dns/models/aws/zone'
+
+module Fog
+  module AWS
+    class DNS
+
+      class Zones < Fog::Collection
+
+        attribute :marker,    :aliases => 'Marker'
+        attribute :max_items, :aliases => 'MaxItems'
+
+        model Fog::AWS::DNS::Zone
+
+        def all(options = {})
+          options['marker']   ||= marker
+          options['maxitems'] ||= max_items
+          data = connection.list_hosted_zones(options).body['HostedZones']
+          load(data)
+        end
+
+        def get(zone_id)
+          data = connection.get_hosted_zone(zone_id).body
+          new(data)
+        rescue Excon::Errors::BadRequest
+          nil
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+require 'fog/core/model'
+
+module Fog
+  module Linode
+    class DNS
+
+      class Record < Fog::Model
+
+        identity :id,         :aliases => ['ResourceID', 'RESOURCEID']
+
+        attribute :ip,        :aliases => 'TARGET'
+        attribute :name,      :aliases => 'NAME'
+        attribute :priority,  :aliases => 'PRIORITY'
+        attribute :ttl,       :aliases => 'TTL_SEC'
+        attribute :type,      :aliases => 'TYPE'
+        attribute :zone_id,   :aliases => 'DOMAINID'
+
+        # "PROTOCOL":"",
+        # "WEIGHT":0,
+        # "PORT":0,
+
+        def initialize(attributes={})
+          self.ttl    ||= 3600
+          super
+        end
+
+        def destroy
+          requires :identity, :zone
+          connection.domain_resource_delete(zone.id, identity)
+          true
+        end
+
+        def zone
+          @zone
+        end
+
+        def save
+          requires :type, :zone
+          options = {}
+          # * options<~Hash>
+          #   * weight<~Integer>: default: 5
+          #   * port<~Integer>: default: 80 
+          #   * protocol<~String>: The protocol to append to an SRV record. Ignored on other record 
+          #                        types. default: udp
+          options[:name]      = name if name
+          options[:priority]  = priority if priority
+          options[:target]    = ip if ip
+          options[:ttl_sec]   = ttl if ttl
+          response = unless identity
+            connection.domain_resource_create(zone.identity, type, options)
+          else
+            options[:type] = type if type
+            connection.domain_resource_update(zone.identity, identity, options)
+          end
+          merge_attributes(response.body['DATA'])
+          true
+        end
+
+        private
+        
+        def zone=(new_zone)
+          @zone = new_zone
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require 'fog/core/collection'
+require 'fog/dns/models/linode/record'
+
+module Fog
+  module Linode
+    class DNS
+
+      class Records < Fog::Collection
+
+        attribute :zone
+
+        model Fog::Linode::DNS::Record
+
+        def all
+          requires :zone
+          data = connection.domain_resource_list(zone.id).body['DATA']
+          load(data)
+        end
+
+        def get(record_id)
+          if data = connection.domain_resource_list(zone.id, record_id).body['DATA'].first
+            new(data)
+          else
+            nil
+          end
+        end
+
+        def new(attributes = {})
+          requires :zone
+          super({ :zone => zone }.merge!(attributes))
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,84 @@
+require 'fog/core/model'
+require 'fog/dns/models/linode/records'
+
+module Fog
+  module Linode
+    class DNS
+
+      class Zone < Fog::Model
+
+        identity :id,           :aliases => ['DomainID', 'DOMAINID', 'ResourceID']
+
+        attribute :description, :aliases => 'DESCRIPTION'
+        attribute :domain,      :aliases => 'DOMAIN'
+        attribute :email,       :aliases => 'SOA_EMAIL'
+        attribute :ttl,         :aliases => 'TTL_SEC'
+        attribute :type,        :aliases => 'TYPE'
+
+        # "STATUS":1,
+        # "RETRY_SEC":0,
+        # "MASTER_IPS":"",
+        # "EXPIRE_SEC":0,
+        # "REFRESH_SEC":0,
+        # "TTL_SEC":0
+
+        def initialize(attributes={})
+          self.type ||= 'master'
+          self.ttl  ||= 3600
+          super
+        end
+
+        def destroy
+          requires :identity
+          connection.domain_delete(identity)
+          true
+        end
+
+        def records
+          @records ||= begin
+            Fog::Linode::DNS::Records.new(
+              :zone       => self,
+              :connection => connection
+            )
+          end
+        end
+
+        def nameservers
+          [
+            'ns1.linode.com',
+            'ns2.linode.com',
+            'ns3.linode.com',
+            'ns4.linode.com',
+            'ns5.linode.com'
+          ]
+        end
+
+        def save
+          requires :domain, :type
+          requires :email if type == 'master'
+          options = {}
+          # * options<~Hash>
+          #   * refresh_sec<~Integer> numeric, default: '0'
+          #   * retry_sec<~Integer> numeric, default: '0'
+          #   * expire_sec<~Integer> numeric, default: '0'
+          #   * status<~Integer> 0, 1, or 2 (disabled, active, edit mode), default: 1 
+          #   * master_ips<~String> When type=slave, the zone's master DNS servers list, semicolon separated
+          options[:description] = description if description
+          options[:soa_email]   = email if email
+          options[:ttl_sec]     = ttl if ttl
+          response = unless identity
+            connection.domain_create(domain, type, options)
+          else
+            options[:domain]  = domain if domain
+            options[:type]    = type if type
+            connection.domain_update(identity, options)
+          end
+          merge_attributes(response.body['DATA'])
+          true
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require 'fog/core/collection'
+require 'fog/dns/models/linode/zone'
+
+module Fog
+  module Linode
+    class DNS
+
+      class Zones < Fog::Collection
+
+        model Fog::Linode::DNS::Zone
+
+        def all
+          data = connection.domain_list.body['DATA']
+          load(data)
+        end
+
+        def get(zone_id)
+          if data = connection.domain_list(zone_id).body['DATA'].first
+            new(data)
+          else
+            nil
+          end
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+require 'fog/core/model'
+
+module Fog
+  module Slicehost
+    class DNS
+
+      class Record < Fog::Model
+
+        identity :id
+
+        attribute :active
+        attribute :ip,          :aliases => 'ip'
+        attribute :name
+        attribute :description, :aliases => 'aux'
+        attribute :ttl
+        attribute :type,        :aliases => 'record_type'
+        attribute :zone_id
+
+        def initialize(attributes={})
+          self.active ||= true
+          self.ttl    ||= 3600
+          super
+        end
+
+        def active=(new_active)
+          attributes[:active] = case new_active
+          when false, 'N'
+            false
+          when true, 'Y'
+            true
+          end
+        end
+
+        def destroy
+          requires :identity
+          connection.delete_record(identity)
+          true
+        end
+
+        def zone
+          @zone
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          requires :ip, :name, :type, :zone
+          options = {}
+          options[:active]  = active ? 'Y' : 'N'
+          options[:aux]     = description if description
+          options[:ttl]     = ttl if ttl
+          data = connection.create_record(type, zone.id, name, ip, options)
+          merge_attributes(data.body)
+          true
+        end
+
+        private
+        
+        def zone=(new_zone)
+          @zone = new_zone
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,36 @@
+require 'fog/core/collection'
+require 'fog/dns/models/slicehost/record'
+
+module Fog
+  module Slicehost
+    class DNS
+
+      class Records < Fog::Collection
+
+        attribute :zone
+
+        model Fog::Slicehost::DNS::Record
+
+        def all
+          requires :zone
+          data = connection.get_records.body['records']
+          load(data).reject {|record| record.zone_id != zone.id}
+        end
+
+        def get(record_id)
+          data = connection.get_record(record_id).body
+          new(data)
+        rescue Excon::Errors::Forbidden
+          nil
+        end
+
+        def new(attributes = {})
+          requires :zone
+          super({ :zone => zone }.merge!(attributes))
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+require 'fog/core/model'
+require 'fog/dns/models/slicehost/records'
+
+module Fog
+  module Slicehost
+    class DNS
+
+      class Zone < Fog::Model
+
+        identity :id
+
+        attribute :active
+        attribute :domain, :aliases => 'origin'
+        attribute :ttl
+
+        def initialize(attributes={})
+          self.active ||= true
+          self.ttl    ||= 3600
+          super
+        end
+
+        def active=(new_active)
+          attributes[:active] = case new_active
+          when false, 'N'
+            false
+          when true, 'Y'
+            true
+          end
+        end
+
+        def destroy
+          requires :identity
+          connection.delete_zone(identity)
+          true
+        end
+
+        def records
+          @records ||= begin
+            Fog::Slicehost::DNS::Records.new(
+              :zone       => self,
+              :connection => connection
+            )
+          end
+        end
+
+        def nameservers
+          [
+            'ns1.slicehost.net',
+            'ns2.slicehost.net',
+            'ns3.slicehost.net'
+          ]
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          requires :active, :domain, :ttl
+          options = {}
+          options[:active]  = active ? 'Y' : 'N'
+          options[:ttl]     = ttl
+          data = connection.create_zone(domain, options)
+          merge_attributes(data.body)
+          true
+        end
+
+      end
+
+    end
+  end
+end