/// <summary>
/// Creates <paramref name="parallelCount"/> write sessions simultaneously over
/// <paramref name="iterations"/> number of iterations.
/// </summary>
private async Task CreateReleaseWriteSessions(
SessionPool pool,
SpannerClient client,
int iterations,
int parallelCount)
{
// We yield to increase contention among parallel tasks that are kicked off.
// This increases the amount of work they are doing on another thread.
await Task.Yield();
for (var i = 0; i < iterations; i++)
{
var readWriteOptions = new TransactionOptions {
ReadWrite = new TransactionOptions.Types.ReadWrite()
};
var writeSessions = await Task.WhenAll(
DuplicateTaskAsync(() => CreateSessionAsync(pool, client, readWriteOptions), parallelCount));
await Task.Delay(TimeSpan.FromMilliseconds(10));
foreach (var session in writeSessions)
{
var transaction = await TransactionPool.BeginPooledTransactionAsync(client, session, readWriteOptions);
await TransactionPool.CommitAsync(transaction, session, new Mutation[0], SpannerOptions.Instance.Timeout, CancellationToken.None);
pool.ReleaseToPool(client, session);
}
}
}
/// <summary>
/// Creates <paramref name="parallelCount"/> read sessions simultaneously over
/// <paramref name="iterations"/> number of iterations.
/// </summary>
private async Task CreateReleaseReadSessions(
SessionPool pool,
SpannerClient client,
int iterations,
int parallelCount)
{
// We yield to increase contention among parallel tasks that are kicked off.
// This increases the amount of work they are doing on another thread.
await Task.Yield();
for (var i = 0; i < iterations; i++)
{
var readOptions = new TransactionOptions {
ReadOnly = new TransactionOptions.Types.ReadOnly()
};
var readSessions = await Task.WhenAll(
DuplicateTaskAsync(() => CreateSessionAsync(pool, client, readOptions), parallelCount));
await Task.Delay(TimeSpan.FromMilliseconds(10));
foreach (var session in readSessions)
{
pool.ReleaseToPool(client, session);
}
}
}
/// <summary>
/// 转发扫水结果到客户端
/// </summary>
/// <param name="sessionId">发送端</param>
/// <param name="content">扫水结果</param>
/// <returns></returns>
public static MQActionVoidResult CollectCompletedToClient(string sessionId, CollectResult content)
{
var session = SessionPool.GetClientsGroup(ClientTypeEnum.Client);
if (session != null)
{
foreach (var item in session)
{
if (item.Key == content.ClientSessionID)
{
MQRouterSendQueue.PushCollectCompleted(item.Key, content);
break;
}
}
return(new MQActionVoidResult()
{
IsOK = true
});
}
else
{
return(new MQActionVoidResult()
{
IsOK = false, ErrorMsg = "未找到出货客户端"
});
}
}
public async Task MaxActiveViolation_WaitOnResourcesExhausted_Blocks()
{
using (var pool = new SessionPool())
{
pool.Options.WaitOnResourcesExhausted = true;
pool.Options.MaximumActiveSessions = 2;
var client = new FakeClient();
var session1 = await CreateSessionAsync(pool, client);
var session2 = await CreateSessionAsync(pool, client);
var createTask = CreateSessionAsync(pool, client);
await Task.WhenAll(createTask, ReleaseAfterDelay(session1));
Assert.Same(session1, await createTask);
async Task ReleaseAfterDelay(Session session)
{
await Task.Delay(TimeSpan.FromMilliseconds(10));
pool.ReleaseToPool(client, session);
}
}
}
public void ShouldLogInUseAndAvailableSessionIds()
{
var mockLogger = new Mock <ILogger>();
var mock = new Mock <IPooledSession>();
mock.Setup(x => x.IsHealthy).Returns(true);
var id = Guid.NewGuid();
var inUseSessions = new Dictionary <Guid, IPooledSession>();
inUseSessions.Add(id, mock.Object);
var sessions = new Queue <IPooledSession>();
var mock1 = new Mock <IPooledSession>();
mock1.Setup(x => x.IsHealthy).Returns(true);
sessions.Enqueue(mock1.Object);
var pool = new SessionPool(sessions, inUseSessions, logger: mockLogger.Object);
pool.Dispose();
mockLogger.Verify(x => x.Info(It.Is <string>(actual => actual.StartsWith("Disposing In Use"))),
Times.Once);
mockLogger.Verify(x => x.Info(It.Is <string>(actual => actual.StartsWith("Disposing Available"))),
Times.Once);
}
public void ShouldNotExceedIdleLimit()
{
var mock = new Mock <IConnection>();
mock.Setup(x => x.IsOpen).Returns(true);
var config = new Config {
MaxIdleSessionPoolSize = 2
};
var pool = new SessionPool(TestUri, AuthTokens.None, null, config, mock.Object);
var sessions = new List <ISession>();
for (var i = 0; i < 4; i++)
{
sessions.Add(pool.GetSession());
pool.NumberOfAvailableSessions.Should().BeLessOrEqualTo(2);
}
foreach (var session in sessions)
{
session.Dispose();
pool.NumberOfAvailableSessions.Should().BeLessOrEqualTo(2);
}
pool.NumberOfAvailableSessions.Should().Be(2);
}
public void ShouldReuseHealthySessionWhenHealthySessionInQueue()
{
var sessions = new Queue <IPooledSession>();
var healthyMock = new Mock <IPooledSession>();
healthyMock.Setup(x => x.IsHealthy).Returns(true);
var unhealthyMock = new Mock <IPooledSession>();
unhealthyMock.Setup(x => x.IsHealthy).Returns(false);
sessions.Enqueue(unhealthyMock.Object);
sessions.Enqueue(healthyMock.Object);
var pool = new SessionPool(sessions, null);
pool.NumberOfAvailableSessions.Should().Be(2);
pool.NumberOfInUseSessions.Should().Be(0);
var session = pool.GetSession();
pool.NumberOfAvailableSessions.Should().Be(0);
pool.NumberOfInUseSessions.Should().Be(1);
unhealthyMock.Verify(x => x.Reset(), Times.Never);
unhealthyMock.Verify(x => x.Close(), Times.Once);
healthyMock.Verify(x => x.Reset(), Times.Once);
session.Should().Be(healthyMock.Object);
}
public void ShouldReleaseAll()
{
var mock = new Mock <IPooledSession>();
mock.Setup(x => x.IsHealthy).Returns(true);
var id = Guid.NewGuid();
var inUseSessions = new Dictionary <Guid, IPooledSession>();
inUseSessions.Add(id, mock.Object);
var sessions = new Queue <IPooledSession>();
var mock1 = new Mock <IPooledSession>();
mock1.Setup(x => x.IsHealthy).Returns(true);
sessions.Enqueue(mock1.Object);
var pool = new SessionPool(sessions, inUseSessions);
pool.NumberOfAvailableSessions.Should().Be(1);
pool.NumberOfInUseSessions.Should().Be(1);
pool.Dispose();
pool.NumberOfAvailableSessions.Should().Be(0);
pool.NumberOfInUseSessions.Should().Be(0);
}
public void ShouldCreateNewSessionWhenQueueOnlyContainsUnhealthySessions()
{
var mock = new Mock <IConnection>();
var sessions = new Queue <IPooledSession>();
var unhealthyId = Guid.NewGuid();
var unhealthyMock = new Mock <IPooledSession>();
unhealthyMock.Setup(x => x.IsHealthy).Returns(false);
unhealthyMock.Setup(x => x.Id).Returns(unhealthyId);
sessions.Enqueue(unhealthyMock.Object);
var pool = new SessionPool(sessions, null, mock.Object);
pool.NumberOfAvailableSessions.Should().Be(1);
pool.NumberOfInUseSessions.Should().Be(0);
var session = pool.GetSession();
pool.NumberOfAvailableSessions.Should().Be(0);
pool.NumberOfInUseSessions.Should().Be(1);
unhealthyMock.Verify(x => x.Reset(), Times.Never);
unhealthyMock.Verify(x => x.Close(), Times.Once);
session.Should().NotBeNull();
((IPooledSession)session).Id.Should().NotBe(unhealthyId);
}
private void Accept(SaeaAwaiter awaiter, SocketError socketError)
{
if (socketError == SocketError.Success)
{
var acceptedSocket = awaiter.Saea.AcceptSocket;
var session = SessionPool.Take();
session.Attach(acceptedSocket);
this.TcpSocketSaeaSessions.Add(session);
this.CompletetionNotify?.Invoke(TcpSocketCompletionNotify.OnConnected, session);
session.StartProcess();
}
else
{
LogHelper.WriteLog("server_accept-fail");
}
if (!this._isRuning)
{
return;
}
awaiter.Saea.AcceptSocket = null;
SaeaExHelper.AcceptAsync(_listener, awaiter, Accept);
}
public void ConnectToServer(IPEndPoint ipEndPoint)
{
Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
var awaiter = HandlerSaeaPool.Take();
awaiter.Saea.RemoteEndPoint = ipEndPoint;
SaeaExHelper.ConnectAsync(socket, awaiter, (a, e) =>
{
HandlerSaeaPool.Return(a);
var session = SessionPool.Take();
if (e != SocketError.Success)
{
LogHelper.WriteLog("client_connect-error");
CompletetionNotify?.Invoke(TcpSessionNotify.OnClosed, session);
SessionPool.Return(session);
return;
}
TcpSocketSaeaSessions.Add(session);
session.Attach(socket);
CompletetionNotify?.Invoke(TcpSessionNotify.OnConnected, session);
session.StartProcess();
});
}
private static TargetedSessionPool CreatePool(bool acquireSessionsImmediately)
{
var client = new SessionTestingSpannerClient();
client.Scheduler.RealTimeTimeout = TimeSpan.FromSeconds(15);
// Fixed session pool options so we can hard-code values without worrying about the defaults changing
var options = new SessionPoolOptions
{
IdleSessionRefreshDelay = TimeSpan.FromMinutes(15),
MaintenanceLoopDelay = TimeSpan.FromSeconds(0), // Disable automatic pool maintenance
PoolEvictionDelay = TimeSpan.FromMinutes(100), // Deliberately not a multiple of 15
SessionEvictionJitter = RetrySettings.NoJitter,
SessionRefreshJitter = RetrySettings.NoJitter,
MaximumActiveSessions = 100,
MaximumConcurrentSessionCreates = 20,
CreateSessionMaximumBatchSize = 5,
MinimumPooledSessions = 10,
Timeout = TimeSpan.FromSeconds(60),
WaitOnResourcesExhausted = ResourcesExhaustedBehavior.Block,
WriteSessionsFraction = 0.2
};
var parent = new SessionPool(client, options);
return(new TargetedSessionPool(parent, s_databaseName, acquireSessionsImmediately));
}
public async Task GetStatisticsSnapshot_MultipleDatabases()
{
var client = new SessionTestingSpannerClient();
var options = new SessionPoolOptions
{
MinimumPooledSessions = 10,
};
var sessionPool = new SessionPool(client, options);
var acquisitionTask1 = sessionPool.AcquireSessionAsync(s_sampleDatabaseName, new TransactionOptions(), default);
var acquisitionTask2 = sessionPool.AcquireSessionAsync(s_sampleDatabaseName2, new TransactionOptions(), default);
// Wait a little in real time because session creation tasks
// are started in a controlled fire and forget manner.
// Let's give time for stats to be updated.
await Task.Delay(TimeSpan.FromMilliseconds(250));
var stats = sessionPool.GetStatisticsSnapshot();
Assert.Equal(2, stats.PerDatabaseStatistics.Count);
Assert.Equal(2, stats.TotalActiveSessionCount);
Assert.Equal(0, stats.TotalReadPoolCount);
// We've asked for 2 sessions, and the databases "know" they need 10 in the pool (each), so
// there will be 22 in-flight requests in total.
Assert.Equal(22, stats.TotalInFlightCreationCount);
Assert.Contains(stats.PerDatabaseStatistics, s => s.DatabaseName == s_sampleDatabaseName);
Assert.Contains(stats.PerDatabaseStatistics, s => s.DatabaseName == s_sampleDatabaseName2);
// xUnit waits until tasks registered in its synchronization context have completed before considering the
// test itself complete, so we need to let the pool complete the acquisition tasks.
await client.Scheduler.RunAsync(TimeSpan.FromMinutes(2));
}
public static SessionInfo From(ISocketClient socketClient, SessionPool sessionPool)
{
var session = new Session(socketClient);
var proxy = new SessionProxy(session, sessionPool);
return(new SessionInfo(session, proxy));
}
public TransferPromptListAction(TransferPromptModel model, TransferPromptController controller,
SessionPool source, SessionPool destination, TransferItem directory, Transfer transfer, TransferItemCache cache)
: base(
controller, source, destination,
new InnerTransferPromptListWorker(model, controller, transfer, directory, cache))
{
}
/// <summary>
/// Creates <paramref name="parallelCount"/> read sessions simultaneously over
/// <paramref name="iterations"/> number of iterations.
/// </summary>
private async Task CreateReleaseReadSessions(
SessionPool pool,
SpannerClient client,
int iterations,
int parallelCount)
{
// We yield to increase contention among parallel tasks that are kicked off.
// This increases the amount of work they are doing on another thread.
await Task.Yield();
for (var i = 0; i < iterations; i++)
{
var readOptions = new TransactionOptions {
ReadOnly = new TransactionOptions.Types.ReadOnly()
};
var readSessions = await Task.WhenAll(
DuplicateTaskAsync(
() =>
pool.CreateSessionFromPoolAsync(
client, s_defaultName.ProjectId,
s_defaultName.InstanceId, s_defaultName.DatabaseId, readOptions,
CancellationToken.None),
parallelCount))
.ConfigureAwait(false);
await Task.Delay(TimeSpan.FromMilliseconds(10)).ConfigureAwait(false);
foreach (var session in readSessions)
{
pool.ReleaseToPool(client, session);
}
}
}
public async Task MaxActiveViolationThrows()
{
using (var pool = new SessionPool())
{
pool.Options.WaitOnResourcesExhausted = false;
pool.Options.MaximumActiveSessions = 2;
var exceptionThrown = false;
var client = CreateMockClient();
await pool.CreateSessionFromPoolAsync(
client.Object, s_defaultName.ProjectId,
s_defaultName.InstanceId, s_defaultName.DatabaseId, null, CancellationToken.None)
.ConfigureAwait(false);
await pool.CreateSessionFromPoolAsync(
client.Object, s_defaultName.ProjectId,
s_defaultName.InstanceId, s_defaultName.DatabaseId, null, CancellationToken.None)
.ConfigureAwait(false);
try
{
await pool.CreateSessionFromPoolAsync(
client.Object, s_defaultName.ProjectId,
s_defaultName.InstanceId, s_defaultName.DatabaseId, null, CancellationToken.None)
.ConfigureAwait(false);
}
catch (RpcException e)
{
Assert.Equal(StatusCode.ResourceExhausted, e.Status.StatusCode);
exceptionThrown = true;
}
Assert.True(exceptionThrown);
}
}
/// <summary>
/// 投注端退出了，注销资源，通知他的控盘端下线
/// </summary>
public static void RemoveBetServer(Session session)
{
if (AvailableBetServers.ContainsKey(session.ClientId))
{
int value;
AvailableBetServers.TryRemove(session.ClientId, out value);
}
// 通知该服务端影响到的一批客户端下线
var allClients = SessionPool.GetClientsGroup(ClientTypeEnum.Client);
if (allClients.Count == 0)
{
return;
}
var clientIds = allClients.Keys.ToArray();
foreach (var clientId in clientIds)
{
if (allClients[clientId].BetServerId == session.ClientId)
{
MQRouterSendQueue.PushBetServerClose(clientId);
}
}
}
public async Task MaxPoolSizeNotViolated()
{
using (var pool = new SessionPool())
{
pool.Options.MaximumPooledSessions = 2;
var client = CreateMockClient();
var sessions = await Task.WhenAll(
pool.CreateSessionFromPoolAsync(
client.Object, s_defaultName.ProjectId,
s_defaultName.InstanceId, s_defaultName.DatabaseId, null, CancellationToken.None),
pool.CreateSessionFromPoolAsync(
client.Object, s_defaultName.ProjectId,
s_defaultName.InstanceId, s_defaultName.DatabaseId, null, CancellationToken.None),
pool.CreateSessionFromPoolAsync(
client.Object, s_defaultName.ProjectId,
s_defaultName.InstanceId, s_defaultName.DatabaseId, null, CancellationToken.None))
.ConfigureAwait(false);
pool.ReleaseToPool(client.Object, sessions[0]);
pool.ReleaseToPool(client.Object, sessions[1]);
pool.ReleaseToPool(client.Object, sessions[2]);
Assert.Equal(
2, pool.GetPoolSize(
client.Object, s_defaultName.ProjectId,
s_defaultName.InstanceId, s_defaultName.DatabaseId));
}
}
public async Task ClientsHaveDifferentPools()
{
using (var pool = new SessionPool())
{
var client1 = CreateMockClient();
var client2 = CreateMockClient();
var session = await pool.CreateSessionFromPoolAsync(
client1.Object, s_defaultName.ProjectId,
s_defaultName.InstanceId, s_defaultName.DatabaseId, null, CancellationToken.None)
.ConfigureAwait(false);
pool.ReleaseToPool(client1.Object, session);
var session2 = await pool.CreateSessionFromPoolAsync(
client2.Object, s_defaultName.ProjectId,
s_defaultName.InstanceId, s_defaultName.DatabaseId, null, CancellationToken.None)
.ConfigureAwait(false);
Assert.NotSame(session, session2);
Assert.Equal(2, _createdSessions.Count);
Assert.Equal(1, _createdSessions[client1].Count);
Assert.Equal(1, _createdSessions[client2].Count);
}
}
public async Task MaxActiveViolationBlocks()
{
using (var pool = new SessionPool())
{
pool.Options.WaitOnResourcesExhausted = true;
pool.Options.MaximumActiveSessions = 2;
var client = CreateMockClient();
var session1 = await pool.CreateSessionFromPoolAsync(
client.Object, s_defaultName.ProjectId,
s_defaultName.InstanceId, s_defaultName.DatabaseId, null, CancellationToken.None)
.ConfigureAwait(false);
await pool.CreateSessionFromPoolAsync(
client.Object, s_defaultName.ProjectId,
s_defaultName.InstanceId, s_defaultName.DatabaseId, null, CancellationToken.None)
.ConfigureAwait(false);
async Task ReleaseTask()
{
await Task.Delay(TimeSpan.FromMilliseconds(10));
pool.ReleaseToPool(client.Object, session1);
}
var createTask = pool.CreateSessionFromPoolAsync(
client.Object, s_defaultName.ProjectId,
s_defaultName.InstanceId, s_defaultName.DatabaseId, null, CancellationToken.None);
await Task.WhenAll(createTask, ReleaseTask()).ConfigureAwait(false);
Assert.Same(session1, createTask.ResultWithUnwrappedExceptions());
}
}
private CommandController(WindowController parent, SessionPool session, ICommandView view)
{
View = view;
_parent = parent;
_session = session;
View.SendEvent += View_SendEvent;
}
void LockConflict(SessionBase sharedReadSession)
{
string host = null;
Random r = new Random(5);
SessionPool sessionPool = new SessionPool(3, () => new ServerClientSession(systemDir, host, 2000, false));
try
{
int iCounter = 0;
int sessionId1 = -1;
SessionBase session1 = null;
for (int i = 0; i < 50; i++)
{
try
{
session1 = sessionPool.GetSession(out sessionId1);
session1.BeginUpdate();
Dokument Doc_A = new Dokument();
Doc_A.Name = "Test A";
session1.Persist(Doc_A);
Console.WriteLine(Doc_A.ToString());
int sessionId2 = -1;
SessionBase session2 = null;
try
{
session2 = sessionPool.GetSession(out sessionId2);
session2.BeginUpdate();
Dokument Doc_B = new Dokument();
Doc_B.Name = "Test_B";
session2.Persist(Doc_B);
Console.WriteLine(Doc_B.ToString());
session2.Commit();
}
finally
{
sessionPool.FreeSession(sessionId2, session2);
}
session1.Commit();
sharedReadSession.ForceDatabaseCacheValidation();
session1.BeginRead();
ulong ct = session1.AllObjects <Dokument>(false).Count;
Console.WriteLine("Number of Dokument found by normal session: " + ct);
session1.Commit();
ct = sharedReadSession.AllObjects <Dokument>(false).Count;
Console.WriteLine("Number of Dokument found by shared read session: " + ct);
}
finally
{
sessionPool.FreeSession(sessionId1, session1);
}
iCounter++;
Console.WriteLine(" -> " + iCounter.ToString());
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
throw;
}
}
public SessionProxy(
Session session,
SessionPool pool)
{
_pool = pool;
_session = session;
}
/// <summary>
/// 客户端注销
/// </summary>
/// <param name="session"></param>
/// <param name="oldUserName"></param>
public static void RemoveClients(Session session, string oldUserName = null)
{
string betServerId = session.BetServerId;
if (string.IsNullOrEmpty(betServerId) || SessionPool.GetByClientId(betServerId, ClientTypeEnum.Bet) == null)
{
return;
}
//// 通知投注端清理投注账号的资源
//List<WebsiteAccountDetail> websiteAccounts =
// WebsiteAccountService.Instance.GetAccountListByMemberId(session);
//if (websiteAccounts != null && websiteAccounts.Count > 0)
//{
// foreach (var account in websiteAccounts)
// {
// MQRouterSendQueue.QuitOut(betServerId, new WebsiteAccountContract()
// {
// WebsiteEnum = account.WebsiteEnum,
// UserName = account.UserName
// });
// }
//}
// 释放一个控盘端可用额
if (AvailableBetServers.ContainsKey(betServerId))
{
AvailableBetServers[betServerId] -= 1;
}
}
internal TcpSocketSaeaFullBased(
TcpSocketConfigurationBase configuration,
SaeaAwaiterPool handlerSaeaPool,
SessionPool sessionPool,
NotifyEventHandler <TcpSessionNotify, TcpSocketSaeaSession> notifyEventHandler,
TcpSocketSaeaEngineBased agent)
: base(notifyEventHandler, configuration, handlerSaeaPool, sessionPool, agent)
=> CompletedBuffer = new byte[configuration.ReceiveBufferSize];
public FilterAction(TransferPromptModel model, TransferPromptController controller,
SessionPool source, SessionPool destination,
Transfer transfer, TransferAction action, TransferItemCache cache)
: base(
controller, source,
new InnerTransferPromptFilterWorker(model, controller, transfer, action, cache))
{
}
public GeneratedSerializerTests()
{
this.serviceProvider = new ServiceCollection()
.AddHagar(hagar => hagar.AddAssembly(typeof(GeneratedSerializerTests).Assembly))
.BuildServiceProvider();
this.codecProvider = this.serviceProvider.GetRequiredService <ITypedCodecProvider>();
this.sessionPool = this.serviceProvider.GetRequiredService <SessionPool>();
}
private static bool CheckForSessionExpiredError(this RpcException rpcException, Func <Session> sessionFunc)
{
if (rpcException.IsSessionExpiredError())
{
SessionPool.MarkSessionExpired(sessionFunc());
}
return(false);
}
public void Dispose()
{
if (null != sessionPool)
{
sessionPool.Dispose();
sessionPool = null;
}
}
private void Initialize()
{
_bufferManager = new GrowingByteBufferManager(_configuration.InitialPooledBufferCount, _configuration.ReceiveBufferSize);
_acceptSaeaPool = new SaeaPool(16, 32,
() =>
{
var saea = new SaeaAwaitable();
return saea;
},
(saea) =>
{
try
{
saea.Saea.AcceptSocket = null;
saea.Saea.SetBuffer(0, 0);
saea.Saea.RemoteEndPoint = null;
saea.Saea.SocketFlags = SocketFlags.None;
}
catch (Exception ex)
{
// _log.Error(ex.Message, ex);
}
});
_handleSaeaPool = new SaeaPool(1024, int.MaxValue,
() =>
{
var saea = new SaeaAwaitable();
return saea;
},
(saea) =>
{
try
{
saea.Saea.AcceptSocket = null;
saea.Saea.SetBuffer(EmptyArray, 0, 0);
saea.Saea.RemoteEndPoint = null;
saea.Saea.SocketFlags = SocketFlags.None;
}
catch (Exception ex)
{
// _log.Error(ex.Message, ex);
}
});
_sessionPool = new SessionPool(1024, int.MaxValue,
() =>
{
var session = new TcpSocketSaeaSession(_configuration, _bufferManager, _handleSaeaPool, _dispatcher, this);
return session;
},
(session) =>
{
try
{
session.Clear();
}
catch (Exception ex)
{
// _log.Error(ex.Message, ex);
}
});
}
void LockConflict(SessionBase sharedReadSession)
{
string host = null;
Random r = new Random(5);
SessionPool sessionPool = new SessionPool(3, () => new ServerClientSession(systemDir, host, 2000, false));
try
{
int iCounter = 0;
int sessionId1 = -1;
SessionBase session1 = null;
for (int i = 0; i < 50; i++)
{
try
{
session1 = sessionPool.GetSession(out sessionId1);
session1.BeginUpdate();
Dokument Doc_A = new Dokument();
Doc_A.Name = "Test A";
session1.Persist(Doc_A);
Console.WriteLine(Doc_A.ToString());
int sessionId2 = -1;
SessionBase session2 = null;
try
{
session2 = sessionPool.GetSession(out sessionId2);
session2.BeginUpdate();
Dokument Doc_B = new Dokument();
Doc_B.Name = "Test_B";
session2.Persist(Doc_B);
Console.WriteLine(Doc_B.ToString());
session2.Commit();
}
finally
{
sessionPool.FreeSession(sessionId2, session2);
}
session1.Commit();
sharedReadSession.ForceDatabaseCacheValidation();
session1.BeginRead();
ulong ct = session1.AllObjects<Dokument>(false).Count;
Console.WriteLine("Number of Dokument found by normal session: " + ct);
session1.Commit();
ct = sharedReadSession.AllObjects<Dokument>(false).Count;
Console.WriteLine("Number of Dokument found by shared read session: " + ct);
}
finally
{
sessionPool.FreeSession(sessionId1, session1);
}
iCounter++;
Console.WriteLine(" -> " + iCounter.ToString());
}
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
throw;
}
}