Add admin panel, manager, node_manager, bandwidth limiter, connection limiter, bonding, failover, vless encryption, mkcp transport

service/manager/repository/postgresql/filter.go

@@ -0,0 +1,155 @@
+package postgresql
+
+import (
+	"encoding/json"
+	"strconv"
+
+	"github.com/huandu/go-sqlbuilder"
+	"github.com/sagernet/sing/common/byteformats"
+)
+
+type Filter func(sb *sqlbuilder.SelectBuilder, value []string) error
+
+func EqualFilter(field string) Filter {
+	return func(sb *sqlbuilder.SelectBuilder, value []string) error {
+		sb.Where(sb.Equal(field, value[0]))
+		return nil
+	}
+}
+
+func EqualOrNullFilter(field string) Filter {
+	return func(sb *sqlbuilder.SelectBuilder, value []string) error {
+		sb.Where(sb.Or(sb.Equal(field, value[0]), sb.IsNull(field)))
+		return nil
+	}
+}
+
+func GreaterThanFilter(field string) Filter {
+	return func(sb *sqlbuilder.SelectBuilder, value []string) error {
+		sb.Where(sb.GreaterThan(field, value[0]))
+		return nil
+	}
+}
+
+func LessThanFilter(field string) Filter {
+	return func(sb *sqlbuilder.SelectBuilder, value []string) error {
+		sb.Where(sb.LessThan(field, value[0]))
+		return nil
+	}
+}
+
+func GreaterEqualThanFilter(field string) Filter {
+	return func(sb *sqlbuilder.SelectBuilder, value []string) error {
+		sb.Where(sb.GreaterEqualThan(field, value[0]))
+		return nil
+	}
+}
+
+func LessEqualThanFilter(field string) Filter {
+	return func(sb *sqlbuilder.SelectBuilder, value []string) error {
+		sb.Where(sb.LessEqualThan(field, value[0]))
+		return nil
+	}
+}
+
+func SpeedGreaterEqualThanFilter(field string) Filter {
+	return func(sb *sqlbuilder.SelectBuilder, value []string) error {
+		bytesSpeed, err := json.Marshal(value[0])
+		if err != nil {
+			return err
+		}
+		speed := &byteformats.NetworkBytesCompat{}
+		err = speed.UnmarshalJSON(bytesSpeed)
+		if err != nil {
+			return err
+		}
+		sb.Where(sb.GreaterEqualThan(field, speed.Value()))
+		return nil
+	}
+}
+
+func SpeedLessEqualThanFilter(field string) Filter {
+	return func(sb *sqlbuilder.SelectBuilder, value []string) error {
+		bytesSpeed, err := json.Marshal(value[0])
+		if err != nil {
+			return err
+		}
+		speed := &byteformats.NetworkBytesCompat{}
+		err = speed.UnmarshalJSON(bytesSpeed)
+		if err != nil {
+			return err
+		}
+		sb.Where(sb.LessEqualThan(field, speed.Value()))
+		return nil
+	}
+}
+
+func ExistsAndWhereInFilter(subquery *sqlbuilder.SelectBuilder, field string) Filter {
+	return func(sb *sqlbuilder.SelectBuilder, value []string) error {
+		values := make([]interface{}, len(value))
+		for i, v := range value {
+			values[i] = v
+		}
+		subquery.Where(subquery.In(field, values...))
+		sb.Where(sb.Exists(subquery))
+		return nil
+	}
+}
+
+func SortAscFilter() Filter {
+	return func(sb *sqlbuilder.SelectBuilder, value []string) error {
+		sb.OrderByAsc(value[0])
+		return nil
+	}
+}
+
+func SortDescFilter() Filter {
+	return func(sb *sqlbuilder.SelectBuilder, value []string) error {
+		sb.OrderByDesc(value[0])
+		return nil
+	}
+}
+
+func ReplacedSortAscFilter(replace map[string]string) Filter {
+	return func(sb *sqlbuilder.SelectBuilder, value []string) error {
+		if replacedValue, ok := replace[value[0]]; ok {
+			sb.OrderByAsc(replacedValue)
+		} else {
+			sb.OrderByAsc(value[0])
+		}
+		return nil
+	}
+}
+
+func ReplacedSortDescFilter(replace map[string]string) Filter {
+	return func(sb *sqlbuilder.SelectBuilder, value []string) error {
+		if replacedValue, ok := replace[value[0]]; ok {
+			sb.OrderByDesc(replacedValue)
+		} else {
+			sb.OrderByDesc(value[0])
+		}
+		return nil
+	}
+}
+
+func LimitFilter() Filter {
+	return func(sb *sqlbuilder.SelectBuilder, value []string) error {
+		limit, err := strconv.Atoi(value[0])
+		if err != nil {
+			return err
+		}
+		sb.Limit(limit)
+		return nil
+	}
+}
+
+func OffsetFilter() Filter {
+	return func(sb *sqlbuilder.SelectBuilder, value []string) error {
+		offset, err := strconv.Atoi(value[0])
+		if err != nil {
+			return err
+		}
+		sb.Offset(offset)
+		return nil
+	}
+}

service/manager/repository/postgresql/migration.go

@@ -0,0 +1,132 @@
+package postgresql
+
+import (
+	"database/sql"
+
+	"github.com/golang-migrate/migrate/v4"
+	"github.com/golang-migrate/migrate/v4/database/postgres"
+	"github.com/sagernet/sing-box/common/migrate/source"
+)
+
+var migrations = map[string]string{
+	"1_initialize_schema.up.sql": `
+        CREATE TABLE squads (
+            id          SERIAL PRIMARY KEY,
+            name        TEXT NOT NULL UNIQUE,
+            created_at  TIMESTAMP NOT NULL,
+            updated_at  TIMESTAMP NOT NULL
+        );
+
+        CREATE TABLE nodes (
+            uuid        VARCHAR(36) PRIMARY KEY,
+            name        TEXT NOT NULL UNIQUE,
+            created_at  TIMESTAMP NOT NULL,
+            updated_at  TIMESTAMP NOT NULL
+        );
+
+        CREATE TABLE node_to_squad (
+            node_uuid VARCHAR(36) NOT NULL,
+            squad_id INTEGER NOT NULL,
+            PRIMARY KEY (node_uuid, squad_id),
+            FOREIGN KEY (node_uuid) REFERENCES nodes(uuid) ON DELETE CASCADE,
+            FOREIGN KEY (squad_id) REFERENCES squads(id) ON DELETE RESTRICT
+        );
+
+        CREATE TABLE users (
+            id          SERIAL PRIMARY KEY,
+            node_uuid   VARCHAR(36),
+            username    TEXT NOT NULL,
+            type        TEXT NOT NULL,
+            inbound     TEXT NOT NULL,
+            uuid        TEXT NOT NULL,
+            password    TEXT NOT NULL,
+            flow        TEXT NOT NULL,
+            alter_id    INTEGER NOT NULL,
+            created_at  TIMESTAMP NOT NULL,
+            updated_at  TIMESTAMP NOT NULL,
+            UNIQUE (username, inbound)
+        );
+
+        CREATE TABLE user_to_squad (
+            user_id  INTEGER NOT NULL,
+            squad_id INTEGER NOT NULL,
+            PRIMARY KEY (user_id, squad_id),
+            FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE CASCADE,
+            FOREIGN KEY (squad_id) REFERENCES squads(id) ON DELETE RESTRICT
+        );
+
+        CREATE TABLE connection_limiters (
+            id              SERIAL PRIMARY KEY,
+            username        TEXT NOT NULL,
+            outbound        TEXT NOT NULL,
+            strategy        TEXT NOT NULL,
+            connection_type TEXT NOT NULL,
+            lock_type       TEXT NOT NULL,
+            count           INTEGER NOT NULL,
+            created_at      TIMESTAMP NOT NULL,
+            updated_at      TIMESTAMP NOT NULL,
+            UNIQUE (username, outbound)
+        );
+
+        CREATE TABLE connection_limiter_to_squad (
+            connection_limiter_id  INTEGER NOT NULL,
+            squad_id INTEGER NOT NULL,
+            PRIMARY KEY (connection_limiter_id, squad_id),
+            FOREIGN KEY (connection_limiter_id) REFERENCES connection_limiters(id) ON DELETE CASCADE,
+            FOREIGN KEY (squad_id) REFERENCES squads(id) ON DELETE RESTRICT
+        );
+
+        CREATE TABLE bandwidth_limiters (
+            id              SERIAL PRIMARY KEY,
+            username        TEXT NOT NULL,
+            outbound        TEXT NOT NULL,
+            strategy        TEXT NOT NULL,
+            mode            TEXT NOT NULL,
+            connection_type TEXT NOT NULL,
+            speed           TEXT NOT NULL,
+            raw_speed       BIGINT NOT NULL DEFAULT 0,
+            created_at      TIMESTAMP NOT NULL,
+            updated_at      TIMESTAMP NOT NULL,
+            UNIQUE (username, outbound)
+        );
+
+        CREATE TABLE bandwidth_limiter_to_squad (
+            bandwidth_limiter_id  INTEGER NOT NULL,
+            squad_id INTEGER NOT NULL,
+            PRIMARY KEY (bandwidth_limiter_id, squad_id),
+            FOREIGN KEY (bandwidth_limiter_id) REFERENCES bandwidth_limiters(id) ON DELETE CASCADE,
+            FOREIGN KEY (squad_id) REFERENCES squads(id) ON DELETE RESTRICT
+        );
+    `,
+	"1_initialize_schema.down.sql": `
+	 	DROP TABLE IF EXISTS squas;
+        DROP TABLE IF EXISTS nodes;
+        DROP TABLE IF EXISTS users;
+        DROP TABLE IF EXISTS bandwidth_limiters;
+        DROP TABLE IF EXISTS connection_limiters;
+    `,
+}
+
+func Migrate(db *sql.DB) error {
+	driver, err := postgres.WithInstance(db, &postgres.Config{})
+	if err != nil {
+		return err
+	}
+
+	sourceDriver := source.NewRawDriver(migrations)
+	if err := sourceDriver.Init(); err != nil {
+		return err
+	}
+
+	m, err := migrate.NewWithInstance(
+		"raw",
+		sourceDriver,
+		"postgres",
+		driver,
+	)
+	if err != nil {
+		return err
+	}
+
+	return m.Up()
+}