let createSubscription = () => {
if (this.openObserver) {
this.openObserver.next(this.stream)
}
let queue = this.destination
this.destination = Subscriber.create(
x => this.stream.writable !== false && this.stream.write(x),
() => {
if (this.closingObserver) {
this.closingObserver.next(undefined)
}
if (this.stream.destroy) {
this.stream.destroy()
}
},
() => {
if (this.closingObserver) {
this.closingObserver.next(undefined)
}
if (this.stream.destroy) {
this.stream.destroy()
}
}
)
if (queue && queue instanceof ReplaySubject) {
subscription.add(queue).subscribe(this.destination)
}
}
export function WebSocketClient(address) {
const socket = io(address);
var packetObservable = SocketPacketSubject(socket);
var observable = Observable.create(function(observer){
socket.on('connect', function(){
packetObservable.subscribe(
function(packet){
observer.next(packet);
},
function(err){
observer.error(err);
},
function(){
observer.complete();
}
);
})
return function(){
socket.close();
}
});
var observer = Subscriber.create(function (event) {
socket.emit(event.name, {data: event.data});
});
return Subject.create(observer, observable);
}
exports.ConnectionSubject = function(io){
var packetDecoder = new Decoder();
var observable = Observable.create(function(subscriber){
io.on('connection', function(socket){
socket.client.conn.on('packet', function(packet){
if(packet.type === 'message'){
packetDecoder.add(packet.data);
}
});
packetDecoder.on('decoded', function(packet){
subscriber.next(packet);
})
})
return function(){
console.log("client disconnected");
}
})
var observer = Subscriber.create(function(x){
console.log('ConnectionSubjectSubscriber::next', x);
});
return Subject.create(observer, observable)
}
function AppComponent() {
var _this = this;
this.title = 'JUG Wish Demo';
this.wishes = [{ "title": "Initializing ...", "clicks": 0 }];
this.newWish = EMPTY_WISH;
this.subject = new Subject_1.Subject();
this.subscription = this.subject.subscribe(function (event) {
var data = event;
// console.log(`data: ${data}`);
var tokens = data.split(/,/);
_this.wishes = [];
for (var tokenId in tokens) {
var parts = tokens[tokenId].split(/:/);
// console.log(tokenId,"->",parts[0], ":", parts[1]);
_this.wishes[tokenId] = { title: parts[0], clicks: parseInt(parts[1]) };
}
updateCloud(_this.wishes);
});
var that = this;
var openSubscriber = Subscriber_1.Subscriber.create(function (e) {
console.info('socket open');
});
// an observer for when the socket is about to close
var closingSubscriber = Subscriber_1.Subscriber.create(function () {
console.log('socket is about to close');
});
//Create WebSocket Subject
this.socketSubject = new ipt_rx_websocket_1.IPTRxWebSocketSubject('ws://127.0.0.1/ws', null, openSubscriber, closingSubscriber);
this.socketSubject.subscribe(function (event) {
console.log(event);
that.subject.next(event);
}, function (err) {
console.log("Error:", event);
that.subject.error(err);
}, function () {
console.log("Complete:", event);
that.subject.complete();
});
}
function IPTRxWebSocketSubject(url, protocol, openObserver, closingObserver) {
var _this = this;
_super.call(this);
this.url = url;
this.openObserver = openObserver;
this.closingObserver = closingObserver;
if (!WebSocket) {
throw new TypeError('WebSocket not implemented in your runtime.');
}
this.websocket = new WebSocket(url);
this.websocket.onopen = function (event) {
_this.openObserver.next(event);
// this.websocket.send("Hi from Websocket client");
};
this.websocket.onclose = function (event) {
_this.closingObserver.next(event);
};
this.websocket.onmessage = function (event) {
try {
_super.prototype.next.call(_this, event.data);
}
catch (e) {
var errorEvent = new ErrorEvent(e);
errorEvent.message = "Invalid event structure.";
errorEvent.error = e;
_super.prototype.error.call(_this, errorEvent);
}
};
this.websocket.onerror = function (event) {
_super.prototype.error.call(_this, event);
};
this.destination = Subscriber_1.Subscriber.create(function (message) {
_this.websocket.send(message);
}, function (error) {
console.log("WebSocket error: " + error);
_this.websocket.close(1011, "Error processing client data stream.");
var errorEvent = new ErrorEvent(error);
errorEvent.message = "Error processing client data stream.";
errorEvent.error = error;
_super.prototype.error.call(_this, errorEvent);
}, //CloseEvent.code = Internal Error
function () {
console.log("WebSocket closing");
_this.websocket.close(1011, "Error processing client data stream.");
var closeEvent = new CloseEvent();
closeEvent.code = 1000; //CLOSE_NORMAL
closeEvent.reason = "WS connection closed by client.";
closeEvent.wasClean = true;
_this.closingObserver.next(closeEvent);
});
}
export function WebSocketServer(http, options) {
var io = new Server(http, options);
var clientConnection = new ConnectionSubject(io);
var observable = new Subject();
clientConnection.subscribe(function(data) {
console.log("data", data);
});
var observer = Subscriber.create(function(event) {
console.log("sending to client: ", event);
clientConnection.next(event);
});
return Subject.create(observer, observable);
}
export function createMainChannelFromSockets(
sockets: {
[string]: moduleJMP.Socket
},
header: HEADER_FILLER = {
session: uuid(),
username: getUsername()
},
jmp = moduleJMP
) {
// The mega subject that encapsulates all the sockets as one multiplexed stream
const subject = Subject.create(
// $FlowFixMe: figure out if this is a shortcoming in the flow def or our declaration
Subscriber.create(
message => {
// There's always a chance that a bad message is sent, we'll ignore it
// instead of consuming it
if (!message || !message.channel) {
console.warn("message sent without a channel", message);
return;
}
const socket = sockets[message.channel];
if (!socket) {
// If, for some reason, a message is sent on a channel we don't have
// a socket for, warn about it but don't bomb the stream
console.warn("channel not understood for message", message);
return;
}
const jMessage = new jmp.Message({
// Fold in the setup header to ease usage of messages on channels
header: { ...message.header, ...header },
parent_header: message.parent_header,
content: message.content,
metadata: message.metadata,
buffers: message.buffers
});
socket.send(jMessage);
},
undefined, // not bothering with sending errors on
() =>
// When the subject is completed / disposed, close all the event
// listeners and shutdown the socket
Object.keys(sockets).forEach(name => {
const socket = sockets[name];
socket.removeAllListeners();
socket.close();
})
),
// Messages from kernel on the sockets
merge(
// Form an Observable with each socket
...Object.keys(sockets).map(name => {
const socket = sockets[name];
return fromEvent(socket, "message").pipe(
map(body => {
// Route the message for the frontend by setting the channel
const msg = { ...body, channel: name };
// Conform to same message format as notebook websockets
// See https://github.com/n-riesco/jmp/issues/10
delete msg.idents;
return msg;
}),
publish(),
refCount()
);
})
).pipe(publish(), refCount())
);
return subject;
}