gaptool-client 0.8.0.pre.alpha4 → 0.8.0.pre.alpha5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3528f94e83fb0e8209a053b24683729e830b61ef
-  data.tar.gz: 1f768dc1e8b37c94b289d00cce7e5935506adf13
+  metadata.gz: 0c7cf10926c2fbafec0a7d1a219d91563d0ef67c
+  data.tar.gz: b76e3252e52ff2d6ed3eeee06092c584fd97df5c
 SHA512:
-  metadata.gz: 55aaebc78a856cfd8b3d92789507855c3b394a04c3d66ce2d6c3ad1283a80a5b5ab73773747a502b01f28f661a1574d36d199affb7f59855301c3f964a9d5310
-  data.tar.gz: 63fbd7d33485fba03a7de11c19db639bf096cd6286ffa31085481fedeed1c62016ae616ad5da7ed2f2363455eaef24618163bc1ff215b51a672eae5a7f506886
+  metadata.gz: f66c772bbf3fc7f69473f10994421a2342840e7ea0da3a31c27974c845558cffcd525ffb58d8d6ae9a97f801476a3660b52eafdcac575c2142a9651bf6f04aea
+  data.tar.gz: a459d7f3e039c50962a3f098dde5d4e3703c2708edc9b643d81405ee30325be76b0c4e304c2ab18c8fe510ccb52230a796addc064471dc4af38191f7dab99e9b

data/VERSION

@@ -1 +1 @@
-0.8.0-alpha4
+0.8.0-alpha5

data/gaptool-client.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
 
   s.rubyforge_project = 'gaptool-client'
 
-  s.files         = Dir['lib/*'] + %w(LICENSE.TXT README.md VERSION Rakefile gaptool-client.gemspec)
+  s.files         = Dir['bin/*'] + Dir['lib/**/*'] + %w(LICENSE.TXT README.md VERSION Rakefile gaptool-client.gemspec)
   s.test_files    = Dir['test/*']
   s.executables = Dir['bin/*'].map {|x| x.sub(/^bin\//, '')}
   s.require_paths = ['lib']

data/lib/gaptool_client/api.rb

@@ -0,0 +1,37 @@
+require 'gaptool-api'
+
+module Gaptool
+  module API
+    def self.client
+      @client ||= GTAPI::GaptoolServer.new(
+        ENV['GT_USER'], ENV['GT_KEY'],
+        ENV['GT_URL'], ENV['GT_AWS_ZONE']
+      )
+    end
+
+    def self.query_nodes(opts)
+      instance = opts[:instance]
+      role = opts[:role]
+      environment = opts[:environment]
+      params = opts[:params]
+
+      if instance
+        puts Rainbow('Ignoring role and environment as instance is set').red \
+          if role || environment
+        [Gaptool::API.client.getonenode(instance)]
+      elsif role && environment
+        Gaptool::API.client.getenvroles(role, environment, params)
+      elsif role
+        Gaptool::API.client.getrolenodes(role, params)
+      elsif environment
+        Gaptool::API.client.getenvnodes(environment, params)
+      else
+        Gaptool::API.client.getallnodes(params)
+      end
+    end
+
+    def self.get_host(node)
+      "#{node['role']}-#{node['environment']}-#{node['instance']}"
+    end
+  end
+end

data/lib/gaptool_client/commands.rb

@@ -0,0 +1,404 @@
+# coding: utf-8
+# rubocop:disable Metrics/LineLength, Lint/Eval
+#
+require 'rainbow'
+require 'json'
+require 'clamp'
+require 'set'
+require 'gaptool_client/api'
+require 'gaptool_client/helpers'
+require 'gaptool_client/ssh'
+
+module Gaptool
+  class InitCommand < Clamp::Command
+    option ['-r', '--role'], 'ROLE', 'Resource name to initilize', required: true
+    option ['-e', '--environment'], 'ENVIRONMENT', 'Which environment, e.g. production', required: true
+    option ['-z', '--zone'], 'ZONE', 'AWS availability zone to put node in', default: 'us-west-2c'
+    option ['-t', '--type'], 'TYPE', 'Type of instance, e.g. m1.large', required: true
+    option ['-s', '--security-group'], 'SECURITY_GROUP', 'Security group name. Defaults to $role-$environment'
+    option ['-a', '--ami'], 'AMI_ID', 'Use a specific AMI for the instance (i.e. ami-xxxxxxx)'
+    option ['-C', '--chef-repo'], 'GITURL', 'git url for the chef repository'
+    option ['-b', '--chef-branch'], 'BRANCH', 'branch of the chef repository to use'
+    option(['-R', '--chef_runlist'], 'RECIPE|ROLE',
+           'override chef run_list. recipe[cb::recipe] or role[myrole]. Can be specified multiple times',
+           multivalued: true, attribute_name: 'chef_runlist')
+    option ['--no-terminate'], :flag, 'Add terminate protection'
+    def execute
+      no_terminate = no_terminate? ? true : nil
+      Gaptool::API.client.addnode(zone, type, role, environment, nil, security_group,
+                                  ami, chef_repo, chef_branch, chef_runlist,
+                                  no_terminate)
+    end
+  end
+
+  class TerminateCommand < Clamp::Command
+    option ['-i', '--instance'], 'INSTANCE', 'Instance ID, e.g. i-12345678', required: true
+    option ['-z', '--zone'], 'ZONE', 'AWS region of the node (deprecated/ignored)'
+    option ['-r', '--role'], 'ROLE', 'Resource name to initilize', required: true
+    option ['-e', '--environment'], 'ENVIRONMENT', 'Which environment, e.g. production', required: true
+
+    def execute
+      node = Gaptool::API.client.getonenode(instance)
+      nodes = [node]
+      Gaptool::Helpers.info(nodes, false, false)
+      zone = node['zone'][0..-2]
+      if node['environment'] != environment || node['role'] != role
+        puts Rainbow("'#{node['role']}-#{node['environment']}' do not match provided value (#{role}-#{environment})").red
+        exit 1
+      end
+      if node['terminate'] == 'false'
+        puts Rainbow('"terminate" command is disabled for this instance').red
+        exit 2
+      end
+      print Rainbow('Terminate instance? [type yes to confirm]: ').green
+      res = $stdin.gets.chomp
+      return 0 unless res.downcase == 'yes'
+      puts "Terminating instance #{node['role']}:#{node['environment']}:#{node['instance']} in region #{zone}"
+      begin
+        Gaptool::API.client.terminatenode(instance, zone)
+      rescue
+        puts Rainbow('Cannot terminate instance').red
+      end
+    end
+  end
+
+  class RuncmdCommand < Clamp::Command
+    option ['-r', '--role'], 'ROLE', 'Instance role'
+    option ['-e', '--environment'], 'ENVIRONMENT', 'Instance environment'
+    option ['-i', '--instance'], 'INSTANCE', 'Instance id (i-xxxxxxxx)'
+    option ['-s', '--serial'], :flag, 'Run command serially. Order of execution is unknown.'
+    option ['-x', '--exclude-hidden'], :flag, 'Exclude hidden hosts'
+    option ['-c', '--continue-on-errors'], :flag, 'Continue execution even if one or more hosts fail'
+    option ['-b', '--batch-size'], 'SIZE', "How many hosts to run in parallel (defaults to #{Gaptool::SSH::BATCH_SIZE})", default: Gaptool::SSH::BATCH_SIZE
+    parameter 'COMMAND ...', 'Command to run', attribute_name: :commands
+
+    def execute
+      params = exclude_hidden? ? {} : { hidden: true }
+      nodes = Gaptool::API.query_nodes(params.merge(instance: instance,
+                                                    role: role, environment: environment))
+      res = Gaptool::SSH.exec(nodes, [commands.join(' ')],
+                              serial: serial?, continue_on_errors: continue_on_errors?,
+                              batch_size: batch_size)
+      exit res
+    end
+  end
+
+  class SSHConfigCommand < Clamp::Command
+    option ['-r', '--remove'], :flag, 'Remove ssh configuration'
+
+    def execute
+      config, content = Gaptool::SSH.config
+
+      if remove?
+        data = ''
+      else
+        puts Rainbow('Getting nodes from API').green
+        data = [Gaptool::SSH::START_MARKER, '# to remove this block, run gt ssh-config --remove']
+        Gaptool::API.client.getallnodes(hidden: true).sort_by { |n| n['instance'] }.each do |node|
+          host = Gaptool::API.get_host(node)
+          puts " - #{Rainbow(host).blue}"
+          data << Gaptool::SSH.config_for(node)
+        end
+        data << Gaptool::SSH::STOP_MARKER
+        data = data.join("\n")
+      end
+
+      if Regexp.new(Gaptool::SSH::START_MARKER).match(content)
+        content.gsub!(/#{Gaptool::SSH::START_MARKER}.*?#{Gaptool::SSH::STOP_MARKER}/m, data)
+      elsif !remove?
+        content = content + "\n" + data
+      end
+      File.open(config, 'w') { |f| f.write(content) }
+    end
+  end
+
+  class SSHCommand < Clamp::Command
+    option ['-r', '--role'], 'ROLE', 'Instance role'
+    option ['-e', '--environment'], 'ENVIRONMENT', 'Instance environment'
+    option ['-i', '--instance'], 'INSTANCE', 'Instance id (i-xxxxxxxx)'
+    option ['-f', '--first'], :flag, 'Just connect to first available instance'
+    option ['-t', '--tmux'], :flag, 'No-op, DEPRECATED'
+
+    def execute
+      puts Rainbow('tmux support has been removed').yellow if tmux?
+      nodes = Gaptool::API.query_nodes(hidden: true,
+                                       instance: instance,
+                                       environment: environment,
+                                       role: role)
+
+      if first? || (nodes.length == 1 && !instance)
+        puts Rainbow('No instance specified, but only one instance in cluster or first forced').green
+        node = nodes.first
+      elsif !instance
+        nodes.each_index do |i|
+          puts "#{i}: #{nodes[i]['instance']}"
+        end
+        print Rainbow('Select a node: ').cyan
+        node = nodes[$stdin.gets.chomp.to_i]
+        error 'Invalid selection' if node.nil?
+      else
+        node = nodes.first
+      end
+      Gaptool::SSH.update_config_for(node)
+      system "ssh #{node['instance']}"
+    end
+  end
+
+  class InfoCommand < Clamp::Command
+    option ['-r', '--role'], 'ROLE', 'Role name, e.g. frontend'
+    option ['-e', '--environment'], 'ENVIRONMENT', 'Which environment, e.g. production'
+    option ['-i', '--instance'], 'INSTANCE', 'Node instance, leave blank to query avilable nodes'
+    option ['-s', '--short'], :flag, 'Only show summary for hosts'
+    option ['-p', '--parseable'], :flag, 'Display in non-pretty parseable JSON'
+    option ['-g', '--grepable'], :flag, 'Display in non-pretty grep-friendly text'
+    option ['-H', '--hidden'], :flag, 'Display hidden hosts'
+
+    def execute
+      params = hidden? ? { hidden: true } : {}
+      nodes = Gaptool::API.query_nodes(params.merge(instance: instance,
+                                                    role: role,
+                                                    environment: environment))
+      Gaptool::Helpers.info(nodes, parseable?, grepable?, short?)
+    end
+  end
+
+  class SetCommand < Clamp::Command
+    option ['-i', '--instance'], 'INSTANCE', 'Node instance, required', required: true
+    option ['-p', '--parseable'], :flag, 'Display in non-pretty parseable JSON'
+    option ['-g', '--grepable'], :flag, 'Display in non-pretty grep-friendly text'
+    option ['-k', '--parameter'], 'NAME', 'Set parameter for the node', required: true, multivalued: true
+    option ['-v', '--value'], 'VALUE', 'Value for parameter', required: true, multivalued: true
+
+    def convert_bool(v)
+      case v.downcase
+      when 'true'
+        true
+      when 'false'
+        false
+      else
+        v
+      end
+    end
+
+    def execute
+      if parameter_list.length != value_list.length
+        puts Rainbow('parameter and value length mismatch').red
+      end
+      params = Hash[parameter_list.each_with_index.map { |p, i| [p, convert_bool(value_list[i])] }]
+      Gaptool::Helpers.info([Gaptool::API.client.setparameters(instance, params)], parseable?, grepable?)
+    end
+  end
+
+  class ChefrunCommand < Clamp::Command
+    option ['-r', '--role'], 'ROLE', 'Role name to ssh to'
+    option ['-e', '--environment'], 'ENVIRONMENT', 'Which environment, e.g. production'
+    option ['-i', '--instance'], 'INSTANCE', 'Instance ID, e.g. i-12345678'
+    option ['-H', '--hidden'], :flag, 'Include hidden hosts'
+    option(['-A', '--attribute'], 'ATTRIBUTE',
+           'Pass one or more parameters to the deploy recipe in recipe.attr=value format',
+           multivalued: true)
+    option(['-b', '--chef-branch'], 'BRANCH',
+           'branch of the chef repository to use (defaults to last branch used during init/chefrun)',
+           default: nil)
+    option ['-s', '--serial'], :flag, 'Run command serially. Order of execution is unknown.'
+    option ['-W', '--whyrun'], :flag, 'Whyrun, like dry-run but different.'
+    option ['-c', '--continue-on-errors'], :flag, 'Continue execution even if one or more hosts fail'
+    option ['-b', '--batch-size'], 'SIZE', "How many hosts to run in parallel (defaults to #{Gaptool::SSH::BATCH_SIZE})", default: Gaptool::SSH::BATCH_SIZE
+
+    def execute
+      attrs = Gaptool::Helpers.split_attrs(attribute_list)
+      nodes = Gaptool::API.query_nodes(hidden: hidden? ? true : nil,
+                                       role: role,
+                                       instance: instance,
+                                       environment: environment)
+
+      nodes = nodes.map do |x|
+        x['whyrun'] = whyrun?
+        x['chef_branch'] = chef_branch
+        x['attrs'] = attrs
+        x
+      end
+
+      pre_hook = proc do |node|
+        if node['chef_runlist'].nil?
+          runlist = ['recipe[main]']
+        elsif node['chef_runlist'].is_a? Array
+          runlist = node['chef_runlist']
+        else
+          runlist = eval(node['chef_runlist'])
+        end
+        json = {
+          'this_server' => "#{node['role']}-#{node['environment']}-#{node['instance']}",
+          'role' => node['role'],
+          'environment' => node['environment'],
+          'app_user' => node['appuser'],
+          'run_list' => runlist,
+          'hostname' => node['hostname'],
+          'instance' => node['instance'],
+          'zone' => node['zone'],
+          'itype' => node['itype'],
+          'apps' => eval(node['apps'] || '[]'),
+          'gaptool' => {
+            'user' => ENV['GT_USER'],
+            'key' => ENV['GT_KEY'],
+            'url' => ENV['GT_URL']
+          }
+        }.merge(node['attrs'])
+        git = 'sudo -u admin git'
+        pull = "#{git} fetch --all; #{git} reset --hard origin/`#{git} rev-parse --abbrev-ref HEAD`"
+        wopts = node['whyrun'] ? ' -W ' : ''
+
+        unless node['chef_branch'].nil?
+          json['chefbranch'] = node['chef_branch']
+          pull = "#{git} checkout -f #{node['chef_branch']}; #{git} fetch --all; #{git} reset --hard origin/#{node['chef_branch']}"
+        end
+        upload!(StringIO.new(json.to_json), '/tmp/chef.json')
+        script = <<-EOS
+cd /var/data/admin/ops
+#{pull}
+sudo chef-solo -c /var/data/admin/ops/cookbooks/solo.rb -j /tmp/chef.json -E #{node['environment']}#{wopts}
+rm -f /tmp/chef.json
+EOS
+        upload!(StringIO.new(script), '/tmp/chef.sh')
+      end
+      res = Gaptool::SSH.exec(
+        nodes, ['chmod +x /tmp/chef.sh', '/tmp/chef.sh', 'rm -f /tmp/chef.sh'],
+        pre_hooks: [pre_hook], serial: serial?, continue_on_errors: continue_on_errors?,
+        batch_size: batch_size
+      )
+      exit res
+    end
+  end
+
+  class DeployCommand < Clamp::Command
+    option(['-a', '--app'], 'APP',
+           'Application(s) to deploy (can be set multiple times)',
+           required: true, multivalued: true)
+    option ['-m', '--migrate'], :flag, 'Toggle running migrations'
+    option ['-e', '--environment'], 'ENVIRONMENT', 'Which environment, e.g. production', required: true
+    option ['-b', '--branch'], 'BRANCH', 'Git branch to deploy, default is master'
+    option ['-r', '--rollback'], :flag, 'Toggle this to rollback last deploy'
+    option ['-i', '--instance'], 'INSTANCE', 'Instance ID, e.g. i-12345678. If set, all applications MUST be hosted on this node.'
+    option ['-A', '--attribute'], 'ATTRIBUTE', 'Pass one or more parameters to the deploy recipe in recipe.attr=value format', multivalued: true
+    option ['-H', '--hidden'], :flag, 'Display hidden hosts'
+    option ['-s', '--serial'], :flag, 'Run command serially. Order of execution is unknown.'
+    option ['-c', '--continue-on-errors'], :flag, 'Continue execution even if one or more hosts fail'
+    option ['-b', '--batch-size'], 'SIZE', "How many hosts to run in parallel (defaults to #{Gaptool::SSH::BATCH_SIZE})", default: Gaptool::SSH::BATCH_SIZE
+
+    def execute # rubocop:disable Metrics/MethodLength
+      attrs = Gaptool::Helpers.split_attrs(attribute_list)
+      if instance
+        n = Gaptool::API.client.getonenode(instance)
+        if n['environment'] != environment
+          Gaptool::Helpers.error "Instance #{instance} is not in environment #{environment}"
+        else
+          app_list.each do |app|
+            Gaptool::Helpers.error "Instance #{instance} does not host #{app} in env #{environment}" \
+              unless n['apps'].include?(app)
+          end
+        end
+        nodes = [n]
+
+      else
+        params = hidden? ? { hidden: true } : {}
+        nodes = []
+        app_list.each do |app|
+          nodes.concat(Gaptool::API.client.getappnodes(app, environment, params))
+        end
+      end
+
+      # dedup nodes
+      seen = Set.new
+      app_set = Set.new(app_list)
+      nodes = nodes.select do |x|
+        res = !seen.include?(x['instance'])
+        seen << x['instance']
+        res
+      end
+      nodes = nodes.map do |x|
+        x['apps'] = eval(x['apps'])
+        x['apps_to_deploy'] = (Set.new(x['apps']) & app_set).to_a
+        x['rollback'] = rollback?
+        x['branch'] = branch || 'master'
+        x['migrate'] = migrate?
+        x['attrs'] = attrs
+        x
+      end
+
+      pre_hook = proc do |node|
+        host = "#{node['role']}:#{node['environment']}:#{node['instance']}"
+        puts "#{Rainbow('Deploying apps').cyan} '" + \
+             Rainbow(node['apps_to_deploy'].join(' ')).green + \
+             "' #{Rainbow('on').cyan} " + \
+             Rainbow(host).green
+
+        if node['chef_runlist'].nil?
+          runlist = ['recipe[deploy]']
+        elsif node['chef_runlist'].is_a? Array
+          runlist = node['chef_runlist']
+        else
+          runlist = eval(node['chef_runlist'])
+        end
+        json = {
+          'this_server' => "#{node['role']}-#{node['environment']}-#{node['instance']}",
+          'role' => node['role'],
+          'environment' => node['environment'],
+          'app_user' => node['appuser'],
+          'run_list' => runlist,
+          'hostname' => node['hostname'],
+          'instance' => node['instance'],
+          'zone' => node['zone'],
+          'itype' => node['itype'],
+          'apps' => node['apps'],
+          'deploy_apps' => node['apps_to_deploy'],
+          'rollback' => node['rollback'],
+          'branch' => node['branch'],
+          'migrate' => node['migrate'],
+          'gaptool' => {
+            'user' => ENV['GT_USER'],
+            'key' => ENV['GT_KEY'],
+            'url' => ENV['GT_URL']
+          }
+        }.merge(node['attrs']).to_json
+        upload!(StringIO.new(json), '/tmp/chef.json')
+        script = <<-EOS
+cd /var/data/admin/ops
+sudo -u admin git pull
+sudo chef-solo -c /var/data/admin/ops/cookbooks/solo.rb -j /tmp/chef.json -E #{node['environment']}
+rm -f /tmp/chef.json
+EOS
+        upload!(StringIO.new(script), '/tmp/deploy.sh')
+      end
+
+      res = Gaptool::SSH.exec(
+        nodes,
+        ['chmod +x /tmp/deploy.sh', '/tmp/deploy.sh', 'rm -f /tmp/deploy.sh'],
+        pre_hooks: [pre_hook], serial: serial?, continue_on_errors: continue_on_errors?,
+        batch_size: batch_size
+      )
+      exit res
+    end
+  end
+
+  class RehashCommand < Clamp::Command
+    option ['-y', '--yes'], :flag, 'YES I REALLY WANT TO DO THIS'
+    def execute
+      if yes?
+        puts Gaptool::API.client.rehash
+      else
+        puts "You need to run this with -y\nIf you don't know what this does or aren't sure, DO NOT RUN IT\nThis will regenerate all host metadata on gaptool-server\nand can break in-progress operations."
+      end
+    end
+  end
+
+  class VersionCommand < Clamp::Command
+    option ['-r', '--remote'], :flag, 'Include remote API version'
+    def execute
+      version = File.read(File.realpath(File.join(File.dirname(__FILE__), '..', 'VERSION'))).strip
+      puts "gaptool-client #{version} using gaptool-api #{Gaptool::API.client.version}"
+      return 0 unless remote?
+      vinfo = Gaptool::API.client.api_version
+      puts "gaptool-server #{vinfo['server_version']}"
+    end
+  end
+end

data/lib/gaptool_client/helpers.rb

@@ -0,0 +1,63 @@
+require 'rainbow'
+
+module Gaptool
+  module Helpers
+    def self.info(nodes, parseable, grepable, short = false)
+      if parseable && !short
+        puts({ nodes: nodes }.to_json)
+      elsif parseable
+        puts({ nodes: nodes.map { |node| node.select { |k, _v| %w(role environment instance).include?(k) } } }.to_json)
+      else
+        nodes.each do |node|
+          host = "#{node['role']}:#{node['environment']}:#{node['instance']}"
+          if grepable && short
+            puts host
+          elsif !grepable
+            puts Rainbow(host).green
+          end
+          next if short
+          keys = node.keys.sort
+          keys.each do |key|
+            value = node[key]
+            if grepable
+              puts "#{host}|#{key}|#{value}"
+            else
+              value = Time.at(node[key].to_i) if key == 'launch_time'
+              if key == keys.last
+                puts "  ┖  #{Rainbow(key).cyan}: #{value}\n\n"
+              else
+                puts "  ┠  #{Rainbow(key).cyan}: #{value}"
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def self.error(message, opts = {})
+      code = opts[:code] || 1
+      color = opts[:color] || :red
+      STDERR.puts(Rainbow(message).send(color))
+      exit code
+    end
+
+    def self.split_attrs(attribute_list)
+      opts = {}
+      attribute_list.each do |attr_|
+        key, value = attr_.split('=', 2)
+        split = key.split('.')
+        cur = opts
+        split.each_with_index do |part, idx|
+          if idx == split.size - 1
+            # leaf, add the value
+            cur[part] = value
+          else
+            cur[part] ||= {}
+          end
+          cur = cur[part]
+        end
+      end
+      opts
+    end
+  end
+end

data/lib/gaptool_client/host.rb

@@ -0,0 +1,42 @@
+require 'rainbow'
+require 'sshkit'
+require 'gaptool_client/api'
+
+module Gaptool
+  class InteractionHandler
+    attr_reader :host
+    def initialize(host)
+      @host = host
+    end
+
+    def on_data(_command, stream_name, data, _channel)
+      case stream_name
+      when :stdout
+        puts "#{Rainbow("#{@host}").yellow}> #{data}"
+      when :stderr
+        STDERR.puts "#{Rainbow("#{@host}").red}> #{data}"
+      end
+    end
+  end
+
+  class Host < SSHKit::Host
+    attr_reader :info
+
+    def initialize(node)
+      super(node['hostname'])
+      @info = node
+    end
+
+    def method_missing(attr)
+      @info[attr]
+    end
+
+    def name
+      @name ||= Gaptool::API.get_host(@info)
+    end
+
+    def handler
+      InteractionHandler.new(name)
+    end
+  end
+end

data/lib/gaptool_client/runner.rb

@@ -0,0 +1,93 @@
+require 'sshkit'
+require 'thread'
+
+module SSHKit
+  module Runner
+    class SafeSequential < Sequential
+      attr_reader :failed, :succeeded
+
+      def initialize(hosts, options = nil, &block)
+        options ||= {}
+        @on_errors = options.delete(:on_errors) || :exit
+        super(hosts, options, &block)
+        @failed = []
+        @succeeded = []
+      end
+
+      def execute
+        super
+      rescue
+        return false
+      else
+        return @failed.length == 0
+      end
+
+      private
+
+      def run_backend(host, &block)
+        backend(host, &block).run
+      rescue => e
+        @failed << { host: host, error: e }
+        raise if @on_errors == :exit
+      else
+        @succeeded << host
+      end
+    end
+
+    class SafeParallel < SafeSequential
+      attr_writer :group_size
+
+      def initialize(hosts, options = nil, &block)
+        super(hosts, options, &block)
+        @failed = Queue.new
+        @succeeded = Queue.new
+      end
+
+      def execute
+        hosts.each_slice(group_size).each do |slice|
+          threads = []
+          slice.each do |host|
+            threads << Thread.new(host) do |h|
+              begin
+                backend(h, &block).run
+                succeeded << host
+              rescue => e
+                failed << { host: host, error: e }
+              end
+            end
+          end
+          threads.map(&:join)
+          return convert_results if failed.length > 0 && @on_errors == :exit
+          sleep wait_interval
+        end
+        convert_results
+      end
+
+      private
+
+      def group_size
+        @group_size || options[:limit] || 2
+      end
+
+      def convert_results
+        @failed = queue_to_array(failed)
+        @succeeded = queue_to_array(succeeded)
+        return true if failed.length == 0
+      end
+
+      def queue_to_array(queue)
+        res = []
+        begin
+          loop do
+            obj = queue.pop(true)
+            break unless obj
+            res << obj
+          end
+        rescue ThreadError
+          return res
+        end
+        res
+      end
+    end
+  end
+end

data/lib/gaptool_client/ssh.rb

@@ -0,0 +1,135 @@
+require 'logger'
+require 'rainbow'
+require 'sshkit'
+require 'gaptool_client/runner'
+require 'gaptool_client/host'
+# rubocop:disable Metrics/LineLength
+
+module Gaptool
+  module SSH
+    BATCH_SIZE = 10
+    START_MARKER = '###### GAPTOOL ######'
+    STOP_MARKER = '###### END GAPTOOL ######'
+
+    def self.config_for(node)
+      host = Gaptool::API.get_host(node)
+      <<-EOF
+# -- #{node['instance']}
+Host #{host} #{node['instance']}
+  Hostname #{node['hostname']}
+  User #{ENV['GT_USER']}
+  LogLevel FATAL
+  PreferredAuthentications publickey
+  CheckHostIP no
+  StrictHostKeyChecking no
+  UserKnownHostsFile /dev/null
+# -- end #{node['instance']}
+  EOF
+    end
+
+    def self.config
+      config = File.join(Dir.home, '.ssh', 'config')
+      dir = File.dirname(config)
+      parent = File.join(dir, '..')
+      if File.exist?(config)
+        Gaptool::Helpers.error "#{config}: not writable" unless File.writable?(config)
+        content = File.read(config)
+        File.open("#{config}.bck", 'w') { |f| f.write(content) }
+      else
+        if !File.exist?(dir)
+          Gaptool::Helpers.error "Home directory #{parent} does not exists"\
+            unless Dir.exist?(parent)
+          Dir.mkdir(dir, 0700)
+        elsif !File.directory?(dir)
+          Gaptool::Helpers.error "#{dir}: not a directory"
+        end
+        content = ''
+      end
+      [config, content]
+    end
+
+    def self.update_config_for(nodes, verbose = true)
+      nodes = [nodes] unless nodes.is_a?(Array)
+      config, content = Gaptool::SSH.config
+      nodes.each do |node|
+        snip = Gaptool::SSH.config_for(node)
+        mark = "# -- #{node['instance']}"
+        emark = "# -- end #{node['instance']}"
+
+        if Regexp.new(mark).match(content)
+          puts Rainbow("Updating ssh config for #{get_host(node)}").green if verbose
+          content.gsub!(/#{mark}.*?#{emark}/m, snip.strip)
+        elsif Regexp.new(STOP_MARKER).match(content)
+          puts Rainbow("Adding ssh config for #{get_host(node)}").green if verbose
+          content.gsub!(/#{STOP_MARKER}/m, snip + "\n" + STOP_MARKER)
+        else
+          puts Rainbow('No gt ssh config found: please run gt ssh-config').yellow
+          puts Rainbow("Adding ssh config for #{get_host(node)}").green if verbose
+          content = <<-EOF
+#{content}
+#{START_MARKER}
+#{snip}
+#{STOP_MARKER}
+EOF
+        end
+      end
+      File.open(config, 'w') { |f| f.write(content) }
+    end
+
+    def self.configure_sshkit
+      SSHKit.config.output_verbosity = Logger::WARN
+      SSHKit::Backend::Netssh.configure do |ssh|
+        ssh.connection_timeout = 30
+        ssh.ssh_options = {
+          forward_agent: true,
+          global_known_hosts_file: '/dev/null',
+          keys_only: true,
+          port: 22,
+          user: ENV['GT_USER']
+        }
+      end
+    end
+
+    def self.exec(nodes, commands, opts = {})
+      logger = SSHKit::Formatter::Pretty.new(STDERR)
+      serial = opts[:serial] || nodes.length == 1
+      if opts[:update_ssh_config].nil? || opts[:update_ssh_config]
+        nodes.each { |n| Gaptool::SSH.update_config_for(n, false) }
+      end
+      pre = opts[:pre_hooks] || []
+      post = opts[:post_hooks] || []
+      opts = {
+        limit: opts[:batch_size].to_i || BATCH_SIZE,
+        on_errors: opts[:continue_on_errors] ? :continue : :exit,
+        wait: opts[:wait] || 0
+      }
+      Gaptool::SSH.configure_sshkit
+      runner_cls = if serial
+                     SSHKit::Runner::SafeSequential
+                   else
+                     SSHKit::Runner::SafeParallel
+                   end
+      hosts = nodes.map { |n| Gaptool::Host.new(n) }
+      runner = runner_cls.new(hosts, opts) do |host|
+        pre.each { |h| instance_exec(host, &h) }
+        commands.each do |cmd|
+          execute(:bash, "-l -c '#{cmd}'",
+                  interaction_handler: host.handler)
+        end
+        post.each { |h| instance_exec(host, &h) }
+      end
+      res = runner.execute
+
+      unless res
+        logger.error("#{runner.failed.length}/#{nodes.length} hosts failed")
+        runner.failed.each do |desc|
+          host = desc[:host]
+          error = desc[:error]
+          logger.error("#{host.name}> #{error.message}")
+        end
+        return runner.failed.length + 100
+      end
+      0
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gaptool-client
 version: !ruby/object:Gem::Version
-  version: 0.8.0.pre.alpha4
+  version: 0.8.0.pre.alpha5
 platform: ruby
 authors:
 - Francesco Laurita
@@ -103,6 +103,12 @@ files:
 - bin/gt
 - gaptool-client.gemspec
 - lib/gaptool_client.rb
+- lib/gaptool_client/api.rb
+- lib/gaptool_client/commands.rb
+- lib/gaptool_client/helpers.rb
+- lib/gaptool_client/host.rb
+- lib/gaptool_client/runner.rb
+- lib/gaptool_client/ssh.rb
 homepage: http://www.gild.com
 licenses:
 - MIT