mystro-common 0.1.11 → 0.2.0

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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,85 @@
+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

@@ -0,0 +1,58 @@
+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

@@ -0,0 +1,72 @@
+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

@@ -0,0 +1,44 @@
+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

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

@@ -0,0 +1,71 @@
+module Fog
+  module DNS
+    class Dynect
+      class Real
+
+        # Create a zone
+        #
+        # ==== Parameters
+        # * rname<~String> - administrative contact
+        # * ttl<~Integer> - time to live (in seconds) for records in this zone
+        # * zone<~String> - name of zone to host
+        # * options<~Hash>:
+        #   * serial_style<~String> - style of serial number, in ['day', 'epoch', 'increment', 'minute']. Defaults to increment
+
+        def post_zone(rname, ttl, zone, options = {})
+          body = Fog::JSON.encode({
+            :rname  => rname,
+            :token  => auth_token,
+            :ttl    => ttl
+          }.merge!(options))
+
+          request(
+            :body     => body,
+            :expects  => 200,
+            :method   => :post,
+            :path     => 'Zone/' << zone
+          )
+        end
+      end
+
+      class Mock
+        def post_zone(rname, ttl, zone, options = {})
+          new_zone = self.data[:zones][zone] = {
+            :next_record_id => 0,
+            :records => Hash.new do |records_hash, type|
+              records_hash[type] = []
+            end,
+            :records_to_delete => [],
+            :rname => rname,
+            :serial_style => options[:serial_style] || "increment",
+            :serial => 0,
+            :ttl => ttl,
+            :zone => zone,
+            :zone_type => "Primary"
+          }
+
+          response = Excon::Response.new
+          response.status = 200
+          response.body = {
+            "status" => "success",
+            "data" => {
+              "zone_type" => new_zone[:zone_type],
+              "serial_style" => new_zone[:serial_style],
+              "serial" => new_zone[:serial],
+              "zone" => zone
+            },
+            "job_id" => Fog::Dynect::Mock.job_id,
+            "msgs" => [{
+              "INFO" => "create: New zone #{zone} created.  Publish it to put it on our server.",
+              "SOURCE" => "BLL",
+              "ERR_CD" => nil,
+              "LVL" => "INFO"
+            }]
+          }
+
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,76 @@
+module Fog
+  module DNS
+    class Dynect
+      class Real
+
+        # Update a zone
+        #
+        # ==== Parameters
+        # * zone<~String> - name or id of zone
+        # * options<~Hash>:
+        #   * freeze<~Boolean> - causes zone to become frozen
+        #   * publish<~Boolean> - causes all pending changes to be pushed to nameservers
+        #   * thaw<~Boolean> - causes zone to cease being frozen
+
+        def put_zone(zone, options = {})
+          request(
+            :body     => Fog::JSON.encode(options),
+            :expects  => 200,
+            :method   => :put,
+            :path     => 'Zone/' << zone
+          )
+        end
+      end
+
+      class Mock
+        def put_zone(zone, options = {})
+          raise Fog::DNS::Dynect::NotFound unless zone = self.data[:zones][zone]
+
+          raise ArgumentError unless options.size == 1
+
+          response = Excon::Response.new
+          response.status = 200
+
+          data = {}
+
+          if options['freeze']
+            zone['frozen'] = true
+            info = "freeze: Your zone is now frozen"
+          elsif options['publish']
+            zone[:changes] = {}
+            zone[:records_to_delete].each do |record|
+              zone[:records][record[:type]].delete_if { |r| r[:fqdn] == record[:fqdn] && r[:record_id] == record[:record_id] }
+            end
+            zone[:records_to_delete] = []
+            data = {
+              "zone_type" => zone[:zone_type],
+              "serial_style" => zone[:serial_style],
+              "serial" => zone[:serial] += 1,
+              "zone" => zone[:zone]
+            }
+            info = "publish: #{zone[:zone]} published"
+          elsif options['thaw']
+            zone[:frozen] = false
+            info = "thaw: Your zone is now thawed, you may edit normally"
+          else
+            raise ArgumentError
+          end
+
+          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.rb

@@ -0,0 +1,26 @@
+require 'nokogiri'
+
+require 'fog/core'
+require 'fog/core/parser'
+
+module Fog
+  module Dynect
+    extend Fog::Provider
+
+    service(:dns, 'ext/dynect/dns', 'DNS')
+
+    class Mock
+      def self.job_id
+        Fog::Mock.random_numbers(8).to_i
+      end
+
+      def self.token
+        Fog::Mock.random_hex(48)
+      end
+
+      def self.version
+        [Fog::Mock.random_numbers(1), Fog::Mock.random_numbers(1), Fog::Mock.random_numbers(1)].join('.')
+      end
+    end
+  end
+end

data/lib/mystro/cloud/action.rb

@@ -0,0 +1,22 @@
+module Mystro
+  module Cloud
+    class Action
+      attr_reader :action
+      attr_accessor :options, :class, :data
+      def initialize(klass, action)
+        @class = klass
+        @action = action
+        @options = {}
+        @data = {}
+      end
+
+      def model
+        @class.split('::').last
+      end
+
+      def to_model
+        @class.constantize.new(@data)
+      end
+    end
+  end
+end

data/lib/mystro/cloud/connect/aws/balancer.rb

@@ -0,0 +1,55 @@
+module Mystro
+  module Cloud
+    module Aws
+      class Balancer < Connect
+        manages 'Fog::Balancer', :load_balancers
+
+        def create(model)
+          list = model.computes
+          enc = encode(model)
+          bal = service.send(collection).create(enc)
+          bal.register_instances(list)
+          bal.save
+          decode(bal)
+        end
+
+        protected
+
+        def _decode(balancer)
+          model = Mystro::Cloud::Balancer.new
+          model.id = balancer.id
+          model.dns = balancer.dns_name
+          model.computes = balancer.instances
+          model.zones = balancer.availability_zones
+          model.health = balancer.health_check
+
+          decoded = []
+          balancer.listeners.each do |l|
+            decoded << listeners.decode(l)
+          end
+          model.listeners = decoded
+
+          model._raw = balancer
+          model
+        end
+
+        def _encode(model)
+          Mystro::Log.debug "encode < #{model.inspect}"
+          o = {
+              id: model.id,
+              'ListenerDescriptions' => model.listeners.map {|l| listeners.encode(l)},
+              'AvailabilityZones' => model.zones
+          }
+          Mystro::Log.debug "encode > #{o.inspect}"
+          o
+        end
+
+        private
+
+        def listeners
+          @listeners ||= Mystro::Cloud::Aws::Listener.new(options)
+        end
+      end
+    end
+  end
+end