miasma 0.0.1 → 0.1.0

data/lib/miasma/contrib/rackspace.rb

@@ -0,0 +1,164 @@
+require 'miasma'
+require 'miasma/utils/smash'
+require 'time'
+
+module Miasma
+  module Contrib
+
+    # Rackspace API core helper
+    class RackspaceApiCore
+
+      module ApiCommon
+
+        # Set attributes into model
+        #
+        # @param klass [Class]
+        def self.included(klass)
+          klass.class_eval do
+            attribute :rackspace_api_key, String, :required => true
+            attribute :rackspace_username, String, :required => true
+            attribute :rackspace_region, String, :required => true
+          end
+        end
+
+        # @return [HTTP] with auth token provided
+        def connection
+          super.with_headers('X-Auth-Token' => token)
+        end
+
+        # @return [String] endpoint URL
+        def endpoint
+          rackspace_api.endpoint_for(
+            Utils.snake(self.class.to_s.split('::')[-2]).to_sym,
+            rackspace_region
+          )
+        end
+
+        # @return [String] valid API token
+        def token
+          rackspace_api.api_token
+        end
+
+        # @return [Miasma::Contrib::RackspaceApiCore]
+        def rackspace_api
+          key = "miasma_rackspace_api_#{attributes.checksum}".to_sym
+          memoize(key, :direct) do
+            Miasma::Contrib::RackspaceApiCore.new(attributes)
+          end
+        end
+
+      end
+
+      # @return [Smash] Authentication endpoints
+      AUTH_ENDPOINT = Smash.new(
+        :us => 'https://identity.api.rackspacecloud.com/v2.0',
+        :uk => 'https://lon.identity.api.rackspacecloud.com/v2.0'
+      )
+
+      # @return [Smash] Mapping to external service name
+      # @note ["cloudFilesCDN", "cloudFiles", "cloudBlockStorage",
+      # "cloudImages", "cloudQueues", "cloudBigData",
+      # "cloudOrchestration", "cloudServersOpenStack", "autoscale",
+      # "cloudDatabases", "cloudBackup", "cloudMetrics",
+      # "cloudLoadBalancers", "cloudNetworks", "cloudFeeds",
+      # "cloudMonitoring", "cloudDNS"]
+
+      API_MAP = Smash.new(
+        'compute' => 'cloudServersOpenStack',
+        'orchestration' => 'cloudOrchestration',
+        'auto_scale' => 'autoscale',
+        'load_balancer' => 'cloudLoadBalancers'
+      )
+
+      # @return [String] username
+      attr_reader :user
+      # @return [Smash] remote service catalog
+      attr_reader :service_catalog
+      # @return [Smash] token information
+      attr_reader :token
+      # @return [Smash] credentials in use
+      attr_reader :credentials
+
+      # Create a new api instance
+      #
+      # @param creds [Smash] credential hash
+      # @return [self]
+      def initialize(creds)
+        @credentials = creds
+      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)
+        identify_and_load unless service_catalog
+        api = API_MAP[api_name]
+        srv = service_catalog.detect do |info|
+          info[:name] == api
+        end
+        unless(srv)
+          raise NotImplementedError.new("No API mapping found for `#{api_name}`")
+        end
+        region = region.to_s.upcase
+        point = srv[:endpoints].detect do |endpoint|
+          endpoint[:region] == region
+        end
+        if(point)
+          point[:publicURL]
+        end
+      end
+
+      # @return [String] API token
+      def api_token
+        if(token.nil? || Time.now > token[:expires])
+          identify_and_load
+        end
+        token[:id]
+      end
+
+      # @return [String] ID of account
+      def account_id
+        if(token.nil? || Time.now > token[:expires])
+          identify_and_load
+        end
+        token[:tenant][:id]
+      end
+
+      # Identify with authentication service and load
+      # token information and service catalog
+      #
+      # @return [TrueClass]
+      def identify_and_load
+        endpoint = credentials[:rackspace_region].to_s == 'lon' ? AUTH_ENDPOINT[:uk] : AUTH_ENDPOINT[:us]
+        result = HTTP.post(File.join(endpoint, 'tokens'),
+          :json => {
+            'auth' => {
+              'RAX-KSKEY:apiKeyCredentials' => {
+                'username' => credentials[:rackspace_username],
+                'apiKey' => credentials[:rackspace_api_key]
+              }
+            }
+          }
+        )
+        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
+  end
+
+  Models::Compute.autoload :Rackspace, 'miasma/contrib/rackspace/compute'
+  Models::Orchestration.autoload :Rackspace, 'miasma/contrib/rackspace/orchestration'
+  Models::AutoScale.autoload :Rackspace, 'miasma/contrib/rackspace/auto_scale'
+  Models::LoadBalancer.autoload :Rackspace, 'miasma/contrib/rackspace/load_balancer'
+end

data/lib/miasma/contrib/rackspace/auto_scale.rb

@@ -0,0 +1,84 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class AutoScale
+      class Rackspace < AutoScale
+
+        include Contrib::RackspaceApiCore::ApiCommon
+
+        # Save auto scale group
+        #
+        # @param group [Models::AutoScale::Group]
+        # @return [Models::AutoScale::Group]
+        def group_save(group)
+          raise NotImplementedError
+        end
+
+        # Reload the group data from the API
+        #
+        # @param group [Models::AutoScale::Group]
+        # @return [Models::AutoScale::Group]
+        def group_reload(group)
+          if(group.persisted?)
+            result = request(
+              :method => :get,
+              :path => "/groups/#{group.id}",
+              :expects => 200
+            )
+            grp = result.get(:body, :group)
+            group.load_data(
+              :name => grp.get('groupConfiguration', :name),
+              :minimum_size => grp.get('groupConfiguration', 'minEntities'),
+              :maximum_size => grp.get('groupConfiguration', 'maxEntities'),
+              :desired_size => grp.get(:state, 'desiredCapacity'),
+              :current_size => grp.get(:state, 'activeCapacity'),
+              :servers => grp.get(:state, :active).map{|s| AutoScale::Group::Server.new(self, :id => s[:id])}
+            ).valid_state
+          else
+            group
+          end
+        end
+
+        # Delete auto scale group
+        #
+        # @param group [Models::AutoScale::Group]
+        # @return [TrueClass, FalseClass]
+        def group_destroy(group)
+          if(group.persisted?)
+            request(
+              :path => "/groups/#{group.id}",
+              :method => :delete,
+              :expects => 204
+            )
+            true
+          else
+            false
+          end
+        end
+
+        # Return all auto scale groups
+        #
+        # @param options [Hash] filter
+        # @return [Array<Models::AutoScale::Group>]
+        def group_all(options={})
+          result = request(
+            :method => :get,
+            :path => '/groups',
+            :expects => 200
+          )
+          result.fetch(:body, 'groups', []).map do |lb|
+            Group.new(
+              self,
+              :id => lb[:id],
+              :name => lb.get(:state, :name),
+              :current_size => lb.get(:state, 'activeCapacity'),
+              :desired_size => lb.get(:state, 'desiredCapacity')
+            ).valid_state
+          end
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,104 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class Compute
+      class Rackspace < Compute
+
+        include Contrib::RackspaceApiCore::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}"
+            )
+          else
+            raise "this doesn't even exist"
+          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/rackspace/load_balancer.rb

@@ -0,0 +1,117 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class LoadBalancer
+      class Rackspace < LoadBalancer
+
+        include Contrib::RackspaceApiCore::ApiCommon
+
+        # Save load balancer
+        #
+        # @param balancer [Models::LoadBalancer::Balancer]
+        # @return [Models::LoadBalancer::Balancer]
+        def balancer_save(balancer)
+          raise NotImplementedError
+        end
+
+        # Reload the balancer data from the API
+        #
+        # @param balancer [Models::LoadBalancer::Balancer]
+        # @return [Models::LoadBalancer::Balancer]
+        def balancer_reload(balancer)
+          if(balancer.persisted?)
+            result = request(
+              :path => "/loadbalancers/#{balancer.id}",
+              :method => :get,
+              :expects => 200
+            )
+            lb = result.get(:body, 'loadBalancer')
+            balancer.load_data(
+              :name => lb[:name],
+              :name => lb[:name],
+              :state => lb[:status] == 'ACTIVE' ? :active : :pending,
+              :status => lb[:status],
+              :created => lb.get(:created, :time),
+              :updated => lb.get(:updated, :time),
+              :public_addresses => lb['virtualIps'].map{|addr|
+                if(addr[:type] == 'PUBLIC')
+                  Balancer::Address.new(
+                    :address => addr[:address],
+                    :version => addr['ipVersion'].sub('IPV', '').to_i
+                  )
+                end
+              }.compact,
+              :private_addresses => lb['virtualIps'].map{|addr|
+                if(addr[:type] != 'PUBLIC')
+                  Balancer::Address.new(
+                    :address => addr[:address],
+                    :version => addr['ipVersion'].sub('IPV', '').to_i
+                  )
+                end
+              }.compact,
+              :servers => lb.fetch('nodes', []).map{|s|
+                srv = self.api_for(:compute).servers.all.detect do |csrv|
+                  csrv.addresses.map(&:address).include?(s[:address])
+                end
+                if(srv)
+                  Balancer::Server.new(self.api_for(:compute), :id => srv.id)
+                end
+              }.compact
+            ).valid_state
+          else
+            balancer
+          end
+        end
+
+        # Delete load balancer
+        #
+        # @param balancer [Models::LoadBalancer::Balancer]
+        # @return [TrueClass, FalseClass]
+        def balancer_destroy(balancer)
+          raise NotImplementedError
+        end
+
+        # Return all load balancers
+        #
+        # @param options [Hash] filter
+        # @return [Array<Models::LoadBalancer::Balancer>]
+        def balancer_all(options={})
+          result = request(
+            :path => '/loadbalancers',
+            :method => :get,
+            :expects => 200
+          )
+          result.fetch(:body, 'loadBalancers', []).map do |lb|
+            Balancer.new(
+              self,
+              :id => lb[:id],
+              :name => lb[:name],
+              :state => lb[:status] == 'ACTIVE' ? :active : :pending,
+              :status => lb[:status],
+              :created => lb.get(:created, :time),
+              :updated => lb.get(:updated, :time),
+              :public_addresses => lb['virtualIps'].map{|addr|
+                if(addr[:type] == 'PUBLIC')
+                  Balancer::Address.new(
+                    :address => addr[:address],
+                    :version => addr['ipVersion'].sub('IPV', '').to_i
+                  )
+                end
+              }.compact,
+              :private_addresses => lb['virtualIps'].map{|addr|
+                if(addr[:type] != 'PUBLIC')
+                  Balancer::Address.new(
+                    :address => addr[:address],
+                    :version => addr['ipVersion'].sub('IPV', '').to_i
+                  )
+                end
+              }.compact
+            ).valid_state
+          end
+        end
+
+      end
+    end
+  end
+end