/// <summary>
/// Executes a packet based on its handler
/// </summary>
public void HandlePacket()
{
try
{
//If no auth client is present we don't need to proceed.
if (AuthClient == null)
{
return;
}
//Create an instance of our handler
dynamic handler = Activator.CreateInstance(_packetHandler);
//Authentication is needed to run most packets, however some work without being logged in.
if (AuthClient.Authenticated || !NeedsAuth(EndPoint))
{
Task.Run(() => { handler.HandlePacket(this); });
}
else
{
EndPointName = "noauth";
EndPoint = EndPoints.NoAuth;
handler = Activator.CreateInstance(typeof(ErrorPacketHandler));
handler.HandlePacket(this);
}
}
catch (Exception)
{
EndPointName = "invalidpacket";
EndPoint = EndPoints.InvalidOrEmptyPacket;
dynamic handler = Activator.CreateInstance(typeof(ErrorPacketHandler));
handler.HandlePacket(this);
}
}
public void UnSubscribeNode(ApUnSubscribeNodeRequest request)
{
Log.Debug(typeof(ApNodeControllerService), "UnSubscribeNode()");
try
{
Node node = Database.GetInstance().Nodes.Find(x => x.IpAddress.Equals(request.IpAddress));
if (node != null)
{
Database.GetInstance().Nodes.Remove(node);
// Update routing mesh in the load balancer
LbRemoveApplicationInstanceRequest request_ = new LbRemoveApplicationInstanceRequest(Credentials);
request_.NodeId = node.Id;
request_.ApplicationId = -1;
request_.InstanceId = -1;
EndPoints.GetLbApplicationGridService().RemoveApplicationInstances(request_);
}
Log.Debug(typeof(ApNodeControllerService), "Node " + node.IpAddress + " removed successfully");
}
catch (Exception e)
{
Log.Error(this, e);
throw e;
}
}
public async ValueTask <ElementId> UploadAsync(long roomId, Stream stream, string filePath, string message)
{
var uri = $"{EndPoints.RoomFiles(roomId)}";
MultipartFormDataContent multipart = new MultipartFormDataContent();
var fileContent = new StreamContent(stream);
fileContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data")
{
Name = "\"file\"",
FileName = $"\"{Path.GetFileName(filePath)}\"",
};
var mimeName = MimeMapping.MimeUtility.GetMimeMapping(filePath);
fileContent.Headers.ContentType = new MediaTypeHeaderValue(mimeName);
var messageContent = new StringContent(message);
messageContent.Headers.ContentDisposition = new ContentDispositionHeaderValue("form-data");
messageContent.Headers.ContentDisposition.Name = "\"message\"";
messageContent.Headers.ContentType = null;
multipart.Add(fileContent);
multipart.Add(messageContent);
return(await this.chatworkClient.QueryContentAsync <ElementId>(new Uri(uri), HttpMethod.Post, multipart));
}
internal void UpdateSentinelAddressList(string serviceName)
{
var firstCompleteRequest = GetServerSnapshot()
.ToArray()
.Where(s => s.ServerType == ServerType.Sentinel)
.AsParallel()
.Select(s =>
{
try { return(GetServer(s.EndPoint).SentinelGetSentinelAddresses(serviceName)); }
catch { return(null); }
})
.FirstOrDefault(r => r != null);
// Ignore errors, as having an updated sentinel list is not essential
if (firstCompleteRequest == null)
{
return;
}
bool hasNew = false;
foreach (EndPoint newSentinel in firstCompleteRequest.Where(x => !EndPoints.Contains(x)))
{
hasNew = true;
EndPoints.TryAdd(newSentinel);
}
if (hasNew)
{
// Reconfigure the sentinel multiplexer if we added new endpoints
ReconfigureAsync(first: false, reconfigureAll: true, null, EndPoints[0], "Updating Sentinel List", false).Wait();
}
}
public async Task <List <GoogleAddress> > GetAddressPosition(string address)
{
var url = EndPoints.GoogleAddressUrl(address);
var client = new HttpClient();
var json = client.GetStringAsync(url).Result;
var adds = new List <GoogleAddress>();
GooglePlaceSearchResponse resp = JsonConvert.DeserializeObject <GooglePlaceSearchResponse>(json);
try
{
foreach (var add in resp.Results)
{
var pos = new GoogleAddress
{
RequestedAddress = address,
FormattedAddress = add.Vicinity,
Lat = add.Geometry.Location.Lat,
Lon = add.Geometry.Location.Lng,
Name = add.Name,
Distance = TrackingHelper.Instance.CalculateDistance(add.Geometry.Location.Lat, add.Geometry.Location.Lng),
};
adds.Add(pos);
}
}
catch (Exception e)
{
}
return(adds.OrderBy(x => x.Distance).ToList());;
}
private void UpdateApplications(List <Node> nodes)
{
foreach (Node node in nodes)
{
try
{
NcDescribeApplicationsRequest request = new NcDescribeApplicationsRequest(Settings.Credentials);
var channel = EndPoints.GetNcApplicationGridService(node);
NcDescribeApplicationsResponse response = channel.DescribeApplications(request);
node.Applications = response.Applications;
foreach (Application application in node.Applications)
{
LbGetApplicationInstancesRequest request1 = new LbGetApplicationInstancesRequest(Settings.Credentials);
request1.NodeId = node.Id;
request1.ApplicationId = application.Id;
LbGetApplicationInstancesResponse response1 = EndPoints.GetLbApplicationGridService().GetApplicationInstances(request1);
application.ApplicationInstances = response1.ApplicationInstances;
}
Log.Debug(this, "Updated applications of node " + node.ToString());
}
catch (Exception e)
{
Log.Error(this, "Could not update applications of node " + node.ToString());
throw e;
}
}
}
public void PostTo()
{
CoapClient c = new CoapClient(Program.Host)
{
UriPath = "/.well-known/core",
UriQuery = "ep=node1",
Timeout = 5000,
EndPoint = EndPoints.First()
};
Response r = c.Post(new byte[] { }, MediaType.ApplicationLinkFormat);
if (r == null)
{
Console.WriteLine("No response received");
}
else
{
if (r.StatusCode != StatusCode.Changed)
{
Console.WriteLine("Incorrect response");
}
Console.WriteLine(Utils.ToString(r));
}
}
public async Task Services_are_resolved_on_service_manifest()
{
// PaymentsService calls AccountsService internally.
// In this test we mock AccountService so we know it is resolved and accessible from within PaymentsService.
IEndPointConfiguration ep = EndPoints.First(x => x.ProviderName == CurrentDatabaseProviderName && x.API_Name == API_Name.BackOffice);
await DropAndRecreate(ep);
Mock <IAccountsService> fakeMSSQLAccountsService = new Mock <IAccountsService>();
fakeMSSQLAccountsService.Setup(x => x.GetAccountByID(It.IsAny <int>())).ReturnsAsync(new Account {
Name = "TEST"
});
using (var scope = Container.BeginLifetimeScope(builder =>
{
builder.RegisterInstance(fakeMSSQLAccountsService.Object).Keyed <IAccountsService>(EndPointType.DBMS + CurrentDatabaseProviderName);
}))
{
IAdaptiveClient <IBOServiceManifest> client = scope.Resolve <IAdaptiveClient <IBOServiceManifest> >();
Account account = await client.CallAsync(x => x.PaymentsService.GetAccountForPaymentID(1), ep.Name);
Assert.AreEqual("TEST", account.Name);
}
}
public void Resolve_DbContext_for_API()
{
IEndPointConfiguration storeFrontep = EndPoints.First(x => x.ProviderName == CurrentDatabaseProviderName && x.API_Name == API_Name.StoreFront);
IEndPointConfiguration backOfficeep = EndPoints.First(x => x.ProviderName == CurrentDatabaseProviderName && x.API_Name == API_Name.BackOffice);
ResolutionHelper resolutionHelper = Container.Resolve <ResolutionHelper>();
DbContext storeFrontContext = resolutionHelper.ResolveDbContext(storeFrontep);
DbContext backOfficeContext = resolutionHelper.ResolveDbContext(backOfficeep);
Assert.IsNotNull(storeFrontContext);
Assert.IsNotNull(backOfficeContext);
Assert.IsTrue(storeFrontContext is Artifacts.StoreFront.Db);
Assert.IsTrue(backOfficeContext is Artifacts.BackOffice.Db);
if (CurrentDatabaseProviderName == DataBaseProviderName.MSSQL)
{
Assert.IsTrue(storeFrontContext.Database.GetDbConnection().ConnectionString == storeFrontep.ConnectionString);
Assert.IsTrue(backOfficeContext.Database.GetDbConnection().ConnectionString == backOfficeep.ConnectionString);
}
else if (CurrentDatabaseProviderName == DataBaseProviderName.MySQL)
{
// MySql database connector changes the connection string.
Assert.IsTrue(storeFrontContext.Database.GetDbConnection().ConnectionString.ToLower().Contains("database=adaptiveclientef_storefront"));
Assert.IsTrue(backOfficeContext.Database.GetDbConnection().ConnectionString.ToLower().Contains("database=adaptiveclientef_backoffice"));
}
}
private int monitoringInterval = 5000; // Monitoring interval 5 sec
public void MonitorRequestQueue()
{
Log.Info(this, "Scaling Manager started");
while (Thread.CurrentThread.IsAlive)
{
LbGetRequestQueueResponse response = null;
try
{
Log.Info(this, "Checking request queue status...");
LbGetRequestQueueRequest request = new LbGetRequestQueueRequest(Settings.Credentials);
response = EndPoints.GetLbApplicationGridService().GetRequestQueue(request);
}
catch (Exception e)
{
Log.Error(this, e);
}
try
{
if (response != null)
{
ScaleApplications(response.RequestQueue);
}
Thread.Sleep(monitoringInterval);
}
catch (Exception e)
{
Log.Error(this, e);
}
}
Log.Info(this, "Scaling Manager stopped");
}
private ConfigurationOptions BuildConfigurationOptions()
{
var result = new ConfigurationOptions();
if (EndPoints != null)
{
foreach (var ep in EndPoints.DefaultIfEmpty())
{
result.EndPoints.Add(ep);
}
}
if (AllowAdmin.HasValue)
{
result.AllowAdmin = AllowAdmin.Value;
}
if (ConnectRetry.HasValue)
{
result.ConnectRetry = ConnectRetry.Value;
}
if (ConnectTimeout.HasValue)
{
result.ConnectTimeout = ConnectTimeout.Value;
}
if (DefaultDatabase.HasValue)
{
result.DefaultDatabase = DefaultDatabase.Value;
}
return(result);
}
public virtual void ClearGraph()
{
Graph.Refresh();
PathFindingStatistics = string.Empty;
GraphParametres = Graph.ToString();
EndPoints.Reset();
}
private bool ScaleDown(int applicationId, string tenantName, int scale)
{
Log.Info(this, "Scaling down application: " + applicationId);
LbGetApplicationInstancesRequest request_ = new LbGetApplicationInstancesRequest(Settings.Credentials);
request_.NodeId = -1;
request_.ApplicationId = applicationId;
LbGetApplicationInstancesResponse response_ = EndPoints.GetLbApplicationGridService().GetApplicationInstances(request_);
List <ApplicationInstance> list = response_.ApplicationInstances.OrderBy(x => x.Id).ToList();
if ((list != null) && (list.Count >= scale))
{
// Stop idling application instances
List <ApplicationInstance> idlingInstances = list.FindAll(x => x.RequestCount == 0);
// Keep one instance alive
if (idlingInstances.Count == list.Count)
{
idlingInstances.Remove(idlingInstances.Last());
}
if (idlingInstances.Count > 0)
{
foreach (ApplicationInstance instance in idlingInstances)
{
ApStopApplicationInstanceRequest request = new ApStopApplicationInstanceRequest(Settings.Credentials);
request.NodeId = instance.NodeId;
request.ApplicationId = instance.ApplicationId;
request.InstanceId = instance.Id;
GetApDashboardService().StopApplicationInstance(request);
}
return(true);
}
}
return(false);
}
internal static string BuildUrl(EndPoints endPoint)
{
string servicePath = "";
switch (endPoint)
{
case EndPoints.ActiveMasterConferences:
servicePath = "/MasterConference.svc/GetActiveMasterConferences";
break;
case EndPoints.SessionsForConferenceId:
servicePath = "/Session.svc/GetSessionsByConferenceId?conferenceId={0}";
break;
case EndPoints.TracksForConferenceId:
servicePath = "/Track.svc/GetTracksByConferenceId?conferenceId={0}";
break;
case EndPoints.SessionForSessionId:
servicePath = "/Session.svc/GetSession?sessionId={0}";
break;
}
return(RootUrl + servicePath);
}
/// <summary>
/// Get request Asynchronously
/// </summary>
/// <typeparam name="T"> The class that the Method Should return and Get</typeparam>
/// <param name="theUri">the specific api Call</param>
/// <param name="id1">this is the first Id, it can be left as a zero but for some Calls cant be left </param>
/// <param name="id2">this is the second Id, for specific subjects</param>
/// <returns>A List of T</returns>
public T GetRequestByIdAsync <T>(EndPoints theUri, int id1 = 0, int id2 = 0) where T : new()
{
using (var handler = new HttpClientHandler())
{
handler.Credentials = new NetworkCredential(_username, _password);
using (var client = new HttpClient(handler))
{
client.BaseAddress = new Uri(_baseAddress);
client.DefaultRequestHeaders.Clear();//making sure that there is no old data within headers
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
var jsonData = string.Empty;
// attempt to download JSON data as a string
try
{
var ext = UriCorrector(theUri, id1, id2);
var response = client.GetAsync(ext).Result;
if (response.IsSuccessStatusCode)
{
jsonData = response.Content.ReadAsStringAsync().Result;
}
}
catch (HttpRequestException exception)
{
//await new MessageDialog(exception.Message).ShowAsync();
}
// if string with JSON data is not empty, deserialize it to class and return its instance
return(!string.IsNullOrEmpty(jsonData) ? JsonConvert.DeserializeObject <T>(jsonData) : new T());
}
}
}
private void UploadApplicationToNode(int applicationId, Node node)
{
Log.Debug(this, "Uploading application " + applicationId + " to node " + node.ToString());
Application app = FindApplication(applicationId);
if (app != null)
{
string filePath = Path.Combine(Settings.ApplicationStorePath, app.FileName);
if (File.Exists(filePath))
{
Log.Debug(this, "Transferring application package...");
NcFileTransferSocket socket = new NcFileTransferSocket(node.IpAddress_, Settings.NcFileTransferSocketPort);
socket.SendFile(filePath);
Log.Debug(this, "Transferring application data...");
NcAddApplicationRequest request = new NcAddApplicationRequest(Credentials);
request.Application = app;
EndPoints.GetNcApplicationGridService(node).AddApplication(request);
}
else
{
throw new MonoscapeException("File not found: " + app.FileName);
}
}
else
{
throw new MonoscapeException("Application not found: " + app.Name);
}
}
/// <summary>
/// Delete Request Asynchronously
/// </summary>
/// <param name="theUri">the specific api Call</param>
/// <param name="id1">this is the first Id, it can be left as a zero but for some Calls it is needed</param>
/// <param name="id2">this is the second Id, for specific subjects</param>
public async void DelRequest(EndPoints theUri, int id1 = 0, int id2 = 0)
{
using (var handler = new HttpClientHandler())
{
handler.Credentials = new NetworkCredential(_username, _password);
using (var client = new HttpClient(handler))
{
client.BaseAddress = new Uri(_baseAddress);
client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
try
{
var ext = UriCorrector(theUri, id1, id2);
var response = await client.DeleteAsync(ext);
if (response.IsSuccessStatusCode)
{
//await new MessageDialog("Succesfully Deleted:\n\t").ShowAsync();
}
}
catch (HttpRequestException exception)
{
//await new MessageDialog(exception.Message).ShowAsync();
}
}
}
}
/// <summary>
/// Change/edit request Asynchronously
/// </summary>
/// <typeparam name="T"> The class that the Method Should return and Get</typeparam>
/// <param name="classToPut"> class wished to retrieve</param>
/// <param name="theUri">the specific api Call</param>
/// <param name="id1">this is the first Id, it can be left as a zero but for some Calls cant be left </param>
/// <param name="id2">this is the second Id, for specific subjects</param>
/// <returns>returns T that is sent to the API for debugging reasons</returns>
public async Task <T> PutRequest <T>(T classToPut, EndPoints theUri, int id1 = 0, int id2 = 0)
{
using (var handler = new HttpClientHandler())
{
handler.Credentials = new NetworkCredential(_username, _password);
using (var client = new HttpClient(handler))
{
client.BaseAddress = new Uri(_baseAddress);
client.DefaultRequestHeaders.Clear();
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
try
{
string serializeObjectToJson = await System.Threading.Tasks.Task.Run(() => JsonConvert.SerializeObject(classToPut));
var ext = UriCorrector(theUri, id1, id2);
var response = await client.PutAsync(ext, new StringContent(serializeObjectToJson, Encoding.UTF8, "application/json"));
if (response.IsSuccessStatusCode)
{
//await new MessageDialog("Succesfully Changed:\n\t" + classToPut).ShowAsync();
}
}
catch (HttpRequestException exception)
{
//await new MessageDialog(exception.Message).ShowAsync();
}
return(classToPut);
}
}
}
/// <summary>
/// Create and return a new packet
/// </summary>
/// <returns>Packet</returns>
public Packet GetPacket()
{
if (string.IsNullOrEmpty(_plainText))
{
return(null);
}
try
{
var deserializedPacket = JObject.Parse(_plainText);
if (deserializedPacket != null)
{
_endPointName = deserializedPacket["endpoint"]?.ToString().Trim().ToLower();
_syncKey = deserializedPacket["synckey"]?.ToString().Trim();
if (deserializedPacket["args"] != null)
{
_args.AddRange(JArray.Parse(deserializedPacket["args"]?.ToString()));
}
var packetInfo = GetPacketInfo(_endPointName);
_packetHandler = packetInfo.Handler;
_endPoints = packetInfo.EndPoint;
return(new Packet(_authClient, _client, _endPointName, _syncKey, _args, _endPoints, _packetHandler));
}
}
catch (Exception e)
{
Console.WriteLine($"Packet failed to deserialize: {e.StackTrace}{e.Message}");
_endPoints = EndPoints.InvalidOrEmptyPacket;
}
return(null);
}
public void Sweep()
{
EndPoints.Sort(EndPoint.Compare);
float beginAngle = 0;
for (int pass = 0; pass < 2; pass++)
{
Segment previous = null;
foreach (EndPoint p in EndPoints)
{
Segment currentOld = Open.FirstOrDefault();
InsertPoint(p);
Segment currentNew = Open.FirstOrDefault();
if (currentOld != currentNew)
{
if (pass == 1)
{
AddTriangle(beginAngle, p.Angle, currentOld, previous);
previous = currentOld;
}
beginAngle = p.Angle;
}
}
}
}
private void FormSettings_Load(object sender, EventArgs e)
{
var devices = EndPoints.GetAllDeviceList();
var cnt = 0;
foreach (var dev in devices)
{
var devID = dev.Key.ID;
var lvitem = new ListViewItem {
Text = dev.Key.FriendlyName, ImageIndex = cnt, Tag = devID
};
var devSettings = Program.settings.Device.Find(x => x.DeviceID == devID);
if (devSettings != null)
{
lvitem.Font = new Font(lvitem.Font, FontStyle.Bold);
if (devSettings.HideFromList)
{
lvitem.Font = new Font(lvitem.Font, FontStyle.Italic);
}
}
listDevices.LargeImageList.Images.Add(dev.Value);
listDevices.Items.Add(lvitem);
cnt++;
}
pictureModded.Image = new Bitmap(Properties.Resources._66_100_highDPI);
var OSDskins = Directory.GetDirectories(Program.Root + "Skins");
foreach (var skinDir in OSDskins)
{
comboOSDSkin.Items.Add(skinDir.Substring(skinDir.LastIndexOf('\\') + 1));
}
comboOSDSkin.Text = Program.settings.OSD.Skin;
trackTransparency.Value = Program.settings.OSD.Transparency;
comboDefMode.Items.Add("Playback");
comboDefMode.Items.Add("Recording");
comboDefMode.Text = Program.settings.DefaultDataFlow == EDataFlow.eCapture ? "Recording" : "Playback";
checkDefaultMultiAndComm.Checked = Program.settings.DefaultMultimediaAndComm;
checkColorVU.Checked = Program.settings.ColorVU;
checkVolScroll.Checked = Program.settings.VolumeScroll.Enabled;
comboScrollKey.Text = Program.settings.VolumeScroll.Key.ToString();
checkScrShowOSD.Checked = Program.settings.VolumeScroll.ShowOSD;
checkCustomOSD.Checked = Program.settings.UseCustomOSD;
checkShowHWName.Checked = Program.settings.ShowHardwareName;
radioQuickSwitch.Checked = Program.settings.QuickSwitchEnabled;
radioAlwaysMenu.Checked = !radioQuickSwitch.Checked;
checkQSShowOSD.Enabled = radioQuickSwitch.Checked;
checkQSShowOSD.Checked = Program.settings.QuickSwitchShowOSD;
gridHotkeys.CellEndEdit += gridHotkeys_CellEndEdit;
gridHotkeys.RowsAdded += gridHotkeys_RowsAdded;
gridHotkeys.RowsRemoved += gridHotkeys_RowsRemoved;
}
public NetworkHeartbeat(IEnumerable <IPAddress> hosts, int pingTimeout, int heartbeatDelay)
{
PingTimeout = pingTimeout;
HeartbeatDelay = heartbeatDelay;
EndPoints = hosts.ToArray();
PingResults = new PingReply[EndPoints.Length];
Pings = EndPoints.Select(h => new Ping()).ToArray();
}
public Configuration()
{
if (!File.Exists(FileName))
{
// Discord
EndPoints.Add(new Endpoint());
}
}
public async ValueTask <IEnumerable <UserMessage> > GetAllAsync(long roomId, bool isForceMode = false)
{
// TODO QueryAsync + data is error
// single arg is invalid ?
var uri = $"{EndPoints.RoomMessages(roomId)}?force={URLArgEncoder.BoolToInt(isForceMode).ToString()}";
return(await this.chatworkClient.QueryAsync <List <UserMessage> >(new Uri(uri), HttpMethod.Get, new Dictionary <string, string>()));
}
//https://api.happynodes.f27.ventures/redis/endpoints
public async Task <EndPoints> GetEndPoints()
{
var result = await _restClient.GetAsync(Endpoints).ConfigureAwait(false);
var data = await result.Content.ReadAsStringAsync();
return(EndPoints.FromJson(data));
}
// Add back in when https://github.com/aspnet/Caching updates to new StackExchange
//public bool HighPrioritySocketThreads { get; set; }
//public int ResponseTimeout { get; set; }
//public int? DefaultDatabase { get; set; }
public override string ToString()
{
if (!string.IsNullOrEmpty(ConnectionString))
{
return(ConnectionString);
}
StringBuilder sb = new StringBuilder();
if (!string.IsNullOrEmpty(this.EndPoints))
{
string endpoints = EndPoints.Trim();
sb.Append(endpoints);
sb.Append(',');
}
else
{
sb.Append(this.Host + ":" + this.Port);
sb.Append(',');
}
AddKeyValue(sb, "password", this.Password);
AddKeyValue(sb, "allowAdmin", this.AllowAdmin);
AddKeyValue(sb, "name", this.ClientName);
if (this.ConnectRetry > 0)
{
AddKeyValue(sb, "connectRetry", this.ConnectRetry);
}
if (this.ConnectTimeout > 0)
{
AddKeyValue(sb, "connectTimeout", this.ConnectTimeout);
}
AddKeyValue(sb, "abortConnect", this.AbortOnConnectFail);
if (this.KeepAlive > 0)
{
AddKeyValue(sb, "keepAlive", this.KeepAlive);
}
AddKeyValue(sb, "resolveDns", this.ResolveDns);
AddKeyValue(sb, "serviceName", this.ServiceName);
AddKeyValue(sb, "ssl", this.Ssl);
AddKeyValue(sb, "sslHost", this.SslHost);
AddKeyValue(sb, "tiebreaker", this.TieBreaker);
if (this.WriteBuffer > 0)
{
AddKeyValue(sb, "writeBuffer", this.WriteBuffer);
}
// Trim ending ','
sb.Remove(sb.Length - 1, 1);
return(sb.ToString());
}
/// <summary>
/// Loads the specified settings, overwriting existing settings.
/// </summary>
/// <param name="updatedEndPointsResult"></param>
/// this <see cref="RemoteHostPool"/>.
/// <exception cref="ArgumentNullException">Thrown when </exception>
/// <exception cref="EnvironmentException"></exception>
private void ReloadEndpoints(EndPointsResult updatedEndPointsResult)
{
lock (_lock)
{
try
{
var updatedEndPoints = updatedEndPointsResult.EndPoints;
if (updatedEndPoints.Any() == false)
{
Health.SetHealthFunction(() =>
{
var config = GetConfig();
if (IsHealthCheckSuppressed(config))
{
return(HealthCheckResult.Healthy($"No endpoints were discovered from source '{config.Source}' but the remote service was not in use for more than {config.SuppressHealthCheckAfterServiceUnused?.TotalSeconds} seconds."));
}
else
{
return(HealthCheckResult.Unhealthy($"No endpoints were discovered from source '{config.Source}'."));
}
});
EndPointsResult = updatedEndPointsResult;
ReachableHosts = new List <RemoteHost>();
UnreachableHosts = new List <RemoteHost>();
}
else
{
if (EndPoints != null)
{
foreach (var removedEndPoint in EndPoints.Except(updatedEndPoints))
{
ReachableHosts.SingleOrDefault(h => h.Equals(removedEndPoint))?.StopMonitoring();
ReachableHosts.RemoveAll(h => h.Equals(removedEndPoint));
UnreachableHosts.RemoveAll(h => h.Equals(removedEndPoint));
}
}
var newHosts = updatedEndPoints
.Except(EndPoints ?? Enumerable.Empty <EndPoint>())
.Select(ep => new RemoteHost(ep.HostName, this, _lock, ep.Port));
ReachableHosts.AddRange(newHosts);
EndPointsResult = updatedEndPointsResult;
Counter = (ulong)_random.Next(0, ReachableHosts.Count);
Health.SetHealthFunction(CheckHealth);
}
}
catch (Exception ex)
{
Log.Warn("Failed to process newly discovered endpoints", exception: ex);
Health.SetHealthFunction(() => HealthCheckResult.Unhealthy("Failed to process newly discovered endpoints: " + HealthMonitor.GetMessages(ex)));
}
}
}
private void QuickSwitchDevice(bool previous, EDataFlow rType, bool showOSD)
{
var devName = previous ? EndPoints.SetPrevDefault(rType) : EndPoints.SetNextDefault(rType);
if (showOSD)
{
Program.frmOSD.ChangeDevice(devName);
}
}
public LightsService(
IOptions <EndPoints> options,
INetworkDiscoveryService networkDiscoveryService,
Helpers.Elgato.IElgatoService elgatoService)
{
_endPoints = options.Value;
_networkDiscoveryService = networkDiscoveryService;
_elgatoService = elgatoService;
}
public IEnumerator Movement()
{
foreach (var obj in endPoints)
{
tempEndpoint = obj;
transform.DOLocalMove(obj.EndPoint, obj.endTime, false).SetEase(Ease.Linear);
yield return(new WaitForSeconds(obj.endTime));
}
}
public static string Converter(EndPoints endpoint)
{
var Url = "";
switch (endpoint)
{
case EndPoints.Users:
Url = "users/";
break;
case EndPoints.Roles:
Url = "roles/";
break;
case EndPoints.Teams:
Url = "teams/";
break;
case EndPoints.Customers:
Url = "customers/";
break;
case EndPoints.BusinessUnits:
Url = "businessunits/";
break;
case EndPoints.Projects:
Url = "projects/";
break;
case EndPoints.ProjectPhase:
Url = "projects/{0}/projectPhase/";
break;
case EndPoints.ProjectTypes:
Url = "projectTypes/";
break;
case EndPoints.ProjectPeopleResources:
Url = "projects/{0}/projectResources/";
break;
case EndPoints.CostTypes:
Url = "projects/{0}/costTypes/";
break;
case EndPoints.UserStories:
Url = "projects/{0}/userStories/";
break;
case EndPoints.UserStoryTypes:
Url = "userStoryTypes/";
break;
case EndPoints.Sprints:
Url = "projects/{0}/sprints/";
break;
case EndPoints.Tasks:
Url = "projects/{0}/tasks/";
break;
case EndPoints.TimeTrackingRegistration:
Url = "projects/{0}/time/";
break;
case EndPoints.ScrumStages:
Url = "projects/{0}/scrumStages/";
break;
case EndPoints.Tags:
Url = "tags/";
break;
case EndPoints.FileAttachments:
throw new NotImplementedException("FileAttachments at this moment isn't implemented for API Calls yet");
case EndPoints.Milestones:
throw new NotImplementedException("Milestones at this moment isn't implemented for API Calls yet");
case EndPoints.Versions:
throw new NotImplementedException("Milestones at this moment isn't implemented for API Calls yet");
default:
throw new ArgumentException("Apicall hasn't been set to anything, this is your Fault");
}
return Url;
}
