brightbox-cli 0.13.1 → 0.14.0

data/lib/brightbox-cli/vendor/fog/lib/fog/slicehost/dns.rb

@@ -0,0 +1,100 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'slicehost'))
+require 'fog/dns'
+
+module Fog
+  module DNS
+    class Slicehost < Fog::Service
+
+      requires :slicehost_password
+      recognizes :host, :port, :scheme, :persistent
+
+      model_path 'fog/slicehost/models/dns'
+      model       :record
+      collection  :records
+      model       :zone
+      collection  :zones
+
+      request_path 'fog/slicehost/requests/dns'
+      request :create_record
+      request :create_zone
+      request :delete_record
+      request :delete_zone
+      request :get_record
+      request :get_records
+      request :get_zone
+      request :get_zones
+
+      class Mock
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {}
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def initialize(options={})
+          @slicehost_password = options[:slicehost_password]
+        end
+
+        def data
+          self.class.data[@slicehost_password]
+        end
+
+        def reset_data
+          self.class.data.delete(@slicehost_password)
+        end
+
+      end
+
+      class Real
+
+        def initialize(options={})
+          require 'fog/core/parser'
+
+          @slicehost_password = options[:slicehost_password]
+          @connection_options     = options[:connection_options] || {}
+          @host       = options[:host]        || "api.slicehost.com"
+          @persistent = options[:persistent]  || false
+          @port       = options[:port]        || 443
+          @scheme     = options[:scheme]      || 'https'
+          @connection = Fog::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def request(params)
+          params[:headers] ||= {}
+          params[:headers].merge!({
+            'Authorization' => "Basic #{Base64.encode64(@slicehost_password).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.merge!({:host => @host}))
+          rescue Excon::Errors::HTTPStatusError => error
+            raise case error
+            when Excon::Errors::NotFound
+              Fog::DNS::Slicehost::NotFound.slurp(error)
+            else
+              error
+            end
+          end
+
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/slicehost/models/compute/flavors.rb

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/slicehost/models/compute/flavor'
+
+module Fog
+  module Compute
+    class Slicehost
+
+      class Flavors < Fog::Collection
+
+        model Fog::Compute::Slicehost::Flavor
+
+        def all
+          data = connection.get_flavors.body['flavors']
+          load(data)
+        end
+
+        def get(flavor_id)
+          data = connection.get_flavor(flavor_id).body
+          new(data)
+        rescue Excon::Errors::Forbidden
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/slicehost/models/compute/images.rb

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/slicehost/models/compute/image'
+
+module Fog
+  module Compute
+    class Slicehost
+
+      class Images < Fog::Collection
+
+        model Fog::Compute::Slicehost::Image
+
+        def all
+          data = connection.get_images.body['images']
+          load(data)
+        end
+
+        def get(image_id)
+          connection.get_image(image_id)
+        rescue Excon::Errors::Forbidden
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/slicehost/models/compute/servers.rb

@@ -0,0 +1,38 @@
+require 'fog/core/collection'
+require 'fog/slicehost/models/compute/server'
+
+module Fog
+  module Compute
+    class Slicehost
+
+      class Servers < Fog::Collection
+
+        model Fog::Compute::Slicehost::Server
+
+        def all
+          data = connection.get_slices.body['slices']
+          load(data)
+        end
+
+        def bootstrap(new_attributes = {})
+          server = create(new_attributes)
+          server.wait_for { ready? }
+          server.setup(:password => server.password)
+          server
+        end
+
+        def get(server_id)
+          if server_id && server = connection.get_slice(server_id).body
+            new(server)
+          elsif !server_id
+            nil
+          end
+        rescue Excon::Errors::Forbidden
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/slicehost/models/dns/records.rb

@@ -0,0 +1,36 @@
+require 'fog/core/collection'
+require 'fog/slicehost/models/dns/record'
+
+module Fog
+  module DNS
+    class Slicehost
+
+      class Records < Fog::Collection
+
+        attribute :zone
+
+        model Fog::DNS::Slicehost::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/brightbox-cli/vendor/fog/lib/fog/slicehost/models/dns/zone.rb

@@ -0,0 +1,69 @@
+require 'fog/core/model'
+require 'fog/slicehost/models/dns/records'
+
+module Fog
+  module DNS
+    class Slicehost
+
+      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::DNS::Slicehost::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

data/lib/brightbox-cli/vendor/fog/lib/fog/slicehost/models/dns/zones.rb

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/slicehost/models/dns/zone'
+
+module Fog
+  module DNS
+    class Slicehost
+
+      class Zones < Fog::Collection
+
+        model Fog::DNS::Slicehost::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 Excon::Errors::Forbidden
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/slicehost/parsers/dns/slicehost/create_record.rb

@@ -0,0 +1,52 @@
+module Fog
+  module DNS
+    class Slicehost
+      class Real
+
+        require 'fog/slicehost/parsers/dns/create_record'
+
+        # Create a new record in a DNS zone - or update an existing one
+        # ==== Parameters
+        # * record_type<~String> - type of DNS record to create (A, CNAME, etc)
+        # * zone_id<~Integer> - ID of the zone to update
+        # * name<~String> - host name this DNS record is for 
+        # * data<~String> - data for the DNS record (ie for an A record, the IP address)
+        # * options<~Hash> - extra parameters that are not mandatory
+        #   * ttl<~Integer> - time to live in seconds
+        #   * active<~String> - whether this record is active or not ('Y' or 'N')
+        #   * aux<~String> - extra data required by the record
+        # ==== 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(record_type, zone_id, name, data, options = {})
+          optional_tags= ''
+          options.each { |option, value|
+            case option
+            when :ttl
+              optional_tags+= "<ttl type='integer'>#{value}</ttl>"
+            when :active
+              optional_tags+= "<active>#{value}</active>"
+            when :aux
+              optional_tags+= "<aux>#{value}</aux>"
+            end
+          }
+          
+          request(
+            :body     => %Q{<?xml version="1.0" encoding="UTF-8"?><record><record_type>#{record_type}</record_type><zone_id type="integer">#{zone_id}</zone_id><name>#{name}</name><data>#{data}</data>#{optional_tags}</record>},
+            :expects  => 201,
+            :method   => 'POST',
+            :parser   => Fog::Parsers::DNS::Slicehost::CreateRecord.new,
+            :path     => 'records.xml'
+          )
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/slicehost/parsers/dns/slicehost/create_zone.rb

@@ -0,0 +1,46 @@
+module Fog
+  module DNS
+    class Slicehost
+      class Real
+
+        require 'fog/slicehost/parsers/dns/create_zone'
+
+        # Create a new zone for Slicehost's DNS servers to serve/host
+        # ==== Parameters
+        # * origin<~String> - domain name to host (ie example.com)
+        # * options<~Hash> - optional paramaters
+        #   * ttl<~Integer> - TimeToLive (ttl) for the domain, in seconds (> 60)
+        #   * active<~String> - whether zone is active in Slicehost DNS server - 'Y' or 'N'
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Hash>:
+        #     * 'origin'<~String> - as above
+        #     * 'id'<~Integer> - Id of zone/domain - used in future API calls
+        #     * 'ttl'<~Integer> - as above
+        #     * 'active'<~String> - as above
+        def create_zone(origin, options = {})
+
+          optional_tags= ''
+          options.each { |option, value|
+            case option
+            when :ttl
+              optional_tags+= "<ttl type='interger'>#{value}</ttl>"
+            when :active
+              optional_tags+= "<active>#{value}</active>"
+            end
+          }
+          
+          request(
+            :body     => %Q{<?xml version="1.0" encoding="UTF-8"?><zone><origin>#{origin}</origin>#{optional_tags}</zone>},
+            :expects  => 201,
+            :method   => 'POST',
+            :parser   => Fog::Parsers::DNS::Slicehost::CreateZone.new,
+            :path     => 'zones.xml'
+          )
+        end
+
+      end
+    end
+  end
+end