public Data.Blockchain ReadBlockchain(BlockchainKey blockchainKey)
{
CheckDatabaseFolder();
var blockListBuilder = ImmutableList.CreateBuilder <ChainedBlock>();
var utxoBuilder = ImmutableDictionary.CreateBuilder <UInt256, UnspentTx>();
var connString = @"Server=localhost; Database=BitSharp_Blockchains; Trusted_Connection=true;";
using (var conn = new SqlConnection(connString))
{
conn.Open();
using (var cmd = conn.CreateCommand())
{
cmd.CommandText = @"
SELECT BlockHash, PreviousBlockHash, Height, TotalWork
FROM ChainedBlocks
WHERE Guid = @guid AND RootBlockHash = @rootBlockHash
ORDER BY Height ASC";
cmd.Parameters.SetValue("@guid", SqlDbType.Binary, 16).Value = blockchainKey.Guid.ToByteArray();
cmd.Parameters.SetValue("@rootBlockHash", SqlDbType.Binary, 32).Value = blockchainKey.RootBlockHash.ToDbByteArray();
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
var blockHash = reader.GetUInt256(0);
var previousBlockHash = reader.GetUInt256(1);
var height = reader.GetInt32(2);
var totalWork = reader.GetBigInteger(3);
blockListBuilder.Add(new ChainedBlock(blockHash, previousBlockHash, height, totalWork));
}
}
}
using (var cmd = conn.CreateCommand())
{
cmd.CommandText = @"
SELECT UtxoChunkBytes
FROM UtxoData
WHERE Guid = @guid AND RootBlockHash = @rootBlockHash";
cmd.Parameters.SetValue("@guid", SqlDbType.Binary, 16).Value = blockchainKey.Guid.ToByteArray();
cmd.Parameters.SetValue("@rootBlockHash", SqlDbType.Binary, 32).Value = blockchainKey.RootBlockHash.ToDbByteArray();
using (var reader = cmd.ExecuteReader())
{
while (reader.Read())
{
var chunkBytes = reader.GetBytes(0);
var chunkStream = new MemoryStream(chunkBytes);
using (var chunkReader = new BinaryReader(chunkStream))
{
var chunkLength = chunkReader.Read4Bytes().ToIntChecked();
var outputs = new TxOutputKey[chunkLength];
for (var i = 0; i < chunkLength; i++)
{
var prevTxHash = chunkReader.Read32Bytes();
var prevTxOutputIndex = chunkReader.Read4Bytes();
outputs[i] = new TxOutputKey(prevTxHash, prevTxOutputIndex);
}
//TODO utxoBuilder.UnionWith(outputs);
}
}
}
}
}
return(new Data.Blockchain(blockListBuilder.ToImmutable(), blockListBuilder.Select(x => x.BlockHash).ToImmutableHashSet(), utxoBuilder.ToImmutable()));
}
protected override ImmutableList <I> SelectItems(ImmutableList <ItemData> .Builder listBuilder, ImmutableHashSet <string> globsToIgnore)
{
var itemsToAdd = ImmutableList.CreateBuilder <I>();
Lazy <Func <string, bool> > excludeTester = null;
ImmutableList <string> .Builder excludePatterns = ImmutableList.CreateBuilder <string>();
if (_excludes != null)
{
// STEP 4: Evaluate, split, expand and subtract any Exclude
foreach (string exclude in _excludes)
{
string excludeExpanded = _expander.ExpandIntoStringLeaveEscaped(exclude, ExpanderOptions.ExpandPropertiesAndItems, _itemElement.ExcludeLocation);
var excludeSplits = ExpressionShredder.SplitSemiColonSeparatedList(excludeExpanded);
excludePatterns.AddRange(excludeSplits);
}
if (excludePatterns.Count > 0)
{
excludeTester = new Lazy <Func <string, bool> >(() => EngineFileUtilities.GetFileSpecMatchTester(excludePatterns, _rootDirectory));
}
}
ISet <string> excludePatternsForGlobs = null;
foreach (var fragment in _itemSpec.Fragments)
{
if (fragment is ItemSpec <P, I> .ItemExpressionFragment itemReferenceFragment)
{
// STEP 3: If expression is "@(x)" copy specified list with its metadata, otherwise just treat as string
var itemsFromExpression = _expander.ExpandExpressionCaptureIntoItems(
itemReferenceFragment.Capture,
_evaluatorData,
_itemFactory,
ExpanderOptions.ExpandItems,
includeNullEntries: false,
isTransformExpression: out _,
elementLocation: _itemElement.IncludeLocation);
itemsToAdd.AddRange(
excludeTester != null
? itemsFromExpression.Where(item => !excludeTester.Value(item.EvaluatedInclude))
: itemsFromExpression);
}
else if (fragment is ValueFragment valueFragment)
{
string value = valueFragment.TextFragment;
if (excludeTester?.Value(EscapingUtilities.UnescapeAll(value)) != true)
{
var item = _itemFactory.CreateItem(value, value, _itemElement.ContainingProject.FullPath);
itemsToAdd.Add(item);
}
}
else if (fragment is GlobFragment globFragment)
{
// If this item is behind a false condition and represents a full drive/filesystem scan, expanding it is
// almost certainly undesired. It should be skipped to avoid evaluation taking an excessive amount of time.
bool skipGlob = !_conditionResult && globFragment.IsFullFileSystemScan && !Traits.Instance.EscapeHatches.AlwaysEvaluateDangerousGlobs && ChangeWaves.AreFeaturesEnabled(ChangeWaves.Wave16_8);
if (!skipGlob)
{
string glob = globFragment.TextFragment;
if (excludePatternsForGlobs == null)
{
excludePatternsForGlobs = BuildExcludePatternsForGlobs(globsToIgnore, excludePatterns);
}
string[] includeSplitFilesEscaped;
if (MSBuildEventSource.Log.IsEnabled())
{
MSBuildEventSource.Log.ExpandGlobStart(_rootDirectory, glob, string.Join(", ", excludePatternsForGlobs));
}
using (_lazyEvaluator._evaluationProfiler.TrackGlob(_rootDirectory, glob, excludePatternsForGlobs))
{
includeSplitFilesEscaped = EngineFileUtilities.GetFileListEscaped(
_rootDirectory,
glob,
excludePatternsForGlobs
);
}
if (MSBuildEventSource.Log.IsEnabled())
{
MSBuildEventSource.Log.ExpandGlobStop(_rootDirectory, glob, string.Join(", ", excludePatternsForGlobs));
}
foreach (string includeSplitFileEscaped in includeSplitFilesEscaped)
{
itemsToAdd.Add(_itemFactory.CreateItem(includeSplitFileEscaped, glob, _itemElement.ContainingProject.FullPath));
}
}
}
else
{
throw new InvalidOperationException(fragment.GetType().ToString());
}
}
return(itemsToAdd.ToImmutable());
}
static ImmutableList <int> .Builder createBuilder() => ImmutableList.CreateBuilder <int>();
public async Task ProcessAsync()
{
var options = _options;
var target = _options.Target ?? FindFallbackProjectFile();
target = new FileInfo(target).FullName;
WriteVerboseInfo($"Using project {target} as generation target.");
WriteVerboseInfo($"MSBuildLocator executing...");
MSBuildLocator.RegisterDefaults();
using (_workspace = MSBuildWorkspace.Create())
{
var projectsBuilder = ImmutableList.CreateBuilder <Project>();
_project = await _workspace.OpenProjectAsync(target);
if (_options.SourceProjects.Any())
{
foreach (var item in _options.SourceProjects)
{
WriteVerboseInfo($"Looking for project {item}.");
var found = _project.Solution.Projects.FirstOrDefault(p => p.Name == item);
if (found == null)
{
WriteErrorOutput($"Project {item} was not found. It needs to be referenced from the target project.");
Environment.Exit(404);
}
projectsBuilder.Add(found);
WriteVerboseInfo($"Found project {item}.");
}
}
else
{
projectsBuilder.Add(_project);
}
var projects = projectsBuilder.ToImmutable();
var interfacesPerProjectBuilder =
ImmutableDictionary.CreateBuilder <Project, ImmutableList <InterfaceDeclarationSyntax> >();
foreach (var project in projects)
{
var interfacesBuilder = ImmutableList.CreateBuilder <InterfaceDeclarationSyntax>();
foreach (var document in project.Documents)
{
var root = await document.GetSyntaxRootAsync();
var interfaces = root.DescendantNodes()
.OfType <InterfaceDeclarationSyntax>()
.Where(p => IsRestContract(p))
.ToImmutableList();
interfacesBuilder.AddRange(interfaces);
}
var allInterfacesPerProject = interfacesBuilder.ToImmutable();
interfacesPerProjectBuilder.Add(project, allInterfacesPerProject);
}
var interfacesPerProject = interfacesPerProjectBuilder.ToImmutable();
var foundInterfaces = interfacesPerProject.SelectMany(pair => pair.Value).ToImmutableList();
Console.WriteLine($"Found {foundInterfaces.Count} matching interfaces.");
if (_options.Verbose)
{
foreach (var item in foundInterfaces)
{
WriteVerboseInfo($"Found interface {item.Identifier.Text}");
}
}
foreach (var projectInterfacesPair in interfacesPerProject)
{
var project = projectInterfacesPair.Key;
var interfaces = projectInterfacesPair.Value;
var compilation = await project.GetCompilationAsync();
foreach (var item in interfaces)
{
var syntaxTree = item.SyntaxTree;
var semanticModel = compilation.GetSemanticModel(syntaxTree);
var interfaceSymbol = semanticModel.GetDeclaredSymbol(item);
await WriteTargetProxyClassAsync(interfaceSymbol);
}
}
}
_workspace = null;
_project = null;
}
private Tuple <ITargetBlock <Type>, Task <DiscoveredParts> > CreateDiscoveryBlockChain(bool typeExplicitlyRequested, IProgress <DiscoveryProgress>?progress, CancellationToken cancellationToken)
{
string status = Strings.ScanningMEFAssemblies;
int typesScanned = 0;
var transformBlock = new TransformBlock <Type, object?>(
type =>
{
try
{
return(this.CreatePart(type, typeExplicitlyRequested));
}
catch (Exception ex)
{
return(new PartDiscoveryException(string.Format(CultureInfo.CurrentCulture, Strings.FailureWhileScanningType, type.FullName), ex)
{
AssemblyPath = type.GetTypeInfo().Assembly.Location, ScannedType = type
});
}
},
new ExecutionDataflowBlockOptions
{
MaxDegreeOfParallelism = Debugger.IsAttached ? 1 : Environment.ProcessorCount,
CancellationToken = cancellationToken,
MaxMessagesPerTask = 10,
BoundedCapacity = 100,
});
var parts = ImmutableHashSet.CreateBuilder <ComposablePartDefinition>();
var errors = ImmutableList.CreateBuilder <PartDiscoveryException>();
var aggregatingBlock = new ActionBlock <object?>(partOrException =>
{
var part = partOrException as ComposablePartDefinition;
var error = partOrException as PartDiscoveryException;
Debug.Assert(partOrException is Exception == partOrException is PartDiscoveryException, "Wrong exception type returned.");
if (part != null)
{
parts.Add(part);
}
else if (error != null)
{
errors.Add(error);
}
progress.ReportNullSafe(new DiscoveryProgress(++typesScanned, 0, status));
});
transformBlock.LinkTo(aggregatingBlock, new DataflowLinkOptions {
PropagateCompletion = true
});
var tcs = new TaskCompletionSource <DiscoveredParts>();
Task.Run(async delegate
{
try
{
await aggregatingBlock.Completion.ConfigureAwait(false);
tcs.SetResult(new DiscoveredParts(parts.ToImmutable(), errors.ToImmutable()));
}
catch (Exception ex)
{
tcs.SetException(ex);
}
});
return(Tuple.Create <ITargetBlock <Type>, Task <DiscoveredParts> >(transformBlock, tcs.Task));
}
private static ImmutableList <ItemData> .Builder ComputeItems(LazyItemList lazyItemList, ImmutableHashSet <string> globsToIgnore)
{
// Stack of operations up to the first one that's cached (exclusive)
Stack <LazyItemList> itemListStack = new Stack <LazyItemList>();
ImmutableList <ItemData> .Builder items = null;
// Keep a separate stack of lists of globs to ignore that only gets modified for Remove operations
Stack <ImmutableHashSet <string> > globsToIgnoreStack = null;
for (var currentList = lazyItemList; currentList != null; currentList = currentList._previous)
{
var globsToIgnoreFromFutureOperations = globsToIgnoreStack?.Peek() ?? globsToIgnore;
ImmutableList <ItemData> itemsFromCache;
if (currentList._memoizedOperation.TryGetFromCache(globsToIgnoreFromFutureOperations, out itemsFromCache))
{
// the base items on top of which to apply the uncached operations are the items of the first operation that is cached
items = itemsFromCache.ToBuilder();
break;
}
// If this is a remove operation, then add any globs that will be removed
// to a list of globs to ignore in previous operations
var removeOperation = currentList._memoizedOperation.Operation as RemoveOperation;
if (removeOperation != null)
{
if (globsToIgnoreStack == null)
{
globsToIgnoreStack = new Stack <ImmutableHashSet <string> >();
}
var globsToIgnoreForPreviousOperations = removeOperation.GetRemovedGlobs();
foreach (var globToRemove in globsToIgnoreFromFutureOperations)
{
globsToIgnoreForPreviousOperations.Add(globToRemove);
}
globsToIgnoreStack.Push(globsToIgnoreForPreviousOperations.ToImmutable());
}
itemListStack.Push(currentList);
}
if (items == null)
{
items = ImmutableList.CreateBuilder <ItemData>();
}
ImmutableHashSet <string> currentGlobsToIgnore = globsToIgnoreStack == null ? globsToIgnore : globsToIgnoreStack.Peek();
// Walk back down the stack of item lists applying operations
while (itemListStack.Count > 0)
{
var currentList = itemListStack.Pop();
// If this is a remove operation, then it could modify the globs to ignore, so pop the potentially
// modified entry off the stack of globs to ignore
var removeOperation = currentList._memoizedOperation.Operation as RemoveOperation;
if (removeOperation != null)
{
globsToIgnoreStack.Pop();
currentGlobsToIgnore = globsToIgnoreStack.Count == 0 ? globsToIgnore : globsToIgnoreStack.Peek();
}
currentList._memoizedOperation.Apply(items, currentGlobsToIgnore);
}
return(items);
}
public void CreateBuilder()
{
ImmutableList <string> .Builder builder = ImmutableList.CreateBuilder <string>();
Assert.NotNull(builder);
}
public ChainBuilder()
{
this.blocks = ImmutableList.CreateBuilder <ChainedHeader>();
}
public object ReadJson(ref JReader reader)
{
string key = null;
int version = 0;
bool deleted = false;
bool on = false;
ImmutableList <Prerequisite> prerequisites = null;
ImmutableList <Target> targets = null;
ImmutableList <FlagRule> rules = null;
string salt = null;
VariationOrRollout fallthrough = new VariationOrRollout();
int?offVariation = null;
ImmutableList <LdValue> variations = null;
bool trackEvents = false, trackEventsFallthrough = false;
UnixMillisecondTime?debugEventsUntilDate = null;
bool clientSide = false;
for (var obj = reader.Object().WithRequiredProperties(_requiredProperties); obj.Next(ref reader);)
{
switch (obj.Name)
{
case var n when n == "key":
key = reader.String();
break;
case var n when n == "version":
version = reader.Int();
break;
case var n when n == "deleted":
deleted = reader.Bool();
break;
case var n when n == "on":
on = reader.Bool();
break;
case var n when n == "prerequisites":
var prereqsBuilder = ImmutableList.CreateBuilder <Prerequisite>();
for (var arr = reader.ArrayOrNull(); arr.Next(ref reader);)
{
prereqsBuilder.Add(ReadPrerequisite(ref reader));
}
prerequisites = prereqsBuilder.ToImmutable();
break;
case var n when n == "targets":
var targetsBuilder = ImmutableList.CreateBuilder <Target>();
for (var arr = reader.ArrayOrNull(); arr.Next(ref reader);)
{
targetsBuilder.Add(ReadTarget(ref reader));
}
targets = targetsBuilder.ToImmutable();
break;
case var n when n == "rules":
var rulesBuilder = ImmutableList.CreateBuilder <FlagRule>();
for (var arr = reader.ArrayOrNull(); arr.Next(ref reader);)
{
rulesBuilder.Add(ReadFlagRule(ref reader));
}
rules = rulesBuilder.ToImmutable();
break;
case var n when n == "fallthrough":
fallthrough = ReadVariationOrRollout(ref reader);
break;
case var n when n == "offVariation":
offVariation = reader.IntOrNull();
break;
case var n when n == "variations":
variations = SerializationHelpers.ReadValues(ref reader);
break;
case var n when n == "salt":
salt = reader.StringOrNull();
break;
case var n when n == "trackEvents":
trackEvents = reader.Bool();
break;
case var n when n == "trackEventsFallthrough":
trackEventsFallthrough = reader.Bool();
break;
case var n when n == "debugEventsUntilDate":
var dt = reader.LongOrNull();
debugEventsUntilDate = dt.HasValue ? UnixMillisecondTime.OfMillis(dt.Value) : (UnixMillisecondTime?)null;
break;
case var n when n == "clientSide":
clientSide = reader.Bool();
break;
}
}
if (key is null && !deleted)
{
throw new RequiredPropertyException("key", 0);
}
return(new FeatureFlag(key, version, deleted, on, prerequisites, targets, rules, fallthrough,
offVariation, variations, salt, trackEvents, trackEventsFallthrough, debugEventsUntilDate, clientSide));
}
public Builder(BlockId id) : base(id)
{
_statements = ImmutableList.CreateBuilder <AstStatement>();
}
public static ImmutableList <MediaTrack> FromSdp(SessionDescription sdp, Uri baseUri, MimeType filter = null)
{
var builder = ImmutableList.CreateBuilder <MediaTrack>();
string sdpConnectionAddr = baseUri.Host;
if (sdp.Connection != null && IsAddressSet(sdp.Connection.Address))
{
sdpConnectionAddr = sdp.Connection.Address;
}
sdp.MediaDescriptions.ForEach(md =>
{
Uri controlUri = baseUri;
string type = md.Media.ToString().ToLower();
string subType = "unknown";
// Prefer the media description's connection address over the sdp connection address.
var connectionAddr = md.Connection != null && !string.IsNullOrEmpty(md.Connection.Address)
? md.Connection.Address
: sdpConnectionAddr;
var rtmpmaps = md.GetRtpMaps();
// Via spec there can be multiple types and rtpmaps, but
// we will assume a single one since all cameras/encoders
// appear to only provide one per Media Description.
var rtpmap = rtmpmaps.IsEmpty ? FromPayloadType(md.MediaFormats[0]) : rtmpmaps.First();
subType = rtpmap.EncodingName;
var control = md.Attributes.Where(a => "control" == a.Name).DefaultIfEmpty(null).First();
if (control != null)
{
controlUri = ResolveUri(baseUri, new Uri(control.Value, UriKind.RelativeOrAbsolute));
}
var mimeType = MimeType.Create(type, rtpmap.EncodingName);
if (mimeType.Is(APPLICATION_SPOOFED))
{
// The MediaGateway and Vxpro us spoofing to determine the client's intentions of
// either playing live or recorded data. Because of the current design they do not
// have a way to know the client's intentions until a play call is issued that contains
// and RTSP Range header with an absolute start-time.
//
// To handle metadata, in a pretty hacky way, a new media description is added to the SDP
// of type application/vnd.pelco.spoofed to indicate to a client that the data is bogus
// The client should continue processing up until the play call is made. At this point the
// MediaGateway or VxPro will issues a redirect to the actual source.
//
// We will make a bogus metadata track to allow the client to continue processing.
builder.Add(MediaTrack.CreateBuilder()
.Address(Dns.GetHostAddresses(baseUri.Host)[0])
.Port(md.Port)
.Type(mimeType)
.Uri(controlUri)
.Build());
}
else if ((filter != null && mimeType.Is(filter)) || (filter == null))
{
// If a filter is defined only return tracks that match the
// defined filter type; otherwise, return all tracks.
if (IsAddressSet(connectionAddr))
{
// If defined as 0.0.0.0 or ::0 then replace with the SDP connection address.
connectionAddr = sdpConnectionAddr;
}
var addrs = Dns.GetHostAddresses(connectionAddr);
builder.Add(MediaTrack.CreateBuilder()
.Address(Dns.GetHostAddresses(connectionAddr)[0])
.Port(md.Port)
.RtpMap(rtpmap)
.Type(mimeType)
.Uri(controlUri)
.Build());
}
});
return(builder.ToImmutable());
}
public ConcurrentListBuilder()
{
this.builder = ImmutableList.CreateBuilder <T>();
this.builderLock = new ReaderWriterLockSlim();
}
private BlockFlow DecodeBlockFlow(
LNode node,
FlowGraphBuilder graph,
Dictionary <Symbol, BasicBlockBuilder> blocks,
Dictionary <Symbol, ValueTag> valueTags)
{
if (node.Calls(CodeSymbols.Goto))
{
Branch target;
if (FeedbackHelpers.AssertArgCount(node, 1, Log) &&
AssertDecodeBranch(node.Args[0], graph, blocks, valueTags, out target))
{
return(new JumpFlow(target));
}
else
{
return(UnreachableFlow.Instance);
}
}
else if (node.Calls(CodeSymbols.Switch))
{
// Decode the value being switched on as well as the default branch.
Instruction switchVal;
Branch defaultTarget;
if (FeedbackHelpers.AssertArgCount(node, 3, Log) &&
AssertDecodeInstruction(node.Args[0], valueTags, out switchVal) &&
AssertDecodeBranch(node.Args[1], graph, blocks, valueTags, out defaultTarget))
{
// Decode the switch cases.
var switchCases = ImmutableList.CreateBuilder <SwitchCase>();
foreach (var caseNode in node.Args[2].Args)
{
if (!FeedbackHelpers.AssertArgCount(caseNode, 2, Log) ||
!FeedbackHelpers.AssertIsCall(caseNode.Args[0], Log))
{
continue;
}
var constants = ImmutableHashSet.CreateRange <Constant>(
caseNode.Args[0].Args
.Select(DecodeConstant)
.Where(x => x != null));
Branch caseTarget;
if (AssertDecodeBranch(caseNode.Args[1], graph, blocks, valueTags, out caseTarget))
{
switchCases.Add(new SwitchCase(constants, caseTarget));
}
}
return(new SwitchFlow(switchVal, switchCases.ToImmutable(), defaultTarget));
}
else
{
return(UnreachableFlow.Instance);
}
}
else if (node.Calls(CodeSymbols.Return))
{
Instruction retValue;
if (FeedbackHelpers.AssertArgCount(node, 1, Log) &&
AssertDecodeInstruction(node.Args[0], valueTags, out retValue))
{
return(new ReturnFlow(retValue));
}
else
{
return(UnreachableFlow.Instance);
}
}
else if (node.Calls(CodeSymbols.Try))
{
Instruction tryValue;
Branch successBranch;
Branch exceptionBranch;
if (FeedbackHelpers.AssertArgCount(node, 3, Log) &&
AssertDecodeInstruction(node.Args[0], valueTags, out tryValue) &&
AssertDecodeBranch(node.Args[1], graph, blocks, valueTags, out successBranch) &&
AssertDecodeBranch(node.Args[2], graph, blocks, valueTags, out exceptionBranch))
{
return(new TryFlow(tryValue, successBranch, exceptionBranch));
}
else
{
return(UnreachableFlow.Instance);
}
}
else if (node.IsIdNamed(EncoderState.unreachableFlowSymbol))
{
return(UnreachableFlow.Instance);
}
else
{
FeedbackHelpers.LogSyntaxError(
Log,
node,
Quotation.QuoteEvenInBold(
"unknown type of flow; expected one of ",
CodeSymbols.Goto.Name, ", ",
CodeSymbols.Switch.Name, ", ",
CodeSymbols.Try.Name, ", ",
CodeSymbols.Return.Name, " or ",
EncoderState.unreachableFlowSymbol.Name, "."));
return(UnreachableFlow.Instance);
}
}
/// <summary>
/// TBD
/// </summary>
/// <param name="currentShardAllocations">TBD</param>
/// <param name="rebalanceInProgress">TBD</param>
/// <returns>TBD</returns>
public override Task <IImmutableSet <ShardId> > Rebalance(IImmutableDictionary <IActorRef, IImmutableList <ShardId> > currentShardAllocations, IImmutableSet <ShardId> rebalanceInProgress)
{
int Limit(int numberOfShards)
{
return(Math.Max(1, Math.Min((int)(_relativeLimit * numberOfShards), _absoluteLimit)));
}
IImmutableSet <ShardId> RebalancePhase1(
int numberOfShards,
int optimalPerRegion,
IImmutableList <RegionEntry> sortedEntries
)
{
var selected = ImmutableList.CreateBuilder <ShardId>();
foreach (var entry in sortedEntries)
{
if (entry.ShardIds.Count > optimalPerRegion)
{
selected.AddRange(entry.ShardIds.Take(entry.ShardIds.Count - optimalPerRegion));
}
}
var result = selected.ToImmutable();
return(result.Take(Limit(numberOfShards)).ToImmutableHashSet());
}
Task <IImmutableSet <ShardId> > RebalancePhase2(
int numberOfShards,
int optimalPerRegion,
IImmutableList <RegionEntry> sortedEntries)
{
// In the first phase the optimalPerRegion is rounded up, and depending on number of shards per region and number
// of regions that might not be the exact optimal.
// In second phase we look for diff of >= 2 below optimalPerRegion and rebalance that number of shards.
var countBelowOptimal = sortedEntries.Select(entry => Math.Max(0, (optimalPerRegion - 1) - entry.ShardIds.Count)).Sum();
if (countBelowOptimal == 0)
{
return(emptyRebalanceResult);
}
else
{
var selected = ImmutableList.CreateBuilder <ShardId>();
foreach (var entry in sortedEntries)
{
if (entry.ShardIds.Count >= optimalPerRegion)
{
selected.Add(entry.ShardIds.First());
}
}
var result = selected.ToImmutable().Take(Math.Min(countBelowOptimal, Limit(numberOfShards))).ToImmutableHashSet();
return(Task.FromResult <IImmutableSet <ShardId> >(result));
}
}
if (rebalanceInProgress.Count > 0)
{
// one rebalance at a time
return(emptyRebalanceResult);
}
else
{
var sortedRegionEntries = RegionEntriesFor(currentShardAllocations).OrderBy(i => i, ShardSuitabilityOrdering.Instance).ToImmutableList();
if (!IsAGoodTimeToRebalance(sortedRegionEntries))
{
return(emptyRebalanceResult);
}
else
{
var numberOfShards = sortedRegionEntries.Select(i => i.ShardIds.Count).Sum();
var numberOfRegions = sortedRegionEntries.Count;
if (numberOfRegions == 0 || numberOfShards == 0)
{
return(emptyRebalanceResult);
}
else
{
var optimalPerRegion = numberOfShards / numberOfRegions + ((numberOfShards % numberOfRegions == 0) ? 0 : 1);
var result1 = RebalancePhase1(numberOfShards, optimalPerRegion, sortedRegionEntries);
if (result1.Count > 0)
{
return(Task.FromResult <IImmutableSet <ShardId> >(result1));
}
else
{
return(RebalancePhase2(numberOfShards, optimalPerRegion, sortedRegionEntries));
}
}
}
}
}
//This function builds and returns an ImmutableList of Client objects.
private static ImmutableList <Client> BuildImmutableList()
{
var builder = ImmutableList.CreateBuilder <Client>();
return(builder.ToImmutableList());
}
public Constraints11ConstraintElement(
IdIndexElement dIndexElement,
IwIndexElement wIndexElement,
Id d,
Il l,
Ipa pa,
IP P,
Iprob prob,
ITPx x,
Iμ μ)
{
Expression LHS = μ.Value[wIndexElement, dIndexElement];
ImmutableList <Tuple <IpIndexElement, IaIndexElement, double> > .Builder builder = ImmutableList.CreateBuilder <Tuple <IpIndexElement, IaIndexElement, double> >();
foreach (IpIndexElement pIndexElement in pa.Value.Where(i => P.IsThereElementAt(wIndexElement, i.pIndexElement)).Select(w => w.pIndexElement).Distinct())
{
foreach (IaIndexElement aIndexElement in pa.Value.Select(w => w.aIndexElement).Distinct())
{
int dLowerBound = aIndexElement.Key <= dIndexElement.Key ? dIndexElement.Key - aIndexElement.Key : d.GetMaximumKey() + dIndexElement.Key - aIndexElement.Key;
double RHSSum = 0;
for (int w = dLowerBound;
w <= l.GetMaximumLengthOfStay();
w = w + 1)
{
RHSSum +=
(double)prob.GetElementAtAsdecimal(
pIndexElement,
l.GetElementAt(
w));
}
builder.Add(
Tuple.Create(
pIndexElement,
aIndexElement,
RHSSum));
}
}
ImmutableList <Tuple <IpIndexElement, IaIndexElement, double> > RHSSums = builder.ToImmutableList();
Expression RHS = Expression.Sum(
pa.Value
.Where(i => P.IsThereElementAt(wIndexElement, i.pIndexElement))
.Select(
y =>
RHSSums.Where(w => w.Item1 == y.pIndexElement && w.Item2 == y.aIndexElement).Select(w => w.Item3).SingleOrDefault()
*
x.Value[
y.pIndexElement,
y.aIndexElement]));
this.Value = LHS == RHS;
}
protected override ComposablePartDefinition?CreatePart(Type partType, bool typeExplicitlyRequested)
{
Requires.NotNull(partType, nameof(partType));
var partTypeInfo = partType.GetTypeInfo();
// We want to ignore abstract classes, but we want to consider static classes.
// Static classes claim to be both abstract and sealed. So to ignore just abstract
// ones, we check that they are not sealed.
if (partTypeInfo.IsAbstract && !partTypeInfo.IsSealed)
{
return(null);
}
BindingFlags everythingLocal = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
BindingFlags instanceLocal = BindingFlags.DeclaredOnly | BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic;
// If the type is abstract only find local static exports
var exportBindingFlags = everythingLocal;
if (partTypeInfo.IsAbstract)
{
exportBindingFlags &= ~BindingFlags.Instance;
}
var declaredMethods = partType.GetMethods(exportBindingFlags); // methods can only export, not import
var declaredProperties = partType.GetProperties(everythingLocal);
var declaredFields = partType.GetFields(everythingLocal);
var allLocalMembers = declaredMethods.Concat <MemberInfo>(declaredProperties).Concat(declaredFields);
var exportingMembers = from member in allLocalMembers
from export in member.GetAttributes <ExportAttribute>()
select new KeyValuePair <MemberInfo, ExportAttribute>(member, export);
var exportedTypes = from export in partTypeInfo.GetAttributes <ExportAttribute>()
select new KeyValuePair <MemberInfo, ExportAttribute>(partTypeInfo, export);
var inheritedExportedTypes = from baseTypeOrInterface in partType.GetInterfaces().Concat(partType.EnumTypeAndBaseTypes().Skip(1))
where baseTypeOrInterface != typeof(object)
from export in baseTypeOrInterface.GetTypeInfo().GetAttributes <InheritedExportAttribute>()
select new KeyValuePair <MemberInfo, ExportAttribute>(baseTypeOrInterface.GetTypeInfo(), export);
var exportsByMember = (from export in exportingMembers.Concat(exportedTypes).Concat(inheritedExportedTypes)
group export.Value by export.Key into exportsByType
select exportsByType).Select(g => new KeyValuePair <MemberInfo, ExportAttribute[]>(g.Key, g.ToArray())).ToArray();
if (exportsByMember.Length == 0)
{
return(null);
}
// Check for PartNotDiscoverable only after we've established it's an interesting part.
// This optimizes for the fact that most types have no exports, in which case it's not a discoverable
// part anyway. Checking for the PartNotDiscoverableAttribute first, which is rarely defined,
// doesn't usually pay for itself in terms of short-circuiting. But it does add an extra
// attribute to look for that we don't need to find for all the types that have no export attributes either.
if (!typeExplicitlyRequested && partTypeInfo.IsAttributeDefined <PartNotDiscoverableAttribute>())
{
return(null);
}
foreach (var exportingMember in exportsByMember)
{
this.ThrowOnInvalidExportingMember(exportingMember.Key);
}
TypeRef partTypeRef = TypeRef.Get(partType, this.Resolver);
Type? partTypeAsGenericTypeDefinition = partTypeInfo.IsGenericType ? partType.GetGenericTypeDefinition() : null;
// Collect information for all imports.
var imports = ImmutableList.CreateBuilder <ImportDefinitionBinding>();
this.AddImportsFromMembers(declaredProperties, declaredFields, partTypeRef, imports);
Type?baseType = partTypeInfo.BaseType;
while (baseType != null && baseType != typeof(object))
{
this.AddImportsFromMembers(baseType.GetProperties(instanceLocal), baseType.GetFields(instanceLocal), partTypeRef, imports);
baseType = baseType.GetTypeInfo().BaseType;
}
var partCreationPolicy = CreationPolicy.Any;
var partCreationPolicyAttribute = partTypeInfo.GetFirstAttribute <PartCreationPolicyAttribute>();
if (partCreationPolicyAttribute != null)
{
partCreationPolicy = (CreationPolicy)partCreationPolicyAttribute.CreationPolicy;
}
var allExportsMetadata = ImmutableDictionary.CreateRange(PartCreationPolicyConstraint.GetExportMetadata(partCreationPolicy));
var inheritedExportContractNamesFromNonInterfaces = ImmutableHashSet.CreateBuilder <string>();
var exportDefinitions = ImmutableList.CreateBuilder <KeyValuePair <MemberInfo, ExportDefinition> >();
foreach (var export in exportsByMember)
{
var memberExportMetadata = allExportsMetadata.AddRange(GetExportMetadata(export.Key));
if (export.Key is MethodInfo method)
{
var exportAttributes = export.Value;
if (exportAttributes.Any())
{
foreach (var exportAttribute in exportAttributes)
{
Type exportedType = exportAttribute.ContractType ?? ReflectionHelpers.GetContractTypeForDelegate(method);
string contractName = string.IsNullOrEmpty(exportAttribute.ContractName) ? GetContractName(exportedType) : exportAttribute.ContractName;
var exportMetadata = memberExportMetadata
.Add(CompositionConstants.ExportTypeIdentityMetadataName, ContractNameServices.GetTypeIdentity(exportedType));
var exportDefinition = new ExportDefinition(contractName, exportMetadata);
exportDefinitions.Add(new KeyValuePair <MemberInfo, ExportDefinition>(export.Key, exportDefinition));
}
}
}
else
{
MemberInfo exportingTypeOrPropertyOrField = export.Key;
Verify.Operation(export.Key is TypeInfo || !partTypeInfo.IsGenericTypeDefinition, Strings.ExportsOnMembersNotAllowedWhenDeclaringTypeGeneric);
Type exportSiteType = ReflectionHelpers.GetMemberType(exportingTypeOrPropertyOrField);
foreach (var exportAttribute in export.Value)
{
Type exportedType = exportAttribute.ContractType ?? partTypeAsGenericTypeDefinition ?? exportSiteType;
string contractName = string.IsNullOrEmpty(exportAttribute.ContractName) ? GetContractName(exportedType) : exportAttribute.ContractName;
if (export.Key is TypeInfo && exportAttribute is InheritedExportAttribute)
{
if (inheritedExportContractNamesFromNonInterfaces.Contains(contractName))
{
// We already have an export with this contract name on this type (from a more derived type)
// using InheritedExportAttribute.
continue;
}
if (!((TypeInfo)export.Key).IsInterface)
{
inheritedExportContractNamesFromNonInterfaces.Add(contractName);
}
}
var exportMetadata = memberExportMetadata
.Add(CompositionConstants.ExportTypeIdentityMetadataName, ContractNameServices.GetTypeIdentity(exportedType));
var exportDefinition = new ExportDefinition(contractName, exportMetadata);
exportDefinitions.Add(new KeyValuePair <MemberInfo, ExportDefinition>(export.Key, exportDefinition));
}
}
}
MethodInfo?onImportsSatisfied = null;
if (typeof(IPartImportsSatisfiedNotification).IsAssignableFrom(partType))
{
onImportsSatisfied = OnImportsSatisfiedMethodInfo;
}
var importingConstructorParameters = ImmutableList.CreateBuilder <ImportDefinitionBinding>();
var importingCtor = GetImportingConstructor <ImportingConstructorAttribute>(partType, publicOnly: false);
if (importingCtor != null) // some parts have exports merely for metadata -- they can't be instantiated
{
foreach (var parameter in importingCtor.GetParameters())
{
var import = this.CreateImport(parameter);
if (import.ImportDefinition.Cardinality == ImportCardinality.ZeroOrMore)
{
Verify.Operation(PartDiscovery.IsImportManyCollectionTypeCreateable(import), Strings.CollectionMustBePublicAndPublicCtorWhenUsingImportingCtor);
}
importingConstructorParameters.Add(import);
}
}
var partMetadata = ImmutableDictionary.CreateBuilder <string, object?>();
foreach (var partMetadataAttribute in partTypeInfo.GetAttributes <PartMetadataAttribute>())
{
partMetadata[partMetadataAttribute.Name] = partMetadataAttribute.Value;
}
var exportsOnType = exportDefinitions.Where(kv => kv.Key is TypeInfo).Select(kv => kv.Value).ToArray();
var exportsOnMembers = (from kv in exportDefinitions
where !(kv.Key is TypeInfo)
group kv.Value by kv.Key into byMember
select byMember).ToDictionary(g => MemberRef.Get(g.Key, this.Resolver), g => (IReadOnlyCollection <ExportDefinition>)g.ToArray());
var assemblyNamesForMetadataAttributes = ImmutableHashSet.CreateBuilder <AssemblyName>(ByValueEquality.AssemblyName);
foreach (var export in exportsByMember)
{
GetAssemblyNamesFromMetadataAttributes <MetadataAttributeAttribute>(export.Key, assemblyNamesForMetadataAttributes);
}
return(new ComposablePartDefinition(
TypeRef.Get(partType, this.Resolver),
partMetadata.ToImmutable(),
exportsOnType,
exportsOnMembers,
imports.ToImmutable(),
partCreationPolicy != CreationPolicy.NonShared ? string.Empty : null,
MethodRef.Get(onImportsSatisfied, this.Resolver),
MethodRef.Get(importingCtor, this.Resolver),
importingCtor != null ? importingConstructorParameters.ToImmutable() : null, // some MEF parts are only for metadata
partCreationPolicy,
assemblyNamesForMetadataAttributes,
partCreationPolicy != CreationPolicy.NonShared));
}
static DeviceInfo()
{
var macAddresses = ImmutableDictionary.CreateBuilder <string, string>();
using (var mo = new ManagementObjectSearcher(@"
SELECT
MACAddress, Name
FROM
Win32_NetworkAdapter
WHERE
(MACAddress IS NOT NULL) AND
(PNPDeviceID LIKE 'PCI\\%')")
.Get())
foreach (var obj in mo)
{
macAddresses.Add(obj["Name"] as string, (obj["MACAddress"] as string).Replace(":", null));
}
MacAddresses = macAddresses.ToImmutable();
var cpus = ImmutableArray.CreateBuilder <string>();
using (var mo = new ManagementObjectSearcher(@"
SELECT
Name
FROM
Win32_Processor")
.Get())
foreach (var obj in mo)
{
cpus.Add(obj["Name"] as string);
}
CPUs = cpus.ToImmutable();
var gpus = ImmutableDictionary.CreateBuilder <string, uint>();
using (var mo = new ManagementObjectSearcher(@"
SELECT
Name, AdapterRAM
FROM
Win32_VideoController")
.Get())
foreach (var obj in mo)
{
gpus.Add(obj["Name"] as string, (uint)obj["AdapterRAM"] / (1 << 30));
}
GPUs = gpus.ToImmutable();
var disks = ImmutableDictionary.CreateBuilder <string, ulong>();
using (var mo = new ManagementObjectSearcher(@"
SELECT
Caption, Size
FROM
Win32_DiskDrive")
.Get())
foreach (var obj in mo)
{
disks.Add(obj["Caption"] as string, (ulong)obj["Size"] / (1 << 30));
}
Disks = disks.ToImmutable();
var rams = ImmutableList.CreateBuilder <ulong>();
using (var mo = new ManagementObjectSearcher(@"
SELECT
Capacity
FROM
Win32_PhysicalMemory")
.Get())
foreach (var obj in mo)
{
rams.Add((ulong)obj["Capacity"] / (1 << 30));
}
RAMs = rams.ToImmutable();
int i = 0;
BigInteger big = 1;
using (var mos = new ManagementObjectSearcher(@"
SELECT
SerialNumber
FROM
Win32_DiskDrive")
.Get())
{
foreach (var mo in mos.Cast <ManagementObject>()
.OrderBy(x => x.Properties["SerialNumber"].Value as string))
{
big ^= (new BigInteger(Encoding.UTF8.GetBytes(mo["SerialNumber"] as string)) << i++);
}
}
using (var mos = new ManagementObjectSearcher(@"
SELECT
MACAddress
FROM
Win32_NetworkAdapter
WHERE
(MACAddress IS NOT NULL) AND
(PNPDeviceID LIKE 'PCI\\%')")
.Get())
{
foreach (var mo in mos.Cast <ManagementObject>()
.OrderBy(x => x.Properties["MACAddress"].Value as string))
{
big ^= (new BigInteger(Encoding.UTF8.GetBytes(mo["MACAddress"] as string)) << i++);
}
}
Identifier = Convert.ToBase64String(big.ToByteArray());
}
protected override ComposablePartDefinition CreatePart(Type partType, bool typeExplicitlyRequested)
{
Requires.NotNull(partType, nameof(partType));
if (!typeExplicitlyRequested)
{
bool isPublic = partType.IsNested ? partType.IsNestedPublic : partType.IsPublic;
if (!this.IsNonPublicSupported && !isPublic)
{
// Skip non-public types.
return(null);
}
}
var declaredProperties = partType.GetProperties(BindingFlags.Instance | this.PublicVsNonPublicFlags);
var exportingProperties = from member in declaredProperties
from export in member.GetAttributes <ExportAttribute>()
select new KeyValuePair <MemberInfo, ExportAttribute>(member, export);
var exportedTypes = from export in partType.GetAttributes <ExportAttribute>()
select new KeyValuePair <MemberInfo, ExportAttribute>(partType, export);
var exportsByMember = (from export in exportingProperties.Concat(exportedTypes)
group export.Value by export.Key into exportsByType
select exportsByType).Select(g => new KeyValuePair <MemberInfo, ExportAttribute[]>(g.Key, g.ToArray())).ToArray();
if (exportsByMember.Length == 0)
{
return(null);
}
// Check for PartNotDiscoverable only after we've established it's an interesting part.
// This optimizes for the fact that most types have no exports, in which case it's not a discoverable
// part anyway. Checking for the PartNotDiscoverableAttribute first, which is rarely defined,
// doesn't usually pay for itself in terms of short-circuiting. But it does add an extra
// attribute to look for that we don't need to find for all the types that have no export attributes either.
if (!typeExplicitlyRequested && partType.IsAttributeDefined <PartNotDiscoverableAttribute>())
{
return(null);
}
TypeRef partTypeRef = TypeRef.Get(partType, this.Resolver);
Type partTypeAsGenericTypeDefinition = partType.IsGenericType ? partType.GetGenericTypeDefinition() : null;
string sharingBoundary = null;
var sharedAttribute = partType.GetFirstAttribute <SharedAttribute>();
if (sharedAttribute != null)
{
sharingBoundary = sharedAttribute.SharingBoundary ?? string.Empty;
}
CreationPolicy partCreationPolicy = sharingBoundary != null ? CreationPolicy.Shared : CreationPolicy.NonShared;
var allExportsMetadata = ImmutableDictionary.CreateRange(PartCreationPolicyConstraint.GetExportMetadata(partCreationPolicy));
var exportsOnType = ImmutableList.CreateBuilder <ExportDefinition>();
var exportsOnMembers = ImmutableDictionary.CreateBuilder <MemberRef, IReadOnlyCollection <ExportDefinition> >();
var imports = ImmutableList.CreateBuilder <ImportDefinitionBinding>();
foreach (var export in exportsByMember)
{
var member = export.Key;
var memberExportMetadata = allExportsMetadata.AddRange(this.GetExportMetadata(member));
if (member is Type)
{
foreach (var exportAttribute in export.Value)
{
Type exportedType = exportAttribute.ContractType ?? partTypeAsGenericTypeDefinition ?? partType;
ExportDefinition exportDefinition = CreateExportDefinition(memberExportMetadata, exportAttribute, exportedType);
exportsOnType.Add(exportDefinition);
}
}
else // property
{
var property = (PropertyInfo)member;
Verify.Operation(!partType.IsGenericTypeDefinition, Strings.ExportsOnMembersNotAllowedWhenDeclaringTypeGeneric);
var exportDefinitions = ImmutableList.CreateBuilder <ExportDefinition>();
foreach (var exportAttribute in export.Value)
{
Type exportedType = exportAttribute.ContractType ?? property.PropertyType;
ExportDefinition exportDefinition = CreateExportDefinition(memberExportMetadata, exportAttribute, exportedType);
exportDefinitions.Add(exportDefinition);
}
exportsOnMembers.Add(MemberRef.Get(member, this.Resolver), exportDefinitions.ToImmutable());
}
}
foreach (var member in declaredProperties)
{
var importAttribute = member.GetFirstAttribute <ImportAttribute>();
var importManyAttribute = member.GetFirstAttribute <ImportManyAttribute>();
Requires.Argument(!(importAttribute != null && importManyAttribute != null), "partType", Strings.MemberContainsBothImportAndImportMany, member.Name);
var importConstraints = GetImportConstraints(member);
ImportDefinition importDefinition;
if (this.TryCreateImportDefinition(ReflectionHelpers.GetMemberType(member), member, importConstraints, out importDefinition))
{
imports.Add(new ImportDefinitionBinding(importDefinition, TypeRef.Get(partType, this.Resolver), MemberRef.Get(member, this.Resolver)));
}
}
MethodInfo onImportsSatisfied = null;
foreach (var method in partType.GetMethods(this.PublicVsNonPublicFlags | BindingFlags.Instance))
{
if (method.IsAttributeDefined <OnImportsSatisfiedAttribute>())
{
Verify.Operation(method.GetParameters().Length == 0, Strings.OnImportsSatisfiedTakeNoParameters);
Verify.Operation(onImportsSatisfied == null, Strings.OnlyOneOnImportsSatisfiedMethodIsSupported);
onImportsSatisfied = method;
}
}
var importingConstructorParameters = ImmutableList.CreateBuilder <ImportDefinitionBinding>();
var importingCtor = GetImportingConstructor <ImportingConstructorAttribute>(partType, publicOnly: !this.IsNonPublicSupported);
Verify.Operation(importingCtor != null, Strings.NoImportingConstructorFound);
foreach (var parameter in importingCtor.GetParameters())
{
var import = this.CreateImport(parameter, GetImportConstraints(parameter));
if (import.ImportDefinition.Cardinality == ImportCardinality.ZeroOrMore)
{
Verify.Operation(PartDiscovery.IsImportManyCollectionTypeCreateable(import), Strings.CollectionMustBePublicAndPublicCtorWhenUsingImportingCtor);
}
importingConstructorParameters.Add(import);
}
var partMetadata = ImmutableDictionary.CreateBuilder <string, object>();
foreach (var partMetadataAttribute in partType.GetAttributes <PartMetadataAttribute>())
{
partMetadata[partMetadataAttribute.Name] = partMetadataAttribute.Value;
}
var assemblyNamesForMetadataAttributes = ImmutableHashSet.CreateBuilder <AssemblyName>();
foreach (var export in exportsByMember)
{
GetAssemblyNamesFromMetadataAttributes <MetadataAttributeAttribute>(export.Key, assemblyNamesForMetadataAttributes);
}
return(new ComposablePartDefinition(
TypeRef.Get(partType, this.Resolver),
partMetadata.ToImmutable(),
exportsOnType.ToImmutable(),
exportsOnMembers.ToImmutable(),
imports.ToImmutable(),
sharingBoundary,
MethodRef.Get(onImportsSatisfied, this.Resolver),
ConstructorRef.Get(importingCtor, this.Resolver),
importingConstructorParameters.ToImmutable(),
partCreationPolicy,
assemblyNamesForMetadataAttributes));
}
public static Parser <ImmutableList <A> > immutableListParser <A>(Parser <A> parser) =>
collectionParser(parser, count => ImmutableList.CreateBuilder <A>(), (b, a) => {
b.Add(a);
return(b);
}).map(_ => _.ToImmutable());
public void DebuggerAttributesValid()
{
DebuggerAttributes.ValidateDebuggerDisplayReferences(ImmutableList.CreateBuilder <int>());
DebuggerAttributes.ValidateDebuggerTypeProxyProperties(ImmutableList.CreateBuilder <string>());
}
protected override ImmutableList <TItem> .Builder CreateProxy(int knownSize) => ImmutableList.CreateBuilder <TItem>();
public Dependency(IDependencyModel dependencyModel, ITargetFramework targetFramework, string containingProjectPath)
{
Requires.NotNull(dependencyModel, nameof(dependencyModel));
Requires.NotNullOrEmpty(dependencyModel.ProviderType, nameof(dependencyModel.ProviderType));
Requires.NotNullOrEmpty(dependencyModel.Id, nameof(dependencyModel.Id));
Requires.NotNull(targetFramework, nameof(targetFramework));
Requires.NotNullOrEmpty(containingProjectPath, nameof(containingProjectPath));
TargetFramework = targetFramework;
_modelId = dependencyModel.Id;
_containingProjectPath = containingProjectPath;
ProviderType = dependencyModel.ProviderType;
Name = dependencyModel.Name ?? string.Empty;
Version = dependencyModel.Version ?? string.Empty;
Caption = dependencyModel.Caption ?? string.Empty;
OriginalItemSpec = dependencyModel.OriginalItemSpec ?? string.Empty;
Path = dependencyModel.Path ?? string.Empty;
SchemaName = dependencyModel.SchemaName ?? Folder.SchemaName;
_schemaItemType = dependencyModel.SchemaItemType ?? Folder.PrimaryDataSourceItemType;
Resolved = dependencyModel.Resolved;
TopLevel = dependencyModel.TopLevel;
Implicit = dependencyModel.Implicit;
Visible = dependencyModel.Visible;
Priority = dependencyModel.Priority;
Flags = dependencyModel.Flags;
// Just in case custom providers don't do it, add corresponding flags for Resolved state.
// This is needed for tree update logic to track if tree node changing state from unresolved
// to resolved or vice-versa (it helps to decide if we need to remove it or update in-place
// in the tree to avoid flicks).
if (Resolved)
{
Flags = Flags.Union(DependencyTreeFlags.ResolvedFlags);
}
else
{
Flags = Flags.Union(DependencyTreeFlags.UnresolvedFlags);
}
Icon = dependencyModel.Icon;
ExpandedIcon = dependencyModel.ExpandedIcon;
UnresolvedIcon = dependencyModel.UnresolvedIcon;
UnresolvedExpandedIcon = dependencyModel.UnresolvedExpandedIcon;
Properties = dependencyModel.Properties ??
ImmutableDictionary <string, string> .Empty
.Add(Folder.IdentityProperty, Caption)
.Add(Folder.FullPathProperty, Path);
if (dependencyModel.DependencyIDs == null)
{
DependencyIDs = ImmutableList <string> .Empty;
}
else
{
var normalizedDependencyIDs = ImmutableList.CreateBuilder <string>();
foreach (var id in dependencyModel.DependencyIDs)
{
normalizedDependencyIDs.Add(GetID(TargetFramework, ProviderType, id));
}
DependencyIDs = normalizedDependencyIDs.ToImmutable();
}
}
protected override void ApplyImpl(ImmutableList <ItemData> .Builder listBuilder, ImmutableHashSet <string> globsToIgnore)
{
if (!_conditionResult)
{
return;
}
ItemSpecMatchesItem matchItemspec;
bool?needToExpandMetadataForEachItem = null;
if (ItemspecContainsASingleItemReference(_itemSpec, _itemElement.ItemType))
{
// Perf optimization: If the Update operation references itself (e.g. <I Update="@(I)"/>)
// then all items are updated and matching is not necessary
matchItemspec = (itemSpec, item) => new MatchResult(true, null);
}
else if (ItemSpecContainsItemReferences(_itemSpec) &&
QualifiedMetadataReferencesExist(_metadata, out needToExpandMetadataForEachItem) &&
!Traits.Instance.EscapeHatches.DoNotExpandQualifiedMetadataInUpdateOperation)
{
var itemReferenceFragments = _itemSpec.Fragments.OfType <ItemSpec <P, I> .ItemExpressionFragment>().ToArray();
var nonItemReferenceFragments = _itemSpec.Fragments.Where(f => !(f is ItemSpec <P, I> .ItemExpressionFragment)).ToArray();
matchItemspec = (itemSpec, item) =>
{
var isMatch = nonItemReferenceFragments.Any(f => f.IsMatch(item.EvaluatedInclude));
Dictionary <string, I> capturedItemsFromReferencedItemTypes = null;
foreach (var itemReferenceFragment in itemReferenceFragments)
{
foreach (var referencedItem in itemReferenceFragment.ReferencedItems)
{
if (referencedItem.ItemAsValueFragment.IsMatch(item.EvaluatedInclude))
{
isMatch = true;
capturedItemsFromReferencedItemTypes ??= new Dictionary <string, I>(StringComparer.OrdinalIgnoreCase);
capturedItemsFromReferencedItemTypes[referencedItem.Item.Key] = referencedItem.Item;
}
}
}
return(new MatchResult(isMatch, capturedItemsFromReferencedItemTypes));
};
}
else
{
matchItemspec = (itemSpec, item) => new MatchResult(itemSpec.MatchesItem(item), null);
}
var itemsToUpdate = ImmutableList.CreateBuilder <ItemBatchingContext>();
for (int i = 0; i < listBuilder.Count; i++)
{
var itemData = listBuilder[i];
var matchResult = matchItemspec(_itemSpec, itemData.Item);
if (matchResult.IsMatch)
{
// items should be deep immutable, so clone and replace items before mutating them
// otherwise, with GetItems caching enabled, the mutations would leak into the cache causing
// future operations to mutate the state of past operations
var clonedItemData = listBuilder[i].Clone(_itemFactory, _itemElement);
listBuilder[i] = clonedItemData;
itemsToUpdate.Add(new ItemBatchingContext(clonedItemData.Item, matchResult.CapturedItemsFromReferencedItemTypes));
}
}
DecorateItemsWithMetadata(itemsToUpdate.ToImmutableList(), _metadata, needToExpandMetadataForEachItem);
}
protected override ICollection <I> SelectItems(ImmutableList <ItemData> .Builder listBuilder, ImmutableHashSet <string> globsToIgnore)
{
List <I> itemsToAdd = new List <I>();
Lazy <Func <string, bool> > excludeTester = null;
ImmutableList <string> .Builder excludePatterns = ImmutableList.CreateBuilder <string>();
if (_excludes != null)
{
// STEP 4: Evaluate, split, expand and subtract any Exclude
foreach (string exclude in _excludes)
{
string excludeExpanded = _expander.ExpandIntoStringLeaveEscaped(exclude, ExpanderOptions.ExpandPropertiesAndItems, _itemElement.ExcludeLocation);
IList <string> excludeSplits = ExpressionShredder.SplitSemiColonSeparatedList(excludeExpanded);
excludePatterns.AddRange(excludeSplits);
}
if (excludePatterns.Any())
{
excludeTester = new Lazy <Func <string, bool> >(() => EngineFileUtilities.GetMatchTester(excludePatterns, _rootDirectory));
}
}
ISet <string> excludePatternsForGlobs = null;
foreach (var fragment in _itemSpec.Fragments)
{
if (fragment is ItemExpressionFragment <P, I> )
{
// STEP 3: If expression is "@(x)" copy specified list with its metadata, otherwise just treat as string
bool throwaway;
var itemsFromExpression = _expander.ExpandExpressionCaptureIntoItems(
((ItemExpressionFragment <P, I>)fragment).Capture, _evaluatorData, _itemFactory, ExpanderOptions.ExpandItems,
false /* do not include null expansion results */, out throwaway, _itemElement.IncludeLocation);
if (excludeTester != null)
{
itemsToAdd.AddRange(itemsFromExpression.Where(item => !excludeTester.Value(item.EvaluatedInclude)));
}
else
{
itemsToAdd.AddRange(itemsFromExpression);
}
}
else if (fragment is ValueFragment)
{
string value = ((ValueFragment)fragment).ItemSpecFragment;
if (excludeTester == null ||
!excludeTester.Value(value))
{
var item = _itemFactory.CreateItem(value, value, _itemElement.ContainingProject.FullPath);
itemsToAdd.Add(item);
}
}
else if (fragment is GlobFragment)
{
string glob = ((GlobFragment)fragment).ItemSpecFragment;
if (excludePatternsForGlobs == null)
{
excludePatternsForGlobs = BuildExcludePatternsForGlobs(globsToIgnore, excludePatterns);
}
string[] includeSplitFilesEscaped = EngineFileUtilities.GetFileListEscaped(
_rootDirectory,
glob,
excludePatternsForGlobs
);
// itemsToAdd might grow 0 or more times during the following iteration. Proactively increase its capacity to ensure only one growth happens
IncreaseListCapacityIfNecessary(itemsToAdd, includeSplitFilesEscaped.Length);
foreach (string includeSplitFileEscaped in includeSplitFilesEscaped)
{
itemsToAdd.Add(_itemFactory.CreateItem(includeSplitFileEscaped, glob, _itemElement.ContainingProject.FullPath));
}
}
else
{
throw new InvalidOperationException(fragment.GetType().ToString());
}
}
return(itemsToAdd);
}
#pragma warning disable CS8618 // Non-nullable field is uninitialized. Consider declaring as nullable.
public DataSetInfo(Options opts)
{
Bin = Enum.IsDefined(typeof(BinType), opts.Bin)
? (BinType)(opts.Bin)
: throw new ArgumentException("Invalid binning type.", nameof(opts));
OutFolder = opts.OutFolder;
Suffix = opts.Suffix;
if (opts.Darks?.Any() ?? false)
{
Dark =
(from glob in opts.Darks
from desc in Ganss.IO.Glob.Expand(glob)
select desc).ToImmutableList();
}
if (opts.Bias?.Any() ?? false)
{
Bias =
(from glob in opts.Bias
from desc in Ganss.IO.Glob.Expand(glob)
select desc).ToImmutableList();
}
var darkPattern = Dark is null && !string.IsNullOrWhiteSpace(opts.DarkPattern)
? new Regex(opts.DarkPattern)
: null;
var biasPattern = Bias is null && !string.IsNullOrWhiteSpace(opts.BiasPattern)
? new Regex(opts.BiasPattern)
: null;
var darkBuilder = darkPattern is null
? null
: ImmutableList.CreateBuilder <IFileSystemInfo>();
var biasBuilder = darkPattern is null
? null
: ImmutableList.CreateBuilder <IFileSystemInfo>();
var filesBuilder = ImmutableList.CreateBuilder <IFileSystemInfo>();
foreach (var item in
from glob in opts.Files
from desc in Ganss.IO.Glob.Expand(glob)
select desc)
{
if (darkPattern?.IsMatch(item.Name) ?? false)
{
darkBuilder?.Add(item);
}
else if (biasPattern?.IsMatch(item.Name) ?? false)
{
biasBuilder?.Add(item);
}
else if ((Dark?.Any(x => x.FullName == item.FullName) ?? false) ||
(Bias?.Any(x => x.FullName == item.FullName) ?? false))
{
Console.Error.WriteLine($"File {item.FullName} is present in calibrations, omitting...");
}
else
{
filesBuilder.Add(item);
}
}
Files = filesBuilder.ToImmutable();
Dark ??= darkBuilder?.ToImmutable() ?? ImmutableList <IFileSystemInfo> .Empty;
Bias ??= biasBuilder?.ToImmutable() ?? ImmutableList <IFileSystemInfo> .Empty;
}
internal static Options Create(string[] args)
{
string analyzerPath = null;
string solutionPath = null;
var builder = ImmutableHashSet.CreateBuilder <string>();
var refactoringBuilder = ImmutableHashSet.CreateBuilder <string>();
bool runConcurrent = false;
bool reportSuppressedDiagnostics = false;
bool applyChanges = false;
bool showStats = false;
bool showCompilerDiagnostics = false;
bool useAll = false;
int iterations = 1;
bool testDocuments = false;
Func <string, bool> testDocumentMatch = _ => true;
int testDocumentIterations = 10;
string logFileName = null;
string profileRoot = null;
var usePersistentStorage = false;
var analysisScope = BackgroundAnalysisScope.Default;
var incrementalAnalyzerNames = ImmutableList.CreateBuilder <string>();
int i = 0;
while (i < args.Length)
{
var arg = args[i++];
string ReadValue() => (i < args.Length) ? args[i++] : throw new InvalidDataException($"Missing value for option {arg}");
switch (arg)
{
case "/all":
useAll = true;
break;
case "/stats":
showStats = true;
break;
case "/compilerStats":
showCompilerDiagnostics = true;
break;
case "/concurrent":
runConcurrent = true;
break;
case "/editperf":
testDocuments = true;
break;
case var _ when arg.StartsWith("/editperf:"):
testDocuments = true;
var expression = new Regex(arg.Substring("/editperf:".Length), RegexOptions.Compiled | RegexOptions.IgnoreCase);
testDocumentMatch = documentPath => expression.IsMatch(documentPath);
break;
case var _ when arg.StartsWith("/edititer:"):
testDocumentIterations = int.Parse(arg.Substring("/edititer:".Length));
break;
case var _ when arg.StartsWith("/iter:"):
iterations = int.Parse(arg.Substring("/iter:".Length));
break;
case "/suppressed":
reportSuppressedDiagnostics = true;
break;
case "/apply":
applyChanges = true;
break;
case "/a":
builder.Add(ReadValue());
break;
case "/refactor":
refactoringBuilder.Add(ReadValue());
break;
case "/log":
logFileName = ReadValue();
break;
case "/profileroot":
profileRoot = ReadValue();
break;
case "/persist":
usePersistentStorage = true;
break;
case "/fsa":
analysisScope = BackgroundAnalysisScope.FullSolution;
break;
case "/ia":
incrementalAnalyzerNames.Add(ReadValue());
break;
default:
if (analyzerPath == null)
{
analyzerPath = arg;
}
else if (solutionPath == null)
{
solutionPath = arg;
}
else
{
throw new InvalidDataException((arg.StartsWith("/", StringComparison.Ordinal) ?
"Unrecognized option " + arg :
"Unrecognized parameter " + arg));
}
break;
}
}
if (analyzerPath == null)
{
throw new InvalidDataException("Missing analyzer path");
}
if (solutionPath == null)
{
throw new InvalidDataException("Missing solution path");
}
return(new Options(
analyzerPath: analyzerPath,
solutionPath: solutionPath,
analyzerIds: builder.ToImmutableHashSet(),
refactoringNodes: refactoringBuilder.ToImmutableHashSet(),
runConcurrent: runConcurrent,
reportSuppressedDiagnostics: reportSuppressedDiagnostics,
applyChanges: applyChanges,
showStats: showStats,
showCompilerDiagnostics: showCompilerDiagnostics,
useAll: useAll,
iterations: iterations,
testDocuments: testDocuments,
testDocumentMatch: testDocumentMatch,
testDocumentIterations: testDocumentIterations,
logFileName: logFileName,
profileRoot: profileRoot,
usePersistentStorage: usePersistentStorage,
analysisScope: analysisScope,
incrementalAnalyzerNames: incrementalAnalyzerNames.ToImmutable()));
}
public ArchiveFileModel ReadMetadata(Stream stream, PasswordStorage password)
{
if (mIsRunning)
{
throw new InvalidOperationException("Recursive invocation.");
}
try
{
mIsRunning = true;
// reset fields to detect bugs
mFileNames = null;
mItemsWithoutStreamMarkers = null;
mEmptyFileMarkers = null;
mDeletionMarkers = null;
mOffsets = null;
mAttributes = null;
mCDates = null;
mMDates = null;
mADates = null;
mItemCount = -1;
mItemsWithoutStream = -1;
var metadata = ReadMetadataCore(stream, password);
mRootFolder = new ArchivedFolder.Builder();
mItemMap = new Dictionary <ArchivedFolder.Builder, List <ArchivedItem.Builder> >();
mItemMap.Add(mRootFolder, new List <ArchivedItem.Builder>());
mFiles = new HashSet <ArchivedFile.Builder>();
mStreamMap = new List <ArchivedFile.Builder>();
mSectionMap = ImmutableArray.CreateBuilder <int>(metadata.DecoderSections.Length + 1);
ArchiveDecoderSection currentDecoder = null;
int currentSectionIndex = -1;
int currentStreamIndex = 0;
int currentStreamCount = 0;
int currentEmptyIndex = 0;
for (int currentFileIndex = 0; currentFileIndex < mFileNames.Count; currentFileIndex++)
{
var filename = mFileNames[currentFileIndex];
bool hasStream = false;
ArchivedFile.Builder file = null;
if (mItemsWithoutStreamMarkers != null && mItemsWithoutStreamMarkers[currentFileIndex])
{
var isFile = (mEmptyFileMarkers == null || mEmptyFileMarkers[currentEmptyIndex]);
var isDeletionMarker = (mDeletionMarkers != null && mDeletionMarkers[currentEmptyIndex]);
if (isDeletionMarker)
{
RemoveItem(mItemMap[mRootFolder], filename, 0);
}
else
{
file = AddItem(mItemMap[mRootFolder], filename, 0, isFile);
}
currentEmptyIndex++;
}
else
{
hasStream = true;
file = AddItem(mItemMap[mRootFolder], filename, 0, true);
}
if (file != null)
{
if (mOffsets != null)
{
file.Offset = mOffsets[currentFileIndex] ?? 0;
}
if (mAttributes != null)
{
var attr = mAttributes[currentFileIndex];
if (attr.HasValue && (attr.Value & ArchivedAttributesExtensions.DirectoryAttribute) != 0)
{
throw new InvalidDataException();
}
file.Attributes = attr;
}
if (mCDates != null)
{
file.Creation = mCDates[currentFileIndex];
}
if (mMDates != null)
{
file.LastWrite = mMDates[currentFileIndex];
}
if (mADates != null)
{
file.LastAccess = mADates[currentFileIndex];
}
if (hasStream)
{
while (currentStreamIndex == currentStreamCount)
{
if (currentSectionIndex == metadata.DecoderSections.Length - 1)
{
throw new InvalidDataException();
}
currentDecoder = metadata.DecoderSections[++currentSectionIndex];
currentStreamCount = currentDecoder.Streams.Length;
currentStreamIndex = 0;
mSectionMap.Add(mStreamMap.Count);
}
file.Stream = new DecodedStreamIndex(currentSectionIndex, currentStreamIndex);
var streamMetadata = currentDecoder.Streams[currentStreamIndex++];
file.Length = streamMetadata.Length;
file.Checksum = streamMetadata.Checksum;
}
}
if (hasStream)
{
mStreamMap.Add(file);
}
}
var finalStreamMap = ImmutableList.CreateBuilder <ArchivedFile>();
foreach (var file in mStreamMap)
{
finalStreamMap.Add(mFiles.Contains(file) ? file.ToImmutable() : null);
}
if (currentStreamIndex != currentStreamCount || currentSectionIndex != metadata.DecoderSections.Length - 1)
{
throw new InvalidDataException();
}
mSectionMap.Add(finalStreamMap.Count);
return(new ArchiveFileModel(metadata, BuildFolder(mRootFolder), mSectionMap.MoveToImmutable(), finalStreamMap.ToImmutable()));
}
finally
{
mIsRunning = false;
}
}
/// <summary>
/// Analyzes the project and returns information about the diagnostics in it.
/// </summary>
/// <returns>A <see cref="Task"/> representing the asynchronous operation.</returns>
public async Task <ImmutableList <StyleCopDiagnostic> > GetDiagnosticsAsync()
{
var diagnostics = ImmutableList.CreateBuilder <StyleCopDiagnostic>();
var syntaxTrees = this.analyzerCompilation.SyntaxTrees;
foreach (var syntaxTree in syntaxTrees)
{
var match = DiagnosticPathRegex.Match(syntaxTree.FilePath);
if (!match.Success)
{
continue;
}
string shortName = match.Groups["name"].Value;
string noCodeFixReason = null;
// Check if this syntax tree represents a diagnostic
SyntaxNode syntaxRoot = await syntaxTree.GetRootAsync().ConfigureAwait(false);
SemanticModel semanticModel = this.analyzerCompilation.GetSemanticModel(syntaxTree);
SyntaxNode classSyntaxNode = syntaxRoot.DescendantNodes().FirstOrDefault(x => x.IsKind(SyntaxKind.ClassDeclaration));
if (classSyntaxNode == null)
{
continue;
}
INamedTypeSymbol classSymbol = semanticModel.GetDeclaredSymbol(classSyntaxNode) as INamedTypeSymbol;
if (!this.InheritsFrom(classSymbol, this.diagnosticAnalyzerTypeSymbol))
{
continue;
}
if (classSymbol.IsAbstract)
{
continue;
}
bool hasImplementation = HasImplementation(syntaxRoot);
IEnumerable <DiagnosticDescriptor> descriptorInfos = this.GetDescriptor(classSymbol);
foreach (var descriptorInfo in descriptorInfos)
{
var(codeFixStatus, fixAllStatus) = this.GetCodeFixAndFixAllStatus(descriptorInfo.Id, classSymbol, out noCodeFixReason);
string status = this.GetStatus(classSymbol, syntaxRoot, semanticModel, descriptorInfo);
if (descriptorInfo.CustomTags.Contains(WellKnownDiagnosticTags.NotConfigurable))
{
continue;
}
var diagnostic = new StyleCopDiagnostic
{
Id = descriptorInfo.Id,
Category = descriptorInfo.Category,
HasImplementation = hasImplementation,
Status = status,
Name = shortName,
Title = descriptorInfo.Title.ToString(),
HelpLink = descriptorInfo.HelpLinkUri,
CodeFixStatus = codeFixStatus,
FixAllStatus = fixAllStatus,
NoCodeFixReason = noCodeFixReason,
};
diagnostics.Add(diagnostic);
}
}
return(diagnostics.ToImmutable());
}
protected override ImmutableList <T> .Builder Create(int count)
{
return(ImmutableList.CreateBuilder <T>());
}
