fog 0.5.3 → 0.6.0

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

@@ -0,0 +1,63 @@
+require 'fog/core/model'
+require 'fog/dns/models/bluebox/records'
+
+module Fog
+  module Bluebox
+    class DNS
+
+      class Zone < Fog::Model
+
+        identity :id
+
+        attribute :domain,        :aliases => 'name'
+        attribute :serial
+        attribute :ttl
+        attribute :retry
+        attribute :expires
+        attribute :record_count,  :aliases => 'record-count'
+        attribute :refresh
+        attribute :minimum
+
+        def initialize(attributes = {})
+          super(attributes)
+        end
+
+        def destroy
+          raise Fog::Errors::Error.new('Not implemented')
+        end
+
+        def records
+          @records ||= begin
+            Fog::Bluebox::DNS::Records.new(
+              :zone       => self,
+              :connection => connection
+            )
+          end
+        end
+
+        def nameservers
+          [
+            'ns1.blueblxgrid.com',
+            'ns2.blueblxgrid.com',
+            'ns3.blueblxgrid.com'
+          ]
+        end
+
+        def destroy
+          requires :identity
+          connection.delete_zone(identity)
+          true
+        end
+
+        def save
+          requires :domain, :ttl
+          options = attributes.dup
+          options[:name] = options.delete(:domain)
+          data = identity.nil? ? connection.create_zone(options) : connection.update_zone(identity, options)
+          merge_attributes(data.body)
+          true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/dns/models/bluebox/zone'
+
+module Fog
+  module Bluebox
+    class DNS
+
+      class Zones < Fog::Collection
+
+        model Fog::Bluebox::DNS::Zone
+
+        def all
+          data = connection.get_zones.body['zones']
+          load(data)
+        end
+
+        def get(zone_id)
+          data = connection.get_zone(zone_id).body
+          new(data)
+        rescue Fog::Service::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,54 @@
+require 'fog/core/model'
+
+module Fog
+  module DNSimple
+    class DNS
+
+      class Record < Fog::Model
+
+        identity :id
+
+        attribute :name
+        attribute :ip,          :aliases => "content"
+        attribute :ttl
+        attribute :created_at
+        attribute :updated_at
+        attribute :zone_id,     :aliases => "domain_id"
+        attribute :type,        :aliases => "record_type"
+        attribute :priority,    :aliases => "prio"
+
+        def initialize(attributes={})
+          self.ttl ||= 3600
+          super
+        end
+
+        def destroy
+          connection.delete_record(zone.domain, identity)
+          true
+        end
+
+        def zone
+          @zone
+        end
+
+        def save
+          requires :name, :type, :ip
+          options = {}
+          options[:prio] = priority if priority
+          options[:ttl]  = ttl if ttl
+          data = connection.create_record(zone.domain, name, type, ip, options)
+          merge_attributes(data.body["record"])
+          true
+        end
+
+        private
+
+        def zone=(new_zone)
+          @zone = new_zone
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'fog/core/collection'
+require 'fog/dns/models/dnsimple/record'
+
+module Fog
+  module DNSimple
+    class DNS
+
+      class Records < Fog::Collection
+
+        attribute :zone
+
+        model Fog::DNSimple::DNS::Record
+
+        def all
+          requires :zone
+          data = connection.list_records(zone.id).body
+        end
+
+        def get(record_id)
+          all.each do |record|
+            if record["record"]["id"] == record_id
+              return new(record)
+            end
+          end
+
+          nil
+        end
+
+        def new(attributes = {})
+          requires :zone
+          super({ :zone => zone }.merge!(attributes))
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require 'fog/core/model'
+require 'fog/dns/models/dnsimple/records'
+
+module Fog
+  module DNSimple
+    class DNS
+
+      class Zone < Fog::Model
+
+        identity :id
+
+        attribute :domain,     :aliases => 'name'
+        attribute :created_at
+        attribute :updated_at
+
+        def destroy
+          connection.delete_domain(identity)
+          true
+        end
+
+        def records
+          @records ||= begin
+                         Fog::DNSimple::DNS::Records.new(
+                                                    :zone       => self,
+                                                    :connection => connection
+                                                    )
+                       end
+        end
+
+        def nameservers
+          [
+           "ns1.dnsimple.com",
+           "ns2.dnsimple.com",
+           "ns3.dnsimple.com",
+           "ns4.dnsimple.com",
+          ]
+        end
+
+        def save
+          requires :domain
+          data = connection.create_domain(domain).body["domain"]
+          merge_attributes(data)
+          true
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/dns/models/dnsimple/zone'
+
+module Fog
+  module DNSimple
+    class DNS
+
+      class Zones < Fog::Collection
+
+        model Fog::DNSimple::DNS::Zone
+
+        def all
+          data = connection.list_domains.body
+          load(data)
+        end
+
+        def get(zone_id)
+          data = connection.get_domain(zone_id).body['domain']
+          new(data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/dns/parsers/bluebox/create_record.rb

@@ -0,0 +1,26 @@
+module Fog
+  module Parsers
+    module Bluebox
+      module DNS
+
+        class CreateRecord < Fog::Parsers::Base
+
+          def reset
+            @response = {}
+          end
+
+          def end_element(name)
+            case name
+            when 'serial', 'ttl', 'retry', 'refresh', 'minimum', 'record-count', 'expires'
+              @response[name] = @value.to_i
+            when 'name', 'id'
+              @response[name] = @value
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Fog
+  module Parsers
+    module Bluebox
+      module DNS
+
+        class CreateZone < Fog::Parsers::Base
+
+          def reset
+            @response = {}
+          end
+
+          def end_element(name)
+            case name
+            when 'serial', 'ttl', 'retry', 'refresh', 'minimum', 'record-count', 'expires'
+              @response[name] = @value.to_i
+            when 'name', 'id'
+              @response[name] = @value
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/dns/parsers/bluebox/get_record.rb

@@ -0,0 +1,21 @@
+module Fog
+  module Parsers
+    module Bluebox
+      module DNS
+
+        class GetRecord < Fog::Parsers::Base
+
+          def reset
+            @response = { }
+          end
+
+          def end_element(name)
+            @response[name] = @value
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/dns/parsers/bluebox/get_records.rb

@@ -0,0 +1,27 @@
+module Fog
+  module Parsers
+    module Bluebox
+      module DNS
+
+        class GetRecords < Fog::Parsers::Base
+
+          def reset
+            @record = {}
+            @response = { 'records' => [] }
+          end
+
+          def end_element(name)
+            case name
+            when 'record'
+              @response['records'] << @record
+              @record = {}
+            else
+              @record[name] = @value
+            end
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/{compute/parsers/terremark_ecloud/get_ip_address.rb → dns/parsers/bluebox/get_zone.rb}

@@ -1,9 +1,8 @@
 module Fog
   module Parsers
-    module TerremarkEcloud
-      module Compute
-
-        class GetIpAddress < Fog::Parsers::Base
+    module Bluebox
+      module DNS
+        class GetZone < Fog::Parsers::Base
 
           def reset
             @response = {}
@@ -11,11 +10,12 @@ module Fog
 
           def end_element(name)
             case name
-            when 'Id', 'Href', 'Name', 'RnatAddress', 'Server', 'Status'
+            when 'serial', 'ttl', 'retry', 'expires', 'record-count', 'refresh', 'minimum'
+              @response[name] = @value.to_i
+            when 'name', 'id'
               @response[name] = @value
             end
           end
-
         end
       end
     end

data/lib/fog/dns/parsers/bluebox/get_zones.rb

@@ -0,0 +1,30 @@
+module Fog
+  module Parsers
+    module Bluebox
+      module DNS
+
+        class GetZones < Fog::Parsers::Base
+
+          def reset
+            @zone = {}
+            @response = { 'zones' => [] }
+          end
+
+          def end_element(name)
+            case name
+            when 'serial', 'ttl', 'retry', 'expires', 'record-count', 'refresh', 'minimum'
+              @zone[name] = @value.to_i
+            when 'name', 'id'
+              @zone[name] = @value
+            when 'record'
+              @response['zones'] << @zone
+              @zone = {}
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/dns/requests/bluebox/create_record.rb

@@ -0,0 +1,48 @@
+module Fog
+  module Bluebox
+    class DNS
+      class Real
+
+        require 'fog/dns/parsers/bluebox/create_record'
+
+        # Create a new record in a DNS zone
+        # ==== Parameters
+        # * type<~String> - type of DNS record to create (A, CNAME, etc)
+        # * name<~String> - host name this DNS record is for
+        # * content<~String> - data for the DNS record (ie for an A record, the IP address)
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'name'<~String> - as above
+        #     * 'id'<~Integer> - Id of zone/domain - used in future API calls for this zone
+        #     * 'ttl'<~Integer> - as above
+        #     * 'data'<~String> - as above
+        #     * 'active'<~String> - as above
+        #     * 'aux'<~String> - as above
+        def create_record(zone_id, type, name, content, options={})
+          body = %Q{<?xml version="1.0" encoding="UTF-8"?><record><type>#{type}</type><name>#{name}</name><content>#{content}</content>}
+          options.each do |k,v|
+            body += %Q{<#{k}>#{v}</#{k}>}
+          end
+          body += %Q{</record>}
+          request(
+            :body     => body,
+            :expects  => 202,
+            :method   => 'POST',
+            :parser   => Fog::Parsers::Bluebox::DNS::CreateRecord.new,
+            :path     => "/api/domains/#{zone_id}/records.xml"
+          )
+        end
+
+      end
+
+      class Mock
+
+        def create_record(zone_id, type, name, content)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end