ConfigLMM 0.1.0 → 0.3.0

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

@@ -0,0 +1,237 @@
+# frozen_string_literal: true
+
+module ConfigLMM
+    module Framework
+
+        class LinuxApp < Framework::Plugin
+
+            LINUX_FOLDER = __dir__ + '/../../../../Plugins/OS/Linux/'
+            SUSE_NAME = 'openSUSE Leap'
+            SUSE_ID = 'opensuse-leap'
+            PODMAN_PACKAGE = 'Podman'
+            SYSTEMD_CONTAINERS_PATH = '~/.config/containers/systemd/'
+
+            def ensurePackage(name, location)
+              self.class.ensurePackages([name], location)
+            end
+
+            def ensurePackages(names, location)
+              self.class.ensurePackages(names, location)
+            end
+
+            def self.ensurePackages(names, locationOrSSH)
+                distroInfo = nil
+                closure = Proc.new 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
+                end
+
+                if locationOrSSH.nil? || locationOrSSH == '@me'
+                    distroInfo = closure.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|
+                        distroInfo = closure.call(ssh)
+                    end
+                else
+                    distroInfo = closure.call(locationOrSSH)
+                end
+                distroInfo
+            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
+            end
+
+            def self.ensureServiceAutoStartOverSSH(name, locationOrSSH)
+                closure = Proc.new do |ssh|
+                    distroInfo = self.currentDistroInfo(ssh)
+
+                    command = distroInfo['AutoStartService'] + ' ' + name.shellescape
+                    self.sshExec!(ssh, command)
+                end
+
+                if locationOrSSH.is_a?(String) || locationOrSSH.is_a?(Addressable::URI)
+                    self.sshStart(locationOrSSH) do |ssh|
+                        closure.call(ssh)
+                    end
+                else
+                    closure.call(locationOrSSH)
+                end
+            end
+
+            def startService(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.startServiceOverSSH(name, location)
+                else
+                    # TODO
+                end
+            end
+
+            def self.startServiceOverSSH(name, locationOrSSH)
+                 closure = Proc.new do |ssh|
+                     distroInfo = self.currentDistroInfo(ssh)
+
+                     command = distroInfo['StartService'] + ' ' + name.shellescape
+                     self.sshExec!(ssh, command)
+                 end
+
+                if locationOrSSH.is_a?(String) || locationOrSSH.is_a?(Addressable::URI)
+                    self.sshStart(locationOrSSH) do |ssh|
+                        closure.call(ssh)
+                    end
+                else
+                    closure.call(locationOrSSH)
+                end
+            end
+
+
+            def self.firewallAddServiceOverSSH(serviceName, locationOrSSH)
+                 closure = Proc.new do |ssh|
+                     command = 'firewall-cmd --permanent --add-service ' + serviceName.shellescape
+                     self.sshExec!(ssh, command, true)
+                     command = 'firewall-cmd --add-service ' + serviceName.shellescape
+                     self.sshExec!(ssh, command, true)
+                 end
+
+                if locationOrSSH.is_a?(String) || locationOrSSH.is_a?(Addressable::URI)
+                    self.sshStart(locationOrSSH) do |ssh|
+                        closure.call(ssh)
+                    end
+                else
+                    closure.call(locationOrSSH)
+                end
+            end
+
+            def self.firewallAddPortOverSSH(portName, locationOrSSH)
+                 closure = Proc.new do |ssh|
+                     command = 'firewall-cmd --permanent --add-port ' + portName.shellescape
+                     self.sshExec!(ssh, command, true)
+                     command = 'firewall-cmd --add-port ' + portName.shellescape
+                     self.sshExec!(ssh, command, true)
+                 end
+
+                if locationOrSSH.is_a?(String) || locationOrSSH.is_a?(Addressable::URI)
+                    self.sshStart(locationOrSSH) do |ssh|
+                        closure.call(ssh)
+                    end
+                else
+                    closure.call(locationOrSSH)
+                end
+            end
+
+            def self.mapPackages(packages, distroName)
+                distroPackages = YAML.load_file(LINUX_FOLDER + 'Packages.yaml')
+                names = []
+                packages.to_a.each do |pkg|
+                    packageName = distroPackages[distroName][pkg]
+                    if packageName
+                        if packageName.is_a?(Array)
+                            names += packageName
+                        else
+                            names << packageName
+                        end
+                    else
+                        names << pkg.downcase
+                    end
+                end
+                names
+            end
+
+            def self.createCertificateOverSSH(ssh)
+                dir = "/etc/letsencrypt/live/Wildcard/"
+                self.sshExec!(ssh, "mkdir -p #{dir}")
+                # Need this temporarily before real certs are created
+                if !self.remoteFilePresent?(dir + 'fullchain.pem', ssh)
+                    self.sshExec!(ssh, "openssl req -x509 -noenc -days 90 -newkey rsa:2048 -keyout #{dir}privkey.pem -out #{dir}fullchain.pem -subj '/C=US/O=ConfigLMM/CN=Wildcard'")
+                    self.sshExec!(ssh, "cp #{dir}fullchain.pem #{dir}chain.pem")
+                end
+                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.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}'")
+            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
+                else
+                    # TODO
+                end
+            end
+
+            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('"', '')
+                end
+            end
+
+            def self.currentDistroInfo(ssh)
+                self.distroInfo(self.distroID(ssh))
+            end
+
+            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]
+            end
+
+        end
+    end
+end

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

@@ -13,30 +13,48 @@ module ConfigLMM
 
         class NginxApp < Framework::Plugin
 
+            NGINX_PACKAGE = 'nginx'
+            CONFIG_DIR = '/etc/nginx/'
+            WWW_DIR = '/srv/www/'
+
             def writeNginxConfig(dir, name, id, target, activeState, context, options)
                 outputFolder = options['output']
 
                 updateTargetConfig(target)
 
+                target = target.dup
+                target['NginxVersion'] = 0 unless target['NginxVersion']
                 template = ERB.new(File.read(dir + '/' + name + '.conf.erb'))
                 renderTemplate(template, target, outputFolder + '/nginx/servers-lmm/' + name + '.conf', options)
-                plugins[:Nginx].actionNginxBuild(id, target, activeState, context, options)
             end
 
             def deployNginxConfig(id, target, activeState, context, options)
-                outputFolder = options['output']
+                outputFolder = options['output'] + '/nginx/servers-lmm'
 
-                if !target['Location'] || target['Location'] == '@me'
-                    copy(outputFolder + '/nginx/servers-lmm', '/etc/nginx/', options['dry'])
+                if target['Location'] && target['Location'] != '@me'
+                    uri = Addressable::URI.parse(target['Location'])
+                    raise Framework::PluginProcessError.new("Unknown Protocol: #{uri.scheme}!") if uri.scheme != 'ssh'
+                    self.class.sshStart(uri) do |ssh|
+                        self.class.uploadFolder(outputFolder, CONFIG_DIR, ssh)
+                        Framework::LinuxApp.firewallAddServiceOverSSH('https', ssh)
+                    end
+                else
+                    copy(outputFolder, CONFIG_DIR, options['dry'])
                 end
-
-                plugins[:Nginx].actionNginxDeploy(id, target, activeState, context, options)
             end
 
             def cleanupNginxConfig(name, id, state, context, options)
                 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
+                else
+                    target['NginxVersion'] = `nginx -v`.strip.split('/')[1].to_f
+                end
+            end
+
             private
 
             def updateTargetConfig(target)

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

@@ -2,8 +2,12 @@
 
 require_relative 'errors'
 require_relative 'store'
+require 'addressable/uri'
 require 'http'
 require 'fileutils'
+require 'net/ssh'
+require 'net/scp'
+require 'open3'
 
 module ConfigLMM
     module Framework
@@ -42,6 +46,8 @@ module ConfigLMM
 
             addMeta :name, :description
 
+            attr_accessor :state
+
             def initialize(logger, prompt, plugins)
                 @Logger = logger
                 @Prompt = prompt
@@ -141,6 +147,150 @@ module ConfigLMM
                 end
             end
 
+            def self.loadVariable(value, target)
+                variableStart = value.index('${')
+                return value unless variableStart
+                variableEnd = value.index('}', variableStart + 2)
+                variableName = value[variableStart + 2...variableEnd]
+                if variableName.start_with?('ENV:')
+                    value = value[0...variableStart].to_s + ENV[variableName[4..variableEnd]] + value[(variableEnd + 1)..-1].to_s
+                else
+                    raise 'Not implemented!'
+                end
+                value
+            end
+
+            CONFIGLMM_SECTION_BEGIN = "# -----BEGIN CONFIGLMM-----\n"
+            CONFIGLMM_SECTION_END   = "# -----END CONFIGLMM-----\n"
+
+            def updateLocalFile(file, options, atTop = false, comment = '#')
+                File.write(file, '') unless File.exist?(file)
+                sectionBegin = CONFIGLMM_SECTION_BEGIN.gsub('#', comment)
+                sectionEnd = CONFIGLMM_SECTION_END.gsub('#', comment)
+                fileLines = File.read(file).lines
+                sectionBeginIndex = fileLines.index(sectionBegin)
+                sectionEndIndex = fileLines.index(sectionEnd)
+                if sectionBeginIndex.nil?
+                    linesBefore = []
+                    linesBefore = fileLines unless atTop
+                    linesBefore << "\n"
+                    linesBefore << sectionBegin
+                    linesAfter = [sectionEnd]
+                    linesAfter << "\n"
+                    linesAfter += fileLines if atTop
+                else
+                    linesBefore = fileLines[0..sectionBeginIndex]
+                    if sectionEndIndex.nil?
+                        linesAfter = [sectionEnd]
+                        linesAfter << "\n"
+                    else
+                        linesAfter = fileLines[sectionEndIndex..fileLines.length]
+                    end
+                end
+
+                fileLines = linesBefore
+                fileLines = yield(fileLines)
+                fileLines += linesAfter
+
+                fileWrite(file, fileLines.join(), options[:dry])
+            end
+
+            def updateRemoteFile(locationOrSSH, file, options, atTop = false, comment = '#', &block)
+
+                closure = Proc.new do |ssh|
+                    localFile = options['output'] + '/' + SecureRandom.alphanumeric(10)
+                    File.write(localFile, '')
+                    self.class.sshExec!(ssh, "touch #{file}")
+                    ssh.scp.download!(file, localFile)
+                    updateLocalFile(localFile, options, atTop, comment, &block)
+                    ssh.scp.upload!(localFile, file)
+                end
+
+                if locationOrSSH.is_a?(String) || locationOrSSH.is_a?(Addressable::URI)
+                    uri = Addressable::URI.parse(locationOrSSH)
+                    raise Framework::PluginProcessError.new("Unknown Protocol: #{uri.scheme}!") if uri.scheme != 'ssh'
+
+                    self.class.sshStart(uri) do |ssh|
+                        closure.call(ssh)
+                    end
+                else
+                    closure.call(locationOrSSH)
+                end
+            end
+
+            def self.filePresent?(file, ssh = nil)
+                result = self.exec("stat #{file}", ssh, true)
+                !result.start_with?('stat: cannot')
+            end
+
+            # DEPRECATED - use filePresent()
+            def self.remoteFilePresent?(file, ssh)
+                self.filePresent?(file, ssh)
+            end
+
+            def self.remoteFileContains?(file, content, ssh)
+                !self.sshExec!(ssh, "grep '#{content}' #{file}", true).strip.empty?
+            end
+
+            def self.uploadNotPresent(file, target, ssh)
+                target += '/' + File.basename(file)
+                if !self.remoteFilePresent?(target, ssh)
+                    ssh.scp.upload!(file, target)
+                end
+            end
+
+            def self.uploadFolder(folder, target, ssh)
+                target += '/' + File.basename(folder) + '/'
+                self.sshExec!(ssh, "mkdir -p #{target}")
+                Dir[folder + '/*'].each do |file|
+                    ssh.scp.upload!(file, target + File.basename(file), recursive: true)
+                end
+            end
+
+            def self.exec(command, ssh = nil, allowFailure = false)
+                if ssh.nil?
+                    stdout, stdeerr, status = Open3.capture3(command)
+                    if !allowFailure && !status.success?
+                        $stderr.puts(stdout)
+                        $stderr.puts(stdeerr)
+                        raise Framework::PluginProcessError.new("Failed '#{command}'")
+                    end
+                    stdout + stdeerr
+                else
+                    self.sshExec!(ssh, command, allowFailure)
+                end
+            end
+
+            def self.toSSHparams(locationUri)
+                server = locationUri.hostname
+                params = {}
+                params[:port] = locationUri.port if locationUri.port
+                params[:user] = locationUri.user if locationUri.user
+                [server, params]
+            end
+
+            def self.sshStart(uri)
+                uri = Addressable::URI.parse(uri) if uri.is_a?(String)
+                server, sshParams = self.toSSHparams(uri)
+                Net::SSH.start(server, nil, sshParams) do |ssh|
+                    yield(ssh)
+                end
+            end
+
+            def self.sshExec!(ssh, command, allowFailure = false)
+                status = {}
+                output = ''
+                channel = ssh.exec(command, status: status) do |channel, stream, data|
+                    output += data
+                end
+                channel.wait
+                if !allowFailure && !status[:exit_code].zero?
+                    $stderr.puts(output)
+                    raise Framework::PluginProcessError.new("Failed '#{command}'")
+                end
+                output
+            end
+
             def renderTemplate(template, target, outputPath, options)
                 variables = {
                     config: target,

data/lib/ConfigLMM/Framework/plugins.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
 require_relative 'plugins/dns'
+require_relative 'plugins/linuxApp'
 require_relative 'plugins/nginxApp'
 require_relative 'plugins/ssh'

data/lib/ConfigLMM/commands/configsCommand.rb

@@ -32,6 +32,9 @@ module ConfigLMM
 
                 # Create Plugin instances
                 Framework::Store.boot(logger, prompt, @Plugins)
+                @Plugins.each do |id, plugin|
+                    plugin.state = @State
+                end
             end
 
             def execute

data/lib/ConfigLMM/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module ConfigLMM
-    VERSION = '0.1.0'
+    VERSION = '0.3.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ConfigLMM
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Dāvis Mosāns
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-11 00:00:00.000000000 Z
+date: 2024-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: addressable
@@ -80,6 +80,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: filesize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fog-libvirt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: fog-powerdns
   requirement: !ruby/object:Gem::Requirement
@@ -108,6 +136,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 5.1.1
+- !ruby/object:Gem::Dependency
+  name: net-scp
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 - !ruby/object:Gem::Dependency
   name: net-ssh
   requirement: !ruby/object:Gem::Requirement
@@ -366,8 +408,19 @@ files:
 - Examples/Linux.mm.yaml
 - Examples/Windows.mm.yaml
 - Examples/configlmmAuth.sh
+- Images/configINconfig.png
+- Images/singleConfig.png
 - Plugins/Apps/ArchiSteamFarm/ArchiSteamFarm.conf.erb
 - Plugins/Apps/ArchiSteamFarm/ArchiSteamFarm.lmm.rb
+- Plugins/Apps/Authentik/Authentik-Server.container
+- Plugins/Apps/Authentik/Authentik-Worker.container
+- Plugins/Apps/Authentik/Authentik.conf.erb
+- Plugins/Apps/Authentik/Authentik.lmm.rb
+- Plugins/Apps/Cassandra/Cassandra.lmm.rb
+- Plugins/Apps/Dovecot/Dovecot.lmm.rb
+- Plugins/Apps/GitLab/GitLab.conf.erb
+- Plugins/Apps/GitLab/GitLab.container
+- Plugins/Apps/GitLab/GitLab.lmm.rb
 - Plugins/Apps/IPFS/IPFS.conf.erb
 - Plugins/Apps/IPFS/IPFS.lmm.rb
 - Plugins/Apps/InfluxDB/InfluxDB.conf.erb
@@ -384,34 +437,61 @@ files:
 - Plugins/Apps/Netdata/Netdata.lmm.rb
 - Plugins/Apps/Nextcloud/Nextcloud.conf.erb
 - Plugins/Apps/Nextcloud/Nextcloud.lmm.rb
+- Plugins/Apps/Nextcloud/config.php
+- Plugins/Apps/Nginx/conf.d/configlmm.conf
 - Plugins/Apps/Nginx/config-lmm/errors.conf
 - Plugins/Apps/Nginx/config-lmm/private.conf
 - Plugins/Apps/Nginx/config-lmm/proxy.conf
 - Plugins/Apps/Nginx/config-lmm/public.conf
+- Plugins/Apps/Nginx/config-lmm/security.conf
 - Plugins/Apps/Nginx/config-lmm/ssl.conf
-- Plugins/Apps/Nginx/main.conf
+- Plugins/Apps/Nginx/main.conf.erb
 - Plugins/Apps/Nginx/nginx.conf
 - Plugins/Apps/Nginx/nginx.lmm.rb
 - Plugins/Apps/Nginx/proxy.conf.erb
 - Plugins/Apps/Odoo/Odoo.conf.erb
+- Plugins/Apps/Odoo/Odoo.container
 - Plugins/Apps/Odoo/Odoo.lmm.rb
+- Plugins/Apps/Odoo/odoo.conf
+- Plugins/Apps/PHP-FPM/PHP-FPM.lmm.rb
+- Plugins/Apps/Peppermint/Peppermint.conf.erb
+- Plugins/Apps/Peppermint/Peppermint.container
+- Plugins/Apps/Peppermint/Peppermint.lmm.rb
+- Plugins/Apps/Postfix/Postfix.lmm.rb
+- Plugins/Apps/Postfix/smtpd.conf
+- Plugins/Apps/PostgreSQL/PostgreSQL.lmm.rb
 - Plugins/Apps/Pterodactyl/Pterodactyl.conf.erb
 - Plugins/Apps/Pterodactyl/Pterodactyl.lmm.rb
 - Plugins/Apps/Pterodactyl/Wings.conf.erb
+- Plugins/Apps/SSH/SSH.lmm.rb
 - Plugins/Apps/Sunshine/Sunshine.conf.erb
 - Plugins/Apps/Sunshine/Sunshine.lmm.rb
+- Plugins/Apps/UVdesk/UVdesk.conf.erb
+- Plugins/Apps/UVdesk/UVdesk.lmm.rb
+- Plugins/Apps/Valkey/Valkey.lmm.rb
 - Plugins/Apps/Vaultwarden/Vaultwarden.conf.erb
+- Plugins/Apps/Vaultwarden/Vaultwarden.container
 - Plugins/Apps/Vaultwarden/Vaultwarden.lmm.rb
 - Plugins/Apps/bitmagnet/bitmagnet.conf.erb
 - Plugins/Apps/bitmagnet/bitmagnet.lmm.rb
 - Plugins/Apps/gollum/config.ru
 - Plugins/Apps/gollum/gollum.conf.erb
+- Plugins/Apps/gollum/gollum.container
 - Plugins/Apps/gollum/gollum.lmm.rb
-- Plugins/OS/Linux.lmm.rb
+- Plugins/OS/Linux/Distributions.yaml
+- Plugins/OS/Linux/Linux.lmm.rb
+- Plugins/OS/Linux/Packages.yaml
+- Plugins/OS/Linux/WireGuard/WireGuard.lmm.rb
+- Plugins/OS/Linux/WireGuard/wg0.conf.erb
+- Plugins/OS/Linux/openSUSE/autoinst.xml.erb
+- Plugins/OS/Linux/systemd/systemd.lmm.rb
+- Plugins/OS/Linux/systemd/user-0.slice
+- Plugins/OS/Linux/systemd/user@.service.d/delegate.conf
 - Plugins/OS/Routers/Aruba/ArubaInstant.lmm.rb
 - Plugins/Platforms/GitHub.lmm.rb
 - Plugins/Platforms/GoDaddy/GoDaddy.lmm.rb
 - Plugins/Platforms/GoDaddy/zone.txt.erb
+- Plugins/Platforms/libvirt/libvirt.lmm.rb
 - Plugins/Platforms/porkbun.lmm.rb
 - Plugins/Platforms/porkbun_spec.rb
 - Plugins/Services/DNS/AmberBit.lmm.rb
@@ -425,11 +505,13 @@ files:
 - bin/configlmm
 - bin/console
 - bin/setup
+- bootstrap.sh
 - lib/ConfigLMM.rb
 - lib/ConfigLMM/Framework.rb
 - lib/ConfigLMM/Framework/plugins.rb
 - lib/ConfigLMM/Framework/plugins/dns.rb
 - lib/ConfigLMM/Framework/plugins/errors.rb
+- lib/ConfigLMM/Framework/plugins/linuxApp.rb
 - lib/ConfigLMM/Framework/plugins/nginxApp.rb
 - lib/ConfigLMM/Framework/plugins/plugin.rb
 - lib/ConfigLMM/Framework/plugins/ssh.rb
@@ -478,7 +560,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.11
+rubygems_version: 3.5.15
 signing_key:
 specification_version: 4
 summary: Manage configuration for your applications/systems/services/servers