check-netscaler 2.0.0__py3-none-any.whl

check_netscaler/__init__.py

@@ -0,0 +1,10 @@
+"""
+check_netscaler - Nagios/Icinga monitoring plugin for Citrix NetScaler ADC
+
+A monitoring plugin for Citrix NetScaler Application Delivery Controllers
+using the NITRO REST API.
+"""
+
+__version__ = "2.0.0"
+__author__ = "slauger"
+__license__ = "MIT"

check_netscaler/__main__.py

@@ -0,0 +1,10 @@
+"""
+CLI entry point for check_netscaler
+"""
+
+import sys
+
+from check_netscaler.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

check_netscaler/cli.py

@@ -0,0 +1,314 @@
+"""
+Command-line interface for check_netscaler
+"""
+
+import argparse
+import os
+import sys
+from typing import List, Optional
+
+from check_netscaler import __version__
+from check_netscaler.constants import (
+    DEFAULT_API_VERSION,
+    DEFAULT_PASSWORD,
+    DEFAULT_TIMEOUT,
+    DEFAULT_USERNAME,
+    STATE_UNKNOWN,
+)
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """Create and configure argument parser"""
+    parser = argparse.ArgumentParser(
+        prog="check_netscaler",
+        description="Nagios/Icinga monitoring plugin for Citrix NetScaler ADC",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+
+    # Version
+    parser.add_argument(
+        "-V",
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+    )
+
+    # Connection arguments
+    parser.add_argument(
+        "-H",
+        "--hostname",
+        default=os.getenv("NETSCALER_HOST"),
+        help="Hostname or IP address of the NetScaler appliance (env: NETSCALER_HOST)",
+    )
+
+    parser.add_argument(
+        "-u",
+        "--username",
+        default=os.getenv("NETSCALER_USER", DEFAULT_USERNAME),
+        help=f"Username for authentication (env: NETSCALER_USER, default: {DEFAULT_USERNAME})",
+    )
+
+    parser.add_argument(
+        "-p",
+        "--password",
+        default=os.getenv("NETSCALER_PASS", DEFAULT_PASSWORD),
+        help=f"Password for authentication (env: NETSCALER_PASS, default: {DEFAULT_PASSWORD})",
+    )
+
+    parser.add_argument(
+        "--no-ssl",
+        dest="ssl",
+        action="store_false",
+        default=True,
+        help="Use HTTP instead of HTTPS (default: HTTPS)",
+    )
+
+    parser.add_argument(
+        "-P",
+        "--port",
+        type=int,
+        help="TCP port to connect to (default: 80 for HTTP, 443 for HTTPS)",
+    )
+
+    parser.add_argument(
+        "-a",
+        "--api",
+        default=DEFAULT_API_VERSION,
+        help=f"NITRO API version (default: {DEFAULT_API_VERSION})",
+    )
+
+    parser.add_argument(
+        "-t",
+        "--timeout",
+        type=int,
+        default=DEFAULT_TIMEOUT,
+        help=f"Connection timeout in seconds (default: {DEFAULT_TIMEOUT})",
+    )
+
+    # Check command arguments
+    parser.add_argument(
+        "-C",
+        "--command",
+        required=True,
+        choices=[
+            "state",
+            "sslcert",
+            "above",
+            "below",
+            "matches",
+            "matches_not",
+            "nsconfig",
+            "hastatus",
+            "servicegroup",
+            "hwinfo",
+            "interfaces",
+            "perfdata",
+            "license",
+            "staserver",
+            "ntp",
+            "debug",
+        ],
+        help="Check command to execute",
+    )
+
+    parser.add_argument(
+        "-o",
+        "--objecttype",
+        help="Object type to check (e.g., lbvserver, service, servicegroup)",
+    )
+
+    parser.add_argument(
+        "-n",
+        "--objectname",
+        help="Filter by specific object name",
+    )
+
+    parser.add_argument(
+        "-e",
+        "--endpoint",
+        choices=["stat", "config"],
+        help="API endpoint type (stat or config)",
+    )
+
+    # Threshold arguments
+    parser.add_argument(
+        "-w",
+        "--warning",
+        help="Warning threshold",
+    )
+
+    parser.add_argument(
+        "-c",
+        "--critical",
+        help="Critical threshold",
+    )
+
+    # Additional options
+    parser.add_argument(
+        "-f",
+        "--filter",
+        help="Filter objects using regular expression",
+    )
+
+    parser.add_argument(
+        "-l",
+        "--limit",
+        help="Limit check to objects matching pattern (regex)",
+    )
+
+    parser.add_argument(
+        "-L",
+        "--label",
+        help="Field name to use as label in output",
+    )
+
+    parser.add_argument(
+        "--separator",
+        default=".",
+        help="Separator for performance data labels (default: .)",
+    )
+
+    parser.add_argument(
+        "-x",
+        "--urlopts",
+        help="Additional URL options for API requests",
+    )
+
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="count",
+        default=0,
+        help="Increase output verbosity (can be repeated)",
+    )
+
+    return parser
+
+
+def main(args: Optional[List[str]] = None) -> int:
+    """Main entry point for CLI"""
+    parser = create_parser()
+    parsed_args = parser.parse_args(args)
+
+    # Validate required arguments
+    if not parsed_args.hostname:
+        parser.error("argument -H/--hostname is required (or set NETSCALER_HOST)")
+
+    try:
+        # Import here to avoid circular dependencies
+        from check_netscaler.client import NITROClient
+        from check_netscaler.commands.state import StateCommand
+        from check_netscaler.output.nagios import NagiosOutput
+
+        # Create NITRO client
+        client = NITROClient(
+            hostname=parsed_args.hostname,
+            username=parsed_args.username,
+            password=parsed_args.password,
+            ssl=parsed_args.ssl,
+            port=parsed_args.port,
+            timeout=parsed_args.timeout,
+            verify_ssl=not parsed_args.ssl,  # TODO: Add --insecure flag
+            api_version=parsed_args.api,
+        )
+
+        # Execute command
+        with client:
+            if parsed_args.command == "state":
+                command = StateCommand(client, parsed_args)
+                result = command.execute()
+            elif parsed_args.command in ["above", "below"]:
+                from check_netscaler.commands.threshold import ThresholdCommand
+
+                command = ThresholdCommand(client, parsed_args)
+                result = command.execute()
+            elif parsed_args.command == "nsconfig":
+                from check_netscaler.commands.nsconfig import NSConfigCommand
+
+                command = NSConfigCommand(client, parsed_args)
+                result = command.execute()
+            elif parsed_args.command == "hwinfo":
+                from check_netscaler.commands.hwinfo import HWInfoCommand
+
+                command = HWInfoCommand(client, parsed_args)
+                result = command.execute()
+            elif parsed_args.command == "sslcert":
+                from check_netscaler.commands.sslcert import SSLCertCommand
+
+                command = SSLCertCommand(client, parsed_args)
+                result = command.execute()
+            elif parsed_args.command == "servicegroup":
+                from check_netscaler.commands.servicegroup import ServiceGroupCommand
+
+                command = ServiceGroupCommand(client, parsed_args)
+                result = command.execute()
+            elif parsed_args.command in ["matches", "matches_not"]:
+                from check_netscaler.commands.matches import MatchesCommand
+
+                command = MatchesCommand(client, parsed_args)
+                result = command.execute()
+            elif parsed_args.command == "staserver":
+                from check_netscaler.commands.staserver import STAServerCommand
+
+                command = STAServerCommand(client, parsed_args)
+                result = command.execute()
+            elif parsed_args.command == "hastatus":
+                from check_netscaler.commands.hastatus import HAStatusCommand
+
+                command = HAStatusCommand(client, parsed_args)
+                result = command.execute()
+            elif parsed_args.command == "license":
+                from check_netscaler.commands.license import LicenseCommand
+
+                command = LicenseCommand(client, parsed_args)
+                result = command.execute()
+            elif parsed_args.command == "interfaces":
+                from check_netscaler.commands.interfaces import InterfacesCommand
+
+                command = InterfacesCommand(client, parsed_args)
+                result = command.execute()
+            elif parsed_args.command == "perfdata":
+                from check_netscaler.commands.perfdata import PerfdataCommand
+
+                command = PerfdataCommand(client, parsed_args)
+                result = command.execute()
+            elif parsed_args.command == "ntp":
+                from check_netscaler.commands.ntp import NTPCommand
+
+                command = NTPCommand(client, parsed_args)
+                result = command.execute()
+            elif parsed_args.command == "debug":
+                from check_netscaler.commands.debug import DebugCommand
+
+                command = DebugCommand(client, parsed_args)
+                result = command.execute()
+            else:
+                print(f"UNKNOWN - Command '{parsed_args.command}' not yet implemented")
+                return STATE_UNKNOWN
+
+        # Format and print output
+        output = NagiosOutput.format_output(
+            status=result.status,
+            message=result.message,
+            perfdata=result.perfdata,
+            long_output=result.long_output,
+            separator=parsed_args.separator,
+        )
+        print(output)
+
+        return result.status
+
+    except KeyboardInterrupt:
+        print("UNKNOWN - Interrupted by user")
+        return STATE_UNKNOWN
+    except Exception as e:
+        print(f"UNKNOWN - Unexpected error: {e}")
+        if parsed_args.verbose > 0:
+            import traceback
+
+            traceback.print_exc()
+        return STATE_UNKNOWN
+
+
+if __name__ == "__main__":
+    sys.exit(main())

check_netscaler/client/__init__.py

@@ -0,0 +1,25 @@
+"""NITRO API client for NetScaler ADC"""
+
+from check_netscaler.client.exceptions import (
+    NITROAPIError,
+    NITROAuthenticationError,
+    NITROConnectionError,
+    NITROException,
+    NITROPermissionError,
+    NITROResourceNotFoundError,
+    NITROTimeoutError,
+)
+from check_netscaler.client.nitro import NITROClient
+from check_netscaler.client.session import NITROSession
+
+__all__ = [
+    "NITROClient",
+    "NITROSession",
+    "NITROException",
+    "NITROAuthenticationError",
+    "NITROConnectionError",
+    "NITROTimeoutError",
+    "NITROAPIError",
+    "NITROResourceNotFoundError",
+    "NITROPermissionError",
+]

check_netscaler/client/exceptions.py

@@ -0,0 +1,48 @@
+"""
+Exceptions for NITRO API client
+"""
+
+
+class NITROException(Exception):
+    """Base exception for all NITRO client errors"""
+
+    pass
+
+
+class NITROAuthenticationError(NITROException):
+    """Authentication failed (login error)"""
+
+    pass
+
+
+class NITROConnectionError(NITROException):
+    """Connection to NetScaler failed"""
+
+    pass
+
+
+class NITROTimeoutError(NITROException):
+    """Request timed out"""
+
+    pass
+
+
+class NITROAPIError(NITROException):
+    """API returned an error response"""
+
+    def __init__(self, message: str, error_code: int = None, response: dict = None):
+        super().__init__(message)
+        self.error_code = error_code
+        self.response = response
+
+
+class NITROResourceNotFoundError(NITROAPIError):
+    """Requested resource not found (404)"""
+
+    pass
+
+
+class NITROPermissionError(NITROAPIError):
+    """Insufficient permissions (403)"""
+
+    pass

check_netscaler/client/nitro.py

@@ -0,0 +1,195 @@
+"""
+NITRO API client for NetScaler
+"""
+
+from typing import Any, Dict, Optional
+
+import requests
+
+from check_netscaler.client.exceptions import (
+    NITROAPIError,
+    NITROConnectionError,
+    NITROPermissionError,
+    NITROResourceNotFoundError,
+    NITROTimeoutError,
+)
+from check_netscaler.client.session import NITROSession
+
+
+class NITROClient:
+    """Client for NetScaler NITRO REST API"""
+
+    def __init__(
+        self,
+        hostname: str,
+        username: str,
+        password: str,
+        ssl: bool = True,
+        port: Optional[int] = None,
+        timeout: int = 15,
+        verify_ssl: bool = True,
+        api_version: str = "v1",
+    ):
+        """
+        Initialize NITRO API client
+
+        Args:
+            hostname: NetScaler hostname or IP address
+            username: Username for authentication
+            password: Password for authentication
+            ssl: Use HTTPS (default: True)
+            port: Custom port (default: 80 for HTTP, 443 for HTTPS)
+            timeout: Request timeout in seconds
+            verify_ssl: Verify SSL certificates (default: True)
+            api_version: API version (default: v1)
+        """
+        self.session = NITROSession(
+            hostname=hostname,
+            username=username,
+            password=password,
+            ssl=ssl,
+            port=port,
+            timeout=timeout,
+            verify_ssl=verify_ssl,
+        )
+        self.api_version = api_version
+
+    def login(self) -> None:
+        """Authenticate with NetScaler"""
+        self.session.login()
+
+    def logout(self) -> None:
+        """Logout from NetScaler"""
+        self.session.logout()
+
+    def get(
+        self,
+        resource_type: str,
+        resource_name: Optional[str] = None,
+        endpoint: str = "stat",
+        url_options: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Perform GET request to NITRO API
+
+        Args:
+            resource_type: Type of resource (e.g., 'lbvserver', 'service')
+            resource_name: Specific resource name (optional)
+            endpoint: API endpoint type ('stat' or 'config')
+            url_options: Additional URL options (e.g., 'args=detail:true')
+
+        Returns:
+            API response as dictionary
+
+        Raises:
+            NITROAPIError: If API returns an error
+            NITROResourceNotFoundError: If resource not found (404)
+            NITROPermissionError: If insufficient permissions (403)
+            NITROConnectionError: If connection fails
+            NITROTimeoutError: If request times out
+        """
+        if not self.session.is_logged_in:
+            raise NITROAPIError("Not logged in. Call login() first.")
+
+        # Build URL
+        url_parts = [self.session.base_url, endpoint, resource_type]
+        if resource_name:
+            url_parts.append(resource_name)
+
+        url = "/".join(url_parts)
+
+        if url_options:
+            url = f"{url}?{url_options}"
+
+        try:
+            response = self.session.session.get(
+                url,
+                timeout=self.session.timeout,
+                verify=self.session.verify_ssl,
+            )
+
+            # Handle HTTP errors
+            if response.status_code == 404:
+                raise NITROResourceNotFoundError(
+                    f"Resource not found: {resource_type}"
+                    + (f"/{resource_name}" if resource_name else "")
+                )
+
+            if response.status_code == 403:
+                raise NITROPermissionError(f"Insufficient permissions to access {resource_type}")
+
+            if response.status_code >= 400:
+                raise NITROAPIError(
+                    f"API error {response.status_code}: {response.text}",
+                    error_code=response.status_code,
+                )
+
+            # Parse JSON response
+            data = response.json()
+
+            # Check for NITRO error in response
+            if "errorcode" in data and data["errorcode"] != 0:
+                error_msg = data.get("message", "Unknown error")
+                error_code = data.get("errorcode")
+                raise NITROAPIError(
+                    f"NITRO API error {error_code}: {error_msg}",
+                    error_code=error_code,
+                    response=data,
+                )
+
+            return data
+
+        except requests.exceptions.Timeout as e:
+            raise NITROTimeoutError(f"Request timed out: {e}") from e
+        except requests.exceptions.ConnectionError as e:
+            raise NITROConnectionError(f"Connection failed: {e}") from e
+        except requests.exceptions.RequestException as e:
+            raise NITROConnectionError(f"Request failed: {e}") from e
+
+    def get_stat(
+        self,
+        resource_type: str,
+        resource_name: Optional[str] = None,
+        url_options: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Get statistics for a resource
+
+        Args:
+            resource_type: Type of resource
+            resource_name: Specific resource name (optional)
+            url_options: Additional URL options
+
+        Returns:
+            Statistics data
+        """
+        return self.get(resource_type, resource_name, endpoint="stat", url_options=url_options)
+
+    def get_config(
+        self,
+        resource_type: str,
+        resource_name: Optional[str] = None,
+        url_options: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        """
+        Get configuration for a resource
+
+        Args:
+            resource_type: Type of resource
+            resource_name: Specific resource name (optional)
+            url_options: Additional URL options
+
+        Returns:
+            Configuration data
+        """
+        return self.get(resource_type, resource_name, endpoint="config", url_options=url_options)
+
+    def __enter__(self):
+        """Context manager entry"""
+        self.login()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """Context manager exit"""
+        self.logout()
+        return False