Exemplo n.º 1
0
def test(resource_identifier):
    """test a resource"""
    resource = Resource.query.filter_by(identifier=resource_identifier).first()
    if resource is None:
        flash(gettext('Resource not found'), 'danger')
        return redirect(request.referrer)

    from healthcheck import run_test_resource
    result = run_test_resource(
        resource)

    if request.method == 'GET':
        if result.message == 'Skipped':
            msg = gettext('INFO')
            flash('%s: %s' % (msg, result.message), 'info')
        elif result.message not in ['OK', None, 'None']:
            msg = gettext('ERROR')
            flash('%s: %s' % (msg, result.message), 'danger')
        else:
            flash(gettext('Resource tested successfully'), 'success')

        return redirect(url_for('get_resource_by_id', lang=g.current_lang,
                                identifier=resource_identifier))
    elif request.method == 'POST':
        return jsonify(result.get_report())
Exemplo n.º 2
0
def test(resource_identifier):
    """test a resource"""
    resource = Resource.query.filter_by(identifier=resource_identifier).first()
    if resource is None:
        flash(gettext('Resource not found'), 'danger')
        return redirect(request.referrer)

    from healthcheck import run_test_resource
    result = run_test_resource(resource)

    if request.method == 'GET':
        if result.message == 'Skipped':
            msg = gettext('INFO')
            flash('%s: %s' % (msg, result.message), 'info')
        elif result.message not in ['OK', None, 'None']:
            msg = gettext('ERROR')
            flash('%s: %s' % (msg, result.message), 'danger')
        else:
            flash(gettext('Resource tested successfully'), 'success')

        return redirect(
            url_for('get_resource_by_id',
                    lang=g.current_lang,
                    identifier=resource_identifier))
    elif request.method == 'POST':
        return jsonify(result.get_report())
Exemplo n.º 3
0
def add():
    if not g.user.is_authenticated():
        return render_template('add.html')
    if request.method == 'GET':
        return render_template('add.html')

    resource_type = request.form['resource_type']
    url = request.form['url'].strip()
    resource = Resource.query.filter_by(resource_type=resource_type,
                                        url=url).first()
    if resource is not None:
        flash('service already registered (%s, %s)' % (resource_type, url),
              'danger')
        if 'resource_type' in request.args:
            rtype = request.args.get('resource_type')
            return redirect(url_for('add', resource_type=rtype))
        return redirect(url_for('add'))

    [title, success, response_time, message,
     start_time] = run_test_resource(resource_type, url)

    resource_to_add = Resource(current_user, resource_type, title, url)
    run_to_add = Run(resource_to_add, success, response_time, message,
                     start_time)

    DB.session.add(resource_to_add)
    DB.session.add(run_to_add)
    try:
        DB.session.commit()
        flash('service registered (%s, %s)' % (resource_type, url), 'success')
    except Exception, err:
        DB.session.rollback()
        flash(str(err), 'danger')
Exemplo n.º 4
0
def add():
    if not g.user.is_authenticated():
        return render_template('add.html')
    if request.method == 'GET':
        return render_template('add.html')

    resource_type = request.form['resource_type']
    url = request.form['url'].strip()
    resource = Resource.query.filter_by(resource_type=resource_type,
                                        url=url).first()
    if resource is not None:
        flash('service already registered (%s, %s)' % (resource_type, url),
              'danger')
        if 'resource_type' in request.args:
            rtype = request.args.get('resource_type')
            return redirect(url_for('add',
                                    resource_type=rtype))
        return redirect(url_for('add'))

    [title, success, response_time, message, start_time] = run_test_resource(
        resource_type, url)

    resource_to_add = Resource(current_user, resource_type, title, url)
    run_to_add = Run(resource_to_add, success, response_time, message,
                     start_time)

    DB.session.add(resource_to_add)
    DB.session.add(run_to_add)
    try:
        DB.session.commit()
        flash('service registered (%s, %s)' % (resource_type, url), 'success')
    except Exception, err:
        DB.session.rollback()
        flash(str(err), 'danger')
Exemplo n.º 5
0
    def testRunResoures(self):
        # Do the whole healthcheck for all Resources for now
        resources = Resource.query.all()
        for resource in resources:
            result = run_test_resource(resource)
            print('resource: %s result=%s' % (resource.url, result.success))
            run = Run(resource, result)

            print('Adding Run: success=%s, response_time=%ss\n' %
                  (str(run.success), run.response_time))
            self.db.session.add(run)
            self.db.session.commit()

        self.db.session.close()

        # Verify
        resources = Resource.query.all()
        for resource in resources:
            # Each Resource should have one Run
            self.assertEqual(resource.runs.count(), 1,
                             'RunCount should be 1 for %s' % resource.url)
            self.assertEqual(
                resource.runs[0].success, True,
                'Run should be success for %s report=%s' %
                (resource.url, str(resource.runs[0])))
Exemplo n.º 6
0
def add():
    """add resource"""
    if not g.user.is_authenticated():
        return render_template('add.html')
    if request.method == 'GET':
        return render_template('add.html')

    tag_list = []

    resource_type = request.form['resource_type']
    tags = request.form.getlist('tags')
    url = request.form['url'].strip()
    resource = Resource.query.filter_by(resource_type=resource_type,
                                        url=url).first()
    if resource is not None:
        msg = gettext('Service already registered')
        flash('%s (%s, %s)' % (msg, resource_type, url), 'danger')
        if 'resource_type' in request.args:
            rtype = request.args.get('resource_type')
            return redirect(url_for('add', lang=g.current_lang,
                                    resource_type=rtype))
        return redirect(url_for('add', lang=g.current_lang))

    [title, success, response_time, message, start_time] = run_test_resource(
        APP.config, resource_type, url)

    if not success:
        flash(message, 'danger')
        return redirect(url_for('add', lang=g.current_lang,
                                resource_type=resource_type))

    if tags:
        for tag in tags:
            tag_found = False
            for tag_obj in Tag.query.all():
                if tag == tag_obj.name:  # use existing
                    tag_found = True
                    tag_list.append(tag_obj)
            if not tag_found:  # add new
                tag_list.append(Tag(name=tag))

    resource_to_add = Resource(current_user, resource_type, title, url,
                               tags=tag_list)
    run_to_add = Run(resource_to_add, success, response_time, message,
                     start_time)

    DB.session.add(resource_to_add)
    DB.session.add(run_to_add)
    try:
        DB.session.commit()
        msg = gettext('Service registered')
        flash('%s (%s, %s)' % (msg, resource_type, url), 'success')
    except Exception as err:
        DB.session.rollback()
        flash(str(err), 'danger')
    return redirect(url_for('home', lang=g.current_lang))
Exemplo n.º 7
0
def test(resource_identifier):
    """test a resource"""
    resource = Resource.query.filter_by(identifier=resource_identifier).first()
    if resource is None:
        flash('resource not found', 'danger')
        return redirect(request.referrer)

    [title, success, response_time, message,
     start_time] = run_test_resource(resource.resource_type, resource.url)

    if message not in ['OK', None, 'None']:
        flash('ERROR: %s' % message, 'danger')
    else:
        flash('Resource tested successfully', 'success')

    return redirect(
        url_for('get_resource_by_id', identifier=resource_identifier))
Exemplo n.º 8
0
def test(resource_identifier):
    """test a resource"""
    resource = Resource.query.filter_by(identifier=resource_identifier).first()
    if resource is None:
        flash(gettext('Resource not found'), 'danger')
        return redirect(request.referrer)

    [title, success, response_time, message, start_time] = run_test_resource(
        APP.config, resource.resource_type, resource.url)

    if message not in ['OK', None, 'None']:
        msg = gettext('ERROR')
        flash('%s: %s' % (msg, message), 'danger')
    else:
        flash(gettext('Resource tested successfully'), 'success')

    return redirect(url_for('get_resource_by_id', lang=g.current_lang,
                    identifier=resource_identifier))
Exemplo n.º 9
0
def test(resource_identifier):
    resource = Resource.query.filter_by(identifier=resource_identifier).first()
    if resource is None:
        flash('resource not found', 'danger')
        return redirect(request.referrer)

    [title, success, response_time, message, start_time] = run_test_resource(
        resource.resource_type, resource.url)
    run_to_add = Run(resource, success, response_time, message, start_time)

    if message not in ['OK', None, 'None']:
        flash('ERROR: %s' % message, 'danger')
    else:
        flash('Resource tested successfully', 'success')

    DB.session.add(run_to_add)

    try:
        DB.session.commit()
    except Exception, err:
        DB.session.rollback()
        flash(str(err), 'danger')
Exemplo n.º 10
0
def test(resource_identifier):
    resource = Resource.query.filter_by(identifier=resource_identifier).first()
    if resource is None:
        flash('resource not found', 'danger')
        return redirect(request.referrer)

    [title, success, response_time, message,
     start_time] = run_test_resource(resource.resource_type, resource.url)
    run_to_add = Run(resource, success, response_time, message, start_time)

    if message not in ['OK', None, 'None']:
        flash('ERROR: %s' % message, 'danger')
    else:
        flash('Resource tested successfully', 'success')

    DB.session.add(run_to_add)

    try:
        DB.session.commit()
    except Exception, err:
        DB.session.rollback()
        flash(str(err), 'danger')
Exemplo n.º 11
0
def add():
    """add resource"""
    if not g.user.is_authenticated():
        return render_template('add.html')
    if request.method == 'GET':
        return render_template('add.html')
    resource_type = request.form['resource_type']
    tags = request.form.getlist('tags')
    url = request.form['url'].strip()
    resources_to_add = []

    from healthcheck import sniff_test_resource, run_test_resource
    sniffed_resources = sniff_test_resource(CONFIG, resource_type, url)

    if not sniffed_resources:
        msg = gettext("No resources detected")
        LOGGER.exception()
        flash(msg, 'danger')

    for (
            resource_type,
            resource_url,
            title,
            success,
            response_time,
            message,
            start_time,
            resource_tags,
    ) in sniffed_resources:

        # sniffed_resources may return list of resource
        # types different from initial one
        # so we need to test each row separately
        resource = Resource.query.filter_by(resource_type=resource_type,
                                            url=url).first()
        if resource is not None:
            msg = gettext('Service already registered')
            flash('%s (%s, %s)' % (msg, resource_type, url), 'danger')

            if len(sniffed_resources) == 1 and 'resource_type' in request.args:
                return redirect(url_for('add', lang=g.current_lang))

        tags_to_add = []
        for tag in chain(tags, resource_tags):
            tag_obj = tag
            if not isinstance(tag, Tag):
                tag_obj = Tag.query.filter_by(name=tag).first()
                if tag_obj is None:
                    tag_obj = Tag(name=tag)
            tags_to_add.append(tag_obj)

        resource_to_add = Resource(current_user,
                                   resource_type,
                                   title,
                                   resource_url,
                                   tags=tags_to_add)

        resources_to_add.append(resource_to_add)
        probe_to_add = None
        checks_to_add = []

        # Always add a default Probe and Check(s)
        # from the GHC_PROBE_DEFAULTS conf
        if resource_type in CONFIG['GHC_PROBE_DEFAULTS']:
            resource_settings = CONFIG['GHC_PROBE_DEFAULTS'][resource_type]
            probe_class = resource_settings['probe_class']
            if probe_class:
                # Add the default Probe
                probe_obj = Factory.create_obj(probe_class)
                probe_to_add = ProbeVars(
                    resource_to_add, probe_class,
                    probe_obj.get_default_parameter_values())

                # Add optional default (parameterized)
                # Checks to add to this Probe
                checks_info = probe_obj.get_checks_info()
                checks_param_info = probe_obj.get_plugin_vars()['CHECKS_AVAIL']
                for check_class in checks_info:
                    check_param_info = checks_param_info[check_class]
                    if 'default' in checks_info[check_class]:
                        if checks_info[check_class]['default']:
                            # Filter out params for Check with fixed values
                            param_defs = check_param_info['PARAM_DEFS']
                            param_vals = {}
                            for param in param_defs:
                                if param_defs[param]['value']:
                                    param_vals[param] = \
                                        param_defs[param]['value']
                            check_vars = CheckVars(probe_to_add, check_class,
                                                   param_vals)
                            checks_to_add.append(check_vars)

        result = run_test_resource(resource_to_add)

        run_to_add = Run(resource_to_add, result)

        DB.session.add(resource_to_add)
        # prepopulate notifications for current user
        resource_to_add.set_recipients('email', [g.user.email])

        if probe_to_add:
            DB.session.add(probe_to_add)
        for check_to_add in checks_to_add:
            DB.session.add(check_to_add)
            DB.session.add(run_to_add)

    try:
        DB.session.commit()
        msg = gettext('Services registered')
        flash('%s (%s, %s)' % (msg, resource_type, url), 'success')
    except Exception as err:
        DB.session.rollback()
        flash(str(err), 'danger')
        return redirect(url_for('home', lang=g.current_lang))

    if len(resources_to_add) == 1:
        return edit_resource(resources_to_add[0].identifier)
    return redirect(url_for('home', lang=g.current_lang))
Exemplo n.º 12
0
                print('Testing %s %s' %
                      (resource.resource_type, resource.url))

                if not resource.active:
                    print('Resource is not active. Skipping')
                    continue

                # Get the status of the last run,
                # assume success if there is none
                last_run_success = True
                last_run = resource.last_run
                if last_run:
                    last_run_success = last_run.success

                # Run test
                result = run_test_resource(resource)

                run1 = Run(resource, result)

                print('Adding Run: success=%s, response_time=%ss\n'
                      % (str(run1.success), run1.response_time))

                DB.session.add(run1)

                # commit or rollback each run to avoid long-lived transactions
                # see https://github.com/geopython/GeoHealthCheck/issues/14
                db_commit()

                if APP.config['GHC_NOTIFICATIONS']:
                    # Attempt notification
                    try:
Exemplo n.º 13
0
            email2 = raw_input('Enter your email again: ').strip()
            if email1 != email2:
                raise ValueError('Emails must match')

            user_to_add = User(username, password1, email1, role='admin')
            DB.session.add(user_to_add)
        elif sys.argv[1] == 'drop':
            print('Dropping database objects')
            DB.drop_all()
        elif sys.argv[1] == 'run':
            print('Running health check tests')
            from healthcheck import run_test_resource
            for res in Resource.query.all():  # run all tests
                print('Testing %s %s' % (res.resource_type, res.url))
                last_run_success = res.last_run.success
                run_to_add = run_test_resource(res.resource_type, res.url)

                run1 = Run(res, run_to_add[1], run_to_add[2],
                           run_to_add[3], run_to_add[4])

                print('Adding run')
                DB.session.add(run1)

                if APP.config['GHC_NOTIFICATIONS']:
                    notify(APP.config, res, run1, last_run_success)

        elif sys.argv[1] == 'flush':
            print('Flushing runs older than %d days' %
                  APP.config['GHC_RETENTION_DAYS'])
            for run1 in Run.query.all():
                here_and_now = datetime.utcnow()
Exemplo n.º 14
0
def add():
    """add resource"""
    if not g.user.is_authenticated():
        return render_template('add.html')
    if request.method == 'GET':
        return render_template('add.html')
    resource_type = request.form['resource_type']
    tags = request.form.getlist('tags')
    url = request.form['url'].strip()
    resources_to_add = []

    sniffed_resources = sniff_test_resource(CONFIG, resource_type, url)

    if not sniffed_resources:
        msg = gettext("No resources detected")
        LOGGER.exception()
        flash(msg, 'danger')

    for (resource_type, resource_url,
         title, success, response_time,
         message, start_time, resource_tags,) in sniffed_resources:

        # sniffed_resources may return list of resource
        # types different from initial one
        # so we need to test each row separately
        resource = Resource.query.filter_by(resource_type=resource_type,
                                            url=url).first()
        if resource is not None:
            msg = gettext('Service already registered')
            flash('%s (%s, %s)' % (msg, resource_type, url), 'danger')

            if len(sniffed_resources) == 1 and 'resource_type' in request.args:
                return redirect(url_for('add', lang=g.current_lang))

        tags_to_add = []
        for tag in chain(tags, resource_tags):
            tag_obj = tag
            if not isinstance(tag, Tag):
                tag_obj = Tag.query.filter_by(name=tag).first()
                if tag_obj is None:
                    tag_obj = Tag(name=tag)
            tags_to_add.append(tag_obj)

        resource_to_add = Resource(current_user,
                                   resource_type,
                                   title,
                                   resource_url,
                                   tags=tags_to_add)

        resources_to_add.append(resource_to_add)
        probe_to_add = None
        checks_to_add = []

        # Always add a default Probe and Check(s)
        # from the GHC_PROBE_DEFAULTS conf
        if resource_type in CONFIG['GHC_PROBE_DEFAULTS']:
            resource_settings = CONFIG['GHC_PROBE_DEFAULTS'][resource_type]
            probe_class = resource_settings['probe_class']
            if probe_class:
                # Add the default Probe
                probe_obj = Factory.create_obj(probe_class)
                probe_to_add = ProbeVars(
                    resource_to_add, probe_class,
                    probe_obj.get_default_parameter_values())

                # Add optional default (parameterized)
                # Checks to add to this Probe
                checks_info = probe_obj.get_checks_info()
                checks_param_info = probe_obj.get_plugin_vars()['CHECKS_AVAIL']
                for check_class in checks_info:
                    check_param_info = checks_param_info[check_class]
                    if 'default' in checks_info[check_class]:
                        if checks_info[check_class]['default']:
                            # Filter out params for Check with fixed values
                            param_defs = check_param_info['PARAM_DEFS']
                            param_vals = {}
                            for param in param_defs:
                                if param_defs[param]['value']:
                                    param_vals[param] =\
                                        param_defs[param]['value']
                            check_vars = CheckVars(
                                probe_to_add, check_class, param_vals)
                            checks_to_add.append(check_vars)

        result = run_test_resource(resource_to_add)

        run_to_add = Run(resource_to_add, result)

        DB.session.add(resource_to_add)
        # prepopulate notifications for current user
        resource_to_add.set_recipients('email', [g.user.email])

        if probe_to_add:
            DB.session.add(probe_to_add)
        for check_to_add in checks_to_add:
            DB.session.add(check_to_add)
            DB.session.add(run_to_add)

    try:
        DB.session.commit()
        msg = gettext('Services registered')
        flash('%s (%s, %s)' % (msg, resource_type, url), 'success')
    except Exception as err:
        DB.session.rollback()
        flash(str(err), 'danger')
        return redirect(url_for('home', lang=g.current_lang))

    if len(resources_to_add) == 1:
        return edit_resource(resources_to_add[0].identifier)
    return redirect(url_for('home', lang=g.current_lang))
Exemplo n.º 15
0
        elif sys.argv[1] == 'run':
            print('START - Running health check tests on %s'
                  % datetime.utcnow().isoformat())
            from healthcheck import run_test_resource
            for res in Resource.query.all():  # run all tests
                print('Testing %s %s' % (res.resource_type, res.url))

                # Get the status of the last run,
                # assume success if there is none
                last_run_success = True
                last_run = res.last_run
                if last_run:
                    last_run_success = last_run.success

                # Run test
                run_to_add = run_test_resource(
                        APP.config, res.resource_type, res.url)

                run1 = Run(res, run_to_add[1], run_to_add[2],
                           run_to_add[3], run_to_add[4])

                print('Adding Run: success=%s, response_time=%ss\n'
                      % (str(run1.success), run1.response_time))
                DB.session.add(run1)
                # commit or rollback each run to avoid long-lived transactions
                # see https://github.com/geopython/GeoHealthCheck/issues/14
                db_commit()

                if APP.config['GHC_NOTIFICATIONS']:
                    # Attempt notification
                    try:
                        notify(APP.config, res, run1, last_run_success)
Exemplo n.º 16
0
     DB.session.add(user_to_add)
     try:
         DB.session.commit()
     except Exception, err:
         DB.session.rollback()
         msg = str(err)
         print(msg)
 elif sys.argv[1] == 'drop':
     print('Dropping database objects')
     DB.drop_all()
 elif sys.argv[1] == 'run':
     print('Running health check tests')
     from healthcheck import run_test_resource
     for res in Resource.query.all():  # run all tests
         print('Testing %s %s' % (res.resource_type, res.url))
         run_to_add = run_test_resource(res.resource_type, res.url)
         run1 = Run(res, run_to_add[1], run_to_add[2], run_to_add[3],
                    run_to_add[4])
         print('Adding run')
         DB.session.add(run1)
     try:
         DB.session.commit()
     except Exception, err:
         DB.session.rollback()
         msg = str(err)
         print(msg)
 elif sys.argv[1] == 'flush':
     print('Flushing runs older than %d days' %
           config.GHC_RETENTION_DAYS)
     for run1 in Run.query.all():
         here_and_now = datetime.utcnow()
Exemplo n.º 17
0
def add():
    """add resource"""
    if not g.user.is_authenticated():
        return render_template('add.html')
    if request.method == 'GET':
        return render_template('add.html')

    tag_list = []

    resource_type = request.form['resource_type']
    tags = request.form.getlist('tags')
    url = request.form['url'].strip()
    resource = Resource.query.filter_by(resource_type=resource_type,
                                        url=url).first()
    if resource is not None:
        msg = gettext('Service already registered')
        flash('%s (%s, %s)' % (msg, resource_type, url), 'danger')
        if 'resource_type' in request.args:
            rtype = request.args.get('resource_type')
            return redirect(
                url_for('add', lang=g.current_lang, resource_type=rtype))
        return redirect(url_for('add', lang=g.current_lang))

    [title, success, response_time, message,
     start_time] = sniff_test_resource(APP.config, resource_type, url)

    if not success:
        flash(message, 'danger')
        return redirect(
            url_for('add', lang=g.current_lang, resource_type=resource_type))

    if tags:
        for tag in tags:
            tag_found = False
            for tag_obj in Tag.query.all():
                if tag == tag_obj.name:  # use existing
                    tag_found = True
                    tag_list.append(tag_obj)
            if not tag_found:  # add new
                tag_list.append(Tag(name=tag))

    resource_to_add = Resource(current_user,
                               resource_type,
                               title,
                               url,
                               tags=tag_list)

    probe_to_add = None
    checks_to_add = []

    # Always add a default Probe and Check(s)  from the GHC_PROBE_DEFAULTS conf
    if resource_type in APP.config['GHC_PROBE_DEFAULTS']:
        resource_settings = APP.config['GHC_PROBE_DEFAULTS'][resource_type]
        probe_class = resource_settings['probe_class']
        if probe_class:
            # Add the default Probe
            probe_obj = Factory.create_obj(probe_class)
            probe_to_add = ProbeVars(resource_to_add, probe_class,
                                     probe_obj.get_default_parameter_values())

            # Add optional default (parameterized) Checks to add to this Probe
            checks_info = probe_obj.get_checks_info()
            checks_param_info = probe_obj.get_plugin_vars()['CHECKS_AVAIL']
            for check_class in checks_info:
                check_param_info = checks_param_info[check_class]
                if 'default' in checks_info[check_class]:
                    if checks_info[check_class]['default']:
                        # Filter out params for Check with fixed values
                        param_defs = check_param_info['PARAM_DEFS']
                        param_vals = {}
                        for param in param_defs:
                            if param_defs[param]['value']:
                                param_vals[param] = param_defs[param]['value']
                        check_vars = CheckVars(probe_to_add, check_class,
                                               param_vals)
                        checks_to_add.append(check_vars)

    result = run_test_resource(resource_to_add)

    run_to_add = Run(resource_to_add, result)

    DB.session.add(resource_to_add)
    if probe_to_add:
        DB.session.add(probe_to_add)
    for check_to_add in checks_to_add:
        DB.session.add(check_to_add)
    DB.session.add(run_to_add)

    try:
        DB.session.commit()
        msg = gettext('Service registered')
        flash('%s (%s, %s)' % (msg, resource_type, url), 'success')
    except Exception as err:
        DB.session.rollback()
        flash(str(err), 'danger')
        return redirect(url_for('home', lang=g.current_lang))
    else:
        return edit_resource(resource_to_add.identifier)
Exemplo n.º 18
0
                print('Testing %s %s' %
                      (resource.resource_type, resource.url))

                if not resource.active:
                    print('Resource is not active. Skipping')
                    continue

                # Get the status of the last run,
                # assume success if there is none
                last_run_success = True
                last_run = resource.last_run
                if last_run:
                    last_run_success = last_run.success

                # Run test
                result = run_test_resource(resource)

                run1 = Run(resource, result)

                print('Adding Run: success=%s, response_time=%ss\n'
                      % (str(run1.success), run1.response_time))

                DB.session.add(run1)

                # commit or rollback each run to avoid long-lived transactions
                # see https://github.com/geopython/GeoHealthCheck/issues/14
                db_commit()

                if APP.config['GHC_NOTIFICATIONS']:
                    # Attempt notification
                    try: