backend/src/appenlight/views/integrations/__init__.py

# -*- coding: utf-8 -*-

# Copyright 2010 - 2017 RhodeCode GmbH and the AppEnlight project authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#   http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

import logging
import random
from datetime import datetime

from pyramid.httpexceptions import HTTPFound
from pyramid.view import view_config

from appenlight.models import DBSession
from appenlight.models.event import Event
from appenlight.models.integrations import IntegrationBase
from appenlight.models.alert_channel import AlertChannel
from appenlight.models.report_group import ReportGroup
from appenlight.models.services.alert_channel import AlertChannelService
from appenlight.lib import generate_random_string

log = logging.getLogger(__name__)

dummy_report = ReportGroup()
dummy_report.error = (
    "ProtocolError: ('Connection aborted.', " "error(111, 'Connection refused'))"
)
dummy_report.total_reports = 4
dummy_report.occurences = 4

dummy_report2 = ReportGroup()
dummy_report2.error = (
    "UnboundLocalError: local variable " "'hits' referenced before assignment"
)
dummy_report2.total_reports = 8
dummy_report2.occurences = 8

dummy_reports = [(4, dummy_report), (8, dummy_report2)]


class IntegrationView(object):
    """
    Base class for 3rd party integrations setup views
    """

    def __init__(self, request):
        self.request = request
        resource = self.request.context.resource
        integration_name = request.matchdict["integration"]
        integration = IntegrationBase.by_app_id_and_integration_name(
            resource.resource_id, integration_name
        )
        if integration:
            dict_config = integration.config
        else:
            dict_config = {}
        self.integration = integration
        self.integration_config = dict_config

    @view_config(
        route_name="integrations_id",
        request_method="DELETE",
        renderer="json",
        permission="edit",
    )
    def remove_integration(self):
        if self.integration:
            DBSession.delete(self.integration)
            self.request.session.flash("Integration removed")
        return ""

    @view_config(
        route_name="integrations_id",
        request_method="POST",
        match_param=["action=test_report_notification"],
        renderer="json",
        permission="edit",
    )
    def test_report_notification(self):
        if not self.integration:
            self.request.session.flash("Integration needs to be configured", "warning")
            return False

        resource = self.integration.resource

        channel = AlertChannelService.by_integration_id(self.integration.id)

        if random.random() < 0.5:
            confirmed_reports = dummy_reports
        else:
            confirmed_reports = [random.choice(dummy_reports)]

        channel.notify_reports(
            resource=resource,
            user=self.request.user,
            request=self.request,
            since_when=datetime.utcnow(),
            reports=confirmed_reports,
        )
        self.request.session.flash("Report notification sent")
        return True

    @view_config(
        route_name="integrations_id",
        request_method="POST",
        match_param=["action=test_error_alert"],
        renderer="json",
        permission="edit",
    )
    def test_error_alert(self):
        if not self.integration:
            self.request.session.flash("Integration needs to be configured", "warning")
            return False

        resource = self.integration.resource

        event_name = random.choice(("error_report_alert", "slow_report_alert"))
        new_event = Event(
            resource_id=resource.resource_id,
            event_type=Event.types[event_name],
            start_date=datetime.utcnow(),
            status=Event.statuses["active"],
            values={"reports": random.randint(11, 99), "threshold": 10},
        )

        channel = AlertChannelService.by_integration_id(self.integration.id)

        channel.notify_alert(
            resource=resource,
            event=new_event,
            user=self.request.user,
            request=self.request,
        )
        self.request.session.flash("Notification sent")
        return True

    @view_config(
        route_name="integrations_id",
        request_method="POST",
        match_param=["action=test_daily_digest"],
        renderer="json",
        permission="edit",
    )
    def test_daily_digest(self):
        if not self.integration:
            self.request.session.flash("Integration needs to be configured", "warning")
            return False

        resource = self.integration.resource
        channel = AlertChannelService.by_integration_id(self.integration.id)

        channel.send_digest(
            resource=resource,
            user=self.request.user,
            request=self.request,
            since_when=datetime.utcnow(),
            reports=dummy_reports,
        )
        self.request.session.flash("Notification sent")
        return True

    @view_config(
        route_name="integrations_id",
        request_method="POST",
        match_param=["action=test_uptime_alert"],
        renderer="json",
        permission="edit",
    )
    def test_uptime_alert(self):
        if not self.integration:
            self.request.session.flash("Integration needs to be configured", "warning")
            return False

        resource = self.integration.resource

        new_event = Event(
            resource_id=resource.resource_id,
            event_type=Event.types["uptime_alert"],
            start_date=datetime.utcnow(),
            status=Event.statuses["active"],
            values={"status_code": 500, "tries": 2, "response_time": 0},
        )

        channel = AlertChannelService.by_integration_id(self.integration.id)
        channel.notify_uptime_alert(
            resource=resource,
            event=new_event,
            user=self.request.user,
            request=self.request,
        )

        self.request.session.flash("Notification sent")
        return True

    @view_config(
        route_name="integrations_id",
        request_method="POST",
        match_param=["action=test_chart_alert"],
        renderer="json",
        permission="edit",
    )
    def test_chart_alert(self):
        if not self.integration:
            self.request.session.flash("Integration needs to be configured", "warning")
            return False

        resource = self.integration.resource

        chart_values = {
            "matched_rule": {"name": "Fraud attempt limit"},
            "matched_step_values": {
                "labels": {"0_1": {"human_label": "Attempts sum"}},
                "values": {"0_1": random.randint(11, 55), "key": "2015-12-16T15:49:00"},
            },
            "start_interval": datetime.utcnow(),
            "resource": 1,
            "chart_name": "Fraud attempts per day",
            "chart_uuid": "some_uuid",
            "step_size": 3600,
            "action_name": "Notify excessive fraud attempts",
        }

        new_event = Event(
            resource_id=resource.resource_id,
            event_type=Event.types["chart_alert"],
            status=Event.statuses["active"],
            values=chart_values,
            target_uuid="some_uuid",
            start_date=datetime.utcnow(),
        )

        channel = AlertChannelService.by_integration_id(self.integration.id)
        channel.notify_chart_alert(
            resource=resource,
            event=new_event,
            user=self.request.user,
            request=self.request,
        )

        self.request.session.flash("Notification sent")
        return True

    def create_missing_channel(self, resource, channel_name):
        """
        Recreates alert channel for the owner of integration
        """
        if self.integration:
            if not self.integration.channel:
                channel = AlertChannel()
                channel.channel_name = channel_name
                channel.channel_validated = True
                channel.channel_value = resource.resource_id
                channel.integration_id = self.integration.id
                security_code = generate_random_string(10)
                channel.channel_json_conf = {"security_code": security_code}
                resource.owner.alert_channels.append(channel)