opsup 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6cc178acdd70bf25302010af889f45a52d95d2f1f1fa841ab7f6534cb98d024a
+  data.tar.gz: 3a063657be7b128f9b4dc47e0c91d4f42a0e0dce978e71d4f89fee9c94f22ca3
+SHA512:
+  metadata.gz: b29e1e1e7842bda942d3ff0c0921b09f47a69aab108f34481e73e7bf520d87820a36d02bc9c6c49e793bb0e16d4fab7688f1281e5e15b39a7b79c627abd6ed63
+  data.tar.gz: 70231d0c02c3e1fd9c135bceae0e41e39cc601bc03e8875e6c50f6c3be88c6c572fbcb37714a05520f75d6269270a8e1cb3b5b3e7be4e73b2a7ef5b4a02b6ab0

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 ryym
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,37 @@
+# Opsup
+
+Opsup is a small command line tool to run commands for [AWS OpsWorks][aws-opsworks].
+
+I created this as an internal tool for my work.
+
+[aws-opsworks]: https://aws.amazon.com/jp/opsworks/
+
+## Installation
+
+```ruby
+gem install opsup
+```
+
+## Usage
+
+Currently Opsup can run these commands:
+
+- `update_cookbooks`
+- `setup`
+- `configure`
+- `deploy`
+
+Example:
+
+```bash
+$ opsup --stack $YOUR_STACK_NAME --aws-cred $AWS_KEY,$AWS_SECRET deploy
+```
+
+Opsup waits until the command completes.
+
+### TODO
+
+- Add a command to build cookbooks and upload them to S3
+- Write tests
+- (maybe) Load options from environment varibles or a configuration file
+- (maybe) Add commands to create, start, stop, and delete instances

data/bin/opsup

@@ -0,0 +1,8 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative '../lib/opsup'
+
+cli = Opsup::CLI.create
+ok = cli.run(ARGV)
+exit(ok ? 0 : 1)

data/lib/opsup.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'opsup/version'
+require_relative 'opsup/error'
+require_relative 'opsup/config'
+require_relative 'opsup/logger'
+require_relative 'opsup/stack_operator'
+require_relative 'opsup/app'
+require_relative 'opsup/cli'
+
+module Opsup
+end

data/lib/opsup/app.rb

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'aws-sdk-opsworks'
+
+module Opsup
+  class App
+    private_class_method :new
+
+    def self.create
+      new(
+        logger: Opsup::Logger.instance,
+      )
+    end
+
+    def initialize(logger:)
+      @logger = logger
+    end
+
+    AVAILABLE_COMMANDS = %w[
+      update_cookbooks
+      setup
+      configure
+      deploy
+    ].freeze
+
+    def available_commands
+      AVAILABLE_COMMANDS
+    end
+
+    def run(commands, config)
+      validate_commands(commands)
+      @logger.warn('Started in DRYRUN MODE') if config.dryrun
+      @logger.debug("Running #{commands} with #{config.to_h}")
+
+      opsworks = new_opsworks_client(config)
+      opsworks_commands = commands.map { |c| command_to_opsworks_command(c) }
+
+      stack_operator = Opsup::StackOperator.create(opsworks: opsworks)
+      stack_operator.run_commands(
+        opsworks_commands,
+        stack_name: config.stack_name,
+        mode: config.running_mode,
+        dryrun: config.dryrun,
+      )
+    ensure
+      @logger.warn('Finished in DRYRUN MODE') if config.dryrun
+    end
+
+    private def validate_commands(commands)
+      raise Opsup::Error, 'No commands specified' if commands.empty?
+
+      unknown_cmds = commands - AVAILABLE_COMMANDS
+      raise Opsup::Error, "Unknown commands: #{unknown_cmds.join(' ')}" unless unknown_cmds.empty?
+    end
+
+    private def new_opsworks_client(config)
+      creds = Aws::Credentials.new(config.aws_access_key_id, config.aws_secret_access_key)
+      Aws::OpsWorks::Client.new(region: config.opsworks_region, credentials: creds)
+    end
+
+    # Assumes the command is a valid value.
+    private def command_to_opsworks_command(command)
+      command == 'update_cookbooks' ? 'update_custom_cookbooks' : command
+    end
+  end
+end

data/lib/opsup/cli.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'optparse'
+
+module Opsup
+  class CLI
+    private_class_method :new
+
+    def self.create
+      new(
+        app: Opsup::App.create,
+        option_builder: Opsup::CLI::OptionBuilder.create,
+      )
+    end
+
+    def initialize(app:, option_builder:)
+      @app = app
+      @option_builder = option_builder
+    end
+
+    def run(argv)
+      parser = create_parser
+      @option_builder.define_options(parser)
+
+      options = {}
+      begin
+        # It automatically exits with a help message if necessary.
+        commands = parser.parse(argv, into: options)
+      rescue OptionParser::MissingArgument => e
+        puts e.message
+        return false
+      end
+
+      begin
+        config = @option_builder.generate_config(options)
+        @app.run(commands, config)
+      rescue Opsup::Error => e
+        puts "Error: #{e.message}"
+        return false
+      end
+
+      true
+    end
+
+    private def create_parser
+      # ref: https://docs.ruby-lang.org/en/2.1.0/OptionParser.html
+      OptionParser.new do |p|
+        p.version = Opsup::VERSION
+        p.banner = <<~BANNER
+          CLI to run Chef commands easily for your OpsWorks stacks.
+          Usage:
+            opsup [options] [commands...]
+          Commands:
+            #{@app.available_commands.join(', ')}
+          Example:
+            opsup -s stack-name deploy
+
+          Options:
+        BANNER
+      end
+    end
+
+    class OptionBuilder
+      private_class_method :new
+
+      def self.create
+        new
+      end
+
+      DEFAULT_OPSWORKS_REGION = 'ap-northeast-1'
+
+      def define_options(parser)
+        parser.tap do |p|
+          p.on('-s', '--stack STACK_NAME', 'target stack name')
+          p.on('-m', '--mode MODE', Opsup::Config::MODES.join(' | ').to_s)
+          p.on('--aws-cred KEY_ID,SECRET_KEY', 'AWS credentials')
+          p.on('--opsworks-region REGION', "default: #{DEFAULT_OPSWORKS_REGION}")
+          p.on('-d', '--dryrun')
+        end
+      end
+
+      def generate_config(options)
+        %w[stack aws-cred].each do |key|
+          raise Opsup::Error, "missing required option: --#{key}" unless options[key.to_sym]
+        end
+
+        aws_key_id, aws_secret = options[:"aws-cred"].split(',')
+        if aws_key_id.nil? || aws_secret.nil?
+          raise Opsup::Error, "aws-cred must be 'key_id,secret_key' format"
+        end
+
+        mode = options[:mode]&.to_sym
+        raise Opsup::Error, "invalid mode: #{mode}" if mode && !Opsup::Config::MODES.include?(mode)
+
+        Opsup::Config.new(
+          stack_name: options[:stack],
+          aws_access_key_id: aws_key_id,
+          aws_secret_access_key: aws_secret,
+          opsworks_region: options[:"opsworks-region"] || DEFAULT_OPSWORKS_REGION,
+          running_mode: mode,
+          dryrun: options[:dryrun] || false,
+        )
+      end
+    end
+  end
+end

data/lib/opsup/config.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Opsup
+  class Config
+    attr_reader :stack_name
+    attr_reader :aws_access_key_id
+    attr_reader :aws_secret_access_key
+    attr_reader :opsworks_region
+    attr_reader :running_mode
+    attr_reader :dryrun
+
+    MODES = %i[parallel serial one_then_all].freeze
+
+    def initialize(
+      stack_name:,
+      aws_access_key_id:,
+      aws_secret_access_key:,
+      opsworks_region:,
+      running_mode: nil,
+      dryrun: false
+    )
+      @stack_name = stack_name
+      @aws_access_key_id = aws_access_key_id
+      @aws_secret_access_key = aws_secret_access_key
+      @opsworks_region = opsworks_region
+      @running_mode = running_mode || MODES[0]
+      @dryrun = dryrun
+    end
+
+    def to_h
+      {
+        stack_name: stack_name,
+        aws_access_key_id: aws_access_key_id,
+        aws_secret_access_key: aws_secret_access_key,
+        opsworks_region: opsworks_region,
+        running_mode: running_mode,
+        dryrun: dryrun,
+      }
+    end
+  end
+end

data/lib/opsup/error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Opsup
+  class Error < StandardError
+  end
+end

data/lib/opsup/logger.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'logger'
+
+module Opsup
+  class Logger
+    def self.instance
+      env_log_level = ENV['OPSUP_LOG_LEVEL']
+      log_level =
+        if env_log_level && ::Logger.const_defined?(env_log_level)
+          ::Logger.const_get(env_log_level)
+        else
+          ::Logger::INFO
+        end
+
+      # Should be able to change the output device.
+      @instance ||= ::Logger.new(STDOUT).tap do |logger|
+        logger.level = log_level
+      end
+    end
+  end
+end

data/lib/opsup/stack_operator.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module Opsup
+  class StackOperator
+    private_class_method :new
+
+    def self.create(opsworks:)
+      new(
+        opsworks: opsworks,
+        logger: Opsup::Logger.instance,
+      )
+    end
+
+    def initialize(opsworks:, logger:)
+      @opsworks = opsworks
+      @logger = logger
+    end
+
+    def run_commands(commands, stack_name:, mode:, dryrun: false)
+      # Find the target stack.
+      @logger.debug('Verifying the specified stack exists...')
+      stacks = @opsworks.describe_stacks.stacks
+      stack = stacks.find { |s| s.name == stack_name }
+      raise Opsup::Error, "Stack #{stack_name} does not exist" if stack.nil?
+
+      # Find the stack's apps.
+      @logger.debug('Verifying the stack has at least one app...')
+      apps = @opsworks.describe_apps(stack_id: stack.stack_id).apps
+      raise Opsup::Error, "#{stack_name} has no apps" if apps.empty?
+
+      # Find the instances to be updated.
+      @logger.debug('Finding all working instances in the stack...')
+      instances = @opsworks.describe_instances(stack_id: stack.stack_id).instances
+      instances = instances.reject { |inst| inst.status == 'stopped' }
+      @logger.debug(
+        "#{instances.size} #{instances.size == 1 ? 'instance is' : 'instances are'} found",
+      )
+
+      # Currently Opsup deploys only the first app by default.
+      app = apps.first
+      instance_ids = instances.map(&:instance_id)
+
+      # Run the commands sequentially.
+      commands.each do |command|
+        @logger.info("Running #{command} command in #{mode} mode...")
+        run_command(
+          command,
+          dryrun: dryrun,
+          mode: mode,
+          stack: stack,
+          app: app,
+          instance_ids: instance_ids,
+        )
+      end
+    end
+
+    private def run_command(command, dryrun:, mode:, stack:, app:, instance_ids:)
+      case mode
+      when :parallel
+        @logger.info("Creating single deployment for the #{instance_ids.size} instances...")
+        create_deployment(command, stack, app, instance_ids) unless dryrun
+      when :serial
+        instance_ids.each.with_index do |id, i|
+          @logger.info("Creating deployment for instances[#{i}] (#{id})...")
+          create_deployment(command, stack, app, [id]) unless dryrun
+        end
+      when :one_then_all
+        @logger.info("Creating deployment for the first instance (#{instance_ids[0]})...")
+        create_deployment(command, stack, app, [instance_ids[0]]) unless dryrun
+
+        rest = instance_ids[1..-1]
+        if !rest.empty?
+          @logger.info("Creating deployment for the other #{rest.size} instances...")
+          create_deployment(command, stack, app, rest) unless dryrun
+        else
+          @logger.info('No other instances exist.')
+        end
+      else
+        raise "Unknown running mode: #{mode}"
+      end
+    end
+
+    private def create_deployment(command, stack, app, instance_ids)
+      res = @opsworks.create_deployment(
+        stack_id: stack.stack_id,
+        app_id: app.app_id,
+        instance_ids: instance_ids,
+        command: { name: command, args: {} },
+      )
+
+      @logger.info("Waiting deployment #{res.deployment_id}...")
+      @opsworks.wait_until(:deployment_successful, {
+        deployment_ids: [res.deployment_id],
+      })
+
+      nil
+    end
+  end
+end

data/lib/opsup/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Opsup
+  VERSION = '0.0.1'
+end

metadata

@@ -0,0 +1,83 @@
+--- !ruby/object:Gem::Specification
+name: opsup
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- ryym
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-07-12 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-opsworks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.71'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.71'
+description: 
+email:
+- ryym.64@gmail.com
+executables:
+- opsup
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- bin/opsup
+- lib/opsup.rb
+- lib/opsup/app.rb
+- lib/opsup/cli.rb
+- lib/opsup/config.rb
+- lib/opsup/error.rb
+- lib/opsup/logger.rb
+- lib/opsup/stack_operator.rb
+- lib/opsup/version.rb
+homepage: https://github.com/ryym/opsup
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: CLI to run commands for AWS OpsWorks
+test_files: []