Configuring webhook by using the mmhealth command

Example 1: Setting up a webhook server by using Rust

#![allow(non_camel_case_types)]
#![allow(non_snake_case)]

use actix_web::{web, App, HttpResponse, HttpServer};
use serde::Deserialize;
use std::collections::HashMap;
use std::env;

#[derive(Deserialize)]
struct HealthEvent {
  cause: String,
  code: String,
  component: String,
  container_restart: bool,
  container_unready: bool,
  description: String,
  entity_name: String,
  entity_type: String,
  event: String,
  event_type: String,
  ftdc_scope: String,
  identifier: String,
  internalComponent: String,
  is_resolvable: bool,
  message: String,
  node: String,
  priority: u64,
  remedy: Option<String>,
  requireUnique: bool,
  scope: String,
  severity: String,
  state: String,
  time: String,
  TZONE: String,
  user_action: String,
}

#[derive(Deserialize)]
struct PostMsg {
  version: String,
  reportingController: String,
  reportingInstance: String,
  events: Vec<HealthEvent>,
}

fn post_handler(events: web::Json<PostMsg>) -> HttpResponse {
  let mut counts: HashMap<String, u64> = HashMap::new();
  for e in &events.events {
    *counts.entry(e.severity.clone()).or_insert(0) += 1;
  }
  println!("{}: {:?}", events.reportingInstance, counts);
  HttpResponse::Ok().content_type("text/html").body("OK")
}

pub fn main() {
  let args: Vec<String> = env::args().collect();
  if args.len() != 2 {
    println!("Usage: {} IPAddr:Port", args[0]);
    return;
  }

  println!("Listening on {}", args[1]);
  HttpServer::new(|| App::new().route("/webhook", web::post().to(post_handler)))
    .bind(&args[1])
    .expect("error binding server to IP address:port")
    .run()
    .expect("error running server");
}

Example 2: Setting up a webhook server by using GO

import (
       "encoding/json"
       "fmt"
       "log"
       "net/http"
       "os"
       "time"
)

type healthEvent struct {
      Cause string `json:"cause"`
      Code string `json:"code"`
      Component string `json:"component"`
      ContainerRestart bool `json:"container_restart"`
      ContainerUnready bool `json:"container_unready"`
      Description string `json:"description"`
      EntityName string `json:"entity_name"`
      EntityType string `json:"entity_type"`
      Event string `json:"event"`
      EventType string `json:"event_type"`
      FTDCScope string `json:"ftdc_scope"`
      Identifier string `json:"identifier"`
      InternalComponent string `json:"internalComponent"`
      IsResolvable bool `json:"is_resolvable"`
      Message string `json:"message"`
      Node string `json:"node"`
      Priority int `json:"priority"`
      Remedy string `json:"remedy"`
      RequireUnique bool `json:"requireUnique"`
      Scope string `json:"scope"`
      Severity string `json:"severity"`
      State string `json:"state"`
      Time time.Time `json:"time"`
      TZone string `json:"TZONE"`
      UserAction string `json:"user_action"`
}

type postMsg struct {
      Version string `json:"version"`
      ReportingController string `json:"reportingController"`
      ReportingInstance string `json:"reportingInstance"`
      Events []healthEvent `json:"events"`
}

func webhook(w http.ResponseWriter, r *http.Request) {
       decoder := json.NewDecoder(r.Body)
       var data postMsg
       if err := decoder.Decode(&data); err != nil {
              fmt.Println(err)
              return
       }
       counts := make(map[string]int)
       for _, event := range data.Events {
             _, matched := counts[event.Severity]
             switch matched {
             case true:
                   counts[event.Severity] += 1
             case false:
                   counts[event.Severity] = 1
             }
       }
       fmt.Println(data.ReportingInstance, ":", counts)
}

func main() {
       http.HandleFunc("/webhook", webhook)

       if len(os.Args) != 2 {
              log.Fatal(fmt.Errorf("usage: %s IPAddr:Port", os.Args[0]))
       }
       fmt.Printf("Starting server listening on %s ...\n", os.Args[1])
       if err := http.ListenAndServe(os.Args[1], nil); err != nil {
              log.Fatal(err)
       }
}

The following example shows starting the GO program that is compiled to a binary named webhook. You must provide the IP address and port number the HTTP server can use.

[httpd-dev]# ./webhook 192.0.2.48:9000
Starting server listening on 192.0.2.48:9000 …

Example 3: Setting up a webhook server by using Python

#!/usr/bin/env python3
import argparse
from collections import Counter
import cherrypy
import json

class DataView(object):
       exposed = True
       @cherrypy.tools.accept(media='application/json')
       def POST(self):
              rawData = cherrypy.request.body.read(int(cherrypy.request.headers['Content-Length'])) 
              b = json.loads(rawData)
              eventCounts = Counter([e['severity'] for e in b['events']]) 
              print(f"{b['reportingInstance']}: {json.dumps(eventCounts)}")
              if dump_json: print(json.dumps(b, indent=4))
              return "OK"

if __name__ == '__main__':
      parser = argparse.ArgumentParser()
      parser.add_argument('--json', action='store_true')
      parser.add_argument('IP', type=str)
      parser.add_argument('PORT', type=int)
      args = parser.parse_args()  
      conf = {
             '/': {'request.dispatch': cherrypy.dispatch.MethodDispatcher(),}
      }
      dump_json = args.json  
      cherrypy.server.socket_host = args.IP
      cherrypy.server.socket_port = args.PORT
      cherrypy.quickstart(DataView(), '/webhook/', conf)