geoengineer 0.1.3 → 0.1.4

data/lib/geoengineer/resources/aws_redshift_cluster.rb

@@ -18,9 +18,9 @@ class GeoEngineer::Resources::AwsRedshiftCluster < GeoEngineer::Resource
 
   after :initialize, -> { _terraform_id -> { cluster_identifier } }
 
-  def self._fetch_remote_resources
+  def self._fetch_remote_resources(provider)
     AwsClients
-      .redshift
+      .redshift(provider)
       .describe_clusters
       .clusters
       .map(&:to_h)

data/lib/geoengineer/resources/aws_route.rb

@@ -22,9 +22,9 @@ class GeoEngineer::Resources::AwsRoute < GeoEngineer::Resource
     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)
       .map { |route_table| _extract_routes(route_table) }

data/lib/geoengineer/resources/aws_route53_record.rb

@@ -19,16 +19,16 @@ class GeoEngineer::Resources::AwsRoute53Record < GeoEngineer::Resource
     false
   end
 
-  def self._fetch_remote_resources
-    _fetch_zones.map { |zone| _fetch_records_for_zone(zone) }.flatten.compact
+  def self._fetch_remote_resources(provider)
+    _fetch_zones(provider).map { |zone| _fetch_records_for_zone(provider, zone) }.flatten.compact
   end
 
-  def self._fetch_zones
-    AwsClients.route53.list_hosted_zones.hosted_zones.map(&:to_h)
+  def self._fetch_zones(provider)
+    AwsClients.route53(provider).list_hosted_zones.hosted_zones.map(&:to_h)
   end
 
-  def self._fetch_records_for_zone(zone)
-    records = AwsClients.route53.list_resource_record_sets({ hosted_zone_id: zone[:id] })
+  def self._fetch_records_for_zone(provider, zone)
+    records = AwsClients.route53(provider).list_resource_record_sets({ hosted_zone_id: zone[:id] })
     records.resource_record_sets.map(&:to_h).map do |record|
       record.merge({ _terraform_id: "#{record[:zone_id]}_#{record[:name]}_#{record[:type]}" })
     end

data/lib/geoengineer/resources/aws_route53_zone.rb

@@ -9,8 +9,8 @@ class GeoEngineer::Resources::AwsRoute53Zone < GeoEngineer::Resource
   after :initialize, -> { _terraform_id -> { NullObject.maybe(remote_resource)._terraform_id } }
   after :initialize, -> { _geo_id -> { self.name } }
 
-  def self._fetch_remote_resources
-    hosted_zones = AwsClients.route53.list_hosted_zones.hosted_zones.map(&:to_h)
+  def self._fetch_remote_resources(provider)
+    hosted_zones = AwsClients.route53(provider).list_hosted_zones.hosted_zones.map(&:to_h)
 
     hosted_zones.map do |zone|
       zone[:_terraform_id] = zone[:id]

data/lib/geoengineer/resources/aws_route_table.rb

@@ -13,8 +13,8 @@ class GeoEngineer::Resources::AwsRouteTable < 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_route_tables['route_tables'].map(&:to_h).map do |route_table|
+  def self._fetch_remote_resources(provider)
+    AwsClients.ec2(provider).describe_route_tables['route_tables'].map(&:to_h).map do |route_table|
       route_table.merge(
         {
           _terraform_id: route_table[:route_table_id],

data/lib/geoengineer/resources/aws_route_table_association.rb

@@ -22,9 +22,9 @@ class GeoEngineer::Resources::AwsRouteTableAssociation < GeoEngineer::Resource
     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)
       .map { |route_table| route_table[:associations] }

data/lib/geoengineer/resources/aws_s3_bucket.rb

@@ -43,8 +43,8 @@ class GeoEngineer::Resources::AwsS3Bucket < GeoEngineer::Resource
     "s3"
   end
 
-  def self._fetch_remote_resources
-    AwsClients.s3.list_buckets[:buckets].map(&:to_h).map do |s3b|
+  def self._fetch_remote_resources(provider)
+    AwsClients.s3(provider).list_buckets[:buckets].map(&:to_h).map do |s3b|
       s3b[:_terraform_id] = s3b[:name]
       s3b[:_geo_id] = s3b[:name]
       s3b[:bucket]  = s3b[:name]

data/lib/geoengineer/resources/aws_s3_bucket_notification.rb

@@ -0,0 +1,38 @@
+########################################################################
+# AwsS3BucketNotification is the +aws_s3_bucket_notification+ terrform resource,
+#
+# {https://www.terraform.io/docs/providers/aws/r/s3_bucket_notification.html Terraform Docs}
+########################################################################
+class GeoEngineer::Resources::AwsS3BucketNotification < GeoEngineer::Resource
+  validate -> { validate_required_attributes([:bucket]) }
+
+  after :initialize, -> { _terraform_id -> { _bucket.bucket } }
+
+  # Setting _bucket
+  after :initialize, -> { self.bucket = _bucket.bucket }
+  after :initialize, -> { depends_on [_bucket.terraform_name] }
+
+  validate -> {
+    validate_subresource_required_attributes(:lambda_function, [:lambda_function_arn, :events])
+  }
+
+  validate -> {
+    validate_subresource_required_attributes(:queue, [:queue_arn, :events])
+  }
+
+  validate -> {
+    validate_subresource_required_attributes(:topic, [:topic_arn, :events])
+  }
+
+  def support_tags?
+    false
+  end
+
+  def to_terraform_state
+    tfstate = super
+    tfstate[:primary][:attributes] = {
+      'bucket' => bucket
+    }
+    tfstate
+  end
+end

data/lib/geoengineer/resources/aws_security_group.rb

@@ -42,8 +42,8 @@ class GeoEngineer::Resources::AwsSecurityGroup < GeoEngineer::Resource
     "sg"
   end
 
-  def self._fetch_remote_resources
-    AwsClients.ec2.describe_security_groups['security_groups'].map(&:to_h).map do |sg|
+  def self._fetch_remote_resources(provider)
+    AwsClients.ec2(provider).describe_security_groups['security_groups'].map(&:to_h).map do |sg|
       sg.merge(
         {
           name: sg[:group_name],

data/lib/geoengineer/resources/aws_ses_receipt_rule.rb

@@ -27,8 +27,8 @@ class GeoEngineer::Resources::AwsSesReceiptRule < GeoEngineer::Resource
     false
   end
 
-  def self._fetch_remote_resources
-    AwsClients.ses.describe_active_receipt_rule_set.rules.map(&:to_h).map do |rule|
+  def self._fetch_remote_resources(provider)
+    AwsClients.ses(provider).describe_active_receipt_rule_set.rules.map(&:to_h).map do |rule|
       {
         _terraform_id: rule[:name],
         _geo_id: rule[:name]

data/lib/geoengineer/resources/aws_ses_receipt_rule_set.rb

@@ -17,8 +17,8 @@ class GeoEngineer::Resources::AwsSesReceiptRuleSet < GeoEngineer::Resource
     false
   end
 
-  def self._fetch_remote_resources
-    AwsClients.ses.list_receipt_rule_sets.rule_sets.map(&:to_h).map do |rule_set|
+  def self._fetch_remote_resources(provider)
+    AwsClients.ses(provider).list_receipt_rule_sets.rule_sets.map(&:to_h).map do |rule_set|
       {
         _terraform_id: rule_set[:name],
         _geo_id: rule_set[:name]

data/lib/geoengineer/resources/aws_sns_topic.rb

@@ -16,8 +16,8 @@ class GeoEngineer::Resources::AwsSnsTopic < GeoEngineer::Resource
     false
   end
 
-  def self._fetch_remote_resources
-    AwsClients.sns.list_topics.topics.map(&:to_h).map do |topic|
+  def self._fetch_remote_resources(provider)
+    AwsClients.sns(provider).list_topics.topics.map(&:to_h).map do |topic|
       {
         _terraform_id: topic[:topic_arn],
         _geo_id: topic[:topic_arn],

data/lib/geoengineer/resources/aws_sns_topic_subscription.rb

@@ -30,8 +30,8 @@ class GeoEngineer::Resources::AwsSnsTopicSubscription < GeoEngineer::Resource
     false
   end
 
-  def self._fetch_remote_resources
-    _get_all_subscriptions.map do |subscription|
+  def self._fetch_remote_resources(provider)
+    _get_all_subscriptions(provider).map do |subscription|
       {
         _terraform_id: subscription[:subscription_arn],
         _geo_id: "#{subscription[:topic_arn]}::" \
@@ -41,11 +41,11 @@ class GeoEngineer::Resources::AwsSnsTopicSubscription < GeoEngineer::Resource
     end
   end
 
-  def self._get_all_subscriptions
-    subs_page = AwsClients.sns.list_subscriptions
+  def self._get_all_subscriptions(provider)
+    subs_page = AwsClients.sns(provider).list_subscriptions
     subs = subs_page.subscriptions.map(&:to_h)
     while subs_page.next_token
-      subs_page = AwsClients.sns.list_subscriptions({ next_token: subs_page.next_token })
+      subs_page = AwsClients.sns(provider).list_subscriptions({ next_token: subs_page.next_token })
       subs.concat subs_page.subscriptions.map(&:to_h)
     end
     subs

data/lib/geoengineer/resources/aws_sqs_queue.rb

@@ -25,8 +25,8 @@ class GeoEngineer::Resources::AwsSqsQueue < GeoEngineer::Resource
     false
   end
 
-  def self._fetch_remote_resources
-    AwsClients.sqs.list_queues['queue_urls'].map do |queue|
+  def self._fetch_remote_resources(provider)
+    AwsClients.sqs(provider).list_queues['queue_urls'].map do |queue|
       {
         _terraform_id: queue,
         _geo_id: queue,

data/lib/geoengineer/resources/aws_subnet.rb

@@ -11,8 +11,8 @@ class GeoEngineer::Resources::AwsSubnet < 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_subnets['subnets'].map(&:to_h).map do |subnet|
+  def self._fetch_remote_resources(provider)
+    AwsClients.ec2(provider).describe_subnets['subnets'].map(&:to_h).map do |subnet|
       subnet.merge(
         {
           _terraform_id: subnet[:subnet_id],

data/lib/geoengineer/resources/aws_vpc.rb

@@ -11,8 +11,8 @@ class GeoEngineer::Resources::AwsVpc < 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_vpcs['vpcs'].map(&:to_h).map do |vpc|
+  def self._fetch_remote_resources(provider)
+    AwsClients.ec2(provider).describe_vpcs['vpcs'].map(&:to_h).map do |vpc|
       vpc.merge(
         {
           _terraform_id: vpc[:vpc_id],

data/lib/geoengineer/resources/aws_vpc_dhcp_options.rb

@@ -16,8 +16,8 @@ class GeoEngineer::Resources::AwsVpcDhcpOptions < 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_dhcp_options['dhcp_options'].map(&:to_h).map do |options|
+  def self._fetch_remote_resources(provider)
+    AwsClients.ec2(provider).describe_dhcp_options['dhcp_options'].map(&:to_h).map do |options|
       options.merge(
         {
           _terraform_id: options[:dhcp_options_id],

data/lib/geoengineer/resources/aws_vpc_dhcp_options_association.rb

@@ -23,9 +23,9 @@ class GeoEngineer::Resources::AwsVpcDhcpOptionsAssociation < GeoEngineer::Resour
     false
   end
 
-  def self._fetch_remote_resources
+  def self._fetch_remote_resources(provider)
     AwsClients
-      .ec2
+      .ec2(provider)
       .describe_vpcs['vpcs']
       .map(&:to_h)
       .select { |vpc| vpc[:dhcp_options_id] }

data/lib/geoengineer/resources/aws_vpc_endpoint.rb

@@ -13,8 +13,8 @@ class GeoEngineer::Resources::AwsVpcEndpoint < GeoEngineer::Resource
     false
   end
 
-  def self._fetch_remote_resources
-    AwsClients.ec2.describe_vpc_endpoints['vpc_endpoints'].map(&:to_h).map do |endpoint|
+  def self._fetch_remote_resources(provider)
+    AwsClients.ec2(provider).describe_vpc_endpoints['vpc_endpoints'].map(&:to_h).map do |endpoint|
       endpoint.merge(
         {
           _terraform_id: endpoint[:vpc_endpoint_id],

data/lib/geoengineer/resources/aws_vpc_peering_connection.rb

@@ -10,9 +10,9 @@ class GeoEngineer::Resources::AwsVpcPeeringConnection < 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
+  def self._fetch_remote_resources(provider)
     AwsClients
-      .ec2
+      .ec2(provider)
       .describe_vpc_peering_connections['vpc_peering_connections']
       .map(&:to_h)
       .map { |connection| _merge_ids(connection) }

data/lib/geoengineer/resources/aws_vpn_connection.rb

@@ -10,8 +10,9 @@ class GeoEngineer::Resources::AwsVpnConnection < 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_vpn_connections['vpn_connections'].map(&:to_h).map do |connection|
+  def self._fetch_remote_resources(provider)
+    AwsClients.ec2(provider)
+              .describe_vpn_connections['vpn_connections'].map(&:to_h).map do |connection|
       connection.merge(
         {
           _terraform_id: connection[:vpn_connection_id],

data/lib/geoengineer/resources/aws_vpn_connection_route.rb

@@ -12,9 +12,9 @@ class GeoEngineer::Resources::AwsVpnConnectionRoute < GeoEngineer::Resource
     false
   end
 
-  def self._fetch_remote_resources
+  def self._fetch_remote_resources(provider)
     AwsClients
-      .ec2
+      .ec2(provider)
       .describe_vpn_connections['vpn_connections']
       .map(&:to_h)
       .select { |connection| !connection[:routes].empty? }

data/lib/geoengineer/resources/aws_vpn_gateway.rb

@@ -9,8 +9,8 @@ class GeoEngineer::Resources::AwsVpnGateway < 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_vpn_gateways['vpn_gateways'].map(&:to_h).map do |gateway|
+  def self._fetch_remote_resources(provider)
+    AwsClients.ec2(provider).describe_vpn_gateways['vpn_gateways'].map(&:to_h).map do |gateway|
       gateway.merge(
         {
           _terraform_id: gateway[:vpn_gateway_id],

data/lib/geoengineer/resources/aws_vpn_gateway_attachment.rb

@@ -23,9 +23,9 @@ class GeoEngineer::Resources::AwsVpnGatewayAttachment < GeoEngineer::Resource
     false
   end
 
-  def self._fetch_remote_resources
+  def self._fetch_remote_resources(provider)
     AwsClients
-      .ec2
+      .ec2(provider)
       .describe_vpn_gateways['vpn_gateways']
       .map(&:to_h)
       .select { |gateway| !gateway[:vpc_attachments].empty? }

data/lib/geoengineer/template.rb

@@ -5,11 +5,13 @@ class GeoEngineer::Template
   include HasAttributes
   include HasResources
 
-  attr_accessor :name, :parameters
+  attr_accessor :name, :parameters, :parent
 
   def initialize(name, parent, parameters = {})
     @name = name
     @parameters = parameters
+    @parent = parent
+
     case parent
     when GeoEngineer::Project then add_project_attributes(parent)
     when GeoEngineer::Environment then add_env_attributes(parent)

data/lib/geoengineer/templates/json_rest_api.rb

@@ -0,0 +1,197 @@
+# This template will create basic JSON REST API gateway resources
+# It is recommended due to difficulties managing API_Gateway resources
+# to use such a template
+# This resource will also delete any resource on the API that is not defined
+# within this template as a means of managing the resources
+# Beta Template
+class GeoEngineer::Templates::JsonRestApi < GeoEngineer::Template
+  attr_reader :rest_api
+
+  def create_rest_resources(params)
+    rest_api = @rest_api
+    api_resources = {}
+    params[:methods].each do |method_name, method_params|
+      path = method_params[:path]
+      next if api_resources[path]
+
+      api_resource = parent.resource("aws_api_gateway_resource", "#{@name}_resource_#{path}") {
+        _rest_api rest_api
+        path_part path
+      }
+
+      api_resources[path] = api_resource
+    end
+    api_resources
+  end
+
+  def create_rest_methods(api_resources, params)
+    rest_api = @rest_api
+    api_methods = {}
+    params[:methods].each do |method_name, method_params|
+      path = method_params[:path]
+      api_resource = api_resources[path]
+      http_method = method_params[:method]
+
+      method_name = "#{@name}_resource_#{path}_method_#{http_method}"
+
+      # METHOD
+      api_methods[method_name] = parent.resource("aws_api_gateway_method", method_name) {
+        _rest_api rest_api
+        _resource api_resource
+        http_method http_method
+        authorization method_params[:auth]
+        api_key_required !!method_params[:api_key]
+      }
+    end
+
+    api_methods
+  end
+
+  def create_rest_integrations(api_resources, params)
+    rest_api = @rest_api
+    api_integrations = {}
+    params[:methods].each do |method_name, method_params|
+      path = method_params[:path]
+      api_resource = api_resources[path]
+      lambda_function = params[:lambda][method_params[:handler]]
+      http_method = method_params[:method]
+
+      method_name = "#{@name}_resource_#{path}_method_#{http_method}"
+
+      api_gateway_arn = "arn:aws:apigateway:#{env.region}"
+      invocation_arn = "functions/#{lambda_function.to_ref('arn')}/invocations"
+      # INTEGRATION
+      api_integrations[method_name] = parent.resource(
+        "aws_api_gateway_integration",
+        "#{method_name}_integration"
+      ) {
+        _rest_api rest_api
+        _resource api_resource
+        http_method http_method
+        self["type"] = "AWS"
+        integration_http_method "POST" # ALWAYS POST TO LAMBDAS
+        uri "#{api_gateway_arn}:lambda:path/2015-03-31/#{invocation_arn}"
+      }
+    end
+    api_integrations
+  end
+
+  def http_method_response_mappings(api_resources, params)
+    https_methods = params[:methods].values.map { |m| m[:method] }.uniq
+
+    response_mappings = {}
+    https_methods.each do |m|
+      response_mappings["#{m}_success"] = {
+        status: "200",
+        method: m
+      }
+
+      response_mappings["#{m}_notfound"] = {
+        status: "404",
+        method: m,
+        selection_pattern: ".*NotFound.*"
+      }
+    end
+
+    api_resources.values.each do |api_resource|
+      response_mappings.each do |name, mapping|
+        yield api_resource, name, mapping
+      end
+    end
+  end
+
+  def create_api_methods_responses(api_resources, api_methods, params)
+    rest_api = @rest_api
+    api_method_responses = []
+
+    http_method_response_mappings(api_resources, params) do |api_resource, name, mapping|
+      http_method = mapping[:method]
+      status = mapping[:status]
+
+      api_method_response = parent.resource(
+        "aws_api_gateway_method_response",
+        "mr_#{api_resource.id}_#{name}"
+      ) {
+        _rest_api rest_api
+        _resource api_resource
+        http_method http_method
+        status_code status
+        depends_on [api_methods.values].flatten.map(&:terraform_name)
+        depends_on api_method_responses.map(&:terraform_name) # force order
+      }
+
+      api_method_responses << api_method_response
+    end
+
+    api_method_responses
+  end
+
+  def create_api_integrations_responses(api_resources, api_integrations, params)
+    rest_api = @rest_api
+    api_integration_responses = []
+
+    http_method_response_mappings(api_resources, params) do |api_resource, name, mapping|
+      http_method = mapping[:method]
+      status = mapping[:status]
+      selection_pattern = mapping[:selection_pattern]
+
+      api_integration_response = parent.resource(
+        "aws_api_gateway_integration_response",
+        "ir_#{api_resource.id}_#{name}"
+      ) {
+        _rest_api rest_api
+        _resource api_resource
+        http_method http_method
+        status_code status
+        selection_pattern selection_pattern if selection_pattern
+        depends_on [api_integrations.values].flatten.map(&:terraform_name)
+        depends_on api_integration_responses.map(&:terraform_name) # force order
+      }
+
+      api_integration_responses << api_integration_response
+    end
+
+    api_integration_responses
+  end
+
+  attr_reader :rest_api
+
+  def initialize(name, parent, params)
+    super(name, parent, params)
+
+    # parameters
+    # lambda:
+    #   <ref>: lambda_resource
+    # methods:
+    #   <name>:
+    #     path:
+    #     method: <POST,PUT,GET...>
+    #     auth: <NONE,CUSTOM,AWS_IAM>
+    #     api_key: <false>
+    #     handler: <lambda ref>
+    #
+
+    ### Rest API
+    @rest_api = parent.resource("aws_api_gateway_rest_api", "#{@name}_rest_api") {
+      name name
+      # Depends on the lambda functions existing
+      depends_on params[:lambda].values.map(&:terraform_name)
+    }
+
+    # Resources and Responses
+    api_resources = create_rest_resources(params)
+
+    api_methods = create_rest_methods(api_resources, params)
+    api_integrations = create_rest_integrations(api_resources, params)
+
+    # RESPONSES
+    create_api_methods_responses(api_resources, api_methods, params)
+    create_api_integrations_responses(api_resources, api_integrations, params)
+
+    # TODO: delete uncodified resources
+  end
+
+  def template_resources
+    @rest_api
+  end
+end