takelage 0.13.3 → 0.14.0

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

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# takelage docker image tag check remote
+module DockerImageTagCheckRemote
+  # Backend method for docker image check tag remote.
+  # @return [Boolean] does remote docker image tag exist?
+  def docker_image_tag_check_remote(tag)
+    log.debug "Check if remote image tag \"#{tag}\" exists"
+
+    return false unless docker_check_running
+
+    if tag.to_s.strip.empty?
+      log.warn 'No remote docker image tag specified'
+      return false
+    end
+
+    image = "#{@docker_user}/#{@docker_repo}:#{tag}"
+
+    return false unless _docker_iamge_check_remote_image? image, tag
+
+    log.debug "Found remote docker image \"#{image}\""
+    true
+  end
+
+  private
+
+  # Check if remote image exists.
+  def _docker_iamge_check_remote_image?(image, tag)
+    tags = docker_image_tag_list_remote
+
+    unless tags != false && tags.include?(tag)
+      log.debug "No remote docker image \"#{image}\" found"
+      return false
+    end
+
+    true
+  end
+end

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

@@ -6,9 +6,11 @@ module Takelage
     include LoggingModule
     include SystemModule
     include ConfigModule
-    include DockerCheckModule
-    include DockerImageTagListModule
-    include DockerImageTagLatestModule
+    include DockerCheckRunning
+    include DockerImageTagListLocal
+    include DockerImageTagListRemote
+    include DockerImageTagLatestLocal
+    include DockerImageTagLatestRemote
 
     # Initialize takelage docker image tag latest
     def initialize(args = [], local_options = {}, configuration = {})

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+# takelage docker image tag latest local
+module DockerImageTagLatestLocal
+  # Backend method for docker image tag latest local.
+  # @return [String] latest local docker image tag
+  def docker_image_tag_latest_local
+    log.debug 'Getting latest local docker image tag'
+
+    return false unless docker_check_running
+
+    tags = docker_image_tag_list_local
+
+    tag_latest_local = tags[-1]
+
+    log.debug "Latest docker local tag: #{tag_latest_local}"
+
+    tag_latest_local
+  end
+end

data/lib/takelage/docker/image/tag/latest/{module.rb → remote.rb}

@@ -1,23 +1,7 @@
 # frozen_string_literal: true
 
-# takelage docker image tag latest module
-module DockerImageTagLatestModule
-  # Backend method for docker image tag latest local.
-  # @return [String] latest local docker image tag
-  def docker_image_tag_latest_local
-    log.debug 'Getting latest local docker image tag'
-
-    return false unless docker_check_running
-
-    tags = docker_image_tag_list_local
-
-    tag_latest_local = tags[-1]
-
-    log.debug "Latest docker local tag: #{tag_latest_local}"
-
-    tag_latest_local
-  end
-
+# takelage docker image tag latest remote
+module DockerImageTagLatestRemote
   # Backend method for docker image tag latest remote.
   # @return [String] latest remote docker image tag
   def docker_image_tag_latest_remote

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

@@ -6,8 +6,9 @@ module Takelage
     include LoggingModule
     include SystemModule
     include ConfigModule
-    include DockerCheckModule
-    include DockerImageTagListModule
+    include DockerCheckRunning
+    include DockerImageTagListLocal
+    include DockerImageTagListRemote
 
     # Initialize takelage docker image tag list
     def initialize(args = [], local_options = {}, configuration = {})

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/{module.rb → remote.rb}

@@ -1,22 +1,7 @@
 # frozen_string_literal: true
 
-# takelage docker image tag list module
-module DockerImageTagListModule
-  # 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
-
+# 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

data/lib/takelage/docker/image/{module.rb → update.rb}

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-# takelage docker image module
-module DockerImageModule
+# takelage docker image uppdate
+module DockerImageUpdate
   # Backend method for docker image update.
   def docker_image_update
     return false unless docker_check_running

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

@@ -6,8 +6,12 @@ module Takelage
     include LoggingModule
     include SystemModule
     include ConfigModule
-    include DockerCheckModule
-    include DockerSocketModule
+    include DockerCheckRunning
+    include DockerSocketLib
+    include DockerSocketHost
+    include DockerSocketScheme
+    include DockerSocketStart
+    include DockerSocketStop
 
     # Initialize docker socket
     def initialize(args = [], local_options = {}, configuration = {})

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,46 @@
+# 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'
+
+    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_scheme = _socket_get_scheme gpg_path, gpg_port, ssh_path, ssh_port
+    log.debug 'Docker socket scheme is ' \
+      "\n\"\"\"\n#{hash_to_yaml socket_scheme}\"\"\""
+
+    socket_scheme
+  end
+
+  private
+
+  # 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(gpg_path, gpg_port, ssh_path, ssh_port)
+    { 'agent-socket' => { 'path' => gpg_path,
+                          'host' => @socket_host,
+                          'port' => gpg_port },
+      'agent-ssh-socket' => { 'path' => ssh_path,
+                              'host' => @socket_host,
+                              'port' => 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