re-org source tree slightly

network layer is net/
protocol is protocol/

cvmts/src/protocol/Protocol.ts

@@ -0,0 +1,195 @@
+import { Rank, User } from '../User';
+
+// We should probably put this in the binproto repository or something
+export enum ProtocolUpgradeCapability {
+	BinRects = 'bin'
+}
+
+export enum ProtocolRenameStatus {
+	Ok = 0,
+	UsernameTaken = 1,
+	UsernameInvalid = 2,
+	UsernameNotAllowed = 3
+}
+
+export interface ScreenRect {
+	x: number;
+	y: number;
+	data: Buffer;
+}
+
+export interface ListEntry {
+	id: string;
+	name: string;
+	thumbnail: Buffer;
+}
+
+export interface ProtocolChatHistory {
+	user: string;
+	msg: string;
+}
+
+export interface ProtocolAddUser {
+	username: string;
+	rank: Rank;
+}
+
+export interface ProtocolFlag {
+	username: string;
+	countryCode: string;
+}
+
+// Protocol handlers. This is implemented by a layer that wants to listen to CollabVM protocol messages.
+export interface IProtocolHandlers {
+	onNop(user: User): void;
+
+	onNoFlag(user: User): void;
+
+	// Called when the client requests a capability upgrade
+	onCapabilityUpgrade(user: User, capability: Array<String>): boolean;
+
+	onLogin(user: User, token: string): void;
+
+	// Called on turn request
+	onTurnRequest(user: User, forfeit: boolean): void;
+
+	onVote(user: User, choice: number): void;
+
+	onList(user: User): void;
+	onConnect(user: User, node: string): void;
+	onView(user: User, node: string, viewMode: number): void;
+
+	// Admin handlers
+	onAdminLogin(user: User, password: string): void;
+	onAdminMonitor(user: User, node: string, command: string): void;
+	onAdminRestore(user: User, node: string): void;
+	onAdminReboot(user: User, node: string): void;
+	onAdminBanUser(user: User, username: string): void;
+	onAdminForceVote(user: User, choice: number): void;
+	onAdminMuteUser(user: User, username: string, temporary: boolean): void;
+	onAdminKickUser(user: User, username: string): void;
+	onAdminEndTurn(user: User, username: string): void;
+	onAdminClearQueue(user: User, node: string): void;
+	onAdminRename(user: User, target: string, newName: string): void;
+	onAdminGetIP(user: User, username: string): void;
+	onAdminBypassTurn(user: User): void;
+	onAdminRawMessage(user: User, message: string): void;
+	onAdminToggleTurns(user: User, enabled: boolean): void;
+	onAdminIndefiniteTurn(user: User): void;
+	onAdminHideScreen(user: User, show: boolean): void;
+	onAdminSystemMessage(user: User, message: string): void;
+
+	onRename(user: User, newName: string | undefined): void;
+	onChat(user: User, message: string): void;
+
+	onKey(user: User, keysym: number, pressed: boolean): void;
+	onMouse(user: User, x: number, y: number, buttonMask: number): void;
+}
+
+// Abstracts away all of the protocol details from the CollabVM server,
+// allowing it to be protocol-independent (as long as the client and server
+// are able to speak the same protocol.)
+export interface IProtocol {
+	// don't implement this yourself, extend from ProtocolBase
+	init(u: User): void;
+	dispose(): void;
+
+	// Sets handler object.
+	setHandler(handlers: IProtocolHandlers): void;
+
+	// Protocol implementation stuff
+
+	// Parses a single message and fires the given handler with deserialized arguments.
+	// This function does not catch any thrown errors; it is the caller's responsibility
+	// to handle errors. It should, however, catch invalid parameters without failing.
+	//
+	// This function will perform conversion to text if it is required.
+	processMessage(buffer: Buffer): boolean;
+
+	// Senders
+
+	sendNop(): void;
+	sendSync(now: number): void;
+
+	sendAuth(authServer: string): void;
+
+	sendCapabilities(caps: ProtocolUpgradeCapability[]): void;
+
+	sendConnectFailResponse(): void;
+	sendConnectOKResponse(votes: boolean): void;
+
+	sendLoginResponse(ok: boolean, message: string | undefined): void;
+
+	sendAdminLoginResponse(ok: boolean, modPerms: number | undefined): void;
+	sendAdminMonitorResponse(output: string): void;
+	sendAdminIPResponse(username: string, ip: string): void;
+
+	sendChatMessage(username: '' | string, message: string): void;
+	sendChatHistoryMessage(history: ProtocolChatHistory[]): void;
+
+	sendAddUser(users: ProtocolAddUser[]): void;
+	sendRemUser(users: string[]): void;
+	sendFlag(flag: ProtocolFlag[]): void;
+
+	sendSelfRename(status: ProtocolRenameStatus, newUsername: string, rank: Rank): void;
+	sendRename(oldUsername: string, newUsername: string, rank: Rank): void;
+
+	sendListResponse(list: ListEntry[]): void;
+
+	sendTurnQueue(turnTime: number, users: string[]): void;
+	sendTurnQueueWaiting(turnTime: number, users: string[], waitTime: number): void;
+
+	sendVoteStarted(): void;
+	sendVoteStats(msLeft: number, nrYes: number, nrNo: number): void;
+	sendVoteEnded(): void;
+	sendVoteCooldown(ms: number): void;
+
+	sendScreenResize(width: number, height: number): void;
+
+	// Sends a rectangle update to the user.
+	sendScreenUpdate(rect: ScreenRect): void;
+}
+
+// Base mixin for all concrete protocols to use. Inherit from this!
+export class ProtocolBase {
+	protected handlers: IProtocolHandlers | null = null;
+	protected user: User | null = null;
+
+	init(u: User): void {
+		this.user = u;
+	}
+
+	dispose(): void {
+		this.user = null;
+		this.handlers = null;
+	}
+
+	setHandler(handlers: IProtocolHandlers): void {
+		this.handlers = handlers;
+	}
+}
+
+// The protocol manager. Holds protocol factories, and provides the ability
+// to create a protocol by name. Avoids direct dependency on a given list of protocols,
+// and allows (relatively simple) expansion.
+export class ProtocolManager {
+	private protocols = new Map<String, () => IProtocol>();
+
+	// Registers a protocol with the given name.
+	registerProtocol(name: string, protocolFactory: () => IProtocol) {
+		if (!this.protocols.has(name)) this.protocols.set(name, protocolFactory);
+	}
+
+	// Creates an instance of a given protocol for a user.
+	createProtocol(name: string, user: User): IProtocol {
+		if (!this.protocols.has(name)) throw new Error(`ProtocolManager does not have protocol \"${name}\"`);
+
+		let factory = this.protocols.get(name)!;
+		let proto = factory();
+		proto.init(user);
+		return proto;
+	}
+}
+
+/// Global protocol manager
+export let TheProtocolManager = new ProtocolManager();