async void BtnNext_Click(object sender, RoutedEventArgs e)
{
var supportsPin = true;
if (supportsPin)
{
await _nav.Navigate(new StartupWizardPage2(_nav, _connectionManager, _presentation, _logger));
}
else
{
Dispatcher.InvokeAsync(() => _presentation.ShowModalLoadingAnimation());
try
{
var connectionResult = await _connectionManager.Connect(CancellationToken.None);
Dispatcher.InvokeAsync(() => _presentation.HideModalLoadingAnimation());
if (connectionResult.State == ConnectionState.Unavailable)
{
await _nav.Navigate(new StartupPageServerEntry(_nav, _connectionManager, _presentation, _logger));
}
else
{
App.Instance.NavigateFromConnectionResult(connectionResult);
}
}
catch (Exception)
{
Dispatcher.InvokeAsync(() => _presentation.HideModalLoadingAnimation());
}
}
}
private async Task SyncInternal(ServerInfo server, bool enableCameraUpload, IProgress <double> progress, CancellationToken cancellationToken)
{
_logger.Debug("Beginning ServerSync with server {0}, Id {1}", server.Name, server.Id);
if (string.IsNullOrWhiteSpace(server.AccessToken) && string.IsNullOrWhiteSpace(server.ExchangeToken))
{
_logger.Info("Skipping sync process for server " + server.Name + ". No server authentication information available.");
progress.Report(100);
return;
}
// Don't need these here
var result = await _connectionManager.Connect(server, new ConnectionOptions
{
EnableWebSocket = false,
ReportCapabilities = false,
UpdateDateLastAccessed = false
}, cancellationToken).ConfigureAwait(false);
if (result.State == ConnectionState.SignedIn)
{
await SyncInternal(server, result.ApiClient, enableCameraUpload, progress, cancellationToken).ConfigureAwait(false);
progress.Report(100);
}
else
{
_logger.Info("Skipping sync process for server " + server.Name + ". ConnectionManager returned a state of {0}", result.State.ToString());
progress.Report(100);
}
}
private async void GoNext()
{
StopPinTimer();
_presentation.ShowModalLoadingAnimation();
try
{
var connectionResult = await _connectionManager.Connect(CancellationToken.None);
_presentation.HideModalLoadingAnimation();
if (connectionResult.State == ConnectionState.Unavailable)
{
connectionResult.State = ConnectionState.ServerSelection;
}
App.Instance.NavigateFromConnectionResult(connectionResult);
return;
}
catch (Exception)
{
_presentation.HideModalLoadingAnimation();
}
await _nav.Navigate(new StartupPageServerEntry(_nav, _connectionManager, _presentation, _logger));
}
public async Task Sync(ServerInfo server, IProgress <double> progress, CancellationToken cancellationToken)
{
if (string.IsNullOrWhiteSpace(server.AccessToken) && string.IsNullOrWhiteSpace(server.ExchangeToken))
{
LogNoAuthentication(server);
progress.Report(100);
return;
}
// Don't need these here
var result = await _connectionManager.Connect(server, new ConnectionOptions
{
EnableWebSocket = false,
ReportCapabilities = false
}, cancellationToken).ConfigureAwait(false);
if (result.State == ConnectionState.SignedIn)
{
await SyncInternal(server, result.ApiClient, progress, cancellationToken).ConfigureAwait(false);
progress.Report(100);
}
else
{
LogNoAuthentication(server);
progress.Report(100);
}
}
async void BtnNext_Click(object sender, RoutedEventArgs e)
{
if (ValidateInput())
{
var serverAddress = string.Format("http://{0}", TxtHost.Text);
if (!string.IsNullOrEmpty(TxtPort.Text))
{
serverAddress += ":" + TxtPort.Text;
}
try
{
var connectionResult = await _connectionManager.Connect(serverAddress, CancellationToken.None);
if (connectionResult.State == ConnectionState.Unavailable)
{
ShowUnavailableMessage();
return;
}
App.Instance.NavigateFromConnectionResult(connectionResult);
}
catch (Exception)
{
ShowUnavailableMessage();
}
}
}
/// <summary>
/// Get search list
/// </summary>
/// <param name="inputObjects">This is the dictionary of arraylists of
/// business object transactions specified by the caller. This typically hails
/// from the web service or page class and simply passed from one object in the
/// chain to another until it is referenced here.</param>
/// <param name="globals">This is a dictionary where the keys are intended to hold globally
/// unique values used to establish relationships between collections of business object
/// transactions in the inputObjects dictionary. The objects corresponding to each key
/// are intended to be a instance of the KeyResolver class.</param>
/// <param name="prototype">search object</param>
/// <returns>List of search</returns>
public List <Isearch> Getsearch(IDictionary <object, object> inputObjects, IDictionary <object, object> globals, Isearch prototype)
{
IDictionary <object, object> workingObjects = new Dictionary <object, object>();
try
{
_cm.Init(base.Env, base.Server);
_cm.Connect(DBEntity.PMC, base.PmcID, base.SiteID, base.UserID);
_dao.CM = _cm;
RPComponents.IBusinessObjectTransaction bot = new RPComponents.BusinessObjectTransaction();
IList <RPComponents.IBusinessObjectTransaction> bots = new List <RPComponents.IBusinessObjectTransaction>();
bot.BusinessObject = prototype;
bot.RequestType = undefinedDAO.RequestTypes.search;
bot.Action = new RPComponents.Action(RPComponents.Action.Select);
bots.Add(bot);
_dao.ProcessTransactions(inputObjects, workingObjects, globals, bots);
}
finally
{
_cm.Disconnect();
}
List <Isearch> list = (List <Isearch>)workingObjects[undefinedDAO.WorkingTypes.search];
return(list);
}
private IConnectionManager GetConnectionMangerWithUnavailableBehavior()
{
TargetInfo fakeTargetInfo = ProbeHelper.CreateFakeTarget();
IList <IConnectionProvider> fakeContext = ProbeHelper.CreateFakeContext();
string errorMessage = string.Format("Error connecting to {0}", fakeTargetInfo.GetAddress());
MockRepository mock = new MockRepository();
IConnectionManager connectionManagerWithInvalidCredentials = mock.DynamicMock <IConnectionManager>();
Expect.Call(connectionManagerWithInvalidCredentials.Connect <RegistryConnectionProvider>(fakeContext, fakeTargetInfo))
.IgnoreArguments().Throw(new CannotConnectToHostException(fakeTargetInfo, errorMessage));
mock.ReplayAll();
return(connectionManagerWithInvalidCredentials);
}
private IConnection EnsureConnection([NotNull] Session childSession)
{
var existsConnection = childSession.TryGetEntry <IConnection>();
if (existsConnection != null)
{
return(existsConnection);
}
var connection = _connectionManager.Connect();
childSession.Include(connection);
return(connection);
}
public void Execute(IConnectionManager connection, ICommand command)
{
INetwork network;
if (command.Network == null)
{
//if the network infomation is not set explicitly
//parse it out, when calling the command as
//a client command /server then this will be the
//case.
string uri = command.Arguments[0];
string protocol = "irc://";
if (!uri.StartsWith(protocol))
{
uri = protocol + uri;
}
Uri networkUrl = new Uri(uri);
if (networkUrl.Port < 0)
{
uri += ":6667";
}
network = new Network
{
Url = new Uri(uri),
LocalUser = new User(command.User),
};
}
else
{
network = command.Network;
}
connection.Connect(network, command.User);
}
private async Task Sync(List <ServerInfo> servers, List <string> cameraUploadServers, bool syncOnlyOnLocalNetwork, IProgress <double> progress, CancellationToken cancellationToken = default(CancellationToken))
{
var numComplete = 0;
double startingPercent = 0;
double percentPerServer = 1;
if (servers.Count > 0)
{
percentPerServer /= servers.Count;
}
_logger.Debug("Beginning MultiServerSync with {0} servers", servers.Count);
foreach (var server in servers)
{
cancellationToken.ThrowIfCancellationRequested();
var currentPercent = startingPercent;
var serverProgress = new DoubleProgress();
serverProgress.RegisterAction(pct =>
{
var totalProgress = pct * percentPerServer;
totalProgress += currentPercent;
progress.Report(totalProgress);
});
// Grab the latest info from the connection manager about that server
var serverInfo = await _connectionManager.GetServerInfo(server.Id).ConfigureAwait(false);
if (serverInfo == null)
{
serverInfo = server;
}
if (syncOnlyOnLocalNetwork)
{
var result = await _connectionManager.Connect(server, new ConnectionOptions
{
EnableWebSocket = false,
ReportCapabilities = false,
UpdateDateLastAccessed = false
}, cancellationToken).ConfigureAwait(false);
var apiClient = result.ApiClient;
var endpointInfo = await apiClient.GetEndPointInfo(cancellationToken).ConfigureAwait(false);
_logger.Debug("Server: {0}, Id: {1}, IsInNetwork:{2}", server.Name, server.Id, endpointInfo.IsInNetwork);
if (!endpointInfo.IsInNetwork)
{
continue;
}
}
var enableCameraUpload = cameraUploadServers.Contains(serverInfo.Id, StringComparer.OrdinalIgnoreCase);
await new ServerSync(_connectionManager, _logger, _localAssetManager, _fileTransferManager, _connectionManager.ClientCapabilities)
.Sync(serverInfo, enableCameraUpload, serverProgress, cancellationToken).ConfigureAwait(false);
numComplete++;
startingPercent = numComplete;
startingPercent /= servers.Count;
startingPercent *= 100;
progress.Report(startingPercent);
}
progress.Report(100);
}
public async Task Run(CancellationToken token)
{
var hubConnection = await _connectionManager.Connect();
var telemetry = new rF2Telemetry();
var scoring = new rF2Scoring();
var playerScoring = new rF2VehicleScoring();
var playerTelemetry = new rF2VehicleTelemetry();
while (true)
{
await Task.Delay(200);
try
{
_scoringBuffer.GetMappedDataPartial(ref scoring);
_telemetryBuffer.GetMappedDataPartial(ref telemetry);
}
catch (Exception)
{
await _connectionManager.Disconnect(hubConnection);
return;
}
if (telemetry.mNumVehicles != 0 && scoring.mScoringInfo.mNumVehicles != 0 && (rFactor2Constants.rF2GamePhase)scoring.mScoringInfo.mGamePhase == rFactor2Constants.rF2GamePhase.GreenFlag)
{
var mappedIds = MapmIdToPositionInArray(ref telemetry);
foreach (var scoringVehicle in scoring.mVehicles)
{
switch ((rFactor2Constants.rF2Control)scoringVehicle.mControl)
{
case rFactor2Constants.rF2Control.AI:
case rFactor2Constants.rF2Control.Player:
case rFactor2Constants.rF2Control.Remote:
if (scoringVehicle.mIsPlayer == 1)
{
playerScoring = scoringVehicle;
}
break;
default:
continue;
}
if (playerScoring.mIsPlayer == 1)
{
break;
}
}
var playerTelemetryId = -1;
if (mappedIds.TryGetValue(playerScoring.mID, out playerTelemetryId))
{
playerTelemetry = telemetry.mVehicles[playerTelemetryId];
}
else
{
continue;
}
var telemetryToSend = new Test
{
Telemetry = new Telemetry(ref playerTelemetry)
};
await hubConnection.SendAsync("Send", telemetryToSend);
}
}
}
public override async Task StartAsync(CancellationToken cancellationToken)
{
_logger.LogInformation($"Worker started at: {DateTime.Now}");
_mqManager.Connect();
await base.StartAsync(cancellationToken);
}
private void Join(object sender, RoutedEventArgs e)
{
connection.Connect(SessionId, session.CurrentUser);
}
public void Connect(string url)
{
m_connectionManager.Connect(url);
}
private void OpenConnection(TargetInfo target)
{
IList <IConnectionProvider> connectionContext = new List <IConnectionProvider>();
this.connectionProvider = connectionManager.Connect <WindowsSystemInformationConnectionProvider>(connectionContext, target);
}
