x
/
fuel-plugin-scaleio
Code Issues Proposed changes

fixed syntax by puppet-lint 

Change-Id: I739186518398928f47fa63b4c687dca8f19e02b9
This commit is contained in:
Andrey Pavlov 2016-08-05 16:44:55 +03:00
parent a9e89dec39
commit f2138fe7dd
14 changed files with 233 additions and 233 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
deployment_scripts/puppet/manifests/cinder.pp
View File

@ -16,14 +16,14 @@ if $scaleio['metadata']['enabled'] {
true => $scaleio['gateway_ip'], true => $scaleio['gateway_ip'],
default => hiera('management_vip') default => hiera('management_vip')
} }
class {'scaleio_openstack::cinder': class {'::scaleio_openstack::cinder':
ensure => present, ensure => present,
gateway_user => $::gateway_user, gateway_user => $::gateway_user,
gateway_password => $scaleio['password'], gateway_password => $scaleio['password'],
gateway_ip => $gateway_ip, gateway_ip => $gateway_ip,
gateway_port => $::gateway_port, gateway_port => $::gateway_port,
protection_domains => $scaleio['protection_domain'], protection_domains => $scaleio['protection_domain'],
storage_pools => $::storage_pools, storage_pools => $::storage_pools,
provisioning_type => $provisioning_type, provisioning_type => $provisioning_type,
} }
} }

116
deployment_scripts/puppet/manifests/cluster.pp
View File

@ -6,12 +6,12 @@ define mdm_standby() {
$ip = $title $ip = $title
notify {"Configure Standby MDM ${ip}": } -> notify {"Configure Standby MDM ${ip}": } ->
scaleio::mdm {"Standby MDM ${ip}": scaleio::mdm {"Standby MDM ${ip}":
ensure => 'present', ensure => 'present',
ensure_properties => 'present', ensure_properties => 'present',
sio_name => $ip, sio_name => $ip,
role => 'manager', role => 'manager',
ips => $ip, ips => $ip,
management_ips => $ip, management_ips => $ip,
} }
} }
@ -19,12 +19,12 @@ define mdm_tb() {
$ip = $title $ip = $title
notify {"Configure Tie-Breaker MDM ${ip}": } -> notify {"Configure Tie-Breaker MDM ${ip}": } ->
scaleio::mdm {"Tie-Breaker MDM ${ip}": scaleio::mdm {"Tie-Breaker MDM ${ip}":
ensure => 'present', ensure => 'present',
ensure_properties => 'present', ensure_properties => 'present',
sio_name => $ip, sio_name => $ip,
role => 'tb', role => 'tb',
ips => $ip, ips => $ip,
management_ips => undef, management_ips => undef,
} }
} }
@ -37,7 +37,7 @@ define storage_pool_ensure(
$rmcache_passthrough_pools, $rmcache_passthrough_pools,
$rmcache_cached_pools, $rmcache_cached_pools,
) { ) {
$parsed_pool_name = split($title, ":") $parsed_pool_name = split($title, ':')
$protection_domain = $parsed_pool_name[0] $protection_domain = $parsed_pool_name[0]
$sp_name = $parsed_pool_name[1] $sp_name = $parsed_pool_name[1]
if $::scaleio_storage_pools and $::scaleio_storage_pools != '' { if $::scaleio_storage_pools and $::scaleio_storage_pools != '' {
@ -77,7 +77,7 @@ define storage_pool_ensure(
} }
} else { } else {
notify {"Skip storage pool ${sp_name} because it is already exists in ${::scaleio_storage_pools}": } notify {"Skip storage pool ${sp_name} because it is already exists in ${::scaleio_storage_pools}": }
} }
} }
define protection_domain_ensure( define protection_domain_ensure(
@ -116,7 +116,7 @@ define sds_ensure(
) { ) {
$sds_name = $title $sds_name = $title
$protection_domain = $sds_to_pd_map[$sds_name] $protection_domain = $sds_to_pd_map[$sds_name]
$sds_node_ = filter_nodes($sds_nodes, 'name', $sds_name) $sds_node_ = filter_nodes($sds_nodes, 'name', $sds_name)
$sds_node = $sds_node_[0] $sds_node = $sds_node_[0]
#ips for data path traffic #ips for data path traffic
$storage_ips = $sds_node['storage_address'] $storage_ips = $sds_node['storage_address']
@ -128,7 +128,7 @@ define sds_ensure(
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") 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 { if $mgmt_ips == $storage_ips {
$sds_ips = "${storage_ips}" $sds_ips = $storage_ips
$sds_ip_roles = 'all' $sds_ip_roles = 'all'
} }
else { else {
@ -166,30 +166,30 @@ define sds_ensure(
} }
notify { "sds ${sds_name}: pools:devices:rfcache: '${sds_pools}': '${sds_device}': '${sds_rfcache_devices}'": } -> notify { "sds ${sds_name}: pools:devices:rfcache: '${sds_pools}': '${sds_device}': '${sds_rfcache_devices}'": } ->
scaleio::sds {$sds_name: scaleio::sds {$sds_name:
ensure => 'present', ensure => 'present',
sio_name => $sds_name, sio_name => $sds_name,
protection_domain => $protection_domain, protection_domain => $protection_domain,
ips => $sds_ips, ips => $sds_ips,
ip_roles => $sds_ip_roles, ip_roles => $sds_ip_roles,
storage_pools => $sds_pools, storage_pools => $sds_pools,
device_paths => $sds_device, device_paths => $sds_device,
rfcache_devices => $sds_rfcache_devices, rfcache_devices => $sds_rfcache_devices,
} }
} }
define cleanup_sdc () { define cleanup_sdc () {
$sdc_ip = $title $sdc_ip = $title
scaleio::sdc {"Remove SDC ${sdc_ip}": scaleio::sdc {"Remove SDC ${sdc_ip}":
ensure => 'absent', ensure => 'absent',
ip => $sdc_ip, ip => $sdc_ip,
} }
} }
define cleanup_sds () { define cleanup_sds () {
$sds_name = $title $sds_name = $title
scaleio::sds {"Remove SDS ${sds_name}": scaleio::sds {"Remove SDS ${sds_name}":
ensure => 'absent', ensure => 'absent',
sio_name => $sds_name, sio_name => $sds_name,
} }
} }
@ -205,11 +205,11 @@ if $scaleio['metadata']['enabled'] {
$use_plugin_roles = $scaleio['enable_sds_role'] $use_plugin_roles = $scaleio['enable_sds_role']
if ! $use_plugin_roles { if ! $use_plugin_roles {
$storage_nodes = filter_nodes($all_nodes, 'role', 'compute') $storage_nodes = filter_nodes($all_nodes, 'role', 'compute')
if $scaleio['sds_on_controller'] { if $scaleio['sds_on_controller'] {
$controller_nodes = filter_nodes($all_nodes, 'role', 'controller') $controller_nodes = filter_nodes($all_nodes, 'role', 'controller')
$pr_controller_nodes = filter_nodes($all_nodes, 'role', 'primary-controller') $pr_controller_nodes = filter_nodes($all_nodes, 'role', 'primary-controller')
$sds_nodes = concat(concat($pr_controller_nodes, $controller_nodes), $storage_nodes) $sds_nodes = concat(concat($pr_controller_nodes, $controller_nodes), $storage_nodes)
} else { } else {
$sds_nodes = $storage_nodes $sds_nodes = $storage_nodes
} }
} else { } else {
@ -217,7 +217,7 @@ if $scaleio['metadata']['enabled'] {
} }
$sds_nodes_names = keys(nodes_to_hash($sds_nodes, 'name', 'internal_address')) $sds_nodes_names = keys(nodes_to_hash($sds_nodes, 'name', 'internal_address'))
$sds_nodes_count = count($sds_nodes_names) $sds_nodes_count = count($sds_nodes_names)
$sdc_nodes =concat(filter_nodes($all_nodes, 'role', 'compute'), filter_nodes($all_nodes, 'role', 'cinder')) $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')) $sdc_nodes_ips = values(nodes_to_hash($sdc_nodes, 'name', 'internal_address'))
$mdm_ip_array = split($::managers_ips, ',') $mdm_ip_array = split($::managers_ips, ',')
$tb_ip_array = split($::tb_ips, ',') $tb_ip_array = split($::tb_ips, ',')
@ -235,13 +235,13 @@ if $scaleio['metadata']['enabled'] {
$standby_ips = delete($mdm_ip_array, $mdm_ip_array[0]) $standby_ips = delete($mdm_ip_array, $mdm_ip_array[0])
if $mdm_count < 3 or $tb_count == 1 { if $mdm_count < 3 or $tb_count == 1 {
$cluster_mode = 3 $cluster_mode = 3
$slave_names = join(values_at($standby_ips, "0-0"), ',') $slave_names = join(values_at($standby_ips, '0-0'), ',')
$tb_names = join(values_at($tb_ip_array, "0-0"), ',') $tb_names = join(values_at($tb_ip_array, '0-0'), ',')
} else { } else {
$cluster_mode = 5 $cluster_mode = 5
# incase of switch 3 to 5 nodes add only standby mdm/tb # 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_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, ','))) $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, ',') $slave_names = join($to_add_slaves, ',')
$tb_names = join($to_add_tb, ',') $tb_names = join($to_add_tb, ',')
} }
@ -250,7 +250,7 @@ if $scaleio['metadata']['enabled'] {
# parse config from centralized DB if exists # parse config from centralized DB if exists
if $::scaleio_sds_config and $::scaleio_sds_config != '' { if $::scaleio_sds_config and $::scaleio_sds_config != '' {
$sds_devices_config = parsejson($::scaleio_sds_config) $sds_devices_config = parsejson($::scaleio_sds_config)
} }
else { else {
$sds_devices_config = undef $sds_devices_config = undef
} }
@ -262,7 +262,7 @@ if $scaleio['metadata']['enabled'] {
} }
if $scaleio['storage_pools'] and $scaleio['storage_pools'] != '' { if $scaleio['storage_pools'] and $scaleio['storage_pools'] != '' {
# if storage pools come from settings remove probable trailing commas # if storage pools come from settings remove probable trailing commas
$pools_array = split($scaleio['storage_pools'], ',') $pools_array = split($scaleio['storage_pools'], ',')
$pools = join($pools_array, ',') $pools = join($pools_array, ',')
} else { } else {
$pools_array = get_pools_from_sds_config($sds_devices_config) $pools_array = get_pools_from_sds_config($sds_devices_config)
@ -365,11 +365,11 @@ if $scaleio['metadata']['enabled'] {
} -> } ->
mdm_tb{$tb_ip_array:} -> mdm_tb{$tb_ip_array:} ->
scaleio::cluster {'Configure cluster mode': scaleio::cluster {'Configure cluster mode':
ensure => 'present', ensure => 'present',
cluster_mode => $cluster_mode, cluster_mode => $cluster_mode,
slave_names => $slave_names, slave_names => $slave_names,
tb_names => $tb_names, tb_names => $tb_names,
require => Scaleio::Login['Normal'], require => Scaleio::Login['Normal'],
} }
} }
protection_domain_ensure {$protection_domain_array: protection_domain_ensure {$protection_domain_array:
@ -384,13 +384,13 @@ if $scaleio['metadata']['enabled'] {
require => Scaleio::Login['Normal'], require => Scaleio::Login['Normal'],
} -> } ->
sds_ensure {$to_add_sds_names: sds_ensure {$to_add_sds_names:
sds_nodes => $sds_nodes, sds_nodes => $sds_nodes,
sds_to_pd_map => $sds_to_pd_map, sds_to_pd_map => $sds_to_pd_map,
storage_pools => $pools, storage_pools => $pools,
device_paths => $paths, device_paths => $paths,
rfcache_devices => $rfcache_devices, rfcache_devices => $rfcache_devices,
sds_devices_config => $sds_devices_config, sds_devices_config => $sds_devices_config,
require => Protection_domain_ensure[$protection_domain_array], require => Protection_domain_ensure[$protection_domain_array],
} }
if $capacity_high_alert_threshold and $capacity_critical_alert_threshold { if $capacity_high_alert_threshold and $capacity_critical_alert_threshold {
scaleio::cluster {'Configure alerts': scaleio::cluster {'Configure alerts':
@ -412,19 +412,19 @@ if $scaleio['metadata']['enabled'] {
notify {"Not Master MDM IP ${master_mdm}": } notify {"Not Master MDM IP ${master_mdm}": }
} }
file_line {'SCALEIO_mdm_ips': file_line {'SCALEIO_mdm_ips':
ensure => present, ensure => present,
path => '/etc/environment', path => '/etc/environment',
match => "^SCALEIO_mdm_ips=", match => '^SCALEIO_mdm_ips=',
line => "SCALEIO_mdm_ips=${::managers_ips}", line => "SCALEIO_mdm_ips=${::managers_ips}",
} -> } ->
# forbid requesting sdc/sds from discovery facters, # forbid requesting sdc/sds from discovery facters,
# this is a workaround of the ScaleIO problem - # this is a workaround of the ScaleIO problem -
# these requests hangs in some reason if cluster is in degraded state # these requests hangs in some reason if cluster is in degraded state
file_line {'SCALEIO_discovery_allowed': file_line {'SCALEIO_discovery_allowed':
ensure => present, ensure => present,
path => '/etc/environment', path => '/etc/environment',
match => "^SCALEIO_discovery_allowed=", match => '^SCALEIO_discovery_allowed=',
line => "SCALEIO_discovery_allowed=no", line => 'SCALEIO_discovery_allowed=no',
} }
} else { } else {

26
deployment_scripts/puppet/manifests/discovery_cluster.pp
View File

@ -12,23 +12,23 @@ if $scaleio['metadata']['enabled'] {
$discovered_tbs_ips = join($current_tbs, ',') $discovered_tbs_ips = join($current_tbs, ',')
notify {"ScaleIO cluster: discovery: discovered_managers_ips='${discovered_managers_ips}', discovered_tbs_ips='${discovered_tbs_ips}'": } -> notify {"ScaleIO cluster: discovery: discovered_managers_ips='${discovered_managers_ips}', discovered_tbs_ips='${discovered_tbs_ips}'": } ->
file_line {'SCALEIO_mdm_ips': file_line {'SCALEIO_mdm_ips':
ensure => present, ensure => present,
path => '/etc/environment', path => '/etc/environment',
match => "^SCALEIO_mdm_ips=", match => '^SCALEIO_mdm_ips=',
line => "SCALEIO_mdm_ips=${discovered_mdms_ips}", line => "SCALEIO_mdm_ips=${discovered_mdms_ips}",
} -> } ->
file_line {'SCALEIO_managers_ips': file_line {'SCALEIO_managers_ips':
ensure => present, ensure => present,
path => '/etc/environment', path => '/etc/environment',
match => "^SCALEIO_managers_ips=", match => '^SCALEIO_managers_ips=',
line => "SCALEIO_managers_ips=${discovered_managers_ips}", line => "SCALEIO_managers_ips=${discovered_managers_ips}",
} -> } ->
file_line {'SCALEIO_tb_ips': file_line {'SCALEIO_tb_ips':
ensure => present, ensure => present,
path => '/etc/environment', path => '/etc/environment',
match => "^SCALEIO_tb_ips=", match => '^SCALEIO_tb_ips=',
line => "SCALEIO_tb_ips=${discovered_tbs_ips}", line => "SCALEIO_tb_ips=${discovered_tbs_ips}",
} }
} else { } else {
notify{'Skip configuring cluster because of using existing cluster': } notify{'Skip configuring cluster because of using existing cluster': }
} }

82
deployment_scripts/puppet/manifests/environment.pp
View File

@ -3,11 +3,11 @@
define env_fact($role, $fact, $value) { define env_fact($role, $fact, $value) {
file_line { "Append a SCALEIO_${role}_${fact} line to /etc/environment": file_line { "Append a SCALEIO_${role}_${fact} line to /etc/environment":
ensure => present, ensure => present,
path => '/etc/environment', path => '/etc/environment',
match => "^SCALEIO_${role}_${fact}=", match => "^SCALEIO_${role}_${fact}=",
line => "SCALEIO_${role}_${fact}=${value}", line => "SCALEIO_${role}_${fact}=${value}",
} }
} }
$scaleio = hiera('scaleio') $scaleio = hiera('scaleio')
@ -19,10 +19,10 @@ if $scaleio['metadata']['enabled'] {
# can be found for example in astute docker container during deloyment) should be set to high values. # can be found for example in astute docker container during deloyment) should be set to high values.
# It'll be invoked only if /tmp/scaleio_debug file exists on particular node and you can use # It'll be invoked only if /tmp/scaleio_debug file exists on particular node and you can use
# "touch /tmp/go" when you're ready to resume. # "touch /tmp/go" when you're ready to resume.
exec { "Wait on debug interrupt: use touch /tmp/go to resume": exec { 'Wait on debug interrupt: use touch /tmp/go to resume':
command => "bash -c 'while [ ! -f /tmp/go ]; do :; done'", command => "bash -c 'while [ ! -f /tmp/go ]; do :; done'",
path => [ '/bin/' ], path => [ '/bin/' ],
onlyif => "ls /tmp/scaleio_debug", onlyif => 'ls /tmp/scaleio_debug',
} }
case $::osfamily { case $::osfamily {
'RedHat': { 'RedHat': {
@ -43,32 +43,32 @@ if $scaleio['metadata']['enabled'] {
# Existing ScaleIO cluster attaching # Existing ScaleIO cluster attaching
notify{'Use existing ScaleIO cluster': } notify{'Use existing ScaleIO cluster': }
env_fact{"Environment fact: role gateway, ips: ${scaleio['gateway_ip']}": env_fact{"Environment fact: role gateway, ips: ${scaleio['gateway_ip']}":
role => 'gateway', role => 'gateway',
fact => 'ips', fact => 'ips',
value => $scaleio['gateway_ip'] value => $scaleio['gateway_ip']
} -> } ->
env_fact{"Environment fact: role gateway, user: ${scaleio['gateway_user']}": env_fact{"Environment fact: role gateway, user: ${scaleio['gateway_user']}":
role => 'gateway', role => 'gateway',
fact => 'user', fact => 'user',
value => $scaleio['gateway_user'] value => $scaleio['gateway_user']
} -> } ->
env_fact{"Environment fact: role gateway, password: ${scaleio['password']}": env_fact{"Environment fact: role gateway, password: ${scaleio['password']}":
role => 'gateway', role => 'gateway',
fact => 'password', fact => 'password',
value => $scaleio['password'] value => $scaleio['password']
} -> } ->
env_fact{"Environment fact: role gateway, port: ${scaleio['gateway_port']}": env_fact{"Environment fact: role gateway, port: ${scaleio['gateway_port']}":
role => 'gateway', role => 'gateway',
fact => 'port', fact => 'port',
value => $scaleio['gateway_port'] value => $scaleio['gateway_port']
} -> } ->
env_fact{"Environment fact: role storage, pools: ${scaleio['existing_storage_pools']}": env_fact{"Environment fact: role storage, pools: ${scaleio['existing_storage_pools']}":
role => 'storage', role => 'storage',
fact => 'pools', fact => 'pools',
value => $scaleio['existing_storage_pools'] value => $scaleio['existing_storage_pools']
} }
# mdm_ips are requested from gateways in separate manifest because no way to pass args to facter # mdm_ips are requested from gateways in separate manifest because no way to pass args to facter
} }
else { else {
# New ScaleIO cluster deployment # New ScaleIO cluster deployment
notify{'Deploy ScaleIO cluster': } notify{'Deploy ScaleIO cluster': }
@ -86,7 +86,7 @@ if $scaleio['metadata']['enabled'] {
if ! $use_plugin_roles { if ! $use_plugin_roles {
$controller_sds_count = $scaleio['sds_on_controller'] ? { $controller_sds_count = $scaleio['sds_on_controller'] ? {
true => count($controller_ips_array), true => count($controller_ips_array),
default => 0 default => 0
} }
$total_sds_count = count(filter_nodes($all_nodes, 'role', 'compute')) + $controller_sds_count $total_sds_count = count(filter_nodes($all_nodes, 'role', 'compute')) + $controller_sds_count
if $total_sds_count < 3 { if $total_sds_count < 3 {
@ -94,7 +94,7 @@ if $scaleio['metadata']['enabled'] {
} }
} else { } else {
$tier1_sds_count = count(filter_nodes($all_nodes, 'role', 'scaleio-storage-tier1')) $tier1_sds_count = count(filter_nodes($all_nodes, 'role', 'scaleio-storage-tier1'))
$tier2_sds_count = count(filter_nodes($all_nodes, 'role', 'scaleio-storage-tier2')) $tier2_sds_count = count(filter_nodes($all_nodes, 'role', 'scaleio-storage-tier2'))
if $tier1_sds_count != 0 and $tier1_sds_count < 3 { if $tier1_sds_count != 0 and $tier1_sds_count < 3 {
$sds_check_msg = 'There are less than 3 nodes with Scaleio Storage Tier1 role.' $sds_check_msg = 'There are less than 3 nodes with Scaleio Storage Tier1 role.'
} }
@ -103,11 +103,11 @@ if $scaleio['metadata']['enabled'] {
} }
} }
if $sds_check_msg { if $sds_check_msg {
if ! $scaleio['skip_checks'] { if ! $scaleio['skip_checks'] {
fail($sds_check_msg) fail($sds_check_msg)
} else{ } else{
warning($sds_check_msg) warning($sds_check_msg)
} }
} }
$nodes = filter_nodes($all_nodes, 'name', $::hostname) $nodes = filter_nodes($all_nodes, 'name', $::hostname)
if ! empty(concat(filter_nodes($nodes, 'role', 'controller'), filter_nodes($nodes, 'role', 'primary-controller'))) { if ! empty(concat(filter_nodes($nodes, 'role', 'controller'), filter_nodes($nodes, 'role', 'primary-controller'))) {
@ -121,51 +121,51 @@ if $scaleio['metadata']['enabled'] {
} }
if $::sds_storage_small_devices { if $::sds_storage_small_devices {
if ! $scaleio['skip_checks'] { if ! $scaleio['skip_checks'] {
fail("Storage devices minimal size is 100GB. The following devices do not meet this requirement ${::sds_storage_small_devices}") fail("Storage devices minimal size is 100GB. The following devices do not meet this requirement ${::sds_storage_small_devices}")
} else { } else {
warning("Storage devices minimal size is 100GB. The following devices do not meet this requirement ${::sds_storage_small_devices}") warning("Storage devices minimal size is 100GB. The following devices do not meet this requirement ${::sds_storage_small_devices}")
} }
} }
# mdm ips and tb ips must be emtpy to avoid queries from ScaleIO about SDC/SDS, # mdm ips and tb ips must be emtpy to avoid queries from ScaleIO about SDC/SDS,
# the next task (cluster discovering) will set them into correct values. # the next task (cluster discovering) will set them into correct values.
env_fact{'Environment fact: mdm ips': env_fact{'Environment fact: mdm ips':
role => 'mdm', role => 'mdm',
fact => 'ips', fact => 'ips',
value => '' value => ''
} -> } ->
env_fact{'Environment fact: managers ips': env_fact{'Environment fact: managers ips':
role => 'managers', role => 'managers',
fact => 'ips', fact => 'ips',
value => '' value => ''
} -> } ->
env_fact{'Environment fact: tb ips': env_fact{'Environment fact: tb ips':
role => 'tb', role => 'tb',
fact => 'ips', fact => 'ips',
value => '' value => ''
} -> } ->
env_fact{'Environment fact: gateway ips': env_fact{'Environment fact: gateway ips':
role => 'gateway', role => 'gateway',
fact => 'ips', fact => 'ips',
value => $ctrl_ips value => $ctrl_ips
} -> } ->
env_fact{'Environment fact: controller ips': env_fact{'Environment fact: controller ips':
role => 'controller', role => 'controller',
fact => 'ips', fact => 'ips',
value => $ctrl_ips value => $ctrl_ips
} -> } ->
env_fact{'Environment fact: role gateway, user: admin': env_fact{'Environment fact: role gateway, user: admin':
role => 'gateway', role => 'gateway',
fact => 'user', fact => 'user',
value => 'admin' value => 'admin'
} -> } ->
env_fact{'Environment fact: role gateway, port: 4443': env_fact{'Environment fact: role gateway, port: 4443':
role => 'gateway', role => 'gateway',
fact => 'port', fact => 'port',
value => 4443 value => 4443
} -> } ->
env_fact{"Environment fact: role storage, pools: ${scaleio['storage_pools']}": env_fact{"Environment fact: role storage, pools: ${scaleio['storage_pools']}":
role => 'storage', role => 'storage',
fact => 'pools', fact => 'pools',
value => $scaleio['storage_pools'] value => $scaleio['storage_pools']
} }
} }

14
deployment_scripts/puppet/manifests/environment_existing_mdm_ips.pp
View File

@ -3,11 +3,11 @@
#TODO: move it from this file and from environment.pp into modules #TODO: move it from this file and from environment.pp into modules
define env_fact($role, $fact, $value) { define env_fact($role, $fact, $value) {
file_line { "Append a SCALEIO_${role}_${fact} line to /etc/environment": file_line { "Append a SCALEIO_${role}_${fact} line to /etc/environment":
ensure => present, ensure => present,
path => '/etc/environment', path => '/etc/environment',
match => "^SCALEIO_${role}_${fact}=", match => "^SCALEIO_${role}_${fact}=",
line => "SCALEIO_${role}_${fact}=${value}", line => "SCALEIO_${role}_${fact}=${value}",
} }
} }
$scaleio = hiera('scaleio') $scaleio = hiera('scaleio')
@ -18,8 +18,8 @@ if $scaleio['metadata']['enabled'] {
fail('Cannot request MDM IPs from existing cluster. Check Gateway address/port and user name with password.') fail('Cannot request MDM IPs from existing cluster. Check Gateway address/port and user name with password.')
} }
env_fact{"Environment fact: role mdm, ips from existing cluster ${ips}": env_fact{"Environment fact: role mdm, ips from existing cluster ${ips}":
role => 'controller', role => 'controller',
fact => 'ips', fact => 'ips',
value => $ips value => $ips
} }
} }

28
deployment_scripts/puppet/manifests/gateway_server.pp
View File

@ -12,29 +12,29 @@ if $scaleio['metadata']['enabled'] {
} }
Haproxy::Service { use_include => true } Haproxy::Service { use_include => true }
Haproxy::Balancermember { use_include => true } Haproxy::Balancermember { use_include => true }
class {'scaleio::gateway_server': class {'::scaleio::gateway_server':
ensure => 'present', ensure => 'present',
mdm_ips => $::managers_ips, mdm_ips => $::managers_ips,
password => $scaleio['password'], password => $scaleio['password'],
} -> } ->
notify { "Configure Haproxy for Gateway nodes: ${gw_ips}": } -> notify { "Configure Haproxy for Gateway nodes: ${gw_ips}": } ->
openstack::ha::haproxy_service { 'scaleio-gateway': openstack::ha::haproxy_service { 'scaleio-gateway':
order => 201, order => 201,
server_names => $gw_ips, server_names => $gw_ips,
ipaddresses => $gw_ips, ipaddresses => $gw_ips,
listen_port => $::gateway_port, listen_port => $::gateway_port,
public_virtual_ip => hiera('public_vip'), public_virtual_ip => hiera('public_vip'),
internal_virtual_ip => hiera('management_vip'), internal_virtual_ip => hiera('management_vip'),
define_backups => true, define_backups => true,
public => true, public => true,
haproxy_config_options => $haproxy_config_options, haproxy_config_options => $haproxy_config_options,
balancermember_options => 'check inter 10s fastinter 2s downinter 3s rise 3 fall 3', balancermember_options => 'check inter 10s fastinter 2s downinter 3s rise 3 fall 3',
} }
} else { } else {
fail('Empty MDM IPs configuration') fail('Empty MDM IPs configuration')
} }
} else { } else {
notify{'Skip deploying gateway server because of using existing cluster': } notify{'Skip deploying gateway server because of using existing cluster': }
} }
} }

6
deployment_scripts/puppet/manifests/mdm_package.pp
View File

@ -4,10 +4,10 @@ $scaleio = hiera('scaleio')
if $scaleio['metadata']['enabled'] { if $scaleio['metadata']['enabled'] {
if ! $scaleio['existing_cluster'] { if ! $scaleio['existing_cluster'] {
$node_ips = split($::ip_address_array, ',') $node_ips = split($::ip_address_array, ',')
if ! empty(intersection(split($::controller_ips, ','), $node_ips)) if ! empty(intersection(split($::controller_ips, ','), $node_ips))
{ {
notify {"Mdm server installation": } -> notify {'Mdm server installation': } ->
class {'scaleio::mdm_server': class {'::scaleio::mdm_server':
ensure => 'present', ensure => 'present',
} }
} else { } else {

24
deployment_scripts/puppet/manifests/mdm_server.pp
View File

@ -31,11 +31,11 @@ if $scaleio['metadata']['enabled'] {
} }
$password = $scaleio['password'] $password = $scaleio['password']
notify {"Controller server is_manager=${is_manager} master_mdm_name=${master_mdm_name} master_ip=${master_ip}": } -> notify {"Controller server is_manager=${is_manager} master_mdm_name=${master_mdm_name} master_ip=${master_ip}": } ->
class {'scaleio::mdm_server': class {'::scaleio::mdm_server':
ensure => 'present', ensure => 'present',
is_manager => $is_manager, is_manager => $is_manager,
master_mdm_name => $master_mdm_name, master_mdm_name => $master_mdm_name,
mdm_ips => $master_ip, mdm_ips => $master_ip,
} }
if $old_password != $password { if $old_password != $password {
if $master_mdm_name { if $master_mdm_name {
@ -44,16 +44,16 @@ if $scaleio['metadata']['enabled'] {
require => Class['scaleio::mdm_server'] require => Class['scaleio::mdm_server']
} -> } ->
scaleio::cluster {'Set password': scaleio::cluster {'Set password':
password => $old_password, password => $old_password,
new_password => $password, new_password => $password,
before => File_line['Append a SCALEIO_mdm_password line to /etc/environment'] before => File_line['Append a SCALEIO_mdm_password line to /etc/environment']
} }
} }
file_line {'Append a SCALEIO_mdm_password line to /etc/environment': file_line {'Append a SCALEIO_mdm_password line to /etc/environment':
ensure => present, ensure => present,
path => '/etc/environment', path => '/etc/environment',
match => "^SCALEIO_mdm_password=", match => '^SCALEIO_mdm_password=',
line => "SCALEIO_mdm_password=${password}", line => "SCALEIO_mdm_password=${password}",
} }
} }
} else { } else {

22
deployment_scripts/puppet/manifests/nova.pp
View File

@ -13,17 +13,17 @@ if $scaleio['metadata']['enabled'] {
$provisioning_type = undef $provisioning_type = undef
} }
$gateway_ip = $scaleio['existing_cluster'] ? { $gateway_ip = $scaleio['existing_cluster'] ? {
true => $scaleio['gateway_ip'], true => $scaleio['gateway_ip'],
default => hiera('management_vip') default => hiera('management_vip')
} }
class {'scaleio_openstack::nova': class {'::scaleio_openstack::nova':
ensure => present, ensure => present,
gateway_user => $::gateway_user, gateway_user => $::gateway_user,
gateway_password => $scaleio['password'], gateway_password => $scaleio['password'],
gateway_ip => $gateway_ip, gateway_ip => $gateway_ip,
gateway_port => $::gateway_port, gateway_port => $::gateway_port,
protection_domains => $scaleio['protection_domain'], protection_domains => $scaleio['protection_domain'],
storage_pools => $::storage_pools, storage_pools => $::storage_pools,
provisioning_type => $provisioning_type, provisioning_type => $provisioning_type,
} }
} }

32
deployment_scripts/puppet/manifests/os.pp
View File

@ -10,25 +10,25 @@ define apply_flavor(
$flavor_name = $parsed_name[0] $flavor_name = $parsed_name[0]
$flavor = $flavors_hash[$flavor_name] $flavor = $flavors_hash[$flavor_name]
scaleio_openstack::flavor {$resource_name: scaleio_openstack::flavor {$resource_name:
ensure => present, ensure => present,
name => $resource_name, name => $resource_name,
storage_pool => $flavor['storage_pool'], storage_pool => $flavor['storage_pool'],
id => $flavor['id'], id => $flavor['id'],
ram_size => $flavor['ram_size'], ram_size => $flavor['ram_size'],
vcpus => $flavor['vcpus'], vcpus => $flavor['vcpus'],
disk_size => $flavor['disk_size'], disk_size => $flavor['disk_size'],
ephemeral_size => $flavor['ephemeral_size'], ephemeral_size => $flavor['ephemeral_size'],
swap_size => $flavor['swap_size'], swap_size => $flavor['swap_size'],
rxtx_factor => $flavor['rxtx_factor'], rxtx_factor => $flavor['rxtx_factor'],
is_public => $flavor['is_public'], is_public => $flavor['is_public'],
provisioning => $flavor['provisioning'], provisioning => $flavor['provisioning'],
} }
} else { } else {
scaleio_openstack::flavor {$resource_name: scaleio_openstack::flavor {$resource_name:
ensure => absent, ensure => absent,
name => $resource_name, name => $resource_name,
} }
} }
} }
$scaleio = hiera('scaleio') $scaleio = hiera('scaleio')
@ -37,7 +37,7 @@ if $scaleio['metadata']['enabled'] {
if ! empty(filter_nodes(filter_nodes($all_nodes, 'name', $::hostname), 'role', 'primary-controller')) { if ! empty(filter_nodes(filter_nodes($all_nodes, 'name', $::hostname), 'role', 'primary-controller')) {
if $scaleio['storage_pools'] and $scaleio['storage_pools'] != '' { if $scaleio['storage_pools'] and $scaleio['storage_pools'] != '' {
# if storage pools come from settings remove probable trailing commas # if storage pools come from settings remove probable trailing commas
$pools_array = split($scaleio['storage_pools'], ',') $pools_array = split($scaleio['storage_pools'], ',')
} else { } else {
$pools_array = get_pools_from_sds_config($sds_devices_config) $pools_array = get_pools_from_sds_config($sds_devices_config)
} }

54
deployment_scripts/puppet/manifests/resize_cluster.pp
View File

@ -5,8 +5,8 @@
define cleanup_mdm () { define cleanup_mdm () {
$mdm_name = $title $mdm_name = $title
scaleio::mdm {"Remove MDM ${mdm_name}": scaleio::mdm {"Remove MDM ${mdm_name}":
ensure => 'absent', ensure => 'absent',
sio_name => $mdm_name, sio_name => $mdm_name,
} }
} }
@ -49,7 +49,7 @@ if $scaleio['metadata']['enabled'] {
$new_tb_ips = join(concat($tbs_present_tmp, values_at($available_nodes, "${first_tb_index}-${last_tb_index}")), ',') $new_tb_ips = join(concat($tbs_present_tmp, values_at($available_nodes, "${first_tb_index}-${last_tb_index}")), ',')
} else { } else {
$new_tb_ips = join($tbs_present, ',') $new_tb_ips = join($tbs_present, ',')
} }
if $to_add_mdm_count > 0 and count($available_nodes) >= $to_add_mdm_count { if $to_add_mdm_count > 0 and count($available_nodes) >= $to_add_mdm_count {
$last_mdm_index = $to_add_mdm_count - 1 $last_mdm_index = $to_add_mdm_count - 1
$mdms_present_tmp = intersection($current_mdms, $controller_ips_array) # use tmp because concat modifys first param $mdms_present_tmp = intersection($current_mdms, $controller_ips_array) # use tmp because concat modifys first param
@ -57,7 +57,7 @@ if $scaleio['metadata']['enabled'] {
} else { } else {
$new_mdms_ips = join($mdms_present, ',') $new_mdms_ips = join($mdms_present, ',')
} }
$is_primary_controller = !empty(filter_nodes(filter_nodes($all_nodes, 'name', $::hostname), 'role', 'primary-controller')) $is_primary_controller = !empty(filter_nodes(filter_nodes($all_nodes, 'name', $::hostname), 'role', 'primary-controller'))
notify {"ScaleIO cluster: resize: controller_ips_array='${controller_ips_array}', current_mdms='${current_mdms}', current_tbs='${current_tbs}'": } notify {"ScaleIO cluster: resize: controller_ips_array='${controller_ips_array}', current_mdms='${current_mdms}', current_tbs='${current_tbs}'": }
if !empty($mdms_absent) or !empty($tbs_absent) { if !empty($mdms_absent) or !empty($tbs_absent) {
notify {"ScaleIO cluster: change: mdms_present='${mdms_present}', mdms_absent='${mdms_absent}', tbs_present='${tbs_present}', tbs_absent='${tbs_absent}'": } notify {"ScaleIO cluster: change: mdms_present='${mdms_present}', mdms_absent='${mdms_absent}', tbs_present='${tbs_present}', tbs_absent='${tbs_absent}'": }
@ -70,12 +70,12 @@ if $scaleio['metadata']['enabled'] {
password => $scaleio['password'] password => $scaleio['password']
} -> } ->
scaleio::cluster {'Resize cluster mode to 1_node and remove other MDMs': scaleio::cluster {'Resize cluster mode to 1_node and remove other MDMs':
ensure => 'absent', ensure => 'absent',
cluster_mode => 1, cluster_mode => 1,
slave_names => $slaves_names, slave_names => $slaves_names,
tb_names => $::scaleio_tb_ips, tb_names => $::scaleio_tb_ips,
require => Scaleio::Login['Normal'], require => Scaleio::Login['Normal'],
before => File_line['SCALEIO_mdm_ips'] before => File_line['SCALEIO_mdm_ips']
} -> } ->
cleanup_mdm {$to_remove_mdms: cleanup_mdm {$to_remove_mdms:
before => File_line['SCALEIO_mdm_ips'] before => File_line['SCALEIO_mdm_ips']
@ -87,31 +87,31 @@ if $scaleio['metadata']['enabled'] {
notify {'ScaleIO cluster: resize: nothing to resize': } notify {'ScaleIO cluster: resize: nothing to resize': }
} }
file_line {'SCALEIO_mdm_ips': file_line {'SCALEIO_mdm_ips':
ensure => present, ensure => present,
path => '/etc/environment', path => '/etc/environment',
match => "^SCALEIO_mdm_ips=", match => '^SCALEIO_mdm_ips=',
line => "SCALEIO_mdm_ips=${mdms_present_str}", line => "SCALEIO_mdm_ips=${mdms_present_str}",
} -> } ->
file_line {'SCALEIO_managers_ips': file_line {'SCALEIO_managers_ips':
ensure => present, ensure => present,
path => '/etc/environment', path => '/etc/environment',
match => "^SCALEIO_managers_ips=", match => '^SCALEIO_managers_ips=',
line => "SCALEIO_managers_ips=${new_mdms_ips}", line => "SCALEIO_managers_ips=${new_mdms_ips}",
} -> } ->
file_line {'SCALEIO_tb_ips': file_line {'SCALEIO_tb_ips':
ensure => present, ensure => present,
path => '/etc/environment', path => '/etc/environment',
match => "^SCALEIO_tb_ips=", match => '^SCALEIO_tb_ips=',
line => "SCALEIO_tb_ips=${new_tb_ips}", line => "SCALEIO_tb_ips=${new_tb_ips}",
} }
# only primary-controller needs discovery of sds/sdc # only primary-controller needs discovery of sds/sdc
if $is_primary_controller { if $is_primary_controller {
file_line {'SCALEIO_discovery_allowed': file_line {'SCALEIO_discovery_allowed':
ensure => present, ensure => present,
path => '/etc/environment', path => '/etc/environment',
match => "^SCALEIO_discovery_allowed=", match => '^SCALEIO_discovery_allowed=',
line => "SCALEIO_discovery_allowed=yes", line => 'SCALEIO_discovery_allowed=yes',
require => File_line['SCALEIO_tb_ips'] require => File_line['SCALEIO_tb_ips']
} }
} }
} else { } else {

8
deployment_scripts/puppet/manifests/sdc.pp
View File

@ -4,11 +4,11 @@
$scaleio = hiera('scaleio') $scaleio = hiera('scaleio')
if $scaleio['metadata']['enabled'] { if $scaleio['metadata']['enabled'] {
if ! $::controller_ips { if ! $::controller_ips {
fail('Empty Controller IPs configuration') fail('Empty Controller IPs configuration')
} }
class {'scaleio::sdc_server': class {'::scaleio::sdc_server':
ensure => 'present', ensure => 'present',
mdm_ip => $::controller_ips, mdm_ip => $::controller_ips,
} }
} }

6
deployment_scripts/puppet/manifests/sdc_server.pp
View File

@ -2,8 +2,8 @@
$scaleio = hiera('scaleio') $scaleio = hiera('scaleio')
if $scaleio['metadata']['enabled'] { if $scaleio['metadata']['enabled'] {
class {'scaleio::sdc_server': class {'::scaleio::sdc_server':
ensure => 'present', ensure => 'present',
mdm_ip => undef, mdm_ip => undef,
} }
} }

30
deployment_scripts/puppet/manifests/sds_server.pp
View File

@ -5,14 +5,14 @@ define sds_device_cleanup() {
$device = $title $device = $title
exec { "device ${device} cleanup": exec { "device ${device} cleanup":
command => "bash -c 'for i in \$(parted ${device} print | awk \"/^ [0-9]+/ {print(\\\$1)}\"); do parted ${device} rm \$i; done'", command => "bash -c 'for i in \$(parted ${device} print | awk \"/^ [0-9]+/ {print(\\\$1)}\"); do parted ${device} rm \$i; done'",
path => [ '/bin/', '/sbin/' , '/usr/bin/', '/usr/sbin/' ], path => [ '/bin/', '/sbin/' , '/usr/bin/', '/usr/sbin/' ],
} }
} }
# Just install packages # Just install packages
$scaleio = hiera('scaleio') $scaleio = hiera('scaleio')
if $scaleio['metadata']['enabled'] { if $scaleio['metadata']['enabled'] {
if ! $scaleio['existing_cluster'] { if ! $scaleio['existing_cluster'] {
$use_plugin_roles = $scaleio['enable_sds_role'] $use_plugin_roles = $scaleio['enable_sds_role']
if ! $use_plugin_roles { if ! $use_plugin_roles {
#it is supposed that task is run on compute or controller #it is supposed that task is run on compute or controller
@ -46,9 +46,9 @@ if $scaleio['metadata']['enabled'] {
sds_device_cleanup {$devices: sds_device_cleanup {$devices:
before => Class['Scaleio::Sds_server'] before => Class['Scaleio::Sds_server']
} -> } ->
class {'scaleio::sds_server': class {'::scaleio::sds_server':
ensure => 'present', ensure => 'present',
xcache => $use_xcache, xcache => $use_xcache,
} }
} else { } else {
# save devices in shared DB # save devices in shared DB
@ -73,30 +73,30 @@ if $scaleio['metadata']['enabled'] {
} else { } else {
$use_xcache = 'absent' $use_xcache = 'absent'
} }
$sds_name = $::hostname $sds_name = $::hostname
$sds_config = { $sds_config = {
"${sds_name}" => { "${sds_name}" => {
'devices' => { 'devices' => {
'tier1' => "${tier1_devices}", 'tier1' => $tier1_devices,
'tier2' => "${tier2_devices}", 'tier2' => $tier2_devices,
'tier3' => "${tier3_devices}", 'tier3' => $tier3_devices,
}, },
'rfcache_devices' => "${rfcache_devices}", 'rfcache_devices' => $rfcache_devices,
} }
} }
# convert hash to string and add escaping of qoutes # convert hash to string and add escaping of qoutes
$sds_config_str = regsubst(regsubst(inline_template('<%= @sds_config.to_s %>'), '=>', ":", 'G'), '"', '\"', 'G') $sds_config_str = regsubst(regsubst(inline_template('<%= @sds_config.to_s %>'), '=>', ':', 'G'), '"', '\"', 'G')
$galera_host = hiera('management_vip') $galera_host = hiera('management_vip')
$mysql_opts = hiera('mysql') $mysql_opts = hiera('mysql')
$mysql_password = $mysql_opts['root_password'] $mysql_password = $mysql_opts['root_password']
$sql_connect = "mysql -h ${galera_host} -uroot -p${mysql_password}" $sql_connect = "mysql -h ${galera_host} -uroot -p${mysql_password}"
$db_query = 'CREATE DATABASE IF NOT EXISTS scaleio; USE scaleio' $db_query = 'CREATE DATABASE IF NOT EXISTS scaleio; USE scaleio'
$table_query = 'CREATE TABLE IF NOT EXISTS sds (name VARCHAR(64), PRIMARY KEY(name), value TEXT(1024))' $table_query = 'CREATE TABLE IF NOT EXISTS sds (name VARCHAR(64), PRIMARY KEY(name), value TEXT(1024))'
$update_query = "INSERT INTO sds (name, value) VALUES ('${sds_name}', '${sds_config_str}') ON DUPLICATE KEY UPDATE value='${sds_config_str}'" $update_query = "INSERT INTO sds (name, value) VALUES ('${sds_name}', '${sds_config_str}') ON DUPLICATE KEY UPDATE value='${sds_config_str}'"
$sql_query = "${sql_connect} -e \"${db_query}; ${table_query}; ${update_query};\"" $sql_query = "${sql_connect} -e \"${db_query}; ${table_query}; ${update_query};\""
class {'scaleio::sds_server': class {'::scaleio::sds_server':
ensure => 'present', ensure => 'present',
xcache => $use_xcache, xcache => $use_xcache,
} -> } ->
package {'mysql-client': package {'mysql-client':
ensure => present, ensure => present,