ConfigLMM 0.4.0 → 0.5.0

data/Plugins/Apps/YaCy/YaCy.conf.erb

@@ -0,0 +1,93 @@
+
+upstream yacy {
+    <% if config['Server'] %>
+        server <%= config['Server'] %>;
+    <% else %>
+        server 127.0.0.1:8090;
+    <% end %>
+}
+
+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['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 %>
+
+    <% if config['Private'] && config['Private'] != 'partial' %>
+        include config-lmm/private.conf;
+    <% end %>
+
+    include config-lmm/errors.conf;
+
+    <% if config['Private'] == 'partial' %>
+        # YaCy exposes a lot of functionality and hence big attack surface
+        # it can be useful to limit it
+
+        location = / {
+           return 403;
+        }
+
+        location / {
+            include config-lmm/private.conf;
+
+            proxy_pass http://yacy;
+            include config-lmm/proxy.conf;
+        }
+
+        location = /seed.txt {
+            proxy_pass http://yacy/seed.txt;
+            include config-lmm/proxy.conf;
+        }
+
+        location /yacy {
+            proxy_pass http://yacy;
+            include config-lmm/proxy.conf;
+        }
+
+        location /solr {
+            proxy_pass http://yacy;
+            include config-lmm/proxy.conf;
+        }
+
+        location /p2p {
+            proxy_pass http://yacy;
+            include config-lmm/proxy.conf;
+        }
+    <% else %>
+        location / {
+            proxy_pass http://yacy;
+            include config-lmm/proxy.conf;
+        }
+    <% end %>
+
+}

data/Plugins/Apps/YaCy/YaCy.container

@@ -0,0 +1,21 @@
+
+[Unit]
+Description=YaCy container
+After=local-fs.target
+
+[Container]
+ContainerName=YaCy
+Image=docker.io/yacy/yacy_search_server:latest
+EnvironmentFile=/var/lib/yacy/.config/containers/systemd/YaCy.env
+PublishPort=127.0.0.1:8090:8090
+UserNS=keep-id:uid=107,gid=113
+Volume=/var/lib/yacy/DATA:/opt/yacy_search_server/DATA
+LogDriver=journald
+AutoUpdate=registry
+
+[Service]
+TimeoutStartSec=6min
+Restart=on-failure
+
+[Install]
+WantedBy=multi-user.target default.target

data/Plugins/Apps/YaCy/YaCy.lmm.rb

@@ -0,0 +1,160 @@
+require 'digest'
+
+module ConfigLMM
+    module LMM
+        class YaCy < Framework::Plugin
+
+            USER = 'yacy'
+            HOME_DIR = '/var/lib/yacy'
+            PORT = 8090
+
+            def actionYaCyDeploy(id, target, activeState, context, options)
+                self.withConnection(target['Location'], target) do |connection|
+                    Linux.withConnection(connection) do |linuxConnection|
+                        if !target.key?('Proxy') || target['Proxy'] == false
+                            deployYaCyService(linuxConnection, target, activeState, context, options)
+                        end
+
+                        deployYaCyProxy(linuxConnection, target, activeState, context, options)
+
+                        if !target.key?('Proxy') || target['Proxy'] == false
+                            linuxConnection.reloadUserServices(USER, options)
+                            linuxConnection.restartUserService(USER, 'YaCy', options)
+                        end
+                    end
+                end
+            end
+
+            def deployYaCyService(linuxConnection, target, activeState, context, options)
+                Podman.ensurePresent(linuxConnection, options)
+                Podman.createUser(USER, HOME_DIR, 'YaCy', linuxConnection, options)
+                linuxConnection.withUserShell(USER) do |shell|
+                    shell.createDirs(options, '~/DATA')
+                end
+
+                path = Podman.containersPath(HOME_DIR)
+
+                linuxConnection.fileWrite("#{path}/YaCy.env", '', options)
+
+                linuxConnection.setUserGroup("#{path}/YaCy.env", USER, USER, options)
+                linuxConnection.setPrivate("#{path}/YaCy.env", options)
+
+                linuxConnection.upload(__dir__ + '/YaCy.container', path, options)
+
+                linuxConnection.reloadUserServices(USER, options)
+
+                configMissing = !linuxConnection.filePresent?("#{HOME_DIR}/DATA/SETTINGS/yacy.conf", { **options, 'dry': false })
+
+                linuxConnection.restartUserService(USER, 'YaCy', options) if configMissing
+
+                linuxConnection.stopUserService(USER, 'YaCy', options)
+
+                settings = target['Settings'].to_h
+                settings['remotesearch.https.preferred'] = true if settings['remotesearch.https.preferred'] != false
+                settings['network.unit.protocol.https.preferred'] = true if settings['network.unit.protocol.https.preferred'] != false
+                settings['upnp.enabled'] = false if settings['upnp.enabled'] != true
+                settings['browserPopUpTrigger'] = false if settings['browserPopUpTrigger'] != false
+                settings['seedFilePath'] = '/opt/yacy_search_server/DATA/HTDOCS/seed.txt' unless settings['seedFilePath']
+
+                settings['adminAccountUserName'] = nil
+                settings['adminRealm'] = nil
+
+                if !target['Admin'].to_h.empty?
+                    settings['adminAccountUserName'] = target['Admin']['Username']
+                    settings['adminRealm'] = target['Admin']['Realm']
+                end
+
+                if !settings['adminAccountUserName']
+                    settings['adminAccountUserName'] = linuxConnection.exec("grep '^adminAccountUserName=' '#{HOME_DIR}/DATA/SETTINGS/yacy.conf' | cut -d= -f2").strip
+                end
+
+                if !settings['adminRealm']
+                    settings['adminRealm'] = linuxConnection.exec("grep '^adminRealm=' '#{HOME_DIR}/DATA/SETTINGS/yacy.conf' | cut -d= -f2").strip
+                end
+
+                adminPassword = context.secrets.load(target['SecretId'], 'ADMIN_PASSWORD')
+                if !adminPassword
+                    adminPassword = SecureRandom.alphanumeric(30)
+                    if !options['dry']
+                        context.secrets.store(target['SecretId'], 'ADMIN_PASSWORD', adminPassword)
+                        context.secrets.print("YaCy Admin '#{settings['adminAccountUserName']}' password", adminPassword)
+                    end
+                end
+
+                settings['adminAccountBase64MD5'] = 'MD5:' + Digest::MD5.hexdigest("#{settings['adminAccountUserName']}:#{settings['adminRealm']}:#{adminPassword}")
+
+                settings.each do |name, value|
+                    hide = name == 'adminAccountBase64MD5'
+                    linuxConnection.fileReplace("#{HOME_DIR}/DATA/SETTINGS/yacy.conf", "^#{name}=.*", "#{name}=#{value}", { **options, hide: hide })
+                end
+
+                target['Profile'].to_h.each do |name, value|
+                    linuxConnection.fileReplace("#{HOME_DIR}/DATA/SETTINGS/profile.txt", "^#{name}=.*", "#{name}=#{value.gsub(':', '\\:')}", options)
+                end
+
+                if settings['staticIP']
+                    linuxConnection.fileReplace("#{HOME_DIR}/DATA/INDEX/freeworld/NETWORK/mySeed.txt", "IP=[^,]*,", "IP=#{settings['staticIP']},", options)
+                end
+
+                if target['PeerName']
+                    linuxConnection.fileReplace("#{HOME_DIR}/DATA/INDEX/freeworld/NETWORK/mySeed.txt", "Name=[^,]*,", "Name=#{target['PeerName']},", options)
+                end
+
+                if target['SeedURL']
+                    linuxConnection.fileReplace("#{HOME_DIR}/DATA/INDEX/freeworld/NETWORK/mySeed.txt", "seedURL=[^,]*,", "seedURL=#{target['SeedURL']},", options)
+                end
+
+                settings['adminAccountBase64MD5'] = '<REDACTED>'
+            end
+
+            def deployYaCyProxy(linuxConnection, target, activeState, context, options)
+                if !target.key?('Proxy') || target['Proxy']
+                    raise Framework::PluginProcessError.new('Domain field must be set!') if !target['Domain'] && (!target.key?('Proxy') || target['Proxy'])
+                    Nginx.withConnection(linuxConnection) do |nginxConnection|
+                        target['Server'] = '127.0.0.1:' + PORT.to_s unless target['Server']
+                        target['Server'] += ':'  + PORT.to_s unless target['Server'].include?(':')
+                        nginxConnection.writeConfig(__dir__, 'YaCy', target, activeState, context, options)
+                        nginxConnection.deployAllConfigs(target, activeState, context, options)
+                    end
+                elsif target.key?('Proxy') && target['Proxy'] == false
+                    path = Podman.containersPath(HOME_DIR)
+                    linuxConnection.fileReplace("#{path}/YaCy.container", 'PublishPort=127.0.0.1:', 'PublishPort=0.0.0.0:', options)
+                    linuxConnection.firewallAddPort("#{PORT}/tcp", options)
+                end
+            end
+
+            def cleanup(configs, state, context, options)
+                cleanupType(:YaCy, configs, state, context, options) do |item, id, state, context, options, connection|
+                    Linux.withConnection(connection) do |linuxConnection|
+
+                        if !item['Config'].key?('Proxy') || item['Config']['Proxy']
+                            Nginx.withConnection(linuxConnection) do |nginxConnection|
+                                nginxConnection.cleanupConfig('YaCy', context, options)
+                                nginxConnection.reload(options)
+                            end
+                        elsif item['Config'].key?('Proxy') && item['Config']['Proxy'] == false
+                            linuxConnection.firewallRemovePort("#{PORT}/tcp", options)
+                        end
+
+                        if !target.key?('Proxy') || target['Proxy'] == false
+                            linuxConnection.stopUserService(USER, 'YaCy', options)
+
+                            path = Podman.containersPath(HOME_DIR)
+                            linuxConnection.rm(path + '/YaCy.container', options[:dry])
+
+                            state.item(id)['Status'] = State::STATUS_DELETED unless options[:dry]
+
+                            if options[:destroy]
+                                linuxConnection.deleteUserAndGroup(USER, options)
+                                state.item(id)['Status'] = State::STATUS_DESTROYED unless options[:dry]
+                            end
+                        else
+                            state.item(id)['Status'] = options[:destroy] ? State::STATUS_DESTROYED : State::STATUS_DELETED unless options[:dry]
+                        end
+                    end
+                end
+            end
+
+        end
+    end
+end

data/Plugins/Apps/ZooKeeper/ZooKeeper.container

@@ -0,0 +1,24 @@
+
+[Unit]
+Description=Apache ZooKeeper container
+After=local-fs.target
+
+[Container]
+ContainerName=ZooKeeper
+Image=docker.io/bitnami/zookeeper:latest
+EnvironmentFile=/var/lib/zookeeper/.config/containers/systemd/ZooKeeper.env
+PublishPort=127.0.0.1:2181:2181
+PublishPort=127.0.0.1:2888:2888
+PublishPort=127.0.0.1:3888:3888
+PublishPort=127.0.0.1:18500:8080
+UserNS=keep-id:uid=1001,gid=1001
+Volume=/var/lib/zookeeper/data:/bitnami/zookeeper/data
+LogDriver=journald
+AutoUpdate=registry
+
+[Service]
+TimeoutStartSec=6min
+Restart=on-failure
+
+[Install]
+WantedBy=multi-user.target default.target

data/Plugins/Apps/ZooKeeper/ZooKeeper.lmm.rb

@@ -0,0 +1,68 @@
+
+module ConfigLMM
+    module LMM
+        class ZooKeeper < Framework::Plugin
+
+            USER = 'zookeeper'
+            HOME_DIR = '/var/lib/zookeeper'
+            SERVICE_NAME = 'ZooKeeper'
+
+            def actionZooKeeperDeploy(id, target, activeState, context, options)
+                self.withConnection(target['Location'], target) do |connection|
+                    Linux.withConnection(connection) do |linuxConnection|
+                        Podman.ensurePresent(linuxConnection, options)
+                        Podman.createUser(USER, HOME_DIR, 'ZooKeeper', linuxConnection, options)
+                        linuxConnection.withUserShell(USER) do |shell|
+                            shell.createDirs(options, '~/data')
+                        end
+
+                        username = target['Username'] || context.secrets.load(target['SecretId'], 'USERNAME') || 'zookeeper'
+                        context.secrets.store(target['SecretId'], 'USERNAME', username)
+                        password = context.secrets.load(target['SecretId'], 'PASSWORD')
+                        if password.nil?
+                            password = SecureRandom.alphanumeric(20)
+                            context.secrets.store(target['SecretId'], 'PASSWORD', password)
+                            context.secrets.print("#{username} password", password)
+                        end
+
+                        path = Podman.containersPath(HOME_DIR)
+                        linuxConnection.fileWrite("#{path}/ZooKeeper.env", 'ZOO_ENABLE_AUTH=yes', options)
+                        linuxConnection.fileAppend("#{path}/ZooKeeper.env", 'ZOO_AUTOPURGE_INTERVAL=1', options)
+
+                        if target['ServerID']
+                            linuxConnection.fileAppend("#{path}/ZooKeeper.env", "ZOO_SERVER_ID=#{target['ServerID']}", options)
+                        end
+
+                        linuxConnection.fileAppend("#{path}/ZooKeeper.env", "ZOO_SERVER_USERS=#{username}", options)
+                        linuxConnection.fileAppend("#{path}/ZooKeeper.env", "ZOO_SERVER_PASSWORDS=#{password}", { **options, hide: true })
+                        linuxConnection.setUserGroup("#{path}/ZooKeeper.env", USER, USER, options)
+                        linuxConnection.setPrivate("#{path}/ZooKeeper.env", options)
+
+                        linuxConnection.upload(__dir__ + '/ZooKeeper.container', path, options)
+                        linuxConnection.reloadUserServices(USER, options)
+                        linuxConnection.restartUserService(USER, SERVICE_NAME, options)
+                    end
+                end
+            end
+
+            def cleanup(configs, state, context, options)
+                cleanupType(:ZooKeeper, configs, state, context, options) do |item, id, state, context, options, connection|
+                    Linux.withConnection(connection) do |linuxConnection|
+                        linuxConnection.stopUserService(USER, SERVICE_NAME, options)
+
+                        path = Podman.containersPath(HOME_DIR)
+                        linuxConnection.rm("#{path}/ZooKeeper.container", options[:dry])
+
+                        state.item(id)['Status'] = State::STATUS_DELETED unless options[:dry]
+
+                        if options[:destroy]
+                            linuxConnection.deleteUserAndGroup(USER, options)
+                            state.item(id)['Status'] = State::STATUS_DESTROYED unless options[:dry]
+                        end
+                    end
+                end
+            end
+
+        end
+    end
+end

data/Plugins/Apps/bitmagnet/bitmagnet.conf.erb

@@ -16,9 +16,6 @@ server {
 
     server_name <%= config['Domain'] %>;
 
-    access_log  /var/log/nginx/bitmagnet.access.log;
-    error_log   /var/log/nginx/bitmagnet.error.log;
-
     include config-lmm/private.conf;
     include config-lmm/errors.conf;
 

data/Plugins/Apps/bitmagnet/bitmagnet.lmm.rb

@@ -10,7 +10,6 @@ module ConfigLMM
             def actionBitmagnetDeploy(id, target, activeState, context, options)
                 if !target['Location'] || target['Location'] == '@me'
                     deployNginxConfig(id, target, activeState, context, options)
-                    activeState['Location'] = '@me'
                 end
             end
 

data/Plugins/Apps/gollum/gollum.conf.erb

@@ -33,14 +33,11 @@ server {
         root               <%= config['Root'] %>;
     <% end %>
 
-    access_log  /var/log/nginx/gollum.access.log;
-    error_log   /var/log/nginx/gollum.error.log;
-
     <% if config['AuthentikDomain'].nil? %>
         include config-lmm/private.conf;
     <% end %>
 
-    include config-lmm/errors.conf;
+    include config-lmm/gateway-errors.conf;
 
     <% if config['CertName'] %>
         ssl_certificate "/etc/letsencrypt/live/<%= config['CertName'] %>/fullchain.pem";
@@ -93,6 +90,7 @@ server {
         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 "";

data/Plugins/Apps/gollum/gollum.container

@@ -3,13 +3,19 @@ Description=gollum container
 After=local-fs.target
 
 [Container]
+ContainerName=gollum
 Image=docker.io/gollumwiki/gollum:master
 Exec=--config=/config/config.rb
 PublishPort=0.0.0.0:14567:4567
 UserNS=keep-id:uid=1000,gid=1000
 Volume=/srv/gollum/repo:/wiki
 Volume=/srv/gollum/config:/config
+LogDriver=journald
 AutoUpdate=registry
 
+[Service]
+TimeoutStartSec=6min
+Restart=on-failure
+
 [Install]
 WantedBy=multi-user.target default.target

data/Plugins/Apps/gollum/gollum.lmm.rb

@@ -1,7 +1,7 @@
 
 module ConfigLMM
     module LMM
-        class Gollum < Framework::NginxApp
+        class Gollum < Framework::Plugin
 
             NAME = 'gollum'
             USER = 'gollum'
@@ -9,11 +9,13 @@ module ConfigLMM
             GOLLUM_PORT = '14567'
 
             def actionGollumBuild(id, target, activeState, context, options)
-                writeNginxConfig(__dir__, NAME, id, target, activeState, context, options)
+                Nginx.withConnection(local) do |nginxConnection|
+                    nginxConnection.writeConfig(__dir__, NAME, target, state, context, options)
+                end
                 targetDir = options['output'] + GOLLUM_PATH
-                mkdir(targetDir + '/config', options['dry'])
-                copy(__dir__ + '/config.ru', targetDir, options['dry'])
-                `git init #{targetDir}/repo`
+                local.mkdir(targetDir + '/config', options['dry'])
+                local.copy(__dir__ + '/config.ru', targetDir, options['dry'])
+                local.exec("git init #{targetDir}/repo", options)
             end
 
             def actionGollumRefresh(id, target, activeState, context, options)
@@ -21,65 +23,64 @@ module ConfigLMM
             end
 
             def actionGollumDeploy(id, target, activeState, context, options)
-                if target['Location'] && target['Location'] != '@me'
-                    uri = Addressable::URI.parse(target['Location'])
-                    self.class.sshStart(uri) do |ssh|
+                self.withConnection(target['Location'], target) do |connection|
+                    Linux.withConnection(connection) do |linuxConnection|
                         if !target.key?('Proxy') || !!target['Proxy']
-                            self.class.prepareNginxConfig(target, ssh)
-                            if !target['Root']
-                                gollumPath = ssh.exec!('gem which gollum').strip
-                                target['Root'] = File.dirname(gollumPath) + '/gollum/public'
+                            #if !target['Root']
+                            #    gollumPath = linuxConnection.exec('gem which gollum', true).strip
+                            #    target['Root'] = File.dirname(gollumPath) + '/gollum/public'
+                            #end
+
+                            Nginx.withConnection(linuxConnection) do |nginxConnection|
+                                target['ConfigName'] = target['Name']
+                                nginxConnection.provision(__dir__, NAME, target, activeState, context, options)
                             end
-                            writeNginxConfig(__dir__, NAME, id, target, state, context, options)
-                            deployNginxConfig(id, target, activeState, context, options)
                         end
                         if !target.key?('Proxy') || target['Proxy'] != 'only'
-                            distroInfo = Framework::LinuxApp.currentDistroInfo(ssh)
-                            Framework::LinuxApp.configurePodmanServiceOverSSH(USER, GOLLUM_PATH, 'gollum', distroInfo, ssh)
-                            if target['Config']
-                                `cp #{target['Config']} #{options['output'] + GOLLUM_PATH}/config/config.rb`
+                            Podman.ensurePresent(linuxConnection, options)
+                            Podman.createUser(USER, GOLLUM_PATH, 'gollum', linuxConnection, options)
+                            linuxConnection.withUserShell(USER) do |shell|
+                                shell.createDirs(options, '~/data')
+                            end
+
+                            if !linuxConnection.filePresent?(GOLLUM_PATH, options)
+                                if target['Config']
+                                    local.copy(target['Config'], "#{options['output'] + GOLLUM_PATH}/config/config.rb", options['dry'])
+                                else
+                                    local.fileWrite(options['output'] + GOLLUM_PATH + "/config/config.rb", '', options['dry'])
+                                end
+                                linuxConnection.uploadFolder(options['output'] + GOLLUM_PATH, '/srv', options)
                             else
-                                `touch #{options['output'] + GOLLUM_PATH}/config/config.rb`
+                                if target['Config']
+                                    linuxConnection.upload(target['Config'], "#{GOLLUM_PATH}/config/config.rb", options)
+                                end
                             end
-                            self.class.uploadFolder(options['output'] + GOLLUM_PATH, '/srv', ssh)
-                            path = Framework::LinuxApp::SYSTEMD_CONTAINERS_PATH.gsub('~', GOLLUM_PATH)
-                            ssh.scp.upload!(__dir__ + '/gollum.container', path)
-                            self.class.sshExec!(ssh, "chown -R #{USER}:#{USER} #{GOLLUM_PATH}")
-                            self.class.sshExec!(ssh, "systemctl --user --machine=#{USER}@ daemon-reload")
-                            self.class.sshExec!(ssh, "systemctl --user --machine=#{USER}@ restart gollum")
+
+                            path = Podman.containersPath(GOLLUM_PATH)
+                            linuxConnection.upload(__dir__ + '/gollum.container', path, options)
+
+                            linuxConnection.setUserGroup(GOLLUM_PATH, USER, USER, options)
+                            linuxConnection.reloadUserServices(USER, options)
+                            linuxConnection.restartUserService(USER, 'gollum', options)
                             if target['Proxy'] != 'only'
-                                Framework::LinuxApp.firewallAddPortOverSSH(GOLLUM_PORT + '/tcp', ssh)
+                                linuxConnection.firewallAddPort(GOLLUM_PORT + '/tcp', options)
                             end
                         end
                     end
-                else
-                    targetDir = GOLLUM_PATH
-                    mkdir(targetDir, options['dry'])
-                    if !target.key?('Proxy') || !!target['Proxy']
-                        self.class.prepareNginxConfig(target)
-                        if !target['Root']
-                            target['Root'] = File.dirname(`gem which gollum`.strip) + '/gollum/public'
-                        end
-                        writeNginxConfig(__dir__, NAME, id, target, state, context, options)
-                        deployNginxConfig(id, target, activeState, context, options)
-                    end
-                    if !target.key?('Proxy') || target['Proxy'] != 'only'
-                        copy(options['output'] + GOLLUM_PATH + '/config.ru', GOLLUM_PATH, options['dry'])
-                        copyNotPresent(options['output'] + GOLLUM_PATH + '/repo', GOLLUM_PATH, options['dry'])
-                        chown('http', 'http', GOLLUM_PATH, options['dry'])
-                    end
-                    activeState['Location'] = '@me'
                 end
             end
 
             def cleanup(configs, state, context, options)
-                items = state.selectType(:Gollum)
-                items.each do |id, item|
-                    if !configs.key?(id)
-                        if item['Location'] == '@me'
-                            cleanupNginxConfig(NAME, id, state, context, options)
-                        else
-                            # TODO
+                cleanupType(:Gollum, configs, state, context, options) do |item, id, state, context, options, connection|
+                    if !item['Config'].key?('Proxy') || !!item['Config']['Proxy']
+                        Linux.withConnection(connection) do |linuxConnection|
+                            Nginx.withConnection(linuxConnection) do |nginxConnection|
+                                configName = NAME
+                                configName = item['Config']['ConfigName'] if item['Config']['ConfigName']
+                                nginxConnection.cleanupConfig(configName, context, options)
+                                nginxConnection.reload(options)
+                            end
+                            state.item(id)['Status'] = State::STATUS_DESTROYED unless options[:dry]
                         end
                     end
                 end

data/Plugins/Apps/llama.cpp/llama.cpp.container

@@ -0,0 +1,28 @@
+
+[Unit]
+Description=llama.cpp container
+After=local-fs.target
+
+[Container]
+ContainerName=llama.cpp
+Image=ghcr.io/ggml-org/llama.cpp:full
+Exec=--server --host 0.0.0.0 $ARGS
+EnvironmentFile=/var/lib/llama.cpp/.config/containers/systemd/llama.cpp.env
+PublishPort=127.0.0.1:18900:8080
+UserNS=keep-id:uid=1000,gid=1000
+# Need newer Podman to use this
+#GroupAdd=keep-groups
+PodmanArgs=--group-add keep-groups
+#PodmanArgs=--passwd-entry 'llama.cpp:x:1000:1000:llama.cpp:/home/llama.cpp:/bin/bash'
+Volume=/var/lib/llama.cpp/.cache:/app/.cache
+Volume=/var/lib/llama.cpp/models:/models
+$DEVICES
+LogDriver=journald
+AutoUpdate=registry
+
+[Service]
+TimeoutStartSec=12min
+Restart=on-failure
+
+[Install]
+WantedBy=multi-user.target default.target