/// <summary> /// Processes the dataset request and returns a collection of distribution plans. /// </summary> /// <param name="activationRequest"> /// The request that describes the characteristics of the dataset that /// should be loaded. /// </param> /// <param name="token">The cancellation token that can be used to terminate the proposal.</param> /// <returns> /// The collection containing all the distribution plans. /// </returns> public IEnumerable <DistributionPlan> ProposeDistributionFor(DatasetActivationRequest activationRequest, CancellationToken token) { var availableEndpoints = new List <Tuple <EndpointId, IDatasetActivationCommands> >(); lock (m_Lock) { foreach (var pair in m_ActivatorCommands) { availableEndpoints.Add(new Tuple <EndpointId, IDatasetActivationCommands>(pair.Key, pair.Value)); } } using (m_Diagnostics.Profiler.Measure(BaseConstants.TimingGroup, "Generating remote proposal")) { var proposals = RetrieveProposals(availableEndpoints, m_Configuration, activationRequest, token); return(proposals .Select( p => { return new DistributionPlan( ImplementPlan, activationRequest.DatasetToActivate, new NetworkIdentifier(p.Endpoint.OriginatesOnMachine()), p); }) .ToList()); } }
private static IEnumerable <DatasetActivationProposal> RetrieveProposals( IEnumerable <Tuple <EndpointId, IDatasetActivationCommands> > availableEndpoints, IConfiguration configuration, DatasetActivationRequest activationRequest, CancellationToken token) { var usableNodes = DetermineUsableEndpoints(availableEndpoints, configuration); var orderedProposals = OrderProposals(activationRequest.ExpectedLoadPerMachine, activationRequest.PreferredLocations, usableNodes, token); return(orderedProposals); }
/// <summary> /// Processes the dataset request and returns a collection of distribution plans. /// </summary> /// <param name="activationRequest"> /// The request that describes the characteristics of the dataset that /// should be loaded. /// </param> /// <param name="token">The cancellation token that can be used to terminate the proposal.</param> /// <returns> /// The collection containing all the distribution plans. /// </returns> public IEnumerable <DistributionPlan> ProposeDistributionFor(DatasetActivationRequest activationRequest, CancellationToken token) { using (m_Diagnostics.Profiler.Measure(BaseConstants.TimingGroup, "Generating local proposal")) { var proposal = m_LocalDistributor.ProposeForLocalMachine(activationRequest.ExpectedLoadPerMachine); var plan = new DistributionPlan( ImplementPlan, activationRequest.DatasetToActivate, new NetworkIdentifier(proposal.Endpoint.OriginatesOnMachine()), proposal); return(new[] { plan }); } }
/// <summary> /// Processes the dataset request and creates a distribution plan /// which can then be accepted by the user. /// </summary> /// <param name="activationRequest"> /// The request that describes the characteristics of the dataset that /// should be loaded. /// </param> /// <param name="token">The cancellation token that can be used to terminate the proposal.</param> /// <returns> /// The distribution plan that takes into account the characteristics of /// the dataset and the currently available computing power. /// </returns> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="activationRequest"/> is <see langword="null" />. /// </exception> public IEnumerable <DistributionPlan> ProposeDistributionFor(DatasetActivationRequest activationRequest, CancellationToken token) { { Enforce.Argument(() => activationRequest); } foreach (var distributor in m_Distributors) { if (token.IsCancellationRequested) { token.ThrowIfCancellationRequested(); } var proposals = distributor.ProposeDistributionFor(activationRequest, token); foreach (var proposal in proposals) { yield return(proposal); } } }
/// <summary> /// Processes the dataset request and creates a distribution plan /// which can then be accepted by the user. /// </summary> /// <param name="activationRequest"> /// The request that describes the characteristics of the dataset that /// should be loaded. /// </param> /// <param name="token">The cancellation token that can be used to terminate the proposal.</param> /// <returns> /// The distribution plan that takes into account the characteristics of /// the dataset and the currently available computing power. /// </returns> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="activationRequest"/> is <see langword="null" />. /// </exception> public IEnumerable<DistributionPlan> ProposeDistributionFor(DatasetActivationRequest activationRequest, CancellationToken token) { { Enforce.Argument(() => activationRequest); } foreach (var distributor in m_Distributors) { if (token.IsCancellationRequested) { token.ThrowIfCancellationRequested(); } var proposals = distributor.ProposeDistributionFor(activationRequest, token); foreach (var proposal in proposals) { yield return proposal; } } }
public void ProposeDistributionFor() { var systemDiagnostics = new SystemDiagnostics((p, s) => { }, null); var offlineInfo = CreateOfflineInfo(new Mock <IPersistenceInformation>().Object); var result = new DatasetActivationProposal { Endpoint = EndpointIdExtensions.CreateEndpointIdForCurrentProcess(), IsAvailable = true, ActivationTime = new TimeSpan(0, 1, 0), TransferTime = new TimeSpan(0, 1, 0), PercentageOfAvailableDisk = 50, PercentageOfMaximumMemory = 50, PercentageOfPhysicalMemory = 50, }; var localDistributor = new Mock <ICalculateDistributionParameters>(); { localDistributor.Setup(l => l.ProposeForLocalMachine(It.IsAny <ExpectedDatasetLoad>())) .Returns(result); } var communicationLayer = new Mock <ICommunicationLayer>(); { communicationLayer.Setup(s => s.LocalConnectionFor(It.Is <ChannelType>(c => c == ChannelType.NamedPipe))) .Returns( new Tuple <EndpointId, Uri, Uri>( EndpointIdExtensions.CreateEndpointIdForCurrentProcess(), new Uri("net.pipe://localhost/pipe"), new Uri("net.pipe://localhost/pipe/data"))); } var loader = new Mock <IDatasetActivator>(); var commandHub = new Mock <ISendCommandsToRemoteEndpoints>(); var notificationHub = new Mock <INotifyOfRemoteEndpointEvents>(); var uploads = new Mock <IStoreUploads>(); var distributor = new LocalDatasetDistributor( localDistributor.Object, loader.Object, commandHub.Object, notificationHub.Object, uploads.Object, (d, e, n) => { return(new DatasetOnlineInformation( d, e, n, commandHub.Object, notificationHub.Object, systemDiagnostics)); }, communicationLayer.Object, systemDiagnostics, new CurrentThreadTaskScheduler()); var request = new DatasetActivationRequest { DatasetToActivate = offlineInfo, ExpectedLoadPerMachine = new ExpectedDatasetLoad(), PreferredLocations = DistributionLocations.All, }; var plans = distributor.ProposeDistributionFor(request, new CancellationToken()); Assert.AreEqual(1, plans.Count()); var plan = plans.First(); Assert.IsTrue(ReferenceEquals(offlineInfo, plan.DistributionFor)); Assert.AreEqual(new NetworkIdentifier(result.Endpoint.OriginatesOnMachine()), plan.MachineToDistributeTo); Assert.IsTrue(ReferenceEquals(result, plan.Proposal)); }
public void ProposeDistributionFor() { var systemDiagnostics = new SystemDiagnostics((p, s) => { }, null); var offlineInfo = CreateOfflineInfo(new Mock<IPersistenceInformation>().Object); var result = new DatasetActivationProposal { Endpoint = EndpointIdExtensions.CreateEndpointIdForCurrentProcess(), IsAvailable = true, ActivationTime = new TimeSpan(0, 1, 0), TransferTime = new TimeSpan(0, 1, 0), PercentageOfAvailableDisk = 50, PercentageOfMaximumMemory = 50, PercentageOfPhysicalMemory = 50, }; var loaderCommands = new Mock<IDatasetActivationCommands>(); { loaderCommands.Setup(l => l.ProposeFor(It.IsAny<ExpectedDatasetLoad>())) .Returns( Task.Factory.StartNew( () => result, new CancellationToken(), TaskCreationOptions.None, new CurrentThreadTaskScheduler())) .Verifiable(); } var commandHub = new Mock<ISendCommandsToRemoteEndpoints>(); { commandHub.Setup(h => h.CommandsFor<IDatasetActivationCommands>(It.IsAny<EndpointId>())) .Returns(loaderCommands.Object); } var notificationHub = new Mock<INotifyOfRemoteEndpointEvents>(); var offlimitsMachines = new SortedList<string, object> { { "someKeyStuff", "otherMachine" } }; var config = new Mock<IConfiguration>(); { config.Setup(c => c.HasValueFor(It.IsAny<ConfigurationKey>())) .Returns(true); config.Setup(c => c.Value<IDictionary<string, object>>(It.IsAny<ConfigurationKey>())) .Returns(offlimitsMachines); } var communicationLayer = new Mock<ICommunicationLayer>(); { communicationLayer.Setup(s => s.LocalConnectionFor(It.Is<ChannelType>(c => c == ChannelType.TcpIP))) .Returns( new Tuple<EndpointId, Uri, Uri>( EndpointIdExtensions.CreateEndpointIdForCurrentProcess(), new Uri("net.tcp://localhost/tcp"), new Uri("net.tcp://localhost/tcp/data"))); } var distributor = new RemoteDatasetDistributor( config.Object, commandHub.Object, notificationHub.Object, new Mock<IStoreUploads>().Object, (d, e, n) => new DatasetOnlineInformation( d, e, n, commandHub.Object, notificationHub.Object, systemDiagnostics), communicationLayer.Object, systemDiagnostics, new CurrentThreadTaskScheduler()); // Add the remote endpoints var forbiddenMachineId = new EndpointId("otherMachine:8080"); commandHub.Raise( h => h.OnEndpointSignedIn += null, new CommandSetAvailabilityEventArgs( forbiddenMachineId, new[] { typeof(IDatasetActivationCommands) })); var legalMachineId = new EndpointId("myMachine:8080"); commandHub.Raise( h => h.OnEndpointSignedIn += null, new CommandSetAvailabilityEventArgs( legalMachineId, new[] { typeof(IDatasetActivationCommands) })); var request = new DatasetActivationRequest { DatasetToActivate = offlineInfo, ExpectedLoadPerMachine = new ExpectedDatasetLoad(), PreferredLocations = DistributionLocations.All, }; var plans = distributor.ProposeDistributionFor(request, new CancellationToken()); var listPlans = plans.ToList(); Assert.AreEqual(1, listPlans.Count()); var plan = listPlans[0]; Assert.IsTrue(ReferenceEquals(offlineInfo, plan.DistributionFor)); Assert.AreEqual(new NetworkIdentifier(result.Endpoint.OriginatesOnMachine()), plan.MachineToDistributeTo); Assert.IsTrue(ReferenceEquals(result, plan.Proposal)); loaderCommands.Verify(l => l.ProposeFor(It.IsAny<ExpectedDatasetLoad>()), Times.Once()); }
/// <summary> /// Processes the dataset request and returns a collection of distribution plans. /// </summary> /// <param name="activationRequest"> /// The request that describes the characteristics of the dataset that /// should be loaded. /// </param> /// <param name="token">The cancellation token that can be used to terminate the proposal.</param> /// <returns> /// The collection containing all the distribution plans. /// </returns> public IEnumerable<DistributionPlan> ProposeDistributionFor(DatasetActivationRequest activationRequest, CancellationToken token) { using (m_Diagnostics.Profiler.Measure(BaseConstants.TimingGroup, "Generating local proposal")) { var proposal = m_LocalDistributor.ProposeForLocalMachine(activationRequest.ExpectedLoadPerMachine); var plan = new DistributionPlan( ImplementPlan, activationRequest.DatasetToActivate, new NetworkIdentifier(proposal.Endpoint.OriginatesOnMachine()), proposal); return new[] { plan }; } }
public void ProposeDistributionFor() { var systemDiagnostics = new SystemDiagnostics((p, s) => { }, null); var offlineInfo = CreateOfflineInfo(new Mock<IPersistenceInformation>().Object); var result = new DatasetActivationProposal { Endpoint = EndpointIdExtensions.CreateEndpointIdForCurrentProcess(), IsAvailable = true, ActivationTime = new TimeSpan(0, 1, 0), TransferTime = new TimeSpan(0, 1, 0), PercentageOfAvailableDisk = 50, PercentageOfMaximumMemory = 50, PercentageOfPhysicalMemory = 50, }; var localDistributor = new Mock<ICalculateDistributionParameters>(); { localDistributor.Setup(l => l.ProposeForLocalMachine(It.IsAny<ExpectedDatasetLoad>())) .Returns(result); } var communicationLayer = new Mock<ICommunicationLayer>(); { communicationLayer.Setup(s => s.LocalConnectionFor(It.Is<ChannelType>(c => c == ChannelType.NamedPipe))) .Returns( new Tuple<EndpointId, Uri, Uri>( EndpointIdExtensions.CreateEndpointIdForCurrentProcess(), new Uri("net.pipe://localhost/pipe"), new Uri("net.pipe://localhost/pipe/data"))); } var loader = new Mock<IDatasetActivator>(); var commandHub = new Mock<ISendCommandsToRemoteEndpoints>(); var notificationHub = new Mock<INotifyOfRemoteEndpointEvents>(); var uploads = new Mock<IStoreUploads>(); var distributor = new LocalDatasetDistributor( localDistributor.Object, loader.Object, commandHub.Object, notificationHub.Object, uploads.Object, (d, e, n) => { return new DatasetOnlineInformation( d, e, n, commandHub.Object, notificationHub.Object, systemDiagnostics); }, communicationLayer.Object, systemDiagnostics, new CurrentThreadTaskScheduler()); var request = new DatasetActivationRequest { DatasetToActivate = offlineInfo, ExpectedLoadPerMachine = new ExpectedDatasetLoad(), PreferredLocations = DistributionLocations.All, }; var plans = distributor.ProposeDistributionFor(request, new CancellationToken()); Assert.AreEqual(1, plans.Count()); var plan = plans.First(); Assert.IsTrue(ReferenceEquals(offlineInfo, plan.DistributionFor)); Assert.AreEqual(new NetworkIdentifier(result.Endpoint.OriginatesOnMachine()), plan.MachineToDistributeTo); Assert.IsTrue(ReferenceEquals(result, plan.Proposal)); }
private static IEnumerable<DatasetActivationProposal> RetrieveProposals( IEnumerable<Tuple<EndpointId, IDatasetActivationCommands>> availableEndpoints, IConfiguration configuration, DatasetActivationRequest activationRequest, CancellationToken token) { var usableNodes = DetermineUsableEndpoints(availableEndpoints, configuration); var orderedProposals = OrderProposals(activationRequest.ExpectedLoadPerMachine, activationRequest.PreferredLocations, usableNodes, token); return orderedProposals; }
/// <summary> /// Processes the dataset request and returns a collection of distribution plans. /// </summary> /// <param name="activationRequest"> /// The request that describes the characteristics of the dataset that /// should be loaded. /// </param> /// <param name="token">The cancellation token that can be used to terminate the proposal.</param> /// <returns> /// The collection containing all the distribution plans. /// </returns> public IEnumerable<DistributionPlan> ProposeDistributionFor(DatasetActivationRequest activationRequest, CancellationToken token) { var availableEndpoints = new List<Tuple<EndpointId, IDatasetActivationCommands>>(); lock (m_Lock) { foreach (var pair in m_ActivatorCommands) { availableEndpoints.Add(new Tuple<EndpointId, IDatasetActivationCommands>(pair.Key, pair.Value)); } } using (m_Diagnostics.Profiler.Measure(BaseConstants.TimingGroup, "Generating remote proposal")) { var proposals = RetrieveProposals(availableEndpoints, m_Configuration, activationRequest, token); return proposals .Select( p => { return new DistributionPlan( ImplementPlan, activationRequest.DatasetToActivate, new NetworkIdentifier(p.Endpoint.OriginatesOnMachine()), p); }) .ToList(); } }
public void ProposeDistributionFor() { var systemDiagnostics = new SystemDiagnostics((p, s) => { }, null); var offlineInfo = CreateOfflineInfo(new Mock <IPersistenceInformation>().Object); var result = new DatasetActivationProposal { Endpoint = EndpointIdExtensions.CreateEndpointIdForCurrentProcess(), IsAvailable = true, ActivationTime = new TimeSpan(0, 1, 0), TransferTime = new TimeSpan(0, 1, 0), PercentageOfAvailableDisk = 50, PercentageOfMaximumMemory = 50, PercentageOfPhysicalMemory = 50, }; var loaderCommands = new Mock <IDatasetActivationCommands>(); { loaderCommands.Setup(l => l.ProposeFor(It.IsAny <ExpectedDatasetLoad>())) .Returns( Task.Factory.StartNew( () => result, new CancellationToken(), TaskCreationOptions.None, new CurrentThreadTaskScheduler())) .Verifiable(); } var commandHub = new Mock <ISendCommandsToRemoteEndpoints>(); { commandHub.Setup(h => h.CommandsFor <IDatasetActivationCommands>(It.IsAny <EndpointId>())) .Returns(loaderCommands.Object); } var notificationHub = new Mock <INotifyOfRemoteEndpointEvents>(); var offlimitsMachines = new SortedList <string, object> { { "someKeyStuff", "otherMachine" } }; var config = new Mock <IConfiguration>(); { config.Setup(c => c.HasValueFor(It.IsAny <ConfigurationKey>())) .Returns(true); config.Setup(c => c.Value <IDictionary <string, object> >(It.IsAny <ConfigurationKey>())) .Returns(offlimitsMachines); } var communicationLayer = new Mock <ICommunicationLayer>(); { communicationLayer.Setup(s => s.LocalConnectionFor(It.Is <ChannelType>(c => c == ChannelType.TcpIP))) .Returns( new Tuple <EndpointId, Uri, Uri>( EndpointIdExtensions.CreateEndpointIdForCurrentProcess(), new Uri("net.tcp://localhost/tcp"), new Uri("net.tcp://localhost/tcp/data"))); } var distributor = new RemoteDatasetDistributor( config.Object, commandHub.Object, notificationHub.Object, new Mock <IStoreUploads>().Object, (d, e, n) => new DatasetOnlineInformation( d, e, n, commandHub.Object, notificationHub.Object, systemDiagnostics), communicationLayer.Object, systemDiagnostics, new CurrentThreadTaskScheduler()); // Add the remote endpoints var forbiddenMachineId = new EndpointId("otherMachine:8080"); commandHub.Raise( h => h.OnEndpointSignedIn += null, new CommandSetAvailabilityEventArgs( forbiddenMachineId, new[] { typeof(IDatasetActivationCommands) })); var legalMachineId = new EndpointId("myMachine:8080"); commandHub.Raise( h => h.OnEndpointSignedIn += null, new CommandSetAvailabilityEventArgs( legalMachineId, new[] { typeof(IDatasetActivationCommands) })); var request = new DatasetActivationRequest { DatasetToActivate = offlineInfo, ExpectedLoadPerMachine = new ExpectedDatasetLoad(), PreferredLocations = DistributionLocations.All, }; var plans = distributor.ProposeDistributionFor(request, new CancellationToken()); var listPlans = plans.ToList(); Assert.AreEqual(1, listPlans.Count()); var plan = listPlans[0]; Assert.IsTrue(ReferenceEquals(offlineInfo, plan.DistributionFor)); Assert.AreEqual(new NetworkIdentifier(result.Endpoint.OriginatesOnMachine()), plan.MachineToDistributeTo); Assert.IsTrue(ReferenceEquals(result, plan.Proposal)); loaderCommands.Verify(l => l.ProposeFor(It.IsAny <ExpectedDatasetLoad>()), Times.Once()); }