ConfigLMM 0.4.0 → 0.5.0

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"