brightbox-cli 0.14.1 → 0.15.0

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/compute.rb

@@ -103,12 +103,17 @@ module Fog
 
         def self.data
           @data ||= Hash.new do |hash, region|
-            owner_id = Fog::AWS::Mock.owner_id
             hash[region] = Hash.new do |region_hash, key|
+              owner_id = Fog::AWS::Mock.owner_id
               region_hash[key] = {
                 :deleted_at => {},
                 :addresses  => {},
                 :images     => {},
+                :image_launch_permissions => Hash.new do |permissions_hash, image_key|
+                  permissions_hash[image_key] = {
+                    :users => []
+                  }
+                end,
                 :instances  => {},
                 :reserved_instances => {},
                 :key_pairs  => {},
@@ -116,9 +121,10 @@ module Fog
                 :owner_id   => owner_id,
                 :security_groups => {
                   'default' => {
-                    'groupDescription'  => 'default group',
-                    'groupName'         => 'default',
-                    'ipPermissions'     => [
+                    'groupDescription'    => 'default group',
+                    'groupName'           => 'default',
+                    'ipPermissionsEgress' => [],
+                    'ipPermissions'       => [
                       {
                         'groups'      => [{'groupName' => 'default', 'userId' => owner_id}],
                         'fromPort'    => -1,
@@ -141,12 +147,15 @@ module Fog
                         'ipRanges'    => []
                       }
                     ],
-                    'ownerId'           => owner_id
+                    'ownerId'             => owner_id
                   }
                 },
                 :snapshots => {},
                 :volumes => {},
-                :tags => {}
+                :tags => {},
+                :tag_sets => Hash.new do |tag_set_hash, resource_id|
+                  tag_set_hash[resource_id] = {}
+                end
               }
             end
           end
@@ -166,36 +175,58 @@ module Fog
           end
         end
 
+        def region_data
+          self.class.data[@region]
+        end
+
         def data
-          self.class.data[@region][@aws_access_key_id]
+          self.region_data[@aws_access_key_id]
         end
 
         def reset_data
-          self.class.data[@region].delete(@aws_access_key_id)
+          self.region_data.delete(@aws_access_key_id)
+        end
+
+        def visible_images
+          images = self.data[:images].values.inject({}) do |h, image|
+            h.update(image['imageId'] => image)
+          end
+
+          self.region_data.each do |aws_access_key_id, data|
+            data[:image_launch_permissions].each do |image_id, list|
+              if list[:users].include?(self.data[:owner_id])
+                images.update(image_id => data[:images][image_id])
+              end
+            end
+          end
+
+          images
         end
 
-        def apply_tag_filters(resources, filters)
+        def apply_tag_filters(resources, filters, resource_id_key)
+          tag_set_fetcher = lambda {|resource| self.data[:tag_sets][resource[resource_id_key]] }
+
           # tag-key: match resources tagged with this key (any value)
           if filters.has_key?('tag-key')
             value = filters.delete('tag-key')
-            resources = resources.select{|r| r['tagSet'].has_key?(value)}
+            resources = resources.select{|r| tag_set_fetcher[r].has_key?(value)}
           end
-          
+
           # tag-value: match resources tagged with this value (any key)
           if filters.has_key?('tag-value')
             value = filters.delete('tag-value')
-            resources = resources.select{|r| r['tagSet'].values.include?(value)}
+            resources = resources.select{|r| tag_set_fetcher[r].values.include?(value)}
           end
-          
-          # tag:key: match resources taged with a key-value pair.  Value may be an array, which is OR'd.
+
+          # tag:key: match resources tagged with a key-value pair.  Value may be an array, which is OR'd.
           tag_filters = {}
-          filters.keys.each do |key| 
+          filters.keys.each do |key|
             tag_filters[key.gsub('tag:', '')] = filters.delete(key) if /^tag:/ =~ key
           end
           for tag_key, tag_value in tag_filters
-            resources = resources.select{|r| tag_value.include?(r['tagSet'][tag_key])}
+            resources = resources.select{|r| tag_value.include?(tag_set_fetcher[r][tag_key])}
           end
-          
+
           resources
         end
       end
@@ -205,7 +236,7 @@ module Fog
         # Initialize connection to EC2
         #
         # ==== Notes
-        # options parameter must include values for :aws_access_key_id and 
+        # options parameter must include values for :aws_access_key_id and
         # :aws_secret_access_key in order to create a connection
         #
         # ==== Examples
@@ -264,7 +295,7 @@ module Fog
         end
 
         private
-        
+
         def request(params)
           idempotent  = params.delete(:idempotent)
           parser      = params.delete(:parser)

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/elasticache.rb

@@ -0,0 +1,127 @@
+module Fog
+  module AWS
+    class Elasticache < Fog::Service
+
+      class IdentifierTaken < Fog::Errors::Error; end
+      class InvalidInstance < Fog::Errors::Error; end
+
+      requires :aws_access_key_id, :aws_secret_access_key
+      recognizes :region, :host, :path, :port, :scheme, :persistent
+
+      request_path 'fog/aws/requests/elasticache'
+
+      request :create_cache_cluster
+      request :delete_cache_cluster
+      request :describe_cache_clusters
+      request :modify_cache_cluster
+      request :reboot_cache_cluster
+
+      request :create_cache_parameter_group
+      request :delete_cache_parameter_group
+      request :describe_cache_parameter_groups
+      request :modify_cache_parameter_group
+      request :reset_cache_parameter_group
+      request :describe_engine_default_parameters
+      request :describe_cache_parameters
+
+      request :create_cache_security_group
+      request :delete_cache_security_group
+      request :describe_cache_security_groups
+      request :authorize_cache_security_group_ingress
+      request :revoke_cache_security_group_ingress
+
+      request :describe_events
+
+      model_path 'fog/aws/models/elasticache'
+      model :cluster
+      collection :clusters
+      model :security_group
+      collection :security_groups
+      model :parameter_group
+      collection :parameter_groups
+
+      class Mock
+        def initalize(options={})
+          Fog::Mock.not_implemented
+        end
+      end
+
+      class Real
+
+        def initialize(options={})
+          @aws_access_key_id      = options[:aws_access_key_id]
+          @aws_secret_access_key  = options[:aws_secret_access_key]
+          @hmac = Fog::HMAC.new('sha256', @aws_secret_access_key)
+
+          options[:region] ||= 'us-east-1'
+          @host = options[:host] || case options[:region]
+          when 'us-east-1'
+            'elasticache.us-east-1.amazonaws.com'
+            #TODO: Support other regions
+          else
+            raise ArgumentError, "Unknown region: #{options[:region].inspect}"
+          end
+          @path       = options[:path]      || '/'
+          @port       = options[:port]      || 443
+          @scheme     = options[:scheme]    || 'https'
+          @connection = Fog::Connection.new(
+            "#{@scheme}://#{@host}:#{@port}#{@path}", options[:persistent]
+          )
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        private
+        def request(params)
+          idempotent  = params.delete(:idempotent)
+          parser      = params.delete(:parser)
+
+          body = Fog::AWS.signed_params(
+            params,
+            {
+            :aws_access_key_id  => @aws_access_key_id,
+            :hmac               => @hmac,
+            :host               => @host,
+            :path               => @path,
+            :port               => @port,
+            :version            => '2011-07-15'
+          }
+          )
+
+          begin
+            response = @connection.request({
+              :body       => body,
+              :expects    => 200,
+              :headers    => { 'Content-Type' => 'application/x-www-form-urlencoded' },
+              :idempotent => idempotent,
+              :host       => @host,
+              :method     => 'POST',
+              :parser     => parser
+            })
+          rescue Excon::Errors::HTTPStatusError => error
+            if match = error.message.match(/<Code>(.*)<\/Code>/m)
+              case match[1]
+              when 'CacheSecurityGroupNotFound', 'CacheParameterGroupNotFound',
+                'CacheClusterNotFound'
+                raise Fog::AWS::Elasticache::NotFound
+              when 'CacheSecurityGroupAlreadyExists'
+                raise Fog::AWS::Elasticache::IdentifierTaken
+              when 'InvalidParameterValue'
+                raise Fog::AWS::Elasticache::InvalidInstance
+              else
+                raise
+              end
+            else
+              raise
+            end
+          end
+
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/models/cloud_watch/alarm.rb

@@ -0,0 +1,12 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class CloudWatch
+
+      class Alarm < Fog::Model
+        attribute :alarm_names, :aliases => 'AlarmNames'
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/models/cloud_watch/alarm_data.rb

@@ -0,0 +1,39 @@
+require 'fog/core/collection'
+require 'fog/aws/models/cloud_watch/alarm_datum'
+
+module Fog
+  module AWS
+    class CloudWatch
+      class AlarmData < Fog::Collection
+        model Fog::AWS::CloudWatch::AlarmDatum
+        
+        def all(conditions={})
+          data = connection.describe_alarms(conditions).body['DescribeAlarmsResult']['MetricAlarms']
+          load(data) # data is an array of attribute hashes
+        end
+        
+        def get(namespace, metric_name, dimensions=nil, period=nil, statistic=nil, unit=nil)
+          list_opts = {'Namespace' => namespace, 'MetricName' => metric_name}
+          if dimensions
+            dimensions_array = dimensions.collect do |name, value|
+              {'Name' => name, 'Value' => value}
+            end
+            list_opts.merge!('Dimensions' => dimensions_array) 
+          end
+          if period
+            list_opts.merge!('Period' => period) 
+          end
+          if statistic
+          list_opts.merge!('Statistic' => statistic) 
+          end
+          if unit
+            list_opts.merge!('Unit' => unit) 
+          end
+          data = connection.describe_alarms_for_metric(list_opts).body['DescribeAlarmsForMetricResult']['MetricAlarms']
+          load(data)
+        end
+        
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/models/cloud_watch/alarm_datum.rb

@@ -0,0 +1,66 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class CloudWatch
+
+      class AlarmDatum < Fog::Model
+        attribute :alarm_name, :aliases => 'AlarmName'
+        attribute :metric_name, :aliases => 'MetricName'
+        attribute :namespace, :aliases => 'Namespace'
+        attribute :dimensions, :aliases => 'Dimensions'
+        attribute :alarm_description, :aliases => 'AlarmDescription'
+        attribute :alarm_arn, :aliases => 'AlarmArn'
+        attribute :state_value, :aliases => 'StateValue'
+        attribute :statistic, :aliases => 'Statistic'
+        attribute :comparison_operator, :aliases => 'ComparisonOperator'
+        attribute :state_reason, :aliases => 'StateReason'
+        attribute :action_enabled, :aliases => 'ActionsEnabled'
+        attribute :period, :aliases => 'Period' 
+        attribute :evaluation_periods, :aliases => 'EvaluationPeriods'
+        attribute :threshold, :aliases => 'Threshold'
+        attribute :alarm_actions, :aliases => 'AlarmActions'
+        attribute :ok_actions, :aliases => 'OKActions'
+        attribute :insufficient_actions, :aliases => 'InsufficientDataActions'
+        attribute :unit, :aliases => 'Unit'
+        attribute :state_updated_timestamp, :aliases => 'StateUpdatedTimestamp'
+        attribute :alarm_configuration_updated_timestamp, :aliases => 'AlarmConfigurationUpdatedTimestamp'
+
+        def save
+          requires :alarm_name
+          requires :comparison_operator
+          requires :evaluation_periods
+          requires :metric_name
+          requires :namespace
+          requires :period
+          requires :statistic
+          requires :threshold
+
+          alarm_definition = {
+              'AlarmName' => alarm_name,
+              'ComparisonOperator' => comparison_operator,
+              'EvaluationPeriods' => evaluation_periods,
+              'MetricName' => metric_name, 
+              'Namespace' => namespace,
+              'Period' => period,
+              'Statistic' => statistic,
+              'Threshold' => threshold
+              }
+
+          alarm_definition.merge!('ActionsEnabled' => action_enabled) if action_enabled
+          alarm_definition.merge!('AlarmActions' => alarm_actions) if alarm_actions
+          alarm_definition.merge!('AlarmDescription' => alarm_description) if alarm_description
+
+          #dimension is an array of Name/Value pairs, ex. [{'Name'=>'host', 'Value'=>'localhost'},{'Name'=>'version', 'Value'=>'0.11.0'}]
+          alarm_definition.merge!('Dimensions' => dimensions) if dimensions
+          alarm_definition.merge!('InsufficientDataActions' => insufficient_actions) if insufficient_actions
+          alarm_definition.merge!('OKActions' => ok_actions) if ok_actions
+          alarm_definition.merge!('Unit' => unit) if unit
+
+          connection.put_metric_alarm(alarm_definition)
+          true
+        end
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/models/cloud_watch/alarm_histories.rb

@@ -0,0 +1,18 @@
+require 'fog/core/collection'
+require 'fog/aws/models/cloud_watch/alarm_history'
+
+module Fog
+  module AWS
+    class CloudWatch
+      class AlarmHistories < Fog::Collection
+        model Fog::AWS::CloudWatch::AlarmHistory
+
+        def all(conditions={})
+          data = connection.describe_alarm_history(conditions).body['DescribeAlarmHistoryResult']['AlarmHistoryItems']
+          load(data) # data is an array of attribute hashes
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/models/cloud_watch/alarm_history.rb

@@ -0,0 +1,16 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class CloudWatch
+
+      class AlarmHistory < Fog::Model
+        attribute :alarm_name, :aliases => 'AlarmName'
+        attribute :end_date, :aliases => 'EndDate'
+        attribute :history_item_type, :aliases => 'HistoryItemType'
+        attribute :max_records, :aliases => 'MaxRecords'
+        attribute :start_date, :aliases => 'StartDate'
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/models/cloud_watch/alarms.rb

@@ -0,0 +1,30 @@
+require 'fog/core/collection'
+require 'fog/aws/models/cloud_watch/alarm'
+
+module Fog
+  module AWS
+    class CloudWatch
+
+      class Alarms < Fog::Collection
+        model Fog::AWS::CloudWatch::Alarm
+    
+        #alarm_names is an array of alarm names
+        def delete(alarm_names)
+          connection.delete_alarms(alarm_names)
+          true
+        end
+
+        def disable(alarm_names)
+          connection.disable_alarm_actions(alarm_names)
+          true
+        end
+
+        def enable(alarm_names)
+          connection.enable_alarm_actions(alarm_names)
+          true
+        end
+
+      end
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/models/compute/servers.rb

@@ -49,7 +49,7 @@ module Fog
         #    user_data=nil
         #  >
         #
-        
+
         def initialize(attributes)
           self.filters ||= {}
           super

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/models/elasticache/cluster.rb

@@ -0,0 +1,69 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class Elasticache
+
+      class Cluster < Fog::Model
+        # simple attributes
+        identity :id, :aliases => 'CacheClusterId'
+        attribute :auto_upgrade, :aliases => 'AutoMinorVersionUpgrade'
+        attribute :status, :aliases => 'CacheClusterStatus'
+        attribute :node_type, :aliases => 'CacheNodeType'
+        attribute :engine, :aliases => 'Engine'
+        attribute :engine_version, :aliases => 'EngineVersion'
+        attribute :num_nodes, :aliases => 'NumCacheNodes'
+        attribute :zone, :aliases => 'PreferredAvailabilityZone'
+        attribute :port, :aliases => 'Port'
+        attribute :maintenance_window, :aliases => 'PreferredMaintenanceWindow'
+        # complex attributes
+        attribute :nodes, :aliases => 'CacheNodes', :type => :array
+        attribute :parameter_group,
+          :aliases => 'CacheParameterGroup', :type => :hash
+        attribute :pending_values,
+          :aliases => 'PendingModifiedValues', :type => :hash
+        attribute :create_time,
+          :aliases => 'CacheClusterCreateTime', :type => :date_time
+        attribute :security_groups,
+          :aliases => 'CacheSecurityGroups', :type => :array
+        attribute :notification_config,
+          :aliases => 'NotificationConfiguration', :type => :hash
+
+        def ready?
+          status == 'available'
+        end
+
+        def destroy
+          requires :id
+          connection.delete_cache_cluster(id)
+          true
+        end
+
+        def save
+          requires :id
+
+          parameter_group     ||= Hash.new
+          notification_config ||= Hash.new
+
+          connection.create_cache_cluster(
+            id, {
+              :node_type                    => node_type,
+              :security_group_names         => security_groups,
+              :num_nodes                    => num_nodes,
+              :auto_minor_version_upgrade   => auto_upgrade,
+              :engine                       => engine,
+              :engine_version               => engine_version,
+              :notification_topic_arn       => notification_config['TopicArn'],
+              :port                         => port,
+              :preferred_availablility_zone => zone,
+              :preferred_maintenance_window => maintenance_window,
+              :parameter_group_name => parameter_group['CacheParameterGroupName'],
+            }
+          )
+        end
+
+      end
+
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/models/elasticache/clusters.rb

@@ -0,0 +1,31 @@
+require 'fog/core/collection'
+require 'fog/aws/models/elasticache/cluster'
+
+module Fog
+  module AWS
+    class Elasticache
+
+      class Clusters < Fog::Collection
+        model Fog::AWS::Elasticache::Cluster
+
+        def all
+          load(
+            connection.describe_cache_clusters(
+              nil, :show_node_info => true
+            ).body['CacheClusters']
+          )
+        end
+
+        def get(identity, show_node_info = true)
+          new(
+            connection.describe_cache_clusters(
+              identity, :show_node_info => show_node_info
+            ).body['CacheClusters'].first
+          )
+        rescue Fog::AWS::Elasticache::NotFound
+        end
+      end
+
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/models/elasticache/parameter_group.rb

@@ -0,0 +1,32 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class Elasticache
+
+      class ParameterGroup < Fog::Model
+
+        identity :id, :aliases => 'CacheParameterGroupName'
+        attribute :description, :aliases => 'Description'
+        attribute :family, :aliases => 'CacheParameterGroupFamily'
+
+        def destroy
+          requires :id
+          connection.delete_cache_parameter_group(id)
+          true
+        end
+
+        def save
+          requires :id
+          connection.create_cache_parameter_group(
+            id,
+            description = id,
+            family      = 'memcached1.4'
+          )
+        end
+
+      end
+
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/models/elasticache/parameter_groups.rb

@@ -0,0 +1,30 @@
+require 'fog/core/collection'
+require 'fog/aws/models/elasticache/parameter_group'
+
+module Fog
+  module AWS
+    class Elasticache
+
+      class ParameterGroups < Fog::Collection
+        model Fog::AWS::Elasticache::ParameterGroup
+
+        def all
+          load(
+            connection.describe_cache_parameter_groups.body['CacheParameterGroups']
+          )
+        end
+
+        def get(identity)
+          new(
+            connection.describe_cache_parameter_groups(
+              identity
+            ).body['CacheParameterGroups'].first
+          )
+        rescue Fog::AWS::Elasticache::NotFound
+          nil
+        end
+      end
+
+    end
+  end
+end

data/lib/brightbox-cli/vendor/fog/lib/fog/aws/models/elasticache/security_group.rb

@@ -0,0 +1,52 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class Elasticache
+
+      class SecurityGroup < Fog::Model
+
+        identity :id, :aliases => 'CacheSecurityGroupName'
+        attribute :description, :aliases => 'Description'
+        attribute :ec2_groups, :aliases => 'EC2SecurityGroups', :type => :array
+        attribute :owner_id, :aliases => 'OwnerId'
+
+        def ready?
+          ec2_groups.all?{|ingress| ingress['Status'] == 'authorized'}
+        end
+
+        def destroy
+          requires :id
+          connection.delete_cache_security_group(id)
+          true
+        end
+
+        def save
+          requires :id
+          requires :description
+          connection.create_cache_security_group(id, description)
+        end
+
+        def authorize_ec2_group(group_name, group_owner_id=owner_id)
+          requires :id
+          requires :owner_id if group_owner_id.nil?
+          data = connection.authorize_cache_security_group_ingress(
+            id, group_name, group_owner_id
+          )
+          merge_attributes(data.body['CacheSecurityGroup'])
+        end
+
+        def revoke_ec2_group(group_name, group_owner_id=owner_id)
+          requires :id
+          requires :owner_id if group_owner_id.nil?
+          data = connection.revoke_cache_security_group_ingress(
+            id, group_name, group_owner_id
+          )
+          merge_attributes(data.body['CacheSecurityGroup'])
+        end
+
+      end
+
+    end
+  end
+end