miasma-aws 0.3.10 → 0.3.12

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

@@ -1,4 +1,4 @@
-require 'miasma'
+require "miasma"
 
 module Miasma
   module Models
@@ -7,9 +7,9 @@ module Miasma
       class Aws < AutoScale
 
         # Service name of the API
-        API_SERVICE = 'autoscaling'.freeze
+        API_SERVICE = "autoscaling".freeze
         # Supported version of the AutoScaling API
-        API_VERSION = '2011-01-01'.freeze
+        API_VERSION = "2011-01-01".freeze
 
         include Contrib::AwsApiCore::ApiCommon
         include Contrib::AwsApiCore::RequestUtils
@@ -27,7 +27,7 @@ module Miasma
         # @param group [Models::AutoScale::Group]
         # @return [Models::AutoScale::Group]
         def group_reload(group)
-          if(group.id || group.name)
+          if group.id || group.name
             load_group_data(group)
           end
           group
@@ -45,35 +45,34 @@ module Miasma
         #
         # @param group [Models::AutoScale::Group]
         # @return [Array<Models::AutoScale::Group>]
-        def load_group_data(group=nil)
-          params = Smash.new('Action' => 'DescribeAutoScalingGroups')
-          if(group)
-            params.merge('AutoScalingGroupNames.member.1' => group.id || group.name)
+        def load_group_data(group = nil)
+          params = Smash.new("Action" => "DescribeAutoScalingGroups")
+          if group
+            params.merge("AutoScalingGroupNames.member.1" => group.id || group.name)
           end
           result = all_result_pages(nil, :body,
-            'DescribeAutoScalingGroupsResponse', 'DescribeAutoScalingGroupsResult',
-            'AutoScalingGroups', 'member'
-          ) do |options|
+                                    "DescribeAutoScalingGroupsResponse", "DescribeAutoScalingGroupsResult",
+                                    "AutoScalingGroups", "member") do |options|
             request(
               :method => :post,
-              :path => '/',
-              :form => options.merge(params)
+              :path => "/",
+              :form => options.merge(params),
             )
           end.map do |grp|
             (group || Group.new(self)).load_data(
-              :id => grp['AutoScalingGroupName'],
-              :name => grp['AutoScalingGroupName'],
-              :servers => [grp.get('Instances', 'member')].flatten(1).compact.map{|i|
-                Group::Server.new(self, :id => i['InstanceId'])
+              :id => grp["AutoScalingGroupName"],
+              :name => grp["AutoScalingGroupName"],
+              :servers => [grp.get("Instances", "member")].flatten(1).compact.map { |i|
+                Group::Server.new(self, :id => i["InstanceId"])
               },
-              :minimum_size => grp['MinSize'],
-              :maximum_size => grp['MaxSize'],
-              :status => grp['Status'],
+              :minimum_size => grp["MinSize"],
+              :maximum_size => grp["MaxSize"],
+              :status => grp["Status"],
               :load_balancers => [
-                grp.get('LoadBalancerNames', 'member')
-              ].flatten(1).compact.map{|i|
+                grp.get("LoadBalancerNames", "member"),
+              ].flatten(1).compact.map { |i|
                 Group::Balancer.new(self, :id => i, :name => i)
-              }
+              },
             ).valid_state
           end
         end
@@ -82,10 +81,9 @@ module Miasma
         #
         # @param options [Hash] filter
         # @return [Array<Models::AutoScale::Group>]
-        def group_all(options={})
+        def group_all(options = {})
           load_group_data
         end
-
       end
     end
   end

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

@@ -1,73 +1,71 @@
-require 'miasma'
+require "miasma"
 
 module Miasma
-
   module Models
     class Compute
       # Compute interface for AWS
       class Aws < Compute
 
         # Service name of the API
-        API_SERVICE = 'ec2'.freeze
+        API_SERVICE = "ec2".freeze
         # Supported version of the EC2 API
-        API_VERSION = '2014-06-15'.freeze
+        API_VERSION = "2014-06-15".freeze
 
         include Contrib::AwsApiCore::ApiCommon
         include Contrib::AwsApiCore::RequestUtils
 
         # @return [Smash] map state to valid internal values
         SERVER_STATE_MAP = Smash.new(
-          'running' => :running,
-          'pending' => :pending,
-          'shutting-down' => :pending,
-          'terminated' => :terminated,
-          'stopping' => :pending,
-          'stopped' => :stopped
+          "running" => :running,
+          "pending" => :pending,
+          "shutting-down" => :pending,
+          "terminated" => :terminated,
+          "stopping" => :pending,
+          "stopped" => :stopped,
         ).to_smash(:freeze)
 
         # @todo catch bad lookup and clear model
         def server_reload(server)
           result = request(
             :method => :post,
-            :path => '/',
+            :path => "/",
             :form => {
-              'Action' => 'DescribeInstances',
-              'InstanceId.1' => server.id
-            }
+              "Action" => "DescribeInstances",
+              "InstanceId.1" => server.id,
+            },
           )
           srv = result.get(:body,
-            'DescribeInstancesResponse', 'reservationSet',
-            'item', 'instancesSet', 'item'
-          )
+                           "DescribeInstancesResponse", "reservationSet",
+                           "item", "instancesSet", "item")
           server.load_data(
             :id => srv[:instanceId],
-            :name => [srv.fetch(:tagSet, :item, [])].flatten.map{|tag|
-              tag[:value] if tag.is_a?(Hash) && tag[:key] == 'Name'
+            :name => [srv.fetch(:tagSet, :item, [])].flatten.map { |tag|
+              tag[:value] if tag.is_a?(Hash) && tag[:key] == "Name"
             }.compact.first,
             :image_id => srv[:imageId],
             :flavor_id => srv[:instanceType],
             :state => SERVER_STATE_MAP.fetch(srv.get(:instanceState, :name), :pending),
             :addresses_private => [
-              Server::Address.new(:version => 4, :address => srv[:privateIpAddress])
+              Server::Address.new(:version => 4, :address => srv[:privateIpAddress]),
             ],
             :addresses_public => [
-              Server::Address.new(:version => 4, :address => srv[:ipAddress])
+              Server::Address.new(:version => 4, :address => srv[:ipAddress]),
             ],
             :status => srv.get(:instanceState, :name),
-            :key_name => srv[:keyName]
+            :key_name => srv[:keyName],
           )
           server.valid_state
         end
 
         def server_destroy(server)
-          if(server.persisted?)
+          if server.persisted?
             result = request(
               :method => :post,
-              :path => '/',
+              :path => "/",
               :form => {
-                'Action' => 'TerminateInstances',
-                'InstanceId.1' => server.id
-              }
+                "Action" => "TerminateInstances",
+                "InstanceId.1" => server.id,
+              },
             )
           else
             raise "this doesn't even exist"
@@ -75,50 +73,48 @@ module Miasma
         end
 
         def server_save(server)
-          unless(server.persisted?)
+          unless server.persisted?
             server.load_data(server.attributes)
             result = request(
               :method => :post,
-              :path => '/',
+              :path => "/",
               :form => {
-                'Action' => 'RunInstances',
-                'ImageId' => server.image_id,
-                'InstanceType' => server.flavor_id,
-                'KeyName' => server.key_name,
-                'MinCount' => 1,
-                'MaxCount' => 1
-              }
+                "Action" => "RunInstances",
+                "ImageId" => server.image_id,
+                "InstanceType" => server.flavor_id,
+                "KeyName" => server.key_name,
+                "MinCount" => 1,
+                "MaxCount" => 1,
+              },
             )
             server.id = result.get(:body,
-              'RunInstancesResponse', 'instancesSet', 'item', 'instanceId'
-            )
+                                   "RunInstancesResponse", "instancesSet", "item", "instanceId")
             server.valid_state
             request(
               :method => :post,
-              :path => '/',
+              :path => "/",
               :form => {
-                'Action' => 'CreateTags',
-                'ResourceId.1' => server.id,
-                'Tag.1.Key' => 'Name',
-                'Tag.1.Value' => server.name
-              }
+                "Action" => "CreateTags",
+                "ResourceId.1" => server.id,
+                "Tag.1.Key" => "Name",
+                "Tag.1.Value" => server.name,
+              },
             )
           else
-            raise 'WAT DO I DO!?'
+            raise "WAT DO I DO!?"
           end
         end
 
         # @todo need to add auto pagination helper (as common util)
         def server_all
           results = all_result_pages(nil, :body,
-            'DescribeInstancesResponse', 'reservationSet', 'item'
-          ) do |options|
+                                     "DescribeInstancesResponse", "reservationSet", "item") do |options|
             request(
               :method => :post,
-              :path => '/',
+              :path => "/",
               :form => options.merge(
-                'Action' => 'DescribeInstances'
-              )
+                "Action" => "DescribeInstances",
+              ),
             )
           end
           results.map do |server|
@@ -126,25 +122,24 @@ module Miasma
               Server.new(
                 self,
                 :id => srv[:instanceId],
-                :name => srv.fetch(:tagSet, :item, []).map{|tag|
-                  tag[:value] if tag.is_a?(Hash) && tag[:key] == 'Name'
+                :name => srv.fetch(:tagSet, :item, []).map { |tag|
+                  tag[:value] if tag.is_a?(Hash) && tag[:key] == "Name"
                 }.compact.first,
                 :image_id => srv[:imageId],
                 :flavor_id => srv[:instanceType],
                 :state => SERVER_STATE_MAP.fetch(srv.get(:instanceState, :name), :pending),
                 :addresses_private => [
-                  Server::Address.new(:version => 4, :address => srv[:privateIpAddress])
+                  Server::Address.new(:version => 4, :address => srv[:privateIpAddress]),
                 ],
                 :addresses_public => [
-                  Server::Address.new(:version => 4, :address => srv[:ipAddress])
+                  Server::Address.new(:version => 4, :address => srv[:ipAddress]),
                 ],
                 :status => srv.get(:instanceState, :name),
-                :key_name => srv[:keyName]
+                :key_name => srv[:keyName],
               ).valid_state
             end
           end.flatten
         end
-
       end
     end
   end

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

@@ -1,70 +1,68 @@
-require 'miasma'
+require "miasma"
 
 module Miasma
   module Models
     class LoadBalancer
       # AWS load balancer API
       class Aws < LoadBalancer
-
         include Contrib::AwsApiCore::ApiCommon
         include Contrib::AwsApiCore::RequestUtils
 
         # Service name of API
-        API_SERVICE = 'elasticloadbalancing'.freeze
+        API_SERVICE = "elasticloadbalancing".freeze
         # Supported version of the ELB API
-        API_VERSION = '2012-06-01'.freeze
+        API_VERSION = "2012-06-01".freeze
 
         # Save load balancer
         #
         # @param balancer [Models::LoadBalancer::Balancer]
         # @return [Models::LoadBalancer::Balancer]
         def balancer_save(balancer)
-          unless(balancer.persisted?)
+          unless balancer.persisted?
             params = Smash.new(
-              'LoadBalancerName' => balancer.name
+              "LoadBalancerName" => balancer.name,
             )
             availability_zones.each_with_index do |az, i|
               params["AvailabilityZones.member.#{i + 1}"] = az
             end
-            if(balancer.listeners)
+            if balancer.listeners
               balancer.listeners.each_with_index do |listener, i|
                 key = "Listeners.member.#{i + 1}"
                 params["#{key}.Protocol"] = listener.protocol
                 params["#{key}.InstanceProtocol"] = listener.instance_protocol
                 params["#{key}.LoadBalancerPort"] = listener.load_balancer_port
                 params["#{key}.InstancePort"] = listener.instance_port
-                if(listener.ssl_certificate_id)
+                if listener.ssl_certificate_id
                   params["#{key}.SSLCertificateId"] = listener.ssl_certificate_id
                 end
               end
             end
             result = request(
               :method => :post,
-              :path => '/',
+              :path => "/",
               :form => params.merge(
                 Smash.new(
-                  'Action' => 'CreateLoadBalancer'
+                  "Action" => "CreateLoadBalancer",
                 )
-              )
+              ),
             )
             balancer.public_addresses = [
               :address => result.get(:body,
-                'CreateLoadBalancerResponse', 'CreateLoadBalancerResult', 'DNSName'
-              )
+                                     "CreateLoadBalancerResponse", "CreateLoadBalancerResult", "DNSName"),
             ]
             balancer.load_data(:id => balancer.name).valid_state
-            if(balancer.health_check)
+            if balancer.health_check
               balancer_health_check(balancer)
             end
-            if(balancer.servers && !balancer.servers.empty?)
+            if balancer.servers && !balancer.servers.empty?
               balancer_set_instances(balancer)
             end
           else
-            if(balancer.dirty?)
-              if(balancer.dirty?(:health_check))
+            if balancer.dirty?
+              if balancer.dirty?(:health_check)
                 balancer_health_check(balancer)
               end
-              if(balancer.dirty?(:servers))
+              if balancer.dirty?(:servers)
                 balancer_set_instances(balancer)
               end
               balancer.reload
@@ -94,13 +92,13 @@ module Miasma
         # @param balancer [Models::LoadBalancer::Balancer]
         # @return [Models::LoadBalancer::Balancer]
         def balancer_reload(balancer)
-          if(balancer.persisted?)
+          if balancer.persisted?
             begin
               load_balancer_data(balancer)
             rescue Miasma::Error::ApiError::RequestError => e
-              if(e.response_error_msg.include?('LoadBalancerNotFound'))
+              if e.response_error_msg.include?("LoadBalancerNotFound")
                 balancer.state = :terminated
-                balancer.status = 'terminated'
+                balancer.status = "terminated"
                 balancer.valid_state
               else
                 raise
@@ -114,65 +112,63 @@ module Miasma
         #
         # @param balancer [Models::LoadBalancer::Balancer]
         # @return [Array<Models::LoadBalancer::Balancer>]
-        def load_balancer_data(balancer=nil)
-          params = Smash.new('Action' => 'DescribeLoadBalancers')
-          if(balancer)
-            params['LoadBalancerNames.member.1'] = balancer.id || balancer.name
+        def load_balancer_data(balancer = nil)
+          params = Smash.new("Action" => "DescribeLoadBalancers")
+          if balancer
+            params["LoadBalancerNames.member.1"] = balancer.id || balancer.name
           end
           result = all_result_pages(nil, :body,
-            'DescribeLoadBalancersResponse', 'DescribeLoadBalancersResult',
-            'LoadBalancerDescriptions', 'member'
-          ) do |options|
+                                    "DescribeLoadBalancersResponse", "DescribeLoadBalancersResult",
+                                    "LoadBalancerDescriptions", "member") do |options|
             request(
               :method => :post,
-              :path => '/',
-              :form => options.merge(params)
+              :path => "/",
+              :form => options.merge(params),
             )
           end
-          if(balancer)
+          if balancer
             health_result = all_result_pages(nil, :body,
-              'DescribeInstanceHealthResponse', 'DescribeInstanceHealthResult',
-              'InstanceStates', 'member'
-            ) do |options|
+                                             "DescribeInstanceHealthResponse", "DescribeInstanceHealthResult",
+                                             "InstanceStates", "member") do |options|
               request(
                 :method => :post,
-                :path => '/',
+                :path => "/",
                 :form => options.merge(
-                  'LoadBalancerName' => balancer.id || balancer.name,
-                  'Action' => 'DescribeInstanceHealth'
-                )
+                  "LoadBalancerName" => balancer.id || balancer.name,
+                  "Action" => "DescribeInstanceHealth",
+                ),
               )
             end
           end
           result.map do |blr|
             (balancer || Balancer.new(self)).load_data(
               Smash.new(
-                :id => blr['LoadBalancerName'],
-                :name => blr['LoadBalancerName'],
+                :id => blr["LoadBalancerName"],
+                :name => blr["LoadBalancerName"],
                 :state => :active,
-                :status => 'ACTIVE',
-                :created => blr['CreatedTime'],
-                :updated => blr['CreatedTime'],
+                :status => "ACTIVE",
+                :created => blr["CreatedTime"],
+                :updated => blr["CreatedTime"],
                 :public_addresses => [
                   Balancer::Address.new(
-                    :address => blr['DNSName'],
-                    :version => 4
-                  )
+                    :address => blr["DNSName"],
+                    :version => 4,
+                  ),
                 ],
-                :servers => [blr.get('Instances', 'member')].flatten(1).compact.map{|i|
-                  Balancer::Server.new(self.api_for(:compute), :id => i['InstanceId'])
-                }
+                :servers => [blr.get("Instances", "member")].flatten(1).compact.map { |i|
+                  Balancer::Server.new(self.api_for(:compute), :id => i["InstanceId"])
+                },
               ).merge(
                 health_result.nil? ? {} : Smash.new(
-                  :server_states => health_result.nil? ? nil : health_result.map{|i|
+                  :server_states => health_result.nil? ? nil : health_result.map { |i|
                     Balancer::ServerState.new(
                       self.api_for(:compute),
-                      :id => i['InstanceId'],
-                      :status => i['State'],
-                      :reason => i['ReasonCode'],
-                      :state => i['State'] == 'InService' ? :up : :down
+                      :id => i["InstanceId"],
+                      :status => i["State"],
+                      :reason => i["ReasonCode"],
+                      :state => i["State"] == "InService" ? :up : :down,
                     )
-                  }
+                  },
                 )
               )
             ).valid_state
@@ -184,17 +180,17 @@ module Miasma
         # @param balancer [Models::LoadBalancer::Balancer]
         # @return [TrueClass, FalseClass]
         def balancer_destroy(balancer)
-          if(balancer.persisted?)
+          if balancer.persisted?
             request(
               :method => :post,
-              :path => '/',
+              :path => "/",
               :form => Smash.new(
-                'Action' => 'DeleteLoadBalancer',
-                'LoadBalancerName' => balancer.name
-              )
+                "Action" => "DeleteLoadBalancer",
+                "LoadBalancerName" => balancer.name,
+              ),
             )
             balancer.state = :pending
-            balancer.status = 'DELETE_IN_PROGRESS'
+            balancer.status = "DELETE_IN_PROGRESS"
             balancer.valid_state
             true
           else
@@ -206,7 +202,7 @@ module Miasma
         #
         # @param options [Hash] filter
         # @return [Array<Models::LoadBalancer::Balancer>]
-        def balancer_all(options={})
+        def balancer_all(options = {})
           load_balancer_data
         end
 
@@ -217,21 +213,19 @@ module Miasma
           memoize(:availability_zones) do
             res = api_for(:compute).request(
               :method => :post,
-              :path => '/',
+              :path => "/",
               :form => Smash.new(
-                'Action' => 'DescribeAvailabilityZones'
-              )
+                "Action" => "DescribeAvailabilityZones",
+              ),
             ).fetch(:body,
-              'DescribeAvailabilityZonesResponse', 'availabilityZoneInfo', 'item', []
-            )
+                    "DescribeAvailabilityZonesResponse", "availabilityZoneInfo", "item", [])
             [res].flatten.compact.map do |item|
-              if(item['zoneState'] == 'available')
-                item['zoneName']
+              if item["zoneState"] == "available"
+                item["zoneName"]
               end
             end.compact
           end
         end
-
       end
     end
   end