takelage 0.18.1

data/lib/takelage/docker/image/tag/list/cli.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Takelage
+  # takelage docker image tag list
+  class DockerImageTagList < SubCommandBase
+    include LoggingModule
+    include SystemModule
+    include ConfigModule
+    include DockerCheckRunning
+    include DockerImageTagListLocal
+    include DockerImageTagListRemote
+
+    # Initialize takelage docker image tag list
+    def initialize(args = [], local_options = {}, configuration = {})
+      # initialize thor parent class
+      super args, local_options, configuration
+
+      @docker_user = config.active['docker_user']
+      @docker_repo = config.active['docker_repo']
+      @docker_registry = config.active['docker_registry']
+    end
+
+    #
+    # docker image tag list local
+    #
+    desc 'local', 'Print local docker image tags'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    Print local docker image tags
+    LONGDESC
+    # Print local docker image tags.
+    def local
+      tag_list_local = docker_image_tag_list_local
+      exit false if tag_list_local == false
+      say tag_list_local
+      true
+    end
+
+    #
+    # docker image tag list remote
+    #
+    desc 'remote', 'Print remote docker image tags'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    Print remote docker image tags
+    LONGDESC
+    # Print latest remote docker image tag.
+    def remote
+      tag_list_remote = docker_image_tag_list_remote
+      exit false if tag_list_remote == false
+      say tag_list_remote
+      true
+    end
+  end
+end

data/lib/takelage/docker/image/tag/list/local.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# takelage docker image tag list local
+module DockerImageTagListLocal
+  # Backend method for docker image tag list local.
+  # @return [Array] local docker image tags
+  def docker_image_tag_list_local
+    cmd_docker_tags =
+      format(
+        config.active['cmd_docker_image_tag_list_local_docker_images'],
+        docker_user: @docker_user,
+        docker_repo: @docker_repo
+      )
+
+    tags = (run cmd_docker_tags).split("\n")
+
+    VersionSorter.sort(tags)
+  end
+end

data/lib/takelage/docker/image/tag/list/remote.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# takelage docker image tag list remote
+module DockerImageTagListRemote
+  # Backend method for docker image tag list remote.
+  # @return [Array] remote docker image tags
+  def docker_image_tag_list_remote
+    log.debug 'Getting docker remote tags ' \
+      "of \"#{@docker_user}/#{@docker_repo}\" " \
+      "from \"#{@docker_registry}\""
+    _docker_image_tag_list_remote_tags
+  end
+
+  private
+
+  # Get docker remote tags.
+  def _docker_image_tag_list_remote_tags
+    user = File.basename @docker_user
+    begin
+      registry = DockerRegistry2.connect(@docker_registry)
+      tags = registry.tags("#{user}/#{@docker_repo}")
+      VersionSorter.sort(tags['tags'])
+    rescue RestClient::Exceptions::OpenTimeout
+      log.error "Timeout while connecting to \"#{@docker_registry}\""
+      false
+    end
+  end
+end

data/lib/takelage/docker/image/update.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+# takelage docker image uppdate
+module DockerImageUpdate
+  # Backend method for docker image update.
+  def docker_image_update
+    return false unless docker_check_running
+
+    tags_remote = docker_image_tag_list_remote
+
+    tag = 'latest'
+    tag = docker_image_tag_latest_remote unless tags_remote.include?('latest')
+
+    cmd_docker_pull_latest = _docker_image_update_cmd_docker_pull_latest tag
+
+    cmd_docker_remove_dangling =
+      config.active['cmd_docker_image_update_docker_remove_dangling']
+
+    run_and_exit "#{cmd_docker_pull_latest} && #{cmd_docker_remove_dangling}"
+  end
+
+  private
+
+  # Prepare dpcker pull latest command.
+  def _docker_image_update_cmd_docker_pull_latest(tag)
+    format(
+      config.active['cmd_docker_image_update_docker_pull_latest'],
+      docker_user: @docker_user,
+      docker_repo: @docker_repo,
+      tag_latest_remote: tag
+    )
+  end
+end

data/lib/takelage/docker/socket/cli.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Takelage
+  # takelage docker socket
+  class DockerSocket < SubCommandBase
+    include LoggingModule
+    include SystemModule
+    include ConfigModule
+    include DockerCheckRunning
+    include DockerSocketLib
+    include DockerSocketHost
+    include DockerSocketScheme
+    include DockerSocketStart
+    include DockerSocketStop
+
+    # Initialize docker socket
+    def initialize(args = [], local_options = {}, configuration = {})
+      # initialize thor parent class
+      super args, local_options, configuration
+
+      @socket_host = docker_socket_host
+      @sockets = docker_socket_scheme
+    end
+
+    #
+    # docker socket host
+    #
+    desc 'host', 'Print docker socket host ip address'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    Print docker socket host ip address
+    LONGDESC
+    # Print docker socket host ip address.
+    def host
+      say @socket_host
+      true
+    end
+
+    #
+    # docker socket scheme
+    #
+    desc 'scheme', 'Print docker socket scheme'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    Print docker socket scheme
+    LONGDESC
+    # Print docker socket scheme.
+    def scheme
+      say hash_to_yaml(@sockets)
+      true
+    end
+
+    #
+    # docker socket start
+    #
+    desc 'start', 'Start sockets for docker container'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    Start sockets for docker container
+    LONGDESC
+    # Start sockets for docker container.
+    def start
+      exit docker_socket_start
+    end
+
+    #
+    # docker socket stop
+    #
+    desc 'stop', 'Stop sockets for docker container'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    Stop sockets for docker container
+    LONGDESC
+    # Stop sockets for docker container.
+    def stop
+      exit docker_socket_stop
+    end
+  end
+end

data/lib/takelage/docker/socket/host.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+# takelage docker socket host
+module DockerSocketHost
+  # Backend method for docker socket host.
+  def docker_socket_host
+    log.debug 'Getting docker socket host ip address'
+
+    socket_host = '127.0.0.1'
+
+    addr_infos = Socket.getifaddrs
+
+    # if interface docker0 exists (== linux host)
+    # then return the ip address
+    addr_infos.each do |addr_info|
+      if addr_info.name == 'docker0'
+        socket_host = addr_info.addr.ip_address if addr_info.addr.ipv4?
+      end
+    end
+
+    log.debug "Docker socket host ip address is \"#{socket_host}\""
+
+    socket_host
+  end
+end

data/lib/takelage/docker/socket/lib.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+# takelage docker socket lib
+module DockerSocketLib
+  private
+
+  # Get socket start commands.
+  # sockets_up is a boolean which defines if the sockets need to be up
+  # to be included in the resulting array of socket start commands
+  def _docker_socket_lib_get_socket_start_commands(mode)
+    cmds_start_socket = []
+
+    # loop over sockets
+    @sockets.each do |socket, socket_config|
+      host = socket_config['host']
+      port = socket_config['port']
+      path = socket_config['path']
+
+      cmd = _docker_socket_lib_get_start_cmd(mode, socket, host, port, path)
+      cmds_start_socket.push cmd if cmd
+    end
+
+    cmds_start_socket
+  end
+
+  # Get socket start command
+  def _docker_socket_lib_get_start_cmd(mode, socket, host, port, path)
+    if mode == 'start'
+      unless _docker_socket_lib_socket_up? socket, host, port, path
+        return _docker_socket_lib_start_cmd(host, port, path)
+      end
+    elsif _docker_socket_lib_socket_up? socket, host, port, path
+      return _docker_socket_lib_start_cmd(host, port, path)
+    end
+    nil
+  end
+
+  # Get socket start command.
+  def _docker_socket_lib_start_cmd(host, port, path)
+    format(
+      config.active['cmd_docker_socket_get_start'],
+      host: host,
+      port: port,
+      path: path
+    )
+  end
+
+  # Check if a socket is available by trying to connect to it via TCP
+  def _docker_socket_lib_socket_up?(socket, host, port, path)
+    error_message = _docker_socket_lib_error_msg socket, host, port, path
+    begin
+      Timeout.timeout(1) do
+        _docker_socket_lib_socket_reachable? socket, host, port, error_message
+      end
+    rescue Timeout::Error
+      log.debug "Timeout: #{error_message}"
+      false
+    end
+  end
+
+  # Create error message.
+  def _docker_socket_lib_error_msg(socket, host, port, path)
+    'failed to connect to ' \
+        "socket \"#{socket}\" " \
+        "using host \"#{host}\", " \
+        "port \"#{port}\", " \
+        "path \"#{path}\""
+  end
+
+  # Test socket.
+  # rubocop:disable Metrics/MethodLength
+  def _docker_socket_lib_socket_reachable?(socket, host, port, error_message)
+    begin
+      s = TCPSocket.new host, port
+      s.close
+      log.debug "Socket \"#{socket}\" up"
+      return true
+    rescue Errno::ECONNREFUSED
+      log.debug "Connection refused: #{error_message}"
+    rescue Errno::EHOSTUNREACH
+      log.debug "Host unreachable: #{error_message}"
+    rescue SocketError
+      log.debug "Socket error: #{error_message}"
+    end
+    false
+  end
+  # rubocop:enable Metrics/MethodLength
+end

data/lib/takelage/docker/socket/scheme.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+# takelage docker socket scheme
+module DockerSocketScheme
+  # Backend method for docker socket scheme.
+  def docker_socket_scheme
+    log.debug 'Getting docker socket scheme'
+
+    socket_scheme = _socket_get_scheme _socket_get_config
+
+    log.debug "Docker socket scheme is \n\"\"\"\n#{hash_to_yaml socket_scheme}\"\"\""
+
+    socket_scheme
+  end
+
+  private
+
+  # Get docker socket config.
+  def _socket_get_config
+    socket_config = {
+      'docker_path' => _socket_get_docker_daemon_path,
+      'docker_port' => config.active['docker_socket_docker_daemon_port'],
+      'gpg_path' => _socket_get_agent_socket_path,
+      'gpg_port' => config.active['docker_socket_gpg_agent_port'],
+      'ssh_path' => _socket_get_agent_ssh_socket_path,
+      'ssh_port' => config.active['docker_socket_gpg_ssh_agent_port']
+    }
+
+    socket_config
+  end
+
+  # Get docker socket path.
+  def _socket_get_docker_daemon_path
+    '/var/run/docker.sock'
+  end
+
+  # Get gpg agent socket path.
+  def _socket_get_agent_socket_path
+    cmd_agent_socket_path =
+      config.active['cmd_docker_socket_config_agent_socket_path']
+    (run cmd_agent_socket_path).chomp
+  end
+
+  # Get gpg ssh agent socket path.
+  def _socket_get_agent_ssh_socket_path
+    cmd_agent_ssh_socket_path =
+      config.active['cmd_docker_socket_config_agent_ssh_socket_path']
+    (run cmd_agent_ssh_socket_path).chomp
+  end
+
+  # Create socket scheme.
+  def _socket_get_scheme(socket_config)
+    { 'docker-daemon' => { 'path' => socket_config['docker_path'],
+                           'host' => @socket_host,
+                           'port' => socket_config['docker_port'] },
+      'gpg-agent' => { 'path' => socket_config['gpg_path'],
+                       'host' => @socket_host,
+                       'port' => socket_config['gpg_port'] },
+      'gpg-ssh-agent' => { 'path' => socket_config['ssh_path'],
+                           'host' => @socket_host,
+                           'port' => socket_config['ssh_port'] } }
+  end
+end

data/lib/takelage/docker/socket/start.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# takelage docker socket start
+module DockerSocketStart
+  # Backend method for docker socket start.
+  def docker_socket_start
+    log.debug 'Starting sockets for docker container'
+
+    return false unless docker_check_running
+
+    cmds_start_socket = _docker_socket_lib_get_socket_start_commands 'start'
+
+    return true if cmds_start_socket.empty?
+
+    _docker_socket_start_get_sudo
+
+    cmds_start_socket.each do |cmd_start_socket|
+      run_and_fork cmd_start_socket
+    end
+
+    true
+  end
+
+  private
+
+  # Get sudo.
+  def _docker_socket_start_get_sudo
+    log.debug 'Request sudo so that ' \
+      'subsequent background tasks run without delay'
+    cmd_sudo_true =
+      config.active['cmd_docker_socket_start_sudo_true']
+    run cmd_sudo_true
+  end
+end

data/lib/takelage/docker/socket/stop.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+# takelage docker socket stop
+module DockerSocketStop
+  # Backend method for docker socket stop.
+  def docker_socket_stop
+    log.debug 'Stopping sockets for docker container'
+
+    return false unless docker_check_running
+
+    # get process list
+    # assuming format: "pid command"
+    cmd_ps =
+      config.active['cmd_docker_socket_stop_docker_socket_ps']
+
+    stdout_str = run cmd_ps
+
+    cmds_start_socket = _docker_socket_lib_get_socket_start_commands 'stop'
+
+    # loop over process list
+    stdout_str.split(/\n+/).each do |process|
+      _docker_socket_stop_kill_process process, cmds_start_socket
+    end
+
+    true
+  end
+
+  private
+
+  # Stop process.
+  def _docker_socket_stop_kill_process(process, cmds_start_socket)
+    # split processes in process id and process command
+    pid_command = process.strip.split(/ /, 2)
+    pid = pid_command[0]
+    command = pid_command[1]
+
+    # loop over socket start commands
+    cmds_start_socket.each do |cmd_start_socket|
+      next unless command == cmd_start_socket
+
+      _docker_socket_stop_kill_pid pid
+    end
+  end
+
+  # Kill process.
+  def _docker_socket_stop_kill_pid(pid)
+    log.debug "Killing PID #{pid}"
+    cmd_kill =
+      format(
+        config.active['cmd_docker_socket_stop_docker_socket_kill'],
+        pid: pid
+      )
+    run cmd_kill
+  end
+end