کتابخانه‌های رسمی

go get github.com/PasarGuard/node_bridge

package main

import (
    "context"
    "log"

    bridge "github.com/PasarGuard/node_bridge"
)

package main

import (
    "context"
    "log"
    
    "github.com/PasarGuard/node_bridge"
    pb "github.com/PasarGuard/node_bridge/proto"
)

func main() {
    client, _ := nodebridge.NewClient("https://node:443", "session-id")
    defer client.Close()

    backend := &pb.Backend{
        Type: pb.BackendType_XRAY,
        Config: `{
            "log": {"loglevel": "warning"},
            "inbounds": [...],
            "outbounds": [...]
        }`,
        Users: []*pb.User{
            {
                Email: "user1@example.com",
                Proxies: &pb.Proxy{
                    Vmess: &pb.Vmess{
                        Id: "uuid-here",
                    },
                },
                Inbounds: []string{"inbound-tag"},
            },
        },
        KeepAlive: 60,
    }

    info, err := client.Start(context.Background(), backend)
    if err != nil {
        log.Fatal(err)
    }
    
    log.Printf("بکند شروع شد: %v", info)
}

// همگام‌سازی یک کاربر
user := &pb.User{
    Email: "newuser@example.com",
    Proxies: &pb.Proxy{
        Vmess: &pb.Vmess{Id: "uuid"},
    },
    Inbounds: []string{"inbound-tag"},
}

err := client.SyncUser(context.Background(), user)
if err != nil {
    log.Fatal(err)
}

// حذف کاربر (ورودی‌های خالی)
user.Inbounds = []string{}
err = client.SyncUser(context.Background(), user)

// دریافت آمار تمام کاربران
statsReq := &pb.StatRequest{
    Type: pb.StatType_UsersStat,
    Reset: false,
}

stats, err := client.GetStats(context.Background(), statsReq)
if err != nil {
    log.Fatal(err)
}

for _, stat := range stats.Stats {
    log.Printf("کاربر: %s، ترافیک: %d بایت", stat.Name, stat.Value)
}

// دریافت آمار یک کاربر خاص و ریست کردن
userStatsReq := &pb.StatRequest{
    Name: "user@example.com",
    Type: pb.StatType_UserStat,
    Reset: true,
}

userStats, err := client.GetStats(context.Background(), userStatsReq)

ctx := context.Background()
logStream, err := client.GetLogs(ctx)
if err != nil {
    log.Fatal(err)
}

for {
    logMsg, err := logStream.Recv()
    if err != nil {
        log.Fatal(err)
    }

    log.Printf("لاگ بکند: %s", logMsg.Detail)
}

sysStats, err := client.GetSystemStats(context.Background())
if err != nil {
    log.Fatal(err)
}

log.Printf("استفاده CPU: %.2f%%", sysStats.CpuUsage)
log.Printf("حافظه: %d/%d MB",
    sysStats.MemUsed/1024/1024,
    sysStats.MemTotal/1024/1024)

client, err := nodebridge.NewGRPCClient(
    "node:50051",
    "session-id",
    grpc.WithTransportCredentials(...),
)

ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
defer cancel()

info, err := client.GetBaseInfo(ctx)

import "google.golang.org/grpc/codes"
import "google.golang.org/grpc/status"

info, err := client.GetBaseInfo(ctx)
if err != nil {
    st, ok := status.FromError(err)
    if ok {
        switch st.Code() {
        case codes.Unauthenticated:
            log.Println("session ID نامعتبره")
        case codes.Unavailable:
            log.Println("نود در دسترس نیست")
        default:
            log.Printf("خطا: %v", st.Message())
        }
    }
}

pip install pasarguard-node-bridge

from pasarguard_node_bridge import NodeClient

# ایجاد کلاینت
client = NodeClient(
    url="https://your-node:443",
    session_id="your-session-id"
)

# دریافت اطلاعات نود
info = client.get_base_info()
print(f"نسخه نود: {info.version}، در حال اجرا: {info.running}")

from pasarguard_node_bridge import NodeClient, Backend, User, Proxy, Vmess

client = NodeClient("https://node:443", "session-id")

backend = Backend(
    type=Backend.Type.XRAY,
    config="""{
        "log": {"loglevel": "warning"},
        "inbounds": [...],
        "outbounds": [...]
    }""",
    users=[
        User(
            email="user1@example.com",
            proxies=Proxy(
                vmess=Vmess(id="uuid-here")
            ),
            inbounds=["inbound-tag"]
        )
    ],
    keep_alive=60
)

info = client.start(backend)
print(f"بکند شروع شد: {info}")

from pasarguard_node_bridge import User, Proxy, Vmess

# اضافه/به‌روزرسانی کاربر
user = User(
    email="newuser@example.com",
    proxies=Proxy(
        vmess=Vmess(id="uuid")
    ),
    inbounds=["inbound-tag"]
)

client.sync_user(user)

# حذف کاربر (ورودی‌های خالی)
user.inbounds = []
client.sync_user(user)

from pasarguard_node_bridge import StatRequest, StatType

# دریافت آمار تمام کاربران
stats_req = StatRequest(
    type=StatType.USERS_STAT,
    reset=False
)

stats = client.get_stats(stats_req)
for stat in stats.stats:
    print(f"کاربر: {stat.name}، ترافیک: {stat.value} بایت")

# دریافت آمار یک کاربر خاص
user_stats_req = StatRequest(
    name="user@example.com",
    type=StatType.USER_STAT,
    reset=True
)

user_stats = client.get_stats(user_stats_req)

# مشاهده لاگ‌ها به صورت لحظه‌ای
for log in client.get_logs():
    print(f"لاگ بکند: {log.detail}")

sys_stats = client.get_system_stats()

print(f"استفاده CPU: {sys_stats.cpu_usage:.2f}%")
print(f"حافظه: {sys_stats.mem_used/1024/1024}/{sys_stats.mem_total/1024/1024} MB")
print(f"دانلود: {sys_stats.incoming_bandwidth_speed/1024/1024:.2f} MB/s")
print(f"آپلود: {sys_stats.outgoing_bandwidth_speed/1024/1024:.2f} MB/s")

online_req = StatRequest(
    name="user@example.com",
    type=StatType.USER_STAT
)

online_stats = client.get_user_online_stats(online_req)
print(f"کاربر {online_stats.value} تا اتصال فعال داره")

# دریافت لیست IP
ip_list = client.get_user_online_ip_list(online_req)
for ip, count in ip_list.value.items():
    print(f"IP: {ip}، تعداد اتصال: {count}")

from pasarguard_node_bridge import AsyncNodeClient

async def main():
    client = AsyncNodeClient("https://node:443", "session-id")

    info = await client.get_base_info()
    print(info)

    await client.close()

# اجرا با asyncio
import asyncio
asyncio.run(main())

from pasarguard_node_bridge import NodeError, AuthenticationError

try:
    info = client.get_base_info()
except AuthenticationError:
    print("session ID نامعتبره")
except NodeError as e:
    print(f"خطای نود: {e}")
except Exception as e:
    print(f"خطای غیرمنتظره: {e}")

client = NodeClient(
    url="node:50051",
    session_id="session-id",
    use_grpc=True
)

// همیشه کلاینت‌ها را ببندید
defer client.Close()

# استفاده از context manager
with NodeClient(url, session_id) as client:
    # استفاده از کلاینت
    pass

# یا بستن دستی
client.close()