ConfigLMM 0.2.0 → 0.3.0

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

@@ -1,22 +1,37 @@
 
 server {
 
-    <% if !config['TLS'] %>
-        listen       <%= config['Port'] %>;
-        listen  [::]:<%= config['Port'] %>;
-    <% else %>
-        listen       <%= config['Port'] %> ssl;
-        listen  [::]:<%= config['Port'] %> ssl;
+    <% 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;
-        include config-lmm/ssl.conf;
+        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'] %>;
 
-    root               <%= config['Root'] %>;
-    passenger_app_root /srv/gollum;
-
-    try_files    $uri @Passenger;
+    <% if config['Root'] %>
+        root               <%= config['Root'] %>;
+    <% end %>
 
     access_log  /var/log/nginx/gollum.access.log;
     error_log   /var/log/nginx/gollum.error.log;
@@ -30,12 +45,24 @@ server {
         ssl_trusted_certificate "/etc/letsencrypt/live/<%= config['CertName'] %>/chain.pem";
     <% end %>
 
-    location @Passenger {
-        passenger_enabled on;
-        passenger_min_instances 1;
-        rails_env production;
+    <% if config['Passenger'] %>
+        passenger_app_root /srv/gollum;
 
-        #passenger_set_cgi_param HTTP_X_FORWARDED_PROTO https;
-        #limit_req zone=one burst=5;
-    }
+        try_files    $uri @Passenger;
+
+        location @Passenger {
+            passenger_enabled on;
+            passenger_min_instances 1;
+            rails_env production;
+
+            #passenger_set_cgi_param HTTP_X_FORWARDED_PROTO https;
+            #limit_req zone=one burst=5;
+        }
+    <% else %>
+        location / {
+            proxy_pass <%= config['Server'] %>;
+
+            include config-lmm/proxy.conf;
+        }
+    <% end %>
 }

data/Plugins/Apps/gollum/gollum.container

@@ -0,0 +1,12 @@
+[Unit]
+Description=gollum container
+After=local-fs.target
+
+[Container]
+Image=gollumwiki/gollum:master
+PublishPort=0.0.0.0:14567:4567
+UserNS=keep-id:uid=1000,gid=1000
+Volume=/srv/gollum/repo:/wiki
+
+[Install]
+WantedBy=multi-user.target default.target

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

@@ -4,12 +4,11 @@ module ConfigLMM
         class Gollum < Framework::NginxApp
 
             NAME = 'gollum'
+            USER = 'gollum'
             GOLLUM_PATH = '/srv/gollum'
+            HOME_DIR = '/var/lib/authentik'
 
             def actionGollumBuild(id, target, activeState, context, options)
-                if !target['Root'] && (!target['Location'] || target['Location'] == '@me')
-                    target['Root'] = File.dirname(`gem which gollum`.strip) + '/gollum/public'
-                end
                 writeNginxConfig(__dir__, NAME, id, target, activeState, context, options)
                 targetDir = options['output'] + GOLLUM_PATH
                 mkdir(targetDir, options['dry'])
@@ -22,16 +21,46 @@ module ConfigLMM
             end
 
             def actionGollumDeploy(id, target, activeState, context, options)
-                if !target['Location'] || target['Location'] == '@me'
+                if target['Location'] && target['Location'] != '@me'
+                    uri = Addressable::URI.parse(target['Location'])
+                    self.class.sshStart(uri) do |ssh|
+                        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'
+                            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)
+                            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}@ start gollum")
+                        end
+                    end
+                else
                     targetDir = GOLLUM_PATH
                     mkdir(targetDir, options['dry'])
-                    deployNginxConfig(id, target, activeState, context, options)
-                    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'])
+                    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'
-                else
-                    # TODO
                 end
             end
 

data/Plugins/OS/Linux/Distributions.yaml

@@ -4,3 +4,13 @@ opensuse-leap:
     InstallPackage: zypper install --no-confirm
     AutoStartService: systemctl enable
     StartService: systemctl start
+    CreateServiceUser: useradd --system --shell /usr/sbin/nologin --user-group
+    ModifyUser: usermod
+
+arch:
+    Name: Arch Linux
+    InstallPackage: pacman -S --noconfirm --needed
+    AutoStartService: systemctl enable
+    StartService: systemctl start
+    CreateServiceUser: useradd --system --shell /usr/sbin/nologin --user-group
+    ModifyUser: usermod

data/Plugins/OS/Linux/Linux.lmm.rb

@@ -10,8 +10,11 @@ module ConfigLMM
 
             ISO_LOCATION = '~/.cache/configlmm/images/'
             HOSTS_FILE = '/etc/hosts'
+            FSTAB_FILE = '/etc/fstab'
             SSH_CONFIG = '~/.ssh/config'
-            SYSCTL_FILE = '/etc/sysctl.d/10-configlmm.conf'
+            SYSCTL_FILE = '/etc/sysctl.d/90-configlmm.conf'
+            FIREWALL_PACKAGE = 'firewalld'
+            FIREWALL_SERVICE = 'firewalld'
 
             def actionLinuxBuild(id, target, activeState, context, options)
                 prepareConfig(target)
@@ -33,8 +36,7 @@ module ConfigLMM
                         raise Framework::PluginProcessError.new("#{id}: Unknown protocol: #{uri.scheme}!")
                     end
                 else
-                    deployLocalHostsFile(target, options)
-                    deployLocalSSHConfig(target, options)
+                    deployLocal(target, options)
                 end
                 if target['AlternativeLocation']
                     uri = Addressable::URI.parse(target['AlternativeLocation'])
@@ -44,31 +46,162 @@ module ConfigLMM
             end
 
             def deployOverSSH(locationUri, id, target, activeState, context, options)
-                if target['Domain'] || target['Hosts']
-                    hostsLines = []
-                    if target['Domain']
-                        self.class.sshStart(locationUri) do |ssh|
+                self.class.sshStart(locationUri) do |ssh|
+                    if target['Domain'] || target['Hosts']
+                        hostsLines = []
+                        if target['Domain']
                             envs = self.class.sshExec!(ssh, "env").split("\n")
                             envVars = Hash[envs.map { |vars| vars.split('=', 2) }]
                             ipAddr = envVars['SSH_CONNECTION'].split[-2]
                             hostsLines << ipAddr.ljust(16) + target['Domain'] + ' ' + target['Name'] + "\n"
                         end
-                    end
-                    target['Hosts'].to_a.each do |ip, entries|
+                        target['Hosts'].to_a.each do |ip, entries|
                             hostsLines << ip.ljust(16) + entries.join(' ') + "\n"
+                        end
+                        updateRemoteFile(ssh, HOSTS_FILE, options, false) do |fileLines|
+                            fileLines + hostsLines
+                        end
                     end
-                    updateRemoteFile(locationUri, HOSTS_FILE, options, false) do |fileLines|
-                        fileLines + hostsLines
+                    distroInfo = self.class.currentDistroInfo(ssh)
+                    if target['Network']
+                        if distroInfo['Name'] == 'openSUSE Leap'
+                            networkFile = '/etc/sysconfig/network/ifcfg-eth0'
+                            if target['Network'] == 'dhcp'
+                                self.class.sshExec!(ssh, "sed -i \"s|^BOOTPROTO=.*|BOOTPROTO='dhcp'|\" #{networkFile}")
+                            else
+                                self.class.sshExec!(ssh, "sed -i \"s|^BOOTPROTO=.*|BOOTPROTO='static'|\" #{networkFile}")
+                                updateRemoteFile(ssh, networkFile, options, false) do |fileLines|
+                                    fileLines << "\n"
+                                    if target['Network']['IP']
+                                        if target['Network']['IP'].is_a?(Array)
+                                            # TODO
+                                        else
+                                            self.class.sshExec!(ssh, "sed -i 's|^IPADDR=|#IPADDR=|' #{networkFile}")
+                                            fileLines << "IPADDR=#{target['Network']['IP']}\n"
+                                        end
+                                    end
+                                    fileLines
+                                end
+                                if target['Network']['DNS']
+                                    configFile = '/etc/sysconfig/network/config'
+                                    dns = target['Network']['DNS']
+                                    dns = [dns] unless dns.is_a?(Array)
+                                    self.class.sshExec!(ssh, "sed -i 's|^NETCONFIG_DNS_STATIC_SERVERS=.*|NETCONFIG_DNS_STATIC_SERVERS=\"#{dns.join(' ')}\"|' #{configFile}")
+                                end
+                                if target['Network']['Gateway']
+                                    routesFile = '/etc/sysconfig/network/routes'
+                                    self.class.sshExec!(ssh, "sed -i 's|^default |#default |' #{routesFile}")
+                                    updateRemoteFile(ssh, routesFile, options) do |fileLines|
+                                        fileLines << "default #{target['Network']['Gateway']}\n"
+                                    end
+                                end
+                            end
+                        else
+                            # TODO
+                            raise 'Not Unimplemented!'
+                        end
+                    end
+                    if target['Tmpfs']
+                        self.class.sshExec!(ssh, "sed -i '/ \\/tmp /d' #{FSTAB_FILE}")
+                        updateRemoteFile(ssh, FSTAB_FILE, options, false) do |fileLines|
+                            fileLines << "tmpfs                                      /tmp                    tmpfs  nodev,nosuid,size=#{target['Tmpfs']}          0  0\n"
+                        end
                     end
+                    if target['Sysctl']
+                        updateRemoteFile(ssh, SYSCTL_FILE, options, false) do |fileLines|
+                            target['Sysctl'].each do |name, value|
+                                fileLines << "#{name} = #{value}\n"
+                                self.class.sshExec!(ssh, "sysctl #{name}=#{value}")
+                            end
+                            fileLines
+                        end
+                    end
+                    if target['Users']
+                        target['Users'].each do |name, info|
+                            userId = ssh.exec!("id -u #{name} 2>/dev/null").strip
+                            if userId.empty?
+                                shell = ''
+                                if info['Shell']
+                                    shell = "--shell '/usr/bin/#{info['Shell']}'"
+                                end
+                                badname = '--badname'
+                                badname = '--badnames' if distroInfo['Name'] == 'openSUSE Leap'
+                                self.class.sshExec!(ssh, "useradd #{badname} --create-home --user-group #{shell} #{name}")
+                            end
+                            homeDir = self.class.sshExec!(ssh, "getent passwd #{name} | cut -d ':' -f 6").strip
+                            keyFile = homeDir + "/.ssh/id_ed25519"
+                            if info['SSHKey'] && !self.class.remoteFilePresent?(keyFile, ssh)
+                                self.class.sshExec!(ssh, "mkdir -p #{homeDir}/.ssh")
+                                self.class.sshExec!(ssh, "ssh-keygen -t ed25519 -f #{keyFile} -P ''")
+                                self.class.sshExec!(ssh, "chown -R #{name}:#{name} #{homeDir}/.ssh")
+                            end
+                        end
+                    end
+                    self.executeCommands(target['Execute'], ssh)
+                end
+                if target['Firewall'] && target['Firewall'] != 'no'
+                    self.ensurePackage(FIREWALL_PACKAGE, locationUri)
+                    self.ensureServiceAutoStart(FIREWALL_SERVICE, locationUri)
+                    self.startService(FIREWALL_SERVICE, locationUri)
                 end
+            end
+
+            def deployLocal(target, options)
+                deployLocalHostsFile(target, options)
+                deployLocalSSHConfig(target, options)
                 if target['Sysctl']
-                    updateRemoteFile(locationUri, SYSCTL_FILE, options, false) do |fileLines|
+                    updateLocalFile(SYSCTL_FILE, options) do |fileLines|
                         target['Sysctl'].each do |name, value|
                             fileLines << "#{name} = #{value}\n"
+                            `sysctl #{name}=#{value}`
                         end
                         fileLines
                     end
                 end
+                if target['Users']
+                    target['Users'].each do |name, info|
+                        userId = self.class.exec("id -u #{name} 2>/dev/null", nil, true).strip
+                        if userId.empty?
+                            shell = ''
+                            if info['Shell']
+                                shell = "--shell '/usr/bin/#{info['Shell']}'"
+                            end
+                            distroInfo = self.class.currentDistroInfo(nil)
+                            badname = '--badname'
+                            badname = '--badnames' if distroInfo['Name'] == 'openSUSE Leap'
+                            self.class.exec("useradd #{badname} --create-home --user-group #{shell} #{name}")
+                        end
+                        homeDir = self.class.exec("getent passwd #{name} | cut -d ':' -f 6").strip
+                        keyFile = homeDir + "/.ssh/id_ed25519"
+                        if info['SSHKey'] && !self.class.filePresent?(keyFile)
+                            self.class.exec("mkdir -p #{homeDir}/.ssh")
+                            self.class.exec("ssh-keygen -t ed25519 -f #{keyFile} -P ''")
+                            self.class.exec("chown -R #{name}:#{name} #{homeDir}/.ssh")
+                        end
+                    end
+                end
+                if target['Firewall'] && target['Firewall'] != 'no'
+                    self.ensurePackage(FIREWALL_PACKAGE, locationUri)
+                    self.ensureServiceAutoStart(FIREWALL_SERVICE, locationUri)
+                    self.startService(FIREWALL_SERVICE, locationUri)
+                end
+                self.executeCommands(target['Execute'])
+            end
+
+            def executeCommands(commands, ssh = nil)
+                return unless commands
+
+                commands.each do |type, data|
+                    case type
+                    when 'sh'
+                        data = [data] unless data.is_a?(Array)
+                        data.each do |cmd|
+                            self.class.exec(cmd, ssh)
+                        end
+                    else
+                        raise 'Unimplemented!'
+                    end
+                end
             end
 
             def deployOverLibvirt(id, target, activeState, context, options)

data/Plugins/OS/Linux/Packages.yaml

@@ -1,13 +1,51 @@
 Arch Linux:
-    sshd: openssh
-    Postfix: postfix
+    Cassandra: AUR|cassandra
+    CertBotNginx:
+        - certbot-nginx
+        - certbot-dns-rfc2136
+    CyrusSASL: cyrus-sasl
     Dovecot: dovecot
+    firewalld: firewalld
+    Nextcloud: nextcloud
+    nginx: nginx
+    PHP-FPM: php-fpm
+    php-pecl: php-pecl
+    Podman: podman
     PostgreSQL: postgresql
+    Postfix: postfix
+    PowerDNS: powerdns
+    sshd: openssh
     Valkey: redis
+    WireGuard: wireguard-tools
+    Yarn: yarn
 
 openSUSE Leap:
-    sshd: openssh
-    Postfix: postfix
+    Cassandra: home:davispuh:branches:server:database|cassandra
+    CertBotNginx:
+        - python3-certbot-nginx
+        - certbot-systemd-timer
+        - python3-certbot-dns-rfc2136
+    CyrusSASL: cyrus-sasl-plain
     Dovecot: dovecot
+    firewalld: firewalld
+    Nextcloud: server:php:applications|nextcloud
+    nginx: nginx
+    PHP-FPM:
+        - php8-devel
+        - php8-mbstring
+        - php8-fpm
+        - php8-redis
+        - php8-pgsql
+        - php8-mysql
+    php-pecl: php8-pecl
+    Podman: podman
     PostgreSQL: postgresql-server
+    Postfix: postfix
+    PowerDNS:
+        - pdns-backend-geoip
+        - pdns-backend-sqlite3
+        - pdns-backend-postgresql
+    sshd: openssh
     Valkey: redis
+    WireGuard: wireguard-tools
+    Yarn: yarn

data/Plugins/OS/Linux/WireGuard/WireGuard.lmm.rb

@@ -0,0 +1,108 @@
+
+module ConfigLMM
+    module LMM
+        class WireGuard < Framework::LinuxApp
+
+            WIREGUARD_PACKAGE = 'WireGuard'
+            SERVICE_NAME = 'wg-quick@wg0'
+            CONFIG_FILE = '/etc/wireguard/wg0.conf'
+            PORT = '51820'
+            SUBNET = '172.20.0.0/20'
+
+            persistBuildDir
+
+            def actionWireGuardDeploy(id, target, activeState, context, options)
+                self.prepareConfig(target)
+                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|
+                        sharedKey = self.class.sshExec!(ssh, "firewall-cmd -q --permanent --add-port='#{PORT}'/udp")
+                        sharedKey = self.class.sshExec!(ssh, "firewall-cmd -q --permanent --zone=trusted --add-source=#{SUBNET}")
+                        sharedKey = self.class.sshExec!(ssh, "firewall-cmd -q --permanent --direct --add-rule ipv4 nat POSTROUTING 0 -s #{SUBNET} ! -d #{SUBNET} -j MASQUERADE")
+
+                        self.class.ensurePackages([WIREGUARD_PACKAGE], ssh)
+                        self.class.ensureServiceAutoStartOverSSH(SERVICE_NAME, ssh)
+
+                        dir = options['output'] + '/' + id + '/etc/wireguard/'
+                        mkdir(dir, false)
+                        template = ERB.new(File.read(__dir__ + '/wg0.conf.erb'))
+
+                        if self.class.remoteFilePresent?(CONFIG_FILE, ssh)
+                            # TODO Implement adding and removing peers
+                        else
+                            if !target['PrivateKey']
+                                target['PrivateKey'] = ENV['WIREGUARD_PRIVATEKEY_' + id]
+                                if !target['PrivateKey']
+                                    target['PrivateKey'] = genkeyOverSSH(ssh)
+                                end
+                            end
+                            publicKey = pubkeyOverSSH(target['PrivateKey'], ssh)
+                            self.class.sshExec!(ssh, "echo '#{publicKey}' > /etc/wireguard/pubkey")
+                            target['Peers'].each do |name, data|
+                                if !data['PublicKey']
+                                    data['PrivateKey'] = genkeyOverSSH(ssh)
+                                    data['PublicKey'] = pubkeyOverSSH(data['PrivateKey'], ssh)
+                                end
+                                if !data['PresharedKey']
+                                    data['PresharedKey'] = ENV['WIREGUARD_PRESHAREDKEY_' + id + '_' + name]
+                                    if !data['PresharedKey']
+                                        data['PresharedKey'] = genpskOverSSH(ssh)
+                                    end
+                                end
+                            end
+
+                            target['Peers'].each do |name, data|
+                                templateData = {}
+                                templateData['Address'] = target['Address']
+                                templateData['PrivateKey'] = data['PrivateKey']
+                                templateData['Peers'] = {}
+                                templateData['Peers'][id] = { 'PublicKey' => publicKey, 'PresharedKey' => data['PresharedKey'] }
+                                target['Peers'].each do |otherName, otherData|
+                                    next if name == otherName
+                                    pskIdB = 'PresharedKey_' + otherName + '_' + name
+                                    if otherData.key?(pskIdB)
+                                        psk = otherData[pskIdB]
+                                    else
+                                        pskIdA = 'PresharedKey_' + name + '_' + otherName
+                                        data[pskIdA] = genpskOverSSH(ssh)
+                                        psk = data[pskIdA]
+                                    end
+                                    templateData['Peers'][otherName] = { 'PublicKey' => otherData['PublicKey'], 'PresharedKey' => psk }
+                                end
+
+                                renderTemplate(template, templateData, dir + name + '.conf', options)
+                            end
+
+                            renderTemplate(template, target, dir + 'wg0.conf', options)
+                            ssh.scp.upload!(dir + 'wg0.conf', CONFIG_FILE)
+                        end
+
+                    end
+                else
+                    # TODO
+                end
+                self.startService(SERVICE_NAME, target['Location'])
+            end
+
+            def genkeyOverSSH(ssh)
+              self.class.sshExec!(ssh, 'wg genkey')
+            end
+
+            def genpskOverSSH(ssh)
+              self.class.sshExec!(ssh, 'wg genpsk')
+            end
+
+            def pubkeyOverSSH(privateKey, ssh)
+              self.class.sshExec!(ssh, " echo '#{privateKey}' | wg pubkey")
+            end
+
+            def prepareConfig(target)
+                target['Address'] = '172.20.0.1' unless target['Address']
+                target['Peers'].each do |name, data|
+                    data['AllowedIPs'] = SUBNET unless data['AllowedIPs']
+                end
+            end
+        end
+    end
+end

data/Plugins/OS/Linux/WireGuard/wg0.conf.erb

@@ -0,0 +1,15 @@
+[Interface]
+Address = <%= config['Address'] %>
+ListenPort = 51820
+PrivateKey = <%= config['PrivateKey'] %>
+
+<% config['Peers'].to_h.each do |name, peer| %>
+# <%= name %>
+[Peer]
+PublicKey = <%= peer['PublicKey'] %>
+PresharedKey = <%= peer['PresharedKey'] %>
+AllowedIPs = <%= peer['AllowedIPs'] %>
+<% if peer['Endpoint'] %>
+Endpoint = <%= peer['Endpoint'] %>:51820
+<% end %>
+<% end %>

data/Plugins/OS/Linux/systemd/systemd.lmm.rb

@@ -0,0 +1,28 @@
+
+module ConfigLMM
+    module LMM
+        class Systemd < Framework::LinuxApp
+
+            SYSTEMD_CONFIG_PATH = '/etc/systemd/system/'
+            USER_SERVICE_DIR = '/etc/systemd/system/user@.service.d/'
+
+            def actionSystemdDeploy(id, target, activeState, context, options)
+                if target['Location'] && target['Location'] != '@me'
+                    if target['UserCgroups']
+                        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|
+                            self.class.sshExec!(ssh, "mkdir -p #{USER_SERVICE_DIR}")
+                            ssh.scp.upload!(__dir__ + '/user-0.slice', SYSTEMD_CONFIG_PATH)
+                            ssh.scp.upload!(__dir__ + '/user@.service.d/delegate.conf', USER_SERVICE_DIR)
+                        end
+                    end
+                else
+                    # TODO
+                end
+
+            end
+
+        end
+    end
+end

data/Plugins/OS/Linux/systemd/user-0.slice

@@ -0,0 +1,9 @@
+
+[Unit]
+Before=systemd-logind.service
+
+[Slice]
+Slice=user.slice
+
+[Install]
+WantedBy=multi-user.target

data/Plugins/OS/Linux/systemd/user@.service.d/delegate.conf

@@ -0,0 +1,3 @@
+
+[Service]
+Delegate=memory pids

data/Plugins/Platforms/GoDaddy/GoDaddy.lmm.rb

@@ -26,8 +26,12 @@ module ConfigLMM
                     data.each do |name, data|
                         self.processDNS(domain, data).each do |type, records|
                             records.each do |record|
-                                shortName = Addressable::IDNA.to_ascii(name)
-                                record[:content] = Addressable::IDNA.to_ascii(record[:content]) if record[:type] == 'CNAME'
+                                shortName = Addressable::IDNA.to_ascii(name) + '.' if type == 'CNAME' || type == 'ALIAS'
+                                if record[:type] == 'MX'
+                                    priority, name = record[:content].split(' ')
+                                    name = Addressable::IDNA.to_ascii(name) + '.'
+                                    record[:content] = [priority, name].join(' ')
+                                end
                                 config['Records'] += [shortName, record[:ttl], ' IN ', record[:type], record[:content]].join("\t") + "\n"
                             end
                         end