takelage 0.1.0

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

@@ -0,0 +1,44 @@
+# 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
+    tags = []
+
+    cmd_docker_images = 'docker images'
+    images = run cmd_docker_images
+
+    images.scan(/.*#{@docker_repo}\/#{@docker_image}.*/) do |line|
+      tags << line.split(/\s+/)[1]
+    end
+
+    tags.sort_by(&Gem::Version.method(:new))
+  end
+
+  # 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 from \"#{@docker_tagsurl}\""
+
+    begin
+      @res = Net::HTTP.get_response URI(@docker_tagsurl)
+      unless @res.code.eql? '200'
+        log.error "Unable to connect to \"#{@docker_tagsurl}\""
+        return
+      end
+    rescue SocketError => e
+      log.debug e
+      exit false
+    end
+
+    begin
+      tags = JSON.parse @res.body
+    rescue JSON::ParserError
+      log.error 'Unable to parse JSON'
+      exit false
+    end
+
+    tags['tags'].sort_by(&Gem::Version.method(:new))
+  end
+end

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

@@ -0,0 +1,61 @@
+module Takelage
+
+  # takelage docker socket
+  class DockerSocket < SubCommandBase
+
+    include LoggingModule
+    include ConfigModule
+    include SystemModule
+    include DockerSocketModule
+
+    # Initialize docker socket
+    def initialize(args = [], local_options = {}, configuration = {})
+
+      # initialize thor parent class
+      super args, local_options, configuration
+
+      @sockets = {
+          :'agent-socket' => {
+              :path => nil,
+              :host => '127.0.0.1',
+              :port => config.active['docker_socket_agent_port']},
+          :'agent-ssh-socket' => {
+              :path => nil,
+              :host => '127.0.0.1',
+              :port => config.active['docker_socket_agent_ssh_port']},
+          :'agent-extra-socket' => {
+              :path => nil,
+              :host => '127.0.0.1',
+              :port => config.active['docker_socket_agent_extra_port']},
+          :'agent-browser-socket' => {
+              :path => nil,
+              :host => '127.0.0.1',
+              :port => config.active['docker_socket_agent_browser_port']}}
+      _get_socket_paths
+    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
+      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
+      docker_socket_stop
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+# takelage docker socket module
+module DockerSocketModule
+
+  # Backend method for docker socket start.
+  def docker_socket_start
+    log.debug 'Starting sockets for docker container'
+
+    cmds_start_socket = _get_socket_start_commands sockets_up = false
+
+    unless cmds_start_socket.empty?
+      log.debug 'Request sudo so that subsequent background tasks run without delay'
+
+      cmd_sudo_true = 'sudo true'
+
+      run cmd_sudo_true
+    end
+
+    cmds_start_socket.each do |cmd_start_socket|
+      run_and_fork cmd_start_socket
+    end
+  end
+
+  # Backend method for docker socket stop.
+  def docker_socket_stop
+    log.debug 'Stopping sockets for docker container'
+
+    cmd_ps = config.active['docker_socket_ps']
+
+    # get process list
+    # assuming format: "pid command"
+    stdout_str, stderr_str, status = run_and_check cmd_ps
+
+    cmds_start_socket = _get_socket_start_commands sockets_up = true
+
+    # loop over process list
+    stdout_str.split(/\n+/).each do |process|
+
+      # 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|
+
+        if command == cmd_start_socket
+          log.debug "Killing PID #{pid}"
+
+          cmd_kill = config.active['docker_socket_kill'] % {pid: pid}
+
+          run cmd_kill
+        end
+      end
+    end
+  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 sockets_up
+    cmds_start_socket = []
+
+    # loop over sockets
+    @sockets.each do |socket, socket_config|
+      cmd_start_socket = config.active['docker_socket_start'] % {
+          host: socket_config[:host],
+          port: socket_config[:port],
+          path: socket_config[:path],
+      }
+
+      if sockets_up
+        if _socket_up? socket, socket_config
+          cmds_start_socket << cmd_start_socket
+        end
+      else
+        unless _socket_up? socket, socket_config
+          cmds_start_socket << cmd_start_socket
+        end
+      end
+    end
+
+    cmds_start_socket
+  end
+
+  # get socket paths
+  def _get_socket_paths
+    cmd_gpgconf_listdirs = config.active['docker_socket_gpgconf']
+    stdout_str, stderr_str, status = run_and_check cmd_gpgconf_listdirs
+
+    stdout_str.split(/\n+/).each do |gpg_path|
+      @sockets.each do |socket, socket_config|
+        gpg_socket = gpg_path.split(':')
+        if gpg_socket[0] == socket.to_s
+          @sockets[socket][:path] = gpg_socket[1]
+        end
+      end
+    end
+  end
+
+  # check if a socket is available
+  # but trying to connect to it via TCP
+  def _socket_up? socket, socket_config
+    host = socket_config[:host]
+    port = socket_config[:port]
+    path = socket_config[:path]
+
+    error_message = "failed to connect to " +
+        "socket \"#{socket}\" " +
+        "using host \"#{host}\", " +
+        "port \"#{port}\", " +
+        "path \"#{path}\""
+
+    # check if socket is available
+    begin
+      Timeout::timeout(1) do
+        begin
+          s = TCPSocket.new host, port
+          s.close
+          log.debug "Socket \"#{socket}\" available"
+          return true
+        rescue Errno::ECONNREFUSED
+          log.debug "Connection refused: #{error_message}"
+          return false
+        rescue Errno::EHOSTUNREACH
+          log.debug "Host unreachable: #{error_message}"
+          return false
+        rescue SocketError
+          log.debug "Socket error: #{error_message}"
+          return false
+        end
+      end
+    rescue Timeout::Error
+      log.debug "Timeout: #{error_message}"
+      return false
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Takelage
+
+  # takelage docker container check
+  class GitCheck < SubCommandBase
+
+    include LoggingModule
+    include SystemModule
+    include GitCheckModule
+
+    #
+    # git check clean
+    #
+    desc 'clean', 'Check if the git workspace is clean'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    Check if the git workspace is clean
+    LONGDESC
+    # Check if the git workspace is clean.
+    def clean
+      exit git_check_clean
+    end
+
+    #
+    # git check master
+    #
+    desc 'master', 'Check if we are on the git master branch'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    Check if we are on the git master branch
+    LONGDESC
+    # Check if we are on the git master branch.
+    def master
+      exit git_check_master
+    end
+
+    #
+    # git check workspace
+    #
+    desc 'workspace', 'Check if a git workspace exists'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    Check if a git workspace exists
+    LONGDESC
+    # Check if a git workspace exists.
+    def workspace
+      exit git_check_workspace
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+# 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
+
+    cmd_git_unstaged = 'git diff --exit-code'
+    cmd_git_uncommitted = 'git diff --cached --exit-code'
+    cmd_git_status = 'git status --porcelain'
+
+    stdout_str, stderr_str, status_unstaged = run_and_check cmd_git_unstaged
+    stdout_str, stderr_str, status_uncommitted = run_and_check cmd_git_uncommitted
+    stdout_str_status, stderr_str, status = run_and_check cmd_git_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
+
+    cmd_get_branch = 'git symbolic-ref HEAD'
+    stdout_str, stderr_str, status = run_and_check cmd_get_branch
+
+    branch = stdout_str.strip.split('/')[-1]
+
+    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'
+
+    cmd_check_git_repo = 'git -C . rev-parse'
+    stdout_str_repo, stderr_str_repo, status_repo = run_and_check cmd_check_git_repo
+
+    cmd_pwd = 'pwd'
+    stdout_str_dir, stderr_str_dir, status_dir = run_and_check cmd_pwd
+
+    dir = stdout_str_dir.strip
+
+    unless status_repo.exitstatus.zero?
+      log.debug "No git workspace found in \"#{dir}\""
+      return false
+    end
+
+    true
+  end
+end

data/lib/takelage/git/cli.rb

@@ -0,0 +1,10 @@
+module Takelage
+
+  # takelage git
+  class Git < SubCommandBase
+
+    desc 'check [COMMAND]', 'Check git state'
+    subcommand 'check', GitCheck
+
+  end
+end

data/lib/takelage/info/cli.rb

@@ -0,0 +1,10 @@
+module Takelage
+
+  # takelage info
+  class Info < SubCommandBase
+
+    desc 'project [COMMAND]', 'Get project info'
+    subcommand 'project', InfoProject
+
+  end
+end

data/lib/takelage/info/project/cli.rb

@@ -0,0 +1,47 @@
+module Takelage
+
+  # takelage info project
+  class InfoProject < SubCommandBase
+
+    include LoggingModule
+    include SystemModule
+    include ConfigModule
+    include ProjectModule
+
+    #
+    # info project active
+    #
+    desc 'active', 'Print active project info'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    Print active project info
+    LONGDESC
+    # Print active project info.
+    def active
+      say hash_to_yaml(project.active)
+    end
+
+    #
+    # info project private
+    #
+    desc 'private', 'Print private project info'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    Print private project info
+    LONGDESC
+    # Print private project info.
+    def private
+      say hash_to_yaml(project.private)
+    end
+
+    #
+    # info project main
+    #
+    desc 'main', 'Print main project info'
+    long_desc <<-LONGDESC.gsub("\n", "\x5")
+    Print main project info
+    LONGDESC
+    # Print main project info.
+    def main
+      say hash_to_yaml(project.main)
+    end
+  end
+end

data/lib/takelage/lib/config.rb

@@ -0,0 +1,80 @@
+# takelage config module
+module ConfigModule
+
+  # takelage config class.
+  class TakelageConfig
+
+    include LoggingModule
+    include SystemModule
+
+    attr_accessor :active, :default, :home, :project
+
+    def initialize
+      @active = Hash.new
+      @default = Hash.new
+      @home = Hash.new
+      @project = Hash.new
+    end
+  end
+
+  # Global singleton config
+  @@config = TakelageConfig.new
+
+  # Initialze config
+  def initialize_config
+    log.debug "takelage version: #{Takelage::VERSION}"
+    log.debug "Current working directory: #{Dir.pwd}"
+
+    # read default config file in lib
+    default_file = "#{File.dirname(__FILE__)}/../default.yml"
+    default_file = File.expand_path default_file
+    if File.exist? default_file
+      @@config.default = read_yaml_file(default_file) || Hash.new
+      @@config.default = @@config.default.sort.to_h
+    end
+
+    # read custom config file in $HOME
+    home_file = "#{Dir.home}/.takelage.yml"
+    if File.exist? home_file
+      @@config.home = read_yaml_file(home_file) || Hash.new
+      @@config.home = @@config.home.sort.to_h
+    end
+
+    # read custom config file next to Rakefile
+    file, path = Rake.application.find_rakefile_location
+    if path
+      project_file = "#{path}/takelage.yml"
+      @@config.project = read_yaml_file(project_file) || Hash.new
+      @@config.project = @@config.project.sort.to_h
+    end
+
+    # make a clone or else we'll change the original hash
+    default = @@config.default.clone
+    home = @@config.home.clone
+    project = @@config.project.clone
+
+    # merge default and home and project to active
+    # project wins against home wins against default
+    project_over_home = home.merge!(project)
+
+    @@config.active = default.merge!(project_over_home)
+    @@config.active = @@config.active.sort.to_h
+  end
+
+  # @return [Object] global singleton config
+  def config
+    @@config
+  end
+
+  # @return [Boolean] check if config keys are configured
+  def configured?(config_keys)
+    @configured = true
+    config_keys.each do |config_key|
+      unless @@config.active.key? config_key
+        log.error "Please configure \"#{config_key}\""
+        @configured = false
+      end
+    end
+    @configured
+  end
+end

data/lib/takelage/lib/logging.rb

@@ -0,0 +1,30 @@
+# takelage logging module
+module LoggingModule
+
+  # Global singleton logger
+  @@log = Logger.new(STDOUT)
+
+  # Initialize logger with loglevel.
+  def initialize_logging(loglevel)
+
+    # logger: format
+    log.formatter = proc do |severity, datetime, progname, msg|
+      "[#{severity}] #{msg}\n"
+    end
+
+    # logger: level
+    if %w(FATAL ERROR WARN INFO DEBUG).include? loglevel
+      log.level = loglevel
+      log.debug "Using loglevel #{loglevel}"
+    else
+      log.level = Logger::INFO
+      log.error 'The parameter "loglevel" must be one of FATAL, ERROR, WARN, INFO, DEBUG'
+      log.info 'Using loglevel INFO'
+    end
+  end
+
+  # @return [Object] global singleton logger
+  def log
+    @@log
+  end
+end

data/lib/takelage/lib/project.rb

@@ -0,0 +1,57 @@
+# takelage project module
+module ProjectModule
+
+  # takelage config class.
+  class TakelageProject
+
+    include LoggingModule
+    include SystemModule
+    include ConfigModule
+
+    attr_accessor :active, :private, :main
+
+    def initialize
+      @active = Hash.new
+      @private = Hash.new
+      @main = Hash.new
+    end
+  end
+
+  # Global singleton config
+  @@project = TakelageProject.new
+
+  # Initialze project
+  def initialize_project
+
+    rakefile, path = Rake.application.find_rakefile_location
+
+    main_file = "#{path}/#{@@project.config.active['info_project_main']}"
+    private_file = "#{path}/#{@@project.config.active['info_project_private']}"
+
+    # read main project info
+    if File.exist? main_file
+      @@project.main = read_yaml_file(main_file) || Hash.new
+      @@project.main = @@project.main.sort.to_h
+    end
+
+    # read private project info
+    if File.exist? private_file
+      @@project.private = read_yaml_file(private_file) || Hash.new
+      @@project.private = @@project.private.sort.to_h
+    end
+
+    # make a clone or else we'll change the original hash
+    main = @@project.main.clone
+    private = @@project.private.clone
+
+    # merge main and private to active
+    # private wins against main
+    @@project.active = main.merge!(private)
+    @@project.active = @@project.active.sort.to_h
+  end
+
+  # @return [Object] global singleton project
+  def project
+    @@project
+  end
+end

data/lib/takelage/lib/subcmd.rb

@@ -0,0 +1,13 @@
+# Thor with subcommands that work correctly with help
+class SubCommandBase < Thor
+
+  # Set the subcommand banner
+  def self.banner(command, namespace = nil, subcommand = false)
+    "#{basename} #{subcommand_prefix} #{command.usage}"
+  end
+
+  # Set the subcommand prefix
+  def self.subcommand_prefix
+    self.name.gsub(%r{.*::}, '').gsub(%r{^[A-Z]}) { |match| match[0].downcase }.gsub(%r{[A-Z]}) { |match| " #{match[0].downcase}" }
+  end
+end