Skip to content

Commit a3dcf58

Browse files
ChunsonHoagChunsonHoag
committed
time travel back in time for some reason
1 parent 801db4b commit a3dcf58

File tree

3 files changed

+96
-119
lines changed

3 files changed

+96
-119
lines changed

‎package.json‎

Lines changed: 2 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -7,13 +7,9 @@
77
"scripts": {
88
"test-jest": "jest",
99
"test-mocha": "mocha",
10-
"prod": "electron --noDevServer .",
11-
"prod2": "webpack --mode production --config webpack.build.config.js && electron --noDevServer .",
12-
"start": "webpack-dev-server --mode development --hot --host 0.0.0.0 --config=./webpack.dev.config.js ",
13-
"dev-server": "cross-env NODE_ENV=development webpack-dev-server --config ./webpack.development.js",
14-
"dev": "electron .",
1510
"build": "cross-env NODE_ENV=production webpack --mode=production --config ./webpack.production.js",
16-
"build2": "webpack --config webpack.build.config.js --mode production",
11+
"start": "electron --noDevServer .",
12+
"dev": "cross-env NODE_ENV=development webpack-dev-server --config ./webpack.development.js",
1713
"server": "nodemon test-server/server.js",
1814
"package-mac": "electron-builder build --x64 --mac",
1915
"package-all": "electron-builder build -mwl",

‎src/client/controllers/grpcController.js‎

Lines changed: 93 additions & 112 deletions
Original file line numberDiff line numberDiff line change
@@ -1,32 +1,23 @@
11
// import { Router } from "express";
2-
import {
3-
ipcRenderer
4-
} from "electron";
5-
import {
6-
remote
7-
} from 'electron';
8-
import * as store from '../store';
9-
import * as actions from '../actions/actions';
10-
import {
11-
Metadata
12-
} from "@grpc/grpc-js";
13-
14-
15-
16-
const async = require('async');
17-
const fs = require('fs');
18-
const parseArgs = require('minimist');
19-
const path = require('path');
20-
const grpc = require('@grpc/grpc-js');
21-
const protoLoader = require('@grpc/proto-loader');
2+
import { ipcRenderer } from "electron";
3+
import { remote } from "electron";
4+
import * as store from "../store";
5+
import * as actions from "../actions/actions";
6+
import { Metadata } from "@grpc/grpc-js";
7+
8+
const async = require("async");
9+
const fs = require("fs");
10+
const parseArgs = require("minimist");
11+
const path = require("path");
12+
const grpc = require("@grpc/grpc-js");
13+
const protoLoader = require("@grpc/proto-loader");
2214

2315
let grpcController = {};
2416

25-
2617
grpcController.openGrpcConnection = (reqResObj, connectionArray) => {
2718
//check for connection, if not open one
2819

29-
reqResObj.connectionType = 'GRPC';
20+
reqResObj.connectionType = "GRPC";
3021
reqResObj.response.times = [];
3122

3223
// build out variables from reqresObj properties
@@ -77,198 +68,188 @@ grpcController.openGrpcConnection = (reqResObj, connectionArray) => {
7768
for (let messageIdx in foundService.messages) {
7869
let message = foundService.messages[messageIdx];
7970

80-
if (foundRpc.req === message.name || foundRpc.req === 'stream ' + message.name) {
71+
if (
72+
foundRpc.req === message.name ||
73+
foundRpc.req === "stream " + message.name
74+
) {
8175
messageDefObj = message.def;
8276
keysArray = [];
8377
Object.keys(messageDefObj).forEach((key) => {
84-
keysArray.push(key)
85-
})
78+
keysArray.push(key);
79+
});
8680
}
8781
}
8882
// build gRPC package definition with protoLoader module
8983
let PROTO_PATH = reqResObj.protoPath;
90-
const packageDefinition = protoLoader.loadSync(
91-
PROTO_PATH, {
92-
keepCase: true,
93-
longs: String,
94-
enums: String,
95-
defaults: true,
96-
oneofs: true
97-
98-
}
99-
)
84+
const packageDefinition = protoLoader.loadSync(PROTO_PATH, {
85+
keepCase: true,
86+
longs: String,
87+
enums: String,
88+
defaults: true,
89+
oneofs: true,
90+
});
10091
// create client credentials
10192
let serverName = grpc.loadPackageDefinition(packageDefinition)[packageName];
102-
let client = new serverName[service](`${url}`, grpc.credentials.createInsecure());
93+
let client = new serverName[service](
94+
`${url}`,
95+
grpc.credentials.createInsecure()
96+
);
10397

10498
// create client requested metadata key and value pair for each type of streaming
105-
let meta = new grpc.Metadata()
99+
let meta = new grpc.Metadata();
106100
let metaArr = reqResObj.request.headers;
107101
for (let i = 0; i < metaArr.length; i += 1) {
108102
let currentHeader = metaArr[i];
109-
meta.add(currentHeader.key, currentHeader.value)
103+
meta.add(currentHeader.key, currentHeader.value);
110104
}
111105

112-
if (rpcType === 'UNARY') {
113-
let query = reqResObj.queryArr[0]
106+
if (rpcType === "UNARY") {
107+
let query = reqResObj.queryArr[0];
114108
let time = {};
115109

116110
// Open Connection and set time sent for Unary
117-
reqResObj.connection = 'open';
111+
reqResObj.connection = "open";
118112

119113
time.timeSent = Date.now();
120114
// make Unary call
121115
client[rpc](query, meta, (err, data) => {
116+
if (err) {
117+
console.log("unary error", err);
118+
}
119+
// Close Connection and set time received for Unary
120+
reqResObj.timeSent = time.timeSent;
122121

123-
if (err) {
124-
console.log('unary error', err);
125-
}
126-
// Close Connection and set time received for Unary
127-
reqResObj.timeSent = time.timeSent;
128-
129-
time.timeReceived = Date.now();
130-
reqResObj.timeReceived = time.timeReceived
131-
132-
reqResObj.connection = 'closed';
133-
reqResObj.response.events.push(data)
134-
reqResObj.response.times.push(time)
135-
store.default.dispatch(actions.reqResUpdate(reqResObj));
136-
122+
time.timeReceived = Date.now();
123+
reqResObj.timeReceived = time.timeReceived;
137124

138-
}) // metadata from server
139-
.on('metadata', (metadata) => {
125+
reqResObj.connection = "closed";
126+
reqResObj.response.events.push(data);
127+
reqResObj.response.times.push(time);
128+
store.default.dispatch(actions.reqResUpdate(reqResObj));
129+
}) // metadata from server
130+
.on("metadata", (metadata) => {
140131
// if metadata is sent back from the server, analyze and handle
141-
let keys = Object.keys(metadata._internal_repr)
132+
let keys = Object.keys(metadata._internal_repr);
142133
for (let i = 0; i < keys.length; i += 1) {
143134
let key = keys[i];
144135
reqResObj.response.headers[key] = metadata._internal_repr[key][0];
145136
}
146-
store.default.dispatch(actions.reqResUpdate(reqResObj))
147-
})
148-
149-
} else if (rpcType === 'CLIENT STREAM') {
137+
store.default.dispatch(actions.reqResUpdate(reqResObj));
138+
});
139+
} else if (rpcType === "CLIENT STREAM") {
150140
// create call and open client stream connection
151-
reqResObj.connection = 'open';
141+
reqResObj.connection = "open";
152142
let timeSent = Date.now();
153143
reqResObj.timeSent = timeSent;
154144
let call = client[rpc](meta, function (error, response) {
155145
if (error) {
156-
console.log('error in client stream', error);
146+
console.log("error in client stream", error);
157147
return;
158148
} else {
159149
//Close Connection for client Stream
160-
reqResObj.connection = 'closed';
150+
reqResObj.connection = "closed";
161151
let curTime = Date.now();
162-
reqResObj.response.times.forEach(time => {
152+
reqResObj.response.times.forEach((time) => {
163153
time.timeReceived = curTime;
164154
reqResObj.timeReceived = time.timeReceived;
165-
166-
})
167-
reqResObj.response.events.push(response)
155+
});
156+
reqResObj.response.events.push(response);
168157
store.default.dispatch(actions.reqResUpdate(reqResObj));
169-
170158
}
171-
}).on('metadata', (metadata) => {
159+
}).on("metadata", (metadata) => {
172160
// if metadata is sent back from the server, analyze and handle
173-
let keys = Object.keys(metadata._internal_repr)
161+
let keys = Object.keys(metadata._internal_repr);
174162
for (let i = 0; i < keys.length; i += 1) {
175163
let key = keys[i];
176164
reqResObj.response.headers[key] = metadata._internal_repr[key][0];
177165
}
178-
store.default.dispatch(actions.reqResUpdate(reqResObj))
166+
store.default.dispatch(actions.reqResUpdate(reqResObj));
179167
});
180168

181-
182169
for (let i = 0; i < queryArr.length; i++) {
183170
let query = queryArr[i];
184171
// Open Connection for client Stream
185172
// this needs additional work to provide correct sent time for each
186173
// request without overwrite
187174
let time = {};
188175

189-
reqResObj.connection = 'pending';
190-
176+
reqResObj.connection = "pending";
191177

192178
time.timeSent = timeSent;
193-
reqResObj.response.times.push(time)
194-
179+
reqResObj.response.times.push(time);
195180

196181
//reqResObj.connectionType = 'plain';
197182
// reqResObj.timeSent = Date.now();
198183

199184
call.write(query);
200185
}
201186
call.end();
202-
} else if (rpcType === 'SERVER STREAM') {
187+
} else if (rpcType === "SERVER STREAM") {
203188
let timesArr = [];
204189
// Open Connection for SERVER Stream
205-
reqResObj.connection = 'open';
190+
reqResObj.connection = "open";
206191
reqResObj.timeSent = Date.now();
207192
const call = client[rpc](reqResObj.queryArr[0], meta);
208-
call.on("data", resp => {
193+
call.on("data", (resp) => {
209194
let time = {};
210195
time.timeReceived = Date.now();
211196
time.timeSent = reqResObj.timeSent;
212197
// add server response to reqResObj and dispatch to state/store
213-
reqResObj.response.events.push(resp)
214-
reqResObj.response.times.push(time)
198+
reqResObj.response.events.push(resp);
199+
reqResObj.response.times.push(time);
215200
reqResObj.timeReceived = time.timeReceived; // overwritten on each call to get the final value
216201

217202
store.default.dispatch(actions.reqResUpdate(reqResObj));
218-
})
219-
call.on('error', () => {
203+
});
204+
call.on("error", () => {
220205
// for fatal error from server
221-
console.log('server side stream erring out')
222-
})
223-
call.on('end', () => {
206+
console.log("server side stream erring out");
207+
});
208+
call.on("end", () => {
224209
// Close Connection for SERVER Stream
225-
reqResObj.connection = 'closed';
210+
reqResObj.connection = "closed";
226211
// no need to push response to reqResObj, no event expected from on 'end'
227212
store.default.dispatch(actions.reqResUpdate(reqResObj));
228-
})
229-
call.on('metadata', (metadata) => {
230-
let keys = Object.keys(metadata._internal_repr)
213+
});
214+
call.on("metadata", (metadata) => {
215+
let keys = Object.keys(metadata._internal_repr);
231216
for (let i = 0; i < keys.length; i += 1) {
232217
let key = keys[i];
233218
reqResObj.response.headers[key] = metadata._internal_repr[key][0];
234-
235219
}
236-
store.default.dispatch(actions.reqResUpdate(reqResObj))
237-
})
220+
store.default.dispatch(actions.reqResUpdate(reqResObj));
221+
});
238222
}
239223
//else BIDIRECTIONAL
240224
else {
241225
// Open duplex stream
242226
let counter = 0;
243227
let call = client[rpc](meta);
244-
call.on('data', (response) => {
228+
call.on("data", (response) => {
245229
let curTimeObj = reqResObj.response.times[counter];
246230
counter++;
247231
//Close Individual Server Response for BIDIRECTIONAL Stream
248-
reqResObj.connection = 'pending';
232+
reqResObj.connection = "pending";
249233
curTimeObj.timeReceived = Date.now();
250234
reqResObj.timeReceived = curTimeObj.timeReceived;
251235
reqResObj.response.events.push(response);
252236
reqResObj.response.times.push(curTimeObj);
253237
store.default.dispatch(actions.reqResUpdate(reqResObj));
254-
255-
256-
}) // metadata from server
257-
call.on('metadata', (metadata) => {
258-
let keys = Object.keys(metadata._internal_repr)
238+
}); // metadata from server
239+
call.on("metadata", (metadata) => {
240+
let keys = Object.keys(metadata._internal_repr);
259241
for (let i = 0; i < keys.length; i += 1) {
260242
let key = keys[i];
261243
reqResObj.response.headers[key] = metadata._internal_repr[key][0];
262-
263244
}
264-
store.default.dispatch(actions.reqResUpdate(reqResObj))
245+
store.default.dispatch(actions.reqResUpdate(reqResObj));
246+
});
247+
call.on("error", () => {
248+
console.log("server ended connection with error");
265249
});
266-
call.on('error', () => {
267-
console.log('server ended connection with error')
268-
})
269-
call.on('end', (data) => {
250+
call.on("end", (data) => {
270251
//Close Final Server Connection for BIDIRECTIONAL Stream
271-
reqResObj.connection = 'closed'
252+
reqResObj.connection = "closed";
272253
// no need to push response to reqResObj, no event expected from on 'end'
273254
store.default.dispatch(actions.reqResUpdate(reqResObj));
274255
});
@@ -278,13 +259,13 @@ grpcController.openGrpcConnection = (reqResObj, connectionArray) => {
278259
let query = queryArr[i];
279260
//Open Connection for BIDIRECTIONAL Stream
280261
if (i === 0) {
281-
reqResObj.connection = 'open';
262+
reqResObj.connection = "open";
282263
} else {
283-
reqResObj.connection = 'pending';
264+
reqResObj.connection = "pending";
284265
}
285266
time.timeSent = Date.now();
286267
reqResObj.timeSent = time.timeSent;
287-
reqResObj.response.times.push(time)
268+
reqResObj.response.times.push(time);
288269
call.write(query);
289270
}
290271
call.end();

‎webpack.config.js‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -11,7 +11,7 @@ module.exports = {
1111
output: {
1212
path: path.resolve(__dirname, "dist"),
1313
filename: "bundle.js",
14-
publicPath: "/",
14+
publicPath: "./",
1515
},
1616
module: {
1717
rules: [

0 commit comments

Comments
 (0)