public static BoolResult IsInstalled(string name) { Log.WriteStart("IsInstalled started. Name:{0}", name); BoolResult res = new BoolResult {IsSuccess = true}; try { bool disableAutoDiscovery; if (!bool.TryParse(ConfigurationManager.AppSettings[DisableAutoDiscovery], out disableAutoDiscovery)) disableAutoDiscovery = false; if (disableAutoDiscovery) { res.Value = true; } else { if (string.IsNullOrEmpty(name)) { res.IsSuccess = false; res.ErrorCodes.Add(ErrorCodes.PROVIDER_NANE_IS_NOT_SPECIFIED); return res; } Type providerType = Type.GetType(name); IHostingServiceProvider provider = (IHostingServiceProvider)Activator.CreateInstance(providerType); res.Value = provider.IsInstalled(); } } catch (Exception ex) { res.IsSuccess = false; res.ErrorCodes.Add(ErrorCodes.CANNOT_CREATE_PROVIDER_INSTANCE); Log.WriteError(ex); } finally { Log.WriteEnd("IsInstalled ended. Name:{0}", name); } return res; }
/// <inheritdoc /> public Task <BoolResult> ShutdownAsync(Context context) { return(ShutdownCall <ContentSessionTracer> .RunAsync( Tracer, context, async() => { ShutdownStarted = true; var finalResult = BoolResult.Success; foreach (var session in SessionsByCacheRoot.Values) { var result = await session.ShutdownAsync(context).ConfigureAwait(false); if (!result.Succeeded) { finalResult = new BoolResult(finalResult, result.ErrorMessage); } } ShutdownCompleted = true; return finalResult; })); }
private async Task RunServerTestAsync(Context context, Func <Context, ServiceConfiguration, Task> funcAsync) { using (var directory = new DisposableDirectory(FileSystem)) { var storeConfig = CreateStoreConfiguration(); storeConfig.Write(FileSystem, directory.Path); var serviceConfig = CreateServiceConfiguration(directory.Path, PortExtensions.GetNextAvailablePort(), Guid.NewGuid().ToString()); using (var server = new ServiceProcess(serviceConfig, Scenario, WaitForServerReadyTimeoutMs, WaitForExitTimeoutMs)) { BoolResult r = await server.StartupAsync(context).ConfigureAwait(false); r.ShouldBeSuccess(); await funcAsync(context, serviceConfig); r = await server.ShutdownAsync(context); r.ShouldBeSuccess(); } } }
/// <summary> /// Determines whether we can still perform an operation based on current state. /// </summary> public BoolResult CheckAndRegisterOperation() { if (_clock.UtcNow.Ticks >= Interlocked.Read(ref _nextOperationLimitTicks)) { lock (this) { if (_clock.UtcNow.Ticks >= _nextOperationLimitTicks) { Interlocked.Exchange(ref _nextOperationLimitTicks, _clock.UtcNow.Ticks + _operationLimitSpan.Ticks); Interlocked.Exchange(ref _count, 0); var nextSpan = new DateTime(ticks: _nextOperationLimitTicks); _errorResult = new BoolResult($"Operation limit has been reached. Throttling operation. Limit={_operationLimitCount}, SpanDuration=[{_operationLimitSpan}] NextSpanStart=[{nextSpan:MM/dd/yyyy hh:mm:ss.ffff}]"); } } } if (Interlocked.Increment(ref _count) > _operationLimitCount) { return(_errorResult); } return(BoolResult.Success); }
/// <inheritdoc /> public Task <BoolResult> ShutdownAsync(Context context) { ShutdownStarted = true; return(ShutdownCall <ContentSessionTracer> .RunAsync(_tracer, context, async() => { var shutdownResults = await Task.WhenAll(_sessionForStream.ShutdownAsync(context), _sessionForPath.ShutdownAsync(context)); Contract.Assert(shutdownResults.Length == 2); var shutdownResultForStream = shutdownResults[0]; var shutdownResultForPath = shutdownResults[1]; var result = shutdownResultForStream & shutdownResultForPath; if (!result.Succeeded) { var sb = new StringBuilder(); if (!shutdownResultForStream.Succeeded) { sb.Concat($"{SessionForStreamText} shutdown failed, error=[{shutdownResultForStream}]", "; "); } if (!shutdownResultForPath.Succeeded) { sb.Concat($"{SessionForPathText} shutdown failed, error=[{shutdownResultForPath}]", "; "); } result = new BoolResult(sb.ToString()); } ShutdownCompleted = true; return result; })); }
/// <summary> /// /// </summary> /// <param name="response">response value arrive from exchange's server</param> /// <returns></returns> public override BoolResult GetResponseMessage(IRestResponse response = null) { var _result = new BoolResult(); if (response != null) { if (response.IsSuccessful == true) { var _json_result = this.DeserializeObject <JToken>(response.Content); var _json_error = _json_result.SelectToken("error"); if (_json_error != null) { var _error_msg = _json_error.Value <string>(); if (_error_msg != "") { _result.SetFailure( _error_msg, ErrorCode.ResponseDataError ); } } } if (_result.success == true && response.IsSuccessful == false) { _result.SetFailure( response.ErrorMessage ?? response.StatusDescription, ErrorCode.ResponseRestError, (int)response.StatusCode, false ); } } return(_result); }
/// <inheritdoc /> public Task <BoolResult> StartupAsync(Context context) { return(StartupCall <ContentSessionTracer> .RunAsync( Tracer, context, async() => { StartupStarted = true; var finalResult = BoolResult.Success; var sessions = SessionsByCacheRoot.Values.ToArray(); for (var i = 0; i < sessions.Length; i++) { var canHibernate = sessions[i] is IHibernateContentSession ? "can" : "cannot"; Tracer.Debug(context, $"Session {sessions[i].Name} {canHibernate} hibernate"); var startupResult = await sessions[i].StartupAsync(context).ConfigureAwait(false); if (!startupResult.Succeeded) { finalResult = startupResult; for (var j = 0; j < i; j++) { var shutdownResult = await sessions[j].ShutdownAsync(context).ConfigureAwait(false); if (!shutdownResult.Succeeded) { finalResult = new BoolResult(finalResult, shutdownResult.ErrorMessage); } } } } StartupCompleted = true; return finalResult; })); }
protected override BoolResult OnCanRun(RunContext context) { if (!Target.CanRun) { return(BoolResult.False("Run is not supported with current build settings")); } var artifact = context.GetBuildArtifact <DotsRuntimeBuildArtifact>(); if (artifact == null) { return(BoolResult.False($"Could not retrieve build artifact '{nameof(DotsRuntimeBuildArtifact)}'.")); } if (artifact.OutputTargetFile == null) { return(BoolResult.False($"{nameof(DotsRuntimeBuildArtifact.OutputTargetFile)} is null.")); } if (!File.Exists(artifact.OutputTargetFile.FullName) && !Directory.Exists(artifact.OutputTargetFile.FullName)) { return(BoolResult.False($"Output target file '{artifact.OutputTargetFile.FullName}' not found.")); } if (!context.TryGetComponent <DotsRuntimeBuildProfile>(out var profile)) { return(BoolResult.False($"Could not retrieve component '{nameof(DotsRuntimeBuildProfile)}'.")); } if (profile.Target == null) { return(BoolResult.False($"{nameof(DotsRuntimeBuildProfile)} target is null.")); } return(BoolResult.True()); }
/// <summary> /// /// </summary> /// <param name="response">response value arrive from exchange's server</param> /// <returns></returns> public override BoolResult GetResponseMessage(IRestResponse response = null) { var _result = new BoolResult(); if (response != null) { if (response.IsSuccessful == true) { var _json_result = this.DeserializeObject <JToken>(response.Content); var _json_success = _json_result["result"]; if (_json_success != null) { if (_json_success.Value <string>() != "success") { _result.SetFailure( _json_result["data"]["message"].Value <string>(), ErrorCode.ResponseDataError ); } } } if (_result.success == true && response.IsSuccessful == false) { _result.SetFailure( response.ErrorMessage ?? response.StatusDescription, ErrorCode.ResponseRestError, (int)response.StatusCode, false ); } } return(_result); }
/// <inheritdoc /> public async Task <Possible <int, Failure> > IncorporateRecordsAsync(IEnumerable <Task <StrongFingerprint> > strongFingerprints, Guid activityId) { var sfpList = new List <StrongFingerprint>(); int count = 0; foreach (var sfpTask in strongFingerprints) { var sfp = await sfpTask; sfpList.Add(sfp); SessionEntries?.TryAdd(sfp, 1); count++; } BoolResult incorporateResult = await CacheSession.IncorporateStrongFingerprintsAsync( new Context(Logger), sfpList.Select(sfp => Task.FromResult(new BuildXL.Cache.MemoizationStore.Interfaces.Sessions.StrongFingerprint( sfp.WeakFingerprint.ToMemoization(), new Selector(sfp.CasElement.ToMemoization(), sfp.HashElement.RawHash.ToByteArray())))), CancellationToken.None); return(incorporateResult.Succeeded ? count : new Possible <int, Failure>(new CacheFailure(incorporateResult.ErrorMessage))); }
/// <inheritdoc /> protected override async Task<BoolResult> StartupCoreAsync(OperationContext context) { BoolResult result = await PreStartupAsync(context); var rpcConfiguration = Configuration.RpcConfiguration; if (result.Succeeded) { _grpcClient = new GrpcContentClient(SessionTracer, FileSystem, rpcConfiguration.GrpcPort, Configuration.Scenario, rpcConfiguration.HeartbeatInterval); result = await Configuration.RetryPolicy.ExecuteAsync(() => _grpcClient.StartupAsync(context, waitMs: 0)); if (!result) { await Configuration.RetryPolicy.ExecuteAsync(() => _grpcClient.ShutdownAsync(context)).ThrowIfFailure(); } } if (!result) { await PostShutdownAsync(context).ThrowIfFailure(); return result; } return result; }
/// <inheritdoc /> public virtual async Task <BoolResult> ShutdownAsync(Context context) { ShutdownStarted = true; var shutdownMemoizationResult = _memoizationReadOnlySession != null ? await _memoizationReadOnlySession.ShutdownAsync(context).ConfigureAwait(false) : BoolResult.Success; var shutdownContentResult = _contentReadOnlySession != null ? await _contentReadOnlySession.ShutdownAsync(context).ConfigureAwait(false) : BoolResult.Success; BoolResult result; if (shutdownMemoizationResult.Succeeded && shutdownContentResult.Succeeded) { result = BoolResult.Success; } else { var sb = new StringBuilder(); if (!shutdownMemoizationResult.Succeeded) { sb.Append($"Memoization session shutdown failed, error=[{shutdownMemoizationResult}]"); } if (!shutdownContentResult.Succeeded) { sb.Append($"Content session shutdown failed, error=[{shutdownContentResult}]"); } result = new BoolResult(sb.ToString()); } ShutdownCompleted = true; return(result); }
public async Task <TResult> RunAsync([CallerMemberName] string?caller = null) { using (_counter?.Start()) { TraceOperationStarted(caller !); var stopwatch = StopwatchSlim.Start(); try { // No need to run anything if the cancellation is requested already. _context.Token.ThrowIfCancellationRequested(); var result = await AsyncOperation(); TraceOperationFinished(result, stopwatch.Elapsed, caller !); return(result); } catch (Exception e) { var resultBase = new BoolResult(e); MarkResultIsCancelledIfNeeded(resultBase, e); // Marking the operation as critical failure only when it was not a cancellation. if (_isCritical && !resultBase.IsCancelled) { resultBase.MakeCritical(); } TraceResultOperationFinished(resultBase, stopwatch.Elapsed, caller !); throw; } } }
public async Task IncorporateSucceedsAsync() { await IncorporateSucceedsAsyncRunner(async (context, incorporateSession, strongFingerprint, contentHashListWithDeterminism) => { var strongFingerprints = new List <Task <StrongFingerprint> >() { Task.FromResult(strongFingerprint) }; BoolResult incorporateResult = await incorporateSession.IncorporateStrongFingerprintsAsync(context, strongFingerprints, Token).ConfigureAwait(false); return(incorporateResult.Succeeded); }); await IncorporateSucceedsAsyncRunner(async (context, incorporateSession, strongFingerprint, contentHashListWithDeterminism) => { var addOrGetResult = await incorporateSession.AddOrGetContentHashListAsync(context, strongFingerprint, contentHashListWithDeterminism, Token).ConfigureAwait(false); return(addOrGetResult.Succeeded); }); await IncorporateSucceedsAsyncRunner(async (context, incorporateSession, strongFingerprint, contentHashListWithDeterminism) => { var getResult = await incorporateSession.GetContentHashListAsync(context, strongFingerprint, Token).ConfigureAwait(false); return(getResult.Succeeded && (getResult.ContentHashListWithDeterminism.ContentHashList != null)); }); }
/// <inheritdoc /> public Task <BoolResult> ShutdownAsync(Context context) { return(ShutdownCall <ContentStoreTracer> .RunAsync(Tracer, context, async() => { ShutdownStarted = true; var finalResult = BoolResult.Success; foreach (var store in _drivesWithContentStore.Values) { if (store.StartupCompleted && !store.ShutdownCompleted) { // Shutdown is available only when the store started up successfully and wasn't shut down yet. var result = await store.ShutdownAsync(context).ConfigureAwait(false); if (!result) { finalResult = new BoolResult(finalResult, result.ErrorMessage); } } } ShutdownCompleted = true; return finalResult; })); }
/// <inheritdoc /> protected override async Task <BoolResult> StartupCoreAsync(OperationContext context) { BoolResult result; try { result = await _configuration.ArtifactHttpClientFactory.StartupAsync(context); if (!result.Succeeded) { return(result); } _artifactHttpClient = _configuration.UseDedupStore ? (IArtifactHttpClient)await _configuration.ArtifactHttpClientFactory.CreateDedupStoreHttpClientAsync(context).ConfigureAwait(false) : await _configuration.ArtifactHttpClientFactory.CreateBlobStoreHttpClientAsync(context).ConfigureAwait(false); } catch (Exception e) { result = new BoolResult(e); } return(result); }
/// <inheritdoc /> public void PostInitializationCompleted(Context context, BoolResult result) { }
public void PostInitializationCompleted(Context context, BoolResult result) { Contract.Requires(ContentStore != null, "ContentStore must be initialized here."); ContentStore.PostInitializationCompleted(context, result); }
/// <summary> /// /// </summary> /// <param name="response">response value arrive from exchange's server</param> /// <returns></returns> public override BoolResult GetResponseMessage(IRestResponse response = null) { var _result = new BoolResult(); if (response != null) { if (response.IsSuccessful == true) { var _json_result = this.DeserializeObject <JToken>(response.Content); var _json_error = _json_result.SelectToken("error"); if (_json_error != null && _json_error.Count() > 0) { var _message = ""; { if (_json_error.GetType() == typeof(JArray)) { if (_json_error.Count() > 0) { _message = _json_error[0].Value <string>(); } } else if (_json_error.GetType() == typeof(JValue)) { _message = _json_error.Value <string>(); } } if (String.IsNullOrEmpty(_message) == false) { var _error_code = ErrorMessages .Where(e => _message.IndexOf(e.Key) >= 0) .OrderByDescending(e => e.Key.Length) .FirstOrDefault(); if (_error_code.Key != null) { _result.errorCode = _error_code.Value; } else { _result.errorCode = ErrorCode.ResponseDataError; } _result.SetFailure( _message, _result.errorCode ); } else { var _token_result = _json_result.SelectToken("result"); if (_token_result == null || ( _token_result != null && _token_result.GetType() == typeof(JArray) && _token_result.Count() <= 0 ) ) { _result.SetFailure(errorCode: ErrorCode.NotFoundData); } } } } if (_result.success == true && response.IsSuccessful == false) { _result.SetFailure( response.ErrorMessage ?? response.StatusDescription, ErrorCode.ResponseRestError, (int)response.StatusCode, false ); } } return(_result); }
public void ConstructFromResultBase() { var other = new BoolResult("error"); Assert.False(new PutResult(other, Hash1, "message").Succeeded); }
public async Task <OpenStreamResult> OpenStreamAsync(Context context, ContentHash contentHash, CancellationToken cts, UrgencyHint urgencyHint = UrgencyHint.Nominal) { BoolResult result = await UnresponsiveUntilCancelledAsync(context, nameof(OpenStreamAsync), cts); return(new OpenStreamResult(result)); }
public async Task <PutResult> PutStreamAsync(Context context, HashType hashType, Stream stream, CancellationToken cts, UrgencyHint urgencyHint = UrgencyHint.Nominal) { BoolResult result = await UnresponsiveUntilCancelledAsync(context, nameof(PutStreamAsync), cts); return(new PutResult(result, new ContentHash(hashType))); }
public virtual void StartupStop(Context context, BoolResult result) { InitializationFinished(context, result, result.Duration, $"{Name}.Startup stop {result.DurationMs}ms result=[{result}]", nameof(StartupStop)); }
/// <inheritdoc /> public Task <BoolResult> StartupAsync(Context context) { StartupStarted = true; return(StartupCall <CacheTracer> .RunAsync(_tracer, context, async() => { var preStartupResult = await PreStartupAsync(context).ConfigureAwait(false); if (!preStartupResult.Succeeded) { return preStartupResult; } var contentStoreTask = Task.Run(() => ContentStore.StartupAsync(context)); var memoizationStoreResult = await MemoizationStore.StartupAsync(context).ConfigureAwait(false); var contentStoreResult = await contentStoreTask.ConfigureAwait(false); BoolResult result; if (!contentStoreResult.Succeeded || !memoizationStoreResult.Succeeded) { var sb = new StringBuilder(); if (contentStoreResult.Succeeded) { var r = await ContentStore.ShutdownAsync(context).ConfigureAwait(false); if (!r.Succeeded) { sb.AppendFormat($"Content store shutdown failed, error=[{r}]"); } } else { sb.AppendFormat($"Content store startup failed, error=[{contentStoreResult}]"); } if (memoizationStoreResult.Succeeded) { var r = await MemoizationStore.ShutdownAsync(context).ConfigureAwait(false); if (!r.Succeeded) { sb.Append(sb.Length > 0 ? ", " : string.Empty); sb.AppendFormat($"Memoization store shutdown failed, error=[{memoizationStoreResult}]"); } } else { sb.Append(sb.Length > 0 ? ", " : string.Empty); sb.AppendFormat($"Memoization store startup failed, error=[{memoizationStoreResult}]"); } result = new BoolResult(sb.ToString()); } else { result = BoolResult.Success; } StartupCompleted = true; return result; })); }
/// <inheritdoc /> public void PostInitializationCompleted(Context context, BoolResult result) { context.Debug($"Setting result for post-initialization completion task to '{result}'."); _postInitializationCompletion.TrySetResult(result); }
/// <inheritdoc /> public Task <BoolResult> StartupAsync(Context context) { StartupStarted = true; return(StartupCall <BuildCacheCacheTracer> .RunAsync(_tracer, context, async() => { BoolResult result; _tracer.Debug(context, $"Creating ContentHashListAdapterFactory with {nameof(_useBlobContentHashLists)}={_useBlobContentHashLists}"); _contentHashListAdapterFactory = await ContentHashListAdapterFactory.CreateAsync( context, _buildCacheHttpClientFactory, _useBlobContentHashLists); Id = await _contentHashListAdapterFactory.BuildCacheHttpClient.GetBuildCacheServiceDeterminism(_cacheNamespace) .ConfigureAwait(false); var backingContentStoreTask = Task.Run(async() => await _backingContentStore.StartupAsync(context).ConfigureAwait(false)); var writeThroughContentStoreResult = _writeThroughContentStore != null ? await _writeThroughContentStore.StartupAsync(context).ConfigureAwait(false) : BoolResult.Success; var backingContentStoreResult = await backingContentStoreTask.ConfigureAwait(false); if (backingContentStoreResult.Succeeded && writeThroughContentStoreResult.Succeeded) { result = BoolResult.Success; } else { var sb = new StringBuilder(); if (backingContentStoreResult.Succeeded) { var r = await _backingContentStore.ShutdownAsync(context).ConfigureAwait(false); if (!r.Succeeded) { sb.Append($"Backing content store shutdown failed, error=[{r}]"); } } else { sb.Append($"Backing content store startup failed, error=[{backingContentStoreResult}]"); } if (writeThroughContentStoreResult.Succeeded) { var r = _writeThroughContentStore != null ? await _writeThroughContentStore.ShutdownAsync(context).ConfigureAwait(false) : BoolResult.Success; if (!r.Succeeded) { sb.Append(sb.Length > 0 ? ", " : string.Empty); sb.Append($"Write-through content store shutdown failed, error=[{r}]"); } } else { sb.Append(sb.Length > 0 ? ", " : string.Empty); sb.Append($"Write-through content store startup failed, error=[{writeThroughContentStoreResult}]"); } result = new BoolResult(sb.ToString()); } StartupCompleted = true; return result; })); }
public async Task MultipleCaches() { const string CacheName1 = "test1"; const string CacheName2 = "test2"; using (var testDirectory0 = new DisposableDirectory(FileSystem)) using (var testDirectory1 = new DisposableDirectory(FileSystem)) using (var testDirectory2 = new DisposableDirectory(FileSystem)) { var config = CreateStoreConfiguration(); var rootPath1 = testDirectory1.Path; config.Write(FileSystem, rootPath1); var rootPath2 = testDirectory2.Path; config.Write(FileSystem, rootPath2); var grpcPort = PortExtensions.GetNextAvailablePort(); var grpcPortFileName = Guid.NewGuid().ToString(); var serviceConfiguration = new ServiceConfiguration( new Dictionary <string, AbsolutePath> { { CacheName1, rootPath1 }, { CacheName2, rootPath2 } }, testDirectory0.Path, ServiceConfiguration.DefaultGracefulShutdownSeconds, grpcPort, grpcPortFileName); using (var server = CreateServer(serviceConfiguration)) { var factory = new MemoryMappedFileGrpcPortSharingFactory(Logger, grpcPortFileName); var reader = factory.GetPortReader(); var port = reader.ReadPort(); var rpcConfig = new ServiceClientRpcConfiguration(port); using (var store1 = new ServiceClientContentStore( Logger, FileSystem, new ServiceClientContentStoreConfiguration(CacheName1, rpcConfig, Scenario))) using (var store2 = new ServiceClientContentStore( Logger, FileSystem, new ServiceClientContentStoreConfiguration(CacheName2, rpcConfig, Scenario))) { try { var rs = await server.StartupAsync(_context); rs.ShouldBeSuccess(); var storeBoolResult1 = await store1.StartupAsync(_context); storeBoolResult1.ShouldBeSuccess(); var storeBoolResult2 = await store2.StartupAsync(_context); storeBoolResult2.ShouldBeSuccess(); IContentSession session1 = null; IContentSession session2 = null; try { var createSessionResult1 = store1.CreateSession(_context, "session1", ImplicitPin.None); createSessionResult1.ShouldBeSuccess(); var createSessionResult2 = store2.CreateSession(_context, "session2", ImplicitPin.None); createSessionResult2.ShouldBeSuccess(); using (createSessionResult1.Session) using (createSessionResult2.Session) { var r1 = await createSessionResult1.Session.StartupAsync(_context); r1.ShouldBeSuccess(); session1 = createSessionResult1.Session; var r2 = await createSessionResult2.Session.StartupAsync(_context); r2.ShouldBeSuccess(); session2 = createSessionResult2.Session; var r3 = await session1.PutRandomAsync( _context, ContentHashType, false, RandomContentByteCount, Token); var pinResult = await session1.PinAsync(_context, r3.ContentHash, Token); pinResult.ShouldBeSuccess(); r3 = await session2.PutRandomAsync( _context, ContentHashType, false, RandomContentByteCount, Token); pinResult = await session2.PinAsync(_context, r3.ContentHash, Token); pinResult.ShouldBeSuccess(); } } finally { if (session2 != null) { await session2.ShutdownAsync(_context).ShouldBeSuccess(); } if (session1 != null) { await session1.ShutdownAsync(_context).ShouldBeSuccess(); } } } finally { BoolResult r1 = null; BoolResult r2 = null; if (store1.StartupCompleted) { r1 = await store1.ShutdownAsync(_context); } if (store2.StartupCompleted) { r2 = await store2.ShutdownAsync(_context); } var r3 = await server.ShutdownAsync(_context); r1?.ShouldBeSuccess(); r2?.ShouldBeSuccess(); r3?.ShouldBeSuccess(); } } } } }
public void PostInitializationCompleted(Context context, BoolResult result) => _local.PostInitializationCompleted(context, result);
public async Task <IEnumerable <Task <Indexed <PinResult> > > > PinAsync(Context context, IReadOnlyList <ContentHash> contentHashes, CancellationToken cts, UrgencyHint urgencyHint = UrgencyHint.Nominal) { BoolResult result = await UnresponsiveUntilCancelledAsync(context, nameof(PinAsync), cts); return(contentHashes.Select(hashWithPath => new PinResult(result)).AsIndexed().AsTasks()); }
/// <summary> /// /// </summary> /// <param name="response">response value arrive from exchange's server</param> /// <returns></returns> public override BoolResult GetResponseMessage(IRestResponse response = null) { var _result = new BoolResult(); if (response != null) { if (response.IsSuccessful == false) // (int) StatusCode >= 200 && (int) StatusCode <= 299 && ResponseStatus == ResponseStatus.Completed; { if ((int)response.StatusCode != 429) { if (String.IsNullOrEmpty(response.Content) == false && response.Content[0] == '{') { var _json_result = this.DeserializeObject <JToken>(response.Content); var _json_error = _json_result.SelectToken("error"); if (_json_error != null) { var _json_message = _json_error.SelectToken("message"); if (_json_message != null) { var _error_code = ErrorCode.ExchangeError; var _error_msg = _json_message.Value <string>(); if (String.IsNullOrEmpty(_error_msg) == false) { if (ErrorMessages.ContainsKey(_error_msg) == true) { _error_code = ErrorMessages[_error_msg]; } } else { _error_msg = response.Content; } _result.SetFailure(_error_msg, _error_code); } } } } else { _result.SetFailure( response.ErrorMessage ?? response.StatusDescription, ErrorCode.DDoSProtection, (int)response.StatusCode, false ); } } if (_result.success == true && response.IsSuccessful == false) { _result.SetFailure( response.ErrorMessage ?? response.StatusDescription, ErrorCode.ResponseRestError, (int)response.StatusCode, false ); } } return(_result); }
public virtual void ShutdownStop(Context context, BoolResult result) { TracerOperationFinished(context, result, $"{Name}.Shutdown stop {result.DurationMs}ms result=[{result}]"); }