kontena-cli 1.3.0.pre2 → 1.3.0.rc1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3cecf22e1d7197b410494d6fbbc265d052c2cb36
-  data.tar.gz: 84f981033ed64b0ba6a85344544d1981a723fd21
+  metadata.gz: d1aa18c17b13a8b1887ca08c0a4a97f01d99b6df
+  data.tar.gz: 396d0b859359808ee9bcc11b0f92c9a6f9c3119b
 SHA512:
-  metadata.gz: 3dabb9b18fe5a4f0c62bb31686311a6fa65c46cc953fb803a0a53f6dad0ea4a7f36e777c995a0b01957e114eb288517b9ecfd41f1648a2555956ed2751f45cc1
-  data.tar.gz: 8203264603f9bb1c79fefd5ce372a85481531eea3e70d44b0aaad9ac57a27a8f641bc13739cc3684bb9a0ca3a2e5cf974d46bf3c9bcb17bb57e39dd9d277f53d
+  metadata.gz: 6c8e6b7eb2767919326db9290c952457303c7c390622fc6d762d9453df15d9d2e5deb9993e7731aff7d7b310cb325dd178da401051c8088d90472595c159d2e1
+  data.tar.gz: 02a1e6756340210bd7de9c552b9f67464165db55476c55defe14a907c9da0ca55a7d05921bf4417b752e1e4712f23aab8dfb5589c1afc724c7e7029831096cb6

data/VERSION

@@ -1 +1 @@
-1.3.0.pre2
+1.3.0.rc1

data/kontena-cli.gemspec

@@ -34,4 +34,5 @@ Gem::Specification.new do |spec|
   spec.add_runtime_dependency "safe_yaml", "~> 1.0"
   spec.add_runtime_dependency "liquid", "~> 4.0.0"
   spec.add_runtime_dependency "tty-table", "~> 0.8.0"
+  spec.add_runtime_dependency "websocket-client-simple", "~> 0.3.0"
 end

data/lib/kontena/cli/common.rb

@@ -248,14 +248,44 @@ module Kontena
       def any_key_to_continue_with_timeout(timeout=9)
         return nil if running_silent?
         return nil unless $stdout.tty?
-        prompt.keypress("Press any key to continue or ctrl-c to cancel (Automatically continuing in :countdown seconds) ...", timeout: timeout)
+        start_time = Time.now.to_i
+        end_time   = start_time + timeout
+        Thread.main['any_key.timed_out']   = false
+        msg = "Press any key to continue or ctrl-c to cancel.. (Automatically continuing in ? seconds)"
+
+        reader_thread = Thread.new do
+          Thread.main['any_key.char'] = $stdin.getch
+        end
+
+        countdown_thread = Thread.new do
+          time_left = timeout
+          while time_left > 0 && Thread.main['any_key.char'].nil?
+            print "\r#{pastel.bright_white("#{msg.sub("?", time_left.to_s)}")} "
+            time_left = end_time - Time.now.to_i
+            sleep 0.1
+          end
+          print "\r#{' ' * msg.length}  \r"
+          reader_thread.kill if reader_thread.alive?
+        end
+
+        countdown_thread.join
+
+        if Thread.main['any_key.char'] == "\u0003"
+          error "Canceled"
+        end
       end
 
       def any_key_to_continue(timeout = nil)
         return nil if running_silent?
         return nil unless $stdout.tty?
         return any_key_to_continue_with_timeout(timeout) if timeout
-        prompt.keypress("Press any key to continue or ctrl-c to cancel..")
+        msg = "Press any key to continue or ctrl-c to cancel.. "
+        print pastel.bright_cyan("#{msg}")
+        char = $stdin.getch
+        print "\r#{' ' * msg.length}\r"
+        if char == "\u0003"
+          error "Canceled"
+        end
       end
 
       def display_account_login_info

data/lib/kontena/cli/containers/exec_command.rb

@@ -1,21 +1,40 @@
+require_relative '../helpers/exec_helper'
+
 module Kontena::Cli::Containers
   class ExecCommand < Kontena::Command
     include Kontena::Cli::Common
     include Kontena::Cli::GridOptions
+    include Kontena::Cli::Helpers::ExecHelper
 
     parameter "CONTAINER_ID", "Container id"
     parameter "CMD ...", "Command"
 
+    option ["--shell"], :flag, "Execute as a shell command"
+    option ["--interactive"], :flag, "Keep stdin open"
+
     def execute
+      require 'websocket-client-simple'
+
       require_api_url
       token = require_token
+      cmd = JSON.dump({cmd: cmd_list})
+      base = self
+      ws = connect(ws_url("#{current_grid}/#{container_id}"), token)
+      ws.on :message do |msg|
+        base.handle_message(msg)
+      end
+      ws.on :open do
+        ws.send(cmd)
+      end
+      ws.on :close do |e|
+        exit 1
+      end
 
-      payload = {cmd: ["sh", "-c", Shellwords.join(cmd_list)]}
-      result = client(token).post("containers/#{current_grid}/#{container_id}/exec", payload)
-
-      puts result[0].join(" ") unless result[0].size == 0
-      $stderr.puts result[1].join(" ") unless result[1].size == 0
-      exit result[2]
+      if interactive?
+        stream_stdin_to_ws(ws).join
+      else 
+        sleep
+      end
     end
   end
 end

data/lib/kontena/cli/helpers/exec_helper.rb

@@ -0,0 +1,61 @@
+module Kontena::Cli::Helpers
+  module ExecHelper
+
+    # @param [WebSocket::Client::Simple] ws 
+    # @return [Thread]
+    def stream_stdin_to_ws(ws)
+      Thread.new {
+        STDIN.raw {
+          while char = STDIN.readpartial(1024)
+            ws.send(JSON.dump({ stdin: char }))
+          end
+        }
+      }
+    end
+
+    # @param [Websocket::Frame::Incoming] msg
+    def handle_message(msg)
+      data = parse_message(msg)
+      if data.is_a?(Hash)
+        if data.has_key?('exit')
+          exit data['exit'].to_i
+        elsif data.has_key?('stream')
+          if data['stream'] == 'stdout'
+            $stdout << data['chunk'] 
+          else 
+            $stderr << data['chunk']
+          end
+        end
+      end
+    rescue => exc
+      $stderr << "#{exc.class.name}: #{exc.message}"
+    end
+
+    # @param [Websocket::Frame::Incoming] msg
+    def parse_message(msg)
+      JSON.parse(msg.data)
+    rescue JSON::ParserError
+      nil
+    end
+
+    # @param [String] container_id
+    # @return [String]
+    def ws_url(container_id)
+      url = require_current_master.url
+      url << '/' unless url.end_with?('/')
+      "#{url.sub('http', 'ws')}v1/containers/#{container_id}/exec"
+    end
+
+    # @param [String] url
+    # @param [String] token
+    # @return [WebSocket::Client::Simple]
+    def connect(url, token)
+      WebSocket::Client::Simple.connect(url, {
+        headers: {
+          'Authorization' => "Bearer #{token.access_token}",
+          'Accept' => 'application/json'
+        }
+      })
+    end
+  end
+end

data/lib/kontena/cli/master/config/get_command.rb

@@ -12,16 +12,14 @@ module Kontena::Cli::Master::Config
 
     option ['-p', '--pair'], :flag, "Print key=value instead of only value"
 
-    option '--return', :flag, "Return the value", hidden: true
+    def response
+      client.get("config/#{key}")
+    end
 
     def execute
-      if self.pair?
-        puts client.get("config/#{self.key}").inspect
-      elsif self.return?
-        return client.get("config/#{self.key}")[self.key]
-      else
-        puts client.get("config/#{self.key}")[self.key]
-      end
+      value = response[key]
+      print(key + '=') if pair?
+      puts value
     end
   end
 end

data/lib/kontena/cli/master/ssh_command.rb

@@ -15,25 +15,50 @@ module Kontena::Cli::Master
       URI.parse(current_master.url).host
     end
 
-    def master_provider
-      Kontena.run!(%w(master config get --return server.provider))
+    def master_provider_vagrant?
+      require 'kontena/cli/master/config/get_command'
+      cmd = Kontena::Cli::Master::Config::GetCommand.new([])
+      cmd.parse(['server.provider'])
+      cmd.response['server.provider'] == 'vagrant'
+    rescue => ex
+      false
     end
 
-    def execute
-      if master_provider == 'vagrant'
-        unless Kontena::PluginManager.instance.plugins.find { |plugin| plugin.name == 'kontena-plugin-vagrant' }
-          exit_with_error 'You need to install vagrant plugin to ssh into this node. Use kontena plugin install vagrant'
+    def vagrant_plugin_installed?
+      Kontena::PluginManager.instance.plugins.any? { |plugin| plugin.name == 'kontena-plugin-vagrant' }
+    end
+
+    def master_is_vagrant?
+      if master_provider_vagrant?
+        unless vagrant_plugin_installed?
+          exit_with_error 'You need to install vagrant plugin to ssh into this master. Use: kontena plugin install vagrant'
         end
-        cmd = ['vagrant', 'master', 'ssh']
-        cmd += commands_list
-        Kontena.run!(cmd)
+        logger.debug { "Master config server.provider is vagrant" }
+        true
+      elsif vagrant_plugin_installed? && current_master.url.include?('192.168.66.')
+        logger.debug { "Vagrant plugin installed and current_master url looks like vagrant" }
+        true
       else
-        cmd = ['ssh']
-        cmd << "#{user}@#{master_host}"
-        cmd += ["-i", identity_file] if identity_file
-        cmd += commands_list
-        exec(*cmd)
+        logger.debug { "Assuming non-vagrant master host" }
+        false
       end
     end
+
+    def run_ssh
+      cmd = ['ssh']
+      cmd << "#{user}@#{master_host}"
+      cmd += ["-i", identity_file] if identity_file
+      cmd += commands_list
+      logger.debug { "Executing #{cmd.inspect}" }
+      exec(*cmd)
+    end
+
+    def run_vagrant_ssh
+      Kontena.run!(['vagrant', 'master', 'ssh'] + commands_list)
+    end
+
+    def execute
+      master_is_vagrant? ? run_vagrant_ssh : run_ssh
+    end
   end
 end

data/lib/kontena/cli/services/exec_command.rb

@@ -1,9 +1,12 @@
+require 'shellwords'
 require_relative 'services_helper'
+require_relative '../helpers/exec_helper'
 
 module Kontena::Cli::Services
   class ExecCommand < Kontena::Command
     include Kontena::Cli::Common
     include Kontena::Cli::GridOptions
+    include Kontena::Cli::Helpers::ExecHelper
     include ServicesHelper
 
     parameter "NAME", "Service name"
@@ -12,6 +15,7 @@ module Kontena::Cli::Services
     option ["-i", "--instance"], "INSTANCE", "Exec on given numbered instance, default first running" do |value| Integer(value) end
     option ["-a", "--all"], :flag, "Exec on all running instances"
     option ["--shell"], :flag, "Execute as a shell command"
+    option ["--interactive"], :flag, "Keep stdin open"
     option ["--skip"], :flag, "Skip failed instances when executing --all"
     option ["--silent"], :flag, "Do not show exec status"
     option ["--verbose"], :flag, "Show exec status"
@@ -19,42 +23,16 @@ module Kontena::Cli::Services
     requires_current_master
     requires_current_grid
 
-    # Exits if exec returns with non-zero
-    def exec_container(container)
-      if shell?
-        cmd = ['sh', '-c', cmd_list.join(' ')]
-      else
-        cmd = cmd_list
-      end
-
-      stdout = stderr = exit_status = nil
-
-      if !silent? && (verbose? || all?)
-        spinner "Executing command on #{container['name']}" do
-          stdout, stderr, exit_status = client.post("containers/#{container['id']}/exec", {cmd: cmd})
-
-          raise Kontena::Cli::SpinAbort if exit_status != 0
-        end
-      else
-        stdout, stderr, exit_status = client.post("containers/#{container['id']}/exec", {cmd: cmd})
-      end
-
-      stdout.each do |chunk| $stdout.write chunk end
-      stderr.each do |chunk| $stderr.write chunk end
+    def execute
+      require 'websocket-client-simple'
 
-      exit exit_status if exit_status != 0 && !skip?
+      exit_with_error "--interactive cannot be used with --all" if all? && interactive?
 
-      return exit_status == 0
-    end
-
-    def execute
       service_containers = client.get("services/#{parse_service_id(name)}/containers")['containers']
       service_containers.sort_by! { |container| container['instance_number'] }
       running_containers = service_containers.select{|container| container['status'] == 'running' }
-
-      if running_containers.empty?
-        exit_with_error "Service #{name} does not have any running containers"
-      end
+      
+      exit_with_error "Service #{name} does not have any running containers" if running_containers.empty?
 
       if all?
         ret = true
@@ -69,16 +47,98 @@ module Kontena::Cli::Services
         end
         return ret
       elsif instance
-        if !(container = service_containers.find{|container| container['instance_number'] == instance})
+        if !(container = service_containers.find{|c| c['instance_number'] == instance})
           exit_with_error "Service #{name} does not have container instance #{instance}"
         elsif container['status'] != 'running'
           exit_with_error "Service #{name} container #{container['name']} is not running, it is #{container['status']}"
-        else
+        elsif interactive?
+          interactive_exec(container)
+        else 
           exec_container(container)
         end
       else
-        exec_container(running_containers.first)
+        if interactive?
+          interactive_exec(running_containers.first)
+        else 
+          exec_container(running_containers.first)
+        end
+      end
+    end
+
+    # Exits if exec returns with non-zero
+    # @param [Hash] container
+    def exec_container(container)
+      exit_status = nil
+      if !silent? && (verbose? || all?)
+        spinner "Executing command on #{container['name']}" do
+          exit_status = normal_exec(container)
+
+          raise Kontena::Cli::SpinAbort if exit_status != 0
+        end
+      else
+        exit_status = normal_exec(container)
+      end
+
+      exit exit_status if exit_status != 0 && !skip?
+
+      return exit_status == 0
+    end
+
+    # @param [Hash] container
+    # @return [Boolean]
+    def normal_exec(container)
+      base = self
+      cmd = JSON.dump({ cmd: cmd_list })
+      exit_status = nil
+      token = require_token
+      url = ws_url(container['id'])
+      url << '?shell=true' if shell?
+      ws = connect(url, token)
+      ws.on :message do |msg|
+        data = base.parse_message(msg)
+        if data 
+          if data['exit']
+            exit_status = data['exit'].to_i
+          elsif data['stream'] == 'stdout'
+            $stdout << data['chunk']
+          else 
+            $stderr << data['chunk']
+          end
+        end
+      end
+      ws.on :open do
+        ws.send(cmd)
+      end
+      ws.on :close do |e|
+        exit_status = 1
+      end
+
+      sleep 0.01 until !exit_status.nil?
+
+      exit_status
+    end
+
+    # @param [Hash] container
+    def interactive_exec(container)
+      require 'io/console'
+
+      token = require_token
+      cmd = JSON.dump({ cmd: cmd_list })
+      base = self
+      url = ws_url(container['id']) << '?interactive=true'
+      url << '&shell=true' if shell?
+      ws = connect(url, token)
+      ws.on :message do |msg|
+        base.handle_message(msg)        
+      end
+      ws.on :open do
+        ws.send(cmd)
+      end
+      ws.on :close do |e|
+        exit 1
       end
+      
+      stream_stdin_to_ws(ws).join
     end
   end
-end
+end

data/lib/kontena/cli/stacks/yaml/opto/service_instances_resolver.rb

@@ -1,8 +1,11 @@
 module Kontena::Cli::Stacks
   module YAML
     class Opto::Resolvers::ServiceInstances < ::Opto::Resolver
+      include Kontena::Cli::Common
+
       def resolve
         return nil unless current_master && current_grid
+        require 'kontena/cli/stacks/show_command'
         read_command = Kontena::Cli::Stacks::ShowCommand.new([self.stack])
         stack = read_command.fetch_stack(self.stack)
         service = stack['services'].find { |s| s['name'] == hint }

data/lib/kontena_cli.rb

@@ -34,7 +34,7 @@ module Kontena
     else
       command = cmdline
     end
-    logger.debug { "Running Kontena.run(#{command.inspect}" }
+    logger.debug { "Running Kontena.run(#{command.inspect})" }
     result = Kontena::MainCommand.new(File.basename(__FILE__)).run(command)
     logger.debug { "Command completed, result: #{result.inspect} status: 0" }
     result

data/spec/kontena/cli/services/exec_command_spec.rb

@@ -1,23 +1,53 @@
+require 'websocket-client-simple'
 require 'kontena/cli/services/exec_command'
 
 describe Kontena::Cli::Services::ExecCommand do
   include ClientHelpers
   include OutputHelpers
 
-  let :exec_ok do
-    [
-      ["ok\n"],
-      [],
-      0, # exit
-    ]
+  let(:ws_client_class) do
+    Class.new do
+
+      Event = Struct.new(:data)
+
+      def initialize
+        @callbacks = {}
+      end
+
+      def on(callback, &block)
+        @callbacks[callback] = block
+        if callback == :open
+          Thread.new { 
+            sleep 0.01 
+            @callbacks[:open].call 
+          }
+        end
+      end
+
+      def receive_message(msg)
+        @callbacks[:message].call(Event.new(JSON.dump(msg)))
+      rescue => exc 
+        STDERR.puts exc.message
+      end
+    end
+  end
+
+  let(:ws_client) do
+    ws_client_class.new
+  end
+
+  let(:master_url) do
+    subject.require_current_master.url.gsub('http', 'ws')
+  end
+
+  def respond_ok(ws_client)
+    ws_client.receive_message({'stream' => 'stdout', 'chunk' => "ok\n"})
+    ws_client.receive_message({'exit' => 0})
   end
 
-  let :exec_fail do
-    [
-      [],
-      ["error\n"],
-      1, # exit
-    ]
+  def respond_error(ws_client)
+    ws_client.receive_message({'stream' => 'stderr', 'chunk' => "error\n"})
+    ws_client.receive_message({'exit' => 1})
   end
 
   context "For a service with one running instance" do
@@ -37,11 +67,15 @@ describe Kontena::Cli::Services::ExecCommand do
     end
 
     it "Executes on the running container by default" do
-      expect(client).to receive(:post).with('containers/test-grid/host/test-service.container-1/exec', { cmd: ['test'] }).and_return(exec_ok)
-
-      expect{subject.run(['test-service', 'test'])}.to return_and_output true, [
-        'ok',
-      ]
+      expect(WebSocket::Client::Simple).to receive(:connect).with("#{master_url}v1/containers/test-grid/host/test-service.container-1/exec", anything).and_return(ws_client)
+      expect(ws_client).to receive(:send) do |foo|
+        ws_client.receive_message({'stream' => 'stdout', 'chunk' => "ok\n"})
+        ws_client.receive_message({'exit' => 0})
+      end
+      
+      expect {
+        subject.run(['test-service', 'test'])
+      }.to output("ok\n").to_stdout
     end
   end
 
@@ -71,30 +105,46 @@ describe Kontena::Cli::Services::ExecCommand do
 
     it "Executes on the first running container by default" do
       expect(client).to receive(:get).with('services/test-grid/null/test-service/containers').and_return(service_containers)
-      expect(client).to receive(:post).with('containers/test-grid/host/test-service.container-1/exec', { cmd: ['test'] }).and_return(exec_ok)
-
-      expect{subject.run(['test-service', 'test'])}.to output_lines ["ok"]
+      expect(WebSocket::Client::Simple).to receive(:connect).with("#{master_url}v1/containers/test-grid/host/test-service.container-1/exec", anything).and_return(ws_client)
+      expect(ws_client).to receive(:send) do
+        respond_ok(ws_client)
+      end
+      expect {
+        subject.run(['test-service', 'test'])
+      }.to output("ok\n").to_stdout
     end
 
     it "Executes on the first running container, even if they are ordered differently" do
       expect(client).to receive(:get).with('services/test-grid/null/test-service/containers').and_return({'containers' => service_containers['containers'].reverse })
-      expect(client).to receive(:post).with('containers/test-grid/host/test-service.container-1/exec', { cmd: ['test'] }).and_return(exec_ok)
-
-      expect{subject.run(['test-service', 'test'])}.to output_lines ["ok"]
+      expect(WebSocket::Client::Simple).to receive(:connect).with("#{master_url}v1/containers/test-grid/host/test-service.container-1/exec", anything).and_return(ws_client)
+      expect(ws_client).to receive(:send) do
+        respond_ok(ws_client)
+      end
+      expect {
+        subject.run(['test-service', 'test'])
+      }.to output("ok\n").to_stdout
     end
 
     it "Executes on the first running container if given" do
       expect(client).to receive(:get).with('services/test-grid/null/test-service/containers').and_return(service_containers)
-      expect(client).to receive(:post).with('containers/test-grid/host/test-service.container-1/exec', { cmd: ['test'] }).and_return(exec_ok)
-
-      expect{subject.run(['--instance=1', 'test-service', 'test'])}.to output_lines ["ok"]
+      expect(WebSocket::Client::Simple).to receive(:connect).with("#{master_url}v1/containers/test-grid/host/test-service.container-1/exec", anything).and_return(ws_client)
+      expect(ws_client).to receive(:send) do
+        respond_ok(ws_client)
+      end
+      expect {
+        subject.run(['test-service', 'test'])
+      }.to output("ok\n").to_stdout
     end
 
     it "Executes on the second running container if given" do
       expect(client).to receive(:get).with('services/test-grid/null/test-service/containers').and_return(service_containers)
-      expect(client).to receive(:post).with('containers/test-grid/host/test-service.container-2/exec', { cmd: ['test'] }).and_return(exec_ok)
-
-      expect{subject.run(['--instance=2', 'test-service', 'test'])}.to output_lines ["ok"]
+      expect(WebSocket::Client::Simple).to receive(:connect).with("#{master_url}v1/containers/test-grid/host/test-service.container-2/exec", anything).and_return(ws_client)
+      expect(ws_client).to receive(:send) do
+        respond_ok(ws_client)
+      end
+      expect {
+        subject.run(['--instance', '2', 'test-service', 'test'])
+      }.to output("ok\n").to_stdout
     end
 
     it "Errors on a nonexistant container if given" do
@@ -105,35 +155,71 @@ describe Kontena::Cli::Services::ExecCommand do
 
     it "Executes on each running container" do
       expect(client).to receive(:get).with('services/test-grid/null/test-service/containers').and_return(service_containers)
-      expect(client).to receive(:post).with('containers/test-grid/host/test-service.container-1/exec', { cmd: ['test'] }).and_return(exec_ok)
-      expect(client).to receive(:post).with('containers/test-grid/host/test-service.container-2/exec', { cmd: ['test'] }).and_return(exec_ok)
-      expect(client).to receive(:post).with('containers/test-grid/host/test-service.container-3/exec', { cmd: ['test'] }).and_return(exec_ok)
 
-      expect{subject.run(['--silent', '--all', 'test-service', 'test'])}.to output_lines ["ok", "ok", "ok"]
+      3.times do |i|
+        ws_client = ws_client_class.new
+        expect(WebSocket::Client::Simple).to receive(:connect).with("#{master_url}v1/containers/test-grid/host/test-service.container-#{i + 1}/exec", anything).and_return(ws_client)
+        expect(ws_client).to receive(:send) do
+          ws_client.receive_message({'stream' => 'stdout', 'chunk' => "test#{i + 1}\n"})
+          ws_client.receive_message({'exit' => 0})
+        end
+      end
+      
+      expect {
+        subject.run(['--silent', '--all', 'test-service', 'test'])
+      }.to output("test1\ntest2\ntest3\n").to_stdout
     end
 
     it "Stops if the first container fails" do
       expect(client).to receive(:get).with('services/test-grid/null/test-service/containers').and_return(service_containers)
-      expect(client).to receive(:post).with('containers/test-grid/host/test-service.container-1/exec', { cmd: ['test'] }).and_return(exec_fail)
-
-      expect{subject.run(['--silent', '--all', 'test-service', 'test'])}.to exit_with_error.and output("error\n").to_stderr
+      expect(WebSocket::Client::Simple).to receive(:connect).with("#{master_url}v1/containers/test-grid/host/test-service.container-1/exec", anything).and_return(ws_client)
+      expect(ws_client).to receive(:send) do
+        respond_error(ws_client)
+      end
+      expect {
+        subject.run(['--silent', '--all', 'test-service', 'test'])
+      }.to output("error\n").to_stderr
     end
 
     it "Stops if the second container fails" do
       expect(client).to receive(:get).with('services/test-grid/null/test-service/containers').and_return(service_containers)
-      expect(client).to receive(:post).with('containers/test-grid/host/test-service.container-1/exec', { cmd: ['test'] }).and_return(exec_ok)
-      expect(client).to receive(:post).with('containers/test-grid/host/test-service.container-2/exec', { cmd: ['test'] }).and_return(exec_fail)
-
-      expect{subject.run(['--silent', '--all', 'test-service', 'test'])}.to exit_with_error.and output("ok\n").to_stdout.and output("error\n").to_stderr
+      i = 1
+      [:ok, :err].each do |status|
+        ws_client = ws_client_class.new
+        expect(WebSocket::Client::Simple).to receive(:connect).with("#{master_url}v1/containers/test-grid/host/test-service.container-#{i}/exec", anything).and_return(ws_client)
+        expect(ws_client).to receive(:send) do
+          if status == :ok
+            respond_ok(ws_client)
+          else 
+            respond_error(ws_client)
+          end
+        end
+        i += 1
+      end
+      expect {
+        subject.run(['--silent', '--all', 'test-service', 'test'])
+      }.to output("ok\n").to_stdout.and output("error\n").to_stderr
     end
 
     it "Keeps going if the second container fails when using --skip" do
       expect(client).to receive(:get).with('services/test-grid/null/test-service/containers').and_return(service_containers)
-      expect(client).to receive(:post).with('containers/test-grid/host/test-service.container-1/exec', { cmd: ['test'] }).and_return(exec_ok)
-      expect(client).to receive(:post).with('containers/test-grid/host/test-service.container-2/exec', { cmd: ['test'] }).and_return(exec_fail)
-      expect(client).to receive(:post).with('containers/test-grid/host/test-service.container-3/exec', { cmd: ['test'] }).and_return(exec_ok)
 
-      expect{subject.run(['--silent', '--all', '--skip', 'test-service', 'test'])}.to exit_with_error.and output("ok\nok\n").to_stdout.and output("error\n").to_stderr
+      i = 1
+      [:ok, :err, :ok].each do |status|
+        ws_client = ws_client_class.new
+        expect(WebSocket::Client::Simple).to receive(:connect).with("#{master_url}v1/containers/test-grid/host/test-service.container-#{i}/exec", anything).and_return(ws_client)
+        expect(ws_client).to receive(:send) do
+          if status == :ok
+            respond_ok(ws_client)
+          else 
+            respond_error(ws_client)
+          end
+        end
+        i += 1
+      end
+      expect {
+        subject.run(['--silent', '--all', '--skip', 'test-service', 'test'])
+      }.to output("ok\nok\n").to_stdout.and output("error\n").to_stderr
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kontena-cli
 version: !ruby/object:Gem::Version
-  version: 1.3.0.pre2
+  version: 1.3.0.rc1
 platform: ruby
 authors:
 - Kontena, Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-26 00:00:00.000000000 Z
+date: 2017-05-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -206,6 +206,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.8.0
+- !ruby/object:Gem::Dependency
+  name: websocket-client-simple
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.3.0
 description: Command-line client for the Kontena container and microservices platform
 email:
 - info@kontena.io
@@ -339,6 +353,7 @@ files:
 - lib/kontena/cli/grids/users/add_command.rb
 - lib/kontena/cli/grids/users/list_command.rb
 - lib/kontena/cli/grids/users/remove_command.rb
+- lib/kontena/cli/helpers/exec_helper.rb
 - lib/kontena/cli/helpers/health_helper.rb
 - lib/kontena/cli/helpers/log_helper.rb
 - lib/kontena/cli/localhost_web_server.rb