miasma 0.2.10 → 0.2.12

data/lib/miasma/contrib/aws/storage.rb

@@ -1,405 +0,0 @@
-require 'stringio'
-require 'xmlsimple'
-require 'miasma'
-
-module Miasma
-  module Models
-    class Storage
-      class Aws < Storage
-
-        # Service name of the API
-        API_SERVICE = 's3'
-        # Supported version of the AutoScaling API
-        API_VERSION = '2006-03-01'
-
-        include Contrib::AwsApiCore::ApiCommon
-        include Contrib::AwsApiCore::RequestUtils
-
-        # Simple init override to force HOST and adjust region for
-        # signatures if required
-        def initialize(args)
-          args = args.to_smash
-          cache_region = args[:aws_region]
-          args[:aws_region] = args.fetch(:aws_bucket_region, 'us-east-1')
-          super(args)
-          aws_region = cache_region
-          if(aws_bucket_region)
-            self.aws_host = "s3-#{aws_bucket_region}.amazonaws.com"
-          else
-            self.aws_host = 's3.amazonaws.com'
-          end
-        end
-
-        # Save bucket
-        #
-        # @param bucket [Models::Storage::Bucket]
-        # @return [Models::Storage::Bucket]
-        def bucket_save(bucket)
-          unless(bucket.persisted?)
-            req_args = Smash.new(
-              :method => :put,
-              :path => '/',
-              :endpoint => bucket_endpoint(bucket)
-            )
-            if(aws_bucket_region)
-              req_args[:body] = XmlSimple.xml_out(
-                Smash.new(
-                  'CreateBucketConfiguration' => {
-                    'LocationConstraint' => aws_bucket_region
-                  }
-                ),
-                'AttrPrefix' => true,
-                'KeepRoot' => true
-              )
-              req_args[:headers] = Smash.new(
-                'Content-Length' => req_args[:body].size.to_s
-              )
-            end
-            request(req_args)
-            bucket.id = bucket.name
-            bucket.valid_state
-          end
-          bucket
-        end
-
-        # Destroy bucket
-        #
-        # @param bucket [Models::Storage::Bucket]
-        # @return [TrueClass, FalseClass]
-        def bucket_destroy(bucket)
-          if(bucket.persisted?)
-            request(
-              :path => '/',
-              :method => :delete,
-              :endpoint => bucket_endpoint(bucket),
-              :expects => 204
-            )
-            true
-          else
-            false
-          end
-        end
-
-        # Reload the bucket
-        #
-        # @param bucket [Models::Storage::Bucket]
-        # @return [Models::Storage::Bucket]
-        def bucket_reload(bucket)
-          if(bucket.persisted?)
-            begin
-              result = request(
-                :path => '/',
-                :method => :head,
-                :endpoint => bucket_endpoint(bucket)
-              )
-            rescue Error::ApiError::RequestError => e
-              if(e.response.status == 404)
-                bucket.data.clear
-                bucket.dirty.clear
-              else
-                raise
-              end
-            end
-          end
-          bucket
-        end
-
-        # Custom bucket endpoint
-        #
-        # @param bucket [Models::Storage::Bucket]
-        # @return [String]
-        # @todo properly escape bucket name
-        def bucket_endpoint(bucket)
-          ::File.join(endpoint, bucket.name)
-        end
-
-        # Return all buckets
-        #
-        # @return [Array<Models::Storage::Bucket>]
-        def bucket_all
-          result = all_result_pages(nil, :body, 'ListAllMyBucketsResult', 'Buckets', 'Bucket') do |options|
-            request(
-              :path => '/',
-              :params => options
-            )
-          end
-          result.map do |bkt|
-            Bucket.new(
-              self,
-              :id => bkt['Name'],
-              :name => bkt['Name'],
-              :created => bkt['CreationDate']
-            ).valid_state
-          end
-        end
-
-        # Return filtered files
-        #
-        # @param args [Hash] filter options
-        # @return [Array<Models::Storage::File>]
-        def file_filter(bucket, args)
-          if(args[:prefix])
-            result = request(
-              :path => '/',
-              :endpoint => bucket_endpoint(bucket),
-              :params => Smash.new(
-                :prefix => args[:prefix]
-              )
-            )
-            [result.get(:body, 'ListBucketResult', 'Contents')].flatten.compact.map do |file|
-              File.new(
-                bucket,
-                :id => ::File.join(bucket.name, file['Key']),
-                :name => file['Key'],
-                :updated => file['LastModified'],
-                :size => file['Size'].to_i
-              ).valid_state
-            end
-          else
-            bucket_all
-          end
-        end
-
-        # Return all files within bucket
-        #
-        # @param bucket [Bucket]
-        # @return [Array<File>]
-        def file_all(bucket)
-          result = all_result_pages(nil, :body, 'ListBucketResult', 'Contents') do |options|
-            request(
-              :path => '/',
-              :params => options,
-              :endpoint => bucket_endpoint(bucket)
-            )
-          end
-          result.map do |file|
-            File.new(
-              bucket,
-              :id => ::File.join(bucket.name, file['Key']),
-              :name => file['Key'],
-              :updated => file['LastModified'],
-              :size => file['Size'].to_i
-            ).valid_state
-          end
-        end
-
-        # Save file
-        #
-        # @param file [Models::Storage::File]
-        # @return [Models::Storage::File]
-        def file_save(file)
-          if(file.dirty?)
-            file.load_data(file.attributes)
-            args = Smash.new
-            args[:headers] = Smash[
-              Smash.new(
-                :content_type => 'Content-Type',
-                :content_disposition => 'Content-Disposition',
-                :content_encoding => 'Content-Encoding'
-              ).map do |attr, key|
-                if(file.attributes[attr])
-                  [key, file.attributes[attr]]
-                end
-              end.compact
-            ]
-            if(file.attributes[:body].is_a?(IO) && file.body.size >= Storage::MAX_BODY_SIZE_FOR_STRINGIFY)
-              upload_id = request(
-                args.merge(
-                  Smash.new(
-                    :path => file_path(file),
-                    :endpoint => bucket_endpoint(bucket),
-                    :params => {
-                      :uploads => true
-                    }
-                  )
-                )
-              ).get(:body, 'InitiateMultipartUploadResult', 'UploadId')
-              count = 1
-              parts = []
-              file.body.rewind
-              while(content = file.body.read(Storage::READ_BODY_CHUNK_SIZE))
-                parts << [
-                  count,
-                  request(
-                    :method => :put,
-                    :path => file_path(file),
-                    :endpoint => bucket_endpoint(bucket),
-                    :headers => Smash.new(
-                      'Content-Length' => content.size,
-                      'Content-MD5' => Digest::MD5.hexdigest(content)
-                    ),
-                    :params => Smash.new(
-                      'partNumber' => count,
-                      'uploadId' => upload_id
-                    ),
-                    :body => content
-                  ).get(:body, :headers, :etag)
-                ]
-                count += 1
-              end
-              complete = SimpleXml.xml_out(
-                Smash.new(
-                  'CompleteMultipartUpload' => {
-                    'Part' => parts.map{|part|
-                      {'PartNumber' => part.first, 'ETag' => part.last}
-                    }
-                  }
-                ),
-                'AttrPrefix' => true,
-                'KeepRoot' => true
-              )
-              result = request(
-                :method => :post,
-                :path => file_path(file),
-                :endpoint => bucket_endpoint(file.bucket),
-                :params => Smash.new(
-                  'UploadId' => upload_id
-                ),
-                :headers => Smash.new(
-                  'Content-Length' => complete.size
-                ),
-                :body => complete
-              )
-              file.etag = result.get(:body, 'CompleteMultipartUploadResult', 'ETag')
-            else
-              if(file.attributes[:body].is_a?(IO) || file.attributes[:body].is_a?(StringIO))
-                args[:headers]['Content-Length'] = file.body.size.to_s
-                file.body.rewind
-                args[:body] = file.body.read
-                file.body.rewind
-              end
-              result = request(
-                args.merge(
-                  Smash.new(
-                    :method => :put,
-                    :path => file_path(file),
-                    :endpoint => bucket_endpoint(file.bucket)
-                  )
-                )
-              )
-              file.etag = result.get(:headers, :etag)
-            end
-            file.id = ::File.join(file.bucket.name, file.name)
-            file.valid_state
-          end
-          file
-        end
-
-        # Destroy file
-        #
-        # @param file [Models::Storage::File]
-        # @return [TrueClass, FalseClass]
-        def file_destroy(file)
-          if(file.persisted?)
-            request(
-              :method => :delete,
-              :path => file_path(file),
-              :endpoint => bucket_endpoint(file.bucket),
-              :expects => 204
-            )
-            true
-          else
-            false
-          end
-        end
-
-        # Reload the file
-        #
-        # @param file [Models::Storage::File]
-        # @return [Models::Storage::File]
-        def file_reload(file)
-          if(file.persisted?)
-            name = file.name
-            result = request(
-              :path => file_path(file),
-              :endpoint => bucket_endpoint(file.bucket)
-            )
-            file.data.clear && file.dirty.clear
-            info = result[:headers]
-            file.load_data(
-              :id => ::File.join(file.bucket.name, name),
-              :name => name,
-              :updated => info[:last_modified],
-              :etag => info[:etag],
-              :size => info[:content_length].to_i,
-              :content_type => info[:content_type]
-            ).valid_state
-          end
-          file
-        end
-
-        # Create publicly accessible URL
-        #
-        # @param timeout_secs [Integer] seconds available
-        # @return [String] URL
-        def file_url(file, timeout_secs)
-          if(file.persisted?)
-            signer.generate_url(
-              :get, ::File.join(uri_escape(file.bucket.name), file_path(file)),
-              :headers => Smash.new(
-                'Host' => aws_host
-              ),
-              :params => Smash.new(
-                'X-Amz-Date' => Contrib::AwsApiCore.time_iso8601,
-                'X-Amz-Expires' => timeout_secs
-              )
-            )
-          else
-            raise Error::ModelPersistError.new "#{file} has not been saved!"
-          end
-        end
-
-        # Fetch the contents of the file
-        #
-        # @param file [Models::Storage::File]
-        # @return [IO, HTTP::Response::Body]
-        def file_body(file)
-          if(file.persisted?)
-            result = request(
-              :path => file_path(file),
-              :endpoint => bucket_endpoint(file.bucket),
-              :disable_body_extraction => true
-            )
-            content = result[:body]
-            begin
-              if(content.is_a?(String))
-                StringIO.new(content)
-              else
-                if(content.respond_to?(:stream!))
-                  content.stream!
-                end
-                content
-              end
-            rescue HTTP::StateError
-              StringIO.new(content.to_s)
-            end
-          else
-            StringIO.new('')
-          end
-        end
-
-        # Simple callback to allow request option adjustments prior to
-        # signature calculation
-        #
-        # @param opts [Smash] request options
-        # @return [TrueClass]
-        # @note this only updates when :body is defined. if a :post is
-        # happening (which implicitly forces :form) or :json is used
-        # it will not properly checksum. (but that's probably okay)
-        def update_request(con, opts)
-          con.default_headers['x-amz-content-sha256'] = Digest::SHA256.
-            hexdigest(opts.fetch(:body, ''))
-          true
-        end
-
-        # @return [String] escaped file path
-        def file_path(file)
-          file.name.split('/').map do |part|
-            uri_escape(part)
-          end.join('/')
-        end
-
-      end
-    end
-  end
-end

data/lib/miasma/contrib/open_stack.rb

@@ -1,341 +0,0 @@
-require 'miasma'
-require 'miasma/utils/smash'
-require 'time'
-
-module Miasma
-  module Contrib
-
-    # OpenStack API core helper
-    class OpenStackApiCore
-
-      # Authentication helper class
-      class Authenticate
-
-        # @return [Smash] token info
-        attr_reader :token
-        # @return [Smash] credentials in use
-        attr_reader :credentials
-
-        # Create new instance
-        #
-        # @return [self]
-        def initialize(credentials)
-          @credentials = credentials.to_smash
-        end
-
-        # @return [String] username
-        def user
-          load!
-          @user
-        end
-
-        # @return [Smash] remote service catalog
-        def service_catalog
-          load!
-          @service_catalog
-        end
-
-        # @return [String] current API token
-        def api_token
-          if(token.nil? || Time.now > token[:expires])
-            identify_and_load
-          end
-          token[:id]
-        end
-
-        # Identify with authentication endpoint
-        # and load the service catalog
-        #
-        # @return [self]
-        def identity_and_load
-          raise NotImplementedError
-        end
-
-        # @return [Smash] authentication request body
-        def authentication_request
-          raise NotImplementedError
-        end
-
-        protected
-
-        # @return [TrueClass] load authenticator
-        def load!
-          !!api_token
-        end
-
-        # Authentication implementation compatible for v2
-        class Version2 < Authenticate
-
-          # @return [Smash] authentication request body
-          def authentication_request
-            if(credentials[:open_stack_token])
-              auth = Smash.new(
-                :token => Smash.new(
-                  :id => credentials[:open_stack_token]
-                )
-              )
-            else
-              auth = Smash.new(
-                'passwordCredentials' => Smash.new(
-                  'username' => credentials[:open_stack_username],
-                  'password' => credentials[:open_stack_password]
-                )
-              )
-            end
-            if(credentials[:open_stack_tenant_name])
-              auth['tenantName'] = credentials[:open_stack_tenant_name]
-            end
-            auth
-          end
-
-          # Identify with authentication service and load
-          # token information and service catalog
-          #
-          # @return [TrueClass]
-          def identify_and_load
-            result = HTTP.post(
-              File.join(
-                credentials[:open_stack_identity_url],
-                'tokens'
-              ),
-              :json => Smash.new(
-                :auth => authentication_request
-              )
-            )
-            unless(result.status == 200)
-              raise Error::ApiError::AuthenticationError.new('Failed to authenticate', :response => result)
-            end
-            info = MultiJson.load(result.body.to_s).to_smash
-            info = info[:access]
-            @user = info[:user]
-            @service_catalog = info[:serviceCatalog]
-            @token = info[:token]
-            token[:expires] = Time.parse(token[:expires])
-            true
-          end
-
-        end
-
-        # Authentication implementation compatible for v2
-        class Version3 < Authenticate
-
-          # @return [Smash] authentication request body
-          def authentication_request
-            ident = Smash.new(:methods => [])
-            if(credentials[:open_stack_password])
-              ident[:methods] << 'password'
-              ident[:password] = Smash.new(
-                :user => Smash.new(
-                  :password => credentials[:open_stack_password]
-                )
-              )
-              if(credentials[:open_stack_user_id])
-                ident[:password][:user][:id] = credentials[:open_stack_user_id]
-              else
-                ident[:password][:user][:name] = credentials[:open_stack_username]
-              end
-              if(credentials[:open_stack_domain])
-                ident[:password][:user][:domain] = Smash.new(
-                  :name => credentials[:open_stack_domain]
-                )
-              end
-            end
-            if(credentials[:open_stack_token])
-              ident[:methods] << 'token'
-              ident[:token] = Smash.new(
-                :token => Smash.new(
-                  :id => credentials[:open_stack_token]
-                )
-              )
-            end
-            if(credentials[:open_stack_project_id])
-              scope = Smash.new(
-                :project => Smash.new(
-                  :id => credentials[:open_stack_project_id]
-                )
-              )
-            else
-              if(credentials[:open_stack_domain])
-                scope = Smash.new(
-                  :domain => Smash.new(
-                    :name => credentials[:open_stack_domain]
-                  )
-                )
-                if(credentials[:open_stack_project])
-                  scope[:project] = Smash.new(
-                    :name => credentials[:open_stack_project]
-                  )
-                end
-              end
-            end
-            auth = Smash.new(:identity => ident)
-            if(scope)
-              auth[:scope] = scope
-            end
-            auth
-          end
-
-          # Identify with authentication service and load
-          # token information and service catalog
-          #
-          # @return [TrueClass]
-          def identify_and_load
-            result = HTTP.post(
-              File.join(credentials[:open_stack_identity_url], 'tokens'),
-              :json => Smash.new(
-                :auth => authentication_request
-              )
-            )
-            unless(result.status == 200)
-              raise Error::ApiError::AuthenticationError.new('Failed to authenticate!', result)
-            end
-            info = MultiJson.load(result.body.to_s).to_smash[:token]
-            @service_catalog = info.delete(:catalog)
-            @token = Smash.new(
-              :expires => Time.parse(info[:expires_at]),
-              :id => result.headers['X-Subject-Token']
-            )
-            @user = info[:user][:name]
-            true
-          end
-
-        end
-
-      end
-
-      # Common API methods
-      module ApiCommon
-
-        # Set attributes into model
-        #
-        # @param klass [Class]
-        def self.included(klass)
-          klass.class_eval do
-            attribute :open_stack_identity_url, String, :required => true
-            attribute :open_stack_username, String
-            attribute :open_stack_user_id, String
-            attribute :open_stack_password, String
-            attribute :open_stack_token, String
-            attribute :open_stack_region, String
-            attribute :open_stack_tenant_name, String
-            attribute :open_stack_domain, String
-            attribute :open_stack_project, String
-          end
-        end
-
-        # @return [HTTP] with auth token provided
-        def connection
-          super.with_headers('X-Auth-Token' => token)
-        end
-
-        # @return [String] endpoint URL
-        def endpoint
-          open_stack_api.endpoint_for(
-            Utils.snake(self.class.to_s.split('::')[-2]).to_sym,
-            open_stack_region
-          )
-        end
-
-        # @return [String] valid API token
-        def token
-          open_stack_api.api_token
-        end
-
-        # @return [Miasma::Contrib::OpenStackApiCore]
-        def open_stack_api
-          key = "miasma_open_stack_api_#{attributes.checksum}".to_sym
-          memoize(key, :direct) do
-            Miasma::Contrib::OpenStackApiCore.new(attributes)
-          end
-        end
-
-      end
-
-      # @return [Smash] Mapping to external service name
-      API_MAP = Smash.new(
-        'compute' => 'nova',
-        'orchestration' => 'heat',
-        'network' => 'neutron',
-        'identity' => 'keystone'
-      )
-
-      include Miasma::Utils::Memoization
-
-      # @return [Miasma::Contrib::OpenStackApiCore::Authenticate]
-      attr_reader :identity
-
-      # Create a new api instance
-      #
-      # @param creds [Smash] credential hash
-      # @return [self]
-      def initialize(creds)
-        @credentials = creds
-        memo_key = "miasma_open_stack_identity_#{creds.checksum}"
-        if(creds[:open_stack_identity_url].include?('v3'))
-          @identity = memoize(memo_key, :direct) do
-            identity_class('Authenticate::Version3').new(creds)
-          end
-        elsif(creds[:open_stack_identity_url].include?('v2'))
-          @identity = memoize(memo_key, :direct) do
-            identity_class('Authenticate::Version2').new(creds)
-          end
-        else
-          # @todo allow attribute to override?
-          raise ArgumentError.new('Failed to determine Identity service version')
-        end
-      end
-
-      # @return [Class] class from instance class, falls back to parent
-      def identity_class(i_name)
-        [self.class, Miasma::Contrib::OpenStackApiCore].map do |klass|
-          i_name.split('::').inject(klass) do |memo, key|
-            if(memo.const_defined?(key))
-              memo.const_get(key)
-            else
-              break
-            end
-          end
-        end.compact.first
-      end
-
-      # Provide end point URL for service
-      #
-      # @param api_name [String] name of api
-      # @param region [String] region in use
-      # @return [String] public URL
-      def endpoint_for(api_name, region)
-        api = self.class.const_get(:API_MAP)[api_name]
-        srv = identity.service_catalog.detect do |info|
-          info[:name] == api
-        end
-        unless(srv)
-          raise NotImplementedError.new("No API mapping found for `#{api_name}`")
-        end
-        if(region)
-          point = srv[:endpoints].detect do |endpoint|
-            endpoint[:region].to_s.downcase == region.to_s.downcase
-          end
-        else
-          point = srv[:endpoints].first
-        end
-        if(point)
-          point.fetch(
-            :publicURL,
-            point[:url]
-          )
-        else
-          raise KeyError.new("Lookup failed for `#{api_name}` within region `#{region}`")
-        end
-      end
-
-      # @return [String] API token
-      def api_token
-        identity.api_token
-      end
-
-    end
-  end
-
-  Models::Compute.autoload :OpenStack, 'miasma/contrib/open_stack/compute'
-  Models::Orchestration.autoload :OpenStack, 'miasma/contrib/open_stack/orchestration'
-end