miasma 0.2.10 → 0.2.12

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

@@ -1,85 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,118 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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