miasma-rackspace 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e13195283606784eb289f722ea0382af4fa5df65
+  data.tar.gz: 7e1de23024e56effc4e8ec5d1c02d229a6a03ccc
+SHA512:
+  metadata.gz: 499abdcaa9e864dfd5a91dcb83a488a6e9b2ec565c422ff70bacca19665806f76cd507af33766d6267a6c6c115d2f8f75161a49f574d2604e77da810494bd987
+  data.tar.gz: 64eecfc7e0a26c1a3339f53d2119e4254bffd17f3fca9470dbc289fea8f212e427ea10333150a2b48d12bd95ac844f65c7a4e2304571f40edec297d3500a9ce1

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 Rackspace
+
+Rackspace API plugin for the miasma cloud library
+
+## Current support matrix
+
+|Model         |Create|Read|Update|Delete|
+|--------------|------|----|------|------|
+|AutoScale     |  X   | X  |      |      |
+|BlockStorage  |      |    |      |      |
+|Compute       |  X   | X  |      |  X   |
+|DNS           |      |    |      |      |
+|LoadBalancer  |      | X  |      |      |
+|Network       |      |    |      |      |
+|Orchestration |  X   | X  |  X   |  X   |
+|Queues        |      |    |      |      |
+|Storage       |      |    |      |      |
+
+## Info
+* Repository: https://github.com/miasma-rb/miasma-rackspace

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

@@ -0,0 +1,85 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class AutoScale
+      class Rackspace < AutoScale
+
+        include Contrib::OpenStackApiCore::ApiCommon
+        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,13 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class Compute
+      class Rackspace < OpenStack
+
+        include Contrib::RackspaceApiCore::ApiCommon
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,118 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class LoadBalancer
+      class Rackspace < LoadBalancer
+
+        include Contrib::OpenStackApiCore::ApiCommon
+        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

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

@@ -0,0 +1,25 @@
+require 'miasma'
+
+module Miasma
+  module Models
+    class Orchestration
+      class Rackspace < OpenStack
+
+        include Contrib::RackspaceApiCore::ApiCommon
+
+        # @return [Smash] external to internal resource mapping
+        RESOURCE_MAPPING = Smash.new(
+          'Rackspace::Cloud::Server' => Smash.new(
+            :api => :compute,
+            :collection => :servers
+          ),
+          'Rackspace::AutoScale::Group' => Smash.new(
+            :api => :auto_scale,
+            :collection => :groups
+          )
+        )
+
+      end
+    end
+  end
+end

data/lib/miasma/contrib/rackspace.rb

@@ -0,0 +1,112 @@
+require 'miasma'
+require 'miasma/contrib/open_stack'
+
+module Miasma
+  module Contrib
+
+    # Rackspace API core helper
+    class RackspaceApiCore < OpenStackApiCore
+
+      # Authentication helper class
+      class Authenticate < OpenStackApiCore::Authenticate
+        # Authentication implementation compatible for v2
+        class Version2 < OpenStackApiCore::Authenticate::Version2
+
+          # @return [Smash] authentication request body
+          def authentication_request
+            Smash.new(
+              'RAX-KSKEY:apiKeyCredentials' => Smash.new(
+                'username' => credentials[:open_stack_username],
+                'apiKey' => credentials[:open_stack_token]
+              )
+            )
+          end
+
+        end
+      end
+
+      # Common API methods
+      module ApiCommon
+
+        # Set attributes into model
+        #
+        # @param klass [Class]
+        def self.included(klass)
+          klass.attributes.clear
+
+          klass.class_eval do
+            attribute :rackspace_api_key, String, :required => true
+            attribute :rackspace_username, String, :required => true
+            attribute :rackspace_region, String, :required => true
+
+            # @return [Miasma::Contrib::RackspaceApiCore]
+            def open_stack_api
+              key = "miasma_rackspace_api_#{attributes.checksum}".to_sym
+              memoize(key, :direct) do
+                Miasma::Contrib::RackspaceApiCore.new(attributes)
+              end
+            end
+
+            # @return [String]
+            def open_stack_region
+              rackspace_region
+            end
+
+          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'
+      )
+
+      # Create a new api instance
+      #
+      # @param creds [Smash] credential hash
+      # @return [self]
+      def initialize(creds)
+        if(creds[:rackspace_region].to_s == 'lon')
+          endpoint = AUTH_ENDPOINT[:uk]
+        else
+          endpoint = AUTH_ENDPOINT[:us]
+        end
+        super Smash.new(
+          :open_stack_username => creds[:rackspace_username],
+          :open_stack_token => creds[:rackspace_api_key],
+          :open_stack_region => creds[:rackspace_region],
+          :open_stack_identity_url => endpoint
+        )
+      end
+
+      # @return [String] ID of account
+      def account_id
+        identity.token[:tenant][:id]
+      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-rackspace/version.rb

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

data/lib/miasma-rackspace.rb

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

data/miasma-rackspace.gemspec

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

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: miasma-rackspace
+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'
+- !ruby/object:Gem::Dependency
+  name: miasma-open-stack
+  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 Rackspace API
+email: code@chrisroberts.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- LICENSE
+- README.md
+- lib/miasma-rackspace.rb
+- lib/miasma-rackspace/version.rb
+- lib/miasma/contrib/rackspace.rb
+- lib/miasma/contrib/rackspace/auto_scale.rb
+- lib/miasma/contrib/rackspace/compute.rb
+- lib/miasma/contrib/rackspace/load_balancer.rb
+- lib/miasma/contrib/rackspace/orchestration.rb
+- miasma-rackspace.gemspec
+homepage: https://github.com/miasma-rb/miasma-rackspace
+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 Rackspace API
+test_files: []
+has_rdoc: