ridoku 0.1.0

data/lib/ridoku/config_wizard.rb

@@ -0,0 +1,195 @@
+
+
+module Ridoku
+  class ConfigWizard
+    attr_accessor :fields
+
+    def initialize
+      self.fields = {
+        service_role_arn: :arn_string,
+        instance_profile_arn: :arn_string,
+        ssh_key: :path
+      }
+    end
+
+    def run
+      $stdout.puts $stdout.colorize(ConfigWizard.help_text, :bold)
+
+      $stdout.puts "Do you wish to run the wizard now? [#{$stdout.colorize('Y', :bold)}|n]"
+      res = $stdin.gets
+      if res.match(%r(^[Nn]))
+        Base.config[:local_init] = true
+        Base.save_config(::RUNCOM)
+        exit 1
+      end
+
+      sra_info = <<-EOF
+    Service Role ARN is used to access OpsWorks and issue commands on your
+    behalf.  No suitable role was found.
+
+    Please enter the appropriate Role used to issue commands on OpsWorks.
+    Leave the field blank to attempt to generate one or to refresh from account
+    credentials. 's' or 'skip' if you wish to use existing values.
+
+    #{$stdout.colorize('Current Service ARN:', [:white, :bold])} #{$stdout.colorize(Base.config[:service_arn], :green)}
+    EOF
+      inst_info = <<-EOF
+    Instance Profile ARN is used to for each instance created for OpsWorks.
+
+    Please enter the appropriate default Role used for instance profiles.
+    Leave the field blank to attempt to generate one or to refresh from account
+    credentials. 's' or 'skip' if you wish to use existing values.
+
+    #{$stdout.colorize('Current Instance ARN:', [:white, :bold])} #{$stdout.colorize(Base.config[:instance_arn], :green)}
+    EOF
+      info = {
+        service_role_arn: sra_info,
+        instance_profile_arn: inst_info
+      }
+
+      ConfigWizard.fetch_input(Base.config, fields, info)
+
+      case Base.config[:service_role_arn]
+      when ''
+        Base.config.delete(:service_arn)
+        Base.configure_service_roles
+      when 's', 'skip'
+      else
+        Base.config[:service_arn] = Base.config[:service_role_arn]
+      end
+
+      case Base.config[:instance_profile_arn]
+      when ''
+        Base.config.delete(:instance_arn)
+        Base.configure_instance_roles
+      when 's', 'skip'
+      else
+        Base.config[:instance_arn] = Base.config[:instance_profile_arn]
+      end
+
+      Base.config[:local_init] = true
+      Base.save_config(::RUNCOM)
+
+      $stdout.puts 'Updating required Security Groups'
+      Base.update_pg_security_groups_in_all_regions
+
+      $stdout.puts 'Configuration complete.'
+      exit 0
+    end
+    protected
+
+    class << self
+
+      def help_text
+        help = <<-EOF
+Configuration Wizard:
+
+In order to get ridoku configured with your OpsWorks account, Ridoku must 
+collect pertinent required info. The wizard can be run at any time after the
+first with the command line option of `--wizard`.
+
+Values to be configured:
+  ssh_key: 
+    Path to the SSH key to be used for git repositories
+    (cook books, apps, etc).  It is recommended that this be generated
+    separately from your personal SSH keys so that they can be revoked
+    effecting other logins.
+
+  service_role_arn:
+    If a valid service_role_arn cannot be found, Ridoku will attempt to
+    generate one for you.  If you've already used OpsWorks, Ridoku should be
+    able to find the necessary Roles for you.
+
+  instance_role_arn:
+    If a valid instance_role_arn cannot be found, Ridoku will attempt to
+    generate one for you.  If you've already used OpsWorks, Ridoku should be
+    able to find the necessary Roles for you.
+        EOF
+      end
+
+      def fetch_input(output, required = {}, info = {})
+        info ||= {}
+        info.merge!({
+          ssh_key: <<-EOF
+    Key files (such as SSH keys) should be provided by file path.  In the case of
+    GIT repository SSH keys (custom cookbooks, application respository), these 
+    should be to the private keys.  I recommend generating keys specifically for 
+    each use, so that the keys can be easily tracked and removed if necessary,
+    without requiring you replace your keys on every machine you access.
+    Enter 's' or 'skip' if you wish to keep the currently configured value.
+    EOF
+        })
+
+        recurse_required(required, output, info)
+      end
+
+      protected
+
+      # Recurse through required hash to collected all necessary information.
+      def recurse_required(req, user, info, buffer = '')
+        req.each do |k,v|
+          if v.is_a?(Hash)
+            buffer += info_for(k, info)
+            buffer += "In #{$stdout.colorize(k, :bold)}:"
+            recurse_required(v, user[k] ||= {}, info, buffer)
+            buffer = ''
+          else
+            next if user[k]
+            $stdout.puts '-'*80
+            $stdout.puts buffer if buffer.length > 0
+            info_block = info_for(k, info)
+            $stdout.puts info_block if info_block.length > 0
+            $stdout.puts "For #{$stdout.colorize(k, :bold)} (#{$stdout.colorize(v, :red)}):"
+            get_response(user, k, v)
+          end
+        end
+      end
+
+      # Handle getting the response from the user and validating input.
+      def get_response(user, key, value)
+        done = false
+        while !done
+          begin
+            val = validate_response(key, value, $stdin.gets.chomp)
+            user[key] = val unless val == :skip
+            done = true
+          rescue ArgumentError => e
+            $stdout.puts e.to_s
+            $stdout.puts 'Retry?'
+            res = $stdin.gets
+            done = (res.match(/^(Y|y)/) == nil)
+          end
+        end
+      end
+
+      # Validate input is as expected.
+      def validate_response(key, expect, value)
+        return :skip if value.match(%r(s|skip))
+
+        case key
+        when :ssh_key
+          value.gsub!(%r(^~), ENV['HOME']) if value.match(%r(^~))
+
+          fail ArgumentError.new('Invalid input provided.') unless
+            File.exists?(value) || value == ''
+        end
+
+        case expect
+        when :arn_string
+          fail ArgumentError.new('Invalid ARN provided.') unless
+            value.match(/^.*:.*:.*:.*:([0-9]+):.*$||/)
+        when :array
+          value = value.split(%r([^\\](:|\|)))
+        end
+
+        value
+      end
+
+      # Print warning info associated with a particular attributes.
+      def info_for(key, info)
+        return $stdout.colorize(info[key], :bold) if info.key?(key)
+        ''
+      end
+    end
+  end
+end

data/lib/ridoku/cook.rb

@@ -0,0 +1,103 @@
+#
+# Command: cook
+#
+
+require 'rugged'
+require 'ridoku/base'
+
+module Ridoku
+  register :cook
+
+  class Cook < Base
+
+    def run      
+      command = Base.config[:command]
+      sub_command = (command.length > 0 && command[1]) || nil
+
+      Base.fetch_stack
+
+      case sub_command
+      # when 'list', nil
+      #   list
+      when 'update'
+        update
+      when 'run'
+        cook
+      else
+        print_cook_help
+      end
+    end
+
+    protected
+
+    def list
+      update unless File.exists?(cookbook_path)
+    end
+
+    def update
+      $stdout.puts "Updating custom cookbooks..."
+
+      Base.run_command(Base.update_cookbooks(Base.extract_instance_ids))
+    end
+
+    class << self
+      def valid_recipe_format?(recipes)
+        return false if recipes.length == 0
+
+        recipe = %r(^[a-zA-Z0-9_\-]+(::[a-zA-Z0-9_\-]+){0,1}$)
+        recipes.each do |cr|
+          return false unless cr.match(recipe)
+        end
+
+        true
+      end
+
+      def cook_recipe(recipes, custom_json = nil)
+        cook_recipe_on_layers(recipes, nil, custom_json)
+      end
+
+      def cook_recipe_on_layers(recipes, layers, custom_json = nil) 
+        Base.fetch_app()
+
+        recipes = [recipes] unless recipes.is_a?(Array)
+
+        unless valid_recipe_format?(recipes)
+          $stderr.puts 'Invalid recipes provided.'
+          print_cook_help
+          exit 1
+        end
+
+        instance_ids = Base.extract_instance_ids(layers)
+
+        if instance_ids.length == 0
+          $stderr.puts 'No valid instances available.'
+          exit 1
+        end
+
+        $stdout.puts "Running recipes:"
+        recipes.each do |arg|
+          $stdout.puts "  #{$stdout.colorize(arg, :green)}"
+        end
+
+        command = Base.execute_recipes(Base.app[:app_id], instance_ids,
+          Base.config[:comment], recipes, custom_json)
+
+        Base.run_command(command)
+      end
+    end
+
+    def cook
+      Ridoku::Cook.cook_recipe(ARGV)
+    end
+
+    def print_cook_help
+      $stderr.puts <<-EOF
+  Command: cook
+
+  List/Modify the current app's associated domains.
+    cook:run      run a specific or set of 'cookbook::recipe'
+    cook:update   update the specified instance 'cookboooks'
+  EOF
+    end
+  end
+end

data/lib/ridoku/create.rb

@@ -0,0 +1,101 @@
+#
+#
+
+require 'ridoku/base'
+
+module Ridoku
+  register :create
+
+  class Create < Base
+
+    def run
+      command = Base.config[:command]
+      sub_command = (command.length > 0 && command[1]) || nil
+      type = (command.length > 1 && command[2]) || nil
+
+      case sub_command
+      when 'app'
+        app(type || 'rails')
+      else
+        print_create_help
+      end
+    end
+
+    protected
+
+    def configure_from_cwd(opt)
+      return unless File.exists?('.git')
+
+      `git remote -v | grep fetch`.match(%r(origin\s*(git@[^\s]*).*)) do |m|
+        opt[:type] = 'git'
+        opt[:url] = m[1]
+        $stdout.puts "Setting Git Application Source from environment:"
+        $stdout.puts "Url: #{$stdout.colorize(m[1], :green)}"
+      end
+    end
+
+    def print_create_help
+      $stderr.puts <<-EOF
+Command: create
+
+List/Modify the current layer's package dependencies.
+  create                      show this help
+  create:app[:rails] <name>   create a new app on the --stack
+
+Currently, if the stack does not exist for a particular app type, you
+will have to create it manually.
+  EOF
+    end
+
+    def app(type)
+      Base.fetch_stack
+      Base.fetch_app
+
+      unless ARGV.length > 0
+        $stderr.puts $stderr.colorize('App name not specified', :red)
+        print_create_help
+        exit 1
+      end
+
+      existing = Base.app_list.select do |app|
+        app[:name] == ARGV[0]
+      end
+
+      if existing.length > 0
+        $stderr.puts $stderr.colorize("App #{ARGV[0]} already exists", :red)
+        print_create_help
+        exit 1
+      end
+
+      config = {
+          type: type,
+          name: ARGV[0],
+          shortname: ARGV[0].downcase.gsub(%r([^a-z0-9]), '-')
+      }
+
+      config.tap do |opt| 
+          opt[:domains] = Base.config[:domains] if Base.config.key?(:domains)
+          opt[:app_source] = {}.tap do |as|
+            configure_from_cwd(as)
+            as[:ssh_key] = Base.config[:ssh_key] if Base.config.key?(:ssh_key)
+          end
+          opt[:attributes] = {}.tap do |atr|
+            atr[:rails_env] = Base.config[:rails_env] if Base.config.key?(:rails_env)
+          end
+      end
+
+      appconfig = RailsDefaults.new.defaults_with_wizard(:app, config)
+
+      begin
+        Base.create_app(appconfig)
+      rescue ::ArgumentError => e
+        $stderr.puts e.to_s
+      end
+    end
+
+    def instance
+      $stderr.puts 'Create instance not yet implemented.'
+      $stderr.puts 'Create an instance for a given layer using OpsWorks Dashboard.'
+    end
+  end
+end

data/lib/ridoku/cron.rb

@@ -0,0 +1,227 @@
+# encoding: utf-8
+
+#
+# Command: cron
+#
+
+# [:day, :hour, :minute, :month, :weekday, :path, :type, :action]
+
+require 'ridoku/base'
+
+module Ridoku
+  register :cron
+
+  class Cron < Base
+    attr_accessor :cron
+
+    def run
+      command = Base.config[:command]
+      sub_command = (command.length > 0 && command[1]) || nil
+
+      load_environment
+
+      case sub_command
+      when 'list', nil
+        list
+      when 'set', 'add', 'update'
+        add
+      when 'delete'
+        delete
+      when 'remove'
+        remove
+      else
+        print_cron_help
+      end
+    end
+
+    protected
+
+    def load_environment
+      Base.fetch_stack
+      Base.fetch_instance('workers')
+
+      @default_instance = Base.instances.first[:hostname]
+      self.cron = (Base.custom_json['deploy'][Base.config[:app].downcase]['cron'] ||= {})
+    end
+
+    def print_cron_help
+      $stderr.puts <<-EOF
+Command: cron
+
+List/Modify the current app's associated cron.
+  cron[:list]   lists the cron jobs associated with an application.
+  cron:add      cron job, e.g., runner:scripts/runme.rb hour:0 minute:0
+  cron:delete   delete this specific cron job
+  cron:remove   removes a cron from the list (run after a delete and push)
+  cron:push     update running cron jobs
+
+Columns             Value (default: *)    Label
+  M   Minute        0-59                  minute
+  H   Hour          0-23                  hour
+  DM  Day of Month  0-30                  day_of_month
+  MO  Month         0-11                  month
+  DW  Day of Week   0-6                   day_of_week
+
+All cron jobs are run on the Workers layer or the AssetMaster on the
+Rails Application layer if one is not set, unless otherwise specified.
+
+Example 'cron:list' output:
+Type     Scripts                M    H    DM   MO   DW
+runner   scripts/runme.rb       0    0    *    *    *
+
+The above list output indicates a DelayedJob cron and two separate
+delayed_job processes.  One processing 'mail'; the other processing 'sms'.
+
+examples:
+  $ cron
+  No cron specified!
+  $ cron:add type:runner path:scripts/runme.rb hour:0 minute:0
+  $ cron:add type:runner path:scripts/runme_also.rb minute:*/5 instance:mukujara
+  $ cron:list
+  Type     Scripts                M    H    DM   MO   DW  Instance
+  runner   scripts/runme.rb       0    0    *    *    *   oiwa
+  runner   scripts/runme_also.rb  */5  *    *    *    *   mukujara
+  $ cron:delete scrips/runme_also.rb
+  Type     Scripts                M    H    DM   MO   DW
+  runner   scripts/runme.rb       0    0    *    *    *   oiwa
+  delete   scripts/runme_also.rb  -    -    -    -    -   mukujara
+EOF
+    end
+
+    def list
+      if cron.length == 0
+        $stdout.puts 'No cron jobs specified!'
+      else
+
+        columns = {
+          type: 'Type',
+          path: 'Scripts',
+          minute: 'M',
+          hour: 'H',
+          day_of_month: 'DM',
+          month: 'MO',
+          day_of_week: 'DW',
+          instance: 'Instance'
+        }
+
+        offset = {}
+
+        self.cron.each do |cr|
+          columns.keys.each do |key|
+            skey = key.to_s
+            cr[skey] = '*' unless cr.key?(skey)
+            val = cr[skey].length
+            offset[key] = val if cr.key?(skey) && val > (offset[key] || 0)
+          end
+        end
+
+        columns.keys.each do |key|
+          offset[key] = columns[key].length if
+            columns[key].length > (offset[key] || 0)
+        end
+
+        $stdout.puts $stdout.colorize(line(offset, columns), :bold)
+        self.cron.each { |cr| $stdout.puts line(offset, cr, columns.keys) }
+      end
+    rescue =>e
+      puts e.backtrace
+      puts e
+    end
+
+    def add
+
+      croninfo = {}
+      cronindex = nil
+
+      ARGV.each do |cron|
+        info = cron.split(':',2)
+        croninfo[info[0].to_s] = info[1]
+        cronindex = get_path_index(info[1]) if info[0] == 'path'
+      end
+
+      croninfo['instance'] = @default_instance unless croninfo.key?('instance')
+
+      if cronindex.nil?
+        self.cron << croninfo
+      else
+        self.cron[cronindex] = croninfo
+      end
+
+      list
+      Base.save_stack
+    end
+
+    def delete
+      return print_cron_help unless ARGV.length > 0
+      cronindex = get_path_index(ARGV.first)
+
+      if cronindex.nil?
+        $stdout.puts $stdout.colorize(
+          'Unable to find the specified script path in the cron list.', :red)
+        return list
+      end
+
+      cr = self.cron[cronindex]
+      cr['type'] = 'delete'
+      cr['minute'] = '-'
+      cr['hour'] = '-'
+      cr['day_of_month'] = '-'
+      cr['month'] = '-'
+      cr['day_of_week'] = '-'
+      
+      list
+      Base.save_stack
+    end
+
+    def remove
+      return print_cron_help unless ARGV.length > 0
+      cronindex = get_path_index(ARGV.first)
+
+      if cronindex.nil?
+        $stdout.puts $stdout.colorize(
+          'Unable to find the specified script path in the cron list.', :red)
+        return list
+      end
+
+      self.cron.delete_at(cronindex)
+
+      list
+      Base.save_stack
+    end
+
+    protected
+
+    def get_path_index(path)
+      cron.each_with_index do |cr, idx|
+        return idx if cr['path'] == path
+      end
+
+      return nil
+    end
+
+    def line(offset, columns, keys = nil)
+      keys ||= columns.keys
+      output = ''
+
+      keys.each do |key|
+        skey = key.to_s
+        content = columns[key] || columns[skey]
+        if skey == 'type'
+          case content
+          when 'delete'
+            output += $stdout.colorize(content, :red)
+          when 'runner'
+            output += $stdout.colorize(content, :green)
+          else
+            output += $stdout.colorize(content, :yellow)
+          end
+        else
+          output += content
+        end
+        output += ' '*(offset[key] - content.length + 2)
+      end
+
+      output
+    end
+  end
+end