Class: OsCtl::Cli::Container

Inherits:

Command

• Object
• Lib::Cli::Command
• Command
• OsCtl::Cli::Container

Includes:

Assets, Attributes, CGroupParams, Devices

Defined in:

lib/osctl/cli/container.rb

Constant Summary

FIELDS =

%i(
  pool
  id
  user
  group
  dataset
  rootfs
  boot_dataset
  boot_rootfs
  lxc_path
  lxc_dir
  group_path
  distribution
  version
  state
  init_pid
  cpu_package_inuse
  cpu_package_set
  cpu_limit
  memory_limit
  swap_limit
  autostart
  autostart_priority
  autostart_delay
  ephemeral
  hostname
  hostname_readout
  dns_resolvers
  nesting
  seccomp_profile
  init_cmd
  raw_lxc
  loadavg
  lxcfs_enable
  lxcfs_worker
  lxcfs_mountpoint
  lxcfs_loadavg
  lxcfs_cfs
) + CGroupParams::CGPARAM_STATS

FILTERS =

%i(
  pool
  user
  group
  distribution
  version
  state
)

DEFAULT_FIELDS =

%i(
  pool
  id
  user
  group
  distribution
  version
  state
  init_pid
  memory
  cpu_us
)

PRLIMIT_FIELDS =

%i(
  name
  soft
  hard
)

DATASET_FIELDS =

%i(
  name
  dataset
)

MOUNT_FIELDS =

%i(
  fs
  dataset
  mountpoint
  type
  opts
  automount
  temporary
)

Constants included from Devices

Devices::DEVICES_FIELDS

Constants included from CGroupParams

OsCtl::Cli::CGroupParams::CGPARAM_DEFAULT_FIELDS, OsCtl::Cli::CGroupParams::CGPARAM_FIELDS, OsCtl::Cli::CGroupParams::CGPARAM_FILTERS, OsCtl::Cli::CGroupParams::CGPARAM_STATS

Instance Method Summary

• #add_loadavg(ct) ⇒ Object protected
• #add_loadavgs(cts) ⇒ Object protected
• #assets ⇒ Object
• #attach ⇒ Object
• #bisect ⇒ Object
• #boot ⇒ Object
• #cgparam_apply ⇒ Object
• #cgparam_list ⇒ Object
• #cgparam_replace ⇒ Object
• #cgparam_set ⇒ Object
• #cgparam_unset ⇒ Object
• #chgrp ⇒ Object
• #chown ⇒ Object
• #config_reload ⇒ Object
• #config_replace ⇒ Object
• #console ⇒ Object
• #copy ⇒ Object
• #create ⇒ Object
• #create_empty ⇒ Object protected
• #create_with_remote_image ⇒ Object protected
• #dataset_create ⇒ Object
• #dataset_delete ⇒ Object
• #dataset_list ⇒ Object
• #delete ⇒ Object
• #device_add ⇒ Object
• #device_chmod ⇒ Object
• #device_delete ⇒ Object
• #device_inherit ⇒ Object
• #device_list ⇒ Object
• #device_promote ⇒ Object
• #device_replace ⇒ Object
• #device_set_inherit ⇒ Object
• #device_unset_inherit ⇒ Object
• #exec ⇒ Object
• #export ⇒ Object
• #freeze ⇒ Object
• #get_ct_wait(v) ⇒ Object protected
• #handle_ct_attach(cmd) ⇒ Object protected
• #handle_exec_io(c) ⇒ Object protected
• #handle_exec_response(c) ⇒ Object protected
• #import ⇒ Object
• #list ⇒ Object
• #log_cat ⇒ Object
• #log_path ⇒ Object
• #mount ⇒ Object
• #mount_activate ⇒ Object
• #mount_create ⇒ Object
• #mount_dataset ⇒ Object
• #mount_deactivate ⇒ Object
• #mount_delete ⇒ Object
• #mount_list ⇒ Object
• #mount_register ⇒ Object
• #move ⇒ Object
• #open_console(ctid, pool, tty, raw, &block) ⇒ Object
• #open_console_raw(ctid, pool, tty) ⇒ Object
• #open_console_tty(ctid, pool, tty) {|c| ... } ⇒ Object
• #passwd ⇒ Object
• #pid ⇒ Object
• #prlimit_list ⇒ Object
• #prlimit_set ⇒ Object
• #prlimit_unset ⇒ Object
• #reconfigure ⇒ Object
• #recover_cleanup ⇒ Object
• #recover_kill ⇒ Object
• #recover_state ⇒ Object
• #reinstall ⇒ Object
• #repo_image_attrs(defaults: true) ⇒ Object protected
• #restart ⇒ Object
• #runscript ⇒ Object
• #set(option) ⇒ Object protected
• #set_attr ⇒ Object
• #set_autostart ⇒ Object
• #set_cpu_limit ⇒ Object
• #set_cpu_package ⇒ Object
• #set_distribution ⇒ Object
• #set_dns_resolver ⇒ Object
• #set_ephemeral ⇒ Object
• #set_hostname ⇒ Object
• #set_image_config ⇒ Object
• #set_init_cmd ⇒ Object
• #set_lxcfs ⇒ Object
• #set_memory_limit ⇒ Object
• #set_nesting ⇒ Object
• #set_raw_lxc ⇒ Object
• #set_seccomp_profile ⇒ Object
• #set_start_menu ⇒ Object
• #show ⇒ Object
• #start ⇒ Object
• #stop ⇒ Object
• #su ⇒ Object
• #tree ⇒ Object
• #unfreeze ⇒ Object
• #unset(option) ⇒ Object protected
• #unset_attr ⇒ Object
• #unset_autostart ⇒ Object
• #unset_cpu_limit ⇒ Object
• #unset_cpu_package ⇒ Object
• #unset_dns_resolver ⇒ Object
• #unset_ephemeral ⇒ Object
• #unset_hostname ⇒ Object
• #unset_init_cmd ⇒ Object
• #unset_lxcfs ⇒ Object
• #unset_memory_limit ⇒ Object
• #unset_nesting ⇒ Object
• #unset_raw_lxc ⇒ Object
• #unset_seccomp_profile ⇒ Object
• #unset_start_menu ⇒ Object
• #wall ⇒ Object

Methods included from Attributes

#do_set_attr, #do_unset_attr

Methods included from Assets

#print_assets

Methods included from Devices

#do_device_add, #do_device_chmod, #do_device_delete, #do_device_inherit, #do_device_list, #do_device_promote, #do_device_replace, #do_device_set_inherit, #do_device_unset_inherit

Methods included from CGroupParams

#cg_add_raw_cgroup_params, #cg_add_stats, #cg_init_subsystems, #cg_list_raw_cgroup_params, #do_cgparam_apply, #do_cgparam_list, #do_cgparam_replace, #do_cgparam_set, #do_cgparam_unset, #do_set_cpu_limit, #do_set_memory, #do_unset_cpu_limit, #do_unset_memory, #parse_cgparams, #parse_subsystem

Methods inherited from Command

#cli_opt, #format_output, #osctld_call, #osctld_fmt, #osctld_open, #osctld_resp, run

Instance Method Details

#add_loadavg(ct) ⇒ Object (protected)

# File 'lib/osctl/cli/container.rb', line 1587

def add_loadavg(ct)
  if ct[:state] != 'running'
    ct[:loadavg] = nil
    return
  end

  begin
    lavgs = OsCtl::Lib::LoadAvgReader.read_for([ct])
  rescue SystemCallError => e
    warn "Unable to read container load averages: #{e.message} (#{e.class})"
    return
  end

  lavg = lavgs["#{ct[:pool]}:#{ct[:id]}"]
  ct[:loadavg] = lavg ? lavg.averages : nil
end

#add_loadavgs(cts) ⇒ Object (protected)

# File 'lib/osctl/cli/container.rb', line 1604

def add_loadavgs(cts)
  begin
    lavgs = OsCtl::Lib::LoadAvgReader.read_for(cts)
  rescue SystemCallError => e
    warn "Unable to read container load averages: #{e.message} (#{e.class})"
    return
  end

  cts.each do |ct|
    if ct[:state] != 'running'
      ct[:loadavg] = nil
      next
    end

    lavg = lavgs[ "#{ct[:pool]}:#{ct[:id]}" ]
    ct[:loadavg] = lavg ? lavg.averages : nil
  end
end

#assets ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1071

def assets
  require_args!('id')

  print_assets(:ct_assets, id: args[0], pool: gopts[:pool])
end

#attach ⇒ Object

# File 'lib/osctl/cli/container.rb', line 445

def attach
  require_args!('id')

  cmd = osctld_call(
    :ct_attach,
    id: args[0],
    pool: gopts[:pool],
    user_shell: opts['user-shell'],
  )

  handle_ct_attach(cmd)
end

#bisect ⇒ Object

# File 'lib/osctl/cli/container.rb', line 958

def bisect
  c = osctld_open
  cg_init_subsystems(c)

  cgparams = cg_list_raw_cgroup_params.map(&:to_sym)

  param_selector = OsCtl::Lib::Cli::ParameterSelector.new(
    all_params: FIELDS + cgparams,
    default_params: DEFAULT_FIELDS,
  )

  if opts[:list]
    puts param_selector
    return
  end

  cmd_opts = {
    state: 'running',
  }

  FILTERS.each do |v|
    [gopts, opts].each do |options|
      next unless options[v]
      cmd_opts[v] = options[v].split(',')
    end
  end

  if opts[:ephemeral]
    cmd_opts[:ephemeral] = true
  elsif opts[:persistent]
    cmd_opts[:ephemeral] = false
  end

  cmd_opts[:ids] = args if args.count > 0

  cts = c.cmd_data!(:ct_list, **cmd_opts)

  if opts[:exclude]
    exclude_ctids = opts[:exclude].split(',').map do |v|
      if v.index(':')
        pool, id = v.split(':')
        [pool, id]
      else
        [nil, v]
      end
    end

    cts.reject! do |ct|
      exclude_ctids.detect do |ex_pool, ex_id|
        (ex_pool.nil? || ct[:pool] == ex_pool) && ct[:id] == ex_id
      end
    end
  end

  cols = param_selector.parse_option(opts[:output])

  cg_add_stats(
    cts,
    lambda { |ct| ct[:group_path] },
    cols,
    gopts[:parsable]
  )

  add_loadavgs(cts)

  cg_add_raw_cgroup_params(
    cts,
    lambda { |ct| ct[:group_path] },
    cols & cgparams
  )

  if opts[:sort]
    sort_cols = param_selector.parse_option(opts[:sort])

    sort_cols.each do |c|
      unless all_fields.include?(c)
        raise GLI::BadCommandLine, "unknown sort parameter '#{c}'"
      end
    end

    cts.sort! do |a, b|
      a_vals = sort_cols.map { |c| a[c] }
      b_vals = sort_cols.map { |c| b[c] }
      cmp = a_vals <=> b_vals
      next(cmp) if cmp

      next(-1) if [nil, false].detect { |v| a_vals.include?(v) }
      next(1) if [nil, false].detect { |v| b_vals.include?(v) }
      0
    end
  end

  bis = Bisect.new(
    cts,
    suspend_action: opts[:action].to_sym,
    cols: cols,
  )
  bis.run
end

#boot ⇒ Object

# File 'lib/osctl/cli/container.rb', line 810

def boot
  require_args!('id')

  if opts[:foreground] && opts[:attach]
    raise GLI::BadCommandLine, 'use either --foreground or --attach'
  end

  cmd_opts = {
    id: args[0],
    pool: opts[:pool] || gopts[:pool],
    repository: opts[:repository],
    force: opts[:force],
    mount_root: opts['mount-root-dataset'],
    zfs_properties: Hash[opts['zfs-property'].map do |v|
      k, v = v.split('=')
      raise GLI::BadCommandLine, "invalid ZFS property '#{v}'" if v.nil?

      [k, v]
    end],
    wait: get_ct_wait(opts[:wait]),
    queue: opts[:queue],
    priority: opts[:priority],
    debug: opts[:debug],
  }

  if opts['from-file']
    cmd_opts.update(
      type: :image,
      path: File.absolute_path(opts['from-file']),
    )
  else
    cmd_opts.update(
      type: :remote,
      image: repo_image_attrs(defaults: false),
    )
  end

  if opts[:foreground]
    open_console(args[0], gopts[:pool], 0, gopts[:json]) do |sock|
      sock.close if osctld_resp(:ct_boot, **cmd_opts).error?
    end

    return
  end

  osctld_fmt(:ct_boot, cmd_opts: cmd_opts)

  if opts[:attach]
    puts 'Attaching'
    attach
  end
end

#cgparam_apply ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1143

def cgparam_apply
  require_args!('id')
  do_cgparam_apply(:ct_cgparam_apply, id: args[0], pool: gopts[:pool])
end

#cgparam_list ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1127

def cgparam_list
  require_args!('id', strict: false)

  do_cgparam_list(:ct_cgparam_list, id: args[0], pool: gopts[:pool])
end

#cgparam_replace ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1148

def cgparam_replace
  require_args!('name')
  do_cgparam_replace(:ct_cgparam_replace, id: args[0], pool: gopts[:pool])
end

#cgparam_set ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1133

def cgparam_set
  require_args!('id', 'parameter', 'value', strict: false)
  do_cgparam_set(:ct_cgparam_set, id: args[0], pool: gopts[:pool])
end

#cgparam_unset ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1138

def cgparam_unset
  require_args!('id', 'parameter')
  do_cgparam_unset(:ct_cgparam_unset, id: args[0], pool: gopts[:pool])
end

#chgrp ⇒ Object

# File 'lib/osctl/cli/container.rb', line 800

def chgrp
  require_args!('id', 'group')
  osctld_fmt(:ct_chgrp, cmd_opts: {
    id: args[0],
    pool: gopts[:pool],
    group: args[1],
    missing_devices: opts['missing-devices']
  })
end

#chown ⇒ Object

# File 'lib/osctl/cli/container.rb', line 791

def chown
  require_args!('id', 'user')
  osctld_fmt(:ct_chown, cmd_opts: {
    id: args[0],
    pool: gopts[:pool],
    user: args[1],
  })
end

#config_reload ⇒ Object

# File 'lib/osctl/cli/container.rb', line 863

def config_reload
  require_args!('id')
  osctld_fmt(:ct_cfg_reload, cmd_opts: {
    id: args[0],
    pool: gopts[:pool],
  })
end

#config_replace ⇒ Object

# File 'lib/osctl/cli/container.rb', line 871

def config_replace
  require_args!('id')
  osctld_fmt(:ct_cfg_replace, cmd_opts: {
    id: args[0],
    pool: gopts[:pool],
    config: STDIN.read,
  })
end

#console ⇒ Object

# File 'lib/osctl/cli/container.rb', line 439

def console
  require_args!('id')

  open_console(args[0], gopts[:pool], opts[:tty], gopts[:json])
end

#copy ⇒ Object

# File 'lib/osctl/cli/container.rb', line 741

def copy
  require_args!('id', 'new-id')

  if args[1].include?(':')
    target_pool, target_id = args[1].split(':')
  else
    target_pool = opts[:pool]
    target_id = args[1]
  end

  cmd_opts = {
    pool: gopts[:pool],
    id: args[0],
    target_pool: target_pool,
    target_id: target_id,
    consistent: opts[:consistent],
    network_interfaces: opts['network-interfaces'],
  }

  cmd_opts[:target_user] = opts[:user] if opts[:user]
  cmd_opts[:target_group] = opts[:group] if opts[:group]
  cmd_opts[:target_dataset] = opts[:dataset] if opts[:dataset]

  osctld_fmt(:ct_copy, cmd_opts: cmd_opts)
end

#create ⇒ Object

# File 'lib/osctl/cli/container.rb', line 276

def create
  require_args!('id')

  if opts['skip-image']
    create_empty
  else
    create_with_remote_image
  end
end

#create_empty ⇒ Object (protected)

# File 'lib/osctl/cli/container.rb', line 1526

def create_empty
  if !opts[:distribution]
    raise GLI::BadCommandLine, 'provide --distribution'
  elsif !opts[:version]
    raise GLI::BadCommandLine, 'provide --version'
  elsif !opts[:arch]
    raise GLI::BadCommandLine, 'provide --arch'
  end

  cmd_opts = {
    id: args[0],
    pool: opts[:pool] || gopts[:pool],
    user: opts[:user],
    distribution: opts[:distribution],
    version: opts[:version],
    arch: opts[:arch],
  }

  %i(group dataset).each do |v|
    cmd_opts[v] = opts[v] if opts[v]
  end

  osctld_fmt(:ct_create_empty, cmd_opts: cmd_opts)
end

#create_with_remote_image ⇒ Object (protected)

# File 'lib/osctl/cli/container.rb', line 1505

def create_with_remote_image
  cmd_opts = {
    id: args[0],
    pool: opts[:pool] || gopts[:pool],
    user: opts[:user],
    repository: opts[:repository],
  }

  %i(group dataset).each do |v|
    cmd_opts[v] = opts[v] if opts[v]
  end

  if !opts[:distribution]
    raise GLI::BadCommandLine, 'provide --distribution'
  end

  cmd_opts[:image] = repo_image_attrs

  osctld_fmt(:ct_create, cmd_opts: cmd_opts)
end

#dataset_create ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1271

def dataset_create
  require_args!('id', 'name', optional: %w(mountpoint))
  osctld_fmt(:ct_dataset_create, cmd_opts: {
    id: args[0],
    pool: gopts[:pool],
    name: args[1],
    mount: opts[:mount],
    mountpoint: args[2]
  })
end

#dataset_delete ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1282

def dataset_delete
  require_args!('id', 'name')
  osctld_fmt(:ct_dataset_delete, cmd_opts: {
    id: args[0],
    pool: gopts[:pool],
    name: args[1],
    recursive: opts[:recursive],
    unmount: opts[:unmount]
  })
end

#dataset_list ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1248

def dataset_list
  param_selector = OsCtl::Lib::Cli::ParameterSelector.new(
    all_params: DATASET_FIELDS,
    default_params: DATASET_FIELDS,
  )

  if opts[:list]
    puts param_selector
    return
  end

  require_args!('id', strict: false)
  props = args[1..-1]

  cmd_opts = {id: args[0], pool: gopts[:pool], properties: props}
  fmt_opts = {layout: :columns}

  fmt_opts[:header] = false if opts['hide-header']
  fmt_opts[:cols] = param_selector.parse_option(opts[:output])

  osctld_fmt(:ct_dataset_list, cmd_opts: cmd_opts, fmt_opts: fmt_opts)
end

#delete ⇒ Object

# File 'lib/osctl/cli/container.rb', line 286

def delete
  require_args!('id')

  osctld_fmt(:ct_delete, cmd_opts: {
    id: args[0],
    pool: gopts[:pool],
    force: opts[:force],
  })
end

#device_add ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1158

def device_add
  require_args!('id', 'type', 'major', 'minor', 'mode', optional: %w(device))
  do_device_add(:ct_device_add, id: args[0], pool: gopts[:pool])
end

#device_chmod ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1168

def device_chmod
  require_args!('id', 'type', 'major', 'minor', 'mode')
  do_device_chmod(:ct_device_chmod, id: args[0], pool: gopts[:pool])
end

#device_delete ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1163

def device_delete
  require_args!('id', 'type', 'major', 'minor')
  do_device_delete(:ct_device_delete, id: args[0], pool: gopts[:pool])
end

#device_inherit ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1178

def device_inherit
  require_args!('id', 'type', 'major', 'minor')
  do_device_inherit(:ct_device_inherit, id: args[0], pool: gopts[:pool])
end

#device_list ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1153

def device_list
  require_args!('id')
  do_device_list(:ct_device_list, id: args[0], pool: gopts[:pool])
end

#device_promote ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1173

def device_promote
  require_args!('id', 'type', 'major', 'minor')
  do_device_chmod(:ct_device_promote, id: args[0], pool: gopts[:pool])
end

#device_replace ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1193

def device_replace
  require_args!('id')
  do_device_replace(:ct_device_replace, id: args[0], pool: gopts[:pool])
end

#device_set_inherit ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1183

def device_set_inherit
  require_args!('id', 'type', 'major', 'minor')
  do_device_set_inherit(:ct_device_set_inherit, id: args[0], pool: gopts[:pool])
end

#device_unset_inherit ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1188

def device_unset_inherit
  require_args!('id', 'type', 'major', 'minor')
  do_device_unset_inherit(:ct_device_unset_inherit, id: args[0], pool: gopts[:pool])
end

#exec ⇒ Object

# File 'lib/osctl/cli/container.rb', line 458

def exec
  require_args!('id', 'command', strict: false)

  c = osctld_open
  cont = c.cmd_data!(
    :ct_exec,
    id: args[0],
    pool: gopts[:pool],
    cmd: args[1..-1],
    run: opts['run-container'],
    network: opts['network'],
  )

  if cont != 'continue'
    warn "exec not available: invalid response '#{cont}'"
    exit(false)
  end

  handle_exec_io(c)
end

#export ⇒ Object

# File 'lib/osctl/cli/container.rb', line 899

def export
  require_args!('id', 'file')

  osctld_fmt(:ct_export, cmd_opts: {
    id: args[0],
    pool: gopts[:pool],
    file: File.expand_path(args[1]),
    consistent: opts[:consistent],
    compression: opts[:compression]
  })
end

#freeze ⇒ Object

# File 'lib/osctl/cli/container.rb', line 948

def freeze
  require_args!('id')
  osctld_fmt(:ct_freeze, cmd_opts: {id: args[0], pool: gopts[:pool]})
end

#get_ct_wait(v) ⇒ Object (protected)

# File 'lib/osctl/cli/container.rb', line 1623

def get_ct_wait(v)
  if v == 'infinity'
    return v
  elsif v.is_a?(::String) && /^\d+$/ !~ v
    raise GLI::BadCommandLine, 'invalid value for --wait'
  end

  v_i = v.to_i

  if v_i < 0
    raise GLI::BadCommandLine, 'invalid value for --wait'
  elsif v_i == 0
    false
  elsif opts[:foreground]
    false
  else
    v_i
  end
end

#handle_ct_attach(cmd) ⇒ Object (protected)

# File 'lib/osctl/cli/container.rb', line 1707

def handle_ct_attach(cmd)
  f = Tempfile.create(['osctl-ct-attach-settings', '.json'], '/tmp')
  f.puts(cmd[:settings].to_json)
  f.close

  pid = Process.fork do
    cmd[:env].each do |k, v|
      ENV[k.to_s] = v
    end

    Process.exec(cmd[:cmd], f.path, '--', *cmd[:args])
  end

  Process.wait(pid)

ensure
  begin
    f && File.unlink(f.path)
  rescue Errno::ENOENT
    # pass
  end
end

#handle_exec_io(c) ⇒ Object (protected)

# File 'lib/osctl/cli/container.rb', line 1643

def handle_exec_io(c)
  r_in, w_in = IO.pipe
  r_out, w_out = IO.pipe
  r_err, w_err = IO.pipe

  c.send_io(r_in)
  c.send_io(w_out)
  c.send_io(w_err)

  r_in.close
  w_out.close
  w_err.close

  watch_ios = [STDIN, r_out, r_err, c.socket]

  loop do
    rs, ws, = IO.select(watch_ios)

    rs.each do |r|
      case r
      when r_out
        data = r.read_nonblock(4096)
        STDOUT.write(data)
        STDOUT.flush

      when r_err
        data = r.read_nonblock(4096)
        STDERR.write(data)
        STDERR.flush

      when STDIN
        begin
          data = r.read_nonblock(4096)
          w_in.write(data)
        rescue EOFError
          w_in.close
          watch_ios.delete(STDIN)
        end

      when c.socket
        r_out.close
        r_err.close

        handle_exec_response(c)
        return
      end
    end
  end

rescue IOError
  handle_exec_response(c)
end

#handle_exec_response(c) ⇒ Object (protected)

# File 'lib/osctl/cli/container.rb', line 1696

def handle_exec_response(c)
  resp = c.receive_resp

  if resp.error?
    fail (resp['message'] || 'exec failed')

  elsif resp[:exitstatus] && resp[:exitstatus] > 0
    raise GLI::CustomExit.new('executed command failed', resp[:exitstatus])
  end
end

#import ⇒ Object

# File 'lib/osctl/cli/container.rb', line 911

def import
  require_args!('file')

  file = File.expand_path(args[0])
  fail "#{file}: not found" unless File.exist?(file)

  cmd_opts = {file: file}

  %w(as-id as-user as-group dataset missing-devices).each do |v|
    cmd_opts[v.sub('-', '_').to_sym] = opts[v] if opts[v]
  end

  osctld_fmt(:ct_import, cmd_opts: cmd_opts)
end

#list ⇒ Object

# File 'lib/osctl/cli/container.rb', line 102

def list
  c = osctld_open
  cg_init_subsystems(c)

  cgparams = cg_list_raw_cgroup_params
  zfsprops = ZfsProperties.new
  keyring = KernelKeyring.new

  param_selector = OsCtl::Lib::Cli::ParameterSelector.new(
    all_params: FIELDS + cgparams + zfsprops.list_property_names + keyring.list_param_names,
    default_params: DEFAULT_FIELDS,
  )

  if opts[:list]
    puts param_selector
    return
  end

  cmd_opts = {}
  fmt_opts = {
    layout: :columns,
    sort: opts[:sort] && param_selector.parse_option(opts[:sort]),
    opts: {
      memory_limit: {
        align: 'right',
        display: Proc.new do |v|
          if v.nil? || gopts[:parsable] || gopts[:json]
            v
          else
            humanize_data(v)
          end
        end,
      },
      swap_limit: {
        align: 'right',
        display: Proc.new do |v|
          if v.nil? || gopts[:parsable] || gopts[:json]
            v
          else
            humanize_data(v)
          end
        end,
      },
    },
  }

  FILTERS.each do |v|
    [gopts, opts].each do |options|
      next unless options[v]
      cmd_opts[v] = options[v].split(',')
    end
  end

  if opts[:ephemeral]
    cmd_opts[:ephemeral] = true
  elsif opts[:persistent]
    cmd_opts[:ephemeral] = false
  end

  cmd_opts[:ids] = args if args.count > 0
  fmt_opts[:header] = false if opts['hide-header']

  cols = param_selector.parse_option(opts[:output])
  cols = zfsprops.validate_property_names(cols)

  fmt_opts[:cols] = cols

  if cols.include?(:hostname_readout)
    cmd_opts[:read_hostname] = true
  end

  cts = cg_add_stats(
    c.cmd_data!(:ct_list, **cmd_opts),
    lambda { |ct| ct[:group_path] },
    cols,
    gopts[:parsable]
  )

  add_loadavgs(cts)

  cg_add_raw_cgroup_params(
    cts,
    lambda { |ct| ct[:group_path] },
    cols & cgparams.map(&:to_sym)
  )

  zfsprops.add_container_values(cts, cols, precise: gopts[:parsable])
  keyring.add_container_values(cts, cols, precise: gopts[:parsable])

  format_output(cts, **fmt_opts)
end

#log_cat ⇒ Object

# File 'lib/osctl/cli/container.rb', line 926

def log_cat
  require_args!('id')

  ct = osctld_call(:ct_show, id: args[0], pool: gopts[:pool])

  File.open(ct[:log_file]) do |f|
    puts f.readline until f.eof?
  end
end

#log_path ⇒ Object

# File 'lib/osctl/cli/container.rb', line 936

def log_path
  require_args!('id')

  ct = osctld_call(:ct_show, id: args[0], pool: gopts[:pool])
  puts ct[:log_file]
end

#mount ⇒ Object

# File 'lib/osctl/cli/container.rb', line 321

def mount
  require_args!('id')
  osctld_fmt(:ct_mount, cmd_opts: {id: args[0], pool: gopts[:pool]})
end

#mount_activate ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1369

def mount_activate
  require_args!('id', 'mountpoint')

  osctld_fmt(:ct_mount_activate, cmd_opts: {
    id: args[0],
    pool: gopts[:pool],
    mountpoint: args[1]
  })
end

#mount_create ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1315

def mount_create
  require_args!('id')

  osctld_fmt(:ct_mount_create, cmd_opts: {
    id: args[0],
    pool: gopts[:pool],
    fs: opts[:fs],
    mountpoint: opts[:mountpoint],
    type: opts[:type],
    opts: opts[:opts],
    automount: opts[:automount],
  })
end

#mount_dataset ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1329

def mount_dataset
  require_args!('id', 'name', 'mountpoint')

  if opts[:ro] && opts[:rw]
    raise GLI::BadCommandLine, 'use either --ro or --rw, not both'

  elsif opts[:ro]
    mode = 'ro'

  elsif opts[:rw]
    mode = 'rw'

  else
    mode = 'rw'
  end

  osctld_fmt(:ct_mount_dataset, cmd_opts: {
    id: args[0],
    pool: gopts[:pool],
    name: args[1],
    mountpoint: args[2],
    mode: mode,
    automount: opts[:automount],
  })
end

#mount_deactivate ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1379

def mount_deactivate
  require_args!('id', 'mountpoint')

  osctld_fmt(:ct_mount_deactivate, cmd_opts: {
    id: args[0],
    pool: gopts[:pool],
    mountpoint: args[1]
  })
end

#mount_delete ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1389

def mount_delete
  require_args!('id', 'mountpoint')

  osctld_fmt(:ct_mount_delete, cmd_opts: {
    id: args[0],
    pool: gopts[:pool],
    mountpoint: args[1]
  })
end

#mount_list ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1293

def mount_list
  param_selector = OsCtl::Lib::Cli::ParameterSelector.new(
    all_params: MOUNT_FIELDS,
    default_params: MOUNT_FIELDS,
  )

  if opts[:list]
    puts param_selector
    return
  end

  require_args!('id')

  cmd_opts = {id: args[0], pool: gopts[:pool]}
  fmt_opts = {layout: :columns}

  fmt_opts[:header] = false if opts['hide-header']
  fmt_opts[:cols] = param_selector.parse_option(opts[:output])

  osctld_fmt(:ct_mount_list, cmd_opts: cmd_opts, fmt_opts: fmt_opts)
end

#mount_register ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1355

def mount_register
  require_args!('id', 'mountpoint')

  osctld_fmt(:ct_mount_register, cmd_opts: {
    id: args[0],
    pool: gopts[:pool],
    fs: opts[:fs],
    mountpoint: args[1],
    type: opts[:type],
    opts: opts[:opts],
    lock: !opts['on-ct-start'],
  })
end

#move ⇒ Object

# File 'lib/osctl/cli/container.rb', line 767

def move
  require_args!('id', 'new-id')

  if args[1].include?(':')
    target_pool, target_id = args[1].split(':')
  else
    target_pool = opts[:pool]
    target_id = args[1]
  end

  cmd_opts = {
    pool: gopts[:pool],
    id: args[0],
    target_pool: target_pool,
    target_id: target_id,
  }

  cmd_opts[:target_user] = opts[:user] if opts[:user]
  cmd_opts[:target_group] = opts[:group] if opts[:group]
  cmd_opts[:target_dataset] = opts[:dataset] if opts[:dataset]

  osctld_fmt(:ct_move, cmd_opts: cmd_opts)
end

#open_console(ctid, pool, tty, raw, &block) ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1077

def open_console(ctid, pool, tty, raw, &block)
  if raw
    open_console_raw(ctid, pool, tty)

  else
    open_console_tty(ctid, pool, tty, &block)
  end
end

#open_console_raw(ctid, pool, tty) ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1114

def open_console_raw(ctid, pool, tty)
  c = osctld_open
  c.cmd_response!(:ct_console, id: ctid, pool: pool, tty: tty)

  console = OsCtl::Console.new(c.socket, STDIN, STDOUT, raw: true)

  Signal.trap('TERM') do
    console.close
  end

  console.open
end

#open_console_tty(ctid, pool, tty) {|c| ... } ⇒ Object

Yields:

• (c)

# File 'lib/osctl/cli/container.rb', line 1086

def open_console_tty(ctid, pool, tty)
  c = osctld_open
  c.cmd_response!(:ct_console, id: ctid, pool: pool, tty: tty)

  puts "Press Ctrl+a q to detach the console"
  puts

  state = `stty -g`
  `stty raw -echo -icanon -isig`

  pid = Process.fork do
    console = OsCtl::Console.new(c.socket, STDIN, STDOUT)

    Signal.trap('WINCH') do
      console.resize(*STDIN.winsize)
    end

    console.open
  end

  yield(c) if block_given?

  Process.wait(pid)

  `stty #{state}`
  puts
end

#passwd ⇒ Object

# File 'lib/osctl/cli/container.rb', line 880

def passwd
  require_args!('id', 'user', optional: %w(password))

  if args[2]
    password = args[2]

  else
    cli = HighLine.new
    password = cli.ask('Password: ') { |q| q.echo = false }.strip
  end

  osctld_fmt(:ct_passwd, cmd_opts: {
    id: args[0],
    pool: gopts[:pool],
    user: args[1],
    password: password,
  })
end

#pid ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1058

def pid
  require_args!('pid|-', strict: false)

  finder = PidFinder.new(header: !opts['hide-header'])

  if args[0] == '-'
    finder.find(STDIN.readline.strip.to_i) until STDIN.eof?

  else
    args.each { |pid| finder.find(pid.to_i) }
  end
end

#prlimit_list ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1198

def prlimit_list
  param_selector = OsCtl::Lib::Cli::ParameterSelector.new(
    all_params: PRLIMIT_FIELDS,
  )

  if opts[:list]
    puts param_selector
    return
  end

  require_args!('id', strict: false)

  cmd_opts = {id: args[0], pool: gopts[:pool]}
  fmt_opts = {layout: :columns}

  cmd_opts[:limits] = args[1..-1] if args.count > 1
  fmt_opts[:header] = false if opts['hide-header']

  fmt_opts[:cols] = param_selector.parse_option(opts[:output])

  data = osctld_call(:ct_prlimit_list, **cmd_opts)
  format_output(data.map { |k, v| v.merge(name: k)}, **fmt_opts)
end

#prlimit_set ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1222

def prlimit_set
  require_args!('id', 'limit', 'value', optional: %w(hard))

  soft, hard = args[2..3].map { |v| /^\d+$/ =~ v ? v.to_i : v }
  hard = soft if hard.nil?

  osctld_fmt(:ct_prlimit_set, cmd_opts: {
    id: args[0],
    pool: gopts[:pool],
    name: args[1],
    soft: soft,
    hard: hard
  })
end

#prlimit_unset ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1237

def prlimit_unset
  require_args!('id', 'limit')

  do_cgparam_unset(
    :ct_prlimit_unset,
    id: args[0],
    pool: gopts[:pool],
    name: args[1]
  )
end

#reconfigure ⇒ Object

# File 'lib/osctl/cli/container.rb', line 943

def reconfigure
  require_args!('id')
  osctld_fmt(:ct_reconfigure, cmd_opts: {id: args[0], pool: gopts[:pool]})
end

#recover_cleanup ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1487

def recover_cleanup
  require_args!('id')

  cleanup = []
  cleanup << 'cgroups' if opts['cgroups']
  cleanup << 'netifs' if opts['network-interfaces']

  cleanup = 'all' if cleanup.empty?

  osctld_fmt(:ct_recover_cleanup, cmd_opts: {
    id: args[0],
    pool: gopts[:pool],
    force: opts[:force],
    cleanup: cleanup,
  })
end

#recover_kill ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1399

def recover_kill
  require_args!('id', optional: %w(signal))

  if args[0].index(':')
    pool, id = args[0].split(':')
  else
    pool = gopts[:pool]
    id = args[0]
  end

  if args[1]
    if args[1] =~ /^\d+$/
      signal = Signal.list.key(args[1].to_i)

      if signal.nil?
        raise GLI::BadCommandLine, "invalid signal '#{args[1]}'"
      end
    else
      name = args[1].upcase

      if Signal.list.has_key?(name)
        signal = name
      else
        raise GLI::BadCommandLine, "invalid signal '#{args[1]}'"
      end
    end
  else
    signal = 'KILL'
  end

  pl = OsCtl::Lib::ProcessList.new do |p|
    ctid = p.ct_id

    next(false) if ctid.nil?

    if pool.nil?
      if ctid[1] == id
        pool = ctid[0]
      else
        next(false)
      end
    end

    ctid[0] == pool && ctid[1] == id
  end

  if pl.empty?
    puts "No processes found"
    return
  end

  out_cols, out_data = Ps::Columns.generate(
    pl,
    Ps::Columns::DEFAULT_ONE_CT,
    gopts[:parsable],
  )

  OsCtl::Lib::Cli::OutputFormatter.print(
    out_data,
    cols: out_cols,
    layout: :columns,
    header: true,
  )

  puts
  STDOUT.write("Kill #{pl.length} processes with SIG#{signal}? [yes/NO]: ")
  STDOUT.flush

  if STDIN.readline.strip.downcase == 'yes'
    pl.each do |p|
      puts "kill -SIG#{signal} #{p.pid}"
      Process.kill(signal, p.pid)
    end
  else
    puts "Aborted"
  end
end

#recover_state ⇒ Object

# File 'lib/osctl/cli/container.rb', line 1477

def recover_state
  require_args!('id')

  osctld_fmt(:ct_recover_state, cmd_opts: {
    id: args[0],
    pool: gopts[:pool],
    manipulation_lock: opts[:lock] ? nil : 'ignore',
  })
end

#reinstall ⇒ Object

# File 'lib/osctl/cli/container.rb', line 296

def reinstall
  require_args!('id')

  cmd_opts = {
    id: args[0],
    pool: opts[:pool] || gopts[:pool],
    repository: opts[:repository],
    remove_snapshots: opts['remove-snapshots'],
  }

  if opts['from-file']
    cmd_opts.update(
      type: :image,
      path: File.absolute_path(opts['from-file']),
    )
  else
    cmd_opts.update(
      type: :remote,
      image: repo_image_attrs(defaults: false),
    )
  end

  osctld_fmt(:ct_reinstall, cmd_opts: cmd_opts)
end

#repo_image_attrs(defaults: true) ⇒ Object (protected)

# File 'lib/osctl/cli/container.rb', line 1567

def repo_image_attrs(defaults: true)
  ret = {}

  if defaults
    ret[:vendor] ||= opts[:vendor] || 'default'
    ret[:variant] ||= opts[:variant] || 'default'
    ret[:arch] ||= opts[:arch] || `uname -m`.strip
    ret[:distribution] ||= opts[:distribution]
    ret[:version] ||= opts[:version] || 'stable'
  else
    ret[:vendor] ||= opts[:vendor]
    ret[:variant] ||= opts[:variant]
    ret[:arch] ||= opts[:arch]
    ret[:distribution] ||= opts[:distribution]
    ret[:version] ||= opts[:version]
  end

  ret
end

#restart ⇒ Object

# File 'lib/osctl/cli/container.rb', line 389

def restart
  require_args!('id')

  if opts[:kill] && opts['dont-kill']
    raise GLI::BadCommandLine, '--kill and --dont-kill cannot be used together'

  elsif (opts[:kill] || opts['dont-kill']) && opts[:reboot]
    raise GLI::BadCommandLine, '--kill and --dont-kill cannot be used with --reboot'

  elsif opts[:kill]
    m = :kill

  elsif opts['dont-kill']
    m = :shutdown_or_fail

  else
    m = :shutdown_or_kill
  end

  if opts[:foreground] && opts[:attach]
    raise GLI::BadCommandLine, 'use either --foreground or --attach'
  end

  cmd_opts = {
    id: args[0],
    pool: gopts[:pool],
    wait: get_ct_wait(opts[:wait]),
    reboot: opts[:reboot],
    stop_timeout: opts[:timeout],
    stop_method: m,
    message: opts[:message],
  }


  if opts[:foreground]
    open_console(args[0], gopts[:pool], 0, gopts[:json]) do |sock|
      sock.close if osctld_resp(:ct_restart, **cmd_opts).error?
    end

    return
  end

  osctld_fmt(:ct_restart, cmd_opts: cmd_opts)

  if opts[:attach]
    puts 'Attaching'
    attach
  end
end

#runscript ⇒ Object

# File 'lib/osctl/cli/container.rb', line 479

def runscript
  require_args!('id', 'script', strict: false)

  c = osctld_open
  cont = c.cmd_data!(
    :ct_runscript,
    id: args[0],
    pool: gopts[:pool],
    script: args[1] == '-' ? nil : File.realpath(args[1]),
    arguments: args[2..-1],
    run: opts['run-container'],
    network: opts['network'],
  )

  if cont != 'continue'
    warn "runscript not available: invalid response '#{cont}'"
    exit(false)
  end

  handle_exec_io(c)
end

#set(option) ⇒ Object (protected)

# File 'lib/osctl/cli/container.rb', line 1551

def set(option)
  require_args!('id', strict: false)
  cmd_opts = {id: args[0], pool: gopts[:pool]}
  cmd_opts[option] = yield(args[1..-1])

  osctld_fmt(:ct_set, cmd_opts: cmd_opts)
end

#set_attr ⇒ Object

# File 'lib/osctl/cli/container.rb', line 722

def set_attr
  require_args!('id', 'attribute', 'value')
  do_set_attr(
    :ct_set,
    {id: args[0], pool: gopts[:pool]},
    args[1],
    args[2],
  )
end

#set_autostart ⇒ Object

# File 'lib/osctl/cli/container.rb', line 521

def set_autostart
  set(:autostart) do
    {
      priority: opts[:priority],
      delay: opts[:delay],
    }
  end
end

#set_cpu_limit ⇒ Object

# File 'lib/osctl/cli/container.rb', line 697

def set_cpu_limit
  require_args!('id', 'limit')
  do_set_cpu_limit(:ct_cgparam_set, id: args[0], pool: gopts[:pool])
end

#set_cpu_package ⇒ Object

# File 'lib/osctl/cli/container.rb', line 611

def set_cpu_package
  set(:cpu_package) do |args|
    str = args[0]

    if %w(auto none).include?(str)
      str
    elsif /^\d+$/ =~ str
      pkg_id = str.to_i

      topology = OsCtl::Lib::CpuTopology.new

      unless topology.packages.has_key?(pkg_id)
        warn "Warning: CPU package #{pkg_id.inspect} does not exist on this system"
        warn "Available CPU packages: #{topology.packages.keys.join(', ')}"
      end

      pkg_id
    else
      raise GLI::BadCommandLine, "CPU package must be a number or auto/none"
    end
  end
end

#set_distribution ⇒ Object

# File 'lib/osctl/cli/container.rb', line 573

def set_distribution
  set(:distribution) do |args|
    if args.count < 2 || args.count > 3
      raise GLI::BadCommandLine, 'expected <distribution> <version> [arch]'
    end

    {
      name: args[0],
      version: args[1],
      arch: args[2],
    }
  end
end

#set_dns_resolver ⇒ Object

# File 'lib/osctl/cli/container.rb', line 552

def set_dns_resolver
  set(:dns_resolvers) do |args|
    raise GLI::BadCommandLine, 'expected at least one address' if args.empty?
    args
  end
end

#set_ephemeral ⇒ Object

# File 'lib/osctl/cli/container.rb', line 534

def set_ephemeral
  set(:ephemeral) { true }
end

#set_hostname ⇒ Object

# File 'lib/osctl/cli/container.rb', line 542

def set_hostname
  set(:hostname) do |args|
    args[0] || (fail 'expected hostname')
  end
end

#set_image_config ⇒ Object

# File 'lib/osctl/cli/container.rb', line 587

def set_image_config
  require_args!('id')

  cmd_opts = {
    id: args[0],
    pool: opts[:pool] || gopts[:pool],
    repository: opts[:repository],
    image: repo_image_attrs(defaults: false),
  }

  if opts['from-file']
    cmd_opts.update(
      type: :image,
      path: File.absolute_path(opts['from-file']),
    )
  else
    cmd_opts.update(
      type: :remote,
    )
  end

  osctld_fmt(:ct_set_image_config, cmd_opts: cmd_opts)
end

#set_init_cmd ⇒ Object

# File 'lib/osctl/cli/container.rb', line 656

def set_init_cmd
  set(:init_cmd) { |args| args }
end

#set_lxcfs ⇒ Object

# File 'lib/osctl/cli/container.rb', line 676

def set_lxcfs
  set(:lxcfs) do
    {
      loadavg: opts[:loadavg],
      cfs: opts[:cfs],
    }
  end
end

#set_memory_limit ⇒ Object

# File 'lib/osctl/cli/container.rb', line 707

def set_memory_limit
  require_args!('id', 'memory', optional: %w(swap))
  do_set_memory(
    :ct_cgparam_set,
    :ct_cgparam_unset,
    id: args[0],
    pool: gopts[:pool]
  )
end

#set_nesting ⇒ Object

# File 'lib/osctl/cli/container.rb', line 563

def set_nesting
  set(:nesting) do |args|
    true
  end
end

#set_raw_lxc ⇒ Object

# File 'lib/osctl/cli/container.rb', line 689

def set_raw_lxc
  set(:raw_lxc) { |args| STDIN.read }
end

#set_seccomp_profile ⇒ Object

# File 'lib/osctl/cli/container.rb', line 638

def set_seccomp_profile
  set(:seccomp_profile) do |args|
    if args.count != 1
      raise GLI::BadCommandLine, 'expected <profile>'

    elsif !File.exist?(args[0])
      raise GLI::BadCommandLine, "file '#{args[0]}' does not exist"

    else
      File.absolute_path(args[0])
    end
  end
end

#set_start_menu ⇒ Object

# File 'lib/osctl/cli/container.rb', line 664

def set_start_menu
  set(:start_menu) do
    {
      timeout: opts[:timeout],
    }
  end
end

#show ⇒ Object

# File 'lib/osctl/cli/container.rb', line 204

def show
  c = osctld_open
  cg_init_subsystems(c)

  cgparams = cg_list_raw_cgroup_params
  zfsprops = ZfsProperties.new
  keyring = KernelKeyring.new

  param_selector = OsCtl::Lib::Cli::ParameterSelector.new(
    all_params: FIELDS + cgparams + zfsprops.list_property_names + keyring.list_param_names,
    default_params: DEFAULT_FIELDS,
  )

  if opts[:list]
    puts param_selector
    return
  end

  require_args!('id')

  cols = param_selector.parse_option(opts[:output])
  cols = zfsprops.validate_property_names(cols)

  cmd_opts = {
    id: args[0],
    pool: gopts[:pool],
  }

  if cols.include?(:hostname_readout)
    cmd_opts[:read_hostname] = true
  end

  ct = c.cmd_data!(:ct_show, **cmd_opts)

  cg_add_stats(ct, ct[:group_path], cols, gopts[:parsable])
  c.close

  add_loadavg(ct)

  cg_add_raw_cgroup_params(
    ct,
    ct[:group_path],
    cols & cgparams.map(&:to_sym)
  )

  zfsprops.add_container_values(ct, cols, precise: gopts[:parsable])
  keyring.add_container_values(ct, cols, precise: gopts[:parsable])

  format_output(ct, cols: cols, header: !opts['hide-header'], opts: {
    memory_limit: {
      align: 'right',
      display: Proc.new do |v|
        if v.nil? || gopts[:parsable] || gopts[:json]
          v
        else
          humanize_data(v)
        end
      end,
    },
    swap_limit: {
      align: 'right',
      display: Proc.new do |v|
        if v.nil? || gopts[:parsable] || gopts[:json]
          v
        else
          humanize_data(v)
        end
      end,
    },
  })
end

#start ⇒ Object

# File 'lib/osctl/cli/container.rb', line 326

def start
  require_args!('id')

  if opts[:foreground] && opts[:attach]
    raise GLI::BadCommandLine, 'use either --foreground or --attach'
  end

  cmd_opts = {
    id: args[0],
    pool: gopts[:pool],
    wait: get_ct_wait(opts[:wait]),
    queue: opts[:queue],
    priority: opts[:priority],
    debug: opts[:debug],
  }

  if opts[:foreground]
    open_console(args[0], gopts[:pool], 0, gopts[:json]) do |sock|
      sock.close if osctld_resp(:ct_start, **cmd_opts).error?
    end

    return
  end

  osctld_fmt(:ct_start, cmd_opts: cmd_opts)

  if opts[:attach]
    puts 'Attaching'
    attach
  end
end

#stop ⇒ Object

# File 'lib/osctl/cli/container.rb', line 358

def stop
  require_args!('id')

  if opts[:kill] && opts['dont-kill']
    raise GLI::BadCommandLine, '--kill and --dont-kill cannot be used together'

  elsif opts[:kill]
    m = :kill

  elsif opts['dont-kill']
    m = :shutdown_or_fail

  else
    m = :shutdown_or_kill
  end

  cmd_opts = {
    id: args[0],
    pool: gopts[:pool],
    timeout: opts[:timeout],
    method: m,
    message: opts[:message],
  }

  return osctld_fmt(:ct_stop, cmd_opts: cmd_opts) unless opts[:foreground]

  open_console(args[0], gopts[:pool], 0, gopts[:json]) do |sock|
    sock.close if osctld_resp(:ct_stop, **cmd_opts).error?
  end
end

#su ⇒ Object

# File 'lib/osctl/cli/container.rb', line 514

def su
  require_args!('id')

  cmd = osctld_call(:ct_su, id: args[0], pool: gopts[:pool])
  handle_ct_attach(cmd)
end

#tree ⇒ Object

# File 'lib/osctl/cli/container.rb', line 194

def tree
  require_args!('pool')
  Tree.print(
    args[0],
    parsable: gopts[:parsable],
    color: gopts[:color],
    containers: true
  )
end

#unfreeze ⇒ Object

# File 'lib/osctl/cli/container.rb', line 953

def unfreeze
  require_args!('id')
  osctld_fmt(:ct_unfreeze, cmd_opts: {id: args[0], pool: gopts[:pool]})
end

#unset(option) ⇒ Object (protected)

# File 'lib/osctl/cli/container.rb', line 1559

def unset(option)
  require_args!('id', strict: false)
  cmd_opts = {id: args[0], pool: gopts[:pool]}
  cmd_opts[option] = block_given? ? yield(args[1..-1]) : true

  osctld_fmt(:ct_unset, cmd_opts: cmd_opts)
end

#unset_attr ⇒ Object

# File 'lib/osctl/cli/container.rb', line 732

def unset_attr
  require_args!('id', 'attribute')
  do_unset_attr(
    :ct_unset,
    {id: args[0], pool: gopts[:pool]},
    args[1],
  )
end

#unset_autostart ⇒ Object

# File 'lib/osctl/cli/container.rb', line 530

def unset_autostart
  unset(:autostart)
end

#unset_cpu_limit ⇒ Object

# File 'lib/osctl/cli/container.rb', line 702

def unset_cpu_limit
  require_args!('id')
  do_unset_cpu_limit(:ct_cgparam_unset, id: args[0], pool: gopts[:pool])
end

#unset_cpu_package ⇒ Object

# File 'lib/osctl/cli/container.rb', line 634

def unset_cpu_package
  unset(:cpu_package)
end

#unset_dns_resolver ⇒ Object

# File 'lib/osctl/cli/container.rb', line 559

def unset_dns_resolver
  unset(:dns_resolvers)
end

#unset_ephemeral ⇒ Object

# File 'lib/osctl/cli/container.rb', line 538

def unset_ephemeral
  unset(:ephemeral)
end

#unset_hostname ⇒ Object

# File 'lib/osctl/cli/container.rb', line 548

def unset_hostname
  unset(:hostname)
end

#unset_init_cmd ⇒ Object

# File 'lib/osctl/cli/container.rb', line 660

def unset_init_cmd
  unset(:init_cmd)
end

#unset_lxcfs ⇒ Object

# File 'lib/osctl/cli/container.rb', line 685

def unset_lxcfs
  unset(:lxcfs)
end

#unset_memory_limit ⇒ Object

# File 'lib/osctl/cli/container.rb', line 717

def unset_memory_limit
  require_args!('id')
  do_unset_memory(:ct_cgparam_unset, id: args[0], pool: gopts[:pool])
end

#unset_nesting ⇒ Object

# File 'lib/osctl/cli/container.rb', line 569

def unset_nesting
  unset(:nesting)
end

#unset_raw_lxc ⇒ Object

# File 'lib/osctl/cli/container.rb', line 693

def unset_raw_lxc
  unset(:raw_lxc)
end

#unset_seccomp_profile ⇒ Object

# File 'lib/osctl/cli/container.rb', line 652

def unset_seccomp_profile
  unset(:seccomp_profile)
end

#unset_start_menu ⇒ Object

# File 'lib/osctl/cli/container.rb', line 672

def unset_start_menu
  unset(:start_menu)
end

#wall ⇒ Object

# File 'lib/osctl/cli/container.rb', line 501

def wall
  msg = opts[:message] || STDIN.read

  osctld_fmt(
    :ct_wall,
    cmd_opts: {
      ids: args.empty? ? nil : args,
      message: msg,
      banner: !opts['hide-banner'],
    },
  )
end