mystro-common 0.3.0 → 0.3.1.alpha2

data/lib/fog/ext/dynect/models/dns/record.rb

@@ -1,66 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module DNS
-    class Dynect
-
-      class Record < Fog::Model
-        extend Fog::Deprecation
-
-        identity  :id
-        attribute :name,        :aliases => [:fqdn, 'fqdn']
-        attribute :rdata
-        attribute :serial_style
-        attribute :ttl
-        attribute :type,        :aliases => 'record_type'
-
-        def destroy
-          requires :identity, :name, :type, :zone
-          service.delete_record(type, zone.identity, name, identity)
-          true
-        end
-
-        def save
-          requires :name, :type, :rdata, :zone
-
-          options = {
-            :ttl => ttl
-          }
-          options.delete_if {|key, value| value.nil?}
-
-          data = service.post_record(type, zone.identity, name, rdata, options).body['data']
-          # avoid overwriting zone object with zone string
-          data = data.reject {|key, value| key == 'zone'}
-          merge_attributes(data)
-
-          zone.publish
-          records = service.get_record(type, zone.identity, name).body['data']
-          # data in format ['/REST/xRecord/domain/fqdn/identity]
-          records.map! do |record|
-            tokens = record.split('/')
-            {
-              :identity => tokens.last,
-              :type     => tokens[2][0...-6] # everything before 'Record'
-            }
-          end
-          record = records.detect {|record| record[:type] == type}
-          merge_attributes(record)
-
-          true
-        end
-
-        def zone
-          @zone
-        end
-
-        private
-
-        def zone=(new_zone)
-          @zone = new_zone
-        end
-
-      end
-
-    end
-  end
-end

data/lib/fog/ext/dynect/models/dns/zone.rb

@@ -1,60 +0,0 @@
-require 'fog/core/model'
-require 'fog/ext/dynect/models/dns/records'
-
-module Fog
-  module DNS
-    class Dynect
-
-      class Zone < Fog::Model
-
-        identity  :domain
-
-        attribute :domain,        :aliases => 'zone'
-        attribute :email,         :aliases => 'rname'
-        attribute :serial
-        attribute :serial_style
-        attribute :ttl
-        attribute :type,          :aliases => 'zone_type'
-
-        def initialize(attributes={})
-          super
-        end
-
-        def destroy
-          requires :domain
-          service.delete_zone(domain)
-          true
-        end
-
-        undef_method :domain=
-        def domain=(new_domain)
-          attributes[:domain] = new_domain.split('/').last
-        end
-
-        def publish
-          requires :identity
-          data = service.put_zone(identity, 'publish' => true)
-          true
-        end
-
-        def records
-          @records ||= Fog::DNS::Dynect::Records.new(:zone => self, :service => service)
-        end
-
-        def nameservers
-          raise 'nameservers Not Implemented'
-        end
-
-        def save
-          self.ttl ||= 3600
-          requires :domain, :email, :ttl
-          data = service.post_zone(email, ttl, domain).body['data']
-          merge_attributes(data)
-          true
-        end
-
-      end
-
-    end
-  end
-end

data/lib/fog/ext/dynect/models/dns/zones.rb

@@ -1,29 +0,0 @@
-require 'fog/core/collection'
-require 'fog/ext/dynect/models/dns/zone'
-
-module Fog
-  module DNS
-    class Dynect
-
-      class Zones < Fog::Collection
-
-        model Fog::DNS::Dynect::Zone
-
-        def all
-          data = service.get_zone.body['data'].map do |zone|
-            { :domain => zone }
-          end
-          load(data)
-        end
-
-        def get(zone_id)
-          new(service.get_zone('zone' => zone_id).body['data'])
-        rescue Excon::Errors::NotFound
-          nil
-        end
-
-      end
-
-    end
-  end
-end

data/lib/fog/ext/dynect/requests/dns/delete_record.rb

@@ -1,56 +0,0 @@
-module Fog
-  module DNS
-    class Dynect
-      class Real
-
-        # Delete a record
-        #
-        # ==== Parameters
-        # * type<~String> - type of record in ['AAAA', 'ANY', 'A', 'CNAME', 'DHCID', 'DNAME', 'DNSKEY', 'DS', 'KEY', 'LOC', 'MX', 'NSA', 'NS', 'PTR', 'PX', 'RP', 'SOA', 'SPF', 'SRV', 'SSHFP', 'TXT']
-        # * zone<~String> - zone of record
-        # * fqdn<~String> - fqdn of record
-        # * record_id<~String> - id of record
-
-        def delete_record(type, zone, fqdn, record_id)
-          request(
-            :expects  => 200,
-            :idempotent => true,
-            :method   => :delete,
-            :path     => ["#{type.to_s.upcase}Record", zone, fqdn, record_id].join('/')
-          )
-        end
-      end
-
-      class Mock
-        def delete_record(type, zone, fqdn, record_id)
-          raise Fog::DNS::Dynect::NotFound unless zone = self.data[:zones][zone]
-
-          raise Fog::DNS::Dynect::NotFound unless zone[:records][type].find { |record| record[:fqdn] == fqdn && record[:record_id] == record_id.to_i }
-
-          zone[:records_to_delete] << {
-            :type => type,
-            :fqdn => fqdn,
-            :record_id => record_id.to_i
-          }
-
-          response = Excon::Response.new
-          response.status = 200
-
-          response.body = {
-            "status" => "success",
-            "data" => {},
-            "job_id" => Fog::Dynect::Mock.job_id,
-            "msgs" => [{
-              "INFO" => "delete: Record will be deleted on zone publish",
-              "SOURCE" => "BLL",
-              "ERR_CD" => nil,
-              "LVL" => "INFO"
-            }]
-          }
-
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/ext/dynect/requests/dns/delete_zone.rb

@@ -1,42 +0,0 @@
-module Fog
-  module DNS
-    class Dynect
-      class Real
-
-        # Delete a zone
-        #
-        # ==== Parameters
-        # * zone<~String> - zone to host
-
-        def delete_zone(zone)
-          request(
-            :expects  => 200,
-            :method   => :delete,
-            :path     => "Zone/#{zone}"
-          )
-        end
-      end
-
-      class Mock
-        def delete_zone(zone)
-          self.data[:zones].delete(zone)
-
-          response = Excon::Response.new
-          response.status = 200
-          response.body = {
-            "status" => "success",
-            "data" => {},
-            "job_id" => Fog::Dynect::Mock.job_id,
-            "msgs" => [{
-              "ERR_CD" => '',
-              "INFO" => '',
-              "LVL" => '',
-              "SOURCE" => ''
-            }]
-          }
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/ext/dynect/requests/dns/get_all_records.rb

@@ -1,56 +0,0 @@
-module Fog
-  module DNS
-    class Dynect
-      class Real
-
-        # Get one or more node lists
-        #
-        # ==== Parameters
-        # * zone<~String> - zone to lookup node lists for
-        # * options<~Hash>
-        #   * fqdn<~String> - fully qualified domain name of node to lookup
-
-        def get_all_records(zone, options = {})
-          requested_fqdn = options['fqdn'] || options[:fqdn]
-          request(
-            :expects  => 200,
-            :idempotent => true,
-            :method   => :get,
-            :path     => ['AllRecord', zone, requested_fqdn].compact.join('/')
-          )
-        end
-      end
-
-      class Mock
-        def get_all_records(zone, options = {})
-          raise Fog::DNS::Dynect::NotFound unless zone = self.data[:zones][zone]
-
-          response = Excon::Response.new
-          response.status = 200
-
-          data = [zone[:zone]]
-
-          if fqdn = options[:fqdn]
-            data = data | zone[:records].collect { |type, records| records.select { |record| record[:fqdn] == fqdn } }.flatten.compact
-          else
-            data = data | zone[:records].collect { |type, records| records.collect { |record| record[:fqdn] } }.flatten
-          end
-
-          response.body = {
-            "status" => "success",
-            "data" => data,
-            "job_id" => Fog::Dynect::Mock.job_id,
-            "msgs" => [{
-              "INFO" => "get_tree: Here is your zone tree",
-              "SOURCE" => "BLL",
-              "ERR_CD" => nil,
-              "LVL" => "INFO"
-            }]
-          }
-
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/ext/dynect/requests/dns/get_node_list.rb

@@ -1,56 +0,0 @@
-module Fog
-  module DNS
-    class Dynect
-      class Real
-
-        # Get one or more node lists
-        #
-        # ==== Parameters
-        # * zone<~String> - zone to lookup node lists for
-        # * options<~Hash>
-        #   * fqdn<~String> - fully qualified domain name of node to lookup
-
-        def get_node_list(zone, options = {})
-          requested_fqdn = options['fqdn'] || options[:fqdn]
-          request(
-            :expects  => 200,
-            :idempotent => true,
-            :method   => :get,
-            :path     => ['AllRecord', zone, requested_fqdn].compact.join('/')
-          )
-        end
-      end
-
-      class Mock
-        def get_node_list(zone, options = {})
-          raise Fog::DNS::Dynect::NotFound unless zone = self.data[:zones][zone]
-
-          response = Excon::Response.new
-          response.status = 200
-
-          data = [zone[:zone]]
-
-          if fqdn = options[:fqdn]
-            data = data | zone[:records].collect { |type, records| records.select { |record| record[:fqdn] == fqdn } }.flatten.compact
-          else
-            data = data | zone[:records].collect { |type, records| records.collect { |record| record[:fqdn] } }.flatten
-          end
-
-          response.body = {
-            "status" => "success",
-            "data" => data,
-            "job_id" => Fog::Dynect::Mock.job_id,
-            "msgs" => [{
-              "INFO" => "get_tree: Here is your zone tree",
-              "SOURCE" => "BLL",
-              "ERR_CD" => nil,
-              "LVL" => "INFO"
-            }]
-          }
-
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/ext/dynect/requests/dns/get_record.rb

@@ -1,85 +0,0 @@
-module Fog
-  module DNS
-    class Dynect
-      class Real
-
-        # List records of a given type
-        #
-        # ==== Parameters
-        # * type<~String> - type of record in ['AAAA', 'ANY', 'A', 'CNAME', 'DHCID', 'DNAME', 'DNSKEY', 'DS', 'KEY', 'LOC', 'MX', 'NSA', 'NS', 'PTR', 'PX', 'RP', 'SOA', 'SPF', 'SRV', 'SSHFP', 'TXT']
-        # * zone<~String> - name of zone to lookup
-        # * fqdn<~String> - name of fqdn to lookup
-        # * options<~Hash>:
-        #   * record_id<~String> - id of record
-
-        def get_record(type, zone, fqdn, options = {})
-          path = ["#{type.to_s.upcase}Record", zone, fqdn, options['record_id']].compact.join('/')
-          request(
-            :expects  => 200,
-            :idempotent => true,
-            :method   => :get,
-            :path     => path
-          )
-        end
-      end
-
-      class Mock
-        def get_record(type, zone, fqdn, options = {})
-          raise ArgumentError unless [
-            'AAAA', 'ANY', 'A', 'CNAME',
-            'DHCID', 'DNAME', 'DNSKEY',
-            'DS', 'KEY', 'LOC', 'MX',
-            'NSA', 'NS', 'PTR', 'PX',
-            'RP', 'SOA', 'SPF', 'SRV',
-            'SSHFP', 'TXT'
-          ].include? type
-          raise Fog::DNS::Dynect::NotFound unless zone = self.data[:zones][zone]
-
-          response = Excon::Response.new
-          response.status = 200
-
-          if record_id = options['record_id']
-            raise Fog::DNS::Dynect::NotFound unless record = zone[:records][type].find { |record| record[:record_id] == record_id.to_i }
-            response.body = {
-              "status" => "success",
-              "data" => {
-                "zone" => record[:zone][:zone],
-                "ttl" => record[:ttl],
-                "fqdn" => record[:fqdn],
-                "record_type" => type,
-                "rdata" => record[:rdata],
-                "record_id" => record[:record_id]
-              },
-              "job_id" => Fog::Dynect::Mock.job_id,
-              "msgs" => [{
-                "INFO" => "get: Found the record",
-                "SOURCE" => "API-B",
-                "ERR_CD" => nil,
-                "LVL" => "INFO"
-              }]
-            }
-          else
-            records = if type == "ANY"
-                        zone[:records].values.flatten.select { |record| record[:fqdn] == fqdn }
-                      else
-                        zone[:records][type].select { |record| record[:fqdn] == fqdn }
-                      end
-            response.body = {
-              "status" => "success",
-              "data" => records.collect { |record| "/REST/#{record[:type]}Record/#{record[:zone][:zone]}/#{record[:fqdn]}/#{record[:record_id]}" },
-              "job_id" => Fog::Dynect::Mock.job_id,
-              "msgs" => [{
-                "INFO" => "detail: Found #{records.size} record",
-                "SOURCE" => "BLL",
-                "ERR_CD" => nil,
-                "LVL" => "INFO"
-              }]
-            }
-          end
-
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/ext/dynect/requests/dns/get_zone.rb

@@ -1,58 +0,0 @@
-module Fog
-  module DNS
-    class Dynect
-      class Real
-
-        # Get one or more zones
-        #
-        # ==== Parameters
-        # * options<~Hash>:
-        #   * zone<~String> - name of zone to lookup, or omit to return list of zones
-
-        def get_zone(options = {})
-          request(
-            :expects  => 200,
-            :idempotent => true,
-            :method   => :get,
-            :path     => ['Zone', options['zone']].compact.join('/')
-          )
-        end
-      end
-
-      class Mock
-        def get_zone(options = {})
-          if options['zone']
-            raise Fog::DNS::Dynect::NotFound unless zone = self.data[:zones][options['zone']]
-            data = {
-              "zone_type" => zone[:zone_type],
-              "serial_style" => zone[:serial_style],
-              "serial" => zone[:serial],
-              "zone" => zone[:zone]
-            }
-            info = "get: Your zone, #{zone[:zone]}"
-          else
-            data = self.data[:zones].collect { |zone, data| "/REST/Zone/#{zone}/" }
-            info = "get: Your #{data.size} zones"
-          end
-
-          response = Excon::Response.new
-          response.status = 200
-
-          response.body = {
-            "status" => "success",
-            "data" => data,
-            "job_id" => Fog::Dynect::Mock.job_id,
-            "msgs" => [{
-              "INFO" => info,
-              "SOURCE" => "BLL",
-              "ERR_CD" => nil,
-              "LVL" => "INFO"
-            }]
-          }
-
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/ext/dynect/requests/dns/post_record.rb

@@ -1,72 +0,0 @@
-module Fog
-  module DNS
-    class Dynect
-      class Real
-
-        # Create a record
-        #
-        # ==== Parameters
-        # * type<~String> - type of record in ['AAAA', 'ANY', 'A', 'CNAME', 'DHCID', 'DNAME', 'DNSKEY', 'DS', 'KEY', 'LOC', 'MX', 'NSA', 'NS', 'PTR', 'PX', 'RP', 'SOA', 'SPF', 'SRV', 'SSHFP', 'TXT']
-        # * zone<~String> - zone of record
-        # * rdata<~Hash> - rdata for record
-        # * options<~Hash>: (options vary by type, listing below includes common parameters)
-        #   * ttl<~Integer> - ttl for the record, defaults to zone ttl
-
-        def post_record(type, zone, fqdn, rdata, options = {})
-          options.merge!('rdata' => rdata)
-          request(
-            :body     => Fog::JSON.encode(options),
-            :expects  => 200,
-            :method   => :post,
-            :path     => ["#{type.to_s.upcase}Record", zone, fqdn].join('/')
-          )
-        end
-      end
-
-      class Mock
-        def post_record(type, zone, fqdn, rdata, options = {})
-          raise Fog::DNS::Dynect::NotFound unless zone = self.data[:zones][zone]
-
-          records = zone[:records]
-          record_id = zone[:next_record_id]
-          zone[:next_record_id] += 1
-
-          record = {
-            :type => type,
-            :zone => zone,
-            :fqdn => fqdn,
-            :rdata => rdata,
-            :ttl => options[:ttl] || zone[:ttl],
-            :record_id => record_id
-          }
-
-          records[type] << record
-
-          response = Excon::Response.new
-          response.status = 200
-
-          response.body = {
-            "status" => "success",
-            "data" => {
-              "zone" => record[:zone][:zone],
-              "ttl" => record[:ttl],
-              "fqdn" => record[:fqdn],
-              "record_type" => record[:type],
-              "rdata" => record[:rdata],
-              "record_id" => record[:record_id]
-           },
-           "job_id" => Fog::Dynect::Mock.job_id,
-           "msgs" => [{
-             "INFO"=>"add: Record added",
-             "SOURCE"=>"BLL",
-             "ERR_CD"=>nil,
-             "LVL"=>"INFO"
-           }]
-          }
-
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/ext/dynect/requests/dns/post_session.rb

@@ -1,44 +0,0 @@
-module Fog
-  module DNS
-    class Dynect
-      class Real
-
-        def post_session
-          request(
-            :expects  => 200,
-            :idempotent => true,
-            :method   => :post,
-            :path     => "Session",
-            :body     => Fog::JSON.encode({
-              :customer_name  => @dynect_customer,
-              :user_name      => @dynect_username,
-              :password       => @dynect_password
-            })
-          )
-        end
-      end
-
-      class Mock
-        def post_session
-          response = Excon::Response.new
-          response.status = 200
-          response.body = {
-            "status" => "success",
-            "data" => {
-              "token" => auth_token,
-              "version" => Fog::Dynect::Mock.version
-            },
-            "job_id" => Fog::Dynect::Mock.job_id,
-            "msgs"=>[{
-              "INFO"=>"login: Login successful",
-              "SOURCE"=>"BLL",
-              "ERR_CD"=>nil,
-              "LVL"=>"INFO"
-            }]
-          }
-          response
-        end
-      end
-    end
-  end
-end