1.6.0

src/Net/Sockets/ISocket.js

@@ -0,0 +1,34 @@
+"use strict";  
+
+import IDestructible from "../../Core/IDestructible.js";
+import SocketState from "./SocketState.js";
+
+export default class ISocket extends IDestructible
+{
+    //SocketState State { get; }
+    //INetworkReceiver<ISocket> Receiver { get; set; }
+
+    constructor(){
+        super();
+        this.state = SocketState.Initial;
+    }
+//    get state() {}
+
+    sendAsync(message, offset, length) { }
+
+    send(message, offset, length) {}
+    close() {}
+    connect(hostname, port) {}
+
+    begin() {}
+    beginAsync() {}
+    acceptAsync() {}
+    accept() {}
+
+    get remoteEndPoint(){}
+    get localEndPoint() {}
+
+    hold() {}
+
+    unhold() {}
+}

src/Net/Sockets/NetworkBuffer.js

@@ -1,119 +0,0 @@
-/*
-* Copyright (c) 2017 Ahmed Kh. Zamil
-*
-* Permission is hereby granted, free of charge, to any person obtaining a copy
-* of this software and associated documentation files (the "Software"), to deal
-* in the Software without restriction, including without limitation the rights
-* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-* copies of the Software, and to permit persons to whom the Software is
-* furnished to do so, subject to the following conditions:
-*
-* The above copyright notice and this permission notice shall be included in all
-* copies or substantial portions of the Software.
-*
-* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-* SOFTWARE.
-*/
-
-/**
- * Created by Ahmed Zamil on 01/09/2017.
- */
-
-"use strict";  
-
-import DC from '../../Data/DataConverter.js';
-
-export default class NetworkBuffer {
-    constructor() {
-        this.neededDataLength = 0;
-        this.data = new DC(0);
-    }
-
-    get protected() {
-        return this.neededDataLength > this.data.length;
-    }
-
-    get available() {
-
-        return this.data.length;
-    }
-
-    holdAllForNextWrite(src) {
-        this.holdFor(src, src.length + 1);
-    }
-
-    holdForNextWrite(src, offset, size) {
-        this.holdFor(src, offset, size, size + 1);
-    }
-
-
-    holdFor(src, offset, size, needed) {
-        if (size >= needed)
-            throw new Error("Size >= Needed !");
-
-        this.data = DC.combine(src, offset, size, this.data, 0, this.data.length);
-        this.neededDataLength = needed;
-    }
-
-    holdAllFor(src, needed) {
-        this.holdFor(src, 0, src.length, needed);
-    }
-
-    protect(data, offset, needed) {
-        var dataLength = data.length - offset;
-
-        // protection
-        if (dataLength < needed) {
-            this.holdFor(data, offset, dataLength, needed);
-            return true;
-        }
-        else
-            return false;
-    }
-
-    writeAll(src) {
-        this.write(src, 0, src.length ? src.length : src.byteLength);
-    }
-
-    write(src, offset, length) {
-        this.data = this.data.append(src, offset, length);
-    }
-
-    get canRead() {
-        if (this.data.length == 0)
-            return false;
-        else if (this.data.length < this.neededDataLength)
-            return false;
-        return true;
-    }
-
-    read() {
-        if (this.data.length == 0)
-            return null;
-
-        var rt = null;
-
-        if (this.neededDataLength == 0) {
-            rt = this.data;
-            this.data = new DC(0);
-        }
-        else {
-            if (this.data.length >= this.neededDataLength) {
-                rt = this.data;
-                this.data = new DC(0);
-                this.neededDataLength = 0;
-                return rt;
-            }
-            else {
-                return null;
-            }
-        }
-
-        return rt;
-    }
-}

src/Net/Sockets/SocketState.js

@@ -0,0 +1,7 @@
+export default {
+    Initial : 0,
+    Listening : 1,
+    Connecting : 2,
+    Established : 3,
+    Closed: 4,    
+}

src/Net/Sockets/WSSocket.js

@@ -0,0 +1,165 @@
+import AsyncReply from "../../Core/AsyncReply.js";
+import ErrorType from "../../Core/ErrorType.js";
+import ExceptionCode from "../../Core/ExceptionCode.js";
+import ISocket from "./ISocket.js";
+import SocketState from "./SocketState.js";
+import NetworkBuffer from "../NetworkBuffer.js";
+
+export default class WSSocket extends ISocket
+{
+      //SocketState State { get; }
+    //INetworkReceiver<ISocket> Receiver { get; set; }
+    constructor(websocket){
+        super();
+        this.receiveNetworkBuffer = new NetworkBuffer();
+        this.sendNetworkBuffer = new NetworkBuffer();
+        this.held = false;
+
+        if (websocket != null)// instanceof WebSocket)
+        {
+            //websocket.onerror = () => {
+            //    self.state = SocketState.Closed;
+            //};   
+            websocket.onopen = () => {
+                self.state = SocketState.Established;
+            };
+    
+            websocket.onerror = () => {
+                self.state = SocketState.Closed;
+            };
+    
+            this._assign(websocket);
+        }
+    }
+
+    destroy(){
+        this.close();   
+        this.receiveNetworkBuffer = null;
+
+        this.receiver = null;
+        thsi.ws = null;
+        this._emit("destroy");
+    }
+
+    sendAsync(message, offset, length) { 
+        
+    }
+
+    sendAll(message)
+    {
+        if (this.held)
+            this.sendNetworkBuffer.writeAll(message);
+        else
+        {
+            try
+            {
+                this.ws.send(message);
+            } catch {
+                this.state = SocketState.Closed;
+            }
+        }
+    }
+
+    send(message, offset, length) {
+        this.sendAll(message.clip(offset, length));
+    }
+
+    close() {
+        this.ws.close();
+    }
+    
+    connect(hostname, port, secure = false) {
+
+        let self = this;
+
+        var rt = new AsyncReply();
+
+        this.state = SocketState.Connecting;
+
+        this.url = `ws${secure ? 's' : ''}://${hostname}:${port}`;
+
+        let ws = new WebSocket(this.url, "iip");
+        ws.binaryType = "arraybuffer";
+
+        ws.onopen = () => {
+            self.state = SocketState.Established;
+            rt.trigger(true);
+        };
+
+        ws.onerror = () => {
+            self.state = SocketState.Closed;
+            rt.triggerError(ErrorType.Management, ExceptionCode.HostNotReachable);
+        };
+
+        this._assign(ws);
+        
+        return rt;// new AsyncReply(true);
+    }
+
+    _assign(ws)
+    {        
+        let self = this;
+
+        ws.onclose = () => {
+            self.state = SocketState.Closed;
+            self.receiver?.networkClose(self);
+        };
+
+        ws.onmessage = function(msg) {
+            self.receiveNetworkBuffer.writeAll(msg.data);
+            self.receiver.networkReceive(this, self.receiveNetworkBuffer);
+            //self.lastAction = new Date();
+        };
+
+        this.ws = ws;
+    }
+
+    begin() {
+
+    }
+
+    beginAsync() {
+
+    }
+
+    acceptAsync() {
+
+    }
+
+    accept() {
+
+    }
+
+    get remoteEndPoint(){}
+    get localEndPoint() {}
+
+    hold()
+    {
+        this.held = true;
+    }
+
+    unhold()
+    {       
+        this.held = false;
+
+        var message = this.sendNetworkBuffer.read();
+
+    
+        if (message == null)
+            return;
+//            totalSent += message.Length;
+                
+        try { 
+            this.ws.send(message); 
+        } catch {
+            this.state = SocketState.Closed;
+        }
+    }
+}
+
+    // if (this.holdSending) {
+    //     //console.log("hold ", data.length);
+    //     this.sendBuffer.writeAll(data);
+    // }
+    // else
+    //     //console.log("Send", data.length);