kontena-cli 0.13.4 → 0.14.0

data/lib/kontena/machine/upcloud/node_destroyer.rb

@@ -0,0 +1,82 @@
+require 'shell-spinner'
+
+module Kontena
+  module Machine
+    module Upcloud
+      class NodeDestroyer
+        include RandomName
+        include UpcloudCommon
+
+        attr_reader :api_client, :username, :password
+
+        # @param [Kontena::Client] api_client Kontena api client
+        # @param [String] token Upcloud token
+        def initialize(api_client, upcloud_username, upcloud_password)
+          @api_client = api_client
+          @username = upcloud_username
+          @password = upcloud_password
+        end
+
+        def run!(grid, name)
+          servers = get('server')
+          unless servers && servers.has_key?(:servers)
+            abort('Upcloud API error')
+          end
+
+          server = servers[:servers][:server].find{|s| s[:hostname] == name}
+            
+          abort "Cannot find node #{name.colorize(:cyan)} in Upcloud" unless server
+
+          server_data = get("server/#{server[:uuid]}")
+
+          storage_devices = server_data.fetch(:server, {}).fetch(:storage_devices, {}).fetch(:storage_device, [])
+          storage_uuids = storage_devices.map{|s| s[:storage]}
+
+          abort('No storage devices found for Upcloud node') if storage_uuids.empty?
+
+          if server
+            unless server[:state].eql?('stopped')
+              ShellSpinner "Shutting down Upcloud node #{name.colorize(:cyan)} " do
+                device_data = post(
+                  "server/#{server[:uuid]}/stop", body: {
+                    stop_server: {
+                      stop_type: 'soft',
+                      timeout: 120
+                    }
+                  }.to_json
+                )
+
+                until device_data && device_data.fetch(:state, nil).to_s.eql?('stopped')
+                  device_data = get("server/#{server[:uuid]}").fetch(:server, {}) rescue nil
+                  sleep 5
+                end
+              end
+            end
+
+            ShellSpinner "Terminating Upcloud node #{name.colorize(:cyan)} " do
+              response = delete("server/#{server[:uuid]}")
+              abort "Cannot delete node #{name.colorize(:cyan)} in Upcloud" unless response[:success]
+            end
+
+            storage_uuids.each do |uuid|
+              ShellSpinner "Deleting Upcloud storage device '#{uuid.colorize(:cyan)}' " do
+                response = delete("storage/#{uuid}")
+                unless response[:success]
+                  puts "#{"WARNING".colorize(:red)}: Couldn't delete Upcloud storage '#{uuid.colorize(:cyan)}', check manually."
+                end
+              end
+            end
+          else
+            abort "Cannot find node #{name.colorize(:cyan)} in Upcloud"
+          end
+          node = api_client.get("grids/#{grid['id']}/nodes")['nodes'].find{|n| n['name'] == name}
+          if node
+            ShellSpinner "Removing node #{name.colorize(:cyan)} from grid #{grid['name'].colorize(:cyan)} " do
+              api_client.delete("grids/#{grid['id']}/nodes/#{name}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kontena/machine/upcloud/node_provisioner.rb

@@ -0,0 +1,119 @@
+require 'fileutils'
+require 'erb'
+require 'open3'
+require 'shell-spinner'
+
+module Kontena
+  module Machine
+    module Upcloud
+      class NodeProvisioner
+        include RandomName
+        include UpcloudCommon
+
+        attr_reader :api_client, :username, :password
+
+        # @param [Kontena::Client] api_client Kontena api client
+        # @param [String] upcloud_username Upcloud username
+        # @param [String] upcloud_password Upcloud password
+        def initialize(api_client, upcloud_username, upcloud_password)
+          @api_client = api_client
+          @username = upcloud_username
+          @password = upcloud_password
+        end
+
+        def run!(opts)
+          if File.readable?(File.expand_path(opts[:ssh_key]))
+            ssh_key = File.read(File.expand_path(opts[:ssh_key])).strip
+          end
+
+          abort('Invalid ssh key') unless ssh_key && ssh_key.start_with?('ssh-')
+
+          userdata_vars = {
+            version: opts[:version],
+            master_uri: opts[:master_uri],
+            grid_token: opts[:grid_token],
+          }
+
+          abort('CoreOS template not found on Upcloud') unless coreos_template = find_template('CoreOS Stable')
+          abort('Server plan not found on Upcloud') unless plan = find_plan(opts[:plan])
+          abort('Zone not found on Upcloud') unless zone_exist?(opts[:zone])
+
+          hostname = generate_name
+
+          device_data = {
+            server: {
+              zone: opts[:zone],
+              title: "Kontena Grid #{opts[:grid]} Node #{hostname}",
+              hostname: hostname,
+              plan: plan[:name],
+              vnc: 'off',
+              timezone: 'UTC',
+              user_data: user_data(userdata_vars),
+              firewall: 'off',
+              storage_devices: {
+                storage_device: [
+                  {
+                    action: 'clone',
+                    storage: coreos_template[:uuid],
+                    title: "From template #{coreos_template[:title]}",
+                    size: plan[:storage_size],
+                    tier: 'maxiops'
+                  }
+                ]
+              },
+              login_user: {
+                create_password: 'no',
+                username: 'root',
+                ssh_keys: {
+                  ssh_key: [ssh_key]
+                }
+              }
+            }
+          }.to_json
+
+          ShellSpinner "Creating Upcloud node #{hostname.colorize(:cyan)} " do
+            response = post('server', body: device_data)
+
+            if response.has_key?(:error)
+              abort("\nUpcloud server creation failed (#{response[:error].fetch(:error_message, '')})")
+            end
+            device_data = response[:server]
+
+            until device_data && device_data.fetch(:state, nil).to_s == 'maintenance'
+              device_data = get("server/#{device[:uuid]}").fetch(:server, {}) rescue nil
+              sleep 5
+            end
+          end
+
+          node = nil
+          ShellSpinner "Waiting for node #{hostname.colorize(:cyan)} join to grid #{opts[:grid].colorize(:cyan)} " do
+            sleep 2 until node = node_exists_in_grid?(opts[:grid], hostname)
+          end
+          set_labels(node, ["region=#{opts[:zone]}", "provider=upcloud"])
+        end
+
+        def user_data(vars)
+          cloudinit_template = File.join(__dir__ , '/cloudinit.yml')
+          erb(File.read(cloudinit_template), vars)
+        end
+
+        def generate_name
+          "#{super}-#{rand(1..99)}"
+        end
+
+        def node_exists_in_grid?(grid, hostname)
+          api_client.get("grids/#{grid}/nodes")['nodes'].find{|n| n['name'] == hostname}
+        end
+
+        def erb(template, vars)
+          ERB.new(template).result(OpenStruct.new(vars).instance_eval { binding })
+        end
+
+        def set_labels(node, labels)
+          data = {labels: labels}
+          api_client.put("nodes/#{node['id']}", data, {}, {'Kontena-Grid-Token' => node['grid']['token']})
+        end
+      end
+    end
+  end
+end

data/lib/kontena/machine/upcloud/node_restarter.rb

@@ -0,0 +1,47 @@
+require 'shell-spinner'
+
+module Kontena
+  module Machine
+    module Upcloud
+      class NodeRestarter
+        include RandomName
+        include UpcloudCommon
+
+        attr_reader :username, :password
+
+        # @param [String] upcloud_username Upcloud username
+        # @param [String] upcloud_password Upcloud password
+        def initialize(upcloud_username, upcloud_password)
+          @username = upcloud_username
+          @password = upcloud_password
+        end
+
+        def run!(name)
+          servers = get('server')
+          unless servers && servers.has_key?(:servers)
+            abort('Upcloud API error')
+          end
+
+          server = servers[:servers][:server].find{|s| s[:hostname] == name}
+
+          if server
+            ShellSpinner "Restarting Upcloud node #{name.colorize(:cyan)} " do
+              result = post(
+                "server/#{server[:uuid]}/restart", body: {
+                  restart_server: {
+                    stop_type: 'soft',
+                    timeout: 600,
+                    timeout_action: 'ignore'
+                  }
+                }.to_json
+              )
+            end
+          else
+            abort "Cannot find node #{name.colorize(:cyan)} in Upcloud"
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/kontena/machine/upcloud/upcloud_common.rb

@@ -0,0 +1,70 @@
+require 'excon'
+require 'json'
+
+module Kontena
+  module Machine
+    module Upcloud
+      module UpcloudCommon
+
+        attr_reader :username
+        attr_reader :password
+        
+        def client
+          @client ||= Excon.new(
+            'https://api.upcloud.com',
+            omit_default_port: true,
+            user: username,
+            password: password,
+            headers: { "Accept-Encoding" => 'application/json' }
+          )
+        end
+
+        def find_template(name)
+          get('storage/template')[:storages][:storage].find{|s| s[:title].downcase.start_with?(name.downcase)}
+        end
+        
+        def find_plan(name)
+          get('plan')[:plans][:plan].find{|s| s[:name].downcase.eql?(name.downcase)}
+        end
+
+        def zone_exist?(name)
+          get('zone')[:zones][:zone].map{|p| p[:id]}.include?(name)
+        end
+
+        def get_server(id)
+          get("server/#{id}").fetch(:server, nil)
+        end
+
+        [:get, :post, :delete].each do |http_method|
+          define_method http_method do |path, opts={}|
+            response = client.send(
+              http_method, 
+              opts.merge(
+                path: File.join('/1.2', path),
+                headers: {
+                  'Content-Type': 'application/json'
+                }
+              )
+            )
+            if response.body && response.body.start_with?('{')
+              JSON.parse(response.body, symbolize_names: true)
+            elsif response.status.to_s.start_with?('2')
+              {success: true}
+            else
+              {error: response.status}
+            end
+          end
+        end
+      end
+    end
+  end
+end
+
+class Testing
+  include Kontena::Machine::Upcloud::UpcloudCommon
+  def initialize(user, pass)
+    @username = user
+    @password = pass
+  end
+end
+

data/lib/kontena/scripts/completer

@@ -55,8 +55,13 @@ class Helper
   end
 
   def yml_services
-    if File.exist?('kontena.yml')
-      services = YAML.load(File.read('kontena.yml'))
+    if File.exist?('kontena.yml')      
+      yaml = YAML.load(File.read('kontena.yml'))
+      if yaml['version'] == '2'
+        services = yaml['services']
+      else
+        services = yaml
+      end
       services.keys
     end
   rescue
@@ -144,7 +149,7 @@ if words.size > 0
       completion.push %w(add list delete)
     when 'app'
       completion.clear
-      sub_commands = %w(init build deploy start stop remove rm ps list
+      sub_commands = %w(init build config deploy start stop remove rm ps list
                         logs monitor show)
       if words[1]
         completion.push(sub_commands) unless sub_commands.include?(words[1])

data/spec/fixtures/docker-compose_v2.yml

@@ -0,0 +1,10 @@
+version: '2'
+services:
+  wordpress:
+    image: wordpress:4.1
+    ports:
+      - 80:80
+    depends_on:
+      - mysql
+  mysql:
+    image: mysql:5.6

data/spec/fixtures/kontena-invalid.yml

@@ -0,0 +1,4 @@
+wordpress:
+  stateful: 'true'
+  environment:
+    WORDPRESS_DB_PASSWORD: %{project}_secret

data/spec/fixtures/kontena-with-variables.yml

@@ -0,0 +1,19 @@
+wordpress:
+  extends:
+    file: docker-compose.yml
+    service: wordpress
+  image: wordpress:$TAG
+  stateful: true
+  environment:
+    - WORDPRESS_DB_PASSWORD=%{project}_secret
+  instances: 2
+  deploy:
+    strategy: ha
+mysql:
+  extends:
+    file: docker-compose.yml
+    service: mysql
+  image: ${MYSQL_IMAGE}
+  stateful: true
+  environment:
+    - INTERNAL_VAR=$$INTERNAL_VAR

data/spec/fixtures/kontena.yml

@@ -4,7 +4,7 @@ wordpress:
     service: wordpress
   stateful: true
   environment:
-    - WORDPRESS_DB_PASSWORD=%{project}_secret
+    WORDPRESS_DB_PASSWORD: %{project}_secret
   instances: 2
   deploy:
     strategy: ha
@@ -14,4 +14,4 @@ mysql:
     service: mysql
   stateful: true
   environment:
-    - MYSQL_ROOT_PASSWORD=%{project}_secret
+    - MYSQL_ROOT_PASSWORD=%{project}_secret

data/spec/fixtures/kontena_v2.yml

@@ -0,0 +1,35 @@
+version: '2'
+name: test-project
+services:
+  wordpress:
+    extends:
+      file: docker-compose_v2.yml
+      service: wordpress
+    stateful: true
+    environment:
+      WORDPRESS_DB_PASSWORD: ${project}_secret
+    instances: 2
+    deploy:
+      strategy: ha
+    networks:
+      - front-tier
+      - back-tier
+  mysql:
+    extends:
+      file: docker-compose_v2.yml
+      service: mysql
+    stateful: true
+    environment:
+      - MYSQL_ROOT_PASSWORD=${project}_secret
+    volumes:
+      - mysql-data:/var/lib/mysql
+    networks:
+      - back-tier
+volumes:
+  mysql-data:
+    driver: local
+networks:
+  front-tier:
+    driver: bridge
+  back-tier:
+    driver: bridge

data/spec/kontena/cli/app/common_spec.rb

@@ -13,6 +13,10 @@ describe Kontena::Cli::Apps::Common do
     fixture('kontena.yml')
   end
 
+  let(:kontena_v2_yml) do
+    fixture('kontena_v2.yml')
+  end
+
   let(:docker_compose_yml) do
     fixture('docker-compose.yml')
   end
@@ -30,122 +34,56 @@ describe Kontena::Cli::Apps::Common do
     }
   end
 
-  describe '#parse_services' do
-
-    it 'returns services from given YAML file' do
-      allow(File).to receive(:read).with("#{Dir.getwd}/kontena.yml").and_return(kontena_yml)
-      allow(File).to receive(:read).with("#{Dir.getwd}/docker-compose.yml").and_return(docker_compose_yml)
-      services = subject.parse_services('kontena.yml')
-      expect(services['wordpress']).not_to be_nil
+  describe '#service_prefix' do
+    it 'returns given project name' do
+      allow(subject).to receive(:project_name).and_return('test')
+      expect(subject.service_prefix).to eq('test')
     end
 
-    it 'raises error if extended service is not found from base file' do
-      allow(File).to receive(:read).with("#{Dir.getwd}/kontena.yml").and_return(kontena_yml)
-      allow(File).to receive(:read).with("#{Dir.getwd}/docker-compose.yml").and_return(mysql_yml)
-
-      expect {
-        subject.parse_services('kontena.yml')
-      }.to raise_error(SystemExit)
+    it 'returns app name from yaml if project name not given' do
+      allow(subject).to receive(:project_name).and_return(nil)
+      allow(subject).to receive(:filename).and_return('kontena.yml')
+      allow(File).to receive(:read).with("#{Dir.getwd}/docker-compose_v2.yml").and_return(docker_compose_yml)
+      allow(File).to receive(:read).with("#{Dir.getwd}/kontena.yml").and_return(kontena_v2_yml)
+      expect(subject.service_prefix).to eq('test-project')
     end
-  end
 
-  describe '#normalize_env_vars' do
-    it 'converts env hash to array' do
-      opts = {
-          'environment' => {
-              'FOO' => 'bar',
-              'BAR' => 'baz'
-          }
-      }
-      subject.normalize_env_vars(opts)
-      env = opts['environment']
-      expect(env).to include('FOO=bar')
-      expect(env).to include('BAR=baz')
-    end
-
-    it 'does nothing to env array' do
-      opts = {
-          'environment' => [
-              'FOO=bar', 'BAR=baz'
-          ]
-      }
-      subject.normalize_env_vars(opts)
-      env = opts['environment']
-      expect(env).to include('FOO=bar')
-      expect(env).to include('BAR=baz')
+    it 'returns current dir as default' do
+      allow(subject).to receive(:project_name).and_return(nil)
+      allow(subject).to receive(:filename).and_return('kontena.yml')
+      allow(subject).to receive(:project_name_from_yaml).and_return(nil)
+      allow(subject).to receive(:current_dir).and_return('working_dir')
+      expect(subject.service_prefix).to eq('working_dir')
     end
   end
 
-  describe '#extend_env_vars' do
-    it 'inherites env vars from upper level' do
-      from = ['FOO=bar']
-      to = nil
-      env_vars = subject.extend_env_vars(from, to)
-      expect(env_vars).to eq(['FOO=bar'])
-    end
-
-    it 'overrides values' do
-      from = ['FOO=bar']
-      to = ['FOO=baz']
-      env_vars = subject.extend_env_vars(from, to)
-      expect(env_vars).to eq(['FOO=baz'])
+  describe '#load_from_yaml' do
+    before(:each) do
+      allow(File).to receive(:read).with("#{Dir.getwd}/kontena.yml").and_return(kontena_yml)
+      allow(File).to receive(:read).with("#{Dir.getwd}/docker-compose.yml").and_return(docker_compose_yml)
     end
 
-    it 'combines variables' do
-      from = ['FOO=bar']
-      to = ['BAR=baz']
-      env_vars = subject.extend_env_vars(from, to)
-      expect(env_vars).to eq(['BAR=baz', 'FOO=bar'])
+    it 'populates env variables' do
+      services = subject.services_from_yaml('kontena.yml',[],'load-test')
+      expect(ENV['grid']).to eq('test-grid')
+      expect(ENV['project']).to eq('load-test')
     end
-  end
 
-  describe '#extend_secrets' do
-    it 'inherites secrets from upper level' do
-      secret = {
-        'secret' => 'CUSTOMER_DB_PASSWORD',
-        'name' => 'MYSQL_PASSWORD',
-        'type' => 'env'
-      }
-      from = [secret]
-      to = nil
-      secrets = subject.extend_secrets(from, to)
-      expect(secrets).to eq([secret])
+    it 'returns services from given YAML file' do
+      services = subject.services_from_yaml('kontena.yml',[],'')
+      expect(services['wordpress']).not_to be_nil
     end
 
-    it 'overrides secrets' do
-      from_secret = {
-        'secret' => 'CUSTOMER_DB_PASSWORD',
-        'name' => 'MYSQL_PASSWORD',
-        'type' => 'env'
-      }
-
-      to_secret = {
-        'secret' => 'CUSTOMER_DB_PASSWORD',
-        'name' => 'MYSQL_ROOT_PASSWORD',
-        'type' => 'env'
-      }
-      from = [from_secret]
-      to = [to_secret]
-      secrets = subject.extend_secrets(from, to)
-      expect(secrets).to eq([to_secret])
+    it 'aborts on validation failure' do
+      allow_any_instance_of(Kontena::Cli::Apps::YAML::Validator).to receive(:validate)
+        .and_return({ :errors => [{ 'wordress' => [] }], :notifications => [] })
+      expect { subject.services_from_yaml('kontena.yml',[],'') }.to raise_error(SystemExit)
     end
 
-    it 'combines secrets' do
-      from_secret = {
-        'secret' => 'CUSTOMER_DB_PASSWORD',
-        'name' => 'MYSQL_PASSWORD',
-        'type' => 'env'
-      }
-
-      to_secret = {
-        'secret' => 'CUSTOMER_API_TOKEN',
-        'name' => 'API_TOKEN',
-        'type' => 'env'
-      }
-      from = [from_secret]
-      to = [to_secret]
-      secrets = subject.extend_secrets(from, to)
-      expect(secrets).to eq([to_secret, from_secret])
+    it 'returns given service from given YAML file' do
+      services = subject.services_from_yaml('kontena.yml',['wordpress'],'')
+      expect(services['wordpress']).not_to be_nil
+      expect(services.size).to eq(1)
     end
   end
 end