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;
}
