571 lines
16 KiB
Ruby
Executable File
571 lines
16 KiB
Ruby
Executable File
#!/usr/bin/ruby
|
|
require 'yaml'
|
|
require 'pp'
|
|
require 'shellwords'
|
|
require 'getoptlong'
|
|
require 'ostruct'
|
|
require 'json'
|
|
|
|
MAPPINGS = [
|
|
# Syntax:
|
|
# [name_in_yml, docker_option_name, lambda_for_creating_yml_for_container=nil, options={}]
|
|
# Options are:
|
|
# type: Sets type of this option
|
|
# switch: Only adds the docker_option_name to the command, ignoring the value.
|
|
# name: Value will be set to the name of the container (from yml filename or root element)
|
|
# hidden: Will not be added to the run command
|
|
# allow_empty: May be empty.
|
|
# escape: If set to false, will not be shellescaped
|
|
|
|
['stdin_open', '--interactive', lambda{|c,i| c.Config.OpenStdin}, {:type=>:switch}],
|
|
['tty', '--tty', lambda{|c,i| c.Config.Tty}, {:type=>:switch}],
|
|
#['detach', '--detach', {:type=>:switch}],
|
|
['remove', '--rm', lambda{|c,i| c.HostConfig.AutoRemove}, {:type=>:switch}],
|
|
['container_name', '--name', nil, {:type=>:name}],
|
|
['ports', '--publish', lambda{|c,i| c.HostConfig.PortBindings.to_h.collect{|k,v| "#{v.first.HostPort}:#{k.to_s.gsub("/tcp", "")}" }}],
|
|
['restart', '--restart', lambda{|c,i| c.HostConfig.RestartPolicy.Name}],
|
|
['environment', '--env', lambda{|c,i| e=c.Config.Env.delete_if{|v| i.Config.Env.include?(v)}; e}],
|
|
['volumes', '--volume', lambda{|c,i| c.HostConfig.Binds}],
|
|
['mem_limit', '--memory', lambda{|c,i| (mem=c.HostConfig.Memory)==0 ? nil : mem}],
|
|
['links', '--link'],
|
|
['stop_signal', '--stop-signal', lambda{|c,i| c.Config.StopSignal!="SIGTERM" ? c.Config.StopSignal : nil}],
|
|
['stop_grace_period', '--stop-timeout', lambda{|c,i| c.Config.StopTimeout}],
|
|
['devices', '--device'],
|
|
['net', '--net'],
|
|
['ipv6', '--ipv6'],
|
|
['user', '--user'],
|
|
['networks', '--network', lambda{|c,i| c.NetworkSettings.Networks.to_h.keys.map(&:to_s)}, {:type=>:hidden}],
|
|
['entrypoint', '--entrypoint', lambda{|c,i| (ep=c.Config.Entrypoint) == i.Config.Entrypoint ? nil : ep}, {:allow_empty=>true}],
|
|
['labels', '--label', lambda{|c,i| l=Hash[c.Config.Labels.to_h.delete_if{|k,v| i.Config.Labels[k]==v rescue false}.map{|k,v| [k.to_s, v]}] ; l}],
|
|
['hostname', '--hostname'],
|
|
['shm_size', '--shm-size'],
|
|
['working_dir', '--workdir', lambda{|c,i| (wd=c.Config.WorkingDir) == i.Config.WorkingDir ? nil : wd}],
|
|
['init', '--init', lambda{|c,i| c.Config.Init}, {:type=>:switch}],
|
|
['image', nil, lambda{|c,i| c.Config.Image}],
|
|
['command', nil, lambda{|c,i| (cmd=c.Config.Cmd.join(" ") rescue nil) == (i.Config.Cmd.join(" ") rescue nil)? nil : cmd}, {:escape=>false}],
|
|
['test', nil, nil, {type: :hidden}],
|
|
['auto_update', nil, nil, {type: :hidden}],
|
|
['ofelia', nil, nil, {type: :hidden}]
|
|
]
|
|
|
|
|
|
def get_sample(name="container")
|
|
return <<~HEREDOC
|
|
image: "my/image:1.2.3"
|
|
restart: always
|
|
detach: true
|
|
test: true # Having this set to true will prevent dup from creating a label de.fabianonline.dup
|
|
auto_update: true # Enabling this adds a label to allow watchtower to automatically update this container
|
|
|
|
ports:
|
|
- "1234:1234"
|
|
- "8080"
|
|
- "1001:1001/udp"
|
|
|
|
environment:
|
|
VERSION: 1.7.0
|
|
TZ:
|
|
|
|
volumes:
|
|
- "/etc/localtime:/etc/localtime:ro"
|
|
|
|
labels:
|
|
# Syntax:
|
|
# <hostname>: Uses the given hostname and the default cert (*.schle.nz)
|
|
# <hostname>@: Uses the given hostname and the cert with the same name
|
|
# <hostname>@<cert>: Uses the given hostname and cert
|
|
nginx_virtual_host: container.home.schle.nz
|
|
nginx_port: 80
|
|
nginx_additional_ports: "443, 5050"
|
|
nginx_no_robots: true
|
|
nginx_public_paths: "/public, /api"
|
|
nginx_type: # "http" (default), "https", "fastcgi", "skip" (doesn't create any entries)
|
|
nginx_client_max_body_size: "25M"
|
|
# Syntax:
|
|
# user:<username>
|
|
# group:<groupname>
|
|
authelia_allow: "user:fabian"
|
|
# Policies:
|
|
# one_factor
|
|
# two_factor
|
|
# bypass
|
|
authelia_policy: one_factor
|
|
|
|
networks:
|
|
- "nginx"
|
|
- "mosquitto"
|
|
- "bridge"
|
|
|
|
user: "1000:1000"
|
|
command: "/bin/bash"
|
|
entrypoint: "/script.sh"
|
|
build: "/data/dir"
|
|
pull: false
|
|
container_name: "Something"
|
|
hostname: "foo"
|
|
mem_limit: 125M
|
|
stdin_open: false
|
|
net: host
|
|
tty: false
|
|
remove: false
|
|
stop_signal: SIGUSR1
|
|
stop_grace_period: 5
|
|
shm_size: 256M
|
|
|
|
before_build:
|
|
- "echo 'Starting build'"
|
|
after_build:
|
|
- "echo 'After build'"
|
|
before_run:
|
|
- "echo 'Starting run'"
|
|
after_run:
|
|
- "echo 'Run has finished.'"
|
|
- "docker restart container"
|
|
|
|
devices:
|
|
- "/dev/ttyUSB0:/dev/ttyUSB0"
|
|
|
|
ofelia:
|
|
- name: update # No spaces!
|
|
schedule: "@every 4h" # go cron format! See https://pkg.go.dev/github.com/robfig/cron?utm_source=godoc
|
|
command: uname -a
|
|
user: foo
|
|
tty: false
|
|
no-overlap: true
|
|
- name: Test 2
|
|
HEREDOC
|
|
end
|
|
|
|
def action_sample
|
|
puts get_sample
|
|
exit 1
|
|
end
|
|
|
|
def action_help
|
|
puts "-h, --help Show this help."
|
|
puts "-n, --dry-run Don't execute any commands."
|
|
puts "-s, --sample Outputs a sample yml file."
|
|
puts "-c, --create Create a new container yml file."
|
|
puts "-p, --pull (Try to) Pull the image(s) before starting the container."
|
|
puts "-l, --list Lists all available containers."
|
|
puts " --host Starts a container with net: host - which implies not using ports, networks and/or links."
|
|
puts " --regenerate Generates YAML content from a running container."
|
|
puts " --all Use all containers defined in yml files."
|
|
puts "-v, --verbose More verbose output."
|
|
puts "-q, --quiet Don't open log after starting a new container."
|
|
exit 1
|
|
end
|
|
|
|
def run_cmd(cmd, ignore_returnvalue=false, catch_interrupt=false, ignore_dry_run: false)
|
|
verbose "+ #{cmd}"
|
|
returnvalue=false
|
|
begin
|
|
returnvalue = ($dry_run && !ignore_dry_run) ? true : system("bash -c #{cmd.shellescape}")
|
|
rescue Interrupt
|
|
raise if not catch_interrupt
|
|
end
|
|
raise "Command returned a non-zero exit value." if returnvalue!=true && !ignore_returnvalue
|
|
return returnvalue
|
|
end
|
|
|
|
def collect_commands(&block)
|
|
$commands = []
|
|
def run_cmd(cmd, ignore_returnvalue=false, catch_interrupt=false, ignore_dry_run: false); $commands<<cmd; return 0; end
|
|
|
|
yield
|
|
|
|
return $commands
|
|
end
|
|
|
|
def esc(obj, escape=true)
|
|
return obj unless escape
|
|
return obj.to_s.shellescape
|
|
end
|
|
|
|
def action_create(container)
|
|
file = container.file
|
|
raise "File #{file} already exists" if File.exists?(file)
|
|
|
|
File.open(file, "w") {|f| f.write(get_sample(container))}
|
|
|
|
exec("/usr/bin/editor #{file.shellescape}")
|
|
exit 1 # will never be reached because exec replaces this process. But just in case... ;-)
|
|
end
|
|
|
|
def action_run(container)
|
|
# $net_host
|
|
container.each{|c| c.run(container.count>1)}
|
|
end
|
|
|
|
def list(base_dir)
|
|
result = {:containers=>{}, :errors=>[]}
|
|
Dir[File.join(base_dir, "*.yml")].sort.each do |file|
|
|
basename = File.basename(file)[0..-5]
|
|
yaml = File.open(file, "r") {|f| YAML.load(f.read)}
|
|
keys = yaml.keys
|
|
|
|
if keys.include? basename
|
|
additional = keys.reject{|k| k==basename}
|
|
result[:containers][basename] = additional
|
|
else
|
|
result[:errors] << "#{file}:\n Missing a key called #{basename}\n Has keys:\n#{keys.map{|k| " #{k}"}.join("\n")}"
|
|
end
|
|
end
|
|
return result
|
|
end
|
|
|
|
def action_list(base_dir)
|
|
list = list(base_dir)
|
|
list[:containers].each do |container, additional|
|
|
puts container
|
|
additional.each{|c| puts " + #{c}"}
|
|
end
|
|
|
|
list[:errors].each do |e|
|
|
puts "ERROR: #{e}"
|
|
puts
|
|
end
|
|
|
|
return list[:errors].empty? ? 0 : 1
|
|
end
|
|
|
|
def action_completion(base_dir, complete_str)
|
|
#puts "in completion"
|
|
return unless base_dir
|
|
#puts "str is #{complete_str}"
|
|
containers = list(base_dir)[:containers].keys.select{|c| c.start_with?(complete_str)}
|
|
puts containers.join(" ")
|
|
end
|
|
|
|
def action_regenerate(container)
|
|
container.each do |c|
|
|
data = c.regenerate
|
|
p collect_commands{ c.run }
|
|
end
|
|
end
|
|
|
|
class Container
|
|
def initialize(name)
|
|
@name = name
|
|
end
|
|
|
|
def exists?
|
|
run_cmd("docker inspect --format='1' #{@name.shellescape} >/dev/null 2>&1", true, ignore_dry_run: true)
|
|
end
|
|
|
|
def load
|
|
raise "File #{self.filename} not found." unless File.exists?(self.filename)
|
|
|
|
@data = File.open(self.filename, "r") {|f| YAML.load(f.read)}
|
|
|
|
if @data.has_key?(@name)
|
|
if @data.keys.count > 1
|
|
raise "Expected #{self.filename} to contain all data on top level or underneath a single root element named #{@name}."
|
|
end
|
|
@data = @data[@name]
|
|
end
|
|
end
|
|
|
|
def filename; "%s/%s.yml" % [$base_dir, @name]; end
|
|
|
|
def add_label(key, value)
|
|
if @data["labels"].is_a? Array
|
|
@data["labels"] << "#{key}=#{value}"
|
|
elsif @data["labels"].is_a? Hash
|
|
@data["labels"][key] = value
|
|
else
|
|
raise "data['labels'] is of an unexpected type: #{@data["labels"].class}"
|
|
end
|
|
end
|
|
|
|
def build_run_command
|
|
$net_host = true if @data["net"]=="host"
|
|
cmd = ["docker", "create"]
|
|
cmd << "--net" << @data["networks"][0] if @data["networks"] && @data["networks"].count>0 && !$net_host
|
|
cmd << "--net" << "host" if $net_host
|
|
|
|
@data["labels"] ||= []
|
|
|
|
if !@data["test"]
|
|
add_label("de.fabianonline.dup", "true")
|
|
end
|
|
|
|
if @data["auto_update"]
|
|
add_label("com.centurylinklabs.watchtower.enable", "true")
|
|
end
|
|
|
|
if @data["ofelia"] && @data["ofelia"].count > 0
|
|
add_label("ofelia.enabled", "true")
|
|
|
|
@data["ofelia"].each_with_index do |job, index|
|
|
name = job["name"] || "job-#{index}"
|
|
name = name.downcase.gsub(/[^a-z0-9\-]/, "-").gsub(/-+/, "-")
|
|
schedule = job["schedule"]
|
|
next unless schedule
|
|
command = job["command"]
|
|
next unless command
|
|
add_label("ofelia.job-exec.#{name}.schedule", schedule)
|
|
add_label("ofelia.job-exec.#{name}.command", command)
|
|
add_label("ofelia.job-exec.#{name}.user", job["user"]) if job["user"]
|
|
add_label("ofelia.job-exec.#{name}.tty", job["tty"].to_s) if job["tty"]!=nil
|
|
ol = job["no-overlap"]
|
|
add_label("ofelia.job-exec.#{name}.no-overlap", ol!=nil ? ol.to_s : "true")
|
|
end
|
|
end
|
|
|
|
MAPPINGS.each do |mapping|
|
|
yml_name, cmd_name, reverse_lambda, options = *mapping
|
|
next if $net_host && %w(links net ports).include?(yml_name)
|
|
next if options && options[:type]==:hidden
|
|
options ||= {}
|
|
if !@data[yml_name]
|
|
if options[:type]==:name
|
|
cmd << cmd_name << esc(@name)
|
|
end
|
|
next
|
|
end
|
|
|
|
if options[:allow_empty] && @data[yml_name]==""
|
|
cmd << cmd_name << '""'
|
|
next
|
|
end
|
|
|
|
|
|
if options[:type]==:switch
|
|
cmd << cmd_name
|
|
next
|
|
end
|
|
|
|
if @data[yml_name].is_a?(Array)
|
|
@data[yml_name].each {|val| cmd << cmd_name << esc(val, options[:escape])}
|
|
elsif @data[yml_name].is_a?(Hash)
|
|
@data[yml_name].each {|key, val| cmd << cmd_name << "#{esc(key, options[:escape])}=\"#{esc(val, options[:escape])}\""}
|
|
else
|
|
cmd << cmd_name << esc(@data[yml_name], options[:escape])
|
|
end
|
|
end
|
|
|
|
return cmd.compact.join(" ")
|
|
end
|
|
|
|
def build
|
|
(@data["before_build"] || []).each{|cmd| run_cmd(cmd)}
|
|
cmd = ["docker", "build", "-t", @data["image"].shellescape, @data["build"].shellescape]
|
|
run_cmd(cmd.join(" "))
|
|
(@data["after_build"] || []).each{|cmd| run_cmd(cmd)}
|
|
end
|
|
|
|
def pull
|
|
run_cmd("docker pull #{@data["image"].shellescape}", true)
|
|
end
|
|
|
|
def stop_and_remove
|
|
verbose "Stopping and removing old container..."
|
|
run_cmd("docker stop #{@name.shellescape} >/dev/null 2>&1", true)
|
|
run_cmd("docker rm -f #{@name.shellescape} >/dev/null 2>&1", true)
|
|
end
|
|
|
|
def create_networks
|
|
if !$net_host && (@data["networks"]||=[]).count>0
|
|
networks = `docker network ls --format '{{.Name}}'`.split
|
|
@data["networks"].each do |network|
|
|
if networks.include?(network)
|
|
verbose "Network #{network} exists."
|
|
else
|
|
verbose "Creating network #{network}..."
|
|
run_cmd("docker network create #{network.shellescape}", true)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def connect_to_networks
|
|
if !$net_host && @data["networks"].count>0
|
|
@data["networks"].each do |network|
|
|
verbose "Connecting container to network #{network}..."
|
|
run_cmd("docker network connect #{network.shellescape} #{@name.shellescape} >/dev/null", true)
|
|
end
|
|
end
|
|
end
|
|
|
|
def attach
|
|
verbose "Attaching container..."
|
|
run_cmd("docker attach #{@name.shellescape}")
|
|
end
|
|
|
|
def log
|
|
puts "Opening log... (press Ctrl-C to exit)"
|
|
puts
|
|
run_cmd("docker logs -f #{@name.shellescape}", true, true)
|
|
end
|
|
|
|
def run(force_background = false)
|
|
raise "No data loaded. Maybe call .load first?" if @data.nil?
|
|
|
|
if @data["build"]
|
|
self.build
|
|
end
|
|
|
|
(@data["before_run"] || []).each{|cmd| run_cmd(cmd)}
|
|
|
|
if @data["pull"] || $pull
|
|
self.pull
|
|
end
|
|
|
|
if self.exists?
|
|
puts "Recreating #{@name}..."
|
|
else
|
|
puts "Creating #{@name}..."
|
|
end
|
|
|
|
self.stop_and_remove
|
|
|
|
self.create_networks
|
|
|
|
verbose "Creating container..."
|
|
cmd = build_run_command
|
|
run_cmd(cmd + " >/dev/null")
|
|
|
|
self.connect_to_networks
|
|
|
|
verbose "Starting container..."
|
|
run_cmd("docker start #{@name.shellescape} >/dev/null")
|
|
|
|
(@data["after_run"] || []).each{|cmd| run_cmd(cmd)}
|
|
|
|
if !force_background
|
|
if ! @data["detach"]
|
|
self.attach
|
|
else
|
|
unless $quiet
|
|
self.log
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
def regenerate
|
|
c_data = `docker inspect #{@name}`
|
|
c = JSON.parse(c_data, object_class: OpenStruct).first
|
|
i_data = `docker inspect #{c.Image}`
|
|
i = JSON.parse(i_data, object_class: OpenStruct).first
|
|
|
|
data = {}
|
|
|
|
MAPPINGS.each do |m|
|
|
name, cmd, lmbd, opts = *m
|
|
|
|
next unless lmbd
|
|
result = lmbd.call(c, i)
|
|
next if opts && opts[:type]==:switch && result==false
|
|
next if result==nil || result==[]
|
|
|
|
data[name] = result
|
|
end
|
|
|
|
@data = data
|
|
return data
|
|
end
|
|
end
|
|
|
|
def verbose(str); puts(str) if $verbose; end
|
|
|
|
action = :run
|
|
container = nil
|
|
$dry_run = false
|
|
$verbose = false
|
|
$pull = false
|
|
needs_container = true
|
|
completion_str = ""
|
|
silent_basedir = false
|
|
$net_host = false
|
|
$quiet = false
|
|
|
|
if ENV['DUP_DIR']
|
|
$base_dir = ENV['DUP_DIR']
|
|
else
|
|
$base_dir = File.join(Dir.home, ".dup")
|
|
STDERR.puts "Environment variable DUP_DIR is not set. Looking for .yml files in #{$base_dir}" unless silent_basedir
|
|
end
|
|
|
|
opts = GetoptLong.new(
|
|
[ '--sample', '-s', GetoptLong::NO_ARGUMENT ],
|
|
[ '--create', '-c', GetoptLong::NO_ARGUMENT ],
|
|
[ '--help', '-h', GetoptLong::NO_ARGUMENT ],
|
|
[ '--dry-run', '-n', GetoptLong::NO_ARGUMENT ],
|
|
[ '--list', '-l', GetoptLong::NO_ARGUMENT ],
|
|
[ '--pull', '-p', GetoptLong::NO_ARGUMENT ],
|
|
[ '--update', '-u', GetoptLong::NO_ARGUMENT ],
|
|
[ '--_completion', GetoptLong::OPTIONAL_ARGUMENT ],
|
|
[ '--host', GetoptLong::NO_ARGUMENT ],
|
|
[ '--regenerate', GetoptLong::NO_ARGUMENT ],
|
|
[ '--verbose', '-v', GetoptLong::NO_ARGUMENT ],
|
|
[ '--all', GetoptLong::NO_ARGUMENT ],
|
|
[ '--quiet', '-q', GetoptLong::NO_ARGUMENT ]
|
|
)
|
|
|
|
opts.each do |opt, arg|
|
|
case opt
|
|
when '--sample'
|
|
action_sample
|
|
when '--create'
|
|
action = :create
|
|
when '--help'
|
|
action_help
|
|
when '--dry-run'
|
|
puts "Dry-run. Not going to execute any command."
|
|
$dry_run = true
|
|
when '--list'
|
|
action = :list
|
|
needs_container = false
|
|
when '--pull'
|
|
$pull = true
|
|
when '--update'
|
|
action = :update
|
|
needs_container = false
|
|
when '--_completion'
|
|
action = :_completion
|
|
completion_str = arg
|
|
needs_container = false
|
|
silent_basedir = true
|
|
when '--host'
|
|
$net_host = true
|
|
when '--regenerate'
|
|
action = :regenerate
|
|
needs_container = false
|
|
when '--verbose'
|
|
$verbose = true
|
|
when '--all'
|
|
container = Dir[$base_dir + "/*.yml"].sort.map{|f| Container.new(File.basename(f, ".yml"))}
|
|
when '--quiet'
|
|
$quiet = true
|
|
end
|
|
end
|
|
|
|
container ||= ARGV.map{|c| Container.new(c)}
|
|
|
|
if needs_container
|
|
if container.empty?
|
|
raise "No container given."
|
|
end
|
|
|
|
container.each(&:load)
|
|
end
|
|
|
|
if action == :create
|
|
action_create(container)
|
|
elsif action == :run
|
|
action_run(container)
|
|
elsif action == :list
|
|
action_list(base_dir)
|
|
elsif action == :update
|
|
action_update(base_dir)
|
|
elsif action == :regenerate
|
|
action_regenerate(container)
|
|
container.each {|c| puts c.build_run_command}
|
|
elsif action == :_completion
|
|
action_completion($base_dir, completion_str)
|
|
end
|
|
|
|
|