miasma-open-stack 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d37df368308f78f1e686ef8c27307a5a41691204
+  data.tar.gz: 9f35dcfd89dcc20fa7fdad3e219709fc665d0ed2
+SHA512:
+  metadata.gz: 21bbe599db191aa0f0d85645f708ca83aa172c07c97139a8563bb9a6db1025886a099cd13b0ed196b3bb44f49edbf005a5c3ad01a5758e0909dda5aeff1df613
+  data.tar.gz: e888e1aecd8bedcb02b63d581965b8bec77a40c222b1d713a13fe7587e2db3c48116e8bb11ae4b342210d3997eb594989b6cafc954aebc337c2e0b796aa40cb9

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+## v0.1.0
+* Initial release

data/LICENSE

@@ -0,0 +1,13 @@
+   Copyright 2014 Chris Roberts
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+     http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

data/README.md

@@ -0,0 +1,20 @@
+# Miasma OpenStack
+
+OpenStack API plugin for the miasma cloud library
+
+## Current support matrix
+
+|Model         |Create|Read|Update|Delete|
+|--------------|------|----|------|------|
+|AutoScale     |      |    |      |      |
+|BlockStorage  |      |    |      |      |
+|Compute       |  X   | X  |      |  X   |
+|DNS           |      |    |      |      |
+|LoadBalancer  |      |    |      |      |
+|Network       |      |    |      |      |
+|Orchestration |  X   | X  |  X   |  X   |
+|Queues        |      |    |      |      |
+|Storage       |  X   | X  |  X   |  X   |
+
+## Info
+* Repository: https://github.com/miasma-rb/miasma-open-stack

data/lib/miasma-open-stack.rb

@@ -0,0 +1,2 @@
+require 'miasma'
+require 'miasma-open-stack/version'

data/lib/miasma-open-stack/version.rb

@@ -0,0 +1,4 @@
+module MiasmaOpenStack
+  # Current library version
+  VERSION = Gem::Version.new('0.1.0')
+end

data/lib/miasma/contrib/open_stack.rb

@@ -0,0 +1,343 @@
+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',
+        'storage' => 'swift'
+      )
+
+      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'
+  Models::Storage.autoload :OpenStack, 'miasma/contrib/open_stack/storage'
+end

data/lib/miasma/contrib/open_stack/compute.rb

@@ -0,0 +1,105 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class Compute
+      class OpenStack < Compute
+
+        include Contrib::OpenStackApiCore::ApiCommon
+
+        # @return [Smash] map state to valid internal values
+        SERVER_STATE_MAP = Smash.new(
+          'ACTIVE' => :running,
+          'DELETED' => :terminated,
+          'SUSPENDED' => :stopped,
+          'PASSWORD' => :running
+        )
+
+        def server_save(server)
+          unless(server.persisted?)
+            server.load_data(server.attributes)
+            result = request(
+              :expects => 202,
+              :method => :post,
+              :path => '/servers',
+              :json => {
+                :server => {
+                  :flavorRef => server.flavor_id,
+                  :name => server.name,
+                  :imageRef => server.image_id,
+                  :metadata => server.metadata,
+                  :personality => server.personality,
+                  :key_pair => server.key_name
+                }
+              }
+            )
+            server.id = result.get(:body, :server, :id)
+          else
+            raise "WAT DO I DO!?"
+          end
+        end
+
+        def server_destroy(server)
+          if(server.persisted?)
+            result = request(
+              :expects => 204,
+              :method => :delete,
+              :path => "/servers/#{server.id}"
+            )
+            true
+          else
+            false
+          end
+        end
+
+        def server_change_state(server, state)
+        end
+
+        def server_reload(server)
+          res = servers.reload.all
+          node = res.detect do |s|
+            s.id == server.id
+          end
+          if(node)
+            server.load_data(node.data.dup)
+            server.valid_state
+          else
+            server.data[:state] = :terminated
+            server.dirty.clear
+            server
+          end
+        end
+
+        def server_all
+          result = request(
+            :method => :get,
+            :path => '/servers/detail'
+          )
+          result[:body].fetch(:servers, []).map do |srv|
+            Server.new(
+              self,
+              :id => srv[:id],
+              :name => srv[:name],
+              :image_id => srv.get(:image, :id),
+              :flavor_id => srv.get(:flavor, :id),
+              :state => SERVER_STATE_MAP.fetch(srv[:status], :pending),
+              :addresses_private => srv.fetch(:addresses, :private, []).map{|a|
+                Server::Address.new(
+                  :version => a[:version].to_i, :address => a[:addr]
+                )
+              },
+              :addresses_public => srv.fetch(:addresses, :public, []).map{|a|
+                Server::Address.new(
+                  :version => a[:version].to_i, :address => a[:addr]
+                )
+              },
+              :status => srv[:status],
+              :key_name => srv[:key_name]
+            ).valid_state
+          end
+        end
+
+      end
+    end
+  end
+end

data/lib/miasma/contrib/open_stack/orchestration.rb

@@ -0,0 +1,255 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class Orchestration
+      class OpenStack < Orchestration
+
+        include Contrib::OpenStackApiCore::ApiCommon
+
+        # @return [Smash] external to internal resource mapping
+        RESOURCE_MAPPING = Smash.new(
+          'OS::Nova::Server' => Smash.new(
+            :api => :compute,
+            :collection => :servers
+          )
+          # 'OS::Heat::AutoScalingGroup' => Smash.new(
+          #   :api => :auto_scale,
+          #   :collection => :groups
+          # )
+        )
+
+        # Save the stack
+        #
+        # @param stack [Models::Orchestration::Stack]
+        # @return [Models::Orchestration::Stack]
+        def stack_save(stack)
+          if(stack.persisted?)
+            stack.load_data(stack.attributes)
+            result = request(
+              :expects => 202,
+              :method => :put,
+              :path => "/stacks/#{stack.name}/#{stack.id}",
+              :json => {
+                :stack_name => stack.name,
+                :template => MultiJson.dump(stack.template),
+                :parameters => stack.parameters || {}
+              }
+            )
+            stack.valid_state
+          else
+            stack.load_data(stack.attributes)
+            result = request(
+              :expects => 201,
+              :method => :post,
+              :path => '/stacks',
+              :json => {
+                :stack_name => stack.name,
+                :template => MultiJson.dump(stack.template),
+                :parameters => stack.parameters || {},
+                :disable_rollback => (!!stack.disable_rollback).to_s
+              }
+            )
+            stack.id = result.get(:body, :stack, :id)
+            stack.valid_state
+          end
+        end
+
+        # Reload the stack data from the API
+        #
+        # @param stack [Models::Orchestration::Stack]
+        # @return [Models::Orchestration::Stack]
+        def stack_reload(stack)
+          if(stack.persisted?)
+            result = request(
+              :method => :get,
+              :path => "/stacks/#{stack.name}/#{stack.id}",
+              :expects => 200
+            )
+            stk = result.get(:body, :stack)
+            stack.load_data(
+              :id => stk[:id],
+              :capabilities => stk[:capabilities],
+              :created => Time.parse(stk[:creation_time]),
+              :description => stk[:description],
+              :disable_rollback => stk[:disable_rollback].to_s.downcase == 'true',
+              :notification_topics => stk[:notification_topics],
+              :name => stk[:stack_name],
+              :state => stk[:stack_status].downcase.to_sym,
+              :status => stk[:stack_status],
+              :status_reason => stk[:stack_status_reason],
+              :template_description => stk[:template_description],
+              :timeout_in_minutes => stk[:timeout_mins].to_s.empty? ? nil : stk[:timeout_mins].to_i,
+              :updated => stk[:updated_time].to_s.empty? ? nil : Time.parse(stk[:updated_time]),
+              :parameters => stk.fetch(:parameters, Smash.new),
+              :outputs => stk.fetch(:outputs, []).map{ |output|
+                Smash.new(
+                  :key => output[:output_key],
+                  :value => output[:output_value],
+                  :description => output[:description]
+                )
+              }
+            ).valid_state
+          end
+          stack
+        end
+
+        # Delete the stack
+        #
+        # @param stack [Models::Orchestration::Stack]
+        # @return [TrueClass, FalseClass]
+        def stack_destroy(stack)
+          if(stack.persisted?)
+            request(
+              :method => :delete,
+              :path => "/stacks/#{stack.name}/#{stack.id}",
+              :expects => 204
+            )
+            true
+          else
+            false
+          end
+        end
+
+        # Fetch stack template
+        #
+        # @param stack [Stack]
+        # @return [Smash] stack template
+        def stack_template_load(stack)
+          if(stack.persisted?)
+            result = request(
+              :method => :get,
+              :path => "/stacks/#{stack.name}/#{stack.id}/template"
+            )
+            result.fetch(:body, Smash.new)
+          else
+            Smash.new
+          end
+        end
+
+        # Validate stack template
+        #
+        # @param stack [Stack]
+        # @return [NilClass, String] nil if valid, string error message if invalid
+        def stack_template_validate(stack)
+          begin
+            result = request(
+              :method => :post,
+              :path => '/validate',
+              :json => Smash.new(
+                :template => stack.template
+              )
+            )
+            nil
+          rescue Error::ApiError::RequestError => e
+            MultiJson.load(e.response.body.to_s).to_smash.get(:error, :message)
+          end
+        end
+
+        # Return all stacks
+        #
+        # @param options [Hash] filter
+        # @return [Array<Models::Orchestration::Stack>]
+        # @todo check if we need any mappings on state set
+        def stack_all(options={})
+          result = request(
+            :method => :get,
+            :path => '/stacks'
+          )
+          result.fetch(:body, :stacks, []).map do |s|
+            Stack.new(
+              self,
+              :id => s[:id],
+              :created => Time.parse(s[:creation_time]),
+              :description => s[:description],
+              :name => s[:stack_name],
+              :state => s[:stack_status].downcase.to_sym,
+              :status => s[:stack_status],
+              :status_reason => s[:stack_status_reason],
+              :updated => s[:updated_time].to_s.empty? ? nil : Time.parse(s[:updated_time])
+            ).valid_state
+          end
+        end
+
+        # Return all resources for stack
+        #
+        # @param stack [Models::Orchestration::Stack]
+        # @return [Array<Models::Orchestration::Stack::Resource>]
+        def resource_all(stack)
+          result = request(
+            :method => :get,
+            :path => "/stacks/#{stack.name}/#{stack.id}/resources",
+            :expects => 200
+          )
+          result.fetch(:body, :resources, []).map do |resource|
+            Stack::Resource.new(
+              stack,
+              :id => resource[:physical_resource_id],
+              :name => resource[:resource_name],
+              :type => resource[:resource_type],
+              :logical_id => resource[:logical_resource_id],
+              :state => resource[:resource_status].downcase.to_sym,
+              :status => resource[:resource_status],
+              :status_reason => resource[:resource_status_reason],
+              :updated => Time.parse(resource[:updated_time])
+            ).valid_state
+          end
+        end
+
+        # Reload the stack resource data from the API
+        #
+        # @param resource [Models::Orchestration::Stack::Resource]
+        # @return [Models::Orchestration::Resource]
+        def resource_reload(resource)
+          resource.stack.resources.reload
+          resource.stack.resources.get(resource.id)
+        end
+
+        # Return all events for stack
+        #
+        # @param stack [Models::Orchestration::Stack]
+        # @return [Array<Models::Orchestration::Stack::Event>]
+        def event_all(stack, marker = nil)
+          params = marker ? {:marker => marker} : {}
+          result = request(
+            :path => "/stacks/#{stack.name}/#{stack.id}/events",
+            :method => :get,
+            :expects => 200,
+            :params => params
+          )
+          result.fetch(:body, :events, []).map do |event|
+            Stack::Event.new(
+              stack,
+              :id => event[:id],
+              :resource_id => event[:physical_resource_id],
+              :resource_name => event[:resource_name],
+              :resource_logical_id => event[:logical_resource_id],
+              :resource_state => event[:resource_status].downcase.to_sym,
+              :resource_status => event[:resource_status],
+              :resource_status_reason => event[:resource_status_reason],
+              :time => Time.parse(event[:event_time])
+            ).valid_state
+          end
+        end
+
+        # Return all new events for event collection
+        #
+        # @param events [Models::Orchestration::Stack::Events]
+        # @return [Array<Models::Orchestration::Stack::Event>]
+        def event_all_new(events)
+          event_all(events.stack, events.all.first.id)
+        end
+
+        # Reload the stack event data from the API
+        #
+        # @param resource [Models::Orchestration::Stack::Event]
+        # @return [Models::Orchestration::Event]
+        def event_reload(event)
+          event.stack.events.reload
+          event.stack.events.get(event.id)
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,342 @@
+require 'miasma'
+require 'securerandom'
+
+module Miasma
+  module Models
+    class Storage
+      class OpenStack < Storage
+
+        include Contrib::OpenStackApiCore::ApiCommon
+
+        # Save bucket
+        #
+        # @param bucket [Models::Storage::Bucket]
+        # @return [Models::Storage::Bucket]
+        def bucket_save(bucket)
+          unless(bucket.persisted?)
+            request(
+              :path => full_path(bucket),
+              :method => :put,
+              :expects => [201, 204]
+            )
+            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 => full_path(bucket),
+              :method => :delete,
+              :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 => full_path(bucket),
+                :method => :head,
+                :expects => 204,
+                :params => {
+                  :format => 'json'
+                }
+              )
+              meta = Smash.new.tap do |m|
+                result[:response].headers.each do |k,v|
+                  if(k.to_s.start_with?('X-Container-Meta-'))
+                    m[k.sub('X-Container-Meta-', '')] = v
+                  end
+                end
+              end
+              bucket.metadata = meta unless meta.empty?
+              bucket.valid_state
+            rescue Error::ApiError::RequestError => e
+              if(e.response.status == 404)
+                bucket.data.clear
+                bucket.dirty.clear
+              else
+                raise
+              end
+            end
+          end
+          bucket
+        end
+
+        # Return all buckets
+        #
+        # @return [Array<Models::Storage::Bucket>]
+        def bucket_all
+          result = request(
+            :path => '/',
+            :expects => [200, 204],
+            :params => {
+              :format => 'json'
+            }
+          )
+          [result[:body]].flatten.compact.map do |bkt|
+            Bucket.new(
+              self,
+              :id => bkt['name'],
+              :name => bkt['name']
+            ).valid_state
+          end
+        end
+
+        # Return filtered files
+        #
+        # @param args [Hash] filter options
+        # @return [Array<Models::Storage::File>]
+        def file_filter(bucket, args)
+          result = request(
+            :path => full_path(bucket),
+            :expects => [200, 204],
+            :params => {
+              :prefix => args[:prefix],
+              :format => :json
+            }
+          )
+          [result[:body]].flatten.compact.map do |file|
+            File.new(
+              bucket,
+              :id => ::File.join(bucket.name, file[:name]),
+              :name => file[:name],
+              :updated => file[:last_modified],
+              :size => file[:bytes].to_i
+            ).valid_state
+          end
+        end
+
+        # Return all files within bucket
+        #
+        # @param bucket [Bucket]
+        # @return [Array<File>]
+        # @todo pagination auto-follow
+        def file_all(bucket)
+          result = request(
+            :path => full_path(bucket),
+            :expects => [200, 204],
+            :params => {
+              :format => :json
+            }
+          )
+          [result[:body]].flatten.compact.map do |file|
+            File.new(
+              bucket,
+              :id => ::File.join(bucket.name, file[:name]),
+              :name => file[:name],
+              :updated => file[:last_modified],
+              :size => file[:bytes].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)
+              parts = []
+              file.body.rewind
+              while(content = file.body.read(Storage::READ_BODY_CHUNK_SIZE))
+                data = Smash.new(
+                  :path => "segments/#{full_path(file)}-#{SecureRandom.uuid}",
+                  :etag => Digest::MD5.hexdigest(content),
+                  :size_bytes => content.length
+                )
+                request(
+                  :path => data[:path],
+                  :method => :put,
+                  :expects => 201,
+                  :headers => {
+                    'Content-Length' => data[:size_bytes],
+                    'Etag' => data[:etag]
+                  }
+                )
+                parts << data
+              end
+              result = request(
+                :path => full_path(file),
+                :method => :put,
+                :expects => 201,
+                :params => {
+                  'multipart-manifest' => :put
+                },
+                :json => parts
+              )
+            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(
+                  :method => :put,
+                  :expects => 201,
+                  :path => full_path(file)
+                )
+              )
+            end
+            file.id = ::File.join(file.bucket.name, file.name)
+            file.reload
+          end
+          file
+        end
+
+        # Destroy file
+        #
+        # @param file [Models::Storage::File]
+        # @return [TrueClass, FalseClass]
+        def file_destroy(file)
+          if(file.persisted?)
+            request(
+              :path => full_path(file),
+              :method => :delete
+            )
+            true
+          else
+            false
+          end
+        end
+
+        # Reload the file
+        #
+        # @param file [Models::Storage::File]
+        # @return [Models::Storage::File]
+        def file_reload(file)
+          if(file.persisted?)
+            result = request(
+              :path => full_path(file),
+              :method => :head
+            )
+            info = result[:headers]
+            new_info = Smash.new.tap do |data|
+              data[:updated] = info[:last_modified]
+              data[:etag] = info[:etag]
+              data[:size] = info[:content_length].to_i
+              data[:content_type] = info[:content_type]
+              meta = Smash.new.tap do |m|
+                result[:response].headers.each do |k, v|
+                  if(k.to_s.start_with?('X-Object-Meta-'))
+                    m[k.sub('X-Object-Meta-', '')] = v
+                  end
+                end
+              end
+              data[:metadata] = meta unless meta.empty?
+            end
+            file.load_data(file.attributes.deep_merge(new_info))
+            file.valid_state
+          end
+          file
+        end
+
+        # Create publicly accessible URL
+        #
+        # @param timeout_secs [Integer] seconds available
+        # @return [String] URL
+        # @todo where is this in swift?
+        def file_url(file, timeout_secs)
+          if(file.persisted?)
+            raise NotImplementedError
+          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 => full_path(file))
+            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
+
+        # @return [String] escaped bucket name
+        def bucket_path(bucket)
+          uri_escape(bucket.name)
+        end
+
+        # @return [String] escaped file path
+        def file_path(file)
+          file.name.split('/').map do |part|
+            uri_escape(part)
+          end.join('/')
+        end
+
+        # Provide full path for object
+        #
+        # @param file_or_bucket [File, Bucket]
+        # @return [String]
+        def full_path(file_or_bucket)
+          path = ''
+          if(file_or_bucket.respond_to?(:bucket))
+            path << '/' << bucket_path(file_or_bucket.bucket)
+          end
+          path << '/' << file_path(file_or_bucket)
+          path
+        end
+
+        # URL string escape
+        #
+        # @param string [String] string to escape
+        # @return [String] escaped string
+        # @todo move this to common module
+        def uri_escape(string)
+          string.to_s.gsub(/([^a-zA-Z0-9_.\-~])/) do
+            '%' << $1.unpack('H2' * $1.bytesize).join('%').upcase
+          end
+        end
+
+      end
+    end
+  end
+end

data/miasma-open-stack.gemspec

@@ -0,0 +1,15 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__)) + '/lib/'
+require 'miasma-open-stack/version'
+Gem::Specification.new do |s|
+  s.name = 'miasma-open-stack'
+  s.version = MiasmaOpenStack::VERSION.version
+  s.summary = 'Smoggy OpenStack API'
+  s.author = 'Chris Roberts'
+  s.email = 'code@chrisroberts.org'
+  s.homepage = 'https://github.com/miasma-rb/miasma-open-stack'
+  s.description = 'Smoggy OpenStack API'
+  s.license = 'Apache 2.0'
+  s.require_path = 'lib'
+  s.add_dependency 'miasma'
+  s.files = Dir['lib/**/*'] + %w(miasma-open-stack.gemspec README.md CHANGELOG.md LICENSE)
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification
+name: miasma-open-stack
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Chris Roberts
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: miasma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Smoggy OpenStack API
+email: code@chrisroberts.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/miasma-open-stack.rb
+- lib/miasma-open-stack/version.rb
+- lib/miasma/contrib/open_stack.rb
+- lib/miasma/contrib/open_stack/compute.rb
+- lib/miasma/contrib/open_stack/orchestration.rb
+- lib/miasma/contrib/open_stack/storage.rb
+- miasma-open-stack.gemspec
+homepage: https://github.com/miasma-rb/miasma-open-stack
+licenses:
+- Apache 2.0
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Smoggy OpenStack API
+test_files: []
+has_rdoc: