takeltau 0.34.9

data/lib/takeltau/bit/scope/list.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+# takeltau bit scope list
+module BitScopeList
+  # Backend method for bit scope list.
+  # @return [String] list of bit scopes
+  def bit_scope_list
+    log.debug 'Listing bit remote scopes'
+
+    return false unless configured? %w[bit_ssh bit_remote]
+
+    # get ssh command from active config.
+    cmd_bit_ssh =
+      config.active['bit_ssh']
+
+    root = config.active['bit_root']
+
+    cmd_bit_scope_list = _bit_scope_list_cmd root
+
+    # run ssh command with scope list command.
+    scope_list = run "#{cmd_bit_ssh} '#{cmd_bit_scope_list}'"
+
+    # remove bit remote root directory from results
+    scope_list.gsub!(%r{#{root}/*}, '')
+
+    # remove /scope.json from results
+    scope_list.gsub!(%r{/scope.json}, '')
+
+    scope_list
+  end
+
+  private
+
+  # Prepare bit scope list command.
+  def _bit_scope_list_cmd(root)
+    format(
+      config.active['cmd_bit_scope_list_find_scopes'],
+      root: root
+    )
+  end
+end

data/lib/takeltau/bit/scope/new.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+# takeltau bit scope new
+module BitScopeNew
+  # Backend method for bit scope new.
+  # @return [Int] status of new command
+  def bit_scope_new(scope)
+    log.debug "Creating new bit remote scope \"#{scope}\""
+
+    return false unless configured? %w[bit_ssh bit_remote]
+
+    return false if _bit_scope_new_scope_exists? scope
+
+    cmd_bit_ssh = config.active['bit_ssh']
+
+    cmd_bit_scope_new = _bit_scope_new_cmd scope
+
+    run "#{cmd_bit_ssh} '#{cmd_bit_scope_new}'"
+
+    log.info "Created new bit remote scope \"#{scope}\""
+  end
+
+  private
+
+  # Check if bit scope already exists.
+  def _bit_scope_new_scope_exists?(scope)
+    scope_list = bit_scope_list
+    return false unless scope_list.include? scope
+
+    log.error "The remote bit scope \"#{scope}\" already exists"
+    false
+  end
+
+  # Prepare bit scope new command.
+  def _bit_scope_new_cmd(scope)
+    root = config.active['bit_root']
+
+    format(
+      config.active['cmd_bit_scope_new_bit_init'],
+      scope: scope,
+      root: root
+    )
+  end
+end

data/lib/takeltau/bit/scope/ssh.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# takeltau bit scope ssh
+module BitScopeSSH
+  # Backend method for bit scope ssh.
+  def bit_scope_ssh
+    log.debug 'Logging in to bit remote server'
+
+    return false unless configured? %w[bit_ssh]
+
+    run_and_exit config.active['bit_ssh']
+  end
+end

data/lib/takeltau/completion/cli.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Takeltau
+  # takeltau completion
+  class Completion < SubCommandBase
+    include LoggingModule
+
+    desc 'bash', 'Print bash completion code'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    Print bash completion code
+    This command will print bash code which can be parsed to enable auto-completion for the takelage cli.
+    Add this to your bash startup files:
+
+    source <(tau completion bash)
+    LONGDESC
+    # Print bash completion code.
+    def bash
+      completion_bash = Takeltau::CLI.new.bash_fylla
+      exit false if completion_bash == false
+      say completion_bash
+      true
+    end
+  end
+end

data/lib/takeltau/default.yml

@@ -0,0 +1,95 @@
+---
+bit_dev_user: 'takelage'
+bit_remote: ''
+bit_require_file: 'bitrequire.yml'
+bit_root: '/bit'
+bit_ssh: ''
+cmd_bit: 'bit'
+cmd_bit_check_workspace_bit_list: 'bit status'
+cmd_bit_check_workspace_pwd: 'pwd'
+cmd_bit_clipboard_lib_bit_status: 'bit status'
+cmd_bit_clipboard_copy_bit_list_scope: 'bit list --skip-update --json %{scope}'
+cmd_bit_clipboard_copy_bit_list_remotes: 'bit remote --skip-update'
+cmd_bit_clipboard_copy_bit_add_dir: 'bit add --skip-update --id %{id} --main %{dir}/README.bit %{dir}'
+cmd_bit_clipboard_copy_bit_tag_id: 'bit tag --skip-update --skip-tests %{id}'
+cmd_bit_clipboard_copy_bit_export_to_scope: 'bit export --skip-update %{scope}'
+cmd_bit_clipboard_git_add: 'git add %{file}'
+cmd_bit_clipboard_git_commit: 'git commit --message="%{message}"'
+cmd_bit_clipboard_git_pull: 'git pull origin %{main}'
+cmd_bit_clipboard_git_push: 'git push origin %{main}'
+cmd_bit_clipboard_paste_bit_list_scope: 'bit list --skip-update --json %{scope}'
+cmd_bit_clipboard_paste_bit_import_cid: 'bit import --ignore-package-json --ignore-dist --skip-update --path %{dir} %{cid}'
+cmd_bit_clipboard_pull_bit_import_all: 'bit import --ignore-package-json --ignore-dist --skip-update'
+cmd_bit_clipboard_pull_bit_checkout_all: 'bit checkout --ignore-package-json --ignore-dist --skip-update --skip-npm-install --all latest'
+cmd_bit_clipboard_push_bit_tag_all: 'bit tag --skip-update --skip-tests --all'
+cmd_bit_clipboard_push_bit_export_all: 'bit export --skip-update --all'
+cmd_bit_clipboard_export_bit_list: 'bit list --skip-update --json %{scope}'
+cmd_bit_require_lib_bit_list: 'bit list --skip-update --json'
+cmd_bit_require_lib_bit_list_ids: 'bit list --skip-update --json --ids'
+cmd_bit_scope_add_scope: 'bit remote add %{remote}/%{scope}'
+cmd_bit_scope_list_find_scopes: 'find -L %{root} -name scope.json'
+cmd_bit_scope_new_bit_init: 'mkdir -p %{root}/%{scope} && cd %{root}/%{scope} && bit init --bare'
+cmd_bit_scope_remove_scope: 'rm --force --recursive %{root}/%{scope}'
+cmd_docker: 'docker'
+cmd_docker_check_daemon_docker_info: 'docker info'
+cmd_docker_container_check_existing_docker_ps: 'docker ps --filter name=^%{container}$ --quiet'
+cmd_docker_container_check_network_docker_network: 'docker network ls --quiet --filter name=^%{network}$'
+cmd_docker_container_check_orphaned_docker_exec: 'docker exec --interactive %{container} ps a'
+cmd_docker_container_create: 'docker run --detach --env TAKELAGE_PROJECT_BASE_DIR=%{workdir} --env TZ=%{timezone} --hostname %{container} --name %{container} --network %{container} --rm --shm-size %{shmsize} --tty --volume %{dockersock}:/var/run/docker.sock --volume %{homedir}:/hostdir --volume %{workdir}:/project %{volume_dev} --workdir /project %{docker_run_options} %{image} %{entrypoint} --gid %{gid} --home %{homedir} --uid %{uid} --username %{username} --extra=%{extra} %{entrypoint_options}'
+cmd_docker_container_create_network: 'docker network create %{network}'
+cmd_docker_container_enter_container: 'docker exec --interactive --tty %{container} %{loginpoint} --username %{username}'
+cmd_docker_container_get_container_name: 'docker ps --filter id=%{container} --format "{{.Names}}"'
+cmd_docker_container_get_containers: 'docker ps --all --filter name=^%{docker_repo}_ --quiet'
+cmd_docker_container_remove_network: 'docker network rm %{network}'
+cmd_docker_container_docker_exec: 'docker exec %{container} su %{username} -c "LANG=en_US.UTF-8 %{command}"'
+cmd_docker_container_stop_container: 'docker stop %{container}'
+cmd_docker_image_tag_check_docker_images: 'docker images --quiet %{image}'
+cmd_docker_image_tag_list_docker_images: 'docker images %{docker_user}\/%{docker_repo} --format "{{.Tag}}"'
+cmd_docker_image_update_docker_pull_latest: 'docker pull %{docker_user}/%{docker_repo}:latest'
+cmd_docker_image_update_docker_remove_dangling: 'docker image prune --force'
+cmd_git: 'git'
+cmd_git_check_clean_git_unstaged: 'git diff --exit-code'
+cmd_git_check_clean_git_uncommitted: 'git diff --cached --exit-code'
+cmd_git_check_clean_git_status: 'git status --porcelain'
+cmd_git_check_bit_get_git_branch: 'git symbolic-ref HEAD'
+cmd_git_check_workspace_git_repo: 'git -C %{dir} rev-parse'
+cmd_git_check_workspace_pwd: 'pwd'
+cmd_info_status_lib_git_name: 'git -C %{root} config user.name'
+cmd_info_status_lib_git_email: 'git -C %{root} config user.email'
+cmd_info_status_lib_git_signingkey: 'git -C %{root} config user.signingKey'
+cmd_info_status_lib_git_key_available: 'gpg --list-key %{key}'
+cmd_info_status_gopass_root_store: 'gopass config | grep "path" | cut -d " " -f 2'
+cmd_info_status_gpg_agent: 'gpg-connect-agent /bye'
+cmd_info_status_gpg_keys: 'gpg --list-keys'
+cmd_info_status_ssh_keys: 'ssh-add -l'
+cmd_info_status_ssh_socket: 'gpgconf --list-dirs agent-ssh-socket'
+cmd_init_lib_bit_init: 'bit init'
+cmd_init_lib_git_init: 'git init && git checkout -b main'
+cmd_init_lib_git_add_all: 'git add --all'
+cmd_init_lib_git_commit_initial: 'git commit -m "Initial commit"'
+cmd_mutagen: 'mutagen'
+cmd_mutagen_check_daemon_host_connection: 'mutagen forward list --label-selector="%{hostlabel}"'
+cmd_mutagen_check_daemon_version: 'mutagen version'
+cmd_mutagen_forward_socket_create: 'mutagen forward create --name=%{socketname} --label=%{hostlabel} --label=%{takellabel} docker://%{username}@%{container}:unix:%{containersock} unix:%{hostsock}'
+cmd_mutagen_forward_socket_check: 'mutagen forward list %{socketname}'
+cmd_mutagen_forward_socket_terminate: 'mutagen forward terminate %{socketname}'
+cmd_mutagen_forward_socket_remove: 'rm -f ~/.mutagen/daemon/*'
+cmd_mutagen_forward_socket_list: 'mutagen forward list --label-selector="%{takellabel}"'
+docker_debug: 'ansible/roles/takel-takelage/files/takelscripts'
+docker_entrypoint_extra: '.config/gcloud'
+docker_entrypoint_options: ''
+docker_registry: 'https://registry.hub.docker.com'
+docker_repo: 'takelage'
+docker_run_options: '--env GOOGLE_APPLICATION_CREDENTIALS=/hostdir/.google/default.json'
+docker_shm_size: '512M'
+docker_tag: 'latest'
+docker_user: 'takelwerk'
+git_bit_branch: 'main'
+info_project_main: 'project.yml'
+info_project_private: 'private/project.yml'
+init_bit_require_import: 'true'
+login_wait_for_sockets: '0'
+mutagen_socket_path_mutagen: '~/.mutagen/daemon/daemon.sock'
+mutagen_socket_path_gpg: '~/.gnupg/S.gpg-agent'
+mutagen_socket_path_ssh: '~/.gnupg/S.gpg-agent.ssh'
+mutagen_socket_takelage_label: 'type=takelage'

data/lib/takeltau/docker/check/cli.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Takeltau
+  # takeltau docker check
+  class DockerCheck < SubCommandBase
+    include LoggingModule
+    include SystemModule
+    include ConfigModule
+    include DockerCheckDaemon
+
+    #
+    # docker check daemon
+    #
+    desc 'daemon', 'Check if docker daemon is running'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    Check if docker daemon is running
+    LONGDESC
+    # Check if docker daemon is running.
+    def daemon
+      exit docker_check_daemon
+    end
+  end
+end

data/lib/takeltau/docker/check/daemon.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# takeltau docker check daemon
+module DockerCheckDaemon
+  # Backend method for docker check daemon.
+  # @return [Boolean] is the docker daemon running?
+  # rubocop:disable Metrics/MethodLength
+  def docker_check_daemon
+    return true if @docker_daemon_running
+
+    return false unless command_available_else_error? config.active['cmd_docker']
+
+    log.debug 'Check if the docker daemon is running'
+
+    status = try config.active['cmd_docker_check_daemon_docker_info']
+
+    unless status.exitstatus.zero?
+      log.error 'The docker daemon is not running'
+      return false
+    end
+
+    log.debug 'The docker daemon is running'
+    @docker_daemon_running = true
+    true
+  end
+  # rubocop:enable Metrics/MethodLength
+end

data/lib/takeltau/docker/cli.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Takeltau
+  # takeltau docker
+  class Docker < SubCommandBase
+    desc 'check [COMMAND]', 'Check docker'
+    subcommand 'check', DockerCheck
+
+    desc 'container [COMMAND]', 'Handle docker container'
+    subcommand 'container', DockerContainer
+
+    desc 'image [COMMAND]', 'Handle docker images'
+    subcommand 'image', DockerImage
+  end
+end

data/lib/takeltau/docker/container/check/cli.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module Takeltau
+  # takeltau docker container check
+  class DockerContainerCheck < SubCommandBase
+    include LoggingModule
+    include SystemModule
+    include ConfigModule
+    include DockerCheckDaemon
+    include DockerContainerCheckExisting
+    include DockerContainerCheckNetwork
+    include DockerContainerCheckOrphaned
+
+    #
+    # docker container check existing
+    #
+    desc 'existing [CONTAINER]', 'Check if docker [CONTAINER] is existing'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    Check if docker container is existing
+    This check looks for a container with a given name.
+    If such a container is existing the result is true else false.
+    LONGDESC
+    # Check if docker container is existing.
+    def existing(container)
+      exit docker_container_check_existing container
+    end
+
+    #
+    # docker container check network
+    #
+    desc 'network [NETWORK]', 'Check if docker [NETWORK] is existing'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    Check if docker network is existing
+    This check looks for a network with a given name.
+    If such a network is existing the result is true else false.
+    LONGDESC
+    # Check if docker network is existing.
+    def network(network)
+      exit docker_container_check_network network
+    end
+
+    #
+    # docker container check orphaned
+    #
+    desc 'orphaned [CONTAINER]', 'Check if docker [CONTAINER] is orphaned'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    Check if docker container is orphaned
+    This check looks for a process which is started
+    when you log in to an takelage docker container.
+    If such a process is found the result is true else false.
+    LONGDESC
+    # Check if docker container is orphaned.
+    def orphaned(container)
+      exit docker_container_check_orphaned container
+    end
+  end
+end

data/lib/takeltau/docker/container/check/existing.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# takeltau docker container check existing
+module DockerContainerCheckExisting
+  # Backend method for docker container check existing.
+  # @return [Boolean] is container existing?
+  def docker_container_check_existing(container)
+    log.debug "Checking if container \"#{container}\" is existing"
+
+    return false unless docker_check_daemon
+
+    stdout_str = run _docker_container_cmd_check_existing container
+
+    if stdout_str.to_s.chomp.empty?
+      log.debug "Container \"#{container}\" is not existing"
+      return false
+    end
+
+    log.debug "Container \"#{container}\" is existing"
+    true
+  end
+
+  private
+
+  # Format command to check if docker container exists.
+  def _docker_container_cmd_check_existing(container)
+    format(
+      config.active['cmd_docker_container_check_existing_docker_ps'],
+      container: container
+    )
+  end
+end

data/lib/takeltau/docker/container/check/network.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# takeltau docker container check network
+module DockerContainerCheckNetwork
+  # Backend method for docker container check network.
+  # @return [Boolean] is network existing?
+  def docker_container_check_network(network)
+    log.debug "Checking if network \"#{network}\" is existing"
+
+    return false unless docker_check_daemon
+
+    stdout_str = run _docker_container_cmd_check_network network
+
+    if stdout_str.to_s.chomp.empty?
+      log.debug "Network \"#{network}\" is not existing"
+      return false
+    end
+
+    log.debug "Network \"#{network}\" is existing"
+    true
+  end
+
+  private
+
+  # Prepare command to check if docker network exists.
+  def _docker_container_cmd_check_network(network)
+    format(
+      config.active['cmd_docker_container_check_network_docker_network'],
+      network: network
+    )
+  end
+end

data/lib/takeltau/docker/container/check/orphaned.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+# takeltau docker container check orphaned
+module DockerContainerCheckOrphaned
+  # Backend method for docker container check orphaned.
+  # @return [Boolean] is container orphaned?
+  def docker_container_check_orphaned(container)
+    log.debug "Check if container \"#{container}\" is orphaned"
+
+    return false unless docker_check_daemon
+
+    stdout_str = run _docker_container_cmd_check_orphaned container
+
+    if stdout_str.include? '/loginpoint.py'
+      log.debug "Container \"#{container}\" isn't orphaned"
+      return false
+    end
+
+    log.debug "Container \"#{container}\" is orphaned"
+    true
+  end
+
+  private
+
+  # Format command to check if docker container is orphaned.
+  def _docker_container_cmd_check_orphaned(container)
+    format(
+      config.active['cmd_docker_container_check_orphaned_docker_exec'],
+      container: container
+    )
+  end
+end