krates 1.6.0

data/lib/kontena/cli/nodes/show_command.rb

@@ -0,0 +1,56 @@
+module Kontena::Cli::Nodes
+  class ShowCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include Kontena::Cli::BytesHelper
+
+    parameter "NODE", "Node name"
+
+    def execute
+      require_api_url
+      require_current_grid
+      token = require_token
+
+      node = client(token).get("nodes/#{current_grid}/#{self.node}")
+      puts "#{node['id']}:"
+      puts "  id: #{node['node_id']}"
+      puts "  agent version: #{node['agent_version']}"
+      puts "  docker version: #{node['docker_version']}"
+      puts "  connected: #{node['connected'] ? 'yes': 'no'}"
+      puts "  last connect: #{node['connected_at']}"
+      puts "  last seen: #{node['last_seen_at']}"
+      puts "  availability: #{node['availability']}"
+      puts "  public ip: #{node['public_ip']}"
+      puts "  private ip: #{node['private_ip']}"
+      puts "  overlay ip: #{node['overlay_ip']}"
+      puts "  os: #{node['os']}"
+      puts "  kernel: #{node['kernel_version']}"
+      puts "  drivers:"
+      puts "    storage: #{node['driver']}"
+      puts "    volume: #{node['volume_drivers'].to_a.map{|v| v['name']}.join(',')}"
+      puts "  initial node: #{node['initial_member'] ? 'yes' : 'no'}"
+      puts "  labels:"
+      if node['labels']
+        node['labels'].each{|l| puts "    - #{l}"}
+      end
+      puts "  stats:"
+      puts "    cpus: #{node['cpus']}"
+      loads = node.dig('resource_usage', 'load')
+      if loads
+        puts "    load: #{loads['1m'].round(2)} #{loads['5m'].round(2)} #{loads['15m'].round(2)}"
+      end
+      mem = node.dig('resource_usage', 'memory')
+      if mem
+        mem_used = mem['used'] - (mem['cached'] + mem['buffers'])
+        puts "    memory: #{to_gigabytes(mem_used, 2)} of #{to_gigabytes(mem['total'], 2)} GB"
+      end
+      fs = node.dig('resource_usage','filesystem')
+      if fs
+        puts "    filesystem:"
+        fs.each do |filesystem|
+          puts "      - #{filesystem['name']}: #{to_gigabytes(filesystem['used'], 2)} of #{to_gigabytes(filesystem['total'], 2)} GB"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,63 @@
+require 'kontena/plugin_manager'
+
+module Kontena::Cli::Nodes
+  class SshCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+
+    usage "[OPTIONS] [NODE] -- [COMMANDS] ..."
+
+    parameter "[NODE]", "SSH to Grid node. Use --any to connect to the first available node"
+    parameter "[COMMANDS] ...", "Run command on host"
+    option ["-a", "--any"], :flag, "Connect to first available node"
+    option ["-i", "--identity-file"], "IDENTITY_FILE", "Path to ssh private key"
+    option ["-u", "--user"], "USER", "Login as a user", default: "core"
+    option "--private-ip", :flag, "Connect to node's private IP address"
+    option "--internal-ip", :flag, "Connect to node's internal IP address (requires VPN connection)"
+
+    requires_current_master
+    requires_current_grid
+
+    def execute
+      exit_with_error "Cannot combine --any with a node name" if self.node && any?
+
+      if self.node
+        node = client.get("nodes/#{current_grid}/#{self.node}")
+      elsif any?
+        nodes = client.get("grids/#{current_grid}/nodes")['nodes']
+        node = nodes.find{ |node| node['connected'] }
+        exit_with_error "There are no online nodes" if node.nil?
+      else
+        exit_with_error "No node name given. Use --any to connect to the first available node"
+      end
+
+      provider = Array(node["labels"]).find{ |l| l.start_with?('provider=')}.to_s.split('=').last
+
+      if provider == 'vagrant'
+        unless Kontena::PluginManager::Common.installed?('vagrant')
+          exit_with_error 'You need to install vagrant plugin to ssh into this node. Use kontena plugin install vagrant'
+        end
+        cmd = ['vagrant', 'node', 'ssh', node['name']]
+        unless commands_list.empty?
+          cmd << '--'
+          cmd.concat(commands_list)
+        end
+        Kontena.run!(cmd)
+      else
+        cmd = ['ssh']
+        cmd += ["-i", identity_file] if identity_file
+        if internal_ip?
+          ip = node['overlay_ip']
+        elsif private_ip?
+          ip = node['private_ip']
+        else
+          ip = node['public_ip']
+        end
+        cmd << "#{user}@#{ip}"
+        cmd += commands_list
+        logger.debug { "Running ssh command: #{cmd.inspect}" }
+        exec(*cmd)
+      end
+    end
+  end
+end

data/lib/kontena/cli/nodes/update_command.rb

@@ -0,0 +1,31 @@
+module Kontena::Cli::Nodes
+  class UpdateCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+
+    requires_current_master
+    requires_current_master_token
+    requires_current_grid
+
+    parameter "NODE ...", "Node name", attribute_name: :nodes
+
+    option ["-l", "--label"], "LABEL", "Node label", multivalued: true
+    option "--clear-labels", :flag, "Clear node labels"
+    option "--availability", "active|drain", "Node scheduling availability"
+
+    def execute
+      data = {}
+
+      data[:labels] = self.label_list unless self.label_list.empty?
+      data[:labels] = [] if self.clear_labels?
+
+      data[:availability] = availability if availability
+
+      nodes.each do |node_name|
+        spinner "Updating node #{pastel.cyan(node_name)} " do
+          client.put("nodes/#{current_grid}/#{node_name}", data)
+        end
+      end
+    end
+  end
+end

data/lib/kontena/cli/plugin_command.rb

@@ -0,0 +1,12 @@
+
+class Kontena::Cli::PluginCommand < Kontena::Command
+
+  subcommand ["list","ls"], "List plugins", load_subcommand('plugins/list_command')
+  subcommand "search", "Search plugins", load_subcommand('plugins/search_command')
+  subcommand "install", "Install a plugin", load_subcommand('plugins/install_command')
+  subcommand "uninstall", "Uninstall a plugin", load_subcommand('plugins/uninstall_command')
+  subcommand "upgrade", "Upgrade plugins", load_subcommand('plugins/upgrade_command')
+
+  def execute
+  end
+end

data/lib/kontena/cli/plugins/common.rb

@@ -0,0 +1,8 @@
+module Kontena::Cli::Plugins
+  module Common
+
+    def short_name(name)
+      name.sub('kontena-plugin-', '')
+    end
+  end
+end

data/lib/kontena/cli/plugins/install_command.rb

@@ -0,0 +1,42 @@
+require 'kontena/plugin_manager'
+
+module Kontena::Cli::Plugins
+  class InstallCommand < Kontena::Command
+    include Kontena::Util
+    include Kontena::Cli::Common
+    include Kontena::PluginManager::Common
+
+    parameter 'NAME', 'Plugin name'
+
+    option ['-v', '--version'], 'VERSION', 'Specify version of plugin to install'
+    option '--pre', :flag, 'Allow pre-release of a plugin to be installed', default: false
+
+    def installer
+      Kontena::PluginManager::Installer.new(name, pre: pre?, version: version)
+    end
+
+    def execute
+      if installed?(name)
+        installed = spinner "Upgrading plugin #{pastel.cyan(name)}" do
+          installer.upgrade
+        end
+
+        spinner "Running cleanup" do |spin|
+          Kontena::PluginManager::Cleaner.new(name).cleanup
+        end
+      else
+        installed = spinner "Installing plugin #{pastel.cyan(name)}" do
+          installer.install
+        end
+      end
+
+      Array(installed).each do |gem|
+        if gem.name.start_with?('kontena-plugin-')
+          puts Kontena.pastel.green("Installed plugin #{gem.name.sub('kontena-plugin-', '')} version #{gem.version}")
+        else
+          puts Kontena.pastel.cyan("Installed dependency #{gem.name} version #{gem.version}")
+        end
+      end
+    end
+  end
+end

data/lib/kontena/cli/plugins/list_command.rb

@@ -0,0 +1,31 @@
+require 'kontena/plugin_manager'
+require_relative 'common'
+
+module Kontena::Cli::Plugins
+  class ListCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::TableGenerator::Helper
+    include Common
+    include Kontena::PluginManager::Common
+
+    banner "List installed plugins"
+
+    def fields
+      quiet? ? [:name] : %i(name version description)
+    end
+
+    def plugin_list
+      plugins.map do |plugin|
+        {
+          name: short_name(plugin.name),
+          version: plugin.version,
+          description: plugin.description
+        }
+      end
+    end
+
+    def execute
+      print_table(plugin_list)
+    end
+  end
+end

data/lib/kontena/cli/plugins/search_command.rb

@@ -0,0 +1,25 @@
+require_relative 'common'
+require 'kontena/plugin_manager'
+
+module Kontena::Cli::Plugins
+  class SearchCommand < Kontena::Command
+    include Common
+    include Kontena::PluginManager::Common
+
+    parameter '[NAME]', 'Search text'
+    option '--pre', :flag, 'Include pre-release versions'
+
+    def execute
+      results = search_plugins(name)
+      exit_with_error("Cannot access plugin server") unless results
+      puts "%-50s %-10s %-60s" % ['NAME', 'VERSION', 'DESCRIPTION']
+      results.each do |item|
+        if pre?
+          latest = rubygems_client.latest_version(item['name'], pre: true)
+          item['version'] = latest.version.to_s
+        end
+        puts "%-50s %-10s %-60s" % [short_name(item['name']), item['version'], item['info']]
+      end
+    end
+  end
+end

data/lib/kontena/cli/plugins/show_command.rb

@@ -0,0 +1,17 @@
+require 'kontena/plugin_manager'
+
+module Kontena::Cli::Plugins
+  class ShowCommand < Kontena::Command
+    parameter 'NAME', 'Plugin name' do |name|
+      "kontena-plugin-#{name}"
+    end
+
+    def execute
+      require 'yaml'
+      plug = Gem::Specification.find { |g| g.name == name }
+      out = {}
+      out[:path] = plug.gem_dir
+      puts out.to_yaml
+    end
+  end
+end

data/lib/kontena/cli/plugins/uninstall_command.rb

@@ -0,0 +1,31 @@
+require 'kontena/plugin_manager'
+
+module Kontena::Cli::Plugins
+  class UninstallCommand < Kontena::Command
+    include Kontena::Util
+    include Kontena::Cli::Common
+
+    parameter 'NAME ...', 'Plugin name'
+
+    def execute
+      name_list.each do |name|
+        exit_with_error "Plugin #{name} has not been installed" unless plugin_installed?(name)
+        spinner "Uninstalling plugin #{pastel.cyan(name)}" do
+          plugin_uninstaller(name).uninstall
+        end
+      end
+    end
+
+    # @param name [String]
+    # @return [Boolean]
+    def plugin_installed?(name)
+      Kontena::PluginManager::Common.installed?(name)
+    end
+
+    # @param name [String]
+    # @return [Kontena::PluginManager::Uninstaller]
+    def plugin_uninstaller(name)
+      Kontena::PluginManager::Uninstaller.new(name)
+    end
+  end
+end

data/lib/kontena/cli/plugins/upgrade_command.rb

@@ -0,0 +1,60 @@
+require 'kontena/plugin_manager'
+require_relative 'common'
+
+module Kontena::Cli::Plugins
+  class UpgradeCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Common
+    include Kontena::PluginManager::Common
+
+    option '--pre', :flag, 'Include pre-release versions'
+    option '--silent', :flag, 'Less verbose output'
+
+    def running_verbose?
+      !silent?
+    end
+
+    def cleanup(*plugins)
+      return if plugins.empty?
+      vspinner "Running cleanup" do
+        plugins.each do |name|
+          Kontena::PluginManager::Cleaner.new(name).cleanup
+        end
+      end
+    end
+
+    def installer(name, version: nil)
+      Kontena::PluginManager::Installer.new(name, pre: pre?, version: version)
+    end
+
+    def upgrade(name, from, to)
+      vspinner "Upgrading #{pastel.cyan(name)} from #{pastel.cyan(from)} to #{pastel.cyan(to)}" do
+        installer(name, version: to).install
+      end
+      sputs "Upgraded #{name} from #{from} to #{to}" if silent?
+    end
+
+    def execute
+      upgradable = {}
+
+      vspinner "Checking for upgrades" do
+        plugins.each do |plugin|
+          short = short_name(plugin.name)
+          available_upgrade = installer(short).available_upgrade
+          unless available_upgrade.nil?
+            upgradable[short] = { from: plugin.version.to_s, to: available_upgrade }
+          end
+        end
+      end
+
+      if upgradable.empty?
+        vputs "Nothing upgraded"
+      else
+        upgradable.each do |name, data|
+          upgrade(name, data[:from], data[:to])
+        end
+        cleanup(upgradable.keys)
+      end
+    end
+  end
+end

data/lib/kontena/cli/registry/create_command.rb

@@ -0,0 +1,151 @@
+require_relative '../stacks/stacks_helper'
+require 'securerandom'
+
+module Kontena::Cli::Registry
+  class CreateCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include Kontena::Cli::Stacks::StacksHelper
+
+    REGISTRY_VERSION = '2.6.0'
+
+    option '--node', 'NODE', 'Node name'
+    option '--s3-bucket', 'S3_BUCKET', 'S3 bucket'
+    option '--s3-region', 'S3_REGION', 'S3 region', default: 'eu-west-1'
+    option '--s3-encrypt', :flag, 'Encrypt S3 objects', default: false
+    option '--s3-secure', :flag, 'Use secure connection in S3', default: true
+    option '--s3-v4auth', :flag, 'Use v4auth on S3', default: true
+    option '--azure-account-name', 'AZURE_ACCOUNT_NAME', 'Azure account name'
+    option '--azure-container-name', 'AZURE_CONTAINER_NAME', 'Azure container name'
+
+    def execute
+      require_api_url
+      token = require_token
+      preferred_node = node
+      secrets = []
+      affinity = []
+      stateful = true
+      instances = 1
+
+      registry = client(token).get("services/#{current_grid}/registry") rescue nil
+      exit_with_error('Registry already exists') if registry
+
+      nodes = client(token).get("grids/#{current_grid}/nodes")
+
+      if s3_bucket
+        ['REGISTRY_STORAGE_S3_ACCESSKEY', 'REGISTRY_STORAGE_S3_SECRETKEY'].each do |secret|
+          exit_with_error("Secret #{secret} does not exist in the vault") unless vault_secret_exists?(secret)
+        end
+        env = [
+            "REGISTRY_STORAGE=s3",
+            "REGISTRY_STORAGE_S3_REGION=#{s3_region}",
+            "REGISTRY_STORAGE_S3_BUCKET=#{s3_bucket}",
+            "REGISTRY_STORAGE_S3_ENCRYPT=#{s3_encrypt?}",
+            "REGISTRY_STORAGE_S3_SECURE=#{s3_secure?}",
+            "REGISTRY_STORAGE_S3_V4AUTH=#{s3_v4auth?}"
+        ]
+        secrets = [
+          {secret: 'REGISTRY_STORAGE_S3_ACCESSKEY', name: 'REGISTRY_STORAGE_S3_ACCESSKEY', type: 'env'},
+          {secret: 'REGISTRY_STORAGE_S3_SECRETKEY', name: 'REGISTRY_STORAGE_S3_SECRETKEY', type: 'env'}
+        ]
+        stateful = false
+        instances = 2 if nodes['nodes'].size > 1
+      elsif azure_account_name || azure_container_name
+        exit_with_error('Option --azure-account-name is missing') if azure_account_name.nil?
+        exit_with_error('Option --azure-container-name is missing') if azure_container_name.nil?
+        exit_with_error('Secret REGISTRY_STORAGE_AZURE_ACCOUNTKEY does not exist in the vault') unless vault_secret_exists?('REGISTRY_STORAGE_AZURE_ACCOUNTKEY')
+        env = [
+            "REGISTRY_STORAGE=azure",
+            "REGISTRY_STORAGE_AZURE_ACCOUNTNAME=#{azure_account_name}",
+            "REGISTRY_STORAGE_AZURE_CONTAINER=#{azure_container_name}"
+        ]
+        secrets = [
+          {secret: 'REGISTRY_STORAGE_AZURE_ACCOUNTKEY', name: 'REGISTRY_STORAGE_AZURE_ACCOUNTKEY', type: 'env'}
+        ]
+        stateful = false
+        instances = 2 if nodes['nodes'].size > 1
+      else
+        env = [
+            "REGISTRY_STORAGE_FILESYSTEM_ROOTDIRECTORY=/registry"
+        ]
+        if preferred_node
+          node = nodes['nodes'].find{|n| n['connected'] && n['name'] == preferred_node }
+          exit_with_error('Node not found') if node.nil?
+          affinity << "node==#{node['name']}"
+        end
+      end
+
+      if vault_secret_exists?('REGISTRY_AUTH_PASSWORD')
+        secrets << {secret: 'REGISTRY_AUTH_PASSWORD', name: 'AUTH_PASSWORD', type: 'env'}
+        configure_registry_auth(vault_secret('REGISTRY_AUTH_PASSWORD'))
+      end
+      if vault_secret_exists?('REGISTRY_HTTP_TLS_CERTIFICATE')
+        secrets << {secret: 'REGISTRY_HTTP_TLS_CERTIFICATE', name: 'REGISTRY_HTTP_TLS_CERTIFICATE', type: 'env'}
+        secrets << {secret: 'REGISTRY_HTTP_TLS_KEY', name: 'REGISTRY_HTTP_TLS_KEY', type: 'env'}
+        env << "REGISTRY_HTTP_ADDR=0.0.0.0:443"
+      else
+        env << "REGISTRY_HTTP_ADDR=0.0.0.0:80"
+      end
+      env << "REGISTRY_HTTP_SECRET=#{SecureRandom.hex(24)}"
+
+      data = {
+        name: 'registry',
+        stack: 'kontena/registry',
+        version: Kontena::Cli::VERSION,
+        source: '---',
+        registry: 'file://',
+        expose: 'api',
+        services: [
+          {
+            name: 'api',
+            stateful: stateful,
+            container_count: instances,
+            image: "kontena/registry:#{REGISTRY_VERSION}",
+            volumes: ['/registry'],
+            env: env,
+            secrets: secrets,
+            affinity: affinity
+          }
+        ]
+      }
+
+      client(token).post("grids/#{current_grid}/stacks", data)
+      deployment = client(token).post("stacks/#{current_grid}/registry/deploy", {})
+      spinner "Deploying #{pastel.cyan(data[:name])} stack " do
+        wait_for_deploy_to_finish(deployment)
+      end
+      puts "\n"
+      puts "Docker Registry #{REGISTRY_VERSION} is now running at registry.#{current_grid}.kontena.local."
+      puts "Note: "
+      puts "  - OpenVPN connection is needed to establish connection to this registry. See http://www.kontena.io/docs/using-kontena/vpn-access for details"
+      puts "  - you must set '--insecure-registry registry.#{current_grid}.kontena.local' to your client docker daemon before you are able to push to this registry"
+    end
+
+    # @param [String] name
+    # @return [Boolean]
+    def vault_secret_exists?(name)
+      client(require_token).get("secrets/#{current_grid}/#{name}")
+      true
+    rescue
+      false
+    end
+
+    # @param [String] name
+    # @return [String]
+    def vault_secret(name)
+      secret = client(require_token).get("secrets/#{current_grid}/#{name}")
+      secret['value']
+    end
+
+    # @param [String] password
+    def configure_registry_auth(password)
+      data = {
+        username: 'admin',
+        password: password,
+        email: 'not@val.id',
+        url: "http://registry.#{current_grid}.kontena.local/"
+      }
+      client(require_token).post("grids/#{current_grid}/external_registries", data) rescue nil
+    end
+  end
+end

data/lib/kontena/cli/registry/remove_command.rb

@@ -0,0 +1,21 @@
+module Kontena::Cli::Registry
+  class RemoveCommand < Kontena::Command
+    include Kontena::Cli::Common
+
+    option "--force", :flag, "Force remove", default: false, attribute_name: :forced
+
+    def execute
+      require_api_url
+      token = require_token
+      confirm unless forced?
+      name = 'registry'
+
+      registry = client(token).get("stacks/#{current_grid}/#{name}") rescue nil
+      exit_with_error("Stack #{pastel.cyan(name)} does not exist") if registry.nil?
+
+      spinner "Removing #{pastel.cyan(name)} stack " do
+        client(token).delete("stacks/#{current_grid}/#{name}")
+      end
+    end
+  end
+end

data/lib/kontena/cli/registry_command.rb

@@ -0,0 +1,8 @@
+class Kontena::Cli::RegistryCommand < Kontena::Command
+
+  subcommand "create", "Create Docker image registry service", load_subcommand('registry/create_command')
+  subcommand ["remove","rm"], "Remove Docker image registry service", load_subcommand('registry/remove_command')
+
+  def execute
+  end
+end

data/lib/kontena/cli/service_command.rb

@@ -0,0 +1,28 @@
+class Kontena::Cli::ServiceCommand < Kontena::Command
+  subcommand ["list","ls"], "List services", load_subcommand('services/list_command')
+  subcommand "create", "Create a new service", load_subcommand('services/create_command')
+  subcommand "show", "Show service details", load_subcommand('services/show_command')
+  subcommand "update", "Update service configuration", load_subcommand('services/update_command')
+  subcommand "deploy", "Deploy service", load_subcommand('services/deploy_command')
+  subcommand "stop", "Stop service", load_subcommand('services/stop_command')
+  subcommand "start", "Start service", load_subcommand('services/start_command')
+  subcommand "restart", "Restart service", load_subcommand('services/restart_command')
+  subcommand "scale", "Scale service", load_subcommand('services/scale_command')
+  subcommand ["remove", "rm"], "Remove service", load_subcommand('services/remove_command')
+  subcommand "containers", "List service containers", load_subcommand('services/containers_command')
+  subcommand "logs", "Show service logs", load_subcommand('services/logs_command')
+  subcommand "events", "Show service events", load_subcommand('services/events_command')
+  subcommand "stats", "Show service statistics", load_subcommand('services/stats_command')
+  subcommand "monitor", "Monitor", load_subcommand('services/monitor_command')
+
+  subcommand "env", "Environment variable specific commands", load_subcommand('services/env_command')
+
+  subcommand "secret", "Secret specific commands", load_subcommand('services/secret_command')
+
+  subcommand "link", "Link service to another service", load_subcommand('services/link_command')
+  subcommand "unlink", "Unlink service from another service", load_subcommand('services/unlink_command')
+  subcommand "exec", "Execute commands in service containers", load_subcommand('services/exec_command')
+
+  def execute
+  end
+end

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

@@ -0,0 +1,8 @@
+
+class Kontena::Cli::ContainerCommand < Kontena::Command
+
+  subcommand "exec", "Execute command inside a container", load_subcommand('containers/exec_command')
+
+  def execute
+  end
+end

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

@@ -0,0 +1,39 @@
+require_relative 'services_helper'
+
+module Kontena::Cli::Services
+  class ContainersCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include ServicesHelper
+
+    parameter "NAME", "Service name"
+    option ['-q', '--quiet'], :flag, "Output the identifying column only"
+
+    def execute
+      require_api_url
+      token = require_token
+
+      result = client(token).get("services/#{parse_service_id(name)}/containers")
+
+      if quiet?
+        puts result['containers'].map { |c| "#{c['node']['name']}/#{c['name']}" }.join("\n")
+        exit 0
+      end
+
+      result['containers'].each do |container|
+        puts "#{container['name']}:"
+        puts "  rev: #{container['deploy_rev']}"
+        puts "  node: #{container['node']['name']}"
+        puts "  dns: #{container['hostname']}.#{container['domainname']}"
+        puts "  ip: #{container['ip_address']}"
+        puts "  public ip: #{container['node']['public_ip']}"
+        if container['status'] == 'unknown'
+          puts "  status: #{pastel.yellow(container['status'])}"
+        else
+          puts "  status: #{container['status']}"
+        end
+        puts ""
+      end
+    end
+  end
+end