minimal_pipeline 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c77dd539e2d2d4c1a1639ed735bb8ef0d1e0802e59a1240e16af9e2baa03954d
+  data.tar.gz: 22fc7cc213e129f5ceada0fde056f61cfaa3722078b65b1dbc99b77d8fa48bcf
+SHA512:
+  metadata.gz: fd61094908f6d9407dbbf1b3e7b8218013125a71d0fe9582887547b297138acfc3952cab760661ab1856a4b80b1d99c12f5771128d6b5b31f27272ad93cd29c8
+  data.tar.gz: cf8b54cdedd4b8bccbbe5539cf6ff15742fc3968bc2ff74aa37f7db0bb9e77d6fd25905af81c635e5250b0d7120df3c8ef0f8cbc1c8399c91cef7c5de7891879

data/lib/minimal_pipeline.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'aws-sdk'
+require 'crossing'
+require 'keystore'
+require 'open3'
+require 'docker'
+require 'json'
+
+# Top level namespace for automation pipeline classes
+class MinimalPipeline
+  # autoload libraries
+  autoload(:Cloudformation, 'minimal_pipeline/cloudformation')
+  autoload(:Crossing, 'minimal_pipeline/crossing')
+  autoload(:Docker, 'minimal_pipeline/docker')
+  autoload(:Keystore, 'minimal_pipeline/keystore')
+end

data/lib/minimal_pipeline/cloudformation.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+require 'aws-sdk'
+
+class MinimalPipeline
+  # Here is an example of how to use this class to deploy CloudFormation Stacks.
+  #
+  # ```
+  # cloudformation = MinimalPipeline::Cloudformation.new
+  #
+  # cloudformation_parameters = {
+  #   'Vpc' => 'vpc-123456',
+  #   'AsgSubnets' => %w[sg-one sg-two sg-three],
+  #   'ElbSecurityGroup' => 'sg-123456',
+  #   'CertName' => 'example'
+  # }
+  #
+  # stack_parameters = {
+  #   stack_name: stack_name,
+  #   template_body: File.read('provisioning/elb.json'),
+  #   capabilities: ['CAPABILITY_IAM'],
+  #   parameters: cloudformation.params(cloudformation_parameters)
+  # }
+  #
+  # cloudformation.deploy_stack('EXAMPLE_ELB', stack_parameters)
+  # name = cloudformation.stack_output(stack_name, 'LoadBalancerName')
+  # ```
+  #
+  # You will need the following environment variables to be present:
+  # * `AWS_REGION` or `region`
+  class Cloudformation
+    # Instance of `Aws::CloudFormation::Client`
+    attr_reader(:client)
+
+    # Sets up `Aws::CloudFormation::Client`
+    # Requires environment variable `AWS_REGION` or `region` to be set.
+    def initialize
+      raise 'You must set env variable AWS_REGION.' if ENV['AWS_REGION'].nil?
+
+      region = ENV['AWS_REGION']
+      @client = Aws::CloudFormation::Client.new(region: region)
+    end
+
+    # Converts a parameter Hash into a CloudFormation friendly structure
+    #
+    # @param parameters [Hash] Key value pair of parameters for a CFN stack.
+    # @return [Hash] CloudFormation friendly data structure of parameter
+    def params(parameters)
+      parameter_list = []
+      parameters.each do |k, v|
+        parameter_list.push(parameter_key: k, parameter_value: v)
+      end
+      parameter_list
+    end
+
+    # Retrieves the CloudFormation stack output of a single value
+    #
+    # @param stack [String] The name of the CloudFormation stack
+    # @param output [String] The name of the output to fetch the value of
+    # @return [String] The value of the output for the CloudFormation stack
+    def stack_output(stack, output)
+      resp = @client.describe_stacks(stack_name: stack)
+
+      raise "#{stack.upcase} stack does not exist!" if resp.stacks.empty?
+
+      resp.stacks.first.outputs.each do |stack_output|
+        zero_output = stack_output.output_key.casecmp(output).zero?
+        return stack_output.output_value if zero_output
+      end
+
+      raise "#{stack.upcase} stack does not have a(n) '#{output}' output!"
+    end
+
+    # Creates or Updates a CloudFormation stack. Checks to see if the stack
+    # already exists and takes the appropriate action. Pauses until a final
+    # stack state is reached.
+
+    # @param stack_name [String] The name of the CloudFormation stack
+    # @param stack_parameters [Hash] Parameters to be passed into the stack
+    def deploy_stack(stack_name, stack_parameters)
+      unless @client.describe_stacks(stack_name: stack_name).stacks.empty?
+        puts 'Updating the existing stack'
+        @client.update_stack(stack_parameters)
+        @client.wait_until(:stack_update_complete, stack_name: stack_name)
+      end
+    rescue Aws::CloudFormation::Errors::ValidationError => error
+      if error.to_s.include? 'No updates are to be performed.'
+        puts "Nothing to do."
+      elsif error.to_s.include? 'Template error'
+        raise error
+      else
+        puts 'Creating a new stack'
+        @client.create_stack(stack_parameters)
+        @client.wait_until(:stack_create_complete, stack_name: stack_name)
+      end
+    end
+  end
+end

data/lib/minimal_pipeline/crossing.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'aws-sdk'
+require 'crossing'
+
+class MinimalPipeline
+  # Here is an example of how to use this class to interact with Crossing.
+  #
+  # ```
+  # crossing = MinimalPipeline::Crossing.new
+  #
+  # # Upload
+  # crossing.upload_content('my-config-bucket', 'example.txt', 'foo')
+  #
+  # # Download
+  # content = crossing.download_file('my-config-bucket', 'example.txt')
+  # puts content # Outputs 'foo'
+  # ```
+  #
+  # You will need the following environment variables to be present:
+  # * `AWS_REGION` or `region`
+  # * `keystore_kms_id`
+  #
+  # For more information on Crossing see https://github.com/stelligent/crossing
+  class Crossing
+    def initialize
+      raise 'You must set env variable AWS_REGION.' if ENV['AWS_REGION'].nil?
+      raise '`keystore_kms_id` in environment!' \
+        if ENV['keystore_kms_id'].nil?
+
+      region = ENV['AWS_REGION']
+      kms = Aws::KMS::Client.new(region: region)
+      s3 = Aws::S3::Encryption::Client.new(kms_key_id: ENV['keystore_kms_id'],
+                                           kms_client: kms,
+                                           region: region)
+      @crossing = ::Crossing.new(s3)
+    end
+
+    # Securely uploads a file to an S3 bucket
+    #
+    # @param config_bucket [String] The name of the S3 bucket
+    # @param filename [String] The name of the file to save content to in the
+    #   bucket
+    # @param content [String] The content to store in the file
+    def upload_content(config_bucket, filename, content)
+      @crossing.put_content(config_bucket, filename, content)
+    end
+
+    # Securely downloads a file from an S3 bucket
+    #
+    # @param config_bucket [String] The name of the S3 bucket
+    # @param filename [String] The name of the file that contains the desired
+    #  content
+    # @return [String] The content that was stored in the file
+    def download_file(config_bucket, filename)
+      @crossing.get_content(config_bucket, filename)
+    end
+  end
+end

data/lib/minimal_pipeline/docker.rb

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require 'open3'
+require 'docker'
+require 'json'
+require 'securerandom'
+
+class MinimalPipeline
+  # Here is an example of how to use this class to manage Docker containers.
+  #
+  # ```
+  # docker = MinimalPipeline::Docker.new
+  # keystore = MinimalPipeline::Keystore.new
+  #
+  # deploy_env = ENV['DEPLOY_ENV']
+  # docker_repo = keystore.retrieve("#{deploy_env}_EXAMPLE_ECR_REPO")
+  # docker_image = "#{docker_repo}/example:latest"
+  # docker.build_docker_image(docker_image, 'containers/example')
+  # docker.push_docker_image(docker_image)
+  # ```
+  class Docker
+    include Rake::DSL
+
+    def initialize
+    end
+
+    # Finds the absolute path to a given executable
+    #
+    # @param cmd [String] The name of the executable to locate
+    # @return [String] The absolute path to the executable
+    def which(cmd)
+      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+      ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+        exts.each do |ext|
+          exe = File.join(path, "#{cmd}#{ext}")
+          return exe if File.executable?(exe) && !File.directory?(exe)
+        end
+      end
+      nil
+    end
+
+    # Outputs JSON build output lines as human readible text
+    #
+    # @param build_output [String] Raw JSON build output line
+    def build_output(build_output)
+      # Each line of the response is its own JSON structure
+      build_output.each_line do |l|
+        if (log = JSON.parse(l)) && log.key?('stream')
+          $stdout.puts log['stream']
+        end
+      end
+    rescue JSON::ParserError
+      $stdout.puts "Bad JSON parse\n"
+      $stdout.puts build_output
+    end
+
+    # Logs in to AWS ECR
+    def ecr_login
+      region = ENV['AWS_REGION'] || ENV['region']
+      `$(aws ecr get-login --region #{region})`
+    end
+
+    # Cleans up docker images
+    #
+    # @param image_id [String] The Docker container ID to delete
+    def clean_up_image(image_id)
+      image = ::Docker::Image.get(image_id)
+      image.remove(force: true)
+    end
+
+    # Builds a docker image from a Dockerfile
+    #
+    # @param image_id [String] The name of the docker image
+    # @param dir [String] The path to the Dockerfile
+    # @param build_args [Hash] Additional build args to pass to Docker
+    # @param timeout [Integer] The Docker build timeout
+    def build_docker_image(image_id, dir = '.', build_args: {}, timeout: 600)
+      %w[HTTP_PROXY HTTPS_PROXY NO_PROXY http_proxy https_proxy
+         no_proxy].each do |arg|
+        build_args[arg] = ENV[arg] if ENV[arg]
+      end
+
+      args = {
+        'nocache' => 'true',
+        'pull' => 'true',
+        't' => image_id,
+        'buildargs' => JSON.dump(build_args)
+      }
+      puts "Build args: #{args.inspect}"
+      ::Docker.options[:read_timeout] = timeout
+      ::Docker::Image.build_from_dir(dir, args) { |v| build_output(v) }
+    end
+
+    # Pushes a docker image from local to AWS ECR.
+    # This handles login, the upload, and local cleanup of the container
+    #
+    # @param image_id [String] The name of the docker image
+    def push_docker_image(image_id)
+      ecr_login
+      docker_bin = which('docker')
+      raise "docker_push: no docker binary: #{image_id}" unless docker_bin
+      stdout, stderr, status = Open3.capture3(docker_bin, 'push', image_id)
+      raise "stdout: #{stdout}\nstderr: #{stderr}\nstatus: #{status}" \
+        unless status.exitstatus.zero?
+      clean_up_image(image_id)
+    end
+
+    # List all containers in the `containers` directory
+    # @return [Array] List of container names
+    def list_containers
+      containers = Dir.glob('containers/*')
+      # Grab container name from containers/name/Dockerfile
+      containers.map{ |container| container.split('/')[1] }
+    end
+  end
+end

data/lib/minimal_pipeline/keystore.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require 'keystore'
+require 'aws-sdk'
+
+class MinimalPipeline
+  # Here is an example of how to use this class to interact with the Keystore.
+  #
+  # ```
+  # keystore = MinimalPipeline::Keystore.new
+  #
+  # # Store
+  # keystore.store('EXAMPLE_KEY', 'foo')
+  #
+  # # Retrieve
+  # content = keystore.retrieve('EXAMPLE_KEY')
+  # puts content # Outputs 'foo'
+  # ```
+  #
+  # You will need the following environment variables to be present:
+  # * `AWS_REGION` or `region`
+  # * `keystore_table`
+  # * `keystore_kms_id`
+  #
+  # For more information on the Keystore please see
+  # https://github.com/stelligent/keystore
+  class Keystore
+    # Initializes a `Keystore` client
+    # Requires environment variables `AWS_REGION` or `region` to be set.
+    # Also requires `keystore_kms_id` and `keystore_table`
+    def initialize
+      raise 'You must set env variable AWS_REGION.' if ENV['AWS_REGION'].nil?
+      raise 'Missing `keystore_table` or `keystore_kms_id` in environment!' \
+        if ENV['keystore_table'].nil? || ENV['keystore_kms_id'].nil?
+
+      region = ENV['AWS_REGION']
+      kms = Aws::KMS::Client.new(region: region)
+      dynamo = Aws::DynamoDB::Client.new(region: region)
+      @keystore = ::Keystore.new(dynamo: dynamo,
+                               table_name: ENV['keystore_table'],
+                               kms: kms,
+                               key_id: ENV['keystore_kms_id'])
+    end
+
+    # Retrieves a value from the Keystore
+    #
+    # @param keyname [String] The name of the Keystore key
+    # @return [String] The value stored in the Keystore for the given key
+    def retrieve(keyname)
+      @keystore.retrieve(key: keyname)
+    end
+
+    # Stores a value in the Keystore
+    #
+    # @param keyname [String] The name of the Keystore key
+    # @param value [String] The value to store for the given key
+    def store(keyname, value)
+      @keystore.store(key: keyname, value: value)
+    end
+  end
+end

metadata

@@ -0,0 +1,135 @@
+--- !ruby/object:Gem::Specification
+name: minimal_pipeline
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Mayowa Aladeojebi
+- Jesse Adams
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-08-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2'
+- !ruby/object:Gem::Dependency
+  name: crossing
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.8
+- !ruby/object:Gem::Dependency
+  name: docker-api
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.34.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 1.34.2
+- !ruby/object:Gem::Dependency
+  name: keystore
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.1.7
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.55.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '='
+      - !ruby/object:Gem::Version
+        version: 0.55.0
+description: Helper gem to orchestrate pipeline tasks
+email:
+- mayowa.aladeojebi@stelligent.com
+- jesse.adams@stelligent.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/minimal_pipeline.rb
+- lib/minimal_pipeline/cloudformation.rb
+- lib/minimal_pipeline/crossing.rb
+- lib/minimal_pipeline/docker.rb
+- lib/minimal_pipeline/keystore.rb
+homepage: https://github.com/stelligent/minimal-pipeline-gem
+licenses:
+- 0BSD
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.7.6
+signing_key: 
+specification_version: 4
+summary: Helper gem to manage pipeline tasks
+test_files: []