import socket
import sys
import yaml
import subprocess
from concurrent.futures import ThreadPoolExecutor, as_completed

# 配置参数 - 在此处定义相关常量
NETWORK_PREFIX = "172.17."  # 网段前缀
SCAN_SUBNET_RANGES = [(0, 2)]  # 要扫描的子网范围，例如[(0, 2), (5, 7)]
SCAN_PORT = 9100  # node_exporter默认端口
PROMETHEUS_CONFIG_PATH = "/opt/prometheus/prometheus/prometheus.yml"  # prometheus配置文件路径
RELOAD_URL = "http://localhost:9090/-/reload"  # 重新加载地址
TARGET_JOB_NAME = "xnyh_mini"  # 目标Job名称（在此处统一定义）
DEFAULT_TIMEOUT = 1  # 超时时间（秒）
DEFAULT_MAX_WORKERS = 64  # 最大线程数


def check_port(ip, port, timeout):
    """检查指定IP的指定端口是否开放"""
    try:
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
            sock.settimeout(timeout)
            result = sock.connect_ex((ip, port))
            return result == 0
    except socket.error:
        return False


def scan_subnets():
    """扫描配置中定义的所有子网段落的指定端口"""
    open_targets = []

    with ThreadPoolExecutor(max_workers=DEFAULT_MAX_WORKERS) as executor:
        for subnet in SCAN_SUBNET_RANGES:
            start_subnet, end_subnet = subnet
            for current_subnet in range(start_subnet, end_subnet + 1):
                current_prefix = f"{NETWORK_PREFIX}{current_subnet}."
                future_to_ip = {
                    executor.submit(check_port, f"{current_prefix}{i}", SCAN_PORT, DEFAULT_TIMEOUT): 
                    f"{current_prefix}{i}:{SCAN_PORT}" 
                    for i in range(1, 255)
                }

                for future in as_completed(future_to_ip):
                    target = future_to_ip[future]
                    try:
                        if future.result():
                            print(f"发现开放端口: {target}")
                            open_targets.append(target)
                    except Exception as exc:
                        print(f"扫描{target}时出错: {exc}")

    return open_targets


def get_existing_targets():
    """从prometheus配置文件中获取已存在的targets"""
    try:
        with open(PROMETHEUS_CONFIG_PATH, 'r') as f:
            config = yaml.safe_load(f)
        
        # 使用开头定义的TARGET_JOB_NAME常量
        for job in config.get('scrape_configs', []):
            if job.get('job_name') == TARGET_JOB_NAME:
                existing = set()
                for static_config in job.get('static_configs', []):
                    existing.update(static_config.get('targets', []))
                return existing
        return set()
    except Exception as e:
        print(f"读取prometheus配置失败: {e}")
        sys.exit(1)


def add_new_targets(new_targets):
    """向prometheus配置添加新的targets"""
    if not new_targets:
        return False

    try:
        with open(PROMETHEUS_CONFIG_PATH, 'r') as f:
            config = yaml.safe_load(f)

        # 使用开头定义的TARGET_JOB_NAME常量
        for job in config.get('scrape_configs', []):
            if job.get('job_name') == TARGET_JOB_NAME:
                for target in new_targets:
                    # 保持与现有配置一致的格式（单个targets项）
                    job['static_configs'].append({'targets': [target]})
                    print(f"已添加新目标: {target}")
                
                with open(PROMETHEUS_CONFIG_PATH, 'w') as f:
                    yaml.dump(config, f, sort_keys=False, default_flow_style=False, allow_unicode=True)
                return True
        return False
    except Exception as e:
        print(f"更新prometheus配置失败: {e}")
        return False


def reload_prometheus():
    """发送重新加载请求到prometheus"""
    try:
        result = subprocess.run(
            ['curl', '-X', 'POST', RELOAD_URL],
            check=True,
            stdout=subprocess.PIPE,  # 捕获标准输出
            stderr=subprocess.PIPE,  # 捕获标准错误
        )
        if result.returncode == 0:
            print("Prometheus配置已成功重新加载")
        else:
            print("重新加载Prometheus失败:", result.stderr)
            return False
        return True
    except subprocess.CalledProcessError as e:
        print(f"重新加载Prometheus失败: {e.stderr}")
        return False


def main():
    print(f"开始扫描网段 {NETWORK_PREFIX} 下的子网 {SCAN_SUBNET_RANGES} 的 {SCAN_PORT} 端口...\n")
    
    open_targets = scan_subnets()
    if not open_targets:
        print("未发现开放的9100端口")
        return

    existing_targets = get_existing_targets()
    print(f"\n已存在的目标数量: {len(existing_targets)}")

    new_targets = [t for t in open_targets if t not in existing_targets]
    if not new_targets:
        print("没有需要添加的新目标")
        return

    print(f"\n需要添加的新目标数量: {len(new_targets)}")

    if add_new_targets(new_targets):
        reload_prometheus()


if __name__ == "__main__":
    main()

import socket
import sys
from concurrent.futures import ThreadPoolExecutor, as_completed

# 定义默认的端口和超时时间
NETWORK_PREFIX = "172.17."  # 网段前缀
DEFAULT_PORT = 22
DEFAULT_TIMEOUT = 1  # 超时时间（秒）
DEFAULT_MAX_WORKERS = 64  # 最大线程数


def check_port(ip, port, timeout):
    """
    检查指定IP的指定端口是否开放。

    :param ip: 要检查的IP地址
    :param port: 要检查的端口号
    :param timeout: 连接超时时间
    :return: 如果端口开放，返回True，否则返回False
    """
    try:
        # 创建一个TCP套接字
        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
            # 设置超时时间
            sock.settimeout(timeout)
            # 尝试连接
            result = sock.connect_ex((ip, port))
            if result == 0:
                return True
    except socket.error:
        pass
    return False


def scan_subnet(network_prefix, subnet_range, port, timeout, max_workers):
    """
    扫描指定范围内的多个子网中指定端口的开放情况。

    :param network_prefix: 网段前缀，例如 "10.4."
    :param subnet_range: 子网范围，例如 (0, 99)
    :param port: 要扫描的端口号
    :param timeout: 连接超时时间
    :param max_workers: 最大线程数
    """
    open_ips = []  # 存储开放端口的IP列表

    # 使用线程池加快扫描速度
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        # 遍历子网范围
        for subnet in range(subnet_range[0], subnet_range[1] + 1):
            current_prefix = f"{network_prefix}{subnet}."
            # 为当前子网的每个IP地址提交一个检查任务
            future_to_ip = {executor.submit(check_port, f"{current_prefix}{i}", port, timeout): f"{current_prefix}{i}"
                            for i in range(1, 255)}

            # 逐个获取完成的任务结果
            for future in as_completed(future_to_ip):
                ip = future_to_ip[future]
                try:
                    if future.result():
                        print(f"端口 {port} 在 {ip} 上是开放的。")
                        open_ips.append(ip)
                except Exception as exc:
                    print(f"{ip} 生成异常: {exc}")

    # 输出所有开放端口的IP
    print("\n扫描完成。以下IP的端口开放：")
    for ip in open_ips:
        print(ip)


def parse_arguments():
    """
    解析命令行参数，获取子网范围。

    :return: 起始子网和结束子网
    """
    if len(sys.argv) != 3:
        print("使用方法: python port_scan.py 起始子网 结束子网")
        print("例如: python port_scan.py 0 99")
        sys.exit(1)
    try:
        start = int(sys.argv[1])
        end = int(sys.argv[2])
        if start < 0 or end > 255 or start > end:
            raise ValueError
        return (start, end)
    except ValueError:
        print("子网范围必须是0到255之间的整数，且起始子网不大于结束子网。")
        sys.exit(1)


if __name__ == "__main__":
    # 解析命令行参数获取子网范围
    subnet_range = parse_arguments()

    NETWORK_PREFIX = NETWORK_PREFIX  # 网段前缀
    PORT = DEFAULT_PORT  # 要扫描的端口号
    TIMEOUT = DEFAULT_TIMEOUT  # 连接超时时间
    MAX_WORKERS = DEFAULT_MAX_WORKERS  # 最大线程数

    print(f"开始扫描网段 {NETWORK_PREFIX}{subnet_range[0]}.0/24 到 {NETWORK_PREFIX}{subnet_range[1]}.0/24 的端口 {PORT}。\n")

    scan_subnet(NETWORK_PREFIX, subnet_range, PORT, TIMEOUT, MAX_WORKERS)