jets_bb_fork 0.0.4

data/lib/jets/resource/api_gateway/rest_api/change_detection.rb

@@ -0,0 +1,42 @@
+class Jets::Resource::ApiGateway::RestApi
+  class ChangeDetection
+    extend Memoist
+    include Jets::AwsServices
+
+    def changed?
+      return false unless parent_stack_exists?
+      current_binary_media_types != new_binary_media_types ||
+      Routes.changed?
+    end
+
+    def new_binary_media_types
+      rest_api = Jets::Resource::ApiGateway::RestApi.new
+      rest_api.binary_media_types
+    end
+    memoize :new_binary_media_types
+
+    # Duplicated in rest_api/change_detection.rb, base_path/role.rb, rest_api/routes.rb
+    def current_binary_media_types
+      return nil unless parent_stack_exists?
+
+      stack = cfn.describe_stacks(stack_name: parent_stack_name).stacks.first
+
+      api_gateway_stack_arn = lookup(stack[:outputs], "ApiGateway")
+
+      stack = cfn.describe_stacks(stack_name: api_gateway_stack_arn).stacks.first
+      rest_api_id = lookup(stack[:outputs], "RestApi")
+
+      resp = apigateway.get_rest_api(rest_api_id: rest_api_id)
+      resp.binary_media_types
+    end
+    memoize :current_binary_media_types
+
+    def parent_stack_exists?
+      stack_exists?(parent_stack_name)
+    end
+
+    def parent_stack_name
+      Jets::Naming.parent_stack_name
+    end
+  end
+end

data/lib/jets/resource/api_gateway/rest_api/logical_id.rb

@@ -0,0 +1,63 @@
+class Jets::Resource::ApiGateway::RestApi
+  class LogicalId
+    extend Memoist
+    include Jets::AwsServices
+
+    def get
+      return default unless stack_exists?(parent_stack_name) && api_gateway_exists?
+
+      if changed?
+        new_id
+      else
+        current
+      end
+    end
+
+    def changed?
+      change_detection = ChangeDetection.new
+      change_detection.changed?
+    end
+
+    # Takes current logical id and increments the number that is appended to it.
+    #
+    # Examples:
+    #
+    #   RestApi => RestApi1
+    #   RestApi1 => RestApi2
+    #   RestApi2 => RestApi3
+    #   RestApi7 => RestApi8
+    def new_id
+      regexp = /(\d+)/
+      md = current.match(regexp)
+      if md
+        current.gsub(regexp,'') + (md[1].to_i + 1).to_s
+      else
+        current + "1"
+      end
+    end
+
+    def current
+      resources = cfn.describe_stack_resources(stack_name: api_gateway_stack_arn).stack_resources
+      rest_api = resources.find { |r| r.resource_type == 'AWS::ApiGateway::RestApi' }
+      rest_api.logical_resource_id
+    end
+    memoize :current
+
+    def api_gateway_stack_arn
+      stack = cfn.describe_stacks(stack_name: parent_stack_name).stacks.first
+      lookup(stack[:outputs], "ApiGateway") # api_gateway_stack_arn
+    end
+
+    def api_gateway_exists?
+      !!api_gateway_stack_arn
+    end
+
+    def parent_stack_name
+      Jets::Naming.parent_stack_name
+    end
+
+    def default
+      "RestApi"
+    end
+  end
+end

data/lib/jets/resource/api_gateway/rest_api/routes.rb

@@ -0,0 +1,7 @@
+class Jets::Resource::ApiGateway::RestApi
+  class Routes
+    def self.changed?
+      Change.new.changed?
+    end
+  end
+end

data/lib/jets/resource/api_gateway/rest_api/routes/change.rb

@@ -0,0 +1,8 @@
+# Detects route changes
+class Jets::Resource::ApiGateway::RestApi::Routes
+  class Change
+    def changed?
+      To.changed? || Variable.changed? || ENV['JETS_REPLACE_API']
+    end
+  end
+end

data/lib/jets/resource/api_gateway/rest_api/routes/change/base.rb

@@ -0,0 +1,130 @@
+class Jets::Resource::ApiGateway::RestApi::Routes::Change
+  class Base
+    extend Memoist
+    include Jets::AwsServices
+
+    # Build up deployed routes from the existing CloudFormation resources.
+    def deployed_routes
+      routes = []
+
+      resources, position = [], true
+      while position
+        position = nil if position == true # start of loop
+        resp = apigateway.get_resources(
+          rest_api_id: rest_api_id,
+          position: position,
+        )
+        resources += resp.items
+        position = resp.position
+      end
+
+      resources.each do |resource|
+        resource_methods = resource.resource_methods
+        next if resource_methods.nil?
+
+        resource_methods.each do |http_verb, resource_method|
+          # puts "#{http_verb} #{resource.path} | resource.id #{resource.id}"
+          # puts to(resource.id, http_verb)
+
+          # Test changing config.cors and CloudFormation does an in-place update
+          # on the resource. So no need to do bluegreen deployments for OPTIONS.
+          next if http_verb == "OPTIONS"
+
+          path = recreate_path(resource.path)
+          method = http_verb.downcase.to_sym
+          to = to(resource.id, http_verb)
+          route = Jets::Route.new(path: path, method: method, to: to)
+          routes << route
+        end
+      end
+      routes
+    end
+    memoize :deployed_routes
+
+    def recreate_path(path)
+      path = path.gsub(%r{^/},'')
+      path = path.gsub(/{([^}]*)\+}/, '*\1')
+      path.gsub(/{([^}]*)}/, ':\1')
+    end
+
+    def to(resource_id, http_method)
+      uri = method_uri(resource_id, http_method)
+      recreate_to(uri) unless uri.nil?
+    end
+
+    def method_uri(resource_id, http_method)
+      resp = apigateway.get_method(
+        rest_api_id: rest_api_id,
+        resource_id: resource_id,
+        http_method: http_method
+      )
+      resp.method_integration.uri
+    end
+
+    # Parses method uri and recreates a Route to argument.
+    # So:
+    #   "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:112233445566:function:demo-test-posts_controller-new/invocations"
+    # Returns:
+    #   posts#new
+    def recreate_to(method_uri)
+      md = method_uri.match(/function:(.*)\//)
+      function_arn = md[1] # IE: demo-dev-posts_controller-new
+      controller, action = get_controller_action(function_arn)
+      "#{controller}##{action}" # IE: posts#new
+    end
+
+    def get_controller_action(function_arn)
+      if function_arn.include?('_controller-')
+        controller_action_from_string(function_arn)
+      else
+        controller_action_from_api(function_arn)
+      end
+    end
+
+    # TODO: If this hits the Lambda Rate limit, then list_functions also contains the Lambda
+    # function description. So we can paginate through list_functions results and store
+    # description from there if needed.
+    # Dont think this will be needed though because controller_action_from_string gets called
+    # most of the time. Also, user might be able to request their Lambda limit to be increased.
+    def controller_action_from_api(function_arn)
+      desc = lambda_function_description(function_arn)
+      controller, action = desc.split('#')
+      controller = controller.underscore.sub(/_controller$/,'')
+      [controller, action]
+    end
+
+    def controller_action_from_string(function_arn)
+      controller_action = function_arn.sub("#{Jets.project_namespace}-", '')
+      md = controller_action.match(/(.*)_controller-(.*)/)
+      controller = md[1]
+      controller = controller.gsub('-','/')
+      action = md[2]
+      [controller, action]
+    end
+
+    def lambda_function_description(function_arn)
+      resp = aws_lambda.get_function(function_name: function_arn)
+      resp.configuration.description # contains full info: PostsController#index
+    end
+
+    # Duplicated in rest_api/change_detection.rb, base_path/role.rb, rest_api/routes.rb
+    def rest_api_id
+      stack_name = Jets::Naming.parent_stack_name
+      return "RestApi" unless stack_exists?(stack_name)
+
+      stack = cfn.describe_stacks(stack_name: stack_name).stacks.first
+
+      api_gateway_stack_arn = lookup(stack[:outputs], "ApiGateway")
+
+      # resources = cfn.describe_stack_resources(stack_name: api_gateway_stack_arn).stack_resources
+      stack = cfn.describe_stacks(stack_name: api_gateway_stack_arn).stacks.first
+      lookup(stack[:outputs], "RestApi") # rest_api_id
+    end
+    memoize :rest_api_id
+
+    def new_routes
+      Jets::Router.routes
+    end
+    memoize :new_routes
+  end
+end

data/lib/jets/resource/api_gateway/rest_api/routes/change/to.rb

@@ -0,0 +1,29 @@
+# Detects route to changes
+class Jets::Resource::ApiGateway::RestApi::Routes::Change
+  class To < Base
+    def self.changed?
+      new.changed?
+    end
+
+    def changed?
+      deployed_routes.each do |deployed_route|
+        new_route = find_comparable_route(deployed_route)
+        if new_route && new_route.to != deployed_route.to
+          # change in already deployed route has been detected, requires bluegreen deploy
+          return true
+        end
+      end
+      false # Reaching here means no routes have been changed in a way that requires a bluegreen deploy
+    end
+
+    # Find a route that has the same path and method. This is a comparable route
+    # Then we will compare the to or controller action to see if an already
+    # deployed route has been changed.
+    def find_comparable_route(deployed_route)
+      new_routes.find do |new_route|
+        new_route.path == deployed_route.path &&
+        new_route.method == deployed_route.method
+      end
+    end
+  end
+end

data/lib/jets/resource/api_gateway/rest_api/routes/change/variable.rb

@@ -0,0 +1,39 @@
+# Detects route variable changes
+class Jets::Resource::ApiGateway::RestApi::Routes::Change
+  class Variable < Base
+    def self.changed?
+      new.changed?
+    end
+
+    def changed?
+      changed = false
+      deployed_routes.each do |deployed_route|
+        parent = collision.variable_parent(deployed_route.path)
+        parent_variables = collision.parent_variables(parent, [deployed_route.path])
+        new_parent_variables = collision.parent_variables(parent, new_paths)
+
+        changed = parent_variables.size > 0 && new_parent_variables.size > 0 &&
+                  parent_variables != new_parent_variables
+        break if changed
+      end
+      changed
+    end
+
+    # Only consider paths with variables
+    def new_paths
+      new_routes.map(&:path).select {|p| p.include?(':')}.uniq
+    end
+
+    # Only consider deployed routes with variables
+    def deployed_routes
+      deployed_routes = super
+      deployed_routes.select do |route|
+        route.path.include?(':')
+      end
+    end
+
+    def collision
+      @collision ||= Jets::Resource::ApiGateway::RestApi::Routes::Collision.new
+    end
+  end
+end

data/lib/jets/resource/api_gateway/rest_api/routes/collision.rb

@@ -0,0 +1,121 @@
+# Detects path variable collisions
+class Jets::Resource::ApiGateway::RestApi::Routes
+  class Collision
+    attr_reader :collisions
+    def initialize
+      @collisions = []
+    end
+
+    def collision?(paths)
+      paths = paths_with_variables(paths)
+      parents = variable_parents(paths)
+
+      collide = false
+      parents.each do |parent|
+        collide ||= variable_collision_exists?(parent, paths)
+      end
+      collide
+    end
+
+    def exception
+      VariableException.new(collision_message)
+    end
+
+    def collision_message
+      <<~EOL
+        There are routes with sibling variables under the same parent that collide.
+
+        Collisions:
+          #{@collisions.join("\n  ")}
+
+        API Gateway only allows one unique variable path You must use the same variable name within
+        the same parent route path.
+        Example: /posts/:id and /posts/:post_id/reveal should both be /posts/:id and /posts/:id/reveal.
+
+        Please check your `config/routes.rb` and remove the colliding routes.
+        More info: http://rubyonjets.com/docs/considerations/api-gateway/
+      EOL
+    end
+
+    def variable_collision_exists?(parent, paths)
+      paths = paths_with_variables(paths)
+      variables = parent_variables(parent, paths)
+      collide = variables.uniq.size > 1
+      register_collision(parent, variables) if collide
+      collide
+    end
+
+    # register collision for later display
+    # We don't register the full path but this might be more helpful.
+    def register_collision(parent, variables)
+      return unless variables.uniq.size # check again just in case
+
+      variables.each do |v|
+        @collisions << "#{parent}/#{v}"
+      end
+      @collisions.uniq!
+    end
+
+    def parent_variables(parent, paths)
+      paths = paths.select do |path|
+        parent?(parent, path)
+      end
+      paths.map do |path|
+        path.sub("#{parent}/",'').gsub(%r{/.*},'')
+      end.uniq.sort
+    end
+
+    def parent?(parent, path)
+      return false if parent == path
+
+      parent_parts = parent.split('/')
+      path_parts = path.split('/')
+
+      n = parent_parts.size-1
+      parent_parts[0..n] == path_parts[0..n]
+    end
+
+    def direct_parent?(parent, path)
+      leaf = variable_leaf(path)
+      leaf_parent = leaf.split('/')[0..-2].join('/')
+      parent == leaf_parent
+    end
+
+    def variable_parents(paths)
+      parents = []
+      paths = paths_with_variables(paths)
+      paths.each do |path|
+        parents << variable_parent(path)
+      end
+      parents.uniq.sort
+    end
+
+    # Strips the path down until only the leaf node part is a variable
+    # Example: users/:user_id/posts/:post_id/edit
+    # Returns: users/:user_id/posts
+    def variable_parent(path)
+      path = variable_leaf(path)
+      # drop last variable to leave behind the parent
+      path.split('/')[0..-2].join('/')
+    end
+
+    # Strips the path down until only the leaf node part is a variable
+    # Example: users/:user_id/posts/:post_id/edit
+    # Returns: users/:user_id/posts
+    def variable_leaf(path)
+      return '' unless path.include?(':')
+
+      parts = path.split('/')
+      is_variable = parts.last.include?(':')
+      until is_variable
+        parts.pop
+        is_variable = parts.last.include?(':')
+      end
+      parts[0..-1].join('/') # parent
+    end
+
+    def paths_with_variables(paths)
+      paths.select { |p| p.include?(':') }.uniq
+    end
+  end
+end