public static async void Connect()
{
ConnectionInfo = Utilities.GetConnectionInfo();
HubConnection = new HubConnectionBuilder()
.WithUrl(ConnectionInfo.Host + "/DeviceHub", options => {
if (!string.IsNullOrWhiteSpace(ConnectionInfo.ProxyUrl))
{
options.Proxy = new WebProxy(ConnectionInfo.ProxyUrl, ConnectionInfo.ProxyPort);
}
})
.Build();
HubConnection.Closed += HubConn_Closed;
RegisterMessageHandlers(HubConnection);
await HubConnection.StartAsync();
var machine = Machine.Create(ConnectionInfo);
await HubConnection.InvokeAsync("MachineCameOnline", machine);
if (string.IsNullOrWhiteSpace(ConnectionInfo.ServerVerificationToken))
{
IsServerVerified = true;
ConnectionInfo.ServerVerificationToken = Guid.NewGuid().ToString();
await HubConnection.InvokeAsync("SetServerVerificationToken", ConnectionInfo.ServerVerificationToken);
Utilities.SaveConnectionInfo(ConnectionInfo);
Updater.CheckForCoreUpdates();
}
else
{
await HubConnection.InvokeAsync("SendServerVerificationToken");
}
if (HeartbeatTimer != null)
{
HeartbeatTimer.Stop();
}
HeartbeatTimer = new Timer(300000);
HeartbeatTimer.Elapsed += HeartbeatTimer_Elapsed;
HeartbeatTimer.Start();
}
public async Task Connect()
{
ConnectionInfo = ConfigService.GetConnectionInfo();
HubConnection = new HubConnectionBuilder()
.WithUrl(ConnectionInfo.Host + "/DeviceHub")
.AddMessagePackProtocol()
.Build();
RegisterMessageHandlers();
await HubConnection.StartAsync();
var device = Device.Create(ConnectionInfo);
await HubConnection.InvokeAsync("DeviceCameOnline", device);
if (string.IsNullOrWhiteSpace(ConnectionInfo.ServerVerificationToken))
{
IsServerVerified = true;
ConnectionInfo.ServerVerificationToken = Guid.NewGuid().ToString();
await HubConnection.InvokeAsync("SetServerVerificationToken", ConnectionInfo.ServerVerificationToken);
ConfigService.SaveConnectionInfo(ConnectionInfo);
}
else
{
await HubConnection.InvokeAsync("SendServerVerificationToken");
}
if (ConfigService.TryGetDeviceSetupOptions(out DeviceSetupOptions options))
{
await HubConnection.InvokeAsync("DeviceSetupOptions", options, ConnectionInfo.DeviceID);
}
HeartbeatTimer?.Dispose();
HeartbeatTimer = new Timer(TimeSpan.FromMinutes(5).TotalMilliseconds);
HeartbeatTimer.Elapsed += HeartbeatTimer_Elapsed;
HeartbeatTimer.Start();
}
public static async void Connect()
{
ConnectionInfo = Utilities.GetConnectionInfo();
HubConnection = new HubConnectionBuilder()
.WithUrl(ConnectionInfo.Host + "/DeviceHub")
.Build();
HubConnection.Closed += HubConn_Closed;
RegisterMessageHandlers(HubConnection);
await HubConnection.StartAsync();
var device = Device.Create(ConnectionInfo);
await HubConnection.InvokeAsync("DeviceCameOnline", device);
if (string.IsNullOrWhiteSpace(ConnectionInfo.ServerVerificationToken))
{
IsServerVerified = true;
ConnectionInfo.ServerVerificationToken = Guid.NewGuid().ToString();
await HubConnection.InvokeAsync("SetServerVerificationToken", ConnectionInfo.ServerVerificationToken);
Utilities.SaveConnectionInfo(ConnectionInfo);
}
else
{
await HubConnection.InvokeAsync("SendServerVerificationToken");
}
if (HeartbeatTimer != null)
{
HeartbeatTimer.Stop();
}
HeartbeatTimer = new Timer(300000);
HeartbeatTimer.Elapsed += HeartbeatTimer_Elapsed;
HeartbeatTimer.Start();
}
private void ChangeConnectionStatus(ServiceConnectionStatus status, ServiceMachineStatus machineConnectionStatus)
{
ConnectionStatus = status;
_DomainManagerProxy.AddMessage(
new DeviceVariableUpdateMessage(ConnectionStatusName, ConnectionStatus)
);
switch (ConnectionStatus)
{
case ServiceConnectionStatus.Connecting:
case ServiceConnectionStatus.Connected:
break;
case ServiceConnectionStatus.Disabled:
foreach (var machine in _Machines)
{
machine.ChangeMachineStatus(ServiceMachineStatus.Disabled);
}
break;
case ServiceConnectionStatus.Disconnected:
foreach (var machine in _Machines)
{
machine.ChangeMachineStatus(machineConnectionStatus);
machine.IsConnected = false;
// TODO: Test / clean-up these falgs
machine.IsHuskyMachineServiceConnected = false;
}
HeartbeatTimer.Interval = _ConnectionTimerIntervalMilliseconds;
HeartbeatTimer.Restart();
break;
}
}
public async Task Connect()
{
try
{
ConnectionInfo = ConfigService.GetConnectionInfo();
HubConnection = new HubConnectionBuilder()
.WithUrl(ConnectionInfo.Host + "/DeviceHub")
.Build();
RegisterMessageHandlers();
await HubConnection.StartAsync();
}
catch (Exception ex)
{
Logger.Write(ex, "Failed to connect to server. Internet connection may be unavailable.", EventType.Warning);
return;
}
try
{
var device = await DeviceInformation.Create(ConnectionInfo.DeviceID, ConnectionInfo.OrganizationID);
var result = await HubConnection.InvokeAsync <bool>("DeviceCameOnline", device);
if (!result)
{
// Orgnanization ID wasn't found, or this device is already connected.
// The above can be caused by temporary issues on the server. So we'll do
// nothing here and wait for it to get resolved.
Logger.Write("There was an issue registering with the server. The server might be undergoing maintenance, or the supplied organization ID might be incorrect.");
await Task.Delay(TimeSpan.FromMinutes(1));
await HubConnection.StopAsync();
return;
}
if (string.IsNullOrWhiteSpace(ConnectionInfo.ServerVerificationToken))
{
IsServerVerified = true;
ConnectionInfo.ServerVerificationToken = Guid.NewGuid().ToString();
await HubConnection.SendAsync("SetServerVerificationToken", ConnectionInfo.ServerVerificationToken);
ConfigService.SaveConnectionInfo(ConnectionInfo);
}
else
{
await HubConnection.SendAsync("SendServerVerificationToken");
}
if (ConfigService.TryGetDeviceSetupOptions(out DeviceSetupOptions options))
{
await HubConnection.SendAsync("DeviceSetupOptions", options, ConnectionInfo.DeviceID);
}
HeartbeatTimer?.Dispose();
HeartbeatTimer = new System.Timers.Timer(TimeSpan.FromMinutes(5).TotalMilliseconds);
HeartbeatTimer.Elapsed += HeartbeatTimer_Elapsed;
HeartbeatTimer.Start();
}
catch (Exception ex)
{
Logger.Write(ex, "Error starting websocket connection.", EventType.Error);
}
}
/// <summary>
/// Stop the Orchestrator
/// </summary>
public void Stop()
{
HeartbeatTimer.Change(Timeout.Infinite, Timeout.Infinite);
RaiseOrchestrationEnded();
}
/// <summary>
/// Stop the periodic heartbeat, if it is running. The server is
/// assumed to be locked.
/// </summary>
public void StopHeartbeat()
{
HeartbeatTimer.Stop();
}
/// <summary>
/// Start the periodic heartbeat, if it is not already running. The
/// server is assumed to be locked.
/// </summary>
public void StartHeartbeat()
{
HeartbeatTimer.Start();
}
private async Task _onWsMessage(object sender, MessageEventArgs msg)
{
var serializedPayload = msg.Data;
var deserializedPayload = JsonConvert.DeserializeObject <DiscordGatewayPayload <dynamic> >(serializedPayload,
new JsonSerializerSettings
{
NullValueHandling = NullValueHandling.Ignore
});
if (deserializedPayload.S != 0)
{
Sequence = deserializedPayload.S;
}
switch (deserializedPayload.Op)
{
case 0:
{
switch (deserializedPayload.T)
{
case "READY":
{
var readyPayload =
JsonConvert.DeserializeObject <DiscordGatewayPayload <ReadyPayload> >(
JsonConvert.SerializeObject(deserializedPayload));
Client.ClientUser = new ClientUser
{
Avatar = readyPayload.D.User.Avatar,
Bot = readyPayload.D.User.Bot,
Discriminator = readyPayload.D.User.Discriminator,
Flags = readyPayload.D.User.Flags,
Id = readyPayload.D.User.Id,
Username = readyPayload.D.User.Username
};
SessionId = readyPayload.D.SessionId;
HeartbeatTimer.Start();
HeartbeatTimer.Elapsed += Heartbeat;
InitialGuilds = readyPayload.D.UnavailableGuilds.Length;
break;
}
case "GUILD_CREATE":
{
var guildPayload =
JsonConvert.DeserializeObject <DiscordGatewayPayload <GuildCreatePayload> >(
JsonConvert.SerializeObject(deserializedPayload));
if (guildPayload.D.Lazy)
{
InitialGuilds--;
await Client.Guilds.GetOrCreateAsync(guildPayload.D.Id,
async() => JsonConvert
.DeserializeObject <DiscordGatewayPayload <Guild> >(JsonConvert.SerializeObject(guildPayload)).D);
if (InitialGuilds == 0)
{
Client.ReadyEvent(EventArgs.Empty);
}
}
else
{
var seeIfGuildWasUnavailable = await Client.UnavailableGuilds.GetAsync(guildPayload.D.Id);
if (seeIfGuildWasUnavailable == null)
{
var guild = await Client.Guilds.GetOrCreateAsync(guildPayload.D.Id,
async() => JsonConvert
.DeserializeObject <DiscordGatewayPayload <Guild> >(JsonConvert.SerializeObject(guildPayload)).D);
Client.GuildCreateEvent(guild);
}
else
{
var guild = await Client.Guilds.GetOrCreateAsync(guildPayload.D.Id,
async() => JsonConvert
.DeserializeObject <DiscordGatewayPayload <Guild> >(JsonConvert.SerializeObject(guildPayload)).D);
await Client.UnavailableGuilds.DeleteAsync(guildPayload.D.Id);
Client.GuildAvailableEvent(guild);
}
}
break;
}
case "GUILD_UPDATE":
{
var guildPayload =
JsonConvert.DeserializeObject <DiscordGatewayPayload <GuildUpdatePayload> >(
JsonConvert.SerializeObject(deserializedPayload));
var findGuild = await Client.Guilds.GetAsync(guildPayload.D.Id);
if (findGuild == null)
{
// TODO: Create the route struct so that i can get the guild and add it to cache.
}
else
{
var newGuild = await Client.Guilds.UpdateAsync(guildPayload.D.Id,
JsonConvert.DeserializeObject <DiscordGatewayPayload <Guild> >(
JsonConvert.SerializeObject(deserializedPayload)).D);
Client.GuildUpdateEvent(new GuildUpdateEventArgs
{
NewGuild = newGuild,
OldGuild = findGuild
});
}
break;
}
case "GUILD_DELETE":
{
var guildPayload =
JsonConvert.DeserializeObject <DiscordGatewayPayload <GuildDeletePayload> >(
JsonConvert.SerializeObject(deserializedPayload));
var findGuild = await Client.Guilds.GetAsync(guildPayload.D.Id);
if (findGuild == null)
{
// TODO: Create the route struct/class so that i can get the guild and add it to cache.
}
else
{
await Client.Guilds.DeleteAsync(guildPayload.D.Id);
if (guildPayload.D.Unavailable)
{
var unavailableGuild =
await Client.UnavailableGuilds.GetOrCreateAsync(guildPayload.D.Id, async() => findGuild);
Client.GuildUnavailableEvent(unavailableGuild);
}
else
{
Client.GuildDeleteEvent(findGuild);
}
}
break;
}
}
break;
}
case 10:
{
var helloPayload =
JsonConvert.DeserializeObject <DiscordGatewayPayload <HelloPayload> >(
JsonConvert.SerializeObject(deserializedPayload));
if (HeartbeatTimer != null)
{
HeartbeatTimer.Elapsed -= Heartbeat;
HeartbeatTimer.Stop();
HeartbeatTimer.Dispose();
}
HeartbeatTimer = new Timer(helloPayload.D.HeartbeatInterval);
HeartbeatTimer.AutoReset = true;
var identifyPayload = new DiscordGatewayPayload <IdentifyPayload>
{
Op = 2,
D = new IdentifyPayload
{
Token = Client.Token,
Properties = new IdentifyPropertiesPayload
{
Browser = "Disharp",
Device = "Disharp",
Os = Environment.OSVersion.Platform.ToString()
},
Compress = false,
LargeThreshold = Client.ClientOptions.LargeThreshold,
Presence = Client.ClientOptions.WsOptions.Presence,
Intents = Client.ClientOptions.WsOptions.Intents
}
};
Send(identifyPayload);
break;
}
}
Console.WriteLine(JsonConvert.SerializeObject(deserializedPayload));
}
