ConfigLMM 0.4.0 → 0.5.0

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

@@ -8,230 +8,183 @@ module ConfigLMM
         class LinuxApp < Framework::Plugin
 
             LINUX_FOLDER = __dir__ + '/../../../../Plugins/OS/Linux/'
-            SUSE_NAME = 'openSUSE Leap'
             SUSE_ID = 'opensuse-leap'
-            DEBIAN_NAME = 'Debian'
-            PROXMOXVE_NAME = 'Proxmox VE'
             PODMAN_PACKAGE = 'Podman'
             SYSTEMD_CONTAINERS_PATH = '~/.config/containers/systemd/'
 
+            # 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.ensurePackage(name, location, binary = nil)
+            # DEPRECATED
+            def self.ensurePackage(name, locationOrConnection, binary = nil)
                 if binary && TTY::Which.which(binary)
                     return
                 end
-                self.ensurePackages([name], location)
+                self.ensurePackages([name], locationOrConnection)
             end
 
-            def self.ensurePackages(names, locationOrSSH)
-                self.doSSH(locationOrSSH) 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
+            # DEPRECATED
+            def self.ensurePackages(names, locationOrConnection)
+                self.doConnection(locationOrConnection) do |connection|
+                    linuxConnection = LMM::LinuxConnection.new(connection)
+                    linuxConnection.ensurePackages(names)
+                    linuxConnection.distroInfo
                 end
             end
 
-            def self.removePackage(name, locationOrSSH, dry = false)
-                self.doSSH(locationOrSSH) do |ssh|
-                    distroInfo = self.currentDistroInfo(ssh)
-                    reposPackages = self.mapPackages([name], distroInfo['Name'])
-
-                    pkgs = []
-                    reposPackages.each do |pkg|
-                        if pkg.include?('|')
-                            repoName, pkg = pkg.split('|')
-                            pkgs << pkg
-                        else
-                            pkgs << pkg
-                        end
-                    end
-
-                    command = distroInfo['RemovePackage'] + ' ' + pkgs.map { |pkg| pkg.shellescape }.join(' ')
-                    if ssh
-                        self.sshExec!(ssh, command, true, dry)
-                    else
-                        if `echo $EUID`.strip == '0'
-                            if dry
-                                puts "Would execute: #{command} >/dev/null"
-                            else
-                                `#{command} >/dev/null`
-                            end
-                        else
-                            if dry
-                                puts "Would execute: sudo #{command} >/dev/null"
-                            else
-                                `sudo #{command} >/dev/null`
-                            end
-                        end
-                    end
-                    distroInfo
+            # 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 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
-                end
+            # DEPRECATED
+            def ensureServiceAutoStart(name, locationOrConnection)
+                self.class.ensureServiceAutoStart(name, locationOrConnection)
             end
 
-            def self.ensureServiceAutoStart(name, locationOrSSH)
-                self.execDistroCommand(name, 'AutoStartService', locationOrSSH)
+            # DEPRECATED
+            def self.ensureServiceAutoStart(name, locationOrConnection)
+                name = self.convertServiceName(name, locationOrConnection)
+                self.execDistroCommand(name, 'AutoStartService', locationOrConnection)
             end
 
-            # Deprecated
-            def self.ensureServiceAutoStartOverSSH(name, locationOrSSH)
-                self.ensureServiceAutoStart(name, locationOrSSH)
+            # DEPRECATED
+            def self.ensureServiceAutoStartOverSSH(name, locationOrConnection)
+                self.ensureServiceAutoStart(name, locationOrConnection)
             end
 
-            def startService(name, location, dry = false)
-                if location && location != '@me'
-                    uri = Addressable::URI.parse(location)
-                    raise Framework::PluginProcessError.new("#{id}: Unknown Protocol: #{uri.scheme}!") if uri.scheme != 'ssh'
-                    self.class.startService(name, location, dry = false)
-                else
-                    # TODO
-                end
+            # DEPRECATED
+            def startService(name, locationOrConnection, dry = false)
+                self.class.startService(name, locationOrConnection, dry = false)
             end
 
-            def self.startService(name, locationOrSSH, dry = false)
-                self.execDistroCommand(name, 'StartService', locationOrSSH, false, dry)
+            # 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, locationOrSSH, dry = false)
-                self.startService(name, locationOrSSH, dry)
+            # DEPRECATED
+            def self.startServiceOverSSH(name, locationOrConnection, dry = false)
+                name = self.convertServiceName(name, locationOrConnection)
+                self.startService(name, locationOrConnection, dry)
             end
 
-            def self.restartService(name, locationOrSSH, dry = false)
-                self.execDistroCommand(name, 'RestartService', locationOrSSH, false, dry)
+            # DEPRECATED
+            def self.restartService(name, locationOrConnection, dry = false)
+                name = self.convertServiceName(name, locationOrConnection)
+                self.execDistroCommand(name, 'RestartService', locationOrConnection, false, dry)
             end
 
-            def self.reloadService(name, locationOrSSH, dry = false)
-                self.execDistroCommand(name, 'ReloadService', locationOrSSH, false, dry)
+            # DEPRECATED
+            def self.reloadService(name, locationOrConnection, dry = false)
+                name = self.convertServiceName(name, locationOrConnection)
+                self.execDistroCommand(name, 'ReloadService', locationOrConnection, false, dry)
             end
 
-            def self.stopService(name, locationOrSSH, dry = false)
-                self.execDistroCommand(name, 'StopService', locationOrSSH, true, dry)
+            # DEPRECATED
+            def self.stopService(name, locationOrConnection, dry = false)
+                name = self.convertServiceName(name, locationOrConnection)
+                self.execDistroCommand(name, 'StopService', locationOrConnection, true, dry)
             end
 
-            def self.disableService(name, locationOrSSH, dry = false)
-                self.execDistroCommand(name, 'DisableService', locationOrSSH, true, dry)
+            # DEPRECATED
+            def self.disableService(name, locationOrConnection, dry = false)
+                name = self.convertServiceName(name, locationOrConnection)
+                self.execDistroCommand(name, 'DisableService', locationOrConnection, true, dry)
             end
 
-            def self.reloadServiceManager(locationOrSSH, dry = false)
-                self.execDistroCommand(nil, 'ReloadServiceManager', locationOrSSH, false, dry)
+            # DEPRECATED
+            def self.reloadServiceManager(locationOrConnection, dry = false)
+                self.execDistroCommand(nil, 'ReloadServiceManager', locationOrConnection, false, dry)
             end
 
-            def self.deleteUserAndGroup(name, locationOrSSH, dry = false)
-                self.execDistroCommand(name, 'DeleteUser', locationOrSSH, true, dry)
-                self.execDistroCommand(name, 'DeleteGroup', locationOrSSH, true, dry)
+            # DEPRECATED
+            def self.deleteUserAndGroup(name, locationOrConnection, dry = false)
+                self.execDistroCommand(name, 'DeleteUser', locationOrConnection, true, dry)
+                self.execDistroCommand(name, 'DeleteGroup', locationOrConnection, true, dry)
             end
 
-            def self.execDistroCommand(param, commandName, locationOrSSH, allowFailure = false, dry = false)
-                self.doSSH(locationOrSSH) do |ssh|
-                    distroInfo = self.currentDistroInfo(ssh)
+            # 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
 
-                    command = distroInfo[commandName]
-                    command += ' ' + param.shellescape unless param.nil?
-                    self.exec(command, ssh, allowFailure, dry)
+            # DEPRECATED
+            def self.convertServiceName(name, connection)
+                self.doConnection(connection) do |connection|
+                    name = LMM::LinuxConnection.new(connection).convertServiceName(name)
                 end
+                name
             end
 
-            def self.doSSH(locationOrSSH, &block)
-                if locationOrSSH.nil? || locationOrSSH == '@me'
+            def self.doConnection(locationOrConnection, &block)
+                if locationOrConnection.nil? || locationOrConnection == '@me'
                     result = block.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'
-
-                    self.sshStart(locationOrSSH) do |ssh|
-                        result = block.call(ssh)
-                    end
+                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
-                    result = block.call(locationOrSSH)
+                    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
 
-            # Deprecated
-            def self.firewallAddServiceOverSSH(serviceName, locationOrSSH)
-                self.firewallAddService(serviceName, locationOrSSH)
+            # DEPRECATED
+            def self.firewallAddServiceOverSSH(serviceName, locationOrConnection)
+                self.firewallAddService(serviceName, locationOrConnection)
             end
 
-            # Deprecated
-            def self.firewallAddPortOverSSH(portName, locationOrSSH)
-                self.firewallAddPort(portName, locationOrSSH)
+            # DEPRECATED
+            def self.firewallAddPortOverSSH(portName, locationOrConnection)
+                self.firewallAddPort(portName, locationOrConnection)
             end
 
-            def self.firewallAddService(serviceName, locationOrSSH = nil, dry = false)
-                self.doSSH(locationOrSSH) do |ssh|
-                     command = 'firewall-cmd --permanent --add-service ' + serviceName.shellescape
-                     self.exec(command, ssh, true, dry)
-                     command = 'firewall-cmd --add-service ' + serviceName.shellescape
-                     self.exec(command, ssh, true, dry)
+            # 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.firewallRemoveService(serviceName, locationOrSSH = nil, dry = false)
-                self.doSSH(locationOrSSH) do |ssh|
-                     command = 'firewall-cmd --permanent --remove-service ' + serviceName.shellescape
-                     self.exec(command, ssh, false, dry)
-                     command = 'firewall-cmd --remove-service ' + serviceName.shellescape
-                     self.exec(command, ssh, false, dry)
+            # 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.firewallAddPort(portName, locationOrSSH = nil, dry = false)
-                self.doSSH(locationOrSSH) do |ssh|
-                     command = 'firewall-cmd --permanent --add-port ' + portName.shellescape
-                     self.exec(command, ssh, true, dry)
-                     command = 'firewall-cmd --add-port ' + portName.shellescape
-                     self.exec(command, ssh, true, dry)
+            # DEPRECATED
+            def self.firewallAddPort(portName, locationOrConnection = nil, dry = false)
+                self.doConnection(locationOrConnection) do |connection|
+                    LMM::LinuxConnection.new(connection).firewallAddPort(portName, { 'dry': dry })
                 end
             end
 
-            def self.firewallRemovePort(portName, locationOrSSH = nil, dry = false)
-                self.doSSH(locationOrSSH) do |ssh|
-                     command = 'firewall-cmd --permanent --remove-port ' + portName.shellescape
-                     self.exec(command, ssh, false, dry)
-                     command = 'firewall-cmd --remove-port ' + portName.shellescape
-                     self.exec(command, ssh, false, dry)
+            # DEPRECATED
+            def self.firewallRemovePort(portName, locationOrConnection = nil, dry = false)
+                self.doConnection(locationOrConnection) do |connection|
+                    LMM::LinuxConnection.new(connection).firewallRemovePort(portName, { 'dry': dry })
                 end
             end
 
@@ -255,6 +208,7 @@ module ConfigLMM
                 names
             end
 
+            # DEPRECATED
             def self.createCertificateOverSSH(ssh)
                 dir = "/etc/letsencrypt/live/Wildcard/"
                 self.sshExec!(ssh, "mkdir -p #{dir}")
@@ -266,52 +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.sshExec!(ssh, "chmod o-rwx #{homedir}")
-                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']
 
@@ -29,6 +32,7 @@ module ConfigLMM
                 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'
 
@@ -48,46 +52,59 @@ module ConfigLMM
                 end
             end
 
-            def cleanupNginxConfig(name, id, state, context, options, ssh = nil)
-                rm('/etc/nginx/servers-lmm/' + name + '.conf', options['dry'], ssh)
+            # 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
 
-            def self.reload(ssh = nil, dry = false)
-                self.exec("systemctl reload nginx", ssh, false, dry)
+            # 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
 
-            def self.ensurePackage(ssh = nil)
-                Framework::LinuxApp.ensurePackages([NGINX_PACKAGE], ssh)
-                Framework::LinuxApp.ensureServiceAutoStartOverSSH(NGINX_PACKAGE, ssh)
+            # DEPRECATED
+            def self.ensurePackage(connection = nil)
+                Framework::LinuxApp.ensurePackages([NGINX_PACKAGE], connection)
+                Framework::LinuxApp.ensureServiceAutoStartOverSSH(NGINX_PACKAGE, connection)
             end
 
-            def useNginxProxy(dir, configName, id, target, activeState, state, context, options, ssh)
-                self.class.ensurePackage(ssh)
-                self.class.prepareNginxConfig(target, ssh)
+            # 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, ssh)
-                self.class.reload(ssh)
+                Framework::LinuxApp.startServiceOverSSH(NGINX_PACKAGE, connectionOrSSH)
+                self.class.reload(connectionOrSSH)
             end
 
-            def deployNginxProxyConfig(server, name, id, target, activeState, state, context, options, ssh)
+            # 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, ssh)
+                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?