public async Task CheckStaleIntervalTests()
{
var activityId = Guid.NewGuid().ToString();
var workerInfo = new MockWorkerInfo();
var settings = new ScaleSettings
{
StaleWorkerCheckInterval = TimeSpan.FromMilliseconds(500)
};
using (var scaleManager = new MockScaleManager(MockBehavior.Strict, settings))
{
// Setup
scaleManager.MockWorkerTable.Setup(t => t.List())
.Returns(Task.FromResult(Enumerable.Empty <IWorkerInfo>()));
scaleManager.MockScaleTracer.Setup(t => t.TraceInformation(activityId, workerInfo, It.IsAny <string>()));
// Test
for (int i = 0; i < 10; ++i)
{
await scaleManager.MockCheckStaleWorker(activityId, workerInfo);
await Task.Delay(100);
}
// Assert
scaleManager.MockWorkerTable.Verify(t => t.List(), Times.AtLeast(1));
scaleManager.MockWorkerTable.Verify(t => t.List(), Times.AtMost(4));
}
}
public async Task BasicTests(int maxWorkers, IWorkerInfo manager, IEnumerable <IWorkerInfo> workers, IEnumerable <IWorkerInfo> toRemoves)
{
var activityId = Guid.NewGuid().ToString();
var settings = new ScaleSettings {
MaxWorkers = maxWorkers
};
var mockManager = new Mock <MockScaleManager>(MockBehavior.Default, MockBehavior.Strict, settings)
{
CallBase = true
};
// Test
using (var scaleManager = mockManager.Object)
{
// Setup
if (toRemoves.Any())
{
scaleManager.MockScaleTracer.Setup(t => t.TraceInformation(activityId, manager, It.Is <string>(s => s.Contains("exceeds maximum number"))));
}
foreach (var toRemove in toRemoves)
{
mockManager.Setup(m => m.MockRequestRemoveWorker(activityId, manager, toRemove))
.Returns(Task.CompletedTask);
}
// test
var actual = await scaleManager.MockTryRemoveIfMaxWorkers(activityId, workers, manager);
// assert
mockManager.VerifyAll();
scaleManager.VerifyAll();
Assert.Equal(toRemoves.Any(), actual);
}
}
public async Task BasicTests(IWorkerInfo manager, IEnumerable <IWorkerInfo> workers, IWorkerInfo loadFactorMinWorker)
{
var activityId = Guid.NewGuid().ToString();
var settings = new ScaleSettings {
MaxWorkers = 2
};
var mockManager = new Mock <MockScaleManager>(MockBehavior.Default, MockBehavior.Strict, settings)
{
CallBase = true
};
// Test
using (var scaleManager = mockManager.Object)
{
// Setup
if (loadFactorMinWorker != null)
{
scaleManager.MockScaleTracer.Setup(t => t.TraceInformation(activityId, loadFactorMinWorker, It.Is <string>(s => s.Contains("have int.MinValue loadfactor"))));
mockManager.Setup(m => m.MockRequestAddWorker(activityId, workers, manager, true))
.Returns(Task.FromResult(true));
mockManager.Setup(m => m.MockRequestRemoveWorker(activityId, manager, loadFactorMinWorker))
.Returns(Task.FromResult(true));
}
// test
var actual = await scaleManager.MockTrySwapIfLoadFactorMinWorker(activityId, workers, manager);
// assert
mockManager.VerifyAll();
scaleManager.VerifyAll();
Assert.Equal(loadFactorMinWorker != null, actual);
}
}
public async Task PingWorkerIntervalTests()
{
var activityId = Guid.NewGuid().ToString();
var workerInfo = new MockWorkerInfo();
var settings = new ScaleSettings
{
WorkerPingInterval = TimeSpan.FromMilliseconds(500)
};
using (var scaleManager = new MockScaleManager(MockBehavior.Strict, settings))
{
// Setup
scaleManager.MockScaleHandler.Setup(h => h.PingWorker(activityId, workerInfo))
.Returns(Task.FromResult(true));
scaleManager.MockWorkerTable.Setup(t => t.AddOrUpdate(workerInfo))
.Returns(Task.CompletedTask);
scaleManager.MockScaleTracer.Setup(t => t.TraceUpdateWorker(activityId, workerInfo, It.Is <string>(s => s.Contains("updated"))));
var loop = 10;
for (int i = 0; i < loop; ++i)
{
// test
await scaleManager.MockPingWorker(activityId, workerInfo);
await Task.Delay(100);
}
// assert
scaleManager.VerifyAll();
scaleManager.MockScaleHandler.Verify(h => h.PingWorker(activityId, workerInfo), Times.Between(2, loop - 1, Range.Inclusive));
scaleManager.MockWorkerTable.Verify(t => t.AddOrUpdate(workerInfo), Times.Exactly(loop));
scaleManager.MockScaleTracer.Verify(t => t.TraceUpdateWorker(activityId, workerInfo, It.Is <string>(s => s.Contains("updated"))), Times.Exactly(loop));
}
}
public void UpdateWorkerStatusTimerTests()
{
var worker = new MockWorkerInfo();
var settings = new ScaleSettings
{
WorkerUpdateInterval = TimeSpan.FromMilliseconds(500)
};
var evt = new AutoResetEvent(false);
var mockScaleManager = new Mock <MockScaleManager>(Mock.Of <IWorkerInfoProvider>(), Mock.Of <IWorkerTable>(), Mock.Of <IScaleHandler>(), Mock.Of <IScaleTracer>(), settings)
{
CallBase = true
};
// Setup
mockScaleManager.Setup(m => m.MockProcessWorkItem(It.IsAny <string>()))
.Callback((string id) => evt.Set())
.Returns(Task.CompletedTask);
using (var manager = mockScaleManager.Object)
{
// Assert
Assert.False(evt.WaitOne(1000));
// Test
manager.Start();
// Assert
Assert.True(evt.WaitOne(1000));
}
}
public async Task BasicTests(double maxBusyWorkerRatio, IWorkerInfo manager, IEnumerable <IWorkerInfo> workers, bool expected)
{
var activityId = Guid.NewGuid().ToString();
var settings = new ScaleSettings
{
MaxBusyWorkerRatio = maxBusyWorkerRatio,
BusyWorkerLoadFactor = 80
};
var mockManager = new Mock <MockScaleManager>(MockBehavior.Default, MockBehavior.Strict, settings)
{
CallBase = true
};
// Test
using (var scaleManager = mockManager.Object)
{
// Setup
if (expected)
{
scaleManager.MockScaleTracer.Setup(t => t.TraceInformation(activityId, manager, It.Is <string>(s => s.Contains("exceeds maximum busy worker ratio"))));
mockManager.Setup(m => m.MockRequestAddWorker(activityId, workers, manager, false))
.Returns(Task.FromResult(true));
}
// test
var actual = await scaleManager.MockTryAddIfMaxBusyWorkerRatio(activityId, workers, manager);
// assert
mockManager.VerifyAll();
scaleManager.VerifyAll();
Assert.Equal(expected, actual);
}
}
public MockScaleManager(MockBehavior behavior, ScaleSettings settings = null)
: this(new Mock <MockWorkerInfoProvider>(behavior) { CallBase = behavior != MockBehavior.Strict },
new Mock <MockWorkerTable>(behavior) { CallBase = behavior != MockBehavior.Strict },
new Mock <MockScaleHandler>(behavior) { CallBase = behavior != MockBehavior.Strict },
new Mock <IScaleTracer>(behavior) { CallBase = behavior != MockBehavior.Strict },
settings)
{
}
/// <summary>
/// Creates a new instance of ManipulatorSettings with default setting values
/// </summary>
internal ManipulatorSettings()
{
mTranslationSettings = new TranslationSettings();
mRotationSettings = new RotationSettings();
mScaleSettings = new ScaleSettings();
mTranslationSettings.RestoreDefaults();
mRotationSettings.RestoreDefaults();
mScaleSettings.RestoreDefaults();
}
private void ReverseSettings()
{
activate = true;
scaleSettings = scaleSettings.Reversed();
rotateSettings = rotateSettings.Reversed();
worldPositionSettings = worldPositionSettings.Reversed();
anchoredPositionSettings = anchoredPositionSettings.Reversed();
colourSettings = colourSettings.Reversed();
fadeSettings = fadeSettings.Reversed();
}
public AnimationOperation(AnimationOperation animationOperation)
{
targetObject = animationOperation.targetObject;
type = animationOperation.type;
easing = animationOperation.easing;
delay = animationOperation.delay;
duration = animationOperation.duration;
activate = animationOperation.activate;
scaleSettings = animationOperation.scaleSettings;
rotateSettings = animationOperation.rotateSettings;
worldPositionSettings = animationOperation.worldPositionSettings;
anchoredPositionSettings = animationOperation.anchoredPositionSettings;
colourSettings = animationOperation.colourSettings;
fadeSettings = animationOperation.fadeSettings;
}
public OpResult CreateSetting(ScaleSettings setting)
{
if (string.IsNullOrEmpty(setting.IpAddress))
{
return(OpResult.Fail("IP地址数据异常！"));
}
var r = ScaleSettingsService.IsExist(p => p.IpAddress == setting.IpAddress && p.CompanyId == Sys.SysCommonRules.CompanyId && p.Store == Sys.SysCommonRules.CurrentStore);
if (r)
{
return(OpResult.Fail("IP地址重复！"));
}
setting.CreateDt = DateTime.Now;
setting.CreateUID = Sys.CurrentUser.UID;
setting.CompanyId = Sys.SysCommonRules.CompanyId;
setting.Store = Sys.SysCommonRules.CurrentStore;
return(ScaleSettingsService.Add(setting));
}
public BatchAIClusterImpl WithManualScale(int targetNodeCount)
{
ManualScaleSettings manualScaleSettings = new ManualScaleSettings()
{
TargetNodeCount = targetNodeCount
};
if (IsInCreateMode())
{
EnsureScaleSettings().Manual = manualScaleSettings;
}
else
{
scaleSettings = new ScaleSettings
{
Manual = manualScaleSettings
};
}
return(this);
}
public async Task BasicTests(IWorkerInfo manager, IEnumerable <IWorkerInfo> workers, bool added, IWorkerInfo toRemove)
{
var activityId = Guid.NewGuid().ToString();
var settings = new ScaleSettings
{
BusyWorkerLoadFactor = 80,
FreeWorkerLoadFactor = 20
};
var mockManager = new Mock <MockScaleManager>(MockBehavior.Default, MockBehavior.Strict, settings)
{
CallBase = true
};
// Test
using (var scaleManager = mockManager.Object)
{
// Setup
if (toRemove != null)
{
scaleManager.MockScaleTracer.Setup(t => t.TraceInformation(activityId, toRemove, It.Is <string>(s => s.Contains("remove slave worker"))));
mockManager.Setup(m => m.MockRequestAddWorker(activityId, Enumerable.Empty <IWorkerInfo>(), manager, true))
.Returns(Task.FromResult(added));
if (added)
{
mockManager.Setup(m => m.MockRequestRemoveWorker(activityId, manager, toRemove))
.Returns(Task.FromResult(true));
}
}
// test
var actual = await scaleManager.MockTryRemoveSlaveWorker(activityId, workers, manager);
// assert
mockManager.VerifyAll();
scaleManager.VerifyAll();
Assert.Equal(toRemove != null, actual);
}
}
public BatchAIClusterImpl WithAutoScale(int minimumNodeCount, int maximumNodeCount)
{
AutoScaleSettings autoScaleSettings = new AutoScaleSettings()
{
MinimumNodeCount = minimumNodeCount,
MaximumNodeCount = maximumNodeCount
};
if (IsInCreateMode())
{
EnsureScaleSettings().AutoScale = autoScaleSettings;
}
else
{
scaleSettings = new ScaleSettings()
{
AutoScale = autoScaleSettings
};
}
return(this);
}
internal override void Parse()
{
Properties = new ScaleSettings();
XNamespace serialisationNamespace = SerialisationNamespace;
XElement rootElements = Document.Element(GetSchema() + "ScaleSettings");
// get the compute modefrom the instance
if (rootElements.Element(GetSchema() + "Tier") != null)
{
Properties.ComputeMode =
(ComputeMode)
Enum.Parse(typeof(ComputeMode), rootElements.Element(GetSchema() + "Tier").Value, true);
}
// test to see whether the sitehas been enabled
if (rootElements.Element(GetSchema() + "NumberOfInstances") != null)
{
Properties.InstanceCount = int.Parse(rootElements.Element(GetSchema() + "NumberOfInstances").Value);
}
CommandResponse = Properties;
}
public async Task BasicTests(int maxWorkers, IEnumerable <IWorkerInfo> workers, IWorkerInfo manager, bool force, bool expected)
{
var activityId = Guid.NewGuid().ToString();
var settings = new ScaleSettings {
MaxWorkers = maxWorkers
};
// Test
using (var scaleManager = new MockScaleManager(MockBehavior.Strict, settings))
{
if (expected)
{
scaleManager.MockScaleTracer.Setup(t => t.TraceAddWorker(activityId, manager, It.IsAny <string>()));
scaleManager.MockScaleHandler.Setup(s => s.AddWorker(activityId, It.IsAny <IEnumerable <string> >(), It.IsAny <int>()))
.Returns(Task.FromResult("3"));
}
else
{
scaleManager.MockScaleTracer.Setup(t => t.TraceWarning(activityId, manager, It.IsAny <string>()));
if (force || workers.Count() < settings.MaxWorkers)
{
scaleManager.MockScaleHandler.Setup(s => s.AddWorker(activityId, It.IsAny <IEnumerable <string> >(), It.IsAny <int>()))
.Returns(Task.FromResult(string.Empty));
}
}
// test
var actual = await scaleManager.MockRequestAddWorker(activityId, workers, manager, force);
// assert
scaleManager.VerifyAll();
Assert.Equal(expected, actual);
}
}
// TODO: parse the response on the way back
protected override void ResponseCallback(System.Net.HttpWebResponse webResponse)
{
ScaleSettings = Parse(webResponse, BaseParser.GetMobileServiceDetailsParser, new GetMobileServicesScaleParser(null));
SitAndWait.Set();
}
/// <summary>
/// Updates properties of a Cluster.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// Name of the resource group to which the resource belongs.
/// </param>
/// <param name='workspaceName'>
/// The name of the workspace. Workspace names can only contain a combination
/// of alphanumeric characters along with dash (-) and underscore (_). The name
/// must be from 1 through 64 characters long.
/// </param>
/// <param name='clusterName'>
/// The name of the cluster within the specified resource group. Cluster names
/// can only contain a combination of alphanumeric characters along with dash
/// (-) and underscore (_). The name must be from 1 through 64 characters long.
/// </param>
/// <param name='scaleSettings'>
/// Scale settings. Desired scale settings for the cluster. Batch AI service
/// supports manual and auto scale clusters.
/// </param>
/// <param name='cancellationToken'>
/// The cancellation token.
/// </param>
public static async Task <Cluster> UpdateAsync(this IClustersOperations operations, string resourceGroupName, string workspaceName, string clusterName, ScaleSettings scaleSettings = default(ScaleSettings), CancellationToken cancellationToken = default(CancellationToken))
{
using (var _result = await operations.UpdateWithHttpMessagesAsync(resourceGroupName, workspaceName, clusterName, scaleSettings, null, cancellationToken).ConfigureAwait(false))
{
return(_result.Body);
}
}
/// <summary>
/// Updates properties of a Cluster.
/// </summary>
/// <param name='operations'>
/// The operations group for this extension method.
/// </param>
/// <param name='resourceGroupName'>
/// Name of the resource group to which the resource belongs.
/// </param>
/// <param name='workspaceName'>
/// The name of the workspace. Workspace names can only contain a combination
/// of alphanumeric characters along with dash (-) and underscore (_). The name
/// must be from 1 through 64 characters long.
/// </param>
/// <param name='clusterName'>
/// The name of the cluster within the specified resource group. Cluster names
/// can only contain a combination of alphanumeric characters along with dash
/// (-) and underscore (_). The name must be from 1 through 64 characters long.
/// </param>
/// <param name='scaleSettings'>
/// Scale settings. Desired scale settings for the cluster. Batch AI service
/// supports manual and auto scale clusters.
/// </param>
public static Cluster Update(this IClustersOperations operations, string resourceGroupName, string workspaceName, string clusterName, ScaleSettings scaleSettings = default(ScaleSettings))
{
return(operations.UpdateAsync(resourceGroupName, workspaceName, clusterName, scaleSettings).GetAwaiter().GetResult());
}
/// <summary>
/// Used to construct a website parser
/// </summary>
/// <param name="document"></param>
public GetMobileServicesScaleParser(XDocument document)
: base(document)
{
CommandResponse = new ScaleSettings();
}
/// <summary>
/// 保存电子秤的配置
/// </summary>
/// <param name="setting"></param>
/// <returns></returns>
public ActionResult CreateSetting(ScaleSettings setting)
{
var result = settingbll.CreateSetting(setting);
return(Content(result.ToJson()));
}
public MockScaleManager(IWorkerInfoProvider provider, IWorkerTable table, IScaleHandler scaleHandler, IScaleTracer tracer, ScaleSettings settings = null)
: base(provider, table, scaleHandler, tracer, settings ?? ScaleSettings.Instance)
{
}
private MockScaleManager(Mock <MockWorkerInfoProvider> provider, Mock <MockWorkerTable> table, Mock <MockScaleHandler> scaleHandler, Mock <IScaleTracer> tracer, ScaleSettings settings)
: this(provider.Object, table.Object, scaleHandler.Object, tracer.Object, settings)
{
MockWorkerInfoProvider = provider;
MockWorkerTable = table;
MockScaleHandler = scaleHandler;
MockScaleTracer = tracer;
}
/// <summary>
/// Specifies the scale settings for the pool.
/// </summary>
/// <param name="scaleSettings">The scale settings value.</param>
/// <return>The next stage of the update.</return>
Pool.Update.IUpdate Pool.Update.IWithAttach.WithScaleSettings(ScaleSettings scaleSettings)
{
return(this.WithScaleSettings(scaleSettings));
}
/// <summary>
/// Specifies the scale settings for the pool.
/// </summary>
/// <param name="scaleSettings">The scale settings value.</param>
/// <return>The next stage of the definition.</return>
Pool.UpdateDefinition.IWithAttach <BatchAccount.Update.IUpdate> Pool.UpdateDefinition.IWithAttach <BatchAccount.Update.IUpdate> .WithScaleSettings(ScaleSettings scaleSettings)
{
return(this.WithScaleSettings(scaleSettings));
}
/// <summary>
/// Specifies the scale settings for the pool.
/// </summary>
/// <param name="scaleSettings">The scale settings value.</param>
/// <return>The next stage of the definition.</return>
Pool.Definition.IWithAttach <BatchAccount.Definition.IWithPool> Pool.Definition.IWithAttach <BatchAccount.Definition.IWithPool> .WithScaleSettings(ScaleSettings scaleSettings)
{
return(this.WithScaleSettings(scaleSettings));
}
public PoolImpl WithScaleSettings(ScaleSettings scaleSettings)
{
Inner.ScaleSettings = scaleSettings;
return(this);
}
