ConfigLMM 0.3.0 → 0.5.0

data/lib/ConfigLMM/Framework/plugins/linuxApp.rb

@@ -1,166 +1,200 @@
 # frozen_string_literal: true
 
+require 'tty-which'
+
 module ConfigLMM
     module Framework
 
         class LinuxApp < Framework::Plugin
 
             LINUX_FOLDER = __dir__ + '/../../../../Plugins/OS/Linux/'
-            SUSE_NAME = 'openSUSE Leap'
             SUSE_ID = 'opensuse-leap'
             PODMAN_PACKAGE = 'Podman'
             SYSTEMD_CONTAINERS_PATH = '~/.config/containers/systemd/'
 
-            def ensurePackage(name, location)
-              self.class.ensurePackages([name], location)
+            # DEPRECATED
+            def ensurePackage(name, location, binary = nil)
+                self.class.ensurePackage(name, location, binary)
             end
 
+            # DEPRECATED
             def ensurePackages(names, location)
-              self.class.ensurePackages(names, location)
-            end
-
-            def self.ensurePackages(names, locationOrSSH)
-                distroInfo = nil
-                closure = Proc.new do |ssh|
-                    distroInfo = self.currentDistroInfo(ssh)
-                    reposPackages = self.mapPackages(names, distroInfo['Name'])
-
-                    repos = []
-                    pkgs = []
-                    reposPackages.each do |pkg|
-                        if pkg.include?('|')
-                            repoName, pkg = pkg.split('|')
-                            repos << repoName
-                            pkgs << pkg
-                        else
-                            pkgs << pkg
-                        end
-                    end
-                    repos.each do |repoName|
-                        self.addRepo(repoName, distroInfo, ssh)
-                    end
-                    command = distroInfo['InstallPackage'] + ' ' + pkgs.map { |pkg| pkg.shellescape }.join(' ')
-                    if ssh
-                        self.sshExec!(ssh, command)
-                    else
-                        if `echo $EUID`.strip == '0'
-                            `#{command} >/dev/null`
-                        else
-                            `sudo #{command} >/dev/null`
-                        end
-                    end
-                    distroInfo
-                end
+                self.class.ensurePackages(names, location)
+            end
 
-                if locationOrSSH.nil? || locationOrSSH == '@me'
-                    distroInfo = closure.call(nil)
-                elsif locationOrSSH.is_a?(String) || locationOrSSH.is_a?(Addressable::URI)
-                    uri = Addressable::URI.parse(locationOrSSH)
-                    raise Framework::PluginProcessError.new("#{id}: Unknown Protocol: #{uri.scheme}!") if uri.scheme != 'ssh'
+            # DEPRECATED
+            def self.ensurePackage(name, locationOrConnection, binary = nil)
+                if binary && TTY::Which.which(binary)
+                    return
+                end
+                self.ensurePackages([name], locationOrConnection)
+            end
 
-                    self.sshStart(locationOrSSH) do |ssh|
-                        distroInfo = closure.call(ssh)
-                    end
-                else
-                    distroInfo = closure.call(locationOrSSH)
+            # DEPRECATED
+            def self.ensurePackages(names, locationOrConnection)
+                self.doConnection(locationOrConnection) do |connection|
+                    linuxConnection = LMM::LinuxConnection.new(connection)
+                    linuxConnection.ensurePackages(names)
+                    linuxConnection.distroInfo
                 end
-                distroInfo
             end
 
-            def ensureServiceAutoStart(name, location)
-                if location && location != '@me'
-                    uri = Addressable::URI.parse(location)
-                    raise Framework::PluginProcessError.new("#{id}: Unknown Protocol: #{uri.scheme}!") if uri.scheme != 'ssh'
-                    self.class.ensureServiceAutoStartOverSSH(name, uri)
-                else
-                    # TODO
+            # DEPRECATED
+            def self.removePackage(name, locationOrConnection, dry = false)
+                self.doConnection(locationOrConnection) do |connection|
+                    linuxConnection = LMM::LinuxConnection.new(connection)
+                    linuxConnection.removePackage(name)
+                    linuxConnection.distroInfo
                 end
             end
 
-            def self.ensureServiceAutoStartOverSSH(name, locationOrSSH)
-                closure = Proc.new do |ssh|
-                    distroInfo = self.currentDistroInfo(ssh)
+            # DEPRECATED
+            def ensureServiceAutoStart(name, locationOrConnection)
+                self.class.ensureServiceAutoStart(name, locationOrConnection)
+            end
+
+            # DEPRECATED
+            def self.ensureServiceAutoStart(name, locationOrConnection)
+                name = self.convertServiceName(name, locationOrConnection)
+                self.execDistroCommand(name, 'AutoStartService', locationOrConnection)
+            end
+
+            # DEPRECATED
+            def self.ensureServiceAutoStartOverSSH(name, locationOrConnection)
+                self.ensureServiceAutoStart(name, locationOrConnection)
+            end
+
+            # DEPRECATED
+            def startService(name, locationOrConnection, dry = false)
+                self.class.startService(name, locationOrConnection, dry = false)
+            end
+
+            # DEPRECATED
+            def self.startService(name, locationOrConnection, dry = false)
+                name = self.convertServiceName(name, locationOrConnection)
+                self.execDistroCommand(name, 'StartService', locationOrConnection, false, dry)
+            end
+
+            # DEPRECATED
+            def self.startServiceOverSSH(name, locationOrConnection, dry = false)
+                name = self.convertServiceName(name, locationOrConnection)
+                self.startService(name, locationOrConnection, dry)
+            end
+
+            # DEPRECATED
+            def self.restartService(name, locationOrConnection, dry = false)
+                name = self.convertServiceName(name, locationOrConnection)
+                self.execDistroCommand(name, 'RestartService', locationOrConnection, false, dry)
+            end
+
+            # DEPRECATED
+            def self.reloadService(name, locationOrConnection, dry = false)
+                name = self.convertServiceName(name, locationOrConnection)
+                self.execDistroCommand(name, 'ReloadService', locationOrConnection, false, dry)
+            end
 
-                    command = distroInfo['AutoStartService'] + ' ' + name.shellescape
-                    self.sshExec!(ssh, command)
+            # DEPRECATED
+            def self.stopService(name, locationOrConnection, dry = false)
+                name = self.convertServiceName(name, locationOrConnection)
+                self.execDistroCommand(name, 'StopService', locationOrConnection, true, dry)
+            end
+
+            # DEPRECATED
+            def self.disableService(name, locationOrConnection, dry = false)
+                name = self.convertServiceName(name, locationOrConnection)
+                self.execDistroCommand(name, 'DisableService', locationOrConnection, true, dry)
+            end
+
+            # DEPRECATED
+            def self.reloadServiceManager(locationOrConnection, dry = false)
+                self.execDistroCommand(nil, 'ReloadServiceManager', locationOrConnection, false, dry)
+            end
+
+            # DEPRECATED
+            def self.deleteUserAndGroup(name, locationOrConnection, dry = false)
+                self.execDistroCommand(name, 'DeleteUser', locationOrConnection, true, dry)
+                self.execDistroCommand(name, 'DeleteGroup', locationOrConnection, true, dry)
+            end
+
+            # DEPRECATED
+            def self.execDistroCommand(param, commandName, locationOrConnection, allowFailure = false, dry = false)
+                self.doConnection(locationOrConnection) do |connection|
+                    LMM::LinuxConnection.new(connection).execDistroCommand(param, commandName, allowFailure, { 'dry': dry })
                 end
+            end
 
-                if locationOrSSH.is_a?(String) || locationOrSSH.is_a?(Addressable::URI)
-                    self.sshStart(locationOrSSH) do |ssh|
-                        closure.call(ssh)
-                    end
-                else
-                    closure.call(locationOrSSH)
+            # DEPRECATED
+            def self.convertServiceName(name, connection)
+                self.doConnection(connection) do |connection|
+                    name = LMM::LinuxConnection.new(connection).convertServiceName(name)
                 end
+                name
             end
 
-            def startService(name, location)
-                if location && location != '@me'
-                    uri = Addressable::URI.parse(location)
-                    raise Framework::PluginProcessError.new("#{id}: Unknown Protocol: #{uri.scheme}!") if uri.scheme != 'ssh'
-                    self.class.startServiceOverSSH(name, location)
+            def self.doConnection(locationOrConnection, &block)
+                if locationOrConnection.nil? || locationOrConnection == '@me'
+                    result = block.call(nil)
+                elsif locationOrConnection.is_a?(String) || locationOrConnection.is_a?(Addressable::URI)
+                    prompt = TTY::Prompt.new
+                    logger = TTY::Logger.new
+                    IO::Connection.tunnel(locationOrConnection, {}, {}, prompt, logger, &block)
                 else
-                    # TODO
+                    if locationOrConnection.is_a?(IO::Connection)
+                        result = block.call(locationOrConnection)
+                    else
+                        prompt = TTY::Prompt.new
+                        logger = TTY::Logger.new
+                        result = block.call(IO::Connection.new(:SSH, IO::SSH.new(prompt, logger, locationOrConnection), prompt, logger))
+                    end
                 end
+                result
             end
 
-            def self.startServiceOverSSH(name, locationOrSSH)
-                 closure = Proc.new do |ssh|
-                     distroInfo = self.currentDistroInfo(ssh)
+            # DEPRECATED
+            def self.firewallAddServiceOverSSH(serviceName, locationOrConnection)
+                self.firewallAddService(serviceName, locationOrConnection)
+            end
 
-                     command = distroInfo['StartService'] + ' ' + name.shellescape
-                     self.sshExec!(ssh, command)
-                 end
+            # DEPRECATED
+            def self.firewallAddPortOverSSH(portName, locationOrConnection)
+                self.firewallAddPort(portName, locationOrConnection)
+            end
 
-                if locationOrSSH.is_a?(String) || locationOrSSH.is_a?(Addressable::URI)
-                    self.sshStart(locationOrSSH) do |ssh|
-                        closure.call(ssh)
-                    end
-                else
-                    closure.call(locationOrSSH)
+            # DEPRECATED
+            def self.firewallAddService(serviceName, locationOrConnection = nil, dry = false)
+                self.doConnection(locationOrConnection) do |connection|
+                    LMM::LinuxConnection.new(connection).firewallAddService(serviceName, { 'dry': dry })
                 end
             end
 
-
-            def self.firewallAddServiceOverSSH(serviceName, locationOrSSH)
-                 closure = Proc.new do |ssh|
-                     command = 'firewall-cmd --permanent --add-service ' + serviceName.shellescape
-                     self.sshExec!(ssh, command, true)
-                     command = 'firewall-cmd --add-service ' + serviceName.shellescape
-                     self.sshExec!(ssh, command, true)
-                 end
-
-                if locationOrSSH.is_a?(String) || locationOrSSH.is_a?(Addressable::URI)
-                    self.sshStart(locationOrSSH) do |ssh|
-                        closure.call(ssh)
-                    end
-                else
-                    closure.call(locationOrSSH)
+            # DEPRECATED
+            def self.firewallRemoveService(serviceName, locationOrConnection = nil, dry = false)
+                self.doConnection(locationOrConnection) do |connection|
+                    LMM::LinuxConnection.new(connection).firewallRemoveService(serviceName, { 'dry': dry })
                 end
             end
 
-            def self.firewallAddPortOverSSH(portName, locationOrSSH)
-                 closure = Proc.new do |ssh|
-                     command = 'firewall-cmd --permanent --add-port ' + portName.shellescape
-                     self.sshExec!(ssh, command, true)
-                     command = 'firewall-cmd --add-port ' + portName.shellescape
-                     self.sshExec!(ssh, command, true)
-                 end
+            # DEPRECATED
+            def self.firewallAddPort(portName, locationOrConnection = nil, dry = false)
+                self.doConnection(locationOrConnection) do |connection|
+                    LMM::LinuxConnection.new(connection).firewallAddPort(portName, { 'dry': dry })
+                end
+            end
 
-                if locationOrSSH.is_a?(String) || locationOrSSH.is_a?(Addressable::URI)
-                    self.sshStart(locationOrSSH) do |ssh|
-                        closure.call(ssh)
-                    end
-                else
-                    closure.call(locationOrSSH)
+            # DEPRECATED
+            def self.firewallRemovePort(portName, locationOrConnection = nil, dry = false)
+                self.doConnection(locationOrConnection) do |connection|
+                    LMM::LinuxConnection.new(connection).firewallRemovePort(portName, { 'dry': dry })
                 end
             end
 
             def self.mapPackages(packages, distroName)
-                distroPackages = YAML.load_file(LINUX_FOLDER + 'Packages.yaml')
+                allPackages = YAML.load_file(LINUX_FOLDER + 'Packages.yaml')
                 names = []
+                raise "Distro '#{distroName}' not implemented!" unless allPackages.key?(distroName)
+                distroPackages = allPackages[distroName].to_h
                 packages.to_a.each do |pkg|
-                    packageName = distroPackages[distroName][pkg]
+                    packageName = distroPackages[pkg]
                     if packageName
                         if packageName.is_a?(Array)
                             names += packageName
@@ -174,6 +208,7 @@ module ConfigLMM
                 names
             end
 
+            # DEPRECATED
             def self.createCertificateOverSSH(ssh)
                 dir = "/etc/letsencrypt/live/Wildcard/"
                 self.sshExec!(ssh, "mkdir -p #{dir}")
@@ -185,51 +220,59 @@ module ConfigLMM
                 dir
             end
 
-            def self.configurePodmanServiceOverSSH(user, homedir, userComment, distroInfo, ssh)
-                Framework::LinuxApp.ensurePackages([PODMAN_PACKAGE], ssh)
-                addUserCmd = "#{distroInfo['CreateServiceUser']} --home-dir '#{homedir}' --create-home --comment '#{userComment}' #{user}"
-                self.sshExec!(ssh, addUserCmd, true)
-                self.createSubuidsOverSSH(user, distroInfo, ssh)
-                self.sshExec!(ssh, "loginctl enable-linger #{user}")
-                self.sshExec!(ssh, "su --login #{user} --shell /bin/sh --command 'mkdir -p #{SYSTEMD_CONTAINERS_PATH}'")
+            # DEPRECATED
+            def self.configurePodmanService(user, homedir, userComment, distroInfo, connection)
+                self.configurePodmanServiceOverSSH(user, homedir, userComment, distroInfo, connection)
             end
 
-            def self.addRepo(name, distroInfo, ssh = nil)
-                if distroInfo['Name'] == 'openSUSE Leap'
-                    if ssh
-                        versionId = ssh.exec!('cat /etc/os-release | grep "^VERSION_ID=" | cut -d "=" -f 2').strip.gsub('"', '')
-                        self.sshExec!(ssh, "zypper addrepo https://download.opensuse.org/repositories/#{name}/#{versionId}/#{name}.repo", true)
-                        self.sshExec!(ssh, "zypper --gpg-auto-import-keys refresh")
-                    else
-                        versionId = `cat /etc/os-release | grep "^VERSION_ID=" | cut -d "=" -f 2`.strip.gsub('"', '')
-                        `zypper addrepo https://download.opensuse.org/repositories/#{name}/#{versionId}/#{name}.repo`
-                        `zypper --gpg-auto-import-keys refresh`
-                    end
+            # DEPRECATED
+            def self.configurePodmanServiceOverSSH(user, homedir, userComment, distroInfo, connectionOrSSH)
+                if connectionOrSSH.is_a?(IO::Connection)
+                    Framework::LinuxApp.ensurePackages([PODMAN_PACKAGE], connectionOrSSH)
+                    addUserCmd = "#{distroInfo['CreateServiceUser']} --home-dir '#{homedir}' --create-home --comment '#{userComment}' #{user}"
+                    connectionOrSSH.exec(addUserCmd, true)
+                    connectionOrSSH.exec("chmod o-rwx #{homedir}")
+                    self.createSubuids(user, distroInfo, connectionOrSSH)
+                    connectionOrSSH.exec("loginctl enable-linger #{user}")
+                    connectionOrSSH.exec("su --login #{user} --shell /bin/sh --command 'mkdir -p #{SYSTEMD_CONTAINERS_PATH}'")
                 else
-                    # TODO
+                    Framework::LinuxApp.ensurePackages([PODMAN_PACKAGE], connectionOrSSH)
+                    addUserCmd = "#{distroInfo['CreateServiceUser']} --home-dir '#{homedir}' --create-home --comment '#{userComment}' #{user}"
+                    self.sshExec!(connectionOrSSH, addUserCmd, true)
+                    self.sshExec!(connectionOrSSH, "chmod o-rwx #{homedir}")
+                    self.createSubuidsOverSSH(user, distroInfo, connectionOrSSH)
+                    self.sshExec!(connectionOrSSH, "loginctl enable-linger #{user}")
+                    self.sshExec!(connectionOrSSH, "su --login #{user} --shell /bin/sh --command 'mkdir -p #{SYSTEMD_CONTAINERS_PATH}'")
                 end
             end
 
+            # DEPRECATED
+            def self.createSubuids(user, distroInfo, connection)
+                connection.exec("#{distroInfo['ModifyUser']} --add-subuids 100000-165535 --add-subgids 100000-165535 #{user}")
+            end
+
+            # DEPRECATED
             def self.createSubuidsOverSSH(user, distroInfo, ssh)
                 self.sshExec!(ssh, "#{distroInfo['ModifyUser']} --add-subuids 100000-165535 --add-subgids 100000-165535 #{user}")
             end
 
-            def self.distroID(ssh = nil)
-                if ssh
-                    ssh.exec!('cat /etc/os-release | grep "^ID=" | cut -d "=" -f 2').strip.gsub('"', '')
-                else
-                    `cat /etc/os-release | grep "^ID=" | cut -d "=" -f 2`.strip.gsub('"', '')
+            # DEPRECATED
+            def self.distroID(connection = nil)
+                id = nil
+                self.doConnection(connection) do |connection|
+                    id = LMM::LinuxConnection.new(connection).distroID
                 end
+                id
             end
 
-            def self.currentDistroInfo(ssh)
-                self.distroInfo(self.distroID(ssh))
+            # DEPRECATED
+            def self.currentDistroInfo(connection)
+                self.distroInfo(self.distroID(connection))
             end
 
+            # DEPRECATED
             def self.distroInfo(distroID)
-                distributions = YAML.load_file(LINUX_FOLDER + 'Distributions.yaml')
-                raise Framework::PluginProcessError.new("Unknown Linux Distro: #{distroID}!") unless distributions.key?(distroID)
-                distributions[distroID]
+                YAML.load_file(LINUX_FOLDER + 'Distributions.yaml')[distroID]
             end
 
         end

data/lib/ConfigLMM/Framework/plugins/nginxApp.rb

@@ -11,12 +11,15 @@ require 'fileutils'
 module ConfigLMM
     module Framework
 
+        # DEPRECATED
         class NginxApp < Framework::Plugin
 
+            # DEPRECATED
             NGINX_PACKAGE = 'nginx'
             CONFIG_DIR = '/etc/nginx/'
             WWW_DIR = '/srv/www/'
 
+            # DEPRECATED
             def writeNginxConfig(dir, name, id, target, activeState, context, options)
                 outputFolder = options['output']
 
@@ -25,9 +28,11 @@ module ConfigLMM
                 target = target.dup
                 target['NginxVersion'] = 0 unless target['NginxVersion']
                 template = ERB.new(File.read(dir + '/' + name + '.conf.erb'))
+                name = target['ConfigName'] if target['ConfigName']
                 renderTemplate(template, target, outputFolder + '/nginx/servers-lmm/' + name + '.conf', options)
             end
 
+            # DEPRECATED
             def deployNginxConfig(id, target, activeState, context, options)
                 outputFolder = options['output'] + '/nginx/servers-lmm'
 
@@ -36,27 +41,70 @@ module ConfigLMM
                     raise Framework::PluginProcessError.new("Unknown Protocol: #{uri.scheme}!") if uri.scheme != 'ssh'
                     self.class.sshStart(uri) do |ssh|
                         self.class.uploadFolder(outputFolder, CONFIG_DIR, ssh)
-                        Framework::LinuxApp.firewallAddServiceOverSSH('https', ssh)
+                        if target['TLS']
+                            Framework::LinuxApp.firewallAddServiceOverSSH('https', ssh)
+                        else
+                            Framework::LinuxApp.firewallAddServiceOverSSH('http', ssh)
+                        end
                     end
                 else
                     copy(outputFolder, CONFIG_DIR, options['dry'])
                 end
             end
 
-            def cleanupNginxConfig(name, id, state, context, options)
-                rm('/etc/nginx/servers-lmm/' + name + '.conf', options['dry'])
+            # DEPRECATED
+            def cleanupNginxConfig(name, id, state, context, options, connection)
+                connection.rm('/etc/nginx/servers-lmm/' + name + '.conf', options['dry'])
             end
 
-            def self.prepareNginxConfig(target, ssh = nil)
-                if ssh
-                    target['NginxVersion'] = self.sshExec!(ssh, 'nginx -v').strip.split('/')[1].to_f
+            # DEPRECATED
+            def self.prepareNginxConfig(target, connectionOrSSH = nil)
+                if connectionOrSSH.is_a?(IO::Connection)
+                    target['NginxVersion'] = connectionOrSSH.exec('nginx -v').strip.split('/')[1].to_f
+                elsif connectionOrSSH
+                    target['NginxVersion'] = self.sshExec!(connectionOrSSH, 'nginx -v').strip.split('/')[1].to_f
                 else
                     target['NginxVersion'] = `nginx -v`.strip.split('/')[1].to_f
                 end
             end
 
+            # DEPRECATED
+            def self.reload(connection = nil, dry = false)
+                if connection.is_a?(IO::Connection)
+                    connection.exec("systemctl reload nginx", false, { 'dry' => dry })
+                else
+                    self.exec("systemctl reload nginx", connection, false, dry)
+                end
+            end
+
+            # DEPRECATED
+            def self.ensurePackage(connection = nil)
+                Framework::LinuxApp.ensurePackages([NGINX_PACKAGE], connection)
+                Framework::LinuxApp.ensureServiceAutoStartOverSSH(NGINX_PACKAGE, connection)
+            end
+
+            # DEPRECATED
+            def useNginxProxy(dir, configName, id, target, activeState, state, context, options, connectionOrSSH)
+                self.class.ensurePackage(connectionOrSSH)
+                self.class.prepareNginxConfig(target, connectionOrSSH)
+                self.writeNginxConfig(dir, configName, id, target, state, context, options)
+                self.deployNginxConfig(id, target, activeState, context, options)
+                Framework::LinuxApp.startServiceOverSSH(NGINX_PACKAGE, connectionOrSSH)
+                self.class.reload(connectionOrSSH)
+            end
+
+            # DEPRECATED
+            def deployNginxProxyConfig(server, name, id, target, activeState, state, context, options, connectionOrSSH)
+                target = target.dup
+                target['Proxy'] = server
+                target['Name'] = name if name
+                target['ConfigName'] = target['Name']
+                useNginxProxy(__dir__ + '/../../../../Plugins/Apps/Nginx', 'proxy', id, target, activeState, state, context, options, connectionOrSSH)
+            end
+
             private
 
+            # DEPRECATED
             def updateTargetConfig(target)
                 target['TLS'] = true if target['TLS'].nil?