go_jolokia.go

// Maintainer Swarvanu Sengupta <swarvanusg@gmail.com>.
//
// Use of this source code is governed by an MIT-style
// license that can be found in the LICENSE file.
package go_jolokia

import (
	"bytes"
	"encoding/json"
	"fmt"
	"io/ioutil"
	"net/http"
	"sort"
	"strings"
)

/* Jolokia Client properties connecting a Jolokia agent */
type JolokiaClient struct {
	// The url of the jolokia agent
	url string
	// The user name for the jolokia agent
	user string
	// The password for the jolokia agent (required if user is specified)
	pass string
	// The target host in a jolokia proxy setup
	target string
	// The target host jmx username
	targetUser string
	// The target host jmx password (required if target user is specified)
	targetPass string
}

/* Jolokia Request properties */
type JolokiaRequest struct {
	// The type of the operation (LIST, READ)
	opType string
	// The domain (mbean name)
	mbean string
	// The bean selection key
	properties []string
	// The attribute name (property name)
	attribute string
	// The path to access node of json tree
	path string
}

/* Jolokia Response for Generic request */
type JolokiaResponse struct {
	// Status of the request
	Status uint32
	// Timestamp value
	Timestamp uint32
	// Request
	Request map[string]interface{}
	// Result value
	Value map[string]interface{}
	// Error
	Error string
}

/* Jolokia Response for Read request */
type JolokiaReadResponse struct {
	// Status of the request
	Status uint32
	// Timestamp value
	Timestamp uint32
	// Request
	Request map[string]interface{}
	// Result value
	Value interface{}
	// Error
	Error string
}

type Target struct {
	Url      string `json:"url"`
	Password string `json:"password"`
	User     string `json:"user"`
}

/* The wrapper structure for json request */
type RequestData struct {
	Type  string `json:"type"`
	Mbean string `json:"mbean"`
	Path  string `json:"path"`
	//Attribute string `json:"attribute"`  -- Attribute get added manually
	Target `json:"target"`
}

/* The wrapper structure for an EXEC json request */
type ExecRequestData struct {
	Type      string      `json:"type"`
	Mbean     string      `json:"mbean"`
	Operation string      `json:"operation"`
	Arguments interface{} `json:"arguments"`
	Target    `json:"target"`
}

/* ENUM to be used */
const (
	// READ for read operation
	READ = "READ"
	// LIST for list operation
	LIST = "LIST"
	// EXEC for exec operation
	EXEC = "EXEC"
)

/* Http request param */
type httpRequest struct {
	Url  string
	Body []byte
}

/* Http response param */
type httpResponse struct {
	Status     string
	StatusCode int
	Body       []byte
}

func performPostRequest(request *httpRequest, user, pass string) (*httpResponse, error) {

	var url = request.Url
	var req *http.Request
	var newReqErr error

	if request.Body != nil {
		var jsonStr = request.Body
		req, newReqErr = http.NewRequest("POST", url, bytes.NewBuffer(jsonStr))
		if newReqErr != nil {
			return nil, newReqErr
		}
		req.Header.Set("Content-Type", "application/json")
	} else {
		req, newReqErr = http.NewRequest("POST", url, nil)
		if newReqErr != nil {
			return nil, newReqErr
		}
	}

	if user != "" || pass != "" {
		req.SetBasicAuth(user, pass)
	}

	client := &http.Client{}

	resp, reqErr := client.Do(req)
	if reqErr != nil {
		fmt.Printf("Request Could not be send")
		return nil, reqErr
	}
	defer resp.Body.Close()

	body, _ := ioutil.ReadAll(resp.Body)

	response := &httpResponse{}
	response.Status = resp.Status
	response.StatusCode = resp.StatusCode
	response.Body = body

	return response, nil
}

/* Internal function used to make the Json request string using the structure */
func wrapRequestData(opType, mbeanName string, properties []string, path, attribute, targetUrl, targerUser, targetPass string) ([]byte, error) {
	mbean := buildMbeanName(mbeanName, properties)
	target := buildTargetUrl(targetUrl)
	requestData := RequestData{Type: opType, Mbean: mbean, Path: path, Target: Target{Url: target, Password: targetPass, User: targerUser}}
	// Marshal to the json string
	jsbyte, err := json.Marshal(requestData)
	if err != nil {
		return nil, err
	}
	jsString := string(jsbyte)
	if attribute != "" {
		last := len(jsString)
		jsString = jsString[:last-1]
		attributeString := "\"attribute\":\"" + attribute + "\""
		jsString = jsString + ", " + attributeString + "}"
	}
	jsbyte = []byte(jsString)
	return jsbyte, nil
}

func wrapExecData(mbeanName string, properties []string, operation string, arguments interface{}, targetUrl, targerUser, targetPass string) ([]byte, error) {
	mbean := buildMbeanName(mbeanName, properties)
	target := buildTargetUrl(targetUrl)
	requestData := ExecRequestData{Type: EXEC, Mbean: mbean, Operation: operation, Arguments: arguments, Target: Target{Url: target, Password: targetPass, User: targerUser}}
	jsbyte, err := json.Marshal(requestData)
	if err != nil {
		return nil, err
	}
	return jsbyte, nil
}

func buildMbeanName(mbeanName string, properties []string) string {
	mbean := mbeanName
	if properties != nil {
		for pos := range properties {
			mbean = mbean + ":" + properties[pos]
		}
	}
	return mbean
}

func buildTargetUrl(targetUrl string) string {
	target := ""
	if targetUrl != "" {
		if strings.HasPrefix(targetUrl, "service:jmx:") {
			target = targetUrl
		} else {
			target = "service:jmx:rmi:///jndi/rmi://" + targetUrl + "/jmxrmi"
		}
	}
	return target
}

/* Creates a Jolokia Client for a specific url e.g. "http://127.0.0.1:8080/jolokia" */
func NewJolokiaClient(jolokiaUrl string) *JolokiaClient {
	jolokiaClient := &JolokiaClient{url: jolokiaUrl}
	return jolokiaClient
}

/* Set access credential to Jolokia client */
func (jolokiaClient *JolokiaClient) SetCredential(userName string, pass string) {
	jolokiaClient.user = userName
	jolokiaClient.pass = pass
}

/* Set target host when jolokia agent working in proxy architecture e.g. "10.0.1.96:7911"
(see: https://jolokia.org/reference/html/proxy.html) */
func (jolokiaClient *JolokiaClient) SetTarget(targetHost string) {
	jolokiaClient.target = targetHost
}

/* Set target host access credential to Jolokia client */
func (jolokiaClient *JolokiaClient) SetTargetCredential(userName string, pass string) {
	jolokiaClient.targetUser = userName
	jolokiaClient.targetPass = pass
}

/* Creates a new Jolokia request */
func NewJolokiaRequest(requestType, mbeanName string, properties []string, attribute string) *JolokiaRequest {
	jolokiaRequest := &JolokiaRequest{opType: requestType, mbean: mbeanName, attribute: attribute}
	if properties != nil {
		jolokiaRequest.properties = make([]string, len(properties))
		for pos := range properties {
			jolokiaRequest.properties[pos] = properties[pos]
		}
	}
	return jolokiaRequest
}

/* Set path to access tree node of json response */
func (jolokiaRequest *JolokiaRequest) SetPath(path string) {
	jolokiaRequest.path = path
}

/* Executes a jolokia request using a jolokia client and return response */
func (jolokiaClient *JolokiaClient) executePostRequestCallback(pattern string, wrapper func() ([]byte, error)) (string, error) {
	jsonReq, wrapError := wrapper()
	if wrapError != nil {
		return "", fmt.Errorf("JSON Wrap Failed: %v", wrapError)
	}
	requestUrl := jolokiaClient.url
	if pattern != "" {
		requestUrl = requestUrl + "/?" + pattern
	}
	request := &httpRequest{Url: requestUrl, Body: jsonReq}
	response, httpErr := performPostRequest(request, jolokiaClient.user, jolokiaClient.pass)
	if httpErr != nil {
		return "", fmt.Errorf("HTTP Request Failed: %v", httpErr)
	}
	if response.StatusCode != 200 {
		return "", fmt.Errorf("HTTP Request Error Code: %v", response.Status)
	}
	jolokiaResponse := string(response.Body)
	return jolokiaResponse, nil
}

/* Executes a jolokia request using a jolokia client and return response */
func (jolokiaClient *JolokiaClient) executePostRequest(jolokiaRequest *JolokiaRequest, pattern string) (string, error) {
	return jolokiaClient.executePostRequestCallback(pattern, func() ([]byte, error) {
		return wrapRequestData(jolokiaRequest.opType, jolokiaRequest.mbean, jolokiaRequest.properties, jolokiaRequest.path, jolokiaRequest.attribute, jolokiaClient.target, jolokiaClient.targetUser, jolokiaClient.targetPass)
	})
}

/* Executes a jolokia operation execution request using a jolokia client and return response */
func (jolokiaClient *JolokiaClient) ExecuteOperation(mBean, operation string, arguments interface{}, pattern string) (*JolokiaReadResponse, error) {
	resp, requestErr := jolokiaClient.executePostRequestCallback(pattern, func() ([]byte, error) {
		return wrapExecData(mBean, nil, operation, arguments, jolokiaClient.target, jolokiaClient.targetUser, jolokiaClient.targetPass)
	})
	if requestErr != nil {
		return nil, requestErr
	}
	var respJ JolokiaReadResponse
	decodeErr := json.Unmarshal([]byte(resp), &respJ)
	if decodeErr != nil {
		return nil, fmt.Errorf("Failed to decode Jolokia resp : %v", decodeErr)
	}
	return &respJ, nil
}

/* Executes a jolokia request using a jolokia client and return response */
func (jolokiaClient *JolokiaClient) ExecuteRequest(jolokiaRequest *JolokiaRequest, pattern string) (*JolokiaResponse, error) {
	resp, requestErr := jolokiaClient.executePostRequest(jolokiaRequest, pattern)
	if requestErr != nil {
		return nil, requestErr
	}
	var respJ JolokiaResponse
	decodeErr := json.Unmarshal([]byte(resp), &respJ)
	if decodeErr != nil {
		return nil, fmt.Errorf("Failed to decode Jolokia resp : %v", decodeErr)
	}
	return &respJ, nil
}

/* Executes a jolokia read request using a jolokia client and return response */
func (jolokiaClient *JolokiaClient) ExecuteReadRequest(jolokiaRequest *JolokiaRequest) (*JolokiaReadResponse, error) {
	resp, requestErr := jolokiaClient.executePostRequest(jolokiaRequest, "")
	if requestErr != nil {
		return nil, requestErr
	}
	var respJ JolokiaReadResponse
	decodeErr := json.Unmarshal([]byte(resp), &respJ)
	if decodeErr != nil {
		return nil, fmt.Errorf("Failed to decode Jolokia resp : %v", decodeErr)
	}
	return &respJ, nil
}

/* List the domains using a jolokia client and return response */
func (jolokiaClient *JolokiaClient) ListDomains() ([]string, error) {
	request := NewJolokiaRequest(LIST, "", nil, "")
	resp, requestErr := jolokiaClient.ExecuteRequest(request, "maxDepth=1")
	if requestErr != nil {
		return nil, requestErr
	}
	ret := make([]string, 0, len(resp.Value))
	for key, _ := range resp.Value {
		ret = append(ret, key)
	}
	sort.Strings(ret)
	return ret, nil
}

/* List the beans of a specific domain using a jolokia client and return response */
func (jolokiaClient *JolokiaClient) ListBeans(domain string) ([]string, error) {
	request := NewJolokiaRequest(LIST, "", nil, "")
	request.SetPath(domain)
	resp, requestErr := jolokiaClient.ExecuteRequest(request, "maxDepth=1")
	if requestErr != nil {
		return nil, requestErr
	}
	ret := make([]string, 0, len(resp.Value))
	for key, _ := range resp.Value {
		ret = append(ret, key)
	}
	sort.Strings(ret)
	return ret, nil
}

/* List the properties of a specific bean and domain using a jolokia client and return response */
func (jolokiaClient *JolokiaClient) ListProperties(domain string, properties []string) ([]string, error) {
	request := NewJolokiaRequest(READ, domain, properties, "")
	resp, requestErr := jolokiaClient.ExecuteRequest(request, "")
	if requestErr != nil {
		return nil, requestErr
	}
	ret := make([]string, 0, len(resp.Value))
	for key, _ := range resp.Value {
		ret = append(ret, key)
	}
	sort.Strings(ret)
	return ret, nil
}

/* Get a attribute value of a specific property of an bean and a domain using a jolokia client */
func (jolokiaClient *JolokiaClient) GetAttr(domain string, properties []string, attribute string) (interface{}, error) {
	request := NewJolokiaRequest(READ, domain, properties, attribute)
	resp, requestErr := jolokiaClient.ExecuteReadRequest(request)
	if requestErr != nil {
		return nil, requestErr
	}
	return resp.Value, nil
}