kontena-cli 0.7.3 → 0.8.0

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

@@ -1,44 +0,0 @@
-require 'kontena/client'
-require_relative '../common'
-
-module Kontena::Cli::Services
-  class Logs
-    include Kontena::Cli::Common
-
-    ##
-    # @param [String] service_id
-    def show(service_id, options)
-      require_api_url
-      token = require_token
-      last_id = nil
-      loop do
-        query_params = last_id.nil? ? '' : "from=#{last_id}"
-        result = client(token).get("services/#{current_grid}/#{service_id}/container_logs?#{query_params}")
-        result['logs'].each do |log|
-          color = color_for_container(log['name'])
-          puts "#{log['name'][0..12].colorize(color)} | #{log['data']}"
-          last_id = log['id']
-        end
-        break unless options.follow
-        sleep(2)
-      end
-    end
-
-    def color_for_container(container_id)
-      color_maps[container_id] = colors.shift unless color_maps[container_id]
-      color_maps[container_id].to_sym
-    end
-
-    def color_maps
-      @color_maps ||= {}
-    end
-
-    def colors
-      if(@colors.nil? || @colors.size == 0)
-        @colors = [:green, :yellow, :magenta, :cyan, :red,
-          :light_green, :light_yellow, :ligh_magenta, :light_cyan, :light_red]
-      end
-      @colors
-    end
-  end
-end

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

@@ -1,175 +0,0 @@
-require 'kontena/client'
-require_relative '../common'
-require_relative 'services_helper'
-
-module Kontena::Cli::Services
-  class Services
-    include Kontena::Cli::Common
-    include Kontena::Cli::Services::ServicesHelper
-
-    def list
-      require_api_url
-      token = require_token
-
-      grids = client(token).get("grids/#{current_grid}/services")
-      puts "%-30.30s %-40.40s %-10s %-8s" % ['NAME', 'IMAGE', 'INSTANCES', 'STATEFUL']
-      grids['services'].each do |service|
-        state = service['stateful'] ? 'yes' : 'no'
-        puts "%-30.30s %-40.40s %-10.10s %-8s" % [service['name'], service['image'], service['container_count'], state]
-      end
-    end
-
-    def show(service_id)
-      require_api_url
-      token = require_token
-
-      service = get_service(token, service_id)
-      puts "#{service['id']}:"
-      puts "  status: #{service['state'] }"
-      puts "  stateful: #{service['stateful'] == true ? 'yes' : 'no' }"
-      puts "  scaling: #{service['container_count'] }"
-      puts "  image: #{service['image']}"
-      if service['cmd']
-        puts "  cmd: #{service['cmd'].join(' ')}"
-      else
-        puts "  cmd: -"
-      end
-
-      puts "  env: "
-      if service['env']
-        service['env'].each{|e| puts "    - #{e}"}
-      end
-      puts "  ports:"
-      service['ports'].each do |p|
-        puts "    - #{p['node_port']}:#{p['container_port']}/#{p['protocol']}"
-      end
-      puts "  links: "
-      if service['links']
-        service['links'].each do |l|
-          puts "    - #{l['alias']}"
-        end
-      end
-      puts "  containers:"
-      result = client(token).get("services/#{parse_service_id(service_id)}/containers")
-      result['containers'].each do |container|
-        puts "    #{container['name']}:"
-        puts "      rev: #{container['deploy_rev']}"
-        puts "      node: #{container['node']['name']}"
-        puts "      dns: #{container['name']}.kontena.local"
-        puts "      ip: #{container['network_settings']['ip_address']}"
-        puts "      public ip: #{container['node']['public_ip']}"
-        if container['status'] == 'unknown'
-          puts "      status: #{container['status'].colorize(:yellow)}"
-        else
-          puts "      status: #{container['status']}"
-        end
-      end
-    end
-
-    def scale(service_id, count, options)
-      client(require_token).put("services/#{parse_service_id(service_id)}", {container_count: count})
-      self.deploy(service_id, options)
-    end
-
-    def deploy(service_id, options)
-      require_api_url
-      token = require_token
-      data = {}
-      data[:strategy] = options.strategy if options.strategy
-      data[:wait_for_port] = options.wait_for_port if options.wait_for_port
-      deploy_service(token, service_id, data)
-      self.show(service_id)
-    end
-
-
-    def restart(service_id)
-      require_api_url
-      token = require_token
-      result = client(token).post("services/#{parse_service_id(service_id)}/restart", {})
-    end
-
-    def stop(service_id)
-      require_api_url
-      token = require_token
-      result = client(token).post("services/#{parse_service_id(service_id)}/stop", {})
-    end
-
-    def start(service_id)
-      require_api_url
-      token = require_token
-
-      result = client(token).post("services/#{parse_service_id(service_id)}/start", {})
-    end
-
-    def create(name, image, options)
-      require_api_url
-      token = require_token
-      data = {
-        name: name,
-        image: image,
-        stateful: !!options.stateful
-      }
-      data.merge!(parse_data_from_options(options))
-      create_service(token, current_grid, data)
-    end
-
-
-    def update(service_id, options)
-      require_api_url
-      token = require_token
-
-      data = parse_data_from_options(options)
-      update_service(token, service_id, data)
-    end
-
-    def destroy(service_id)
-      require_api_url
-      token = require_token
-
-      result = client(token).delete("services/#{parse_service_id(service_id)}")
-    end
-
-    private
-
-    ##
-    # parse given options to hash
-    # @return [Hash]
-    def parse_data_from_options(options)
-      data = {}
-      data[:ports] = parse_ports(options.ports) if options.ports
-      data[:links] = parse_links(options.link) if options.link
-      data[:volumes] = options.volume if options.volume
-      data[:volumes_from] = options.volumes_from if options.volumes_from
-      data[:memory] = parse_memory(options.memory) if options.memory
-      data[:memory_swap] = parse_memory(options.memory_swap) if options.memory_swap
-      data[:cpu_shares] = options.cpu_shares if options.cpu_shares
-      data[:affinity] = options.affinity if options.affinity
-      data[:env] = parse_env_options(options.env) if options.env
-      data[:container_count] = options.instances if options.instances
-      data[:cmd] = options.cmd.split(" ") if options.cmd
-      data[:user] = options.user if options.user
-      data[:image] = options.image if options.image
-      data[:cap_add] = options.cap_add if options.cap_add
-      data[:cap_drop] = options.cap_drop if options.cap_drop
-      data
-    end
-
-    ##
-    # @param [Array<String>] values
-    # @return [Array<String>]
-    def parse_env_options(values)
-      copy = values.dup
-      copy.each_index do |i|
-        key, value = copy[i].split("=", 2)
-        if value.nil?
-          copy[i] = "#{values[i - 1]},#{values[i]}"
-        elsif key != key.upcase
-          copy[i - 1] = "#{values[i - 1]},#{values[i]}"
-          copy.delete_at(i)
-        end
-      end
-
-      copy
-    end
-  end
-end

data/lib/kontena/cli/stacks/commands.rb

@@ -1,13 +0,0 @@
-module Kontena::Cli::Stacks; end;
-require_relative 'stacks'
-
-command 'deploy' do |c|
-  c.syntax = 'kontena deploy'
-  c.description = 'Create and deploy multiple services from YAML file'
-  c.option '-f', '--file String', 'path to kontena.yml file, default: current directory'
-  c.option '-p', '--prefix String', 'prefix of service names, default: name of the current directory'
-  c.option '-s', '--service Array', Array, 'Services to deploy'
-  c.action do |args, options|
-    Kontena::Cli::Stacks::Stacks.new.deploy(options)
-  end
-end

data/spec/kontena/cli/server/user_spec.rb

@@ -1,59 +0,0 @@
-require_relative "../../../spec_helper"
-require "kontena/cli/server/user"
-
-module Kontena::Cli::Server
-  describe User do
-    describe '#register' do
-
-      let(:auth_client) do
-        double(Kontena::Client)
-      end
-
-      it 'asks email' do
-        expect(subject).to receive(:ask).once.and_return('john.doe@acme.io')
-        allow(subject).to receive(:password).and_return('secret')
-        allow(Kontena::Client).to receive(:new).and_return(auth_client)
-        allow(auth_client).to receive(:post)
-        subject.register(nil, {})
-      end
-
-      it 'asks password twice' do
-        allow(subject).to receive(:ask).once.and_return('john.doe@acme.io')
-        expect(subject).to receive(:password).twice.and_return('secret')
-        allow(Kontena::Client).to receive(:new).and_return(auth_client)
-        allow(auth_client).to receive(:post)
-        subject.register(nil, {})
-      end
-
-      it 'validates given passwords' do
-        allow(subject).to receive(:ask).once.and_return('john.doe@acme.io')
-        expect(subject).to receive(:password).twice.and_return('secret', 'secret2')
-        expect{subject.register(nil, {})}.to raise_error(ArgumentError)
-      end
-
-      it 'uses https://auth.kontena.io as default auth provider' do
-        allow(subject).to receive(:ask).and_return('john.doe@acme.io')
-        allow(subject).to receive(:password).and_return('secret')
-        expect(Kontena::Client).to receive(:new).with('https://auth.kontena.io').and_return(auth_client)
-        allow(auth_client).to receive(:post)
-        subject.register(nil, {})
-      end
-
-      it 'uses given auth provider' do
-        allow(subject).to receive(:ask).and_return('john.doe@acme.io')
-        allow(subject).to receive(:password).and_return('secret')
-        expect(Kontena::Client).to receive(:new).with('http://custom.auth-provider.io').and_return(auth_client)
-        allow(auth_client).to receive(:post)
-        subject.register('http://custom.auth-provider.io', {})
-      end
-
-      it 'sends register request to auth provider' do
-        allow(subject).to receive(:ask).and_return('john.doe@acme.io')
-        allow(subject).to receive(:password).and_return('secret')
-        allow(Kontena::Client).to receive(:new).with('https://auth.kontena.io').and_return(auth_client)
-        expect(auth_client).to receive(:post).with('users', {email: 'john.doe@acme.io', password: 'secret'})
-        subject.register(nil, {})
-      end
-    end
-  end
-end

data/spec/kontena/cli/stacks/stacks_spec.rb

@@ -1,212 +0,0 @@
-require_relative "../../../spec_helper"
-require "kontena/cli/stacks/stacks"
-
-module Kontena::Cli::Stacks
-  describe Stacks do
-    let(:settings) do
-      {'server' => {'url' => 'http://kontena.test', 'token' => token}}
-    end
-
-    let(:token) do
-      '1234567'
-    end
-
-    let(:yml) do
-      content = <<content
-wordpress:
-  image: wordpress:4.1
-  stateful: true
-  ports:
-    - 80:80
-  links:
-    - mysql:mysql
-  environment:
-    - WORDPRESS_DB_PASSWORD=%{prefix}_secret
-  instances: 2
-  deploy:
-    strategy: ha
-mysql:
-  image: mysql:5.6
-  stateful: true
-  environment:
-    - MYSQL_ROOT_PASSWORD=%{prefix}_secret
-content
-      content
-    end
-
-    let(:services) do
-      {
-          'wordpress' => {
-              'image' => 'wordpress:latest',
-              'links' => ['mysql:db'],
-              'ports' => ['80:80'],
-              'instances' => 2,
-              'deploy' => {
-                  'strategy' => 'ha'
-              }
-          },
-          'mysql' => {
-              'image' => 'mysql:5.6',
-              'stateful' => true
-          }
-      }
-    end
-
-    let(:client) do
-      double
-    end
-
-    let(:options) do
-      options = double({prefix: false, file: false, service: nil})
-    end
-
-    let(:env_vars) do
-      ["#comment line", "TEST_ENV_VAR=test", "MYSQL_ADMIN_PASSWORD=abcdef"]
-    end
-
-    let(:dot_env) do
-      ["TEST_ENV_VAR=test2","", "TEST_ENV_VAR2=test3"]
-    end
-
-    describe '#deploy' do
-      context 'when api_url is nil' do
-        it 'raises error' do
-          allow(subject).to receive(:settings).and_return({'server' => {}})
-          expect{subject.deploy({})}.to raise_error(ArgumentError)
-        end
-      end
-
-      context 'when token is nil' do
-        it 'raises error' do
-          allow(subject).to receive(:settings).and_return({'server' => {'url' => 'http://kontena.test'}})
-          expect{subject.deploy({})}.to raise_error(ArgumentError)
-        end
-      end
-
-      context 'when api url and token are valid' do
-        before(:each) do
-          allow(subject).to receive(:settings).and_return(settings)
-          allow(File).to receive(:read).and_return(yml)
-          allow(subject).to receive(:get_service).and_raise(Kontena::Errors::StandardError.new(404, 'Not Found'))
-          allow(subject).to receive(:create_service).and_return({'id' => 'kontena-test-mysql'},{'id' => 'kontena-test-wordpress'})
-          allow(subject).to receive(:current_grid).and_return('1')
-          allow(subject).to receive(:deploy_service).and_return(nil)
-        end
-
-        it 'reads ./kontena.yml file by default' do
-          allow(subject).to receive(:settings).and_return(settings)
-          expect(File).to receive(:read).with('./kontena.yml').and_return(yml)
-          expect(options).to receive(:file).once.and_return(false)
-          subject.deploy(options)
-        end
-
-        it 'reads given yml file' do
-          expect(options).to receive(:file).once.and_return('custom.yml')
-          expect(File).to receive(:read).with('custom.yml').and_return(yml)
-          subject.deploy(options)
-        end
-
-        it 'uses current directory as service name prefix by default' do
-          current_dir = '/kontena/tests/stacks'
-          allow(Dir).to receive(:getwd).and_return(current_dir)
-          expect(File).to receive(:basename).with(current_dir).and_return('stacks')
-          subject.deploy(options)
-        end
-
-        context 'when yml file has multiple env files' do
-          it 'merges environment variables correctly' do
-            allow(subject).to receive(:current_dir).and_return("kontena-test")
-            allow(YAML).to receive(:load).and_return(services)
-            services['wordpress']['environment'] = ['MYSQL_ADMIN_PASSWORD=password']
-            services['wordpress']['env_file'] = %w(/path/to/env_file .env)
-
-            expect(File).to receive(:readlines).with('/path/to/env_file').and_return(env_vars)
-            expect(File).to receive(:readlines).with('.env').and_return(dot_env)
-
-            data = {
-                :name =>"kontena-test-wordpress",
-                :image=>"wordpress:latest",
-                :env=>["MYSQL_ADMIN_PASSWORD=password", "TEST_ENV_VAR=test", "TEST_ENV_VAR2=test3"],
-                :container_count=>2,
-                :stateful=>false,
-                :links=>[{:name=>"kontena-test-mysql", :alias=>"db"}],
-                :ports=>[{:container_port=>"80", :node_port=>"80", :protocol=>"tcp"}]
-            }
-
-            expect(subject).to receive(:create_service).with('1234567', '1', data)
-            subject.deploy(options)
-          end
-        end
-
-        context 'when yml file has one env file' do
-          it 'merges environment variables correctly' do
-            allow(subject).to receive(:current_dir).and_return("kontena-test")
-            allow(YAML).to receive(:load).and_return(services)
-            services['wordpress']['environment'] = ['MYSQL_ADMIN_PASSWORD=password']
-            services['wordpress']['env_file'] = '/path/to/env_file'
-
-            expect(File).to receive(:readlines).with('/path/to/env_file').and_return(env_vars)
-
-            data = {
-                :name =>"kontena-test-wordpress",
-                :image=>"wordpress:latest",
-                :env=>["MYSQL_ADMIN_PASSWORD=password", "TEST_ENV_VAR=test"],
-                :container_count=>2,
-                :stateful=>false,
-                :links=>[{:name=>"kontena-test-mysql", :alias=>"db"}],
-                :ports=>[{:container_port=>"80", :node_port=>"80", :protocol=>"tcp"}]
-            }
-
-            expect(subject).to receive(:create_service).with('1234567', '1', data)
-            subject.deploy(options)
-          end
-        end
-
-        it 'creates mysql service before wordpress' do
-          allow(subject).to receive(:current_dir).and_return("kontena-test")
-          data = {:name =>"kontena-test-mysql", :image=>'mysql:5.6', :env=>["MYSQL_ROOT_PASSWORD=kontena-test_secret"], :container_count=>nil, :stateful=>true}
-          expect(subject).to receive(:create_service).with('1234567', '1', data)
-
-          subject.deploy(options)
-        end
-
-        it 'creates wordpress service' do
-          allow(subject).to receive(:current_dir).and_return("kontena-test")
-
-          data = {
-              :name =>"kontena-test-wordpress",
-              :image=>"wordpress:4.1",
-              :env=>["WORDPRESS_DB_PASSWORD=kontena-test_secret"],
-              :container_count=>2,
-              :stateful=>true,
-              :links=>[{:name=>"kontena-test-mysql", :alias=>"mysql"}],
-              :ports=>[{:container_port=>"80", :node_port=>"80", :protocol=>"tcp"}]
-          }
-          expect(subject).to receive(:create_service).with('1234567', '1', data)
-
-          subject.deploy(options)
-        end
-
-        it 'deploys services' do
-          allow(subject).to receive(:current_dir).and_return("kontena-test")
-          expect(subject).to receive(:deploy_service).with('1234567', 'kontena-test-mysql', {})
-          expect(subject).to receive(:deploy_service).with('1234567', 'kontena-test-wordpress', {:strategy => 'ha'})
-          subject.deploy(options)
-        end
-
-        context 'when giving service option' do
-          it 'deploys only given services' do
-            allow(subject).to receive(:current_dir).and_return("kontena-test")
-            allow(options).to receive(:service).and_return(['wordpress'])
-            allow(subject).to receive(:deploy_services).and_return({})
-            expect(subject).to receive(:create).once.with('wordpress', anything).and_return({})
-            expect(subject).not_to receive(:create).with('mysql', services['mysql'])
-
-            subject.deploy(options)
-          end
-        end
-      end
-
-    end
-  end
-end