fog 0.9.0 → 0.10.0

data/lib/fog/aws/models/auto_scaling/instance.rb

@@ -0,0 +1,60 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class AutoScaling
+      class Instance < Fog::Model
+
+        identity  :id,                        :aliases => 'InstanceId'
+        attribute :auto_scaling_group_name,   :aliases => 'AutoScalingGroupName'
+        attribute :availability_zone,         :aliases => 'AvailabilityZone'
+        attribute :health_status,             :aliases => 'HealthStatus'
+        attribute :launch_configuration_name, :aliases => 'LaunchConfigurationName'
+        attribute :life_cycle_state,          :aliases => 'LifecycleState'
+
+        def initialize(attributes={})
+          super
+        end
+
+        def group
+          connection.groups.get(attributes['AutoScalingGroupName'])
+        end
+
+        def configuration
+          connection.configurations.get(attributes['LaunchConfigurationName'])
+        end
+
+        def set_health(health_status, options)
+          requires :id
+          connection.set_instance_health(health_status, id, options)
+          reload
+        end
+
+        def terminate(should_decrement_desired_capacity)
+          requires :id
+          connection.terminate_instance_in_auto_scaling_group(id, should_decrement_desired_capacity)
+          reload
+        end
+
+        def healthy?
+          health_status == 'HEALTHY'
+        end
+
+        def ready?
+          life_cycle_state == 'InService'
+        end
+
+        def reload
+          super
+          self
+        end
+
+        #def destroy
+        #  requires :id
+        #  connection.delete_auto_scaling_group(id)
+        #end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/models/auto_scaling/instances.rb

@@ -0,0 +1,30 @@
+require 'fog/aws/models/auto_scaling/instance'
+
+module Fog
+  module AWS
+    class AutoScaling
+      class Instances < Fog::Collection
+
+        model Fog::AWS::AutoScaling::Instance
+
+        def all
+          data = []
+          next_token = nil
+          loop do
+            result = connection.describe_auto_scaling_instances('NextToken' => next_token).body['DescribeAutoScalingInstancesResult']
+            data += result['AutoScalingInstances']
+            next_token = result['NextToken']
+            break if next_token.nil?
+          end
+          load(data)
+        end
+
+        def get(identity)
+          data = connection.describe_auto_scaling_instances('InstanceIds' => identity).body['DescribeAutoScalingInstancesResult']['AutoScalingInstances'].first
+          new(data) unless data.nil?
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/models/cloud_watch/metric.rb

@@ -0,0 +1,14 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class CloudWatch
+
+      class Metric < Fog::Model
+        attribute :name, :aliases => 'MetricName'
+        attribute :namespace, :aliases => 'Namespace'
+        attribute :dimensions, :aliases => 'Dimensions'
+      end
+    end
+  end
+end

data/lib/fog/aws/models/cloud_watch/metric_statistic.rb

@@ -0,0 +1,46 @@
+require 'fog/core/model'
+
+module Fog
+  module AWS
+    class CloudWatch
+
+      class MetricStatistic < Fog::Model
+        attribute :label, :aliases => 'Label'
+        attribute :minimum, :aliases => 'Minimum'
+        attribute :maximum, :aliases => 'Maximum'
+        attribute :sum, :aliases => 'Sum'
+        attribute :average, :aliases => 'Average'
+        attribute :sample_count, :aliases => 'SampleCount'
+        attribute :timestamp, :aliases => 'Timestamp'
+        attribute :unit, :aliases => 'Unit'
+        attribute :metric_name, :aliases => 'MetricName'
+        attribute :namespace, :aliases => 'Namespace'
+        attribute :dimensions, :aliases => 'Dimensions'
+        attribute :value
+        
+        def save
+          requires :metric_name
+          requires :namespace
+          requires :unit
+
+          put_opts = {'MetricName' => metric_name, 'Unit' => unit}
+          put_opts.merge!('Dimensions' => dimensions) if dimensions
+          put_opts.merge!('Timestamp' => dimensions) if timestamp
+          if value
+            put_opts.merge!('Value' => value)
+          else
+            put_opts.merge!('StatisticValues' => {
+              'Minimum' => minimum,
+              'Maximum' => maximum,
+              'Sum' => sum,
+              'Average' => average,
+              'SampleCount' => sample_count
+            })
+          end
+          connection.put_metric_data(namespace, [put_opts])
+          true
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/models/cloud_watch/metric_statistics.rb

@@ -0,0 +1,23 @@
+require 'fog/core/collection'
+require 'fog/aws/models/cloud_watch/metric_statistic'
+
+module Fog
+  module AWS
+    class CloudWatch
+      class MetricStatistics < Fog::Collection
+        model Fog::AWS::CloudWatch::MetricStatistic
+        
+        def all(conditions)
+          metricName = conditions['MetricName']
+          namespace = conditions['Namespace']
+          dimensions = conditions['Dimensions']
+          get_metric_opts = {"StartTime" => (Time.now-3600).iso8601, "EndTime" => Time.now.iso8601, "Period" => 300}.merge(conditions)
+          data = connection.get_metric_statistics(get_metric_opts).body['GetMetricStatisticsResult']['Datapoints']
+          data.collect! { |datum| datum.merge('MetricName' => metricName, 'Namespace' => namespace, 'Dimensions' => dimensions) }
+          load(data) # data is an array of attribute hashes
+        end
+        
+      end
+    end
+  end
+end

data/lib/fog/aws/models/cloud_watch/metrics.rb

@@ -0,0 +1,32 @@
+require 'fog/core/collection'
+require 'fog/aws/models/cloud_watch/metric'
+
+module Fog
+  module AWS
+    class CloudWatch
+
+      class Metrics < Fog::Collection
+        model Fog::AWS::CloudWatch::Metric
+        
+        def all(conditions={})
+          data = connection.list_metrics(conditions).body['ListMetricsResult']['Metrics']
+          load(data) # data is an array of attribute hashes
+        end
+        
+        def get(namespace, metric_name, dimensions=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 data = connection.list_metrics(list_opts).body['ListMetricsResult']['Metrics'].first
+            new(data)
+          end
+        end
+        
+      end
+    end
+  end
+end

data/lib/fog/aws/models/elb/listener.rb

@@ -10,6 +10,12 @@ module Fog
         attribute :protocol,      :aliases => 'Protocol'
         attribute :ssl_id,        :aliases => 'SSLCertificateId'
 
+        def initialize(attributes={})
+          # set defaults, which may be overridden in super
+          merge_attributes(:policy_names => [], :instance_port => 80, :lb_port => 80, :protocol => 'HTTP')
+          super
+        end
+
         def save
           requires :load_balancer, :instance_port, :lb_port, :protocol
           connection.create_load_balancer_listeners(load_balancer.id, [to_params])

data/lib/fog/aws/models/elb/listeners.rb

@@ -17,9 +17,9 @@ module Fog
         end
 
         private
-        # Munge an array of ListernerDescription hashes like:
+        # Munge an array of ListenerDescription hashes like:
         # {'Listener' => listener, 'PolicyNames' => []}
-        # to an array of listeners withi a PolicyNames key
+        # to an array of listeners with a PolicyNames key
         def munged_data
           data.map {|description|
             description['Listener'].merge('PolicyNames' => description['PolicyNames'])

data/lib/fog/aws/models/elb/load_balancer.rb

@@ -14,11 +14,14 @@ module Fog
         attribute :source_group,          :aliases => 'SourceSecurityGroup'
 
         def initialize(attributes={})
-          attributes[:availability_zones] ||= %w(us-east-1a us-east-1b us-east-1c us-east-1d)
-          attributes['ListenerDescriptions'] ||= [{
-            'Listener' => {'LoadBalancerPort' => 80, 'InstancePort' => 80, 'Protocol' => 'http'},
-            'PolicyNames' => []
-          }]
+          attributes[:availability_zones] ||= attributes['AvailabilityZones'] || %w(us-east-1a us-east-1b us-east-1c us-east-1d)
+          unless attributes['ListenerDescriptions']
+            new_listener = Fog::AWS::ELB::Listener.new
+            attributes['ListenerDescriptions'] = [{
+              'Listener' => new_listener.to_params,
+              'PolicyNames' => new_listener.policy_names
+            }]
+          end
           attributes['Policies'] ||= {'AppCookieStickinessPolicies' => [], 'LBCookieStickinessPolicies' => []}
           super
         end

data/lib/fog/aws/models/rds/server.rb

@@ -28,6 +28,7 @@ module Fog
         attribute :db_security_groups, :aliases => 'DBSecurityGroups'
         attribute :db_parameter_groups, :aliases => 'DBParameterGroups'
         attribute :backup_retention_period, :aliases => 'BackupRetentionPeriod', :type => :integer
+        attribute :license_model, :aliases => 'LicenseModel'
 
         attr_accessor :password, :parameter_group_name, :security_group_names, :port
         
@@ -89,7 +90,8 @@ module Fog
             'MasterUserPassword'            => password,
             'PreferredMaintenanceWindow'    => preferred_maintenance_window,
             'PreferredBackupWindow'         => preferred_backup_window,
-            'MultiAZ'                       => multi_az
+            'MultiAZ'                       => multi_az,
+            'LicenseModel'                  => license_model
           }
           options.delete_if {|key, value| value.nil?}
 

data/lib/fog/aws/parsers/auto_scaling/basic.rb

@@ -0,0 +1,28 @@
+module Fog
+  module Parsers
+    module AWS
+      module AutoScaling
+
+        class Basic < Fog::Parsers::Base
+
+          def reset
+            @response = { 'ResponseMetadata' => {} }
+          end
+
+          def start_element(name, attrs = [])
+            super
+          end
+
+          def end_element(name)
+            case name
+            when 'RequestId'
+              @response['ResponseMetadata'][name] = value
+            end
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/aws/parsers/auto_scaling/describe_adjustment_types.rb

@@ -0,0 +1,39 @@
+module Fog
+  module Parsers
+    module AWS
+      module AutoScaling
+
+        class DescribeAdjustmentTypes < Fog::Parsers::Base
+
+          def reset
+            reset_adjustment_type
+            @results = { 'AdjustmentTypes' => [] }
+            @response = { 'DescribeAdjustmentTypesResult' => {}, 'ResponseMetadata' => {} }
+          end
+
+          def reset_adjustment_type
+            @adjustment_type = {}
+          end
+
+          def end_element(name)
+            case name
+            when 'member'
+              @results['AdjustmentTypes'] << @adjustment_type
+              reset_adjustment_type
+
+            when 'AdjustmentType'
+              @adjustment_type[name] = value
+
+            when 'RequestId'
+              @response['ResponseMetadata'][name] = value
+
+            when 'DescribeAdjustmentTypesResponse'
+              @response['DescribeAdjustmentTypesResult'] = @results
+            end
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/fog/aws/parsers/auto_scaling/describe_auto_scaling_groups.rb

@@ -0,0 +1,126 @@
+module Fog
+  module Parsers
+    module AWS
+      module AutoScaling
+
+        class DescribeAutoScalingGroups < Fog::Parsers::Base
+
+          def reset
+            reset_auto_scaling_group
+            reset_enabled_metric
+            reset_instance
+            reset_suspended_process
+            @results = { 'AutoScalingGroups' => [] }
+            @response = { 'DescribeAutoScalingGroupsResult' => {}, 'ResponseMetadata' => {} }
+          end
+
+          def reset_auto_scaling_group
+            @auto_scaling_group = { 'AvailabilityZones' => [], 'EnabledMetrics' => [], 'Instances' => [], 'LoadBalancerNames' => [], 'SuspendedProcesses' => [] }
+          end
+
+          def reset_enabled_metric
+            @enabled_metric = {}
+          end
+
+          def reset_instance
+            @instance = {}
+          end
+
+          def reset_suspended_process
+            @suspended_process = {}
+          end
+
+          def start_element(name, attrs = [])
+            super
+            case name
+            when 'AvailabilityZones'
+              @in_availability_zones = true
+            when 'EnabledMetrics'
+              @in_enabled_metrics = true
+            when 'Instances'
+              @in_instances = true
+            when 'LoadBalancerNames'
+              @in_load_balancer_names = true
+            when 'SuspendedProcesses'
+              @in_suspended_processes = true
+            end
+          end
+
+          def end_element(name)
+            case name
+            when 'member'
+              if @in_availability_zones
+                @auto_scaling_group['AvailabilityZones'] << value
+              elsif @in_enabled_metrics
+                @auto_scaling_group['EnabledMetrics'] << @enabled_metric
+                reset_enabled_metric
+              elsif @in_instances
+                @auto_scaling_group['Instances'] << @instance
+                reset_instance
+              elsif @in_load_balancer_names
+                @auto_scaling_group['LoadBalancerNames'] << value
+              elsif @in_suspended_processes
+                @auto_scaling_group['SuspendedProcesses'] << @suspended_process
+                reset_suspended_process
+              elsif !@in_instances && !@in_policies
+                @results['AutoScalingGroups'] << @auto_scaling_group
+                reset_auto_scaling_group
+              end
+
+            when 'AvailabilityZones'
+              @in_availability_zones = false
+              
+            when 'Granularity', 'Metric'
+              @enabled_metric[name] = value
+            when 'EnabledMetrics'
+              @in_enabled_metrics = false
+
+            when 'LaunchConfigurationName'
+              if @in_instances
+                @instance[name] = value
+              else
+                @auto_scaling_group[name] = value
+              end
+
+            when 'AvailabilityZone', 'HealthStatus', 'InstanceId', 'LifecycleState'
+              @instance[name] = value
+            when 'Instances'
+              @in_instances = false
+
+            when 'LoadBalancerNames'
+              @in_load_balancer_names = false
+
+            when 'ProcessName', 'SuspensionReason'
+              @suspended_process[name] = value
+            when 'SuspendedProcesses'
+              @in_suspended_processes = false
+
+            when 'AutoScalingGroupARN', 'AutoScalingGroupName'
+              @auto_scaling_group[name] = value
+            when 'CreatedTime'
+              @auto_scaling_group[name] = Time.parse(value)
+            when 'DefaultCooldown', 'DesiredCapacity', 'HealthCheckGracePeriod'
+              @auto_scaling_group[name] = value.to_i
+            when 'HealthCheckType'
+              @auto_scaling_group[name] = value
+            when 'MaxSize', 'MinSize'
+              @auto_scaling_group[name] = value.to_i
+            when 'PlacementGroup', 'VPCZoneIdentifier'
+              @auto_scaling_group[name] = value
+
+            when 'NextToken'
+              @results[name] = value
+
+            when 'RequestId'
+              @response['ResponseMetadata'][name] = value
+
+            when 'DescribeAutoScalingGroupsResponse'
+              @response['DescribeAutoScalingGroupsResult'] = @results
+            end
+          end
+
+        end
+      end
+    end
+  end
+end