ConfigLMM 0.3.0 → 0.5.0

data/Plugins/Apps/Peppermint/Peppermint.lmm.rb

@@ -11,44 +11,40 @@ module ConfigLMM
                 raise Framework::PluginProcessError.new('Domain field must be set!') unless 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.class.sshStart(uri) do |ssh|
-
-                        dbPassword = self.configurePostgreSQL(target['Database'], ssh)
-                        distroInfo = Framework::LinuxApp.currentDistroInfo(ssh)
-                        Framework::LinuxApp.configurePodmanServiceOverSSH(USER, HOME_DIR, 'Peppermint Ticket Management', distroInfo, ssh)
-
-                        path = Framework::LinuxApp::SYSTEMD_CONTAINERS_PATH.gsub('~', HOME_DIR)
-                        self.class.sshExec!(ssh, " echo 'DB_HOST=#{HOST_IP}' > #{path}/Peppermint.env")
-                        self.class.sshExec!(ssh, " echo 'DB_USERNAME=#{USER}' >> #{path}/Peppermint.env")
-                        self.class.sshExec!(ssh, " echo 'DB_PASSWORD=#{dbPassword}' >> #{path}/Peppermint.env")
-                        self.class.sshExec!(ssh, " echo 'SECRET=#{SecureRandom.urlsafe_base64(60)}' >> #{path}/Peppermint.env")
-                        self.class.sshExec!(ssh, " echo 'API_URL=https://#{target['Domain']}/api' >> #{path}/Peppermint.env")
-                        self.class.sshExec!(ssh, "chown #{USER}:#{USER} #{path}/Peppermint.env")
-                        self.class.sshExec!(ssh, "chmod 600 #{path}/Peppermint.env")
-
-                        ssh.scp.upload!(__dir__ + '/Peppermint.container', path)
-                        self.class.sshExec!(ssh, "systemctl --user --machine=#{USER}@ daemon-reload")
-                        self.class.sshExec!(ssh, "systemctl --user --machine=#{USER}@ start Peppermint")
-
-                        Framework::LinuxApp.ensurePackages([NGINX_PACKAGE], ssh)
-                        Framework::LinuxApp.ensureServiceAutoStartOverSSH(NGINX_PACKAGE, ssh)
-                        self.class.prepareNginxConfig(target, ssh)
-                        self.writeNginxConfig(__dir__, 'Peppermint', id, target, state, context, options)
-                        self.deployNginxConfig(id, target, activeState, context, options)
-                        Framework::LinuxApp.startServiceOverSSH(NGINX_PACKAGE, ssh)
+                self.withConnection(target['Location'], target) do |connection|
+                    Linux.withConnection(connection) do |linuxConnection|
+                        dbPassword = self.configurePostgreSQL(target['Database'], linuxConnection, options)
+
+                        Podman.ensurePresent(linuxConnection, options)
+                        Podman.createUser(USER, HOME_DIR, 'Peppermint Ticket Management', linuxConnection, options)
+                        path = Podman.containersPath(HOME_DIR)
+
+                        linuxConnection.fileWrite("#{path}/Peppermint.env", "DB_HOST=#{HOST_IP}", options)
+                        linuxConnection.fileAppend("#{path}/Peppermint.env", "DB_USERNAME=#{USER}", options)
+                        linuxConnection.fileAppend("#{path}/Peppermint.env", "DB_PASSWORD=#{dbPassword}", { **options, hide: true })
+                        linuxConnection.fileAppend("#{path}/Peppermint.env", "SECRET=#{SecureRandom.urlsafe_base64(60)}", { **options, hide: true })
+                        linuxConnection.fileAppend("#{path}/Peppermint.env", "API_URL=https://#{target['Domain']}/api", options)
+
+                        linuxConnection.setUserGroup("#{path}/Peppermint.env", USER, USER, options)
+                        linuxConnection.setPrivate("#{path}/Peppermint.env", options)
+
+                        linuxConnection.upload(__dir__ + '/Peppermint.container', path, options)
+
+                        linuxConnection.reloadUserServices(USER, options)
+                        linuxConnection.restartUserService(USER, 'Peppermint', options)
+
+                        Nginx.withConnection(linuxConnection) do |nginxConnection|
+                            nginxConnection.provision(__dir__, 'Peppermint', target, activeState, context, options)
+                        end
                     end
-                else
-                    # TODO
                 end
             end
 
-            def configurePostgreSQL(settings, ssh)
+            def configurePostgreSQL(dbSettings, linuxConnection, options)
                 password = SecureRandom.alphanumeric(20)
-                PostgreSQL.createRemoteUserAndDBOverSSH(settings, USER, password, ssh)
+                PostgreSQL.withConnection(dbSettings, linuxConnection) do |postgresConnection|
+                    postgresConnection.createUserAndDB(USER, password, options)
+                end
                 password
             end
 

data/Plugins/Apps/Perplexica/Perplexica.container

@@ -0,0 +1,25 @@
+
+[Unit]
+Description=Perplexica container
+After=local-fs.target
+
+[Container]
+ContainerName=Perplexica
+Image=docker.io/itzcrazykns1337/perplexica:main
+EnvironmentFile=/var/lib/perplexica/.config/containers/systemd/Perplexica.env
+Network=slirp4netns:allow_host_loopback=true
+PublishPort=127.0.0.1:13500:3000
+UserNS=keep-id:uid=1000,gid=1000
+Volume=/var/lib/perplexica/data:/home/perplexica/data
+Volume=/var/lib/perplexica/uploads:/home/perplexica/uploads
+Volume=/var/lib/perplexica/config.toml:/home/perplexica/config.toml
+
+LogDriver=journald
+AutoUpdate=registry
+
+[Service]
+TimeoutStartSec=6min
+Restart=on-failure
+
+[Install]
+WantedBy=multi-user.target default.target

data/Plugins/Apps/Perplexica/Perplexica.lmm.rb

@@ -0,0 +1,92 @@
+
+module ConfigLMM
+    module LMM
+        class Perplexica < Framework::Plugin
+
+            USER = 'perplexica'
+            HOME_DIR = '/var/lib/perplexica'
+
+            def actionPerplexicaDeploy(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, 'Perplexica', linuxConnection, options)
+                        linuxConnection.withUserShell(USER) do |shell|
+                                shell.createDirs(options, '~/data', '~/uploads')
+                        end
+
+                        linuxConnection.upload(__dir__ + '/config.toml', HOME_DIR, options)
+
+                        grokKey = target['GrokSecretId'] ? context.secrets.load(target['GrokSecretId'], 'API_KEY') : nil
+                        linuxConnection.fileReplace("#{HOME_DIR}/config.toml", '\$GROQ_KEY', grokKey, options)
+
+                        anthropicKey = target['AnthropicSecretId'] ? context.secrets.load(target['AnthropicSecretId'], 'API_KEY') : nil
+                        linuxConnection.fileReplace("#{HOME_DIR}/config.toml", '\$ANTHROPIC_KEY', anthropicKey, options)
+
+                        geminiKey = target['GeminiSecretId'] ? context.secrets.load(target['GeminiSecretId'], 'API_KEY') : nil
+                        linuxConnection.fileReplace("#{HOME_DIR}/config.toml", '\$GEMINI_KEY', geminiKey, options)
+
+                        deepseekKey = target['DeepSeekSecretId'] ? context.secrets.load(target['DeepSeekSecretId'], 'API_KEY') : nil
+                        linuxConnection.fileReplace("#{HOME_DIR}/config.toml", '\$DEEPSEEK_KEY', deepseekKey, options)
+
+                        openaiKey = nil
+                        openaiURL = nil
+                        openaiModel = nil
+                        if target['OpenAI'] && !target['OpenAI'].to_h.empty?
+                            openaiKey = target['OpenAI']['SecretId'] ? context.secrets.load(target['OpenAI']['SecretId'], 'API_KEY') : nil
+                            openaiURL = Podman.updateURL(target['OpenAI']['URL']) unless target['OpenAI']['URL'].to_s.empty?
+                            openaiModel = target['OpenAI']['Model']
+                        end
+                        linuxConnection.fileReplace("#{HOME_DIR}/config.toml", '\$OPENAI_KEY', openaiKey, options)
+                        linuxConnection.fileReplace("#{HOME_DIR}/config.toml", '\$OPENAI_URL', openaiURL, options)
+                        linuxConnection.fileReplace("#{HOME_DIR}/config.toml", '\$OPENAI_MODEL', openaiModel, options)
+
+                        ollamaURL = nil
+                        if target['Ollama'] && !target['Ollama'].to_h.empty?
+                            ollamaURL = Podman.updateURL(target['Ollama']['URL'], Ollama::PORT)
+                        end
+                        linuxConnection.fileReplace("#{HOME_DIR}/config.toml", '\$OLLAMA_URL', ollamaURL, options)
+
+                        linuxConnection.setUserGroup("#{HOME_DIR}/config.toml", USER, USER, options)
+
+                        path = Podman.containersPath(HOME_DIR)
+
+                        searxng = Podman.updateURL(target['SearXNG'], SearXNG::PORT)
+
+                        linuxConnection.fileWrite("#{path}/Perplexica.env", "SEARXNG_API_URL=#{searxng}", options)
+
+                        linuxConnection.setUserGroup("#{path}/Perplexica.env", USER, USER, options)
+                        linuxConnection.setPrivate("#{path}/Perplexica.env", options)
+
+                        linuxConnection.upload(__dir__ + '/Perplexica.container', path, options)
+
+                        linuxConnection.reloadUserServices(USER, options)
+                        linuxConnection.restartUserService(USER, 'Perplexica', options)
+                    end
+                end
+            end
+
+            def cleanup(configs, state, context, options)
+                cleanupType(:Perplexica, configs, state, context, options) do |item, id, state, context, options, connection|
+                    Linux.withConnection(connection) do |linuxConnection|
+
+                        linuxConnection.stopUserService(USER, 'Perplexica', options)
+
+                        path = Podman.containersPath(HOME_DIR)
+                        linuxConnection.rm(path + '/Perplexica.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/Perplexica/config.toml

@@ -0,0 +1,26 @@
+[GENERAL]
+SIMILARITY_MEASURE = "cosine" # "cosine" or "dot"
+KEEP_ALIVE = "5m" # How long to keep Ollama models loaded into memory. (Instead of using -1 use "-1m")
+
+[MODELS.OPENAI]
+API_KEY = "$OPENAI_KEY"
+
+[MODELS.GROQ]
+API_KEY = "$GROQ_KEY"
+
+[MODELS.ANTHROPIC]
+API_KEY = "$ANTHROPIC_KEY"
+
+[MODELS.GEMINI]
+API_KEY = "$GEMINI_KEY"
+
+[MODELS.CUSTOM_OPENAI]
+API_KEY = "$OPENAI_KEY"
+API_URL = "$OPENAI_URL"
+MODEL_NAME = "$OPENAI_MODEL"
+
+[MODELS.OLLAMA]
+API_URL = "$OLLAMA_URL" # Ollama API URL
+
+[MODELS.DEEPSEEK]
+API_KEY = "$DEEPSEEK_KEY"

data/Plugins/Apps/Podman/Connection.rb

@@ -0,0 +1,24 @@
+
+module ConfigLMM
+    module LMM
+        class PodmanConnection
+
+            attr_reader :connection
+
+            def initialize(connection, container)
+                @connection = connection
+                @container = container
+            end
+
+            def exec(command, allowFailure = false, options = {})
+                workdir = ''
+                if options[:workdir]
+                    workdir = "--workdir #{options[:workdir].shellescape}"
+                end
+                cmd = "podman exec #{workdir} #{@container['Id'].shellescape} sh -c '#{LinuxShell.escapeSingleQuotes(command)}'"
+                @connection.exec(cmd, allowFailure, options)
+            end
+
+        end
+    end
+end

data/Plugins/Apps/Podman/Podman.lmm.rb

@@ -0,0 +1,80 @@
+require_relative 'Connection'
+
+require 'uri'
+
+module ConfigLMM
+    module LMM
+        class Podman < Framework::Plugin
+
+            PACKAGE_NAME = 'Podman'
+            SYSTEM_CONTAINERS_PATH = '/etc/containers/systemd'
+            USER_CONTAINERS_PATH = '~/.config/containers/systemd'
+            HOST_IP = '10.0.2.2'
+
+            def self.ensurePresent(linuxConnection, options = {})
+                linuxConnection.ensurePackage(PACKAGE_NAME, options)
+            end
+
+            def self.container(name, connection, options = {})
+                result = connection.exec("podman ps --format json --filter name='^#{name}$'", false, { **options, dry: false }).strip
+                containers = JSON.parse(result)
+                raise "Failed to find container #{name}!" if containers.empty?
+                containers.first
+            rescue JSON::ParserError => error
+                return { 'Id' => name } if options['dry']
+                raise error
+            end
+
+            def self.withConnection(connection, container)
+                yield(PodmanConnection.new(connection, container))
+            end
+
+            def self.run(imageId, name, cmd, linuxConnection, options)
+                linuxConnection.exec("podman run --name #{name} --replace --rm -it #{imageId} #{cmd}")
+            end
+
+            def self.createUser(user, homedir, userComment, linuxConnection, options)
+                linuxConnection.createServiceUser(user, homedir, userComment, options)
+                linuxConnection.createSubuids(user, options)
+                linuxConnection.enableLinger(user, options)
+                linuxConnection.withUserShell(user) do |shell|
+                    shell.createDirs(options, USER_CONTAINERS_PATH)
+                end
+                # This is a workaround for performance issue with Podman --userns keep-id
+                # See https://github.com/containers/podman/issues/16541
+                linuxConnection.upload(__dir__ + '/storage.conf', homedir + '/.config/containers/', options)
+            end
+
+            def self.loadImage(userShell, imageFile, options = {})
+                cmd = "podman image load --input '#{imageFile.shellescape}'"
+                userShell.exec(cmd, false, options)
+            end
+
+            def self.removeImage(userShell, imageFile, options = {})
+                cmd = "podman image rm --ignore '#{imageFile.shellescape}'"
+                userShell.exec(cmd, false, options)
+            end
+
+            def self.containersPath(homeDir = nil)
+                if homeDir.nil?
+                    SYSTEM_CONTAINERS_PATH
+                else
+                    USER_CONTAINERS_PATH.gsub('~', homeDir)
+                end
+            end
+
+            def self.updateHost(host)
+                host = HOST_IP if host.to_s.empty? || ['localhost', '127.0.0.1', '::1'].include?(host)
+                host
+            end
+
+            def self.updateURL(url, defaultPort = nil)
+                uri = URI.parse(url.to_s)
+                uri.scheme = 'http' unless uri.scheme
+                uri.port = defaultPort if !uri.port && defaultPort
+                uri.host = self.updateHost(uri.host)
+                uri.to_s
+            end
+        end
+    end
+end

data/Plugins/Apps/Podman/storage.conf

@@ -0,0 +1,6 @@
+
+[storage]
+driver = "overlay"
+
+[storage.options.overlay]
+mount_program = "/usr/bin/fuse-overlayfs"