404Forbiden

✏️ Editing: jboss.py

import agent_util
import logging
from agent_util import float
from urllib.parse import quote

logger = logging.getLogger(__name__)

def check_for_curl_installation():
    result = agent_util.which("curl")
    if result != "None":
        return True
    return False

def execute_query(config, query, data=None):
    if "username" in config:
        username = config["username"] + ":"
    else:
        username = ""
    if "password" in config and config["password"].strip():
        password = config["password"].strip() + "@"
    else:
        password = ""
    url = config["console_url"].replace("://", "://" + username + password)
    # JBoss API does not handle a double-/ well
    url.rstrip("/")

if check_for_curl_installation():
        queryType = "curl --digest --silent"
    else:
        queryType = "wget -qO-"

if data is not None:
        encoded_data = quote(data, safe="")
        query = query % (queryType, url, encoded_data)
    else:
        query = query % (queryType, url)

ret, output = agent_util.execute_command(query)
    return str(output)

class JBossPlugin(agent_util.Plugin):
    textkey = "jboss"
    label = "JBoss"

@classmethod
    def get_metadata(self, config):
        status = agent_util.SUPPORTED
        msg = None

# check for jboss configuration block
        if (
            "username" not in config
            or "console_url" not in config
            or "password" not in config
        ):
            self.log.info("jboss is not configured")
            status = agent_util.MISCONFIGURED
            msg = "jboss is not configured properly"
            return {}

# check if jboss is even installed or running - any response to server-state is enough to pass here
        query = '%s "%s/management?operation=attribute&name=server-state"'
        output = execute_query(config, query)
        if config.get("debug", False):
            self.log.debug("#####################################################")
            self.log.debug("Jboss command '%s' output:" % query)
            self.log.debug(str(output))
            self.log.debug("#####################################################")
        if output.strip() == "":
            self.log.info("jboss is not running or installed")
            status = agent_util.UNSUPPORTED
            msg = "jboss not found"
            return {}

source_options = []
        query = (
            '%s "%s/management/subsystem/datasources?read-resource'
            '&include-runtime=true&recursive&json.pretty"'
        )
        output = execute_query(config, query)
        if config.get("debug", False):
            self.log.debug("#####################################################")
            self.log.debug("Jboss command '%s' output:" % query)
            self.log.debug(str(output))
            self.log.debug("#####################################################")
        json_output = agent_util.json_loads(output)
        for children in json_output["data-source"]:
            if children not in source_options:
                source_options.append(children)

if status is agent_util.SUPPORTED and not source_options:
            status = agent_util.MISCONFIGURED
            msg = "No data-source found on JBoss server."

data = {
            "jdbc.prepared_statement_cache_access_count": {
                "label": "Prepared statement cache access",
                "options": source_options,
                "status": status,
                "error_message": msg,
            },
            "jdbc.prepared_statement_cache_add_count": {
                "label": "Prepared statement cache add",
                "options": source_options,
                "status": status,
                "error_message": msg,
            },
            "jdbc.prepared_statement_cache_current_size": {
                "label": "Prepared statement cache current size",
                "options": source_options,
                "status": status,
                "error_message": msg,
            },
            "jdbc.prepared_statement_cache_delete_count": {
                "label": "Prepared statement cache delete",
                "options": source_options,
                "status": status,
                "error_message": msg,
            },
            "jdbc.prepared_statement_cache_hit_count": {
                "label": "Prepared statement cache hit",
                "options": source_options,
                "status": status,
                "error_message": msg,
            },
            "jdbc.prepared_statement_cache_miss_count": {
                "label": "Prepared statement cache miss",
                "options": source_options,
                "status": status,
                "error_message": msg,
            },
            "pool.active_count": {
                "label": "Pool active count",
                "options": source_options,
                "status": status,
                "error_message": msg,
            },
            "pool.available_count": {
                "label": "Pool available count",
                "options": source_options,
                "status": status,
                "error_message": msg,
            },
            "pool.average_blocking_time": {
                "label": "Pool average blocking time",
                "options": source_options,
                "status": status,
                "error_message": msg,
            },
            "pool.average_creation_time": {
                "label": "Pool average creation time",
                "options": source_options,
                "status": status,
                "error_message": msg,
            },
            "pool.created_count": {
                "label": "Pools created",
                "options": source_options,
                "status": status,
                "error_message": msg,
            },
            "pool.destroyed_count": {
                "label": "Pools destroyed",
                "options": source_options,
                "status": status,
                "error_message": msg,
            },
            "pool.max_creation_time": {
                "label": "Pools max creation time",
                "options": source_options,
                "status": status,
                "error_message": msg,
            },
            "pool.max_used_count": {
                "label": "Pools max used count",
                "options": source_options,
                "status": status,
                "error_message": msg,
            },
            "pool.max_wait_time": {
                "label": "Pools max wait time",
                "options": source_options,
                "status": status,
                "error_message": msg,
            },
            "pool.timed_out": {
                "label": "Pools timed out",
                "options": source_options,
                "status": status,
                "error_message": msg,
            },
            "pool.total_blocking_time": {
                "label": "Pools total blocking time",
                "options": source_options,
                "status": status,
                "error_message": msg,
            },
            "pool.TotalCreationTime": {
                "label": "Pools total creation time",
                "options": source_options,
                "status": status,
                "error_message": msg,
            },
            "idle_timeout_minutes": {
                "label": "Time spend for idle pools to be timeout",
                "options": source_options,
                "status": status,
                "error_message": msg,
            },
            "jvm.heap.used": {
                "label": "Total heap memory used",
                "options": None,
                "status": status,
                "error_message": msg,
                "unit": "MB",
            },
            "jvm.heap.committed": {
                "label": "Total heap memory committed",
                "options": None,
                "status": status,
                "error_message": msg,
                "unit": "MB",
            },
            "jvm.nonheap.used": {
                "label": "Total non-heap memory used",
                "options": None,
                "status": status,
                "error_message": msg,
                "unit": "MB",
            },
            "jvm.nonheap.committed": {
                "label": "Total non-heap memory committed",
                "options": None,
                "status": status,
                "error_message": msg,
                "unit": "MB",
            },
            "jvm.threads.live": {
                "label": "Total number of live threads used",
                "options": None,
                "status": status,
                "error_message": msg,
            },
            "jvm.threads.daemon": {
                "label": "Number of daemon threads used",
                "options": None,
                "status": status,
                "error_message": msg,
            },
        }
        return data

def check(self, textkey, data, config):
        if textkey.split(".")[0] in ["jbc", "pool", "idle_timeout_minutes"]:
            query = (
                '%s "%s/management/subsystem/datasources/data-source/%s/statistics'
                '?read-resource&include-runtime=true&recursive&json.pretty"'
            )
            json_output = execute_query(config, query, data)
            data = agent_util.json_loads(json_output)

if textkey == "jdbc.prepared_statement_cache_access_count":
                val = data["statistics"]["jdbc"]["PreparedStatementCacheAccessCount"]

elif textkey == "jdbc.prepared_statement_cache_add_count":
                val = data["statistics"]["jdbc"]["PreparedStatementCacheAddCount"]

elif textkey == "jdbc.prepared_statement_cache_current_size":
                val = data["statistics"]["jdbc"]["PreparedStatementCacheCurrentSize"]

elif textkey == "jdbc.prepared_statement_cache_delete_count":
                val = data["statistics"]["jdbc"]["PreparedStatementCacheDeleteCount"]

elif textkey == "jdbc.prepared_statement_cache_hit_count":
                val = data["statistics"]["jdbc"]["PreparedStatementCacheHitCount"]

elif textkey == "jdbc.prepared_statement_cache_miss_count":
                val = data["statistics"]["jdbc"]["PreparedStatementCacheMissCount"]

elif textkey == "pool.active_count":
                val = data["statistics"]["pool"]["ActiveCount"]

elif textkey == "pool.available_count":
                val = data["statistics"]["pool"]["AvailableCount"]

elif textkey == "pool.average_blocking_time":
                val = data["statistics"]["pool"]["AverageBlockingTime"]

elif textkey == "pool.average_creation_time":
                val = data["statistics"]["pool"]["AverageCreationTime"]

elif textkey == "pool.created_count":
                val = data["statistics"]["pool"]["CreatedCount"]
            elif textkey == "pool.destroyed_count":
                val = data["statistics"]["pool"]["DestroyedCount"]

elif textkey == "pool.max_creation_time":
                val = data["statistics"]["pool"]["MaxCreationTime"]

elif textkey == "pool.max_used_count":
                val = data["statistics"]["pool"]["MaxUsedCount"]

elif textkey == "pool.max_wait_time":
                val = data["statistics"]["pool"]["MaxWaitTime"]

elif textkey == "pool.timed_out":
                val = data["statistics"]["pool"]["TimedOut"]

elif textkey == "pool.total_blocking_time":
                val = data["statistics"]["pool"]["TotalBlockingTime"]

elif textkey == "pool.TotalCreationTime":
                val = data["statistics"]["pool"]["TotalCreationTime"]

elif textkey == "idle_timeout_minutes":
                val = data["statistics"]["idle-timeout-minutes"]

else:
                val = 0

elif textkey.split(".")[0] in ["jvm"]:
            query = (
                '%s "%s/management/core-service/platform-mbean'
                '?read-attribute&recursive&json.pretty"'
            )
            json_output = execute_query(config, query, data)
            data = agent_util.json_loads(json_output)

heap_used_total = 0
            heap_committed_total = 0
            non_heap_used_total = 0
            non_heap_committed_total = 0
            if textkey.split(".")[1] in ["heap", "nonheap"]:
                data = data["type"]["memory-pool"]
                for name, value in data["name"].items():
                    if value["type"] == "HEAP":
                        heap_used_total += value["usage"]["used"]
                        heap_committed_total += value["usage"]["committed"]
                    elif value["type"] == "NON_HEAP":
                        non_heap_used_total += value["usage"]["used"]
                        non_heap_committed_total += value["usage"]["committed"]
            elif textkey.split(".")[1] in ["threads"]:
                data = data["type"]["threading"]

conversion = 1024**2
            if textkey == "jvm.heap.used":
                val = heap_used_total / conversion
            elif textkey == "jvm.heap.committed":
                val = heap_committed_total / conversion
            elif textkey == "jvm.nonheap.used":
                val = non_heap_used_total / conversion
            elif textkey == "jvm.nonheap.committed":
                val = non_heap_committed_total / conversion
            elif textkey == "jvm.threads.live":
                val = data["thread-count"]
            elif textkey == "jvm.threads.daemon":
                val = data["daemon-thread-count"]
            else:
                val = 0

else:
            val = 0

if not val:
            return 0.0
        return float(val)

Sid Gifari From Gifari Industries - BD Cyber Security Team