@tachybase/test 0.23.8

package/lib/index.d.ts

@@ -0,0 +1 @@
+export * from './server';

package/lib/index.js

@@ -0,0 +1,21 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./server"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./server")
+});

package/lib/scripts/test-db-creator.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/scripts/test-db-creator.js

@@ -0,0 +1,163 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_http = __toESM(require("http"));
+var import_path = __toESM(require("path"));
+var import_url = __toESM(require("url"));
+var import_dotenv = __toESM(require("dotenv"));
+var import_mariadb = __toESM(require("mariadb"));
+var import_promise = __toESM(require("mysql2/promise"));
+var import_pg = __toESM(require("pg"));
+import_dotenv.default.config({ path: import_path.default.resolve(process.cwd(), ".env.test") });
+const _BaseClient = class _BaseClient {
+  _client = null;
+  createdDBs = /* @__PURE__ */ new Set();
+  async createDB(name) {
+    if (this.createdDBs.has(name)) {
+      return;
+    }
+    if (!this._client) {
+      this._client = await this._createConnection();
+    }
+    await this._createDB(name);
+    this.createdDBs.add(name);
+  }
+  async releaseAll() {
+    if (!this._client) {
+      return;
+    }
+    const dbNames = Array.from(this.createdDBs);
+    for (const name of dbNames) {
+      console.log(`Removing database: ${name}`);
+      await this._removeDB(name);
+      this.createdDBs.delete(name);
+    }
+  }
+};
+__name(_BaseClient, "BaseClient");
+let BaseClient = _BaseClient;
+const _PostgresClient = class _PostgresClient extends BaseClient {
+  async _removeDB(name) {
+    await this._client.query(`DROP DATABASE IF EXISTS ${name}`);
+  }
+  async _createDB(name) {
+    await this._client.query(`DROP DATABASE IF EXISTS ${name}`);
+    await this._client.query(`CREATE DATABASE ${name};`);
+  }
+  async _createConnection() {
+    const client2 = new import_pg.default.Client({
+      host: process.env["DB_HOST"],
+      port: Number(process.env["DB_PORT"]),
+      user: process.env["DB_USER"],
+      password: process.env["DB_PASSWORD"],
+      database: process.env["DB_DATABASE"]
+    });
+    await client2.connect();
+    return client2;
+  }
+};
+__name(_PostgresClient, "PostgresClient");
+let PostgresClient = _PostgresClient;
+const _MySQLClient = class _MySQLClient extends BaseClient {
+  async _removeDB(name) {
+    await this._client.query(`DROP DATABASE IF EXISTS ${name}`);
+  }
+  async _createDB(name) {
+    await this._client.query(`CREATE DATABASE IF NOT EXISTS ${name}`);
+  }
+  async _createConnection() {
+    return import_promise.default.createConnection({
+      host: process.env["DB_HOST"],
+      port: Number(process.env["DB_PORT"]),
+      user: process.env["DB_USER"],
+      password: process.env["DB_PASSWORD"],
+      database: process.env["DB_DATABASE"]
+    });
+  }
+};
+__name(_MySQLClient, "MySQLClient");
+let MySQLClient = _MySQLClient;
+const _MariaDBClient = class _MariaDBClient extends BaseClient {
+  async _removeDB(name) {
+    await this._client.query(`DROP DATABASE IF EXISTS ${name}`);
+  }
+  async _createDB(name) {
+    await this._client.query(`CREATE DATABASE IF NOT EXISTS ${name}`);
+  }
+  async _createConnection() {
+    return await import_mariadb.default.createConnection({
+      host: process.env["DB_HOST"],
+      port: Number(process.env["DB_PORT"]),
+      user: process.env["DB_USER"],
+      password: process.env["DB_PASSWORD"],
+      database: process.env["DB_DATABASE"]
+    });
+  }
+};
+__name(_MariaDBClient, "MariaDBClient");
+let MariaDBClient = _MariaDBClient;
+const client = {
+  postgres: /* @__PURE__ */ __name(() => {
+    return new PostgresClient();
+  }, "postgres"),
+  mysql: /* @__PURE__ */ __name(() => {
+    return new MySQLClient();
+  }, "mysql"),
+  mariadb: /* @__PURE__ */ __name(() => {
+    return new MariaDBClient();
+  }, "mariadb")
+};
+const dialect = process.env["DB_DIALECT"];
+if (!client[dialect]) {
+  throw new Error(`Unknown dialect: ${dialect}`);
+}
+const dbClient = client[dialect]();
+const server = import_http.default.createServer((req, res) => {
+  const parsedUrl = import_url.default.parse(req.url, true);
+  const path2 = parsedUrl.pathname;
+  const trimmedPath = path2.replace(/^\/+|\/+$/g, "");
+  if (trimmedPath === "acquire") {
+    const name = parsedUrl.query.name;
+    dbClient.createDB(name).then(() => {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end();
+    }).catch((error) => {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error }));
+    });
+  } else if (trimmedPath === "release") {
+    dbClient.releaseAll().then(() => {
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end();
+    }).catch((error) => {
+      res.writeHead(500, { "Content-Type": "application/json" });
+      res.end(JSON.stringify({ error }));
+    });
+  } else {
+    res.writeHead(404, { "Content-Type": "text/plain" });
+    res.end("Not Found\n");
+  }
+});
+server.listen(23450, "127.0.0.1", () => {
+  console.log("Server is running at http://127.0.0.1:23450/");
+});

package/lib/scripts/test-db-distributor.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/scripts/test-db-distributor.js

@@ -0,0 +1,234 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var import_fs = __toESM(require("fs"));
+var import_http = __toESM(require("http"));
+var import_path = __toESM(require("path"));
+var import_url = __toESM(require("url"));
+var import_dotenv = __toESM(require("dotenv"));
+var import_pg = __toESM(require("pg"));
+import_dotenv.default.config({ path: import_path.default.resolve(process.cwd(), ".env.test") });
+const delay = /* @__PURE__ */ __name((ms) => new Promise((resolve) => setTimeout(resolve, ms)), "delay");
+const _DBManager = class _DBManager {
+  acquiredDBs = /* @__PURE__ */ new Map();
+  acquire(name, via) {
+    console.log("acquire", name, "via", via);
+    if (this.acquiredDBs.has(name)) {
+      this.acquiredDBs.get(name).add(via);
+    } else {
+      this.acquiredDBs.set(name, /* @__PURE__ */ new Set([via]));
+    }
+  }
+  async release(name, via, relaseDb) {
+    var _a;
+    console.log("release", name, "via", via);
+    const vias = this.acquiredDBs.get(name);
+    if (!vias || !vias.has(via)) {
+      console.log(`Cannot release ${name}, it is not acquired via ${via}`);
+      return;
+    }
+    vias.delete(via);
+    if (vias.size === 0) {
+      console.log("DB", name, "is not used anymore, release it");
+      await delay(1e3);
+      if (((_a = this.acquiredDBs.get(name)) == null ? void 0 : _a.size) === 0) {
+        console.log("start to release DB", name);
+        await (relaseDb == null ? void 0 : relaseDb());
+        this.acquiredDBs.delete(name);
+        console.log("DB", name, "is released, current usesd db count:", this.acquiredDBs.size);
+      }
+    }
+    return null;
+  }
+  isAcquired(name) {
+    return this.acquiredDBs.has(name);
+  }
+};
+__name(_DBManager, "DBManager");
+let DBManager = _DBManager;
+const getDBNames = /* @__PURE__ */ __name((size, name) => {
+  const names = [];
+  for (let i = 0; i < size; i++) {
+    names.push(`auto_named_${name}_${i}`);
+  }
+  return names;
+}, "getDBNames");
+const _BasePool = class _BasePool {
+  constructor(size) {
+    this.size = size;
+  }
+  dbManager = new DBManager();
+  async init() {
+    const promises = [];
+    for (const name of getDBNames(this.size, this.getConfiguredDatabaseName())) {
+      promises.push(
+        (async () => {
+          console.log("create database", name);
+          await this.createDatabase(name);
+        })()
+      );
+    }
+    await Promise.all(promises);
+  }
+  async acquire(name, via) {
+    if (!name) {
+      name = getDBNames(this.size, this.getConfiguredDatabaseName()).find((name2) => !this.dbManager.isAcquired(name2));
+    }
+    if (!name) {
+      throw new Error("No available database");
+    }
+    this.dbManager.acquire(name, via);
+    return name;
+  }
+  async release(name, via) {
+    await this.dbManager.release(name, via, async () => {
+      await this.cleanDatabase(name);
+    });
+  }
+};
+__name(_BasePool, "BasePool");
+let BasePool = _BasePool;
+const _PostgresPool = class _PostgresPool extends BasePool {
+  async _createConnection(options, callback) {
+    const config = this.getDatabaseConfiguration();
+    const databaseName = this.getConfiguredDatabaseName();
+    const client = new import_pg.default.Client({
+      host: config["host"],
+      port: config["port"],
+      user: config["username"],
+      password: config["password"],
+      database: databaseName,
+      ...options
+    });
+    await client.connect();
+    await callback(client);
+    await client.end();
+  }
+  async cleanDatabase(name) {
+    await this._createConnection({ database: name }, async (client) => {
+      await client.query(`DROP SCHEMA public CASCADE;CREATE SCHEMA public;`);
+    });
+  }
+  async createDatabase(name, options) {
+    const { log } = options || {};
+    await this._createConnection({}, async (client) => {
+      if (log) {
+        console.log(`DROP DATABASE IF EXISTS ${name}`);
+      }
+      await client.query(`DROP DATABASE IF EXISTS ${name}`);
+      if (log) {
+        console.log(`CREATE DATABASE ${name}`);
+      }
+      await client.query(`CREATE DATABASE ${name}`);
+      if (log) {
+        console.log(`end`);
+      }
+    });
+  }
+  getDatabaseConfiguration() {
+    return {
+      host: process.env.DB_HOST,
+      port: process.env.DB_PORT,
+      username: process.env.DB_USERNAME,
+      password: process.env.DB_PASSWORD
+    };
+  }
+  getConfiguredDatabaseName() {
+    return process.env.DB_DATABASE;
+  }
+};
+__name(_PostgresPool, "PostgresPool");
+let PostgresPool = _PostgresPool;
+const _SqlitePool = class _SqlitePool extends BasePool {
+  async createDatabase(name, options) {
+    return import_fs.default.promises.writeFile(import_path.default.resolve(this.getStoragePath(), name), "");
+  }
+  async cleanDatabase(name) {
+    return import_fs.default.promises.unlink(import_path.default.resolve(this.getStoragePath(), name));
+  }
+  getDatabaseConfiguration() {
+    return {
+      storage: process.env.DB_STORAGE
+    };
+  }
+  getConfiguredDatabaseName() {
+    const storagePath = process.env.DB_STORAGE;
+    if (storagePath && storagePath !== ":memory:") {
+      return import_path.default.basename(storagePath);
+    }
+  }
+  getStoragePath() {
+    const storagePath = process.env.DB_STORAGE;
+    if (storagePath && storagePath !== ":memory:") {
+      return import_path.default.dirname(storagePath);
+    }
+  }
+};
+__name(_SqlitePool, "SqlitePool");
+let SqlitePool = _SqlitePool;
+const pools = {
+  postgres: PostgresPool,
+  sqlite: SqlitePool
+};
+(async () => {
+  const poolSize = process.env.TEST_DB_POOL_SIZE || 100;
+  const poolClass = pools[process.env.DB_DIALECT];
+  if (!poolClass) {
+    throw new Error(`Unknown pool class ${process.env.DB_DIALECT}`);
+  }
+  const pool = new poolClass(poolSize);
+  await pool.init();
+  return pool;
+})().then((pool) => {
+  const server = import_http.default.createServer((req, res) => {
+    const parsedUrl = import_url.default.parse(req.url, true);
+    const path2 = parsedUrl.pathname;
+    const trimmedPath = path2.replace(/^\/+|\/+$/g, "");
+    if (trimmedPath === "acquire") {
+      const via = parsedUrl.query.via;
+      const name = parsedUrl.query.name;
+      pool.acquire(name, via).then((name2) => {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ name: name2 }));
+      }).catch((err) => {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ error: err.message }));
+      });
+    } else if (trimmedPath === "release") {
+      const via = parsedUrl.query.via;
+      const name = parsedUrl.query.name;
+      pool.release(name, via);
+      res.writeHead(200, { "Content-Type": "application/json" });
+      res.end();
+    } else {
+      res.writeHead(404, { "Content-Type": "text/plain" });
+      res.end("Not Found\n");
+    }
+  });
+  server.listen(23450, "127.0.0.1", () => {
+    console.log("Server is running at http://127.0.0.1:23450/");
+  });
+}).catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/lib/server/index.d.ts

@@ -0,0 +1,17 @@
+export { mockDatabase } from '@tachybase/database';
+export { default as supertest } from 'supertest';
+export * from './mockServer';
+export declare const pgOnly: () => any;
+export declare const isPg: () => boolean;
+export declare function randomStr(): string;
+export declare const waitSecond: (timeout?: number) => Promise<void>;
+export declare const startServerWithRandomPort: (startServer: any) => Promise<unknown>;
+export declare const createWsClient: ({ serverPort, options }: {
+    serverPort: any;
+    options?: {};
+}) => Promise<{
+    wsc: any;
+    messages: any[];
+    stop(): Promise<void>;
+    lastMessage(): any;
+}>;

package/lib/server/index.js

@@ -0,0 +1,105 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var server_exports = {};
+__export(server_exports, {
+  createWsClient: () => createWsClient,
+  isPg: () => isPg,
+  mockDatabase: () => import_database.mockDatabase,
+  pgOnly: () => pgOnly,
+  randomStr: () => randomStr,
+  startServerWithRandomPort: () => startServerWithRandomPort,
+  supertest: () => import_supertest.default,
+  waitSecond: () => waitSecond
+});
+module.exports = __toCommonJS(server_exports);
+var import_vitest = require("vitest");
+var import_ws = __toESM(require("ws"));
+var import_database = require("@tachybase/database");
+var import_supertest = __toESM(require("supertest"));
+__reExport(server_exports, require("./mockServer"), module.exports);
+const pgOnly = /* @__PURE__ */ __name(() => process.env.DB_DIALECT == "postgres" ? import_vitest.describe : import_vitest.describe.skip, "pgOnly");
+const isPg = /* @__PURE__ */ __name(() => process.env.DB_DIALECT == "postgres", "isPg");
+function randomStr() {
+  return Math.random().toString(36).substring(2);
+}
+__name(randomStr, "randomStr");
+const waitSecond = /* @__PURE__ */ __name(async (timeout = 1e3) => {
+  await new Promise((resolve) => setTimeout(resolve, timeout));
+}, "waitSecond");
+const startServerWithRandomPort = /* @__PURE__ */ __name(async (startServer) => {
+  return await new Promise((resolve) => {
+    startServer({
+      port: 0,
+      host: "localhost",
+      callback(server) {
+        const port = server.address().port;
+        resolve(port);
+      }
+    });
+  });
+}, "startServerWithRandomPort");
+const createWsClient = /* @__PURE__ */ __name(async ({ serverPort, options = {} }) => {
+  console.log(`connect to ws://localhost:${serverPort}${process.env.WS_PATH}`, options);
+  const wsc = new import_ws.default(`ws://localhost:${serverPort}${process.env.WS_PATH}`, options);
+  const messages = [];
+  wsc.on("message", (data) => {
+    const message = data.toString();
+    messages.push(message);
+  });
+  await new Promise((resolve) => {
+    wsc.on("open", resolve);
+  });
+  return {
+    wsc,
+    messages,
+    async stop() {
+      const promise = new Promise((resolve) => {
+        wsc.on("close", resolve);
+      });
+      wsc.close();
+      await promise;
+    },
+    lastMessage() {
+      return JSON.parse(messages[messages.length - 1]);
+    }
+  };
+}, "createWsClient");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createWsClient,
+  isPg,
+  mockDatabase,
+  pgOnly,
+  randomStr,
+  startServerWithRandomPort,
+  supertest,
+  waitSecond,
+  ...require("./mockServer")
+});

package/lib/server/mockServer.d.ts

@@ -0,0 +1,75 @@
+import { Application, ApplicationOptions } from '@tachybase/server';
+import supertest, { SuperAgentTest } from 'supertest';
+interface ActionParams {
+    filterByTk?: any;
+    fields?: string[];
+    filter?: any;
+    sort?: string[];
+    page?: number;
+    pageSize?: number;
+    values?: any;
+    /**
+     * @deprecated
+     */
+    resourceName?: string;
+    /**
+     * @deprecated
+     */
+    resourceIndex?: string;
+    /**
+     * @deprecated
+     */
+    associatedName?: string;
+    /**
+     * @deprecated
+     */
+    associatedIndex?: string;
+    [key: string]: any;
+}
+interface SortActionParams {
+    resourceName?: string;
+    resourceIndex?: any;
+    associatedName?: string;
+    associatedIndex?: any;
+    sourceId?: any;
+    targetId?: any;
+    sortField?: string;
+    method?: string;
+    target?: any;
+    sticky?: boolean;
+    [key: string]: any;
+}
+interface Resource {
+    get: (params?: ActionParams) => Promise<supertest.Response>;
+    list: (params?: ActionParams) => Promise<supertest.Response>;
+    create: (params?: ActionParams) => Promise<supertest.Response>;
+    update: (params?: ActionParams) => Promise<supertest.Response>;
+    destroy: (params?: ActionParams) => Promise<supertest.Response>;
+    sort: (params?: SortActionParams) => Promise<supertest.Response>;
+    [name: string]: (params?: ActionParams) => Promise<supertest.Response>;
+}
+interface ExtendedAgent extends SuperAgentTest {
+    login: (user: any) => ExtendedAgent;
+    loginUsingId: (userId: number) => ExtendedAgent;
+    resource: (name: string, resourceOf?: any) => Resource;
+}
+export declare class MockServer extends Application {
+    loadAndInstall(options?: any): Promise<void>;
+    cleanDb(): Promise<void>;
+    quickstart(options?: {
+        clean?: boolean;
+    }): Promise<void>;
+    destroy(options?: any): Promise<void>;
+    agent(): ExtendedAgent;
+    protected createDatabase(options: ApplicationOptions): import("@tachybase/database").MockDatabase;
+}
+export declare function mockServer(options?: ApplicationOptions): MockServer;
+export declare function startMockServer(options?: ApplicationOptions): Promise<MockServer>;
+type BeforeInstallFn = (app: any) => Promise<void>;
+export declare function createMockServer(options?: ApplicationOptions & {
+    version?: string;
+    beforeInstall?: BeforeInstallFn;
+    skipInstall?: boolean;
+    skipStart?: boolean;
+}): Promise<any>;
+export default mockServer;