ConfigLMM 0.4.0 → 0.5.0

data/Plugins/Apps/SigNoz/SigNoz.lmm.rb

@@ -0,0 +1,319 @@
+require 'yaml'
+require 'uri'
+
+module ConfigLMM
+    module LMM
+        class SigNoz < Framework::Plugin
+
+            VERSION = 'v0.79.1'
+            COLLECTOR_VERSION = 'v0.111.39'
+
+            USER = 'signoz'
+            COLLECTOR_USER = 'signoz-collector'
+            FRONTEND_USER = 'signoz-frontend'
+            HOME_DIR = '/var/lib/signoz'
+            COLLECTOR_HOME_DIR = '/var/lib/signoz-collector'
+            FRONTEND_HOME_DIR = '/var/lib/signoz-frontend'
+            HOST_IP = '10.0.2.2'
+            DB_ANALYTICS = 'signoz_analytics'
+            DB_METADATA = 'signoz_metadata'
+            DB_TRACES = 'signoz_traces'
+            DB_METRICS = 'signoz_metrics'
+            DB_LOGS = 'signoz_logs'
+
+            def actionSigNozDeploy(id, target, activeState, context, options)
+                self.withConnection(target['Location'], target) do |connection|
+                    Linux.withConnection(connection) do |linuxConnection|
+                        if !target.key?('Proxy') || target['Proxy'] == false
+                            deploySigNozService(linuxConnection, target, activeState, context, options)
+                        end
+
+                        deploySigNozProxy(id, linuxConnection, target, activeState, context, options)
+
+                        if !target.key?('Proxy') || target['Proxy'] == false
+                            linuxConnection.reloadUserServices(USER, options)
+                            linuxConnection.restartUserService(USER, 'SigNoz-Migrator', options)
+                            linuxConnection.restartUserService(USER, 'SigNoz', options)
+                        end
+                    end
+                end
+            end
+
+            def deploySigNozService(linuxConnection, target, activeState, context, options)
+                Podman.ensurePresent(linuxConnection, options)
+                username, password = self.configureClickHouseSigNoz(target, linuxConnection, activeState, context, options)
+                Podman.createUser(USER, HOME_DIR, 'SigNoz', linuxConnection, options)
+                linuxConnection.withUserShell(USER) do |shell|
+                    shell.createDirs(options, '~/data', '~/config/dashboards')
+                end
+
+                path = Podman.containersPath(HOME_DIR)
+
+                dbUrl = self.class.buildEndpoint(target['Database']['HostName'],
+                                                 target['Database']['Port'],
+                                                 '',
+                                                 username,
+                                                 password)
+
+                jwtSecret = SecureRandom.alphanumeric(30)
+
+                linuxConnection.fileWrite("#{path}/SigNoz.env", 'TELEMETRY_ENABLED=false', options)
+                linuxConnection.fileAppend("#{path}/SigNoz.env", 'SIGNOZ_JWT_SECRET=' + jwtSecret, options)
+                linuxConnection.fileAppend("#{path}/SigNoz.env", 'SIGNOZ_TELEMETRYSTORE_PROVIDER=clickhouse', options)
+                linuxConnection.fileAppend("#{path}/SigNoz.env", "SIGNOZ_TELEMETRYSTORE_CLICKHOUSE_DSN=#{dbUrl}", options)
+
+                if target['SMTP'] && target['SMTP']['Host']
+                    port = target['SMTP']['Port']
+                    port = 25 unless port
+                    linuxConnection.fileAppend(path + '/SigNoz.env', 'SIGNOZ_ALERTMANAGER_SIGNOZ_GLOBAL_SMTP__SMARTHOST=' + target['SMTP']['Host'] + ':' + port.to_s, options)
+                    if target['SMTP']['Username']
+                        linuxConnection.fileAppend(path + '/SigNoz.env', 'SIGNOZ_ALERTMANAGER_SIGNOZ_GLOBAL_SMTP__AUTH__USERNAME=' + target['SMTP']['Username'], options)
+                    end
+                    if target['SMTP']['SecretId']
+                        smtpPassword = context.secrets.load(target['SMTP']['SecretId'], target['SMTP']['Username'].upcase + '_PASSWORD')
+                        linuxConnection.fileAppend(path + '/SigNoz.env', 'SIGNOZ_ALERTMANAGER_SIGNOZ_GLOBAL_SMTP__AUTH__PASSWORD=' + smtpPassword.to_s, { **options, hide: true })
+                    end
+                    if target['SMTP']['FromAddress']
+                        linuxConnection.fileAppend(path + '/SigNoz.env', 'SIGNOZ_ALERTMANAGER_SIGNOZ_GLOBAL_SMTP__FROM=' + target['SMTP']['Username'], options)
+                    end
+                end
+
+                linuxConnection.setUserGroup("#{path}/SigNoz.env", USER, USER, options)
+                linuxConnection.setPrivate("#{path}/SigNoz.env", options)
+
+                config = YAML.load_file(__dir__ + '/Config/prometheus.yml')
+                config['remote_read'].first['url'] = self.class.buildEndpoint(target['Database']['HostName'],
+                                                                              target['Database']['Port'],
+                                                                              DB_METRICS)
+
+                configFile = options['output'] + '/prometheus.yml'
+                File.write(configFile, config.to_yaml)
+
+                linuxConnection.upload(__dir__ + '/SigNoz.container', path, options)
+                linuxConnection.upload(__dir__ + '/SigNoz-Migrator.container', path, options)
+                linuxConnection.upload(configFile, HOME_DIR + '/config', options)
+                linuxConnection.upload(__dir__ + '/Config/alerts.yml', HOME_DIR + '/config', options)
+
+                linuxConnection.fileReplace("#{path}/SigNoz.container", '\$VERSION', VERSION, options)
+                linuxConnection.fileReplace("#{path}/SigNoz-Migrator.container", '\$VERSION', COLLECTOR_VERSION, options)
+                linuxConnection.fileReplace("#{path}/SigNoz-Migrator.container", '\$DSN', dbUrl, { **options, hide: true })
+            end
+
+            def deploySigNozProxy(id, linuxConnection, target, activeState, context, options)
+                if !target.key?('Proxy') || target['Proxy']
+                    raise Framework::PluginProcessError.new('Domain field must be set!') unless target['Domain']
+                    Nginx.withConnection(linuxConnection) do |nginxConnection|
+                        target['Server'] = '127.0.0.1:18600' unless target['Server']
+                        target['Server'] += ':18600' unless target['Server'].include?(':')
+                        target['ConfigName'] = target['Name']
+                        nginxConnection.provision(__dir__, 'SigNoz', target, activeState, context, options)
+                    end
+                elsif target.key?('Proxy') && target['Proxy'] == false
+                    path = Podman.containersPath(HOME_DIR)
+                    linuxConnection.fileReplace("#{path}/SigNoz.container", 'PublishPort=127.0.0.1:18600:', 'PublishPort=0.0.0.0:18600:', options)
+                    linuxConnection.firewallAddPort('18600/tcp', options)
+                end
+            end
+
+            def actionSigNozCollectorDeploy(id, target, activeState, context, options)
+                self.withConnection(target['Location'], target) do |connection|
+                    Linux.withConnection(connection) do |linuxConnection|
+                        Podman.ensurePresent(linuxConnection, options)
+                        username, password = self.configureClickHouseCollector(target, linuxConnection, activeState, context, options)
+                        Podman.createUser(COLLECTOR_USER, COLLECTOR_HOME_DIR, 'SigNoz Collector', linuxConnection, options)
+
+                        config = YAML.load_file(__dir__ + '/Config/otel-collector-config.yaml')
+
+                        config['exporters']['clickhousetraces']['datasource'] = self.class.buildEndpoint(target['Database']['HostName'],
+                                                                                                         target['Database']['Port'],
+                                                                                                         DB_TRACES,
+                                                                                                         username,
+                                                                                                         password)
+
+                        config['exporters']['clickhousemetricswrite']['endpoint'] = self.class.buildEndpoint(target['Database']['HostName'],
+                                                                                                            target['Database']['Port'],
+                                                                                                            DB_METRICS,
+                                                                                                            username,
+                                                                                                            password)
+
+                        config['exporters']['clickhousemetricswrite/prometheus']['endpoint'] = self.class.buildEndpoint(target['Database']['HostName'],
+                                                                                                                        target['Database']['Port'],
+                                                                                                                        DB_METRICS,
+                                                                                                                        username,
+                                                                                                                        password)
+
+                        config['exporters']['signozclickhousemetrics']['dsn'] = self.class.buildEndpoint(target['Database']['HostName'],
+                                                                                                         target['Database']['Port'],
+                                                                                                         DB_METRICS,
+                                                                                                         username,
+                                                                                                         password)
+
+                        config['exporters']['clickhouselogsexporter']['dsn'] = self.class.buildEndpoint(target['Database']['HostName'],
+                                                                                                        target['Database']['Port'],
+                                                                                                        DB_LOGS,
+                                                                                                        username,
+                                                                                                        password)
+
+                        configFile = options['output'] + '/otel-collector-config.yaml'
+                        File.write(configFile, config.to_yaml)
+
+                        linuxConnection.upload(__dir__ + '/SigNoz-Collector.container', Podman.containersPath(COLLECTOR_HOME_DIR), options)
+                        linuxConnection.upload(configFile, COLLECTOR_HOME_DIR, options)
+                        linuxConnection.upload(__dir__ + '/Config/otel-collector-opamp-config.yaml', COLLECTOR_HOME_DIR, options)
+
+                        path = Podman.containersPath(COLLECTOR_HOME_DIR)
+                        linuxConnection.fileReplace("#{path}/SigNoz-Collector.container", '\$VERSION', COLLECTOR_VERSION, options)
+
+                        if target['Listen']
+                            linuxConnection.fileReplace("#{path}/SigNoz-Collector.container", 'PublishPort=127.0.0.1:', "PublishPort=#{target['Listen']}:", options)
+                            linuxConnection.firewallAddPort('4317/tcp', options)
+                            linuxConnection.firewallAddPort('4318/tcp', options)
+                        end
+
+                        linuxConnection.reloadUserServices(COLLECTOR_USER, options)
+                        linuxConnection.restartUserService(COLLECTOR_USER, 'SigNoz-Collector', options)
+                    end
+                end
+            end
+
+            def configureClickHouseSigNoz(target, linuxConnection, activeState, context, options)
+                target['Database'] ||= {}
+                ClickHouse.defaults(target['Database'])
+                username = target['Database']['Username'] || context.secrets.load(target['SecretId'], 'CLICKHOUSE_USERNAME') || USER
+                context.secrets.store(target['SecretId'], 'CLICKHOUSE_USERNAME', username)
+                password = context.secrets.load(target['SecretId'], 'CLICKHOUSE_PASSWORD')
+                if password.nil?
+                    password = SecureRandom.alphanumeric(20)
+                    context.secrets.store(target['SecretId'], 'CLICKHOUSE_PASSWORD', password)
+                end
+
+                ClickHouse.withConnection(target['Database'], linuxConnection, context.secrets, options) do |connection|
+                    connection.createUser(username, password, nil, options)
+                    connection.createDB(DB_ANALYTICS, ClickHouse::DEFAULT_CLUSTER, options)
+                    connection.createDB(DB_METADATA, ClickHouse::DEFAULT_CLUSTER, options)
+                    connection.grantDB('ALL', username, DB_ANALYTICS, nil, options)
+                    connection.grantDB('ALL', username, DB_METADATA, nil, options)
+                    connection.grantDB('ALL', username, DB_TRACES, nil, options)
+                    connection.grantDB('ALL', username, DB_METRICS, nil, options)
+                    connection.grantDB('ALL', username, DB_LOGS, nil, options)
+                    connection.grant('SELECT', username, 'system.clusters', nil, options)
+                    connection.grant('SELECT', username, 'system.distributed_ddl_queue', nil, options)
+                    connection.grant('SELECT', username, 'system.disks', nil, options)
+                    connection.grantCluster(username, nil, options)
+                    connection.grantRemote(username, nil, options)
+                end
+
+                if target['Database']['HostName'] == 'localhost'
+                    target['Database']['HostName'] = HOST_IP
+                end
+                [username, password]
+            end
+
+            def configureClickHouseCollector(target, linuxConnection, activeState, context, options)
+                target['Database'] ||= {}
+                ClickHouse.defaults(target['Database'])
+                username = target['Database']['Username'] || context.secrets.load(target['SecretId'], 'CLICKHOUSE_USERNAME') || 'otel'
+                context.secrets.store(target['SecretId'], 'CLICKHOUSE_USERNAME', username)
+                password = context.secrets.load(target['SecretId'], 'CLICKHOUSE_PASSWORD')
+                if password.nil?
+                    password = SecureRandom.alphanumeric(20)
+                    context.secrets.store(target['SecretId'], 'CLICKHOUSE_PASSWORD', password)
+                end
+
+                ClickHouse.withConnection(target['Database'], linuxConnection, context.secrets, options) do |connection|
+                    connection.createUser(username, password, nil, options)
+                    connection.createDB(DB_TRACES, ClickHouse::DEFAULT_CLUSTER, options)
+                    connection.createDB(DB_METRICS, ClickHouse::DEFAULT_CLUSTER, options)
+                    connection.createDB(DB_LOGS, ClickHouse::DEFAULT_CLUSTER, options)
+                    connection.grantDB('CREATE DATABASE', username, DB_TRACES, nil, options)
+                    connection.grantDB('INSERT', username, DB_TRACES, nil, options)
+                    connection.grantDB('SELECT', username, DB_TRACES, nil, options)
+                    connection.grantDB('INSERT', username, DB_METRICS, nil, options)
+                    connection.grantDB('SELECT', username, DB_METRICS, nil, options)
+                    connection.grantDB('INSERT', username, DB_LOGS, nil, options)
+                    connection.grantDB('SELECT', username, DB_LOGS, nil, options)
+                    connection.grant('SELECT', username, 'system.clusters', nil, options)
+                    connection.grantCluster(username, nil, options)
+                end
+
+                if target['Database']['HostName'] == 'localhost'
+                    target['Database']['HostName'] = HOST_IP
+                end
+                [username, password]
+            end
+
+            def self.buildEndpoint(hostname, port, database, username = nil, password = nil)
+                query = ''
+                if username
+                    username = URI.encode_uri_component(username)
+                    query = "?username=#{username}"
+                    if password
+                        password = URI.encode_uri_component(password)
+                        query += "&password=#{password}"
+                    end
+                end
+                "tcp://#{hostname}:#{port}/#{database}#{query}"
+            end
+
+            def cleanup(configs, state, context, options)
+                cleanupType(:SigNozCollector, configs, state, context, options) do |item, id, state, context, options, connection|
+                    Linux.withConnection(connection) do |linuxConnection|
+                        linuxConnection.stopUserService(USER, 'signoz-otel-collector', options)
+
+                        path = Podman.containersPath(COLLECTOR_HOME_DIR)
+                        linuxConnection.rm(path + 'signoz-otel-collector.container', options[:dry])
+
+                        state.item(id)['Status'] = State::STATUS_DELETED unless options[:dry]
+
+                        if options[:destroy]
+                            username = context.secrets.load(item['Config']['SecretId'], 'CLICKHOUSE_USERNAME')
+                            if !username.nil?
+                                ClickHouse.withConnection(item['Config']['Database'], connection, context.secrets, options) do |connection|
+                                    connection.dropUser(username)
+                                end
+                            end
+                            linuxConnection.deleteUserAndGroup(COLLECTOR_USER, options)
+                            state.item(id)['Status'] = State::STATUS_DESTROYED unless options[:dry]
+                        end
+                    end
+                end
+                cleanupType(:SigNoz, 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('SigNoz', context, options)
+                                nginxConnection.reload(options)
+                            end
+                        elsif item['Config'].key?('Proxy') && item['Config']['Proxy'] == false
+                            linuxConnection.firewallRemovePort('3301/tcp', options)
+                        end
+
+                        linuxConnection.stopUserService(USER, 'SigNoz', options)
+                        linuxConnection.stopUserService(USER, 'SigNoz-Migrator', options)
+
+                        path = Podman.containersPath(HOME_DIR)
+                        linuxConnection.rm(path + 'SigNoz.container', options[:dry])
+                        linuxConnection.rm(path + 'SigNoz-Migrator.container', options[:dry])
+
+                        state.item(id)['Status'] = State::STATUS_DELETED unless options[:dry]
+
+                        if options[:destroy]
+                            ClickHouse.withConnection(item['Config']['Database'], connection, context.secrets, options) do |connection|
+                                username = context.secrets.load(item['Config']['SecretId'], 'CLICKHOUSE_USERNAME')
+                                if !username.nil?
+                                    connection.dropUser(username, nil, options)
+                                end
+                                connection.dropDB(DB_TRACES, ClickHouse::DEFAULT_CLUSTER, options)
+                                connection.dropDB(DB_METRICS, ClickHouse::DEFAULT_CLUSTER, options)
+                                connection.dropDB(DB_LOGS, ClickHouse::DEFAULT_CLUSTER, options)
+                            end
+                            linuxConnection.deleteUserAndGroup(USER, connection, options[:dry])
+                            state.item(id)['Status'] = State::STATUS_DESTROYED unless options[:dry]
+                        end
+                    end
+                end
+            end
+
+        end
+    end
+end

data/Plugins/Apps/Solr/log4j2.xml

@@ -0,0 +1,89 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+      http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+  -->
+
+<!-- Default production configuration is asynchronous logging -->
+<Configuration>
+  <Appenders>
+
+    <Console name="STDOUT" target="SYSTEM_OUT">
+      <JsonTemplateLayout />
+      <!--<PatternLayout>
+        <Pattern>
+          %maxLen{%d{yyyy-MM-dd HH:mm:ss.SSS} %-5p (%t) [%notEmpty{c:%X{collection}}%notEmpty{ s:%X{shard}}%notEmpty{ r:%X{replica}}%notEmpty{ x:%X{core}}%notEmpty{ t:%X{trace_id}}] %c{1.} %m%notEmpty{ =>%ex{short}}}{10240}%n
+        </Pattern>
+      </PatternLayout>-->
+    </Console>
+
+    <RollingRandomAccessFile
+        name="MainLogFile"
+        fileName="${sys:solr.log.dir}/solr.json"
+        filePattern="${sys:solr.log.dir}/solr.json.%i" >
+      <JsonTemplateLayout />
+      <!--<PatternLayout>
+        <Pattern>
+          %maxLen{%d{yyyy-MM-dd HH:mm:ss.SSS} %-5p (%t) [%notEmpty{c:%X{collection}}%notEmpty{ s:%X{shard}}%notEmpty{ r:%X{replica}}%notEmpty{ x:%X{core}}%notEmpty{ t:%X{trace_id}}] %c{1.} %m%notEmpty{ =>%ex{short}}}{10240}%n
+        </Pattern>
+      </PatternLayout>-->
+      <Policies>
+        <OnStartupTriggeringPolicy />
+        <SizeBasedTriggeringPolicy size="32 MB"/>
+      </Policies>
+      <DefaultRolloverStrategy max="10"/>
+    </RollingRandomAccessFile>
+
+    <RollingRandomAccessFile
+        name="SlowLogFile"
+        fileName="${sys:solr.log.dir}/solr_slow_requests.log"
+        filePattern="${sys:solr.log.dir}/solr_slow_requests.log.%i" >
+      <PatternLayout>
+        <Pattern>
+          %maxLen{%d{yyyy-MM-dd HH:mm:ss.SSS} %-5p (%t) [%notEmpty{c:%X{collection}}%notEmpty{ s:%X{shard}}%notEmpty{ r:%X{replica}}%notEmpty{ x:%X{core}}%notEmpty{ t:%X{trace_id}}] %c{1.} %m%notEmpty{ =>%ex{short}}}{10240}%n
+        </Pattern>
+      </PatternLayout>
+      <Policies>
+        <OnStartupTriggeringPolicy />
+        <SizeBasedTriggeringPolicy size="32 MB"/>
+      </Policies>
+      <DefaultRolloverStrategy max="10"/>
+    </RollingRandomAccessFile>
+
+  </Appenders>
+  <Loggers>
+    <!-- Use <AsyncLogger/<AsyncRoot and <Logger/<Root for asynchronous logging or synchronous logging respectively -->
+    <AsyncLogger name="org.apache.hadoop" level="warn"/>
+    <AsyncLogger name="org.apache.solr.update.LoggingInfoStream" level="off"/>
+    <AsyncLogger name="org.apache.zookeeper" level="warn"/>
+    <!-- HttpSolrCall adds markers denoting the handler class to allow fine grained control, metrics are
+         very noisy so by default the metrics handler is turned off to see metrics logging set DENY to ACCEPT -->
+    <AsyncLogger name="org.apache.solr.servlet.HttpSolrCall" level="info">
+      <MarkerFilter marker="org.apache.solr.handler.admin.MetricsHandler" onMatch="DENY" onMismatch="ACCEPT"/>
+    </AsyncLogger>
+    <AsyncLogger name="org.apache.solr.core.SolrCore.SlowRequest" level="info" additivity="false">
+      <AppenderRef ref="SlowLogFile"/>
+    </AsyncLogger>
+    <AsyncLogger name="org.eclipse.jetty.deploy" level="warn"/>
+    <AsyncLogger name="org.eclipse.jetty.webapp" level="warn"/>
+    <AsyncLogger name="org.eclipse.jetty.server.session" level="warn"/>
+
+    <AsyncRoot level="info">
+      <AppenderRef ref="MainLogFile"/>
+      <AppenderRef ref="STDOUT"/>
+    </AsyncRoot>
+  </Loggers>
+</Configuration>
+

data/Plugins/Apps/Solr/solr.lmm.rb

@@ -0,0 +1,82 @@
+
+module ConfigLMM
+    module LMM
+        class Solr < Framework::Plugin
+
+            USER = 'solr'
+            HOME_DIR = '/var/lib/solr'
+            INSTALL_PATH = '/opt/solr'
+            VERSION = '9.8.1'
+            URL = "https://www.apache.org/dyn/closer.lua/solr/solr/#{VERSION}/solr-#{VERSION}.tgz?action=download"
+
+            # Systemd support will be only with 10.x version but we want to already use it
+            INSTALL_SCRIPT = 'https://raw.githubusercontent.com/apache/solr/ccd5ede68bf0cd19be63cda4e35a320842336e07/solr/bin/install_solr_service.sh'
+            SYSTEMD_SERVICE = 'https://raw.githubusercontent.com/apache/solr/ccd5ede68bf0cd19be63cda4e35a320842336e07/solr/bin/systemd/solr.service'
+
+            def actionSolrDeploy(id, target, activeState, context, options)
+                self.withConnection(target['Location'], target) do |connection|
+                    Linux.withConnection(connection) do |linuxConnection|
+                        if linuxConnection.distroName == Linux::ARCH_NAME
+                            linuxConnection.ensurePackage('solr', options)
+                        else
+                            if !linuxConnection.filePresent?(INSTALL_PATH)
+                                linuxConnection.createServiceUser(USER, HOME_DIR, 'Apache Solr', options)
+
+                                linuxConnection.exec("curl --silent --location --output /tmp/solr-#{VERSION}.tgz '#{URL}'", false, options)
+
+                                # FIXME Once Solr 10.x is released
+                                #linuxConnection.exec("tar --extract --strip-components=2 --directory /tmp --file /tmp/solr-#{VERSION}.tgz --wildcards '*/install_solr_service.sh'", false, options)
+                                # BEGIN HACK
+                                linuxConnection.exec("curl --silent --location --output /tmp/install_solr_service.sh '#{INSTALL_SCRIPT}'", false, options)
+                                linuxConnection.exec("curl --silent --location --output /tmp/solr.service '#{SYSTEMD_SERVICE}'", false, options)
+                                linuxConnection.exec("sed -i 's|$SOLR_INSTALL_DIR/bin/systemd|/tmp|' /tmp/install_solr_service.sh", false, options)
+                                linuxConnection.exec("chmod +x /tmp/install_solr_service.sh", false, options)
+                                # END HACK
+
+                                linuxConnection.exec("/tmp/install_solr_service.sh /tmp/solr-#{VERSION}.tgz -u #{USER} -d #{HOME_DIR}", false, options)
+
+                                linuxConnection.exec('rm -rf solr.service', false, options) # CLEANUP HACK
+
+                                linuxConnection.exec("rm -rf /tmp/install_solr_service.sh /tmp/solr-#{VERSION}.tgz", false, options)
+
+                                activeState['Version'] = VERSION
+
+                                # To use JSON logging
+                                linuxConnection.upload(__dir__ + '/log4j2.xml', HOME_DIR, options)
+                                linuxConnection.restartService("solr.service", options)
+                            end
+                        end
+                    end
+                end
+            end
+
+            def cleanup(configs, state, context, options)
+                cleanupType(:Solr, configs, state, context, options) do |item, id, state, context, options, connection|
+                    Linux.withConnection(connection) do |linuxConnection|
+
+                        linuxConnection.stopService('solr.service', options)
+                        linuxConnection.disableService('solr.service', options)
+
+                        linuxConnection.rm('/etc/systemd/system/solr.service', options[:dry])
+
+                        version = state.item(id)['Version']
+                        if !version.to_s.empty?
+                            linuxConnection.rm(INSTALL_PATH, options[:dry])
+                            linuxConnection.rm(INSTALL_PATH + '-' + version, options[:dry])
+                        end
+
+                        state.item(id)['Status'] = State::STATUS_DELETED unless options[:dry]
+
+                        if options[:destroy]
+                            linuxConnection.deleteUserAndGroup(USER, options)
+                            linuxConnection.rm(HOME_DIR, options[:dry])
+                            linuxConnection.rm('/etc/default/solr.in.sh', options[:dry])
+                            state.item(id)['Status'] = State::STATUS_DESTROYED unless options[:dry]
+                        end
+                    end
+                end
+            end
+        end
+    end
+end
+

data/Plugins/Apps/Sunshine/Sunshine.conf.erb

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

data/Plugins/Apps/Sunshine/Sunshine.lmm.rb

@@ -12,7 +12,6 @@ module ConfigLMM
             def actionSunshineDeploy(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/Tunnel/tunnel.lmm.rb

@@ -4,57 +4,53 @@ module ConfigLMM
         class Tunnel < Framework::NginxApp
 
             def actionTunnelDeploy(id, target, activeState, context, options)
-
-                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|
-
-                        Framework::LinuxApp.ensurePackage('socat', ssh)
+                self.withConnection(target['Location'], target) do |connection|
+                    Linux.withConnection(connection) do |linuxConnection|
+                        linuxConnection.ensurePackage('socat', options)
 
                         port = target['Port']
-                        activeState['Port'] = port
-                        activeState['UDP'] = target['UDP']
                         if target['UDP']
                             name = "tunnelUDP-#{port}"
-                            ssh.scp.upload!(__dir__ + '/tunnelUDP.service', "/etc/systemd/system/#{name}.service")
-                            ssh.scp.upload!(__dir__ + '/tunnelUDP.socket', "/etc/systemd/system/#{name}.socket")
-                            self.class.exec("sed -i 's|$PORT|#{port}|' /etc/systemd/system/#{name}.service", ssh)
-                            self.class.exec("sed -i 's|$PORT|#{port}|' /etc/systemd/system/#{name}.socket", ssh)
-                            self.class.exec("sed -i 's|$REMOTE|#{target['Remote']}|' /etc/systemd/system/#{name}.service", ssh)
+                            linuxConnection.upload(__dir__ + '/tunnelUDP.service', "/etc/systemd/system/#{name}.service", options)
+                            linuxConnection.upload(__dir__ + '/tunnelUDP.socket', "/etc/systemd/system/#{name}.socket", options)
+                            linuxConnection.fileReplace("/etc/systemd/system/#{name}.service", '\$PORT', port, options)
+                            linuxConnection.fileReplace("/etc/systemd/system/#{name}.socket", '\$PORT', port, options)
+                            linuxConnection.fileReplace("/etc/systemd/system/#{name}.service", '\$REMOTE', Addressable::IDNA.to_ascii(target['Remote']) , options)
+                            linuxConnection.firewallAddPort("#{port}/udp", options)
                         else
                             name = "tunnelTCP-#{port}"
-                            ssh.scp.upload!(__dir__ + '/tunnelTCP.service', "/etc/systemd/system/#{name}.service")
-                            ssh.scp.upload!(__dir__ + '/tunnelTCP.socket', "/etc/systemd/system/#{name}.socket")
-                            self.class.exec("sed -i 's|$PORT|#{port}|' /etc/systemd/system/#{name}.service", ssh)
-                            self.class.exec("sed -i 's|$PORT|#{port}|' /etc/systemd/system/#{name}.socket", ssh)
-                            self.class.exec("sed -i 's|$REMOTE|#{target['Remote']}|' /etc/systemd/system/#{name}.service", ssh)
+                            linuxConnection.upload(__dir__ + '/tunnelTCP.service', "/etc/systemd/system/#{name}.service", options)
+                            linuxConnection.upload(__dir__ + '/tunnelTCP.socket', "/etc/systemd/system/#{name}.socket", options)
+                            linuxConnection.fileReplace("/etc/systemd/system/#{name}.service", '\$PORT', port, options)
+                            linuxConnection.fileReplace("/etc/systemd/system/#{name}.socket", '\$PORT', port, options)
+                            linuxConnection.fileReplace("/etc/systemd/system/#{name}.service", '\$REMOTE', Addressable::IDNA.to_ascii(target['Remote']), options)
+                            linuxConnection.firewallAddPort("#{port}/tcp", options)
                         end
 
-                        Framework::LinuxApp.reloadServiceManager(ssh)
-                        Framework::LinuxApp.ensureServiceAutoStart(name + '.socket', ssh)
-                        Framework::LinuxApp.stopService(name + '.service', ssh)
-                        Framework::LinuxApp.startService(name + '.socket', ssh)
+                        linuxConnection.reloadServiceManager(options)
+                        linuxConnection.ensureServiceAutoStart(name + '.socket', options)
+                        linuxConnection.stopService(name + '.service', options)
+                        linuxConnection.startService(name + '.socket', options)
                     end
-                else
-                    # TODO
                 end
-                activeState['Status'] = State::STATUS_DEPLOYED
             end
 
             def cleanup(configs, state, context, options)
-                cleanupType(:Tunnel, configs, state, context, options) do |item, id, state, context, options, ssh|
-                    if item['UDP']
-                        name = "tunnelUDP-#{item['Port']}"
-                    else
-                        name = "tunnelTCP-#{item['Port']}"
+                cleanupType(:Tunnel, configs, state, context, options) do |item, id, state, context, options, connection|
+                    Linux.withConnection(connection) do |linuxConnection|
+                        if item['Config']['UDP']
+                            name = "tunnelUDP-#{item['Config']['Port']}"
+                            linuxConnection.firewallRemovePort("#{item['Config']['Port']}/udp", options)
+                        else
+                            name = "tunnelTCP-#{item['Config']['Port']}"
+                            linuxConnection.firewallRemovePort("#{item['Config']['Port']}/tcp", options)
+                        end
+                        linuxConnection.stopService(name + '.socket', options)
+                        linuxConnection.disableService(name + '.socket', options)
+                        linuxConnection.rm("/etc/systemd/system/#{name}.service", options[:dry])
+                        linuxConnection.rm("/etc/systemd/system/#{name}.socket", options[:dry])
+                        state.item(id)['Status'] = State::STATUS_DESTROYED
                     end
-                    Framework::LinuxApp.stopService(name + '.socket', ssh)
-                    Framework::LinuxApp.disableService(name + '.socket', ssh)
-                    rm("/etc/systemd/system/#{name}.service", options[:dry], ssh)
-                    rm("/etc/systemd/system/#{name}.socket", options[:dry], ssh)
-                    state.item(id)['Status'] = State::STATUS_DESTROYED
                 end
             end
 

data/Plugins/Apps/UVdesk/UVdesk.conf.erb

@@ -31,9 +31,6 @@ server
 
     server_name <%= config['Domain'] %>;
 
-    access_log  /var/log/nginx/uvdesk.access.log;
-    error_log   /var/log/nginx/uvdesk.error.log;
-
     root /srv/uvdesk/public;
     index index.php;
 

data/Plugins/Apps/Umami/Umami.container

@@ -0,0 +1,19 @@
+
+[Unit]
+Description=Umami container
+After=local-fs.target
+
+[Container]
+ContainerName=Umami
+Image=docker.umami.is/umami-software/umami:postgresql-latest
+EnvironmentFile=/var/lib/umami/.config/containers/systemd/Umami.env
+Network=slirp4netns:allow_host_loopback=true
+PublishPort=127.0.0.1:13300:3000
+LogDriver=journald
+AutoUpdate=registry
+
+[Service]
+Restart=on-failure
+
+[Install]
+WantedBy=multi-user.target default.target