oorja 1.11.4 → 2.0.1

package/dist/lib/{surya → connect}/index.js

@@ -1,37 +1,37 @@
 // backend api client
-import https from "https";
-import axios, { AxiosError } from "axios";
-import { encode, decode } from "@msgpack/msgpack";
-import { defaultParser } from "./resources.js";
-import { getSuryaConfig } from "../config.js";
-import { Unauthorized, BadRequest } from "./errors.js";
-import { Socket, Presence } from "./vendor/phoenix/index.js";
-import camelcaseKeys from "camelcase-keys";
-export class SuryaError extends Error {
+import https from 'https';
+import axios, { AxiosError } from 'axios';
+import { encode, decode } from '@msgpack/msgpack';
+import { defaultParser } from './resources.js';
+import { getConnectConfig } from '../config.js';
+import { Unauthorized, BadRequest } from './errors.js';
+import { Socket, Presence } from 'phoenix';
+import camelcaseKeys from 'camelcase-keys';
+export class ApiClientError extends Error {
 }
-export class SuryaClient {
+export class ConnectClient {
     config;
     client;
     socket;
-    constructor(env) {
-        const config = getSuryaConfig(env);
+    constructor(env, region) {
+        const config = getConnectConfig(env, region);
         this.client = axios.create({
             httpsAgent: new https.Agent({
-                minVersion: "TLSv1.2",
-                maxVersion: "TLSv1.2",
+                minVersion: 'TLSv1.2',
+                maxVersion: 'TLSv1.2',
             }),
-            baseURL: suryaBaseURL(config.host, config.enableTLS),
+            baseURL: connectBaseURL(config.host),
             timeout: 5000,
-            responseType: "json",
+            responseType: 'json',
             headers: {
-                "x-access-token": config.token || "",
+                'x-access-token': config.token || '',
             },
         });
         this.config = config;
     }
     fetchCliManifest = async () => {
         try {
-            const response = await this.client.get("/cli");
+            const response = await this.client.get('/cli');
             return camelcaseKeys(response.data);
         }
         catch (error) {
@@ -40,7 +40,7 @@ export class SuryaClient {
     };
     fetchSessionUser = async () => {
         try {
-            const response = await this.client.get("/session/user");
+            const response = await this.client.get('/session/user');
             return defaultParser(response.data.data);
         }
         catch (error) {
@@ -52,11 +52,11 @@ export class SuryaClient {
             room: {
                 apps,
                 locked: false,
-                name: roomName || "-",
+                name: roomName || '-',
             },
         };
         try {
-            const response = await this.client.post("/rooms", body);
+            const response = await this.client.post('/rooms', body);
             return defaultParser(response.data.data);
         }
         catch (error) {
@@ -65,7 +65,7 @@ export class SuryaClient {
     };
     createAnonymousUser = async () => {
         try {
-            const response = await this.client.post("/session/anon");
+            const response = await this.client.post('/session/anon');
             return response.data.access_token;
         }
         catch (error) {
@@ -74,7 +74,7 @@ export class SuryaClient {
     };
     accessTokenFromRoomParticipantOTP = async (roomId, otp) => {
         try {
-            const response = await this.client.post("/access_tokens/from_room_participant_otp", {
+            const response = await this.client.post('/access_tokens/from_room_participant_otp', {
                 room_id: roomId,
                 otp: otp,
             });
@@ -94,7 +94,7 @@ export class SuryaClient {
         }
     };
     establishSocket = async () => {
-        const protocolPrefix = this.config.enableTLS ? `wss://` : `ws://`;
+        const protocolPrefix = `wss://`;
         const host = this.config.host;
         let encodeMessage = (rawdata, callback) => {
             if (!rawdata)
@@ -113,8 +113,9 @@ export class SuryaClient {
                 params: {
                     access_token: this.config.token,
                 },
+                transport: WebSocket,
                 heartbeatIntervalMs: 10000,
-                binaryType: "arraybuffer",
+                binaryType: 'arraybuffer',
                 encode: encodeMessage,
                 decode: decodeMessage,
             });
@@ -127,7 +128,7 @@ export class SuryaClient {
                     reject();
                     return;
                 }
-                console.error("connection error");
+                console.error('connection error');
                 process.exit(2);
             });
             // @ts-ignore
@@ -136,33 +137,33 @@ export class SuryaClient {
     };
     joinChannel = ({ channel, params, onJoin, onClose, onError, onMessage, handleSessionJoin, handleSessionLeave, }) => {
         if (!this.socket)
-            throw Error("no socket connection");
+            throw Error('no socket connection');
         const chan = this.socket.channel(channel, params);
         if (onError)
             chan.onError(onError);
         if (onClose)
             chan.onClose(onClose);
         let presences = [];
-        chan.on("new_msg", (msg) => {
+        chan.on('new_msg', (msg) => {
             onMessage(msg);
         });
-        chan.on("presence_state", (response) => {
+        chan.on('presence_state', (response) => {
             Presence.syncState(presences, response, handleSessionJoin, undefined);
             presences = response;
         });
-        chan.on("presence_diff", (newPresence) => {
+        chan.on('presence_diff', (newPresence) => {
             presences = Presence.syncDiff(presences, newPresence, handleSessionJoin, handleSessionLeave);
         });
         chan
             .join()
-            .receive("ok", () => {
+            .receive('ok', () => {
             if (onJoin)
                 onJoin();
         })
-            .receive("error", (resp) => {
-            if (resp && resp.reason === "unauthorized") {
+            .receive('error', (resp) => {
+            if (resp && resp.reason === 'unauthorized') {
                 if (onError)
-                    onError(new Unauthorized("unauthorized: user needs to join the room before a stream can be started."));
+                    onError(new Unauthorized('unauthorized: user needs to join the room before a stream can be started.'));
                 return;
             }
             process.exit(3);
@@ -172,7 +173,9 @@ export class SuryaClient {
     destroy = async () => {
         return new Promise((resolve) => {
             if (this.socket) {
-                this.socket.disconnect(resolve, 1000, "disconnecting surya client");
+                this.socket.disconnect(() => {
+                    resolve(undefined);
+                }, 1000, 'disconnecting connect client');
             }
             else {
                 resolve(undefined);
@@ -180,7 +183,7 @@ export class SuryaClient {
         });
     };
 }
-const suryaBaseURL = (host, tlsEnabled) => `${tlsEnabled ? "https" : "http"}://${host}/api/v1`;
+const connectBaseURL = (host) => `https://${host}/api/v1`;
 const handleError = (error) => {
     if (error instanceof AxiosError) {
         const { response } = error;

package/dist/lib/{surya → connect}/resources.js

@@ -1,5 +1,5 @@
-import camelcaseKeys from "camelcase-keys";
-const parseDateFields = (resource, fields = ["createdAt", "updatedAt"]) => {
+import camelcaseKeys from 'camelcase-keys';
+const parseDateFields = (resource, fields = ['createdAt', 'updatedAt']) => {
     fields.forEach((key) => {
         const val = resource[key];
         if (val)

package/dist/lib/{surya → connect}/types.d.ts

@@ -1,5 +1,4 @@
-/// <reference types="node" resolution-mode="require"/>
-type ProfileType = "GitHub" | "Google" | "anon";
+type ProfileType = 'GitHub' | 'Google' | 'anon';
 export type RoomApp = {
     appId: string;
     config: any;
@@ -21,7 +20,6 @@ type ResourceTimestamps = {
 };
 export type CliManifest = {
     cliVersion: number;
-    suryaHosts: string[];
 };
 export type User = UserProfile & ResourceTimestamps;
 export type Room = {

package/dist/lib/encryption.d.ts

@@ -1,11 +1,10 @@
-/// <reference types="node" resolution-mode="require"/>
-import { RoomKey } from "./surya/types.js";
+import { RoomKey } from './connect/types.js';
 export type EncryptedPayload = {
     iv: Buffer | Uint8Array;
     data: Buffer | Uint8Array;
 };
 export declare const createRoomKey: (roomId: string) => RoomKey;
 export declare const exportKey: (key: Buffer) => string;
-export declare const importKey: (exportedKey: string) => Buffer;
+export declare const importKey: (exportedKey: string) => Buffer<ArrayBuffer>;
 export declare const encrypt: (data: any, roomKey: RoomKey) => EncryptedPayload;
 export declare const decrypt: (payload: EncryptedPayload, roomKey: RoomKey) => any;

package/dist/lib/encryption.js

@@ -1,6 +1,6 @@
-import * as crypto from "crypto";
-import { encode, decode } from "@msgpack/msgpack";
-const ALG = "aes-128-gcm";
+import * as crypto from 'crypto';
+import { encode, decode } from '@msgpack/msgpack';
+const ALG = 'aes-128-gcm';
 const KEY_SIZE = 16; // 128 bit AES
 const AUTH_TAG_LEN = 16;
 export const createRoomKey = (roomId) => ({
@@ -8,19 +8,15 @@ export const createRoomKey = (roomId) => ({
     key: createAESEncryptionKey(),
 });
 const createAESEncryptionKey = () => crypto.randomBytes(KEY_SIZE);
-export const exportKey = (key) => key.toString("base64");
-export const importKey = (exportedKey) => Buffer.from(exportedKey, "base64");
+export const exportKey = (key) => key.toString('base64');
+export const importKey = (exportedKey) => Buffer.from(exportedKey, 'base64');
 const createIV = () => crypto.randomBytes(16);
 export const encrypt = (data, roomKey) => {
     const iv = createIV();
     const cipher = crypto.createCipheriv(ALG, roomKey.key, iv);
     return {
         iv,
-        data: Buffer.concat([
-            cipher.update(encode(data)),
-            cipher.final(),
-            cipher.getAuthTag(),
-        ]),
+        data: Buffer.concat([cipher.update(encode(data)), cipher.final(), cipher.getAuthTag()]),
     };
 };
 export const decrypt = (payload, roomKey) => {

package/dist/lib/oorja/client.d.ts

@@ -0,0 +1,3 @@
+export declare class OorjaClientError extends Error {
+}
+export declare const getRegion: () => Promise<string>;

package/dist/lib/oorja/client.js

@@ -0,0 +1,52 @@
+import haversine from 'haversine-distance';
+export class OorjaClientError extends Error {
+}
+const _maybeError = (response) => {
+    const { status } = response;
+    if (status >= 400) {
+        throw new OorjaClientError('oorja network client error');
+    }
+};
+class Client {
+    async get(url, options = {}) {
+        const response = await fetch(url, {
+            ...options,
+            method: options.method || 'GET',
+            headers: { ...options.headers },
+            cache: 'no-store',
+            redirect: 'follow',
+            signal: AbortSignal.timeout(options.timeout || 6_000),
+        });
+        _maybeError(response);
+        return response;
+    }
+}
+const _client = new Client();
+export const getRegion = async () => {
+    const response = await _client.get('https://oorja.io/nudge', {
+        method: 'GET',
+    });
+    if (response.status !== 200) {
+        console.error('There seems to be an issue with the network');
+        process.exit(1);
+    }
+    const settings = (await response.json());
+    try {
+        const clientLocation = {
+            lat: parseFloat(response.headers.get('oorja-lat')),
+            lng: parseFloat(response.headers.get('oorja-lon')),
+        };
+        const distances = settings.regions.map((region) => {
+            return {
+                name: region.name,
+                distance: haversine(clientLocation, region.location),
+            };
+        });
+        const minDistance = distances.reduce((a, b) => (a.distance < b.distance ? a : b));
+        return minDistance.name;
+    }
+    catch {
+        console.error('error determining region');
+        process.exit(1);
+    }
+};

package/dist/lib/oorja/index.d.ts

@@ -1,16 +1,16 @@
-import { oorjaConfig } from "../config.js";
-import { User, RoomKey } from "../surya/types.js";
-import { TeletypeOptions } from "../teletype/index.js";
-import { CreateRoomOptions, SuryaClient } from "../surya/index.js";
+import { oorjaConfig } from '../config.js';
+import { User, RoomKey } from '../connect/types.js';
+import { TeletypeOptions } from '../teletype/index.js';
+import { CreateRoomOptions, ConnectClient } from '../connect/index.js';
 export declare class InvalidRoomLink extends Error {
 }
 declare class OORJA {
     private config;
-    private suryaClient;
+    private connectClient;
     user: User;
-    constructor(config: oorjaConfig, suryaClient: SuryaClient, user: User);
+    constructor(config: oorjaConfig, connectClient: ConnectClient, user: User);
     createRoom: (options: CreateRoomOptions) => Promise<{
-        room: import("../surya/types.js").Room;
+        room: import("../connect/types.js").Room;
         roomKey: RoomKey;
     }>;
     linkForRoom: (roomKey: RoomKey) => string;

package/dist/lib/oorja/index.js

@@ -1,23 +1,25 @@
-import { determineENV, getoorjaConfig, INVALID_ROOM_LINK_MESSAGE, setENVAccessToken, } from "../config.js";
-import { teletypeApp } from "../teletype/index.js";
-import { SuryaClient } from "../surya/index.js";
-import { URL, URLSearchParams } from "url";
-import { importKey, createRoomKey, exportKey } from "../encryption.js";
-import { loginByRoomOTP, preflight, promptAuth, resumeSession, validateCliVersion, } from "./preflight.js";
+import { determineENV, getoorjaConfig, INVALID_ROOM_LINK_MESSAGE, setENVAccessToken, } from '../config.js';
+import { teletypeApp } from '../teletype/index.js';
+import { ConnectClient } from '../connect/index.js';
+import { URL, URLSearchParams } from 'url';
+import { importKey, createRoomKey, exportKey } from '../encryption.js';
+import { loginByRoomOTP, preflight, promptAuth, resumeSession, validateCliVersion } from './preflight.js';
+import { getRegion } from './client.js';
+import ora from 'ora';
 export class InvalidRoomLink extends Error {
 }
 class OORJA {
     config;
-    suryaClient;
+    connectClient;
     user;
     // should capture domain related commands and queries
-    constructor(config, suryaClient, user) {
+    constructor(config, connectClient, user) {
         this.config = config;
-        this.suryaClient = suryaClient;
+        this.connectClient = connectClient;
         this.user = user;
     }
     createRoom = async (options) => {
-        const room = await this.suryaClient.createRoom(options);
+        const room = await this.connectClient.createRoom(options);
         const roomKey = createRoomKey(room.id);
         return {
             room,
@@ -37,7 +39,7 @@ class OORJA {
     teletype = (options) => {
         return teletypeApp({
             userId: this.user.id,
-            joinChannel: this.suryaClient.joinChannel,
+            joinChannel: this.connectClient.joinChannel,
             ...options,
         });
     };
@@ -52,48 +54,57 @@ const parseRoomURL = (roomLink) => {
 };
 const getRoomId = (roomURL) => {
     const params = new URLSearchParams(roomURL.search);
-    return params.get("id") || undefined;
+    return params.get('id') || undefined;
 };
 const oorjaURL = (config) => {
-    const { host, enableTLS } = config;
-    return enableTLS ? `https://${host}` : `http://${host}`;
+    const { host } = config;
+    return `https://${host}`;
 };
 const linkForTokenGen = (config) => `${oorjaURL(config)}/access_token`;
 const init = async (env, options = {}) => {
     const config = getoorjaConfig(env);
-    let suryaClient = new SuryaClient(env);
-    await validateCliVersion(suryaClient);
-    let user = await resumeSession(env, suryaClient, options.roomId);
+    const spinner = ora({
+        text: 'Connecting...',
+        discardStdin: true,
+    }).start();
+    const region = await getRegion();
+    let connectClient = new ConnectClient(env, region);
+    await validateCliVersion(connectClient);
+    let user = await resumeSession(env, connectClient, options.roomId);
+    spinner.succeed('Online');
     if (!user) {
-        let token = "";
+        let token = '';
         if (options.roomId) {
-            token = await loginByRoomOTP(suryaClient, options.roomId);
+            token = await loginByRoomOTP(connectClient, options.roomId);
         }
         else {
-            token = await promptAuth(suryaClient, linkForTokenGen(config));
+            token = await promptAuth(connectClient, linkForTokenGen(config));
             if (!token) {
-                console.log("Token not provided :(");
+                console.log('Token not provided :(');
                 process.exit(12);
             }
         }
         setENVAccessToken(env, token);
     }
-    await suryaClient.destroy();
-    suryaClient = new SuryaClient(env);
-    user = await preflight(env, suryaClient);
-    return new OORJA(config, suryaClient, user);
+    await connectClient.destroy();
+    connectClient = new ConnectClient(env, region);
+    user = await preflight(env, connectClient);
+    return new OORJA(config, connectClient, user);
 };
 let currentEnv;
-let oorja;
+let oorja = null;
 export const getApp = async (options = {}) => {
     const { roomLink } = options;
     const roomURL = roomLink ? parseRoomURL(roomLink) : undefined;
-    const env = determineENV(undefined);
+    const env = determineENV(roomURL);
     if (oorja) {
         if (env !== currentEnv) {
-            return Promise.reject("Attempt to run different env in same session");
+            return Promise.reject('Attempt to run different env in same session');
         }
         return Promise.resolve(oorja);
     }
-    return await init(env, { roomId: roomURL ? getRoomId(roomURL) : undefined });
+    const app = await init(env, { roomId: roomURL ? getRoomId(roomURL) : undefined });
+    currentEnv = env;
+    oorja = app;
+    return app;
 };

package/dist/lib/oorja/preflight.d.ts

@@ -1,9 +1,9 @@
-import { env } from "../config.js";
-import { SuryaClient } from "../surya/index.js";
-import { User } from "../surya/types.js";
+import { env } from '../config.js';
+import { ConnectClient } from '../connect/index.js';
+import { User } from '../connect/types.js';
 export declare const promptRoomParticipantOTP: () => Promise<string>;
-export declare const promptAuth: (suryaClient: SuryaClient, generateTokenLink: string) => Promise<string>;
-export declare const loginByRoomOTP: (suryaClient: SuryaClient, roomId: string) => Promise<string>;
-export declare const validateCliVersion: (suryaClient: SuryaClient) => Promise<void>;
-export declare const resumeSession: (env: env, suryaClient: SuryaClient, roomId?: string) => Promise<User | null>;
-export declare const preflight: (env: env, suryaClient: SuryaClient) => Promise<User>;
+export declare const promptAuth: (connectClient: ConnectClient, generateTokenLink: string) => Promise<string>;
+export declare const loginByRoomOTP: (connectClient: ConnectClient, roomId: string) => Promise<string>;
+export declare const validateCliVersion: (connectClient: ConnectClient) => Promise<void>;
+export declare const resumeSession: (env: env, connectClient: ConnectClient, roomId?: string) => Promise<User | null>;
+export declare const preflight: (env: env, connectClient: ConnectClient) => Promise<User>;

package/dist/lib/oorja/preflight.js

@@ -1,124 +1,128 @@
-import chalk from "chalk";
+import chalk from 'chalk';
 import inquirer from 'inquirer';
-import ora from "ora";
-import { setENVAccessToken, CLI_VERSION, getENVAccessToken, } from "../config.js";
-import { BadRequest, Unauthorized } from "../surya/errors.js";
-const promptToken = () => inquirer.prompt([
+import ora from 'ora';
+import { setENVAccessToken, CLI_VERSION, getENVAccessToken } from '../config.js';
+import { BadRequest, Unauthorized } from '../connect/errors.js';
+const promptToken = () => inquirer
+    .prompt([
     {
         type: 'input',
         name: 'accessToken',
         message: 'Please enter your access token for authentication:',
-    }
-]).then(answers => answers.accessToken);
-export const promptRoomParticipantOTP = () => inquirer.prompt([
+    },
+])
+    .then((answers) => answers.accessToken);
+export const promptRoomParticipantOTP = () => inquirer
+    .prompt([
     {
         type: 'input',
         name: 'otp',
         message: 'Please enter your OTP for authentication (switch to teletype app in the room and click on blue "Generate OTP" button):',
-    }
-]).then(answers => answers.otp);
+    },
+])
+    .then((answers) => answers.otp);
 const OTP_HELP_MESSAGE = "You can generate OTP from the room, it's in the instruction steps";
-export const promptAuth = async (suryaClient, generateTokenLink) => {
-    const ANON = "Proceed as an anonymous user";
-    const SIGN_IN = "Sign-in with oorja";
-    console.log(`\n${chalk.bold("PRO-TIP:")} If you sign-in, you can control your shell from the web-ui as well, without enabling collaboration mode for the other participants\n`);
+export const promptAuth = async (connectClient, generateTokenLink) => {
+    const ANON = 'Proceed as an anonymous user';
+    const SIGN_IN = 'Sign-in with oorja';
+    console.log(`\n${chalk.bold('PRO-TIP:')} If you sign-in, you can control your shell from the web-ui as well, without enabling collaboration mode for the other participants\n`);
     const { answer } = await inquirer.prompt([
         {
             type: 'list',
             name: 'answer',
             message: 'You need an access-token for authentication.\n ',
             choices: [ANON, SIGN_IN],
-        }
+        },
     ]);
     switch (answer) {
         case ANON:
-            console.log("Creating anonymous user...");
-            return suryaClient.createAnonymousUser();
+            console.log('Creating anonymous user...');
+            return connectClient.createAnonymousUser();
         case SIGN_IN:
             console.log(`You can sign-in and generate your token here: ${chalk.blue(generateTokenLink)}`);
             return promptToken();
     }
-    throw Error("Unexpected input");
+    throw Error('Unexpected input');
 };
-export const loginByRoomOTP = async (suryaClient, roomId) => {
+export const loginByRoomOTP = async (connectClient, roomId) => {
     const otp = await promptRoomParticipantOTP();
     if (!otp) {
-        console.log("OTP not provided :(");
+        console.log('OTP not provided :(');
         console.log(OTP_HELP_MESSAGE);
         process.exit(213);
     }
     try {
-        return await suryaClient.accessTokenFromRoomParticipantOTP(roomId, otp);
+        return await connectClient.accessTokenFromRoomParticipantOTP(roomId, otp);
     }
     catch (e) {
         if (e instanceof BadRequest) {
-            console.log(chalk.redBright("Invalid otp. It may have expired."));
+            console.log(chalk.redBright('Invalid otp. It may have expired.'));
             console.log(OTP_HELP_MESSAGE);
             process.exit();
         }
         throw e;
     }
 };
-export const validateCliVersion = async (suryaClient) => {
-    const manifest = await suryaClient.fetchCliManifest();
+export const validateCliVersion = async (connectClient) => {
+    const manifest = await connectClient.fetchCliManifest();
     if (manifest.cliVersion > CLI_VERSION) {
-        console.log(chalk.redBright("Your oorja cli is outdated. Please run: npm update -g oorja"));
+        console.log(chalk.redBright('Your oorja cli is outdated. Please run: npm update -g oorja'));
         process.exit(1);
     }
 };
-export const resumeSession = async (env, suryaClient, roomId) => {
+export const resumeSession = async (env, connectClient, roomId) => {
     const token = getENVAccessToken(env);
     if (!token)
         return null;
     // try to validate authorization with existing token
     try {
-        const user = await suryaClient.fetchSessionUser();
+        const user = await connectClient.fetchSessionUser();
         if (roomId) {
-            await suryaClient.fetchRoom(roomId);
+            await connectClient.fetchRoom(roomId);
         }
         return user;
     }
     catch (e) {
         if (e instanceof Unauthorized) {
-            setENVAccessToken(env, "");
+            setENVAccessToken(env, '');
             return null;
         }
         throw e;
     }
 };
-export const preflight = async (env, suryaClient) => {
+export const preflight = async (env, connectClient) => {
     const spinner = ora({
-        text: "Authenticating",
+        text: 'Authenticating',
         discardStdin: false,
     }).start();
     try {
-        const user = await suryaClient.fetchSessionUser();
+        const user = await connectClient.fetchSessionUser();
         spinner.succeed(`Authenticated: Welcome ${user.name}`);
-        if (user.profileType === "anon") {
+        if (user.profileType === 'anon') {
             // don't persist tokens for anonymous users
-            setENVAccessToken(env, "");
+            setENVAccessToken(env, '');
             console.log(chalk.yellowBright("You're an anonymous user. CLI will not remember the auth-token"));
         }
-        spinner.start("Connecting..");
-        return suryaClient
+        spinner.start('Connecting..');
+        return connectClient
             .establishSocket()
             .then(() => {
-            spinner.succeed("Connected").clear();
+            spinner.succeed('Connected').clear();
             return user;
         })
             .catch((e) => {
-            spinner.fail("Socket connection failure..");
+            spinner.fail('Socket connection failure..');
             throw e;
         });
     }
     catch (e) {
-        setENVAccessToken(env, "");
+        setENVAccessToken(env, '');
         if (e instanceof Unauthorized) {
-            spinner.fail("Your access token failed authentication, resetting...");
+            spinner.fail('Your access token failed authentication, resetting...');
             process.exit(33);
         }
         else {
-            spinner.fail("Something went wrong :(");
+            spinner.fail('Something went wrong :(');
         }
         throw e;
     }