@5minds/node-red-contrib-processcube 1.5.2-feature-4db23e-m33j5ixt → 1.5.2-feature-03d546-m361r6u4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (2) hide show
  1. package/package.json +2 -2
  2. package/processcube-engine-config.js +151 -153
package/package.json CHANGED
@@ -1,6 +1,6 @@
1
1
  {
2
2
  "name": "@5minds/node-red-contrib-processcube",
3
- "version": "1.5.2-feature-4db23e-m33j5ixt",
3
+ "version": "1.5.2-feature-03d546-m361r6u4",
4
4
  "license": "MIT",
5
5
  "description": "Node-RED nodes for ProcessCube",
6
6
  "scripts": {
@@ -57,7 +57,7 @@
57
57
  "examples": "examples"
58
58
  },
59
59
  "dependencies": {
60
- "@5minds/processcube_engine_client": "^5.1.0",
60
+ "@5minds/processcube_engine_client": "5.1.0-hotfix-a73235-m346kg1n",
61
61
  "jwt-decode": "^4.0.0",
62
62
  "openid-client": "^5.5.0"
63
63
  },
package/processcube-engine-config.js CHANGED
@@ -12,52 +12,8 @@ module.exports = function (RED) {
12
12
  this.url = RED.util.evaluateNodeProperty(n.url, n.urlType, node);
13
13
  this.identity = null;
14
14
 
15
- async function startUpdatingCredentialsCycle() {
16
- let retries = 5;
17
- const UPDATE_INTERVAL = 10000;
18
- let previousClientId, previousClientSecret;
19
-
20
- const updateCredentials = async () => {
21
- try {
22
- const newClientId = RED.util.evaluateNodeProperty(n.clientId, n.clientIdType, node);
23
- const newClientSecret = RED.util.evaluateNodeProperty(n.clientSecret, n.clientSecretType, node);
24
-
25
- if (newClientId !== previousClientId || newClientSecret !== previousClientSecret) {
26
- if (this.engineClient) this.engineClient.dispose();
27
-
28
- this.credentials.clientId = newClientId;
29
- this.credentials.clientSecret = newClientSecret;
30
-
31
- this.engineClient = new engine_client.EngineClient(this.url);
32
-
33
- if (this.credentials.clientId && this.credentials.clientSecret) {
34
- const authorityUrl = await this.engineClient.applicationInfo.getAuthorityAddress();
35
- startRefreshingIdentityCycle(
36
- this.credentials.clientId,
37
- this.credentials.clientSecret,
38
- authorityUrl,
39
- node
40
- ).catch(console.error);
41
- }
42
-
43
- previousClientId = newClientId;
44
- previousClientSecret = newClientSecret;
45
- }
46
-
47
- retries = 5;
48
- setTimeout(updateCredentials, UPDATE_INTERVAL);
49
- } catch (error) {
50
- if (retries === 0) return console.error('Credential update failed permanently:', error);
51
- console.error('Credential update error, retrying:', { error, retries });
52
- retries--;
53
- setTimeout(updateCredentials, 2000);
54
- }
55
- };
56
-
57
- await updateCredentials();
58
- }
59
-
60
- console.log('luis888', this.credentials.clientId);
15
+ this.credentials.clientId = RED.util.evaluateNodeProperty(n.clientId, n.clientIdType, node);
16
+ this.credentials.clientSecret = RED.util.evaluateNodeProperty(n.clientSecret, n.clientSecretType, node);
61
17
 
62
18
  this.registerOnIdentityChanged = function (callback) {
63
19
  identityChangedCallbacks.push(callback);
@@ -80,6 +36,51 @@ module.exports = function (RED) {
80
36
  }
81
37
  };
82
38
 
39
+ async function getFreshIdentity(url) {
40
+ try {
41
+ if (
42
+ !RED.util.evaluateNodeProperty(n.clientId, n.clientIdType, node) ||
43
+ !RED.util.evaluateNodeProperty(n.clientSecret, n.clientSecretType, node)
44
+ )
45
+ return null;
46
+ const res = await fetch(url + '/atlas_engine/api/v1/authority', {
47
+ method: 'GET',
48
+ headers: {
49
+ Authorization: `Bearer ZHVtbXlfdG9rZW4=`,
50
+ 'Content-Type': 'application/json',
51
+ },
52
+ });
53
+
54
+ const issuer = await oidc.Issuer.discover(await res.json());
55
+
56
+ const client = new issuer.Client({
57
+ client_id: RED.util.evaluateNodeProperty(n.clientId, n.clientIdType, node),
58
+ client_secret: RED.util.evaluateNodeProperty(n.clientSecret, n.clientSecretType, node),
59
+ });
60
+
61
+ const tokenSet = await client.grant({
62
+ grant_type: 'client_credentials',
63
+ scope: 'engine_etw engine_read engine_write',
64
+ });
65
+
66
+ const accessToken = tokenSet.access_token;
67
+ const decodedToken = jwt.jwtDecode(accessToken);
68
+
69
+ const freshIdentity = {
70
+ token: tokenSet.access_token,
71
+ userId: decodedToken.sub,
72
+ };
73
+
74
+ configNode.setIdentity(freshIdentity);
75
+
76
+ return freshIdentity;
77
+ } catch (e) {
78
+ console.log('Could not get fresh identity', e);
79
+ node.error('Could not get fresh identity');
80
+ node.error(e);
81
+ }
82
+ }
83
+
83
84
  node.on('close', async () => {
84
85
  if (this.engineClient) {
85
86
  this.engineClient.dispose();
@@ -87,32 +88,29 @@ module.exports = function (RED) {
87
88
  }
88
89
  });
89
90
 
90
- startUpdatingCredentialsCycle();
91
-
92
- // if (this.credentials.clientId && this.credentials.clientSecret) {
93
- // console.log('luis999', this.credentials.clientId);
94
- // this.engineClient = new engine_client.EngineClient(this.url);
95
-
96
- // this.engineClient.applicationInfo
97
- // .getAuthorityAddress()
98
- // .then((authorityUrl) => {
99
- // startRefreshingIdentityCycle(
100
- // this.credentials.clientId,
101
- // this.credentials.clientSecret,
102
- // authorityUrl,
103
- // node
104
- // ).catch((reason) => {
105
- // console.error(reason);
106
- // node.error(reason);
107
- // });
108
- // })
109
- // .catch((reason) => {
110
- // console.error(reason);
111
- // node.error(reason);
112
- // });
113
- // } else {
114
- // this.engineClient = new engine_client.EngineClient(this.url);
115
- // }
91
+ if (this.credentials.clientId && this.credentials.clientSecret) {
92
+ this.engineClient = new engine_client.EngineClient(this.url, () => getFreshIdentity(this.url));
93
+
94
+ // this.engineClient.applicationInfo
95
+ // .getAuthorityAddress()
96
+ // .then((authorityUrl) => {
97
+ // startRefreshingIdentityCycle(
98
+ // this.credentials.clientId,
99
+ // this.credentials.clientSecret,
100
+ // authorityUrl,
101
+ // node
102
+ // ).catch((reason) => {
103
+ // console.error(reason);
104
+ // node.error(reason);
105
+ // });
106
+ // })
107
+ // .catch((reason) => {
108
+ // console.error(reason);
109
+ // node.error(reason);
110
+ // });
111
+ } else {
112
+ this.engineClient = new engine_client.EngineClient(this.url);
113
+ }
116
114
  }
117
115
  RED.nodes.registerType('processcube-engine-config', ProcessCubeEngineNode, {
118
116
  credentials: {
@@ -122,84 +120,84 @@ module.exports = function (RED) {
122
120
  });
123
121
  };
124
122
 
125
- async function getFreshTokenSet(clientId, clientSecret, authorityUrl) {
126
- const issuer = await oidc.Issuer.discover(authorityUrl);
127
-
128
- const client = new issuer.Client({
129
- client_id: clientId,
130
- client_secret: clientSecret,
131
- });
132
-
133
- const tokenSet = await client.grant({
134
- grant_type: 'client_credentials',
135
- scope: 'engine_etw engine_read engine_write',
136
- });
137
-
138
- return tokenSet;
139
- }
140
-
141
- function getIdentityForExternalTaskWorkers(tokenSet) {
142
- const accessToken = tokenSet.access_token;
143
- const decodedToken = jwt.jwtDecode(accessToken);
144
-
145
- return {
146
- token: tokenSet.access_token,
147
- userId: decodedToken.sub,
148
- };
149
- }
150
-
151
- async function getExpiresInForExternalTaskWorkers(tokenSet) {
152
- let expiresIn = tokenSet.expires_in;
153
-
154
- if (!expiresIn && tokenSet.expires_at) {
155
- expiresIn = Math.floor(tokenSet.expires_at - Date.now() / 1000);
156
- }
157
-
158
- if (expiresIn === undefined) {
159
- throw new Error('Could not determine the time until the access token for external task workers expires');
160
- }
161
-
162
- return expiresIn;
163
- }
164
-
165
- /**
166
- * Start refreshing the identity in regular intervals.
167
- * @param {TokenSet | null} tokenSet The token set to refresh the identity for
168
- * @returns {Promise<void>} A promise that resolves when the timer for refreshing the identity is initialized
169
- * */
170
- async function startRefreshingIdentityCycle(clientId, clientSecret, authorityUrl, configNode) {
171
- let retries = 5;
172
-
173
- const refresh = async () => {
174
- try {
175
- const newTokenSet = await getFreshTokenSet(clientId, clientSecret, authorityUrl);
176
- const expiresIn = await getExpiresInForExternalTaskWorkers(newTokenSet);
177
- const delay = expiresIn * DELAY_FACTOR * 1000;
178
-
179
- freshIdentity = getIdentityForExternalTaskWorkers(newTokenSet);
180
-
181
- configNode.setIdentity(freshIdentity);
182
-
183
- retries = 5;
184
- setTimeout(refresh, delay);
185
- } catch (error) {
186
- if (retries === 0) {
187
- console.error(
188
- 'Could not refresh identity for external task worker processes. Stopping all external task workers.',
189
- { error }
190
- );
191
- return;
192
- }
193
- console.error('Could not refresh identity for external task worker processes.', {
194
- error,
195
- retryCount: retries,
196
- });
197
- retries--;
198
-
199
- const delay = 2 * 1000;
200
- setTimeout(refresh, delay);
201
- }
202
- };
203
-
204
- await refresh();
205
- }
123
+ // async function getFreshTokenSet(clientId, clientSecret, authorityUrl) {
124
+ // const issuer = await oidc.Issuer.discover(authorityUrl);
125
+
126
+ // const client = new issuer.Client({
127
+ // client_id: clientId,
128
+ // client_secret: clientSecret,
129
+ // });
130
+
131
+ // const tokenSet = await client.grant({
132
+ // grant_type: 'client_credentials',
133
+ // scope: 'engine_etw engine_read engine_write',
134
+ // });
135
+
136
+ // return tokenSet;
137
+ // }
138
+
139
+ // function getIdentityForExternalTaskWorkers(tokenSet) {
140
+ // const accessToken = tokenSet.access_token;
141
+ // const decodedToken = jwt.jwtDecode(accessToken);
142
+
143
+ // return {
144
+ // token: tokenSet.access_token,
145
+ // userId: decodedToken.sub,
146
+ // };
147
+ // }
148
+
149
+ // async function getExpiresInForExternalTaskWorkers(tokenSet) {
150
+ // let expiresIn = tokenSet.expires_in;
151
+
152
+ // if (!expiresIn && tokenSet.expires_at) {
153
+ // expiresIn = Math.floor(tokenSet.expires_at - Date.now() / 1000);
154
+ // }
155
+
156
+ // if (expiresIn === undefined) {
157
+ // throw new Error('Could not determine the time until the access token for external task workers expires');
158
+ // }
159
+
160
+ // return expiresIn;
161
+ // }
162
+
163
+ // /**
164
+ // * Start refreshing the identity in regular intervals.
165
+ // * @param {TokenSet | null} tokenSet The token set to refresh the identity for
166
+ // * @returns {Promise<void>} A promise that resolves when the timer for refreshing the identity is initialized
167
+ // * */
168
+ // async function startRefreshingIdentityCycle(clientId, clientSecret, authorityUrl, configNode) {
169
+ // let retries = 5;
170
+
171
+ // const refresh = async () => {
172
+ // try {
173
+ // const newTokenSet = await getFreshTokenSet(clientId, clientSecret, authorityUrl);
174
+ // const expiresIn = await getExpiresInForExternalTaskWorkers(newTokenSet);
175
+ // const delay = expiresIn * DELAY_FACTOR * 1000;
176
+
177
+ // freshIdentity = getIdentityForExternalTaskWorkers(newTokenSet);
178
+
179
+ // configNode.setIdentity(freshIdentity);
180
+
181
+ // retries = 5;
182
+ // setTimeout(refresh, delay);
183
+ // } catch (error) {
184
+ // if (retries === 0) {
185
+ // console.error(
186
+ // 'Could not refresh identity for external task worker processes. Stopping all external task workers.',
187
+ // { error }
188
+ // );
189
+ // return;
190
+ // }
191
+ // console.error('Could not refresh identity for external task worker processes.', {
192
+ // error,
193
+ // retryCount: retries,
194
+ // });
195
+ // retries--;
196
+
197
+ // const delay = 2 * 1000;
198
+ // setTimeout(refresh, delay);
199
+ // }
200
+ // };
201
+
202
+ // await refresh();
203
+ // }