protected override async Task Process(IObservable <IParsedDocumentHolder> reviews, ISessionContainer container, ISentimentDataHolder sentimentAdjustment) { var client = container.GetTesting(Config.Model); container.Context.Lexicon = sentimentAdjustment; using (Observable.Interval(TimeSpan.FromSeconds(30)) .Subscribe(item => Logger.LogInformation(client.Pipeline.Monitor.ToString()))) { client.TrackArff = false; client.UseBagOfWords = Config.UseBagOfWords; client.Init(); var result = await client.Process(reviews.ObserveOn(TaskPoolScheduler.Default)) .Select( item => { Semaphore.Release(); return(Resolve(item)); }) .ToArray(); SaveDocuments(result); } }
internal static Container GetContainerWithIntercepter( string databaseId, string containerId, Action <Uri, ResourceOperation, DocumentServiceRequest> interceptor, bool useGatewayMode = false, Func <Uri, ResourceOperation, DocumentServiceRequest, StoreResponse> interceptorWithStoreResult = null, ISessionContainer sessionContainer = null) { CosmosClient clientWithIntercepter = TestCommon.CreateCosmosClient( builder => { if (useGatewayMode) { builder.WithConnectionModeGateway(); } if (sessionContainer != null) { builder.WithSessionContainer(sessionContainer); } builder.WithTransportClientHandlerFactory(transportClient => new TransportClientWrapper( transportClient, interceptor, interceptorWithStoreResult)); }); return(clientWithIntercepter.GetContainer(databaseId, containerId)); }
public ClientCollectionCache(ISessionContainer sessionContainer, IStoreModel storeModel, ICosmosAuthorizationTokenProvider tokenProvider, IRetryPolicyFactory retryPolicy) { this.storeModel = storeModel ?? throw new ArgumentNullException("storeModel"); this.tokenProvider = tokenProvider; this.retryPolicy = retryPolicy; this.sessionContainer = sessionContainer; }
public TokenRefreshDelegatingHandler( ISessionContainer sessionInfoContainer, ITokenRefreshStrategy tokenRefreshStrategy) { _sessionInfoContainer = sessionInfoContainer; _tokenRefreshStrategy = tokenRefreshStrategy; }
protected BaseRawCommand(ILogger log, T config, IDataLoader loader, ISessionContainer container) : base(log) { Config = config ?? throw new ArgumentNullException(nameof(config)); this.container = container ?? throw new ArgumentNullException(nameof(container)); this.loader = loader; }
public PhotoRepository(ISessionContainer sessionContainer, IImageGenerator imageGenerator, IConfigAccessor configAccessor, ILogger logger) { this.sessionContainer = sessionContainer; this.imageGenerator = imageGenerator; this.configAccessor = configAccessor; this.logger = logger; }
public async Task TestGatewayModelSession() { ContainerProperties containerProperties = await this.Container.GetCachedContainerPropertiesAsync( false, Trace.GetRootTrace("Test"), CancellationToken.None); ISessionContainer sessionContainer = this.cosmosClient.DocumentClient.sessionContainer; string docLink = "dbs/" + this.database.Id + "/colls/" + containerProperties.Id + "/docs/3"; Documents.Collections.INameValueCollection headers = new StoreRequestNameValueCollection(); headers.Set(HttpConstants.HttpHeaders.PartitionKey, "[\"Status3\"]"); DocumentServiceRequest request = DocumentServiceRequest.Create(OperationType.Read, ResourceType.Document, docLink, AuthorizationTokenType.PrimaryMasterKey, headers); string globalSessionToken = sessionContainer.ResolveGlobalSessionToken(request); Assert.IsTrue(globalSessionToken.Split(',').Length > 1); await GatewayStoreModel.ApplySessionTokenAsync(request, Cosmos.ConsistencyLevel.Session, sessionContainer, await this.cosmosClient.DocumentClient.GetPartitionKeyRangeCacheAsync(NoOpTrace.Singleton), await this.cosmosClient.DocumentClient.GetCollectionCacheAsync(NoOpTrace.Singleton)); string sessionToken = request.Headers[HttpConstants.HttpHeaders.SessionToken]; Assert.IsTrue(!string.IsNullOrEmpty(sessionToken) && sessionToken.Split(',').Length == 1); }
public GatewayStoreModel( GlobalEndpointManager endpointManager, ISessionContainer sessionContainer, TimeSpan requestTimeout, ConsistencyLevel defaultConsistencyLevel, DocumentClientEventSource eventSource, JsonSerializerSettings serializerSettings, UserAgentContainer userAgent, ApiType apiType, Func <HttpClient> httpClientFactory) : this(endpointManager, sessionContainer, defaultConsistencyLevel, eventSource) { HttpClient httpClient = httpClientFactory(); if (httpClient == null) { throw new InvalidOperationException("HttpClientFactory did not produce an HttpClient"); } this.InitializeGatewayStoreClient( requestTimeout, serializerSettings, userAgent, apiType, httpClient); }
public RenameCollectionAwareClientRetryPolicy(ISessionContainer sessionContainer, ClientCollectionCache collectionCache, IDocumentClientRetryPolicy retryPolicy) { this.retryPolicy = retryPolicy; this.sessionContainer = sessionContainer; this.collectionCache = collectionCache; this.request = null; }
internal static async Task ApplySessionTokenAsync( DocumentServiceRequest request, ConsistencyLevel defaultConsistencyLevel, ISessionContainer sessionContainer, PartitionKeyRangeCache partitionKeyRangeCache, CollectionCache clientCollectionCache, IGlobalEndpointManager globalEndpointManager) { if (request.Headers == null) { Debug.Fail("DocumentServiceRequest does not have headers."); return; } // Master resource operations don't require session token. if (GatewayStoreModel.IsMasterOperation(request.ResourceType, request.OperationType)) { if (!string.IsNullOrEmpty(request.Headers[HttpConstants.HttpHeaders.SessionToken])) { request.Headers.Remove(HttpConstants.HttpHeaders.SessionToken); } return; } if (!string.IsNullOrEmpty(request.Headers[HttpConstants.HttpHeaders.SessionToken])) { return; // User is explicitly controlling the session. } string requestConsistencyLevel = request.Headers[HttpConstants.HttpHeaders.ConsistencyLevel]; bool isReadOrBatchRequest = request.IsReadOnlyRequest || request.OperationType == OperationType.Batch; bool requestHasConsistencySet = !string.IsNullOrEmpty(requestConsistencyLevel) && isReadOrBatchRequest; // Only read requests can have their consistency modified bool sessionConsistencyApplies = (!requestHasConsistencySet && defaultConsistencyLevel == ConsistencyLevel.Session) || (requestHasConsistencySet && string.Equals(requestConsistencyLevel, GatewayStoreModel.sessionConsistencyAsString, StringComparison.OrdinalIgnoreCase)); bool isMultiMasterEnabledForRequest = globalEndpointManager.CanUseMultipleWriteLocations(request); if (!sessionConsistencyApplies || (!isReadOrBatchRequest && !isMultiMasterEnabledForRequest)) { return; // Only apply the session token in case of session consistency and the request is read only or read/write on multimaster } (bool isSuccess, string sessionToken) = await GatewayStoreModel.TryResolveSessionTokenAsync( request, sessionContainer, partitionKeyRangeCache, clientCollectionCache); if (isSuccess && !string.IsNullOrEmpty(sessionToken)) { request.Headers[HttpConstants.HttpHeaders.SessionToken] = sessionToken; } }
public void SetUp() { mockery = new Mockery(); dependencySessionContainer = mockery.NewMock<ISessionContainer>(); dependencyDb = mockery.NewMock<IWorkTimeAccountingPlatformDAO>(); dependencySessionIdProvider = mockery.NewMock<ISessionIdProvider>(); testee = new CommunicationService(dependencySessionContainer, dependencyDb, dependencySessionIdProvider); }
internal static async Task ApplySessionTokenAsync( DocumentServiceRequest request, ConsistencyLevel defaultConsistencyLevel, ISessionContainer sessionContainer, PartitionKeyRangeCache partitionKeyRangeCache, CollectionCache clientCollectionCache) { if (request.Headers == null) { Debug.Fail("DocumentServiceRequest does not have headers."); return; } // Master resource operations don't require session token. if (GatewayStoreModel.IsMasterOperation(request.ResourceType, request.OperationType)) { if (!string.IsNullOrEmpty(request.Headers[HttpConstants.HttpHeaders.SessionToken])) { request.Headers.Remove(HttpConstants.HttpHeaders.SessionToken); } return; } if (!string.IsNullOrEmpty(request.Headers[HttpConstants.HttpHeaders.SessionToken])) { return; // User is explicitly controlling the session. } string requestConsistencyLevel = request.Headers[HttpConstants.HttpHeaders.ConsistencyLevel]; bool sessionConsistency = defaultConsistencyLevel == ConsistencyLevel.Session || (!string.IsNullOrEmpty(requestConsistencyLevel) && string.Equals(requestConsistencyLevel, ConsistencyLevel.Session.ToString(), StringComparison.OrdinalIgnoreCase)); if (!sessionConsistency || (!request.IsReadOnlyRequest && request.OperationType != OperationType.Batch)) { return; // Only apply the session token in case of session consistency and the request is read only } (bool isSuccess, string sessionToken) = await GatewayStoreModel.TryResolveSessionTokenAsync( request, sessionContainer, partitionKeyRangeCache, clientCollectionCache); if (!isSuccess) { sessionToken = sessionContainer.ResolveGlobalSessionToken(request); } if (!string.IsNullOrEmpty(sessionToken)) { request.Headers[HttpConstants.HttpHeaders.SessionToken] = sessionToken; } }
public static IObservable <IParsedDocumentHolder> GetParsedReviewHolders(this ISessionContainer container, IDataSource data) { var all = data.Load() .Select(processingData => (IParsedDocumentHolder) new AsyncParsingDocumentHolder( ConstructHolder(container, processingData))); return(all); }
public void SetUp() { _session = MockRepository.GenerateStub<ISession>(); sessionContainer = MockRepository.GenerateMock<ISessionContainer>(); sessionContainer.Stub(x => x.CurrentSession).Return(_session); _repository = new NHibernateSampleApplication.Repository.Repository(sessionContainer); _book = new Book(); }
public void SetUp() { _session = MockRepository.GenerateStub <ISession>(); sessionContainer = MockRepository.GenerateMock <ISessionContainer>(); sessionContainer.Stub(x => x.CurrentSession).Return(_session); _repository = new NHibernateSampleApplication.Repository.Repository(sessionContainer); _book = new Book(); }
public TokenRefreshStrategy( ITokenRefreshInvoker tokenRefreshInvoker, ILoggerFactory loggerFactory, ISessionContainer sessionInfoContainer) { _tokenRefreshInvoker = tokenRefreshInvoker; _logger = loggerFactory.CreateLogger <TokenRefreshStrategy>(); _sessionInfoContainer = sessionInfoContainer; }
public async ValueTask ExecuteAsync(IAppSession session, PackageInfo package) { _sessionContainer = _serviceProvider.GetSessionContainer(); var sessions = _sessionContainer.GetSessions <ServerSession>(n => n.ClientType == ClientType.Web).ToList(); foreach (IAppSession serverSession in sessions) { await serverSession.SendAsync(Encoding.UTF8.GetBytes($"Output {package.Content}{Package.Terminator}")); } }
public void SetUp() { _sessionFactory = MockRepository.GenerateMock<ISessionFactory>(); _session = MockRepository.GenerateStub<ISession>(); _transaction = MockRepository.GenerateStub<ITransaction>(); _sessionFactory.Expect(x => x.OpenSession()).Return(_session); _session.Stub(x => x.BeginTransaction()).Return(_transaction); _sessionContainer = new SessionContainer(_sessionFactory); }
public void SetUp() { _sessionFactory = MockRepository.GenerateMock <ISessionFactory>(); _session = MockRepository.GenerateStub <ISession>(); _transaction = MockRepository.GenerateStub <ITransaction>(); _sessionFactory.Expect(x => x.OpenSession()).Return(_session); _session.Stub(x => x.BeginTransaction()).Return(_transaction); _sessionContainer = new SessionContainer(_sessionFactory); }
static void QueryTheDatabase(ISessionContainer sessionContainer) { //you've got to open the session before we can use it sessionContainer.OpenSession(); //using the opened session from the sessionContainer, we can query the database List<Account> accounts = sessionContainer.Session.Query<Account>().ToList(); accounts.ForEach(x => Console.WriteLine(x.Name)); //afterwards, you need to close the session sessionContainer.CloseSession(); }
public ClearIdleSessionMiddleware(IServiceProvider serviceProvider, IOptions <ServerOptions> serverOptions) { _sessionContainer = serviceProvider.GetService <ISessionContainer <TSessionData> >(); if (_sessionContainer == null) { throw new Exception($"{nameof(ClearIdleSessionMiddleware<TSessionData>)} needs a middleware of {nameof(ISessionContainer<TSessionData>)}"); } _serverOptions = serverOptions.Value; _logger = LoggerManager.GetLogger("ClearIdleSessionMiddleware"); }
public ClearIdleSessionMiddleware(IServiceProvider serviceProvider, IOptions <ServerOptions> serverOptions, ILoggerFactory loggerFactory) { _sessionContainer = serviceProvider.GetService <ISessionContainer>(); if (_sessionContainer == null) { throw new Exception($"{nameof(ClearIdleSessionMiddleware)} needs a middleware of {nameof(ISessionContainer)}"); } _serverOptions = serverOptions.Value; _logger = loggerFactory.CreateLogger <ClearIdleSessionMiddleware>(); }
private GatewayStoreModel( GlobalEndpointManager endpointManager, ISessionContainer sessionContainer, ConsistencyLevel defaultConsistencyLevel, DocumentClientEventSource eventSource) { // CookieContainer is not really required, but is helpful in debugging. this.cookieJar = new CookieContainer(); this.endpointManager = endpointManager; this.sessionContainer = sessionContainer; this.defaultConsistencyLevel = defaultConsistencyLevel; this.eventSource = eventSource; }
public AuthenticationInfoService( IUserProfileContainer userProfileContainer, IAccountContainer accountContainer, ISessionContainer sessionContainer, IMetadataContainer metadataContainer, ILoggerFactory loggerFactory) { _userProfileContainer = userProfileContainer; _accountContainer = accountContainer; _sessionContainer = sessionContainer; _metadataContainer = metadataContainer; _logger = loggerFactory.CreateLogger <AuthenticationInfoService>(); }
public async ValueTask ExecuteAsync(IAppSession session, PackageInfo package) { var command = Command.Parser.ParseFrom(Encoding.UTF8.GetBytes(package.Content)); _sessionContainer = _serviceProvider.GetSessionContainer(); var sessions = _sessionContainer.GetSessions <ServerSession>(n => n.ClientType == ClientType.Agent && n.Ip == command.Ip).ToList(); foreach (IAppSession serverSession in sessions) { await serverSession.SendAsync(Encoding.UTF8.GetBytes($"{CommandKey.Execute} {package.Content}{Package.Terminator}")); } await session.SendAsync(Encoding.UTF8.GetBytes($"{CommandKey.Execute} Started{Package.Terminator}")); }
internal static async Task <Tuple <bool, string> > TryResolveSessionTokenAsync( DocumentServiceRequest request, ISessionContainer sessionContainer, PartitionKeyRangeCache partitionKeyRangeCache, CollectionCache clientCollectionCache) { if (request == null) { throw new ArgumentNullException(nameof(request)); } if (sessionContainer == null) { throw new ArgumentNullException(nameof(sessionContainer)); } if (partitionKeyRangeCache == null) { throw new ArgumentNullException(nameof(partitionKeyRangeCache)); } if (clientCollectionCache == null) { throw new ArgumentNullException(nameof(clientCollectionCache)); } if (request.ResourceType.IsPartitioned()) { (bool isSuccess, PartitionKeyRange partitionKeyRange) = await TryResolvePartitionKeyRangeAsync( request : request, sessionContainer : sessionContainer, partitionKeyRangeCache : partitionKeyRangeCache, clientCollectionCache : clientCollectionCache, refreshCache : false); if (isSuccess && sessionContainer is SessionContainer gatewaySessionContainer) { request.RequestContext.ResolvedPartitionKeyRange = partitionKeyRange; string localSessionToken = gatewaySessionContainer.ResolvePartitionLocalSessionTokenForGateway(request, partitionKeyRange.Id); if (!string.IsNullOrEmpty(localSessionToken)) { return(new Tuple <bool, string>(true, localSessionToken)); } } } return(new Tuple <bool, string>(false, null)); }
public async ValueTask ExecuteAsync(IAppSession session, PackageInfo package) { _sessionContainer = _serviceProvider.GetSessionContainer(); var sessions = _sessionContainer.GetSessions <ServerSession>(n => n.ClientType == ClientType.Agent).ToList(); var agents = sessions.Select(n => new AgentInfo { SessionId = n.SessionID, Ip = n.Ip, Port = n.Port, ConnectTime = n.ConnectTime }).ToList(); await session.SendAsync(Encoding.UTF8.GetBytes($"{CommandKey.ListAgent} {JsonConvert.SerializeObject(agents)}{Package.Terminator}")); }
internal static void ApplySessionToken( DocumentServiceRequest request, ConsistencyLevel defaultConsistencyLevel, ISessionContainer sessionContainer) { if (request.Headers == null) { Debug.Fail("DocumentServiceRequest does not have headers."); return; } // Master resource operations don't require session token. if (GatewayStoreModel.IsMasterOperation(request.ResourceType, request.OperationType)) { if (!string.IsNullOrEmpty(request.Headers[HttpConstants.HttpHeaders.SessionToken])) { request.Headers.Remove(HttpConstants.HttpHeaders.SessionToken); } return; } if (!string.IsNullOrEmpty(request.Headers[HttpConstants.HttpHeaders.SessionToken])) { return; // User is explicitly controlling the session. } string requestConsistencyLevel = request.Headers[HttpConstants.HttpHeaders.ConsistencyLevel]; bool sessionConsistency = defaultConsistencyLevel == ConsistencyLevel.Session || (!string.IsNullOrEmpty(requestConsistencyLevel) && string.Equals(requestConsistencyLevel, ConsistencyLevel.Session.ToString(), StringComparison.OrdinalIgnoreCase)); if (!sessionConsistency) { return; // Only apply the session token in case of session consistency } //Apply the ambient session. string sessionToken = sessionContainer.ResolveGlobalSessionToken(request); if (!string.IsNullOrEmpty(sessionToken)) { request.Headers[HttpConstants.HttpHeaders.SessionToken] = sessionToken; } }
public async Task ValidateAsync(ISessionContainer sessionContainer) { if (sessionContainer == null) { throw new ArgumentNullException(nameof(sessionContainer)); } if (sessionContainer.SessionId.HasValue) { var department = await this.SessionDAL.GetAsync(new SessionIdentityModel((int)sessionContainer.SessionId)); if (department == null) { throw new InvalidOperationException($"Session not found by id {sessionContainer.SessionId}"); } } }
public async ValueTask ExecuteAsync(IAppSession session, PackageInfo package) { Console.WriteLine(package.Content); _sessionContainer = _serviceProvider.GetSessionContainer(); var targetSession = _sessionContainer.GetSessions <ServerSession>(n => n.SessionID == package.Content).SingleOrDefault(); if (targetSession != null) { await targetSession.CloseAsync(); await session.SendAsync(Encoding.UTF8.GetBytes($"{CommandKey.Disconnect} {package.Content} is disconnected{Package.Terminator}")); } else { await session.SendAsync(Encoding.UTF8.GetBytes($"{CommandKey.Disconnect} {package.Content} is not found{Package.Terminator}")); } }
public GatewayStoreModel( GlobalEndpointManager endpointManager, ISessionContainer sessionContainer, TimeSpan requestTimeout, ConsistencyLevel defaultConsistencyLevel, DocumentClientEventSource eventSource, JsonSerializerSettings serializerSettings, UserAgentContainer userAgent, ApiType apiType = ApiType.None, HttpMessageHandler messageHandler = null) { // CookieContainer is not really required, but is helpful in debugging. this.cookieJar = new CookieContainer(); this.endpointManager = endpointManager; HttpClient httpClient = new HttpClient(messageHandler ?? new HttpClientHandler { CookieContainer = this.cookieJar }); this.sessionContainer = sessionContainer; this.defaultConsistencyLevel = defaultConsistencyLevel; // Use max of client specified and our own request timeout value when sending // requests to gateway. Otherwise, we will have gateway's transient // error hiding retries are of no use. httpClient.Timeout = (requestTimeout > this.requestTimeout) ? requestTimeout : this.requestTimeout; httpClient.DefaultRequestHeaders.CacheControl = new CacheControlHeaderValue { NoCache = true }; httpClient.AddUserAgentHeader(userAgent); httpClient.AddApiTypeHeader(apiType); // Set requested API version header that can be used for // version enforcement. httpClient.DefaultRequestHeaders.Add(HttpConstants.HttpHeaders.Version, HttpConstants.Versions.CurrentVersion); httpClient.DefaultRequestHeaders.Add(HttpConstants.HttpHeaders.Accept, RuntimeConstants.MediaTypes.Json); this.eventSource = eventSource; this.gatewayStoreClient = new GatewayStoreClient( httpClient, this.eventSource, serializerSettings); }
public GatewayStoreModel( GlobalEndpointManager endpointManager, ISessionContainer sessionContainer, ConsistencyLevel defaultConsistencyLevel, DocumentClientEventSource eventSource, JsonSerializerSettings serializerSettings, HttpClient httpClient) { this.endpointManager = endpointManager; this.sessionContainer = sessionContainer; this.defaultConsistencyLevel = defaultConsistencyLevel; this.eventSource = eventSource; this.gatewayStoreClient = new GatewayStoreClient( httpClient, this.eventSource, serializerSettings); }
private static async Task <IParsedDocumentHolder> ConstructHolder(ISessionContainer container, DataPair processingData) { var result = await processingData.Data.ConfigureAwait(false); if (processingData.Sentiment == SentimentClass.Positive) { SetStars(result, 5); } else if (processingData.Sentiment == SentimentClass.Negative) { SetStars(result, 1); } return(new ParsingDocumentHolder(container.GetTextSplitter(), container.GetWordFactory(), container.Resolve <IContextSentenceRepairHandler>(), result)); }
public void SetUp() { sessionContainer = MockRepository.GenerateMock<ISessionContainer>(); _atomicRequestHandler = new AtomicRequestHandler(sessionContainer); }
public SessionManagementFilter(ISessionContainer sessionContainer) { _sessionContainer = sessionContainer; }
public CommunicationService(ISessionContainer sessionContainer, IWorkTimeAccountingPlatformDAO db, ISessionIdProvider sessionIdProvider) { _sessionContainer = sessionContainer; _db = db; _sessionIdProvider = sessionIdProvider; }