private void InitializeStream(Stream stream, CompressionLevel level, bool compress)
{
this.flushOption = FlushOption.NoFlush;
this.buffer = new byte[this.bufsize];
this.stream = stream;
this.compress = compress;
if (compress)
{
this.zip.InitializeDeflater(level);
}
else
{
this.zip.InitializeInflater();
}
}
public object Intercept(IMethodInvocation invocation, params object[] args)
{
String key = ObtainSessionFactoryKeyFor(invocation.InvocationTarget);
if (SessionManager.IsCurrentSessionCompatible(key))
{
return(invocation.Proceed(args));
}
ISessionFactory sessionFactory = ObtainSessionFactoryFor(key);
ISession session = null;
if (_kernel.HasComponent(typeof(NHibernate.IInterceptor)))
{
session = sessionFactory.OpenSession((NHibernate.IInterceptor)_kernel[typeof(NHibernate.IInterceptor)]);
}
else
{
session = sessionFactory.OpenSession();
}
SessionManager.Push(session, key);
FlushOption flushOption = ExtractFlushOption(invocation.MethodInvocationTarget);
ConfigureFlushMode(flushOption, session);
if (EnlistSessionIfHasTransactionActive(key, session))
{
return(invocation.Proceed(args));
}
try
{
return(invocation.Proceed(args));
}
finally
{
if (flushOption == FlushOption.Force)
{
session.Flush();
}
session.Close();
SessionManager.Pop(key);
}
}
private static void ConfigureFlushMode(FlushOption flushOption, ISession session)
{
switch (flushOption)
{
case FlushOption.Auto:
session.FlushMode = FlushMode.Auto;
break;
case FlushOption.Commit:
session.FlushMode = FlushMode.Commit;
break;
case FlushOption.Never:
session.FlushMode = FlushMode.Never;
break;
}
}
public ChunkManagerConfig(string basePath,
IFileNamingStrategy fileNamingStrategy,
int chunkDataSize,
int chunkDataUnitSize,
int chunkDataCount,
int flushChunkIntervalMilliseconds,
bool enableCache,
bool syncFlush,
FlushOption flushOption,
int chunkReaderCount,
int maxLogRecordSize,
int chunkWriteBuffer,
int chunkReadBuffer,
int chunkCacheMaxCount,
int chunkCacheMinCount,
int preCacheChunkCount,
int chunkInactiveTimeMaxSeconds,
int chunkLocalCacheSize,
bool enableChunkStatistic)
{
Ensure.NotNullOrEmpty(basePath, "basePath");
Ensure.NotNull(fileNamingStrategy, "fileNamingStrategy");
Ensure.Nonnegative(chunkDataSize, "chunkDataSize");
Ensure.Nonnegative(chunkDataUnitSize, "chunkDataUnitSize");
Ensure.Nonnegative(chunkDataCount, "chunkDataCount");
Ensure.Positive(flushChunkIntervalMilliseconds, "flushChunkIntervalMilliseconds");
Ensure.Positive(maxLogRecordSize, "maxLogRecordSize");
Ensure.Positive(chunkWriteBuffer, "chunkWriteBuffer");
Ensure.Positive(chunkReadBuffer, "chunkReadBuffer");
Ensure.Positive(chunkCacheMaxCount, "chunkCacheMaxCount");
Ensure.Positive(chunkCacheMinCount, "chunkCacheMinCount");
Ensure.Nonnegative(preCacheChunkCount, "preCacheChunkCount");
Ensure.Nonnegative(chunkInactiveTimeMaxSeconds, "chunkInactiveTimeMaxSeconds");
Ensure.Positive(chunkLocalCacheSize, "chunkLocalCacheSize");
if (chunkDataSize <= 0 && (chunkDataUnitSize <= 0 || chunkDataCount <= 0))
{
throw new ArgumentException(string.Format("Invalid chunk data size arugment. chunkDataSize: {0}, chunkDataUnitSize: {1}, chunkDataCount: {2}", chunkDataSize, chunkDataUnitSize, chunkDataCount));
}
BasePath = basePath;
FileNamingStrategy = fileNamingStrategy;
ChunkDataSize = chunkDataSize;
ChunkDataUnitSize = chunkDataUnitSize;
ChunkDataCount = chunkDataCount;
FlushChunkIntervalMilliseconds = flushChunkIntervalMilliseconds;
EnableCache = enableCache;
SyncFlush = syncFlush;
FlushOption = flushOption;
ChunkReaderCount = chunkReaderCount;
MaxLogRecordSize = maxLogRecordSize;
ChunkWriteBuffer = chunkWriteBuffer;
ChunkReadBuffer = chunkReadBuffer;
ChunkCacheMaxCount = chunkCacheMaxCount;
ChunkCacheMinCount = chunkCacheMinCount;
PreCacheChunkCount = preCacheChunkCount;
ChunkInactiveTimeMaxSeconds = chunkInactiveTimeMaxSeconds;
ChunkLocalCacheSize = chunkLocalCacheSize;
EnableChunkStatistic = enableChunkStatistic;
if (GetChunkDataSize() > 1024 * 1024 * 1024)
{
throw new ArgumentException("Chunk data size cannot bigger than 1G");
}
}
public ChunkFileStream(Stream stream, FlushOption flushOption)
{
Stream = stream;
FlushOption = flushOption;
}
public BrokerSetting(bool isMessageStoreMemoryMode = false, string chunkFileStoreRootPath = @"c:\equeue-store", int messageChunkDataSize = 1024 * 1024 * 1024, int chunkFlushInterval = 100, int chunkCacheMaxCount = 10, int chunkCacheMinCount = 2, int maxLogRecordSize = 5 * 1024 * 1024, int chunkWriteBuffer = 128 * 1024, int chunkReadBuffer = 128 * 1024, bool syncFlush = false, FlushOption flushOption = FlushOption.FlushToOS, bool enableCache = true, int messageChunkLocalCacheSize = 300000, int queueChunkLocalCacheSize = 10000)
{
BrokerInfo = new BrokerInfo(
"DefaultBroker",
"DefaultGroup",
"DefaultCluster",
BrokerRole.Master,
new IPEndPoint(IPAddress.Loopback, 5000).ToAddress(),
new IPEndPoint(IPAddress.Loopback, 5001).ToAddress(),
new IPEndPoint(IPAddress.Loopback, 5002).ToAddress());
NameServerList = new List <IPEndPoint>()
{
new IPEndPoint(IPAddress.Loopback, 9493)
};
NotifyWhenMessageArrived = true;
RegisterBrokerToNameServerInterval = 1000 * 5;
DeleteMessagesInterval = 1000 * 10;
DeleteQueueMessagesInterval = 1000 * 10;
DeleteMessageIgnoreUnConsumed = true;
PersistConsumeOffsetInterval = 1000 * 1;
CheckBlockingPullRequestMilliseconds = 1000 * 1;
ProducerExpiredTimeout = 1000 * 30;
ConsumerExpiredTimeout = 1000 * 30;
RemoveConsumerWhenDisconnect = true;
AutoCreateTopic = true;
TopicDefaultQueueCount = 4;
TopicMaxQueueCount = 256;
MessageMaxSize = 1024 * 1024 * 4;
MessageWriteQueueThreshold = 2 * 10000;
BatchMessageWriteQueueThreshold = 1 * 10000;
IsMessageStoreMemoryMode = isMessageStoreMemoryMode;
FileStoreRootPath = chunkFileStoreRootPath;
LatestMessageShowCount = 100;
MessageChunkConfig = new ChunkManagerConfig(
Path.Combine(chunkFileStoreRootPath, @"message-chunks"),
new DefaultFileNamingStrategy("message-chunk-"),
messageChunkDataSize,
0,
0,
chunkFlushInterval,
enableCache,
syncFlush,
flushOption,
Environment.ProcessorCount * 8,
maxLogRecordSize,
chunkWriteBuffer,
chunkReadBuffer,
chunkCacheMaxCount,
chunkCacheMinCount,
1,
5,
messageChunkLocalCacheSize,
true);
QueueChunkConfig = new ChunkManagerConfig(
Path.Combine(chunkFileStoreRootPath, @"queue-chunks"),
new DefaultFileNamingStrategy("queue-chunk-"),
0,
12,
1000000,
chunkFlushInterval,
enableCache,
syncFlush,
flushOption,
Environment.ProcessorCount * 2,
12,
chunkWriteBuffer,
chunkReadBuffer,
chunkCacheMaxCount,
chunkCacheMinCount,
1,
5,
queueChunkLocalCacheSize,
false);
}
public SessionFlushAttribute(FlushOption option)
{
_option = option;
}
