public async Task <TTenantInfo?> TryGetAsync(string id)
{
if (id is null)
{
throw new ArgumentNullException(nameof(id));
}
return(await Task.FromResult(tenantMap?.Where(kv => kv.Value.Id == id).SingleOrDefault().Value));
}
public static unsafe bool HasDuplicateBranchReferences(Transaction tx, Page start,out long pageNumberWithDuplicates)
{
var stack = new Stack<Page>();
var existingTreeReferences = new ConcurrentDictionary<long, List<long>>();
stack.Push(start);
while (stack.Count > 0)
{
var currentPage = stack.Pop();
if (currentPage.IsBranch)
{
for (int nodeIndex = 0; nodeIndex < currentPage.NumberOfEntries; nodeIndex++)
{
var node = currentPage.GetNode(nodeIndex);
existingTreeReferences.AddOrUpdate(currentPage.PageNumber, new List<long> { node->PageNumber },
(branchPageNumber, pageNumberReferences) =>
{
pageNumberReferences.Add(node->PageNumber);
return pageNumberReferences;
});
}
for (int nodeIndex = 0; nodeIndex < currentPage.NumberOfEntries; nodeIndex++)
{
var node = currentPage.GetNode(nodeIndex);
if (node->PageNumber < 0 || node->PageNumber > tx.State.NextPageNumber)
{
throw new InvalidDataException("found invalid reference on branch - tree is corrupted");
}
var child = tx.GetReadOnlyPage(node->PageNumber);
stack.Push(child);
}
}
}
Func<long, HashSet<long>> relevantPageReferences =
branchPageNumber => new HashSet<long>(existingTreeReferences
.Where(kvp => kvp.Key != branchPageNumber)
.SelectMany(kvp => kvp.Value));
// ReSharper disable once LoopCanBeConvertedToQuery
foreach (var branchReferences in existingTreeReferences)
{
if (
branchReferences.Value.Any(
referencePageNumber => relevantPageReferences(branchReferences.Key).Contains(referencePageNumber)))
{
pageNumberWithDuplicates = branchReferences.Key;
return true;
}
}
pageNumberWithDuplicates = -1;
return false;
}
public async Task NizzleName(int numberOfMessages, int numberOfWorkers)
{
var activator = new BuiltinHandlerActivator();
var sentmessageIds = new ConcurrentDictionary<int, int>();
var receivedMessageIds = new ConcurrentDictionary<int, int>();
activator.Handle<SomeMessage>(async message =>
{
var id = message.Id;
receivedMessageIds.AddOrUpdate(id, i => 1, (i, existing) => existing + 1);
});
var bus = (RebusBus)Configure.With(activator)
.Logging(l => l.None())
.Transport(t => t.UseMsmq(InputQueueName))
.Routing(t => t.TypeBased().Map<SomeMessage>(InputQueueName))
.Options(o => o.SetNumberOfWorkers(0))
.Start();
Using(bus);
var sendStopwatch = Stopwatch.StartNew();
Console.WriteLine("Sending {0} messages", numberOfMessages);
await Task.WhenAll(Enumerable
.Range(0, numberOfMessages)
.Select(id => bus.Send(new SomeMessage { Id = id })));
var elapsedSending = sendStopwatch.Elapsed;
Console.WriteLine("SENT {0} messages in {1:0.0} s - that's {2:0.0}/s",
numberOfMessages, elapsedSending.TotalSeconds, numberOfMessages / elapsedSending.TotalSeconds);
bus.SetNumberOfWorkers(numberOfWorkers);
var receiveStopwatch = Stopwatch.StartNew();
Console.WriteLine("Waiting until they have been received");
while (receivedMessageIds.Count < numberOfMessages)
{
Console.WriteLine("got {0} messages so far...", receivedMessageIds.Count);
await Task.Delay(1000);
}
var elapsedReceiving = receiveStopwatch.Elapsed;
Console.WriteLine("RECEIVED {0} messages in {1:0.0} s - that's {2:0.0}/s",
numberOfMessages, elapsedReceiving.TotalSeconds, numberOfMessages/elapsedReceiving.TotalSeconds);
var sentButNotReceived = sentmessageIds.Keys.Except(receivedMessageIds.Keys).ToList();
var receivedMoreThanOnce = receivedMessageIds.Where(kvp => kvp.Value > 1).ToList();
if (sentButNotReceived.Any())
{
Assert.Fail("The following IDs were sent but not received: {0}", string.Join(", ", sentButNotReceived));
}
if (receivedMoreThanOnce.Any())
{
Assert.Fail("The following IDs were received more than once: {0}",
string.Join(", ", receivedMoreThanOnce.Select(kvp => string.Format("{0} ({1})", kvp.Key, kvp.Value))));
}
}
private static IEnumerable <KeyValuePair <string, TimerExecutorItem> > _where(
this ConcurrentDictionary <string, TimerExecutorItem> store, Func <TimerExecutorItem, bool> predicateWhere)
{
return(store?.Where(i => predicateWhere(i.Value)));
}
/// <inheritdoc cref="ICacheManager"/>
public virtual void RemoveByPattern(string pattern)
{
this.RemoveByPattern(pattern, AllKeys.Where(p => p.Value).Select(p => p.Key));
}
public sealed override void Initialize(AnalysisContext context)
{
context.EnableConcurrentExecution();
// Security analyzer - analyze and report diagnostics on generated code.
context.ConfigureGeneratedCodeAnalysis(GeneratedCodeAnalysisFlags.Analyze | GeneratedCodeAnalysisFlags.ReportDiagnostics);
context.RegisterCompilationStartAction(
(CompilationStartAnalysisContext compilationStartAnalysisContext) =>
{
var compilation = compilationStartAnalysisContext.Compilation;
var serializableAttributeTypeSymbol = WellKnownTypes.SerializableAttribute(compilation);
if (serializableAttributeTypeSymbol == null)
{
return;
}
var nonSerializedAttribute = WellKnownTypes.NonSerializedAttribute(compilation);
if (nonSerializedAttribute == null)
{
return;
}
var forwardGraph = new ConcurrentDictionary <ISymbol, ConcurrentDictionary <ISymbol, bool> >();
var invertedGraph = new ConcurrentDictionary <ISymbol, ConcurrentDictionary <ISymbol, bool> >();
// It keeps the out Degree of every vertex in the invertedGraph, which is corresponding to the in Degree of the vertex in forwardGraph.
var inDegree = new ConcurrentDictionary <ISymbol, int>();
// It Keeps the out degree of every vertex in the forwardGraph, which is corresponding to the in Degree of the vertex in invertedGraph.
var outDegree = new ConcurrentDictionary <ISymbol, int>();
compilationStartAnalysisContext.RegisterSymbolAction(
(SymbolAnalysisContext symbolAnalysisContext) =>
{
DrawGraph(symbolAnalysisContext.Symbol as ITypeSymbol);
}, SymbolKind.NamedType);
compilationStartAnalysisContext.RegisterCompilationEndAction(
(CompilationAnalysisContext compilationAnalysisContext) =>
{
ModifyDegree(inDegree, forwardGraph);
ModifyDegree(outDegree, invertedGraph);
// If the degree of a vertex is greater than 0 both in the forward graph and inverted graph after topological sorting,
// the vertex must belong to a loop.
var leftVertices = inDegree.Where(s => s.Value > 0).Select(s => s.Key).ToImmutableHashSet();
var invertedLeftVertices = outDegree.Where(s => s.Value > 0).Select(s => s.Key).ToImmutableHashSet();
var verticesInLoop = leftVertices.Intersect(invertedLeftVertices);
foreach (var vertex in verticesInLoop)
{
if (vertex is IFieldSymbol fieldInLoop)
{
var associatedSymbol = fieldInLoop.AssociatedSymbol;
compilationAnalysisContext.ReportDiagnostic(
fieldInLoop.CreateDiagnostic(
Rule,
associatedSymbol == null ? vertex.Name : associatedSymbol.Name));
}
}
});
/// <summary>
/// Traverse from point to its descendants, save the information into a directed graph.
/// </summary>
/// <param name="point">The initial point</param>
void DrawGraph(ITypeSymbol point)
{
// If the point has been visited, return;
// otherwise, add it to the graph and mark it as visited.
if (!AddPointToBothGraphs(point))
{
return;
}
foreach (var associatedTypePoint in GetAssociatedTypes(point))
{
if (associatedTypePoint == null ||
associatedTypePoint.Equals(point))
{
continue;
}
AddLineToBothGraphs(point, associatedTypePoint);
DrawGraph(associatedTypePoint);
}
if (point.IsInSource() &&
point.HasAttribute(serializableAttributeTypeSymbol))
{
var fieldPoints = point.GetMembers().OfType <IFieldSymbol>().Where(s => !s.HasAttribute(nonSerializedAttribute) &&
!s.IsStatic);
foreach (var fieldPoint in fieldPoints)
{
var fieldTypePoint = fieldPoint.Type;
AddLineToBothGraphs(point, fieldPoint);
AddLineToBothGraphs(fieldPoint, fieldTypePoint);
DrawGraph(fieldTypePoint);
}
}
}
HashSet <ITypeSymbol> GetAssociatedTypes(ITypeSymbol type)
{
var result = new HashSet <ITypeSymbol>();
if (type is INamedTypeSymbol namedTypeSymbol)
{
// 1. Type arguments of generic type.
if (namedTypeSymbol.IsGenericType)
{
foreach (var arg in namedTypeSymbol.TypeArguments)
{
result.Add(arg);
}
}
// 2. The type it constructed from.
var constructedFrom = namedTypeSymbol.ConstructedFrom;
result.Add(constructedFrom);
}
else if (type is IArrayTypeSymbol arrayTypeSymbol)
{
// 3. Element type of the array.
result.Add(arrayTypeSymbol.ElementType);
}
// 4. Base type.
result.Add(type.BaseType);
return(result);
}
/// <summary>
/// Add a line to the graph.
/// </summary>
/// <param name="from">The start point of the line</param>
/// <param name="to">The end point of the line</param>
/// <param name="degree">The out degree of all vertices in the graph</param>
/// <param name="graph">The graph</param>
void AddLine(ISymbol from, ISymbol to, ConcurrentDictionary <ISymbol, int> degree, ConcurrentDictionary <ISymbol, ConcurrentDictionary <ISymbol, bool> > graph)
{
graph.AddOrUpdate(from, new ConcurrentDictionary <ISymbol, bool> {
[to] = true
}, (k, v) => { v[to] = true; return(v); });
degree.AddOrUpdate(from, 1, (k, v) => v + 1);
}
/// <summary>
/// Add a point to the graph.
/// </summary>
/// <param name="point">The point to be added</param>
/// <param name="degree">The out degree of all vertices in the graph</param>
/// <param name="graph">The graph</param>
bool AddPoint(ISymbol point, ConcurrentDictionary <ISymbol, int> degree, ConcurrentDictionary <ISymbol, ConcurrentDictionary <ISymbol, bool> > graph)
{
degree.TryAdd(point, 0);
return(graph.TryAdd(point, new ConcurrentDictionary <ISymbol, bool>()));
}
/// <summary>
/// Add a line to the forward graph and inverted graph unconditionally.
/// </summary>
/// <param name="from">The start point of the line</param>
/// <param name="to">The end point of the line</param>
void AddLineToBothGraphs(ISymbol from, ISymbol to)
{
AddLine(from, to, outDegree, forwardGraph);
AddLine(to, from, inDegree, invertedGraph);
}
/// <summary>
/// Add a point to the forward graph and inverted graph unconditionally.
/// </summary>
/// <param name="point">The point to be added</param>
/// <returns>
/// <c>true</c> if <paramref name="point"/> is added to the forward graph successfully;
/// otherwise <c>false</c>.
/// </returns>
bool AddPointToBothGraphs(ISymbol point)
{
AddPoint(point, inDegree, invertedGraph);
return(AddPoint(point, outDegree, forwardGraph));
}
/// <summary>
/// According to topological sorting, modify the degree of every vertex in the graph.
/// </summary>
/// <param name="degree">The in degree of all vertices in the graph</param>
/// <param name="graph">The graph</param>
void ModifyDegree(ConcurrentDictionary <ISymbol, int> degree, ConcurrentDictionary <ISymbol, ConcurrentDictionary <ISymbol, bool> > graph)
{
var stack = new Stack <ISymbol>(degree.Where(s => s.Value == 0).Select(s => s.Key));
while (stack.Count != 0)
{
var start = stack.Pop();
degree.AddOrUpdate(start, -1, (k, v) => v - 1);
foreach (var vertex in graph[start].Keys)
{
degree.AddOrUpdate(vertex, -1, (k, v) => v - 1);
if (degree[vertex] == 0)
{
stack.Push(vertex);
}
}
}
}
});
}
/// <summary>
/// Gets the specified set of IWebSocketConnections with the same clientIdentifier.
/// </summary>
/// <param name="clientIdentifier">The clientIdentifier.</param>
/// <returns></returns>
public IWebSocketConnection[] GetConnectionsByClientIdentifier(string clientIdentifier)
{
return(_clientMap.Where(x => x.Key.ClientIdentifier == clientIdentifier).Select(x => x.Key).ToArray());
}
/// <summary>
/// Retrieves all known key/value pairs from the secrets file where the key begins with with <paramref name="prefix"/>.
/// </summary>
/// <param name="prefix">A prefix string to filter the list of potential keys retrieved from the source.</param>
/// <returns>A collection of key/value pairs.</returns>
public override ICollection <KeyValuePair <string, string> > GetAllValues(string prefix)
{
ReadAllValues(DirectoryPath, "", _allValues);
return(_allValues?.Where(s => s.Key.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)).ToList());
}
public IEnumerable <StreamingContextRepository <TStreamingService> > AllExcept(TKey exceptKey)
{
return(repositories.Where(x => !comparer.Equals(x.Key, exceptKey)).Select(x => x.Value));
}
public WriteObjectReply Write(WriteObjectRequest request)
{
Console.WriteLine("Received write with params:");
Console.WriteLine($"Partition_id: {request.Key.PartitionId}");
Console.WriteLine($"Object_id: {request.Key.ObjectId}");
Console.WriteLine($"Value: {request.Value}");
if (MasteredPartitions.Contains(request.Key.PartitionId))
{
lock (WriteGlobalLock)
{
// I'm master of this object's partition
// Send request to all other servers of partition
ServersByPartition.TryGetValue(request.Key.PartitionId, out List <string> serverIds);
if (!KeyValuePairs.TryGetValue(new ObjectKey(request.Key), out ObjectValueManager objectValueManager))
{
LocalReadWriteLock.AcquireWriterLock(-1);
objectValueManager = new ObjectValueManager();
KeyValuePairs[new ObjectKey(request.Key)] = objectValueManager;
objectValueManager.LockWrite();
LocalReadWriteLock.ReleaseWriterLock();
}
else
{
objectValueManager.LockWrite();
}
var connectionCrashedServers = new HashSet <string>();
foreach (var server in ServerUrls.Where(x => serverIds.Contains(x.Key) && x.Key != MyId))
{
var channel = GrpcChannel.ForAddress(server.Value);
var client = new ServerSyncGrpcService.ServerSyncGrpcServiceClient(channel);
// What to do if success returns false ?
try
{
client.LockObject(new LockObjectRequest
{
Key = request.Key
});
} catch (RpcException e)
{
// If grpc does no respond, we can assume it has crashed
if (e.Status.StatusCode == StatusCode.DeadlineExceeded || e.Status.StatusCode == StatusCode.Unavailable || e.Status.StatusCode == StatusCode.Internal)
{
// Add to hash Set
Console.WriteLine($"Server {server.Key} has crashed");
connectionCrashedServers.Add(server.Key);
}
else
{
throw e;
}
}
}
foreach (var server in ServerUrls.Where(x => serverIds.Contains(x.Key) && x.Key != MyId))
{
try
{
var channel = GrpcChannel.ForAddress(server.Value);
var client = new ServerSyncGrpcService.ServerSyncGrpcServiceClient(channel);
// What to do if success returns false ?
client.ReleaseObjectLock(new ReleaseObjectLockRequest
{
Key = request.Key,
Value = request.Value
});
}
catch (RpcException e)
{
if (e.Status.StatusCode == StatusCode.DeadlineExceeded || e.Status.StatusCode == StatusCode.Unavailable || e.Status.StatusCode == StatusCode.Internal)
{
// Add to hash Set
Console.WriteLine($"Server {server.Key} has crashed");
connectionCrashedServers.Add(server.Key);
}
else
{
throw e;
}
}
}
if (connectionCrashedServers.Any())
{
// Update the crashed servers
UpdateCrashedServers(request.Key.PartitionId, connectionCrashedServers);
// Contact Partition slaves an update their view of the partition
foreach (var server in ServerUrls.Where(x => serverIds.Contains(x.Key) && x.Key != MyId))
{
var channel = GrpcChannel.ForAddress(server.Value);
var client = new ServerSyncGrpcService.ServerSyncGrpcServiceClient(channel);
client.RemoveCrashedServers(new RemoveCrashedServersRequest
{
PartitionId = request.Key.PartitionId,
ServerIds = { connectionCrashedServers }
});
}
}
objectValueManager.UnlockWrite(request.Value);
return(new WriteObjectReply
{
Ok = true
});
}
}
else
{
// Tell him I'm not the master
throw new RpcException(new Status(StatusCode.PermissionDenied, $"Server {MyId} is not the master of partition {request.Key.PartitionId}"));
}
}
private async Task FinishSession()
{
try
{
if (Result > 0)
{
return;
}
Result = RandomUtil.NextInt(2) + RandomUtil.NextInt(2) + RandomUtil.NextInt(2) + RandomUtil.NextInt(2);
_logic.CalculateResult(Result, SessionId);
string data = _logic.GetQuery();
if (string.IsNullOrEmpty(data))
{
return;
}
History.Enqueue(Result);
if (History.Count > 50)
{
History.TryDequeue(out var r);
}
await GameDAO.ExecuteAsync(data);
NLogManager.LogMessage("FINISH SESION: => " + data);
var rewards = _logic.GetReward();
var listSit = Sitting.Values.ToList();
List <object> sittings = new List <object>();
foreach (var re in rewards)
{
Player p = GetPlayer(re.Key);
if (p != null)
{
long totalLose = re.Value.Sum(x => x.Lose);
long totalwin = re.Value.Sum(x => x.Prize);
long totalrefund = re.Value.Sum(x => x.Refund);
if (re.Key == Banker)
{
p.IncreaseBalance(totalwin - totalLose, MoneyType);
}
else
{
p.IncreaseBalance(totalwin + totalrefund, MoneyType);
}
if (listSit.Exists(x => x?.AccountId == re.Key))
{
sittings.Add(new
{
AccountId = p.AccountId,
Balance = MoneyType == MoneyType.GOLD ? p.Gold : p.Coin,
TotalLose = totalLose,
TotalWin = totalwin,
TotalRefund = re.Key == Banker ? 0 : totalrefund,
TotalPrize = totalwin
});
}
}
}
foreach (var re in rewards)
{
Player p = GetPlayer(re.Key);
if (p != null)
{
long balance = MoneyType == MoneyType.GOLD ? p.Gold : p.Coin;
var lstConnection = _connectionHandler.GetConnections(p.AccountId);
_hubContext.Clients.Clients(lstConnection.ToList()).showResult(Result, new
{
winLose = re.Value,
balance = balance
}, sittings);
}
}
var player = _players.Where(x => !rewards.ContainsKey(x.Key));
foreach (var re in player)
{
long balance = MoneyType == MoneyType.GOLD ? re.Value.Gold : re.Value.Coin;
var lstConnection = _connectionHandler.GetConnections(re.Value.AccountId);
_hubContext.Clients.Clients(lstConnection.ToList()).showResult(Result, new
{
winLose = new List <Reward>(),
balance = balance
}, sittings);
}
}
catch (Exception ex)
{
NLogManager.PublishException(ex);
}
}
/// <summary>
/// A long running method that monitors and processes a list of transactions that need to send a reliable
/// request or response.
/// </summary>
private void ProcessPendingTransactions()
{
Thread.CurrentThread.Name = TXENGINE_THREAD_NAME;
try
{
while (!m_isClosed)
{
if (m_pendingTransactions.IsEmpty)
{
Thread.Sleep(MAX_TXCHECK_WAIT_MILLISECONDS);
}
else
{
foreach (var(_, transaction) in m_pendingTransactions.Where(x => x.Value.DeliveryPending))
{
try
{
if (transaction.TransactionState == SIPTransactionStatesEnum.Terminated ||
transaction.TransactionState == SIPTransactionStatesEnum.Confirmed ||
transaction.HasTimedOut)
{
transaction.DeliveryPending = false;
}
else if (transaction.HasDeliveryExpired(m_t6))
{
if (transaction.TransactionState == SIPTransactionStatesEnum.Proceeding)
{
// If the transaction is a UAS and still in the progress state then the timeout was
// for a provisional response and it should not set any transaction properties that
// will affect the delivery of any subsequent final response.
transaction.OnTimedOutProvisionalResponse();
}
else
{
transaction.Expire(DateTime.Now);
}
}
else
{
if (transaction.DeliveryPending && transaction.IsRetransmitDue(m_t1, m_t2))
{
SocketError sendResult = SocketError.Success;
switch (transaction.TransactionType)
{
case SIPTransactionTypesEnum.InviteServer:
switch (transaction.TransactionState)
{
case SIPTransactionStatesEnum.Calling:
break;
case SIPTransactionStatesEnum.Trying:
break;
case SIPTransactionStatesEnum.Proceeding:
if (transaction.ReliableProvisionalResponse != null)
{
sendResult = SendTransactionProvisionalResponse(transaction)
.Result;
}
break;
case SIPTransactionStatesEnum.Completed:
sendResult = SendTransactionFinalResponse(transaction).Result;
break;
case SIPTransactionStatesEnum.Confirmed:
transaction.DeliveryPending = false;
break;
case SIPTransactionStatesEnum.Cancelled:
sendResult = SendTransactionFinalResponse(transaction).Result;
break;
default:
logger.LogWarning(
$"InviteServer Transaction entered an unexpected transaction state {transaction.TransactionState}.");
transaction.DeliveryFailed = true;
break;
}
break;
case SIPTransactionTypesEnum.InviteClient:
switch (transaction.TransactionState)
{
case SIPTransactionStatesEnum.Calling:
sendResult = SendTransactionRequest(transaction).Result;
break;
case SIPTransactionStatesEnum.Trying:
break;
case SIPTransactionStatesEnum.Proceeding:
transaction.DeliveryPending = false;
break;
case SIPTransactionStatesEnum.Completed:
transaction.DeliveryPending = false;
break;
case SIPTransactionStatesEnum.Confirmed:
transaction.DeliveryPending = false;
break;
case SIPTransactionStatesEnum.Cancelled:
transaction.DeliveryPending = false;
break;
default:
logger.LogWarning(
$"InviteClient Transaction entered an unexpected transaction state {transaction.TransactionState}.");
transaction.DeliveryFailed = true;
break;
}
break;
case SIPTransactionTypesEnum.NonInvite:
switch (transaction.TransactionState)
{
case SIPTransactionStatesEnum.Calling:
sendResult = SendTransactionRequest(transaction).Result;
break;
case SIPTransactionStatesEnum.Trying:
break;
case SIPTransactionStatesEnum.Proceeding:
break;
case SIPTransactionStatesEnum.Completed:
if (transaction.TransactionFinalResponse != null)
{
// Sending a single final response on a non-INVITE tx. The same response
// will be automatically resent if the same request is received.
sendResult = m_sipTransport
.SendResponseAsync(transaction.TransactionFinalResponse)
.Result;
transaction.DeliveryPending = false;
}
break;
case SIPTransactionStatesEnum.Confirmed:
transaction.DeliveryPending = false;
break;
default:
logger.LogWarning(
$"NonInvite Transaction entered an unexpected transaction state {transaction.TransactionState}.");
transaction.DeliveryFailed = true;
break;
}
break;
default:
logger.LogWarning(
$"Unrecognised transaction type {transaction.TransactionType}.");
break;
}
if (sendResult != SocketError.Success)
{
// Example of failures here are requiring a specific TCP or TLS connection that no longer exists
// or attempting to send to a UDP socket that has previously returned an ICMP error.
transaction.DeliveryPending = false;
transaction.DeliveryFailed = true;
transaction.TimedOutAt = DateTime.Now;
transaction.FireTransactionTimedOut();
}
}
}
}
catch (Exception excp)
{
logger.LogError($"Exception processing pending transactions. {excp.Message}");
}
}
RemoveExpiredTransactions();
Thread.Sleep(TXCHECK_WAIT_MILLISECONDS);
}
}
}
catch (Exception excp)
{
logger.LogError("Exception SIPTransactionEngine ProcessPendingTransactions. " + excp.Message);
}
}
public void ApplyCommand(BaseCommand command)
{
try
{
switch (command)
{
case UpsertNodeInformation t1:
if (Nodes.ContainsKey(t1.Id))
{
Nodes[t1.Id] = new NodeInformation()
{
Name = t1.Name,
TransportAddress = t1.TransportAddress,
Id = t1.Id,
IsContactable = t1.IsContactable
};
}
else
{
//Only add if it is marking as contactable
if (t1.IsContactable)
{
var nodes = Nodes.Where(n => n.Value.TransportAddress == t1.TransportAddress);
if (nodes.Count() > 0)
{
foreach (var node in nodes)
{
Nodes.Remove(node.Key, out _);
}
}
Nodes.TryAdd(t1.Id, new NodeInformation()
{
Name = t1.Name,
TransportAddress = t1.TransportAddress,
Id = t1.Id,
IsContactable = t1.IsContactable
});
}
}
break;
case DeleteNodeInformation t1:
if (Nodes.ContainsKey(t1.Id))
{
Nodes.TryRemove(t1.Id, out _);
}
break;
case CreateIndex t1:
Indexes.TryAdd(t1.Type, new Index()
{
Shards = t1.Shards.Select(s => s.DeepCopy()).ToList(),
Type = t1.Type
});
break;
case UpdateClusterTasks t1:
if (t1.TasksToAdd != null)
{
foreach (var task in t1.TasksToAdd)
{
if (GetRunningTask(task.UniqueRunningId) == null)
{
if (!ClusterTasks.TryAdd(task.Id, SystemExtension.Clone(task)))
{
//Can't add a task twice
if (ClusterTasks.ContainsKey(task.Id))
{
if (_logger == null)
{
Console.WriteLine("Critical error while trying to add cluster task " + task.Id + " the id already exists as the object " + JsonConvert.SerializeObject(ClusterTasks[task.Id], Formatting.Indented));
}
else
{
_logger.LogDebug("Critical error while trying to add cluster task " + task.Id + " the id already exists as the object " + JsonConvert.SerializeObject(ClusterTasks[task.Id], Formatting.Indented));
}
}
else
{
throw new Exception("Critical error while trying to add cluster task " + task.Id);
}
}
}
else
{
if (_logger == null)
{
Console.WriteLine("The task already exists and is running. Skipping addition of task " + task.Id);
}
else
{
_logger.LogInformation("The task already exists and is running. Skipping addition of task " + task.Id);
}
}
}
}
if (t1.TasksToRemove != null)
{
foreach (var task in t1.TasksToRemove)
{
if (!ClusterTasks.TryRemove(task, out _))
{
throw new Exception("Critical error while trying to remove cluster task " + task);
}
}
}
if (t1.TasksToUpdate != null)
{
foreach (var task in t1.TasksToUpdate)
{
if (ClusterTasks.ContainsKey(task.TaskId))
{
ClusterTasks[task.TaskId].CompletedOn = task.CompletedOn;
ClusterTasks[task.TaskId].Status = task.Status;
ClusterTasks[task.TaskId].ErrorMessage = task.ErrorMessage;
}
else
{
if (_logger == null)
{
Console.WriteLine("Critical error while trying to update cluster task " + task.TaskId + " task is not present in dictionary.");
}
else
{
_logger.LogInformation("Critical error while trying to update cluster task " + task.TaskId + " task is not present in dictionary.");
}
}
}
}
break;
case UpdateShardMetadataAllocations t1:
if (t1.InsyncAllocationsToAdd != null)
{
var newList = new HashSet <Guid>();
Indexes[t1.Type].Shards.Where(s => s.Id == t1.ShardId).FirstOrDefault().InsyncAllocations.ToList().ForEach(ia => newList.Add(ia));
foreach (var allocation in t1.InsyncAllocationsToAdd)
{
//Indexes[t1.Type].Shards.Where(s => s.Id == t1.ShardId).FirstOrDefault().InsyncAllocations = newList;
newList.Add(allocation);
}
Indexes[t1.Type].Shards.Where(s => s.Id == t1.ShardId).FirstOrDefault().InsyncAllocations = new HashSet <Guid>(newList);
// Indexes[t1.Type].Shards.Where(s => s.Id == t1.ShardId).FirstOrDefault().StaleAllocations = Indexes[t1.Type].Shards.Where(s => s.Id == t1.ShardId).FirstOrDefault().StaleAllocations.Where(sa => !t1.InsyncAllocationsToAdd.Contains(sa)).ToHashSet();
}
if (t1.InsyncAllocationsToRemove != null)
{
Indexes[t1.Type].Shards.Where(s => s.Id == t1.ShardId).FirstOrDefault().InsyncAllocations = new HashSet <Guid>(Indexes[t1.Type].Shards.Where(s => s.Id == t1.ShardId).FirstOrDefault().InsyncAllocations.Where(ia => !t1.InsyncAllocationsToRemove.Contains(ia)));
}
if (t1.StaleAllocationsToAdd != null)
{
var newList = new HashSet <Guid>();
Indexes[t1.Type].Shards.Where(s => s.Id == t1.ShardId).FirstOrDefault().StaleAllocations.ToList().ForEach(ia => newList.Add(ia));
foreach (var allocation in t1.StaleAllocationsToAdd)
{
newList.Add(allocation);
}
Indexes[t1.Type].Shards.Where(s => s.Id == t1.ShardId).FirstOrDefault().StaleAllocations = new HashSet <Guid>(newList);
}
if (t1.StaleAllocationsToRemove != null)
{
var newList = new HashSet <Guid>();
Indexes[t1.Type].Shards.Where(s => s.Id == t1.ShardId).FirstOrDefault().StaleAllocations.Where(sa => !t1.StaleAllocationsToRemove.Contains(sa)).ToList().ForEach(ia => newList.Add(ia));
Indexes[t1.Type].Shards.Where(s => s.Id == t1.ShardId).FirstOrDefault().StaleAllocations = new HashSet <Guid>(newList);
}
if (t1.PrimaryAllocation != null)
{
Indexes[t1.Type].Shards.Where(s => s.Id == t1.ShardId).FirstOrDefault().PrimaryAllocation = t1.PrimaryAllocation.Value;
}
break;
case SetLock t1:
var stringLockResult = Locks.TryAdd(t1.Name, new Lock()
{
LockTimeoutMs = t1.TimeoutMs,
Name = t1.Name,
LockId = t1.LockId,
CreatedOn = t1.CreatedOn
});
if (!stringLockResult)
{
throw new ConflictingObjectLockException("String " + t1.Name + " is already locked.");
}
break;
case RemoveLock t1:
string lockName = t1.Name;
var objectLocksWithLockId = Locks.Where(ob => ob.Value.LockId == t1.LockId).Select(t => t.Value);
if (objectLocksWithLockId.Count() == 0)
{
throw new ConflictingObjectLockException("No lock with id " + t1.LockId);
}
Lock existingStringLock;
var removeStringLockResult = Locks.TryRemove(t1.Name, out existingStringLock);
if (!removeStringLockResult)
{
throw new ConflictingObjectLockException("String Lock " + t1.Name + " did not exist in locks.");
}
break;
default:
ApplyCommandToState(command);
break;
}
}
catch (Exception e)
{
throw new Exception("Failed to apply command " + command.CommandName + " to state with exception \"" + e.Message + "\"." + Environment.NewLine + JsonConvert.SerializeObject(command, Formatting.Indented));
}
}
public void WhenInboundHasProblemsOutboundJustKeepsOnTrucking(int numberOfMessages)
{
// arrange
var receivedMessageCount = 0;
var messageTracker = new ConcurrentDictionary <Guid, int>();
var resetEvent = new ManualResetEvent(false);
orderSystemHandlerActivator.Handle <PlaceOrderRequest>(req =>
{
if (req.What != "beer" || req.HowMuch != 12)
{
return;
}
OnCommit.Do(() =>
{
messageTracker.AddOrUpdate(req.MsgId, 1, (id, count) => count + 1);
var newValue = Interlocked.Increment(ref receivedMessageCount);
if (newValue >= numberOfMessages)
{
resetEvent.Set();
}
});
});
var timeout = numberOfMessages.Seconds();
var keepMakingChaos = true;
var chaosMonkey = new Thread(() =>
{
while (keepMakingChaos)
{
Thread.Sleep(0.1.Seconds());
inbound.Stop();
Console.WriteLine("Inbound stopped - {0} messages processed...", receivedMessageCount);
Thread.Sleep(0.2.Seconds());
inbound.Start();
Thread.Sleep(2.2331.Seconds());
}
});
// act
chaosMonkey.Start();
numberOfMessages.Times(() => pricedesk.Send(CreateMessage()));
// assert
var resetEventWasSet = resetEvent.WaitOne(timeout + 5.Seconds());
keepMakingChaos = false;
chaosMonkey.Join();
// chill, be more sure to empty the queue completely
Thread.Sleep(1.Seconds());
Assert.That(resetEventWasSet, Is.True, "Request was not received in order system within timeout of {0}", timeout);
receivedMessageCount.ShouldBeGreaterThanOrEqualTo(numberOfMessages);
Console.WriteLine("Actual number of received messages: {0}", receivedMessageCount);
if (messageTracker.Any(t => t.Value > 1))
{
Console.WriteLine(@"The following IDs were received more than once:
{0}", string.Join(Environment.NewLine, messageTracker.Where(t => t.Value > 1).Select(kvp => " " + kvp.Key + ": " + kvp.Value)));
}
messageTracker.Count.ShouldBe(numberOfMessages);
}
/// <summary>
/// Check if it's possible move readable pages to free list - if not possible, extend memory
/// </summary>
private void Extend()
{
// count how many pages in cache are available to be re-used (is not in use at this time)
var emptyShareCounter = _readable.Values.Count(x => x.ShareCounter == 0);
// get segmentSize
var segmentSize = _segmentSizes[Math.Min(_segmentSizes.Length - 1, _extends)];
// if this count is larger than MEMORY_SEGMENT_SIZE, re-use all this pages
if (emptyShareCounter > segmentSize)
{
// get all readable pages that can return to _free (slow way)
// sort by timestamp used (set as free oldest first)
var readables = _readable
.Where(x => x.Value.ShareCounter == 0)
.OrderBy(x => x.Value.Timestamp)
.Select(x => x.Key)
.Take(segmentSize)
.ToArray();
// move pages from readable list to free list
foreach (var key in readables)
{
var removed = _readable.TryRemove(key, out var page);
ENSURE(removed, "page should be in readable list before moving to free list");
// if removed page was changed between make array and now, must add back to readable list
if (page.ShareCounter > 0)
{
// but wait: between last "remove" and now, another thread can added this page
if (!_readable.TryAdd(key, page))
{
// this is a terrible situation, to avoid memory corruption I will throw expcetion for now
throw new LiteException(0, "MemoryCache: removed in-use memory page. This situation has no way to fix (yet). Throwing exception to avoid database corruption. No other thread can read/write from database now.");
}
}
else
{
ENSURE(page.ShareCounter == 0, "page should not be in use by anyone");
// clean controls
page.Position = long.MaxValue;
page.Origin = FileOrigin.None;
_free.Enqueue(page);
}
}
LOG($"re-using cache pages (flushing {_free.Count} pages)", "CACHE");
}
else
{
// create big linear array in heap memory (LOH => 85Kb)
var buffer = new byte[PAGE_SIZE * segmentSize];
var uniqueID = this.ExtendPages + 1;
// split linear array into many array slices
for (var i = 0; i < segmentSize; i++)
{
_free.Enqueue(new PageBuffer(buffer, i * PAGE_SIZE, uniqueID++));
}
_extends++;
LOG($"extending memory usage: (segments: {_extends})", "CACHE");
}
}
private bool DoWorkFrom(
ConcurrentDictionary<ITransferController, object> activeItems)
{
// Filter items with work only.
List<KeyValuePair<ITransferController, object>> activeItemsWithWork =
new List<KeyValuePair<ITransferController, object>>(
activeItems.Where(item => item.Key.HasWork && !item.Key.IsFinished));
if (0 != activeItemsWithWork.Count)
{
// Select random item and get work delegate.
int idx = this.randomGenerator.Next(activeItemsWithWork.Count);
ITransferController transferController = activeItemsWithWork[idx].Key;
DoControllerWork(transferController);
return true;
}
return false;
}
private static HashSet<uint> GetGamesToFarmSolo(ConcurrentDictionary<uint, float> gamesToFarm) {
if (gamesToFarm == null) {
Logging.LogNullError(nameof(gamesToFarm));
return null;
}
HashSet<uint> result = new HashSet<uint>();
foreach (KeyValuePair<uint, float> keyValue in gamesToFarm.Where(keyValue => keyValue.Value >= 2)) {
result.Add(keyValue.Key);
}
return result;
}
/// <summary>
/// Does not attempt to retrieve any data
/// </summary>
public IStreamReader Fetch(Symbol symbol, SubscriptionDataSource source, DateTime date, Resolution resolution, TickType tickType)
{
string entryName = null; // default to all entries
var filename = source.Source;
var hashIndex = source.Source.LastIndexOf("#", StringComparison.Ordinal);
if (hashIndex != -1)
{
entryName = source.Source.Substring(hashIndex + 1);
filename = source.Source.Substring(0, hashIndex);
}
if (!File.Exists(filename))
{
return(null);
}
// handles zip files
if (filename.GetExtension() == ".zip")
{
IStreamReader reader = null;
try
{
// cleaning the outdated cache items
if (_lastDate == DateTime.MinValue || _lastDate < date.Date)
{
// clean all items that that are older than _cachePeriodBars bars than the current date
foreach (var zip in _zipFileCache.Where(x => x.Value.Value.Item1 < date.Date.AddDays(-CachePeriodBars)))
{
// removing it from the cache
Lazy <CacheEntry> removed;
if (_zipFileCache.TryRemove(zip.Key, out removed))
{
// disposing zip archive
removed.Value.Item2.Dispose();
}
}
_lastDate = date.Date;
}
_zipFileCache.AddOrUpdate(filename,
x =>
{
var newItem = Tuple.Create(date.Date, new ZipFile(filename));
reader = new LocalFileSubscriptionStreamReader(newItem.Item2, entryName);
return(newItem);
},
(x, existingEntry) =>
{
reader = new LocalFileSubscriptionStreamReader(existingEntry.Item2, entryName);
return(existingEntry);
});
return(reader);
}
catch (Exception err)
{
Log.Error(err, "Inner try/catch");
if (reader != null)
{
reader.Dispose();
}
return(null);
}
}
else
{
// handles text files
return(new LocalFileSubscriptionStreamReader(filename, entryName));
}
}
private IEnumerable <ShellContext> GetShellsToRun(IEnumerable <ShellContext> shells)
{
var tenantsToRun = _schedulers.Where(s => s.Value.CanRun()).Select(s => s.Value.Tenant).Distinct().ToArray();
return(shells.Where(s => tenantsToRun.Contains(s.Settings.Name)).ToArray());
}
public Engine CheckoutScript(Func <ScriptedPatchRequest, Engine> createEngine, ScriptedPatchRequest request, RavenJObject customFunctions)
{
CachedResult value;
var patchRequestAndCustomFunctionsTuple = new ScriptedPatchRequestAndCustomFunctionsToken(request, customFunctions);
if (cacheDic.TryGetValue(patchRequestAndCustomFunctionsTuple, out value))
{
Interlocked.Increment(ref value.Usage);
Engine context;
if (value.Queue.TryDequeue(out context))
{
return(context);
}
}
var result = createEngine(request);
RavenJToken functions;
if (customFunctions != null && customFunctions.TryGetValue("Functions", out functions))
{
result.Execute(string.Format(@"var customFunctions = function() {{ var exports = {{ }}; {0};
return exports;
}}();
for(var customFunction in customFunctions) {{
this[customFunction] = customFunctions[customFunction];
}};", functions), new ParserOptions {
Source = "customFunctions.js"
});
}
var cachedResult = new CachedResult
{
Usage = 1,
Queue = new ConcurrentQueue <Engine>(),
Timestamp = SystemTime.UtcNow
};
cacheDic.AddOrUpdate(patchRequestAndCustomFunctionsTuple, cachedResult, (_, existing) =>
{
Interlocked.Increment(ref existing.Usage);
return(existing);
});
if (cacheDic.Count > CacheMaxSize)
{
foreach (var source in cacheDic
.Where(x => x.Value != null)
.OrderByDescending(x => x.Value.Usage)
.ThenBy(x => x.Value.Timestamp)
.Skip(CacheMaxSize - CacheMaxSize / 10))
{
if (Equals(source.Key, request))
{
continue; // we don't want to remove the one we just added
}
CachedResult ignored;
cacheDic.TryRemove(source.Key, out ignored);
}
foreach (var source in cacheDic.Where(x => x.Value == null))
{
CachedResult ignored;
cacheDic.TryRemove(source.Key, out ignored);
}
}
return(result);
}
/// <summary>
/// Processes all synchronous events that must take place before the next time loop for the algorithm
/// </summary>
public virtual void ProcessSynchronousEvents()
{
// how to do synchronous market orders for real brokerages?
// in backtesting we need to wait for orders to be removed from the queue and finished processing
if (!_algorithm.LiveMode)
{
if (_orderRequestQueue.IsBusy && !_orderRequestQueue.WaitHandle.WaitOne(Time.OneSecond, _cancellationTokenSource.Token))
{
Log.Error("BrokerageTransactionHandler.ProcessSynchronousEvents(): Timed out waiting for request queue to finish processing.");
}
return;
}
Log.Debug("BrokerageTransactionHandler.ProcessSynchronousEvents(): Enter");
// every morning flip this switch back
var currentTimeNewYork = DateTime.UtcNow.ConvertFromUtc(TimeZones.NewYork);
if (_syncedLiveBrokerageCashToday && currentTimeNewYork.Date != LastSyncDate)
{
_syncedLiveBrokerageCashToday = false;
}
// we want to sync up our cash balance before market open
if (_algorithm.LiveMode && !_syncedLiveBrokerageCashToday && currentTimeNewYork.TimeOfDay >= LiveBrokerageCashSyncTime)
{
try
{
// only perform cash syncs if we haven't had a fill for at least 10 seconds
if (TimeSinceLastFill > TimeSpan.FromSeconds(10))
{
PerformCashSync();
}
}
catch (Exception err)
{
Log.Error(err, "Updating cash balances");
}
}
// we want to remove orders older than 10k records, but only in live mode
const int maxOrdersToKeep = 10000;
if (_orders.Count < maxOrdersToKeep + 1)
{
Log.Debug("BrokerageTransactionHandler.ProcessSynchronousEvents(): Exit");
return;
}
int max = _orders.Max(x => x.Key);
int lowestOrderIdToKeep = max - maxOrdersToKeep;
foreach (var item in _orders.Where(x => x.Key <= lowestOrderIdToKeep))
{
Order value;
OrderTicket ticket;
_orders.TryRemove(item.Key, out value);
_orderTickets.TryRemove(item.Key, out ticket);
}
Log.Debug("BrokerageTransactionHandler.ProcessSynchronousEvents(): Exit");
}
private void RaiseProcessStatusesChangedEvent(List <ProcessStatus> processStatuses)
{
ProcessStatusesChanged?.Invoke(this, new ProcessStatusesEventArgs(processStatuses, _processStatusListeners.Where(x => x.Value).Select(x => x.Key).ToArray()));
}
private void FrmMain_Load(object sender, EventArgs e)
{
tsOnline.Text = "没有在线设备";
uid = Guid.NewGuid().ToString("N");
InitListView();
//测试地址
//txtAddress.Text = "183.62.237.211:18831";
ActConnetct = MonitorConnect;
#region 清理多包缓存
//定时清理缓存
thCache = new Thread(() =>
{
while (true)
{
if (dicPage.Count > 0)
{
foreach (var item in dicPage)
{
TimeSpan ts = DateTime.Now - item.Value.dt;
if (ts.TotalMinutes > 3)
{
lock (Pagelocker)
{
CacheData cd;
dicPage.TryRemove(item.Key, out cd);
AppLog.Warn($"清除设备编号为{cd.DeviceNo}的缓存包，包内容为->{cd.ToString()}");
this.statusStrip1.Invoke(new MethodInvoker(() =>
{
tsl.Text = $"清理一条缓存，还有{dicPage.Count}条缓存";
})
);
}
}
}
}
else
{
this.statusStrip1.Invoke((MethodInvoker) delegate()
{
tsl.Text = "没有缓存数据";
});
}
Thread.Sleep(new TimeSpan(0, 3, 0));
}
});
thCache.Start();
#endregion
#region 处理在线数据
thOnLine = new Thread(() =>
{
while (true)
{
if (dicOnLine.Count > 0)
{
lock (OnlineLocker)
{
foreach (var item in dicOnLine.Where(a => a.Value.IsWill == false))//只处理没有遗言的设备
{
TimeSpan ts = DateTime.Now - item.Value.Dt;
if (ts.TotalMinutes > 10)//如果10分钟没有设备上传数据，则判定改设备下线
{
OnlineData data;
dicOnLine.TryRemove(item.Key, out data);
//更改设备在线状态
HandleDeviceOnlineData(item.Key, false, data.Token, data.DeviceSn);
//从设备缓存中剔除出已掉线的设备(目的是更新设备缓存列表，处理设备no和sn不一致的问题)
//DicDevice.Remove(item.Key);
SetOnlineData();
}
}
}
}
Thread.Sleep(new TimeSpan(0, 3, 0));//每隔10分钟清理一次在线数据
}
});
thOnLine.Start();
#endregion
}
private string GetConnectionDispatcherChannel(string connectionId)
{
return(DispatcherConnections.Where(kvp => kvp.Value == connectionId)
.Select(kvp => new { kvp.Key, kvp.Value })
.FirstOrDefault()?.Key);
}
void RunHost()
{
try
{
while (!Terminated)
{
var listener = new TcpListener(RouterContext.Inst.LocalInterface, DefaultI2CPPort);
listener.Start();
try
{
listener.BeginAcceptTcpClient(HandleListenerAsyncCallback, listener);
while (!Terminated)
{
Thread.Sleep(10000);
var stuck = Sessions.Where(s =>
s.Value.LastReception.DeltaToNow > TickSpan.Minutes(30));
foreach (var one in stuck)
{
try
{
Logging.LogWarning($"{this}: Terminating stuck session {one} {one.Value.LastReception}");
one.Value.Terminate();
}
catch (Exception ex)
{
Logging.Log(ex);
}
}
var terminated = Sessions.Where(s =>
s.Value.CurrentState is null);
foreach (var one in terminated)
{
try
{
Logging.LogInformation($"{this}: Removing terminated session {one}");
Sessions.TryRemove(one.Key, out _);
}
catch (Exception ex)
{
Logging.Log(ex);
}
}
}
}
catch (ThreadAbortException ex)
{
Logging.Log(ex);
}
catch (Exception ex)
{
Logging.Log(ex);
}
finally
{
listener.Stop();
}
}
}
finally
{
Terminated = true;
Worker = null;
}
}
private bool IsMiscellaneousDocument(DocumentId documentId)
{
return(miscDocumentsProjectInfos.Where(p => p.Value.Id == documentId.ProjectId).Any());
}
public override ICollection <KeyValuePair <string, string> > GetAllValues(string prefix)
{
return(_secrets?.Where(s => s.Key.StartsWith(prefix, StringComparison.OrdinalIgnoreCase)).ToList());
}
public IEnumerable <KeyValuePair <string, string> > GetRange(string keyPrefix)
{
return(_dictionary.Where(keyValuePair => keyValuePair.Key.StartsWith(keyPrefix)));
}
private static HashSet<QueueId> GetQueuesOfImmatureSilos(ISiloStatusOracle siloStatusOracle,
ConcurrentDictionary<SiloAddress, bool> immatureSilos,
Dictionary<string, List<QueueId>> idealDistribution)
{
HashSet<QueueId> queuesOfImmatureSilos = new HashSet<QueueId>();
foreach (var silo in immatureSilos.Where(s => s.Value)) // take only those from immature set that have their immature status bit set
{
string siloName;
if (siloStatusOracle.TryGetSiloName(silo.Key, out siloName))
{
List<QueueId> queues;
if (idealDistribution.TryGetValue(siloName, out queues))
{
queuesOfImmatureSilos.UnionWith(queues);
}
}
}
return queuesOfImmatureSilos;
}
public Task <IEnumerable <string> > GetFollowing(string userHandle)
{
return(Task.FromResult(HandleToFollower.Where(x => x.Value.ContainsKey(userHandle)).Select(x => x.Key) ?? Enumerable.Empty <string>()));
}
public async Task LotsOfAsyncStuffGoingDown(int numberOfMessages)
{
var receivedMessages = 0;
var messageIds = new ConcurrentDictionary<int, int>();
Console.WriteLine("Sending {0} messages", numberOfMessages);
await Task.WhenAll(Enumerable.Range(0, numberOfMessages)
.Select(async i =>
{
using (var context = new DefaultTransactionContext())
{
await _transport.Send(QueueName, RecognizableMessage(i), context);
await context.Complete();
messageIds[i] = 0;
}
}));
Console.WriteLine("Receiving {0} messages", numberOfMessages);
using (var timer = new Timer(1000))
{
timer.Elapsed += delegate
{
Console.WriteLine("Received: {0} msgs", receivedMessages);
};
timer.Start();
await Task.WhenAll(Enumerable.Range(0, numberOfMessages)
.Select(async i =>
{
using (var context = new DefaultTransactionContext())
{
var msg = await _transport.Receive(context);
await context.Complete();
Interlocked.Increment(ref receivedMessages);
var id = int.Parse(msg.Headers["id"]);
messageIds.AddOrUpdate(id, 1, (_, existing) => existing + 1);
}
}));
await Task.Delay(1000);
}
Assert.That(messageIds.Keys.OrderBy(k => k).ToArray(), Is.EqualTo(Enumerable.Range(0, numberOfMessages).ToArray()));
var kvpsDifferentThanOne = messageIds.Where(kvp => kvp.Value != 1).ToList();
if (kvpsDifferentThanOne.Any())
{
Assert.Fail(@"Oh no! the following IDs were not received exactly once:
{0}",
string.Join(Environment.NewLine, kvpsDifferentThanOne.Select(kvp => string.Format(" {0}: {1}", kvp.Key, kvp.Value))));
}
}
private async Task clearOutdatedConnections()
{
while (runCleanUpTask)
{
try
{
foreach (var item in cache)
{
var queue = item.Value;
while (queue.Count > 0)
{
if (queue.TryDequeue(out var connection))
{
var cutOff = DateTime.Now.AddSeconds(-1 * server.ConnectionTimeOutSeconds);
if (!server.EnableConnectionPool ||
connection.LastAccess < cutOff)
{
disposalBag.Add(connection);
continue;
}
queue.Enqueue(connection);
break;
}
}
}
try
{
await @lock.WaitAsync();
//clear empty queues
var emptyKeys = cache.Where(x => x.Value.Count == 0).Select(x => x.Key).ToList();
foreach (string key in emptyKeys)
{
cache.TryRemove(key, out var _);
}
}
finally
{
@lock.Release();
}
while (!disposalBag.IsEmpty)
{
if (disposalBag.TryTake(out var connection))
{
connection?.Dispose();
}
}
}
catch (Exception e)
{
server.ExceptionFunc(new Exception("An error occurred when disposing server connections.", e));
}
finally
{
//cleanup every 3 seconds by default
await Task.Delay(1000 * 3);
}
}
}
public static void Main(string[] args)
{
Stopwatch sw = new Stopwatch();
sw.Start();
List<Basket> baskets = new List<Basket>();
ConcurrentDictionary<int, int> c1 = new ConcurrentDictionary<int, int>();
for (int i = 0; i < NUM_BASKETS; i++)
{
var basket = ReadBasket("../../../../new_data/modified_basket_" + i.ToString("000000") + ".dat");
baskets.Add(basket);
foreach (var item in basket.Items)
{
c1.AddOrUpdate(item.ItemId, 1, (key, value) => value + 1);
}
}
var f1 = c1.Where(x => x.Value >= s).Select(x => x.Key).ToList();
var c2 = new ConcurrentDictionary<Tuple<int, int>, int>();
foreach (var basket in baskets)
{
for (int i = 0; i < basket.Items.Count - 1; i++)
{
if (f1.Contains(basket.Items[i].ItemId))
{
for (int j = i + 1; j < basket.Items.Count; j++)
{
if (f1.Contains(basket.Items[j].ItemId))
{
c2.AddOrUpdate(new Tuple<int, int>(basket.Items[i].ItemId,
basket.Items[j].ItemId),
1, (key, value) => value + 1);
}
}
}
}
}
var f2 = c2.Where(x => x.Value >= s).ToList();
/*
* The pool of items that could be in a triple with support s consists of
* items that are in at least two pairs with support s
*/
var singleItems = new ConcurrentDictionary<int, int>();
foreach (var pair in f2)
{
singleItems.AddOrUpdate(pair.Key.Item1, 1, (key, value) => value + 1);
singleItems.AddOrUpdate(pair.Key.Item2, 1, (key, value) => value + 1);
}
var triplePool = singleItems.Keys.Where(x => x >= 2);
var c3 = new ConcurrentDictionary<Tuple<int, int, int>, int>();
foreach (var basket in baskets)
{
for (int i = 0; i < basket.Items.Count - 2; i++)
{
if (triplePool.Contains(basket.Items[i].ItemId))
{
for (int j = i + 1; j < basket.Items.Count - 1; j++)
{
if (triplePool.Contains(basket.Items[j].ItemId))
{
for (int k = j + 1; k < basket.Items.Count; k++)
{
if (triplePool.Contains(basket.Items[k].ItemId))
{
c3.AddOrUpdate(new Tuple<int, int, int>(basket.Items[i].ItemId,
basket.Items[j].ItemId,
basket.Items[k].ItemId),
1, (key, value) => value + 1);
}
}
}
}
}
}
}
var f3 = c3.Where(x => x.Value >= s).ToList();
using (var writer = new StreamWriter("../../../../output.txt"))
{
foreach (var itemSet in f3)
{
writer.WriteLine(PrintSet(itemSet));
}
}
// Stage 2
Dictionary<string, int> sentiments = File.ReadLines("../../../../sentiment.csv")
.Select(line => line.Split('\t'))
.ToDictionary(line => line[0], line => Int32.Parse(line[1]));
var triples = f3.Select(x => new Triple(x.Key.Item1, x.Key.Item2, x.Key.Item3)).ToList();
foreach (var triple in triples)
{
foreach (var basket in baskets)
{
var itemIds = basket.Items.Select(x => x.ItemId).ToList();
var day = GetDayOfWeek(basket.Weekday);
if(itemIds.Contains(triple.Ids[0]) && itemIds.Contains(triple.Ids[1])
&& itemIds.Contains(triple.Ids[2]))
{
foreach (var item in triple.Ids)
{
var itemReview = basket.Items.Where(i => i.ItemId == item).First().Review;
var score = getScore(sentiments, itemReview);
triple.AddSentiment(score, day);
}
}
}
}
using (var writer = new StreamWriter("../../../../outputPhase2.txt"))
{
writer.WriteLine("Set\tMonday\tTuesday\tWednesday\tThursday\tFriday\tSaturday\tSunday");
foreach (var triple in triples)
{
writer.WriteLine(PrintSetWithReviews(triple));
}
}
sw.Stop();
if (sw.ElapsedMilliseconds < 1000)
{
Console.WriteLine("\nProcessing Time: {0} milliseconds", sw.ElapsedMilliseconds);
}
else
{
Console.WriteLine("\nProcessing Time: {0:00}:{1:00}.{2:00}:{3:000}", sw.Elapsed.Hours, sw.Elapsed.Minutes, sw.Elapsed.Seconds, sw.Elapsed.Milliseconds);
}
Console.WriteLine("\nPress the any key to exit.");
Console.ReadKey();
}
public List <CommandRegistryItem> GetByCorrelationIds(string[] correlationIds) => _inner .Where(x => correlationIds.Contains(x.Key)) .Select(x => x.Value) .ToList();
public void WhenInboundHasProblemsOutboundJustKeepsOnTrucking(int numberOfMessages)
{
// arrange
var receivedMessageCount = 0;
var messageTracker = new ConcurrentDictionary<Guid, int>();
var resetEvent = new ManualResetEvent(false);
orderSystemHandlerActivator.Handle<PlaceOrderRequest>(req =>
{
if (req.What != "beer" || req.HowMuch != 12) return;
OnCommit.Do(() =>
{
messageTracker.AddOrUpdate(req.MsgId, 1, (id, count) => count + 1);
var newValue = Interlocked.Increment(ref receivedMessageCount);
if (newValue >= numberOfMessages)
{
resetEvent.Set();
}
});
});
var timeout = numberOfMessages.Seconds();
var keepMakingChaos = true;
var chaosMonkey = new Thread(() =>
{
while (keepMakingChaos)
{
Thread.Sleep(0.1.Seconds());
inbound.Stop();
Console.WriteLine("Inbound stopped - {0} messages processed...", receivedMessageCount);
Thread.Sleep(0.2.Seconds());
inbound.Start();
Thread.Sleep(2.2331.Seconds());
}
});
// act
chaosMonkey.Start();
numberOfMessages.Times(() => pricedesk.Send(CreateMessage()));
// assert
var resetEventWasSet = resetEvent.WaitOne(timeout + 5.Seconds());
keepMakingChaos = false;
chaosMonkey.Join();
// chill, be more sure to empty the queue completely
Thread.Sleep(1.Seconds());
Assert.That(resetEventWasSet, Is.True, "Request was not received in order system within timeout of {0}", timeout);
receivedMessageCount.ShouldBeGreaterThanOrEqualTo(numberOfMessages);
Console.WriteLine("Actual number of received messages: {0}", receivedMessageCount);
if (messageTracker.Any(t => t.Value > 1))
{
Console.WriteLine(@"The following IDs were received more than once:
{0}", string.Join(Environment.NewLine, messageTracker.Where(t => t.Value > 1).Select(kvp => " " + kvp.Key + ": " + kvp.Value)));
}
messageTracker.Count.ShouldBe(numberOfMessages);
}
public IEnumerable <object> Enumerate(Type type)
{
if (type == typeof(object))
{
type = null;
}
else if (type != null)
{
AutoRegisterType(type);
}
var taken = false;
ulong oid = 0;
ulong finalOid = _owner.GetLastAllocatedOid();
long prevProtectionCounter = 0;
try
{
while (true)
{
if (!taken)
{
_keyValueTrProtector.Start(ref taken);
}
if (oid == 0)
{
prevProtectionCounter = _keyValueTrProtector.ProtectionCounter;
_keyValueTr.SetKeyPrefix(ObjectDB.AllObjectsPrefix);
if (!_keyValueTr.FindFirstKey())
{
break;
}
}
else
{
if (_keyValueTrProtector.WasInterupted(prevProtectionCounter))
{
_keyValueTr.SetKeyPrefix(ObjectDB.AllObjectsPrefix);
oid++;
byte[] key = BuildKeyFromOid(oid);
if (_keyValueTr.FindKey(key, 0, key.Length, FindKeyStrategy.OnlyNext) == FindKeyResult.NotFound)
{
oid--;
break;
}
}
else
{
if (!_keyValueTr.FindNextKey())
{
break;
}
}
}
oid = ReadOidFromCurrentKeyInTransaction();
WeakReference weakObj;
if (_objCache.TryGetValue(oid, out weakObj))
{
var o = weakObj.Target;
if (o != null)
{
if (type == null || type.IsAssignableFrom(o.GetType()))
{
_keyValueTrProtector.Stop(ref taken);
yield return(o);
continue;
}
continue;
}
}
TableInfo tableInfo;
KeyValueDBValueReader reader = ReadObjStart(oid, out tableInfo);
if (type != null && !type.IsAssignableFrom(tableInfo.ClientType))
{
continue;
}
object obj = ReadObjFinish(oid, tableInfo, reader);
_keyValueTrProtector.Stop(ref taken);
yield return(obj);
}
}
finally
{
if (taken)
{
_keyValueTrProtector.Stop();
}
}
var dirtyObjsToEnum = _dirtyObjSet.Where(p => p.Key > oid && p.Key <= finalOid).ToList();
dirtyObjsToEnum.Sort((p1, p2) =>
{
if (p1.Key < p2.Key)
{
return(-1);
}
if (p1.Key > p2.Key)
{
return(1);
}
return(0);
});
foreach (var dObjPair in dirtyObjsToEnum)
{
object obj = dObjPair.Value;
if (type != null && !type.IsAssignableFrom(obj.GetType()))
{
continue;
}
yield return(obj);
}
}
public WallItemsComposer(ConcurrentDictionary <int, Item> items)
{
wallItems = items.Where(x => x.Value.Definition.HasBehaviour(ItemBehaviour.WALL_ITEM)).Select(x => x.Value).ToList();
owners = wallItems.GroupBy(x => x.Data.OwnerId).Select(p => p.First().Data.OwnerData).ToList(); // Create distinct list of room owners
}
public static IEnumerable <Room> GetEmptyRooms()
{
return(_rooms.Where(r => r.Value.Other == null).Select(r => r.Value));
}
