# Protection domains and Storage Pools.
# The puppet configures ScaleIO cluster - adds MDMs, SDSs, sets up

#Helpers for array processing
define mdm_standby() {
  $ip = $title
  notify {"Configure Standby MDM ${ip}": } ->
  scaleio::mdm {"Standby MDM ${ip}":
      ensure              => 'present',
      ensure_properties   => 'present',
      sio_name            => $ip,
      role                => 'manager',
      ips                 => $ip,
      management_ips      => $ip,
  }
}

define mdm_tb() {
  $ip = $title
  notify {"Configure Tie-Breaker MDM ${ip}": } ->
  scaleio::mdm {"Tie-Breaker MDM ${ip}":
      ensure              => 'present',
      ensure_properties   => 'present',
      sio_name            => $ip,
      role                => 'tb',
      ips                 => $ip,
      management_ips      => undef,
  }
}

define storage_pool_ensure(
  $protection_domain,
  $zero_padding,
  $scanner_mode,
  $checksum_mode,
  $spare_policy,
  $cached_storage_pools_array,
) {
  $sp_name = $title
  if $::scaleio_storage_pools and $::scaleio_storage_pools != '' {
    $current_pools = split($::scaleio_storage_pools, ',')
  } else {
    $current_pools = []
  }
  if ! ("${protection_domain}:${sp_name}" in $current_pools) {
    if $sp_name in $cached_storage_pools_array {
      $rfcache_usage = 'use'
    } else {
      $rfcache_usage = 'dont_use'
    }
    notify {"storage_pool_ensure ${protection_domain}:${sp_name}: zero_padding=${zero_padding}, checksum=${checksum_mode}, scanner=${scanner_mode}, spare=${spare_policy}, rfcache=${rfcache_usage}":
    } ->
    scaleio::storage_pool {"Storage Pool ${protection_domain}:${sp_name}":
      sio_name            => $sp_name,
      protection_domain   => $protection_domain,
      zero_padding_policy => $zero_padding,
      checksum_mode       => $checksum_mode,
      scanner_mode        => $scanner_mode,
      spare_percentage    => $spare_policy,
      rfcache_usage       => $rfcache_usage,
    }
  } else {
    notify {"Skip storage pool ${sp_name} because it is already exists in ${::scaleio_storage_pools}": }
  } 
}

define sds_ensure(
  $sds_nodes,
  $protection_domain,
  $storage_pools,       # if sds_devices_config==undef then storage_pools and device_paths are used,
  $device_paths,        #   this is FUELs w/o plugin's roles support, so all SDSes have the same config
  $rfcache_devices,
  $sds_devices_config,  # for FUELs with plugin's roles support, config could be different for SDSes
) {
  $sds_name = $title
  $sds_node_ = filter_nodes($sds_nodes, 'name', $sds_name) 
  $sds_node = $sds_node_[0]
  #ips for data path traffic
  $storage_ips      = $sds_node['storage_address']
  $storage_ip_roles = 'sdc_only'
  #ips for communication with MDM and SDS<=>SDS
  $mgmt_ips      = $sds_node['internal_address']
  $mgmt_ip_roles = 'sds_only'
  if count(split($storage_ips, ',')) != 1 or count(split($mgmt_ips, ',')) != 1 {
    fail("TODO: behaviour changed: address becomes comma-separated list ${storage_ips} or ${mgmt_ips}, so it is needed to add the generation of ip roles")
  }
  if $mgmt_ips == $storage_ips {
    $sds_ips      = "${storage_ips}"
    $sds_ip_roles = 'all'
  }
  else {
    $sds_ips      = "${storage_ips},${mgmt_ips}"
    $sds_ip_roles = "${storage_ip_roles},${mgmt_ip_roles}"
  }
  if $sds_devices_config {
    $cfg = $sds_devices_config[$sds_name]
    if $cfg {
      notify{"sds ${sds_name} config: ${cfg}": }
      $pool_devices = $cfg  ? { false => undef, default => convert_sds_config($cfg) }
      if $pool_devices {
        $sds_pools = $pool_devices[0]
        $sds_device = $pool_devices[1]
      } else {
        warn("sds ${sds_name} there is empty pools and devices in configuration")
        $sds_pools = undef
        $sds_device = undef
      }
      if $cfg['rfcache_devices'] and $cfg['rfcache_devices'] != '' {
        $sds_rfcache_devices = $cfg['rfcache_devices']
      } else {
        $sds_rfcache_devices = undef
      }
    } else {
      warn("sds ${sds_name} there is no sds config in DB")
      $sds_pools = undef
      $sds_device = undef
      $sds_rfcache_devices = undef
    }
  } else {
    $sds_pools = $storage_pools
    $sds_device = $device_paths
    $sds_rfcache_devices = $rfcache_devices
  }
  notify { "sds ${sds_name}: pools:devices:rfcache: '${sds_pools}': '${sds_device}': '${sds_rfcache_devices}'": } ->
  scaleio::sds {$sds_name:
    ensure             => 'present',
    sio_name           => $sds_name,
    protection_domain  => $protection_domain,
    ips                => $sds_ips,
    ip_roles           => $sds_ip_roles,
    storage_pools      => $sds_pools,
    device_paths       => $sds_device,
    rfcache_devices    => $sds_rfcache_devices,
  }
}

define cleanup_sdc () {
  $sdc_ip = $title
  scaleio::sdc {"Remove SDC ${sdc_ip}":
    ensure             => 'absent',
    ip                 => $sdc_ip,
  }
}

define cleanup_sds () {
  $sds_name = $title
  scaleio::sds {"Remove SDS ${sds_name}":
    ensure             => 'absent',
    sio_name           => $sds_name,
  }
}


# The only first mdm which is proposed to be the first master does cluster configuration
$scaleio = hiera('scaleio')
if $scaleio['metadata']['enabled'] {
  if ! $scaleio['existing_cluster'] {
    if $::managers_ips {
      $all_nodes = hiera('nodes')
      # primary controller configures cluster
      if ! empty(filter_nodes(filter_nodes($all_nodes, 'name', $::hostname), 'role', 'primary-controller')) {
        $use_plugin_roles = $scaleio['enable_sds_role']
        if ! $use_plugin_roles {
          $storage_nodes = filter_nodes($all_nodes, 'role', 'compute')
          if $scaleio['sds_on_controller'] {    
            $controller_nodes  = filter_nodes($all_nodes, 'role', 'controller')   
            $pr_controller_nodes = filter_nodes($all_nodes, 'role', 'primary-controller')
            $sds_nodes = concat(concat($pr_controller_nodes, $controller_nodes), $storage_nodes)
          } else {    
            $sds_nodes = $storage_nodes
          }
        } else {
          $sds_nodes = concat(filter_nodes($all_nodes, 'role', 'scaleio-storage-tier1'), filter_nodes($all_nodes, 'role', 'scaleio-storage-tier2'))
        }
        $sds_nodes_names = keys(nodes_to_hash($sds_nodes, 'name', 'internal_address'))
        $sds_nodes_count = count($sds_nodes_names)
        $sdc_nodes =concat(filter_nodes($all_nodes, 'role', 'compute'), filter_nodes($all_nodes, 'role', 'cinder'))
        $sdc_nodes_ips = values(nodes_to_hash($sdc_nodes, 'name', 'internal_address'))
        $mdm_ip_array = split($::managers_ips, ',')
        $tb_ip_array = split($::tb_ips, ',')
        $mdm_count = count($mdm_ip_array)
        $tb_count = count($tb_ip_array)
        if $mdm_count < 2 or $tb_count == 0 {
          $cluster_mode = 1
          $standby_ips = []
          $slave_names = undef
          $tb_names    = undef
        } else {
          # primary controller IP is first in the list in case of first deploy and it creates cluster.
          # it's guaranied by the tasks environment.pp and resize_cluster.pp
          # in case of re-deploy the first ip is current master ip
          $standby_ips = delete($mdm_ip_array, $mdm_ip_array[0])
          if $mdm_count < 3 or $tb_count == 1 {
            $cluster_mode = 3
            $slave_names = join(values_at($standby_ips, "0-0"), ',')
            $tb_names    = join(values_at($tb_ip_array, "0-0"), ',')
          } else {
            $cluster_mode = 5
            # incase of switch 3 to 5 nodes add only standby mdm/tb
            $to_add_slaves = difference(values_at($standby_ips, "0-1"), intersection(values_at($standby_ips, "0-1"), split($::scaleio_mdm_ips, ',')))
            $to_add_tb = difference(values_at($tb_ip_array, "0-1"), intersection(values_at($tb_ip_array, "0-1"), split($::scaleio_tb_ips, ',')))
            $slave_names = join($to_add_slaves, ',')
            $tb_names    = join($to_add_tb, ',')
          }
        }
        $password = $scaleio['password']
        if $scaleio['protection_domain_nodes'] {
          $protection_domain_number = ($sds_nodes_count + $scaleio['protection_domain_nodes'] - 1) / $scaleio['protection_domain_nodes']
        } else {
          $protection_domain_number = 1
        }
        $protection_domain =  $protection_domain_number ? {
          0       => $scaleio['protection_domain'],
          1       => $scaleio['protection_domain'],
          default => "${scaleio['protection_domain']}_${protection_domain_number}"
        }
        # parse config from centralized DB if exists
        if $::scaleio_sds_config and $::scaleio_sds_config != '' {
          $sds_devices_config = parsejson($::scaleio_sds_config)
          }
        else {
          $sds_devices_config = undef
        }
        if $scaleio['device_paths'] and $scaleio['device_paths'] != '' {
          # if devices come from settings, remove probable trailing commas
          $paths = join(split($scaleio['device_paths'], ','), ',')
        } else {
          $paths = undef
        }
        if $scaleio['storage_pools'] and $scaleio['storage_pools'] != '' {
          # if storage pools come from settings remove probable trailing commas
          $pools_array = split($scaleio['storage_pools'], ',') 
          $pools = join($pools_array, ',')
        } else {
          $pools_array = get_pools_from_sds_config($sds_devices_config)
          $pools = undef
        }
        $zero_padding = $scaleio['zero_padding'] ? {
          false   => 'disable',
          default => 'enable'
        }
        $scanner_mode = $scaleio['scanner_mode'] ? {
          false   => 'disable',
          default => 'enable'
        }
        $checksum_mode = $scaleio['checksum_mode'] ? {
          false   => 'disable',
          default => 'enable'
        }
        $spare_policy = $scaleio['spare_policy'] ? {
          false   => undef,
          default => $scaleio['spare_policy']
        }
        if $scaleio['rfcache_devices'] and $scaleio['rfcache_devices'] != '' {
          $rfcache_devices = $scaleio['rfcache_devices']
        } else {
          $rfcache_devices = undef
        }
        if $scaleio['cached_storage_pools'] and $scaleio['cached_storage_pools'] != '' {
          $cached_storage_pools_array = split($scaleio['cached_storage_pools'], ',')
        } else {
          $cached_storage_pools_array = []
        }
        if $scaleio['capacity_high_alert_threshold'] and $scaleio['capacity_high_alert_threshold'] != '' {
          $capacity_high_alert_threshold = $scaleio['capacity_high_alert_threshold']
        } else {
          $capacity_high_alert_threshold = undef
        }
        if $scaleio['capacity_critical_alert_threshold'] and $scaleio['capacity_critical_alert_threshold'] != '' {
          $capacity_critical_alert_threshold = $scaleio['capacity_critical_alert_threshold']
        } else {
          $capacity_critical_alert_threshold = undef
        }
        notify {"Configure cluster MDM: ${master_mdm}": } ->
        scaleio::login {'Normal':
          password => $password,
          require  => File_line['SCALEIO_discovery_allowed']
        }
        if $::scaleio_sdc_ips {
          $current_sdc_ips = split($::scaleio_sdc_ips, ',')
          $to_keep_sdc = intersection($current_sdc_ips, $sdc_nodes_ips)
          $to_remove_sdc = difference($current_sdc_ips, $to_keep_sdc)
          # todo: not clear is it safe: actually task sdc is run before cluster task,
          # so there to_add_sdc_ips is always empty, because all SDCs
          # are already registered in cluster and are returned from facter scaleio_current_sdc_list
          notify {"SDC change current='${::scaleio_current_sdc_list}', to_add='${to_add_sdc_ips}', to_remove='${to_remove_sdc}'": } ->
          cleanup_sdc {$to_remove_sdc:
            require             => Scaleio::Login['Normal'],
          }
        }
        if $::scaleio_sds_names {
          $current_sds_names = split($::scaleio_sds_names, ',')
          $to_keep_sds = intersection($current_sds_names, $sds_nodes_names)
          $to_add_sds_names = difference($sds_nodes_names, $to_keep_sds)
          $to_remove_sds = difference($current_sds_names, $to_keep_sds)
          notify {"SDS change current='${::scaleio_sds_names}' new='${new_sds_names}' to_remove='${to_remove_sds}'": } ->
          cleanup_sds {$to_remove_sds:
            require             => Scaleio::Login['Normal'],
          }
        } else {
          $to_add_sds_names = $sds_nodes_names
        }
        if $cluster_mode != 1 {
          mdm_standby {$standby_ips:
            require             => Scaleio::Login['Normal'],
          } ->
          mdm_tb{$tb_ip_array:} ->
          scaleio::cluster {'Configure cluster mode':
            ensure              => 'present',
            cluster_mode        => $cluster_mode,
            slave_names         => $slave_names,
            tb_names            => $tb_names,
            require             => Scaleio::Login['Normal'],
          }
        }
        $protection_domain_resource_name = "Ensure protection domain ${protection_domain}"
        scaleio::protection_domain {$protection_domain_resource_name:
          sio_name            => $protection_domain,
          require             => Scaleio::Login['Normal'],
        } ->
        storage_pool_ensure {$pools_array:
          protection_domain           => $protection_domain,
          zero_padding                => $zero_padding,
          scanner_mode                => $scanner_mode,
          checksum_mode               => $checksum_mode,
          spare_policy                => $spare_policy,
          cached_storage_pools_array  => $cached_storage_pools_array,
        } ->
        sds_ensure {$to_add_sds_names:
          sds_nodes           => $sds_nodes,
          protection_domain   => $protection_domain,
          storage_pools       => $pools,
          device_paths        => $paths,
          rfcache_devices     => $rfcache_devices,
          sds_devices_config  => $sds_devices_config,
          require             => Scaleio::Protection_domain[$protection_domain_resource_name],
        }
        if $capacity_high_alert_threshold and $capacity_critical_alert_threshold {
          scaleio::cluster {'Configure alerts':
            ensure                            => 'present',
            capacity_high_alert_threshold     => $capacity_high_alert_threshold,
            capacity_critical_alert_threshold => $capacity_critical_alert_threshold,
            require                           => Scaleio::Protection_domain[$protection_domain_resource_name],
          }
        }
        # Apply high performance profile to SDC-es
        # Use first sdc ip because underlined puppet uses all_sdc parameters
        if ! empty($sdc_nodes_ips) {
          scaleio::sdc {'Set performance settings for all available SDCs':
            ip      => $sdc_nodes_ips[0],
            require => Scaleio::Protection_domain[$protection_domain_resource_name],
          }
        }
      } else {
        notify {"Not Master MDM IP ${master_mdm}": }
      }
      file_line {'SCALEIO_mdm_ips':
        ensure  => present,
        path    => '/etc/environment',
        match   => "^SCALEIO_mdm_ips=",
        line    => "SCALEIO_mdm_ips=${::managers_ips}",
      } ->
      # forbid requesting sdc/sds from discovery facters,
      # this is a workaround of the ScaleIO problem -
      # these requests hangs in some reason if cluster is in degraded state
      file_line {'SCALEIO_discovery_allowed':
        ensure  => present,
        path    => '/etc/environment',
        match   => "^SCALEIO_discovery_allowed=",
        line    => "SCALEIO_discovery_allowed=no",
      }

    } else {
      fail('Empty MDM IPs configuration')
    }
  } else {
    notify{'Skip configuring cluster because of using existing cluster': }
  }
}