codepipeline 0.1.0 → 0.2.0

data/lib/codepipe/schedule.rb

@@ -0,0 +1,99 @@
+module Codepipe
+  class Schedule
+    include Codepipe::Dsl::Schedule
+    include Evaluate
+
+    def initialize(options={})
+      @options = options
+      @schedule_path = options[:schedule_path] || get_schedule_path
+      @properties = default_properties
+    end
+
+    def run
+      return unless File.exist?(@schedule_path)
+
+      old_properties = @properties.clone
+      evaluate(@schedule_path)
+
+      @properties[:schedule_expression] = @schedule_expression if @schedule_expression
+      set_rule_event! if @rule_event_props
+      return if old_properties == @properties # empty schedule.rb file
+
+      resource = {
+        events_rule: {
+          type: "AWS::Events::Rule",
+          properties: @properties
+        },
+        events_rule_role: events_rule_role,
+      }
+      CfnCamelizer.transform(resource)
+    end
+
+    def set_rule_event!
+      props = @rule_event_props
+      if props.key?(:detail)
+        description = props.key?(:description) ? props.delete(:description) : rule_description
+        rule_props = { event_pattern: props, description: description }
+      else # if props.key?(:event_pattern)
+        props[:description] ||= rule_description
+        rule_props = props
+      end
+
+      @properties.merge!(rule_props)
+    end
+
+    def default_properties
+      description = "CodePipeline #{@options[:full_pipeline_name]}"
+      name = description.gsub(" ", "-").downcase
+      {
+        description: description,
+        # event_pattern: ,
+        name: name,
+        # schedule_expression: ,
+        state: "ENABLED",
+        targets: [{
+          arn: "arn:aws:codepipeline:#{aws.region}:#{aws.account}:#{@options[:full_pipeline_name]}",
+          role_arn: { "Fn::GetAtt": "EventsRuleRole.Arn" }, # required for specific CodePipeline target.
+          id: "CodePipelineTarget",
+        }]
+      }
+    end
+
+  private
+    def get_schedule_path
+      lookup_codepipeline_file("schedule.rb")
+    end
+
+    def events_rule_role
+      {
+        type: "AWS::IAM::Role",
+        properties: {
+          assume_role_policy_document: {
+            statement: [{
+              action: [ "sts:AssumeRole" ],
+              effect: "Allow",
+              principal: { service: [ "events.amazonaws.com" ] }
+            }],
+            version: "2012-10-17"
+          },
+          path: "/",
+          policies: [{
+            policy_name: "CodePipelineAccess",
+            policy_document: {
+              version: "2012-10-17",
+              statement: [{
+                action: "codepipeline:StartPipelineExecution",
+                effect: "Allow",
+                resource: "arn:aws:codepipeline:#{aws.region}:#{aws.account}:#{@options[:full_pipeline_name]}"
+              }]
+            }
+          }]
+        }
+      }
+    end
+
+    def aws
+      @aws ||= AwsData.new
+    end
+  end
+end

data/lib/codepipe/sequence.rb

@@ -0,0 +1,66 @@
+require 'fileutils'
+require 'thor'
+
+module Codepipe
+  class Sequence < Thor::Group
+    include AwsServices
+    include Thor::Actions
+
+    add_runtime_options! # force, pretend, quiet, skip options
+      # https://github.com/erikhuda/thor/blob/master/lib/thor/actions.rb#L49
+
+    def self.source_paths
+      [File.expand_path("../../template", __FILE__)]
+    end
+
+  private
+    def override_source_paths(*paths)
+      # Using string with instance_eval because block doesnt have access to
+      # path at runtime.
+      self.class.instance_eval %{
+        def self.source_paths
+          #{paths.flatten.inspect}
+        end
+      }
+    end
+
+    def sync_template_repo
+      unless git_installed?
+        abort "Unable to detect git installation on your system.  Git needs to be installed in order to use the --template option."
+      end
+
+      template_path = "#{ENV['HOME']}/.codebuild/templates/#{full_repo_name}"
+      if File.exist?(template_path)
+        sh("cd #{template_path} && git pull")
+      else
+        FileUtils.mkdir_p(File.dirname(template_path))
+        sh("git clone #{repo_url} #{template_path}")
+      end
+    end
+
+    def full_repo_name
+      full_repo = options[:template].split("/")[-2..-1].join("/")
+      full_repo = full_repo.split(":").last
+      full_repo.sub(".git", "")
+    end
+
+    # normalize repo_url
+    def repo_url
+      template = options[:template]
+      if template.include?('github.com')
+        template # leave as is, user has provided full github url
+      else
+        "https://github.com/#{template}"
+      end
+    end
+
+    def git_installed?
+      system("type git > /dev/null")
+    end
+
+    def sh(command)
+      puts "=> #{command}"
+      system(command)
+    end
+  end
+end

data/lib/codepipe/setting.rb

@@ -0,0 +1,79 @@
+require 'yaml'
+require 'render_me_pretty'
+
+module Codepipe
+  class Setting
+    extend Memoist
+    def initialize(check_codepipeline_project=true)
+      @check_codepipeline_project = check_codepipeline_project
+    end
+
+    # data contains the settings.yml config.  The order or precedence for settings
+    # is the project ufo/settings.yml and then the ~/.codepipeline/settings.yml.
+    def data
+      Codepipe.check_codepipeline_project! if @check_codepipeline_project
+      return {} unless File.exist?(project_settings_path)
+
+      # project based settings files
+      project = load_file(project_settings_path)
+
+      user_file = "#{ENV['HOME']}/.codepipeline/settings.yml"
+      user = File.exist?(user_file) ? YAML.load_file(user_file) : {}
+
+      default_file = File.expand_path("default/settings.yml", __dir__)
+      default = load_file(default_file)
+
+      all_envs = default.deep_merge(user.deep_merge(project))
+      all_envs = merge_base(all_envs)
+      data = all_envs[pipe_env] || all_envs["base"] || {}
+      data.deep_symbolize_keys
+    end
+    memoize :data
+
+    # Resolves infinite problem since Codepipe.env can be determined from PIPE_ENV or settings.yml files.
+    # When ufo is determined from settings it should not called Codepipe.env since that in turn calls
+    # Settings.new.data which can then cause an infinite loop.
+    def pipe_env
+      settings = YAML.load_file("#{cb_root}/.codepipeline/settings.yml")
+      env = settings.find do |_env, section|
+        section ||= {}
+        ENV['AWS_PROFILE'] && ENV['AWS_PROFILE'] == section['aws_profile']
+      end
+
+      pipe_env = env.first if env
+      pipe_env = ENV['PIPE_ENV'] if ENV['PIPE_ENV'] # highest precedence
+      pipe_env || 'development'
+    end
+
+  private
+    def load_file(path)
+      return Hash.new({}) unless File.exist?(path)
+
+      content = RenderMePretty.result(path)
+      data = YAML.load(content)
+      # If key is is accidentally set to nil it screws up the merge_base later.
+      # So ensure that all keys with nil value are set to {}
+      data.each do |env, _setting|
+        data[env] ||= {}
+      end
+      data
+    end
+
+    # automatically add base settings to the rest of the environments
+    def merge_base(all_envs)
+      base = all_envs["base"] || {}
+      all_envs.each do |env, settings|
+        all_envs[env] = base.merge(settings) unless env == "base"
+      end
+      all_envs
+    end
+
+    def project_settings_path
+      "#{cb_root}/.codepipeline/settings.yml"
+    end
+
+    def cb_root
+      ENV["CODEPIPELINE_ROOT"] || Dir.pwd
+    end
+  end
+end

data/lib/codepipe/sns.rb

@@ -0,0 +1,43 @@
+module Codepipe
+  class Sns
+    include Codepipe::Dsl::Sns
+    include Evaluate
+
+    def initialize(options={})
+      @options = options
+      @sns_path = options[:sns_path] || get_sns_path
+      @properties = default_properties
+    end
+
+    def run
+      evaluate(@sns_path) if File.exist?(@sns_path)
+
+      resource = {
+        sns_topic: {
+          type: "AWS::SNS::Topic",
+          properties: @properties
+        }
+      }
+      CfnCamelizer.transform(resource)
+    end
+
+    def default_properties
+      display_name = "#{@options[:full_pipeline_name]} pipeline"
+      {
+        display_name: display_name,
+        # kms_master_key_id: "string",
+        # subscription: [{
+        #   endpoint: '',
+        #   protocol: ','
+        # }],
+        # topic_name: "string", # Not setting because update requires: Replacement. Dont want 2 pipelines to collide
+      }
+      # https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-sns-subscription.html
+    end
+
+  private
+    def get_sns_path
+      lookup_codepipeline_file("sns.rb")
+    end
+  end
+end

data/lib/codepipe/stack.rb

@@ -0,0 +1,95 @@
+require "aws-sdk-cloudformation"
+
+module Codepipe
+  class Stack
+    include AwsServices
+
+    def initialize(options)
+      @options = options
+      @pipeline_name = @options[:pipeline_name] || inferred_pipeline_name
+      @stack_name = options[:stack_name] || inferred_stack_name(@pipeline_name)
+
+      @full_pipeline_name = pipeline_name_convention(@pipeline_name)
+      @template = {
+        "Description" => "CodePipeline Project: #{@full_pipeline_name}",
+        "Resources" => {}
+      }
+    end
+
+    def run
+      options = @options.merge(
+        pipeline_name: @pipeline_name,
+        full_pipeline_name: @full_pipeline_name,
+      )
+
+      pipeline_builder = Pipeline.new(options)
+      unless pipeline_builder.exist?
+        puts "ERROR: pipeline does not exist: #{pipeline_builder.pipeline_path}".color(:red)
+        exit 1
+        return
+      end
+      pipeline = pipeline_builder.run
+      @template["Resources"].merge!(pipeline)
+
+      if pipeline["Pipeline"]["Properties"]["RoleArn"] == {"Fn::GetAtt"=>"IamRole.Arn"}
+        role = Role.new(options).run
+        @template["Resources"].merge!(role)
+      end
+
+      if sns_topic?(pipeline)
+        role = Sns.new(options).run
+        @template["Resources"].merge!(role)
+      end
+
+      webhook = Webhook.new(options).run
+      @template["Resources"].merge!(webhook) if webhook
+
+      schedule = Schedule.new(options).run
+      @template["Resources"].merge!(schedule) if schedule
+
+      template_path = "/tmp/codepipeline.yml"
+      FileUtils.mkdir_p(File.dirname(template_path))
+      IO.write(template_path, YAML.dump(@template))
+      puts "Generated CloudFormation template at #{template_path.color(:green)}"
+      return if @options[:noop]
+      puts "Deploying stack #{@stack_name.color(:green)} with CodePipeline project #{@full_pipeline_name.color(:green)}"
+
+      begin
+        perform
+        url_info
+        return unless @options[:wait]
+        status.wait
+        exit 2 unless status.success?
+      rescue Aws::CloudFormation::Errors::ValidationError => e
+        if e.message.include?("No updates") # No updates are to be performed.
+          puts "WARN: #{e.message}".color(:yellow)
+        else
+          puts "ERROR ValidationError: #{e.message}".color(:red)
+          exit 1
+        end
+      end
+    end
+
+  private
+    def sns_topic?(template)
+      stages = template['Pipeline']['Properties']['Stages']
+      stages.detect do |stage|
+        stage['Actions'].detect do |action|
+          action['Configuration']['NotificationArn'] == {'Ref'=>'SnsTopic'}
+        end
+      end
+    end
+
+    def url_info
+      stack = cfn.describe_stacks(stack_name: @stack_name).stacks.first
+      region = `aws configure get region`.strip rescue "us-east-1"
+      url = "https://console.aws.amazon.com/cloudformation/home?region=#{region}#/stacks"
+      puts "Stack name #{@stack_name.color(:yellow)} status #{stack["stack_status"].color(:yellow)}"
+      puts "Here's the CloudFormation url to check for more details #{url}"
+    end
+
+    def status
+      @status ||= Cfn::Status.new(@stack_name)
+    end
+  end
+end

data/lib/codepipe/start.rb

@@ -0,0 +1,83 @@
+module Codepipe
+  class Start
+    extend Memoist
+    include AwsServices
+
+    def initialize(options)
+      @options = options
+      @pipeline_name = options[:pipeline_name] || inferred_pipeline_name
+      @full_pipeline_name = pipeline_name_convention(@pipeline_name)
+      @stack_name = options[:stack_name] || inferred_stack_name(@pipeline_name)
+    end
+
+    def run
+      check_pipeline_exists!
+      redeploy
+      resp = codepipeline.start_pipeline_execution(name: pipeline_name)
+      codepipeline_info(resp.pipeline_execution_id)
+    end
+
+    # Codepipeline does not currently support specifying a different branch starting an execution.
+    # Workaround this limitation by updating the pipeline and then starting the execution.
+    def redeploy
+      return unless different_branch?
+      puts "Different branch detected."
+      puts "  Current pipeline branch: #{current_pipeline_branch}"
+      puts "  Requested branch: #{@options[:branch]}"
+      puts "Updating pipeline with new branch.".color(:green)
+      Deploy.new(@options).run
+    end
+
+    def different_branch?
+      current_pipeline_branch != @options[:branch]
+    end
+
+    # Actual branch on current pipeline
+    def current_pipeline_branch
+      resp = codepipeline.get_pipeline(name: pipeline_name)
+      source_stage = resp.pipeline.stages.find { |s| s.name == "Source" }
+      action = source_stage.actions.first
+      action.configuration['Branch']
+    end
+    memoize :current_pipeline_branch
+
+    def check_pipeline_exists!
+      pipeline_name
+    end
+
+    def pipeline_name
+      if pipeline_exists?(@full_pipeline_name)
+        @full_pipeline_name
+      elsif stack_exists?(@stack_name) # allow `cb start STACK_NAME` to work too
+        resp = cfn.describe_stack_resources(stack_name: @stack_name)
+        resource = resp.stack_resources.find do |r|
+          r.logical_resource_id == "CodePipeline"
+        end
+        resource.physical_resource_id # codepipeline project name
+      else
+        puts "ERROR: Unable to find the codepipeline project with either full_pipeline_name: #{@full_pipeline_name} or stack name: #{@stack_name}".color(:red)
+        exit 1
+      end
+    end
+    memoize :pipeline_name
+
+  private
+    def codepipeline_info(execution_id)
+      region = `aws configure get region`.strip rescue "us-east-1"
+      url = "https://#{region}.console.aws.amazon.com/codesuite/codepipeline/pipelines/#{pipeline_name}/view"
+      cli = "aws codepipeline get-pipeline-execution --pipeline-execution-id #{execution_id} --pipeline-name #{pipeline_name}"
+
+      puts "Pipeline started: #{pipeline_name}"
+      puts "Please check the CodePipeline console for the status."
+      puts "CodePipeline Console: #{url}"
+      puts "Pipeline cli: #{cli}"
+    end
+
+    def pipeline_exists?(name)
+      codepipeline.get_pipeline(name: name)
+      true
+    rescue Aws::CodePipeline::Errors::PipelineNotFoundException
+      false
+    end
+  end
+end