kontena-cli 1.4.0.pre1 → 1.4.0.pre2

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

@@ -1,57 +1,9 @@
-require 'kontena/websocket/client'
 require 'kontena/cli/services/exec_command'
 
 describe Kontena::Cli::Services::ExecCommand do
   include ClientHelpers
   include OutputHelpers
 
-  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 connect ; 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
-
-  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
     let :service_containers do
       { 'containers' => [
@@ -69,21 +21,16 @@ describe Kontena::Cli::Services::ExecCommand do
     end
 
     it "Executes on the running container by default" do
-      expect(Kontena::Websocket::Client).to receive(:new).with("#{master_url}v1/containers/test-grid/host/test-service.container-1/exec", anything).and_return(ws_client)
-      expect(ws_client).to receive(:text) 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
+      expect(subject).to receive(:container_exec).with('test-grid/host/test-service.container-1', ['test'],
+        interactive: false, shell: false, tty: false,
+      ).and_return(0)
+      expect{subject.run(['test-service', 'test'])}.to_not exit_with_error
     end
   end
 
   context "For a service with multiple running instances" do
     let :service_containers do
-      { 'containers' => [
+       [
         {
           'id' => 'test-grid/host/test-service.container-1',
           'name' => 'test-service.container-1',
@@ -102,126 +49,108 @@ describe Kontena::Cli::Services::ExecCommand do
           'instance_number' => 3,
           'status' => 'running',
         },
-      ] }
+      ]
     end
 
     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(Kontena::Websocket::Client).to receive(:new).with("#{master_url}v1/containers/test-grid/host/test-service.container-1/exec", anything).and_return(ws_client)
-      expect(ws_client).to receive(:text) do
-        respond_ok(ws_client)
+      expect(client).to receive(:get).with('services/test-grid/null/test-service/containers').and_return('containers' => service_containers)
+
+      expect(subject).to receive(:container_exec).with('test-grid/host/test-service.container-1', ['test'],
+        interactive: false, shell: false, tty: false,
+      ) do
+        puts 'ok 1'
+        0
       end
-      expect {
+
+      expect{
         subject.run(['test-service', 'test'])
-      }.to output("ok\n").to_stdout
+      }.to output_lines [ 'ok 1' ]
     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(Kontena::Websocket::Client).to receive(:new).with("#{master_url}v1/containers/test-grid/host/test-service.container-1/exec", anything).and_return(ws_client)
-      expect(ws_client).to receive(:text) do
-        respond_ok(ws_client)
-      end
-      expect {
-        subject.run(['test-service', 'test'])
-      }.to output("ok\n").to_stdout
+      expect(client).to receive(:get).with('services/test-grid/null/test-service/containers').and_return('containers' => service_containers.reverse)
+
+      expect(subject).to receive(:container_exec).with('test-grid/host/test-service.container-1', ['test'],
+        interactive: false, shell: false, tty: false,
+      ).and_return(0)
+      expect{subject.run(['test-service', 'test'])}.to_not exit_with_error
     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(Kontena::Websocket::Client).to receive(:new).with("#{master_url}v1/containers/test-grid/host/test-service.container-1/exec", anything).and_return(ws_client)
-      expect(ws_client).to receive(:text) do
-        respond_ok(ws_client)
+    context do
+      before do
+        expect(client).to receive(:get).with('services/test-grid/null/test-service/containers').and_return('containers' => service_containers)
       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(Kontena::Websocket::Client).to receive(:new).with("#{master_url}v1/containers/test-grid/host/test-service.container-2/exec", anything).and_return(ws_client)
-      expect(ws_client).to receive(:text) do
-        respond_ok(ws_client)
+      it "Executes on the first running container if given" do
+        expect(subject).to receive(:container_exec).with('test-grid/host/test-service.container-1', ['test'],
+        interactive: false, shell: false, tty: false,
+        ).and_return(0)
+        expect{subject.run(['--instance=1', 'test-service', 'test'])}.to_not exit_with_error
       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
-      expect(client).to receive(:get).with('services/test-grid/null/test-service/containers').and_return(service_containers)
+      it "Executes on the second running container if given" do
+        expect(subject).to receive(:container_exec).with('test-grid/host/test-service.container-2', ['test'],
+        interactive: false, shell: false, tty: false,
+        ).and_return(0)
+        expect{subject.run(['--instance=2', 'test-service', 'test'])}.to_not exit_with_error
+      end
 
-      expect{subject.run(['--instance=4', 'test-service', 'test'])}.to exit_with_error.and output(/Service test-service does not have container instance 4/).to_stderr
-    end
+      it "Errors on a nonexistant container if given" do
+        expect{subject.run(['--instance=4', 'test-service', 'test'])}.to exit_with_error.and output(/Service test-service does not have container instance 4/).to_stderr
+      end
 
-    it "Executes on each running container" do
-      expect(client).to receive(:get).with('services/test-grid/null/test-service/containers').and_return(service_containers)
+      it "Executes on each running container" do
+        expect(subject).to receive(:container_exec).with('test-grid/host/test-service.container-1', ['test'],
+        interactive: false, shell: false, tty: false,
+        ).and_return(0)
+        expect(subject).to receive(:container_exec).with('test-grid/host/test-service.container-2', ['test'],
+        interactive: false, shell: false, tty: false,
+        ).and_return(0)
+        expect(subject).to receive(:container_exec).with('test-grid/host/test-service.container-3', ['test'],
+        interactive: false, shell: false, tty: false,
+        ).and_return(0)
 
-      3.times do |i|
-        ws_client = ws_client_class.new
-        expect(Kontena::Websocket::Client).to receive(:new).with("#{master_url}v1/containers/test-grid/host/test-service.container-#{i + 1}/exec", anything).and_return(ws_client)
-        expect(ws_client).to receive(:text) do
-          ws_client.receive_message({'stream' => 'stdout', 'chunk' => "test#{i + 1}\n"})
-          ws_client.receive_message({'exit' => 0})
-        end
+        subject.run(['--silent', '--all', 'test-service', 'test'])
       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(subject).to receive(:container_exec).with('test-grid/host/test-service.container-1', ['test'],
+        interactive: false, shell: false, tty: false,
+        ) { $stderr << 'error'; 1 }
 
-    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(Kontena::Websocket::Client).to receive(:new).with("#{master_url}v1/containers/test-grid/host/test-service.container-1/exec", anything).and_return(ws_client)
-      expect(ws_client).to receive(:text) do
-        respond_error(ws_client)
+        expect {
+          subject.run(['--silent', '--all', 'test-service', 'test'])
+        }.to exit_with_error.and output("error").to_stderr
       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)
-      i = 1
-      [:ok, :err].each do |status|
-        ws_client = ws_client_class.new
-        expect(Kontena::Websocket::Client).to receive(:new).with("#{master_url}v1/containers/test-grid/host/test-service.container-#{i}/exec", anything).and_return(ws_client)
-        expect(ws_client).to receive(:text) do
-          if status == :ok
-            respond_ok(ws_client)
-          else
-            respond_error(ws_client)
-          end
-        end
-        i += 1
+      it "Stops if the second container fails" do
+        expect(subject).to receive(:container_exec).with('test-grid/host/test-service.container-1', ['test'],
+        interactive: false, shell: false, tty: false,
+        ) { $stdout << 'ok 1'; 0 }
+        expect(subject).to receive(:container_exec).with('test-grid/host/test-service.container-2', ['test'],
+        interactive: false, shell: false, tty: false,
+        ) { $stderr << 'error 2'; 1 }
+
+        expect {
+          subject.run(['--silent', '--all', 'test-service', 'test'])
+        }.to exit_with_error.and output("ok 1").to_stdout.and output("error 2").to_stderr
       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)
 
-      i = 1
-      [:ok, :err, :ok].each do |status|
-        ws_client = ws_client_class.new
-        expect(Kontena::Websocket::Client).to receive(:new).with("#{master_url}v1/containers/test-grid/host/test-service.container-#{i}/exec", anything).and_return(ws_client)
-        expect(ws_client).to receive(:text) do
-          if status == :ok
-            respond_ok(ws_client)
-          else
-            respond_error(ws_client)
-          end
-        end
-        i += 1
+      it "Keeps going if the second container fails when using --skip" do
+        expect(subject).to receive(:container_exec).with('test-grid/host/test-service.container-1', ['test'],
+        interactive: false, shell: false, tty: false,
+        ) { puts 'ok 1'; 0}
+        expect(subject).to receive(:container_exec).with('test-grid/host/test-service.container-2', ['test'],
+        interactive: false, shell: false, tty: false,
+        ) { puts 'err 2'; 2 }
+        expect(subject).to receive(:container_exec).with('test-grid/host/test-service.container-3', ['test'],
+        interactive: false, shell: false, tty: false,
+        ) { puts 'ok 3'; 0 }
+
+        expect {
+          subject.run(['--silent', '--all', '--skip', 'test-service', 'test'])
+        }.to exit_with_error.and output_lines ['ok 1', 'err 2', 'ok 3']
       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

data/spec/support/client_helpers.rb

@@ -9,6 +9,8 @@ module ClientHelpers
       instance_double(Kontena::Client, :client)
     end
 
+    base.let(:master_url) { 'http://someurl.example.com/' }
+
     base.let(:token) do
       '1234567'
     end
@@ -21,17 +23,18 @@ module ClientHelpers
       {'current_server' => 'alias',
        'current_account' => 'kontena',
        'servers' => [
-           {'name' => 'some_master', 'url' => 'http://someurl.example.com'},
-           {'name' => 'alias', 'url' => 'http://someurl.example.com/', 'token' => token, 'account' => 'master', 'grid' => current_grid},
+           {'name' => 'some_master', 'url' => master_url },
+           {'name' => 'alias', 'url' => master_url, 'token' => token, 'account' => 'master', 'grid' => current_grid},
        ]
       }
     end
 
     base.before(:each) do
+      master_host = URI(master_url).host
       RSpec::Mocks.space.proxy_for(File).reset
       allow(subject).to receive(:client).and_return(client)
       allow(subject).to receive(:current_grid).and_return(current_grid)
-      allow(File).to receive(:exist?).with(File.join(Dir.home, '.kontena/certs/someurl.example.com.pem')).and_return(false)
+      allow(File).to receive(:exist?).with(File.join(Dir.home, ".kontena/certs/#{master_host}.pem")).and_return(false)
       allow(File).to receive(:exist?).with(File.join(Dir.home, '.kontena_client.json')).and_return(true)
       allow(File).to receive(:readable?).with(File.join(Dir.home, '.kontena_client.json')).and_return(true)
       allow(File).to receive(:read).and_call_original

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kontena-cli
 version: !ruby/object:Gem::Version
-  version: 1.4.0.pre1
+  version: 1.4.0.pre2
 platform: ruby
 authors:
 - Kontena, Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-26 00:00:00.000000000 Z
+date: 2017-07-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -193,19 +193,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: 0.8.0
 - !ruby/object:Gem::Dependency
-  name: websocket-driver-kontena
+  name: kontena-websocket-client
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.5
+        version: 0.1.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - '='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.6.5
+        version: 0.1.0
 description: Command-line client for the Kontena container and microservices platform
 email:
 - info@kontena.io
@@ -517,8 +517,6 @@ files:
 - lib/kontena/stacks_cache.rb
 - lib/kontena/stacks_client.rb
 - lib/kontena/util.rb
-- lib/kontena/websocket/client.rb
-- lib/kontena/websocket/client/connection.rb
 - lib/kontena_cli.rb
 - omnibus/.gitignore
 - omnibus/.kitchen.yml
@@ -590,6 +588,7 @@ files:
 - spec/kontena/cli/cloud/logout_command_spec.rb
 - spec/kontena/cli/cloud/master/add_command_spec.rb
 - spec/kontena/cli/common_spec.rb
+- spec/kontena/cli/containers/exec_command_spec.rb
 - spec/kontena/cli/containers/list_command_spec.rb
 - spec/kontena/cli/containers/logs_command_spec.rb
 - spec/kontena/cli/etcd/health_command_spec.rb
@@ -756,6 +755,7 @@ test_files:
 - spec/kontena/cli/cloud/logout_command_spec.rb
 - spec/kontena/cli/cloud/master/add_command_spec.rb
 - spec/kontena/cli/common_spec.rb
+- spec/kontena/cli/containers/exec_command_spec.rb
 - spec/kontena/cli/containers/list_command_spec.rb
 - spec/kontena/cli/containers/logs_command_spec.rb
 - spec/kontena/cli/etcd/health_command_spec.rb

data/lib/kontena/websocket/client.rb

@@ -1,12 +0,0 @@
-require 'websocket/driver'
-module Kontena
-  module Websocket
-    module Client
-      def self.new(*args)
-        Connection.new(*args)
-      end
-    end
-  end
-end
-
-require_relative 'client/connection'

data/lib/kontena/websocket/client/connection.rb

@@ -1,65 +0,0 @@
-require 'forwardable'
-require 'socket'
-require 'openssl'
-
-module Kontena
-  module Websocket
-    module Client
-      class Connection
-        extend Forwardable
-
-        FRAME_SIZE = 1024
-
-        attr_reader :url
-
-        # @param [String] url
-        # @param [Hash] options
-        def initialize(url, options = {})
-          @options = options
-          @url = url
-          @client = ::WebSocket::Driver.client(self)
-          if headers = options[:headers]
-            headers.each do |k, v|
-              @client.set_header(k, v)
-            end
-          end
-        end
-
-        def connect
-          uri = URI.parse(@url)
-          port = uri.port || (uri.scheme == "ws" ? 80 : 443)
-          @socket = ::TCPSocket.new(uri.host, port)
-          if uri.scheme == "wss"
-            ctx = ::OpenSSL::SSL::SSLContext.new
-            ctx.ssl_version = @options[:ssl_version] if @options[:ssl_version]
-            ctx.verify_mode = @options[:verify_mode] if @options[:verify_mode]
-            cert_store = ::OpenSSL::X509::Store.new
-            cert_store.set_default_paths
-            ctx.cert_store = cert_store
-            @socket = ::OpenSSL::SSL::SSLSocket.new(@socket, ctx)
-            @socket.connect
-          end
-          @client.start
-          Thread.new { self.read_socket }
-        end
-
-        def_delegators :@client, :text, :binary, :ping, :close, :protocol, :on
-
-        def write(buffer)
-          @socket.write(buffer)
-        end
-
-        def read_socket
-          loop do
-            begin
-              @client.parse(@socket.readpartial(FRAME_SIZE))
-            rescue EOFError
-              break
-            end
-          end
-        end
-      end
-    end
-  end
-end
-