yadecli 0.1.3 → 0.1.4

data/lib/yadecli/service/composer_service.rb

@@ -1,416 +0,0 @@
-# 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_api_url] = UserInput.ask(' * Gitlab API Url?', :git_api_url)
-        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', 'Branches', '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(', ')
-
-          gitlab_client = Yadecli::Client::GitlabClient.new
-
-          branches = gitlab_client.get_branch_names(p.git_repo_name)
-          default_branch = gitlab_client.get_default_branch(p.git_repo_name)
-
-          if project_installed
-            current_branch = FileUtil.git_current_branch(p.install_dir)
-          else
-            current_branch = nil
-          end
-
-          branches = branches.map do |b|
-            if b == default_branch && b == current_branch
-              "#{b} (Default, Current)"
-            elsif b == default_branch && b != current_branch
-              "#{b} (Default)"
-            elsif b == current_branch && b != default_branch
-                "#{b} (Current)"
-            else
-              b
-            end
-          end
-
-          table << [project_id, project_name, service_names , project_installed, branches.join(', '), 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(project_name, branch_name = nil, options)
-        CliUtil.print_header('YadeCli Composer Install',
-                             ["Going to install Yade composer project #{project_name}", ''])
-
-        composer_project = @composer_project_client.get_by_name(project_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_name = UserInput.select_branch(composer_project.git_repo_name) if branch_name == nil && !already_installed && !options[:yes]
-
-        if already_installed
-          puts "Composer project #{project_name} already installed.".colorize(color: :blue, mode: :bold)
-          puts '  ↳ Doing a git pull.'
-
-          pull_repository(composer_project, options)
-        else
-          puts "Composer project #{project_name} will be installed.".colorize(color: :blue, mode: :bold)
-          puts '  ↳ Doing a git clone.'
-
-          clone_repository(composer_project, branch_name)
-        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, branch_name)
-        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 "
-        cmdline += "-b #{branch_name} " if branch_name != nil
-        cmdline += "#{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

@@ -1,19 +0,0 @@
-# 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

@@ -1,191 +0,0 @@
-# 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