def run(self): self.no_args() host = self.get_opt('host') port = self.get_opt('port') validate_host(host) validate_port(port) expected = self.get_opt('expected') if expected is not None: validate_regex(expected) log.info('expected version regex: %s', expected) url = 'http://%(host)s:%(port)s/' % locals() + self.url_path log.debug('GET %s' % url) try: req = requests.get(url) except requests.exceptions.RequestException as _: raise CriticalError(_) log.debug("response: %s %s", req.status_code, req.reason) log.debug("content:\n%s\n%s\n%s", '=' * 80, req.content.strip(), '=' * 80) if req.status_code != 200: raise CriticalError("%s %s" % (req.status_code, req.reason)) soup = BeautifulSoup(req.content, 'html.parser') if log.isEnabledFor(logging.DEBUG): log.debug("BeautifulSoup prettified:\n{0}\n{1}".format( soup.prettify(), '=' * 80)) self.ok() version = self.parse_version(soup) self.msg = 'HBase {0} version = {1}'.format(self.role, version) if expected is not None and not re.search(expected, version): self.msg += " (expected '{0}')".format(expected) self.critical()
def run(self): self.no_args() host = self.get_opt('host') port = self.get_opt('port') table = self.get_opt('table') validate_host(host) validate_port(port) validate_database_tablename(table) # raises 500 error if table doesn't exist url = 'http://%(host)s:%(port)s/table.jsp?name=%(table)s' % locals() log.debug('GET %s', url) try: req = requests.get(url) except requests.exceptions.RequestException as _: raise CriticalError(_) log.debug("response: %s %s", req.status_code, req.reason) log.debug("content:\n%s\n%s\n%s", '='*80, req.content.strip(), '='*80) if req.status_code != 200: info = '' #if req.status_code == '500' and 'TableNotFoundException' in req.content: if 'TableNotFoundException' in req.content: info = 'table not found' raise CriticalError("%s %s %s" % (req.status_code, req.reason, info)) is_table_compacting = self.parse_is_table_compacting(req.content) self.msg = 'HBase table \'{0}\' '.format(table) if is_table_compacting: self.warning() self.msg += 'has compaction in progress' else: self.msg += 'has no compaction in progress'
def process_options(self): self.no_args() self.host = self.get_opt('host') self.port = self.get_opt('port') validate_host(self.host) validate_port(self.port) if self.auth: self.user = self.get_opt('user') self.password = self.get_opt('password') if self.auth == 'optional': if self.user and self.password: validate_user(self.user) validate_password(self.password) else: validate_user(self.user) validate_password(self.password) ssl = self.get_opt('ssl') log_option('ssl', ssl) if ssl and self.protocol == 'http': self.protocol = 'https' if self.json: # recommended for many systems like CouchDB # but breaks Ambari API calls #self.headers['Accept'] = 'application/json' self.headers['Content-Type'] = 'application/json'
def run(self): self.no_args() host = self.options.host port = self.options.port validate_host(host) validate_port(port) url = 'http://%(host)s:%(port)s/oozie/v1/admin/status' % locals() log.debug('GET %s' % url) try: req = requests.get(url) except requests.exceptions.RequestException as _: qquit('CRITICAL', _) log.debug("response: %s %s" % (req.status_code, req.reason)) log.debug("content: '%s'" % req.content) if req.status_code != 200: qquit('CRITICAL', "Non-200 response! %s %s" % (req.status_code, req.reason)) # should == NORMAL if not isJson(req.content): qquit('UNKNOWN', 'non-JSON returned by Oozie server at {0}:{1}'.format(host, port)) status = None try: _ = json.loads(req.content) status = _['systemMode'] except KeyError: qquit('UNKNOWN', 'systemMode key was not returned in output from Oozie. {0}'.format(support_msg_api())) self.msg = 'Oozie status = {0}'.format(status) if status == 'NORMAL': self.ok() else: self.critical()
def process_options(self): super(CheckSeleniumHubBrowser, self).process_options() self.hub_url = self.get_opt('hub_url') if self.hub_url: validate_url(self.hub_url, 'hub') else: self.host = self.get_opt('host') self.port = self.get_opt('port') validate_host(self.host) validate_port(self.port) if self.get_opt('ssl') or int(self.port) == 443: self.protocol = 'https' self.hub_url = '{protocol}://{host}:{port}/{path}'\ .format(protocol=self.protocol, \ host=self.host, \ port=self.port, \ path=self.path) self.url = self.get_opt('url') if ':' not in self.url: self.url = 'http://' + self.url validate_url(self.url) self.browser = self.get_opt('browser') if self.browser: self.browser = self.browser.upper() validate_alnum(self.browser, 'browser') self.expected_content = self.get_opt('content') self.expected_regex = self.get_opt('regex') if self.expected_regex: validate_regex(self.expected_regex) self.expected_regex = re.compile(self.expected_regex) elif self.url == self.url_default: self.expected_content = self.expected_content_default
def run(self): self.no_args() host = self.get_opt('host') port = self.get_opt('port') validate_host(host) validate_port(port) url = 'http://%(host)s:%(port)s/jmx' % locals() log.debug('GET %s', url) try: req = requests.get(url) except requests.exceptions.RequestException as _: qquit('CRITICAL', _) log.debug("response: %s %s", req.status_code, req.reason) log.debug("content:\n%s\n%s\n%s", '='*80, req.content.strip(), '='*80) if req.status_code != 200: qquit('CRITICAL', "%s %s" % (req.status_code, req.reason)) compaction_queue_size = self.parse(req.content) self.msg = 'HBase RegionServer compaction ' if compaction_queue_size > 0: self.warning() self.msg += 'in progress' else: self.msg += 'not in progress' self.msg += ', compactionQueueSize = {0}'.format(compaction_queue_size) self.msg += ' | compactionQueueSize={0};0;0'.format(compaction_queue_size)
def process_args(self): # this resets DEBUG env var #log.setLevel(logging.INFO) self.no_args() self.host = self.get_opt('host') self.port = self.get_opt('port') validate_host(self.host) validate_port(self.port) self.table = self.get_opt('table') self.num_rows = self.get_opt('num') self.key_length = self.get_opt('key_length') self.value_length = self.get_opt('value_length') validate_database_tablename(self.table) validate_int(self.num_rows, 'num rows', 1, 1000000000) validate_int(self.key_length, 'key length', 10, 1000) validate_int(self.value_length, 'value length', 1, 1000000) self.num_rows = int(self.num_rows) self.skew = self.get_opt('skew') log_option('skew data', self.skew) self.skew_pc = self.get_opt('skew_percentage') validate_int(self.skew_pc, 'skew percentage', 0, 100) self.skew_pc = int(self.skew_pc) self.drop_table = self.get_opt('drop_table') self.use_existing_table = self.get_opt('use_existing_table') if self.drop_table and self.table != self.default_table_name: die("not allowed to use --drop-table if using a table name other than the default table '{0}'"\ .format(self.default_table_name))
def run(self): self.no_args() host = self.get_opt('host') port = self.get_opt('port') table = self.get_opt('table') validate_host(host) validate_port(port) validate_database_tablename(table) # raises 500 error if table doesn't exist url = 'http://%(host)s:%(port)s/table.jsp?name=%(table)s' % locals() log.debug('GET %s', url) try: req = requests.get(url) except requests.exceptions.RequestException as _: qquit('CRITICAL', _) log.debug("response: %s %s", req.status_code, req.reason) log.debug("content:\n%s\n%s\n%s", '='*80, req.content.strip(), '='*80) if req.status_code != 200: info = '' #if req.status_code == '500' and 'TableNotFoundException' in req.content: if 'TableNotFoundException' in req.content: info = 'table not found' qquit('CRITICAL', "%s %s %s" % (req.status_code, req.reason, info)) is_table_compacting = self.parse_is_table_compacting(req.content) self.msg = 'HBase table \'{0}\' '.format(table) if is_table_compacting: self.warning() self.msg += 'has compaction in progress' else: self.msg += 'has no compaction in progress'
def run(self): self.no_args() host = self.get_opt('host') port = self.get_opt('port') validate_host(host) validate_port(port) # observed bug in HDP 2.3 (HBase 1.1.2) where the JMX metric from HMaster UI /jmx is displaying 0 for beans # [ {"name":"Hadoop:service=HBase,name=Master,sub=AssignmentManger", ..., "ritCountOverThreshold" : 0 } # https://issues.apache.org/jira/browse/HBASE-16636 #url = 'http://%(host)s:%(port)s/jmx' % locals() # could get info from flat txt debug page but it doesn't contain the summary count #url = 'http://%(host)s:%(port)s/dump' % locals() url = 'http://%(host)s:%(port)s/master-status' % locals() log.debug('GET %s', url) try: req = requests.get(url) except requests.exceptions.RequestException as _: qquit('CRITICAL', _) log.debug("response: %s %s", req.status_code, req.reason) log.debug("content:\n%s\n%s\n%s", '='*80, req.content.strip(), '='*80) if req.status_code != 200: qquit('CRITICAL', "%s %s" % (req.status_code, req.reason)) regions_stuck_in_transition = self.parse(req.content) if regions_stuck_in_transition is None: qquit('UNKNOWN', 'parse error - failed to find number for regions stuck in transition') if not isInt(regions_stuck_in_transition): qquit('UNKNOWN', 'parse error - got non-integer for regions stuck in transition when parsing HMaster UI') if regions_stuck_in_transition == 0: self.ok() else: self.critical() self.msg = '{0} regions stuck in transition (ie. transitioning longer than HBase threshold)'\ .format(regions_stuck_in_transition) self.msg += " | regions_stuck_in_transition={0};0;0".format(regions_stuck_in_transition)
def process_options(self): self.no_args() self.host = self.get_opt('host') self.port = self.get_opt('port') validate_host(self.host) validate_port(self.port) self.process_expected_version_option()
def run(self): self.no_args() host = self.get_opt('host') port = self.get_opt('port') validate_host(host) validate_port(port) url = 'http://%(host)s:%(port)s/jmx' % locals() log.debug('GET %s', url) try: req = requests.get(url) except requests.exceptions.RequestException as _: qquit('CRITICAL', _) log.debug("response: %s %s", req.status_code, req.reason) log.debug("content:\n%s\n%s\n%s", '=' * 80, req.content.strip(), '=' * 80) if req.status_code != 200: qquit('CRITICAL', "%s %s" % (req.status_code, req.reason)) compaction_queue_size = self.parse(req.content) self.msg = 'HBase RegionServer compaction ' if compaction_queue_size > 0: self.warning() self.msg += 'in progress' else: self.msg += 'not in progress' self.msg += ', compactionQueueSize = {0}'.format(compaction_queue_size) self.msg += ' | compactionQueueSize={0};0;0'.format( compaction_queue_size)
def run(self): self.no_args() host = self.get_opt('host') port = self.get_opt('port') validate_host(host) validate_port(port) url = 'http://%(host)s:%(port)s/status' % locals() log.debug('GET %s' % url) try: req = requests.get(url) except requests.exceptions.RequestException as _: qquit('CRITICAL', _) log.debug("response: %s %s" % (req.status_code, req.reason)) log.debug("content:\n{0}\n{1}\n{2}".format('='*80, req.content.strip(), '='*80)) if req.status_code != 200: qquit('CRITICAL', "%s %s" % (req.status_code, req.reason)) soup = BeautifulSoup(req.content, 'html.parser') #if log.isEnabledFor(logging.DEBUG): # log.debug("BeautifulSoup prettified:\n{0}\n{1}".format(soup.prettify(), '='*80)) try: status = soup.find('div', { 'class': 'alert alert-success'}).get_text().strip() except (AttributeError, TypeError): qquit('UNKNOWN', 'failed to parse Apache Drill status page. %s' % support_msg()) self.msg = "Apache Drill status = '{0}'".format(status) if re.match('Running!', status): self.ok() else: self.critical()
def process_args(self): self.host_list = self.args if not self.host_list: self.usage( 'no host arguments given, must give at least one regionserver host as an argument' ) for host in self.host_list: validate_host(host) self.port = self.get_opt('port') validate_port(self.port) self.table = self.get_opt('table') table_chars = 'A-Za-z0-9:._-' if self.table: validate_chars(self.table, 'table', table_chars) else: self.table = '[{}]+'.format(table_chars) self.namespace = self.get_opt('namespace') validate_chars(self.namespace, 'hbase namespace', 'A-Za-z0-9:._-') self.top_n = self.get_opt('top') if self.top_n: validate_int(self.top_n, 'top N', 1) self.top_n = int(self.top_n) self.request_threshold = self.get_opt('requests') validate_int(self.request_threshold, 'request count threshold') self.request_threshold = int(self.request_threshold)
def process_args(self): self.host_list = self.args if not self.host_list: self.usage( 'no host arguments given, must give at least one regionserver host as an argument' ) for host in self.host_list: validate_host(host) self.port = self.get_opt('port') validate_port(self.port) self.interval = self.get_opt('interval') self.count = self.get_opt('count') self.since_uptime = self.get_opt('average') validate_int(self.interval, 'interval') validate_int(self.count, 'count') self.interval = int(self.interval) self.count = int(self.count) if self.count == 0: self.disable_timeout() self.request_type = self.get_opt('type') if self.request_type: self.request_type = [ _.strip() for _ in self.request_type.split(',') ] for _ in self.request_type: if _ not in self.request_types: self.usage('--type may only include: {}'.format(', '.join( self.request_types)))
def run(self): self.no_args() host = self.get_opt('host') port = self.get_opt('port') warn_on_recent_start = self.get_opt('warn_on_recent_start') validate_host(host) validate_port(port) log.info('querying Tachyon%(name)s' % self.__dict__) url = 'http://%(host)s:%(port)s/home' % locals() log.debug('GET %s' % url) try: req = requests.get(url) except requests.exceptions.RequestException as _: qquit('CRITICAL', _) log.debug("response: %s %s" % (req.status_code, req.reason)) log.debug("content:\n{0}\n{1}\n{2}".format('=' * 80, req.content.strip(), '=' * 80)) if req.status_code != 200: qquit('CRITICAL', "%s %s" % (req.status_code, req.reason)) soup = BeautifulSoup(req.content, 'html.parser') try: uptime = soup.find('th', text=re.compile( 'Uptime:?', re.I)).find_next_sibling().get_text() version = soup.find('th', text=re.compile( 'Version:?', re.I)).find_next_sibling().get_text() except (AttributeError, TypeError): qquit( 'UNKNOWN', 'failed to find parse Tachyon%(name)s uptime/version info' % self.__dict__) if not uptime or not isStr(uptime) or not re.search( r'\d+\s+second', uptime): qquit( 'UNKNOWN', 'Tachyon{0} uptime format not recognized: {1}'.format( self.name, uptime)) if not isVersion(version): qquit( 'UNKNOWN', 'Tachyon{0} version format not recognized: {1}'.format( self.name, version)) self.msg = 'Tachyon{0} version: {1}, uptime: {2}'.format( self.name, version, uptime) # pylint: disable=attribute-defined-outside-init self.ok() if warn_on_recent_start: match = re.match( r'^(\d+)\s+day[^\d\s]+\s+(\d+)\s+hour[^\d\s]+\s+(\d+)\s+minute', uptime, re.I) if match: days = int(match.group(1)) hours = int(match.group(2)) mins = int(match.group(3)) if days == 0 and hours == 0 and mins < 30: self.warning() self.msg += ' (< 30 mins)' else: self.unknown() self.msg += " (couldn't determine if uptime < 30 mins)"
def process_args(self): self.host_list = self.args if not self.host_list: self.usage( 'no host arguments given, must give at least one regionserver host as an argument' ) for host in self.host_list: validate_host(host) self.port = self.get_opt('port') validate_port(self.port) self.table = self.get_opt('table') table_chars = 'A-Za-z0-9:._-' if self.table: validate_chars(self.table, 'table', table_chars) else: self.table = '[{}]+'.format(table_chars) self.namespace = self.get_opt('namespace') validate_chars(self.namespace, 'hbase namespace', 'A-Za-z0-9:._-') self.region_regex = re.compile('^Namespace_{namespace}_table_({table})_region_(.+)_metric_{metric}'\ .format(namespace=self.namespace, table=self.table, metric=self.metric)) self.top_n = self.get_opt('top') if self.top_n: validate_int(self.top_n, 'top N', 1) self.top_n = int(self.top_n)
def run(self): self.no_args() host = self.get_opt('host') port = self.get_opt('port') validate_host(host) validate_port(port) log.info('querying Tachyon Master') url = 'http://%(host)s:%(port)s/workers' % locals() log.debug('GET %s' % url) try: req = requests.get(url) except requests.exceptions.RequestException as _: qquit('CRITICAL', _) log.debug("response: %s %s" % (req.status_code, req.reason)) log.debug("content:\n{0}\n{1}\n{2}".format('='*80, req.content.strip(), '='*80)) if req.status_code != 200: qquit('CRITICAL', "%s %s" % (req.status_code, req.reason)) soup = BeautifulSoup(req.content, 'html.parser') dead_workers = 0 try: dead_workers = len([_ for _ in soup.find(id='data2').find('tbody').find_all('tr') if _]) except (AttributeError, TypeError): qquit('UNKNOWN', 'failed to find parse Tachyon Master info for dead workers' % self.__dict__) try: dead_workers = int(dead_workers) except (ValueError, TypeError): qquit('UNKNOWN', 'Tachyon Master dead workers parsing returned non-integer: {0}'.format(dead_workers)) self.msg = 'Tachyon dead workers = {0}'.format(dead_workers) # pylint: disable=attribute-defined-outside-init self.ok() # TODO: thresholds on number of dead workers (coming soon) if dead_workers: self.critical()
def process_args(self): # this resets DEBUG env var #log.setLevel(logging.INFO) self.no_args() self.host = self.get_opt('host') self.port = self.get_opt('port') validate_host(self.host) validate_port(self.port) # happybase socket requires an integer self.port = int(self.port) self.table = self.get_opt('table') self.num_rows = self.get_opt('num') self.key_length = self.get_opt('key_length') self.value_length = self.get_opt('value_length') validate_database_tablename(self.table) validate_int(self.num_rows, 'num rows', 1, 1000000000) validate_int(self.key_length, 'key length', 10, 1000) validate_int(self.value_length, 'value length', 1, 1000000) self.num_rows = int(self.num_rows) self.skew = self.get_opt('skew') log_option('skew data', self.skew) self.skew_pc = self.get_opt('skew_percentage') validate_int(self.skew_pc, 'skew percentage', 0, 100) self.skew_pc = int(self.skew_pc) self.drop_table = self.get_opt('drop_table') self.use_existing_table = self.get_opt('use_existing_table') if self.drop_table and self.table != self.default_table_name: die("not allowed to use --drop-table if using a table name other than the default table '{0}'"\ .format(self.default_table_name))
def run(self): self.no_args() host = self.get_opt('host') port = self.get_opt('port') validate_host(host) validate_port(port) url = 'http://%(host)s:%(port)s/oozie/v1/admin/status' % locals() log.debug('GET %s' % url) try: req = requests.get(url) except requests.exceptions.RequestException as _: qquit('CRITICAL', _) log.debug("response: %s %s" % (req.status_code, req.reason)) log.debug("content: '%s'" % req.content) if req.status_code != 200: qquit('CRITICAL', "%s %s" % (req.status_code, req.reason)) # should == NORMAL if not isJson(req.content): qquit('UNKNOWN', 'non-JSON returned by Oozie server at {0}:{1}'.format(host, port)) status = None try: _ = json.loads(req.content) status = _['systemMode'] except KeyError: qquit('UNKNOWN', 'systemMode key was not returned in output from Oozie. {0}'.format(support_msg_api())) self.msg = 'Oozie status = {0}'.format(status) if status == 'NORMAL': self.ok() else: self.critical()
def run(self): self.no_args() host = self.get_opt('host') port = self.get_opt('port') validate_host(host) validate_port(port) self.validate_thresholds(integer=False) url = 'http://%(host)s:%(port)s/master-status' % locals() log.debug('GET %s', url) try: req = requests.get(url) except requests.exceptions.RequestException as _: qquit('CRITICAL', _) log.debug("response: %s %s", req.status_code, req.reason) log.debug("content:\n%s\n%s\n%s", '=' * 80, req.content.strip(), '=' * 80) if req.status_code != 200: qquit('CRITICAL', ("%s %s" % (req.status_code, req.reason))) self.parse_output(req.content) log.info('server with min regions = %s regions on %s', self.server_min_regions[1], self.server_min_regions[0]) log.info('server with max regions = %s regions on %s', self.server_max_regions[1], self.server_max_regions[0]) imbalance = self.calculate_imbalance() self.msg = '{0}% region imbalance'.format(imbalance) self.check_thresholds(imbalance) self.msg += ' between HBase RegionServers hosting the most vs least number of regions' self.msg += ' (min = {0}, max = {1})'.format( self.server_min_regions[1], self.server_max_regions[1]) self.msg += " | '% region imbalance'={0}%".format(imbalance) self.msg += self.get_perf_thresholds() self.msg += ' min_regions={0} max_regions={1}'.format( self.server_min_regions[1], self.server_max_regions[1])
def process_args(self): self.host = self.get_opt('host') self.port = self.get_opt('port') # pika library requires int type self.port = self.port self.user = self.get_opt('user') self.password = self.get_opt('password') validate_host(self.host) validate_port(self.port) self.port = int(self.port) validate_user(self.user) validate_password(self.password) self.vhost = self.get_opt('vhost') self.vhost = self.vhost if self.vhost else '/' validate_chars(self.vhost, 'vhost', r'/\w\._-') self.exchange = self.get_opt('exchange') if self.exchange: validate_chars(self.exchange, 'exchange', r'\w\._-') else: log_option('exchange', self.exchange) self.exchange_type = self.get_opt('exchange_type') if self.exchange_type: if self.exchange_type not in self.valid_exchange_types: self.usage('invalid --exchange-type given, expected one of: {valid_exchange_types}'\ .format(valid_exchange_types=', '.join(self.valid_exchange_types))) log_option('exchange type', self.exchange_type) self.queue = self.get_opt('queue') if self.queue: validate_chars(self.queue, 'queue', r'\w\._-') else: log_option('queue', self.queue) self.routing_key = self.get_opt('routing_key') if not self.routing_key: self.routing_key = self.queue log_option('routing key', self.routing_key) #self.no_ack = self.get_opt('no_ack') log_option('no ack', self.no_ack) self.connection_attempts = self.get_opt('connection_attempts') validate_int(self.connection_attempts, 'connection attempts', min_value=1, max_value=10) self.connection_attempts = int(self.connection_attempts) self.retry_delay = self.get_opt('retry_delay') validate_int(self.retry_delay, 'retry delay', min_value=0, max_value=10) self.retry_delay = int(self.retry_delay) self.use_transactions = self.get_opt('use_transactions') #self.durable = not self.get_opt('non_durable') if self.get_opt('non_durable'): self.durable = False log_option('non-durable', not self.durable) sleep_secs = self.get_opt('sleep') if sleep_secs: # validation done through property wrapper self.sleep_secs = sleep_secs log_option('sleep secs', self.sleep_secs) self.validate_thresholds()
def run(self): self.no_args() host = self.get_opt('host') port = self.get_opt('port') validate_host(host) validate_port(port) log.info('querying Tachyon Master') url = 'http://%(host)s:%(port)s/home' % locals() log.debug('GET %s' % url) try: req = requests.get(url) except requests.exceptions.RequestException as _: qquit('CRITICAL', _) log.debug("response: %s %s" % (req.status_code, req.reason)) log.debug("content:\n{0}\n{1}\n{2}".format('='*80, req.content.strip(), '='*80)) if req.status_code != 200: qquit('CRITICAL', "Non-200 response! %s %s" % (req.status_code, req.reason)) soup = BeautifulSoup(req.content, 'html.parser') try: running_workers = soup.find('th', text=re.compile(r'Running\s+Workers:?', re.I))\ .find_next_sibling().get_text() except (AttributeError, TypeError): qquit('UNKNOWN', 'failed to find parse Tachyon Master info for running workers' % self.__dict__) try: running_workers = int(running_workers) except (ValueError, TypeError): qquit('UNKNOWN', 'Tachyon Master live workers parsing returned non-integer: {0}'.format(running_workers)) self.msg = 'Tachyon running workers = {0}'.format(running_workers) # pylint: disable=attribute-defined-outside-init self.ok() # TODO: thresholds on number of live workers (coming soon) if running_workers < 1: self.critical()
def run(self): self.no_args() host = self.get_opt('host') port = self.get_opt('port') validate_host(host) validate_port(port) self.validate_thresholds(integer=False) url = 'http://%(host)s:%(port)s/master-status' % locals() log.debug('GET %s', url) try: req = requests.get(url) except requests.exceptions.RequestException as _: qquit('CRITICAL', _) log.debug("response: %s %s", req.status_code, req.reason) log.debug("content:\n%s\n%s\n%s", '='*80, req.content.strip(), '='*80) if req.status_code != 200: qquit('CRITICAL', ("%s %s" % (req.status_code, req.reason))) self.parse_output(req.content) log.info('server with min regions = %s regions on %s', self.server_min_regions[1], self.server_min_regions[0]) log.info('server with max regions = %s regions on %s', self.server_max_regions[1], self.server_max_regions[0]) imbalance = self.calculate_imbalance() self.msg = '{0}% region imbalance'.format(imbalance) self.check_thresholds(imbalance) self.msg += ' between HBase RegionServers hosting the most vs least number of regions' self.msg += ' (min = {0}, max = {1})'.format(self.server_min_regions[1], self.server_max_regions[1]) self.msg += " | '% region imbalance'={0}%".format(imbalance) self.msg += self.get_perf_thresholds() self.msg += ' min_regions={0} max_regions={1}'.format(self.server_min_regions[1], self.server_max_regions[1])
def process_options(self): super(SeleniumHubBrowserTest, self).process_options() self.hub_url = self.get_opt('hub_url') if self.hub_url: validate_url(self.hub_url, 'hub') else: self.host = self.get_opt('host') self.port = self.get_opt('port') validate_host(self.host) validate_port(self.port) if self.get_opt('ssl') or int(self.port) == 443: self.protocol = 'https' self.hub_url = '{protocol}://{host}:{port}/{path}'\ .format(protocol=self.protocol, \ host=self.host, \ port=self.port, \ path=self.path) self.url = self.get_opt('url') if ':' not in self.url: self.url = 'http://' + self.url validate_url(self.url) self.expected_content = self.get_opt('content') self.expected_regex = self.get_opt('regex') if self.expected_regex: validate_regex(self.expected_regex) self.expected_regex = re.compile(self.expected_regex) elif self.url == self.url_default: self.expected_content = self.expected_content_default if not self.args: # test basic Chrome and Firefox are available self.args.append('chrome') self.args.append('firefox')
def run(self): self.no_args() host = self.get_opt('host') port = self.get_opt('port') validate_host(host) validate_port(port) url = 'http://%(host)s:%(port)s/oozie/v1/admin/status' % locals() req = RequestHandler().get(url) # should == NORMAL if not isJson(req.content): raise UnknownError( 'non-JSON returned by Oozie server at {0}:{1}'.format( host, port)) status = None try: _ = json.loads(req.content) status = _['systemMode'] except KeyError: raise UnknownError( 'systemMode key was not returned in output from Oozie. {0}'. format(support_msg_api())) self.msg = 'Oozie status = {0}'.format(status) if status == 'NORMAL': self.ok() else: self.critical()
def process_args(self): self.host_list = self.args if not self.host_list: self.usage( 'no host arguments given, must give at least one regionserver host as an argument' ) for host in self.host_list: validate_host(host) self.port = self.get_opt('port') validate_port(self.port) self.table = self.get_opt('table') table_chars = 'A-Za-z0-9:._-' if self.table: validate_chars(self.table, 'table', table_chars) else: self.table = '[{}]+'.format(table_chars) self.namespace = self.get_opt('namespace') validate_chars(self.namespace, 'hbase namespace', 'A-Za-z0-9:._-') self.interval = self.get_opt('interval') self.count = self.get_opt('count') self.since_uptime = self.get_opt('average') validate_int(self.interval, 'interval') validate_int(self.count, 'count') self.interval = int(self.interval) self.count = int(self.count) if self.count == 0: self.disable_timeout() if self.get_opt('reads'): self.show.add('read') if self.get_opt('writes'): self.show.add('write') if self.get_opt('total'): self.show.add('total')
def run(self): self.no_args() host = self.get_opt('host') port = self.get_opt('port') user = self.get_opt('user') password = self.get_opt('password') if self.get_opt('ssl'): self.protocol = 'https' history_mins = self.get_opt('history_mins') num = self.get_opt('num') #inventory_id = self.get_opt('id') source = self.get_opt('source') dest = self.get_opt('dest') max_age = self.get_opt('max_age') max_runtime = self.get_opt('max_runtime') validate_host(host) validate_port(port) validate_user(user) validate_password(password) validate_float(history_mins, 'history mins') self.history_mins = float(history_mins) filter_opts = {} if self.history_mins: now = datetime.now() filter_opts['dateRangeStart'] = datetime.strftime(now - timedelta(minutes=self.history_mins), '%F %H:%M:%S') filter_opts['dateRangeEnd'] = datetime.strftime(now, '%F %H:%M:%S') if num is not None: validate_int(num, 'num ingestions', 1) #if inventory_id is not None: # validate_chars(inventory_id, 'ingestion id', r'\w-') # filter_opts['inventoryId'] = inventory_id if source is not None: log_option('source', source) filter_opts['fileName'] = source if dest is not None: log_option('dest', dest) filter_opts['destinationPath'] = dest if max_age is not None: validate_float(max_age, 'max age', 1) max_age = float(max_age) if max_runtime is not None: validate_float(max_runtime, 'max incomplete runtime', 1) max_runtime = float(max_runtime) self.url_base = '{protocol}://{host}:{port}/bedrock-app/services/rest'.format(host=host, port=port, protocol=self.protocol) # auth first, get JSESSIONID cookie # cookie jar doesn't work in Python or curl, must extract JSESSIONID to header manually #self.jar = cookielib.CookieJar() log.info('authenticating to Zaloni Bedrock') (_, self.auth_time) = self.req(url='{url_base}/admin/getUserRole'.format(url_base=self.url_base), # using json instead of constructing string manually, # this correctly escapes backslashes in password body=json.dumps({"username": user, "password": password})) if self.get_opt('list'): self.list_ingestions(num=num) self.check_ingestion(num=num, filter_opts=filter_opts, max_age=max_age, max_runtime=max_runtime)
def run(self): validate_host(self.host) validate_port(self.port) validate_user(self.user) validate_password(self.password) all_services = self.get_opt('all') services_str = self.get_opt('services') cancel = self.get_opt('cancel') if cancel and (all_services or services_str): self.usage( 'cannot specify --cancel and --services/--all simultaneously' + ', --cancel will cancel all pending service checks') if all_services and services_str: self.usage( 'cannot specify --all and --services simultaneously, they are mutually exclusive' ) services_requested = [] if services_str: services_requested = [ service.strip().upper() for service in services_str.split(',') ] list_clusters = self.get_opt('list_clusters') list_services = self.get_opt('list_services') clusters = self.get_clusters() if list_clusters: if self.verbose > 0: print('Ambari Clusters:\n') print('\n'.join(clusters)) sys.exit(3) if not self.cluster and len(clusters) == 1: self.cluster = clusters[0] log.info( 'no --cluster specified, but only one cluster managed by Ambari' + ', inferring --cluster=\'%s\'', self.cluster) validate_chars(self.cluster, 'cluster', r'\w\s\.-') self.services = self.get_services() if list_services: if self.verbose > 0: print('Ambari Services:\n') print('\n'.join(self.services)) sys.exit(3) if not services_requested and not all_services and not cancel: self.usage('no --services specified, nor was --all requested') services_to_check = [] if all_services: services_to_check = self.services else: for service_requested in services_requested: if service_requested not in self.services: die('service \'{0}\' is not in the list of available services in Ambari!' .format(service_requested) + ' Here is the list of services available:\n' + '\n'.join(self.services)) services_to_check = services_requested if cancel: self.cancel_service_checks() else: self.request_service_checks(services_to_check)
def process_options(self): self.host = self.get_opt('host') self.port = self.get_opt('port') validate_host(self.host) validate_port(self.port) ssl = self.get_opt('ssl') log_option('ssl', ssl) if ssl: self.protocol = 'https'
def process_args(self): if not self.name: raise CodingError("didn't name check, please set self.name in __init__()") self.no_args() self.host = self.get_opt('host') self.port = self.get_opt('port') validate_host(self.host) validate_port(self.port) self._process_args()
def process_args(self): if not self.name: raise CodingError("didn't name check, please set self.name in __init__()") self.no_args() self.host = self.get_opt("host") self.port = self.get_opt("port") validate_host(self.host) validate_port(self.port) self.validate_thresholds()
def run(self): self.no_args() host = self.get_opt('host') port = self.get_opt('port') slave = self.get_opt('slave') list_slaves = self.get_opt('list_slaves') validate_host(host) validate_port(port) if not list_slaves: validate_host(slave, 'slave') url = 'http://%(host)s:%(port)s/master/slaves' % locals() log.debug('GET %s', url) try: req = requests.get(url) except requests.exceptions.RequestException as _: qquit('CRITICAL', _) log.debug("response: %s %s", req.status_code, req.reason) log.debug("content:\n{0}\n{1}\n{2}".format('=' * 80, req.content.strip(), '=' * 80)) if req.status_code != 200: qquit('CRITICAL', "Non-200 response! %s %s" % (req.status_code, req.reason)) content = req.content if not isJson(content): qquit('UNKNOWN', 'invalid JSON returned by Mesos Master') data = json.loads(content) if log.isEnabledFor(logging.DEBUG): log.debug('\n%s', jsonpp(data)) slaves = {} regex = re.compile(r'^slave\(\d+\)\@(.+):\d+') try: for item in data['slaves']: match = regex.match(item['pid']) if match: slaves[item['hostname']] = match.group(1) else: slaves[item['hostname']] = item['pid'] except KeyError: qquit( 'UNKNOWN', 'failed to parse slaves from Mesos API output. {0}'.format( support_msg_api)) if list_slaves: qquit('UNKNOWN', 'Slaves list:\n\n{0}'.format(dict_lines(slaves))) log.info('found slaves:\n\n{0}\n'.format(dict_lines(slaves))) slave = slave.lower() for _ in slaves: if slave == _.lower() or slave == slaves[_].lower(): qquit('OK', "Mesos slave '{0}' registered with master".format(slave)) break else: qquit('CRITICAL', "Mesos slave '{0}' not registered with master".format(slave))
def process_options(self): self.no_args() self.host = self.get_opt('host') self.port = self.get_opt('port') validate_host(self.host) validate_port(self.port) self.expected = self.get_opt('expected') if self.expected is not None: validate_regex(self.expected) log.info('expected version regex: %s', self.expected)
def process_options(self): self.host = self.get_opt('host') self.port = self.get_opt('port') validate_host(self.host) validate_port(self.port) ssl = self.get_opt('ssl') log_option('ssl', ssl) if ssl: self.protocol = 'https' self.validate_thresholds(simple='lower')
def process_options(self): super(PostgreSQLCLI, self).process_options() self.host = self.get_opt('host') self.host = self.get_opt('host') self.user = self.get_opt('user') self.password = self.get_opt('password') validate_host(self.host) validate_port(self.port) validate_user(self.user) validate_password(self.password) self.port = int(self.port)
def process_options(self): self.no_args() self.host = self.get_opt('host') self.port = self.get_opt('port') validate_host(self.host) validate_port(self.port) ssl = self.get_opt('ssl') log_option('ssl', ssl) if self.get_opt('ssl'): self.protocol = 'https' self.validate_thresholds(optional=True)
def process_options(self): host = self.get_opt('host') port = self.get_opt('port') validate_host(host) validate_port(port) if self.get_opt('ssl'): log_option('ssl', 'True') self.protocol = 'https' self.url_base = '{protocol}://{host}:{port}/v2'.format(protocol=self.protocol, host=host, port=port)
def process_args(self): log.setLevel(logging.INFO) self.no_args() self.host = self.get_opt('host') self.port = self.get_opt('port') validate_host(self.host) validate_port(self.port) regex = self.get_opt('regex') if regex: validate_regex(regex) self.table_regex = re.compile(regex, re.I) log.info('filtering to compact only tables matching regex \'{0}\''.format(regex))
def process_args(self): #log.setLevel(logging.INFO) self.no_args() self.host = self.get_opt('host') self.port = self.get_opt('port') self.table = self.get_opt('table') validate_host(self.host) validate_port(self.port) if not self.get_opt('list_tables'): validate_chars(self.table, 'hbase table', 'A-Za-z0-9:._-') self.short_region_name = self.get_opt('short_region_name') log_option('shorten region name', self.short_region_name)
def process_args(self): if not self.name: raise CodingError("didn't name check, please set self.name in __init__()") self.no_args() self.host = self.get_opt('host') self.port = self.get_opt('port') validate_host(self.host) validate_port(self.port) self.validate_thresholds() sleep_secs = self.get_opt('sleep') if sleep_secs: # validation done through property wrapper self.sleep_secs = sleep_secs
def validate_options(self): if not self.host_list: self.usage('no hosts specified') validate_hostport_list(self.host_list, port_optional=True) validate_port(self.port) if self.protocol and self.protocol not in ('http', 'https', 'ping'): code_error('invalid protocol, must be one of http or https') if self.regex: if not self.protocol: self.usage('--regex cannot be used without --http / --https') validate_regex(self.regex) self.regex = re.compile(self.regex) validate_int(self.num_threads, 'num threads', 1, 100)
def run(self): self.no_args() host = self.get_opt('host') port = self.get_opt('port') slave = self.get_opt('slave') list_slaves = self.get_opt('list_slaves') validate_host(host) validate_port(port) if not list_slaves: validate_host(slave, 'slave') url = 'http://%(host)s:%(port)s/master/slaves' % locals() log.debug('GET %s', url) try: req = requests.get(url) except requests.exceptions.RequestException as _: qquit('CRITICAL', _) log.debug("response: %s %s", req.status_code, req.reason) log.debug("content:\n{0}\n{1}\n{2}".format('='*80, req.content.strip(), '='*80)) if req.status_code != 200: if req.status_code == 404: qquit('CRITICAL', '%s %s (did you point this at the correct Mesos Master?)' % (req.status_code, req.reason)) qquit('CRITICAL', "Non-200 response! %s %s" % (req.status_code, req.reason)) content = req.content if not isJson(content): qquit('UNKNOWN', 'invalid JSON returned by Mesos Master') data = json.loads(content) if log.isEnabledFor(logging.DEBUG): log.debug('\n%s', jsonpp(data)) slaves = {} regex = re.compile(r'^slave\(\d+\)\@(.+):\d+') try: for item in data['slaves']: match = regex.match(item['pid']) if match: slaves[item['hostname']] = match.group(1) else: slaves[item['hostname']] = item['pid'] except KeyError: qquit('UNKNOWN', 'failed to parse slaves from Mesos API output. {0}'.format(support_msg_api)) if list_slaves: qquit('UNKNOWN', 'Slaves list:\n\n{0}'.format(dict_lines(slaves))) log.info('found slaves:\n\n{0}\n'.format(dict_lines(slaves))) slave = slave.lower() for _ in slaves: if slave == _.lower() or slave == slaves[_].lower(): qquit('OK', "Mesos slave '{0}' registered with master".format(slave)) break else: qquit('CRITICAL', "Mesos slave '{0}' not registered with master".format(slave))
def process_options(self): self.host = self.get_opt("host") self.port = self.get_opt("port") self.user = self.get_opt("user") self.password = self.get_opt("password") validate_host(self.host) validate_port(self.port) validate_user(self.user) validate_password(self.password) ssl = self.get_opt("ssl") log_option("ssl", ssl) if ssl: self.protocol = "https" self.validate_thresholds(simple="lower", optional=True)
def process_options(self): self.no_args() self.host = self.get_opt('host') self.port = self.get_opt('port') self.user = self.get_opt('user') self.password = self.get_opt('password') validate_host(self.host) validate_user(self.user) validate_password(self.password) validate_port(self.port) use_ssl = self.get_opt('use_ssl') log_option('ssl', use_ssl) if use_ssl and self.protocol == 'http': self.protocol = 'https'
def process_options(self): self.host = self.get_opt('host') self.port = self.get_opt('port') self.user = self.get_opt('user') self.password = self.get_opt('password') validate_host(self.host) validate_port(self.port) validate_user(self.user) validate_password(self.password) ssl = self.get_opt('ssl') log_option('ssl', ssl) if ssl: self.protocol = 'https' self.validate_thresholds(simple='lower', optional=True)
def run(self): validate_host(self.host) validate_port(self.port) validate_user(self.user) validate_password(self.password) all_services = self.get_opt('all') services_str = self.get_opt('services') cancel = self.get_opt('cancel') if cancel and (all_services or services_str): self.usage('cannot specify --cancel and --services/--all simultaneously' + ', --cancel will cancel all pending service checks') if all_services and services_str: self.usage('cannot specify --all and --services simultaneously, they are mutually exclusive') services_requested = [] if services_str: services_requested = [service.strip().upper() for service in services_str.split(',')] list_clusters = self.get_opt('list_clusters') list_services = self.get_opt('list_services') clusters = self.get_clusters() if list_clusters: if self.verbose > 0: print('Ambari Clusters:\n') print('\n'.join(clusters)) sys.exit(3) if not self.cluster and len(clusters) == 1: self.cluster = clusters[0] log.info('no --cluster specified, but only one cluster managed by Ambari' + ', inferring --cluster=\'%s\'', self.cluster) validate_chars(self.cluster, 'cluster', r'\w\s\.-') self.services = self.get_services() if list_services: if self.verbose > 0: print('Ambari Services:\n') print('\n'.join(self.services)) sys.exit(3) if not services_requested and not all_services and not cancel: self.usage('no --services specified, nor was --all requested') services_to_check = [] if all_services: services_to_check = self.services else: for service_requested in services_requested: if service_requested not in self.services: die('service \'{0}\' is not in the list of available services in Ambari!'.format(service_requested) + ' Here is the list of services available:\n' + '\n'.join(self.services)) services_to_check = services_requested if cancel: self.cancel_service_checks() else: self.request_service_checks(services_to_check)
def process_options(self): self.no_args() self.host = self.get_opt('host') self.port = self.get_opt('port') self.user = self.get_opt('user') self.password = self.get_opt('password') validate_host(self.host) validate_port(self.port) validate_user(self.user) validate_password(self.password) ssl = self.get_opt('ssl') log_option('ssl', ssl) if ssl: self.protocol = 'https' self.process_expected_version_option()
def process_args(self): #log.setLevel(logging.INFO) self.no_args() self.host = self.get_opt('host') self.port = self.get_opt('port') self.table = self.get_opt('table') self.prefix_length = self.get_opt('key_prefix_length') self.sort = self.get_opt('sort') self.sort_desc = self.get_opt('desc') validate_host(self.host) validate_port(self.port) if not self.get_opt('list_tables'): validate_chars(self.table, 'hbase table', 'A-Za-z0-9:._-') validate_int(self.prefix_length, 'row key prefix length', 1, 10) self.prefix_length = int(self.prefix_length)
def process_options(self): self.host = self.get_opt('host') self.port = self.get_opt('port') validate_host(self.host) validate_port(self.port) ssl = self.get_opt('ssl') log_option('ssl', ssl) if ssl: self.protocol = 'https' self.metrics = self.get_opt('metrics') if not self.metrics and not self.get_opt('list_metrics'): self.usage("--metrics not specified, use --list-metrics to see what's available in Attivio's API") for key in self.filter_types: self.filters[key] = self.get_opt(key) self.precision = self.get_opt('precision') self.validate_thresholds(optional=True)