takelage 0.1.0

data/README.md

@@ -0,0 +1,159 @@
+# takelage-cli
+
+*takelage-cli* is a command line interface 
+to facilitate the takelage devops workflow.
+The takelage devops workflow helps devops engineers
+build, test and deploy os images.
+
+The *takelage-cli* executable *tau* is a 
+[ruby](https://www.ruby-lang.org/) 
+command line script using the 
+[thor](http://whatisthor.com/) toolkit.
+
+## Ecosystem
+
+The takelage devops framework consists of these projects:
+
+| App | Description |
+| --- | ----------- |
+| *[takelage-cli](https://github.com/geospin-takelage/takelage-cli)* | The takelage command line interface |
+| *[takelage-dev](https://github.com/geospin-takelage/takelage-dev)* | The takelage development environment |
+| **[takelage-bit](https://github.com/geospin-takelage/takelage-bit)** | The takelage [bit](https://github.com/teambit/bit) server | 
+
+## Installation
+
+*tau* is part of *takelage-dev*'s docker image 
+but you typically want to install it on the host system as well.
+Install the takelage gem and its dependencies 
+through the [gem](https://github.com/rubygems/rubygems)
+command line tool:
+
+```bash
+gem install takelage thor fylla logger
+```
+
+## Commands
+
+*takelage-cli* uses [cucumber](https://github.com/cucumber/cucumber)
+to system test its features.
+You are encouraged to read the cucumber feature files
+for the *tau* commands
+to get an idea of how the commands work.
+You can list the *tau* commands by running
+*tau [self list](features/takelage/self/self.list.feature)*
+or *tau list*:
+
+Command	| Description
+------- | -----------
+tau config | # Alias for tau [self config active](features/takelage/self/self.config.active.feature)
+tau copy [DIR] [SCOPE] | # Alias for tau [bit clipboard copy](features/takelage/bit/bit.clipboard.copy.feature)
+tau list | # Alias for tau [self list](features/takelage/self/self.list.feature)
+tau login | # Alias for tau [docker container login](features/takelage/docker/docker.container.login.feature)
+tau nuke | # Alias for tau [docker container nuke](features/takelage/docker/docker.container.nuke.feature)
+tau paste [COMPONENT] [DIR] | # Alias for tau [bit clipboard paste](features/takelage/bit/bit.clipboard.paste.feature)
+tau project | # Alias for tau [info project active](features/takelage/info/info.project.active.feature)
+tau pull | # Alias for tau [bit clipboard pull](features/takelage/bit/bit.clipboard.pull.feature)
+tau purge | # Alias for tau [docker container purge](features/takelage/docker/docker.container.purge.feature)
+tau push | # Alias for tau [bit clipboard push](features/takelage/bit/bit.clipboard.push.feature)
+tau update | # Alias for tau [docker image update](features/takelage/docker/docker.image.update.feature)
+tau version | # Alias for tau [self version](features/takelage/self/self.version.feature)
+tau [bit clipboard copy](features/takelage/bit/bit.clipboard.copy.feature) [DIR] [SCOPE] | # Copy new [DIR] to [SCOPE]
+tau [bit clipboard paste](features/takelage/bit/bit.clipboard.paste.feature) [COMPONENT] [DIR] | # Paste bit [COMPONENT] into [DIR]
+tau [bit clipboard pull](features/takelage/bit/bit.clipboard.pull.feature) | # Pull all updates for bit components from bit remote scopes
+tau [bit clipboard push](features/takelage/bit/bit.clipboard.push.feature) | # Push all updates of bit components to bit remote scopes
+tau [bit scope add](features/takelage/bit/bit.scope.add.feature) [SCOPE] | # Add a bit [SCOPE]
+tau [bit scope list](features/takelage/bit/bit.scope.list.feature) | # List bit remote scopes
+tau [bit scope new](features/takelage/bit/bit.scope.new.feature) [SCOPE] | # Init a new bit [SCOPE]
+tau [completion bash](features/takelage/completion/completion.bash.feature) | # Print bash completion code
+tau [docker container check existing](features/takelage/docker/docker.container.check.existing.feature) [CONTAINER] | # Check if docker [CONTAINER] is existing
+tau [docker container check orphaned](features/takelage/docker/docker.container.check.orphaned.feature) [CONTAINER] | # Check if docker [CONTAINER] is orphaned
+tau [docker container command](features/takelage/docker/docker.container.command.feature) [CMD] | # Run [CMD] in a docker container
+tau [docker container daemon](features/takelage/docker/docker.container.daemon.feature) | # Run docker container in daemon mode
+tau [docker container login](features/takelage/docker/docker.container.login.feature) | # Log in to latest local docker container
+tau [docker container nuke](features/takelage/docker/docker.container.nuke.feature) | # Remove all docker containers
+tau [docker container purge](features/takelage/docker/docker.container.purge.feature) | # Remove orphaned docker containers
+tau [docker image tag check local](features/takelage/docker/docker.image.tag.check.local.feature) [TAG] | # Check if local docker image [TAG] exists
+tau [docker image tag check remote](features/takelage/docker/docker.image.tag.check.remote.feature) [TAG] | # Check if remote docker image [TAG] exists
+tau [docker image tag latest local](features/takelage/docker/docker.image.tag.latest.local.feature) | # Print latest local docker image tag
+tau [docker image tag latest remote](features/takelage/docker/docker.image.tag.latest.remote.feature) | # Print latest remote docker image tag
+tau [docker image tag list local](features/takelage/docker/docker.image.tag.list.local.feature) | # Print local docker image tags
+tau [docker image tag list remote](features/takelage/docker/docker.image.tag.list.remote.feature) | # Print remote docker image tags
+tau [docker image update](features/takelage/docker/docker.image.update.feature) | # Get latest remote docker container
+tau [docker socket start](features/takelage/docker/docker.socket.start.feature) | # Start sockets for docker container
+tau [docker socket stop](features/takelage/docker/docker.socket.stop.feature) | # Stop sockets for docker container
+tau [git check clean](features/takelage/git/git.check.clean.feature) | # Check if the git workspace is clean
+tau [git check master](features/takelage/git/git.check.master.feature) | # Check if we are on the git master branch
+tau [git check workspace](features/takelage/git/git.check.workspace.feature) | # Check if a git workspace exists
+tau [info project active](features/takelage/info/info.project.active.feature) | # Print active project info
+tau [info project private](features/takelage/info/info.project.private.feature) | # Print private project info
+tau [info project main](features/takelage/info/info.project.main.feature) | # Print main project info
+tau [self config active](features/takelage/self/self.config.active.feature) | # Print active takelage configuration
+tau [self config default](features/takelage/self/self.config.default.feature) | # Print takelage default configuration
+tau [self config home](features/takelage/self/self.config.home.feature) | # Print takelage home config file configuration
+tau [self config project](features/takelage/self/self.config.project.feature) | # Print takelage project config file configuration
+tau [self list](features/takelage/self/self.list.feature) | # List all commands
+tau [self version](features/takelage/self/self.version.feature) | # Print tau semantic version number
+
+## Configuration
+
+### Configuration Files
+
+*takelage-cli* uses three different YAML configuration files
+which have different precedences.
+They are merged to an active configuration during runtime
+which can be inspected with 
+*tau [self config active](features/takelage/self/self.config.active.feature)*
+or *tau config*.
+
+| Filename | Precedence | Description |
+| -------- | ---------- | ----------- |
+| *default.yml* | lowest | Shipped with *takelage-cli*. Sets defaults where applicable. |
+| *~/.takelage.yml* | normal | User-wide configuration file in your home directory. This is your normal custom configuration file. |
+| *takelage.yml* | highest | Project-specific configuration file next to your main Rakefile. Some projects need special configuration. |
+
+### Configuration Examples
+ 
+- You should the following configuration items in your *~/.takelage.yml*:
+```yaml
+---
+bit_remote: 'ssh://bit@bit.example.com:2222:/bit'
+bit_ssh: 'ssh -p 2222 bit@bit.example.com'
+docker_image: 'takelage'
+docker_repo: 'hub.example.com'
+docker_tagsurl: 'https://hub.example.com/v2/repositories/library/takelage/tags'
+```
+
+- If you want to pin a specific docker tag for one of your projects
+then create an *takelage.yml* file with:
+```yaml
+---
+docker_tag: '1.2.3'
+```
+
+- The cucumber tests make use of an *~/.takelage.yml*
+to overwrite defaults like:
+```yaml
+---
+docker_image: takelage-mock
+```
+
+### Project Files
+
+*tau* reads two different YAML project files
+which have different precedences.
+They are merged to an active configuration during runtime
+which can be inspected with 
+*tau [info project active](features/takelage/info/info.project.active.feature)*
+or *tau project*.
+
+| Default filename | Config key | Precedence | Description |
+| -------- | ---------- | ---------- | ----------- |
+| *project.yml* | info_project_main | normal | Main project file.  |
+| *ansible/group_vars/private/project.yml* | info_project_private | highest | Private project file. Should be in *.gitignore*. |
+
+### Bash Completion
+
+Add this to your bash configuration file like *~/.bash_profile* or *~/.bashrc*:
+```bash
+source <(tau completion bash)
+```

data/bin/tau

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'takelage'
+Fylla.load('tau')
+Takelage::CLI.start

data/lib/Thorfile

@@ -0,0 +1 @@
+require_relative 'takelage'

data/lib/takelage/bit/cli.rb

@@ -0,0 +1,18 @@
+require 'pathname'
+
+module Takelage
+
+  # takelage bit
+  class Bit < SubCommandBase
+
+    include LoggingModule
+    include SystemModule
+    include ConfigModule
+
+    desc 'clipboard [COMMAND]', 'Manage bit clipboard'
+    subcommand 'clipboard', BitClipboard
+
+    desc 'scope [COMMAND]', 'Manage bit scopes'
+    subcommand 'scope', BitScope
+  end
+end

data/lib/takelage/bit/clipboard/cli.rb

@@ -0,0 +1,68 @@
+require 'pathname'
+
+module Takelage
+
+  # takelage bit
+  class BitClipboard < SubCommandBase
+
+    include LoggingModule
+    include ConfigModule
+    include SystemModule
+    include GitCheckModule
+    include BitClipboardModule
+
+    #
+    # bit copy
+    #
+    desc 'copy [DIR] [SCOPE]', 'Copy new [DIR] to [SCOPE]'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    Copy a directory as a bit component to a bit remote scope
+    This command will add a directory as a bit component and tag it.
+    The id of the component will be created from the directory name.
+    The directory needs to contain a README.bit file 
+    or else a new README.bit file will be created.
+    The README.bit will be the main file of the component which must not be deleted.
+    The tagged bit component will be exported to a bit remote scope.
+    LONGDESC
+    # Copy a file or directory as a bit component to a bit remote scope.
+    def copy(dir_or_file, scope)
+      bit_clipboard_copy dir_or_file, scope
+    end
+
+    #
+    # bit paste
+    #
+    desc 'paste [COMPONENT] [DIR]', 'Paste bit [COMPONENT] into [DIR]'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    Paste a bit component into a directory
+    LONGDESC
+    # Paste a bit component into a directory.
+    def paste(cid, dir)
+      bit_clipboard_paste cid, dir
+    end
+
+    #
+    # bit pull
+    #
+    desc 'pull', 'Pull all updates for bit components from bit remote scopes'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    Pull all updates for bit components from bit remote scopes
+    LONGDESC
+    # Pull all updates for bit components from bit remote scopes.
+    def pull
+      bit_clipboard_pull
+    end
+
+    #
+    # bit push
+    #
+    desc 'push', 'Push all updates of bit components to bit remote scopes'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    Push all updates of bit components to bit remote scopes
+    LONGDESC
+    # Push all updates of bit components to bit remote scopes.
+    def push
+      bit_clipboard_push
+    end
+  end
+end

data/lib/takelage/bit/clipboard/module.rb

@@ -0,0 +1,174 @@
+# takelage bit clipboard module
+module BitClipboardModule
+
+  # Backend method for bit copy.
+  def bit_clipboard_copy(dir, scope)
+    log.debug "Running bit copy \"#{dir}\" to \"#{scope}\""
+
+    if git_check_workspace
+      unless git_check_master
+        log.error 'Not on git master branch'
+        return
+      end
+    end
+
+    if File.directory? dir
+
+      # remove trailing slash
+      dir = dir.chomp('/')
+
+      log.debug "Adding the directory \"#{dir}\" as a tagged bit component"
+
+      # check if bit remote scope is added to local workspace
+      cmd_bit_list_remotes = config.active['bit_list_remotes']
+      stdout_str, stderr_str, status = run_and_check cmd_bit_list_remotes
+      unless /.*\s+#{scope}\s+.*/m.match? stdout_str
+        log.error "No bit remote scope \"#{scope}\" found in local bit workspace"
+        return
+      end
+
+      # check if a README.bit file exists in a subdirectory
+      Dir.glob("#{dir}/**/README.bit").each do |file|
+        unless file == "#{dir}/README.bit"
+          log.error "Nested README.bit file detected"
+          return
+        end
+      end
+
+      # touch README.bit if necessary
+      readme_bit = "#{dir}/README.bit"
+      unless File.file? readme_bit
+        log.warn "Creating \"README.bit\" in \"#{dir}\""
+        File.open(readme_bit, 'w') {}
+      end
+
+      # generate component id from directory name
+      id = _id(File.basename(dir))
+
+      # get bit add dir command from active config
+      cmd_bit_add_dir = config.active['bit_add_dir'] % {id: id, dir: dir}
+      run cmd_bit_add_dir
+
+      # get bit tag dir command from active config
+      cmd_bit_tag_id = config.active['bit_tag_id'] % {id: id}
+      run cmd_bit_tag_id
+    else
+      log.error "The directory \"#{dir}\" does not exist"
+      return
+    end
+
+    # export component to bit remote scope
+    cmd_bit_export_to_scope = config.active['bit_export_to_scope'] % {scope: scope}
+    run cmd_bit_export_to_scope
+
+    # remove node_modules directory
+    _rm_node_modules
+
+    log.info "Copied directory \"#{dir}\" " +
+                 "as bit component \"#{id}\" " +
+                 "to bit remote scope \"#{scope}\""
+  end
+
+  # Backend method for bit paste.
+  def bit_clipboard_paste(cid, dir)
+    log.debug "Running bit paste \"#{cid}\" to \"#{dir}\""
+
+    if git_check_workspace
+      unless git_check_master
+        log.error 'Not on git master branch'
+        return
+      end
+    end
+
+    # paste bit component into directory
+    cmd_bit_import_cid = config.active['bit_import_cid'] % {cid: cid, dir: dir}
+    run cmd_bit_import_cid
+
+    # remove node_modules directory
+    _rm_node_modules
+
+    FileUtils.remove_entry_secure("#{dir}/index.bit", force: true)
+
+    log.info "Pasted bit component \"#{cid}\"" +
+                 "to directory \"#{dir}\""
+  end
+
+  # Backend method for bit pull.
+  def bit_clipboard_pull
+    log.debug "Running bit pull"
+
+    if git_check_workspace
+      unless git_check_master
+        log.error 'Not on git master branch'
+        return
+      end
+    end
+
+    # import components into workspace
+    cmd_bit_import_all = config.active['bit_import_all']
+    run cmd_bit_import_all
+
+    # checkout components and merge them
+    cmd_bit_checkout_all = config.active['bit_checkout_all']
+    run cmd_bit_checkout_all
+
+    # remove node_modules directory
+    _rm_node_modules
+
+    log.info "Pulled bit components"
+  end
+
+  # Backend method for bit push
+  def bit_clipboard_push
+    log.debug "Running bit push"
+
+    if git_check_workspace
+      unless git_check_master
+        log.error 'Not on git master branch'
+        return
+      end
+    end
+
+    # tag all components
+    cmd_bit_tag_all = config.active['bit_tag_all']
+    run cmd_bit_tag_all
+
+    # export components
+    cmd_bit_export_all = config.active['bit_export_all']
+    run cmd_bit_export_all
+
+    # remove node_modules directory
+    _rm_node_modules
+
+    log.info "Pushed bit components"
+  end
+
+  # Generate bit component ID.
+  def _id(name)
+    id = ''
+
+    # bit restrictions:
+    # component names can only contain alphanumeric,
+    # lowercase characters, and the following ["-", "_", "$", "!", "/"]
+
+    # convert directory name to lowercase characters
+    dir_downcase = name.downcase
+
+    # construct array of allowed characters
+    allowed_chars = [*('a'..'z'), *('0'..'9'), '-', '_', '$', '!', '/']
+
+    # iterate over directory or file name
+    # and replace invalid characters with underscore
+    dir_downcase.split('').each do |char|
+      id += (allowed_chars.include? char) ? char : '_'
+    end
+
+    log.debug "Generated bit id \"#{id}\" from \"#{name}\""
+    id
+  end
+
+  # Remove node_modules directory.
+  def _rm_node_modules
+    FileUtils.remove_entry_secure('node_modules', force: true)
+  end
+end

data/lib/takelage/bit/scope/cli.rb

@@ -0,0 +1,58 @@
+module Takelage
+
+  # takelage bit scope
+  class BitScope < SubCommandBase
+
+    include LoggingModule
+    include SystemModule
+    include ConfigModule
+    include GitCheckModule
+    include BitScopeModule
+
+    #
+    # bit scope add
+    #
+    desc 'add [SCOPE]', 'Add a bit [SCOPE]'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    Add bit remote scope
+    This command will add a bit remote scope to a local bit workspace.
+    The scope must exist on the bit remote server.
+    LONGDESC
+    # Add bit remote scope.
+    def add(scope)
+      exit false unless configured? %w(bit_ssh bit_remote)
+      bit_scope_add scope
+    end
+
+    #
+    # bit scope new
+    #
+    desc 'new [SCOPE]', 'Init a new bit [SCOPE]'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    Create new bit remote scope
+    This command will create a new directory on the remote bit server.
+    Then it will run "bit init --bare" in the newly created directory.
+    See the bit documentation: http://docs.bit.dev/docs/bit-server
+    LONGDESC
+    # Create new bit remote scope.
+    def new(scope)
+      exit false unless configured? %w(bit_ssh bit_remote)
+      bit_scope_new scope
+    end
+
+    #
+    # bit scope list
+    #
+    desc 'list', 'List bit remote scopes'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    List bit remote scopes
+    This command will list bit remote scopes.
+    LONGDESC
+    # List bit remote scopes.
+    def list
+      exit false unless configured? %w(bit_ssh bit_remote)
+      scopes = bit_scope_list
+      say scopes unless scopes.to_s.strip.empty?
+    end
+  end
+end

data/lib/takelage/bit/scope/module.rb

@@ -0,0 +1,81 @@
+# takelage bit scope module
+module BitScopeModule
+
+  # Backend method for bit scope add.
+  def bit_scope_add(scope)
+    log.debug "Adding bit remote scope \"#{scope}\" to local workspace"
+
+    if git_check_workspace
+      unless git_check_master
+        log.error 'Not on git master branch'
+        return
+      end
+    end
+
+    # check if bit remote scope exists
+    scope_list = bit_scope_list
+    log.debug scope_list
+    unless scope_list.include? scope
+      log.error "The bit remote bit scope \"#{scope}\" doesn't exist"
+      exit false
+    end
+
+    # get bit remote from active config
+    bit_remote = config.active['bit_remote']
+
+    # prepare scope add command
+    cmd_bit_scope_add = "bit remote add #{bit_remote}/#{scope}"
+    run cmd_bit_scope_add
+
+    log.info "Added bit remote scope \"#{scope}\" to local bit workspace"
+  end
+
+  # Backend method for bit scope list.
+  # @return [String] list of bit scopes
+  def bit_scope_list
+    log.debug "Listing bit remote scopes"
+
+    # get ssh command from active config
+    cmd_bit_ssh = config.active['bit_ssh']
+
+    # prepare scope list command
+    root = config.active['bit_scope_root']
+    cmd_bit_scope_list = config.active['bit_scope_list'] % {root: root}
+
+    # run ssh command with scope list command
+    scope_list, stderr, status = run_and_check "#{cmd_bit_ssh} '#{cmd_bit_scope_list}'"
+
+    # remove bit remote root directory from results
+    scope_list.gsub!(/#{root}\/*/, '')
+
+    # remove /scope.json from results
+    scope_list.gsub!(/\/scope.json/, '')
+
+    scope_list
+  end
+
+  # 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}\""
+
+    # check if bit remote scope already exists
+    scope_list = bit_scope_list
+    if scope_list.include? scope
+      log.error "The remote bit scope \"#{scope}\" already exists"
+      exit false
+    end
+
+    # get ssh command from active config
+    cmd_bit_ssh = config.active['bit_ssh']
+
+    # prepare scope list command
+    root = config.active['bit_scope_root']
+    cmd_bit_scope_new = config.active['bit_scope_new'] % {scope: scope, root: root}
+
+    # run ssh command with scope new command
+    run "#{cmd_bit_ssh} '#{cmd_bit_scope_new}'"
+
+    log.info "Created new bit remote scope \"#{scope}\""
+  end
+end

data/lib/takelage/completion/cli.rb

@@ -0,0 +1,21 @@
+module Takelage
+
+  # takelage 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.
+    Put the following line in your shell start script like ~/.bashrc or ~/.bash_profile:
+
+    source <(takelage completion bash)
+    LONGDESC
+    # Print bash completion code.
+    def bash
+      say Takelage::CLI.new.bash_fylla
+    end
+  end
+end

data/lib/takelage/default.yml

@@ -0,0 +1,30 @@
+---
+bit_add_dir: 'bit add --skip-update --id %{id} --main %{dir}/README.bit %{dir}'
+bit_checkout_all: 'bit checkout --ignore-package-json --skip-update -i --all latest'
+bit_export_to_scope: 'bit export --skip-update %{scope}'
+bit_export_all: 'bit export --skip-update'
+bit_import_cid: 'bit import --ignore-package-json --skip-update -p %{dir} %{cid}'
+bit_import_all: 'bit import --skip-update --ignore-package-json -m manual'
+bit_list_remotes: 'bit remote --skip-update'
+bit_scope_root: '/bit'
+bit_scope_list: 'find %{root} -name scope.json'
+bit_scope_new: 'mkdir -p %{root}/%{scope} && cd %{root}/%{scope} && bit init -b'
+bit_scope_remove: 'rm -fr %{root}/%{scope}'
+bit_tag_id: 'bit tag --skip-update --skip-tests %{id}'
+bit_tag_all: 'bit tag --all'
+docker_socket_agent_port: 20000
+docker_socket_agent_ssh_port: 20001
+docker_socket_agent_extra_port: 20002
+docker_socket_agent_browser_port: 20003
+docker_socket_ps: 'sudo ps a -o pid,command'
+docker_socket_gpgconf: 'gpgconf --list-dirs'
+docker_socket_kill: 'sudo kill -SIGTERM %{pid}'
+docker_socket_start: 'sudo socat TCP-LISTEN:%{port},bind=%{host},reuseaddr,fork UNIX-CLIENT:%{path}'
+docker_tag: 'latest'
+info_project_main: 'project.yml'
+info_project_private: 'private/project.yml'
+#bit_remote: 'ssh://bit@bit.example.com:2222:/bit'
+#bit_ssh: 'ssh -p 2222 bit@bit.example.com'
+#docker_image: 'takelage'
+#docker_repo: 'hub.docker.com'
+#docker_tagsurl: 'https://hub.docker.com/v2/repositories/library/takelage/tags'

data/lib/takelage/docker/cli.rb

@@ -0,0 +1,16 @@
+module Takelage
+
+  # takelage docker
+  class Docker < SubCommandBase
+
+    desc 'container [COMMAND]', 'Handle docker container'
+    subcommand 'container', DockerContainer
+
+    desc 'image [COMMAND]', 'Handle docker images'
+    subcommand 'image', DockerImage
+
+    desc 'socket [COMMAND]', 'Handle sockets for docker containers'
+    subcommand 'socket', DockerSocket
+
+  end
+end

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

@@ -0,0 +1,40 @@
+module Takelage
+
+  # takelage docker container check
+  class DockerContainerCheck < SubCommandBase
+
+    include LoggingModule
+    include SystemModule
+    include ConfigModule
+    include DockerContainerCheckModule
+
+    #
+    # 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 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