/// <summary>
/// The function to be called for each message received on listening websocket
/// </summary>
/// <param name="message">The message received</param>
/// <param name="ws">The websocket on which the message was received</param>
void OnMessage(string message, WebSocketWrapper ws)
{
Console.WriteLine(message);
if (message == null || message == "")
{
return;
}
try
{
Response response = JsonConvert.DeserializeObject <Response>(message);
response.Handle(message, this);
}
catch (WebSocketException e)
{
Console.WriteLine("Exception in websocket:");
Console.WriteLine(e);
}
catch (Exception e)
{
Console.WriteLine(message);
Console.WriteLine("{0}: {1}", e.GetType(), e.Message);
ws.Close();
}
}
private static async Task TestPoloniex()
{
var uri = new Uri("wss://api2.poloniex.com");
using (var socket = new WebSocketWrapper(uri))
{
MessageArrived(socket);
await socket.ConnectAsync();
// subscribe to chanell BTC_NXT
await socket.SendAsync(new
{
command = "subscribe",
channel = 69
});
await Task.Delay(10000);
await socket.SendAsync(new
{
command = "unsubscribe",
channel = 69
});
await Task.Delay(500);
}
}
public async Task Start()
{
if (_started)
{
throw new Exception("already_started");
}
await Task.Run(() => WebSocketClientWrapper.ConnectAsync(
$"wss://{_options.Url}:{_options.Port}",
CancellationToken.None,
(context) =>
{
_socketWrapper = context;
context.OnOpen += OnOpen;
context.OnClose += _options.OnClose;
context.OnError += _options.OnError;
context.OnReceive += OnReceived;
_options.OnConnected?.Invoke();
},
true,
false,
3,
_options.InternalWebSocketOptions
));
}
/// <summary>
/// Connects to Cirrus
/// </summary>
/// <returns>If the connection was successfully opened</returns>
public bool Connect()
{
socket = WebSocketWrapper.Create(Config.ReadSetting("YanziHost"));
try
{
socket.Connect();
}
catch (Exception e)
{
Console.WriteLine("Could not connect to Cirrus");
//Console.WriteLine(e);
return(false);
}
if (socket.State() != WebSocketState.Open)
{
Console.WriteLine("Could not connect to Cirrus");
return(false);
}
socket.OnConnect((WebSocketWrapper ws) => Console.WriteLine("Has connected"));
socket.OnMessage(OnMessage);
socket.OnDisconnect((WebSocketWrapper ws) => Create());
return(true);
}
private async void Websocket_OnClosed(object sender, WebSocketWrapper socket)
{
await ExecuteSafeAsync(async() =>
{
SendChatLog("Websocket: Connection Closed", ChatLogType.Debug);
await Disconnect(true);
});
}
public ProvisioningSocket(string httpUri, CancellationToken token)
{
Token = token;
WsUri = httpUri.Replace("https://", "wss://")
.Replace("http://", "ws://") + "/v1/websocket/provisioning/";
WebSocket = new WebSocketWrapper(WsUri, token);
WebSocket.OnMessage(Connection_OnMessage);
}
public ServerCommandListener(MazeSocketConnector connector, WebSocketWrapper mazeSocket, MazeServer mazeServer,
ILifetimeScope container)
{
_connector = connector;
_mazeSocket = mazeSocket;
_mazeServer = mazeServer;
_container = container;
}
private async Task ParseMessage(SocketEventHandlerArgs msg)
{
string symbol = msg.chnlName;
switch (msg.type)
{
case StreamMessageType.Data:
{
var jsonResponse = Encoding.UTF8.GetString(msg.msg, 0, msg.msg.Length);
if (String.IsNullOrEmpty(jsonResponse))
{
_logger.Log(LogPriority.Warning, $"<--Report : Empty message received - '{jsonResponse}' : ", ExchName);
return;
}
if (symbol.Equals(BinanceClient.connectSymbol + "@ticker"))
{
return;
}
JObject jToken = JObject.Parse(jsonResponse);
var symbolItem = jToken["s"].ToString();
MarketBook mb = new MarketBook()
{
AskPrice = jToken["a"].ToObject <double>(),
AskSize = jToken["A"].ToObject <double>(),
BidPrice = jToken["b"].ToObject <double>(),
BidSize = jToken["B"].ToObject <double>(),
ServerTime = new DateTime(1970, 1, 1, 0, 0, 0, 0).AddMilliseconds(jToken["E"].ToObject <double>()),
LocalTime = DateTime.Now
};
_client.OnReport(ExchName, ExchName + symbolItem, mb);
}
break;
case StreamMessageType.Logon:
{
_client.OnEvent(ExchName, BrokerEvent.ConnectorStarted, string.Empty);
using (await _lock.LockAsync())
{
if (SubscribeList.Count > 0)
{
foreach (var i in SubscribeList)
{
chnl = new WebSocketWrapper(Uri + i.Key, i.Key, _logger, ExchName);
await chnl.Start(ParseMessage);
}
}
}
}
break;
default:
break;
}
}
public ServerHub(Uri uri)
{
HubUri = uri;
ConnectLoop = new CancellableRunLoop();
ConnectLoop.LoopIterationEvent += ConnectLoop_LoopIterationEvent;
Socket = new WebSocketWrapper(HubUri);
Socket.KeepAlive += Socket_KeepAlive;
Socket.OnConnected += Socket_OnConnected;
Socket.DataReceived += Socket_DataReceived;
}
public async Task Start(string endpoint, Instrument pair, SubscriptionModel model)
{
Id = pair.Id();
_endpoint = endpoint;
_pair = pair;
_model = model;
chnl = new WebSocketWrapper(Uri + _endpoint, _endpoint, _logger, ExchName);
await chnl.Start(ParseMessage);
}
public async Task InvokeAsync(HttpContext context)
{
if (!context.WebSockets.IsWebSocketRequest)
{
await _next(context);
return;
}
if (!context.User.Identity.IsAuthenticated)
{
context.Response.StatusCode = (int)HttpStatusCode.Unauthorized;
return;
}
var socket = await context.WebSockets.AcceptWebSocketAsync();
var wrapper = new WebSocketWrapper(socket, _options.PackageBufferSize);
var server = new MazeServer(wrapper, _options.PackageBufferSize, _options.MaxHeaderSize, ArrayPool <byte> .Shared);
if (context.User.IsAdministrator())
{
var accountId = context.User.GetAccountId();
var connection = new AdministrationConnection(accountId, wrapper, server);
_connectionManager.AdministrationConnections.TryAdd(accountId, connection);
try
{
await connection.BeginListen();
}
finally
{
_connectionManager.AdministrationConnections.TryRemove(accountId, out _);
}
}
else
{
var clientId = context.User.GetClientId();
var connection = new ClientConnection(clientId, wrapper, server);
_connectionManager.ClientConnections.TryAdd(clientId, connection);
_serviceProvider.Execute <IClientConnectedAction, IClientConnection>(connection).Forget();
try
{
await connection.BeginListen();
}
finally
{
_connectionManager.ClientConnections.TryRemove(clientId, out _);
}
await _serviceProvider.Execute <IClientDisconnectedAction, int>(connection.ClientId);
}
}
private void _CreateWebsocket()
{
var headers = new Dictionary <string, string>(StringComparer.CurrentCultureIgnoreCase);
headers.Add("origin", "https://plug.dj");
Websocket = new WebSocketWrapper(null, headers);
Websocket.OnMessageReceived += Websocket_OnMessage;
Websocket.OnConnected += Websocket_OnOpened;
Websocket.OnError += Websocket_OnError;
Websocket.OnDisconnected += Websocket_OnClosed;
}
public MainPage()
{
InitializeComponent();
UserInfo.Messages = new System.Collections.Generic.List <Message>();
messages = new ObservableCollection <Message>();
#region WebSocket Handling
var uri = new Uri("ws://" + SERVER_ADDRESS + "?impuAddress=" +
Uri.EscapeDataString(UserInfo.Number));
socket = WebSocketWrapper.Create(uri);
socket.Connect();
socket.OnMessage += (w, message) =>
{
Console.WriteLine("Received Message: " + message);
var package = JsonConvert.DeserializeObject <WebSocketPackage>(message);
if (package.callEvent == "CalledNumber")
{
inACall = true;
}
if (!String.IsNullOrEmpty(package.mediaInteractionResult))
{
var answer = "[RESPONSE]: " + package.mediaInteractionResult;
UserInfo.Messages.Add(new Message
{
Date = DateTime.Now,
Text = answer,
Number = UserInfo.LatestPartnerNumber
});
//messages.Add(new Message()
//{
// Number = GetSignitureInGoodFormat(DateTime.Now, ChannelPicker.SelectedItem.ToString(), UserInfo.LatestPartnerNumber),
// Text = answer,
//});
RefreshListView();
}
};
socket.OnDisconnected += (w) => { inACall = false; };
#endregion
if (ChannelPicker.SelectedItem == null)
{
ChannelPicker.SelectedItem = "0";
}
//RefreshListView();
RefreshBannerLine();
lstView.ItemsSource = messages;
}
protected override IBrokerage CreateBrokerage(IOrderProvider orderProvider, ISecurityProvider securityProvider)
{
var restClient = new RestClient("https://api.gdax.com");
var webSocketClient = new WebSocketWrapper();
var algorithm = new Mock <IAlgorithm>();
algorithm.Setup(a => a.BrokerageModel).Returns(new BitfinexBrokerageModel(AccountType.Cash));
return(new BitfinexBrokerage(Config.Get("gdax-url", "wss://ws-feed.gdax.com"), webSocketClient, restClient, Config.Get("bitfinex-api-key"), Config.Get("bitfinex-api-secret"),
algorithm.Object));
}
public void GetsHistory(Symbol symbol, Resolution resolution, TickType tickType, TimeSpan period, bool shouldBeEmpty)
{
var restClient = new RestClient("https://api.pro.coinbase.com");
var webSocketClient = new WebSocketWrapper();
var brokerage = new GDAXBrokerage(
Config.Get("gdax-url", "wss://ws-feed.pro.coinbase.com"), webSocketClient, restClient,
Config.Get("gdax-api-key"), Config.Get("gdax-api-secret"), Config.Get("gdax-passphrase"), null, null);
var historyProvider = new BrokerageHistoryProvider();
historyProvider.SetBrokerage(brokerage);
historyProvider.Initialize(new HistoryProviderInitializeParameters(null, null, null, null, null, null));
var now = DateTime.UtcNow;
var requests = new[]
{
new HistoryRequest(now.Add(-period),
now,
typeof(TradeBar),
symbol,
resolution,
SecurityExchangeHours.AlwaysOpen(TimeZones.Utc),
DateTimeZone.Utc,
resolution,
false,
false,
DataNormalizationMode.Adjusted,
tickType)
};
var history = historyProvider.GetHistory(requests, TimeZones.Utc).ToList();
foreach (var slice in history)
{
var bar = slice.Bars[symbol];
Log.Trace($"{bar.Time}: {bar.Symbol} - O={bar.Open}, H={bar.High}, L={bar.Low}, C={bar.Close}, V={bar.Volume}");
}
if (shouldBeEmpty)
{
Assert.IsTrue(history.Count == 0);
}
else
{
Assert.IsTrue(history.Count > 0);
}
Log.Trace("Data points retrieved: " + historyProvider.DataPointCount);
}
private void OnConnect(WebSocketWrapper wrapper)
{
_symbolLookup = new Dictionary <string, string>();
foreach (var coin in _exchange.Coins)
{
foreach (var childCoin in coin.Coins)
{
var symbol = coin.Symbol + childCoin.Symbol;
_symbolLookup.Add(symbol, $"{coin.Symbol},{childCoin.Symbol}");
var json = "{\"method\":\"subscribeTicker\",\"params\":{\"symbol\":\"" + symbol + "\"}, \"id\": 123}";
wrapper.SendMessage(json);
}
}
}
public void Monitor()
{
try
{
var socket = WebSocketWrapper.Create("wss://api.hitbtc.com/api/2/ws");
socket.OnConnect(OnConnect);
socket.OnMessage(OnMessage);
socket.OnDisconnect(OnDisconnect);
socket.Connect();
}
catch (Exception ex)
{
Colorful.Console.WriteLine($"HitBtc Monitor(): {ex.Message}\r\n{ex.StackTrace}", Color.Red);
}
}
public void Monitor()
{
try
{
var socket = WebSocketWrapper.Create("wss://ws-feed.gdax.com");
socket.OnConnect(OnConnect);
socket.OnMessage(OnMessage);
socket.OnDisconnect(OnDisconnect);
socket.Connect();
}
catch (Exception ex)
{
Colorful.Console.WriteLine($"Coinbase Monitor(): {ex.Message}\r\n{ex.StackTrace}", Color.Red);
}
}
// Start is called before the first frame update
void Start()
{
//unityWebRequest = new UnityWebRequest();
//DoFetch();
wsw = WebSocketWrapper.Create(socketURL);
onMessageAction = OnMessageCallback;
onConnectAction = OnConnectCallback;
wsw.OnConnect(onConnectAction);
wsw.OnMessage(onMessageAction);
wsw.Connect();
}
protected override IBrokerage CreateBrokerage(IOrderProvider orderProvider, ISecurityProvider securityProvider)
{
var restClient = new RestClient("https://api.pro.coinbase.com");
var webSocketClient = new WebSocketWrapper();
var algorithm = new Mock <IAlgorithm>();
algorithm.Setup(a => a.BrokerageModel).Returns(new GDAXBrokerageModel(AccountType.Cash));
var priceProvider = new ApiPriceProvider(Config.GetInt("job-user-id"), Config.Get("api-access-token"));
return(new GDAXBrokerage(Config.Get("gdax-url", "wss://ws-feed.pro.coinbase.com"), webSocketClient, restClient,
Config.Get("gdax-api-key"), Config.Get("gdax-api-secret"), Config.Get("gdax-passphrase"), algorithm.Object,
priceProvider));
}
public void Monitor()
{
try
{
var channels = BuildChannels();
var socket = WebSocketWrapper.Create($"wss://stream.binance.com:9443/ws{channels}");
socket.OnMessage(OnMessage);
socket.OnDisconnect(OnDisconnect);
socket.Connect();
}
catch (Exception ex)
{
Colorful.Console.WriteLine($"Binance Monitor(): {ex.Message}", Color.Red);
}
}
private static GDAXBrokerage GetBrokerage()
{
var wssUrl = Config.Get("gdax-url", "wss://ws-feed.pro.coinbase.com");
var webSocketClient = new WebSocketWrapper();
var restClient = new RestClient("https://api.pro.coinbase.com");
var apiKey = Config.Get("gdax-api-key");
var apiSecret = Config.Get("gdax-api-secret");
var passPhrase = Config.Get("gdax-passphrase");
var algorithm = new QCAlgorithm();
var userId = Config.GetInt("job-user-id");
var userToken = Config.Get("api-access-token");
var priceProvider = new ApiPriceProvider(userId, userToken);
return(new GDAXBrokerage(wssUrl, webSocketClient, restClient, apiKey, apiSecret, passPhrase, algorithm, priceProvider));
}
private static GDAXBrokerage GetBrokerage()
{
var wssUrl = Config.Get("gdax-url", "wss://ws-feed.pro.coinbase.com");
var webSocketClient = new WebSocketWrapper();
var restClient = new RestClient("https://api.pro.coinbase.com");
var apiKey = Config.Get("gdax-api-key");
var apiSecret = Config.Get("gdax-api-secret");
var passPhrase = Config.Get("gdax-passphrase");
var algorithm = new QCAlgorithm();
var brokerage = new GDAXBrokerage(wssUrl, webSocketClient, restClient, apiKey, apiSecret, passPhrase, algorithm);
brokerage.Connect();
return(brokerage);
}
private void OnMessage(string message, WebSocketWrapper wrapper)
{
if (string.IsNullOrEmpty(message))
{
return;
}
var items = JsonConvert.DeserializeObject <TickerChannelDto>(message);
if (items.Type == "ticker")
{
var pricingItem = _builderFactory.Create <TickerChannelDto, PricingItem>(items).Build();
var fromSymbol = items.Product_Id.Split("-")[0];
var toSymbol = items.Product_Id.Split("-")[1];
_serviceProvider.GetRequiredService <IPricingService>().UpdatePricingForMinute(ExchangeConstants.Coinbase, fromSymbol, toSymbol, pricingItem);
}
}
private void OnMessage(string message, WebSocketWrapper wrapper)
{
var item = JsonConvert.DeserializeObject <ResponseDto <TickerDto> >(message);
if (item.Method == "ticker" && !string.IsNullOrEmpty(item.Params.Ask) && !string.IsNullOrEmpty(item.Params.Bid))
{
var pricingItem = _builderFactory.Create <TickerDto, PricingItem>(item.Params).Build();
if (_symbolLookup.ContainsKey(item.Params.Symbol))
{
var symbolPair = _symbolLookup[item.Params.Symbol].Split(",");
var fromSymbol = symbolPair[0];
var toSymbol = symbolPair[1];
_serviceProvider.GetRequiredService <IPricingService>().UpdatePricingForMinute(ExchangeConstants.HitBtc, fromSymbol, toSymbol, pricingItem);
}
}
}
/// <summary>
/// Play sound when recieving message with active alarm
/// </summary>
/// <param name="message"></param>
/// <param name="socketWrapper"></param>
private async void OnMessageAsync(string message, WebSocketWrapper socketWrapper)
{
var webSocketDefinition = new { globalAlarmId = "", active = true }; //active = true is active alarm
var webSocketMessage = message.GetJsonObject(webSocketDefinition);
if (!_alreadyPlayed.Contains(webSocketMessage.globalAlarmId))
{
_alreadyPlayed.Add(webSocketMessage.globalAlarmId);
var alarmInfo = await _httpRequest.GetAlarmInfo(webSocketMessage.globalAlarmId, _accesstoken);
if (webSocketMessage.active && alarmInfo > 0)
{
_soundService.PlaySound();
}
}
}
private void Socket_DataReceived(WebSocketWrapper wrapper, ArraySegment <byte> data)
{
try
{
IMessage message = JsonSerializer.Deserialize <IMessage>(data, new JsonSerializerOptions
{
PropertyNameCaseInsensitive = true,
});
if (message == null)
{
return;
}
switch (message.Type)
{
case ChatMessage.TypeString:
if (IMessage.TryParseMessage <ChatMessage>(data, out ChatMessage chatMessage))
{
ChatMessageReceived?.Invoke(chatMessage);
}
else
{
Console.WriteLine(String.Format("Unable to parse ChatMessage out of ChatMessage header."));
}
break;
case ServerCommand.TypeString:
if (IMessage.TryParseMessage <ServerCommand>(data, out ServerCommand serverCommand))
{
ServerCommandReceived?.Invoke(serverCommand);
}
else
{
Console.WriteLine(String.Format("Unable to parse ServerCommand out of ServerCommand header."));
}
break;
default:
Console.WriteLine(String.Format("Unhandled Hub Message of type = {0}", message.Type));
break;
}
}
catch (Exception e)
{
Console.WriteLine(String.Format("Error deserializing Json message = {0}", e.ToString()));
}
}
private static void MessageArrived(WebSocketWrapper socket)
{
socket.MessageArrived += (message) =>
{
Console.WriteLine(message);
};
socket.ConnectionClosed += () =>
{
Console.WriteLine("Connection Closed");
};
socket.ConnectionError += (exception) =>
{
Console.WriteLine("Connection Error");
};
}
public static void Main(string[] args)
{
var configuration = new ConfigurationBuilder()
.AddCommandLine(args)
.Build();
string peers = configuration["peers"];
Console.WriteLine(peers);
if (!string.IsNullOrEmpty(peers))
{
foreach (var peer in peers.Split(','))
{
WebSocketWrapper peerConnection = WebSocketWrapper.Create(peer);
peerConnection.OnConnect(wsw =>
{
Console.WriteLine($"connected to {peer}");
});
peerConnection.OnMessage((message, wsw) =>
{
Console.WriteLine(Convert.ToBase64String(message));
Blockchain bc = DeserializeBlockchain(message);
Console.WriteLine($"LENGTH: {bc.Length} blocks - Last Block Timestamp {bc.LastBlock.Timestamp}");
});
connectedClients.Add(peerConnection);
peerConnection.Connect();
peerConnection.OnDisconnect(wsw =>
{
Console.WriteLine($"Disconnecting...");
connectedClients.Remove(wsw);
});
}
}
var host = new WebHostBuilder()
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseIISIntegration()
.UseStartup <Startup>()
.UseApplicationInsights()
.UseConfiguration(configuration)
.Build();
host.Run();
}
private void OnMessage(string message, WebSocketWrapper wrapper)
{
if (!string.IsNullOrEmpty(message) && message.Contains("\"e\":\"24hrTicker\""))
{
try
{
var items = JsonConvert.DeserializeObject <TickerDto>(message);
var pricingItem = _builderFactory.Create <TickerDto, PricingItem>(items).Build();
var fromSymbol = _channels[items.Symbol.ToUpper()].Split(",")[0];
var toSymbol = _channels[items.Symbol.ToUpper()].Split(",")[1];
_serviceProvider.GetRequiredService <IPricingService>().UpdatePricingForMinute(_apiService.Name, fromSymbol, toSymbol, pricingItem);
}
catch (Exception ex)
{
Colorful.Console.WriteLine($"Binance OnMessage(): {ex.Message}", Color.Red);
}
}
}
