Skip to content

Latest commit

 

History

History
451 lines (356 loc) · 19.5 KB

README.md

File metadata and controls

451 lines (356 loc) · 19.5 KB

Codacy

npm -g install sockizy
git clone https://github.com/Daeren/sockizy.git

Goals:

  1. Low memory usage;
  2. Maximum performance;
  3. Flexibility;
  4. Games.

Index

Server:

const sockizy = require("sockizy");

//-----------------------------------------------------

const io = sockizy(1337, {
    "packets": [
        null, // srv.on
        null, // srv.emit
        {     // srv.on + srv.emit
            "chat.message": [
                "uid:uint32",
                "text:str8"
            ]
        }
    ]
});

//-----------------------------------------------------

io.on("connection", function(socket, request) {
    socket.on("chat.message", function() {
        const bytes = this.emit("chat.message", {uid: 13, text: "Hello"});
        console.log("Number of bytes sent:", bytes);
    });
});

Client:

<script src="//localhost:1337"></script>

<script>
    const socket = io("localhost:1337");
    socket.on("chat.message", console.log);
</script>

SSL

const ssl = {
    "dir":       "/www/site",

    "key":       "/3_site.xx.key",
    "cert":      "/2_site.xx.crt",
    "ca":       [
        "/AddTrustExternalCARoot.crt",
        "/COMODORSAAddTrustCA.crt",
        "/COMODORSADomainValidationSecureServerCA.crt"
    ]
};

//-----------------------------------------------------

const io = sockizy(1337, {ssl, "maxPayload": 1024});

Verify

/*
    const info = {
        "origin": request.headers.origin,
        "secure": request.connection.authorized !== undefined || request.connection.encrypted !== undefined,
        "req":    request
    };
*/

// Async

io.verifyClient(function(info, callback) {
    setTimeout(callback, 1000 * 2, false, 400, "Client verification failed");
});

// Sync

io.verifyClient(function(info) {
    return true;
});

Packets

// (!) order is important


// Server

io.packets(
    // Unpack | server.socket.on
    {
        "rtt": null
    },

    // Pack | server.socket.emit
    {
        "rtt": null,

        "game.monster": [
            "lvl:uint8",
            "hp:uint8"
        ]
    },

    // Shared | server.socket.on | server.socket.emit
    {
        "user.gold": "uint16",
        "chat.message": [
            "uid:uint32",
            "text:str"
        ],
        "game.hero": [
            "name:str32",
            "lvl:int8",
            "hp:uint8",
            "x:uint16",
            "y:uint16"
        ]
    }
);


// Client

socket.packets(
    // Pack | server.socket.on
    {
        "rtt": null
    },

    // Unpack | server.socket.emit
    {
        "rtt": null,
        "game.monster": [
            "lvl:uint8",
            "hp:uint8"
        ]
    },

    // Shared | server.socket.on | server.socket.emit
    {
        "user.gold": "uint16",
        "chat.message": [
            "uid:uint32",
            "text:str"
        ],
        "game.hero": [
            "name:str32",
            "lvl:int8",
            "hp:uint8",
            "x:uint16",
            "y:uint16"
        ]
    }
);


// Server

io.emit("user.gold", 20);
io.emit("game.monster", {lvl: 13, hp: 69});


// Client

socket.on("game.monster", console.log);


// Server or Client

socket.emit("rtt");
socket.emit("chat.message", [0, "Helword"]);

socket.emit("game.hero", {name: "D", lvl: 13, hp: 69, x: -8, y: -8});
socket.emit("game.hero", ["D", 13, 69, -8, -8]);

Bundle (only Server)

io.packets(
    null,
    null,
    {
        "on.arg.asArray.zCopy ([])": [
            "text:str"
        ],
        "on.arg.asArray.new ([@])": [
            "text:str"
        ],

        "on.arg.asHashTable.zCopy.default": [
            "text:str"
        ],
        "on.arg.asHashTable.new ({@})": [
            "text:str"
        ]
    }
);

io.on("connection", function(socket, request) {
    socket.on("on.arg.asHashTable.new", function(data) {
        const bd = this.bundle(true);

        for(let i = 0; i < 10; ++i) { 
            bd.write("on.arg.asArray.zCopy", {text: `Helword: ${i}`});
        }

        bd.write("on.arg.asArray.zCopy");
        bd.end("on.arg.asArray.zCopy");
    });
});

Packet type
Name Alias Note
-
bin<size (byte)> b default: 1024 (0-65535); server: Buffer; client: Uint8Array;
str<size (byte)> s default: 256 (0-65535)
int<size (bit)> i size: 8, 16, 32, 64 (BigInt64Array)
uint<size (bit)> u size: 8, 16, 32, 64 (BigUint64Array)
float<size (bit)> f size: 32, 64
json<size (byte)> j default: 8192 (0-65535)
Server options
Name Note
-
port default: undefined
host default: *
server default: http.Server
path default: "/"
-
ssl
-
maxPayload default: 1024 * 32
perMessageDeflate default: false
noDelay default: true
-
ping default: {"interval": 10000} (ms)
clientJs default: true
packets dependencies: clientJs;(autointegration)
Bundle: app.bundle(), socket.bundle([isBroadcast])
Name Note
-
write(name, data) returns: number of bytes written
end([name, data]) returns: number of bytes sent
Server: app([port, options])
Name Note
app.property
wss uws
app.method
emit(name[, data]) returns: number of bytes sent
bundle()
text(data)
json(data)
broadcast(data[, options]) native
-
listen([port, host, callback]) default: "localhost:1337"
close([callback])
-
packets([unpack, pack, shared]) return this;
verifyClient(func(info[, callback])) return this;
sendPacketTransform(func(type, data)) return this;
recvPacketTransform(func(data)) return this;
-
on(name, listener) return this;
off([name, listener]) return this;
app.events
connection (socket, request)
close (socket, code, reason, wasClean)
packet (name, data, socket, accept)
listening ()
error (e)
socket.property
readyState number (read only)
upgradeReq object (read only)
-
remotePort (read only)
remoteAddress (read only)
remoteFamily (read only)
socket.method
emit(name, [data, isBroadcast]) returns: number of bytes sent
bundle([isBroadcast])
text (data[, isBroadcast])
json (data[, isBroadcast])
send(data[, options]) native
-
disconnect([code, reason]) code: 4000-4999
terminate()
-
ping([message])
-
on(name, listener) return this;
once(name, listener) return this;
off([name, listener]) return this;
socket.events
close (code, reason, wasClean)
disconnected (code, reason)
terminated (code)
error (e)
-
message (data)
text (data)
json (data)
arraybuffer (data) intercepts and blocks unpacking of packets
-
ping (message)
pong (message)
-
myEvent (data)

Client options
Name Note
-
secure
reconnectionDelay default: 1 sec (minimum)
reconnectionAttempts default: Infinity
Client: app([url, options])
Name Note
app.property
url string (read only)
reconnecting bool (read only)
bufferedAmount number (read only)
readyState number (read only)
app.method
emit(name[, data]) returns: number of bytes sent
text(data)
json(data)
send(data) native
-
disconnect(code, reason) code: 4000-4999
-
packets([pack, unpack, shared]) return this;
sendPacketTransform(func(type, data)) return this;
recvPacketTransform(func(data)) return this;
-
on(name, listener) return this;
once(name, listener) return this;
off([name, listener]) return this;
app.events
restoring (attempts)
restored (attempts)
unrestored (attempts)
-
open ()
close (code, reason, event) code: 1003 - invalid packet
disconnected (code, reason, event)
terminated (code, event)
-
message (data, event)
text (data, event)
json (data, event)
arraybuffer (data, event) intercepts and blocks unpacking of packets
packet (name, data, accept)
error (e)
-
myEvent (data)

License

MIT

@ Daeren @ Telegram