def post_upgrade_restart(self, env, upgrade_type=None):
if upgrade_type == "nonrolling":
return
Logger.info("Executing Stack Upgrade post-restart")
import params
env.set_params(params)
zk_server_host = random.choice(params.zookeeper_hosts)
cli_shell = format(
"{zk_cli_shell} -server {zk_server_host}:{client_port}")
# Ensure that a quorum is still formed.
unique = get_unique_id_and_date()
create_command = format("echo 'create /{unique} mydata' | {cli_shell}")
list_command = format("echo 'ls /' | {cli_shell}")
delete_command = format("echo 'delete /{unique} ' | {cli_shell}")
quorum_err_message = "Failed to establish zookeeper quorum"
call_and_match_output(create_command, 'Created', quorum_err_message)
call_and_match_output(list_command, r"\[.*?" + unique + ".*?\]",
quorum_err_message)
call(delete_command)
if params.client_port:
check_leader_command = format(
"echo stat | nc localhost {client_port} | grep Mode")
code, out = call(check_leader_command, logoutput=False)
if code == 0 and out:
Logger.info(out)
def service_check(self, env):
import params
env.set_params(params)
# TODO, Kafka was introduced in HDP 2.2 but will not support running in a kerberized cluster until HDP 2.3 (tentatively)
# Kafka uses its own Zookeeper instance and it does not yet have the capability of running in a secure mode.
kafka_config = self.read_kafka_config()
create_topic_cmd_created_output = "Created topic \"ambari_kafka_service_check\"."
create_topic_cmd_exists_output = "Topic \"ambari_kafka_service_check\" already exists."
source_cmd = format("source {conf_dir}/kafka-env.sh")
create_topic_cmd = format(
"{kafka_home}/bin/kafka-topics.sh --zookeeper {kafka_config[zookeeper.connect]} --create --topic ambari_kafka_service_check --partitions 1 --replication-factor 1"
)
command = source_cmd + " ; " + create_topic_cmd
Logger.info("Running kafka create topic command: %s" % command)
call_and_match_output(
command,
format(
"({create_topic_cmd_created_output})|({create_topic_cmd_exists_output})"
),
"Failed to check that topic exists",
user=params.kafka_user)
def service_check(self, env):
import params
env.set_params(params)
url = "http://" + params.solr_server_host + ":" + str(
params.solr_port) + "/solr/"
if params.security_enabled:
kinit_cmd = format(
"{kinit_path_local} -kt {smoke_user_keytab} {smokeuser_principal};"
)
Execute(kinit_cmd, user=params.smokeuser, logoutput=True)
create_collection_cmd = format(
"SOLR_INCLUDE={solr_conf_dir}/solr.in.sh solr create -c smokeuser_ExampleCollection -s 2 -d data_driven_schema_configs"
)
Logger.info("Creating solr collection from example: %s" %
create_collection_cmd)
Execute(create_collection_cmd, user=params.smokeuser, logoutput=True)
list_collection_cmd = "su " + params.smokeuser + " -c 'curl -s --negotiate -u : " + url + "admin/collections?action=list'"
list_collection_output = "<str>smokeuser_ExampleCollection</str>"
Logger.info("List Collections: %s" % list_collection_cmd)
call_and_match_output(
list_collection_cmd, format("({list_collection_output})"),
"Failed to create collection \"smokeuser_ExampleCollection\" or check that collection exists"
)
delete_collection_cmd = format(
"SOLR_INCLUDE={solr_conf_dir}/solr.in.sh solr delete -c smokeuser_ExampleCollection"
)
Logger.info("Deleting solr collection : %s" % delete_collection_cmd)
Execute(delete_collection_cmd, user=params.smokeuser, logoutput=True)
def service_check(self, env):
import params
env.set_params(params)
# TODO, Kafka Service check should be more robust , It should get all the broker_hosts
# Produce some messages and check if consumer reads same no.of messages.
kafka_config = self.read_kafka_config()
topic = "ambari_kafka_service_check"
create_topic_cmd_created_output = "Created topic \"ambari_kafka_service_check\"."
create_topic_cmd_exists_output = "Topic \"ambari_kafka_service_check\" already exists."
source_cmd = format("source {conf_dir}/kafka-env.sh")
topic_exists_cmd = format(
"{kafka_home}/bin/kafka-topics.sh --zookeeper {kafka_config[zookeeper.connect]} --topic {topic} --list"
)
topic_exists_cmd_p = subprocess.Popen(topic_exists_cmd.split(" "),
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
topic_exists_cmd_out, topic_exists_cmd_err = topic_exists_cmd_p.communicate(
)
# run create topic command only if the topic doesn't exists
if topic not in topic_exists_cmd_out:
create_topic_cmd = format(
"{kafka_home}/bin/kafka-topics.sh --zookeeper {kafka_config[zookeeper.connect]} --create --topic {topic} --partitions 1 --replication-factor 1"
)
command = source_cmd + " ; " + create_topic_cmd
Logger.info("Running kafka create topic command: %s" % command)
call_and_match_output(
command,
format(
"({create_topic_cmd_created_output})|({create_topic_cmd_exists_output})"
),
"Failed to check that topic exists",
user=params.kafka_user)
def post_upgrade_restart(self, env, upgrade_type=None):
if upgrade_type == "nonrolling":
return
Logger.info("Executing Stack Upgrade post-restart")
import params
env.set_params(params)
zk_server_host = random.choice(params.zookeeper_hosts)
cli_shell = format("{zk_cli_shell} -server {zk_server_host}:{client_port}")
# Ensure that a quorum is still formed.
unique = get_unique_id_and_date()
create_command = format("echo 'create /{unique} mydata' | {cli_shell}")
list_command = format("echo 'ls /' | {cli_shell}")
delete_command = format("echo 'delete /{unique} ' | {cli_shell}")
quorum_err_message = "Failed to establish zookeeper quorum"
call_and_match_output(create_command, 'Created', quorum_err_message, user=params.zk_user)
call_and_match_output(list_command, r"\[.*?" + unique + ".*?\]", quorum_err_message, user=params.zk_user)
shell.call(delete_command, user=params.zk_user)
if params.client_port:
check_leader_command = format("echo stat | nc localhost {client_port} | grep Mode")
code, out = shell.call(check_leader_command, logoutput=False)
if code == 0 and out:
Logger.info(out)
def service_check(self, env):
import params
env.set_params(params)
# TODO, Kafka Service check should be more robust , It should get all the broker_hosts
# Produce some messages and check if consumer reads same no.of messages.
kafka_config = self.read_kafka_config()
topic = "ambari_kafka_service_check"
create_topic_cmd_created_output = "Created topic \"ambari_kafka_service_check\"."
create_topic_cmd_exists_output = "Topic \"ambari_kafka_service_check\" already exists."
source_cmd = format("source {conf_dir}/kafka-env.sh")
topic_exists_cmd = format(
source_cmd + " ; " +
"{kafka_home}/bin/kafka-topics.sh --zookeeper {kafka_config[zookeeper.connect]} --topic {topic} --list"
)
topic_exists_cmd_code, topic_exists_cmd_out = shell.call(
topic_exists_cmd,
logoutput=True,
quiet=False,
user=params.kafka_user)
if topic_exists_cmd_code > 0:
raise Fail(
"Error encountered when attempting to list topics: {0}".format(
topic_exists_cmd_out))
if not params.kafka_delete_topic_enable:
Logger.info(
'Kafka delete.topic.enable is not enabled. Skipping topic creation: %s'
% topic)
return
# run create topic command only if the topic doesn't exists
delete_topic_cmd = format(
"{kafka_home}/bin/kafka-topics.sh --zookeeper {kafka_config[zookeeper.connect]} --delete --topic {topic}"
)
create_topic_cmd = format(
"{kafka_home}/bin/kafka-topics.sh --zookeeper {kafka_config[zookeeper.connect]} --create --topic {topic} --partitions 1 --replication-factor 1"
)
if topic in topic_exists_cmd_out:
# run delete topic and recreate the topic command only if the topic exists
command = source_cmd + " ; " + delete_topic_cmd + ";" + create_topic_cmd
else:
# run create topic command
command = source_cmd + " ; " + create_topic_cmd
Logger.info("Running kafka create topic command: %s" % command)
call_and_match_output(
command,
format(
"({create_topic_cmd_created_output})|({create_topic_cmd_exists_output})"
),
"Failed to check that topic exists",
user=params.kafka_user)
def solr_service(action='start'):
import params
cmd = format("{solr_home}/bin/solr")
if action == 'start':
if params.security_enabled:
if params.solr_principal is None:
solr_principal_with_host = 'missing_principal'
else:
solr_principal_with_host = params.solr_principal.replace("_HOST", params.hostname)
kinit_cmd = format("{kinit_path_local} -kt {solr_keytab} {solr_principal_with_host};")
Execute(kinit_cmd,user=params.solr_user)
Execute ('echo "Creating znode" ' + params.zookeeper_chroot)
Execute (params.cloud_scripts + '/zkcli.sh -zkhost ' + params.zookeeper_hosts_list + ' -cmd makepath ' + params.zookeeper_chroot, user=params.solr_user, ignore_failures=True )
# copy titan directory and jar for titan and solr integration
if (('titan-env' in params.configuration_tags) and not (os.path.exists(params.solr_conf_trg_file))):
Execute(("cp", "-r", params.titan_solr_conf_dir, params.solr_conf_trg_dir), sudo = True)
Execute(("cp", params.titan_solr_jar_file, params.solr_jar_trg_file), sudo = True)
Execute(("chmod", "644", params.solr_jar_trg_file), sudo=True)
Execute(("mv", params.solr_solr_conf_dir, params.solr_titan_conf_dir), sudo = True)
daemon_cmd = format("SOLR_INCLUDE={solr_conf_dir}/solr.in.sh {cmd} start -c -V")
no_op_test = format("ls {solr_pid_file} >/dev/null 2>&1 && ps `cat {solr_pid_file}` >/dev/null 2>&1")
Execute(daemon_cmd,
not_if=no_op_test,
user=params.solr_user
)
if not params.upgrade_direction: #Only do this for a fresh IOP 4.2 cluster
# create collection for titan and solr integration
if (('titan-env' in params.configuration_tags) and (os.path.exists(params.solr_conf_trg_file))):
create_collection_cmd = format("SOLR_INCLUDE={solr_conf_dir}/solr.in.sh solr create -c {titan_solr_configset} -s 2 -d {titan_solr_configset}")
create_collection_output = "success"
create_collection_exists_output = format("Collection '{titan_solr_configset}' already exists!")
call_and_match_output(create_collection_cmd, format("({create_collection_output})|({create_collection_exists_output})"), "Failed to create collection")
elif action == 'stop':
daemon_cmd = format("export SOLR_PID_DIR=" + params.pid_dir + "; SOLR_INCLUDE={solr_conf_dir}/solr.in.sh {cmd} stop -all")
no_op_test = format("! ((`SOLR_INCLUDE={solr_conf_dir}/solr.in.sh {cmd} status |grep process |wc -l`))")
rm_pid = format("rm -f {solr_pid_file}")
Execute(daemon_cmd,
not_if=no_op_test,
user=params.solr_user
)
Execute(rm_pid)
def service_check(self, env):
import params
env.set_params(params)
# TODO, Kafka was introduced in HDP 2.2 but will not support running in a kerberized cluster until HDP 2.3 (tentatively)
# Kafka uses its own Zookeeper instance and it does not yet have the capability of running in a secure mode.
kafka_config = self.read_kafka_config()
create_topic_cmd_created_output = "Created topic \"ambari_kafka_service_check\"."
create_topic_cmd_exists_output = "Topic \"ambari_kafka_service_check\" already exists."
source_cmd = format("source {conf_dir}/kafka-env.sh")
create_topic_cmd = format("{kafka_home}/bin/kafka-topics.sh --zookeeper {kafka_config[zookeeper.connect]} --create --topic ambari_kafka_service_check --partitions 1 --replication-factor 1")
command = source_cmd + " ; " + create_topic_cmd
Logger.info("Running kafka create topic command: %s" % command)
call_and_match_output(command, format("({create_topic_cmd_created_output})|({create_topic_cmd_exists_output})"), "Failed to check that topic exists")
def service_check(self, env):
import params
env.set_params(params)
# TODO, Kafka Service check should be more robust , It should get all the broker_hosts
# Produce some messages and check if consumer reads same no.of messages.
kafka_config = self.read_kafka_config()
topic = "ambari_kafka_service_check"
create_topic_cmd_created_output = "Created topic \"ambari_kafka_service_check\"."
create_topic_cmd_exists_output = "Topic \"ambari_kafka_service_check\" already exists."
source_cmd = format("source {conf_dir}/kafka-env.sh")
topic_exists_cmd = format("{kafka_home}/bin/kafka-topics.sh --zookeeper {kafka_config[zookeeper.connect]} --topic {topic} --list")
topic_exists_cmd_p = subprocess.Popen(topic_exists_cmd.split(" "), stdout=subprocess.PIPE, stderr=subprocess.PIPE)
topic_exists_cmd_out, topic_exists_cmd_err = topic_exists_cmd_p.communicate()
# run create topic command only if the topic doesn't exists
if topic not in topic_exists_cmd_out:
create_topic_cmd = format("{kafka_home}/bin/kafka-topics.sh --zookeeper {kafka_config[zookeeper.connect]} --create --topic {topic} --partitions 1 --replication-factor 1")
command = source_cmd + " ; " + create_topic_cmd
Logger.info("Running kafka create topic command: %s" % command)
call_and_match_output(command, format("({create_topic_cmd_created_output})|({create_topic_cmd_exists_output})"), "Failed to check that topic exists", user=params.kafka_user)
def service_check(self, env):
import params
env.set_params(params)
# TODO, ClickHouse Service check should be more robust , It should get all the broker_hosts
# Produce some messages and check if consumer reads same no.of messages.
clickhouse_hosts_config = self.read_clickhouse_config()
create_local_table = 'CREATE TABLE ambari_clickhouse_service_check_local (FlightDate Date,Year UInt16) ENGINE = MergeTree(FlightDate, (Year, FlightDate), 8192)'
create_all_table = 'CREATE TABLE ambari_clickhouse_service_check_all AS ambari_clickhouse_service_check_local ENGINE = Distributed(ck_cluster, default, ambari_clickhouse_service_check_local, rand())'
# delete all node table
for host in clickhouse_hosts_config:
table_list_sql = format("/usr/bin/clickhouse-client -h {host} -d default -m -u admin --password admin -q 'show tables' ")
import os
table_list = os.popen(table_list_sql).read().split("\n")
if 'ambari_clickhouse_service_check_local' in table_list:
drop_table_sql_local = format("/usr/bin/clickhouse-client -h {host} -d default -m -u admin --password admin -q 'drop table ambari_clickhouse_service_check_local' ")
Logger.info("Running clickhouse-client drop table {host} command: %s" % drop_table_sql_local)
Execute(
drop_table_sql_local,
user=params.clickhouse_user,
timeout=900,
logoutput=True)
if 'ambari_clickhouse_service_check_all' in table_list:
drop_table_sql_all = format("/usr/bin/clickhouse-client -h {host} -d default -m -u admin --password admin -q 'drop table ambari_clickhouse_service_check_all' ")
Logger.info("Running clickhouse-client drop table {host} command: %s" % drop_table_sql_all)
Execute(
drop_table_sql_all,
user=params.clickhouse_user,
timeout=900,
logoutput=True)
# create table for all node
for host in clickhouse_hosts_config:
create_sql_cmd_local = format("/usr/bin/clickhouse-client -h {host} -d default -m -u admin --password admin -q '{create_local_table}' ")
Execute(
create_sql_cmd_local,
user=params.clickhouse_user,
timeout=900,
logoutput=True)
create_sql_cmd_all = format("/usr/bin/clickhouse-client -h {host} -d default -m -u admin --password admin -q '{create_all_table}' ")
Execute(
create_sql_cmd_all,
user=params.clickhouse_user,
timeout=900,
logoutput=True)
insert_sql_cmd_all = format("/usr/bin/clickhouse-client -h {host} -d default -m -u admin --password admin -q 'insert into ambari_clickhouse_service_check_local (FlightDate,Year) values(now(),toYear(now()))' ")
Execute(
insert_sql_cmd_all,
user=params.clickhouse_user,
timeout=900,
logoutput=True)
command = create_sql_cmd_local + ";" + create_sql_cmd_all + ";" + insert_sql_cmd_all
Logger.info("Running clickhouse-client create and insert command: %s" % command)
statistics_sql = format("/usr/bin/clickhouse-client -h 127.0.0.1 -d default -m -u admin --password admin -q 'select count(*) from ambari_clickhouse_service_check_all' ")
call_and_match_output(statistics_sql, format(str(len(clickhouse_hosts_config))), "SERVICE CHECK FAILED: statistics_sql exec failed.", user=params.clickhouse_user)