galileo_websocket

Description:

galileo websocket

galileo_websocket #


WebSocket plugin for Galileo.
This plugin broadcasts events from hooked services via WebSockets.
In addition, it adds itself to the app's IoC container as GalileoWebSocket, so that it can be used
in controllers as well.
WebSocket contexts are add to req.properties as 'socket'.
Usage #
Server-side
import "package:galileo_framework/galileo_framework.dart";
import "package:galileo_websocket/server.dart";

main() async {
var app = new Galileo();

var ws = new GalileoWebSocket();

// This is a plug-in. It hooks all your services,
// to automatically broadcast events.
await app.configure(ws.configureServer);

// Listen for requests at `/ws`.
app.all('/ws', ws.handleRequest);
}

copied to clipboard
Filtering events is easy with hooked services. Just return a bool, whether
synchronously or asynchronously.
myService.properties['ws:filter'] = (HookedServiceEvent e, WebSocketContext socket) async {
return true;
}

myService.index({
'ws:filter': (e, socket) => ...;
});
copied to clipboard
Adding Handlers within a Controller
WebSocketController extends a normal Controller, but also listens to WebSockets.
import 'dart:async';
import "package:galileo_framework/galileo_framework.dart";
import "package:galileo_websocket/server.dart";

@Expose("/")
class MyController extends WebSocketController {
// A reference to the WebSocket plug-in is required.
MyController(GalileoWebSocket ws):super(ws);

@override
void onConnect(WebSocketContext socket) {
// On connect...
}

// Dependency injection works, too..
@ExposeWs("read_message")
void sendMessage(WebSocketContext socket, WebSocketAction action, Db db) async {
socket.send(
"found_message",
db.collection("messages").findOne(where.id(action.data['message_id'])));
}

// Event filtering
@ExposeWs("foo")
void foo() {
broadcast(new WebSocketEvent(...), filter: (socket) async => ...);
}
}
copied to clipboard
Client Use
This repo also provides two client libraries browser and io that extend the base
galileo_client interface, and allow you to use a very similar API on the client to that of
the server.
The provided clients also automatically try to reconnect their WebSockets when disconnected,
which means you can restart your development server without having to reload browser windows.
They also provide streams of data that pump out filtered data as it comes in from the server.
Clients can even perform authentication over WebSockets.
In the Browser
import "package:galileo_websocket/browser.dart";

main() async {
Galileo app = new WebSockets("/ws");
await app.connect();

var Cars = app.service("api/cars");

Cars.onCreated.listen((car) => print("New car: $car"));

// Happens asynchronously
Cars.create({"brand": "Toyota"});

// Authenticate a WebSocket, if you were not already authenticated...
app.authenticateViaJwt('<some-jwt>');

// Listen for arbitrary events
app.on['custom_event'].listen((event) {
// For example, this might be sent by a
// WebSocketController.
print('Hi!');
});
}
copied to clipboard
CLI Client
import "package:galileo_framework/common.dart";
import "package:galileo_websocket/io.dart";

// You can include these in a shared file and access on both client and server
class Car extends Model {
int year;
String brand, make;

Car({this.year, this.brand, this.make});

@override String toString() => "$year $brand $make";
}

main() async {
Galileo app = new WebSockets("/ws");

// Wait for WebSocket connection...
await app.connect();

var Cars = app.service("api/cars", type: Car);

Cars.onCreated.listen((Car car) {
// Automatically deserialized into a car :)
//
// I just bought a new 2016 Toyota Camry!
print("I just bought a new $car!");
});

// Happens asynchronously
Cars.create({"year": 2016, "brand": "Toyota", "make": "Camry"});

// Authenticate a WebSocket, if you were not already authenticated...
app.authenticateViaJwt('<some-jwt>');
}
copied to clipboard