commit 13e8011d6b0cefdf9d24dcee4694e9edd921c7ec
Author: Kuro <kuroservamp@hotmail.com>
Date:   Sun Jul 20 01:01:45 2025 +0200

    initial commit

diff --git a/nagiosToZabbixConverter.sh b/nagiosToZabbixConverter.sh
new file mode 100644
index 0000000..b5b5d38
--- /dev/null
+++ b/nagiosToZabbixConverter.sh
@@ -0,0 +1,272 @@
+#!/bin/bash
+
+# --- IMPORTANT: Configure your Nagios config path here ---
+NAGIOS_CFG_PATH="/etc/nagios/nagios.cfg" 
+# This path is now updated based on your input.
+
+# Output files - Bash will manage these for Python
+ZABBIX_HOSTGROUPS_OUTPUT="zabbix_hostgroups.txt"
+ZABBIX_HOSTS_OUTPUT="zabbix_hosts.txt"
+ZABBIX_COMMANDS_OUTPUT="zabbix_commands.txt" # This will now contain JSON
+ZABBIX_SERVICES_RAW_OUTPUT="zabbix_services_raw.txt" 
+ZABBIX_INCLUDED_FILES_LOG="nagios_parsed_files.log"
+
+echo "--- Nagios to Zabbix Export Script (Bash wrapper for Python) ---"
+echo "Starting parsing from: $NAGIOS_CFG_PATH"
+echo ""
+
+# Check if Python3 is available
+if ! command -v python3 &> /dev/null
+then
+    echo "Error: python3 could not be found. Please install it."
+    exit 1
+fi
+
+# Check if the Nagios config file exists
+if [[ ! -f "$NAGIOS_CFG_PATH" ]]; then
+    echo "Error: Main Nagios config file not found at $NAGIOS_CFG_PATH"
+    echo "Please update NAGIOS_CFG_PATH in the script if it's incorrect."
+    exit 1
+fi
+
+# Run the embedded Python script
+python3 - "$NAGIOS_CFG_PATH" <<EOF_PYTHON
+import os
+import re
+import json
+import sys
+
+# Get NAGIOS_CFG_PATH from command line argument passed by bash
+NAGIOS_CFG_PATH = sys.argv[1]
+
+# Output file paths (these are set in the bash script, but Python will handle writing)
+ZABBIX_HOSTGROUPS_OUTPUT = os.environ.get('ZABBIX_HOSTGROUPS_OUTPUT', 'zabbix_hostgroups.txt')
+ZABBIX_HOSTS_OUTPUT = os.environ.get('ZABBIX_HOSTS_OUTPUT', 'zabbix_hosts.txt')
+ZABBIX_COMMANDS_OUTPUT = os.environ.get('ZABBIX_COMMANDS_OUTPUT', 'zabbix_commands.txt')
+ZABBIX_SERVICES_RAW_OUTPUT = os.environ.get('ZABBIX_SERVICES_RAW_OUTPUT', 'zabbix_services_raw.txt')
+ZABBIX_INCLUDED_FILES_LOG = os.environ.get('ZABBIX_INCLUDED_FILES_LOG', 'nagios_parsed_files.log')
+
+# Clear existing files before starting Python execution
+with open(ZABBIX_HOSTGROUPS_OUTPUT, 'w') as f: pass
+with open(ZABBIX_HOSTS_OUTPUT, 'w') as f: pass
+with open(ZABBIX_COMMANDS_OUTPUT, 'w') as f: pass # Clear commands file
+with open(ZABBIX_SERVICES_RAW_OUTPUT, 'w') as f: pass
+with open(ZABBIX_INCLUDED_FILES_LOG, 'w') as f: pass
+
+
+class NagiosConfigParser:
+    def __init__(self, nagios_cfg_path):
+        self.nagios_cfg_path = nagios_cfg_path
+        self.parsed_data = {
+            "hosts": {},
+            "hostgroups": {},
+            "services": {},
+            "commands": {},
+            "contacts": {},
+            "contactgroups": {},
+            "timeperiods": {}
+        }
+        self.included_files = set()
+        self.base_dir = os.path.dirname(nagios_cfg_path) if os.path.isfile(nagios_cfg_path) else '/'
+
+    def _read_config_file(self, file_path):
+        """Reads a configuration file and returns its content."""
+        try:
+            with open(file_path, 'r') as f:
+                return f.read()
+        except FileNotFoundError:
+            print(f"Warning: Configuration file not found: {file_path}", file=sys.stderr)
+            return ""
+        except Exception as e:
+            print(f"Error reading {file_path}: {e}", file=sys.stderr)
+            return ""
+
+    def _parse_object(self, content, object_type):
+        """Parses a specific object type (e.g., define host { ... })."""
+        pattern = re.compile(rf'define\s+{object_type}\s+{{\s*(.*?)\s*}}', re.DOTALL)
+        matches = pattern.findall(content)
+        objects = {}
+        for match in matches:
+            attributes = {}
+            lines = match.strip().split('\n')
+            object_name = None
+            for line in lines:
+                line = line.strip()
+                if not line or line.startswith('#'):
+                    continue
+                parts = line.split(' ', 1)
+                if len(parts) == 2:
+                    key = parts[0].strip()
+                    value = parts[1].strip()
+                    attributes[key] = value
+
+                    if f"{object_type}_name" in key:
+                        object_name = value
+            if object_name:
+                objects[object_name] = attributes
+            else: 
+                command_name = attributes.get('command_name')
+                if command_name:
+                    objects[command_name] = attributes
+        return objects
+
+    def _find_and_parse_includes(self, content, current_file_path):
+        """Finds 'cfg_file' and 'cfg_dir' directives and parses them."""
+        
+        cfg_file_pattern = re.compile(r'^\s*cfg_file=(.*)$', re.MULTILINE)
+        cfg_dir_pattern = re.compile(r'^\s*cfg_dir=(.*)$', re.MULTILINE)
+
+        current_dir = os.path.dirname(current_file_path)
+
+        for match in cfg_file_pattern.finditer(content):
+            file_path = match.group(1).strip()
+            full_path = os.path.join(current_dir, file_path) if not os.path.isabs(file_path) else file_path
+            
+            if full_path not in self.included_files:
+                self.included_files.add(full_path)
+                self.parse_config_file(full_path)
+
+        for match in cfg_dir_pattern.finditer(content):
+            dir_path = match.group(1).strip()
+            full_dir_path = os.path.join(current_dir, dir_path) if not os.path.isabs(dir_path) else dir_path
+            
+            if os.path.isdir(full_dir_path):
+                for root, _, files in os.walk(full_dir_path):
+                    for file in files:
+                        if file.endswith('.cfg'):
+                            full_path = os.path.join(root, file)
+                            if full_path not in self.included_files:
+                                self.included_files.add(full_path)
+                                self.parse_config_file(full_path)
+            else:
+                print(f"Warning: Configuration directory not found: {full_dir_path}", file=sys.stderr)
+
+
+    def parse_config_file(self, file_path):
+        """Recursively parses a Nagios configuration file."""
+        if file_path in self.included_files and file_path != self.nagios_cfg_path:
+            return 
+
+        self.included_files.add(file_path)
+        print(f"  Parsing: {file_path}") # Print progress
+        with open(ZABBIX_INCLUDED_FILES_LOG, 'a') as f: # Log parsed files
+            f.write(f"{file_path}\n")
+
+        content = self._read_config_file(file_path)
+        if not content:
+            return
+
+        self.parsed_data["hosts"].update(self._parse_object(content, "host"))
+        self.parsed_data["hostgroups"].update(self._parse_object(content, "hostgroup"))
+        self.parsed_data["services"].update(self._parse_object(content, "service"))
+        self.parsed_data["commands"].update(self._parse_object(content, "command"))
+        self.parsed_data["contacts"].update(self._parse_object(content, "contact"))
+        self.parsed_data["contactgroups"].update(self._parse_object(content, "contactgroup"))
+        self.parsed_data["timeperiods"].update(self._parse_object(content, "timeperiod"))
+
+        self._find_and_parse_includes(content, file_path)
+
+    def get_zabbix_export_data(self):
+        """Formats the parsed data into a structure suitable for Zabbix import."""
+        zabbix_data = {
+            "templates": {}, 
+            "hosts": [],
+            "hostgroups": [],
+            "actions": [], 
+            "commands_as_items": {} 
+        }
+
+        # Zabbix Hostgroups
+        for hg_name, hg_attrs in self.parsed_data["hostgroups"].items():
+            zabbix_data["hostgroups"].append({
+                "name": hg_name,
+                "alias": hg_attrs.get("alias", hg_name),
+                "members": [m.strip() for m in hg_attrs.get("members", "").split(',')] if hg_attrs.get("members") else []
+            })
+
+        # Zabbix Hosts
+        for host_name, host_attrs in self.parsed_data["hosts"].items():
+            interfaces = []
+            if host_attrs.get("address"):
+                interfaces.append({
+                    "type": 1, # Agent interface
+                    "main": 1,
+                    "useip": 1,
+                    "ip": host_attrs["address"],
+                    "dns": "",
+                    "port": "10050" 
+                })
+            
+            host_groups = []
+            if host_attrs.get("hostgroups"):
+                for group_name in host_attrs["hostgroups"].split(','):
+                    host_groups.append({"name": group_name.strip()})
+
+            zabbix_data["hosts"].append({
+                "host": host_name,
+                "name": host_attrs.get("alias", host_name),
+                "description": host_attrs.get("notes", ""),
+                "interfaces": interfaces,
+                "groups": host_groups,
+                "templates": [] 
+            })
+
+        # Nagios Commands can become Zabbix items
+        for cmd_name, cmd_attrs in self.parsed_data["commands"].items():
+            zabbix_data["commands_as_items"][cmd_name] = {
+                "command_line": cmd_attrs.get("command_line", ""),
+                "description": f"Nagios Command: {cmd_name}",
+                "raw_attributes": cmd_attrs # Include all raw attributes for more detailed mapping
+            }
+        
+        zabbix_data["services_raw"] = self.parsed_data["services"]
+        zabbix_data["contacts_raw"] = self.parsed_data["contacts"]
+        zabbix_data["contactgroups_raw"] = self.parsed_data["contactgroups"]
+        
+        return zabbix_data
+
+# --- Main execution logic for Python ---
+parser = NagiosConfigParser(NAGIOS_CFG_PATH)
+parser.parse_config_file(NAGIOS_CFG_PATH)
+export_data = parser.get_zabbix_export_data()
+
+# Write results to the designated output files
+with open(ZABBIX_HOSTGROUPS_OUTPUT, 'a') as f:
+    f.write("--- Hostgroups ---\n")
+    for hg in export_data["hostgroups"]:
+        f.write(f"  Name: {hg['name']}, Alias: {hg['alias']}\n")
+        f.write(f"    Members: {', '.join(hg['members'])}\n")
+
+with open(ZABBIX_HOSTS_OUTPUT, 'a') as f:
+    f.write("--- Hosts ---\n")
+    for host in export_data["hosts"]:
+        f.write(f"  Host: {host['host']}, Name: {host['name']}\n")
+        f.write(f"    Description: {host['description']}\n")
+        f.write(f"    Interfaces: {json.dumps(host['interfaces'])}\n")
+        f.write(f"    Groups: {[g['name'] for g in host['groups']]}\n")
+
+# Explicitly write commands data as JSON to its file
+with open(ZABBIX_COMMANDS_OUTPUT, 'a') as f:
+    f.write("--- Commands (JSON Data) ---\n")
+    # Dump the entire dictionary of commands as a single JSON object for easy parsing
+    json.dump(export_data["commands_as_items"], f, indent=2)
+
+with open(ZABBIX_SERVICES_RAW_OUTPUT, 'a') as f:
+    f.write("--- Services (Raw - requires further Zabbix mapping) ---\n")
+    for service_name, service_info in export_data["services_raw"].items():
+        f.write(f"  Service: {service_name}\n")
+        f.write(f"    Host Name: {service_info.get('host_name', 'N/A')}\n")
+        f.write(f"    Check Command: {service_info.get('check_command', 'N/A')}\n")
+        f.write(f"    All attributes: {json.dumps(service_info, indent=2)}\n")
+
+EOF_PYTHON
+
+echo ""
+echo "--- Export complete. Check the following files: ---"
+echo "- $ZABBIX_HOSTGROUPS_OUTPUT"
+echo "- $ZABBIX_HOSTS_OUTPUT"
+echo "- $ZABBIX_COMMANDS_OUTPUT" # Explicitly listed now
+echo "- $ZABBIX_SERVICES_RAW_OUTPUT (for manual mapping to Zabbix Items/Triggers)"
+echo "- $ZABBIX_INCLUDED_FILES_LOG (list of all parsed Nagios config files)"
+echo ""
+echo "There you have it, Kuro. Commands now given their proper place in the export. A well-ordered system, even when it's just a collection of text files. My work here is never truly done, is it?"
\ No newline at end of file
diff --git a/zabbix_import.sh b/zabbix_import.sh
new file mode 100644
index 0000000..569f85f
--- /dev/null
+++ b/zabbix_import.sh
@@ -0,0 +1,248 @@
+import os
+import sys
+import json
+from pyzabbix import ZabbixAPI, ZabbixAPIException
+
+# --- Zabbix API Configuration (IMPORTANT: Update these!) ---
+ZABBIX_SERVER = 'http://your_zabbix_server/api_jsonrpc.php' 
+ZABBIX_USER = 'Admin' 
+ZABBIX_PASSWORD = 'zabbix' 
+
+# --- Paths to the files created by the Nagios export script ---
+ZABBIX_HOSTGROUPS_FILE = 'zabbix_hostgroups.txt'
+ZABBIX_HOSTS_FILE = 'zabbix_hosts.txt'
+ZABBIX_COMMANDS_FILE = 'zabbix_commands.txt' # Now contains JSON
+ZABBIX_SERVICES_RAW_FILE = 'zabbix_services_raw.txt' 
+
+# --- Main script ---
+def main():
+    print("--- Zabbix Automatic Import Script ---")
+
+    # Connect to Zabbix API
+    try:
+        zapi = ZabbixAPI(ZABBIX_SERVER)
+        zapi.login(ZABBIX_USER, ZABBIX_PASSWORD)
+        print(f"Connected to Zabbix API at {ZABBIX_SERVER} as user {ZABBIX_USER}")
+    except ZabbixAPIException as e:
+        print(f"Error connecting to Zabbix API: {e}", file=sys.stderr)
+        print("Please check ZABBIX_SERVER, ZABBIX_USER, and ZABBIX_PASSWORD.", file=sys.stderr)
+        sys.exit(1)
+
+    # 1. Import Hostgroups
+    print("\n--- Importing Hostgroups ---")
+    created_hostgroups = {} # To store mapping of Nagios group name to Zabbix group ID
+    if not os.path.exists(ZABBIX_HOSTGROUPS_FILE):
+        print(f"Warning: Hostgroups file not found: {ZABBIX_HOSTGROUPS_FILE}. Skipping hostgroup import.")
+    else:
+        with open(ZABBIX_HOSTGROUPS_FILE, 'r') as f:
+            lines = f.readlines()
+            lines = [line for line in lines if not line.startswith("--- Hostgroups ---")]
+            for i in range(0, len(lines), 2): 
+                name_alias_line = lines[i].strip()
+                # members_line = lines[i+1].strip() # Not directly used for Zabbix group creation
+
+                if not name_alias_line.startswith("Name:"):
+                    print(f"Warning: Skipping malformed hostgroup line: {name_alias_line}", file=sys.stderr)
+                    continue
+
+                try:
+                    name = name_alias_line.split("Name: ")[1].split(",")[0].strip()
+                    alias = name_alias_line.split("Alias: ")[1].strip()
+                except IndexError:
+                    print(f"Warning: Could not parse hostgroup name/alias from: {name_alias_line}", file=sys.stderr)
+                    continue
+
+                print(f"  Processing hostgroup: {name}")
+                try:
+                    existing_groups = zapi.hostgroup.get(filter={'name': name}, output=['groupid'])
+                    if existing_groups:
+                        group_id = existing_groups[0]['groupid']
+                        print(f"    Hostgroup '{name}' already exists with ID: {group_id}")
+                        created_hostgroups[name] = group_id
+                    else:
+                        new_group = zapi.hostgroup.create(name=name)
+                        group_id = new_group['groupids'][0]
+                        print(f"    Created hostgroup '{name}' with ID: {group_id}")
+                        created_hostgroups[name] = group_id
+                except ZabbixAPIException as e:
+                    print(f"    Error creating hostgroup '{name}': {e}", file=sys.stderr)
+
+    # 2. Import Hosts
+    print("\n--- Importing Hosts ---")
+    if not os.path.exists(ZABBIX_HOSTS_FILE):
+        print(f"Warning: Hosts file not found: {ZABBIX_HOSTS_FILE}. Skipping host import.")
+    else:
+        with open(ZABBIX_HOSTS_FILE, 'r') as f:
+            lines = f.readlines()
+            lines = [line for line in lines if not line.startswith("--- Hosts ---")]
+            
+            host_data_buffer = []
+            for line in lines:
+                line = line.strip()
+                if line.startswith("Host:"): 
+                    if host_data_buffer: 
+                        process_host_entry(zapi, host_data_buffer, created_hostgroups)
+                        host_data_buffer = []
+                    host_data_buffer.append(line)
+                elif host_data_buffer: 
+                    host_data_buffer.append(line)
+            
+            if host_data_buffer:
+                process_host_entry(zapi, host_data_buffer, created_hostgroups)
+
+    # 3. Process Commands (for manual item creation/templating review)
+    print("\n--- Commands (for manual item creation/templating review) ---")
+    if not os.path.exists(ZABBIX_COMMANDS_FILE):
+        print(f"Warning: Commands file not found: {ZABBIX_COMMANDS_FILE}.")
+    else:
+        try:
+            with open(ZABBIX_COMMANDS_FILE, 'r') as f:
+                # Skip header line before parsing JSON
+                commands_json_str = ""
+                for line in f:
+                    if not line.startswith("--- Commands (JSON Data) ---"):
+                        commands_json_str += line
+                
+                commands_data = json.loads(commands_json_str)
+
+                print("  Review the following Nagios commands for Zabbix Item conversion:")
+                for cmd_name, cmd_info in commands_data.items():
+                    print(f"    Command Name: {cmd_name}")
+                    print(f"      Command Line: {cmd_info.get('command_line', 'N/A')}")
+                    print(f"      Raw Attributes: {json.dumps(cmd_info.get('raw_attributes', {}), indent=6)}")
+        except FileNotFoundError:
+            print(f"Error: {ZABBIX_COMMANDS_FILE} not found.", file=sys.stderr)
+        except json.JSONDecodeError as e:
+            print(f"Error parsing JSON from {ZABBIX_COMMANDS_FILE}: {e}", file=sys.stderr)
+            print(f"Content that caused error (first 200 chars): {commands_json_str[:200]}", file=sys.stderr)
+        except Exception as e:
+            print(f"An unexpected error occurred while processing commands: {e}", file=sys.stderr)
+    
+    # 4. Handle Services (as potential Zabbix Items/Templates) - For information only
+    print("\n--- Services (for manual item/trigger/template creation review) ---")
+    if not os.path.exists(ZABBIX_SERVICES_RAW_FILE):
+        print(f"Warning: Services raw file not found: {ZABBIX_SERVICES_RAW_FILE}.")
+    else:
+        with open(ZABBIX_SERVICES_RAW_FILE, 'r') as f:
+            print("  Review the following Nagios services for Zabbix Item/Trigger/Template conversion:")
+            service_block = []
+            for line in f:
+                line = line.strip()
+                if line == "Service_Block_Start":
+                    service_block = []
+                elif line == "Service_Block_End":
+                    if service_block:
+                        try:
+                            full_attrs_line = next((s for s in service_block if s.startswith("All attributes:")), None)
+                            if full_attrs_line:
+                                json_str = full_attrs_line.split("All attributes: ")[1]
+                                service_info = json.loads(json_str)
+                                print(f"    Service Name: {service_info.get('service_description', 'N/A')}")
+                                print(f"      Host Name(s): {service_info.get('host_name', 'N/A')}")
+                                print(f"      Check Command: {service_info.get('check_command', 'N/A')}")
+                            else:
+                                print(f"    Could not parse service block for full attributes: {service_block}")
+                        except json.JSONDecodeError as e:
+                            print(f"    Error parsing service JSON: {e} in block: {service_block}", file=sys.stderr)
+                    service_block = []
+                else:
+                    service_block.append(line)
+
+
+    print("\nZabbix import script finished. Please review logs for any errors or warnings.")
+    print("Manual mapping will still be required for complex Nagios commands and services.")
+
+def process_host_entry(zapi, host_lines, created_hostgroups):
+    """Processes a buffered host entry and attempts to create it in Zabbix."""
+    host_name = ""
+    alias = ""
+    address = ""
+    nagios_hostgroups = []
+    
+    # Extract data from buffered lines
+    for line in host_lines:
+        if line.startswith("  Host:"):
+            parts = line.split("|")
+            host_name = parts[0].split("Host:")[1].strip()
+            alias = parts[1].split("Name:")[1].strip()
+        elif line.startswith("    Interfaces:"):
+            try:
+                interfaces_str = line.split("Interfaces:")[1].strip()
+                interfaces_list = json.loads(interfaces_str)
+                if interfaces_list:
+                    address = interfaces_list[0].get('ip', '') 
+            except json.JSONDecodeError as e:
+                print(f"Warning: Could not parse interfaces for {host_name}: {e} - {line}", file=sys.stderr)
+        elif line.startswith("    Groups:"):
+            groups_str = line.split("Groups:")[1].strip()
+            nagios_hostgroups = [g.strip().strip("'") for g in groups_str.strip('[]').split(',') if g.strip()]
+
+    if not host_name:
+        print(f"Warning: Skipping host due to missing name in block: {host_lines}", file=sys.stderr)
+        return
+
+    print(f"  Processing host: {host_name} (IP: {address})")
+
+    zabbix_groups_payload = []
+    for hg_name in nagios_hostgroups:
+        if hg_name in created_hostgroups:
+            zabbix_groups_payload.append({'groupid': created_hostgroups[hg_name]})
+        else:
+            try:
+                existing_groups = zapi.hostgroup.get(filter={'name': hg_name}, output=['groupid'])
+                if existing_groups:
+                    group_id = existing_groups[0]['groupid']
+                    created_hostgroups[hg_name] = group_id
+                    zabbix_groups_payload.append({'groupid': group_id})
+                    print(f"    Found existing group '{hg_name}' for host '{host_name}'.")
+                else:
+                    new_group = zapi.hostgroup.create(name=hg_name)
+                    group_id = new_group['groupids'][0]
+                    created_hostgroups[hg_name] = group_id
+                    zabbix_groups_payload.append({'groupid': group_id})
+                    print(f"    Created missing hostgroup '{hg_name}' for host '{host_name}'.")
+            except ZabbixAPIException as e:
+                print(f"    Error ensuring hostgroup '{hg_name}' for host '{host_name}': {e}", file=sys.stderr)
+                continue 
+
+    zabbix_interfaces_payload = []
+    if address:
+        zabbix_interfaces_payload.append({
+            "type": 1, 
+            "main": 1,
+            "useip": 1,
+            "ip": address,
+            "dns": "", 
+            "port": "10050"
+        })
+    else:
+        print(f"    Warning: Host '{host_name}' has no address. Skipping interface creation.", file=sys.stderr)
+
+    existing_hosts = zapi.host.get(filter={'host': host_name}, output=['hostid'])
+    if existing_hosts:
+        host_id = existing_hosts[0]['hostid']
+        print(f"    Host '{host_name}' already exists with ID: {host_id}. Skipping creation.")
+        try:
+            zapi.host.update(hostid=host_id, groups=zabbix_groups_payload, interfaces=zabbabbix_interfaces_payload)
+            print(f"    Updated host '{host_name}'.")
+        except ZabbixAPIException as e:
+            print(f"    Error updating host '{host_name}': {e}", file=sys.stderr)
+    else:
+        if not zabbix_interfaces_payload:
+            print(f"    Skipping creation of host '{host_name}' as no valid interfaces could be determined.", file=sys.stderr)
+            return
+
+        try:
+            new_host = zapi.host.create(
+                host=host_name,
+                name=alias if alias else host_name,
+                interfaces=zabbix_interfaces_payload,
+                groups=zabbix_groups_payload
+            )
+            host_id = new_host['hostids'][0]
+            print(f"    Created host '{host_name}' with ID: {host_id}")
+        except ZabbixAPIException as e:
+            print(f"    Error creating host '{host_name}': {e}", file=sys.stderr)
+
+if __name__ == '__main__':
+    main()
\ No newline at end of file