def execute(self, args): """ Quickly creates Zato components 1) CA and crypto material 2) ODB 3) ODB initial data 4) server1 5) server2 6) load-balancer 7) Web admin 8) Scripts """ next_step = count(1) next_port = count(http_plain_server_port) total_steps = 8 cluster_name = 'quickstart-{}'.format(random.getrandbits(20)).zfill(7) server_names = {'1': 'server1', '2': 'server2'} admin_invoke_password = uuid4().hex broker_host = 'localhost' broker_port = 6379 lb_host = 'localhost' lb_port = 11223 lb_agent_port = 20151 args_path = os.path.abspath(args.path) # This could've been set to True by user in the command-line so we'd want # to unset it so that individual commands quickstart invokes don't attempt # to store their own configs. args.store_config = False # # 1) CA # ca_path = os.path.join(args_path, 'ca') os.mkdir(ca_path) ca_args = self._bunch_from_args(args, cluster_name) ca_args.path = ca_path ca_args_server1 = deepcopy(ca_args) ca_args_server1.server_name = server_names['1'] ca_args_server2 = deepcopy(ca_args) ca_args_server2.server_name = server_names['2'] ca_create_ca.Create(ca_args).execute(ca_args, False) ca_create_lb_agent.Create(ca_args).execute(ca_args, False) ca_create_server.Create(ca_args_server1).execute( ca_args_server1, False) ca_create_server.Create(ca_args_server2).execute( ca_args_server2, False) ca_create_web_admin.Create(ca_args).execute(ca_args, False) server_crypto_loc = {} for key in server_names: server_crypto_loc[key] = CryptoMaterialLocation( ca_path, '{}-{}'.format(cluster_name, server_names[key])) lb_agent_crypto_loc = CryptoMaterialLocation(ca_path, 'lb-agent') web_admin_crypto_loc = CryptoMaterialLocation(ca_path, 'web-admin') self.logger.info('[{}/{}] Certificate authority created'.format( next_step.next(), total_steps)) # # 2) ODB # if create_odb.Create(args).execute(args, False) == self.SYS_ERROR.ODB_EXISTS: self.logger.info('[{}/{}] ODB schema already exists'.format( next_step.next(), total_steps)) else: self.logger.info('[{}/{}] ODB schema created'.format( next_step.next(), total_steps)) # # 3) ODB initial data # create_cluster_args = self._bunch_from_args(args, cluster_name) create_cluster_args.broker_host = broker_host create_cluster_args.broker_port = broker_port create_cluster_args.lb_host = lb_host create_cluster_args.lb_port = lb_port create_cluster_args.lb_agent_port = lb_agent_port create_cluster_args.admin_invoke_password = admin_invoke_password create_cluster.Create(create_cluster_args).execute( create_cluster_args, False) self.logger.info('[{}/{}] ODB initial data created'.format( next_step.next(), total_steps)) # # 4) server1 # 5) server2 # for key in server_names: server_path = os.path.join(args_path, server_names[key]) os.mkdir(server_path) create_server_args = self._bunch_from_args(args, cluster_name) create_server_args.server_name = server_names[key] create_server_args.path = server_path create_server_args.cert_path = server_crypto_loc[key].cert_path create_server_args.pub_key_path = server_crypto_loc[key].pub_path create_server_args.priv_key_path = server_crypto_loc[key].priv_path create_server_args.ca_certs_path = server_crypto_loc[ key].ca_certs_path create_server.Create(create_server_args).execute( create_server_args, next_port.next(), False) self.logger.info('[{}/{}] server{} created'.format( next_step.next(), total_steps, key)) # # 6) load-balancer # lb_path = os.path.join(args_path, 'load-balancer') os.mkdir(lb_path) create_lb_args = self._bunch_from_args(args, cluster_name) create_lb_args.path = lb_path create_lb_args.cert_path = lb_agent_crypto_loc.cert_path create_lb_args.pub_key_path = lb_agent_crypto_loc.pub_path create_lb_args.priv_key_path = lb_agent_crypto_loc.priv_path create_lb_args.ca_certs_path = lb_agent_crypto_loc.ca_certs_path # Need to substract 1 because we've already called .next() twice # when creating servers above. server2_port = next_port.next() - 1 create_lb.Create(create_lb_args).execute(create_lb_args, True, server2_port, False) self.logger.info('[{}/{}] Load-balancer created'.format( next_step.next(), total_steps)) # # 7) Web admin # web_admin_path = os.path.join(args_path, 'web-admin') os.mkdir(web_admin_path) create_web_admin_args = self._bunch_from_args(args, cluster_name) create_web_admin_args.path = web_admin_path create_web_admin_args.cert_path = web_admin_crypto_loc.cert_path create_web_admin_args.pub_key_path = web_admin_crypto_loc.pub_path create_web_admin_args.priv_key_path = web_admin_crypto_loc.priv_path create_web_admin_args.ca_certs_path = web_admin_crypto_loc.ca_certs_path create_web_admin_args.admin_invoke_password = admin_invoke_password password = generate_password() admin_created = create_web_admin.Create(create_web_admin_args).execute( create_web_admin_args, False, password, True) # Need to reset the logger here because executing the create_web_admin command # loads the web admin's logger which doesn't like that of ours. self.reset_logger(args, True) self.logger.info('[{}/{}] Web admin created'.format( next_step.next(), total_steps)) # # 8) Scripts # zato_bin = 'zato' zato_qs_start_path = os.path.join(args_path, 'zato-qs-start.sh') zato_qs_stop_path = os.path.join(args_path, 'zato-qs-stop.sh') zato_qs_restart_path = os.path.join(args_path, 'zato-qs-restart.sh') open(zato_qs_start_path, 'w').write( zato_qs_start_template.format(zato_bin=zato_bin, script_dir=script_dir)) open(zato_qs_stop_path, 'w').write( zato_qs_stop_template.format(zato_bin=zato_bin, script_dir=script_dir)) open(zato_qs_restart_path, 'w').write(zato_qs_restart.format(script_dir=script_dir)) file_mod = stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR | stat.S_IRGRP os.chmod(zato_qs_start_path, file_mod) os.chmod(zato_qs_stop_path, file_mod) os.chmod(zato_qs_restart_path, file_mod) self.logger.info('[{}/{}] Management scripts created'.format( next_step.next(), total_steps)) self.logger.info('Quickstart cluster {} created'.format(cluster_name)) if admin_created: self.logger.info( 'Web admin user:[admin], password:[{}]'.format(password)) else: self.logger.info('User [admin] already exists in the ODB') start_command = os.path.join(args_path, 'zato-qs-start.sh') self.logger.info('Start the cluster by issuing the {} command'.format( start_command)) self.logger.info( 'Visit https://zato.io/support for more information and support options' )
def execute(self, args, show_output=True, password=None, needs_admin_created_flag=False): os.chdir(self.target_dir) repo_dir = os.path.join(self.target_dir, 'config', 'repo') web_admin_conf_path = os.path.join(repo_dir, 'web-admin.conf') initial_data_json_path = os.path.join(repo_dir, 'initial-data.json') os.mkdir(os.path.join(self.target_dir, 'logs')) os.mkdir(os.path.join(self.target_dir, 'config')) os.mkdir(repo_dir) user_name = 'admin' password = password if password else generate_password() self.copy_web_admin_crypto(repo_dir, args) priv_key = open(os.path.join(repo_dir, 'web-admin-priv-key.pem')).read() config = { 'host': web_admin_host, 'port': web_admin_port, 'db_type': args.odb_type, 'log_config': 'logging.conf', 'DATABASE_NAME': args.odb_db_name or args.sqlite_path, 'DATABASE_USER': args.odb_user or '', 'DATABASE_PASSWORD': encrypt(args.odb_password, priv_key) if args.odb_password else '', 'DATABASE_HOST': args.odb_host or '', 'DATABASE_PORT': args.odb_port or '', 'SITE_ID': getrandbits(20), 'SECRET_KEY': encrypt(uuid.uuid4().hex, priv_key), 'ADMIN_INVOKE_NAME': 'admin.invoke', 'ADMIN_INVOKE_PASSWORD': encrypt( getattr(args, 'admin_invoke_password', None) or getattr(args, 'tech_account_password'), priv_key), } open(os.path.join(repo_dir, 'logging.conf'), 'w').write( common_logging_conf_contents.format( log_path='./logs/web-admin.log')) open(web_admin_conf_path, 'w').write(config_template.format(**config)) open(initial_data_json_path, 'w').write(initial_data_json.format(**config)) # Initial info self.store_initial_info(self.target_dir, self.COMPONENTS.WEB_ADMIN.code) config = json.loads( open(os.path.join(repo_dir, 'web-admin.conf')).read()) config['config_dir'] = self.target_dir update_globals(config, self.target_dir) os.environ['DJANGO_SETTINGS_MODULE'] = 'zato.admin.settings' import django django.setup() self.reset_logger(args, True) # Can't import these without DJANGO_SETTINGS_MODULE being set from django.contrib.auth.models import User from django.db import connection from django.db.utils import IntegrityError call_command('migrate', run_syncdb=True, interactive=False, verbosity=0) call_command('loaddata', initial_data_json_path, verbosity=0) try: call_command('createsuperuser', interactive=False, username=user_name, first_name='admin-first-name', last_name='admin-last-name', email='*****@*****.**') admin_created = True user = User.objects.get(username=user_name) user.set_password(password) user.save() except IntegrityError, e: admin_created = False connection._rollback() self.logger.info('Ignoring IntegrityError e:[%s]', format_exc(e).decode('utf-8'))
def execute(self, args): """ Quickly creates Zato components 1) CA and crypto material 2) ODB 3) ODB initial data 4) servers 5) load-balancer 6) Web admin 7) Scheduler 8) Scripts """ if args.odb_type == 'sqlite': args.sqlite_path = os.path.abspath( os.path.join(args.path, 'zato.db')) ''' cluster_id_args = Bunch() cluster_id_args.odb_db_name = args.odb_db_name cluster_id_args.odb_host = args.odb_host cluster_id_args.odb_password = args.odb_password cluster_id_args.odb_port = args.odb_port cluster_id_args.odb_type = args.odb_type cluster_id_args.odb_user = args.odb_user cluster_id_args.postgresql_schema = args.postgresql_schema cluster_id_args.sqlite_path = args.sqlite_path ''' next_step = count(1) next_port = count(http_plain_server_port) cluster_name = getattr(args, 'cluster_name', None) or 'quickstart-{}'.format( random.getrandbits(20)).zfill(7) servers = int(getattr(args, 'servers', 0) or DEFAULT_NO_SERVERS) server_names = OrderedDict() for idx in range(1, servers + 1): server_names['{}'.format(idx)] = 'server{}'.format(idx) total_steps = 7 + servers admin_invoke_password = uuid4().hex broker_host = 'localhost' broker_port = 6379 lb_host = 'localhost' lb_port = 11223 lb_agent_port = 20151 args_path = os.path.abspath(args.path) # This could've been set to True by user in the command-line so we'd want # to unset it so that individual commands quickstart invokes don't attempt # to store their own configs. args.store_config = False # ################################################################################################################################ # # 1) CA # ca_path = os.path.join(args_path, 'ca') os.mkdir(ca_path) ca_args = self._bunch_from_args(args, cluster_name) ca_args.path = ca_path ca_create_ca.Create(ca_args).execute(ca_args, False) ca_create_lb_agent.Create(ca_args).execute(ca_args, False) ca_create_web_admin.Create(ca_args).execute(ca_args, False) ca_create_scheduler.Create(ca_args).execute(ca_args, False) server_crypto_loc = {} for name in server_names: ca_args_server = deepcopy(ca_args) ca_args_server.server_name = server_names[name] ca_create_server.Create(ca_args_server).execute( ca_args_server, False) server_crypto_loc[name] = CryptoMaterialLocation( ca_path, '{}-{}'.format(cluster_name, server_names[name])) lb_agent_crypto_loc = CryptoMaterialLocation(ca_path, 'lb-agent') web_admin_crypto_loc = CryptoMaterialLocation(ca_path, 'web-admin') scheduler_crypto_loc = CryptoMaterialLocation(ca_path, 'scheduler1') self.logger.info('[{}/{}] Certificate authority created'.format( next_step.next(), total_steps)) # ################################################################################################################################ # # 2) ODB # if create_odb.Create(args).execute(args, False) == self.SYS_ERROR.ODB_EXISTS: self.logger.info('[{}/{}] ODB schema already exists'.format( next_step.next(), total_steps)) else: self.logger.info('[{}/{}] ODB schema created'.format( next_step.next(), total_steps)) # ################################################################################################################################ # # 3) ODB initial data # create_cluster_args = self._bunch_from_args(args, cluster_name) create_cluster_args.broker_host = broker_host create_cluster_args.broker_port = broker_port create_cluster_args.lb_host = lb_host create_cluster_args.lb_port = lb_port create_cluster_args.lb_agent_port = lb_agent_port create_cluster_args.admin_invoke_password = admin_invoke_password create_cluster.Create(create_cluster_args).execute( create_cluster_args, False) self.logger.info('[{}/{}] ODB initial data created'.format( next_step.next(), total_steps)) # ################################################################################################################################ # # 4) servers # # Must be shared by all servers jwt_secret = Fernet.generate_key() for name in server_names: server_path = os.path.join(args_path, server_names[name]) os.mkdir(server_path) create_server_args = self._bunch_from_args(args, cluster_name) create_server_args.server_name = server_names[name] create_server_args.path = server_path create_server_args.cert_path = server_crypto_loc[name].cert_path create_server_args.pub_key_path = server_crypto_loc[name].pub_path create_server_args.priv_key_path = server_crypto_loc[ name].priv_path create_server_args.ca_certs_path = server_crypto_loc[ name].ca_certs_path create_server_args.jwt_secret = jwt_secret create_server.Create(create_server_args).execute( create_server_args, next_port.next(), False) self.logger.info('[{}/{}] server{} created'.format( next_step.next(), total_steps, name)) # ################################################################################################################################ # # 5) load-balancer # lb_path = os.path.join(args_path, 'load-balancer') os.mkdir(lb_path) create_lb_args = self._bunch_from_args(args, cluster_name) create_lb_args.path = lb_path create_lb_args.cert_path = lb_agent_crypto_loc.cert_path create_lb_args.pub_key_path = lb_agent_crypto_loc.pub_path create_lb_args.priv_key_path = lb_agent_crypto_loc.priv_path create_lb_args.ca_certs_path = lb_agent_crypto_loc.ca_certs_path # Need to substract 1 because we've already called .next() twice # when creating servers above. servers_port = next_port.next() - 1 create_lb.Create(create_lb_args).execute(create_lb_args, True, servers_port, False) self.logger.info('[{}/{}] Load-balancer created'.format( next_step.next(), total_steps)) # ################################################################################################################################ # # 6) Web admin # web_admin_path = os.path.join(args_path, 'web-admin') os.mkdir(web_admin_path) create_web_admin_args = self._bunch_from_args(args, cluster_name) create_web_admin_args.path = web_admin_path create_web_admin_args.cert_path = web_admin_crypto_loc.cert_path create_web_admin_args.pub_key_path = web_admin_crypto_loc.pub_path create_web_admin_args.priv_key_path = web_admin_crypto_loc.priv_path create_web_admin_args.ca_certs_path = web_admin_crypto_loc.ca_certs_path create_web_admin_args.admin_invoke_password = admin_invoke_password password = generate_password() admin_created = create_web_admin.Create(create_web_admin_args).execute( create_web_admin_args, False, password, True) # Need to reset the logger here because executing the create_web_admin command # loads the web admin's logger which doesn't like that of ours. self.reset_logger(args, True) self.logger.info('[{}/{}] Web admin created'.format( next_step.next(), total_steps)) # ################################################################################################################################ # # 7) Scheduler # scheduler_path = os.path.join(args_path, 'scheduler') os.mkdir(scheduler_path) session = get_session(get_engine(args)) with closing(session): cluster_id = session.query(Cluster.id).\ filter(Cluster.name==cluster_name).\ one()[0] create_scheduler_args = self._bunch_from_args(args, cluster_name) create_scheduler_args.path = scheduler_path create_scheduler_args.cert_path = scheduler_crypto_loc.cert_path create_scheduler_args.pub_key_path = scheduler_crypto_loc.pub_path create_scheduler_args.priv_key_path = scheduler_crypto_loc.priv_path create_scheduler_args.ca_certs_path = scheduler_crypto_loc.ca_certs_path create_scheduler_args.cluster_id = cluster_id password = generate_password() admin_created = create_scheduler.Create(create_scheduler_args).execute( create_scheduler_args, False, password, True) self.logger.info('[{}/{}] Scheduler created'.format( next_step.next(), total_steps)) # ################################################################################################################################ # # 8) Scripts # zato_bin = 'zato' zato_qs_start_path = os.path.join(args_path, 'zato-qs-start.sh') zato_qs_stop_path = os.path.join(args_path, 'zato-qs-stop.sh') zato_qs_restart_path = os.path.join(args_path, 'zato-qs-restart.sh') sanity_checks = [] start_servers = [] stop_servers = [] for name in server_names: sanity_checks.append( sanity_checks_template.format(server_name=server_names[name])) start_servers.append( start_servers_template.format(server_name=server_names[name], step_number=int(name) + 3)) stop_servers.append( stop_servers_template.format(server_name=server_names[name], step_number=int(name) + 1)) sanity_checks = '\n'.join(sanity_checks) start_servers = '\n'.join(start_servers) stop_servers = '\n'.join(stop_servers) start_steps = 4 + servers stop_steps = 2 + servers zato_qs_start_head = zato_qs_start_head_template.format( zato_bin=zato_bin, script_dir=script_dir, cluster_name=cluster_name, start_steps=start_steps) zato_qs_start_body = zato_qs_start_body_template.format( sanity_checks=sanity_checks, start_servers=start_servers) zato_qs_start = zato_qs_start_head + zato_qs_start_body + zato_qs_start_tail zato_qs_stop = zato_qs_stop_template.format(zato_bin=zato_bin, script_dir=script_dir, cluster_name=cluster_name, stop_steps=stop_steps, stop_servers=stop_servers) open(zato_qs_start_path, 'w').write(zato_qs_start) open(zato_qs_stop_path, 'w').write(zato_qs_stop) open(zato_qs_restart_path, 'w').write( zato_qs_restart.format(script_dir=script_dir, cluster_name=cluster_name)) file_mod = stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR | stat.S_IRGRP os.chmod(zato_qs_start_path, file_mod) os.chmod(zato_qs_stop_path, file_mod) os.chmod(zato_qs_restart_path, file_mod) self.logger.info('[{}/{}] Management scripts created'.format( next_step.next(), total_steps)) self.logger.info('Quickstart cluster {} created'.format(cluster_name)) if admin_created: self.logger.info( 'Web admin user:[admin], password:[{}]'.format(password)) else: self.logger.info('User [admin] already exists in the ODB') start_command = os.path.join(args_path, 'zato-qs-start.sh') self.logger.info('Start the cluster by issuing the {} command'.format( start_command)) self.logger.info( 'Visit https://zato.io/support for more information and support options' )
def execute(self, args, show_output=True, password=None): os.chdir(self.target_dir) repo_dir = os.path.join(self.target_dir, 'config', 'repo') zato_admin_conf_path = os.path.join(repo_dir, 'zato-admin.conf') initial_data_json_path = os.path.join(repo_dir, 'initial-data.json') os.mkdir(os.path.join(self.target_dir, 'logs')) os.mkdir(os.path.join(self.target_dir, 'config')) os.mkdir(os.path.join(self.target_dir, 'config', 'zdaemon')) os.mkdir(repo_dir) user_name = 'admin' password = password if password else generate_password() self.copy_zato_admin_crypto(repo_dir, args) pub_key = open(os.path.join(repo_dir, 'zato-admin-pub-key.pem')).read() config = { 'host': zato_admin_host, 'port': zato_admin_port, 'db_type': args.odb_type, 'log_config': 'logging.conf', 'DATABASE_NAME': args.odb_db_name, 'DATABASE_USER': args.odb_user, 'DATABASE_PASSWORD': encrypt(args.odb_password, pub_key), 'DATABASE_HOST': args.odb_host, 'DATABASE_PORT': args.odb_port, 'SITE_ID': getrandbits(20), 'SECRET_KEY': encrypt(uuid.uuid4().hex, pub_key), 'TECH_ACCOUNT_NAME':args.tech_account_name, 'TECH_ACCOUNT_PASSWORD':encrypt(args.tech_account_password, pub_key), } open(os.path.join(repo_dir, 'logging.conf'), 'w').write(common_logging_conf_contents.format(log_path='./logs/zato-admin.log')) open(zato_admin_conf_path, 'w').write(config_template.format(**config)) open(initial_data_json_path, 'w').write(initial_data_json.format(**config)) # Initial info self.store_initial_info(self.target_dir, self.COMPONENTS.ZATO_ADMIN.code) config = json.loads(open(os.path.join(repo_dir, 'zato-admin.conf')).read()) config['config_dir'] = self.target_dir update_globals(config, self.target_dir) os.environ['DJANGO_SETTINGS_MODULE'] = 'zato.admin.settings' # Can't import these without DJANGO_SETTINGS_MODULE being set from django.contrib.auth.models import User from django.db import connection from django.db.utils import IntegrityError call_command('syncdb', interactive=False, verbosity=0) call_command('loaddata', initial_data_json_path, verbosity=0) try: call_command('createsuperuser', interactive=False, username=user_name, first_name='admin-first-name', last_name='admin-last-name', email='*****@*****.**') admin_created = True except IntegrityError, e: admin_created = False connection._rollback() msg = 'Ignoring IntegrityError e:[{}]'.format(format_exc(e)) self.logger.info(msg)
def execute(self, args): """ Quickly creates Zato components 1) CA and crypto material 2) ODB 3) ODB initial data 4) server1 5) server2 6) load-balancer 7) Web admin 8) Scripts """ next_step = count(1) next_port = count(http_plain_server_port) total_steps = 8 cluster_name = "quickstart-{}".format(random.getrandbits(20)).zfill(7) server_names = {"1": "server1", "2": "server2"} admin_invoke_password = uuid4().hex broker_host = "localhost" broker_port = 6379 lb_host = "localhost" lb_port = 11223 lb_agent_port = 20151 args_path = os.path.abspath(args.path) # This could've been set to True by user in the command-line so we'd want # to unset it so that individual commands quickstart invokes don't attempt # to store their own configs. args.store_config = False # # 1) CA # ca_path = os.path.join(args_path, "ca") os.mkdir(ca_path) ca_args = self._bunch_from_args(args, cluster_name) ca_args.path = ca_path ca_args_server1 = deepcopy(ca_args) ca_args_server1.server_name = server_names["1"] ca_args_server2 = deepcopy(ca_args) ca_args_server2.server_name = server_names["2"] ca_create_ca.Create(ca_args).execute(ca_args, False) ca_create_lb_agent.Create(ca_args).execute(ca_args, False) ca_create_server.Create(ca_args_server1).execute(ca_args_server1, False) ca_create_server.Create(ca_args_server2).execute(ca_args_server2, False) ca_create_web_admin.Create(ca_args).execute(ca_args, False) server_crypto_loc = {} for key in server_names: server_crypto_loc[key] = CryptoMaterialLocation(ca_path, "{}-{}".format(cluster_name, server_names[key])) lb_agent_crypto_loc = CryptoMaterialLocation(ca_path, "lb-agent") web_admin_crypto_loc = CryptoMaterialLocation(ca_path, "web-admin") self.logger.info("[{}/{}] Certificate authority created".format(next_step.next(), total_steps)) # # 2) ODB # if create_odb.Create(args).execute(args, False) == self.SYS_ERROR.ODB_EXISTS: self.logger.info("[{}/{}] ODB schema already exists".format(next_step.next(), total_steps)) else: self.logger.info("[{}/{}] ODB schema created".format(next_step.next(), total_steps)) # # 3) ODB initial data # create_cluster_args = self._bunch_from_args(args, cluster_name) create_cluster_args.broker_host = broker_host create_cluster_args.broker_port = broker_port create_cluster_args.lb_host = lb_host create_cluster_args.lb_port = lb_port create_cluster_args.lb_agent_port = lb_agent_port create_cluster_args.admin_invoke_password = admin_invoke_password create_cluster.Create(create_cluster_args).execute(create_cluster_args, False) self.logger.info("[{}/{}] ODB initial data created".format(next_step.next(), total_steps)) # # 4) server1 # 5) server2 # for key in server_names: server_path = os.path.join(args_path, server_names[key]) os.mkdir(server_path) create_server_args = self._bunch_from_args(args, cluster_name) create_server_args.server_name = server_names[key] create_server_args.path = server_path create_server_args.cert_path = server_crypto_loc[key].cert_path create_server_args.pub_key_path = server_crypto_loc[key].pub_path create_server_args.priv_key_path = server_crypto_loc[key].priv_path create_server_args.ca_certs_path = server_crypto_loc[key].ca_certs_path create_server.Create(create_server_args).execute(create_server_args, next_port.next(), False) self.logger.info("[{}/{}] server{} created".format(next_step.next(), total_steps, key)) # # 6) load-balancer # lb_path = os.path.join(args_path, "load-balancer") os.mkdir(lb_path) create_lb_args = self._bunch_from_args(args, cluster_name) create_lb_args.path = lb_path create_lb_args.cert_path = lb_agent_crypto_loc.cert_path create_lb_args.pub_key_path = lb_agent_crypto_loc.pub_path create_lb_args.priv_key_path = lb_agent_crypto_loc.priv_path create_lb_args.ca_certs_path = lb_agent_crypto_loc.ca_certs_path # Need to substract 1 because we've already called .next() twice # when creating servers above. server2_port = next_port.next() - 1 create_lb.Create(create_lb_args).execute(create_lb_args, True, server2_port, False) self.logger.info("[{}/{}] Load-balancer created".format(next_step.next(), total_steps)) # # 7) Web admin # web_admin_path = os.path.join(args_path, "web-admin") os.mkdir(web_admin_path) create_web_admin_args = self._bunch_from_args(args, cluster_name) create_web_admin_args.path = web_admin_path create_web_admin_args.cert_path = web_admin_crypto_loc.cert_path create_web_admin_args.pub_key_path = web_admin_crypto_loc.pub_path create_web_admin_args.priv_key_path = web_admin_crypto_loc.priv_path create_web_admin_args.ca_certs_path = web_admin_crypto_loc.ca_certs_path create_web_admin_args.admin_invoke_password = admin_invoke_password password = generate_password() admin_created = create_web_admin.Create(create_web_admin_args).execute(create_web_admin_args, False, password) # Need to reset the logger here because executing the create_web_admin command # loads the web admin's logger which doesn't like that of ours. self.reset_logger(args, True) self.logger.info("[{}/{}] Web admin created".format(next_step.next(), total_steps)) # # 8) Scripts # zato_bin = "zato" zato_qs_start_path = os.path.join(args_path, "zato-qs-start.sh") zato_qs_stop_path = os.path.join(args_path, "zato-qs-stop.sh") zato_qs_restart_path = os.path.join(args_path, "zato-qs-restart.sh") open(zato_qs_start_path, "w").write(zato_qs_start_template.format(zato_bin=zato_bin, script_dir=script_dir)) open(zato_qs_stop_path, "w").write(zato_qs_stop_template.format(zato_bin=zato_bin, script_dir=script_dir)) open(zato_qs_restart_path, "w").write(zato_qs_restart.format(script_dir=script_dir)) file_mod = stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR | stat.S_IRGRP os.chmod(zato_qs_start_path, file_mod) os.chmod(zato_qs_stop_path, file_mod) os.chmod(zato_qs_restart_path, file_mod) self.logger.info("[{}/{}] Management scripts created".format(next_step.next(), total_steps)) self.logger.info("Quickstart cluster {} created".format(cluster_name)) if admin_created: self.logger.info("Web admin user:[admin], password:[{}]".format(password)) else: self.logger.info("User [admin] already exists in the ODB") start_command = os.path.join(args_path, "zato-qs-start.sh") self.logger.info("Start the cluster by issuing the {} command".format(start_command)) self.logger.info("Visit https://zato.io/support for more information and support options")
def execute(self, args): """ Quickly creates Zato components 1) CA and crypto material 2) ODB 3) ODB initial data 4) servers 5) load-balancer 6) Web admin 7) Scripts """ if args.odb_type == 'sqlite': args.sqlite_path = os.path.abspath(os.path.join(args.path, 'zato.db')) next_step = count(1) next_port = count(http_plain_server_port) cluster_name = getattr(args, 'cluster_name', None) or 'quickstart-{}'.format(random.getrandbits(20)).zfill(7) servers = int(getattr(args, 'servers', 0) or DEFAULT_NO_SERVERS) server_names = OrderedDict() for idx in range(1, servers+1): server_names['{}'.format(idx)] = 'server{}'.format(idx) total_steps = 6 + servers admin_invoke_password = uuid4().hex broker_host = 'localhost' broker_port = 6379 lb_host = 'localhost' lb_port = 11223 lb_agent_port = 20151 args_path = os.path.abspath(args.path) # This could've been set to True by user in the command-line so we'd want # to unset it so that individual commands quickstart invokes don't attempt # to store their own configs. args.store_config = False # # 1) CA # ca_path = os.path.join(args_path, 'ca') os.mkdir(ca_path) ca_args = self._bunch_from_args(args, cluster_name) ca_args.path = ca_path ca_create_ca.Create(ca_args).execute(ca_args, False) ca_create_lb_agent.Create(ca_args).execute(ca_args, False) ca_create_web_admin.Create(ca_args).execute(ca_args, False) server_crypto_loc = {} for name in server_names: ca_args_server = deepcopy(ca_args) ca_args_server.server_name = server_names[name] ca_create_server.Create(ca_args_server).execute(ca_args_server, False) server_crypto_loc[name] = CryptoMaterialLocation(ca_path, '{}-{}'.format(cluster_name, server_names[name])) lb_agent_crypto_loc = CryptoMaterialLocation(ca_path, 'lb-agent') web_admin_crypto_loc = CryptoMaterialLocation(ca_path, 'web-admin') self.logger.info('[{}/{}] Certificate authority created'.format(next_step.next(), total_steps)) # # 2) ODB # if create_odb.Create(args).execute(args, False) == self.SYS_ERROR.ODB_EXISTS: self.logger.info('[{}/{}] ODB schema already exists'.format(next_step.next(), total_steps)) else: self.logger.info('[{}/{}] ODB schema created'.format(next_step.next(), total_steps)) # # 3) ODB initial data # create_cluster_args = self._bunch_from_args(args, cluster_name) create_cluster_args.broker_host = broker_host create_cluster_args.broker_port = broker_port create_cluster_args.lb_host = lb_host create_cluster_args.lb_port = lb_port create_cluster_args.lb_agent_port = lb_agent_port create_cluster_args.admin_invoke_password = admin_invoke_password create_cluster.Create(create_cluster_args).execute(create_cluster_args, False) self.logger.info('[{}/{}] ODB initial data created'.format(next_step.next(), total_steps)) # # 4) servers # for name in server_names: server_path = os.path.join(args_path, server_names[name]) os.mkdir(server_path) create_server_args = self._bunch_from_args(args, cluster_name) create_server_args.server_name = server_names[name] create_server_args.path = server_path create_server_args.cert_path = server_crypto_loc[name].cert_path create_server_args.pub_key_path = server_crypto_loc[name].pub_path create_server_args.priv_key_path = server_crypto_loc[name].priv_path create_server_args.ca_certs_path = server_crypto_loc[name].ca_certs_path create_server.Create(create_server_args).execute(create_server_args, next_port.next(), False) self.logger.info('[{}/{}] server{} created'.format(next_step.next(), total_steps, name)) # # 5) load-balancer # lb_path = os.path.join(args_path, 'load-balancer') os.mkdir(lb_path) create_lb_args = self._bunch_from_args(args, cluster_name) create_lb_args.path = lb_path create_lb_args.cert_path = lb_agent_crypto_loc.cert_path create_lb_args.pub_key_path = lb_agent_crypto_loc.pub_path create_lb_args.priv_key_path = lb_agent_crypto_loc.priv_path create_lb_args.ca_certs_path = lb_agent_crypto_loc.ca_certs_path # Need to substract 1 because we've already called .next() twice # when creating servers above. servers_port = next_port.next() - 1 create_lb.Create(create_lb_args).execute(create_lb_args, True, servers_port, False) self.logger.info('[{}/{}] Load-balancer created'.format(next_step.next(), total_steps)) # # 6) Web admin # web_admin_path = os.path.join(args_path, 'web-admin') os.mkdir(web_admin_path) create_web_admin_args = self._bunch_from_args(args, cluster_name) create_web_admin_args.path = web_admin_path create_web_admin_args.cert_path = web_admin_crypto_loc.cert_path create_web_admin_args.pub_key_path = web_admin_crypto_loc.pub_path create_web_admin_args.priv_key_path = web_admin_crypto_loc.priv_path create_web_admin_args.ca_certs_path = web_admin_crypto_loc.ca_certs_path create_web_admin_args.admin_invoke_password = admin_invoke_password password = generate_password() admin_created = create_web_admin.Create(create_web_admin_args).execute( create_web_admin_args, False, password, True) # Need to reset the logger here because executing the create_web_admin command # loads the web admin's logger which doesn't like that of ours. self.reset_logger(args, True) self.logger.info('[{}/{}] Web admin created'.format(next_step.next(), total_steps)) # # 7) Scripts # zato_bin = 'zato' zato_qs_start_path = os.path.join(args_path, 'zato-qs-start.sh') zato_qs_stop_path = os.path.join(args_path, 'zato-qs-stop.sh') zato_qs_restart_path = os.path.join(args_path, 'zato-qs-restart.sh') sanity_checks = [] start_servers = [] stop_servers = [] for name in server_names: sanity_checks.append(sanity_checks_template.format(server_name=server_names[name])) start_servers.append(start_servers_template.format(server_name=server_names[name], step_number=int(name)+3)) stop_servers.append(stop_servers_template.format(server_name=server_names[name], step_number=int(name)+1)) sanity_checks = '\n'.join(sanity_checks) start_servers = '\n'.join(start_servers) stop_servers = '\n'.join(stop_servers) start_steps = 4 + servers stop_steps = 2 + servers zato_qs_start_head = zato_qs_start_head_template.format( zato_bin=zato_bin, script_dir=script_dir, cluster_name=cluster_name, start_steps=start_steps) zato_qs_start_body = zato_qs_start_body_template.format(sanity_checks=sanity_checks, start_servers=start_servers) zato_qs_start = zato_qs_start_head + zato_qs_start_body + zato_qs_start_tail zato_qs_stop = zato_qs_stop_template.format( zato_bin=zato_bin, script_dir=script_dir, cluster_name=cluster_name, stop_steps=stop_steps, stop_servers=stop_servers) open(zato_qs_start_path, 'w').write(zato_qs_start) open(zato_qs_stop_path, 'w').write(zato_qs_stop) open(zato_qs_restart_path, 'w').write(zato_qs_restart.format(script_dir=script_dir, cluster_name=cluster_name)) file_mod = stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR | stat.S_IRGRP os.chmod(zato_qs_start_path, file_mod) os.chmod(zato_qs_stop_path, file_mod) os.chmod(zato_qs_restart_path, file_mod) self.logger.info('[{}/{}] Management scripts created'.format(next_step.next(), total_steps)) self.logger.info('Quickstart cluster {} created'.format(cluster_name)) if admin_created: self.logger.info('Web admin user:[admin], password:[{}]'.format(password)) else: self.logger.info('User [admin] already exists in the ODB') start_command = os.path.join(args_path, 'zato-qs-start.sh') self.logger.info('Start the cluster by issuing the {} command'.format(start_command)) self.logger.info('Visit https://zato.io/support for more information and support options')
def execute(self, args, show_output=True, password=None, needs_admin_created_flag=False): os.chdir(self.target_dir) repo_dir = os.path.join(self.target_dir, 'config', 'repo') web_admin_conf_path = os.path.join(repo_dir, 'web-admin.conf') initial_data_json_path = os.path.join(repo_dir, 'initial-data.json') os.mkdir(os.path.join(self.target_dir, 'logs')) os.mkdir(os.path.join(self.target_dir, 'config')) os.mkdir(repo_dir) user_name = 'admin' password = password if password else generate_password() self.copy_web_admin_crypto(repo_dir, args) priv_key = open(os.path.join(repo_dir, 'web-admin-priv-key.pem')).read() config = { 'host': web_admin_host, 'port': web_admin_port, 'db_type': args.odb_type, 'log_config': 'logging.conf', 'DATABASE_NAME': args.odb_db_name or args.sqlite_path, 'DATABASE_USER': args.odb_user or '', 'DATABASE_PASSWORD': encrypt(args.odb_password, priv_key) if args.odb_password else '', 'DATABASE_HOST': args.odb_host or '', 'DATABASE_PORT': args.odb_port or '', 'SITE_ID': getrandbits(20), 'SECRET_KEY': encrypt(uuid.uuid4().hex, priv_key), 'ADMIN_INVOKE_NAME':'admin.invoke', 'ADMIN_INVOKE_PASSWORD':encrypt(getattr(args, 'admin_invoke_password', None) or getattr(args, 'tech_account_password'), priv_key), } open(os.path.join(repo_dir, 'logging.conf'), 'w').write(common_logging_conf_contents.format(log_path='./logs/web-admin.log')) open(web_admin_conf_path, 'w').write(config_template.format(**config)) open(initial_data_json_path, 'w').write(initial_data_json.format(**config)) # Initial info self.store_initial_info(self.target_dir, self.COMPONENTS.WEB_ADMIN.code) config = json.loads(open(os.path.join(repo_dir, 'web-admin.conf')).read()) config['config_dir'] = self.target_dir update_globals(config, self.target_dir) os.environ['DJANGO_SETTINGS_MODULE'] = 'zato.admin.settings' # Can't import these without DJANGO_SETTINGS_MODULE being set from django.contrib.auth.models import User from django.db import connection from django.db.utils import IntegrityError call_command('syncdb', interactive=False, verbosity=0) call_command('loaddata', initial_data_json_path, verbosity=0) try: call_command( 'createsuperuser', interactive=False, username=user_name, first_name='admin-first-name', last_name='admin-last-name', email='*****@*****.**') admin_created = True user = User.objects.get(username=user_name) user.set_password(password) user.save() except IntegrityError, e: admin_created = False connection._rollback() self.logger.info('Ignoring IntegrityError e:[%s]', format_exc(e).decode('utf-8'))
def execute(self, args, show_output=True, password=None, needs_admin_created_flag=False): os.chdir(self.target_dir) repo_dir = os.path.join(self.target_dir, 'config', 'repo') web_admin_conf_path = os.path.join(repo_dir, 'web-admin.conf') initial_data_json_path = os.path.join(repo_dir, 'initial-data.json') os.mkdir(os.path.join(self.target_dir, 'logs')) os.mkdir(os.path.join(self.target_dir, 'config')) os.mkdir(repo_dir) user_name = 'admin' password = password if password else generate_password() self.copy_web_admin_crypto(repo_dir, args) priv_key = open(os.path.join(repo_dir, 'web-admin-priv-key.pem')).read() config = { 'host': web_admin_host, 'port': web_admin_port, 'db_type': args.odb_type, 'log_config': 'logging.conf', 'DATABASE_NAME': args.odb_db_name or args.sqlite_path, 'DATABASE_USER': args.odb_user or '', 'DATABASE_PASSWORD': encrypt(args.odb_password, priv_key) if args.odb_password else '', 'DATABASE_HOST': args.odb_host or '', 'DATABASE_PORT': args.odb_port or '', 'SITE_ID': getrandbits(20), 'SECRET_KEY': encrypt(uuid.uuid4().hex, priv_key), 'ADMIN_INVOKE_NAME': 'admin.invoke', 'ADMIN_INVOKE_PASSWORD': encrypt( getattr(args, 'admin_invoke_password', None) or getattr(args, 'tech_account_password'), priv_key), } open(os.path.join(repo_dir, 'logging.conf'), 'w').write( common_logging_conf_contents.format( log_path='./logs/web-admin.log')) open(web_admin_conf_path, 'w').write(config_template.format(**config)) open(initial_data_json_path, 'w').write(initial_data_json.format(**config)) # Initial info self.store_initial_info(self.target_dir, self.COMPONENTS.WEB_ADMIN.code) config = json.loads( open(os.path.join(repo_dir, 'web-admin.conf')).read()) config['config_dir'] = self.target_dir update_globals(config, self.target_dir) os.environ['DJANGO_SETTINGS_MODULE'] = 'zato.admin.settings' import django django.setup() self.reset_logger(args, True) # Can't import these without DJANGO_SETTINGS_MODULE being set from django.contrib.auth.models import User from django.db import connection from django.db.utils import IntegrityError call_command('migrate', run_syncdb=True, interactive=False, verbosity=0) call_command('loaddata', initial_data_json_path, verbosity=0) try: call_command('createsuperuser', interactive=False, username=user_name, first_name='admin-first-name', last_name='admin-last-name', email='*****@*****.**') admin_created = True user = User.objects.get(username=user_name) user.set_password(password) user.save() except IntegrityError: # This will happen if user 'admin' already exists, e.g. if this is not the first cluster in this database admin_created = False connection._rollback() # Needed because Django took over our logging config self.reset_logger(args, True) if show_output: if self.verbose: msg = """Successfully created a web admin instance. You can start it with the 'zato start {path}' command.""".format( path=os.path.abspath( os.path.join(os.getcwd(), self.target_dir))) self.logger.debug(msg) else: self.logger.info('OK') # We return it only when told to explicitly so when the command runs from CLI # it doesn't return a non-zero exit code. if needs_admin_created_flag: return admin_created
def execute(self, args, show_output=True, password=None, needs_created_flag=False): os.chdir(self.target_dir) repo_dir = os.path.join(self.target_dir, 'config', 'repo') conf_path = os.path.join(repo_dir, 'scheduler.conf') startup_jobs_conf_path = os.path.join(repo_dir, 'startup_jobs.conf') sql_conf_path = os.path.join(repo_dir, 'sql.conf') os.mkdir(os.path.join(self.target_dir, 'logs')) os.mkdir(os.path.join(self.target_dir, 'config')) os.mkdir(repo_dir) self.copy_scheduler_crypto(repo_dir, args) priv_key = open(os.path.join(repo_dir, 'zato-scheduler-priv-key.pem')).read() config = { 'odb_db_name': args.odb_db_name or args.sqlite_path, 'odb_engine': args.odb_type, 'odb_host': args.odb_host or '', 'odb_port': args.odb_port or '', 'odb_password': encrypt(args.odb_password, priv_key) if args.odb_password else '', 'odb_username': args.odb_user or '', 'broker_host': args.kvdb_host, 'broker_port': args.kvdb_port, 'broker_password': encrypt(args.kvdb_password, priv_key) if args.kvdb_password else '', 'user1_password': generate_password(), 'cluster_id': args.cluster_id, } open(os.path.join(repo_dir, 'logging.conf'), 'w').write( common_logging_conf_contents.format( log_path='./logs/scheduler.log')) open(conf_path, 'w').write(config_template.format(**config)) open(startup_jobs_conf_path, 'w').write(startup_jobs) open(sql_conf_path, 'w').write(sql_conf_contents) # Initial info self.store_initial_info(self.target_dir, self.COMPONENTS.SCHEDULER.code) if show_output: if self.verbose: msg = """Successfully created a scheduler instance. You can start it with the 'zato start {path}' command.""".format( path=os.path.abspath( os.path.join(os.getcwd(), self.target_dir))) self.logger.debug(msg) else: self.logger.info('OK') # We return it only when told to explicitly so when the command runs from CLI # it doesn't return a non-zero exit code. if needs_created_flag: return True
def execute(self, args): """ Quickly creates Zato components 1) CA and crypto material 2) ODB 3) ODB initial data 4) server1 5) server2 6) load-balancer 7) Zato admin 8) Scripts """ next_step = count(1) next_port = count(http_plain_server_port) total_steps = 8 cluster_name = 'quickstart-{}'.format(random.getrandbits(20)).zfill(7) server_names = {'1':'server1', '2':'server2'} tech_account_name = 'techacct-{}'.format(random.getrandbits(20)).zfill(7) tech_account_password = uuid4().hex broker_host = 'localhost' broker_port = 6379 lb_host = 'localhost' lb_port = 11223 lb_agent_port = 20151 # This could've been set to True by user in the command-line so we'd want # to unset it so that individual commands quickstart invokes don't attempt # to store their own configs. args.store_config = False # # 1) CA # ca_path = os.path.join(args.path, 'ca') os.mkdir(ca_path) ca_args = self._bunch_from_args(args, cluster_name) ca_args.path = ca_path ca_args_server1 = deepcopy(ca_args) ca_args_server1.server_name = server_names['1'] ca_args_server2 = deepcopy(ca_args) ca_args_server2.server_name = server_names['2'] ca_create_ca.Create(ca_args).execute(ca_args, False) ca_create_lb_agent.Create(ca_args).execute(ca_args, False) ca_create_server.Create(ca_args_server1).execute(ca_args_server1, False) ca_create_server.Create(ca_args_server2).execute(ca_args_server2, False) ca_create_zato_admin.Create(ca_args).execute(ca_args, False) server_crypto_loc = {} for key in server_names: server_crypto_loc[key] = CryptoMaterialLocation(ca_path, '{}-{}'.format(cluster_name, server_names[key])) lb_agent_crypto_loc = CryptoMaterialLocation(ca_path, 'lb-agent') zato_admin_crypto_loc = CryptoMaterialLocation(ca_path, 'zato-admin') self.logger.info('[{}/{}] Certificate authority created'.format(next_step.next(), total_steps)) # # 2) ODB # if create_odb.Create(args).execute(args, False) == self.SYS_ERROR.ODB_EXISTS: self.logger.info('[{}/{}] ODB schema already exists, not creating it'.format(next_step.next(), total_steps)) else: self.logger.info('[{}/{}] ODB schema created'.format(next_step.next(), total_steps)) # # 3) ODB initial data # create_cluster_args = self._bunch_from_args(args, cluster_name) create_cluster_args.broker_host = broker_host create_cluster_args.broker_port = broker_port create_cluster_args.lb_host = lb_host create_cluster_args.lb_port = lb_port create_cluster_args.lb_agent_port = lb_agent_port create_cluster_args.tech_account_name = tech_account_name create_cluster_args.tech_account_password = tech_account_password create_cluster.Create(create_cluster_args).execute(create_cluster_args, False) self.logger.info('[{}/{}] ODB initial data created'.format(next_step.next(), total_steps)) # # 4) server1 # 5) server2 # for key in server_names: server_path = os.path.join(args.path, server_names[key]) os.mkdir(server_path) create_server_args = self._bunch_from_args(args, cluster_name) create_server_args.server_name = server_names[key] create_server_args.path = server_path create_server_args.cert_path = server_crypto_loc[key].cert_path create_server_args.pub_key_path = server_crypto_loc[key].pub_path create_server_args.priv_key_path = server_crypto_loc[key].priv_path create_server_args.ca_certs_path = server_crypto_loc[key].ca_certs_path create_server.Create(create_server_args).execute(create_server_args, next_port.next(), False) self.logger.info('[{}/{}] server{} created'.format(next_step.next(), total_steps, key)) # # 6) load-balancer # lb_path = os.path.join(args.path, 'load-balancer') os.mkdir(lb_path) create_lb_args = self._bunch_from_args(args, cluster_name) create_lb_args.path = lb_path create_lb_args.cert_path = lb_agent_crypto_loc.cert_path create_lb_args.pub_key_path = lb_agent_crypto_loc.pub_path create_lb_args.priv_key_path = lb_agent_crypto_loc.priv_path create_lb_args.ca_certs_path = lb_agent_crypto_loc.ca_certs_path # Need to substract 1 because we've already called .next() twice # when creating servers above. server2_port = next_port.next()-1 create_lb.Create(create_lb_args).execute(create_lb_args, True, server2_port, False) self.logger.info('[{}/{}] Load-balancer created'.format(next_step.next(), total_steps)) # # 7) Zato admin # zato_admin_path = os.path.join(args.path, 'zato-admin') os.mkdir(zato_admin_path) create_zato_admin_args = self._bunch_from_args(args, cluster_name) create_zato_admin_args.path = zato_admin_path create_zato_admin_args.cert_path = zato_admin_crypto_loc.cert_path create_zato_admin_args.pub_key_path = zato_admin_crypto_loc.pub_path create_zato_admin_args.priv_key_path = zato_admin_crypto_loc.priv_path create_zato_admin_args.ca_certs_path = zato_admin_crypto_loc.ca_certs_path create_zato_admin_args.tech_account_name = tech_account_name create_zato_admin_args.tech_account_password = tech_account_password password = generate_password() admin_created = create_zato_admin.Create(create_zato_admin_args).execute(create_zato_admin_args, False, password) # Need to reset the logger here because executing the create_zato_admin command # loads the Zato admin's logger which doesn't like that of ours. self.reset_logger(args, True) self.logger.info('[{}/{}] Zato admin created'.format(next_step.next(), total_steps)) # # 8) Scripts # zato_bin = os.path.join(os.path.dirname(sys.executable), 'zato') zato_qs_start_path = os.path.join(args.path, 'zato-qs-start.sh') zato_qs_stop_path = os.path.join(args.path, 'zato-qs-stop.sh') zato_qs_restart_path = os.path.join(args.path, 'zato-qs-restart.sh') open(zato_qs_start_path, 'w').write(zato_qs_start_template.format(zato_bin=zato_bin, script_dir=script_dir)) open(zato_qs_stop_path, 'w').write(zato_qs_stop_template.format(zato_bin=zato_bin, script_dir=script_dir)) open(zato_qs_restart_path, 'w').write(zato_qs_restart.format(script_dir=script_dir)) file_mod = stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR | stat.S_IRGRP os.chmod(zato_qs_start_path, file_mod) os.chmod(zato_qs_stop_path, file_mod) os.chmod(zato_qs_restart_path, file_mod) self.logger.info('[{}/{}] Management scripts created'.format(next_step.next(), total_steps)) self.logger.info('Quickstart cluster {} created'.format(cluster_name)) if admin_created: self.logger.info('Zato admin user:[admin], password:[{}]'.format(password)) else: self.logger.info('User [admin] already exists in the ODB') self.logger.info('Start the cluster by issuing the {}/zato-qs-start.sh command'.format(args.path)) self.logger.info('Visit https://TODO for more information and support options')