コード例 #1
0
 def read(self, request, network_id=None):
     """
     If the network_id is specified returns network details,
     otherwise returns networks list.
     
     Method: GET
     
     Request parematers:
         * network_id (optional) - network which details we want
         * get_hosts (optional) - if 'true' and network_id is
           specified, then list of hosts in the network is returned
         * order_by (optional) - if network_id is not specified
           then networks list will be sorted according to this
           parameter; the allowed values are:
             ** name - order by name
             ** last_event - order by occurance of last event
     
     Network details response:
         * network_id
         * network_name - name of the network
         * network_description - description of the network
         * hosts (optional)
             ** id - host identifier
             ** name - host name
         
     Networks list reponse:
         * networks
             ** id - network identifier
             ** name - network name
     """ 
     
     if not network_id:
         networks = Network.objects.filter(user=request.user)
         if not networks:
             return api_error(_('The networks list is empty'))
         
         order_by = request.GET.get('order_by', 'name')
         if order_by == 'name':
             networks = networks.order_by('name')
         elif order_by == 'latest_event':
             networks = sorted(networks, key=lambda net: net.latest_event())
         
         response = {
             'networks': [net.api_list() for net in networks]
         }
         return api_response(response)
     
     try:
         network = Network.objects.get(pk=network_id, user=request.user)
     except Network.DoesNotExist:
         return api_error(_('Network does not exist'))
     
     response = network.api_detail()
     
     get_hosts = request.GET.get('get_hosts', 'true')
     if get_hosts.lower() == 'true':
         response['hosts'] = [host.api_list() for host in network.hosts()]
         
     return api_response(response)
コード例 #2
0
 def read(self, request, host_id=None):
     """
     Returns host details if host_id is specified, otherwise returns
     list of hosts.
     
     Method: GET
     
     Request parameters:
         * host_id (optional) - if specified, host details are returned
         * order_by (optional) - if host_id is not specified, order
           hosts list according to this parameter; allowed values are:
             ** name - order by name
             ** last_event - order by occurance of last event
         * limit - maximum number of hosts on a list
             
     Host details response:
         * host_id
         * host_name
         * host_description
         * ipv4 - IPv4 address of the host
         * ipv6 - IPv6 address of the host
         * events (optional) - list of events for the host
             ** id - event identifier
             ** message - event message
             
     Hosts list response:
         * hosts
             ** id - host identifier
             ** name - host name
     """
     
     if not host_id:
         hosts = Host.objects.filter(user=request.user)
         if not hosts:
             return api_error(_('The hosts list is empty'))
         
         order_by = request.GET.get('order_by', 'name')
         if order_by == 'name':
             hosts = hosts.order_by('name')
         elif order_by == 'latest_event':
             hosts = sorted(hosts, key=lambda host: host.latest_event())
             
         limit = request.GET.get('limit')
         if limit:
             hosts = hosts[:limit]
         
         response = {
             'hosts': [host.api_list() for host in hosts]
         }
         return api_response(response)
     
     try:
         host = Host.objects.get(pk=host_id, user=request.user)
     except Host.DoesNotExist:
         return api_error(_('Host does not exist'))
     
     return api_response(host.api_detail())
コード例 #3
0
    def read(self, request, network_id=None):
        """
        If the network_id is specified returns network details,
        otherwise returns networks list.
        
        Method: GET
        
        Request parematers:
            * network_id (optional) - network which details we want
            * get_hosts (optional) - if 'true' and network_id is
              specified, then list of hosts in the network is returned
            * order_by (optional) - if network_id is not specified
              then networks list will be sorted according to this
              parameter; the allowed values are:
                ** name - order by name
                ** last_event - order by occurance of last event
        
        Network details response:
            * network_id
            * network_name - name of the network
            * network_description - description of the network
            * hosts (optional)
                ** id - host identifier
                ** name - host name
            
        Networks list reponse:
            * networks
                ** id - network identifier
                ** name - network name
        """

        if not network_id:
            networks = Network.objects.filter(user=request.user)
            if not networks:
                return api_error(_('The networks list is empty'))

            order_by = request.GET.get('order_by', 'name')
            if order_by == 'name':
                networks = networks.order_by('name')
            elif order_by == 'latest_event':
                networks = sorted(networks, key=lambda net: net.latest_event())

            response = {'networks': [net.api_list() for net in networks]}
            return api_response(response)

        try:
            network = Network.objects.get(pk=network_id, user=request.user)
        except Network.DoesNotExist:
            return api_error(_('Network does not exist'))

        response = network.api_detail()

        get_hosts = request.GET.get('get_hosts', 'true')
        if get_hosts.lower() == 'true':
            response['hosts'] = [host.api_list() for host in network.hosts()]

        return api_response(response)
コード例 #4
0
    def read(self, request, host_id=None):
        """
        Returns host details if host_id is specified, otherwise returns
        list of hosts.
        
        Method: GET
        
        Request parameters:
            * host_id (optional) - if specified, host details are returned
            * order_by (optional) - if host_id is not specified, order
              hosts list according to this parameter; allowed values are:
                ** name - order by name
                ** last_event - order by occurance of last event
            * limit - maximum number of hosts on a list
                
        Host details response:
            * host_id
            * host_name
            * host_description
            * ipv4 - IPv4 address of the host
            * ipv6 - IPv6 address of the host
            * events (optional) - list of events for the host
                ** id - event identifier
                ** message - event message
                
        Hosts list response:
            * hosts
                ** id - host identifier
                ** name - host name
        """

        if not host_id:
            hosts = Host.objects.filter(user=request.user)
            if not hosts:
                return api_error(_('The hosts list is empty'))

            order_by = request.GET.get('order_by', 'name')
            if order_by == 'name':
                hosts = hosts.order_by('name')
            elif order_by == 'latest_event':
                hosts = sorted(hosts, key=lambda host: host.latest_event())

            limit = request.GET.get('limit')
            if limit:
                hosts = hosts[:limit]

            response = {'hosts': [host.api_list() for host in hosts]}
            return api_response(response)

        try:
            host = Host.objects.get(pk=host_id, user=request.user)
        except Host.DoesNotExist:
            return api_error(_('Host does not exist'))

        return api_response(host.api_detail())
コード例 #5
0
 def read(self, request, event_id=None):
     """
     The part of the public API. If the event_id parameter is specified,
     returns event details, otherwise returns events list ordered by timestamp.
     In the second case, events may be filtered by source host or
     timestamp and their number may be limited. 
     
     Method: GET
     
     Request parameters:
         * source_host - identifier of a source host
         * time_from - include only those events which timestamp is greater
           or equal than this value
         * time_to - include only those events which timestamp if less than
           this value
         * limit - maximal number of events on a list
     
     Response for events list:
         * events - list of events
             ** id - event identifier
             ** message - event message
             
     Response for event details:
         * event_id
         * description - event message
         * description - event short message
         * timestamp - event timestamp
         * event_type - type of event 
         * source_host_id - identifier of source host
         * module_id - identifier of monitoring module
         * module_fields - fields defined by monitoring module
     """
     if not event_id:
         events = Event.objects.all().order_by('-timestamp')
         if not events:
             return api_error(_('The events list is empty'))
         
         source_host = request.GET.get('source_host')
         if source_host:
             events = events.filter(source_host__pk=source_host)
             
         time_from = request.GET.get('time_from')
         time_to = request.GET.get('time_to')
         if time_from:
             time_from = datetime.datetime.fromtimestamp(float(time_from))
             events = events.filter(timestamp__gte=time_from)
         if time_to:
             time_to = datetime.datetime.fromtimestamp(float(time_to))
             events = events.filter(timestamp__lt=time_to)
             
         # because of limited JOINs, we cannot use events.filter(source_host__user=request.user)
         events = filter(lambda event: event.user == request.user, events)
         
         limit = request.GET.get('limit')
         if limit and limit > 0:
             events = events[:limit]
         
         response = {
             'events': [event.api_list() for event in events]
         }
         return api_response(response)
     
     try:
         event = Event.objects.get(pk=event_id)
     except Event.DoesNotExist:
         return api_error(_('Event does not exist'))
     
     if event.source_host.user != request.user:
         return api_error(_('Event does not exist'))
     
     return api_response(event.api_detail())
コード例 #6
0
 def create(self, request):
     """
     Receives one or more notifications and saves them to the database.
     This method is a part of private API.
     
     Method: POST
     URL: /api/event/report/
     
     Case 1: Reporting single event (notification)
     ---------------------------------------------
     
     Request parameters:
         * description - message describing the event
         * short_description - shorter message, e.g. to use in list
         * timestamp - when the event occurred
         * event_type - type of the event which should also describe
           its importance
         * protocol - network protocol related to the event
         * hostname - name of the source host
         * source_host_ipv4, source_host_ipv6 - IPv4 and IPv6
           addresses of the source host
         * fields_class - monitoring module identifier
     
     Any additional data provided with the event will be serialized and
     saved together with fields described above.
           
     Response:
         * status - **ok** or **error**
         * message - details of the result
         
     Case 2: Reporting multiple events at once
     -----------------------------------------
     
     Request parameters:
         * events - list of events serialized with JSON
         
     Response:
         * status - **ok** or **error**
         * message - details of the result
     
     """
     if request.POST.get('events'):
         try:
             events = json.loads(request.POST.get('events', ''))
         except ValueError:
             return api_error(_('No events could be read'))
         
         for event_dict in events:
             try:
                 event_data = get_event_data(request, event_dict)
             except EventParseError, e:
                 message = str(e)
                 return api_error(_(message))
             event = Event(**event_data)
             event.save()
             
             if event.event_type.notify:
                 notifier.manager.add(event.short_message, event.message,
                                      event.user(), event)
         
         return api_ok(_('Events reported successfully'))
コード例 #7
0
    def read(self, request, event_id=None):
        """
        The part of the public API. If the event_id parameter is specified,
        returns event details, otherwise returns events list ordered by timestamp.
        In the second case, events may be filtered by source host or
        timestamp and their number may be limited. 
        
        Method: GET
        
        Request parameters:
            * source_host - identifier of a source host
            * time_from - include only those events which timestamp is greater
              or equal than this value
            * time_to - include only those events which timestamp if less than
              this value
            * limit - maximal number of events on a list
        
        Response for events list:
            * events - list of events
                ** id - event identifier
                ** message - event message
                
        Response for event details:
            * event_id
            * description - event message
            * description - event short message
            * timestamp - event timestamp
            * event_type - type of event 
            * source_host_id - identifier of source host
            * module_id - identifier of monitoring module
            * module_fields - fields defined by monitoring module
        """
        if not event_id:
            events = Event.objects.all().order_by('-timestamp')
            if not events:
                return api_error(_('The events list is empty'))

            source_host = request.GET.get('source_host')
            if source_host:
                events = events.filter(source_host__pk=source_host)

            time_from = request.GET.get('time_from')
            time_to = request.GET.get('time_to')
            if time_from:
                time_from = datetime.datetime.fromtimestamp(float(time_from))
                events = events.filter(timestamp__gte=time_from)
            if time_to:
                time_to = datetime.datetime.fromtimestamp(float(time_to))
                events = events.filter(timestamp__lt=time_to)

            # because of limited JOINs, we cannot use events.filter(source_host__user=request.user)
            events = filter(lambda event: event.user == request.user, events)

            limit = request.GET.get('limit')
            if limit and limit > 0:
                events = events[:limit]

            response = {'events': [event.api_list() for event in events]}
            return api_response(response)

        try:
            event = Event.objects.get(pk=event_id)
        except Event.DoesNotExist:
            return api_error(_('Event does not exist'))

        if event.source_host.user != request.user:
            return api_error(_('Event does not exist'))

        return api_response(event.api_detail())
コード例 #8
0
    def create(self, request):
        """
        Receives one or more notifications and saves them to the database.
        This method is a part of private API.
        
        Method: POST
        URL: /api/event/report/
        
        Case 1: Reporting single event (notification)
        ---------------------------------------------
        
        Request parameters:
            * description - message describing the event
            * short_description - shorter message, e.g. to use in list
            * timestamp - when the event occurred
            * event_type - type of the event which should also describe
              its importance
            * protocol - network protocol related to the event
            * hostname - name of the source host
            * source_host_ipv4, source_host_ipv6 - IPv4 and IPv6
              addresses of the source host
            * fields_class - monitoring module identifier
        
        Any additional data provided with the event will be serialized and
        saved together with fields described above.
              
        Response:
            * status - **ok** or **error**
            * message - details of the result
            
        Case 2: Reporting multiple events at once
        -----------------------------------------
        
        Request parameters:
            * events - list of events serialized with JSON
            
        Response:
            * status - **ok** or **error**
            * message - details of the result
        
        """
        if request.POST.get('events'):
            try:
                events = json.loads(request.POST.get('events', ''))
            except ValueError:
                return api_error(_('No events could be read'))

            for event_dict in events:
                try:
                    event_data = get_event_data(request, event_dict)
                except EventParseError, e:
                    message = str(e)
                    return api_error(_(message))
                event = Event(**event_data)
                event.save()

                if event.event_type.notify:
                    notifier.manager.add(event.short_message, event.message,
                                         event.user(), event)

            return api_ok(_('Events reported successfully'))
コード例 #9
0
class EventHandler(BaseHandler):
    """
    Event handler is responsible for receiving notifications (events)
    and saving them to the Network Administrator database. Its second
    task is to return events list or details of event.
    
    Every event has its source host which is the host from where it
    comes. In the notification the source host is identified by pair
    of IPv4 and IPv6 addresses, where the second one is optional so far.
    So to relate the upcoming event with the corresponding host in
    database we have to search for the host which has the same
    addresses like the source host in the notification. 
    """
    allowed_methods = ('POST', 'GET')

    def create(self, request):
        """
        Receives one or more notifications and saves them to the database.
        This method is a part of private API.
        
        Method: POST
        URL: /api/event/report/
        
        Case 1: Reporting single event (notification)
        ---------------------------------------------
        
        Request parameters:
            * description - message describing the event
            * short_description - shorter message, e.g. to use in list
            * timestamp - when the event occurred
            * event_type - type of the event which should also describe
              its importance
            * protocol - network protocol related to the event
            * hostname - name of the source host
            * source_host_ipv4, source_host_ipv6 - IPv4 and IPv6
              addresses of the source host
            * fields_class - monitoring module identifier
        
        Any additional data provided with the event will be serialized and
        saved together with fields described above.
              
        Response:
            * status - **ok** or **error**
            * message - details of the result
            
        Case 2: Reporting multiple events at once
        -----------------------------------------
        
        Request parameters:
            * events - list of events serialized with JSON
            
        Response:
            * status - **ok** or **error**
            * message - details of the result
        
        """
        if request.POST.get('events'):
            try:
                events = json.loads(request.POST.get('events', ''))
            except ValueError:
                return api_error(_('No events could be read'))

            for event_dict in events:
                try:
                    event_data = get_event_data(request, event_dict)
                except EventParseError, e:
                    message = str(e)
                    return api_error(_(message))
                event = Event(**event_data)
                event.save()

                if event.event_type.notify:
                    notifier.manager.add(event.short_message, event.message,
                                         event.user(), event)

            return api_ok(_('Events reported successfully'))

        try:
            event_data = get_event_data(request, request.POST)
        except EventParseError, e:
            message = str(e)
            return api_error(_(message))