brightbox-cli 0.18.1 → 1.0.0.rc1

data/lib/brightbox-cli/vendor/fog/lib/fog/rackspace/models/storage/directories.rb

@@ -1,43 +0,0 @@
-require 'fog/core/collection'
-require 'fog/rackspace/models/storage/directory'
-
-module Fog
-  module Storage
-    class Rackspace
-
-      class Directories < Fog::Collection
-
-        model Fog::Storage::Rackspace::Directory
-
-        def all
-          data = connection.get_containers.body
-          load(data)
-        end
-
-        # Supply the :cdn_cname option to use the Rackspace CDN CNAME functionality on the public_url.
-        #
-        # > fog.directories.get('video', :cdn_cname => 'http://cdn.lunenburg.org').files.first.public_url
-        # => 'http://cdn.lunenburg.org/hayley-dancing.mov'
-        def get(key, options = {})
-          data = connection.get_container(key, options)
-          directory = new(:key => key, :cdn_cname => options[:cdn_cname])
-          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::Storage::Rackspace::NotFound
-          nil
-        end
-
-      end
-
-    end
-  end
-end

data/lib/brightbox-cli/vendor/fog/lib/fog/rackspace/models/storage/directory.rb

@@ -1,80 +0,0 @@
-require 'fog/core/model'
-require 'fog/rackspace/models/storage/files'
-
-module Fog
-  module Storage
-    class Rackspace
-
-      class Directory < Fog::Model
-
-        identity  :key, :aliases => 'name'
-
-        attribute :bytes, :aliases => 'X-Container-Bytes-Used'
-        attribute :count, :aliases => 'X-Container-Object-Count'
-        attribute :cdn_cname
-
-        def destroy
-          requires :key
-          connection.delete_container(key)
-          connection.cdn.post_container(key, 'X-CDN-Enabled' => 'False')
-          true
-        rescue Excon::Errors::NotFound
-          false
-        end
-
-        def files
-          @files ||= begin
-            Fog::Storage::Rackspace::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)
-              if response.headers['X-CDN-Enabled'] == 'True'
-                if connection.rackspace_cdn_ssl == true
-                  response.headers['X-CDN-SSL-URI']
-                else
-                  cdn_cname || response.headers['X-CDN-URI']
-                end
-              end
-            rescue Fog::Service::NotFound
-              nil
-            end
-          end
-        end
-
-        def save
-          requires :key
-          connection.put_container(key)
-
-          if @connection.cdn && @public
-            # if public and CDN connection then update cdn to public
-            uri_header = 'X-CDN-URI'
-            if connection.rackspace_cdn_ssl == true
-              uri_header = 'X-CDN-SSL-URI'
-            end
-            @public_url = connection.cdn.put_container(key, 'X-CDN-Enabled' => 'True').headers[uri_header]
-          elsif @connection.cdn && !@public
-            connection.cdn.put_container(key, 'X-CDN-Enabled' => 'False')
-            @public_url = nil
-          elsif !@connection.cdn && @public
-            # if public but no CDN connection then error
-            raise(Fog::Storage::Rackspace::Error.new("Directory can not be set as :public without a CDN provided"))
-          end
-          true
-        end
-
-      end
-
-    end
-  end
-end

data/lib/brightbox-cli/vendor/fog/lib/fog/rackspace/models/storage/file.rb

@@ -1,82 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Storage
-    class Rackspace
-
-      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 copy(target_directory_key, target_file_key, options={})
-          requires :directory, :key
-          connection.copy_object(directory.key, key, target_directory_key, target_file_key)
-          target_directory = connection.directories.new(:key => target_directory_key)
-          target_directory.files.get(target_file_key)
-        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 :key
-          self.collection.get_url(self.key)
-        end
-
-        def save(options = {})
-          requires :body, :directory, :key
-          options['Content-Type'] = content_type if content_type
-          data = connection.put_object(directory.key, key, body, options)
-          merge_attributes(data.headers)
-          self.content_length = Fog::Storage.get_body_size(body)
-          true
-        end
-
-        private
-
-        def directory=(new_directory)
-          @directory = new_directory
-        end
-
-      end
-
-    end
-  end
-end

data/lib/brightbox-cli/vendor/fog/lib/fog/rackspace/models/storage/files.rb

@@ -1,94 +0,0 @@
-require 'fog/core/collection'
-require 'fog/rackspace/models/storage/file'
-
-module Fog
-  module Storage
-    class Rackspace
-
-      class Files < Fog::Collection
-
-        attribute :directory
-        attribute :limit
-        attribute :marker
-        attribute :path
-        attribute :prefix
-
-        model Fog::Storage::Rackspace::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
-
-        alias :each_file_this_page :each
-        def each
-          if !block_given?
-            self
-          else
-            subset = dup.all
-
-            subset.each_file_this_page {|f| yield f}
-            until subset.empty? || subset.length == (subset.limit || 10000)
-              subset = subset.all(:marker => subset.last.key)
-              subset.each_file_this_page {|f| yield f}
-            end
-
-            self
-          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::Storage::Rackspace::NotFound
-          nil
-        end
-
-        def get_url(key)
-          requires :directory
-          if self.directory.public_url
-            "#{self.directory.public_url}/#{Fog::Rackspace.escape(key, '/')}"
-          end
-        end
-
-        def head(key, options = {})
-          requires :directory
-          data = connection.head_object(directory.key, key)
-          file_data = data.headers.merge({
-            :key => key
-          })
-          new(file_data)
-        rescue Fog::Storage::Rackspace::NotFound
-          nil
-        end
-
-        def new(attributes = {})
-          requires :directory
-          super({ :directory => directory }.merge!(attributes))
-        end
-
-      end
-
-    end
-  end
-end

data/lib/brightbox-cli/vendor/fog/lib/fog/rackspace/requests/cdn/get_containers.rb

@@ -1,31 +0,0 @@
-module Fog
-  module CDN
-    class Rackspace
-      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
-    end
-  end
-end

data/lib/brightbox-cli/vendor/fog/lib/fog/rackspace/requests/cdn/head_container.rb

@@ -1,33 +0,0 @@
-module Fog
-  module CDN
-    class Rackspace
-      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
-    end
-  end
-end

data/lib/brightbox-cli/vendor/fog/lib/fog/rackspace/requests/cdn/post_container.rb

@@ -1,30 +0,0 @@
-module Fog
-  module CDN
-    class Rackspace
-      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 post_container(name, options = {})
-          response = request(
-            :expects  => [201, 202],
-            :headers  => options,
-            :method   => 'POST',
-            :path     => CGI.escape(name)
-          )
-          response
-        end
-
-      end
-    end
-  end
-end

data/lib/brightbox-cli/vendor/fog/lib/fog/rackspace/requests/cdn/put_container.rb

@@ -1,30 +0,0 @@
-module Fog
-  module CDN
-    class Rackspace
-      class Real
-
-        # enable CDN 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
-    end
-  end
-end

data/lib/brightbox-cli/vendor/fog/lib/fog/rackspace/requests/compute/confirm_resized_server.rb

@@ -1,34 +0,0 @@
-module Fog
-  module Compute
-    class Rackspace
-      class Real
-
-        # Confirm resizing
-        #
-        # ==== Parameters
-        # * server_id<~Integer> - Id of server to confirm
-        #
-        def confirm_resized_server(server_id)
-          body = { 'confirmResize' => nil }
-          server_action(server_id, body, 204)
-        end
-
-      end
-
-      class Mock
-
-        def confirm_resized_server(server_id)
-          response = Excon::Response.new
-          response.status = 204
-
-          self.data[:servers][server_id].delete('old_flavorId')
-          self.data[:last_modified][:servers][server_id] = Time.now
-          self.data[:servers][server_id]['status'] = 'ACTIVE'
-
-          response
-        end
-
-      end
-    end
-  end
-end

data/lib/brightbox-cli/vendor/fog/lib/fog/rackspace/requests/compute/create_image.rb

@@ -1,60 +0,0 @@
-module Fog
-  module Compute
-    class Rackspace
-      class Real
-
-        # Create an image from a running server
-        #
-        # ==== Parameters
-        # * server_id<~Integer> - Id of server to create image from
-        # * options<~Hash> - Name
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * 'image'<~Hash>:
-        #     * 'id'<~Integer> - Id of image
-        #     * 'name'<~String> - Name of image
-        #     * 'serverId'<~Integer> - Id of server
-        def create_image(server_id, options = {})
-          data = {
-            'image' => {
-              'serverId' => server_id
-            }
-          }
-          data['image'].merge!(options)
-          request(
-            :body     => MultiJson.encode(data),
-            :expects  => 202,
-            :method   => 'POST',
-            :path     => "images"
-          )
-        end
-
-      end
-
-      class Mock
-
-        def create_image(server_id, options = {})
-          response = Excon::Response.new
-          response.status = 202
-
-          now = Time.now
-          data = {
-            'created'   => now,
-            'id'        => Fog::Mock.random_numbers(6).to_i,
-            'name'      => options['name'] || '',
-            'serverId'  => server_id,
-            'status'    => 'SAVING',
-            'updated'   => now.to_s,
-          }
-
-          self.data[:last_modified][:images][data['id']] = now
-          self.data[:images][data['id']] = data
-          response.body = { 'image' => data.reject {|key, value| !['id', 'name', 'serverId', 'status', 'updated'].include?(key)} }
-          response
-        end
-
-      end
-    end
-  end
-end

data/lib/brightbox-cli/vendor/fog/lib/fog/rackspace/requests/compute/create_server.rb

@@ -1,94 +0,0 @@
-module Fog
-  module Compute
-    class Rackspace
-      class Real
-
-        # Create a new server
-        #
-        # ==== Parameters
-        # * flavor_id<~Integer> - Id of flavor for server
-        # * image_id<~Integer> - Id of image for server
-        # * name<~String> - Name of server
-        # * options<~Hash>:
-        #   * 'metadata'<~Hash> - Up to 5 key value pairs containing 255 bytes of info
-        #   * 'name'<~String> - Name of server, defaults to "slice#{id}"
-        #   * 'personality'<~Array>: Up to 5 files to customize server
-        #     * file<~Hash>:
-        #       * 'contents'<~String> - Contents of file (10kb total of contents)
-        #       * 'path'<~String> - Path to file (255 bytes total of path strings)
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #   * 'server'<~Hash>:
-        #     * 'addresses'<~Hash>:
-        #       * 'public'<~Array> - public address strings
-        #       * 'private'<~Array> - private address strings
-        #     * 'adminPass'<~String> - Admin password for server
-        #     * 'flavorId'<~Integer> - Id of servers current flavor
-        #     * 'hostId'<~String>
-        #     * 'id'<~Integer> - Id of server
-        #     * 'imageId'<~Integer> - Id of image used to boot server
-        #     * 'metadata'<~Hash> - metadata
-        #     * 'name<~String> - Name of server
-        #     * 'progress'<~Integer> - Progress through current status
-        #     * 'status'<~String> - Current server status
-        def create_server(flavor_id, image_id, options = {})
-          data = {
-            'server' => {
-              'flavorId'  => flavor_id,
-              'imageId'   => image_id
-            }
-          }
-          if options['metadata']
-            data['server']['metadata'] = options['metadata']
-          end
-          if options['name']
-            data['server']['name'] = options['name']
-          end
-          if options['personality']
-            data['server']['personality'] = []
-            for file in options['personality']
-              data['server']['personality'] << {
-                'contents'  => Base64.encode64(file['contents']),
-                'path'      => file['path']
-              }
-            end
-          end
-          request(
-            :body     => MultiJson.encode(data),
-            :expects  => [200, 202],
-            :method   => 'POST',
-            :path     => 'servers.json'
-          )
-        end
-
-      end
-
-      class Mock
-
-        def create_server(flavor_id, image_id, options = {})
-          response = Excon::Response.new
-          response.status = 202
-
-          data = {
-            'addresses' => { 'private' => ['0.0.0.0'], 'public' => ['0.0.0.0'] },
-            'flavorId'  => flavor_id,
-            'id'        => Fog::Mock.random_numbers(6).to_i,
-            'imageId'   => image_id,
-            'hostId'    => "123456789ABCDEF01234567890ABCDEF",
-            'metadata'  => options['metadata'] || {},
-            'name'      => options['name'] || "server_#{rand(999)}",
-            'progress'  => 0,
-            'status'    => 'BUILD'
-          }
-          self.data[:last_modified][:servers][data['id']] = Time.now
-          self.data[:servers][data['id']] = data
-          response.body = { 'server' => data.merge({'adminPass' => 'password'}) }
-          response
-        end
-
-      end
-    end
-  end
-end

data/lib/brightbox-cli/vendor/fog/lib/fog/rackspace/requests/compute/delete_image.rb

@@ -1,45 +0,0 @@
-module Fog
-  module Compute
-    class Rackspace
-      class Real
-
-        # Delete an image
-        #
-        # ==== Parameters
-        # * image_id<~Integer> - Id of image to delete
-        #
-        def delete_image(image_id)
-          request(
-            :expects  => 204,
-            :method   => 'DELETE',
-            :path     => "images/#{image_id}"
-          )
-        end
-
-      end
-
-      class Mock
-
-        def delete_image(image_id)
-          response = Excon::Response.new
-          if image = list_images_detail.body['images'].detect {|_| _['id'] == image_id}
-            if image['status'] == 'SAVING'
-              response.status = 409
-              raise(Excon::Errors.status_error({:expects => 202}, response))
-            else
-              self.data[:last_modified][:images].delete(image_id)
-              self.data[:images].delete(image_id)
-              response.status = 202
-            end
-            response
-          else
-            response.status = 400
-            raise(Excon::Errors.status_error({:expects => 202}, response))
-          end
-
-        end
-
-      end
-    end
-  end
-end