ktheory-fog 1.1.2

data/lib/fog/rackspace/models/compute/server.rb

@@ -0,0 +1,130 @@
+require 'fog/compute/models/server'
+
+module Fog
+  module Compute
+    class Rackspace
+
+      class Server < Fog::Compute::Server
+
+        identity :id
+
+        attribute :addresses
+        attribute :flavor_id,   :aliases => 'flavorId', :type => :integer
+        attribute :host_id,     :aliases => 'hostId'
+        attribute :image_id,    :aliases => 'imageId',  :type => :integer
+        attribute :metadata
+        attribute :name
+        attribute :personality
+        attribute :progress
+        attribute :state,       :aliases => 'status'
+
+        attr_reader :password
+        attr_writer :private_key, :private_key_path, :public_key, :public_key_path, :username
+
+        def initialize(attributes={})
+          self.flavor_id  ||= 1  # 256 server
+          self.image_id   ||= 49 # Ubuntu 10.04 LTS 64bit
+          super
+        end
+
+        def destroy
+          requires :id
+          connection.delete_server(id)
+          true
+        end
+
+        def flavor
+          requires :flavor_id
+          connection.flavors.get(flavor_id)
+        end
+
+        def image
+          requires :image_id
+          connection.images.get(image_id)
+        end
+
+        def images
+          requires :id
+          connection.images(:server => self)
+        end
+
+        def private_ip_address
+          nil
+        end
+
+        def private_key_path
+          @private_key_path ||= Fog.credentials[:private_key_path]
+          @private_key_path &&= File.expand_path(@private_key_path)
+        end
+
+        def private_key
+          @private_key ||= private_key_path && File.read(private_key_path)
+        end
+
+        def public_ip_address
+          addresses['public'].first
+        end
+
+        def public_key_path
+          @public_key_path ||= Fog.credentials[:public_key_path]
+          @public_key_path &&= File.expand_path(@public_key_path)
+        end
+
+        def public_key
+          @public_key ||= public_key_path && File.read(public_key_path)
+        end
+
+        def ready?
+          self.state == 'ACTIVE'
+        end
+
+        def reboot(type = 'SOFT')
+          requires :id
+          connection.reboot_server(id, type)
+          true
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          requires :flavor_id, :image_id
+          options = {
+            'metadata'    => metadata,
+            'name'        => name,
+            'personality' => personality
+          }
+          options = options.reject {|key, value| value.nil?}
+          data = connection.create_server(flavor_id, image_id, options)
+          merge_attributes(data.body['server'])
+          true
+        end
+
+        def setup(credentials = {})
+          requires :public_ip_address, :identity, :public_key, :username
+          Fog::SSH.new(public_ip_address, username, credentials).run([
+            %{mkdir .ssh},
+            %{echo "#{public_key}" >> ~/.ssh/authorized_keys},
+            %{passwd -l #{username}},
+            %{echo "#{MultiJson.encode(attributes)}" >> ~/attributes.json},
+            %{echo "#{MultiJson.encode(metadata)}" >> ~/metadata.json}
+          ])
+        rescue Errno::ECONNREFUSED
+          sleep(1)
+          retry
+        end
+
+        def username
+          @username ||= 'root'
+        end
+
+        private
+
+        def adminPass=(new_admin_pass)
+          @password = new_admin_pass
+        end
+
+      end
+
+    end
+  end
+
+end

data/lib/fog/rackspace/models/compute/servers.rb

@@ -0,0 +1,36 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/compute/server'
+
+module Fog
+  module Compute
+    class Rackspace
+
+      class Servers < Fog::Collection
+
+        model Fog::Compute::Rackspace::Server
+
+        def all
+          data = connection.list_servers_detail.body['servers']
+          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 = connection.get_server_details(server_id).body['server']
+            new(server)
+          end
+        rescue Fog::Compute::Rackspace::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/rackspace/models/dns/callback.rb

@@ -0,0 +1,30 @@
+module Fog
+  module DNS
+    class Rackspace
+
+      module Callback
+
+        protected
+
+        def wait_for_job(job_id, timeout=Fog.timeout, interval=1)
+          retries = 5
+          response = nil
+          Fog.wait_for(timeout, interval) do
+            response = connection.callback job_id
+            if response.body['status'] == 'COMPLETED'
+              true
+            elsif response.body['status'] == 'ERROR'
+              raise Fog::DNS::Rackspace::CallbackError.new(response)
+            elsif retries == 0
+              raise Fog::Errors::Error.new("Wait on job #{job_id} took too long")
+            else
+              retries -= 1
+              false
+            end
+          end
+          response
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+require 'fog/core/model'
+require 'fog/rackspace/models/dns/callback'
+
+module Fog
+  module DNS
+    class Rackspace
+
+      class Record < Fog::Model
+        include Fog::DNS::Rackspace::Callback
+        extend Fog::Deprecation
+        deprecate :ip, :value
+        deprecate :ip=, :value=
+
+        identity :id
+
+        attribute :name
+        attribute :value,       :aliases => 'data'
+        attribute :ttl
+        attribute :type
+        attribute :priority
+        attribute :created
+        attribute :updated
+
+        def destroy
+          requires :zone, :identity
+          wait_for_job connection.remove_record(@zone.identity, identity).body['jobId']
+          true
+        end
+
+        def zone
+          @zone
+        end
+
+        def save
+          if identity
+            update
+          else
+            create
+          end
+        end
+
+        private
+
+        def create
+          requires :name, :type, :value, :zone
+
+          options = {
+            :name => name,
+            :type => type,
+            :data => value
+          }
+
+          if priority
+            options[:priority] = priority
+          end
+
+          response = wait_for_job connection.add_records(@zone.identity, [options]).body['jobId']
+          merge_attributes(response.body['response']['records'].select {|record| record['name'] == self.name && record['type'] == self.type && record['data'] == self.value}.first)
+          true
+        end
+
+        def update
+          requires :identity, :zone
+
+          options = {}
+          options[:name] = name if name
+          options[:type] = type if type
+          options[:data] = value if value
+          options[:priority] = priority if priority
+
+          wait_for_job connection.modify_record(@zone.identity, identity, options).body['jobId']
+          true
+        end
+
+        def zone=(new_zone)
+          @zone = new_zone
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,38 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/dns/record'
+
+module Fog
+  module DNS
+    class Rackspace
+
+      class Records < Fog::Collection
+
+        attribute :zone
+
+        model Fog::DNS::Rackspace::Record
+
+        def all
+          requires :zone
+          data = connection.list_records(zone.identity)
+          load(data.body['records'])
+        end
+
+        def get(record_id)
+          requires :zone
+          data = connection.list_record_details(zone.identity, record_id).body
+          new(data)
+        #nil or empty string will trigger an argument error
+        rescue ArgumentError
+          nil
+        rescue Fog::Rackspace::Errors::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          requires :zone
+          super({ :zone => zone }.merge!(attributes))
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+require 'fog/core/model'
+require 'fog/rackspace/models/dns/records'
+
+module Fog
+  module DNS
+    class Rackspace
+
+      class Zone < Fog::Model
+        include Fog::DNS::Rackspace::Callback
+
+        identity :id
+
+        attribute :email,       :aliases => 'emailAddress'
+        attribute :domain,      :aliases => 'name'
+        attribute :created
+        attribute :updated
+        attribute :account_id,  :aliases => 'accountId'
+        attribute :ttl
+        attribute :nameservers
+        attribute :comment
+
+        def destroy
+          response = connection.remove_domain(identity)
+          wait_for_job response.body['jobId'], Fog.timeout
+          true
+        end
+
+        def records
+          @records ||= begin
+            Fog::DNS::Rackspace::Records.new(
+              :zone       => self,
+              :connection => connection
+            )
+          end
+        end
+
+        def save
+          if identity
+            update
+          else
+            create
+          end
+          true
+        end
+
+        private
+
+        def create
+          requires :domain, :email
+
+          data = { :name => domain, :email => email }
+          response = connection.create_domains([data])
+
+          response = wait_for_job response.body['jobId']
+          merge_attributes(response.body['response']['domains'].select {|domain| domain['name'] == self.domain}.first)
+        end
+
+        def update
+          requires :ttl, :email
+
+          response = connection.modify_domain(identity, { :ttl => ttl, :comment => comment, :email => email})
+          wait_for_job response.body['jobId']
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/dns/zone'
+
+module Fog
+  module DNS
+    class Rackspace
+      class Zones < Fog::Collection
+
+        model Fog::DNS::Rackspace::Zone
+
+        def all
+          clear
+          data = connection.list_domains.body['domains']
+          load(data)
+        end
+
+        def get(zone_id)
+          if zone_id.nil? or zone_id.to_s.empty?
+            return nil
+          end
+
+          data = connection.list_domain_details(zone_id).body
+          new(data)
+        rescue Fog::Rackspace::Errors::NotFound
+          nil
+        #Accessing a valid (but other customer's) id returns a 503 error
+        rescue Fog::Rackspace::Errors::ServiceUnavailable
+          nil
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/load_balancers/access_rule.rb

@@ -0,0 +1,39 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class LoadBalancers
+      class AccessRule < Fog::Model
+
+        identity :id
+
+        attribute :address
+        attribute :type
+
+        def destroy
+          requires :identity, :load_balancer
+          connection.delete_access_rule(load_balancer.identity, identity)
+          true
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          requires :load_balancer, :address, :type
+          connection.create_access_rule(load_balancer.id, address, type)
+
+          #Unfortunately, access rules creation doesn't return an ID, we require a subsequent list call and comparison
+          data = connection.list_access_rules(load_balancer.id).body['accessList'].select do |ar|
+            ar['address'] == address && ar['type'] == type
+          end.first
+          merge_attributes(data)
+          true
+        end
+
+        private
+        def load_balancer
+          collection.load_balancer
+        end
+      end
+    end
+  end
+end