def process_options(self):
     super(CheckJenkinsJobExists, self).process_options()
     self.job = self.get_opt('job')
     self.list_jobs = self.get_opt('list')
     if not self.list_jobs:
         validate_chars(self.job, 'job', r'A-Za-z0-9\s\._-')
         self.msg += "'{job}' ".format(job=self.job)
 def process_options(self):
     super(CheckHadoopDatanodeLastContact, self).process_options()
     self.datanode = self.get_opt('node')
     self.list_nodes = self.get_opt('list_nodes')
     if not self.list_nodes:
         validate_chars(self.datanode, 'datanode', 'A-Za-z0-9:_-')
     self.validate_thresholds()
    def process_options(self):
        super(CheckHadoopYarnAppRunning, self).process_options()

        self.app = self.get_opt('app')
        self.app_user = self.get_opt('user')
        self.queue = self.get_opt('queue')
        self.min_containers = self.get_opt('min_containers')
        self.limit = self.get_opt('limit')
        self.warn_on_dup_app = self.get_opt('warn_on_duplicate_app')
        self.list_apps = self.get_opt('list_apps')

        if not self.list_apps:
            if not self.app:
                self.usage('--app regex not defined')
            validate_regex(self.app, 'app')
        if self.app_user is not None:
            validate_chars(self.app_user, 'app user', r'\w')
        if self.queue is not None:
            validate_chars(self.queue, 'queue', r'\w-')
        if self.min_containers is not None:
            validate_int(self.min_containers, 'min containers', 0, None)
            self.min_containers = int(self.min_containers)

        self.limit = self.get_opt('limit')
        validate_int(self.limit, 'num results', 1, None)
        self.path += '?states=running&limit={0}'.format(self.limit)

        self.validate_thresholds(optional=True)
 def process_options(self):
     super(CheckJenkinsJobCount, self).process_options()
     self.view = self.get_opt('view')
     self.list_views = self.get_opt('list_views')
     if self.view:
         validate_chars(self.view, 'view', r'A-Za-z0-9\s\.,_-')
     self.validate_thresholds(optional=True)
 def run(self):
     self.no_args()
     directory = self.get_opt('directory')
     validate_directory(directory)
     directory = os.path.abspath(directory)
     self.remote = self.get_opt('remote')
     validate_chars(self.remote, 'remote', r'A-Za-z0-9_\.-')
     try:
         repo = git.Repo(directory)
     except InvalidGitRepositoryError as _:
         raise CriticalError("directory '{}' does not contain a valid Git repository!".format(directory))
     try:
         if not self.get_opt('no_fetch'):
             log.info('fetching from remote repo: {}'.format(self.remote))
             repo.git.fetch(self.remote)
         branch = repo.active_branch
         log.info('active branch: %s', branch)
         commits_behind = repo.iter_commits('{branch}..{remote}/{branch}'.format(remote=self.remote, branch=branch))
         commits_ahead = repo.iter_commits('{remote}/{branch}..{branch}'.format(remote=self.remote, branch=branch))
         num_commits_behind = sum(1 for c in commits_behind)
         num_commits_ahead = sum(1 for c in commits_ahead)
     # happens with detached HEAD checkout like Travis CI does
     except TypeError as _:
         raise CriticalError(_)
     except GitCommandError as _:
         raise CriticalError(', '.join(str(_.stderr).split('\n')))
     self.msg = "git checkout branch '{}' is ".format(branch)
     if num_commits_ahead + num_commits_behind == 0:
         self.ok()
         self.msg += 'up to date with'
     else:
         self.critical()
         self.msg += '{} commits behind, {} commits ahead of'.format(num_commits_behind, num_commits_ahead)
     self.msg += " remote '{}'".format(self.remote)
     self.msg += ' | commits_behind={};0;0 commits_ahead={};0;0'.format(num_commits_behind, num_commits_ahead)
Пример #6
0
 def run(self):
     self.no_args()
     directory = self.get_opt('directory')
     validate_directory(directory)
     directory = os.path.abspath(directory)
     self.remote = self.get_opt('remote')
     validate_chars(self.remote, 'remote', r'A-Za-z0-9_\.-')
     try:
         repo = git.Repo(directory)
     except git.InvalidGitRepositoryError as _:
         raise CriticalError("directory '{}' does not contain a valid Git repository!".format(directory))
     try:
         if not self.get_opt('no_fetch'):
             log.info('fetching from remote repo: {}'.format(self.remote))
             repo.git.fetch(self.remote)
         branch = repo.active_branch
         log.info('active branch: %s', branch)
         commits_behind = repo.iter_commits('{branch}..{remote}/{branch}'.format(remote=self.remote, branch=branch))
         commits_ahead = repo.iter_commits('{remote}/{branch}..{branch}'.format(remote=self.remote, branch=branch))
         num_commits_behind = sum(1 for c in commits_behind)
         num_commits_ahead = sum(1 for c in commits_ahead)
     # happens with detached HEAD checkout like Travis CI does
     except TypeError as _:
         raise CriticalError(_)
     except git.GitCommandError as _:
         raise CriticalError(', '.join(str(_.stderr).split('\n')))
     self.msg = "git checkout branch '{}' is ".format(branch)
     if num_commits_ahead + num_commits_behind == 0:
         self.ok()
         self.msg += 'up to date with'
     else:
         self.critical()
         self.msg += '{} commits behind, {} commits ahead of'.format(num_commits_behind, num_commits_ahead)
     self.msg += " remote '{}'".format(self.remote)
     self.msg += ' | commits_behind={};0;0 commits_ahead={};0;0'.format(num_commits_behind, num_commits_ahead)
 def process_options(self):
     super(CheckJenkinsJobColor, self).process_options()
     self.job = self.get_opt('job')
     self.list_jobs = self.get_opt('list')
     if not self.list_jobs:
         validate_chars(self.job, 'job', r'A-Za-z0-9\s\._-')
         self.path = '/job/{job}/api/json'.format(job=self.job)
 def process_options(self):
     super(CheckJenkinsJobColor, self).process_options()
     self.job = self.get_opt('job')
     self.list_jobs = self.get_opt('list')
     if not self.list_jobs:
         validate_chars(self.job, 'job', r'A-Za-z0-9\s\._-')
         self.path = '/job/{job}/api/json'.format(job=self.job)
Пример #9
0
    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)
Пример #10
0
    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)
Пример #11
0
 def process_options(self):
     super(CheckRabbitMQExchange, self).process_options()
     self.vhost = self.get_opt('vhost')
     validate_chars(self.vhost, 'vhost', r'/\w\+-')
     self.path += '/' + urllib.quote_plus(self.vhost)
     self.exchange = self.get_opt('exchange')
     if self.get_opt('list_exchanges'):
         pass
     else:
         if self.exchange == '':
             # nameless exchange
             pass
         else:
             validate_chars(self.exchange, 'exchange', r'/\w\.\+-')
         self.path += '/' + urllib.quote_plus(self.exchange)
     self.expected_type = self.get_opt('type')
     self.expected_durable = self.get_opt('durable')
     if self.expected_type and self.expected_type not in self.valid_exchange_types:
         self.usage("invalid --type '{0}' given, if specified must be one of: {1}"\
                    .format(self.expected_type, ', '.join(self.valid_exchange_types)))
     if self.expected_durable:
         self.expected_durable = self.expected_durable.lower()
         if self.expected_durable not in ('true', 'false'):
             self.usage("invalid --durable '{0}' given, if specified must be either 'true' or 'false'".\
                        format(self.expected_durable))
Пример #12
0
    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')
Пример #13
0
 def process_options(self):
     super(CheckHadoopDatanodeLastContact, self).process_options()
     self.datanode = self.get_opt('node')
     self.list_nodes = self.get_opt('list_nodes')
     if not self.list_nodes:
         validate_chars(self.datanode, 'datanode', 'A-Za-z0-9:_-')
     self.validate_thresholds()
Пример #14
0
    def process_options(self):
        super(CheckHadoopYarnAppLastFinishedState, self).process_options()

        self.app = self.get_opt('app')
        self.app_user = self.get_opt('user')
        self.queue = self.get_opt('queue')
        self.limit = self.get_opt('limit')
        self.warn_on_dup_app = self.get_opt('warn_on_duplicate_app')
        self.list_apps = self.get_opt('list_apps')

        if not self.list_apps:
            if not self.app:
                self.usage('--app name is not defined')
            validate_regex(self.app, 'app')
        if self.app_user is not None:
            validate_chars(self.app_user, 'app user', r'\w')
        if self.queue is not None:
            validate_chars(self.queue, 'queue', r'\w-')

        self.limit = self.get_opt('limit')
        validate_int(self.limit, 'num results', 1, None)
        # Not limited to states here in case we miss one, instead will return all and
        # then explicitly skip only RUNNING/ACCEPTED states
        self.path += '?limit={0}'.format(self.limit)

        self.validate_thresholds(optional=True)
Пример #15
0
 def process_options(self):
     self.job_id = self.get_opt('job_id')
     self.travis_token = self.get_opt('travis_token')
     self.repo = self.get_opt('repo')
     #if travis_token is None:
     #    self.usage('--travis-token option or ' +
     #               '$TRAVIS_TOKEN environment variable required to authenticate to the API')
     if self.args:
         # assume arg is a repo in form of HariSekhon/nagios-plugins but do not use url which we are more likely to
         # have pasted a travis-ci url to a job, see a few lines further down
         if '/' in self.args[0] and '://' not in self.args[0]:
             if not self.repo:
                 log.info('using argument as --repo')
                 self.repo = self.args[0]
         elif not self.job_id:
             log.info('using argument as --job-id')
             self.job_id = self.args[0]
     if self.job_id:
         # convenience to be able to lazily paste a URL like the following and still have it extract the job_id
         # https://travis-ci.org/HariSekhon/nagios-plugins/jobs/283840596#L1079
         self.job_id = self.job_id.split('/')[-1].split('#')[0]
         validate_chars(self.job_id, 'job id', '0-9')
     elif self.repo:
         validate_chars(self.repo, 'repo', r'\/\w\.-')
     else:
         self.usage('--job-id / --repo not specified')
     validate_alnum(self.travis_token, 'travis token')
     self.headers['Authorization'] = 'token {0}'.format(self.travis_token)
 def process_options(self):
     super(CheckJenkinsJobCount, self).process_options()
     self.view = self.get_opt('view')
     self.list_views = self.get_opt('list_views')
     if self.view:
         validate_chars(self.view, 'view', r'A-Za-z0-9\s\.,_-')
     self.validate_thresholds(optional=True)
Пример #17
0
 def process_options(self):
     self.travis_token = self.get_opt('travis_token')
     self.repo = self.get_opt('repo')
     self.job_id = self.get_opt('job_id')
     if self.args:
         if '/' in self.args[0] and '://' not in self.args[0]:
             if not self.repo:
                 log.info('using argument as --repo')
                 self.repo = self.args[0]
         elif not self.job_id:
             log.info('using argument as --job-id')
             self.job_id = self.args[0]
     if self.job_id:
         # convenience to be able to lazily paste a URL like the following and still have it extract the job_id
         # https://travis-ci.org/HariSekhon/nagios-plugins/jobs/283840596#L1079
         self.job_id = self.job_id.split('/')[-1].split('#')[0]
         validate_chars(self.job_id, 'job id', '0-9')
     elif self.repo:
         travis_user = os.getenv('TRAVIS_USER')
         if '/' not in self.repo:
             self.repo = '/' + self.repo
         if self.repo[0] == '/' and travis_user:
             self.repo = travis_user + self.repo
         validate_chars(self.repo, 'repo', r'\/\w\.-')
     else:
         self.usage('--job-id / --repo not specified')
     validate_alnum(self.travis_token, 'travis token')
     self.headers['Authorization'] = 'token {0}'.format(self.travis_token)
     self.num = self.get_opt('num')
     validate_int(self.num, 'num', 1)
     self.num = int(self.num)
     self.completed = self.get_opt('completed')
     self.failed = self.get_opt('failed')
Пример #18
0
 def process_docker_options(self):
     # should look like unix:///var/run/docker.sock or tcp://127.0.0.1:1234
     self.base_url = self.get_opt('base_url')
     if self.base_url:
         validate_chars(self.base_url, 'base url', r'A-Za-z0-9\/\:\.')
     self.tls = self.get_opt('tls')
     if not self.tls and os.getenv('DOCKER_TLS_VERIFY'):
         self.tls = True
     log_option('tls', self.tls)
     if self.tls:
         ca_file = self.get_opt('tlscacert')
         cert_file = self.get_opt('tlscert')
         key_file = self.get_opt('tlskey')
         tls_verify = self.get_opt('tlsverify')
         docker_cert_path = os.getenv('DOCKER_CERT_PATH')
         if docker_cert_path:
             if not ca_file:
                 ca_file = os.path.join(docker_cert_path, 'ca.pem')
             if not cert_file:
                 cert_file = os.path.join(docker_cert_path, 'cert.pem')
             if not key_file:
                 key_file = os.path.join(docker_cert_path, 'key.pem')
             if not tls_verify and os.getenv('DOCKER_TLS_VERIFY'):
                 tls_verify = True
         validate_file(ca_file, 'TLS CA cert file')
         validate_file(cert_file, 'TLS cert file')
         validate_file(key_file, 'TLS key file')
         log_option('TLS verify', tls_verify)
         self.tls_config = docker.tls.TLSConfig(
             ca_cert=ca_file,  # pylint: disable=redefined-variable-type
             verify=tls_verify,
             client_cert=(cert_file, key_file))
    def process_options(self):
        super(CheckHadoopYarnAppRunning, self).process_options()

        self.app = self.get_opt('app')
        self.app_user = self.get_opt('user')
        self.queue = self.get_opt('queue')
        self.min_containers = self.get_opt('min_containers')
        self.limit = self.get_opt('limit')
        self.warn_on_dup_app = self.get_opt('warn_on_duplicate_app')
        self.list_apps = self.get_opt('list_apps')

        if not self.list_apps:
            if not self.app:
                self.usage('--app regex not defined')
            validate_regex(self.app, 'app')
        if self.app_user is not None:
            validate_chars(self.app_user, 'app user', r'\w')
        if self.queue is not None:
            validate_chars(self.queue, 'queue', r'\w-')
        if self.min_containers is not None:
            validate_int(self.min_containers, 'min containers', 0, None)
            self.min_containers = int(self.min_containers)

        self.limit = self.get_opt('limit')
        validate_int(self.limit, 'num results', 1, None)
        self.path += '?states=running&limit={0}'.format(self.limit)

        self.validate_thresholds(optional=True)
 def process_options(self):
     super(CheckJenkinsJobHealthReport, self).process_options()
     self.job = self.get_opt('job')
     self.list_jobs = self.get_opt('list')
     if not self.list_jobs:
         validate_chars(self.job, 'job', r'A-Za-z0-9\s\._-')
         self.path = '/job/{job}/api/json'.format(job=self.job)
     self.validate_thresholds(percent=True, simple='lower')
 def process_options(self):
     self.no_args()
     self.docker_image = self.get_opt('docker_image')
     validate_chars(self.docker_image, 'docker image', 'A-Za-z0-9/:-')
     self.expected_id = self.get_opt('id')
     if self.expected_id is not None:
         validate_chars(self.expected_id, 'expected id', 'A-Za-z0-9:-')
     self.validate_thresholds(optional=True)
 def process_options(self):
     super(CheckLogstashPlugins, self).process_options()
     plugins = self.get_opt('plugins')
     if plugins:
         self.plugins = [plugin.strip() for plugin in plugins.split(',')]
         for plugin in self.plugins:
             validate_chars(plugin, 'plugin', 'A-Za-z0-9_-')
     self.validate_thresholds(optional=True)
 def process_options(self):
     super(CheckLogstashPlugins, self).process_options()
     plugins = self.get_opt('plugins')
     if plugins:
         self.plugins = [plugin.strip() for plugin in plugins.split(',')]
         for plugin in self.plugins:
             validate_chars(plugin, 'plugin', 'A-Za-z0-9_-')
     self.validate_thresholds(optional=True)
 def process_options(self):
     super(CheckJenkinsNode, self).process_options()
     self.node = self.get_opt('node')
     self.list_nodes = self.get_opt('list')
     if not self.list_nodes:
         validate_chars(self.node, 'node', r'A-Za-z0-9\._-')
         self.msg += '{0} is '.format(self.node)
     self.validate_thresholds(simple='lower')
 def process_options(self):
     super(CheckJenkinsPlugin, self).process_options()
     self.plugin = self.get_opt('plugin')
     self.list_plugins = self.get_opt('list')
     if not self.list_plugins:
         validate_chars(self.plugin, 'plugin', r'A-Za-z0-9\s\.,_-')
     self.check_update = self.get_opt('check_update')
     log_option('check for updates', self.check_update)
 def process_options(self):
     super(CheckDockerImage, self).process_options()
     self.docker_image = self.get_opt('docker_image')
     validate_chars(self.docker_image, 'docker image', r'A-Za-z0-9/:\.-')
     self.expected_id = self.get_opt('id')
     if self.expected_id is not None:
         validate_chars(self.expected_id, 'expected id', 'A-Za-z0-9:-')
     self.validate_thresholds(optional=True)
 def process_options(self):
     super(CheckApacheDrillConfig, self).process_options()
     self.config_key = self.get_opt('key')
     self.expected_value = self.get_opt('expected')
     self.list_config = self.get_opt('list')
     if not self.list_config:
         validate_chars(self.config_key, 'config key', r'A-Za-z0-9_\.-')
         validate_regex(self.expected_value, 'expected value regex')
Пример #28
0
 def process_options(self):
     super(CheckJenkinsNode, self).process_options()
     self.node = self.get_opt('node')
     self.list_nodes = self.get_opt('list')
     if not self.list_nodes:
         validate_chars(self.node, 'node', r'A-Za-z0-9\._-')
         self.msg += '{0} is '.format(self.node)
     self.validate_thresholds(simple='lower')
 def process_options(self):
     super(CheckJenkinsJobHealthReport, self).process_options()
     self.job = self.get_opt('job')
     self.list_jobs = self.get_opt('list')
     if not self.list_jobs:
         validate_chars(self.job, 'job', r'A-Za-z0-9\s\._-')
         self.path = '/job/{job}/api/json'.format(job=self.job)
     self.validate_thresholds(percent=True, simple='lower')
 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)
Пример #31
0
 def process_options(self):
     super(CheckDockerSwarmServiceStatus, self).process_options()
     self.service = self.get_opt('service')
     self.updated = self.get_opt('warn_if_last_updated_within')
     validate_chars(self.service, 'docker service', r'A-Za-z0-9/:\._-')
     if self.updated is not None:
         validate_int(self.updated, 'last updated threshold')
         self.updated = int(self.updated)
     self.validate_thresholds(simple='lower', positive=True, optional=True)
 def process_options(self):
     super(CheckRabbitMQVhost, self).process_options()
     if not self.get_opt('list_vhosts'):
         self.vhost = self.get_opt('vhost')
         validate_chars(self.vhost, 'vhost', r'/\w\+-')
     # more concise but we'll get a more generic 404 object not found error
     # requires 'administrator' user tag
     #self.path += '/' + urllib.quote_plus(self.vhost)
     self.no_tracing = self.get_opt('no_tracing')
Пример #33
0
 def process_args(self):
     self.no_args()
     self.repo = self.get_opt('repo')
     if self.repo is None:
         self.usage('--repo not defined')
     parts = self.repo.split('/')
     if len(parts) != 2 or not parts[0] or not parts[1]:
         self.usage("invalid --repo format, must be in form of 'user/repo'")
     validate_chars(self.repo, 'repo', r'\/\w\.-')
 def process_options(self):
     super(CheckRabbitMQVhost, self).process_options()
     if not self.get_opt('list_vhosts'):
         self.vhost = self.get_opt('vhost')
         validate_chars(self.vhost, 'vhost', r'/\w\+-')
     # more concise but we'll get a more generic 404 object not found error
     # requires 'administrator' user tag
     #self.path += '/' + urllib.quote_plus(self.vhost)
     self.no_tracing = self.get_opt('no_tracing')
Пример #35
0
 def process_options(self):
     super(CheckGoCDStageStatus, self).process_options()
     self.pipeline = self.get_opt('pipeline')
     self.stage = self.get_opt('stage')
     validate_chars(self.pipeline, 'pipeline', 'A-Za-z0-9-')
     validate_chars(self.stage, 'stage', 'A-Za-z0-9-')
     self.path += '/{pipeline}/{stage}/history'.format(
         pipeline=self.pipeline,
         stage=self.stage)
Пример #36
0
 def process_options(self):
     super(CheckCouchDBDatabaseStats, self).process_options()
     if self.get_opt('list'):
         self.path = '/_all_dbs'
     else:
         self.database = self.get_opt('database')
         # lowercase characters (a-z), digits (0-9), and any of the characters _, $, (, ), +, -, and /
         validate_chars(self.database, 'database', r'a-z0-9_\$\(\)\+\-/')
         self.path = '/{0}'.format(self.database)
     self.validate_thresholds(optional=True)
 def process_args(self):
     self.no_args()
     self.repo = self.get_opt('repo')
     if self.repo is None:
         self.usage('--repo not defined')
     parts = self.repo.split('/')
     if len(parts) != 2 or not parts[0] or not parts[1]:
         self.usage("invalid --repo format, must be in form of 'user/repo'")
     validate_chars(self.repo, 'repo', r'\/\w\.-')
     self.validate_thresholds(optional=True)
 def process_options(self):
     super(CheckConsulServiceLeaderElected, self).process_options()
     self.key = self.get_opt('key')
     self.regex = self.get_opt('regex')
     if not self.key:
         self.usage('--key not defined')
     self.key = self.key.lstrip('/')
     validate_chars(self.key, 'key', r'\w\/-')
     if self.regex:
         validate_regex(self.regex, 'key')
     self.path += '{}'.format(self.key)
 def process_options(self):
     super(CheckCouchDBDatabaseStats, self).process_options()
     if self.get_opt('list'):
         self.path = '/_all_dbs'
     else:
         self.database = self.get_opt('database')
         # lowercase characters (a-z), digits (0-9), and any of the characters _, $, (, ), +, -, and /
         validate_chars(self.database, 'database', r'a-z0-9_\$\(\)\+\-/')
         self.path = '/{0}'.format(self.database)
     if self.has_thresholds:
         self.validate_thresholds(optional=True)
 def process_options(self):
     super(CheckAmbariClusterHdfsRackResilience, self).process_options()
     self.no_args()
     cluster = self.get_opt('cluster')
     validate_chars(cluster, 'cluster', 'A-Za-z0-9-_')
     self.path = self.path.format(cluster=cluster)
     # RestNagiosPlugin auto sets 'Accept'='application/json' but this breaks Ambari, fixed in pylib now
     #self.headers = {}
     if self.get_opt('list'):
         self.path = '/api/v1/clusters'
         self.list = True
 def process_options(self):
     super(CheckAmbariClusterHdfsRackResilience, self).process_options()
     self.no_args()
     cluster = self.get_opt('cluster')
     validate_chars(cluster, 'cluster', 'A-Za-z0-9-_')
     self.path = self.path.format(cluster=cluster)
     # RestNagiosPlugin auto sets 'Accept'='application/json' but this breaks Ambari, fixed in pylib now
     #self.headers = {}
     if self.get_opt('list'):
         self.path = '/api/v1/clusters'
         self.list = True
 def process_options(self):
     super(CheckConsulServiceLeaderElected, self).process_options()
     self.key = self.get_opt('key')
     self.regex = self.get_opt('regex')
     if not self.key:
         self.usage('--key not defined')
     self.key = self.key.lstrip('/')
     validate_chars(self.key, 'key', r'\w\/-')
     if self.regex:
         validate_regex(self.regex, 'key')
     self.path += '{}'.format(self.key)
 def process_options(self):
     super(CheckJenkinsJob, self).process_options()
     self.job = self.get_opt('job')
     self.list_jobs = self.get_opt('list')
     if self.list_jobs:
         self.path = '/api/json'
     else:
         validate_chars(self.job, 'job', r'A-Za-z0-9\s\._-')
         self.path = '/job/{job}/api/json'.format(job=self.job)
         self.msg += "'{job}' is ".format(job=self.job)
     self.validate_thresholds(integer=False, optional=True)
 def process_options(self):
     super(CheckJenkinsJob, self).process_options()
     self.job = self.get_opt('job')
     self.list_jobs = self.get_opt('list')
     if self.list_jobs:
         self.path = '/api/json'
     else:
         validate_chars(self.job, 'job', r'A-Za-z0-9\s\._-')
         self.path = '/job/{job}/api/json'.format(job=self.job)
         self.msg += "'{job}' is ".format(job=self.job)
     self.validate_thresholds(integer=False, optional=True)
Пример #45
0
 def process_options(self):
     super(CheckJenkinsJob, self).process_options()
     self.job = self.get_opt('job')
     self.list_jobs = self.get_opt('list')
     if not self.list_jobs:
         validate_chars(self.job, 'job', r'A-Za-z0-9\s\._-')
         self.msg += "'{job}' ".format(job=self.job)
     self.age = self.get_opt('age')
     if self.age:
         validate_int(self.age, 'age')
         self.age = int(self.age)
     self.validate_thresholds(integer=False, optional=True)
 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)
Пример #47
0
 def process_options(self):
     super(CheckJenkinsJob, self).process_options()
     self.job = self.get_opt('job')
     self.list_jobs = self.get_opt('list')
     if not self.list_jobs:
         validate_chars(self.job, 'job', r'A-Za-z0-9\s\._-')
         self.msg += "'{job}' ".format(job=self.job)
     self.age = self.get_opt('age')
     if self.age:
         validate_int(self.age, 'age')
         self.age = int(self.age)
     self.validate_thresholds(integer=False, 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):
     super(CheckCouchDBDatabaseExists, self).process_options()
     if self.get_opt('list'):
         self.path = '/_all_dbs'
     else:
         self.database = self.get_opt('database')
         # lowercase characters (a-z), digits (0-9), and any of the characters _, $, (, ), +, -, and /
         validate_chars(self.database, 'database', r'a-z0-9_\$\(\)\+\-/')
         self.path = '/{0}'.format(self.database)
         if not self.get_opt('get'):
             self.request_method = 'head'
             self.json = False
         self.request.check_response_code = self.check_response_code
         self.msg += "'{0}' ".format(self.database)
 def process_options(self):
     super(CheckAtlasEntity, self).process_options()
     self.entity_name = self.get_opt('entity_name')
     self.entity_id = self.get_opt('entity_id')
     self.list_entities = self.get_opt('list')
     if not self.list_entities:
         if not self.entity_name and not self.entity_id:
             self.usage('must supply an --entity-id/--entity-name to find or --list-entities')
         if self.entity_name and self.entity_id:
             self.usage('cannot specify both --entity-id and --entity-name as the search criteria ' +
                        'at the same time, prefer --entity-id it\'s more efficient')
         if self.entity_name:
             # this can contain pretty much anything including /haritest
             #validate_chars(self.entity_name, 'entity name', r'A-Za-z0-9\.\,_-')
             log_option('entity_name', self.entity_name)
         if self.entity_id:
             validate_chars(self.entity_id, 'entity id', r'A-Za-z0-9-')
             # v1
             self.path += '/{0}'.format(self.entity_id)
             # v2
             #self.path += '/guids?guid={0}'.format(self.entity_id)
     self._type = self.get_opt('type')
     self.tags = self.get_opt('tags')
     #self.traits = self.get_opt('traits')
     if self._type:
         validate_chars(self._type, 'type', r'A-Za-z0-9_-')
     if self.tags:
         self.tags = sorted(self.tags.split(','))
         for tag in self.tags:
             validate_chars(tag, 'tag', r'A-Za-z0-9\.\,_-')
     if self.traits:
         self.traits = sorted(self.traits.split(','))
         for trait in self.traits:
             validate_chars(trait, 'trait', r'A-Za-z0-9\.\,_-')
 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)
Пример #52
0
    def process_args(self):
        self.brokers = self.get_opt('brokers')
        # TODO: add broker list validation back in
        # validate_hostport(self.brokers)
        log_option('brokers', self.brokers)
        self.timeout_ms = max((self.timeout * 1000 - 1000) / 2, 1000)

        try:
            list_topics = self.get_opt('list_topics')
            list_partitions = self.get_opt('list_partitions')
            if list_topics:
                self.print_topics()
                sys.exit(ERRORS['UNKNOWN'])
            self.topic = self.get_opt('topic')
        except KafkaError:
            raise CriticalError(self.exception_msg())

        if self.topic:
            validate_chars(self.topic, 'topic', 'A-Za-z-')
        elif list_topics or list_partitions:
            pass
        else:
            self.usage('--topic not specified')

        try:
            if list_partitions:
                if self.topic:
                    self.print_topic_partitions(self.topic)
                else:
                    for topic in self.get_topics():
                        self.print_topic_partitions(topic)
                sys.exit(ERRORS['UNKNOWN'])
        except KafkaError:
            raise CriticalError(self.exception_msg())

        self.partition = self.get_opt('partition')
        # technically optional, will hash to a random partition, but need to know which partition to get offset
        # if self.partition is not None:
        validate_int(self.partition, "partition", 0, 10000)
        self.topic_partition = TopicPartition(self.topic, self.partition)
        self.acks = self.get_opt('acks')
        try:
            self.acks = int(self.acks)
        except ValueError:
            pass
        log_option('acks', self.acks)
        self.validate_thresholds()
 def process_options(self):
     super(CheckRabbitMQQueue, self).process_options()
     self.vhost = self.get_opt('vhost')
     validate_chars(self.vhost, 'vhost', r'/\w\+-')
     self.path += '/' + urllib.quote_plus(self.vhost)
     self.queue = self.get_opt('queue')
     if self.get_opt('list_queues'):
         pass
     else:
         validate_chars(self.queue, 'queue', r'/\w\.\+-')
         self.path += '/' + urllib.quote_plus(self.queue)
     self.expected_durable = self.get_opt('durable')
     if self.expected_durable:
         self.expected_durable = self.expected_durable.lower()
         if self.expected_durable not in ('true', 'false'):
             self.usage("invalid --durable option '{0}' given, if specified must be either 'true' or 'false'".\
                        format(self.expected_durable))
Пример #54
0
 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.key = self.get_opt('key')
     self.regex = self.get_opt('regex')
     if not self.key:
         self.usage('--key not defined')
     self.key = self.key.lstrip('/')
     validate_chars(self.key, 'key', r'\w\/-')
     if self.regex:
         validate_regex(self.regex, 'key')
     self.validate_thresholds(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')
     self._all = self.get_opt('all')
     self.workflow_id = self.get_opt('id')
     self.workflow_name = self.get_opt('name')
     self.max_age = self.get_opt('max_age')
     self.max_runtime = self.get_opt('max_runtime')
     self.min_runtime = self.get_opt('min_runtime')
     if self.get_opt('ssl'):
         self.protocol = 'https'
     validate_host(self.host)
     validate_port(self.port)
     validate_user(self.user)
     validate_password(self.password)
     if self._all and (self.workflow_name is not None or self.workflow_id is not None):
         self.usage('cannot specify both --all and --name/--id simultaneously')
     if self.workflow_id is not None:
         if self.workflow_name is not None:
             self.usage('cannot specify both --id and --name simultaneously')
         validate_int(self.workflow_id, 'workflow id', 1)
         self.workflow_id = int(self.workflow_id)
     elif self.workflow_name is not None:
         validate_chars(self.workflow_name, 'workflow name', r'\w\s-')
     elif self._all:
         pass
     elif self.get_opt('list'):
         pass
     else:
         self.usage('must specify one of --name / --id / --all or use --list to find workflow names/IDs to specify')
     if self.max_age is not None:
         validate_float(self.max_age, 'max age', 1)
         self.max_age = float(self.max_age)
     if self.max_runtime is not None:
         validate_float(self.max_runtime, 'max runtime', 1)
         self.max_runtime = float(self.max_runtime)
     if self.min_runtime is not None:
         validate_float(self.min_runtime, 'min runtime', 0)
         self.min_runtime = float(self.min_runtime)
         if self.max_runtime is not None and self.min_runtime > self.max_runtime:
             self.usage('--min-runtime cannot be greater than --max-runtime!')