def on_host_init_response(self, message):
with bus.initialization_op as op:
with op.phase(self._phase_rabbitmq):
with op.step(self._step_accept_scalr_conf):
if not message.body.has_key("rabbitmq"):
raise HandlerError("HostInitResponse message for RabbitMQ behaviour must have 'rabbitmq' property")
rabbitmq_data = message.rabbitmq.copy()
if not rabbitmq_data['password']:
rabbitmq_data['password'] = cryptotool.pwgen(10)
hostname = RABBIT_HOSTNAME_TPL % int(message.server_index)
rabbitmq_data['server_index'] = message.server_index
rabbitmq_data['hostname'] = hostname
dns.ScalrHosts.set('127.0.0.1', hostname)
with open('/etc/hostname', 'w') as f:
f.write(hostname)
system2(('hostname', '-F', '/etc/hostname'))
volume_config = rabbitmq_data.pop('volume_config')
volume_config['mpoint'] = DEFAULT_STORAGE_PATH
rabbitmq_data['volume'] = storage2.volume(volume_config)
rabbitmq_data['volume'].tags = self.rabbitmq_tags
__rabbitmq__.update(rabbitmq_data)
def reset_password(self, new_password=None):
""" Reset password for RabbitMQ user 'scalr'. Return new password """
if not new_password:
new_password = pwgen(10)
rabbitmq_svc.set_user_password('scalr', new_password)
__rabbitmq__['password'] = new_password
return new_password
def reset_password(self):
""" Reset password for Mongo user 'scalr'. Return new password """
#TODO: review and finish this method
new_password = pwgen(10)
mdb = mongo_svc.MongoDB()
mdb.cli.create_or_update_admin_user(mongo_svc.SCALR_USER, new_password)
return new_password
def on_host_init_response(self, message):
with bus.initialization_op as op:
with op.phase(self._phase_rabbitmq):
with op.step(self._step_accept_scalr_conf):
if not message.body.has_key("rabbitmq"):
raise HandlerError("HostInitResponse message for RabbitMQ behaviour must have 'rabbitmq' property")
rabbitmq_data = message.rabbitmq.copy()
if not rabbitmq_data['password']:
rabbitmq_data['password'] = cryptotool.pwgen(10)
hostname = RABBIT_HOSTNAME_TPL % int(message.server_index)
rabbitmq_data['server_index'] = message.server_index
rabbitmq_data['hostname'] = hostname
dns.ScalrHosts.set('127.0.0.1', hostname)
with open('/etc/hostname', 'w') as f:
f.write(hostname)
system2(('hostname', '-F', '/etc/hostname'))
volume_config = rabbitmq_data.pop('volume_config')
volume_config['mpoint'] = DEFAULT_STORAGE_PATH
rabbitmq_data['volume'] = storage2.volume(volume_config)
__rabbitmq__.update(rabbitmq_data)
def reset_password(self, new_password=None):
""" Reset password for RabbitMQ user 'scalr'. Return new password """
if not new_password:
new_password = pwgen(10)
rabbitmq_svc.set_user_password('scalr', new_password)
__rabbitmq__['password'] = new_password
return new_password
def on_host_init_response(self, message):
with bus.initialization_op as op:
with op.phase(self._phase_rabbitmq):
with op.step(self._step_accept_scalr_conf):
if not message.body.has_key("rabbitmq"):
raise HandlerError("HostInitResponse message for RabbitMQ behaviour must have 'rabbitmq' property")
path = os.path.dirname(self._volume_config_path)
if not os.path.exists(path):
os.makedirs(path)
rabbitmq_data = message.rabbitmq.copy()
if not rabbitmq_data['password']:
rabbitmq_data['password'] = cryptotool.pwgen(10)
if os.path.exists(self._volume_config_path):
os.remove(self._volume_config_path)
hostname = RABBIT_HOSTNAME_TPL % int(message.server_index)
rabbitmq_data['server_index'] = message.server_index
rabbitmq_data['hostname'] = hostname
dns.ScalrHosts.set('127.0.0.1', hostname)
with open('/etc/hostname', 'w') as f:
f.write(hostname)
system2(('hostname', '-F', '/etc/hostname'))
if OPT_VOLUME_CNF in rabbitmq_data:
if rabbitmq_data[OPT_VOLUME_CNF]:
storage.Storage.backup_config(rabbitmq_data[OPT_VOLUME_CNF], self._volume_config_path)
del rabbitmq_data[OPT_VOLUME_CNF]
self._update_config(rabbitmq_data)
def reset_password(self, new_password=None):
"""
Reset password for RabbitMQ user 'scalr_master'. Return new password
"""
if not new_password:
new_password = pwgen(10)
rabbitmq_svc.check_master_user(new_password)
return new_password
def get_main_password(self):
password = __redis__["master_password"]
if self.use_passwords and not password:
password = cryptotool.pwgen(20)
__redis__["master_password"] = password
return password
def reset_password(self, new_password=None):
"""
Reset password for RabbitMQ user 'scalr_master'. Return new password
"""
if not new_password:
new_password = pwgen(10)
rabbitmq_svc.check_master_user(new_password)
return new_password
def reset_password(self):
""" Reset password for Mongo user 'scalr'. Return new password """
#TODO: review and finish this method
new_password = pwgen(10)
mdb = mongo_svc.MongoDB()
mdb.cli.create_or_update_admin_user(mongo_svc.SCALR_USER,
new_password)
return new_password
def get_main_password(self):
password = __redis__["master_password"]
if self.use_passwords and not password:
password = cryptotool.pwgen(20)
__redis__["master_password"] = password
return password
def get_main_password(self):
password = None
if self.using_password:
if self._cnf.rawini.has_option(CNF_SECTION, OPT_MASTER_PASSWORD):
password = self._cnf.rawini.get(CNF_SECTION, OPT_MASTER_PASSWORD)
if not password:
password = cryptotool.pwgen(20)
self._update_config({OPT_MASTER_PASSWORD:password})
return password
def init_processes(self, ports=[], passwords=[]): if not passwords: passwords = [cryptotool.pwgen(20) for port in ports] creds = dict(zip(ports or [], passwords)) for port,password in creds.items(): if port not in self.ports: create_redis_conf_copy(port) redis_process = Redis(self.master, self.persistence_type, port, password) self.instances.append(redis_process)
def reset_password(self, new_password=None):
""" Reset password for MySQL user 'scalr'. Return new password """
if not new_password:
new_password = pwgen(20)
mysql_cli = mysql_svc.MySQLClient(__mysql__['root_user'],
__mysql__['root_password'])
mysql_cli.set_user_password('scalr', 'localhost', new_password)
mysql_cli.flush_privileges()
__mysql__['root_password'] = new_password
return new_password
def reset_password(self, new_password=None):
""" Reset password for PostgreSQL user 'scalr'. Return new password """
if not new_password:
new_pass = pwgen(10)
pg = postgresql_svc.PostgreSql()
pg.root_user.change_role_password(new_pass)
pg.root_user.change_system_password(new_pass)
pg.reload()
return new_pass
def reset_password(self, new_password=None):
""" Reset password for MySQL user 'scalr'. Return new password """
if not new_password:
new_password = pwgen(20)
mysql_cli = mysql_svc.MySQLClient(__mysql__['root_user'],
__mysql__['root_password'])
mysql_cli.set_user_password('scalr', 'localhost', new_password)
mysql_cli.flush_privileges()
__mysql__['root_password'] = new_password
return new_password
def get_main_password(self):
try:
password = __redis__[OPT_MASTER_PASSWORD]
except KeyError:
password = None
if self.use_passwords and not password:
password = cryptotool.pwgen(20)
__redis__[OPT_MASTER_PASSWORD] = password
return password
def get_main_password(self):
try:
password = __redis__[OPT_MASTER_PASSWORD]
except KeyError:
password = None
if self.use_passwords and not password:
password = cryptotool.pwgen(20)
__redis__[OPT_MASTER_PASSWORD] = password
return password
def reset_password(self):
"""
Resets password for MongoDB user 'scalr'.
:return: new 10-char password.
:rtype: str
"""
#TODO: review and finish this method
new_password = pwgen(10)
mdb = mongo_svc.MongoDB()
mdb.cli.create_or_update_admin_user(mongo_svc.SCALR_USER,
new_password)
return new_password
def get_user_creds(self):
options = {
__mysql__['root_user']: '******',
__mysql__['repl_user']: '******',
__mysql__['stat_user']: '******'}
creds = {}
for login, opt_pwd in options.items():
password = __mysql__[opt_pwd]
if not password:
password = cryptotool.pwgen(20)
__mysql__[opt_pwd] = password
creds[login] = password
return creds
def reset_password(self):
"""
Resets password for MongoDB user 'scalr'.
:return: new 10-char password.
:rtype: str
"""
#TODO: review and finish this method
new_password = pwgen(10)
mdb = mongo_svc.MongoDB()
mdb.cli.create_or_update_admin_user(mongo_svc.SCALR_USER,
new_password)
return new_password
def on_host_init_response(self, message):
log = bus.init_op.logger
log.info('Accept Scalr configuration')
if not message.body.has_key("rabbitmq"):
raise HandlerError(
"HostInitResponse message for RabbitMQ behaviour must have 'rabbitmq' property"
)
rabbitmq_data = message.rabbitmq.copy()
if not rabbitmq_data['password']:
rabbitmq_data['password'] = cryptotool.pwgen(10)
self.service.stop()
self.cleanup_hosts_file('/')
if os.path.exists(RABBITMQ_ENV_CFG_PATH):
os.remove(RABBITMQ_ENV_CFG_PATH)
if not os.path.isdir(DEFAULT_STORAGE_PATH):
os.makedirs(DEFAULT_STORAGE_PATH)
rabbitmq_user = pwd.getpwnam("rabbitmq")
os.chown(DEFAULT_STORAGE_PATH, rabbitmq_user.pw_uid,
rabbitmq_user.pw_gid)
self._logger.info('Performing initial cluster reset')
hostname = rabbitmq_svc.RABBIT_HOSTNAME_TPL % int(message.server_index)
__rabbitmq__['hostname'] = hostname
dns.ScalrHosts.set('127.0.0.1', hostname)
self._prepare_env_config()
self.service.start()
self.rabbitmq.stop_app()
self.rabbitmq.reset()
self.service.stop()
# Use RABBITMQ_NODENAME instead of setting actual hostname
#with open('/etc/hostname', 'w') as f:
# f.write(hostname)
#system2(('hostname', '-F', '/etc/hostname'))
volume_config = rabbitmq_data.pop('volume_config')
volume_config['mpoint'] = DEFAULT_STORAGE_PATH
rabbitmq_data['volume'] = storage2.volume(volume_config)
__rabbitmq__.update(rabbitmq_data)
def reset_password(self, new_password=None):
"""
Resets password for RabbitMQ user 'scalr_master'.
:param new_password: New password. If not provided, 10-character string will be generated.
:type new_password: str
:returns: New password.
:rtype: str
"""
if not new_password:
new_password = pwgen(10)
self.rabbitmq.check_master_user(new_password)
return new_password
def reset_password(self, new_password=None):
""" Reset password for PostgreSQL user 'scalr_master'. Return new password """
if not new_password:
new_password = pwgen(10)
pg = postgresql_svc.PostgreSql()
if pg.master_user.exists():
pg.master_user.change_role_password(new_password)
pg.master_user.change_system_password(new_password)
else:
pg.create_linux_user(pg.master_user.name, new_password)
pg.create_pg_role(pg.master_user.name,
new_password,
super=True,
force=False)
return new_password
def reset_password(self, new_password=None):
"""
Resets password for RabbitMQ user 'scalr_master'.
:param new_password: New password. If not provided, 10-character string will be generated.
:type new_password: str
:returns: New password.
:rtype: str
"""
if not new_password:
new_password = pwgen(10)
self.rabbitmq.check_master_user(new_password)
return new_password
def reset_password(self, new_password=None):
""" Reset password for PostgreSQL user 'scalr_master'. Return new password """
if not new_password:
new_password = pwgen(10)
pg = postgresql_svc.PostgreSql()
if pg.master_user.exists():
pg.master_user.change_role_password(new_password)
pg.master_user.change_system_password(new_password)
else:
pg.create_linux_user(pg.master_user.name, new_password)
pg.create_pg_role(pg.master_user.name,
new_password,
super=True,
force=False)
return new_password
def on_host_init_response(self, message):
log = bus.init_op.logger
log.info('Accept Scalr configuration')
if not message.body.has_key("rabbitmq"):
raise HandlerError("HostInitResponse message for RabbitMQ behaviour must have 'rabbitmq' property")
rabbitmq_data = message.rabbitmq.copy()
if not rabbitmq_data['password']:
rabbitmq_data['password'] = cryptotool.pwgen(10)
self.cleanup_hosts_file('/')
if os.path.exists(RABBITMQ_ENV_CFG_PATH):
os.remove(RABBITMQ_ENV_CFG_PATH)
if not os.path.isdir(DEFAULT_STORAGE_PATH):
os.makedirs(DEFAULT_STORAGE_PATH)
rabbitmq_user = pwd.getpwnam("rabbitmq")
os.chown(DEFAULT_STORAGE_PATH, rabbitmq_user.pw_uid, rabbitmq_user.pw_gid)
self._logger.info('Performing initial cluster reset')
self.service.stop()
hostname = rabbitmq_svc.RABBIT_HOSTNAME_TPL % int(message.server_index)
__rabbitmq__['hostname'] = hostname
dns.ScalrHosts.set('127.0.0.1', hostname)
self._set_nodename_in_env()
self.service.start()
self.rabbitmq.stop_app()
self.rabbitmq.reset()
self.service.stop()
# Use RABBITMQ_NODENAME instead of setting actual hostname
#with open('/etc/hostname', 'w') as f:
# f.write(hostname)
#system2(('hostname', '-F', '/etc/hostname'))
volume_config = rabbitmq_data.pop('volume_config')
volume_config['mpoint'] = DEFAULT_STORAGE_PATH
rabbitmq_data['volume'] = storage2.volume(volume_config)
rabbitmq_data['volume'].tags = self.rabbitmq_tags
__rabbitmq__.update(rabbitmq_data)
def get_user_creds(self):
options = {
__mysql__['root_user']: '******',
__mysql__['repl_user']: '******',
__mysql__['stat_user']: '******',
# __mysql__['master_user']: '******'
# TODO: disabled scalr_master user until scalr will send/recv it in communication messages
}
creds = {}
for login, opt_pwd in options.items():
password = __mysql__[opt_pwd]
if not password:
password = cryptotool.pwgen(20)
__mysql__[opt_pwd] = password
creds[login] = password
return creds
def init_processes(self, num, ports=None, passwords=None):
ports = ports or []
passwords = passwords or []
if not __redis__["use_password"]:
# Ignoring passwords from HostInitResponse if use_password=0
passwords = [None for password in passwords]
if len(ports) < num:
diff = num - len(ports)
LOG.debug("Passed ports: %s. Need to find %s more." %
(str(ports), diff))
additional_ports = [
port for port in get_available_ports() if port not in ports
]
if len(additional_ports) < diff:
raise ServiceError('Not enough free ports')
LOG.debug("Found available ports: %s" % str(additional_ports))
ports += additional_ports[:diff]
if len(passwords) < len(ports):
diff = len(ports) - len(passwords)
if __redis__["use_password"]:
LOG.debug("Generating %s additional passwords for ports %s" %
(diff, ports[-diff:]))
additional_passwords = [
cryptotool.pwgen(20) for port in ports[-diff:]
]
LOG.debug("Generated passwords: %s" %
str(additional_passwords))
passwords += additional_passwords
else:
LOG.debug(
"Setting %s additional empty passwords for ports %s" %
(diff, ports[-diff:]))
passwords += [None for port in ports[-diff:]]
assert len(ports) == len(passwords)
creds = dict(zip(ports, passwords))
LOG.debug("Initializing redis processes: %s" % str(creds))
for port, password in creds.items():
if port not in self.ports:
create_redis_conf_copy(port)
redis_process = Redis(port, password)
self.instances.append(redis_process)
LOG.debug('Total of redis processes: %d' % len(self.instances))
def reset_password(self, port=DEFAULT_PORT, new_password=None):
""" Reset auth for Redis process on port `port`. Return new password """
if not new_password:
new_password = pwgen(20)
redis_conf = redis_service.RedisConf.find(port=port)
redis_conf.requirepass = new_password
if redis_conf.slaveof:
redis_conf.masterauth = new_password
redis_wrapper = redis_service.Redis(port=port)
redis_wrapper.service.reload()
if int(port) == DEFAULT_PORT:
__redis__['master_password'] = new_password
return new_password
def reset_password(self, port=DEFAULT_PORT, new_password=None):
""" Reset auth for Redis process on port `port`. Return new password """
if not new_password:
new_password = pwgen(20)
redis_conf = redis_service.RedisConf.find(port=port)
redis_conf.requirepass = new_password
if redis_conf.slaveof:
redis_conf.masterauth = new_password
redis_wrapper = redis_service.Redis(port=port)
redis_wrapper.service.reload()
if int(port) == DEFAULT_PORT:
__redis__["master_password"] = new_password
return new_password
def on_Mysql_CreatePmaUser(self, message):
LOG.debug("on_Mysql_CreatePmaUser")
assert message.pma_server_ip
assert message.farm_role_id
try:
# Operation allowed only on Master server
if not int(__mysql__['replication_master']):
msg = 'Cannot add pma user on slave. ' \
'It should be a Master server'
raise HandlerError(msg)
pma_server_ip = message.pma_server_ip
farm_role_id = message.farm_role_id
pma_password = cryptotool.pwgen(20)
LOG.info("Adding phpMyAdmin system user")
if self.root_client.user_exists(__mysql__['pma_user'], pma_server_ip):
LOG.info('PhpMyAdmin system user already exists. Removing user.')
self.root_client.remove_user(__mysql__['pma_user'], pma_server_ip)
self.root_client.create_user(__mysql__['pma_user'], pma_server_ip,
pma_password, privileges=None)
LOG.info('PhpMyAdmin system user successfully added')
# Notify Scalr
self.send_message(MysqlMessages.CREATE_PMA_USER_RESULT, dict(
status = 'ok',
pma_user = __mysql__['pma_user'],
pma_password = pma_password,
farm_role_id = farm_role_id,
))
except (Exception, BaseException), e:
LOG.exception(e)
# Notify Scalr about error
self.send_message(MysqlMessages.CREATE_PMA_USER_RESULT, dict(
status = 'error',
last_error = str(e).strip(),
farm_role_id = farm_role_id
))
def reset_password(self,
port=__redis__['defaults']['port'],
new_password=None):
""" Reset auth for Redis process on port `port`. Return new password """
if not new_password:
new_password = pwgen(20)
redis_conf = redis_service.RedisConf.find(port=port)
redis_conf.requirepass = new_password
if redis_conf.slaveof:
redis_conf.masterauth = new_password
redis_wrapper = redis_service.Redis(port=port, password=new_password)
redis_wrapper.service.reload()
if int(port) == __redis__['defaults']['port']:
__redis__["master_password"] = new_password
return new_password
def reset_password(self, new_password=None):
"""
Reset password for MySQL user 'scalr_master'. Return new password
"""
if not new_password:
new_password = pwgen(20)
mysql_cli = mysql_svc.MySQLClient(__mysql__['root_user'],
__mysql__['root_password'])
master_user = __mysql__['master_user']
if mysql_cli.user_exists(master_user, 'localhost'):
mysql_cli.set_user_password(master_user, 'localhost', new_password)
else:
mysql_cli.create_user(master_user, 'localhost', new_password)
if mysql_cli.user_exists(master_user, '%'):
mysql_cli.set_user_password(master_user, '%', new_password)
else:
mysql_cli.create_user(master_user, '%', new_password)
mysql_cli.flush_privileges()
return new_password
def init_processes(self, num, ports=None, passwords=None):
ports = ports or []
passwords = passwords or []
if not __redis__["use_password"]:
# Ignoring passwords from HostInitResponse if use_password=0
passwords = [None for password in passwords]
if len(ports) < num:
diff = num-len(ports)
LOG.debug("Passed ports: %s. Need to find %s more." % (str(ports), diff))
additional_ports = [port for port in get_available_ports() if port not in ports]
if len(additional_ports) < diff:
raise ServiceError('Not enough free ports')
LOG.debug("Found available ports: %s" % str(additional_ports))
ports += additional_ports[:diff]
if len(passwords) < len(ports):
diff = len(ports) - len(passwords)
if __redis__["use_password"]:
LOG.debug("Generating %s additional passwords for ports %s" % (diff, ports[-diff:]))
additional_passwords= [cryptotool.pwgen(20) for port in ports[-diff:]]
LOG.debug("Generated passwords: %s" % str(additional_passwords))
passwords += additional_passwords
else:
LOG.debug("Setting %s additional empty passwords for ports %s" % (diff, ports[-diff:]))
passwords += [None for port in ports[-diff:]]
assert len(ports) == len(passwords)
creds = dict(zip(ports, passwords))
LOG.debug("Initializing redis processes: %s" % str(creds))
for port, password in creds.items():
if port not in self.ports:
create_redis_conf_copy(port)
redis_process = Redis(port, password)
self.instances.append(redis_process)
LOG.debug('Total of redis processes: %d' % len(self.instances))
def generate_password(self, length=20): return cryptotool.pwgen(length)
def on_host_init_response(self, message):
"""
Check postgresql data in host init response
@type message: scalarizr.messaging.Message
@param message: HostInitResponse
"""
with bus.initialization_op as op:
with op.phase(self._phase_postgresql):
with op.step(self._step_accept_scalr_conf):
if not message.body.has_key(BEHAVIOUR) or message.db_type != BEHAVIOUR:
raise HandlerError("HostInitResponse message for PostgreSQL behaviour must have 'postgresql' property and db_type 'postgresql'")
'''
if message.postgresql[OPT_REPLICATION_MASTER] != '1' and \
(not message.body.has_key(OPT_ROOT_SSH_PUBLIC_KEY) or not
message.body.has_key(OPT_ROOT_SSH_PRIVATE_KEY)):
raise HandlerError("HostInitResponse message for PostgreSQL slave must contain both public and private ssh keys")
'''
dir = os.path.dirname(self._volume_config_path)
if not os.path.exists(dir):
os.makedirs(dir)
postgresql_data = message.postgresql.copy()
root = PgUser(ROOT_USER, self.pg_keys_dir)
root.store_keys(postgresql_data[OPT_ROOT_SSH_PUBLIC_KEY], postgresql_data[OPT_ROOT_SSH_PRIVATE_KEY])
del postgresql_data[OPT_ROOT_SSH_PUBLIC_KEY]
del postgresql_data[OPT_ROOT_SSH_PRIVATE_KEY]
for key, file in ((OPT_VOLUME_CNF, self._volume_config_path),
(OPT_SNAPSHOT_CNF, self._snapshot_config_path)):
if os.path.exists(file):
os.remove(file)
if key in postgresql_data:
if postgresql_data[key]:
Storage.backup_config(postgresql_data[key], file)
del postgresql_data[key]
root_user= postgresql_data[OPT_ROOT_USER] or ROOT_USER
postgresql_data['%s_password' % root_user] = postgresql_data.get(OPT_ROOT_PASSWORD) or cryptotool.pwgen(10)
del postgresql_data[OPT_ROOT_PASSWORD]
self._logger.debug("Update postgresql config with %s", postgresql_data)
self._update_config(postgresql_data)
def on_host_init_response(self, message):
"""
Check postgresql data in host init response
@type message: scalarizr.messaging.Message
@param message: HostInitResponse
"""
with bus.initialization_op as op:
with op.phase(self._phase_postgresql):
with op.step(self._step_accept_scalr_conf):
if not message.body.has_key(BEHAVIOUR) or message.db_type != BEHAVIOUR:
raise HandlerError("HostInitResponse message for PostgreSQL behaviour must have 'postgresql' property and db_type 'postgresql'")
postgresql_data = message.postgresql.copy()
#Extracting service configuration preset from message
if 'preset' in postgresql_data:
self.initial_preset = postgresql_data['preset']
LOG.debug('Scalr sent current preset: %s' % self.initial_preset)
del postgresql_data['preset']
#Extracting or generating postgresql root password
postgresql_data['%s_password' % ROOT_USER] = postgresql_data.get(OPT_ROOT_PASSWORD) or cryptotool.pwgen(10)
del postgresql_data[OPT_ROOT_PASSWORD]
#Extracting replication ssh keys from message
root = PgUser(ROOT_USER, self.postgresql.pg_keys_dir)
root.store_keys(postgresql_data[OPT_ROOT_SSH_PUBLIC_KEY], postgresql_data[OPT_ROOT_SSH_PRIVATE_KEY])
del postgresql_data[OPT_ROOT_SSH_PUBLIC_KEY]
del postgresql_data[OPT_ROOT_SSH_PRIVATE_KEY]
if postgresql_data.get('volume'):
# New format
postgresql_data['compat_prior_backup_restore'] = False
postgresql_data['volume'] = storage2.volume(postgresql_data['volume'])
LOG.debug("message.pg['volume']:", postgresql_data['volume'])
if 'backup' in postgresql_data:
postgresql_data['backup'] = backup.backup(postgresql_data['backup'])
LOG.debug("message.pg['backup']:", postgresql_data['backup'])
if 'restore' in postgresql_data:
postgresql_data['restore'] = backup.restore(postgresql_data['restore'])
LOG.debug("message.pg['restore']:", postgresql_data['restore'])
else:
# Compatibility transformation
# - volume_config -> volume
# - master n'th start, type=ebs - del snapshot_config
# - snapshot_config -> restore
# - create backup object on master 1'st start
postgresql_data['compat_prior_backup_restore'] = True
if postgresql_data.get(OPT_VOLUME_CNF):
postgresql_data['volume'] = storage2.volume(
postgresql_data.pop(OPT_VOLUME_CNF))
elif postgresql_data.get(OPT_SNAPSHOT_CNF):
postgresql_data['volume'] = storage2.volume(
type=postgresql_data[OPT_SNAPSHOT_CNF]['type'])
else:
raise HandlerError('No volume config or snapshot config provided')
if postgresql_data['volume'].device and \
postgresql_data['volume'].type in ('ebs', 'csvol', 'cinder', 'raid'):
LOG.debug("Master n'th start detected. Removing snapshot config from message")
postgresql_data.pop(OPT_SNAPSHOT_CNF, None)
if postgresql_data.get(OPT_SNAPSHOT_CNF):
postgresql_data['restore'] = backup.restore(
type='snap_postgresql',
snapshot=postgresql_data.pop(OPT_SNAPSHOT_CNF),
volume=postgresql_data['volume'])
if int(postgresql_data['replication_master']):
postgresql_data['backup'] = backup.backup(
type='snap_postgresql',
volume=postgresql_data['volume'])
LOG.debug("Update postgresql config with %s", postgresql_data)
__postgresql__.update(postgresql_data)
__postgresql__['volume'].mpoint = __postgresql__['storage_dir']
__postgresql__['volume'].tags = self.resource_tags()
if 'backup' in __postgresql__:
__postgresql__['backup'].tags = self.resource_tags()
def on_host_init_response(self, message):
"""
Check postgresql data in host init response
@type message: scalarizr.messaging.Message
@param message: HostInitResponse
"""
log = bus.init_op.logger
log.info('Accept Scalr configuration')
if not message.body.has_key(BEHAVIOUR) or message.db_type != BEHAVIOUR:
raise HandlerError(
"HostInitResponse message for PostgreSQL behaviour must have 'postgresql' property and db_type 'postgresql'"
)
postgresql_data = message.postgresql.copy()
#Extracting service configuration preset from message
if 'preset' in postgresql_data:
self.initial_preset = postgresql_data['preset']
LOG.debug('Scalr sent current preset: %s' % self.initial_preset)
del postgresql_data['preset']
#Extracting or generating postgresql root password
postgresql_data['%s_password' % ROOT_USER] = postgresql_data.get(
OPT_ROOT_PASSWORD) or cryptotool.pwgen(10)
del postgresql_data[OPT_ROOT_PASSWORD]
#Extracting replication ssh keys from message
root = PgUser(ROOT_USER, self.postgresql.pg_keys_dir)
root.store_keys(postgresql_data[OPT_ROOT_SSH_PUBLIC_KEY],
postgresql_data[OPT_ROOT_SSH_PRIVATE_KEY])
del postgresql_data[OPT_ROOT_SSH_PUBLIC_KEY]
del postgresql_data[OPT_ROOT_SSH_PRIVATE_KEY]
if postgresql_data.get('volume'):
# New format
postgresql_data['compat_prior_backup_restore'] = False
postgresql_data['volume'] = storage2.volume(
postgresql_data['volume'])
LOG.debug("message.pg['volume']: %s", postgresql_data['volume'])
if 'backup' in postgresql_data:
postgresql_data['backup'] = backup.backup(
postgresql_data['backup'])
LOG.debug("message.pg['backup']: %s",
postgresql_data['backup'])
if 'restore' in postgresql_data:
postgresql_data['restore'] = backup.restore(
postgresql_data['restore'])
LOG.debug("message.pg['restore']: %s",
postgresql_data['restore'])
else:
# Compatibility transformation
# - volume_config -> volume
# - master n'th start, type=ebs - del snapshot_config
# - snapshot_config -> restore
# - create backup object on master 1'st start
postgresql_data['compat_prior_backup_restore'] = True
if postgresql_data.get(OPT_VOLUME_CNF):
postgresql_data['volume'] = storage2.volume(
postgresql_data.pop(OPT_VOLUME_CNF))
elif postgresql_data.get(OPT_SNAPSHOT_CNF):
postgresql_data['volume'] = storage2.volume(
type=postgresql_data[OPT_SNAPSHOT_CNF]['type'])
else:
raise HandlerError(
'No volume config or snapshot config provided')
if postgresql_data['volume'].device and \
postgresql_data['volume'].type in ('ebs', 'csvol', 'cinder', 'raid', 'gce_persistent'):
LOG.debug(
"Master n'th start detected. Removing snapshot config from message"
)
postgresql_data.pop(OPT_SNAPSHOT_CNF, None)
if postgresql_data.get(OPT_SNAPSHOT_CNF):
postgresql_data['restore'] = backup.restore(
type='snap_postgresql',
snapshot=postgresql_data.pop(OPT_SNAPSHOT_CNF),
volume=postgresql_data['volume'])
if int(postgresql_data['replication_master']):
postgresql_data['backup'] = backup.backup(
type='snap_postgresql', volume=postgresql_data['volume'])
self._hir_volume_growth = postgresql_data.pop('volume_growth', None)
LOG.debug("Update postgresql config with %s", postgresql_data)
__postgresql__.update(postgresql_data)
__postgresql__['volume'].mpoint = __postgresql__['storage_dir']
