takelage 0.13.3 → 0.14.0

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

@@ -1,227 +0,0 @@
-# frozen_string_literal: true
-
-# takelage docker socket module
-module DockerSocketModule
-  # 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
-
-  # 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
-
-  # 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 = _get_socket_start_commands 'start'
-
-    return true if cmds_start_socket.empty?
-
-    _socket_get_sudo
-
-    cmds_start_socket.each do |cmd_start_socket|
-      run_and_fork cmd_start_socket
-    end
-
-    true
-  end
-
-  # 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 = _get_socket_start_commands 'stop'
-
-    # loop over process list
-    stdout_str.split(/\n+/).each do |process|
-      _socket_stop_process process, cmds_start_socket
-    end
-
-    true
-  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
-
-  # 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 _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 = _get_socket_start_command mode, socket, host, port, path
-      cmds_start_socket.push cmd if cmd
-    end
-
-    cmds_start_socket
-  end
-
-  # Get socket start command
-  def _get_socket_start_command(mode, socket, host, port, path)
-    if mode == 'start'
-      unless _socket_up? socket, host, port, path
-        return _socket_get_cmd_start_socket(host, port, path)
-      end
-    elsif _socket_up? socket, host, port, path
-      return _socket_get_cmd_start_socket(host, port, path)
-    end
-    nil
-  end
-
-  # Get socket start command.
-  def _socket_get_cmd_start_socket(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 _socket_up?(socket, host, port, path)
-    error_message = _socket_get_error_message socket, host, port, path
-    begin
-      Timeout.timeout(1) do
-        _socket_reachable? socket, host, port, error_message
-      end
-    rescue Timeout::Error
-      log.debug "Timeout: #{error_message}"
-      false
-    end
-  end
-
-  # Create error message.
-  def _socket_get_error_message(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 _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
-
-  # Kill process.
-  def _socket_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
-
-  # Get sudo.
-  def _socket_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
-
-  # Stop process.
-  def _socket_stop_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
-
-      _socket_kill_pid pid
-    end
-  end
-end

data/lib/takelage/git/check/module.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-# takelage git check module
-module GitCheckModule
-  # Backend method for git check clean.
-  # @return [Boolean] is git workspace clean?
-  def git_check_clean
-    log.debug 'Checking if git workspace is clean'
-
-    return false unless git_check_workspace
-
-    status_unstaged = _git_get_status_unstaged
-    status_uncommitted = _git_get_status_uncommitted
-    stdout_str_status = _git_get_str_status
-
-    # only return true if neither unstaged nor uncommitted nor empty files
-    sum = status_unstaged.exitstatus +
-          status_uncommitted.exitstatus +
-          stdout_str_status.length
-
-    sum.zero?
-  end
-
-  # Backend method for git check master.
-  # @return [Boolean] are we on the git master branch?
-  def git_check_master
-    log.debug 'Check if we are on the git master branch'
-
-    return false unless git_check_workspace
-
-    branch = _git_get_branch
-    log.debug "We are on git branch \"#{branch}\""
-
-    branch == 'master'
-  end
-
-  # Backend method for git check workspace.
-  # @return [Boolean] is this a git workspace?
-  def git_check_workspace
-    log.debug 'Check if this is a git workspace'
-    status_repo = _git_get_status_repo
-    dir = _git_get_dir
-    unless status_repo.exitstatus.zero?
-      log.debug "No git workspace found in \"#{dir}\""
-      return false
-    end
-    true
-  end
-
-  private
-
-  # Get git status of unstaged changes.
-  def _git_get_status_unstaged
-    cmd_git_unstaged =
-      config.active['cmd_git_check_clean_git_unstaged']
-    try cmd_git_unstaged
-  end
-
-  # Get git status of uncommitted changes.
-  def _git_get_status_uncommitted
-    cmd_git_uncommitted =
-      config.active['cmd_git_check_clean_git_uncommitted']
-    try cmd_git_uncommitted
-  end
-
-  # Get git status result.
-  def _git_get_str_status
-    cmd_git_status =
-      config.active['cmd_git_check_clean_git_status']
-    run cmd_git_status
-  end
-
-  # Get git branch.
-  def _git_get_branch
-    cmd_get_branch =
-      config.active['cmd_git_check_master_git_branch']
-    (run cmd_get_branch).strip.split('/')[-1]
-  end
-
-  # Get git repository status.
-  def _git_get_status_repo
-    cmd_git_repo =
-      config.active['cmd_git_check_workspace_git_repo']
-    try cmd_git_repo
-  end
-
-  # Get current working directory.
-  def _git_get_dir
-    cmd_pwd =
-      config.active['cmd_git_check_workspace_pwd']
-    (run cmd_pwd).strip
-  end
-end