public Username(string username) { Contract.Assert(!string.IsNullOrWhiteSpace(username)); _username = username.Trim(); }
/// <summary> /// Returns a collection of profiled entries that resulted from evaluation /// </summary> /// <remarks> /// Evaluation should be finished in order to call this function /// </remarks> public IReadOnlyCollection <ProfiledFunctionCall> GetProfiledEntries() { Contract.Assert(m_evaluationFinished, "Evaluation should be finished to be able to retrieve the profiled entries"); return(m_profilerEntries.ToArray()); }
public static void Main(string[] args) { Contract.Assert(args[0] != null); Contract.Assert(args[0] == ""); }
private async Task <Possible <ProjectGraphWithPredictionsResult <AbsolutePath> > > ComputeBuildGraphAsync( AbsolutePath responseFile, IEnumerable <AbsolutePath> projectEntryPoints, AbsolutePath outputFile, IEnumerable <AbsolutePath> msBuidSearchLocations, IEnumerable <AbsolutePath> dotnetSearchLocations, BuildParameters.IBuildParameters buildParameters) { AbsolutePath dotnetExeLocation = AbsolutePath.Invalid; if (m_resolverSettings.ShouldRunDotNetCoreMSBuild()) { if (!TryFindDotNetExe(dotnetSearchLocations, out dotnetExeLocation, out string failure)) { return(ProjectGraphWithPredictionsResult <AbsolutePath> .CreateFailure( GraphConstructionError.CreateFailureWithoutLocation(failure), CollectionUtilities.EmptyDictionary <string, AbsolutePath>(), AbsolutePath.Invalid)); } } SandboxedProcessResult result = await RunMsBuildGraphBuilderAsync(responseFile, projectEntryPoints, outputFile, msBuidSearchLocations, dotnetExeLocation, buildParameters); string standardError = result.StandardError.CreateReader().ReadToEndAsync().GetAwaiter().GetResult(); if (result.ExitCode != 0) { // In case of a cancellation, the tool may have exited with a non-zero // code, but that's expected if (!m_context.CancellationToken.IsCancellationRequested) { // This should never happen! Report the standard error and exit gracefully Tracing.Logger.Log.GraphConstructionInternalError( m_context.LoggingContext, m_resolverSettings.Location(m_context.PathTable), standardError); } return(new MsBuildGraphConstructionFailure(m_resolverSettings, m_context.PathTable)); } // If the tool exited gracefully, but standard error is not empty, that // is interpreted as a warning. We propagate that to the BuildXL log if (!string.IsNullOrEmpty(standardError)) { Tracing.Logger.Log.GraphConstructionFinishedSuccessfullyButWithWarnings( m_context.LoggingContext, m_resolverSettings.Location(m_context.PathTable), standardError); } TrackFilesAndEnvironment(result.AllUnexpectedFileAccesses, outputFile.GetParent(m_context.PathTable)); var serializer = JsonSerializer.Create(ProjectGraphSerializationSettings.Settings); serializer.Converters.Add(new AbsolutePathJsonConverter(m_context.PathTable)); serializer.Converters.Add(new ValidAbsolutePathEnumerationJsonConverter()); using (var sr = new StreamReader(outputFile.ToString(m_context.PathTable))) using (var reader = new JsonTextReader(sr)) { var projectGraphWithPredictionsResult = serializer.Deserialize <ProjectGraphWithPredictionsResult <AbsolutePath> >(reader); // A successfully constructed graph should always have a valid path to MsBuild Contract.Assert(!projectGraphWithPredictionsResult.Succeeded || projectGraphWithPredictionsResult.PathToMsBuild.IsValid); // A successfully constructed graph should always have at least one project node Contract.Assert(!projectGraphWithPredictionsResult.Succeeded || projectGraphWithPredictionsResult.Result.ProjectNodes.Length > 0); // A failed construction should always have a failure set Contract.Assert(projectGraphWithPredictionsResult.Succeeded || projectGraphWithPredictionsResult.Failure != null); // Let's log the paths to the used MsBuild assemblies, just for debugging purposes Tracing.Logger.Log.GraphConstructionToolCompleted( m_context.LoggingContext, m_resolverSettings.Location(m_context.PathTable), string.Join(",\n", projectGraphWithPredictionsResult.MsBuildAssemblyPaths.Select(kvp => I($"[{kvp.Key}]:{kvp.Value.ToString(m_context.PathTable)}"))), projectGraphWithPredictionsResult.PathToMsBuild.ToString(m_context.PathTable)); return(m_resolverSettings.ShouldRunDotNetCoreMSBuild() ? projectGraphWithPredictionsResult.WithPathToDotNetExe(dotnetExeLocation) : projectGraphWithPredictionsResult); } }
public async Task RunAsync(CancellationToken cancellationToken = default) { if (IsPersistanceEnabled()) { LoadState(_configuration.PersistStatePath); // Persist before the run begins, store the reconciliation SaveState(_configuration.PersistStatePath); } _logger.Debug("Starting to monitor"); Dictionary <State, int> oldStates = null; while (!cancellationToken.IsCancellationRequested) { var now = _clock.UtcNow; // Approximate count of rules in each state. They do not necessarily sum to the total, because rules // may change state as we are computing the dictionary. var states = new Dictionary <State, int>() { { State.Running, 0 }, { State.Scheduled, 0 }, { State.Waiting, 0 }, { State.Failed, 0 }, }; foreach (var kvp in _schedule) { var rule = kvp.Value.Rule; var entry = kvp.Value; lock (entry.Lock) { states[entry.State] += 1; if (!entry.ShouldSchedule(now, retryOnFailureWaitTime: _configuration.RetryOnFailureAfter)) { continue; } Contract.Assert(entry.State != State.Running && entry.State != State.Scheduled); entry.State = State.Scheduled; } _ = Task.Run(async() => { // NOTE(jubayard): make sure this runs in a different thread than the scheduler. await Task.Yield(); #pragma warning disable ERP022 // Unobserved exception in generic exception handler try { await RunRuleAsync(entry); } catch (Exception exception) { _logger.Fatal($"Scheduler threw an exception while running rule: {exception?.ToString()}"); } #pragma warning restore ERP022 // Unobserved exception in generic exception handler }); } if (oldStates == null || states.Any(kvp => oldStates[kvp.Key] != kvp.Value)) { var statesString = string.Join(", ", states.Select(kvp => $"{kvp.Key}={kvp.Value}")); _logger.Debug($"Scheduler state: {statesString}"); oldStates = states; } if (IsPersistanceEnabled()) { SaveState(_configuration.PersistStatePath); } if (!cancellationToken.IsCancellationRequested) { await Task.Delay(_configuration.PollingPeriod); } } // TODO(jubayard): wait until all rules are done executing. Not implemented because it really isn't that // important for now. It would be if we were hot-reloading configuration files. }
//--------------------------------------------------------------------------------------- // Dispose of resources associated with the underlying enumerator. // protected override void Dispose(bool disposing) { Contract.Assert(m_source != null); m_source.Dispose(); }
/// <summary> /// Diffs weak fingerprints. /// </summary> /// <param name="weakFingerprint">Weak fingerprint.</param> /// <param name="weakFingerprintTree">Weak fingerprint tree.</param> /// <param name="otherWeakFingerprint">Other weak fingerprint.</param> /// <param name="otherWeakFingerprintTree">Other weak fingerprint tree.</param> /// <returns></returns> public static JObject DiffWeakFingerprints( string weakFingerprint, JsonNode weakFingerprintTree, string otherWeakFingerprint, JsonNode otherWeakFingerprintTree) { JObject result = new JObject(); if (weakFingerprint == otherWeakFingerprint) { return(result); } // { // WeakFingerprint: { Old: old_weak_fingerprint, New: new_weak_fingerprint } // } AddPropertyIfNotNull(result, RenderSingleValueDiff("WeakFingerprint", weakFingerprint, otherWeakFingerprint)); using (var weakFingerprintDataPool = JsonNodeMapPool.GetInstance()) using (var otherWeakFingerprintDataPool = JsonNodeMapPool.GetInstance()) { var weakFingerprintData = weakFingerprintDataPool.Instance; var otherWeakFingerprintData = otherWeakFingerprintDataPool.Instance; JsonTree.VisitTree(weakFingerprintTree, wfNode => weakFingerprintData[wfNode.Name] = wfNode, recurse: false); JsonTree.VisitTree(otherWeakFingerprintTree, wfNode => otherWeakFingerprintData[wfNode.Name] = wfNode, recurse: false); var fields = new HashSet <string>(weakFingerprintData.Keys.Concat(otherWeakFingerprintData.Keys)); foreach (var field in fields) { bool getFieldNode = weakFingerprintData.TryGetValue(field, out JsonNode fieldNode); bool getOtherFieldNode = otherWeakFingerprintData.TryGetValue(field, out JsonNode otherFieldNode); if (getFieldNode != getOtherFieldNode) { string fieldValue = getFieldNode ? (fieldNode.Values != null && fieldNode.Values.Count == 1 ? fieldNode.Values[0] : CacheMissAnalysisUtilities.RepeatedStrings.ExistentValue) : CacheMissAnalysisUtilities.RepeatedStrings.UnspecifiedValue; string otherFieldValue = getOtherFieldNode ? (otherFieldNode.Values != null && otherFieldNode.Values.Count == 1 ? otherFieldNode.Values[0] : CacheMissAnalysisUtilities.RepeatedStrings.ExistentValue) : CacheMissAnalysisUtilities.RepeatedStrings.UnspecifiedValue; AddPropertyIfNotNull(result, RenderSingleValueDiff(field, fieldValue, otherFieldValue)); } else if (getFieldNode && getOtherFieldNode) { Contract.Assert(fieldNode != null); Contract.Assert(otherFieldNode != null); AddPropertyIfNotNull(result, DiffWeakFingerprintField(fieldNode, otherFieldNode)); } } } Contract.Assert(result.Count > 0); return(result); }
private BindableVectorToListAdapter() { Contract.Assert(false, "This class is never instantiated"); }
public CompareAttributeAdapter(ModelMetadata metadata, ControllerContext context, DataAnnotationsCompareAttribute attribute) : base(metadata, context, attribute) { Contract.Assert(attribute.GetType() == typeof(DataAnnotationsCompareAttribute)); }
private void WriteFeed(IEnumerable enumerable, IEdmTypeReference feedType, ODataDeltaWriter writer, ODataSerializerContext writeContext) { Contract.Assert(writer != null); Contract.Assert(writeContext != null); Contract.Assert(enumerable != null); Contract.Assert(feedType != null); IEdmStructuredTypeReference elementType = GetResourceType(feedType); if (elementType.IsComplex()) { ODataResourceSet resourceSet = new ODataResourceSet() { TypeName = feedType.FullName() }; writer.WriteStart(resourceSet); ODataResourceSerializer entrySerializer = SerializerProvider.GetEdmTypeSerializer(elementType) as ODataResourceSerializer; if (entrySerializer == null) { throw new SerializationException( Error.Format(SRResources.TypeCannotBeSerialized, elementType.FullName(), typeof(ODataMediaTypeFormatter).Name)); } foreach (object entry in enumerable) { entrySerializer.WriteDeltaObjectInline(entry, elementType, writer, writeContext); } } else { ODataDeltaResourceSet deltaFeed = CreateODataDeltaFeed(enumerable, feedType.AsCollection(), writeContext); if (deltaFeed == null) { throw new SerializationException(Error.Format(SRResources.CannotSerializerNull, DeltaFeed)); } // save this for later to support JSON odata.streaming. Uri nextPageLink = deltaFeed.NextPageLink; deltaFeed.NextPageLink = null; //Start writing of the Delta Feed writer.WriteStart(deltaFeed); //Iterate over all the entries present and select the appropriate write method. //Write method creates ODataDeltaDeletedEntry / ODataDeltaDeletedLink / ODataDeltaLink or ODataEntry. foreach (object entry in enumerable) { if (entry == null) { throw new SerializationException(SRResources.NullElementInCollection); } IEdmChangedObject edmChangedObject = entry as IEdmChangedObject; if (edmChangedObject == null) { throw new SerializationException(Error.Format(SRResources.CannotWriteType, GetType().Name, enumerable.GetType().FullName)); } switch (edmChangedObject.DeltaKind) { case EdmDeltaEntityKind.DeletedEntry: WriteDeltaDeletedEntry(entry, writer, writeContext); break; case EdmDeltaEntityKind.DeletedLinkEntry: WriteDeltaDeletedLink(entry, writer, writeContext); break; case EdmDeltaEntityKind.LinkEntry: WriteDeltaLink(entry, writer, writeContext); break; case EdmDeltaEntityKind.Entry: { ODataResourceSerializer entrySerializer = SerializerProvider.GetEdmTypeSerializer(elementType) as ODataResourceSerializer; if (entrySerializer == null) { throw new SerializationException( Error.Format(SRResources.TypeCannotBeSerialized, elementType.FullName(), typeof(ODataMediaTypeFormatter).Name)); } entrySerializer.WriteDeltaObjectInline(entry, elementType, writer, writeContext); break; } default: break; } } // Subtle and surprising behavior: If the NextPageLink property is set before calling WriteStart(feed), // the next page link will be written early in a manner not compatible with odata.streaming=true. Instead, if // the next page link is not set when calling WriteStart(feed) but is instead set later on that feed // object before calling WriteEnd(), the next page link will be written at the end, as required for // odata.streaming=true support. if (nextPageLink != null) { deltaFeed.NextPageLink = nextPageLink; } } //End Writing of the Delta Feed writer.WriteEnd(); }
internal StreamAsyncHelper(Stream stream) { Contract.Assert(stream != null); _stream = stream; }
internal static void ContractAssertMonitorStatus(object syncObj, bool held) { Contract.Requires(syncObj != null, "The monitor object to check must be provided."); Contract.Assert(Monitor.IsEntered(syncObj) == held, "The locking scheme was not correctly followed."); }
internal EnumTypeConfiguration(EnumTypeConfiguration configuration) { Contract.Assert(configuration != null); Contract.Assert(configuration.ClrType == typeof(TEnumType)); this._configuration = configuration; }
public CompleteTaskOnCloseStream(Stream innerStream, TaskCompletionSource <bool> serializeToStreamTask) : base(innerStream) { Contract.Assert(serializeToStreamTask != null); _serializeToStreamTask = serializeToStreamTask; }
public static ODataPathTemplate ParseTemplate(this IODataPathTemplateHandler handler, IEdmModel model, string odataPathTemplate) { Contract.Assert(handler != null); return(handler.ParseTemplate(odataPathTemplate, new MockContainer(model))); }
private static string FormatPropertyForClientValidation(string property) { Contract.Assert(property != null); return("*." + property); }
public override bool CanHandle(MethodCallExpression expression) { Contract.Assert(expression.Method != null); return(expression.Method.DeclaringType == typeof(Math) && expression.Method.Name == "Floor"); }
public FaultingHttpContent(Exception exception) { Contract.Assert(exception != null); _exception = exception; }
/// <summary> /// Diffs strong fingerprints. /// </summary> /// <param name="pathSetHash">Pathset hash.</param> /// <param name="pathSetTree">Pathset tree.</param> /// <param name="strongFingerprintInputTree">Strong fingerprint input tree.</param> /// <param name="otherPathSetHash">Other pathset hash.</param> /// <param name="otherPathSetTree">Other pathset tree.</param> /// <param name="otherStrongFingerprintInputTree">Other strong fingerprint input tree.</param> /// <param name="getDirectoryMembership">Delegate for getting directory membership.</param> /// <param name="getOtherDirectoryMembership">Delegate for getting other directory membership.</param> /// <returns></returns> public static JObject DiffPathSets( string pathSetHash, JsonNode pathSetTree, JsonNode strongFingerprintInputTree, string otherPathSetHash, JsonNode otherPathSetTree, JsonNode otherStrongFingerprintInputTree, Func <string, IReadOnlyList <string> > getDirectoryMembership, Func <string, IReadOnlyList <string> > getOtherDirectoryMembership) { JObject result = new JObject(); if (pathSetHash == otherPathSetHash) { return(result); } // { // PathSetHash: { Old: old_path_set_hash, New: new_path_set_hash } // } AddPropertyIfNotNull(result, RenderSingleValueDiff("PathSetHash", pathSetHash, otherPathSetHash)); JsonNode unsafeOptionsNode = JsonTree.FindNodeByName(pathSetTree, ObservedPathSet.Labels.UnsafeOptions); JsonNode otherUnsafeOptionsNode = JsonTree.FindNodeByName(otherPathSetTree, ObservedPathSet.Labels.UnsafeOptions); // { // UnsafeOptions: // { // <property_Name>: // { // Old: old_value, // New: new_value // } // PreserveOutputInfo: // { // <property_Name>: // { // Old: old_value, // New: new_value // } // } // } AddPropertyIfNotNull(result, DiffUnsafeOptions(unsafeOptionsNode, otherUnsafeOptionsNode)); AddPropertyIfNotNull( result, DiffObservedPaths( pathSetTree, strongFingerprintInputTree, otherPathSetTree, otherStrongFingerprintInputTree, getDirectoryMembership, getOtherDirectoryMembership)); JsonNode obsFileNameNode = JsonTree.FindNodeByName(pathSetTree, ObservedPathSet.Labels.ObservedAccessedFileNames); JsonNode otherObsFileNameNode = JsonTree.FindNodeByName(otherPathSetTree, ObservedPathSet.Labels.ObservedAccessedFileNames); bool hasDiff = ExtractUnorderedListDiff(obsFileNameNode.Values, otherObsFileNameNode.Values, out var addedFileNames, out var removedFileName); if (hasDiff) { result.Add(new JProperty( ObservedPathSet.Labels.ObservedAccessedFileNames, RenderUnorderedListDiff(addedFileNames, removedFileName, RenderPath))); } Contract.Assert(result.Count > 0); return(result); }
public void Test1() { var path = Dijkstra <int> .FindPath(new[] { 3 }, i => new[] { i + 1 }, i => i == 10); Contract.Assert(path.SequenceEqual(Enumerable.Range(3, 10 + 1 - 3))); }
private static void TraversePathSetPaths( JsonNode pathSetPathsNode, JsonNode observedInputs, Action <ObservedInputData> action) { string path = null; string flags = null; string pattern = null; string hashMarker = null; string hash = null; var obIt = observedInputs?.Children.First; for (var it = pathSetPathsNode.Children.First; it != null; it = it.Next) { var elem = it.Value; switch (elem.Name) { case ObservedPathEntryConstants.Path: if (path != null) { action(new ObservedInputData(path, flags, pattern, hashMarker, hash)); path = null; flags = null; pattern = null; hashMarker = null; hash = null; } path = elem.Values[0]; if (obIt != null) { hashMarker = obIt.Value.Name; hash = obIt.Value.Values[0]; obIt = obIt.Next; } break; case ObservedPathEntryConstants.Flags: Contract.Assert(path != null); flags = elem.Values[0]; break; case ObservedPathEntryConstants.EnumeratePatternRegex: Contract.Assert(path != null); pattern = elem.Values[0]; break; default: break; } } if (path != null) { action(new ObservedInputData(path, flags, pattern, hashMarker, hash)); } }
public void Test2() { var path = Dijkstra <int> .FindPath(new[] { 1 }, i => new[] { i + 1, i * 2 }, i => i == 10); Contract.Assert(path.SequenceEqual(new[] { 1, 2, 4, 5, 10 })); }
private Task <SandboxedProcessResult> RunMsBuildGraphBuilderAsync( AbsolutePath responseFile, IEnumerable <AbsolutePath> projectEntryPoints, AbsolutePath outputFile, IEnumerable <AbsolutePath> msBuildSearchLocations, AbsolutePath dotnetExeLocation, BuildParameters.IBuildParameters buildParameters) { Contract.Assert(!m_resolverSettings.ShouldRunDotNetCoreMSBuild() || dotnetExeLocation.IsValid); AbsolutePath toolDirectory = m_configuration.Layout.BuildEngineDirectory.Combine(m_context.PathTable, RelativePathToGraphConstructionTool).GetParent(m_context.PathTable); string outputDirectory = outputFile.GetParent(m_context.PathTable).ToString(m_context.PathTable); string outputFileString = outputFile.ToString(m_context.PathTable); IReadOnlyCollection <string> entryPointTargets = m_resolverSettings.InitialTargets ?? CollectionUtilities.EmptyArray <string>(); var requestedQualifiers = m_requestedQualifiers.Select(qualifierId => MsBuildResolverUtils.CreateQualifierAsGlobalProperties(qualifierId, m_context)).ToList(); var arguments = new MSBuildGraphBuilderArguments( projectEntryPoints.Select(entryPoint => entryPoint.ToString(m_context.PathTable)).ToList(), outputFileString, new GlobalProperties(m_resolverSettings.GlobalProperties ?? CollectionUtilities.EmptyDictionary <string, string>()), msBuildSearchLocations.Select(location => location.ToString(m_context.PathTable)).ToList(), entryPointTargets, requestedQualifiers, m_resolverSettings.AllowProjectsToNotSpecifyTargetProtocol == true, m_resolverSettings.ShouldRunDotNetCoreMSBuild()); var responseFilePath = responseFile.ToString(m_context.PathTable); SerializeResponseFile(responseFilePath, arguments); string graphConstructionToolPath = m_configuration.Layout.BuildEngineDirectory.Combine(m_context.PathTable, RelativePathToGraphConstructionTool).ToString(m_context.PathTable); string pathToTool; string toolArguments; // if we should call the dotnet core version of MSBuild, we need to actually call dotnet.exe and pass the tool itself as its first argument if (m_resolverSettings.ShouldRunDotNetCoreMSBuild()) { pathToTool = dotnetExeLocation.ToString(m_context.PathTable); toolArguments = I($"\"{graphConstructionToolPath}\" \"{responseFilePath}\""); } else { pathToTool = graphConstructionToolPath; toolArguments = I($"\"{responseFilePath}\""); } Tracing.Logger.Log.LaunchingGraphConstructionTool(m_context.LoggingContext, m_resolverSettings.Location(m_context.PathTable), arguments.ToString(), pathToTool); // Just being defensive, make sure there is not an old output file lingering around File.Delete(outputFileString); return(FrontEndUtilities.RunSandboxedToolAsync( m_context, pathToTool, buildStorageDirectory: outputDirectory, fileAccessManifest: GenerateFileAccessManifest(toolDirectory, outputFile), arguments: toolArguments, workingDirectory: outputDirectory, description: "MsBuild graph builder", buildParameters, beforeLaunch: () => ConnectToServerPipeAndLogProgress(outputFileString))); }
public void Test5() { var path = Dijkstra <int> .FindPath(new[] { 10 }, i => new[] { i + 2, i * 3 - 1 }, i => i == 10); Contract.Assert(path.SequenceEqual(new[] { 10 })); }
private async Task RunRuleAsync(Entry entry) { Contract.AssertNotNull(entry); var rule = entry.Rule; var stopwatch = new Stopwatch(); var failed = false; RuleContext context = null; Exception exception = null; try { await _runGate.WaitAsync(); lock (entry.Lock) { Contract.Assert(entry.State == State.Scheduled); entry.State = State.Running; } _logger.Debug($"Running rule `{rule.Identifier}`. `{_runGate.CurrentCount}` more allowed to run"); context = new RuleContext(Guid.NewGuid(), _clock.UtcNow); stopwatch.Restart(); await rule.Run(context); } catch (Exception thrownException) { failed = true; exception = thrownException; } finally { stopwatch.Stop(); _runGate.Release(); lock (entry.Lock) { entry.LastRunTimeUtc = _clock.UtcNow; Contract.Assert(entry.State == State.Running); entry.State = failed ? State.Failed : State.Waiting; var logMessage = $"Rule `{rule.Identifier}` finished running @ `{entry.LastRunTimeUtc}`, took {stopwatch.Elapsed} to run"; if (!failed) { _logger.Debug(logMessage); } else { _logger.Error($"{logMessage}. An exception has been caught and the rule has been disabled. Exception: {exception?.ToString() ?? "N/A"}"); } } _notifier?.Emit(new LogEntry { RunTimeUtc = context?.RunTimeUtc ?? _clock.UtcNow, RuleIdentifier = rule.Identifier, RunGuid = context?.RunGuid ?? Guid.Empty, Elapsed = stopwatch.Elapsed, ErrorMessage = failed ? exception?.ToString() : "", }); } }
public void TestFail() { var path = Dijkstra <int> .FindPath(new[] { 1 }, i => new[] { (i * 3 - 1) % 20 }, i => i == 10); Contract.Assert(path == null); }
private static ParserState ParseNameValuePairs( byte[] buffer, int bytesReady, ref int bytesConsumed, ref NameValueState nameValueState, long maximumLength, ref long totalBytesConsumed, CurrentNameValuePair currentNameValuePair, ICollection <KeyValuePair <string, string> > nameValuePairs) { Contract.Assert((bytesReady - bytesConsumed) >= 0, "ParseNameValuePairs()|(inputBufferLength - bytesParsed) < 0"); Contract.Assert(maximumLength <= 0 || totalBytesConsumed <= maximumLength, "ParseNameValuePairs()|Headers already read exceeds limit."); // Remember where we started. int initialBytesParsed = bytesConsumed; int segmentStart; // Set up parsing status with what will happen if we exceed the buffer. ParserState parseStatus = ParserState.DataTooBig; long effectiveMax = maximumLength <= 0 ? Int64.MaxValue : maximumLength - totalBytesConsumed + initialBytesParsed; if (bytesReady < effectiveMax) { parseStatus = ParserState.NeedMoreData; effectiveMax = bytesReady; } Contract.Assert(bytesConsumed < effectiveMax, "We have already consumed more than the max buffer length."); switch (nameValueState) { case NameValueState.Name: segmentStart = bytesConsumed; while (buffer[bytesConsumed] != '=' && buffer[bytesConsumed] != '&') { if (++bytesConsumed == effectiveMax) { string name = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart); currentNameValuePair.Name.Append(name); goto quit; } } if (bytesConsumed > segmentStart) { string name = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart); currentNameValuePair.Name.Append(name); } // Check if we got name=value or just name if (buffer[bytesConsumed] == '=') { // Move part the '=' nameValueState = NameValueState.Value; if (++bytesConsumed == effectiveMax) { goto quit; } goto case NameValueState.Value; } else { // Copy parsed name-only to collection currentNameValuePair.CopyNameOnlyTo(nameValuePairs); // Move past the '&' but stay in same state if (++bytesConsumed == effectiveMax) { goto quit; } goto case NameValueState.Name; } case NameValueState.Value: segmentStart = bytesConsumed; while (buffer[bytesConsumed] != '&') { if (++bytesConsumed == effectiveMax) { string value = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart); currentNameValuePair.Value.Append(value); goto quit; } } if (bytesConsumed > segmentStart) { string value = Encoding.UTF8.GetString(buffer, segmentStart, bytesConsumed - segmentStart); currentNameValuePair.Value.Append(value); } // Copy parsed name value pair to collection currentNameValuePair.CopyTo(nameValuePairs); // Move past the '&' nameValueState = NameValueState.Name; if (++bytesConsumed == effectiveMax) { goto quit; } goto case NameValueState.Name; } quit: totalBytesConsumed += bytesConsumed - initialBytesParsed; return(parseStatus); }
private void EndStep(RunnablePip runnablePip, PipExecutionStep step, TimeSpan duration) { var pipId = runnablePip.PipId; var loggingContext = runnablePip.LoggingContext; var pip = runnablePip.Pip; var description = runnablePip.Description; var executionResult = runnablePip.ExecutionResult; var completionData = m_pendingPipCompletions[pipId]; completionData.SerializedData.ExecuteStepTicks = duration.Ticks; switch (step) { case PipExecutionStep.MaterializeInputs: if (!runnablePip.Result.HasValue || !runnablePip.Result.Value.Status.IndicatesFailure()) { m_workerPipStateManager.Transition(pipId, WorkerPipState.Prepped); } break; case PipExecutionStep.ExecuteProcess: case PipExecutionStep.ExecuteNonProcessPip: executionResult.Seal(); m_workerPipStateManager.Transition(pipId, WorkerPipState.Executed); if (!executionResult.Result.IndicatesFailure()) { foreach (var outputContent in executionResult.OutputContent) { Tracing.Logger.Log.DistributionWorkerPipOutputContent( loggingContext, pip.SemiStableHash, description, outputContent.fileArtifact.Path.ToString(m_environment.Context.PathTable), outputContent.fileInfo.Hash.ToHex()); } } break; case PipExecutionStep.CacheLookup: var runnableProcess = (ProcessRunnablePip)runnablePip; executionResult = new ExecutionResult(); var cacheResult = runnableProcess.CacheResult; executionResult.SetResult( loggingContext, status: cacheResult == null ? PipResultStatus.Failed : PipResultStatus.Succeeded); if (cacheResult != null) { executionResult.WeakFingerprint = cacheResult.WeakFingerprint; if (cacheResult.CanRunFromCache) { var cacheHitData = cacheResult.GetCacheHitData(); if (m_environment.State.Cache.IsNewlyAdded(cacheHitData.PathSetHash)) { executionResult.PathSet = cacheHitData.PathSet; } executionResult.PipCacheDescriptorV2Metadata = cacheHitData.Metadata; executionResult.TwoPhaseCachingInfo = new TwoPhaseCachingInfo( weakFingerprint: cacheResult.WeakFingerprint, pathSetHash: cacheHitData.PathSetHash, strongFingerprint: cacheHitData.StrongFingerprint, // NOTE: This should not be used so we set it to default values except the metadata hash (it is used for HistoricMetadataCache). cacheEntry: new CacheEntry(cacheHitData.MetadataHash, "unused", ArrayView <ContentHash> .Empty)); } } executionResult.CacheLookupPerfInfo = runnableProcess.CacheLookupPerfInfo; executionResult.Seal(); break; case PipExecutionStep.PostProcess: // Execution result is already computed during ExecuteProcess. Contract.Assert(executionResult != null); break; } if (executionResult == null) { executionResult = new ExecutionResult(); // If no result is set, the step succeeded executionResult.SetResult(loggingContext, runnablePip.Result?.Status ?? PipResultStatus.Succeeded); executionResult.Seal(); } completionData.StepExecutionCompleted.SetResult(executionResult); }
//----------------------------------------------------------------------------------- // Initializes a new enumerator with the specified group state. // protected MergeEnumerator(QueryTaskGroupState taskGroupState) { Contract.Assert(taskGroupState != null); _taskGroupState = taskGroupState; }
public Func <SerializationContext, PolymorphismSchema, MessagePackSerializer> CreateObjectConstructor(AssemblyBuilderEmittingContext context, AssemblyBuilderSerializerBuilder builder, SerializationTarget targetInfo) { var hasPackActions = targetInfo != null && !typeof(IPackable).IsAssignableFrom(builder.TargetType); var hasUnpackActions = targetInfo != null && !typeof(IUnpackable).IsAssignableFrom(builder.TargetType); var hasUnpackActionTables = hasUnpackActions && targetInfo.Members.Any(m => m.Member != null); // Except tuples #if FEATURE_TAP var hasPackAsyncActions = targetInfo != null && !typeof(IAsyncPackable).IsAssignableFrom(builder.TargetType); var hasUnpackAsyncActions = targetInfo != null && !typeof(IAsyncUnpackable).IsAssignableFrom(builder.TargetType); var hasUnpackAsyncActionTables = hasUnpackAsyncActions && targetInfo.Members.Any(m => m.Member != null); // Except tuples #endif // FEATURE_TAP // ReSharper disable RedundantDelegateCreation Func <bool, Func <ILConstruct> > packActionsInitialization = isAsync => new Func <ILConstruct>(() => builder.EmitPackOperationListInitialization(context, targetInfo, isAsync)); Func <bool, Func <ILConstruct> > packActionTableInitialization = isAsync => new Func <ILConstruct>(() => builder.EmitPackOperationTableInitialization(context, targetInfo, isAsync)); Func <bool, Func <ILConstruct> > unpackActionsInitialization = isAsync => new Func <ILConstruct>(() => builder.EmitUnpackOperationListInitialization(context, targetInfo, isAsync)); Func <bool, Func <ILConstruct> > unpackActionTableInitialization = isAsync => new Func <ILConstruct>(() => builder.EmitUnpackOperationTableInitialization(context, targetInfo, isAsync)); // ReSharper restore RedundantDelegateCreation var contextfulConstructor = this.CreateConstructor( MethodAttributes.Public, ConstructorParameterTypes, (type, il) => this.CreateContextfulObjectConstructor( context, type, il, hasPackActions ? packActionsInitialization(false) : default(Func <ILConstruct>), hasPackActions ? packActionTableInitialization(false) : default(Func <ILConstruct>), hasUnpackActions ? unpackActionsInitialization(false) : default(Func <ILConstruct>), hasUnpackActionTables ? unpackActionTableInitialization(false) : default(Func <ILConstruct>), #if FEATURE_TAP hasPackAsyncActions&& context.SerializationContext.SerializerOptions.WithAsync ? packActionsInitialization(true) : default(Func <ILConstruct>), hasPackAsyncActions && context.SerializationContext.SerializerOptions.WithAsync ? packActionTableInitialization(true) : default(Func <ILConstruct>), hasUnpackAsyncActions && context.SerializationContext.SerializerOptions.WithAsync ? unpackActionsInitialization(true) : default(Func <ILConstruct>), hasUnpackAsyncActionTables && context.SerializationContext.SerializerOptions.WithAsync ? unpackActionTableInitialization(true) : default(Func <ILConstruct>), #endif // FEATURE_TAP ( hasUnpackActions #if FEATURE_TAP || hasUnpackAsyncActions #endif // FEATURE_TAP ) ? () => builder.EmitMemberListInitialization(context, targetInfo) : default(Func <ILConstruct>), context.IsUnpackToUsed ? () => builder.EmitUnpackToInitialization(context) : default(Func <ILConstruct>) ) ); this.CreateConstructor( MethodAttributes.Public, ReflectionAbstractions.EmptyTypes, (_, il) => CreateDefaultObjectConstructor(contextfulConstructor, il) ); #if !NETSTANDARD1_1 && !NETSTANDARD1_3 var ctor = this._typeBuilder.CreateType().GetConstructor(ConstructorParameterTypes); #else var ctor = this._typeBuilder.CreateTypeInfo().GetConstructor(ConstructorParameterTypes); #endif // !NETSTANDARD1_1 && !NETSTANDARD1_3 var contextParameter = Expression.Parameter(typeof(SerializationContext), "context"); var schemaParameter = Expression.Parameter(typeof(PolymorphismSchema), "schema"); #if DEBUG Contract.Assert(ctor != null, "ctor != null"); #endif return (Expression.Lambda <Func <SerializationContext, PolymorphismSchema, MessagePackSerializer> >( Expression.New( ctor, contextParameter ), contextParameter, schemaParameter ).Compile()); }