yadecli 0.1.1

data/lib/yadecli/service/composer_service.rb

@@ -0,0 +1,395 @@
+# frozen_string_literal: true
+
+require 'colorize'
+require 'tty-command'
+require 'tty-prompt'
+require 'tty-table'
+require 'fileutils'
+require 'yaml'
+require 'uri'
+require 'dotenv'
+
+# composer service
+module Yadecli
+  module Service
+    class ComposerService
+
+      def initialize
+        @composer_project_client = Yadecli::Client::ComposerProjectClient.new
+        @composer_service_client = Yadecli::Client::ComposerServiceClient.new
+        @composer_container_client = Yadecli::Client::ComposerContainerClient.new
+      end
+
+      def setup
+        CliUtil.print_header('YadeCli Composer Setup',
+                             ['Answer the following questions to setup Composer on this host:', ''])
+
+        AppConfig[:git_username] = UserInput.ask(' * Gitlab Username?', :git_username)
+        AppConfig[:git_password] = UserInput.ask(' * Gitlab Password?', :git_password)
+        AppConfig[:git_token] = UserInput.ask(' * Gitlab Api Token?', :git_token)
+        AppConfig[:docker_registry_url] = UserInput.ask(' * Docker Registry Url?', :docker_registry_url)
+        AppConfig[:docker_registry_username] = UserInput.ask(' * Docker Registry Username?', :docker_registry_username)
+        AppConfig[:docker_registry_password] = UserInput.ask(' * Docker Registry Password?', :docker_registry_password)
+
+        AppConfig.write!
+      end
+
+      # list composer projects from gitlab
+      def list
+        CliUtil.print_header('YadeCli Composer List',
+                             ['This are the available Yade composer projects you can install', ''])
+
+        composer_projects = @composer_project_client.list
+
+        # print table
+        table = TTY::Table.new header: ['Id', 'Name', 'Services', 'Installed', 'Branch', 'Git Url']
+
+        # add as rows to table
+        composer_projects.each do |p|
+          project_id = p.id
+          project_name = p.name
+          project_installed = p.installed?
+
+          composer_services = @composer_service_client.get_by_composer_project_id(project_id)
+          service_names = composer_services.collect(&:name).join(', ')
+          if project_installed
+            branch_name = FileUtil.git_current_branch(p.install_dir)
+          else
+            branch_name = '-'
+          end
+
+          table << [project_id, project_name, service_names , project_installed, branch_name, p.gitUrl]
+        end
+
+        renderer = TTY::Table::Renderer::ASCII.new(table, padding: [0, 1])
+        puts renderer.render
+
+        puts ''
+        puts 'You can install any of the listed project with the following command:'
+        puts ''
+        puts '  bin/yadecli composer install <name> <branch> [--pull] [--setup] [--clean]'.colorize(:mode => :bold)
+        puts ''
+      end
+
+      # install composer project with name
+      def install(name, options)
+        CliUtil.print_header('YadeCli Composer Install',
+                             ["Going to install Yade composer project #{name}", ''])
+
+        composer_project = @composer_project_client.get_by_name(name)
+
+        #   # delete already installed when option --clean given
+        #   uninstall(options, true) if options[:clean]
+
+        #   # truncate log file
+        #   File.open(@log_file, 'w') { |file| file.truncate(0) }
+
+        # check preconditions
+        check_install_preconditions(options)
+
+        # check already installed
+        already_installed = composer_project.installed?
+
+        # ask for branch if not given from commandline
+        # @branch = UserInput.select_branch(composer_project) if @branch == nil || (@name.nil? && !already_installed)
+
+        if already_installed
+          puts "Composer project #{name} already installed.".colorize(color: :blue, mode: :bold)
+          puts '  ↳ Doing a git pull.'
+
+          pull_repository(composer_project, options)
+        else
+          puts "Composer project #{name} will be installed.".colorize(color: :blue, mode: :bold)
+          puts '  ↳ Doing a git clone.'
+
+          clone_repository(composer_project)
+        end
+
+        puts ''
+        if already_installed
+          puts "  Successfully updated '#{composer_project.name}' at #{composer_project.install_dir}."
+        else
+          puts "  Successfully installed '#{composer_project.name}' to #{composer_project.install_dir}."
+        end
+
+        composer_services = @composer_service_client.get_by_composer_project_id(composer_project.id)
+        service_names = composer_services.collect(&:name).join(' | ')
+
+        puts ''
+        puts '  Use the following commands to manage the service(s)'
+        puts "    Start : bin/yadecli composer start #{composer_project.name} #{service_names}"
+        puts "    Stop  : bin/yadecli composer stop  #{composer_project.name} #{service_names}"
+
+        pull_container(composer_project) if options[:pull]
+
+        # if options[:setup]
+        #   if SystemUtil.os == :linux
+        #     setup_services
+        #   else
+        #     puts ''
+        #     puts 'WARNING: Setting up services on systems other then linux is not supported.'.colorize(:yellow)
+        #   end
+        # end
+      end
+
+      # switch to branch
+      def switch(project_name, target_branch, options)
+        CliUtil.print_header('Composer Switch',
+                             ["Going to switch branch of composer project #{project_name} to #{target_branch}", ''])
+
+        composer_project = @composer_project_client.get_by_name(project_name)
+
+        message = "Switching to branch #{target_branch}"
+        message += ' and pull changes' if options[:pull]
+
+        print message
+
+        cmdline = "git fetch && git checkout -B #{target_branch}"
+        cmdline += " && git pull origin #{target_branch}" if options[:pull]
+
+        begin
+          cmd = TTY::Command.new(output: Yadecli.LOGGER)
+
+          cmd.run(cmdline, chdir: composer_project.install_dir)
+
+          puts ' done'.colorize(:green)
+        rescue TTY::Command::ExitError => e
+          puts ' failed'.colorize(:red)
+          puts e
+        end
+      end
+
+      # uninstall a composer project
+      def uninstall(name, options, suppress_header = false)
+        CliUtil.print_header('YadeCli Composer Uninstall',
+                             ["Going to uninstall composer project #{name}", '']) unless suppress_header
+
+        composer_project = @composer_project_client.get_by_name(name)
+
+        # unless CliUtil.check_root
+        #   puts ''
+        #   puts 'ERROR: The composer uninstall must run with sudo.'.colorize(:red)
+        #   exit 2
+        # end
+
+        answer = false
+        unless options[:yes]
+          prompt = TTY::Prompt.new
+          answer = prompt.yes?("Do you really want to uninstall the #{composer_project.name} composer project?".colorize(:mode => :bold))
+        end
+
+        if options[:yes] || answer
+          FileUtils.rm_rf(composer_project.install_dir)
+          # FileUtils.rm_f("/etc/systemd/system/#{@name}.service")
+        else
+          puts 'There is nothing more I can do for you. Bye.'
+          exit(1)
+        end
+
+        puts ''
+        puts 'Composer project successfully uninstalled'.colorize(:color => :green, :mode => :bold)
+        puts ''
+      end
+
+      # starts the composer service with the given name
+      def start_service(project_name, service_name)
+        CliUtil.print_header('YadeCli Composer Start',
+                             ['Going to start composer service:',
+                              " ↳ Composer Project : #{project_name}",
+                              " ↳ Service Name     : #{service_name}"])
+
+        begin
+          composer_project = @composer_project_client.get_by_name(project_name)
+          composer_services = @composer_service_client.get_by_composer_project_id(composer_project.id)
+
+          # load project dotenv
+          dotenv_file = "#{composer_project.install_dir}/.env"
+          Dotenv.load(dotenv_file)
+
+          # check required envs are set fom .env file or system environment variables
+
+          composer_service = composer_services.select { |s| s.name == service_name }.first
+
+          composer_service.requiredEnvs&.split(',').each do |re|
+            if ENV[re] == nil
+              puts ''
+              puts "Unable to start service. Required environment variable #{re} is not set.".colorize(:red)
+              puts "Either specify the variable and a value in #{dotenv_file} or as a system environment variable an try to run again.".colorize(:red)
+
+              exit 1
+            end
+          end
+
+          composer_containers = @composer_container_client.get_by_composer_service_id(composer_service.id)
+
+          cmdline = "docker-compose up -d #{composer_containers.map(&:name).join(' ')}"
+
+          cmd = TTY::Command.new(output: Yadecli.LOGGER)
+
+          puts ''
+          print "Executing command '#{cmdline}'... "
+
+          cmd.run(cmdline, chdir: composer_project.install_dir)
+
+          puts 'done'.colorize(:green)
+        rescue TTY::Command::ExitError => e
+          puts 'failed'.colorize(:red)
+        end
+      end
+
+      # stops the composer service with the given name
+      def stop_service(project_name, service_name, options)
+        CliUtil.print_header('Composer Service Stop',['Going to stop composer service:',
+                              " ↳ Composer Project : #{project_name}",
+                              " ↳ Service Name     : #{service_name}"])
+
+        begin
+          composer_project = @composer_project_client.get_by_name(project_name)
+          composer_services = @composer_service_client.get_by_composer_project_id(composer_project.id)
+
+          composer_service = composer_services.select { |s| s.name == service_name }.first
+
+          composer_containers = @composer_container_client.get_by_composer_service_id(composer_service.id)
+
+          container_names = composer_containers.map(&:name).join(' ')
+
+          cmdline = "docker-compose stop #{container_names}"
+          cmdline += " && docker-compose rm -f #{container_names}" if options[:rm]
+          cmdline += ' && docker-compose down -v' if options[:down]
+
+          cmd = TTY::Command.new(output: Yadecli.LOGGER)
+
+          puts ''
+          print "Executing command '#{cmdline}'... "
+
+          cmd.run(cmdline, chdir: composer_project.install_dir)
+
+          puts 'done'.colorize(:green)
+        rescue TTY::Command::ExitError => e
+          puts 'failed'.colorize(:red)
+        end
+      end
+
+      # log the containers output of the composer service with the given name
+      def log_service(project_name, service_name, options)
+        CliUtil.print_header('Composer Service Log',["Going to show logs for composer service #{service_name}.",
+                                                     'Hit ctrl + c to stopp when you use the -f option'])
+
+        sleep 1
+
+        composer_project = @composer_project_client.get_by_name(project_name)
+        composer_services = @composer_service_client.get_by_composer_project_id(composer_project.id)
+
+        composer_service = composer_services.select { |s| s.name == service_name }.first
+
+        composer_containers = @composer_container_client.get_by_composer_service_id(composer_service.id)
+
+        container_names = composer_containers.map(&:name).join(' ')
+
+        begin
+          cmdline = 'docker-compose logs'
+          cmdline += ' -f' if options[:follow]
+          cmdline += " #{container_names}"
+
+          cmd = TTY::Command.new(uuid: false)
+
+          cmd.run(cmdline, chdir: install_dir)
+        rescue TTY::Command::ExitError => e
+          puts e
+        end
+      end
+
+      private
+
+      # pull container
+      def pull_container(composer_project)
+        # make shure we are logged in to the docker registry
+        docker_login
+
+        cmd = TTY::Command.new(output: Yadecli.LOGGER)
+
+        puts ''
+        puts 'Pulling docker images:'.colorize(color: :blue)
+
+        doco = YAML.load_file("#{composer_project.install_dir}/docker-compose.yml")
+
+        has_failed_pulls = false
+        doco['services'].each do |k, v|
+          cmdline = "docker-compose pull #{k}"
+
+          print " ↳  #{cmdline}... "
+          begin
+            cmd.run(cmdline, chdir: composer_project.install_dir)
+
+            puts 'done'.colorize(:green)
+          rescue TTY::Command::ExitError => e
+            puts 'failed'.colorize(:red)
+            has_failed_pulls = true
+          end
+        end
+
+        puts ''
+        puts 'Successfully pulled all docker containers.'.colorize(:green) unless has_failed_pulls
+        puts "Failed to pull for at least on container. See log at #{Dir.pwd}/composer.log".colorize(:red) if has_failed_pulls
+        puts ''
+      end
+
+      # docker login
+      def docker_login
+        cmd = TTY::Command.new(output: Yadecli.LOGGER)
+
+        cmdline = "docker login #{AppConfig[:docker_registry_url]} -u #{AppConfig[:docker_registry_username]} -p #{AppConfig[:docker_registry_password]}"
+
+        cmd.run(cmdline, only_output_on_error: true)
+      end
+
+      # clone repository
+      def clone_repository(composer_project)
+        username = AppConfig[:git_username]
+        password = AppConfig[:git_password]
+
+        git_url = URI.parse(composer_project.gitUrl)
+
+        scheme = git_url.scheme
+        host = git_url.host
+        path = git_url.path
+
+        url_with_auth = "#{scheme}://#{username}:#{password}@#{host}#{path}"
+
+        cmd = TTY::Command.new(output: Yadecli.LOGGER)
+        cmdline = "git clone --depth=1 #{url_with_auth} #{composer_project.install_dir}"
+
+        cmd.run(cmdline, only_output_on_error: true)
+      end
+
+      # pull repository
+      def pull_repository(composer_project, options)
+        if options[:yes]
+          answer = true
+        else
+          puts ''
+          answer = TTY::Prompt.new.yes?('Do you want to pull the changes for the repository?')
+        end
+
+        if answer
+          cmd = TTY::Command.new(output: Yadecli.LOGGER)
+          cmd.run('git pull', only_output_on_error: true, chdir: composer_project.install_dir)
+        else
+          puts 'There is nothing more I can do for you. Bye.'
+          exit(1)
+        end
+      end
+
+      # check install preconditions
+      def check_install_preconditions(options)
+        cmd = TTY::Command.new(output: Yadecli.LOGGER)
+
+        cmd.run('test -x /usr/bin/docker') if SystemUtil.os == 'linux'
+        cmd.run('test -x /usr/local/bin/docker') if SystemUtil.os == 'macosx'
+
+        cmd.run('test -x /usr/local/bin/docker-compose')
+      end
+
+    end
+  end
+end

data/lib/yadecli/service/connect_service.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+# yadecli cli
+module Yadecli
+  module Service
+
+    # connect
+    class ConnectService
+      def connect(url)
+        CliUtil.print_header('Yade Connect',
+                             ["Going to connect to yade backend at #{url}", ''])
+
+        AppConfig[:url] = url
+
+        AppConfig.write!
+      end
+    end
+  end
+end

data/lib/yadecli/service/host_service.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require 'tty-table'
+require 'net/ssh'
+require 'fileutils'
+
+# yadecli cli
+module Yadecli
+  module Service
+
+    # host service
+    class HostService
+
+      def initialize
+        @host_client = Yadecli::Client::HostClient.new
+        @domain_client = Yadecli::Client::DomainClient.new
+        @role_client = Yadecli::Client::RoleClient.new
+      end
+
+      # list the available hosts
+      def list
+        CliUtil.print_header'Yade List Hosts', ['This are the available hosts', '']
+
+        hosts = @host_client.list
+
+        table = TTY::Table.new header: ['Name', 'Domain', 'Role', 'Ip', 'OsType', 'Environment']
+
+        hosts.each do |h|
+          domain_id = h.domainId
+          domain = @domain_client.get(domain_id)
+
+          role_id = h.roleId
+          role = @role_client.get(role_id)
+
+          table << [h.name, domain.name, role.name, h.ip, h.osType, h.environmentType]
+        end
+
+        puts table.render(:ascii, width: 100, resize: true, padding: [0, 1])
+        puts ''
+      end
+
+      # bootstrap a host
+      def bootstrap(host_fqdn, options)
+        CliUtil.print_header'Yade bootstrap Host',
+                            ["Going to bootstrap Yade host #{host_fqdn}", '']
+
+        master_host = @host_client.master
+        host = @host_client.host_by_fqdn(host_fqdn)
+
+        domain_id = host.domainId
+        domain = @domain_client.get(domain_id)
+
+        role_id = host.roleId
+        role = @role_client.get(role_id)
+
+        username = 'administrator'
+        port = 22
+
+        Net::SSH.start(host.hostName, username, port: port) do |ssh|
+          checkout_dir = "/home/#{username}/.yade"
+          local_repo = "#{checkout_dir}/yade-puppet-bootstrap"
+
+          # clone or update
+          output = ssh.exec!("mkdir -p #{checkout_dir}")
+          puts output if options[:verbose]
+
+          output = ssh.exec!("git clone -b test --depth 1 https://gitlab.com/yadedev/yade-puppet-bootstrap.git #{local_repo} || (cd #{local_repo} ; git pull)")
+          puts output if options[:verbose]
+
+          # setup
+          if options[:setup]
+            output = ssh.exec!("mkdir -p #{local_repo}")
+            puts output if options[:verbose]
+
+            output = ssh.exec!("sudo #{local_repo}/scripts/ubuntu/setup-managed-host.sh #{host.hostName} #{domain.name} #{host.ip}")
+            puts output if options[:verbose]
+
+            output = ssh.exec!("sudo #{local_repo}/scripts/ubuntu/local-bootstrap.sh \"mc nano\"")
+            puts output if options[:verbose]
+
+            output = ssh.exec!("sudo #{local_repo}/scripts/ubuntu/puppet-install.sh")
+            puts output if options[:verbose]
+
+            # noinspection RubyLiteralArrayInspection
+            modules = {
+                'puppetlabs/ntp': '7.1.1',
+                'saz/timezone': '4.1.1',
+                'cjtoolseram/puppetconf': '0.2.7',
+                'puppetlabs/puppet_authorization': '0.4.0',
+                'puppetlabs/puppetdb': '7.0.1',
+                'puppetlabs-puppetserver_gem': '1.0.0',
+                'puppet-r10k': '6.6.1',
+                'abrader-gms': '1.0.3',
+                'theforeman-puppet': '9.1.0',
+                #'theforeman-foreman': '9.2.0'
+            }
+
+            FileUtils.rm_rf 'modules'
+            FileUtils.mkdir_p 'modules'
+
+            modules.each do |mod, version|
+              cmd = "puppet module install --modulepath #{local_repo}/modules --version #{version} #{mod}"
+
+              output = ssh.exec!(cmd)
+              puts output if options[:verbose]
+            end
+          end
+
+          # provision
+          cmd_a = [
+              'FACTER_vagrant=1',
+              "FACTER_host_ip=#{host.ip}",
+              "FACTER_host_name=#{host.hostName}",
+              "FACTER_host_domain=#{domain.name}",
+              "FACTER_master_ip=#{master_host.ip}",
+              "FACTER_master_host_name=#{master_host.hostName}",
+              "FACTER_role=#{role.name}",
+              "FACTER_datacenter=#{host.datacenter}",
+              "FACTER_zone=#{host.zone}",
+              "FACTER_is_master=#{host.isMaster}",
+              "FACTER_username=#{username}",
+              'sudo --preserve-env puppet apply',
+              "--hiera_config=#{local_repo}/config/hiera.yml",
+              "--modulepath=#{local_repo}/modules:#{local_repo}/dist",
+              "#{local_repo}/environments/production/manifests/default.pp"
+          ]
+
+          cmd_line = cmd_a.join(' ')
+
+          puts cmd_line if options[:verbose]
+
+          channel = ssh.open_channel do |ch|
+            ch.exec cmd_line do |ch, success|
+              raise "could not execute command" unless success
+
+              # "on_data" is called when the process writes something to stdout
+              ch.on_data do |c, data|
+                $stdout.print data if options[:verbose]
+              end
+
+              # "on_extended_data" is called when the process writes something to stderr
+              ch.on_extended_data do |c, type, data|
+                $stderr.print data if options[:verbose]
+              end
+
+              ch.on_close { puts "done!" }
+            end
+          end
+
+          channel.wait
+        end
+      end
+
+      # provision a host
+      def provision(host_fqdn, options)
+        CliUtil.print_header'Yade provision Host',
+                            ["Going to provision Yade host #{host_fqdn}", '']
+
+        host = @host_client.host_by_fqdn(host_fqdn)
+
+        username = 'administrator'
+        port = 22
+
+        Net::SSH.start(host.hostName, username, port: port) do |ssh|
+          # clone or update
+          cmd_line = "sudo puppet agent -t --environment=#{host.environmentType.downcase}"
+
+          channel = ssh.open_channel do |ch|
+            ch.exec cmd_line do |ch, success|
+              raise "could not execute command" unless success
+
+              # "on_data" is called when the process writes something to stdout
+              ch.on_data do |c, data|
+                $stdout.print data if options[:verbose]
+              end
+
+              # "on_extended_data" is called when the process writes something to stderr
+              ch.on_extended_data do |c, type, data|
+                $stderr.print data if options[:verbose]
+              end
+
+              ch.on_close { puts "done!" }
+            end
+          end
+
+          channel.wait
+        end
+      end
+    end
+  end
+end

data/lib/yadecli/service/module_service.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'tty-table'
+
+# yadecli cli
+module Yadecli
+  module Service
+
+    # module service
+    class ModuleService
+
+      def initialize
+        @project_client = Yadecli::Client::ProjectClient.new
+        @module_client = Yadecli::Client::ProjectModuleClient.new
+        @vcs_client = Yadecli::Client::VcsClient.new
+      end
+
+      # list the available modules for the project
+      def list(project_name)
+        CliUtil.print_header'YadeCli List Modules', ["This are the available modules for the Yade project #{project_name}", '']
+
+        project = @project_client.project_by_name(project_name)
+
+        puts "Project: #{project.name}".colorize(:mode => :bold)
+
+        project_modules = @module_client.modules_for_project(project.id)
+
+        rows = []
+        project_modules.each do |m|
+          module_name = m.name
+          is_installed = m.installed?
+          git_status = '-'
+          git_status = FileUtil.git_status(m.home) if is_installed
+          rows << [module_name, is_installed, git_status]
+        end
+        table = TTY::Table.new header: ['Module name', 'Installed', 'Git Status'], rows: rows
+        puts table.render(:ascii, padding: [0, 1])
+        puts ''
+
+        # puts "You can run 'yadecli module install <project_name> <module_name>' to install the module to the project src directory"
+        # puts ''
+      end
+
+      # install the module of a project
+      def install(project_name, module_name, options)
+        CliUtil.print_header'YadeCli Install Module',
+                            ["Going to install module #{module_name} for Yade project #{project_name}", '']
+
+        project = @project_client.project_by_name(project_name)
+        project_module = @module_client.module_for_project(project.id, module_name)
+        vcs = @vcs_client.get(project_module.vcsId)
+
+        if project_module.installed?
+          puts "The module with name #{module_name} is already installed"
+
+          if options[:yes]
+            do_update = true
+          else
+            puts ''
+            prompt = TTY::Prompt.new
+            do_update = prompt.yes?('Do you want to pull the changes for the project? ')
+          end
+        end
+
+        cmd = TTY::Command.new(output: Yadecli.LOGGER)
+
+        if do_update
+          cmd_line = 'git pull'
+          cmd.run(cmd_line, chdir: project_module.home)
+        else
+          cmd_line = "git clone #{vcs.url} #{project_module.home}"
+          cmd.run(cmd_line)
+        end
+      end
+
+    end
+  end
+end