diff --git a/manifests/config.pp b/manifests/config.pp
index f4776e5..7f60614 100644
--- a/manifests/config.pp
+++ b/manifests/config.pp
@@ -1,90 +1,90 @@
 # Class: zookeeper::config
 #
 # This module manages the configuration directories
 #
 # PRIVATE CLASS - do not use directly (use main `zookeeper` class).
 class zookeeper::config inherits zookeeper {
 
   file { $zookeeper::cfg_dir:
     ensure  => directory,
     owner   => $zookeeper::user,
     group   => $zookeeper::group,
     recurse => true,
     mode    => '0644',
   }
 
   file { $zookeeper::log_dir:
     ensure  => directory,
     owner   => $zookeeper::user,
     group   => $zookeeper::group,
     recurse => false,
     mode    => '0644',
   }
 
   file { $zookeeper::datastore:
     ensure  => directory,
     owner   => $zookeeper::user,
     group   => $zookeeper::group,
     mode    => '0644',
     recurse => false, # intentionally, puppet run would take too long #41
   }
 
   if $zookeeper::datalogstore {
     file { $zookeeper::datalogstore:
       ensure  => directory,
       owner   => $zookeeper::user,
       group   => $zookeeper::group,
       mode    => '0644',
       recurse => false, # intentionally, puppet run would take too long #41
     }
   }
 
   if $zookeeper::service_provider != 'exhibitor' {
     file { "${zookeeper::cfg_dir}/zoo.cfg":
       owner   => $zookeeper::user,
       group   => $zookeeper::group,
       mode    => '0644',
       content => template("${module_name}/conf/zoo.cfg.erb"),
     }
 
     # we should notify Class['::zookeeper::service'] however it's not configured
     # at this point (first run), so we have to subscribe from service declaration
     file { "${zookeeper::cfg_dir}/myid":
       ensure  => file,
       content => template("${module_name}/conf/myid.erb"),
       owner   => $zookeeper::user,
       group   => $zookeeper::group,
       mode    => '0644',
       require => File[$zookeeper::cfg_dir],
     }
 
     file { "${zookeeper::datastore}/myid":
       ensure => 'link',
       target => "${zookeeper::cfg_dir}/myid",
     }
   }
 
   file { "${zookeeper::cfg_dir}/${zookeeper::environment_file}":
     owner   => $zookeeper::user,
     group   => $zookeeper::group,
     mode    => '0644',
     content => template("${module_name}/conf/environment.erb"),
   }
 
   file { "${zookeeper::cfg_dir}/log4j.properties":
     owner   => $zookeeper::user,
     group   => $zookeeper::group,
     mode    => '0644',
     content => template("${module_name}/conf/log4j.properties.erb"),
   }
 
   # Initialize the datastore if required
   if $zookeeper::initialize_datastore {
     exec { 'initialize_datastore':
-      command => "/usr/bin/zookeeper-server-initialize --myid=${zookeeper::id}",
+      command => "${zookeeper::initialize_datastore_bin} --myid=${zookeeper::id}",
       user    => $zookeeper::user,
       creates => "${zookeeper::datastore}/version-2",
       require => [ File[$zookeeper::datastore], Class['zookeeper::install'] ],
     }
   }
 }
diff --git a/manifests/init.pp b/manifests/init.pp
index 3fd3ff9..edfed20 100644
--- a/manifests/init.pp
+++ b/manifests/init.pp
@@ -1,164 +1,165 @@
 # Class: zookeeper
 #
 # This module manages ZooKeeper installation
 #
 #
 # Parameters:
 # * [global_outstanding_limit] Clients can submit requests faster than ZooKeeper can process them,
 #    especially if there are a lot of clients. To prevent ZooKeeper from running out of memory due to
 #    queued requests, ZooKeeper will throttle clients so that there is no more than globalOutstandingLimit
 #    outstanding requests in the system
 #
 #
 # * [whitelist_4lw] Fine grained control over the set of commands ZooKeeper can execute
 #
 #                   whitelist_4lw = ['stat','ruok']
 #
 class zookeeper(
   # meta options
   String                                     $ensure                   = $zookeeper::params::ensure,
   Variant[Boolean,String]                    $ensure_account           = $zookeeper::params::ensure_account,
   Boolean                                    $ensure_cron              = $zookeeper::params::ensure_cron,
   String                                     $group                    = $zookeeper::params::group,
   Boolean                                    $system_group             = $zookeeper::params::system_group,
   Array[String]                              $packages                 = $zookeeper::params::packages,
   String                                     $shell                    = $zookeeper::params::shell,
   String                                     $user                     = $zookeeper::params::user,
   Boolean                                    $system_user              = $zookeeper::params::system_user,
   # installation options
   Hash                                       $archive_checksum         = $zookeeper::params::archive_checksum,
   Optional[String]                           $archive_dl_site          = $zookeeper::params::archive_dl_site,
   Integer                                    $archive_dl_timeout       = $zookeeper::params::archive_dl_timeout,
   Optional[String]                           $archive_dl_url           = $zookeeper::params::archive_dl_url,
   String                                     $archive_install_dir      = $zookeeper::params::archive_install_dir,
   Boolean                                    $archive_symlink          = $zookeeper::params::archive_symlink,
   String                                     $archive_symlink_name     = $zookeeper::params::archive_symlink_name,
   String                                     $archive_version          = $zookeeper::params::archive_version,
   Optional[String]                           $proxy_server             = $zookeeper::params::proxy_server,
   Optional[String]                           $proxy_type               = $zookeeper::params::proxy_type,
   Optional[String]                           $cdhver                   = $zookeeper::params::cdhver,
   Boolean                                    $install_java             = $zookeeper::params::install_java,
   String                                     $install_method           = $zookeeper::params::install_method,
   String                                     $java_bin                 = $zookeeper::params::java_bin,
   String                                     $java_opts                = $zookeeper::params::java_opts,
   Optional[String]                           $java_package             = $zookeeper::params::java_package,
   Optional[Variant[String,Hash]]             $repo                     = $zookeeper::params::repo,
   # service options
   Boolean                                    $manage_service           = $zookeeper::params::manage_service,
   Boolean                                    $manage_service_file      = $zookeeper::params::manage_service_file,
   String                                     $pid_dir                  = $zookeeper::params::pid_dir,
   Optional[String]                           $pid_file                 = $zookeeper::params::pid_file,
   Boolean                                    $restart_on_change        = $zookeeper::params::restart_on_change,
   String                                     $service_ensure           = $zookeeper::params::service_ensure,
   String                                     $service_name             = $zookeeper::params::service_name,
   Optional[String]                           $service_provider         = $zookeeper::params::service_provider,
   Optional[String]                           $systemd_unit_want        = $zookeeper::params::systemd_unit_want,
   String                                     $systemd_unit_after       = $zookeeper::params::systemd_unit_after,
   String                                     $systemd_path             = $zookeeper::params::systemd_path,
   String                                     $zk_dir                   = $zookeeper::params::zk_dir,
   # zookeeper config
   String                                     $cfg_dir                  = $zookeeper::params::cfg_dir,
   String                                     $cleanup_sh               = $zookeeper::params::cleanup_sh,
   Optional[String]                           $client_ip                = $zookeeper::params::client_ip,
   Integer                                    $client_port              = $zookeeper::params::client_port,
   Optional[Integer]                          $secure_client_port       = $zookeeper::params::secure_client_port,
   String                                     $datastore                = $zookeeper::params::datastore,
   Optional[String]                           $datalogstore             = $zookeeper::params::datalogstore,
   Integer                                    $election_port            = $zookeeper::params::election_port,
   String                                     $export_tag               = $zookeeper::params::export_tag,
   String                                     $id                       = $zookeeper::params::id,
   Integer                                    $init_limit               = $zookeeper::params::init_limit,
   Boolean                                    $initialize_datastore     = $zookeeper::params::initialize_datastore,
+  String                                     $initialize_datastore_bin = $zookeeper::params::initialize_datastore_bin,
   Boolean                                    $leader                   = $zookeeper::params::leader,
   Integer                                    $leader_port              = $zookeeper::params::leader_port,
   String                                     $log_dir                  = $zookeeper::params::log_dir,
   Boolean                                    $manual_clean             = $zookeeper::params::manual_clean,
   Optional[Integer]                          $max_session_timeout      = $zookeeper::params::max_session_timeout,
   Optional[Integer]                          $min_session_timeout      = $zookeeper::params::min_session_timeout,
   Array[String]                              $observers                = $zookeeper::params::observers,
   Integer                                    $purge_interval           = $zookeeper::params::purge_interval,
   Variant[Array[String],Hash[String,String]] $servers                  = $zookeeper::params::servers,
   Integer                                    $snap_count               = $zookeeper::params::snap_count,
   Integer                                    $snap_retain_count        = $zookeeper::params::snap_retain_count,
   Integer                                    $sync_limit               = $zookeeper::params::sync_limit,
   Integer                                    $tick_time                = $zookeeper::params::tick_time,
   Integer                                    $global_outstanding_limit = $zookeeper::params::global_outstanding_limit,
   Boolean                                    $use_sasl_auth            = $zookeeper::params::use_sasl_auth,
   String                                     $zoo_dir                  = $zookeeper::params::zoo_dir,
   String                                     $zoo_main                 = $zookeeper::params::zoo_main,
   # log4j properties
   String                                     $environment_file         = $zookeeper::params::environment_file,
   String                                     $log4j_prop               = $zookeeper::params::log4j_prop,
   String                                     $maxfilesize              = $zookeeper::params::maxfilesize,
   Integer                                    $maxbackupindex           = $zookeeper::params::maxbackupindex,
   Optional[Integer]                          $max_allowed_connections  = $zookeeper::params::max_allowed_connections,
   String                                     $peer_type                = $zookeeper::params::peer_type,
   String                                     $rollingfile_threshold    = $zookeeper::params::rollingfile_threshold,
   String                                     $tracefile_threshold      = $zookeeper::params::tracefile_threshold,
   String                                     $console_threshold        = $zookeeper::params::console_threshold,
   Hash[String,Hash[String,String]]           $extra_appenders          = $zookeeper::params::extra_appenders,
   # sasl options
   Hash[String, String]                       $sasl_users               = $zookeeper::params::sasl_users,
   String                                     $keytab_path              = $zookeeper::params::keytab_path,
   String                                     $principal                = $zookeeper::params::principal,
   String                                     $realm                    = $zookeeper::params::realm,
   Boolean                                    $sasl_krb5                = $zookeeper::params::sasl_krb5,
   Boolean                                    $store_key                = $zookeeper::params::store_key,
   Boolean                                    $use_keytab               = $zookeeper::params::use_keytab,
   Boolean                                    $use_ticket_cache         = $zookeeper::params::use_ticket_cache,
   Boolean                                    $remove_host_principal    = $zookeeper::params::remove_host_principal,
   Boolean                                    $remove_realm_principal   = $zookeeper::params::remove_realm_principal,
   # four letter words whitelist
   Array[String]                              $whitelist_4lw            = $zookeeper::params::whitelist_4lw,
 ) inherits ::zookeeper::params {
 
   if $pid_file {
     $pid_path = $pid_file
   } else {
     $pid_path = "${pid_dir}/zookeeper.pid"
   }
 
   $repo_source = is_hash($repo) ? {
     true  => 'custom',
     false => $repo
   }
 
   if $zookeeper::ensure_account {
     group { $group:
       ensure => $ensure_account,
       system => $system_group,
     }
 
     user { $user:
       ensure  => $ensure_account,
       home    => $datastore,
       comment => 'Zookeeper',
       gid     => $group,
       shell   => $shell,
       system  => $system_user,
       require => Group[$group],
     }
   }
 
   include zookeeper::install
   include zookeeper::config
   anchor { 'zookeeper::start': }
   -> Class['zookeeper::install']
   -> Class['zookeeper::config']
 
   if ($use_sasl_auth) {
     include zookeeper::sasl
     Class['zookeeper::config']
     -> Class['zookeeper::sasl']
     -> Class['zookeeper::service']
   }
 
   if ($manage_service) and ($service_provider != 'exhibitor') {
     include zookeeper::service
     Class['zookeeper::config']
     -> Class['zookeeper::service']
     -> Anchor['zookeeper::end']
   }
   anchor { 'zookeeper::end': }
 
 }
diff --git a/manifests/params.pp b/manifests/params.pp
index 594f5e5..62e399e 100644
--- a/manifests/params.pp
+++ b/manifests/params.pp
@@ -1,181 +1,185 @@
 # OS specific configuration should be defined here
 #
 # PRIVATE CLASS - do not use directly (use main `zookeeper` class).
 class zookeeper::params {
   $_defaults = {
     'packages' => ['zookeeper'],
   }
 
   $os_family = $facts['os']['family']
   $os_name = $facts['os']['name']
   $os_release = $facts['os']['release']['major']
 
   case $os_family {
     'Debian': {
       case $os_name {
         'Debian', 'Ubuntu': {
           $initstyle = 'systemd'
         }
         default: { $initstyle = undef }
       }
 
       $_os_overrides = {
-        'packages'         => ['zookeeper', 'zookeeperd'],
-        'service_name'     => 'zookeeper',
-        'service_provider' => $initstyle,
-        'shell'            => '/bin/false',
+        'packages'                 => ['zookeeper', 'zookeeperd'],
+        'service_name'             => 'zookeeper',
+        'service_provider'         => $initstyle,
+        'shell'                    => '/bin/false',
+        'initialize_datastore_bin' => '/usr/bin/zookeeper-server-initialize'
       }
       # 'environment' file probably read just by Debian
       # see #16, #81
       $environment_file = 'environment'
     }
     'RedHat': {
       case $os_name {
         'RedHat', 'CentOS': {
           if versioncmp($os_release, '7') < 0 {
             $initstyle = 'redhat'
           } else {
             $initstyle = 'systemd'
           }
         }
         default: {
           $initstyle = undef
         }
       }
 
       $_os_overrides = {
-        'packages'         => ['zookeeper', 'zookeeper-server'],
-        'service_name'     => 'zookeeper-server',
-        'service_provider' => $initstyle,
-        'shell'            => '/sbin/nologin',
+        'packages'                 => ['zookeeper', 'zookeeper-server'],
+        'service_name'             => 'zookeeper-server',
+        'service_provider'         => $initstyle,
+        'shell'                    => '/sbin/nologin',
+        'initialize_datastore_bin' => '/usr/bin/zookeeper-server-initialize'
       }
       $environment_file = 'java.env'
     }
     'Suse': {
       case $os_name {
         'SLES': {
           $initstyle = 'systemd'
         }
         default: { $initstyle = undef }
       }
 
       $_os_overrides = {
-        'packages'         => ['zookeeper', 'zookeeper-server'],
-        'service_name'     => 'zookeeper-server',
-        'service_provider' => $initstyle,
-        'shell'            => '/bin/false',
+        'packages'                 => ['zookeeper', 'zookeeper-server'],
+        'service_name'             => 'zookeeper-server',
+        'service_provider'         => $initstyle,
+        'shell'                    => '/bin/false',
+        'initialize_datastore_bin' => '/usr/bin/zookeeper-server-initialize'
       }
       $environment_file = 'java.env'
     }
 
     default: {
       fail("Module '${module_name}' is not supported on OS: '${os_name}', family: '${os_family}'")
     }
   }
   $_params = merge($_defaults, $_os_overrides)
 
   # meta options
   $ensure = present
   $ensure_account = present
   $ensure_cron = true
   $group = 'zookeeper'
   $system_group = false
   $packages = $_params['packages']
   $shell = $_params['shell']
   $user = 'zookeeper'
   $system_user = false
 
   # installation options
   $archive_checksum = {}
   $archive_dl_site = undef
   $archive_dl_timeout = 600
   $archive_dl_url = undef
   $archive_install_dir = '/opt'
   $archive_symlink = true
   $archive_symlink_name = "${archive_install_dir}/zookeeper"
   $archive_version = '3.4.8'
   $cdhver = '5'
   $install_java = false
   $install_method = 'package'
   $java_bin = '/usr/bin/java'
   $java_opts = ''
   $java_package = undef
   $repo = undef
   $proxy_server = undef
   $proxy_type = undef
 
   # service options
   $manage_service = true
   $manage_service_file = false
   $pid_dir = '/var/run'
   $pid_file = undef
   $restart_on_change = true
   $service_ensure = 'running'
   $service_name = $_params['service_name']
   $service_provider = $_params['service_provider']
   # systemd_unit_want and _after can be overridden to
   # donate the matching directives in the [Unit] section
   $systemd_unit_want = undef
   $systemd_unit_after = 'network.target'
   $systemd_path = '/etc/systemd/system'
 
   $zk_dir = '/etc/zookeeper'
   # zookeeper config
   $cfg_dir = '/etc/zookeeper/conf'
   $cleanup_sh = '/usr/share/zookeeper/bin/zkCleanup.sh'
   $client_ip = undef # use e.g. $::ipaddress if you want to bind to single interface
   $client_port = 2181
   $secure_client_port = undef
   $datastore = '/var/lib/zookeeper'
   # datalogstore used to put transaction logs in separate location than snapshots
   $datalogstore = undef
   $election_port = 2888
   $export_tag = 'zookeeper'
   $id = '1'
   $init_limit = 10
   $initialize_datastore = false
+  $initialize_datastore_bin = $_params['initialize_datastore_bin']
   $leader = true
   $leader_port = 3888
   $log_dir = '/var/log/zookeeper'
   $manual_clean = false
   $max_allowed_connections = undef
   $max_session_timeout = undef
   $min_session_timeout = undef
   $observers = []
   # interval in hours, purging enabled when >= 1
   $purge_interval = 0
   $servers = []
   $snap_count = 10000
   # since zookeeper 3.4, for earlier version cron task might be used
   $snap_retain_count = 3
   $sync_limit = 5
   $tick_time = 2000
   $global_outstanding_limit = 1000
   $use_sasl_auth = false
   $zoo_dir = '/usr/lib/zookeeper'
   $zoo_main = 'org.apache.zookeeper.server.quorum.QuorumPeerMain'
 
   # log4j properties
   $log4j_prop = 'INFO,ROLLINGFILE'
   $peer_type = 'UNSET'
   $rollingfile_threshold = 'INFO'
   $console_threshold = 'INFO'
   $tracefile_threshold = 'TRACE'
   $maxfilesize = '256MB'
   $maxbackupindex = 20
   $extra_appenders = {}
 
   # sasl options
   $sasl_krb5 = true
   $sasl_users = {}
   $keytab_path = '/etc/zookeeper/conf/zookeeper.keytab'
   $principal = "zookeeper/${facts['networking']['fqdn']}"
   $realm = pick($trusted['domain'], $trusted['certname'])
   $store_key = true
   $use_keytab = true
   $use_ticket_cache = false
   $remove_host_principal = false
   $remove_realm_principal = false
   # whitelist of Four Letter Words commands, see https://zookeeper.apache.org/doc/r3.4.12/zookeeperAdmin.html#sc_zkCommands
   $whitelist_4lw = []
 }