(CAT-1147)-erb to epp conversion

.rubocop_todo.yml

@@ -95,6 +95,7 @@ RSpec/NamedSubject:
     - 'spec/classes/mysql_server_spec.rb'
     - 'spec/defines/mysql_db_spec.rb'
     - 'spec/functions/mysql_normalise_and_deepmerge_spec.rb'
+    - 'spec/functions/mysql_innobackupex_args_spec.rb'
     - 'spec/functions/mysql_strip_hash_spec.rb'
 
 # Offense count: 45

lib/puppet/functions/mysql/innobackupex_args.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+Puppet::Functions.create_function(:'mysql::innobackupex_args') do
+  dispatch :innobackupex_args do
+    required_param 'Optional[String]', :backupuser
+    required_param 'Boolean', :backupcompress
+    required_param 'Optional[Variant[String, Sensitive[String]]]', :backuppassword_unsensitive
+    required_param 'Array[String[1]]', :backupdatabases
+    required_param 'Array[String[1]]', :optional_args
+    return_type 'Variant[String]'
+  end
+
+  def innobackupex_args(backupuser, backupcompress, backuppassword_unsensitive, backupdatabases, optional_args)
+    innobackupex_args = ''
+    innobackupex_args = "--user=\"#{backupuser}\" --password=\"#{backuppassword_unsensitive}\"" if backupuser && backuppassword_unsensitive
+
+    innobackupex_args = "#{innobackupex_args} --compress" if backupcompress
+
+    innobackupex_args = "#{innobackupex_args} --databases=\"#{backupdatabases.join(' ')}\"" if backupdatabases.is_a?(Array) && !backupdatabases.empty?
+
+    if optional_args.is_a?(Array)
+      optional_args.each do |arg|
+        innobackupex_args = "#{innobackupex_args} #{arg}"
+      end
+    end
+    innobackupex_args
+  end
+end

manifests/backup/mysqldump.pp

@@ -88,14 +88,38 @@
     require  => File['mysqlbackup.sh'],
   }
 
+  $parameters = {
+    'backupuser'=> $backupuser,
+    'backuppassword_unsensitive'=> $backuppassword_unsensitive,
+    'maxallowedpacket'=> $maxallowedpacket,
+    'backupdir'=> $backupdir,
+    'backuprotate'=> $backuprotate,
+    'prescript'=> $prescript,
+    'ignore_events'=> $ignore_events,
+    'backupdatabases'=> $backupdatabases,
+    'include_triggers'=> $include_triggers,
+    'optional_args'=> $optional_args,
+    'execpath'=> $execpath,
+    'delete_before_dump'=> $delete_before_dump,
+    'excludedatabases'=> $excludedatabases,
+    'backupmethod'=> $backupmethod,
+    'backupcompress'=> $backupcompress,
+    'compression_command'=> $compression_command,
+    'compression_extension'=> $compression_extension,
+    'backup_success_file_path'=> $backup_success_file_path,
+    'postscript'=> $postscript,
+    'file_per_database'=> $file_per_database,
+    'include_routines' => $include_routines,
+  }
+
   # TODO: use EPP instead of ERB, as EPP can handle Data of Type Sensitive without further ado
   file { 'mysqlbackup.sh':
     ensure  => $ensure,
     path    => '/usr/local/sbin/mysqlbackup.sh',
     mode    => '0700',
     owner   => 'root',
     group   => $mysql::params::root_group,
-    content => template('mysql/mysqlbackup.sh.erb'),
+    content => epp('mysql/mysqlbackup.sh.epp',$parameters),
   }
 
   if $mysqlbackupdir_target {

manifests/backup/xtrabackup.pp

@@ -13,7 +13,7 @@
   String[1]                                     $backupdirgroup           = $mysql::params::root_group,
   Boolean                                       $backupcompress           = true,
   Variant[Integer, String[1]]                   $backuprotate             = 30,
-  String[1]                                     $backupscript_template    = 'mysql/xtrabackup.sh.erb',
+  String[1]                                     $backupscript_template    = 'mysql/xtrabackup.sh.epp',
   Optional[String[1]]                           $backup_success_file_path = undef,
   Boolean                                       $ignore_events            = true,
   Boolean                                       $delete_before_dump       = false,
@@ -176,12 +176,23 @@
   }
 
   # TODO: use EPP instead of ERB, as EPP can handle Data of Type Sensitive without further ado
+  $parameters = {
+    'innobackupex_args' => mysql::innobackupex_args($backupuser, $backupcompress, $backuppassword_unsensitive, $backupdatabases, $optional_args),
+    'backuprotate' => $backuprotate,
+    'backupdir' => $backupdir,
+    'backupmethod' => $backupmethod,
+    'delete_before_dump' => $delete_before_dump,
+    'prescript' => $prescript,
+    'backup_success_file_path'=> $backup_success_file_path,
+    'postscript'=> $postscript,
+  }
+
   file { 'xtrabackup.sh':
     ensure  => $ensure,
     path    => '/usr/local/sbin/xtrabackup.sh',
     mode    => '0700',
     owner   => 'root',
     group   => $mysql::params::root_group,
-    content => template($backupscript_template),
+    content => epp($backupscript_template,$parameters),
   }
 }

manifests/server/config.pp

@@ -61,10 +61,15 @@
     default: {}
   }
 
+  $parameters= {
+    'options' => $options,
+    'includedir' => $includedir,
+  }
+
   if $mysql::server::manage_config_file {
     file { 'mysql-config-file':
       path                    => $mysql::server::config_file,
-      content                 => template('mysql/my.cnf.erb'),
+      content                 => epp('mysql/my.cnf.epp', $parameters),
       mode                    => $mysql::server::config_file_mode,
       owner                   => $mysql::server::mycnf_owner,
       group                   => $mysql::server::mycnf_group,

manifests/server/root_password.pp

@@ -37,10 +37,16 @@
     }
   }
 
+  $parameters = {
+    'root_password_set' => $root_password_set,
+    'root_password' => $root_password,
+    'options' => $options,
+  }
+
   if $mysql::server::create_root_my_cnf and $root_password_set {
     # TODO: use EPP instead of ERB, as EPP can handle Data of Type Sensitive without further ado
     file { "${facts['root_home']}/.my.cnf":
-      content => template('mysql/my.cnf.pass.erb'),
+      content => epp('mysql/my.cnf.pass.epp',$parameters),
       owner   => 'root',
       mode    => '0600',
     }

spec/functions/mysql_innobackupex_args_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'mysql::innobackupex_args' do
+  it 'exists' do
+    expect(subject).not_to be_nil
+  end
+
+  it 'accepts empty strings as puppet undef' do
+    expect(subject).to run.with_params('', true, '', [], [])
+  end
+
+  context 'should work with username and password' do
+    it 'returns args with username and password' do
+      expect(subject).to run.with_params('root', false, '12345', [], []).and_return('--user="root" --password="12345"')
+    end
+
+    it 'returns args with database lists' do
+      expect(subject).to run.with_params('root', false, '12345', ['db1', 'db2'], []).and_return('--user="root" --password="12345" --databases="db1 db2"')
+    end
+
+    it 'returns args with backup compress only' do
+      expected_results = '--user="root" --password="12345" --compress'
+      expect(subject).to run.with_params('root', true, '12345', [], []).and_return(expected_results)
+    end
+
+    it 'returns args with backup compress, database list and optional_args' do
+      expected_results = '--user="root" --password="12345" --compress --databases="db1 db2" tst_arg_1 tst_arg_2'
+      expect(subject).to run.with_params('root', true, '12345', ['db1', 'db2'], ['tst_arg_1', 'tst_arg_2']).and_return(expected_results)
+    end
+  end
+
+  context 'should work without database args' do
+    it 'returns args without database list' do
+      expect(subject).to run.with_params('root', false, '12345', [], []).and_return('--user="root" --password="12345"')
+    end
+  end
+
+  it 'returns args without backup compress' do
+    expect(subject).to run.with_params('root', false, '12345', [], []).and_return('--user="root" --password="12345"')
+  end
+
+  it 'returns args with backup compress and database list' do
+    expected_results = '--user="root" --password="12345" --compress --databases="db1 db2"'
+    expect(subject).to run.with_params('root', true, '12345', ['db1', 'db2'], []).and_return(expected_results)
+  end
+
+  it 'returns args without backup compress database list and optional_args' do
+    expected_results = '--user="root" --password="12345" --databases="db1 db2" tst_arg_1 tst_arg_2'
+    expect(subject).to run.with_params('root', false, '12345', ['db1', 'db2'], ['tst_arg_1', 'tst_arg_2']).and_return(expected_results)
+  end
+
+  it 'returns args without backup compress database list and with optional_args' do
+    expected_results = '--user="root" --password="12345" tst_arg_1 tst_arg_2'
+    expect(subject).to run.with_params('root', false, '12345', [], ['tst_arg_1', 'tst_arg_2']).and_return(expected_results)
+  end
+end

templates/my.cnf.epp

@@ -0,0 +1,25 @@
+### MANAGED BY PUPPET ###
+
+<% sort($options.map |$key, $value| { [$key, $value] }).map |$v| { -%>
+<% if type($v[1]) =~ Type[Hash] { -%>
+[<%= $v[0] %>]
+<%sort($v[1].map |$key, $value| { [$key, $value] }).map |$vi| { -%>
+<%- if ($vi[0] == 'ssl-disable') or ($vi[0] =~ /^ssl/ and $v[1]['ssl-disable'] == true) or ($vi[0] =~ /^ssl-/ and $v[1]['ssl'] == false) { -%>
+<%- next -%>
+<%- } elsif $vi[1] == true or $vi[1] == '' { -%>
+<%= $vi[0] -%>
+<%- } elsif type($vi[1]) =~ Type[Array] { -%>
+<%- $vi[1].each |$vii| { -%>
+<%-$base = $vi[0]-%>
+<%= $base %> = <%= $vii %>
+<%- } -%>
+<%- } elsif !($vi[1] ==nil or $vi[1]=='' or $vi[1]==undef) { -%>
+<%-$base = $vi[0]-%>
+<%= $base %> = <%= $vi[1] -%>
+<% } %>
+<% } %>
+<% } %>
+<% } %>
+<% if $includedir and $includedir != '' { -%>
+!includedir <%= $includedir %>
+<% } -%>

templates/my.cnf.pass.epp

@@ -0,0 +1,9 @@
+<%['mysql', 'client', 'mysqldump', 'mysqladmin', 'mysqlcheck'].each |$section| { %>
+[<%= $section -%>]
+user=root
+host=localhost
+<% if $root_password_set { -%>
+password='<%= $root_password %>'
+<% } -%>
+socket=<%= $options['client']['socket'] %>
+<% } %>

templates/mysqlbackup.sh.epp

@@ -0,0 +1,121 @@
+<%- if $kernel == 'Linux' { -%>
+#!/bin/bash
+<%- } else { -%>
+#!/bin/sh
+<%- } -%>
+#
+# MySQL Backup Script
+#  Dumps mysql databases to a file for another backup tool to pick up.
+#
+# MySQL code:
+# GRANT SELECT, RELOAD, LOCK TABLES ON *.* TO 'user'@'localhost'
+# IDENTIFIED BY 'password';
+# FLUSH PRIVILEGES;
+#
+##### START CONFIG ###################################################
+
+USER=<%= $backupuser %>
+PASS='<%= $backuppassword_unsensitive %>'
+MAX_ALLOWED_PACKET=<%= $maxallowedpacket %>
+DIR=<%= $backupdir %>
+ROTATE=<%= [ Integer($backuprotate) - 1, 0 ].max %>
+
+# Create temporary mysql cnf file.
+TMPFILE=`mktemp /tmp/backup.XXXXXX` || exit 1
+echo -e "[client]\npassword=$PASS\nuser=$USER\nmax_allowed_packet=$MAX_ALLOWED_PACKET" > $TMPFILE
+
+<% if $prescript { -%>
+<%- [$prescript].flatten().filter |$value| {$value}.each |$script| { %>
+<%= $script %>
+<%- } -%>
+<% } -%>
+
+# Ensure backup directory exist.
+mkdir -p $DIR
+
+PREFIX=mysql_backup_
+<% if $ignore_events { %>
+ADDITIONAL_OPTIONS="--ignore-table=mysql.event"
+<% } else { %>
+ADDITIONAL_OPTIONS="--events"
+<% } %>
+
+<%# Only include routines or triggers if we're doing a file per database -%>
+<%# backup. This happens if we named databases, or if we explicitly set -%>
+<%# file per database mode -%>
+<% if !$backupdatabases.empty or $file_per_database { -%>
+<% if $include_triggers { -%>
+ADDITIONAL_OPTIONS="$ADDITIONAL_OPTIONS --triggers"
+<% } else { -%>
+ADDITIONAL_OPTIONS="$ADDITIONAL_OPTIONS --skip-triggers"
+<% } -%>
+<% if $include_routines { -%>
+ADDITIONAL_OPTIONS="$ADDITIONAL_OPTIONS --routines"
+<% } else { -%>
+ADDITIONAL_OPTIONS="$ADDITIONAL_OPTIONS --skip-routines"
+<% } -%>
+<% } -%>
+
+<%- if $optional_args and type($optional_args) =~ Type(Array) { -%>
+<% $optional_args.each |$arg| { -%>
+ADDITIONAL_OPTIONS="$ADDITIONAL_OPTIONS <%= $arg %>"
+<%- } -%>
+<%- } -%>
+##### STOP CONFIG ####################################################
+PATH=<%= $execpath %>
+
+<%- if $kernel == 'Linux' { -%>
+set -o pipefail
+<%- } -%>
+
+
+
+cleanup()
+{
+	find "${DIR}/" -maxdepth 1 -type f -name "${PREFIX}*.sql*" -mtime +${ROTATE} -print0 | xargs -0 -r rm -f
+}
+
+<% if $delete_before_dump { -%>
+cleanup
+
+<% } -%>
+<% if $backupdatabases.empty { -%>
+<% if $file_per_database { -%>
+<% if $excludedatabases.empty { -%>
+mysql --defaults-extra-file=$TMPFILE -s -r -N -e 'SHOW DATABASES' | while read dbname
+<%} else {-%>
+mysql --defaults-extra-file=$TMPFILE -s -r -N -e 'SHOW DATABASES' | grep -v '^\(<%= $excludedatabases.join('|') %>\)$' | while read dbname
+<% } -%>
+do
+  <%= $backupmethod %> --defaults-extra-file=$TMPFILE --opt --flush-logs --single-transaction \
+    ${ADDITIONAL_OPTIONS} \
+    ${dbname} <% if $backupcompress { %>| <%= $compression_command %> <% } %>> ${DIR}/${PREFIX}${dbname}_`date +%Y%m%d-%H%M%S`.sql<% if $backupcompress { %><%= $compression_extension %><% }  %>
+done
+<% } else { -%>
+<%= $backupmethod %> --defaults-extra-file=$TMPFILE --opt --flush-logs --single-transaction \
+ ${ADDITIONAL_OPTIONS} \
+ --all-databases <% if $backupcompress { %>| <%= $compression_command %> <% } %>> ${DIR}/${PREFIX}`date +%Y%m%d-%H%M%S`.sql<% if $backupcompress { %><%= $compression_extension %><% }  %>
+<% } -%>
+<% } else { -%>
+<% $backupdatabases.each |$db| { -%>
+<%= $backupmethod %> --defaults-extra-file=$TMPFILE --opt --flush-logs --single-transaction \
+    ${ADDITIONAL_OPTIONS} \
+ <%= $db %><% if $backupcompress { %>| <%= $compression_command %> <% } %>> ${DIR}/${PREFIX}<%= $db %>_`date +%Y%m%d-%H%M%S`.sql<% if $backupcompress { %><%= $compression_extension %><% }  %>
+<% } -%>
+<% } -%>
+
+<% unless $delete_before_dump { -%>
+if [ $? -eq 0 ] ; then
+    cleanup
+    touch <%= $backup_success_file_path %>
+fi
+<% } -%>
+
+<% if $postscript { -%>
+  <%- [$postscript].flatten().filter |$value| { $value }.each |$script| { %>
+<%= $script %>
+  <%- } -%>
+<% } -%>
+
+# Remove temporary file
+rm -f $TMPFILE