110 |
114 |
115 | Controls
111 | 112 | 113 |114 |
116 |
119 |
120 |
121 |
--------------------------------------------------------------------------------
/hyco-websocket/test/unit/request.js:
--------------------------------------------------------------------------------
1 | var test = require('tape');
2 |
3 | var WebSocketClient = require('../../lib/WebSocketClient');
4 | var server = require('../shared/test-server');
5 | var stopServer = server.stopServer;
6 |
7 | test('Request can only be rejected or accepted once.', function(t) {
8 | t.plan(6);
9 |
10 | t.on('end', function() {
11 | stopServer();
12 | });
13 |
14 | server.prepare(function(err, wsServer) {
15 | if (err) {
16 | t.fail('Unable to start test server');
17 | return t.end();
18 | }
19 |
20 | wsServer.once('request', firstReq);
21 | connect(2);
22 |
23 | function firstReq(request) {
24 | var accept = request.accept.bind(request, request.requestedProtocols[0], request.origin);
25 | var reject = request.reject.bind(request);
26 |
27 | t.doesNotThrow(accept, 'First call to accept() should succeed.');
28 | t.throws(accept, 'Second call to accept() should throw.');
29 | t.throws(reject, 'Call to reject() after accept() should throw.');
30 |
31 | wsServer.once('request', secondReq);
32 | }
33 |
34 | function secondReq(request) {
35 | var accept = request.accept.bind(request, request.requestedProtocols[0], request.origin);
36 | var reject = request.reject.bind(request);
37 |
38 | t.doesNotThrow(reject, 'First call to reject() should succeed.');
39 | t.throws(reject, 'Second call to reject() should throw.');
40 | t.throws(accept, 'Call to accept() after reject() should throw.');
41 |
42 | t.end();
43 | }
44 |
45 | function connect(numTimes) {
46 | var client;
47 | for (var i = 0; i < numTimes; i++) {
48 | client = new WebSocketClient();
49 | client.connect('ws://localhost:64321/', 'foo');
50 | client.on('connect', function(connection) { connection.close(); });
51 | }
52 | }
53 | });
54 | });
55 |
56 | test('Protocol mismatch should be handled gracefully', function(t) {
57 | var wsServer;
58 |
59 | t.test('setup', function(t) {
60 | server.prepare(function(err, result) {
61 | if (err) {
62 | t.fail('Unable to start test server');
63 | return t.end();
64 | }
65 |
66 | wsServer = result;
67 | t.end();
68 | });
69 | });
70 |
71 | t.test('mismatched protocol connection', function(t) {
72 | t.plan(2);
73 | wsServer.on('request', handleRequest);
74 |
75 | var client = new WebSocketClient();
76 |
77 | var timer = setTimeout(function() {
78 | t.fail('Timeout waiting for client event');
79 | }, 2000);
80 |
81 | client.connect('ws://localhost:64321/', 'some_protocol_here');
82 | client.on('connect', function(connection) {
83 | clearTimeout(timer);
84 | connection.close();
85 | t.fail('connect event should not be emitted on client');
86 | });
87 | client.on('connectFailed', function() {
88 | clearTimeout(timer);
89 | t.pass('connectFailed event should be emitted on client');
90 | });
91 |
92 |
93 |
94 | function handleRequest(request) {
95 | var accept = request.accept.bind(request, 'this_is_the_wrong_protocol', request.origin);
96 | t.throws(accept, 'request.accept() should throw');
97 | }
98 | });
99 |
100 | t.test('teardown', function(t) {
101 | stopServer();
102 | t.end();
103 | });
104 | });
105 |
--------------------------------------------------------------------------------
/hyco-websocket/test/scripts/echo-server.js:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env node
2 | /************************************************************************
3 | * Copyright 2010-2015 Brian McKelvey.
4 | *
5 | * Licensed under the Apache License, Version 2.0 (the 'License');
6 | * you may not use this file except in compliance with the License.
7 | * You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an 'AS IS' BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | ***********************************************************************/
17 |
18 | var WebSocket = require('../..');
19 | var WebSocketServer = require('../../lib/HybridConnectionsWebSocketServer');
20 |
21 | var args = { /* defaults */
22 | debug: false,
23 | ns : process.env.RELAY_NAMESPACE,
24 | path : process.env.RELAY_PATH,
25 | keyrule : process.env.RELAY_KEYRULE,
26 | key : process.env.RELAY_KEY
27 | };
28 |
29 | /* Parse command line options */
30 | var pattern = /^--(.*?)(?:=(.*))?$/;
31 | process.argv.forEach(function(value) {
32 | var match = pattern.exec(value);
33 | if (match) {
34 | args[match[1]] = match[2] ? match[2] : true;
35 | }
36 | });
37 |
38 | var ns = args.ns;
39 | var path = args.path;
40 | var keyrule = args.keyrule;
41 | var key = args.key;
42 | var debug = args.debug;
43 |
44 | console.log('WebSocket-Node: echo-server');
45 |
46 | if (ns == null || path == null || keyrule == null || key == null) {
47 | console.log('Usage: ./echo-server.js [--ns=ns.servicebus.windows.net] [--path=path] [--keyrule=keyrule] [--key=key] [--debug]');
48 | return;
49 | }
50 |
51 | var uri = WebSocket.createRelayListenUri(ns, path);
52 |
53 | var wsServer = new WebSocketServer({
54 | server : uri,
55 | token: WebSocket.createRelayToken(uri, keyrule, key),
56 | autoAcceptConnections: true,
57 | maxReceivedFrameSize: 64*1024*1024, // 64MiB
58 | maxReceivedMessageSize: 64*1024*1024, // 64MiB
59 | fragmentOutgoingMessages: false,
60 | keepalive: false,
61 | disableNagleAlgorithm: false
62 | });
63 |
64 | wsServer.on('connect', function(connection) {
65 | if (debug) { console.log((new Date()) + ' Connection accepted' +
66 | ' - Protocol Version ' + connection.webSocketVersion); }
67 | function sendCallback(err) {
68 | if (err) {
69 | console.error('send() error: ' + err);
70 | connection.drop();
71 | setTimeout(function() {
72 | process.exit(100);
73 | }, 100);
74 | }
75 | }
76 | connection.on('message', function(message) {
77 | if (message.type === 'utf8') {
78 | if (debug) { console.log('Received utf-8 message of ' + message.utf8Data.length + ' characters.'); }
79 | connection.sendUTF(message.utf8Data, sendCallback);
80 | }
81 | else if (message.type === 'binary') {
82 | if (debug) { console.log('Received Binary Message of ' + message.binaryData.length + ' bytes'); }
83 | connection.sendBytes(message.binaryData, sendCallback);
84 | }
85 | });
86 | connection.on('close', function(reasonCode, description) {
87 | if (debug) { console.log((new Date()) + ' Peer ' + connection.remoteAddress + ' disconnected.'); }
88 | connection._debug.printOutput();
89 | });
90 | });
91 |
--------------------------------------------------------------------------------
/hyco-websocket/test/scripts/libwebsockets-test-client.js:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env node
2 | /************************************************************************
3 | * Copyright 2010-2015 Brian McKelvey.
4 | *
5 | * Licensed under the Apache License, Version 2.0 (the 'License');
6 | * you may not use this file except in compliance with the License.
7 | * You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an 'AS IS' BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | ***********************************************************************/
17 |
18 | var WebSocketClient = require('../../lib/WebSocketClient');
19 |
20 | var args = { /* defaults */
21 | secure: false,
22 | version: 13
23 | };
24 |
25 | /* Parse command line options */
26 | var pattern = /^--(.*?)(?:=(.*))?$/;
27 | process.argv.forEach(function(value) {
28 | var match = pattern.exec(value);
29 | if (match) {
30 | args[match[1]] = match[2] ? match[2] : true;
31 | }
32 | });
33 |
34 | args.protocol = args.secure ? 'wss:' : 'ws:';
35 | args.version = parseInt(args.version, 10);
36 |
37 | if (!args.host || !args.port) {
38 | console.log('WebSocket-Node: Test client for Andy Green\'s libwebsockets-test-server');
39 | console.log('Usage: ./libwebsockets-test-client.js --host=127.0.0.1 --port=8080 [--version=8|13] [--secure]');
40 | console.log('');
41 | return;
42 | }
43 |
44 | var mirrorClient = new WebSocketClient({
45 | webSocketVersion: args.version
46 | });
47 |
48 | mirrorClient.on('connectFailed', function(error) {
49 | console.log('Connect Error: ' + error.toString());
50 | });
51 |
52 | mirrorClient.on('connect', function(connection) {
53 | console.log('lws-mirror-protocol connected');
54 | connection.on('error', function(error) {
55 | console.log('Connection Error: ' + error.toString());
56 | });
57 | connection.on('close', function() {
58 | console.log('lws-mirror-protocol Connection Closed');
59 | });
60 | function sendCallback(err) {
61 | if (err) { console.error('send() error: ' + err); }
62 | }
63 | function spamCircles() {
64 | if (connection.connected) {
65 | // c #7A9237 487 181 14;
66 | var color = 0x800000 + Math.round(Math.random() * 0x7FFFFF);
67 | var x = Math.round(Math.random() * 502);
68 | var y = Math.round(Math.random() * 306);
69 | var radius = Math.round(Math.random() * 30);
70 | connection.send('c #' + color.toString(16) + ' ' + x + ' ' + y + ' ' + radius + ';', sendCallback);
71 | setTimeout(spamCircles, 10);
72 | }
73 | }
74 | spamCircles();
75 | });
76 |
77 | mirrorClient.connect(args.protocol + '//' + args.host + ':' + args.port + '/', 'lws-mirror-protocol');
78 |
79 | var incrementClient = new WebSocketClient({
80 | webSocketVersion: args.version
81 | });
82 |
83 | incrementClient.on('connectFailed', function(error) {
84 | console.log('Connect Error: ' + error.toString());
85 | });
86 |
87 | incrementClient.on('connect', function(connection) {
88 | console.log('dumb-increment-protocol connected');
89 | connection.on('error', function(error) {
90 | console.log('Connection Error: ' + error.toString());
91 | });
92 | connection.on('close', function() {
93 | console.log('dumb-increment-protocol Connection Closed');
94 | });
95 | connection.on('message', function(message) {
96 | console.log('Number: \'' + message.utf8Data + '\'');
97 | });
98 | });
99 |
100 | incrementClient.connect(args.protocol + '//' + args.host + ':' + args.port + '/', 'dumb-increment-protocol');
101 |
--------------------------------------------------------------------------------
/hyco-websocket/index.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var crypto = require('crypto')
4 | var moment = require('moment')
5 | var url = require('url');
6 |
7 | var WS = module.exports = require('./lib/hybridconnectionswebsocket');
8 |
9 | /**
10 | * Create a Relay Token
11 | *
12 | * @param {String} uri The URL/address to connect to.
13 | * @param {String} keyName The SharedAccessSignature key name.
14 | * @param {String} key The SharedAccessSignature key value.
15 | * @param {number} expirationSeconds Optional number of seconds until the generated token should expire. Default is 1 hour (3600) if not specified.
16 | * @api public
17 | */
18 | WS.createRelayToken = function createRelayToken(uri, keyName, key, expirationSeconds) {
19 | var parsedUrl = url.parse(uri);
20 | parsedUrl.protocol = 'http';
21 | parsedUrl.search = parsedUrl.hash = parsedUrl.port = null;
22 | parsedUrl.pathname = parsedUrl.pathname.replace('$hc/','');
23 | uri = url.format(parsedUrl);
24 |
25 | if (!expirationSeconds) {
26 | // Token expires in one hour (3600 seconds)
27 | expirationSeconds = 3600;
28 | }
29 |
30 | var unixSeconds = moment().add(expirationSeconds, 'seconds').unix();
31 | var string_to_sign = encodeURIComponent(uri) + '\n' + unixSeconds;
32 | var hmac = crypto.createHmac('sha256', key);
33 | hmac.update(string_to_sign);
34 | var signature = hmac.digest('base64');
35 | var token = 'SharedAccessSignature sr=' + encodeURIComponent(uri) + '&sig=' + encodeURIComponent(signature) + '&se=' + unixSeconds + '&skn=' + keyName;
36 | return token;
37 | };
38 |
39 | /**
40 | * Create a Relay Token and append it to an existing Uri
41 | *
42 | * @param {String} uri The URL/address to connect to.
43 | * @param {String} keyName The SharedAccessSignature key name.
44 | * @param {String} key The SharedAccessSignature key value.
45 | * @param {number} expirationSeconds Optional number of seconds until the generated token should expire. Default is 1 hour (3600) if not specified.
46 | * @api public
47 | */
48 | WS.appendRelayToken = function appendRelayToken(uri, keyName, key, expirationSeconds) {
49 | var token = WS.createRelayToken(uri, keyName, key, expirationSeconds);
50 |
51 | var parsedUrl = url.parse(uri);
52 | parsedUrl.search = parsedUrl.search + '&sb-hc-token=' + encodeURIComponent(token);
53 | return url.format(parsedUrl);
54 | }
55 |
56 | /**
57 | * Create a Uri for using with Relay Hybrid Connections
58 | *
59 | * @param {String} serviceBusNamespace The ServiceBus namespace, e.g. 'contoso.servicebus.windows.net'.
60 | * @param {String} path The endpoint path.
61 | * @api public
62 | */
63 | WS.createRelayBaseUri = function createRelayBaseUri(serviceBusNamespace, path) {
64 | return 'wss://' + serviceBusNamespace + ':443/$hc/' + path;
65 | }
66 |
67 | /**
68 | * Create a Uri for sending to a Relay Hybrid Connection endpoint
69 | *
70 | * @param {String} serviceBusNamespace The ServiceBus namespace, e.g. 'contoso.servicebus.windows.net'.
71 | * @param {String} path The endpoint path.
72 | * @param {String} token Optional SharedAccessSignature token for authenticating the sender.
73 | * @param {String} id Optional A Guid string for end to end correlation.
74 | * @api public
75 | */
76 | WS.createRelaySendUri = function createRelaySendUri(serviceBusNamespace, path, token, id) {
77 | var uri = WS.createRelayBaseUri(serviceBusNamespace, path);
78 | uri = uri + (uri.indexOf('?') == -1 ? '?' : '&') + 'sb-hc-action=connect';
79 | if (token != null) {
80 | uri = uri + '&sb-hc-token=' + encodeURIComponent(token);
81 | }
82 | if (id != null) {
83 | uri = uri + '&sb-hc-id=' + encodeURIComponent(id);
84 | }
85 | return uri;
86 | }
87 |
88 | /**
89 | * Create a Uri for listening on a Relay Hybrid Connection endpoint
90 | *
91 | * @param {String} serviceBusNamespace The ServiceBus namespace, e.g. 'contoso.servicebus.windows.net'.
92 | * @param {String} path The endpoint path.
93 | * @param {String} token Optional SharedAccessSignature token for authenticating the listener.
94 | * @param {String} id Optional A Guid string for end to end correlation.
95 | * @api public
96 | */
97 | WS.createRelayListenUri = function createRelayListenUri(serviceBusNamespace, path, token, id) {
98 | var uri = WS.createRelayBaseUri(serviceBusNamespace, path);
99 | uri = uri + (uri.indexOf('?') == -1 ? '?' : '&') + 'sb-hc-action=listen';
100 | if (token != null) {
101 | uri = uri + '&sb-hc-token=' + encodeURIComponent(token);
102 | }
103 | if (id != null) {
104 | uri = uri + '&sb-hc-id=' + encodeURIComponent(id);
105 | }
106 | return uri;
107 | }
--------------------------------------------------------------------------------
/hyco-https/tests/pipe.test.js:
--------------------------------------------------------------------------------
1 | var https = require('..');
2 | const Stream = require('stream');
3 |
4 | var ns = process.env.SB_HC_NAMESPACE ? process.env.SB_HC_NAMESPACE.replace(/^"(.*)"$/, '$1') : null;
5 | var path = process.env.SB_HC_PATH ? process.env.SB_HC_PATH : "a2";
6 | var keyrule = process.env.SB_HC_KEYRULE ? process.env.SB_HC_KEYRULE.replace(/^"(.*)"$/, '$1') : null;
7 | var key = process.env.SB_HC_KEY ? process.env.SB_HC_KEY.replace(/^"(.*)"$/, '$1') : null;
8 |
9 | expect(ns).toBeDefined();
10 | expect(path).toBeDefined();
11 | expect(keyrule).toBeDefined();
12 | expect(key).toBeDefined();
13 |
14 | var smallMessage = "SmallMessage";
15 | var kb = "";
16 | for (var i = 1024; i > 0; i--) {
17 | kb += String.fromCharCode(i % 128);
18 | }
19 | // let stream push 1kb at a time
20 | var over64kbMessage = [];
21 | for (var j = 64; j >= 0; j--) {
22 | over64kbMessage.push(kb);
23 | }
24 |
25 | jest.setTimeout(10000);
26 |
27 | function streamResponse(preStreamMessage, streamMessage, postStreamMessage, done) {
28 | var responseExpected = "";
29 | var uri = https.createRelayListenUri(ns, path);
30 | var server = https.createRelayedServer(
31 | {
32 | server: uri,
33 | token: () => https.createRelayToken(uri, keyrule, key)
34 | },
35 | function (req, res) {
36 | var readStream = new Stream.Readable();
37 |
38 | readStream.on('error', function(err) {
39 | expect(err).toBeUndefined();
40 | });
41 | readStream.on('end', function() {
42 | if (postStreamMessage) {
43 | res.write(postStreamMessage);
44 | responseExpected += postStreamMessage;
45 | }
46 | res.end();
47 | });
48 |
49 | res.setHeader('Content-type', 'text/plain');
50 | readStream.pipe(res);
51 |
52 | if (preStreamMessage) {
53 | res.write(preStreamMessage);
54 | responseExpected += preStreamMessage;
55 | }
56 |
57 | for (var i = 0; i < streamMessage.length; i++) {
58 | readStream.push(streamMessage[i]);
59 | responseExpected += streamMessage[i];
60 | }
61 | readStream.push(null); // signal the end of stream
62 | }
63 | );
64 |
65 | // fail we get an error
66 | server.listen((err) => {
67 | expect(err).toBeUndefined();
68 | });
69 |
70 | // fail if we get an error (we'll always get one if this triggers)
71 | server.on('error', (err) => {
72 | expect(err).toBeUndefined();
73 | });
74 |
75 | server.on('listening', () => {
76 | https.get({
77 | hostname: ns,
78 | path: ((!path || path.length == 0 || path[0] !== '/') ? '/' : '') + path,
79 | port: 443,
80 | method : "GET",
81 | headers: {
82 | 'ServiceBusAuthorization': https.createRelayToken(uri, keyrule, key),
83 | 'Custom' : 'Hello',
84 | }
85 | }, (res) => {
86 | var chunks = '';
87 | expect(res.statusCode).toBe(200);
88 | res.setEncoding('utf8');
89 | res.on('data', (chunk) => {
90 | chunks += chunk;
91 | });
92 | res.on('end', () => {
93 | expect(chunks.length).toBe(Buffer.byteLength(responseExpected));
94 | expect(chunks).toBe(responseExpected);
95 | server.close();
96 | jest.clearAllTimers();
97 | done();
98 | });
99 | }).on('error', (e) => {
100 | expect(e).toBeUndefined();
101 | });
102 | });
103 | }
104 |
105 | test('PipeSmallStreamOnly', (done) => {
106 | streamResponse(null, smallMessage, null, done);
107 | });
108 |
109 | test('PipeLargeStreamOnly', (done) => {
110 | streamResponse(null, over64kbMessage.join(""), null, done);
111 | });
112 |
113 | test('SmallMessageThenPipeSmallStream', (done) => {
114 | streamResponse(smallMessage, smallMessage, null, done);
115 | });
116 |
117 | test('LargeMessageThenPipeSmallStream', (done) => {
118 | streamResponse(over64kbMessage.join(""), smallMessage, null, done);
119 | });
120 |
121 | test('SmallMessageThenPipeLargeStream', (done) => {
122 | streamResponse(smallMessage, over64kbMessage.join(""), null, done);
123 | });
124 |
125 | test('PipeSmallStreamThenSmallMessage', (done) => {
126 | streamResponse(null, smallMessage, smallMessage, done);
127 | });
128 |
129 | test('PipeSmallStreamThenLargeMessage', (done) => {
130 | streamResponse(null, smallMessage, over64kbMessage.join(""), done);
131 | });
132 |
133 | test('PipeLargeStreamThenSmallMessage', (done) => {
134 | streamResponse(null, over64kbMessage.join(""), smallMessage, done);
135 | });
136 |
137 |
138 |
139 |
--------------------------------------------------------------------------------
/hyco-websocket/test/scripts/autobahn-test-client.js:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env node
2 | /************************************************************************
3 | * Copyright 2010-2015 Brian McKelvey.
4 | *
5 | * Licensed under the Apache License, Version 2.0 (the 'License');
6 | * you may not use this file except in compliance with the License.
7 | * You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an 'AS IS' BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | ***********************************************************************/
17 |
18 | var WebSocketClient = require('../../lib/WebSocketClient');
19 | var wsVersion = require('../../lib/websocket').version;
20 | var querystring = require('querystring');
21 |
22 | var args = { /* defaults */
23 | secure: false,
24 | port: '9000',
25 | host: 'localhost'
26 | };
27 |
28 | /* Parse command line options */
29 | var pattern = /^--(.*?)(?:=(.*))?$/;
30 | process.argv.forEach(function(value) {
31 | var match = pattern.exec(value);
32 | if (match) {
33 | args[match[1]] = match[2] ? match[2] : true;
34 | }
35 | });
36 |
37 | args.protocol = args.secure ? 'wss:' : 'ws:';
38 |
39 | console.log('WebSocket-Node: Echo test client for running against the Autobahn test suite');
40 | console.log('Usage: ./autobahn-test-client.js --host=127.0.0.1 --port=9000 [--secure]');
41 | console.log('');
42 |
43 | console.log('Starting test run.');
44 |
45 | getCaseCount(function(caseCount) {
46 | var currentCase = 1;
47 | runNextTestCase();
48 |
49 | function runNextTestCase() {
50 | runTestCase(currentCase++, caseCount, function() {
51 | if (currentCase <= caseCount) {
52 | process.nextTick(runNextTestCase);
53 | }
54 | else {
55 | process.nextTick(function() {
56 | console.log('Test suite complete, generating report.');
57 | updateReport(function() {
58 | console.log('Report generated.');
59 | });
60 | });
61 | }
62 | });
63 | }
64 | });
65 |
66 |
67 | function runTestCase(caseIndex, caseCount, callback) {
68 | console.log('Running test ' + caseIndex + ' of ' + caseCount);
69 | var echoClient = new WebSocketClient({
70 | maxReceivedFrameSize: 64*1024*1024, // 64MiB
71 | maxReceivedMessageSize: 64*1024*1024, // 64MiB
72 | fragmentOutgoingMessages: false,
73 | keepalive: false,
74 | disableNagleAlgorithm: false
75 | });
76 |
77 | echoClient.on('connectFailed', function(error) {
78 | console.log('Connect Error: ' + error.toString());
79 | });
80 |
81 | echoClient.on('connect', function(connection) {
82 | connection.on('error', function(error) {
83 | console.log('Connection Error: ' + error.toString());
84 | });
85 | connection.on('close', function() {
86 | callback();
87 | });
88 | connection.on('message', function(message) {
89 | if (message.type === 'utf8') {
90 | connection.sendUTF(message.utf8Data);
91 | }
92 | else if (message.type === 'binary') {
93 | connection.sendBytes(message.binaryData);
94 | }
95 | });
96 | });
97 |
98 | var qs = querystring.stringify({
99 | case: caseIndex,
100 | agent: 'WebSocket-Node Client v' + wsVersion
101 | });
102 | echoClient.connect('ws://' + args.host + ':' + args.port + '/runCase?' + qs, []);
103 | }
104 |
105 | function getCaseCount(callback) {
106 | var client = new WebSocketClient();
107 | var caseCount = NaN;
108 | client.on('connect', function(connection) {
109 | connection.on('close', function() {
110 | callback(caseCount);
111 | });
112 | connection.on('message', function(message) {
113 | if (message.type === 'utf8') {
114 | console.log('Got case count: ' + message.utf8Data);
115 | caseCount = parseInt(message.utf8Data, 10);
116 | }
117 | else if (message.type === 'binary') {
118 | throw new Error('Unexpected binary message when retrieving case count');
119 | }
120 | });
121 | });
122 | client.connect('ws://' + args.host + ':' + args.port + '/getCaseCount', []);
123 | }
124 |
125 | function updateReport(callback) {
126 | var client = new WebSocketClient();
127 | var qs = querystring.stringify({
128 | agent: 'WebSocket-Node Client v' + wsVersion
129 | });
130 | client.on('connect', function(connection) {
131 | connection.on('close', callback);
132 | });
133 | client.connect('ws://localhost:9000/updateReports?' + qs);
134 | }
135 |
--------------------------------------------------------------------------------
/hyco-https/tests/chunkedpost.test.js:
--------------------------------------------------------------------------------
1 |
2 | var https = require('..')
3 |
4 | var ns = process.env.SB_HC_NAMESPACE ? process.env.SB_HC_NAMESPACE.replace(/^"(.*)"$/, '$1') : null;
5 | var path = process.env.SB_HC_PATH ? process.env.SB_HC_PATH : "a2";
6 | var keyrule = process.env.SB_HC_KEYRULE ? process.env.SB_HC_KEYRULE.replace(/^"(.*)"$/, '$1') : null;
7 | var key = process.env.SB_HC_KEY ? process.env.SB_HC_KEY.replace(/^"(.*)"$/, '$1') : null;
8 |
9 | expect(ns).toBeDefined();
10 | expect(path).toBeDefined();
11 | expect(keyrule).toBeDefined();
12 | expect(key).toBeDefined();
13 |
14 | // create a large message over 64kb to force a rendezvous connection
15 | var largeMessage = "";
16 | for (var i = 1024 * 64; i >= 0; i--) {
17 | largeMessage += String.fromCharCode(i % 128);
18 | }
19 |
20 | function sendAndReceive(requestMsg, responseMsg, done) {
21 | var totalRequests = 10; // Total requests to send over the test
22 | jest.setTimeout(5000 + (totalRequests * 200)); // Expect 5 seconds + 5 requests per second
23 |
24 | var requestLength = requestMsg.length;
25 | var responseLength = responseMsg.length;
26 | var listenerCount = 0;
27 | var senderCount = 0;
28 |
29 | /* set up the listener */
30 | var uri = https.createRelayListenUri(ns, path);
31 | var server = https.createRelayedServer({
32 | server: uri,
33 | token: () => https.createRelayToken(uri, keyrule, key)
34 | },
35 | (req, res) => {
36 | var chunks = '';
37 | expect(req.method).toBe("POST");
38 | expect(req.headers.custom).toBe("Hello");
39 | req.setEncoding('utf-8');
40 | req.on('data', (chunk) => {
41 | chunks += chunk;
42 | });
43 | req.on('end', () => {
44 | expect(chunks.length).toBe(requestLength);
45 | expect(chunks).toBe(requestMsg);
46 | res.write(responseMsg.substring(0, responseLength / 4));
47 | res.write(responseMsg.substring(responseLength / 4, responseLength / 2));
48 | res.write(responseMsg.substring(responseLength / 2, responseLength));
49 | res.end();
50 | listenerCount++;
51 | });
52 | });
53 |
54 | // fail we get an error
55 | server.listen((err) => {
56 | expect(err).toBeUndefined();
57 | });
58 | // fail if we get an error (we'll always get one if this triggers)
59 | server.on('error', (err) => {
60 | expect(err).toBeUndefined();
61 | });
62 |
63 | /* set up the client */
64 | var clientUri = https.createRelayHttpsUri(ns, path);
65 | var token = https.createRelayToken(clientUri, keyrule, key);
66 |
67 | server.on('listening', () => {
68 | for (var i = 0; i < totalRequests; i++) {
69 | var req = https.request({
70 | hostname: ns,
71 | path: ((!path || path.length == 0 || path[0] !== '/') ? '/' : '') + path,
72 | port: 443,
73 | method : "POST",
74 | headers: {
75 | 'ServiceBusAuthorization': token,
76 | 'Custom' : 'Hello',
77 | 'Content-Type': 'text/plain',
78 | // 'Content-Length': Buffer.byteLength(requestMsg)
79 | }
80 | }, (res) => {
81 | var chunks = '';
82 | expect(res.statusCode).toBe(200);
83 | res.setEncoding('utf8');
84 | res.on('data', (chunk) => {
85 | chunks += chunk;
86 | });
87 | res.on('end', () => {
88 | expect(chunks.length).toBe(responseLength);
89 | expect(chunks).toBe(responseMsg);
90 | senderCount++;
91 | if (listenerCount == totalRequests && senderCount == totalRequests) {
92 | server.close();
93 | jest.clearAllTimers();
94 | done();
95 | }
96 | });
97 | }).on('error', (e) => {
98 | expect(e).toBeUndefined();
99 | });
100 |
101 | req.write(requestMsg.substring(0, requestLength / 4));
102 | req.write(requestMsg.substring(requestLength / 4, requestLength / 2));
103 | req.write(requestMsg.substring(requestLength / 2, requestLength));
104 | req.end();
105 | }
106 | });
107 | }
108 |
109 | test('HttpChunkedPostEmptyReqEmptyRes', (done) => {
110 | sendAndReceive("", "", done);
111 | })
112 |
113 | test('HttpChunkedPostSmallReqSmallRes', (done) => {
114 | sendAndReceive("Hello", "Goodbye", done);
115 | });
116 |
117 | test('HttpChunkedPostSmallReqLargeRes', (done) => {
118 | sendAndReceive("Hello", largeMessage, done);
119 | });
120 |
121 | test('HttpChunkedPostLargeReqSmallRes', (done) => {
122 | sendAndReceive(largeMessage, "Goodbye", done);
123 | });
124 |
125 | test('HttpChunkedPostLargeReqLargeRes', (done) => {
126 | sendAndReceive(largeMessage, largeMessage, done);
127 | });
--------------------------------------------------------------------------------
/hyco-websocket/test/scripts/fragmentation-test-client.js:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env node
2 | /************************************************************************
3 | * Copyright 2010-2015 Brian McKelvey.
4 | *
5 | * Licensed under the Apache License, Version 2.0 (the 'License');
6 | * you may not use this file except in compliance with the License.
7 | * You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an 'AS IS' BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | ***********************************************************************/
17 |
18 | var WebSocketClient = require('../../lib/WebSocketClient');
19 |
20 | console.log('WebSocket-Node: Test client for parsing fragmented messages.');
21 |
22 | var args = { /* defaults */
23 | secure: false,
24 | port: '8080',
25 | host: '127.0.0.1',
26 | 'no-defragment': false,
27 | binary: false
28 | };
29 |
30 | /* Parse command line options */
31 | var pattern = /^--(.*?)(?:=(.*))?$/;
32 | process.argv.forEach(function(value) {
33 | var match = pattern.exec(value);
34 | if (match) {
35 | args[match[1]] = match[2] ? match[2] : true;
36 | }
37 | });
38 |
39 | args.protocol = args.secure ? 'wss:' : 'ws:';
40 |
41 | if (args.help) {
42 | console.log('Usage: ./fragmentation-test-client.js [--host=127.0.0.1] [--port=8080] [--no-defragment] [--binary]');
43 | console.log('');
44 | return;
45 | }
46 | else {
47 | console.log('Use --help for usage information.');
48 | }
49 |
50 |
51 | var client = new WebSocketClient({
52 | maxReceivedMessageSize: 128*1024*1024, // 128 MiB
53 | maxReceivedFrameSize: 1*1024*1024, // 1 MiB
54 | assembleFragments: !args['no-defragment']
55 | });
56 |
57 | client.on('connectFailed', function(error) {
58 | console.log('Client Error: ' + error.toString());
59 | });
60 |
61 |
62 | var requestedLength = 100;
63 | var messageSize = 0;
64 | var startTime;
65 | var byteCounter;
66 |
67 | client.on('connect', function(connection) {
68 | console.log('Connected');
69 | startTime = new Date();
70 | byteCounter = 0;
71 |
72 | connection.on('error', function(error) {
73 | console.log('Connection Error: ' + error.toString());
74 | });
75 |
76 | connection.on('close', function() {
77 | console.log('Connection Closed');
78 | });
79 |
80 | connection.on('message', function(message) {
81 | if (message.type === 'utf8') {
82 | console.log('Received utf-8 message of ' + message.utf8Data.length + ' characters.');
83 | logThroughput(message.utf8Data.length);
84 | requestData();
85 | }
86 | else {
87 | console.log('Received binary message of ' + message.binaryData.length + ' bytes.');
88 | logThroughput(message.binaryData.length);
89 | requestData();
90 | }
91 | });
92 |
93 | connection.on('frame', function(frame) {
94 | console.log('Frame: 0x' + frame.opcode.toString(16) + '; ' + frame.length + ' bytes; Flags: ' + renderFlags(frame));
95 | messageSize += frame.length;
96 | if (frame.fin) {
97 | console.log('Total message size: ' + messageSize + ' bytes.');
98 | logThroughput(messageSize);
99 | messageSize = 0;
100 | requestData();
101 | }
102 | });
103 |
104 | function logThroughput(numBytes) {
105 | byteCounter += numBytes;
106 | var duration = (new Date()).valueOf() - startTime.valueOf();
107 | if (duration > 1000) {
108 | var kiloBytesPerSecond = Math.round((byteCounter / 1024) / (duration/1000));
109 | console.log(' Throughput: ' + kiloBytesPerSecond + ' KBps');
110 | startTime = new Date();
111 | byteCounter = 0;
112 | }
113 | }
114 |
115 | function sendUTFCallback(err) {
116 | if (err) { console.error('sendUTF() error: ' + err); }
117 | }
118 |
119 | function requestData() {
120 | if (args.binary) {
121 | connection.sendUTF('sendBinaryMessage|' + requestedLength, sendUTFCallback);
122 | }
123 | else {
124 | connection.sendUTF('sendMessage|' + requestedLength, sendUTFCallback);
125 | }
126 | requestedLength += Math.ceil(Math.random() * 1024);
127 | }
128 |
129 | function renderFlags(frame) {
130 | var flags = [];
131 | if (frame.fin) {
132 | flags.push('[FIN]');
133 | }
134 | if (frame.rsv1) {
135 | flags.push('[RSV1]');
136 | }
137 | if (frame.rsv2) {
138 | flags.push('[RSV2]');
139 | }
140 | if (frame.rsv3) {
141 | flags.push('[RSV3]');
142 | }
143 | if (frame.mask) {
144 | flags.push('[MASK]');
145 | }
146 | if (flags.length === 0) {
147 | return '---';
148 | }
149 | return flags.join(' ');
150 | }
151 |
152 | requestData();
153 | });
154 |
155 | if (args['no-defragment']) {
156 | console.log('Not automatically re-assembling fragmented messages.');
157 | }
158 | else {
159 | console.log('Maximum aggregate message size: ' + client.config.maxReceivedMessageSize + ' bytes.');
160 | }
161 | console.log('Connecting');
162 |
163 | client.connect(args.protocol + '//' + args.host + ':' + args.port + '/', 'fragmentation-test');
164 |
--------------------------------------------------------------------------------
/hyco-websocket/test/scripts/fragmentation-test-server.js:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env node
2 | /************************************************************************
3 | * Copyright 2010-2015 Brian McKelvey.
4 | *
5 | * Licensed under the Apache License, Version 2.0 (the 'License');
6 | * you may not use this file except in compliance with the License.
7 | * You may obtain a copy of the License at
8 | *
9 | * http://www.apache.org/licenses/LICENSE-2.0
10 | *
11 | * Unless required by applicable law or agreed to in writing, software
12 | * distributed under the License is distributed on an 'AS IS' BASIS,
13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 | * See the License for the specific language governing permissions and
15 | * limitations under the License.
16 | ***********************************************************************/
17 |
18 | var WebSocketServer = require('../../lib/WebSocketServer');
19 | var WebSocketRouter = require('../../lib/WebSocketRouter');
20 | var http = require('http');
21 | var fs = require('fs');
22 |
23 | console.log('WebSocket-Node: Test server to spit out fragmented messages.');
24 |
25 | var args = {
26 | 'no-fragmentation': false,
27 | 'fragment': '16384',
28 | 'port': '8080'
29 | };
30 |
31 | /* Parse command line options */
32 | var pattern = /^--(.*?)(?:=(.*))?$/;
33 | process.argv.forEach(function(value) {
34 | var match = pattern.exec(value);
35 | if (match) {
36 | args[match[1]] = match[2] ? match[2] : true;
37 | }
38 | });
39 |
40 | args.protocol = 'ws:';
41 |
42 | if (args.help) {
43 | console.log('Usage: ./fragmentation-test-server.js [--port=8080] [--fragment=n] [--no-fragmentation]');
44 | console.log('');
45 | return;
46 | }
47 | else {
48 | console.log('Use --help for usage information.');
49 | }
50 |
51 | var server = http.createServer(function(request, response) {
52 | console.log((new Date()) + ' Received request for ' + request.url);
53 | if (request.url === '/') {
54 | fs.readFile('fragmentation-test-page.html', 'utf8', function(err, data) {
55 | if (err) {
56 | response.writeHead(404);
57 | response.end();
58 | }
59 | else {
60 | response.writeHead(200, {
61 | 'Content-Type': 'text/html'
62 | });
63 | response.end(data);
64 | }
65 | });
66 | }
67 | else {
68 | response.writeHead(404);
69 | response.end();
70 | }
71 | });
72 | server.listen(args.port, function() {
73 | console.log((new Date()) + ' Server is listening on port ' + args.port);
74 | });
75 |
76 | var wsServer = new WebSocketServer({
77 | httpServer: server,
78 | fragmentOutgoingMessages: !args['no-fragmentation'],
79 | fragmentationThreshold: parseInt(args['fragment'], 10)
80 | });
81 |
82 | var router = new WebSocketRouter();
83 | router.attachServer(wsServer);
84 |
85 | var lorem = 'Lorem ipsum dolor sit amet, consectetuer adipiscing elit, sed diam nonummy nibh euismod tincidunt ut laoreet dolore magna aliquam erat volutpat.';
86 |
87 | router.mount('*', 'fragmentation-test', function(request) {
88 | var connection = request.accept(request.origin);
89 | console.log((new Date()) + ' connection accepted from ' + connection.remoteAddress);
90 |
91 |
92 | connection.on('message', function(message) {
93 | function sendCallback(err) {
94 | if (err) { console.error('send() error: ' + err); }
95 | }
96 | if (message.type === 'utf8') {
97 | var length = 0;
98 | var match = /sendMessage\|(\d+)/.exec(message.utf8Data);
99 | var requestedLength;
100 | if (match) {
101 | requestedLength = parseInt(match[1], 10);
102 | var longLorem = '';
103 | while (length < requestedLength) {
104 | longLorem += (' ' + lorem);
105 | length = Buffer.byteLength(longLorem);
106 | }
107 | longLorem = longLorem.slice(0,requestedLength);
108 | length = Buffer.byteLength(longLorem);
109 | if (length > 0) {
110 | connection.sendUTF(longLorem, sendCallback);
111 | console.log((new Date()) + ' sent ' + length + ' byte utf-8 message to ' + connection.remoteAddress);
112 | }
113 | return;
114 | }
115 |
116 | match = /sendBinaryMessage\|(\d+)/.exec(message.utf8Data);
117 | if (match) {
118 | requestedLength = parseInt(match[1], 10);
119 |
120 | // Generate random binary data.
121 | var buffer = new Buffer(requestedLength);
122 | for (var i = 0; i < requestedLength; i++) {
123 | buffer[i] = Math.ceil(Math.random()*255);
124 | }
125 |
126 | connection.sendBytes(buffer, sendCallback);
127 | console.log((new Date()) + ' sent ' + buffer.length + ' byte binary message to ' + connection.remoteAddress);
128 | return;
129 | }
130 | }
131 | });
132 |
133 | connection.on('close', function(reasonCode, description) {
134 | console.log((new Date()) + ' peer ' + connection.remoteAddress + ' disconnected.');
135 | });
136 |
137 | connection.on('error', function(error) {
138 | console.log('Connection error for peer ' + connection.remoteAddress + ': ' + error);
139 | });
140 | });
141 |
142 | console.log('Point your WebSocket Protocol Version 8 compliant browser at http://localhost:' + args.port + '/');
143 | if (args['no-fragmentation']) {
144 | console.log('Fragmentation disabled.');
145 | }
146 | else {
147 | console.log('Fragmenting messages at ' + wsServer.config.fragmentationThreshold + ' bytes');
148 | }
149 |
--------------------------------------------------------------------------------
/hyco-websocket/.jshintrc:
--------------------------------------------------------------------------------
1 | {
2 | // JSHint Default Configuration File (as on JSHint website)
3 | // See http://jshint.com/docs/ for more details
4 |
5 | "maxerr" : 50, // {int} Maximum error before stopping
6 |
7 | // Enforcing
8 | "bitwise" : false, // true: Prohibit bitwise operators (&, |, ^, etc.)
9 | "camelcase" : false, // true: Identifiers must be in camelCase
10 | "curly" : true, // true: Require {} for every new block or scope
11 | "eqeqeq" : true, // true: Require triple equals (===) for comparison
12 | "freeze" : true, // true: prohibits overwriting prototypes of native objects such as Array, Date etc.
13 | "forin" : false, // true: Require filtering for..in loops with obj.hasOwnProperty()
14 | "immed" : true, // true: Require immediate invocations to be wrapped in parens e.g. `(function () { } ());`
15 | "latedef" : "nofunc", // true: Require variables/functions to be defined before being used
16 | "newcap" : true, // true: Require capitalization of all constructor functions e.g. `new F()`
17 | "noarg" : true, // true: Prohibit use of `arguments.caller` and `arguments.callee`
18 | "noempty" : true, // true: Prohibit use of empty blocks
19 | "nonbsp" : true, // true: Prohibit "non-breaking whitespace" characters.
20 | "nonew" : true, // true: Prohibit use of constructors for side-effects (without assignment)
21 | "plusplus" : false, // true: Prohibit use of `++` & `--`
22 | "quotmark" : "single", // Quotation mark consistency:
23 | // false : do nothing (default)
24 | // true : ensure whatever is used is consistent
25 | // "single" : require single quotes
26 | // "double" : require double quotes
27 | "undef" : true, // true: Require all non-global variables to be declared (prevents global leaks)
28 | "unused" : "vars", // vars: Require all defined variables be used, ignore function params
29 | "strict" : false, // true: Requires all functions run in ES5 Strict Mode
30 | "maxparams" : false, // {int} Max number of formal params allowed per function
31 | "maxdepth" : false, // {int} Max depth of nested blocks (within functions)
32 | "maxstatements" : false, // {int} Max number statements per function
33 | "maxcomplexity" : false, // {int} Max cyclomatic complexity per function
34 | "maxlen" : false, // {int} Max number of characters per line
35 |
36 | // Relaxing
37 | "asi" : false, // true: Tolerate Automatic Semicolon Insertion (no semicolons)
38 | "boss" : false, // true: Tolerate assignments where comparisons would be expected
39 | "debug" : false, // true: Allow debugger statements e.g. browser breakpoints.
40 | "eqnull" : false, // true: Tolerate use of `== null`
41 | "es5" : false, // true: Allow ES5 syntax (ex: getters and setters)
42 | "esnext" : true, // true: Allow ES.next (ES6) syntax (ex: `const`)
43 | "moz" : false, // true: Allow Mozilla specific syntax (extends and overrides esnext features)
44 | // (ex: `for each`, multiple try/catch, function expression…)
45 | "evil" : false, // true: Tolerate use of `eval` and `new Function()`
46 | "expr" : false, // true: Tolerate `ExpressionStatement` as Programs
47 | "funcscope" : false, // true: Tolerate defining variables inside control statements
48 | "globalstrict" : false, // true: Allow global "use strict" (also enables 'strict')
49 | "iterator" : false, // true: Tolerate using the `__iterator__` property
50 | "lastsemic" : false, // true: Tolerate omitting a semicolon for the last statement of a 1-line block
51 | "laxbreak" : false, // true: Tolerate possibly unsafe line breakings
52 | "laxcomma" : false, // true: Tolerate comma-first style coding
53 | "loopfunc" : false, // true: Tolerate functions being defined in loops
54 | "multistr" : false, // true: Tolerate multi-line strings
55 | "noyield" : false, // true: Tolerate generator functions with no yield statement in them.
56 | "notypeof" : false, // true: Tolerate invalid typeof operator values
57 | "proto" : false, // true: Tolerate using the `__proto__` property
58 | "scripturl" : false, // true: Tolerate script-targeted URLs
59 | "shadow" : false, // true: Allows re-define variables later in code e.g. `var x=1; x=2;`
60 | "sub" : true, // true: Tolerate using `[]` notation when it can still be expressed in dot notation
61 | "supernew" : false, // true: Tolerate `new function () { ... };` and `new Object;`
62 | "validthis" : false, // true: Tolerate using this in a non-constructor function
63 |
64 | // Environments
65 | "browser" : true, // Web Browser (window, document, etc)
66 | "browserify" : true, // Browserify (node.js code in the browser)
67 | "couch" : false, // CouchDB
68 | "devel" : true, // Development/debugging (alert, confirm, etc)
69 | "dojo" : false, // Dojo Toolkit
70 | "jasmine" : false, // Jasmine
71 | "jquery" : false, // jQuery
72 | "mocha" : false, // Mocha
73 | "mootools" : false, // MooTools
74 | "node" : true, // Node.js
75 | "nonstandard" : false, // Widely adopted globals (escape, unescape, etc)
76 | "prototypejs" : false, // Prototype and Scriptaculous
77 | "qunit" : false, // QUnit
78 | "rhino" : false, // Rhino
79 | "shelljs" : false, // ShellJS
80 | "worker" : false, // Web Workers
81 | "wsh" : false, // Windows Scripting Host
82 | "yui" : false, // Yahoo User Interface
83 |
84 | // Custom Globals
85 | "globals" : { // additional predefined global variables
86 | "WebSocket": true
87 | }
88 | }
89 |
--------------------------------------------------------------------------------
/hyco-ws/index.js:
--------------------------------------------------------------------------------
1 | 'use strict';
2 |
3 | var crypto = require('crypto')
4 | var moment = require('moment')
5 | var url = require('url');
6 |
7 | /**
8 | * Adapted from
9 | * ws: a node.js websocket client
10 | * Copyright(c) 2011 Einar Otto Stangvik Output
117 |Ready.
118 | libwebsockets "dumb-increment-protocol" test applet
11 | The incrementing number is coming from the server and is individual for 12 | each connection to the server... try opening a second browser window. 13 | Click the button to send the server a websocket message to 14 | reset the number.15 | 16 |
| 19 | 20 | 21 | | 22 |Not initialized |
24 |
libwebsockets "lws-mirror-protocol" test applet
28 | Use the mouse to draw on the canvas below -- all other browser windows open 29 | on this page see your drawing in realtime and you can see any of theirs as 30 | well. 31 |32 | The lws-mirror protocol doesn't interpret what is being sent to it, it just 33 | re-sends it to every other websocket it has a connection with using that 34 | protocol, including the guy who sent the packet. 35 |
libwebsockets-test-client spams circles on to this shared canvas when 36 | run.
37 |38 | 39 |
| Drawing color: 42 | 48 | | 49 |Not initialized |
50 |
2 | 
3 |