public static async Task <FarmSetup> AssignAccounts(IFarmContext context, FarmSettings settings)
{
var possibleMules = await context.Accounts
.Include(a => a.Proxy)
.Where(a => a.Mule)
.Where(IsUsable)
.Take(settings.MaxActiveMules).ToListAsync();
if (possibleMules.Count < settings.MinActiveMules)
{
return(new FarmSetup());
}
var possibleBots = await context.Accounts
.Include(a => a.Proxy)
.Where(a => !a.Mule)
.Where(IsUsable)
.Take(settings.MaxActiveBots)
.ToListAsync();
if (possibleBots.Count == 0)
{
return(new FarmSetup());
}
return(new FarmSetup(possibleBots, possibleMules));
}
public async void LaunchInstance(bool startClient, bool mule)
{
Instance instance;
if (mule)
{
instance = BogusData.Mules.Generate();
}
else
{
instance = BogusData.Bots.Generate();
}
var settings = new FarmSettings
{
ID = 2,
BotScriptName = "BotScript",
MuleScriptName = "MuleScrip",
ApiKey = "JFDKSLFDSJKL7u894312709jfdksl"
};
using (var context = NewContext)
{
context.FarmSettingsTable.Update(settings);
await context.SaveChangesAsync();
}
var state = new FarmState
{
SocketAddress = Guid.NewGuid()
};
var dateTime = new Mock <IDateTime>();
var stateService = new Mock <IStateService>();
stateService.Setup(s => s.GetFarmState()).ReturnsAsync(state);
var clientHandler = new Mock <IClientHandler>();
clientHandler.Setup(c => c.StartClient(It.IsAny <Guid>(), It.IsAny <ClientStartArgs>(), It.IsAny <string>()))
.ReturnsAsync(startClient);
var instanceService = new FORFarm.Application.Farm.InstanceService(dateTime.Object, clientHandler.Object, stateService.Object, Mapper, NewContext);
var result = await instanceService.LaunchInstance(instance);
result.Should().Be(startClient);
clientHandler.Verify(c => c.StartClient(
It.Is <Guid>(s => s == state.SocketAddress),
It.Is <ClientStartArgs>(
args => args.Username == instance.Account.Username &&
args.Password == instance.Account.Password &&
args.ScriptName == (mule ? settings.MuleScriptName : settings.BotScriptName)
), It.Is <string>(s => s == settings.ApiKey)));
}
public async void AreSettingsReady_NotReady(FarmSettings farmSettings)
{
using (var context = NewContext)
{
farmSettings.ID = 1;
context.Update(farmSettings);
await context.SaveChangesAsync();
}
var settingsManager = new FORFarm.Application.Farm.SettingsService(NewContext);
var result = await settingsManager.AreSettingsReady();
result.Should().BeFalse();
}
public void PatchFarm()
{
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(ExpectedResults.FarmGetResponse)
};
var handler = new RecordedDelegatingHandler(response)
{
StatusCodeToReturn = HttpStatusCode.OK
};
var subscriptionId = Guid.NewGuid().ToString();
var token = new TokenCloudCredentials(subscriptionId, Constants.TokenString);
var client = GetClient(handler, token);
var settings = new FarmSettings
{
SettingsPollingIntervalInSecond = 100
};
var farmReq = new FarmUpdateParameters
{
Farm = new FarmBase
{
Settings = settings
}
};
var result = client.Farms.Update(
Constants.ResourceGroupName,
Constants.FarmId,
farmReq);
// validate requestor
Assert.Equal(handler.Method.Method, "PATCH", StringComparer.OrdinalIgnoreCase);
var expectedUri = string.Format(
GetUriTemplate,
Constants.BaseUri,
subscriptionId,
Constants.ResourceGroupName,
Constants.FarmId);
Assert.Equal(handler.Uri.AbsoluteUri, expectedUri);
CompareExpectedResult(result.Farm);
}
public static void GetStarted()
{
FarmSettings.RootPath();
CopyAddDirectoryImage();
GetNetworkPoolInfo();
Job.ClearJsonsDirectory();
var timer = new System.Threading.Timer(
e => HardwareInfoStartUp(),
null,
TimeSpan.Zero,
TimeSpan.FromMinutes(5));
}
protected override void Execute()
{
string confirmString;
FarmSettings settings = Tools.ToSettingsObject <SetAdminFarm, FarmSettings>(this, out confirmString);
if (ShouldProcess(
Resources.SetFarmDescription.FormatInvariantCulture(FarmName, confirmString),
Resources.SetFarmWarning.FormatInvariantCulture(FarmName, confirmString),
Resources.ShouldProcessCaption))
{
FarmUpdateParameters parameters = new FarmUpdateParameters
{
Farm = new FarmBase {
Settings = settings
}
};
FarmGetResponse response = Client.Farms.Update(ResourceGroupName, FarmName, parameters);
WriteObject(new FarmResponse(response.Farm));
}
}
public void PatchFarm()
{
var response = new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(ExpectedResults.FarmGetResponse)
};
var handler = new RecordedDelegatingHandler(response)
{
StatusCodeToReturn = HttpStatusCode.OK
};
var subscriptionId = Guid.NewGuid().ToString();
var token = new TokenCloudCredentials(subscriptionId, Constants.TokenString);
var client = GetClient(handler, token);
var settings = new FarmSettings
{
SettingsPollingIntervalInSecond = 100
};
var farmReq = new FarmUpdateParameters
{
Farm = new FarmBase
{
Settings = settings
}
};
var result = client.Farms.Update(
Constants.ResourceGroupName,
Constants.FarmId,
farmReq);
// validate requestor
Assert.Equal(handler.Method.Method, "PATCH", StringComparer.OrdinalIgnoreCase);
var expectedUri = string.Format(
GetUriTemplate,
Constants.BaseUri,
subscriptionId,
Constants.ResourceGroupName,
Constants.FarmId);
Assert.Equal(handler.Uri.AbsoluteUri, expectedUri);
CompareExpectedResult(result.Farm);
}
public static async Task <bool> AssignProxies(IFarmContext context, FarmSetup farmSetup, FarmSettings settings)
{
var neededBotProxySpots = farmSetup.Bots.Count(a => a.Proxy == null);
var neededMuleProxySpots = farmSetup.Mules.Count(a => a.Proxy == null);
var neededSpots = neededBotProxySpots + neededMuleProxySpots;
if (neededSpots == 0)
{
return(true);
}
var candidateBotProxies = await context.Proxies
.Include(p => p.ActiveAccounts)
.Where(HasNoMules)
.Where(p => p.ActiveAccounts.Count < settings.ConcurrentAccountsPerProxy)
.Where(p => p.BannedMules + p.BannedBots + p.ActiveAccounts.Count < settings.MaxAccountsPerProxy)
.Take(neededBotProxySpots).ToListAsync();
var remainingSpotsToAssign = neededBotProxySpots;
var takenProxyIds = new HashSet <int>();
foreach (var proxy in candidateBotProxies)
{
if (remainingSpotsToAssign == 0)
{
break;
}
remainingSpotsToAssign -= GetRemainingSpots(proxy, settings.ConcurrentAccountsPerProxy, settings.MaxActiveBots);
takenProxyIds.Add(proxy.ID);
}
if (remainingSpotsToAssign > 0)
{
return(false);
}
var remainingProxies = candidateBotProxies
.Where(p => !takenProxyIds.Contains(p.ID))
.Where(HasNoBots.Compile())
.Where(HasSpotRemaining(settings.ConcurrentAccountsPerProxy, settings.MaxAccountsPerProxy).Compile())
.ToList();
var remainingSpots = GetRemainingSpots(remainingProxies, settings.ConcurrentAccountsPerProxy,
settings.MaxAccountsPerProxy);
var candidateMuleProxies = await context.Proxies
.Include(p => p.ActiveAccounts)
.Where(HasNoBots)
.Where(p => !takenProxyIds.Contains(p.ID))
.Take(neededMuleProxySpots - remainingSpots).ToListAsync();
candidateBotProxies.RemoveAll(p => !takenProxyIds.Contains(p.ID));
candidateMuleProxies.AddRange(remainingProxies);
remainingSpotsToAssign = neededMuleProxySpots;
foreach (var proxy in candidateMuleProxies)
{
if (remainingSpotsToAssign == 0)
{
break;
}
remainingSpotsToAssign -= GetRemainingSpots(proxy, settings.ConcurrentAccountsPerProxy,
settings.MaxAccountsPerProxy);
}
if (remainingSpotsToAssign > 0)
{
return(false);
}
foreach (var acc in farmSetup.Bots.Where(a => a.Proxy == null))
{
var proxy = candidateBotProxies.First(
HasSpotRemaining(settings.ConcurrentAccountsPerProxy, settings.MaxAccountsPerProxy).Compile());
acc.Proxy = proxy;
proxy.ActiveAccounts.Add(acc);
}
foreach (var acc in farmSetup.Mules.Where(a => a.Proxy == null))
{
var proxy = candidateMuleProxies.First(
HasSpotRemaining(settings.ConcurrentAccountsPerProxy, settings.MaxAccountsPerProxy).Compile());
acc.Proxy = proxy;
proxy.ActiveAccounts.Add(acc);
}
await context.SaveChangesAsync();
return(true);
}
