#!/usr/bin/env python3
"""
Zabbix API Python封装
"""

import requests
import json
from typing import Optional, Dict, List, Any


class ZabbixAPI:
    def __init__(self, url: str, user: str, password: str):
        self.url = url
        self.user = user
        self.password = password
        self.auth_token: Optional[str] = None
        self.headers = {"Content-Type": "application/json-rpc"}
    
    def login(self) -> str:
        """登录获取认证令牌"""
        payload = {
            "jsonrpc": "2.0",
            "method": "user.login",
            "params": {
                "user": self.user,
                "password": self.password
            },
            "id": 1
        }
        response = requests.post(
            self.url, 
            data=json.dumps(payload), 
            headers=self.headers
        )
        result = response.json()
        if "error" in result:
            raise Exception(f"Login failed: {result['error']}")
        self.auth_token = result["result"]
        return self.auth_token
    
    def call(self, method: str, params: Dict[str, Any]) -> Any:
        """调用API方法"""
        if not self.auth_token:
            self.login()
        
        payload = {
            "jsonrpc": "2.0",
            "method": method,
            "params": params,
            "auth": self.auth_token,
            "id": 2
        }
        response = requests.post(
            self.url,
            data=json.dumps(payload),
            headers=self.headers
        )
        result = response.json()
        if "error" in result:
            raise Exception(f"API call failed: {result['error']}")
        return result["result"]
    
    def get_hosts(self, **kwargs) -> List[Dict]:
        """获取主机列表"""
        return self.call("host.get", kwargs)
    
    def create_host(self, **kwargs) -> str:
        """创建主机"""
        return self.call("host.create", kwargs)
    
    def update_host(self, hostid: str, **kwargs) -> Dict:
        """更新主机"""
        kwargs["hostid"] = hostid
        return self.call("host.update", kwargs)
    
    def delete_host(self, hostid: str) -> Dict:
        """删除主机"""
        return self.call("host.delete", [hostid])
    
    def get_templates(self, **kwargs) -> List[Dict]:
        """获取模板列表"""
        return self.call("template.get", kwargs)
    
    def get_groups(self, **kwargs) -> List[Dict]:
        """获取主机组列表"""
        return self.call("hostgroup.get", kwargs)
    
    def create_graph(self, **kwargs) -> str:
        """创建图形"""
        return self.call("graph.create", kwargs)
    
    def create_trigger(self, **kwargs) -> str:
        """创建触发器"""
        return self.call("trigger.create", kwargs)
    
    def logout(self):
        """登出"""
        if self.auth_token:
            self.call("user.logout", {})
            self.auth_token = None

#!/usr/bin/env python3
"""
批量创建Zabbix主机
"""

from zabbix_api import ZabbixAPI

def batch_create_hosts():
    api = ZabbixAPI(
        url="http://zabbix-server/api_jsonrpc.php",
        user="Admin",
        password="zabbix"
    )
    api.login()
    
    hosts = [
        {"name": "web-01", "ip": "192.168.1.101", "group": "Web Servers", "template": "Template OS Linux"},
        {"name": "web-02", "ip": "192.168.1.102", "group": "Web Servers", "template": "Template OS Linux"},
        {"name": "web-03", "ip": "192.168.1.103", "group": "Web Servers", "template": "Template OS Linux"},
        {"name": "db-01", "ip": "192.168.1.201", "group": "Database Servers", "template": "Template OS Linux"},
        {"name": "db-02", "ip": "192.168.1.202", "group": "Database Servers", "template": "Template OS Linux"},
    ]
    
    for host in hosts:
        try:
            result = api.create_host(
                host=host["name"],
                interfaces=[{
                    "type": 1,
                    "main": 1,
                    "useip": 1,
                    "ip": host["ip"],
                    "port": "10050"
                }],
                groups=[{"groupid": api.get_groups(filter={"name": host["group"]})[0]["groupid"]}],
                templates=[{"templateid": api.get_templates(filter={"host": host["template"]})[0]["templateid"]}]
            )
            print(f"Created host: {host['name']} (ID: {result['hostids'][0]})")
        except Exception as e:
            print(f"Failed to create host {host['name']}: {e}")
    
    api.logout()

if __name__ == "__main__":
    batch_create_hosts()

#!/usr/bin/env python3
"""
主机状态管理：启用/禁用/删除
"""

from zabbix_api import ZabbixAPI

def manage_host_status():
    api = ZabbixAPI(
        url="http://zabbix-server/api_jsonrpc.php",
        user="Admin",
        password="zabbix"
    )
    api.login()
    
    # 获取所有已禁用主机
    disabled_hosts = api.get_hosts(output=["hostid", "name", "status"], filter={"status": "1"})
    print(f"Disabled hosts: {len(disabled_hosts)}")
    for host in disabled_hosts:
        print(f"  - {host['name']} ({host['hostid']})")
    
    # 获取所有已启用主机
    enabled_hosts = api.get_hosts(output=["hostid", "name", "status"], filter={"status": "0"})
    print(f"\nEnabled hosts: {len(enabled_hosts)}")
    for host in enabled_hosts:
        print(f"  - {host['name']} ({host['hostid']})")
    
    # 批量禁用主机
    host_ids = [host["hostid"] for host in enabled_hosts[:5]]
    if host_ids:
        print(f"\nDisabling hosts: {host_ids}")
        api.call("host.massupdate", {
            "hosts": [{"hostid": hid} for hid in host_ids],
            "status": "1"
        })
    
    # 批量删除主机
    # host_ids = ["12345", "12346"]
    # api.call("host.delete", host_ids)
    
    api.logout()

if __name__ == "__main__":
    manage_host_status()

#!/usr/bin/env python3
"""
模板导入导出自动化
"""

import json
from zabbix_api import ZabbixAPI

def export_template(template_name: str, output_file: str):
    """导出模板到JSON文件"""
    api = ZabbixAPI(
        url="http://zabbix-server/api_jsonrpc.php",
        user="Admin",
        password="zabbix"
    )
    api.login()
    
    templates = api.get_templates(filter={"host": template_name}, output="extend")
    if not templates:
        print(f"Template {template_name} not found")
        return
    
    template = templates[0]
    template_id = template["templateid"]
    
    # 获取模板的监控项、触发器、图形等
    items = api.call("item.get", {"templateids": [template_id]})
    triggers = api.call("trigger.get", {"templateids": [template_id]})
    graphs = api.call("graph.get", {"templateids": [template_id]})
    dashboards = api.call("template.get", {"templateids": [template_id], "selectDashboards": "extend"})
    
    export_data = {
        "template": template,
        "items": items,
        "triggers": triggers,
        "graphs": graphs,
        "dashboards": dashboards
    }
    
    with open(output_file, "w", encoding="utf-8") as f:
        json.dump(export_data, f, indent=2, ensure_ascii=False)
    
    print(f"Template {template_name} exported to {output_file}")
    api.logout()

def import_template(input_file: str):
    """从JSON文件导入模板"""
    with open(input_file, "r", encoding="utf-8") as f:
        import_data = json.load(f)
    
    api = ZabbixAPI(
        url="http://zabbix-server/api_jsonrpc.php",
        user="Admin",
        password="zabbix"
    )
    api.login()
    
    # 导入配置
    result = api.call("configuration.import", {
        "format": "json",
        "rules": {
            "templates": {"createMissing": True, "updateExisting": True},
            "items": {"createMissing": True, "updateExisting": True},
            "triggers": {"createMissing": True, "updateExisting": True},
            "graphs": {"createMissing": True, "updateExisting": True}
        },
        "source": json.dumps(import_data)
    })
    
    if result:
        print(f"Template imported successfully")
    else:
        print(f"Template import failed")
    
    api.logout()

if __name__ == "__main__":
    export_template("Template OS Linux", "template_linux_export.json")

#!/usr/bin/env python3
"""
Zabbix配置自动备份
"""

import os
import json
import tarfile
import datetime
from zabbix_api import ZabbixAPI

def backup_zabbix_config(output_dir: str):
    api = ZabbixAPI(
        url="http://zabbix-server/api_jsonrpc.php",
        user="Admin",
        password="zabbix"
    )
    api.login()
    
    timestamp = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
    backup_file = os.path.join(output_dir, f"zabbix_backup_{timestamp}")
    
    os.makedirs(backup_file, exist_ok=True)
    
    # 备份主机
    print("备份主机配置...")
    hosts = api.get_hosts(output="extend")
    with open(os.path.join(backup_file, "hosts.json"), "w") as f:
        json.dump(hosts, f, indent=2)
    
    # 备份模板
    print("备份模板配置...")
    templates = api.get_templates(output="extend")
    with open(os.path.join(backup_file, "templates.json"), "w") as f:
        json.dump(templates, f, indent=2)
    
    # 备份主机组
    print("备份主机组...")
    groups = api.get_groups(output="extend")
    with open(os.path.join(backup_file, "groups.json"), "w") as f:
        json.dump(groups, f, indent=2)
    
    # 导出完整配置
    print("导出完整配置...")
    export_data = api.call("configuration.export", {
        "format": "json",
        "options": {
            "templates": [t["templateid"] for t in templates],
            "hosts": [h["hostid"] for h in hosts],
            "groups": [g["groupid"] for g in groups]
        }
    })
    with open(os.path.join(backup_file, "full_export.json"), "w") as f:
        json.dump(export_data, f, indent=2)
    
    # 打包备份
    print("打包备份文件...")
    tar_file = f"{backup_file}.tar.gz"
    with tarfile.open(tar_file, "w:gz") as tar:
        tar.add(backup_file, arcname=os.path.basename(backup_file))
    
    # 清理临时目录
    import shutil
    shutil.rmtree(backup_file)
    
    print(f"备份完成: {tar_file}")
    api.logout()
    return tar_file

if __name__ == "__main__":
    import sys
    output_dir = sys.argv[1] if len(sys.argv) > 1 else "/tmp"
    backup_zabbix_config(output_dir)

#!/usr/bin/env python3
"""
Zabbix配置恢复
"""

import os
import json
import tarfile
from zabbix_api import ZabbixAPI

def restore_zabbix_config(backup_file: str):
    api = ZabbixAPI(
        url="http://zabbix-server/api_jsonrpc.php",
        user="Admin",
        password="zabbix"
    )
    api.login()
    
    # 解压备份文件
    print(f"解压备份文件: {backup_file}")
    with tarfile.open(backup_file, "r:gz") as tar:
        extract_dir = backup_file.replace(".tar.gz", "")
        tar.extractall(path=os.path.dirname(backup_file))
    
    # 恢复主机组
    print("恢复主机组...")
    with open(os.path.join(extract_dir, "groups.json"), "r") as f:
        groups = json.load(f)
    
    for group in groups:
        try:
            existing = api.get_groups(filter={"name": group["name"]})
            if not existing:
                api.call("hostgroup.create", {"name": group["name"]})
                print(f"  创建主机组: {group['name']}")
            else:
                print(f"  主机组已存在: {group['name']}")
        except Exception as e:
            print(f"  创建主机组失败 {group['name']}: {e}")
    
    # 导入完整配置
    print("导入完整配置...")
    with open(os.path.join(extract_dir, "full_export.json"), "r") as f:
        export_data = json.load(f)
    
    result = api.call("configuration.import", {
        "format": "json",
        "rules": {
            "templates": {"createMissing": True, "updateExisting": True},
            "hosts": {"createMissing": True, "updateExisting": True},
            "groups": {"createMissing": True, "updateExisting": True},
            "items": {"createMissing": True, "updateExisting": True},
            "triggers": {"createMissing": True, "updateExisting": True},
            "graphs": {"createMissing": True, "updateExisting": True}
        },
        "source": export_data
    })
    
    if result:
        print("配置恢复成功！")
    else:
        print("配置恢复失败！")
    
    # 清理临时文件
    import shutil
    shutil.rmtree(extract_dir)
    
    api.logout()

if __name__ == "__main__":
    import sys
    if len(sys.argv) < 2:
        print("用法: python restore_config.py <backup_file>")
        sys.exit(1)
    restore_zabbix_config(sys.argv[1])

#!/usr/bin/env python3
"""
变更审计日志
"""

from zabbix_api import ZabbixAPI
from datetime import datetime
import json

def audit_changes(days: int = 7):
    api = ZabbixAPI(
        url="http://zabbix-server/api_jsonrpc.php",
        user="Admin",
        password="zabbix"
    )
    api.login()
    
    # 获取最近的审计日志
    audit_logs = api.call("auditlog.get", {
        "output": "extend",
        "limit": 1000,
        "sortfield": "clock",
        "sortorder": "DESC"
    })
    
    # 按用户分组统计
    user_changes = {}
    for log in audit_logs:
        user = log["userid"]
        if user not in user_changes:
            user_changes[user] = []
        user_changes[user].append(log)
    
    # 输出审计报告
    print("=" * 60)
    print(f"Zabbix变更审计报告（最近{days}天）")
    print("=" * 60)
    
    for user_id, changes in user_changes.items():
        user_info = api.call("user.get", {"userids": [user_id]})
        if user_info:
            username = user_info[0]["alias"]
        else:
            username = user_id
        
        print(f"\n用户: {username}")
        print(f"变更次数: {len(changes)}")
        
        for change in changes[:5]:  # 只显示前5条
            timestamp = datetime.fromtimestamp(int(change["clock"]))
            print(f"  [{timestamp}] {change['action']} - {change['resourcetype']}")
    
    api.logout()

if __name__ == "__main__":
    audit_changes()

# 添加调试日志
import requests

response = requests.post(url, data=json.dumps(payload), headers=headers)
print(f"Status Code: {response.status_code}")
print(f"Response: {response.text}")

# 检查错误信息
result = response.json()
if "error" in result:
    print(f"Error Code: {result['error']['code']}")
    print(f"Error Message: {result['error']['message']}")
    print(f"Error Data: {result['error']['data']}")