geoengineer 0.1.3 → 0.1.4

data/lib/geoengineer/resources/aws_iam_group_membership.rb

@@ -35,7 +35,7 @@ class GeoEngineer::Resources::AwsIamGroupMembership < GeoEngineer::Resource
     return {} unless _group
     return {} unless _group.remote_resource
 
-    users = AwsClients.iam.get_group({ group_name: _group.name })['users']
+    users = AwsClients.iam(provider).get_group({ group_name: _group.name })['users']
     build_remote_resource_params(users)
   end
 

data/lib/geoengineer/resources/aws_iam_instance_profile.rb

@@ -4,7 +4,7 @@
 # {https://www.terraform.io/docs/providers/aws/r/iam_instance_profile.html Terraform Docs}
 ########################################################################
 class GeoEngineer::Resources::AwsIamInstanceProfile < GeoEngineer::Resource
-  validate -> { validate_required_attributes([:name, :roles]) }
+  validate -> { validate_required_attributes([:name, :role]) }
 
   before :validation, -> { policy_arn _policy.to_ref(:arn) if _policy }
 
@@ -15,8 +15,8 @@ class GeoEngineer::Resources::AwsIamInstanceProfile < GeoEngineer::Resource
     false
   end
 
-  def self._fetch_remote_resources
-    profiles = AwsClients.iam.list_instance_profiles['instance_profiles'].map(&:to_h)
+  def self._fetch_remote_resources(provider)
+    profiles = AwsClients.iam(provider).list_instance_profiles['instance_profiles'].map(&:to_h)
     profiles.map do |p|
       {
         name: p[:instance_profile_name],

data/lib/geoengineer/resources/aws_iam_policy.rb

@@ -44,12 +44,14 @@ class GeoEngineer::Resources::AwsIamPolicy < GeoEngineer::Resource
     URI.decode(response.policy_version.document)
   end
 
-  def self._all_remote_policies
-    AwsClients.iam.list_policies({ scope: "Local" }).each.map(&:policies).flatten.map(&:to_h)
+  def self._all_remote_policies(provider)
+    AwsClients.iam(provider)
+              .list_policies({ scope: "Local" })
+              .each.map(&:policies).flatten.map(&:to_h)
   end
 
-  def self._fetch_remote_resources
-    _all_remote_policies.map(&:to_h).map do |policy|
+  def self._fetch_remote_resources(provider)
+    _all_remote_policies(provider).map(&:to_h).map do |policy|
       {
         _terraform_id: policy[:arn],
         _geo_id: policy[:policy_name],

data/lib/geoengineer/resources/aws_iam_policy_attachment.rb

@@ -77,7 +77,7 @@ class GeoEngineer::Resources::AwsIamPolicyAttachment < GeoEngineer::Resource
     return {} unless _policy.remote_resource
 
     arn = _policy.remote_resource._terraform_id
-    entities = AwsClients.iam.list_entities_for_policy({ policy_arn: arn })
+    entities = AwsClients.iam(provider).list_entities_for_policy({ policy_arn: arn })
     build_remote_resource_params(arn, entities)
   end
 

data/lib/geoengineer/resources/aws_iam_role.rb

@@ -33,8 +33,8 @@ class GeoEngineer::Resources::AwsIamRole < GeoEngineer::Resource
     false
   end
 
-  def self._fetch_remote_resources
-    roles = AwsClients.iam.list_roles['roles'].map(&:to_h)
+  def self._fetch_remote_resources(provider)
+    roles = AwsClients.iam(provider).list_roles['roles'].map(&:to_h)
     roles.map do |r|
       r.merge({ name: r[:role_name],
                 _geo_id: r[:role_name],

data/lib/geoengineer/resources/aws_iam_role_policy.rb

@@ -32,32 +32,33 @@ class GeoEngineer::Resources::AwsIamRolePolicy < GeoEngineer::Resource
     _json_file(:policy, path, binding_obj)
   end
 
-  def self._fetch_remote_resources
+  def self._fetch_remote_resources(provider)
     AwsClients
-      .iam
+      .iam(provider)
       .list_roles
       .roles
       .map(&:to_h)
-      .map { |role| _get_role_policies(role) }
+      .map { |role| _get_role_policies(provider, role) }
       .flatten
       .compact
-      .map { |role_policy| _get_policy(role_policy) }
+      .map { |role_policy| _get_policy(provider, role_policy) }
   end
 
-  def self._get_role_policies(role)
+  def self._get_role_policies(provider, role)
     AwsClients
-      .iam
+      .iam(provider)
       .list_role_policies({ role_name: role[:role_name] })
       .map(&:policy_names)
       .flatten
       .map { |policy| { role_name: role[:role_name], policy_name: policy } }
   end
 
-  def self._get_policy(role_policy)
+  def self._get_policy(provider, role_policy)
     AwsClients
-      .iam
+      .iam(provider)
       .get_role_policy(role_policy)
       .to_h
-      .merge({ _terraform_id: "#{role_policy[:role_name]}:#{role_policy[:policy_name]}" })
+      .merge({ _terraform_id: "#{role_policy[:role_name]}:#{role_policy[:policy_name]}",
+               _geo_id: "#{role_policy[:role_name]}:#{role_policy[:policy_name]}" })
   end
 end

data/lib/geoengineer/resources/aws_iam_user.rb

@@ -26,12 +26,12 @@ class GeoEngineer::Resources::AwsIamUser < GeoEngineer::Resource
     false
   end
 
-  def self._all_remote_users
-    AwsClients.iam.list_users.each.map(&:users).flatten.map(&:to_h)
+  def self._all_remote_users(provider)
+    AwsClients.iam(provider).list_users.each.map(&:users).flatten.map(&:to_h)
   end
 
-  def self._fetch_remote_resources
-    _all_remote_users.map do |user|
+  def self._fetch_remote_resources(provider)
+    _all_remote_users(provider).map do |user|
       {
         _terraform_id: user[:user_name],
         _geo_id: user[:user_name],

data/lib/geoengineer/resources/aws_instance.rb

@@ -10,12 +10,12 @@ class GeoEngineer::Resources::AwsInstance < GeoEngineer::Resource
   after :initialize, -> { _terraform_id -> { NullObject.maybe(remote_resource)._terraform_id } }
   after :initialize, -> { _geo_id -> { NullObject.maybe(tags)[:Name] } }
 
-  def self._all_remote_instances
+  def self._all_remote_instances(provider)
     AwsClients.ec2.describe_instances.reservations.map(&:instances).flatten.map(&:to_h)
   end
 
-  def self._fetch_remote_resources
-    _all_remote_instances.map do |instance|
+  def self._fetch_remote_resources(provider)
+    _all_remote_instances(provider).map do |instance|
       instance.merge(
         {
           _terraform_id: instance[:instance_id],

data/lib/geoengineer/resources/aws_internet_gateway.rb

@@ -10,8 +10,9 @@ class GeoEngineer::Resources::AwsInternetGateway < GeoEngineer::Resource
   after :initialize, -> { _terraform_id -> { NullObject.maybe(remote_resource)._terraform_id } }
   after :initialize, -> { _geo_id -> { NullObject.maybe(tags)[:Name] } }
 
-  def self._fetch_remote_resources
-    AwsClients.ec2.describe_internet_gateways['internet_gateways'].map(&:to_h).map do |gateway|
+  def self._fetch_remote_resources(provider)
+    AwsClients.ec2(provider)
+              .describe_internet_gateways['internet_gateways'].map(&:to_h).map do |gateway|
       gateway.merge(
         {
           _terraform_id: gateway[:internet_gateway_id],

data/lib/geoengineer/resources/aws_kinesis_stream.rb

@@ -19,9 +19,9 @@ class GeoEngineer::Resources::AwsKinesisStream < GeoEngineer::Resource
     tfstate
   end
 
-  def self._all_streams
+  def self._all_streams(provider)
     streams = []
-    AwsClients.kinesis.list_streams[:stream_names].each do |stream_name|
+    AwsClients.kinesis(provider).list_streams[:stream_names].each do |stream_name|
       AwsClients.kinesis.describe_stream({ stream_name: stream_name }).map(&:to_h).map do |stream|
         streams << stream[:stream_description]
       end
@@ -29,8 +29,8 @@ class GeoEngineer::Resources::AwsKinesisStream < GeoEngineer::Resource
     streams
   end
 
-  def self._fetch_remote_resources
-    self._all_streams.map do |stream|
+  def self._fetch_remote_resources(provider)
+    self._all_streams(provider).map do |stream|
       stream.merge({
                      _terraform_id: stream[:stream_arn],
                      _geo_id: stream[:stream_name]

data/lib/geoengineer/resources/aws_kms_key.rb

@@ -8,14 +8,16 @@ class GeoEngineer::Resources::AwsKmsKey < GeoEngineer::Resource
 
   after :initialize, -> { _terraform_id -> { NullObject.maybe(remote_resource)._terraform_id } }
   after :initialize, -> { _geo_id -> { description } }
+  after :initialize, -> { _arn -> { NullObject.maybe(remote_resource)._arn } }
 
-  def self._fetch_remote_resources
-    keys = AwsClients.kms.list_keys[:keys].map do |i|
-      AwsClients.kms.describe_key({ key_id: i.key_id }).key_metadata.to_h
+  def self._fetch_remote_resources(provider)
+    keys = AwsClients.kms(provider).list_keys[:keys].map do |i|
+      AwsClients.kms(provider).describe_key({ key_id: i.key_id }).key_metadata.to_h
     end
 
     keys.map do |k|
       k[:_terraform_id] = k[:key_id]
+      k[:_arn] = k[:arn]
       k[:_geo_id] = k[:description]
       k
     end

data/lib/geoengineer/resources/aws_lambda_alias.rb

@@ -35,17 +35,17 @@ class GeoEngineer::Resources::AwsLambdaAlias < GeoEngineer::Resource
   end
 
   # TODO(Brad) - May need to implement solution for pagination...
-  def self._fetch_functions
+  def self._fetch_functions(provider)
     AwsClients
-      .lambda
+      .lambda(provider)
       .list_functions['functions']
       .map(&:to_h)
   end
 
   # TODO(Brad) - May need to implement solution for pagination...
-  def self._fetch_aliases(function)
+  def self._fetch_aliases(provider, function)
     options = { function_name: function[:function_name] }
-    AwsClients.lambda.list_aliases(options)[:aliases].map(&:to_h).map do |f_alias|
+    AwsClients.lambda(provider).list_aliases(options)[:aliases].map(&:to_h).map do |f_alias|
       geo_id_components = [f_alias[:name], function[:function_arn], f_alias[:function_version]]
       f_alias.merge(
         {
@@ -56,9 +56,9 @@ class GeoEngineer::Resources::AwsLambdaAlias < GeoEngineer::Resource
     end
   end
 
-  def self._fetch_remote_resources
-    _fetch_functions
-      .map { |function| _fetch_aliases(function) }
+  def self._fetch_remote_resources(provider)
+    _fetch_functions(provider)
+      .map { |function| _fetch_aliases(provider, function) }
       .flatten
       .compact
   end

data/lib/geoengineer/resources/aws_lambda_event_source_mapping.rb

@@ -29,9 +29,9 @@ class GeoEngineer::Resources::AwsLambdaEventSourceMapping < GeoEngineer::Resourc
     arn_components[arn_components.index("function") + 1] if arn_components.index("function")
   end
 
-  def self._fetch_remote_resources
+  def self._fetch_remote_resources(provider)
     AwsClients
-      .lambda
+      .lambda(provider)
       .list_event_source_mappings['event_source_mappings']
       .map(&:to_h)
       .map do |event|

data/lib/geoengineer/resources/aws_lambda_function.rb

@@ -36,8 +36,8 @@ class GeoEngineer::Resources::AwsLambdaFunction < GeoEngineer::Resource
     false
   end
 
-  def self._fetch_remote_resources
-    AwsClients.lambda.list_functions['functions'].map(&:to_h).map do |function|
+  def self._fetch_remote_resources(provider)
+    AwsClients.lambda(provider).list_functions['functions'].map(&:to_h).map do |function|
       function.merge({ _terraform_id: function[:function_name] })
     end
   end

data/lib/geoengineer/resources/aws_lambda_permission.rb

@@ -21,15 +21,16 @@ class GeoEngineer::Resources::AwsLambdaPermission < GeoEngineer::Resource
     tfstate
   end
 
-  def self._fetch_functions
+  def self._fetch_functions(provider)
     AwsClients
-      .lambda
+      .lambda(provider)
       .list_functions['functions']
       .map(&:to_h)
   end
 
-  def self._fetch_policy(function)
-    policy = AwsClients.lambda.get_policy({ function_name: function[:function_name] })&.policy
+  def self._fetch_policy(provider, function)
+    policy = AwsClients.lambda(provider)
+                       .get_policy({ function_name: function[:function_name] })&.policy
     parsed = _parse_policy(policy) if policy
     function.merge({ policy: parsed }) if parsed
   end
@@ -60,9 +61,9 @@ class GeoEngineer::Resources::AwsLambdaPermission < GeoEngineer::Resource
   # Right now, this only fetches policies for the $LATEST version
   # If you want to fetch the policy for a version other than $LATEST
   # set `find_remote_as_individual?` to `true` for that resource
-  def self._fetch_remote_resources
-    _fetch_functions
-      .map { |function| _fetch_policy(function) }
+  def self._fetch_remote_resources(provider)
+    _fetch_functions(provider)
+      .map { |function| _fetch_policy(provider, function) }
       .compact
       .map { |function| _create_permission(function) }
       .flatten
@@ -74,7 +75,7 @@ class GeoEngineer::Resources::AwsLambdaPermission < GeoEngineer::Resource
     params[:qualifier] = qualifier if qualifier
 
     begin
-      policy = _fetch_policy(params)[:policy]
+      policy = _fetch_policy(fetch_provider, params)[:policy]
       return {} if policy.nil?
     rescue Aws::Lambda::Errors::ResourceNotFoundException
       return {}

data/lib/geoengineer/resources/aws_lb_cookie_stickiness_policy.rb

@@ -0,0 +1,47 @@
+########################################################################
+# AwsLbCookieStickinessPolicy is the +aws_lb_cookie_stickiness_policy+ terrform resource,
+#
+# {https://www.terraform.io/docs/providers/aws/r/lb_cookie_stickiness_policy.html Terraform Docs}
+########################################################################
+class GeoEngineer::Resources::AwsLbCookieStickinessPolicy < GeoEngineer::Resource
+  validate -> { validate_required_attributes([:name, :load_balancer, :lb_port]) }
+
+  after :initialize, -> { _terraform_id -> { "#{load_balancer}:#{lb_port}:#{name}" } }
+
+  def support_tags?
+    false
+  end
+
+  def short_type
+    "elbcookiepolicy"
+  end
+
+  def self._generate_policies(elb, policies)
+    policies&.map do |policy|
+      listener = elb[:listener_descriptions]
+                 .find { |desc| desc[:policy_names].include?(policy[:policy_name]) }
+
+      next unless listener
+
+      id = "#{elb[:load_balancer_name]}:#{listener[:load_balancer_port]}:#{policy[:policy_name]}"
+      {
+        load_balancer: elb[:load_balancer_name],
+        lb_port: listener[:listener][:load_balancer_port],
+        name: policy[:policy_name],
+        cookie_expiration_period: policy[:cookie_expiration_period],
+        _terraform_id: id
+      }
+    end
+  end
+
+  def self._fetch_remote_resources(provider)
+    AwsClients
+      .elb(provider)
+      .describe_load_balancers['load_balancer_descriptions']
+      .map(&:to_h)
+      .select { |elb| !elb.dig(:policies, :lb_cookie_stickiness_policies)&.empty? }
+      .map { |elb| _generate_policies(elb, elb.dig(:policies, :lb_cookie_stickiness_policies)) }
+      .flatten
+      .compact
+  end
+end

data/lib/geoengineer/resources/aws_load_balancer_backend_server_policy.rb

@@ -25,9 +25,9 @@ class GeoEngineer::Resources::AwsLoadBalancerBackendServerPolicy < GeoEngineer::
     false
   end
 
-  def self._fetch_remote_resources
+  def self._fetch_remote_resources(provider)
     AwsClients
-      .elb
+      .elb(provider)
       .describe_load_balancers
       .load_balancer_descriptions
       .map { |load_balancer| _extract_backend_servers(load_balancer.to_h) }

data/lib/geoengineer/resources/aws_load_balancer_policy.rb

@@ -14,20 +14,20 @@ class GeoEngineer::Resources::AwsLoadBalancerPolicy < GeoEngineer::Resource
     false
   end
 
-  def self._fetch_remote_resources
+  def self._fetch_remote_resources(provider)
     AwsClients
-      .elb
+      .elb(provider)
       .describe_load_balancers
       .load_balancer_descriptions
       .map(&:to_h)
-      .map { |load_balancer| _policies_for_load_balancer(load_balancer) }
+      .map { |load_balancer| _policies_for_load_balancer(provider, load_balancer) }
       .flatten
       .compact
   end
 
-  def self._policies_for_load_balancer(load_balancer)
+  def self._policies_for_load_balancer(provider, load_balancer)
     AwsClients
-      .elb
+      .elb(provider)
       .describe_load_balancer_policies({ load_balancer_name: load_balancer[:load_balancer_name] })
       .policy_descriptions
       .map(&:to_h)

data/lib/geoengineer/resources/aws_main_route_table_association.rb

@@ -22,9 +22,9 @@ class GeoEngineer::Resources::AwsMainRouteTableAssociation < GeoEngineer::Resour
     false
   end
 
-  def self._fetch_remote_resources
+  def self._fetch_remote_resources(provider)
     AwsClients
-      .ec2
+      .ec2(provider)
       .describe_route_tables['route_tables']
       .map(&:to_h)
       .select { |route_table| route_table[:associations] }

data/lib/geoengineer/resources/aws_nat_gateway.rb

@@ -13,8 +13,8 @@ class GeoEngineer::Resources::AwsNatGateway < GeoEngineer::Resource
     false
   end
 
-  def self._fetch_remote_resources
-    AwsClients.ec2.describe_nat_gateways['nat_gateways'].map(&:to_h).map do |gateway|
+  def self._fetch_remote_resources(provider)
+    AwsClients.ec2(provider).describe_nat_gateways['nat_gateways'].map(&:to_h).map do |gateway|
       # AWS SDK has `nat_gateway_addresses` as an array, but you should only be able to
       # have exactly 1 elastic IP association. This logic should cover the bases...
       allocation = gateway[:nat_gateway_addresses].find { |addr| addr.key?(:allocation_id) }

data/lib/geoengineer/resources/aws_network_acl.rb

@@ -25,8 +25,8 @@ class GeoEngineer::Resources::AwsNetworkAcl < GeoEngineer::Resource
   after :initialize, -> { _terraform_id -> { NullObject.maybe(remote_resource)._terraform_id } }
   after :initialize, -> { _geo_id -> { NullObject.maybe(tags)[:Name] } }
 
-  def self._fetch_remote_resources
-    AwsClients.ec2.describe_network_acls['network_acls'].map(&:to_h).map do |network_acl|
+  def self._fetch_remote_resources(provider)
+    AwsClients.ec2(provider).describe_network_acls['network_acls'].map(&:to_h).map do |network_acl|
       network_acl.merge(
         {
           _terraform_id: network_acl[:network_acl_id],

data/lib/geoengineer/resources/aws_network_acl_rule.rb

@@ -36,9 +36,9 @@ class GeoEngineer::Resources::AwsNetworkAclRule < GeoEngineer::Resource
     false
   end
 
-  def self._fetch_remote_resources
+  def self._fetch_remote_resources(provider)
     AwsClients
-      .ec2
+      .ec2(provider)
       .describe_network_acls['network_acls']
       .map(&:to_h)
       .select { |network_acl| !network_acl[:entries].empty? }

data/lib/geoengineer/resources/aws_proxy_protocol_policy.rb

@@ -33,7 +33,7 @@ class GeoEngineer::Resources::AwsProxyProtocolPolicy < GeoEngineer::Resource
   end
 
   # This is a weird resource and it is not listed
-  def self._fetch_remote_resources
+  def self._fetch_remote_resources(provider)
     []
   end
 end