public bool Initialize(IPAddress ipAddress, int port = default)
{
if (_isDisposed)
{
throw new ObjectDisposedException(nameof(BroadcastService));
}
if (ipAddress == null)
{
throw new ArgumentNullException(nameof(ipAddress));
}
if (IsReady && Equals(LocalEndPoint, new IPEndPoint(ipAddress, port)))
{
return(true);
}
if (!_networkUtility.IsReadyToUse(ipAddress))
{
return(false); //Throw exception here?
}
if (IsReceiving)
{
CancelReceive();
}
_broadcastImpl?.Dispose();
_broadcastImpl = port == default
? _broadcastFactory.Create(ipAddress)
: _broadcastFactory.Create(ipAddress, port);
IsReady = true;
return(true);
}
public Submit(ISolutions solutions, IChallenges challenges, IVerification verification, IBroadcast broadcast, DiscordSocketClient client)
{
_solutions = solutions;
_challenges = challenges;
_verification = verification;
_broadcast = broadcast;
_client = client;
}
public InMemoryScheduler(IChallenges challenges, ISolutions solutions, IBroadcast broadcaster, ILeaderboard leaderboard, DiscordSocketClient client)
{
_challenges = challenges;
_solutions = solutions;
_broadcaster = broadcaster;
_client = client;
_leaderboard = leaderboard;
}
public InMemoryScheduler(IChallenges challenges, ISolutions solutions, IBroadcast broadcaster, ILeaderboard leaderboard, DiscordSocketClient client, IMessages messages, ITrueskillUpdater skillUpdate)
{
_challenges = challenges;
_solutions = solutions;
_broadcaster = broadcaster;
_client = client;
_messages = messages;
_skillUpdate = skillUpdate;
_leaderboard = leaderboard;
}
public static double GetScore(this IBroadcast broadcast)
{
var weightedPolarities = GetWeightedPolarities(broadcast);
var weightSum = weightedPolarities.Sum(w => w.Value);
if (weightSum == 0 || !weightedPolarities.TryGetValue(RatingPolarity.Positive, out var positiveWeight) || positiveWeight == 0)
{
return(0);
}
return((double)positiveWeight / weightSum);
}
public Chainer(IBroadcast broadcast, int payloadSegmentLength = 8192) : base(broadcast)
{
if (payloadSegmentLength is < MinSegmentLength or > MaxSegmentLength)
{
throw new ArgumentOutOfRangeException(nameof(payloadSegmentLength),
$"Provided segment length should be in range from {MinSegmentLength} to {MaxSegmentLength}");
}
_payloadSegmentLength = payloadSegmentLength;
_formatter = new BinaryFormatter();
_receivedSegmentsBuffer = new ConcurrentDictionary <Guid, Chain>();
_cleanupTimer = new Timer(CleanupCallback, null, 0, CleanupPeriodMs);
}
public DbSolutions(IDatabase database, IBroadcast broadcast)
{
_database = database;
try
{
_database.Exec("CREATE TABLE IF NOT EXISTS `Solutions` (`ChallengeId` INTEGER NOT NULL,`UserId` INTEGER NOT NULL,`Score` INTEGER NOT NULL,`Yolol` TEXT NOT NULL,PRIMARY KEY(`ChallengeId`,`UserId`));");
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
public Runtime(
ITestRunner testRunner,
IArgosRunner argosRunner,
IDashboardRepository dashboardRepository,
IBroadcast broadcast)
{
_testRunner = testRunner;
_argosRunner = argosRunner;
_dashboardRepository = dashboardRepository;
_broadcast = broadcast;
_runtimeThread = new Thread(RuntimeThread);
_runtimeThread.IsBackground = true;
}
public static DateTime GetTimestamp(this IBroadcast self)
{
switch (self.State)
{
case BroadcastState.Broadcasted:
return(self.BroadcastedUtc.Value);
case BroadcastState.Completed:
return(self.CompletedUtc.Value);
case BroadcastState.Failed:
return(self.FailedUtc.Value);
default:
throw new ArgumentException($"Unsupported IBroadcast.State={Enum.GetName(typeof(BroadcastState), self.State)}");
}
}
private void NetworkStateChangedHandler(object sender, EventArgs e)
{
if (!IsReady || _networkUtility.IsReadyToUse(_broadcastImpl.LocalEndPoint.Address))
{
return;
}
if (IsReceiving && _cancelReceiveTokenSource is not null)
{
_cancelReceiveTokenSource.Cancel();
}
_cancelReceiveTokenSource?.Dispose();
IsReady = IsReceiving = false;
_broadcastImpl?.Dispose();
_broadcastImpl = null;
ConnectionLost?.Invoke(this, EventArgs.Empty);
}
public async Task DeleteBroadcastAsync(IBroadcast broadcast)
{
await _broadcastInProgressRepository.DeleteAsync(broadcast.OperationId);
await _broadcastRepository.DeleteAsync(broadcast.OperationId);
}
protected BroadcastDecorator(IBroadcast broadcast)
{
Broadcast = broadcast ?? throw new ArgumentNullException(nameof(broadcast));
}
public async Task <bool> HandleAsync(IBroadcast <Before, ILoggable <Before> > e)
{
await Write("Before", e.Subject);
return(false);
}
public void Dispose()
{
_broadcast = null;
}
public async Task<bool> HandleAsync(IBroadcast<Failed, ILoggable<Failed>> e)
{
await Write("Failed", e.Subject, e.Exception);
return false;
}
public async Task <bool> HandleAsync(IBroadcast <Unhandled, ILoggable <Unhandled> > e)
{
await Write("Unhandled", e.Subject);
return(false);
}
/// <summary>
/// Sends only broadcasts.
/// </summary>
public OrderResponse LaunchBroadcast(IBroadcast broadcast)
{
CheckInitialized();
return SendOrder(broadcast);
}
public async Task<bool> HandleAsync(IBroadcast<Unhandled, ILoggable<Unhandled>> e)
{
await Write("Unhandled", e.Subject);
return false;
}
public async Task<bool> HandleAsync(IBroadcast<Before, ILoggable<Before>> e)
{
await Write("Before", e.Subject);
return false;
}
public static IDictionary <RatingPolarity, int> GetWeightedPolarities(this IBroadcast broadcasts) => broadcasts .Ratings.GroupBy(r => r.Polarity).ToDictionary(g => g.Key, g => g.Sum(r => r.Weight));
public async Task <bool> HandleAsync(IBroadcast <Failed, ILoggable <Failed> > e)
{
await Write("Failed", e.Subject, e.Exception);
return(false);
}
