opsup 0.0.2 → 0.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0698811d56d95cb68cd1e4bc1575bacaff650c46ed2e22e4ccb84a5d2196a769'
-  data.tar.gz: 4e65ac9d6515e35a4c5f71ed72bacda9bb17c7b188b3dd0412a76344bc4403bc
+  metadata.gz: 8030ca85d3e6f53108fdda9754e8aca25918716218f0bb72d0bb3c48dcbbeb8b
+  data.tar.gz: 62a00a6858cb1cb044d0f4f78d7f1fc28f1915819253c28aab6306d4e0026b42
 SHA512:
-  metadata.gz: 6453421cf1c5ef732f00e21c243eb8f324ca8e486564663166fa5a892402ec041cecf1b7f160bc3e207da5c4d64267fa6d3232d7012e8020b008f6a8eb8ec2a7
-  data.tar.gz: 76af537846ec040151228949946efdd8e3b5c93dff6dee1eedaa127d01a5e8919a8ca45c2aaa62b4f27939a157313afc7be23b37348e41d1b42990dbec939cea
+  metadata.gz: 7566237b3ed9fea0b6458f2691632e4ebea7739f128c0cdade3d726a218a86dbebe34d69cc5c224ea20de781599d1c6bfc03565cc22ba6f7f39cf204db4d1abb
+  data.tar.gz: 11cf8034044990549f00d1153983366c0c9dd67acc98b7814480e64e71fa51bff54a9fe474165e59eb20bc47a61dc2cda4be0192ecb3abe258f51c5baa1fad5d

data/README.md

@@ -16,6 +16,7 @@ gem install opsup
 
 Currently Opsup can run these commands:
 
+- `upload_cookbooks` (to S3)
 - `update_cookbooks`
 - `setup`
 - `configure`
@@ -31,7 +32,6 @@ 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/lib/opsup.rb

@@ -2,12 +2,15 @@
 # frozen_string_literal: true
 
 require 'sorbet-runtime'
+require 'aws-sdk-opsworks'
+require 'aws-sdk-s3'
 
 require_relative 'opsup/version'
 require_relative 'opsup/error'
 require_relative 'opsup/config'
 require_relative 'opsup/logger'
 require_relative 'opsup/stack_operator'
+require_relative 'opsup/cookbook_uploader'
 require_relative 'opsup/app'
 require_relative 'opsup/cli'
 

data/lib/opsup/app.rb

@@ -1,17 +1,13 @@
 # typed: strict
 # frozen_string_literal: true
 
-require 'aws-sdk-opsworks'
-
 module Opsup
   class App
     extend T::Sig
 
     sig { returns(Opsup::App) }
     def self.create
-      new(
-        logger: Opsup::Logger.instance,
-      )
+      new(logger: Opsup::Logger.instance)
     end
 
     sig { params(logger: ::Logger).void }
@@ -21,6 +17,7 @@ module Opsup
 
     AVAILABLE_COMMANDS = T.let(
       %w[
+        upload_cookbooks
         update_cookbooks
         setup
         configure
@@ -41,15 +38,20 @@ module Opsup
       @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,
+      deployer = stack_operator.new_deployer(
         stack_name: config.stack_name,
         mode: config.running_mode,
         dryrun: config.dryrun,
       )
+
+      commands.each do |command|
+        if command == 'upload_cookbooks'
+          upload_cookbooks(config)
+          next
+        end
+        deployer.run_command(command_to_opsworks_command(command))
+      end
     ensure
       @logger.warn('Finished in DRYRUN MODE') if config.dryrun
     end
@@ -73,5 +75,32 @@ module Opsup
     private def command_to_opsworks_command(command)
       command == 'update_cookbooks' ? 'update_custom_cookbooks' : command
     end
+
+    sig { params(config: Opsup::Config).void }
+    def upload_cookbooks(config)
+      if config.cookbook_url.nil?
+        raise Opsup::Error, 'cookbook URL is required to run upload_cookbooks'
+      end
+      if config.s3_bucket_name.nil?
+        raise Opsup::Error, 'S3 Bucket name is required to run upload_cookbooks'
+      end
+
+      s3_object_config = CookbookUploader::S3ObjectConfig.new(
+        bucket_name: T.must(config.s3_bucket_name),
+        key: "cookbook_#{config.stack_name}.tar.gz",
+      )
+
+      cookbook_uploader = CookbookUploader.create(s3: new_s3_client(config), config: config)
+      cookbook_uploader.build_and_upload(
+        cookbook_url: T.must(config.cookbook_url),
+        s3_object_config: s3_object_config,
+      )
+    end
+
+    sig { params(config: Opsup::Config).returns(Aws::S3::Client) }
+    private def new_s3_client(config)
+      creds = Aws::Credentials.new(config.aws_access_key_id, config.aws_secret_access_key)
+      Aws::S3::Client.new(region: config.s3_region, credentials: creds)
+    end
   end
 end

data/lib/opsup/cli.rb

@@ -2,6 +2,7 @@
 # frozen_string_literal: true
 
 require 'optparse'
+require_relative 'cli/option_builder'
 
 module Opsup
   class CLI
@@ -12,13 +13,21 @@ module Opsup
       new(
         app: Opsup::App.create,
         option_builder: Opsup::CLI::OptionBuilder.create,
+        env_vars: ENV.to_h,
       )
     end
 
-    sig { params(app: Opsup::App, option_builder: Opsup::CLI::OptionBuilder).void }
-    def initialize(app:, option_builder:)
+    sig do
+      params(
+        app: Opsup::App,
+        option_builder: Opsup::CLI::OptionBuilder,
+        env_vars: T::Hash[String, T.nilable(String)],
+      ).void
+    end
+    def initialize(app:, option_builder:, env_vars:)
       @app = T.let(app, Opsup::App)
       @option_builder = T.let(option_builder, Opsup::CLI::OptionBuilder)
+      @env_vars = T.let(env_vars, T::Hash[String, T.nilable(String)])
     end
 
     sig { params(argv: T::Array[String]).returns(T::Boolean) }
@@ -26,7 +35,7 @@ module Opsup
       parser = create_parser
       @option_builder.define_options(parser)
 
-      options = {}
+      options = @option_builder.options_from_env_vars(@env_vars)
       begin
         # It automatically exits with a help message if necessary.
         commands = parser.parse(argv, into: options)
@@ -64,51 +73,5 @@ module Opsup
         BANNER
       end
     end
-
-    class OptionBuilder
-      extend T::Sig
-
-      sig { returns(Opsup::CLI::OptionBuilder) }
-      def self.create
-        new
-      end
-
-      DEFAULT_OPSWORKS_REGION = 'ap-northeast-1'
-
-      sig { params(parser: OptionParser).returns(OptionParser) }
-      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
-
-      sig { params(options: T::Hash[Symbol, T.untyped]).returns(Opsup::Config) }
-      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/cli/option_builder.rb

@@ -0,0 +1,77 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Opsup
+  class CLI
+    class OptionBuilder
+      extend T::Sig
+
+      sig { returns(Opsup::CLI::OptionBuilder) }
+      def self.create
+        new
+      end
+
+      DEFAULT_AWS_REGION = 'ap-northeast-1'
+
+      sig { params(parser: OptionParser).returns(OptionParser) }
+      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_AWS_REGION}")
+          p.on('--cookbook-url URL', 'URL of cookbook to upload')
+          p.on('--s3-bucket NAME', 'S3 bucket name for cookbooks')
+          p.on('-d', '--dryrun')
+        end
+      end
+
+      sig do
+        params(
+          env_vars: T::Hash[String, T.nilable(String)],
+        ).returns(T::Hash[Symbol, T.untyped])
+      end
+      def options_from_env_vars(env_vars)
+        [
+          %w[stack STACK],
+          %w[mode MODE],
+          %w[aws-cred AWS_CRED],
+          %w[opsworks-region OPSWORKS_REGION],
+          %w[cookbook-url COOKBOOK_URL],
+          %w[s3-bucket S3_BUCKET],
+          %w[dryrun DRYRUN],
+        ].each_with_object({}) do |(key, env_key), obj|
+          value = env_vars["OPSUP_#{env_key}"]
+          obj[key.to_sym] = value if value
+        end
+      end
+
+      sig { params(options: T::Hash[Symbol, T.untyped]).returns(Opsup::Config) }
+      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_AWS_REGION,
+          cookbook_url: options[:"cookbook-url"],
+          s3_bucket_name: options[:"s3-bucket"],
+          s3_region: options[:"s3-region"] || DEFAULT_AWS_REGION,
+          running_mode: mode,
+          dryrun: options[:dryrun] || false,
+        )
+      end
+    end
+  end
+end

data/lib/opsup/config.rb

@@ -17,6 +17,15 @@ module Opsup
     sig { returns(String) }
     attr_reader :opsworks_region
 
+    sig { returns(T.nilable(String)) }
+    attr_reader :cookbook_url
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :s3_bucket_name
+
+    sig { returns(T.nilable(String)) }
+    attr_reader :s3_region
+
     sig { returns(Symbol) }
     attr_reader :running_mode
 
@@ -31,6 +40,9 @@ module Opsup
         aws_access_key_id: String,
         aws_secret_access_key: String,
         opsworks_region: String,
+        cookbook_url: T.nilable(String),
+        s3_bucket_name: T.nilable(String),
+        s3_region: T.nilable(String),
         running_mode: T.nilable(Symbol),
         dryrun: T::Boolean,
       ).void
@@ -40,6 +52,9 @@ module Opsup
       aws_access_key_id:,
       aws_secret_access_key:,
       opsworks_region:,
+      cookbook_url:,
+      s3_bucket_name: nil,
+      s3_region: nil,
       running_mode: nil,
       dryrun: false
     )
@@ -47,6 +62,9 @@ module Opsup
       @aws_access_key_id = T.let(aws_access_key_id, String)
       @aws_secret_access_key = T.let(aws_secret_access_key, String)
       @opsworks_region = T.let(opsworks_region, String)
+      @cookbook_url = T.let(cookbook_url, T.nilable(String))
+      @s3_bucket_name = T.let(s3_bucket_name, T.nilable(String))
+      @s3_region = T.let(s3_region, T.nilable(String))
       @running_mode = T.let(running_mode || MODES.fetch(0), Symbol)
       @dryrun = T.let(dryrun, T::Boolean)
     end
@@ -58,6 +76,9 @@ module Opsup
         aws_access_key_id: aws_access_key_id,
         aws_secret_access_key: aws_secret_access_key,
         opsworks_region: opsworks_region,
+        cookbook_url: cookbook_url,
+        s3_bucket_name: s3_bucket_name,
+        s3_region: s3_region,
         running_mode: running_mode,
         dryrun: dryrun,
       }

data/lib/opsup/cookbook_uploader.rb

@@ -0,0 +1,80 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Opsup
+  class CookbookUploader
+    extend T::Sig
+
+    class S3ObjectConfig < T::Struct
+      const :bucket_name, String
+      const :key, String
+    end
+
+    sig do
+      params(
+        s3: Aws::S3::Client,
+        config: Opsup::Config,
+      ).returns(Opsup::CookbookUploader)
+    end
+    def self.create(s3:, config:)
+      new(s3: s3, config: config, logger: Opsup::Logger.instance)
+    end
+
+    sig do
+      params(
+        s3: Aws::S3::Client,
+        config: Opsup::Config,
+        logger: ::Logger,
+      ).void
+    end
+    def initialize(s3:, config:, logger:)
+      @s3 = T.let(s3, Aws::S3::Client)
+      @config = T.let(config, Opsup::Config)
+      @logger = T.let(logger, ::Logger)
+    end
+
+    sig { params(cookbook_url: String, s3_object_config: S3ObjectConfig).void }
+    def build_and_upload(cookbook_url:, s3_object_config:)
+      Dir.mktmpdir do |work_dir|
+        clone(work_dir, cookbook_url)
+        package_path = build(work_dir)
+        upload(package_path, s3_object_config)
+      end
+    end
+
+    sig { params(cmd: String).void }
+    private def system(cmd)
+      if @config.dryrun
+        @logger.info("(dryrun) #{cmd}")
+      else
+        super(cmd)
+      end
+    end
+
+    sig { params(dir: String, url: String).void }
+    private def clone(dir, url)
+      system("git clone --depth=1 #{url} #{dir}")
+    end
+
+    sig { params(dir: String).returns(String) }
+    private def build(dir)
+      Dir.chdir(dir) do
+        system('bundle')
+        system('bundle exec berks package built.tar.gz')
+      end
+      "#{dir}/built.tar.gz"
+    end
+
+    sig { params(package_path: String, object_config: S3ObjectConfig).void }
+    private def upload(package_path, object_config)
+      unless @config.dryrun
+        @s3.put_object(
+          bucket: object_config.bucket_name,
+          body: File.open(package_path),
+          key: object_config.key,
+        )
+      end
+      @logger.info("cookbook #{object_config.key} uploaded")
+    end
+  end
+end

data/lib/opsup/stack_operator.rb

@@ -1,6 +1,8 @@
 # typed: strict
 # frozen_string_literal: true
 
+require_relative 'stack_operator/command_deployer'
+
 module Opsup
   class StackOperator
     extend T::Sig
@@ -21,13 +23,12 @@ module Opsup
 
     sig do
       params(
-        commands: T::Array[String],
         stack_name: String,
         mode: Symbol,
         dryrun: T::Boolean,
-      ).void
+      ).returns(StackOperator::CommandDeployer)
     end
-    def run_commands(commands, stack_name:, mode:, dryrun: false)
+    def new_deployer(stack_name:, mode:, dryrun: false)
       # Find the target stack.
       @logger.debug('Verifying the specified stack exists...')
       stacks = @opsworks.describe_stacks.stacks
@@ -50,82 +51,19 @@ module Opsup
         "#{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
-
-    sig do
-      params(
-        command: String,
-        dryrun: T::Boolean,
-        mode: Symbol,
-        stack: Aws::OpsWorks::Types::Stack,
-        app: Aws::OpsWorks::Types::App,
-        instance_ids: T::Array[String],
-      ).void
-    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, [T.must(instance_ids[0])]) unless dryrun
-
-        rest = T.must(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
-
-    sig do
-      params(
-        command: String,
-        stack: Aws::OpsWorks::Types::Stack,
-        app: Aws::OpsWorks::Types::App,
-        instance_ids: T::Array[String],
-      ).void
-    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: {} },
+      config = StackOperator::CommandDeployer::Config.new(
+        stack: stack,
+        mode: mode,
+        # Currently Opsup deploys only the first app by default.
+        app: apps.first,
+        instance_ids: instances.map(&:instance_id),
+        dryrun: dryrun,
+      )
+      StackOperator::CommandDeployer.create(
+        config: config,
+        opsworks: @opsworks,
+        logger: @logger,
       )
-
-      @logger.info("Waiting deployment #{res.deployment_id}...")
-      @opsworks.wait_until(:deployment_successful, {
-        deployment_ids: [res.deployment_id],
-      })
-
-      nil
     end
   end
 end

data/lib/opsup/stack_operator/command_deployer.rb

@@ -0,0 +1,97 @@
+# typed: strict
+# frozen_string_literal: true
+
+module Opsup
+  class StackOperator
+    class CommandDeployer
+      extend T::Sig
+
+      class Config < T::Struct
+        const :stack, Aws::OpsWorks::Types::Stack
+        const :mode, Symbol
+        const :app, Aws::OpsWorks::Types::App
+        const :instance_ids, T::Array[String]
+        const :dryrun, T::Boolean
+      end
+
+      sig do
+        params(
+          config: Config,
+          opsworks: Aws::OpsWorks::Client,
+          logger: ::Logger,
+        ).returns(Opsup::StackOperator::CommandDeployer)
+      end
+      def self.create(config:, opsworks:, logger:)
+        new(config: config, opsworks: opsworks, logger: logger)
+      end
+
+      sig do
+        params(
+          config: Config,
+          opsworks: Aws::OpsWorks::Client,
+          logger: ::Logger,
+        ).void
+      end
+      def initialize(config:, opsworks:, logger:)
+        @config = T.let(config, Config)
+        @opsworks = T.let(opsworks, Aws::OpsWorks::Client)
+        @logger = T.let(logger, ::Logger)
+      end
+
+      sig { params(command: String).void }
+      def run_command(command)
+        mode = @config.mode
+        instance_ids = @config.instance_ids
+        dryrun = @config.dryrun
+
+        @logger.info("Running #{command} command in #{mode} mode...")
+
+        case mode
+        when :parallel
+          @logger.info("Creating single deployment for the #{instance_ids.size} instances...")
+          create_deployment(command, 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, [id]) unless dryrun
+          end
+        when :one_then_all
+          @logger.info("Creating deployment for the first instance (#{instance_ids[0]})...")
+          create_deployment(command, [T.must(instance_ids[0])]) unless dryrun
+
+          rest = T.must(instance_ids[1..-1])
+          if !rest.empty?
+            @logger.info("Creating deployment for the other #{rest.size} instances...")
+            create_deployment(command, rest) unless dryrun
+          else
+            @logger.info('No other instances exist.')
+          end
+        else
+          raise "Unknown running mode: #{mode}"
+        end
+      end
+
+      sig do
+        params(
+          command: String,
+          instance_ids: T::Array[String],
+        ).void
+      end
+      private def create_deployment(command, instance_ids)
+        res = @opsworks.create_deployment(
+          stack_id: @config.stack.stack_id,
+          app_id: @config.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
+end

data/lib/opsup/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Opsup
-  VERSION = '0.0.2'
+  VERSION = '0.0.3'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: opsup
 version: !ruby/object:Gem::Version
-  version: 0.0.2
+  version: 0.0.3
 platform: ruby
 authors:
 - ryym
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-25 00:00:00.000000000 Z
+date: 2019-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: aws-sdk-opsworks
@@ -24,6 +24,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: aws-sdk-s3
+  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
@@ -80,10 +94,13 @@ files:
 - lib/opsup.rb
 - lib/opsup/app.rb
 - lib/opsup/cli.rb
+- lib/opsup/cli/option_builder.rb
 - lib/opsup/config.rb
+- lib/opsup/cookbook_uploader.rb
 - lib/opsup/error.rb
 - lib/opsup/logger.rb
 - lib/opsup/stack_operator.rb
+- lib/opsup/stack_operator/command_deployer.rb
 - lib/opsup/version.rb
 homepage: https://github.com/ryym/opsup
 licenses: