ConfigLMM 0.4.0 → 0.5.0

data/Plugins/Apps/ERPNext/ERPNext.lmm.rb

@@ -1,37 +1,44 @@
 
 module ConfigLMM
     module LMM
-        class ERPNext < Framework::NginxApp
+        class ERPNext < Framework::Plugin
 
             USER = 'erpnext'
             HOME_DIR = '/var/lib/erpnext'
             VERSION = '15'
             FRAPPE_REPO = 'https://github.com/frappe/frappe_docker.git'
             IMAGE_ID = 'ConfigLM.moe/erpnext:v' + VERSION
+            CONTAINER_NAME = 'ERPNext'
 
             def actionERPNextBuild(id, target, activeState, context, options)
                 buildContainer(id, target, options)
             end
 
             def buildContainer(id, target, options)
-                begin
-                    Framework::LinuxApp.ensurePackage('git', '@me', 'git')
-                    Framework::LinuxApp.ensurePackage('Podman', '@me', 'podman')
-                rescue RuntimeError => error
-                    prompt.say(error, :color => :red)
-                end
-                frappe = File.expand_path(REPOS_CACHE + '/frappe_docker')
-                if !File.exist?(frappe)
-                    mkdir(File.expand_path(REPOS_CACHE), false)
-                    self.class.exec('cd #{REPOS_CACHE} && git clone --quiet #{FRAPPE_REPO}')
-                else
-                    self.class.exec('cd #{REPOS_CACHE}/frappe_docker && git pull --quiet')
-                end
-                self.class.exec('cd #{REPOS_CACHE}/frappe_docker && git checkout . --quiet')
-
-                if !self.class.cmdSuccess?("podman image exists #{IMAGE_ID}")
-                    appsJSON = Base64.urlsafe_encode64(File.read(__dir__ + '/sites/apps.json').gsub('$VERSION', VERSION))
-                    self.class.exec("cd #{REPOS_CACHE}/frappe_docker && podman build --tag=#{IMAGE_ID} --build-arg APPS_JSON_BASE64=#{appsJSON} --build-arg FRAPPE_BRANCH=version-#{VERSION}  --file images/custom/Containerfile .")
+                Linux.withConnection(local) do |localLinux|
+                    begin
+                        localLinux.ensurePackages(['git', 'Podman'], options) unless localLinux.hasBinaries?(['git', 'podman'], options)
+                    rescue RuntimeError => error
+                        prompt.say(error, :color => :red)
+                    end
+                    frappe = File.expand_path(REPOS_CACHE + '/frappe_docker')
+                    if !File.exist?(frappe)
+                        localLinux.createDirs(options, File.expand_path(REPOS_CACHE))
+                        localLinux.exec("cd #{REPOS_CACHE} && git clone --quiet #{FRAPPE_REPO}", false, options)
+                    else
+                        localLinux.exec("cd #{REPOS_CACHE}/frappe_docker && git pull --quiet", false, options)
+                    end
+                    localLinux.exec("cd #{REPOS_CACHE}/frappe_docker && git checkout . --quiet", false, options)
+
+                    if !IO::Connection.cmdSuccess?("podman image exists #{IMAGE_ID}")
+                        appsJSON = Base64.urlsafe_encode64(File.read(__dir__ + '/sites/apps.json').gsub('$VERSION', VERSION))
+                        # if you see error like "newuidmap 5227 0 1000 1 1 100000 65536: newuidmap: write to uid_map failed: Operation not permitted"
+                        # then for LXC you need to set idmap like:
+                        # LXC:
+                        #     - idmap: u 0 100000 165536
+                        #     - idmap: g 0 100000 165536
+                        localLinux.exec("cd #{REPOS_CACHE}/frappe_docker && podman build --tag=#{IMAGE_ID} --build-arg APPS_JSON_BASE64=#{appsJSON} --build-arg FRAPPE_BRANCH=version-#{VERSION}  --file images/custom/Containerfile .", false, options)
+                    end
                 end
             end
 
@@ -39,149 +46,153 @@ module ConfigLMM
                 raise Framework::PluginProcessError.new('Domain field must be set!') if (!target.key?('Proxy') || target['Proxy']) && !target['Domain']
 
                 target['Database'] ||= {}
-                if target['Location'] && target['Location'] != '@me'
-                    uri = Addressable::URI.parse(target['Location'])
-                    raise Framework::PluginProcessError.new("#{id}: Unknown Protocol: #{uri.scheme}!") if uri.scheme != 'ssh'
+                self.withConnection(target['Location'], target) do |connection|
+                    Linux.withConnection(connection) do |linuxConnection|
+
+                        dbPassword = self.configureMariaDB(target['Database'], activeState, linuxConnection, options)
 
-                    self.class.sshStart(uri) do |ssh|
+                        Podman.ensurePresent(linuxConnection, options)
+                        Podman.createUser(USER, HOME_DIR, 'ERPNext', linuxConnection, options)
 
-                        activeState['Database'] = target['Database']
-                        dbPassword = self.configureMariaDB(target['Database'], activeState, ssh)
-                        distroInfo = Framework::LinuxApp.currentDistroInfo(ssh)
-                        Framework::LinuxApp.configurePodmanServiceOverSSH(USER, HOME_DIR, 'ERPNext', distroInfo, ssh)
-                        self.class.exec("su --login #{USER} --shell /bin/sh --command 'mkdir -p ~/sites ~/logs'", ssh)
+                        cmd = IO::SSH.cmd(target['Location'])
+                        local.exec("podman image save ConfigLM.moe/erpnext:v#{VERSION} | #{cmd} 'cat > #{HOME_DIR}/erpnext.tar'", false, options)
+
+                        linuxConnection.withUserShell(USER) do |shell|
+                            shell.createDirs(options, '~/sites', '~/logs')
+                            Podman.loadImage(shell, 'erpnext.tar', options)
+                        end
 
-                        cmd = self.class.cmdSSH(uri)
-                        self.class.exec("podman image save ConfigLM.moe/erpnext:v#{VERSION} | #{cmd} 'cat > #{HOME_DIR}/erpnext.tar'")
-                        self.class.exec("su --login #{USER} --shell /usr/bin/sh --command 'podman image load --input erpnext.tar'", ssh)
-                        self.class.exec("rm -f #{HOME_DIR}/erpnext.tar", ssh)
+                        linuxConnection.exec("rm -f #{HOME_DIR}/erpnext.tar", false, options)
 
-                        path = Framework::LinuxApp::SYSTEMD_CONTAINERS_PATH.gsub('~', HOME_DIR)
-                        self.class.exec(" echo 'FRAPPE_DB_PASSWORD=#{dbPassword}' > #{path}/ERPNext.env", ssh)
-                        self.class.exec("echo 'FRAPPE_SITE_NAME_HEADER=erpnext' >> #{path}/ERPNext.env", ssh)
-                        #self.class.exec("echo 'UPSTREAM_REAL_IP_ADDRESS=127.0.0.1' >> #{path}/ERPNext.env", ssh)
-                        #self.class.exec("echo 'UPSTREAM_REAL_IP_RECURSIVE=on' >> #{path}/ERPNext.env", ssh)
-                        self.class.exec("echo 'BACKEND=10.90.50.10:8000' >> #{path}/ERPNext.env", ssh)
-                        self.class.exec("echo 'SOCKETIO=10.90.50.11:9000' >> #{path}/ERPNext.env", ssh)
+                        path = Podman.containersPath(HOME_DIR)
+                        linuxConnection.exec(" echo 'FRAPPE_DB_PASSWORD=#{dbPassword}' > #{path}/ERPNext.env", false, options)
+                        linuxConnection.exec("echo 'FRAPPE_SITE_NAME_HEADER=site' >> #{path}/ERPNext.env", false, options)
+                        #linuxConnection.exec("echo 'UPSTREAM_REAL_IP_ADDRESS=127.0.0.1' >> #{path}/ERPNext.env", false, options)
+                        #linuxConnection.exec("echo 'UPSTREAM_REAL_IP_RECURSIVE=on' >> #{path}/ERPNext.env", false, options)
+                        linuxConnection.exec("echo 'BACKEND=10.90.50.10:8000' >> #{path}/ERPNext.env", false, options)
+                        linuxConnection.exec("echo 'SOCKETIO=10.90.50.11:9000' >> #{path}/ERPNext.env", false, options)
 
-                        self.class.exec("chown #{USER}:#{USER} #{path}/ERPNext.env", ssh)
-                        self.class.exec("chmod 600 #{path}/ERPNext.env", ssh)
+                        linuxConnection.exec("chown #{USER}:#{USER} #{path}/ERPNext.env", false, options)
+                        linuxConnection.exec("chmod 600 #{path}/ERPNext.env", false, options)
 
-                        ssh.scp.upload!(__dir__ + '/sites/apps.txt', HOME_DIR + '/sites/')
-                        ssh.scp.upload!(__dir__ + '/sites/common_site_config.json', HOME_DIR + '/sites/')
+                        linuxConnection.upload(__dir__ + '/sites/apps.txt', HOME_DIR + '/sites/', options)
+                        linuxConnection.upload(__dir__ + '/sites/common_site_config.json', HOME_DIR + '/sites/', options)
 
                         if target['Database'] && target['Database']['HostName']
-                            self.class.exec("sed -i 's|\"10.0.2.2\"|\"#{target['Database']['HostName']}\"|' #{HOME_DIR}/sites/common_site_config.json", ssh)
+                            linuxConnection.exec("sed -i 's|\"10.0.2.2\"|\"#{target['Database']['HostName']}\"|' #{HOME_DIR}/sites/common_site_config.json", false, options)
                         end
 
                         if target['Valkey']
-                            self.class.exec("sed -i 's|10.0.2.2:6379|#{target['Valkey']}|' #{HOME_DIR}/sites/common_site_config.json", ssh)
+                            linuxConnection.exec("sed -i 's|10.0.2.2:6379|#{target['Valkey']}|' #{HOME_DIR}/sites/common_site_config.json", false, options)
                         end
 
-                        valkeyPassword = ENV[id + '-VALKEY_PASSWORD'] || ENV['VALKEY_PASSWORD']
-                        if valkeyPassword
-                            self.class.exec("sed -i 's|\"use_rq_auth\": false|\"use_rq_auth\": true|' #{HOME_DIR}/sites/common_site_config.json", ssh)
-                            self.class.exec("sed -i 's|$VALKEY_PASSWORD|#{valkeyPassword}|' #{HOME_DIR}/sites/common_site_config.json", ssh)
+                        if target['ValkeySecretId']
+                            valkeyPassword = context.secrets.load(target['ValkeySecretId'], 'VALKEY_PASSWORD')
+                            linuxConnection.exec("sed -i 's|\"use_rq_auth\": false|\"use_rq_auth\": true|' #{HOME_DIR}/sites/common_site_config.json", false, options)
+                            linuxConnection.exec("sed -i 's|$VALKEY_PASSWORD|#{valkeyPassword}|' #{HOME_DIR}/sites/common_site_config.json", false, { **options, hide: true })
                         end
 
-                        self.class.exec("chown -R #{USER}:#{USER} " + HOME_DIR + '/sites', ssh)
+                        linuxConnection.exec("chown -R #{USER}:#{USER} " + HOME_DIR + '/sites', false, options)
 
-                        ssh.scp.upload!(__dir__ + '/ERPNext.network', path)
-                        ssh.scp.upload!(__dir__ + '/ERPNext.container', path)
-                        ssh.scp.upload!(__dir__ + '/ERPNext-Queue.container', path)
-                        ssh.scp.upload!(__dir__ + '/ERPNext-Scheduler.container', path)
-                        ssh.scp.upload!(__dir__ + '/ERPNext-Websocket.container', path)
-                        ssh.scp.upload!(__dir__ + '/ERPNext-Frontend.container', path)
-                        self.class.exec("sed -i 's|$VERSION|#{VERSION}|' #{path}/ERPNext.container", ssh)
-                        self.class.exec("sed -i 's|$VERSION|#{VERSION}|' #{path}/ERPNext-Queue.container", ssh)
-                        self.class.exec("sed -i 's|$VERSION|#{VERSION}|' #{path}/ERPNext-Scheduler.container", ssh)
-                        self.class.exec("sed -i 's|$VERSION|#{VERSION}|' #{path}/ERPNext-Websocket.container", ssh)
-                        self.class.exec("sed -i 's|$VERSION|#{VERSION}|' #{path}/ERPNext-Frontend.container", ssh)
+                        linuxConnection.upload(__dir__ + '/ERPNext.network', path, options)
+                        linuxConnection.upload(__dir__ + '/ERPNext.container', path, options)
+                        linuxConnection.upload(__dir__ + '/ERPNext-Queue.container', path, options)
+                        linuxConnection.upload(__dir__ + '/ERPNext-Scheduler.container', path, options)
+                        linuxConnection.upload(__dir__ + '/ERPNext-Websocket.container', path, options)
+                        linuxConnection.upload(__dir__ + '/ERPNext-Frontend.container', path, options)
+                        linuxConnection.exec("sed -i 's|$VERSION|#{VERSION}|' #{path}/ERPNext.container", false, options)
+                        linuxConnection.exec("sed -i 's|$VERSION|#{VERSION}|' #{path}/ERPNext-Queue.container", false, options)
+                        linuxConnection.exec("sed -i 's|$VERSION|#{VERSION}|' #{path}/ERPNext-Scheduler.container", false, options)
+                        linuxConnection.exec("sed -i 's|$VERSION|#{VERSION}|' #{path}/ERPNext-Websocket.container", false, options)
+                        linuxConnection.exec("sed -i 's|$VERSION|#{VERSION}|' #{path}/ERPNext-Frontend.container", false, options)
 
                         if !target.key?('Proxy') || target['Proxy']
-                            deployNginxProxyConfig('http://127.0.0.1:18400', 'ERPNext', id, target, activeState, state, context, options, ssh)
+                            Nginx.withConnection(linuxConnection) do |nginxConnection|
+                                nginxConnection.provisionProxy('http://127.0.0.1:18400', 'ERPNext', target, activeState, context, options)
+                            end
                         elsif target.key?('Proxy') && target['Proxy'] == false
-                            self.class.exec("sed -i 's|PublishPort=127.0.0.1:18400:|PublishPort=0.0.0.0:18400:|' #{path}ERPNext-Frontend.container", ssh)
-                            Framework::LinuxApp.firewallAddPort('18400/tcp', ssh)
+                            linuxConnection.exec("sed -i 's|PublishPort=127.0.0.1:18400:|PublishPort=0.0.0.0:18400:|' #{path}/ERPNext-Frontend.container", false, options)
+                            linuxConnection.firewallAddPort('18400/tcp', options)
                         end
 
-                        self.class.exec("systemctl --user --machine=#{USER}@ daemon-reload", ssh)
-                        self.class.exec("systemctl --user --machine=#{USER}@ restart ERPNext-network", ssh)
-                        self.class.exec("systemctl --user --machine=#{USER}@ restart ERPNext", ssh)
-
-                        containers = JSON.parse(self.class.exec("su --login #{USER} --shell /usr/bin/sh --command 'podman ps --format json --filter name=^ERPNext$'", ssh).strip)
-                        raise 'Failed to find container!' if containers.empty?
-
-                        MariaDB.executeRemotely(target['Database'], ssh) do |sshDB|
-                            if !MariaDB.tableExist?(USER, 'tabUser', sshDB)
-                                adminPassword = SecureRandom.alphanumeric(20)
-                                self.class.exec("rm -rf " + HOME_DIR + '/sites/erpnext', ssh)
-                                #self.class.exec(" su --login #{USER} --shell /usr/bin/sh --command \"podman exec #{containers.first['Id']} sh -c 'bench new-site --no-setup-db --db-name erpnext --db-user erpnext --admin-password #{adminPassword} --install-app erpnext --set-default erpnext'\"", ssh)
-                                dbAdminPassword = MariaDB.createAdmin(sshDB)
-                                MariaDB.executeSQL("DROP DATABASE #{USER}", nil, sshDB)
-                                self.class.exec(" su --login #{USER} --shell /usr/bin/sh --command \" podman exec #{containers.first['Id']} sh -c ' bench new-site --db-root-username admin --db-root-password #{dbAdminPassword} --db-name erpnext --admin-password #{adminPassword} --install-app erpnext --set-default erpnext'\"", ssh)
-                                MariaDB.dropAdmin(sshDB)
-                                self.class.exec("su --login #{USER} --shell /usr/bin/sh --command \"podman exec #{containers.first['Id']} sh -c 'bench --site erpnext install-app hrms'\"", ssh)
-                                prompt.say("Administrator password: #{adminPassword}", :color => :magenta)
+                        linuxConnection.reloadUserServices(USER, options)
+                        linuxConnection.restartUserService(USER, 'ERPNext-network', options)
+                        linuxConnection.restartUserService(USER, 'ERPNext', options)
+
+                        MariaDB.withConnection(target['Database'], linuxConnection) do |connectionDB|
+                            if !connectionDB.tableExist?(USER, 'tabUser', { **options, 'dry': false })
+                                linuxConnection.withUserShell(USER) do |shellConnection|
+                                    Podman.withConnection(shellConnection, Podman.container(CONTAINER_NAME, shellConnection, options)) do |podmanConnection|
+                                        adminPassword = SecureRandom.alphanumeric(20)
+                                        dbAdminPassword = connectionDB.createAdmin(options)
+                                        linuxConnection.exec("rm -rf " + HOME_DIR + '/sites/erpnext', false, options)
+                                        #podmanConnection.exec("bench new-site --no-setup-db --db-name erpnext --db-user erpnext --admin-password #{adminPassword} --install-app erpnext --set-default site", false, { **options, hide: true })
+                                        connectionDB.dropDB(USER, options)
+                                        podmanConnection.exec("bench new-site --db-root-username admin --db-root-password #{dbAdminPassword} --db-name erpnext --admin-password #{adminPassword} --install-app erpnext --set-default site", false, { **options, hide: true })
+                                        podmanConnection.exec("bench --site site install-app hrms", false, options)
+                                        prompt.say("Administrator password: #{adminPassword}", :color => :magenta)
+                                        connectionDB.dropAdmin(options)
+                                    end
+                                end
                             end
                         end
 
-                        self.class.exec("systemctl --user --machine=#{USER}@ restart ERPNext-Queue", ssh)
-                        self.class.exec("systemctl --user --machine=#{USER}@ restart ERPNext-Scheduler", ssh)
-                        self.class.exec("systemctl --user --machine=#{USER}@ restart ERPNext-Websocket", ssh)
-                        self.class.exec("systemctl --user --machine=#{USER}@ restart ERPNext-Frontend", ssh)
-
-
+                        linuxConnection.restartUserService(USER, 'ERPNext-Queue', options)
+                        linuxConnection.restartUserService(USER, 'ERPNext-Scheduler', options)
+                        linuxConnection.restartUserService(USER, 'ERPNext-Websocket', options)
+                        linuxConnection.restartUserService(USER, 'ERPNext-Frontend', options)
                     end
-                else
-                    # TODO
                 end
             end
 
-            def configureMariaDB(settings, activeState, ssh)
+            def configureMariaDB(settings, activeState, linuxConnection, options)
                 password = SecureRandom.alphanumeric(20)
-                MariaDB.createRemoteUserAndDB(settings, USER, password, ssh)
+                MariaDB.withConnection(settings, linuxConnection) do |mariaConnection|
+                    mariaConnection.createUserAndDB(USER, password, nil, options)
+                end
                 password
             end
 
             def cleanup(configs, state, context, options)
-                cleanupType(:ERPNext, configs, state, context, options) do |item, id, state, context, options, ssh|
-                    if item['Proxy'].nil? || item['Proxy']
-                        self.cleanupNginxConfig('ERPNext', id, state, context, options, ssh)
-                        self.class.reload(ssh, options[:dry])
-                    end
-                    Framework::LinuxApp.firewallRemovePort('18400/tcp', ssh, options[:dry])
-
-                    self.class.exec("systemctl --user --machine=#{USER}@ stop ERPNext", ssh, true, options[:dry])
-                    self.class.exec("systemctl --user --machine=#{USER}@ stop ERPNext-Frontend", ssh, true, options[:dry])
-                    self.class.exec("systemctl --user --machine=#{USER}@ stop ERPNext-Websocket", ssh, true, options[:dry])
-                    self.class.exec("systemctl --user --machine=#{USER}@ stop ERPNext-Scheduler", ssh, true, options[:dry])
-                    self.class.exec("systemctl --user --machine=#{USER}@ stop ERPNext-Queue", ssh, true, options[:dry])
-                    self.class.exec("systemctl --user --machine=#{USER}@ stop ERPNext-network", ssh, true, options[:dry])
-
-                    path = Framework::LinuxApp::SYSTEMD_CONTAINERS_PATH.gsub('~', HOME_DIR)
-                    rm(path + 'ERPNext.network', options[:dry], ssh)
-                    rm(path + 'ERPNext.container', options[:dry], ssh)
-                    rm(path + 'ERPNext-Queue.container', options[:dry], ssh)
-                    rm(path + 'ERPNext-Scheduler.container', options[:dry], ssh)
-                    rm(path + 'ERPNext-Websocket.container', options[:dry], ssh)
-                    rm(path + 'ERPNext-Frontend.container', options[:dry], ssh)
-
-                    self.class.exec("podman rmi #{IMAGE_ID}", ssh, true, options[:dry])
-
-                    state.item(id)['Status'] = State::STATUS_DELETED unless options[:dry]
-
-                    if options[:destroy]
-                        item['Database'] ||= {}
-                        MariaDB.executeRemotely(item['Database'], ssh) do |sshDB|
-                            MariaDB.executeSQL("DROP DATABASE #{USER}", nil, sshDB, true, options[:dry])
+                cleanupType(:ERPNext, configs, state, context, options) do |item, id, state, context, options, connection|
+                    Linux.withConnection(connection) do |linuxConnection|
+                        if item['Config']['Proxy'].nil? || item['Config']['Proxy']
+                            Nginx.withConnection(linuxConnection) do |nginxConnection|
+                                nginxConnection.cleanupConfig('ERPNext', context, options)
+                                nginxConnection.reload(options)
+                            end
                         end
-                        Framework::LinuxApp.deleteUserAndGroup(USER, ssh, options[:dry])
-                        rm(HOME_DIR, options[:dry], ssh)
-                        rm('/var/log/nginx/erpnext.access.log', options[:dry], ssh)
-                        rm('/var/log/nginx/erpnext.error.log', options[:dry], ssh)
+                        linuxConnection.firewallRemovePort('18400/tcp', options)
+
+                        linuxConnection.stopUserService(USER, 'ERPNext-Frontend', options)
+                        linuxConnection.stopUserService(USER, 'ERPNext', options)
+                        linuxConnection.stopUserService(USER, 'ERPNext-Websocket', options)
+                        linuxConnection.stopUserService(USER, 'ERPNext-Scheduler', options)
+                        linuxConnection.stopUserService(USER, 'ERPNext-Queue', options)
+                        linuxConnection.stopUserService(USER, 'ERPNext-network', options)
+
+                        path = Podman.containersPath(HOME_DIR)
+                        linuxConnection.rm(path + 'ERPNext.network', options[:dry])
+                        linuxConnection.rm(path + 'ERPNext.container', options[:dry])
+                        linuxConnection.rm(path + 'ERPNext-Queue.container', options[:dry])
+                        linuxConnection.rm(path + 'ERPNext-Scheduler.container', options[:dry])
+                        linuxConnection.rm(path + 'ERPNext-Websocket.container', options[:dry])
+                        linuxConnection.rm(path + 'ERPNext-Frontend.container', options[:dry])
+
+                        linuxConnection.exec("podman rmi #{IMAGE_ID}", true, options)
+
+                        state.item(id)['Status'] = State::STATUS_DELETED unless options[:dry]
+
+                        if options[:destroy]
+                            item['Config']['Database'] ||= {}
+                            MariaDB.withConnection(item['Config']['Database'], linuxConnection) do |connectionDB|
+                                connectionDB.dropDB(USER, options)
+                            end
+                            linuxConnection.deleteUserAndGroup(USER, options)
+                            linuxConnection.rm(HOME_DIR, options[:dry])
 
-                        state.item(id)['Status'] = State::STATUS_DESTROYED unless options[:dry]
+                            state.item(id)['Status'] = State::STATUS_DESTROYED unless options[:dry]
+                        end
                     end
                 end
             end

data/Plugins/Apps/GitLab/GitLab.container

@@ -4,6 +4,7 @@ Description=GitLab container
 After=local-fs.target firewalld.service
 
 [Container]
+ContainerName=GitLab
 Image=docker.io/gitlab/gitlab-ce:latest
 PublishPort=127.0.0.1:18100:80
 PublishPort=0.0.0.0:22:22
@@ -12,7 +13,12 @@ Volume=/var/lib/gitlab/logs:/var/log/gitlab
 Volume=/var/lib/gitlab/data:/var/opt/gitlab
 Volume=/var/lib/gitlab/backups:/var/opt/gitlab/backups
 ShmSize=256M
+LogDriver=journald
 AutoUpdate=registry
 
+[Service]
+TimeoutStartSec=20min
+Restart=on-failure
+
 [Install]
 WantedBy=multi-user.target default.target

data/Plugins/Apps/GitLab/GitLab.lmm.rb

@@ -1,44 +1,46 @@
 
 module ConfigLMM
     module LMM
-        class GitLab < Framework::NginxApp
+        class GitLab < Framework::Plugin
 
             HOME_DIR = '/var/lib/gitlab'
             IMAGE_ID = 'docker.io/gitlab/gitlab-ce:latest'
 
             def actionGitLabDeploy(id, target, activeState, context, options)
+                raise Framework::PluginProcessError.new('Domain field must be set!') unless target['Domain']
 
-                if target['Location'] && target['Location'] != '@me'
-                    uri = Addressable::URI.parse(target['Location'])
-                    raise Framework::PluginProcessError.new("#{id}: Unknown Protocol: #{uri.scheme}!") if uri.scheme != 'ssh'
+                self.withConnection(target['Location'], target) do |connection|
+                    Linux.withConnection(connection) do |linuxConnection|
 
-                    self.class.sshStart(uri) do |ssh|
-                        self.prepareConfig(target, ssh)
-
-                        distroInfo = Framework::LinuxApp.currentDistroInfo(ssh)
-                        self.class.exec("mkdir -p #{HOME_DIR}/config", ssh)
-                        self.class.exec("mkdir -p #{HOME_DIR}/logs", ssh)
-                        self.class.exec("mkdir -p #{HOME_DIR}/data", ssh)
-                        self.class.exec("mkdir -p #{HOME_DIR}/backups", ssh)
+                        linuxConnection.createDirs(options, "#{HOME_DIR}/config", "#{HOME_DIR}/logs", "#{HOME_DIR}/data", "#{HOME_DIR}/backups")
 
                         path = '/etc/containers/systemd'
-                        ssh.scp.upload!(__dir__ + '/GitLab.container', path)
+                        linuxConnection.upload(__dir__ + '/GitLab.container', path, options)
 
                         if !target.key?('Proxy') || target['Proxy']
-                            deployNginxProxyConfig('http://127.0.0.1:18100', 'GitLab', id, target, activeState, state, context, options, ssh)
+                            Nginx.withConnection(linuxConnection) do |nginxConnection|
+                                nginxConnection.provisionProxy('http://127.0.0.1:18100', 'GitLab', target, activeState, context, options)
+                            end
                         elsif target.key?('Proxy') && target['Proxy'] == false
-                            self.class.exec("sed -i 's|PublishPort=127.0.0.1:18100:|PublishPort=0.0.0.0:18100:|' #{path}/GitLab.container", ssh)
-                            Framework::LinuxApp.firewallAddPort('18100/tcp', ssh)
+                            linuxConnection.fileReplace("#{path}/GitLab.container", 'PublishPort=127.0.0.1:18100:', 'PublishPort=0.0.0.0:18100:', options)
+                            linuxConnection.firewallAddPort('18100/tcp', options)
                         end
 
-                        Framework::LinuxApp.reloadServiceManager(ssh)
-                        Framework::LinuxApp.restartService('GitLab', ssh)
+                        linuxConnection.reloadServiceManager(options)
+                        linuxConnection.restartService('GitLab', options)
 
                         configFile = HOME_DIR + '/config/gitlab.rb'
-                        while !self.class.remoteFilePresent?(configFile, ssh)
-                            sleep(2)
+                        if options['dry']
+                            linuxConnection.filePresent?(configFile, options)
+                        else
+                            counter = 200
+                            while !linuxConnection.filePresent?(configFile, options)
+                                counter -= 1
+                                raise "Timeout while waiting for #{configFile}!" if counter <= 0
+                                sleep(2)
+                            end
                         end
-                        updateRemoteFile(ssh, configFile, options, true) do |fileLines|
+                        linuxConnection.updateFile(configFile, options, true) do |fileLines|
                             fileLines << "external_url 'https://#{target['Domain']}'\n"
                             fileLines << "letsencrypt['enable'] = false\n"
                             fileLines << "nginx['listen_port'] = 80\n"
@@ -48,9 +50,9 @@ module ConfigLMM
                             fileLines << "mattermost_nginx['listen_port'] = 80\n"
                             fileLines << "mattermost_nginx['listen_https'] = false\n"
                             if target['SMTP']
-                                fileLines << "gitlab_rails['smtp_address'] = '#{target['SMTP']['HostName']}'\n"
+                                fileLines << "gitlab_rails['smtp_address'] = '#{target['SMTP']['Host']}'\n"
                                 fileLines << "gitlab_rails['smtp_port'] = '#{target['SMTP']['Port']}'\n"
-                                fileLines << "gitlab_rails['smtp_user_name'] = '#{target['SMTP']['User']}'\n"
+                                fileLines << "gitlab_rails['smtp_user_name'] = '#{target['SMTP']['Username']}'\n"
                                 if target['SMTP']['TLS']
                                     fileLines << "gitlab_rails['smtp_tls'] = true\n"
                                     fileLines << "gitlab_rails['smtp_openssl_verify_mode'] = 'peer'\n"
@@ -58,37 +60,29 @@ module ConfigLMM
                             end
                         end
 
-                        Framework::LinuxApp.restartService('GitLab', ssh)
+                        linuxConnection.restartService('GitLab', options)
                     end
-                else
-                    # TODO
                 end
-                activeState['Status'] = State::STATUS_DEPLOYED
-            end
-
-            def prepareConfig(target, ssh)
-              raise Framework::PluginProcessError.new('Domain field must be set!') unless target['Domain']
-
-              Framework::LinuxApp.ensurePackages([NGINX_PACKAGE], ssh)
-              self.class.prepareNginxConfig(target, ssh)
             end
 
             def cleanup(configs, state, context, options)
-                cleanupType(:GitLab, configs, state, context, options) do |item, id, state, context, options, ssh|
-                    if item['Proxy'].nil? || item['Proxy']
-                        self.cleanupNginxConfig('GitLab', id, state, context, options, ssh)
-                        self.class.reload(ssh, options[:dry])
-                    end
-                    Framework::LinuxApp.firewallRemovePort('18100/tcp', ssh, options[:dry])
-                    Framework::LinuxApp.stopService('GitLab', ssh, options[:dry])
-                    rm('/etc/containers/systemd/GitLab.container', options[:dry], ssh)
-                    self.class.exec("podman rmi #{IMAGE_ID}", ssh, true, options[:dry])
-                    state.item(id)['Status'] = State::STATUS_DELETED unless options[:dry]
-                    if options[:destroy]
-                        rm('/var/lib/gitlab', options[:dry], ssh)
-                        rm('/var/log/nginx/gitlab.access.log', options[:dry], ssh)
-                        rm('/var/log/nginx/gitlab.error.log', options[:dry], ssh)
-                        state.item(id)['Status'] = State::STATUS_DESTROYED unless options[:dry]
+                cleanupType(:GitLab, configs, state, context, options) do |item, id, state, context, options, connection|
+                    Linux.withConnection(connection) do |linuxConnection|
+                        if item['Config']['Proxy'].nil? || item['Config']['Proxy']
+                            Nginx.withConnection(linuxConnection) do |nginxConnection|
+                                nginxConnection.cleanupConfig('GitLab', context, options)
+                                nginxConnection.reload(options)
+                            end
+                        end
+                        linuxConnection.firewallRemovePort('18100/tcp', options)
+                        linuxConnection.stopService('GitLab', options)
+                        linuxConnection.rm('/etc/containers/systemd/GitLab.container', options[:dry])
+                        linuxConnection.exec("podman rmi #{IMAGE_ID}", true, options)
+                        state.item(id)['Status'] = State::STATUS_DELETED unless options[:dry]
+                        if options[:destroy]
+                            connection.rm('/var/lib/gitlab', options[:dry])
+                            state.item(id)['Status'] = State::STATUS_DESTROYED unless options[:dry]
+                        end
                     end
                 end
             end

data/Plugins/Apps/Homepage/Homepage.conf.erb

@@ -0,0 +1,86 @@
+
+server {
+
+    <% if config['NginxVersion'] >= 1.25 %>
+        <% if !config['TLS'] %>
+            listen       <%= config['Port'] %>;
+            listen  [::]:<%= config['Port'] %>;
+        <% else %>
+            listen       <%= config['Port'] %> ssl;
+            listen  [::]:<%= config['Port'] %> ssl;
+
+            include config-lmm/ssl.conf;
+        <% end %>
+        http2 on;
+        http3 on;
+        quic_retry on;
+        add_header Alt-Svc 'h3=":443"; ma=86400';
+    <% else %>
+        <% if !config['TLS'] %>
+            listen       <%= config['Port'] %>;
+            listen  [::]:<%= config['Port'] %>;
+        <% else %>
+            listen       <%= config['Port'] %> ssl http2;
+            listen  [::]:<%= config['Port'] %> ssl http2;
+
+            include config-lmm/ssl.conf;
+        <% end %>
+    <% end %>
+
+    server_name <%= config['Domain'] %>;
+
+    <% if config['AuthentikDomain'].nil? %>
+        include config-lmm/private.conf;
+    <% end %>
+
+    include config-lmm/errors.conf;
+
+    <% if config['CertName'] %>
+        ssl_certificate "/etc/letsencrypt/live/<%= config['CertName'] %>/fullchain.pem";
+        ssl_certificate_key "/etc/letsencrypt/live/<%= config['CertName'] %>/privkey.pem";
+        ssl_trusted_certificate "/etc/letsencrypt/live/<%= config['CertName'] %>/chain.pem";
+    <% end %>
+
+    location / {
+        proxy_pass <%= config['Server'] %>;
+
+        <% if config['AuthentikDomain'] %>
+            error_page       401 = @authenticate;
+            include config-lmm/errors.conf;
+
+            auth_request     /outpost.goauthentik.io/auth/nginx;
+
+            # translate headers from the outposts back to the actual upstream
+            auth_request_set $authentik_username $upstream_http_x_authentik_username;
+            auth_request_set $authentik_groups $upstream_http_x_authentik_groups;
+            auth_request_set $authentik_email $upstream_http_x_authentik_email;
+            auth_request_set $authentik_name $upstream_http_x_authentik_name;
+            auth_request_set $authentik_uid $upstream_http_x_authentik_uid;
+
+            proxy_set_header REMOTE_USER $authentik_username;
+            proxy_set_header REMOTE_GROUPS $authentik_groups;
+            proxy_set_header REMOTE_EMAIL $authentik_email;
+            proxy_set_header REMOTE_NAME $authentik_name;
+            proxy_set_header REMOTE_UID $authentik_uid;
+        <% end %>
+
+        include config-lmm/proxy.conf;
+    }
+
+    <% if config['AuthentikDomain'] %>
+        location /outpost.goauthentik.io {
+            proxy_pass              https://<%= config['AuthentikDomain'] %>/outpost.goauthentik.io;
+            proxy_ssl_protocols     TLSv1.2 TLSv1.3;
+            proxy_set_header        X-Authentik-Host $host;
+            proxy_set_header        X-Original-URL $scheme://$http_host$request_uri;
+            proxy_pass_request_body off;
+            proxy_set_header        Content-Length "";
+        }
+
+        location @authenticate {
+            internal;
+            return 302 /outpost.goauthentik.io/start?rd=$request_uri;
+        }
+    <% end %>
+}
+

data/Plugins/Apps/Homepage/Homepage.container

@@ -0,0 +1,19 @@
+
+[Unit]
+Description=Homepage container
+After=local-fs.target
+
+[Container]
+ContainerName=Homepage
+Image=ghcr.io/gethomepage/homepage:latest
+PublishPort=127.0.0.1:13400:3000
+LogDriver=journald
+AutoUpdate=registry
+Volume=/var/lib/homepage/config:/app/config
+
+[Service]
+TimeoutStartSec=3min
+Restart=on-failure
+
+[Install]
+WantedBy=multi-user.target default.target