public override bool VerifyHandshake(WebSocket websocket, WebSocketCommandInfo handshakeInfo, out string description)
{
var challenge = handshakeInfo.Data;
if (challenge.Length != challenge.Length)
{
description = m_Error_ChallengeLengthNotMatch;
return false;
}
for (var i = 0; i < m_ExpectedChallenge.Length; i++)
{
if (challenge[i] != m_ExpectedChallenge[i])
{
description = m_Error_ChallengeNotMatch;
return false;
}
}
if (!handshakeInfo.Text.ParseMimeHeader(websocket.Items))
{
description = m_Error_InvalidHandshake;
return false;
}
description = string.Empty;
return true;
}
// -----------------------------------------------------------------
/// <summary>
///
/// </summary>
void Connect()
{
ws = new WebSocket (WSAddress);
ws.OnOpen += (sender, e) => {
Debug.Log ("<color=lime>WebSocket Open</color>");
};
ws.OnMessage += (sender, e) => {
lock (messageQueue.SyncRoot) {
try {
messageQueue.Enqueue (e.Data.ToString ());
} catch (System.Exception ex) {
Debug.Log (ex.ToString ());
}
}
//Debug.Log ("<color=cyan>WebSocket Message Type: " + e.Type + ", Data: " + e.Data + "</color>");
};
ws.OnError += (sender, e) => {
Debug.Log ("<color=red>WebSocket Error Message: " + e.Message + "</color>");
};
ws.OnClose += (sender, e) => {
Debug.Log ("<color=orange>WebSocket Close</color>");
};
ws.Connect ();
}
// -----------------------------------------------------------------
/// <summary>
///
/// </summary>
void Disconnect()
{
if (ws.IsAlive) {
ws.Close ();
}
ws = null;
}
public void Play()
{
var uri = new Uri(Server + "?user="******"Something strange is happening on the server... Response:\n{0}", response);
ShouldExit = true;
}
else
{
var boardString = response.Substring(ResponsePrefix.Length);
var action = DoMove(new GameBoard(boardString));
socket.Send(action);
}
}
}
}
internal HttpListenerWebSocketContext(
HttpListenerContext context, Logger logger)
{
_context = context;
_stream = WsStream.CreateServerStream (context);
_websocket = new WebSocket (this, logger ?? new Logger ());
}
public WebSocketFrame(WebSocket webSocket, WebSocketFrameTypes type, byte[] data, UInt64 pos, UInt64 length, bool isFinal, bool useExtensions)
{
this.Type = type;
this.IsFinal = isFinal;
this.UseExtensions = useExtensions;
if (data != null)
{
this.Data = new byte[length];
Array.Copy(data, (int)pos, this.Data, 0, (int)length);
}
else
data = NoData;
// First byte: Final Bit + Rsv flags + OpCode
byte finalBit = (byte)(IsFinal ? 0x80 : 0x0);
this.Header = (byte)(finalBit | (byte)Type);
if (this.UseExtensions && webSocket != null && webSocket.Extensions != null)
{
for (int i = 0; i < webSocket.Extensions.Length; ++i)
{
var ext = webSocket.Extensions[i];
if (ext != null)
{
this.Header |= ext.GetFrameHeader(this, this.Header);
this.Data = ext.Encode(this);
}
}
}
}
void Connect()
{
//接続
//ポートの指定はしなくても大丈夫だった。80で接続してるはず。
ws = new WebSocket(url);
ws.OnOpen += (sender, e) => {
//接続したら自分を制御用PCとしてサーバーに教える
//SendSetPCMessage();
print("Connected");
};
ws.OnMessage += (sender, e) => {
string s = e.Data;
//Debug.Log (s);
Dictionary<string, object> dict = Json.Deserialize (s) as Dictionary<string, object>;
//Debug.Log (dict["power"].GetType() );
long val = (long)dict["power"];
//Debug.Log ("val="+val);
toColor = GetColor(val/divBy);
value = val/divBy;
};
ws.Connect();
ws.OnClose += (sender, e) => {
print("Closed");
};
ws.OnError += (sender, e) => {
print("Error : " + e.Message);
};
}
/// <summary>
/// Start the Birb Client.
/// </summary>
/// <returns>Nothing right now.</returns>
IEnumerator Start()
{
gameStateManager = GetComponent<GameStateManager>();
Uri server = new Uri("ws://birb.herokuapp.com");
Uri localhost = new Uri("ws://localhost:5000");
socket = new WebSocket(server);
callbacks = new Dictionary<BirbMessageCode, Callback>();
yield return StartCoroutine(socket.Connect());
int i = 0;
// Testing
//RunUnitTests();
while (true)
{
string reply = socket.RecvString();
if (reply != null)
{
Debug.Log("Received: " + reply);
Process(reply);
}
if (socket.Error != null)
{
Debug.LogError("Error: " + socket.Error);
break;
}
yield return 0;
}
socket.Close();
}
/// <summary>
/// Returns a handler for incoming Web stream requests.
/// </summary>
/// <param name="route">
/// The handler.
/// </param>
/// <param name="controller">
/// The controller.
/// </param>
/// <param name="args">
/// The request parameters.
/// </param>
/// <returns>
/// A handler for incoming Web stream requests.
/// </returns>
public static Func<IDictionary<string, object>, Task> WebSocketRequestHandler(
this ControllerRoute route,
object controller,
IDictionary<string, string> args)
{
return async environment =>
{
using (var socket = new WebSocket(environment))
{
Task incomingMessagePump;
Func<string, IObservable<string>> getObservable;
if (route.ObservableParameters != null)
{
// Route has observable parameters.
var observableParams = route.ObservableParameters.ToDictionary(_ => _, _ => new SingleSubscriptionObservable());
getObservable = name => observableParams[name].Observable;
incomingMessagePump = IncomingMessagePump(socket, observableParams);
}
else
{
// No observable parameters.
getObservable = _ => Observable.Empty<string>();
incomingMessagePump = Task.FromResult(0);
}
// Hook up the incoming and outgoing message pumps.
var outgoing = GetObservableFromHandler(() => route.Invoke(controller, args, getObservable));
var outgoingMessagePump = OutgoingMessagePump(outgoing, socket);
// Close the socket when both pumps finish.
await Task.WhenAll(outgoingMessagePump, incomingMessagePump);
}
};
}
public override void SendCloseHandshake(WebSocket websocket, int statusCode, string closeReason)
{
int size = (string.IsNullOrEmpty(closeReason) ? 0 : Encoding.UTF8.GetMaxByteCount(closeReason.Length)) + 2;
byte[] playloadData = new byte[size];
int highByte = statusCode / 256;
int lowByte = statusCode % 256;
playloadData[0] = (byte)highByte;
playloadData[1] = (byte)lowByte;
// don't send close handshake now because the connection was closed already
if (websocket.State == WebSocketState.Closed)
return;
if (!string.IsNullOrEmpty(closeReason))
{
int bytesCount = Encoding.UTF8.GetBytes(closeReason, 0, closeReason.Length, playloadData, 2);
SendDataFragment(websocket, OpCode.Close, playloadData, 0, bytesCount + 2);
}
else
{
SendDataFragment(websocket, OpCode.Close, playloadData, 0, playloadData.Length);
}
}
// Use this for initialization
IEnumerator Start () {
WebSocket w = new WebSocket(new Uri("ws://127.0.0.1:8080/websocket"));
yield return StartCoroutine(w.Connect());
int i = 0;
w.SendString(PackMessage("Hi there", i));
while (true)
{
string reply = w.RecvString();
if (reply != null)
{
Message msg = UnpackMessage (reply);
Debug.Log ("Received: " + msg.msg + ", " + msg.no);
w.SendString (PackMessage ("Hi there", i));
}
if (w.error != null)
{
Debug.LogError ("Error: " + w.error);
break;
}
++i;
yield return 0;
}
w.Close();
}
void Connect()
{
ws = new WebSocket("ws://socket.nappers.jp:8888");
// called when websocket messages come.
ws.OnMessage += (sender, e) =>
{
string s = e.Data;
Debug.Log(string.Format( "Receive {0}",s));
messages.Add("> " + e.Data);
if(messages.Count > 10){
messages.RemoveAt(0);
}
};
ws.OnError += (sender, e) =>
{
Debug.Log("OnError");
};
ws.OnClose += (sender, e) =>
{
Debug.Log("OnClose");
};
ws.OnOpen += (sender, e) =>
{
Debug.Log("OnOpen");
};
ws.Connect();
Debug.Log("Connect to " + ws.Url);
}
public override bool Connect()
{
//bool baseOk = base.Connect();
//if (!baseOk)
//{
// return false;
//}
State = PhotonSocketState.Connecting;
if (websocketConnectionObject != null)
{
UnityEngine.Object.Destroy(websocketConnectionObject);
}
websocketConnectionObject = new GameObject("websocketConnectionObject");
MonoBehaviour mb = websocketConnectionObject.AddComponent<MonoBehaviour>();
// TODO: not hidden for debug
//websocketConnectionObject.hideFlags = HideFlags.HideInHierarchy;
UnityEngine.Object.DontDestroyOnLoad(websocketConnectionObject);
this.sock = new WebSocket(new Uri(ServerAddress));
mb.StartCoroutine(this.sock.Connect());
mb.StartCoroutine(ReceiveLoop());
return true;
}
void InitWebSocket()
{
_ws = new WebSocket ("wss://echo.websocket.org/");
_ws.OnMessage += MessageCallback;
_ws.OnError += ErrorCallback;
_ws.Connect ();
}
void Start() {
ws = new WebSocket("ws://echo.websocket.org");
ws.OnOpen += OnOpenHandler;
ws.OnMessage += OnMessageHandler;
ws.OnClose += OnCloseHandler;
stateMachine.AddHandler(State.Running, () => {
new Wait(this, 3, () => {
ws.ConnectAsync();
});
});
stateMachine.AddHandler(State.Connected, () => {
stateMachine.Transition(State.Ping);
});
stateMachine.AddHandler(State.Ping, () => {
new Wait(this, 3, () => {
ws.SendAsync("This WebSockets stuff is a breeze!", OnSendComplete);
});
});
stateMachine.AddHandler(State.Pong, () => {
new Wait(this, 3, () => {
ws.CloseAsync();
});
});
stateMachine.Run();
}
public override void SendCloseHandshake(WebSocket websocket, int statusCode, string closeReason)
{
// don't send close handshake now because the connection was closed already
if (websocket.State == WebSocketState.Closed)
return;
websocket.Client.Send(CloseHandshake, 0, CloseHandshake.Length);
}
internal TcpListenerWebSocketContext(TcpClient client, bool secure, X509Certificate cert)
{
_client = client;
_secure = secure;
_stream = WsStream.CreateServerStream (client, secure, cert);
_request = HandshakeRequest.Parse (_stream.ReadHandshake ());
_websocket = new WebSocket (this);
}
IEnumerator Start()
{
_game = gameObject.GetComponent<MainProxy>();
_state = ConnectionState.UNKNOWN;
_socket = new WebSocket (new Uri ("ws://188.242.130.83:3000/echo"));
yield return StartCoroutine (_socket.Connect ());
}
public void CloseSocket()
{
if (_socket != null)
{
_socket.Dispose();
_socket = null;
}
}
internal TcpListenerWebSocketContext(TcpClient client, bool secure)
{
_client = client;
_isSecure = secure;
_stream = WsStream.CreateServerStream(client, secure);
_request = RequestHandshake.Parse(_stream.ReadHandshake());
_socket = new WebSocket(this);
}
private static void CheckReservedInfo(WebSocket sender)
{
var rows = ReservedUserInfos.Where(t => t.Sender == sender);
// 최초 요청부터 현재 요청까지 1분 안에 5건 이상이라면 너무 많은 요청으로 간주한다.
if ((rows.Count() >= 5) && rows.Last().Time - rows.First().Time <= TimeSpan.FromMinutes(1))
throw new OverflowException();
}
public void OnConnect()
{
this.ws = new WebSocket("ws://10.0.1.3:8080");
this.ws.OnMessage += (object sender, MessageEventArgs e) => {
this.Message = e.Data;
};
this.ws.Connect ();
}
void Start() {
ws = new WebSocket("ws://echo.websocket.org");
ws.OnOpen += OnOpenHandler;
ws.OnMessage += OnMessageHandler;
ws.OnClose += OnCloseHandler;
ws.ConnectAsync();
}
public override void SendMessage(WebSocket websocket, string message)
{
var maxByteCount = Encoding.UTF8.GetMaxByteCount(message.Length) + 2;
var sendBuffer = new byte[maxByteCount];
sendBuffer[0] = StartByte;
int bytesCount = Encoding.UTF8.GetBytes(message, 0, message.Length, sendBuffer, 1);
sendBuffer[1 + bytesCount] = EndByte;
websocket.Client.Send(sendBuffer, 0, bytesCount + 2);
}
internal TcpListenerWebSocketContext(
TcpClient client, X509Certificate cert, bool secure, Logger logger)
{
_client = client;
_secure = secure;
_stream = WsStream.CreateServerStream (client, cert, secure);
_request = _stream.ReadHandshake<HandshakeRequest> (
HandshakeRequest.Parse, 90000);
_websocket = new WebSocket (this, logger);
}
// Use this for initialization
void Start()
{
ws = new WebSocket(serverIp);
ws.OnOpen += OnOpenHandler;
ws.OnMessage += OnMessageHandler;
ws.OnClose += OnCloseHandler;
ws.ConnectAsync();
}
public void AddUser(long userId, WebSocket socket)
{
var context = Contexts.FirstOrDefault(t => t.WebSocket == socket);
if (context == null)
Log.Exception("NOT EXISTS SOCKET CONTEXT : {0}", userId);
Users[context] = userId;
// TODO : 개발 도중에는 중복 로그인이 빈번하게 일어나므로 아직 처리하지 않는다.
//Users.Add(context, userId);
}
public WebtestClient(string port)
{
client = new WebSocket(@"ws://127.0.0.1:" + port + "/Simulator");
client.Connect();
client.OnError += (sender, e) =>
Debug.Log("error: " + e.Message.ToString());
client.OnClose += (sender, e) =>
Debug.Log("client on closing");
}
private void OnMessageReceived(WebSocket webSocket, string message)
{
Debug.Log("Text Message received from server: " + message);
labelMessage.text = message;
}
public WsQueue(WebSocket sock)
{
this.Ws = sock;
pending = new List <byte []> ();
}
public abstract IObservable <Task> ReceiveAsync(WebSocket socket, WebSocketReceiveResult result, byte[] buffer);
public WebSocketHandler(WebSocket ws)
{
this.ws = ws;
}
public void Dispose()
{
_listener = null;
socket = null;
}
// Start is called before the first frame update
void Start()
{
ws = new WebSocket("ws://drumath-unity-web-socket.herokuapp.com");
ws.Connect();
}
/// <summary>
/// Initializes a new instance of the <see cref="WebSocketStreamingConnection"/> class.
/// </summary>
/// <param name="socket"><see cref="WebSocket"/> instance on which streams are transported between client and server.</param>
/// <param name="logger"><see cref="ILogger"/> for the connection.</param>
public WebSocketStreamingConnection(WebSocket socket, ILogger logger)
: base(logger)
{
_socket = socket ?? throw new ArgumentNullException(nameof(socket));
}
public AtivoMonitorado(Chamada Chamada, string symbol)
{
Symbol = symbol;
this.chamada = Chamada;
GainMonitor = chamada.PrecoGain;
LossMonitor = chamada.PrecoLoss;
ws = new WebSocket("wss://stream.binance.com:9443/stream?streams=" + symbol.ToLower() + "@trade");
//ws.Log.Level = LogLevel.Trace;
//ws.Log.File = "changetofilepath";
ws.OnOpen += (sender, e) =>
{
Logs.LogConexaoAtivos(chamada.Id + " => " + DateTime.UtcNow + " => type ( Start Monitor )");
};
//Para envio de ping
ws.EmitOnPing = true;
ws.OnMessage += (sender, e) =>
{
try
{
if (e.IsPing)
{
ws.Ping();
return;
}
var content = e.Data;
var ws_trade = JsonConvert.DeserializeObject <WS_Trade>(content);
var marketvalue = ws_trade.data.p;
if (chamada.ChamadaStatus_Id == 1)
{
//verifica se a ordem foi criada com valor acima do preco de mercado || se a ordem foi criada com valor abaixo do preco de mercado
if ((chamada.PrecoMercadoHoraChamada > chamada.PrecoEntrada && marketvalue <= chamada.PrecoEntrada) || (chamada.PrecoMercadoHoraChamada < chamada.PrecoEntrada && marketvalue >= chamada.PrecoEntrada))
{
using (var _ChamadasRepo = new ChamadasRepository())
{
chamada.ChamadaStatus_Id = 2;
_ChamadasRepo.Update(chamada);
var userIds = _ChamadasRepo.NaoRecusaram_e_nao_Aceitaram_Chamada(chamada.Id);
//remove card de chamadas da tela dos clientes
signalContext.Clients.Users(userIds).EncerrarChamada(chamada.Id);
signalContext.Clients.User("admin").MudarParaEdicao(chamada.Id);
Logs.LogConexaoAtivos(chamada.Id + " => " + DateTime.UtcNow + " => type ( Preco Entrada Alcançado ) => " + marketvalue);
}
}
}
else if (chamada.ChamadaStatus_Id == 2)
{
if (marketvalue > GainMonitor)
{
using (var _ChamadasRepo = new ChamadasRepository())
{
chamada.ChamadaStatus_Id = 4;
chamada.ResultadoChamada_Id = 1;
_ChamadasRepo.Update(chamada);
//signalContext.Clients.User("admin").RemoverEdicao(chamada.Id);
signalContext.Clients.All.RemoverEdicao(chamada.Id);
Logs.LogConexaoAtivos(chamada.Id + " => " + DateTime.UtcNow + " => type ( Preco Gain Alcançado) => " + marketvalue);
this.Dispose(true);
}
}
else if (marketvalue < LossMonitor)
{
using (var _ChamadasRepo = new ChamadasRepository())
{
chamada.ChamadaStatus_Id = 4;
chamada.ResultadoChamada_Id = 2;
_ChamadasRepo.Update(chamada);
//signalContext.Clients.User("admin").RemoverEdicao(chamada.Id);
signalContext.Clients.All.RemoverEdicao(chamada.Id);
Logs.LogConexaoAtivos(chamada.Id + " => " + DateTime.UtcNow + " => type ( Preco Loss Alcançado) => " + marketvalue);
this.Dispose(true);
}
}
}
}
catch (Exception ex)
{
Logs.LogConexaoAtivos("Error on Try Catch => " + ex.Message + " => inner exception => " + ex.InnerException.Message + " => stack trace => " + ex.StackTrace);
}
};
ws.OnClose += (sender, e) =>
{
Logs.LogConexaoAtivos(chamada.Id + " => OnClose Event => " + DateTime.UtcNow + " code => " + e.Code + " motivo => " + e.Reason);
var monitor = Market_Monitor.Instancia;
monitor.RemoveMonitor(chamada.Id);
};
ws.OnError += (sender, e) =>
{
Logs.LogConexaoAtivos(chamada.Id + " => OnError Event => " + DateTime.UtcNow + " Msg Erro => " + e.Message + " => inner exception => " + e.Exception.Message + " => stack trace => " + e.Exception.StackTrace);
};
ws.Connect();
}
void OnErrorDesc(WebSocket ws, string error)
{
Debug.Log("Error: " + error);
}
private string GetPeerUrl(WebSocket socket)
{
return(this.sockets.FirstOrDefault(p => p.Value == socket).Key);
}
public virtual async Task OnDisconnected(WebSocket socket)
{
await WebSocketConnectionManager.RemoveSocket(WebSocketConnectionManager.GetId(socket));
}
public Task Run(Uri browserUri, WebSocket ideSocket)
{
return(proxy.Run(browserUri, ideSocket));
}
public ValueTask <ValueWebSocketReceiveResult> ReadAsync(Memory <byte> buffer, CancellationToken cancellationToken = default)
{
return(WebSocket.ReceiveAsync(buffer, cancellationToken));
}
public WebSocketProtocol(WebSocket websocket, ConnectionContext connection)
{
WebSocket = websocket;
Connection = connection;
}
private void OnWebSocketClosed(WebSocket webSocket, UInt16 code, string message)
{
Debug.Log("WebSocket Closed!");
Thread.Sleep(1000);
}
public Task RemoveSocket(WebSocket socket)
{
string id = this.GetPeerUrl(socket);
return(this.RemoveSocket(id));
}
public void AddSocket(WebSocket socket, string url)
{
this.sockets.TryAdd(url, socket);
}
/*protected void _PingEventHandler(TimerEvent e)
{
this._pingTimer.Reset ();
if (this.IsConnected ())
{
}
}*/
public override bool Connect (string URL = "", params string[] rest)
{
// base.connect (URL, rest);
if (this._webSocket == null)
{
if (String.IsNullOrEmpty (URL) )
{
return false;
}
this._webSocket = new WebSocket (URL, rest);
this._webSocket.OnClose += (sender, e) => {
Tracer.Echo("WebSocketConnect : OnClose : " + e.Reason );
this._isConnected = false;
this.DispatchEvent(new ServiceEvent(ServiceEvent.DISCONNECTED, null, e));
if(this.autoReconnect)
{
Tracer.Echo("WebSocketConnect : OnClose : auto reconnect!" );
this.DispatchEvent(new ServiceEvent(ServiceEvent.CONNECTING, null, e));
this.Connect();
}
};
this._webSocket.OnError += (object sender, ErrorEventArgs e) => {
Tracer.Echo("WebSocketConnect : OnError : " + e.Message);
// this.Fault(e);
};
this._webSocket.OnMessage += (object sender, MessageEventArgs e) => {
Tracer.Echo("WebSocketConnect : OnMessage : ");
Tracer.Echo(e.Data);
this.Result(e.Data);
};
this._webSocket.OnOpen += (object sender, EventArgs e) => {
Tracer.Echo("WebSocketConnect : OnOpen : ");
this._isConnecting = false;
this._isConnected = true;
this.DispatchEvent(new ServiceEvent(ServiceEvent.CONNECT_SUCCESS, null, e));
Tracer.Echo(String.Format("WebSocketConnect : OnOpen : making {0} pending request", this._pendingRequestList.Count));
while(this._pendingRequestList.Count > 0)
{
IServiceRequest targetRequest = this._pendingRequestList[0];
this._pendingRequestList.Remove(targetRequest);
this.Request(targetRequest);
}
};
}
if (this.isConnecting)
{
Tracer.Echo ("WebSocketConnect : Connect : connection is being made please wait!");
return false;
}
this._isConnecting = true;
//set auto reconnect
this.autoReconnect = true;
this._webSocket.Connect ();
return true;
}
public WsClientExample(String url)
{
this.ws = new WebSocket(url);
}
public IAuthenticationProvider Create(string ip, int port, WebSocket webSocket)
{
return(new AuthenticationProvider(ip, port, webSocket));
}
public void startslcan(byte canport)
{
but_slcanmode1.Enabled = false;
but_slcanmode2.Enabled = false;
try
{
if (!MainV2.comPort.BaseStream.IsOpen)
{
if (CustomMessageBox.Show(
"You are not currently connected via mavlink. Please make sure the device is already in slcan mode or this is the slcan serialport.",
"SLCAN", CustomMessageBox.MessageBoxButtons.OKCancel) != CustomMessageBox.DialogResult.OK)
{
return;
}
}
if (MainV2.comPort.BaseStream.IsOpen)
{
var cport = MainV2.comPort.MAV.param["CAN_SLCAN_CPORT"].Value;
MainV2.comPort.setParam((byte)MainV2.comPort.sysidcurrent, (byte)MainV2.comPort.compidcurrent,
"CAN_SLCAN_CPORT", canport, true);
if (cport == 0)
{
CustomMessageBox.Show("Reboot required" + " after setting CPORT. Please reboot!",
Strings.ERROR);
return;
}
MainV2.comPort.setParam((byte)MainV2.comPort.sysidcurrent, (byte)MainV2.comPort.compidcurrent,
"CAN_SLCAN_TIMOUT", 2, true);
MainV2.comPort.setParam((byte)MainV2.comPort.sysidcurrent, (byte)MainV2.comPort.compidcurrent,
"CAN_P" + canport + "_DRIVER", 1);
//MainV2.comPort.setParam((byte)MainV2.comPort.sysidcurrent, (byte)MainV2.comPort.compidcurrent, "CAN_SLCAN_SERNUM", 0, true); // usb
// blind send
var paramname = "CAN_SLCAN_SERNUM";
var req = new MAVLink.mavlink_param_set_t
{
target_system = (byte)MainV2.comPort.sysidcurrent,
target_component = (byte)MainV2.comPort.compidcurrent,
param_type = (byte)MainV2.comPort
.MAVlist[(byte)MainV2.comPort.sysidcurrent, (byte)MainV2.comPort.compidcurrent]
.param_types[paramname],
param_id = paramname.MakeBytesSize(16)
};
MainV2.comPort.sendPacket(req, (byte)MainV2.comPort.sysidcurrent,
(byte)MainV2.comPort.compidcurrent);
MainV2.comPort.sendPacket(req, (byte)MainV2.comPort.sysidcurrent,
(byte)MainV2.comPort.compidcurrent);
}
}
catch
{
}
{
// grab the connected port
var port = MainV2.comPort.BaseStream;
// place an invalid port in its place
if (port != null)
{
MainV2.comPort.BaseStream = new Comms.SerialPort()
{
PortName = port.PortName, BaudRate = port.BaudRate
}
}
;
//check if we started from within mavlink - if not get settings from menu and create port
if (port == null || !port.IsOpen)
{
switch (MainV2._connectionControl.CMB_serialport.Text)
{
case "TCP":
port = new TcpSerial();
break;
case "UDP":
port = new UdpSerial();
break;
case "WS":
port = new WebSocket();
break;
case "UDPCl":
port = new UdpSerialConnect();
break;
default:
port = new SerialPort()
{
PortName = MainV2._connectionControl.CMB_serialport.Text,
BaudRate = int.Parse(MainV2._connectionControl.CMB_baudrate.Text)
};
break;
}
}
if (can == null)
{
can = new uavcan();
}
can.SourceNode = 127;
can.NodeAdded += (id, msg) =>
{
this.BeginInvoke((Action) delegate
{
allnodes.Add(new UAVCANModel()
{
ID = id,
Name = "?",
Health = msg.health.ToString(),
Mode = msg.mode.ToString(),
Uptime = TimeSpan.FromSeconds(msg.uptime_sec),
VSC = msg.vendor_specific_status_code
});
uAVCANModelBindingSource.ResetBindings(false);
});
};
if (!port.IsOpen)
{
try
{
port.Open();
}
catch (Exception e)
{
CustomMessageBox.Show(Strings.CheckPortSettingsOr);
return;
}
}
if (chk_log.Checked)
{
can.LogFile = Settings.Instance.LogDir + Path.DirectorySeparatorChar +
DateTime.Now.ToString("yyyy-MM-dd HH-mm-ss") + ".can";
}
var prd = new ProgressReporterDialogue();
prd.UpdateProgressAndStatus(-1, "Trying to connect");
prd.DoWork += sender => can.StartSLCAN(port.BaseStream);
prd.btnCancel.Click += (sender, args) =>
{
prd.doWorkArgs.CancelAcknowledged = true;
port.Close();
};
prd.RunBackgroundOperationAsync();
if (prd.doWorkArgs.CancelRequested || prd.doWorkArgs.ErrorMessage != null)
{
return;
}
can.SetupFileServer();
can.SetupDynamicNodeAllocator();
can.MessageReceived += (frame, msg, transferID) =>
{
if (msg.GetType() == typeof(UAVCAN.uavcan.uavcan_protocol_NodeStatus))
{
var ns = msg as UAVCAN.uavcan.uavcan_protocol_NodeStatus;
var nodes = allnodes.Where((a) => a.ID == frame.SourceNode);
if (nodes.Count() > 0 && nodes.First().Name == "?")
{
var statetracking = new UAVCAN.uavcan.statetracking();
// get node info
UAVCAN.uavcan.uavcan_protocol_GetNodeInfo_req gnireq = new UAVCAN.uavcan.uavcan_protocol_GetNodeInfo_req()
{
};
gnireq.encode(UAVCAN.uavcan.uavcan_transmit_chunk_handler, statetracking);
var slcan = can.PackageMessage(frame.SourceNode, 30, 0, gnireq);
can.WriteToStream(slcan);
}
foreach (var item in nodes)
{
switch (ns.health)
{
case (byte)UAVCAN.uavcan.UAVCAN_PROTOCOL_NODESTATUS_HEALTH_OK:
item.Health = "OK";
break;
case (byte)UAVCAN.uavcan.UAVCAN_PROTOCOL_NODESTATUS_HEALTH_WARNING:
item.Health = "WARNING";
break;
case (byte)UAVCAN.uavcan.UAVCAN_PROTOCOL_NODESTATUS_HEALTH_ERROR:
item.Health = "ERROR";
break;
case (byte)UAVCAN.uavcan.UAVCAN_PROTOCOL_NODESTATUS_HEALTH_CRITICAL:
item.Health = "CRITICAL";
break;
}
switch (ns.mode)
{
case (byte)UAVCAN.uavcan.UAVCAN_PROTOCOL_NODESTATUS_MODE_OPERATIONAL:
item.Mode = "OPERATIONAL";
break;
case (byte)UAVCAN.uavcan.UAVCAN_PROTOCOL_NODESTATUS_MODE_INITIALIZATION:
item.Mode = "INITIALIZATION";
break;
case (byte)UAVCAN.uavcan.UAVCAN_PROTOCOL_NODESTATUS_MODE_MAINTENANCE:
item.Mode = "MAINTENANCE";
break;
case (byte)UAVCAN.uavcan.UAVCAN_PROTOCOL_NODESTATUS_MODE_SOFTWARE_UPDATE:
item.Mode = "SOFTWARE_UPDATE";
break;
case (byte)UAVCAN.uavcan.UAVCAN_PROTOCOL_NODESTATUS_MODE_OFFLINE:
item.Mode = "OFFLINE";
break;
}
item.Uptime = TimeSpan.FromSeconds(ns.uptime_sec);
}
_updatePending = true;
}
else if (msg.GetType() == typeof(UAVCAN.uavcan.uavcan_protocol_GetNodeInfo_res))
{
var gnires = msg as UAVCAN.uavcan.uavcan_protocol_GetNodeInfo_res;
var nodes = allnodes.Where((a) => a.ID == frame.SourceNode);
foreach (var item in nodes)
{
item.Name = ASCIIEncoding.ASCII.GetString(gnires.name, 0, gnires.name_len);
item.HardwareVersion = gnires.hardware_version.major + "." + gnires.hardware_version.minor;
item.SoftwareVersion = gnires.software_version.major + "." + gnires.software_version.minor + "." + gnires.software_version.vcs_commit.ToString("X");
item.SoftwareCRC = gnires.software_version.image_crc;
item.HardwareUID = gnires.hardware_version.unique_id.Select(a => a.ToString("X2")).Aggregate((a, b) =>
{
return(a + " " + b);
});
item.RawMsg = gnires;
item.VSC = gnires.status.vendor_specific_status_code;
}
_updatePending = true;
}
else if (msg.GetType() == typeof(UAVCAN.uavcan.uavcan_protocol_debug_LogMessage))
{
var debug = msg as UAVCAN.uavcan.uavcan_protocol_debug_LogMessage;
this.BeginInvoke((Action) delegate()
{
DGDebug.Rows.Insert(0, new object[]
{
frame.SourceNode, debug.level.value,
ASCIIEncoding.ASCII.GetString(debug.source, 0, debug.source_len),
ASCIIEncoding.ASCII.GetString(debug.text, 0, debug.text_len)
});
if (DGDebug.Rows.Count > 100)
{
DGDebug.Rows.RemoveAt(DGDebug.Rows.Count - 1);
}
});
}
};
}
}
UAVCAN.uavcan can = new UAVCAN.uavcan();
public async Task Invoke(HttpContext context, EnterChatContext chatContext)
{
if (!context.WebSockets.IsWebSocketRequest)
{
await _next.Invoke(context);
return;
}
CancellationToken ct = context.RequestAborted;
WebSocket currentSocket = await context.WebSockets.AcceptWebSocketAsync();
var socketId = Guid.NewGuid().ToString();
_sockets.TryAdd(socketId, currentSocket);
while (true)
{
if (ct.IsCancellationRequested)
{
break;
}
var response = await ReceiveStringAsync(currentSocket, ct);
if (string.IsNullOrEmpty(response))
{
if (currentSocket.State != WebSocketState.Open)
{
break;
}
continue;
}
int user_id = Int32.Parse(context.User.FindFirst(ClaimTypes.NameIdentifier).Value);
int comp_id = Int32.Parse(context.User.FindFirst("CompanyID").Value);
User user = await chatContext.Users.Where(u => u.ID == user_id).FirstOrDefaultAsync();
Worker worker = await chatContext.Workers.Where(w => w.ID == user.WorkerID).FirstOrDefaultAsync();
int index_stick = response.IndexOf('|');
string idRaw = response.Substring(0, index_stick);
string trueMessage = response.Remove(0, index_stick + 1);
if (idRaw.Equals("NoN"))
{
GroupChatMessage message = new GroupChatMessage
{
UserID = user_id,
CompanyID = comp_id,
Text = trueMessage,
CreationDate = DateTime.Now
};
await chatContext.GroupChatMessages.AddAsync(message);
await chatContext.SaveChangesAsync();
}
else
{
TopicMessage topicMessage = new TopicMessage
{
TopicID = Convert.ToInt32(idRaw),
UserID = user_id,
CompanyID = comp_id,
Text = trueMessage,
CreationDate = DateTime.Now
};
await chatContext.TopicMessages.AddAsync(topicMessage);
await chatContext.SaveChangesAsync();
}
string responceMessage = worker.FirstName + " " + worker.SecondName + ": " + trueMessage;
foreach (var socket in _sockets)
{
if (socket.Value.State != WebSocketState.Open)
{
continue;
}
await SendStringAsync(socket.Value, responceMessage, ct);
}
}
WebSocket dummy;
_sockets.TryRemove(socketId, out dummy);
await currentSocket.CloseAsync(WebSocketCloseStatus.NormalClosure, "Closing", ct);
currentSocket.Dispose();
}
public override void ExecuteCommand(WebSocket session, WebSocketCommandInfo commandInfo)
{
session.LastActiveTime = DateTime.Now;
session.ProtocolProcessor.SendPong(session, commandInfo.Text);
}
private async Task SendConnIDAsync(WebSocket socket, string connID)
{
var buffer = Encoding.UTF8.GetBytes("ConnID: " + connID);
await socket.SendAsync(buffer, WebSocketMessageType.Text, true, CancellationToken.None);
}
public string GetId(WebSocket socket)
{
return(_sockets.FirstOrDefault(p => p.Value == socket).Key);
}
//Asynchronous request handler.
public async Task WebSocketRequestHandler(WebSocketContext webSocketContext)
{
//Gets the current WebSocket object.
WebSocket webSocket = webSocketContext.WebSocket;
//check the integrity of the connection
/*We define a certain constant which will represent
* size of received data. It is established by us and
* we can set any value. We know that in this case the size of the sent
* data is very small.
*/
const int maxMessageSize = 512;
//Buffer for received bits.
var receivedDataBuffer = new ArraySegment <Byte>(new Byte[maxMessageSize]);
var cancellationToken = new CancellationToken();
//Checks WebSocket state.
while (webSocket.State == WebSocketState.Open)
{
//Reads data.
WebSocketReceiveResult webSocketReceiveResult =
await webSocket.ReceiveAsync(receivedDataBuffer, cancellationToken);
bool errorDetected = false;
//If input frame is cancelation frame, send close command.
if (webSocketReceiveResult.MessageType == WebSocketMessageType.Close)
{
await webSocket.CloseAsync(WebSocketCloseStatus.NormalClosure,
String.Empty, cancellationToken);
}
else
{
byte[] payloadData = receivedDataBuffer.Array.ToList()
.GetRange(0, webSocketReceiveResult.Count).ToArray();
WebsocketDataPackage package = GetPackage(ref payloadData);
string clientWsToken = GetConnectionCredential(package.clientId).HashedKey;
if (!CheckDataIntegrity(package.Data, package.HashedKey, clientWsToken))
{
errorDetected = true;
byte[] serializedData =
Encoding.UTF8.GetBytes(
JsonConvert.SerializeObject(package.Data) + clientWsToken);
string receivedHashedKey =
Convert.ToBase64String(SHA1.Create().ComputeHash(serializedData));
string message =
String.Format(
"Corrupted package: SHA1 received: {0} SHA1 expected: {1}",
receivedHashedKey, package.HashedKey);
Byte[] bytesToSend = System.Text.Encoding.UTF8.GetBytes(message);
//Sends data back.
await webSocket.SendAsync(new ArraySegment <byte>(bytesToSend),
WebSocketMessageType.Text, true, cancellationToken);
}
if (!errorDetected)
{
ConnectionCredentials cc = GetConnectionCredential(package.clientId);
if (!cc.ConnectionSet)
{
Connection conn = new Connection(cc, webSocket);
BindConnection(GetConnectionCredential(package.clientId), conn);
}
var newString =
String.Format(
"Hello, package with hashed key: " + package.HashedKey +
" validated! Time {0}", DateTime.Now.ToString());
Byte[] bytes = System.Text.Encoding.UTF8.GetBytes(newString);
//Sends data back.
await webSocket.SendAsync(new ArraySegment <byte>(bytes),
WebSocketMessageType.Text, true, cancellationToken);
}
}
}
}
public static WebSocketProtocol CreateFromConnection(ConnectionContext connection, bool isServer, string subProtocol, TimeSpan keepAliveInterval)
{
var websocket = WebSocket.CreateFromStream(new DuplexPipeStream(connection.Transport.Input, connection.Transport.Output), isServer, subProtocol, keepAliveInterval);
return(new WebSocketProtocol(websocket, connection));
}
private async Task Send(WebSocket webSocket, ConcurrentQueue <(int index, MemoryStream stream)> responses, AutoResetEvent autoResetEvent)
private async Task dealWithTeamBegain(WebSocket webSocketFromGameHandler)
{
WebSocketReceiveResult Wrr;
do
{
var returnResult = await ReceiveStringAsync(webSocketFromGameHandler, 1024 * 1024 * 10);
Wrr = returnResult.wr;
//returnResult.wr;
string outPut = "haveNothingToReturn";
{
var notifyJson = returnResult.result;
// var notifyJson = getBodyStr(context);
Console.WriteLine($"createTeam receive:{notifyJson}");
CommonClass.Command c = Newtonsoft.Json.JsonConvert.DeserializeObject <CommonClass.Command>(notifyJson);
switch (c.c)
{
case "TeamBegain":
{
CommonClass.TeamBegain teamBegain = Newtonsoft.Json.JsonConvert.DeserializeObject <CommonClass.TeamBegain>(notifyJson);
Team t = null;
lock (Program.teamLock)
{
if (Program.allTeams.ContainsKey(teamBegain.TeamNum))
{
t = Program.allTeams[teamBegain.TeamNum];
}
//Program.allTeams.Add()
}
if (t == null)
{
outPut = "ng";
}
else
{
for (var i = 0; i < t.member.Count; i++)
{
var secret = CommonClass.AES.AesEncrypt("team:" + teamBegain.RoomIndex.ToString(), t.member[i].CommandStart);
CommonClass.TeamNumWithSecret teamNumWithSecret = new CommonClass.TeamNumWithSecret()
{
c = "TeamNumWithSecret",
WebSocketID = t.member[i].WebSocketID,
Secret = secret
};
var json = Newtonsoft.Json.JsonConvert.SerializeObject(teamNumWithSecret);
await sendMsg(t.captain.FromUrl, json);
}
t.IsBegun = true;
outPut = "ok";
}
}; break;
}
}
{
var sendData = Encoding.UTF8.GetBytes(outPut);
await webSocketFromGameHandler.SendAsync(new ArraySegment <byte>(sendData, 0, sendData.Length), WebSocketMessageType.Text, true, CancellationToken.None);
}
} while (!Wrr.CloseStatus.HasValue);
}
public virtual async Task OnConnected(WebSocket socket)
{
WebSocketConnectionManager.AddSocket(socket);
}
void Connect(){
int id = (int)((1.0+Random.value)*0x10000);
ws = new WebSocket("ws://localhost:3000/websocket");
// called when websocket messages come.
ws.OnMessage += (sender, e) =>
{
//JSONObjectで解析
JSONObject json = new JSONObject(e.Data);
switch(json[0][0].str){
case "new_message":
messages.Add(string.Format("> {0}:{1}",json[0][1]["data"]["name"].str,
json[0][1]["data"]["body"].str));
if(messages.Count > 10){
messages.RemoveAt(0);
}
break;
case "websocket_rails.ping":
Debug.Log(string.Format("Send: [\"websocket_rails.pong\",{{\"id\":{0},\"data\":{{}}}}]", id));
ws.Send(string.Format("[\"websocket_rails.pong\",{{\"id\":{0},\"data\":{{}}}}]", id));
this.message = "";
break;
}
Debug.Log("Receive: " + e.Data);
};
ws.Connect();
Debug.Log("Connect to: " + ws.Url);
}
public async Task TestConnectWebSocket()
{
var wsUrl = Resources.WsServerAddress + "test";
Assert.IsNotNull(WebServer.Module<WebSocketsModule>(), "WebServer has WebSocketsModule");
Assert.AreEqual(WebServer.Module<WebSocketsModule>().Handlers.Count, 1, "WebSocketModule has one handler");
#if NET46
var clientSocket = new ClientWebSocket();
var ct = new CancellationTokenSource();
await clientSocket.ConnectAsync(new Uri(wsUrl), ct.Token);
Assert.AreEqual(WebSocketState.Open, clientSocket.State, "Connection is open");
var message = new ArraySegment<byte>(System.Text.Encoding.Default.GetBytes("HOLA"));
var buffer = new ArraySegment<byte>(new byte[1024]);
await clientSocket.SendAsync(message, WebSocketMessageType.Text, true, ct.Token);
var result = await clientSocket.ReceiveAsync(buffer, ct.Token);
Assert.IsTrue(result.EndOfMessage, "End of message is true");
Assert.IsTrue(System.Text.Encoding.UTF8.GetString(buffer.Array).TrimEnd((char) 0) == "WELCOME", "Final message is WELCOME");
#else
var clientSocket = new WebSocket(wsUrl);
clientSocket.Connect();
Assert.AreEqual(WebSocketState.Open, clientSocket.State, "Connection is open");
clientSocket.Send("HOLA");
await Task.Delay(100);
#endif
}
