ConfigLMM 0.2.0 → 0.3.0

data/Plugins/Services/DNS/PowerDNS.lmm.rb

@@ -13,6 +13,9 @@ module ConfigLMM
             DEFAULT_HOST = 'localhost'
             DEFAULT_PORT = 8081
             SSH_TIMEOUT = 10
+            PACKAGE_NAME = 'PowerDNS'
+            SERVICE_NAME = 'pdns'
+            USER = 'pdns'
 
             # TODO
             # def actionPowerDNSValidate(id, target, activeState, context, options)
@@ -21,6 +24,7 @@ module ConfigLMM
 
             def actionPowerDNSBuild(id, target, activeState, context, options)
                 if target['Settings']
+                    prepareSettings(target)
                     targetDir = options['output'] + CONFIG_DIR + '/'
                     mkdir(targetDir, options['dry'])
                     content = ''
@@ -44,7 +48,7 @@ module ConfigLMM
             def actionPowerDNSDeploy(id, target, activeState, context, options)
                 #actionPowerDNSDiff(id, target, activeState, context, options)
 
-                deploySettings(target)
+                deploySettings(target, options)
                 if target['DNS']
                     connect(id, target, activeState, context, options) do |host, port, key|
                         updateDNS(host, port, key, target['DNS'])
@@ -103,8 +107,8 @@ module ConfigLMM
                     rrsets = []
                     remove = []
                     info.each do |name, data|
-                        fullName = name + '.' + domain + '.'
-                        fullName = domain + '.' if name == '@'
+                        fullName = Addressable::IDNA.to_ascii(name) + '.' + Addressable::IDNA.to_ascii(domain) + '.'
+                        fullName = Addressable::IDNA.to_ascii(domain) + '.' if name == '@'
                         self.processDNS(domain, data).each do |type, records|
                             #remove += removeConflicting(zone, fullName, type)
                             rrset = {
@@ -115,6 +119,12 @@ module ConfigLMM
                                 records: []
                             }
                             records.each do |record|
+                                record[:content] = Addressable::IDNA.to_ascii(record[:content]) + '.' if type == 'CNAME' || type == 'ALIAS'
+                                if type == 'MX'
+                                    priority, name = record[:content].split(' ')
+                                    name = Addressable::IDNA.to_ascii(name) + '.'
+                                    record[:content] = [priority, name].join(' ')
+                                end
                                 rrset[:records] << { content: record[:content], disabled: false }
                             end
                             rrsets << rrset
@@ -129,12 +139,65 @@ module ConfigLMM
 
             end
 
-            def deploySettings(target)
-                if target['Settings']
-                    # TODO
+            def prepareSettings(target)
+                if !target['Settings'].key?('api')
+                    target['Settings']['api'] = 'yes'
+                end
+                if !target['Settings'].key?('expand-alias')
+                    target['Settings']['expand-alias'] = 'yes'
+                end
+                if !target['Settings'].key?('launch')
+                    target['Settings']['launch'] = 'gpgsql'
+                    target['Settings']['gpgsql-host'] = '/run/postgresql'
+                    target['Settings']['gpgsql-user'] = USER
+                    target['Settings']['gpgsql-dbname'] = USER
+                end
+            end
+
+            def deploySettings(target, options)
+                if target['Location']
+                    uri = Addressable::URI.parse(target['Location'])
+                    params = {}
+                    params = CGI.parse(uri.query) if uri.query
+                    if uri.scheme == 'ssh' && !params.key?('host')
+                        self.class.sshStart(uri) do |ssh|
+                            Framework::LinuxApp.ensurePackages([PACKAGE_NAME], ssh)
+                            Framework::LinuxApp.ensureServiceAutoStartOverSSH(SERVICE_NAME, ssh)
+                            if target['Settings']
+                                prepareSettings(target)
+                                self.class.sshExec!(ssh, "mkdir -p #{CONFIG_DIR}")
+                                self.class.sshExec!(ssh, "sed -i 's|# include-dir=|include-dir=#{CONFIG_DIR}|' /etc/pdns/pdns.conf")
+                                ssh.scp.upload!(options['output'] + CONFIG_DIR + '/configlmm.conf', CONFIG_DIR + '/configlmm.conf')
+                                apiKeyFile = CONFIG_DIR + '/apiKey.conf'
+                                if !self.class.remoteFilePresent?(apiKeyFile, ssh)
+                                    apiKey = ENV['POWERDNS_API_KEY']
+                                    apiKey = SecureRandom.urlsafe_base64(60) unless apiKey
+                                    self.class.sshExec!(ssh, " echo 'api-key=#{apiKey}' > #{apiKeyFile}")
+                                    self.class.sshExec!(ssh, " chown #{USER}:#{USER} #{apiKeyFile}")
+                                    self.class.sshExec!(ssh, " chmod 400 #{apiKeyFile}")
+                                    prompt.say("PowerDNS API Key: #{apiKey}", )
+                                end
+                                self.configurePostgreSQL(target['Settings'], ssh)
+                            end
+                            Framework::LinuxApp.startServiceOverSSH(SERVICE_NAME, ssh)
+                        end
+                    end
                 end
             end
 
+            def configurePostgreSQL(settings, ssh)
+                password = SecureRandom.alphanumeric(20)
+                if settings['gpgsql-host'] == 'localhost' || settings['gpgsql-host'].start_with?('/')
+                    PostgreSQL.createUserAndDBOverSSH(USER, password, ssh)
+                    PostgreSQL.importSQL(USER, USER, '/usr/share/doc/packages/pdns/schema.pgsql.sql', ssh)
+                else
+                    self.class.sshStart("ssh://#{settings['gpgsql-host']}/") do |ssh|
+                        PostgreSQL.createUserAndDBOverSSH(USER, password, ssh)
+                        PostgreSQL.importSQL(USER, USER, '/usr/share/doc/packages/pdns/schema.pgsql.sql', ssh)
+                    end
+                end
+                password
+            end
 
             def connect(id, target, activeState, context, options)
                 host = DEFAULT_HOST

data/README.md

@@ -221,6 +221,12 @@ First you need to have Ruby and RubyGems. Then you can install it with:
 
     $ gem install ConfigLMM
 
+If that doesn't work (eg. your Ruby is too old) then install with (it will install [RVM](https://rvm.io/))
+
+```
+$ curl -sS https://raw.githubusercontent.com/ConfigLMM/ConfigLMM/master/bootstrap.sh | sh
+```
+
 ## Usage
 
 Create yaml file with desired config, eg.

data/bootstrap.sh

@@ -0,0 +1,54 @@
+#!/usr/bin/sh
+
+distro=$(cat /etc/os-release | grep ^ID= |  cut -d '=' -f 2 | cut -d '"' -f 2)
+
+function admin {
+    if [ "$EUID" -eq "0" ]; then
+        "$@"
+    else
+        sudo "$@"
+    fi
+}
+
+
+case $distro in
+
+opensuse-leap)
+    admin zypper install --no-confirm ruby libvirt-devel
+    ;;
+
+arch)
+    admin pacman -S --noconfirm --needed ruby rubygems
+    ;;
+
+*)
+    if ! command -v ruby &> /dev/null
+    then
+        echo "Ruby not found!" >&2
+        echo "Don't know how to install it for your $distro distribution!" >&2
+        echo "Submit a PR :)" >&2
+        exit 1
+    fi
+    ;;
+esac
+
+if ! command -v gem &> /dev/null; then
+    echo "RubyGems not found!" >&2
+    exit 2
+fi
+
+rubyTooOld=$(ruby -e 'puts RUBY_VERSION.to_f < 3.3 ? 1 : 0')
+
+if [ "$rubyTooOld" -eq "1" ]; then
+    echo "Ruby is too old! Will install RVM" >&2
+    gpg2 --keyserver hkp://keyserver.ubuntu.com --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3 7D2BAF1CF37B13E2069D6956105BD0E739499BDB >/dev/null
+    curl -sSL https://get.rvm.io | bash -s stable --ruby=3.3.4
+    source /etc/profile.d/rvm.sh
+
+    if [ "$SHELL" = "/usr/bin/fish" ]; then
+        curl -L --create-dirs -o ~/.config/fish/functions/rvm.fish https://raw.github.com/lunks/fish-nuggets/master/functions/rvm.fish
+        echo "rvm default" >> ~/.config/fish/config.fish
+    fi
+fi
+
+gem install ConfigLMM

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

@@ -23,8 +23,7 @@ module ConfigLMM
 
                 items.each do |item|
                     type, content = item.strip.split('=')
-                    content += '.' if type == 'CNAME' || type == 'ALIAS'
-                    content = domain + '.' if content == '@' || content == '@.'
+                    content = domain if content == '@'
                     content = self.class.externalIp if content == '@me'
                     records[type] ||= []
                     records[type] << { type: type, content: content, ttl: DEFAULT_TTL }

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

@@ -8,29 +8,80 @@ module ConfigLMM
             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.ensurePackage(name, location)
+              self.class.ensurePackages([name], location)
             end
 
-            def self.ensurePackage(name, location)
+            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.ensurePackageOverSSH(name, uri)
+                    self.class.ensureServiceAutoStartOverSSH(name, uri)
                 else
                     # TODO
                 end
             end
 
-            def self.ensurePackageOverSSH(name, locationOrSSH)
-
+            def self.ensureServiceAutoStartOverSSH(name, locationOrSSH)
                 closure = Proc.new do |ssh|
-                    distroInfo = self.distroInfoFromSSH(ssh)
-                    pkgs = self.mapPackages([name], distroInfo['Name']).first
+                    distroInfo = self.currentDistroInfo(ssh)
 
-                    pkgs = [pkgs] unless pkgs.is_a?(Array)
-                    command = distroInfo['InstallPackage'] + ' ' + pkgs.map { |pkg| pkg.shellescape }.join(' ')
+                    command = distroInfo['AutoStartService'] + ' ' + name.shellescape
                     self.sshExec!(ssh, command)
                 end
 
@@ -39,38 +90,69 @@ module ConfigLMM
                         closure.call(ssh)
                     end
                 else
-                  closure.call(locationOrSSH)
+                    closure.call(locationOrSSH)
                 end
-
             end
 
-            def ensureServiceAutoStart(name, location)
+            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.sshStart(uri) do |ssh|
-                        distroInfo = self.class.distroInfoFromSSH(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
 
-                        command = distroInfo['AutoStartService'] + ' ' + name.shellescape
-                        self.class.sshExec!(ssh, command)
+                if locationOrSSH.is_a?(String) || locationOrSSH.is_a?(Addressable::URI)
+                    self.sshStart(locationOrSSH) do |ssh|
+                        closure.call(ssh)
                     end
                 else
-                    # TODO
+                    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.sshStart(uri) do |ssh|
-                        distroInfo = self.class.distroInfoFromSSH(ssh)
 
-                        command = distroInfo['StartService'] + ' ' + name.shellescape
-                        self.class.sshExec!(ssh, command)
+            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
-                    # TODO
+                    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
 
@@ -80,7 +162,11 @@ module ConfigLMM
                 packages.to_a.each do |pkg|
                     packageName = distroPackages[distroName][pkg]
                     if packageName
-                        names << packageName
+                        if packageName.is_a?(Array)
+                            names += packageName
+                        else
+                            names << packageName
+                        end
                     else
                         names << pkg.downcase
                     end
@@ -88,20 +174,56 @@ module ConfigLMM
                 names
             end
 
-            def self.createSubuidsOverSSH(user, distroInfo, ssh)
-                self.sshExec!(ssh, "#{distroInfo['ModifyUser']} --add-subuids 100000-165535 --add-subgids 100000-165535 #{user}")
+            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.distroID
-                `cat /etc/os-release | grep "^ID=" | cut -d "=" -f 2`.strip.gsub('"', '')
+            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.distroIDfromSSH(ssh)
-                ssh.exec!('cat /etc/os-release | grep "^ID=" | cut -d "=" -f 2').strip.gsub('"', '')
+            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.distroInfoFromSSH(ssh)
-                distroInfo = self.distroInfo(self.distroIDfromSSH(ssh))
+            def self.currentDistroInfo(ssh)
+                self.distroInfo(self.distroID(ssh))
             end
 
             def self.distroInfo(distroID)

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

@@ -7,6 +7,7 @@ require 'http'
 require 'fileutils'
 require 'net/ssh'
 require 'net/scp'
+require 'open3'
 
 module ConfigLMM
     module Framework
@@ -146,25 +147,41 @@ 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)
+            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(CONFIGLMM_SECTION_BEGIN)
-                sectionEndIndex = fileLines.index(CONFIGLMM_SECTION_END)
+                sectionBeginIndex = fileLines.index(sectionBegin)
+                sectionEndIndex = fileLines.index(sectionEnd)
                 if sectionBeginIndex.nil?
                     linesBefore = []
                     linesBefore = fileLines unless atTop
                     linesBefore << "\n"
-                    linesBefore << CONFIGLMM_SECTION_BEGIN
-                    linesAfter = [CONFIGLMM_SECTION_END]
+                    linesBefore << sectionBegin
+                    linesAfter = [sectionEnd]
                     linesAfter << "\n"
                     linesAfter += fileLines if atTop
                 else
                     linesBefore = fileLines[0..sectionBeginIndex]
                     if sectionEndIndex.nil?
-                        linesAfter = [CONFIGLMM_SECTION_END]
+                        linesAfter = [sectionEnd]
                         linesAfter << "\n"
                     else
                         linesAfter = fileLines[sectionEndIndex..fileLines.length]
@@ -178,14 +195,14 @@ module ConfigLMM
                 fileWrite(file, fileLines.join(), options[:dry])
             end
 
-            def updateRemoteFile(locationOrSSH, file, options, atTop = false, &block)
+            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, &block)
+                    updateLocalFile(localFile, options, atTop, comment, &block)
                     ssh.scp.upload!(localFile, file)
                 end
 
@@ -201,14 +218,23 @@ module ConfigLMM
                 end
             end
 
-            def self.remoteFilePresent?(file, ssh)
-                result = self.sshExec!(ssh, "stat #{file}", true)
+            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)
+                if !self.remoteFilePresent?(target, ssh)
                     ssh.scp.upload!(file, target)
                 end
             end
@@ -217,7 +243,21 @@ module ConfigLMM
                 target += '/' + File.basename(folder) + '/'
                 self.sshExec!(ssh, "mkdir -p #{target}")
                 Dir[folder + '/*'].each do |file|
-                    ssh.scp.upload!(file, target + File.basename(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
 

data/lib/ConfigLMM/version.rb

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