def check_process_status(pid_file): """ Function checks whether process is running. Process is considered running, if pid file exists, and process with a pid, mentioned in pid file is running If process is not running, will throw ComponentIsNotRunning exception @param pid_file: path to service pid file """ from resource_management.core import sudo if not pid_file or not os.path.isfile(pid_file): Logger.info("Pid file {0} is empty or does not exist".format( str(pid_file))) raise ComponentIsNotRunning() try: pid = int(sudo.read_file(pid_file)) except: Logger.info( "Pid file {0} does not exist or does not contain a process id number" .format(pid_file)) raise ComponentIsNotRunning() try: # Kill will not actually kill the process # From the doc: # If sig is 0, then no signal is sent, but error checking is still # performed; this can be used to check for the existence of a # process ID or process group ID. sudo.kill(pid, 0) except OSError: Logger.info("Process with pid {0} is not running. Stale pid file" " at {1}".format(pid, pid_file)) raise ComponentIsNotRunning()
def status(self, env): print('status') from resource_management.core import sudo import params env.set_params(params) # file_handle=open('/root/1.txt',mode='a') # file_handle.write('\n' + "check_pricess_status : " + str(check_process_status(status_params.pid_file))) # file_handle.close() # # Use built-in method to check status using pidfile # check_process_status(status_params.pid_file) if (os.path.exists('/data/redis/redis/cluster') == False): raise Exception('---> /data/redis/redis/cluster目录不存在!!! <---') ## 判断每个redis实例的pid文件是否存在,不存在则抛异常 redis_node_detail = params.redis_node_detail CLUSTER_HOME = '/data/redis/redis' REDIS_HOME = '/opt/redis/redis-4.0.8' localIP = socket.gethostbyname(socket.gethostname()) for i in range(len(redis_node_detail.split(','))): if (redis_node_detail.split(',')[i].split(':')[0] == localIP): port_num = int(redis_node_detail.split(',')[i].split(':')[1]) for j in range(port_num): port = 7000 + j if (os.path.exists("/data/redis/redis/cluster/" + str(port) + "/redis.pid") == False): raise ComponentIsNotRunning() pid = int( sudo.read_file("/data/redis/redis/cluster/" + str(port) + "/redis.pid")) try: sudo.kill(pid, 0) except: raise ComponentIsNotRunning()
def check_process_status(pid_file): """ Function checks whether process is running. Process is considered running, if pid file exists, and process with a pid, mentioned in pid file is running If process is not running, will throw ComponentIsNotRunning exception @param pid_file: path to service pid file """ if not pid_file or not os.path.isfile(pid_file): raise ComponentIsNotRunning() try: pid = int(sudo.read_file(pid_file)) except: Logger.debug("Pid file {0} does not exist".format(pid_file)) raise ComponentIsNotRunning() code, out = shell.call(["ps","-p", str(pid)]) if code: Logger.debug("Process with pid {0} is not running. Stale pid file" " at {1}".format(pid, pid_file)) raise ComponentIsNotRunning() pass
def check_process_status(pid_file): """ Function checks whether process is running. Process is considered running, if pid file exists, and process with a pid, mentioned in pid file is running If process is not running, will throw ComponentIsNotRunning exception @param pid_file: path to service pid file """ if not pid_file or not os.path.isfile(pid_file): raise ComponentIsNotRunning() with open(pid_file, "r") as f: try: pid = int(f.read()) except: Logger.debug("Pid file {0} does not exist".format(pid_file)) raise ComponentIsNotRunning() try: # Kill will not actually kill the process # From the doc: # If sig is 0, then no signal is sent, but error checking is still # performed; this can be used to check for the existence of a # process ID or process group ID. os.kill(pid, 0) except OSError: Logger.debug("Process with pid {0} is not running. Stale pid file" " at {1}".format(pid, pid_file)) raise ComponentIsNotRunning() pass
def sdc_status(self, pid): from resource_management.core.exceptions import ComponentIsNotRunning print "checking status..." try: if not pid: raise ComponentIsNotRunning() except Exception, e: raise ComponentIsNotRunning()
def status(self, env): # Read from the status file, and check the index exists if not os.path.exists(self.status_file): raise ComponentIsNotRunning() klfile = None with open(self.status_file) as fp: klfile = fp.read().split()[0].strip() if len(klfile) < 5 or (not os.path.exists(klfile)): raise ComponentIsNotRunning() super(KaveLanding, self).status(env)
def status(self, env): print "status" import params env.set_params(params) print str(datetime.now()) + ":check docker container status" #cmd = format("docker inspect {containerName} | grep running") try: container = Elasticsearch.cli.inspect_container('drs-search') isRunning = container['State']['Running'] print isRunning if isRunning == False: raise ComponentIsNotRunning() except Exception, e: traceback.print_exc() raise ComponentIsNotRunning()
def status(self, env): import subprocess check = subprocess.Popen('systemctl is-active --quiet lcm-ui', shell=True) check.wait() if int(check.returncode) != 0: raise ComponentIsNotRunning() return True
def supervisord_check_status(component_name): try: Execute( format( "supervisorctl status kafka-{component_name} | grep RUNNING")) except Fail: raise ComponentIsNotRunning()
def service_check(cmd, user, label): """ Executes a service check command that adheres to LSB-compliant return codes. The return codes are interpreted as defined by the LSB. See http://refspecs.linuxbase.org/LSB_3.0.0/LSB-PDA/LSB-PDA/iniscrptact.html for more information. :param cmd: The service check command to execute. :param label: The name of the service. """ Logger.info( "Performing service check; cmd={0}, user={1}, label={2}".format( cmd, user, label)) rc, out, err = get_user_call_output(cmd, user, is_checked_call=False) if len(err) > 0: Logger.error(err) if rc in [1, 2, 3]: # if return code in [1, 2, 3], then 'program is not running' or 'program is dead' Logger.info("{0} is not running".format(label)) raise ComponentIsNotRunning() elif rc == 0: # if return code = 0, then 'program is running or service is OK' Logger.info("{0} is running".format(label)) else: # else service state is unknown err_msg = "{0} service check failed; cmd '{1}' returned {2}".format( label, cmd, rc) Logger.error(err_msg) raise ExecutionFailed(err_msg, rc, out, err)
def security_auth(configs, host_name, solr_user): """ Call kinit before pursuit with any other action :type configs dict :type host_name str :type solr_user str """ solr_kerberos_keytab = configs[ SMOKEUSER_KEYTAB_KEY] if SMOKEUSER_KEYTAB_KEY in configs else None solr_principal = configs[SMOKEUSER_PRINCIPAL_KEY].replace( '_HOST', host_name.lower()) if SMOKEUSER_PRINCIPAL_KEY in configs else None krb_executable_search_paths = configs[ KRB_EXEC_SEARCH_PATHS_KEY] if KRB_EXEC_SEARCH_PATHS_KEY in configs else None kinit_path_local = get_kinit_path(krb_executable_search_paths) if not solr_principal or not solr_kerberos_keytab: raise ComponentIsNotRunning( "Error: solr principal or solr kerberos keytab can't be None") kinit_cmd = "{kinit_path_local} -kt {solr_kerberos_keytab} {solr_principal};".format( kinit_path_local=kinit_path_local, solr_kerberos_keytab=solr_kerberos_keytab, solr_principal=solr_principal) Execute(kinit_cmd, user=solr_user)
def status(self, env): import params env.set_params(params) processes = get_flume_status(params.flume_conf_dir, params.flume_run_dir) expected_agents = find_expected_agent_names(params.flume_conf_dir) json = {} json['processes'] = processes self.put_structured_out(json) if len(expected_agents) > 0: for proc in processes: if not proc.has_key('status') or proc['status'] == 'NOT_RUNNING': raise ComponentIsNotRunning() elif len(expected_agents) == 0 and 'INSTALLED' == get_desired_state(): raise ComponentIsNotRunning()
def status(self, env): import status_params env.set_params(status_params) commands = Commands(status_params) if not commands.is_topology_active(): raise ComponentIsNotRunning()
def mysql_service(action='start'): daemon_name = get_daemon_name() status_cmd = format("pgrep -l '^{process_name}$'") cmd = ('service', daemon_name, action) if action == 'status': try: Execute(status_cmd) except Fail: raise ComponentIsNotRunning() elif action == 'stop': import params Execute( cmd, logoutput=True, only_if=status_cmd, sudo=True, ) elif action == 'start': import params Execute( cmd, logoutput=True, not_if=status_cmd, sudo=True, )
def status(self, env): cmd = 'ps -ef | grep proc_rangerkms | grep -v grep' code, output = shell.call(cmd, timeout=20) if code != 0: Logger.debug('KMS process not running') raise ComponentIsNotRunning() pass
def status(self, env): import os.path import params if not os.path.isfile( os.path.join(params.qw_master_pid_dir, "qw_master.pid")): raise ComponentIsNotRunning() print "QW Master Status..."
def check_flink_status(self, pid_file): from resource_management.core.exceptions import ComponentIsNotRunning from resource_management.core import sudo from subprocess import PIPE, Popen import shlex if not os.path.exists(pid_file) or not os.path.isfile(pid_file): raise ComponentIsNotRunning() try: pid = str(sudo.read_file(pid_file)) cmd_line = "/usr/bin/yarn application -list" args = shlex.split(cmd_line) proc = Popen(args, stdout=PIPE) p = str(proc.communicate()[0].split()) if p.find(pid.strip()) < 0: raise ComponentIsNotRunning() except Exception, e: raise ComponentIsNotRunning()
def assert_component_running(component_name): """ Based on the port and process identifies the status of the component """ port_number = common.get_local_hawq_site_property_value(hawq_constants.COMPONENT_ATTRIBUTES_MAP[component_name]['port_property']) return_code, _ = call(utils.generate_hawq_process_status_cmd(component_name, port_number)) if return_code: raise ComponentIsNotRunning()
def status(self, env): from params import status_params env.set_params(status_params) cmd = format('curl --max-time 3 {hostname}:{metron_rest_port}') try: get_user_call_output(cmd, user=status_params.metron_user) except ExecutionFailed: raise ComponentIsNotRunning()
def deal(self, action): import storage_params daemon_name = storage_params.server_name cmd = ('service', daemon_name, action) if action == 'status': try: Execute(cmd) except Fail, e: raise ComponentIsNotRunning()
def status(self, env): from params import daemon_control_script try: Execute('{0} status'.format(daemon_control_script)) except ExecutionFailed as ef: if ef.code == 3: raise ComponentIsNotRunning("ComponentIsNotRunning") else: raise ef
def status(self, env): launcher = '/usr/hdp/current/presto-worker/bin/launcher' try: Execute('{0} status'.format(launcher)) except ExecutionFailed as ef: if ef.code == 3: raise ComponentIsNotRunning("ComponentIsNotRunning") else: raise ef
def status(self, env): try: Execute( 'export AZ_CNT=`ps -ef |grep -v grep |grep azkaban-exec-server | wc -l` && `if [ $AZ_CNT -ne 0 ];then exit 0;else exit 3;fi `' ) except ExecutionFailed as ef: if ef.code == 3: raise ComponentIsNotRunning("ComponentIsNotRunning") else: raise ef
def status(self, env): import params env.set_params(params) processes = get_flume_status(params.flume_conf_dir, params.flume_run_dir) expected_agents = find_expected_agent_names(params.flume_conf_dir) json = {} json['processes'] = processes self.put_structured_out(json) # only throw an exception if there are agents defined and there is a # problem with the processes; if there are no agents defined, then # the service should report STARTED (green) ONLY if the desired state is started. otherwise, INSTALLED (red) if len(expected_agents) > 0: for proc in processes: if not proc.has_key('status') or proc['status'] == 'NOT_RUNNING': raise ComponentIsNotRunning() elif len(expected_agents) == 0 and 'INSTALLED' == get_desired_state(): raise ComponentIsNotRunning()
def service_check(self, env): import params env.set_params(params) status_cmd = format("pgrep nifi") code, output = shell.call(status_cmd, timeout=10) if code == 0: Logger.info('Nifi is up and running') else: Logger.debug('Nifi is not running') raise ComponentIsNotRunning()
def status(self, env): # need to save pid in filr and retrieve to see the value of status import subprocess # use the bind address/port number! p = subprocess.Popen([self.symlink + self.statcmd], stdout=subprocess.PIPE) stdout, stderr = p.communicate() if '"running"' not in stdout: print stdout, stderr raise ComponentIsNotRunning()
def status(self, env): import params #call status cmd = params.base_dir + '/bin/tachyon status slave' try: Execute(cmd) except Fail: raise ComponentIsNotRunning()
def service_check(self, env): import params env.set_params(params) cmd = 'ps -ef | grep proc_rangerkms | grep -v grep' code, output = shell.call(cmd, timeout=20) if code == 0: Logger.info('KMS process up and running') else: Logger.debug('KMS process not running') raise ComponentIsNotRunning()
def status(self, env): cmd = 'ps -ef | grep proc_rangeradmin | grep -v grep' code, output = shell.call(cmd, timeout=20) if code != 0: if self.is_ru_rangeradmin_in_progress(): Logger.info('Ranger admin process not running - skipping as rolling upgrade is in progress') else: Logger.debug('Ranger admin process not running') raise ComponentIsNotRunning() pass
def status(self, env): import params import os import subprocess check = subprocess.Popen('systemctl status airflow-webserver', shell=True) check.wait() if int(check.returncode) != 0: raise ComponentIsNotRunning() return True