fog 2.0.0 → 2.1.0

data/lib/fog/bluebox/models/blb/lb_services.rb

@@ -1,27 +0,0 @@
-require 'fog/core/collection'
-require 'fog/bluebox/models/blb/lb_service'
-
-module Fog
-  module Bluebox
-    class BLB
-      class LbServices < Fog::Collection
-        model Fog::Bluebox::BLB::LbService
-
-        attr_accessor :lb_application
-
-        def all
-          data = service.get_lb_services(lb_application.id).body
-          load(data)
-        end
-
-        def get(lb_service_id)
-          if lb_service = service.get_lb_service(lb_application.id, lb_service_id).body
-            new(lb_service)
-          end
-        rescue Fog::Bluebox::BLB::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/fog/bluebox/models/compute/flavor.rb

@@ -1,41 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class Bluebox
-      class Flavor < Fog::Model
-        identity :id
-
-        attribute :name
-        attribute :cost
-        attribute :description
-
-        def bits
-          # 64
-          raise StandardError.new("Figure me out!?!")
-        end
-
-        def cores
-          # # 2 quad-cores >= 2Ghz = 8 cores
-          # 8 * case ram
-          # when 256
-          #   1/64.0
-          # when 512
-          #   1/32.0
-          # when 1024
-          #   1/16.0
-          # when 2048
-          #   1/8.0
-          # when 4096
-          #   1/4.0
-          # when 8192
-          #   1/2.0
-          # when 15872
-          #   1
-          # end
-          raise StandardError.new("Figure me out!?!")
-        end
-      end
-    end
-  end
-end

data/lib/fog/bluebox/models/compute/flavors.rb

@@ -1,24 +0,0 @@
-require 'fog/core/collection'
-require 'fog/bluebox/models/compute/flavor'
-
-module Fog
-  module Compute
-    class Bluebox
-      class Flavors < Fog::Collection
-        model Fog::Compute::Bluebox::Flavor
-
-        def all
-          data = service.get_products.body
-          load(data)
-        end
-
-        def get(product_id)
-          response = service.get_product(product_id)
-          new(response.body)
-        rescue Fog::Compute::Bluebox::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/fog/bluebox/models/compute/image.rb

@@ -1,30 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class Bluebox
-      class Image < Fog::Model
-        identity :id
-
-        attribute :block_id
-        attribute :description
-        attribute :public
-        attribute :created_at, :aliases => 'created'
-
-        def save
-          requires :block_id
-
-          data = service.create_template(block_id, attributes)
-          true
-        end
-
-        def destroy
-          requires :id
-
-          data = service.destroy_template(id)
-          true
-        end
-      end
-    end
-  end
-end

data/lib/fog/bluebox/models/compute/images.rb

@@ -1,24 +0,0 @@
-require 'fog/core/collection'
-require 'fog/bluebox/models/compute/image'
-
-module Fog
-  module Compute
-    class Bluebox
-      class Images < Fog::Collection
-        model Fog::Compute::Bluebox::Image
-
-        def all
-          data = service.get_templates.body
-          load(data)
-        end
-
-        def get(template_id)
-          response = service.get_template(template_id)
-          new(response.body)
-        rescue Fog::Compute::Bluebox::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/fog/bluebox/models/compute/location.rb

@@ -1,13 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class Bluebox
-      class Location < Fog::Model
-        identity :id
-
-        attribute :description
-      end
-    end
-  end
-end

data/lib/fog/bluebox/models/compute/locations.rb

@@ -1,24 +0,0 @@
-require 'fog/core/collection'
-require 'fog/bluebox/models/compute/location'
-
-module Fog
-  module Compute
-    class Bluebox
-      class Locations < Fog::Collection
-        model Fog::Compute::Bluebox::Location
-
-        def all
-          data = service.get_locations.body
-          load(data)
-        end
-
-        def get(location_id)
-          response = service.get_location(location_id)
-          new(response.body)
-        rescue Fog::Compute::Bluebox::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,121 +0,0 @@
-require 'fog/compute/models/server'
-
-module Fog
-  module Compute
-    class Bluebox
-      class BlockInstantiationError < StandardError; end
-
-      class Server < Fog::Compute::Server
-        identity :id
-
-        attribute :cpu
-        attribute :description
-        attribute :flavor_id,   :aliases => :product, :squash => 'id'
-        attribute :hostname
-        attribute :image_id
-        attribute :location_id
-        attribute :ips
-        attribute :memory
-        attribute :state,       :aliases => "status"
-        attribute :storage
-        attribute :template
-        attribute :ipv6_only
-        attribute :vsh_id
-
-        attr_accessor :hostname, :password, :lb_applications, :lb_services, :lb_backends
-
-        def initialize(attributes={})
-          self.flavor_id    ||= '94fd37a7-2606-47f7-84d5-9000deda52ae' # Block 1GB Virtual Server
-          self.image_id     ||= 'a8f05200-7638-47d1-8282-2474ef57c4c3' # Scientific Linux 6
-          self.location_id  ||= '37c2bd9a-3e81-46c9-b6e2-db44a25cc675' # Seattle, WA
-          super
-        end
-
-        def destroy
-          requires :id
-          service.destroy_block(id)
-          true
-        end
-
-        def flavor
-          requires :flavor_id
-          service.flavors.get(flavor_id)
-        end
-
-        def image
-          requires :image_id
-          service.images.get(image_id)
-        end
-
-        def location
-          requires :location_id
-          service.locations.get(location_id)
-        end
-
-        def private_ip_address
-          nil
-        end
-
-        def public_ip_address
-          if ip = ips.first
-            ip['address']
-          end
-        end
-
-        def ready?
-          self.state == 'running'
-        end
-
-        def reboot(type = 'SOFT')
-          requires :id
-          service.reboot_block(id, type)
-          true
-        end
-
-        def save
-          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
-          requires :flavor_id, :image_id, :location_id
-          options = {}
-
-          unless persisted?  # new record
-            raise(ArgumentError, "password or public_key is required for this operation") if !password && !public_key
-            options['ssh_public_key'] = public_key if public_key
-            options['password'] = password if @password
-          end
-
-          if @lb_backends
-            options['lb_backends'] = lb_backends
-          elsif @lb_services
-            options['lb_services'] = lb_services
-          elsif @lb_applications
-            options['lb_applications'] = lb_applications
-          end
-
-          options['username'] = username
-          options['hostname'] = hostname if @hostname
-          options['ipv6_only'] = ipv6_only if ipv6_only
-          data = service.create_block(flavor_id, image_id, location_id, options)
-          merge_attributes(data.body)
-          true
-        end
-
-        def setup(credentials = {})
-          requires :identity, :ips, :public_key, :username
-          Fog::SSH.new(ssh_ip_address, username, credentials).run([
-            %{mkdir .ssh},
-            %{echo "#{public_key}" >> ~/.ssh/authorized_keys},
-            %{passwd -l #{username}},
-            %{echo "#{Fog::JSON.encode(attributes)}" >> ~/attributes.json}
-          ])
-        rescue Errno::ECONNREFUSED
-          sleep(1)
-          retry
-        end
-
-        def username
-          @username ||= 'deploy'
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-require 'fog/core/collection'
-require 'fog/bluebox/models/compute/server'
-
-module Fog
-  module Compute
-    class Bluebox
-      class Servers < Fog::Collection
-        model Fog::Compute::Bluebox::Server
-
-        def all
-          data = service.get_blocks.body
-          load(data)
-        end
-
-        def bootstrap(new_attributes = {})
-          server = create(new_attributes)
-          server.wait_for { ready? }
-          server.setup(:key_data => [server.private_key])
-          server
-        end
-
-        def get(server_id)
-          if server_id && server = service.get_block(server_id).body
-            new(server)
-          end
-        rescue Fog::Compute::Bluebox::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,52 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module DNS
-    class Bluebox
-      class Record < Fog::Model
-        extend Fog::Deprecation
-        deprecate :ip, :value
-        deprecate :ip=, :value=
-
-        identity :id
-
-        attribute :name
-        attribute :domain_id,   :aliases => 'domain-id'
-        attribute :domain
-        attribute :type
-        attribute :value,       :aliases => 'content'
-
-        def initialize(attributes={})
-          super
-        end
-
-        def destroy
-          requires :identity
-          service.delete_record(@zone.identity, identity)
-          true
-        end
-
-        def zone
-          @zone
-        end
-
-        def save
-          requires :zone, :type, :name, :value
-          data = unless identity
-            service.create_record(zone.identity, type, name, value)
-          else
-            service.update_record(zone.identity, identity, {:type => type, :name => name, :content => value})
-          end
-          merge_attributes(data.body)
-          true
-        end
-
-        private
-
-        def zone=(new_zone)
-          @zone = new_zone
-        end
-      end
-    end
-  end
-end

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

@@ -1,32 +0,0 @@
-require 'fog/core/collection'
-require 'fog/bluebox/models/dns/record'
-
-module Fog
-  module DNS
-    class Bluebox
-      class Records < Fog::Collection
-        attribute :zone
-
-        model Fog::DNS::Bluebox::Record
-
-        def all
-          requires :zone
-          data = service.get_records(zone.identity).body['records']
-          load(data)
-        end
-
-        def get(record_id)
-          data = service.get_record(zone.identity, record_id).body
-          new(data)
-        rescue Fog::Service::NotFound
-          nil
-        end
-
-        def new(attributes = {})
-          requires :zone
-          super({ :zone => zone }.merge!(attributes))
-        end
-      end
-    end
-  end
-end

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

@@ -1,62 +0,0 @@
-require 'fog/core/model'
-require 'fog/bluebox/models/dns/records'
-
-module Fog
-  module DNS
-    class Bluebox
-      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::DNS::Bluebox::Records.new(
-              :zone       => self,
-              :service => service
-            )
-          end
-        end
-
-        def nameservers
-          [
-            'ns1.blueblxgrid.com',
-            'ns2.blueblxgrid.com',
-            'ns3.blueblxgrid.com'
-          ]
-        end
-
-        def destroy
-          requires :identity
-          service.delete_zone(identity)
-          true
-        end
-
-        def save
-          self.ttl ||= 3600
-          requires :domain, :ttl
-          options = attributes.dup
-          options[:name] = options.delete(:domain)
-          data = identity.nil? ? service.create_zone(options) : service.update_zone(identity, options)
-          merge_attributes(data.body)
-          true
-        end
-      end
-    end
-  end
-end