bbcloud 0.8 → 0.8.1

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/rackspace/models/compute/flavors.rb

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/compute/flavor'
+
+module Fog
+  module Rackspace
+    class Compute
+
+      class Flavors < Fog::Collection
+
+        model Fog::Rackspace::Compute::Flavor
+
+        def all
+          data = connection.list_flavors_detail.body['flavors']
+          load(data)
+        end
+
+        def get(flavor_id)
+          data = connection.get_flavor_details(flavor_id).body['flavor']
+          new(data)
+        rescue Fog::Rackspace::Compute::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/rackspace/models/compute/image.rb

@@ -0,0 +1,48 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class Compute
+
+      class Image < Fog::Model
+
+        identity :id
+
+        attribute :name
+        attribute :created_at,  :aliases => 'created'
+        attribute :updated_at,  :aliases => 'updated'
+        attribute :progress
+        attribute :status
+        attribute :server_id,   :aliases => 'serverId'
+
+        def server=(new_server)
+          requires :id
+
+          self.server_id = new_server.id
+        end
+
+        def destroy
+          requires :id
+
+          connection.delete_image(id)
+          true
+        end
+
+        def ready?
+          status == 'ACTIVE'
+        end
+
+        def save
+          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if identity
+          requires :server_id
+
+          data = connection.create_image(server_id, 'name' => name)
+          merge_attributes(data.body['image'])
+          true
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/rackspace/models/compute/images.rb

@@ -0,0 +1,33 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/compute/image'
+
+module Fog
+  module Rackspace
+    class Compute
+
+      class Images < Fog::Collection
+
+        model Fog::Rackspace::Compute::Image
+
+        attribute :server
+
+        def all
+          data = connection.list_images_detail.body['images']
+          load(data)
+          if server
+            self.replace(self.select {|image| image.server_id == server.id})
+          end
+        end
+
+        def get(image_id)
+          data = connection.get_image_details(image_id).body['image']
+          new(data)
+        rescue Fog::Rackspace::Compute::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/rackspace/models/compute/server.rb

@@ -0,0 +1,126 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class Compute
+
+      class Server < Fog::Model
+
+        identity :id
+
+        attribute :addresses
+        attribute :flavor_id,   :aliases => 'flavorId'
+        attribute :host_id,     :aliases => 'hostId'
+        attribute :image_id,    :aliases => 'imageId'
+        attribute :metadata
+        attribute :name
+        attribute :personality
+        attribute :progress
+        attribute :status
+
+        attr_reader :password
+        attr_writer :private_key, :private_key_path, :public_key, :public_key_path, :username
+
+        def initialize(attributes={})
+          self.flavor_id ||= 1
+          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_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_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?
+          status == '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, :name
+          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 :addresses, :identity, :public_key, :username
+          Fog::SSH.new(addresses['public'].first, username, credentials).run([
+            %{mkdir .ssh},
+            %{echo "#{public_key}" >> ~/.ssh/authorized_keys},
+            %{passwd -l root},
+            %{echo "#{attributes.to_json}" >> ~/attributes.json},
+            %{echo "#{metadata.to_json}" >> ~/metadata.json}
+          ])
+        rescue Errno::ECONNREFUSED
+          sleep(1)
+          retry
+        end
+
+        def ssh(commands)
+          requires :addresses, :identity, :private_key, :username
+          Fog::SSH.new(addresses['public'].first, username, :key_data => [private_key]).run(commands)
+        end
+
+        def username
+          @username ||= 'root'
+        end
+
+        private
+
+        def adminPass=(new_admin_pass)
+          @password = new_admin_pass
+        end
+
+      end
+
+    end
+  end
+
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/rackspace/models/compute/servers.rb

@@ -0,0 +1,36 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/compute/server'
+
+module Fog
+  module Rackspace
+    class Compute
+
+      class Servers < Fog::Collection
+
+        model Fog::Rackspace::Compute::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::Rackspace::Compute::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/rackspace/models/storage/directories.rb

@@ -0,0 +1,39 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/storage/directory'
+
+module Fog
+  module Rackspace
+    class Storage
+
+      class Directories < Fog::Collection
+
+        model Fog::Rackspace::Storage::Directory
+
+        def all
+          data = connection.get_containers.body
+          load(data)
+        end
+
+        def get(key, options = {})
+          data = connection.get_container(key, options)
+          directory = new(:key => key)
+          for key, value in data.headers
+            if ['X-Container-Bytes-Used', 'X-Container-Object-Count'].include?(key)
+              directory.merge_attributes(key => value)
+            end
+          end
+          directory.files.merge_attributes(options)
+          directory.files.instance_variable_set(:@loaded, true)
+          data.body.each do |file|
+            directory.files << directory.files.new(file)
+          end
+          directory
+        rescue Fog::Rackspace::Storage::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/rackspace/models/storage/directory.rb

@@ -0,0 +1,63 @@
+require 'fog/core/model'
+require 'fog/rackspace/models/storage/files'
+
+module Fog
+  module Rackspace
+    class Storage
+
+      class Directory < Fog::Model
+        extend Fog::Deprecation
+        deprecate(:name, :key)
+        deprecate(:name=, :key=)
+
+        identity  :key, :aliases => 'name'
+
+        attribute :bytes, :aliases => 'X-Container-Bytes-Used'
+        attribute :count, :aliases => 'X-Container-Object-Count'
+
+        def destroy
+          requires :key
+          connection.delete_container(key)
+          true
+        rescue Excon::Errors::NotFound
+          false
+        end
+
+        def files
+          @files ||= begin
+            Fog::Rackspace::Storage::Files.new(
+              :directory    => self,
+              :connection   => connection
+            )
+          end
+        end
+
+        def public=(new_public)
+          @public = new_public
+        end
+
+        def public_url
+          requires :key
+          @public_url ||= begin
+            begin response = connection.cdn.head_container(key)
+              response.headers['X-CDN-URI']
+            rescue Fog::Service::NotFound
+              nil
+            end
+          end
+        end
+
+        def save
+          requires :key
+          connection.put_container(key)
+          if @public
+            @public_url = connection.cdn.put_container(key).headers['X-CDN-URI']
+          end
+          true
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/rackspace/models/storage/file.rb

@@ -0,0 +1,80 @@
+require 'fog/core/model'
+
+module Fog
+  module Rackspace
+    class Storage
+
+      class File < Fog::Model
+
+        identity  :key,             :aliases => 'name'
+
+        attribute :content_length,  :aliases => ['bytes', 'Content-Length'], :type => :integer
+        attribute :content_type,    :aliases => ['content_type', 'Content-Type']
+        attribute :etag,            :aliases => ['hash', 'Etag']
+        attribute :last_modified,   :aliases => ['last_modified', 'Last-Modified'], :type => :time
+
+        def body
+          attributes[:body] ||= if last_modified
+            collection.get(identity).body
+          else
+            ''
+          end
+        end
+
+        def body=(new_body)
+          attributes[:body] = new_body
+        end
+
+        def directory
+          @directory
+        end
+
+        def destroy
+          requires :directory, :key
+          connection.delete_object(directory.key, key)
+          true
+        end
+
+        def owner=(new_owner)
+          if new_owner
+            attributes[:owner] = {
+              :display_name => new_owner['DisplayName'],
+              :id           => new_owner['ID']
+            }
+          end
+        end
+
+        def public=(new_public)
+          new_public
+        end
+
+        def public_url
+          requires :directory, :key
+          if @directory.public_url
+            "#{@directory.public_url}/#{key}"
+          end
+        end
+
+        def save(options = {})
+          requires :body, :directory, :key
+          data = connection.put_object(directory.key, key, body, options)
+          merge_attributes(data.headers)
+          if body.is_a?(String)
+            self.content_length = body.size
+          else
+            self.content_length = ::File.size(body.path)
+          end
+          true
+        end
+
+        private
+
+        def directory=(new_directory)
+          @directory = new_directory
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/rackspace/models/storage/files.rb

@@ -0,0 +1,75 @@
+require 'fog/core/collection'
+require 'fog/rackspace/models/storage/file'
+
+module Fog
+  module Rackspace
+    class Storage
+
+      class Files < Fog::Collection
+
+        attribute :directory
+        attribute :limit
+        attribute :marker
+        attribute :path
+        attribute :prefix
+
+        model Fog::Rackspace::Storage::File
+
+        def all(options = {})
+          requires :directory
+          options = {
+            'limit'   => limit,
+            'marker'  => marker,
+            'path'    => path,
+            'prefix'  => prefix
+          }.merge!(options)
+          merge_attributes(options)
+          parent = directory.collection.get(
+            directory.key,
+            options
+          )
+          if parent
+            load(parent.files.map {|file| file.attributes})
+          else
+            nil
+          end
+        end
+
+        def get(key, &block)
+          requires :directory
+          data = connection.get_object(directory.key, key, &block)
+          file_data = data.headers.merge({
+            :body => data.body,
+            :key  => key
+          })
+          new(file_data)
+        rescue Fog::Rackspace::Storage::NotFound
+          nil
+        end
+
+        def get_url(key, expires)
+          requires :directory
+          connection.get_object_url(directory.name, key, expires)
+        end
+
+        def head(key, options = {})
+          requires :directory
+          data = connection.head_object(directory.name, key, options)
+          file_data = data.headers.merge({
+            :key => key
+          })
+          new(file_data)
+        rescue Fog::Rackspace::Storage::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          requires :directory
+          super({ :directory => directory }.merge!(attributes))
+        end
+
+      end
+
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/rackspace/requests/cdn/get_containers.rb

@@ -0,0 +1,39 @@
+module Fog
+  module Rackspace
+    class CDN
+      class Real
+
+        # List existing cdn-enabled storage containers
+        #
+        # ==== Parameters
+        # * options<~Hash>:
+        #   * 'enabled_only'<~Boolean> - Set to true to limit results to cdn enabled containers
+        #   * 'limit'<~Integer> - Upper limit to number of results returned
+        #   * 'marker'<~String> - Only return objects with name greater than this value
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~Array>:
+        #     * container<~String>: Name of container
+        def get_containers(options = {})
+          response = request(
+            :expects  => [200, 204],
+            :method   => 'GET',
+            :path     => '',
+            :query    => {'format' => 'json'}.merge!(options)
+          )
+          response
+        end
+
+      end
+
+      class Mock
+
+        def get_containers(options = {})
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/rackspace/requests/cdn/head_container.rb

@@ -0,0 +1,41 @@
+module Fog
+  module Rackspace
+    class CDN
+      class Real
+
+        # List cdn properties for a container
+        #
+        # ==== Parameters
+        # * container<~String> - Name of container to retrieve info for
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * headers<~Hash>:
+        #     * 'X-CDN-Enabled'<~Boolean> - cdn status for container
+        #     * 'X-CDN-URI'<~String> - cdn url for this container
+        #     * 'X-TTL'<~String> - integer seconds before data expires, defaults to 86400 (1 day)
+        #     * 'X-Log-Retention'<~Boolean> - ?
+        #     * 'X-User-Agent-ACL'<~String> - ?
+        #     * 'X-Referrer-ACL'<~String> - ?
+        def head_container(container)
+          response = request(
+            :expects  => 204,
+            :method   => 'HEAD',
+            :path     => container,
+            :query    => {'format' => 'json'}
+          )
+          response
+        end
+
+      end
+
+      class Mock
+
+        def head_container(container)
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end

data/lib/bbcloud/vendor/fog-0.3.23/lib/fog/rackspace/requests/cdn/put_container.rb

@@ -0,0 +1,38 @@
+module Fog
+  module Rackspace
+    class CDN
+      class Real
+
+        # modify CDN properties for a container
+        #
+        # ==== Parameters
+        # * name<~String> - Name for container, should be < 256 bytes and must not contain '/'
+        # # options<~Hash>:
+        #   * 'X-CDN-Enabled'<~Boolean> - cdn status for container
+        #   * 'X-CDN-URI'<~String> - cdn url for this container
+        #   * 'X-TTL'<~String> - integer seconds before data expires, defaults to 86400 (1 day), in 3600..259200
+        #   * 'X-Log-Retention'<~Boolean> - ?
+        #   * 'X-User-Agent-ACL'<~String> - ?
+        #   * 'X-Referrer-ACL'<~String> - ?
+        def put_container(name, options = {})
+          response = request(
+            :expects  => [201, 202],
+            :headers  => options,
+            :method   => 'PUT',
+            :path     => CGI.escape(name)
+          )
+          response
+        end
+
+      end
+
+      class Mock
+
+        def put_container(name, options = {})
+          Fog::Mock.not_implemented
+        end
+
+      end
+    end
+  end
+end