@5minds/node-red-contrib-processcube 1.5.2-feature-4db23e-m33j5ixt → 1.5.2-feature-059ba7-m35qmr4f

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 +146 -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-059ba7-m35qmr4f",
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,46 @@ module.exports = function (RED) {
80
36
  }
81
37
  };
82
38
 
39
+ async function getFreshIdentity(url) {
40
+ console.log('luis777');
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
+ }
78
+
83
79
  node.on('close', async () => {
84
80
  if (this.engineClient) {
85
81
  this.engineClient.dispose();
@@ -87,32 +83,29 @@ module.exports = function (RED) {
87
83
  }
88
84
  });
89
85
 
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
- // }
86
+ if (this.credentials.clientId && this.credentials.clientSecret) {
87
+ this.engineClient = new engine_client.EngineClient(this.url, () => getFreshIdentity(this.url));
88
+
89
+ // this.engineClient.applicationInfo
90
+ // .getAuthorityAddress()
91
+ // .then((authorityUrl) => {
92
+ // startRefreshingIdentityCycle(
93
+ // this.credentials.clientId,
94
+ // this.credentials.clientSecret,
95
+ // authorityUrl,
96
+ // node
97
+ // ).catch((reason) => {
98
+ // console.error(reason);
99
+ // node.error(reason);
100
+ // });
101
+ // })
102
+ // .catch((reason) => {
103
+ // console.error(reason);
104
+ // node.error(reason);
105
+ // });
106
+ } else {
107
+ this.engineClient = new engine_client.EngineClient(this.url);
108
+ }
116
109
  }
117
110
  RED.nodes.registerType('processcube-engine-config', ProcessCubeEngineNode, {
118
111
  credentials: {
@@ -122,84 +115,84 @@ module.exports = function (RED) {
122
115
  });
123
116
  };
124
117
 
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
- }
118
+ // async function getFreshTokenSet(clientId, clientSecret, authorityUrl) {
119
+ // const issuer = await oidc.Issuer.discover(authorityUrl);
120
+
121
+ // const client = new issuer.Client({
122
+ // client_id: clientId,
123
+ // client_secret: clientSecret,
124
+ // });
125
+
126
+ // const tokenSet = await client.grant({
127
+ // grant_type: 'client_credentials',
128
+ // scope: 'engine_etw engine_read engine_write',
129
+ // });
130
+
131
+ // return tokenSet;
132
+ // }
133
+
134
+ // function getIdentityForExternalTaskWorkers(tokenSet) {
135
+ // const accessToken = tokenSet.access_token;
136
+ // const decodedToken = jwt.jwtDecode(accessToken);
137
+
138
+ // return {
139
+ // token: tokenSet.access_token,
140
+ // userId: decodedToken.sub,
141
+ // };
142
+ // }
143
+
144
+ // async function getExpiresInForExternalTaskWorkers(tokenSet) {
145
+ // let expiresIn = tokenSet.expires_in;
146
+
147
+ // if (!expiresIn && tokenSet.expires_at) {
148
+ // expiresIn = Math.floor(tokenSet.expires_at - Date.now() / 1000);
149
+ // }
150
+
151
+ // if (expiresIn === undefined) {
152
+ // throw new Error('Could not determine the time until the access token for external task workers expires');
153
+ // }
154
+
155
+ // return expiresIn;
156
+ // }
157
+
158
+ // /**
159
+ // * Start refreshing the identity in regular intervals.
160
+ // * @param {TokenSet | null} tokenSet The token set to refresh the identity for
161
+ // * @returns {Promise<void>} A promise that resolves when the timer for refreshing the identity is initialized
162
+ // * */
163
+ // async function startRefreshingIdentityCycle(clientId, clientSecret, authorityUrl, configNode) {
164
+ // let retries = 5;
165
+
166
+ // const refresh = async () => {
167
+ // try {
168
+ // const newTokenSet = await getFreshTokenSet(clientId, clientSecret, authorityUrl);
169
+ // const expiresIn = await getExpiresInForExternalTaskWorkers(newTokenSet);
170
+ // const delay = expiresIn * DELAY_FACTOR * 1000;
171
+
172
+ // freshIdentity = getIdentityForExternalTaskWorkers(newTokenSet);
173
+
174
+ // configNode.setIdentity(freshIdentity);
175
+
176
+ // retries = 5;
177
+ // setTimeout(refresh, delay);
178
+ // } catch (error) {
179
+ // if (retries === 0) {
180
+ // console.error(
181
+ // 'Could not refresh identity for external task worker processes. Stopping all external task workers.',
182
+ // { error }
183
+ // );
184
+ // return;
185
+ // }
186
+ // console.error('Could not refresh identity for external task worker processes.', {
187
+ // error,
188
+ // retryCount: retries,
189
+ // });
190
+ // retries--;
191
+
192
+ // const delay = 2 * 1000;
193
+ // setTimeout(refresh, delay);
194
+ // }
195
+ // };
196
+
197
+ // await refresh();
198
+ // }