@contrail/flexplm 1.7.7-alpha.7ad4e7e → 1.7.7-alpha.89ddfa2

package/lib/interfaces/interfaces.d.ts

@@ -6,10 +6,6 @@ export interface FCConfig {
     eventObjectClassParam?: string;
     eventFlexTypePathParam?: string;
     flexplmConnect?: any;
-    'flexplmConnect.sessionReuse.enabled'?: boolean | string;
-    'flexplmConnect.sessionReuse.ttlSeconds'?: number | string;
-    'flexplmConnect.sessionReuse.cookieName'?: string;
-    'flexplmConnect.sessionReuse.retryStatuses'?: number | number[] | string;
     taskId?: string;
     apiHost: string;
     userName(): string;

package/lib/util/flexplm-connect.d.ts

@@ -6,14 +6,6 @@ export declare class FlexPLMConnect {
     payloadSendAsArray: boolean;
     constructor(_config: FCConfig, endPoint?: any, payloadAsArray?: any);
     private get sessionOptions();
-    /**
-     * Waits until no cold session acquisition is running for this key.
-     * Callers must `await` this only when it returns a promise: awaiting even a resolved promise yields,
-     * and the check-then-register in runColdAcquisition has to stay synchronous to be race free.
-     */
-    private waitForInFlightAcquisition;
-    /** Runs a cold acquisition and registers it so concurrent callers wait for it instead of opening their own session. */
-    private runColdAcquisition;
     private getSessionKey;
     private getCachedSession;
     private storeSession;
@@ -22,8 +14,11 @@ export declare class FlexPLMConnect {
     private extractSessionCookie;
     private cookieHeader;
     private getRequestOptions;
-    getCSRF(getNewSession?: boolean, rejectedCookie?: string): any;
-    private fetchCSRF;
+    getCSRF(getNewSession?: boolean): Promise<{
+        nonce_key: any;
+        nonce: any;
+        sessionCookie: string;
+    }>;
     sendRequest(csrf: any, payload: any): Promise<Response>;
     protected processRequest(payload: any): Promise<FlexPLMResponseData>;
     sendToFlexPLM(payload: PayloadType): Promise<FlexPLMResponseData>;

package/lib/util/flexplm-connect.js

@@ -2,41 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FlexPLMConnect = void 0;
 const app_framework_1 = require("@contrail/app-framework");
-// Module-level on purpose: a new FlexPLMConnect is constructed for every event. Declaring for Session reusing use case.
+// Module-level on purpose: a new FlexPLMConnect is constructed for every event. Declaring for Session resuing use case.
 const sessionCache = new Map();
-// In-flight cold session acquisitions per key, so concurrent events share one FlexPLM session instead of each creating their own.
-const inFlightAcquisitions = new Map();
-const DEFAULT_SESSION_COOKIE_NAME = 'JSESSIONID';
-const DEFAULT_SESSION_TTL_SECONDS = 900;
-const DEFAULT_RETRY_STATUSES = [401, 403];
-const COOKIE_NAME_TOKEN = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/;
-// Thrown internally when a cached cookie was rejected, so the caller can re-acquire under the lock.
-class SessionRejectedError extends Error {
-}
-const escapeRegExp = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-const parseRetryStatuses = (value) => {
-    let list = [];
-    if (Array.isArray(value))
-        list = value;
-    else if (typeof value === 'string')
-        list = value.split(',');
-    else if (value !== undefined && value !== null)
-        list = [value];
-    const statuses = list
-        .map(v => (typeof v === 'string' ? v.trim() : v))
-        .filter(v => v !== '' && v !== null && v !== undefined)
-        .map(Number)
-        .filter(n => Number.isInteger(n) && n >= 100 && n <= 599);
-    return statuses.length ? statuses : DEFAULT_RETRY_STATUSES;
-};
-const parseTtlSeconds = (value) => {
-    const ttl = Number(value);
-    return Number.isFinite(ttl) && ttl > 0 ? ttl : DEFAULT_SESSION_TTL_SECONDS;
-};
-const parseCookieName = (value) => {
-    const name = typeof value === 'string' ? value.trim() : '';
-    return COOKIE_NAME_TOKEN.test(name) ? name : DEFAULT_SESSION_COOKIE_NAME;
-};
 // Added for Session reuse - ET-390 - Ends
 class FlexPLMConnect {
     constructor(_config, endPoint = undefined, payloadAsArray = undefined) {
@@ -76,41 +43,11 @@ class FlexPLMConnect {
         const enabled = sessReuseEntries('enabled');
         return {
             enabled: enabled === true || String(enabled).toLowerCase() === 'true',
-            ttlMs: parseTtlSeconds(sessReuseEntries('ttlSeconds')) * 1000,
-            cookieName: parseCookieName(sessReuseEntries('cookieName')),
-            retryStatuses: parseRetryStatuses(sessReuseEntries('retryStatuses')),
+            ttlMs: (sessReuseEntries('ttlSeconds') ?? 900) * 1000,
+            cookieName: sessReuseEntries('cookieName') ?? 'JSESSIONID',
+            retryStatuses: (sessReuseEntries('retryStatuses') ?? [401, 403]),
         };
     }
-    /**
-     * Waits until no cold session acquisition is running for this key.
-     * Callers must `await` this only when it returns a promise: awaiting even a resolved promise yields,
-     * and the check-then-register in runColdAcquisition has to stay synchronous to be race free.
-     */
-    waitForInFlightAcquisition() {
-        const key = this.getSessionKey();
-        if (!inFlightAcquisitions.has(key))
-            return undefined;
-        return (async () => {
-            let pending = inFlightAcquisitions.get(key);
-            while (pending) {
-                await pending.catch(() => undefined);
-                pending = inFlightAcquisitions.get(key);
-            }
-        })();
-    }
-    /** Runs a cold acquisition and registers it so concurrent callers wait for it instead of opening their own session. */
-    async runColdAcquisition(acquire) {
-        const key = this.getSessionKey();
-        const acquisition = acquire();
-        inFlightAcquisitions.set(key, acquisition);
-        try {
-            return await acquisition;
-        }
-        finally {
-            if (inFlightAcquisitions.get(key) === acquisition)
-                inFlightAcquisitions.delete(key);
-        }
-    }
     getSessionKey() {
         return [this.config.apiHost, this.config.urlContext, this.config.userName(), this.config.plmEnviornment].join('|');
     }
@@ -147,7 +84,7 @@ class FlexPLMConnect {
             raw = [respHeader.get('set-cookie')];
         }
         const name = this.sessionOptions.cookieName;
-        const regexFilter = new RegExp('(?:^|[,\\s])' + escapeRegExp(name) + '=([^;,\\s]+)', 'g');
+        const regexFilter = new RegExp('(?:^|[,\\s])' + name + '=([^;,\\s]+)', 'g');
         let jSession;
         for (const line of raw) {
             let cookieNameMatcher = regexFilter.exec(line);
@@ -202,47 +139,26 @@ class FlexPLMConnect {
     /////////////////////////////////////////////////////////////////////////////
     // ET-390 - adding a new parameter getNewSession to the getCSRF function
     // Whenever a getCSRF is called without getNewSession, the default value of false will be used
-    // rejectedCookie: the cookie that was rejected by the caller, so a refresh already done by a concurrent event is not thrown away
-    async getCSRF(getNewSession = false, rejectedCookie) {
-        // Added for Session reuse - ET-390 - Starts
-        if (!this.sessionOptions.enabled)
-            return this.fetchCSRF(undefined);
-        for (let wait = this.waitForInFlightAcquisition(); wait; wait = this.waitForInFlightAcquisition())
-            await wait;
-        if (getNewSession) {
-            const current = this.getCachedSession();
-            if (!current || current === rejectedCookie)
-                this.clearSession();
-        }
-        const cached = this.getCachedSession();
-        if (cached) {
-            try {
-                return await this.fetchCSRF(cached);
-            }
-            catch (e) {
-                if (!(e instanceof SessionRejectedError))
-                    throw e;
-                // if the cached cookie is rejected (401/403), drop it and acquire a new session (serialized)
-                if (this.getCachedSession() === cached)
-                    this.clearSession();
-                return this.getCSRF();
-            }
-        }
-        return this.runColdAcquisition(() => this.fetchCSRF(undefined));
-        // Added for Session reuse - ET-390 - Ends
-    }
-    async fetchCSRF(sentCookie) {
+    async getCSRF(getNewSession = false) {
         const urlContext = this.config.urlContext;
         const csrfEndpoint = this.config.csrfEndpoint;
         const csrfURL = this.config.apiHost + urlContext + csrfEndpoint;
         console.info('csrfURL: ' + csrfURL);
+        // Added for Session reuse - ET-390 - Starts
+        if (getNewSession)
+            this.clearSession();
+        let sentCookie = this.getCachedSession();
         // getRequestOptions will be called with additional sentCookie parameter
         const csrfOptions = this.getRequestOptions('GET', sentCookie);
-        const response = await fetch(csrfURL, csrfOptions);
+        // Added for Session reuse - ET-390 - Ends
+        let response = await fetch(csrfURL, csrfOptions);
         // Added for Session reuse - ET-390 - Starts
+        // if the response status is 401 or 403, then get a new session id
         if (sentCookie && this.sessionOptions.retryStatuses.includes(response.status)) {
             console.warn('Cached FlexPLM session rejected on csrf call (status ' + response.status + '). Retrying with a new session.');
-            throw new SessionRejectedError();
+            this.clearSession();
+            sentCookie = undefined;
+            response = await fetch(csrfURL, this.getRequestOptions('GET'));
         }
         // Added for Session reuse - ET-390 - Ends
         if (response.status >= 300) {
@@ -325,7 +241,7 @@ class FlexPLMConnect {
         let response = await this.sendRequest(csrf, payload);
         if (csrf.sessionCookie && this.sessionOptions.retryStatuses.includes(response.status)) {
             console.warn('FlexPLM rejected session/nonce (status ' + response.status + '). Getting a new session and retrying once.');
-            csrf = await this.getCSRF(true, csrf.sessionCookie);
+            csrf = await this.getCSRF(true);
             response = await this.sendRequest(csrf, payload);
         }
         // Added for Session reuse - ET-390 - Ends
@@ -382,31 +298,17 @@ class FlexPLMConnect {
         const path = urlPath || ('/servlet/rest' + this.vibeEventEndpoint);
         const vibeEventsURL = this.config.apiHost + urlContext + path;
         // Added for Session reuse - ET-390 - Starts
-        const attempt = async () => {
-            if (!this.sessionOptions.enabled) {
-                return { response: await fetch(vibeEventsURL, this.getRequestOptions('GET')), sent: undefined };
-            }
-            for (let wait = this.waitForInFlightAcquisition(); wait; wait = this.waitForInFlightAcquisition())
-                await wait;
-            const sent = this.getCachedSession();
-            const call = async () => {
-                const res = await fetch(vibeEventsURL, this.getRequestOptions('GET', sent));
-                // A rejected cookie must not be stored again; only keep a cookie that was accepted or newly issued.
-                if (!(sent && this.sessionOptions.retryStatuses.includes(res.status))) {
-                    const cookie = this.extractSessionCookie(res) ?? sent;
-                    if (cookie)
-                        this.storeSession(cookie);
-                }
-                return { response: res, sent };
-            };
-            return sent ? call() : this.runColdAcquisition(call);
-        };
-        const first = await attempt();
-        let response = first.response;
-        if (first.sent && this.sessionOptions.retryStatuses.includes(response.status)) {
-            if (this.getCachedSession() === first.sent)
-                this.clearSession();
-            response = (await attempt()).response;
+        const cached = this.getCachedSession();
+        const csrfOptions = this.getRequestOptions('GET', cached);
+        let response = await fetch(vibeEventsURL, csrfOptions);
+        if (cached && this.sessionOptions.retryStatuses.includes(response.status)) {
+            this.clearSession();
+            response = await fetch(vibeEventsURL, this.getRequestOptions('GET'));
+        }
+        if (this.sessionOptions.enabled) {
+            const cachedCookie = this.extractSessionCookie(response) ?? cached;
+            if (cachedCookie)
+                this.storeSession(cachedCookie);
         }
         // Added for Session reuse - ET-390 - Ends
         if (response.status >= 300) {

package/lib/util/flexplm-connect.spec.js

@@ -145,7 +145,7 @@ describe('FlexPLMConnect.sendRequest', () => {
 // Added for Session reuse - ET-390 - Starts
 describe('FlexPLMConnect session reuse', () => {
     const payload = { id: '123' };
-    it('should capture JSESSIONID from the CSRF GET and send it on the POST', async () => {
+    it('captures JSESSIONID from the csrf GET and sends it on the POST', async () => {
         const u = uniqueUser();
         fetchMock()
             .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1; Path=/; HttpOnly']))
@@ -326,121 +326,6 @@ describe('FlexPLMConnect session reuse', () => {
         isInfoOn.mockRestore();
         info.mockRestore();
     });
-    describe('option normalisation', () => {
-        const rejectedOnceThenOk = (u, opts) => {
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=old.tomcat1']))
-                .mockResolvedValueOnce(resp(403, [], {}))
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=new.tomcat1']))
-                .mockResolvedValueOnce(resp(200, [], {}));
-            return new flexplm_connect_1.FlexPLMConnect(sessionConfig(u, { enabled: true, ...opts })).sendToFlexPLM(payload);
-        };
-        it.each([
-            ['a scalar number', 403],
-            ['a comma separated string', '401, 403'],
-            ['garbage (falls back to 401/403)', 'abc'],
-            ['an empty array (falls back to 401/403)', []],
-        ])('retryStatuses given as %s does not throw and still retries on 403', async (_label, retryStatuses) => {
-            await rejectedOnceThenOk(uniqueUser(), { retryStatuses });
-            expect(fetchMock()).toHaveBeenCalledTimes(4);
-        });
-        it.each([['abc'], [0], [-5]])('invalid ttlSeconds (%p) falls back to the 900s default', async (ttlSeconds) => {
-            const u = uniqueUser();
-            const realNow = Date.now();
-            const nowSpy = jest.spyOn(Date, 'now').mockReturnValue(realNow);
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1']))
-                .mockResolvedValueOnce(resp(200, [], {}))
-                .mockResolvedValueOnce(resp(200, []))
-                .mockResolvedValueOnce(resp(200, [], {}));
-            const cfg = sessionConfig(u, { enabled: true, ttlSeconds });
-            await new flexplm_connect_1.FlexPLMConnect(cfg).sendToFlexPLM(payload);
-            nowSpy.mockReturnValue(realNow + 2000);
-            await new flexplm_connect_1.FlexPLMConnect(cfg).sendToFlexPLM(payload);
-            expect(callHeaders(2).Cookie).toBe('JSESSIONID=abc.tomcat1');
-            nowSpy.mockRestore();
-        });
-        it('a blank cookieName falls back to JSESSIONID', async () => {
-            const u = uniqueUser();
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1']))
-                .mockResolvedValueOnce(resp(200, [], {}));
-            await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u, { enabled: true, cookieName: '   ' })).sendToFlexPLM(payload);
-            expect(callHeaders(1).Cookie).toBe('JSESSIONID=abc.tomcat1');
-        });
-    });
-    describe('cookie names containing regex metacharacters', () => {
-        it('extracts a cookie whose name contains "+"', async () => {
-            const u = uniqueUser();
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['SID+=abc; Path=/']))
-                .mockResolvedValueOnce(resp(200, [], {}));
-            await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u, { enabled: true, cookieName: 'SID+' })).sendToFlexPLM(payload);
-            expect(callHeaders(1).Cookie).toBe('SID+=abc');
-        });
-        it('treats "." literally and does not match a look-alike cookie', async () => {
-            const u = uniqueUser();
-            fetchMock()
-                .mockResolvedValueOnce(resp(200, ['AxB=wrong; Path=/']))
-                .mockResolvedValueOnce(resp(200, [], {}));
-            await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u, { enabled: true, cookieName: 'A.B' })).sendToFlexPLM(payload);
-            expect(callHeaders(1).Cookie).toBeUndefined();
-        });
-    });
-    describe('concurrent session acquisition', () => {
-        const flush = () => new Promise(r => setImmediate(r));
-        const isColdGet = (call) => call[1].method === 'GET' && !call[1].headers.Cookie;
-        it('shares one session across concurrent events on a cold cache', async () => {
-            const u = uniqueUser();
-            let release;
-            const gate = new Promise(r => { release = r; });
-            fetchMock().mockImplementation(async (_url, opts) => {
-                if (opts.method === 'GET' && !opts.headers.Cookie) {
-                    await gate;
-                    return resp(200, ['JSESSIONID=abc.tomcat1']);
-                }
-                return resp(200, []);
-            });
-            const all = Promise.all([1, 2, 3].map(() => new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).getCSRF()));
-            await flush();
-            expect(fetchMock()).toHaveBeenCalledTimes(1); // the other two are waiting for the first acquisition
-            release();
-            const results = await all;
-            expect(fetchMock().mock.calls.filter(isColdGet)).toHaveLength(1);
-            results.forEach(r => expect(r.sessionCookie).toBe('abc.tomcat1'));
-        });
-        it('a waiter does not inherit the failure of the first acquisition', async () => {
-            const u = uniqueUser();
-            let release;
-            const gate = new Promise(r => { release = r; });
-            fetchMock()
-                .mockImplementationOnce(async () => { await gate; return resp(500, []); })
-                .mockResolvedValueOnce(resp(200, ['JSESSIONID=abc.tomcat1']));
-            const first = new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).getCSRF();
-            const firstResult = first.catch(e => e);
-            const second = new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).getCSRF();
-            await flush();
-            release();
-            expect(await firstResult).toBeInstanceOf(Error);
-            expect((await second).sessionCookie).toBe('abc.tomcat1');
-        });
-        it('parallel events rejected with 403 create only one replacement session', async () => {
-            const u = uniqueUser();
-            fetchMock().mockResolvedValueOnce(resp(200, ['JSESSIONID=old.tomcat1']));
-            await new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).getCSRF(); // prime the cache with the old session
-            fetchMock().mockReset();
-            fetchMock().mockImplementation(async (_url, opts) => {
-                const cookie = opts.headers.Cookie;
-                if (opts.method === 'POST')
-                    return cookie === 'JSESSIONID=new.tomcat1' ? resp(200, [], {}) : resp(403, [], {});
-                if (!cookie)
-                    return resp(200, ['JSESSIONID=new.tomcat1']);
-                return resp(200, []);
-            });
-            await Promise.all([1, 2, 3].map(() => new flexplm_connect_1.FlexPLMConnect(sessionConfig(u)).sendToFlexPLM(payload)));
-            expect(fetchMock().mock.calls.filter(isColdGet)).toHaveLength(1);
-        });
-    });
 });
 describe('FlexPLMConnect session reuse - feature disabled (default)', () => {
     const payload = { id: '123' };
@@ -476,7 +361,7 @@ describe('FlexPLMConnect session reuse - feature disabled (default)', () => {
         expect(callHeaders(1).Cookie).toBeUndefined();
     });
 });
-describe('FlexPLMConnect.getRequest session reuse', () => {
+describe('FlexPLMConnect.getRequest session reuse (only if you applied step 2g)', () => {
     it('sends the cached cookie on image/GET requests', async () => {
         const u = uniqueUser();
         fetchMock()
@@ -501,20 +386,5 @@ describe('FlexPLMConnect.getRequest session reuse', () => {
         expect(callHeaders(2).Cookie).toBe('JSESSIONID=abc.tomcat1');
         expect(callHeaders(3).Cookie).toBeUndefined();
     });
-    it('does not re-store the rejected cookie when the retry issues no Set-Cookie', async () => {
-        const u = uniqueUser();
-        fetchMock()
-            .mockResolvedValueOnce(resp(200, ['JSESSIONID=stale.tomcat1']))
-            .mockResolvedValueOnce(resp(200, [], {}))
-            .mockResolvedValueOnce(resp(401, [])) // getRequest with the cached cookie
-            .mockResolvedValueOnce(resp(200, [], { items: [] })) // retry succeeds, no Set-Cookie
-            .mockResolvedValueOnce(resp(200, [], { items: [] })); // next getRequest
-        const connect = new flexplm_connect_1.FlexPLMConnect(sessionConfig(u));
-        await connect.sendToFlexPLM({ id: '1' });
-        await connect.getRequest();
-        await connect.getRequest();
-        expect(callHeaders(3).Cookie).toBeUndefined();
-        expect(callHeaders(4).Cookie).toBeUndefined(); // stale cookie must not be sent again
-    });
 });
 // Added for Session reuse - ET-390 - Ends

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contrail/flexplm",
-  "version": "1.7.7-alpha.7ad4e7e",
+  "version": "1.7.7-alpha.89ddfa2",
   "description": "Library used for integration with flexplm.",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",