public ChatClientNetChannel(IActorSystem<IRoomActor> rooms, ICallbacksGatewayNode callbacksNode, INetNode node,
ITransportChannel transportChannel, IMessageSerializer serializer, ICoreEvents logger, INetNodeConfig config, IBufferPool bufferPool)
: base(node, transportChannel, serializer, logger, config, bufferPool)
{
_rooms = rooms;
_callbacksNode = callbacksNode;
}
public AsyncProcessingNetChannel(Func<IMessageProcessingPipeBuilder, IMessageProcessingPipeBuilder> configureProcesssingPipe, INetNode node,
ITransportChannel transportChannel, IMessageSerializer serializer, ICoreEvents logger, INetNodeConfig config, IBufferPool bufferPool)
: base(node, transportChannel, serializer, logger, config, bufferPool)
{
_pipeBuilder = configureProcesssingPipe(new MessageProcessingPipeBuilder());
_processor = _pipeBuilder.Build();
}
public TsPesPacketPool(IBufferPool bufferPool)
{
if (null == bufferPool)
throw new ArgumentNullException(nameof(bufferPool));
_bufferPool = bufferPool;
}
public StorageActionsAccessor(TableStorage storage, Reference<WriteBatch> writeBatch, Reference<SnapshotReader> snapshot, IdGenerator generator, IBufferPool bufferPool, OrderedPartCollection<AbstractFileCodec> fileCodecs)
: base(snapshot, generator, bufferPool)
{
this.storage = storage;
this.writeBatch = writeBatch;
this.fileCodecs = fileCodecs;
}
public GeneralStorageActions(TableStorage storage, Reference<WriteBatch> writeBatch, Reference<SnapshotReader> snapshot, IBufferPool bufferPool)
: base(snapshot, bufferPool)
{
this.storage = storage;
this.writeBatch = writeBatch;
this.snapshot = snapshot;
}
public TcpConnection(Socket socket, SocketSetting setting, IBufferPool receiveDataBufferPool, Action<ITcpConnection, byte[]> messageArrivedHandler, Action<ITcpConnection, SocketError> connectionClosedHandler)
{
Ensure.NotNull(socket, "socket");
Ensure.NotNull(setting, "setting");
Ensure.NotNull(receiveDataBufferPool, "receiveDataBufferPool");
Ensure.NotNull(messageArrivedHandler, "messageArrivedHandler");
Ensure.NotNull(connectionClosedHandler, "connectionClosedHandler");
_socket = socket;
_setting = setting;
_receiveDataBufferPool = receiveDataBufferPool;
_localEndPoint = socket.LocalEndPoint;
_remotingEndPoint = socket.RemoteEndPoint;
_messageArrivedHandler = messageArrivedHandler;
_connectionClosedHandler = connectionClosedHandler;
_sendSocketArgs = new SocketAsyncEventArgs();
_sendSocketArgs.AcceptSocket = _socket;
_sendSocketArgs.Completed += OnSendAsyncCompleted;
_receiveSocketArgs = new SocketAsyncEventArgs();
_receiveSocketArgs.AcceptSocket = socket;
_receiveSocketArgs.Completed += OnReceiveAsyncCompleted;
_logger = ObjectContainer.Resolve<ILoggerFactory>().Create(GetType().FullName);
_framer = ObjectContainer.Resolve<IMessageFramer>();
_framer.RegisterMessageArrivedCallback(OnMessageArrived);
TryReceive();
TrySend();
}
public QueueStorageActions(TableStorage tableStorage, IUuidGenerator generator, Reference<SnapshotReader> snapshot, Reference<WriteBatch> writeBatch, IBufferPool bufferPool)
: base(snapshot, bufferPool)
{
this.tableStorage = tableStorage;
this.writeBatch = writeBatch;
this.generator = generator;
}
public TableStorage(StorageEnvironmentOptions options, IBufferPool bufferPool)
{
if (options == null)
throw new ArgumentNullException("options");
_options = options;
this.bufferPool = bufferPool;
Debug.Assert(options != null);
//#if DEBUG
// var directoryOptions = options as StorageEnvironmentOptions.DirectoryStorageEnvironmentOptions;
//
// string debugJournalName;
// if (directoryOptions != null)
// debugJournalName = directoryOptions.TempPath.Replace(Path.DirectorySeparatorChar, '_').Replace(':','_');
// else
// debugJournalName = "InMemoryDebugJournal-" + Interlocked.Increment(ref debugJournalCount);
//
// env = new StorageEnvironment(options, debugJournalName) {IsDebugRecording = true};
//#else
env = new StorageEnvironment(options);
//#endif
Initialize();
}
public TableStorage(StorageEnvironment environment, IBufferPool bufferPool)
{
this.bufferPool = bufferPool;
env = environment;
Initialize();
}
public MappedResultsStorageActions(TableStorage tableStorage, IUuidGenerator generator, OrderedPartCollection<AbstractDocumentCodec> documentCodecs, Reference<SnapshotReader> snapshot, Reference<WriteBatch> writeBatch, IBufferPool bufferPool)
: base(snapshot, bufferPool)
{
this.tableStorage = tableStorage;
this.generator = generator;
this.documentCodecs = documentCodecs;
this.writeBatch = writeBatch;
}
/// <summary>
/// Initializes a new instance of the ServiceSocket class.
/// </summary>
/// <param name="socket">The .NET Socket object to encapsulate</param>
/// <param name="IsPeerSocket">Indicates if this socket was spawned from the state server peer port</param>
public ServiceSocket(Socket socket, bool IsPeerSocket, IBufferPool Buffers)
{
this.socket = socket;
fromPeerListener = IsPeerSocket;
sessionKey = null;
id = Guid.NewGuid();
bufferPool = Buffers;
}
protected TableBase(string tableName, IBufferPool bufferPool)
{
if (string.IsNullOrEmpty(tableName))
throw new ArgumentNullException(tableName);
BufferPool = bufferPool;
TableName = tableName;
}
public TransactionalStorage(InMemoryRavenConfiguration configuration, Action onCommit)
{
this.configuration = configuration;
this.onCommit = onCommit;
documentCacher = new DocumentCacher(configuration);
exitLockDisposable = new DisposableAction(() => Monitor.Exit(this));
bufferPool = new BufferPool(configuration.Storage.Voron.MaxBufferPoolSize * 1024 * 1024 * 1024, int.MaxValue); // 2GB max buffer size (voron limit)
}
public Table(string tableName, IBufferPool bufferPool, params string[] indexNames)
: base(tableName, bufferPool)
{
tableIndexes = new ConcurrentDictionary<string, Index>();
foreach (var indexName in indexNames)
GetIndex(indexName);
}
public SocketRemotingServer(string name, IPEndPoint listeningEndPoint, SocketSetting setting = null)
{
_setting = setting ?? new SocketSetting();
_receiveDataBufferPool = new BufferPool(_setting.ReceiveDataBufferSize, _setting.ReceiveDataBufferPoolSize);
_serverSocket = new ServerSocket(listeningEndPoint, _setting, _receiveDataBufferPool, HandleRemotingRequest);
_requestHandlerDict = new Dictionary<int, IRequestHandler>();
_logger = ObjectContainer.Resolve<ILoggerFactory>().Create(name ?? GetType().Name);
}
public IndexingStorageActions(TableStorage tableStorage, IUuidGenerator generator, Reference<SnapshotReader> snapshot, Reference<WriteBatch> writeBatch, IStorageActionsAccessor storageActionsAccessor, IBufferPool bufferPool)
: base(snapshot, bufferPool)
{
this.tableStorage = tableStorage;
this.generator = generator;
this.writeBatch = writeBatch;
this.currentStorageActionsAccessor = storageActionsAccessor;
}
public HttpListenerContextAdpater(HttpListenerContext ctx, InMemoryRavenConfiguration configuration, IBufferPool bufferPool)
{
this.ctx = ctx;
this.configuration = configuration;
this.bufferPool = bufferPool;
ResponseInternal = new HttpListenerResponseAdapter(ctx.Response, bufferPool);
RequestInternal = new HttpListenerRequestAdapter(ctx.Request);
SetMaxAge();
}
public MappedResultsStorageActions(TableStorage tableStorage, IUuidGenerator generator, OrderedPartCollection<AbstractDocumentCodec> documentCodecs, Reference<SnapshotReader> snapshot,
Reference<WriteBatch> writeBatch, IBufferPool bufferPool, IStorageActionsAccessor storageActionsAccessor, ConcurrentDictionary<int, RemainingReductionPerLevel> ScheduledReductionsPerViewAndLevel)
: base(snapshot, bufferPool)
{
this.tableStorage = tableStorage;
this.generator = generator;
this.documentCodecs = documentCodecs;
this.writeBatch = writeBatch;
this.storageActionsAccessor = storageActionsAccessor;
this.scheduledReductionsPerViewAndLevel = ScheduledReductionsPerViewAndLevel;
}
public TableStorage(StorageEnvironmentOptions options, IBufferPool bufferPool)
{
if (options == null)
throw new ArgumentNullException("options");
_options = options;
this.bufferPool = bufferPool;
env = new StorageEnvironment(_options);
Initialize();
}
public TransactionalStorage(InMemoryRavenConfiguration configuration, Action onCommit, Action onStorageInaccessible)
{
this.configuration = configuration;
this.onCommit = onCommit;
this.onStorageInaccessible = onStorageInaccessible;
RecoverFromFailedCompact(configuration.DataDirectory);
documentCacher = new DocumentCacher(configuration);
exitLockDisposable = new DisposableAction(() => Monitor.Exit(this));
bufferPool = new BufferPool(configuration.Storage.Voron.MaxBufferPoolSize * 1024 * 1024 * 1024, int.MaxValue); // 2GB max buffer size (voron limit)
}
public TableStorage(StorageEnvironmentOptions options, IBufferPool bufferPool)
{
if (options == null)
throw new ArgumentNullException("options");
_options = options;
this.bufferPool = bufferPool;
Debug.Assert(options != null);
env = new StorageEnvironment(options);
Initialize();
CreateSchema();
}
protected MediaDumpBase(Action<IProgramStreams> programStreamsHandler)
{
_programStreamsHandler = programStreamsHandler;
BufferPool = new BufferPool(new DefaultBufferPoolParameters
{
BaseSize = 5 * 64 * 1024,
Pools = 2
});
PacketPool = new TsPesPacketPool(BufferPool);
_bufferingManager = new NullBufferingManager(PacketPool);
_streamReader = new SignalTask(ReadStreams);
}
public TsPacketizedElementaryStream(IBufferPool bufferPool, ITsPesPacketPool pesPacketPool, Action<TsPesPacket> packetHandler, TsStreamType streamType, uint pid)
{
if (null == bufferPool)
throw new ArgumentNullException(nameof(bufferPool));
if (null == pesPacketPool)
throw new ArgumentNullException(nameof(pesPacketPool));
_bufferPool = bufferPool;
_pesPacketPool = pesPacketPool;
_streamType = streamType;
_pid = pid;
_handler = packetHandler;
}
public ServerSocket(IPEndPoint listeningEndPoint, SocketSetting setting, IBufferPool receiveDataBufferPool, Action<ITcpConnection, byte[], Action<byte[]>> messageArrivedHandler)
{
Ensure.NotNull(listeningEndPoint, "listeningEndPoint");
Ensure.NotNull(setting, "setting");
Ensure.NotNull(receiveDataBufferPool, "receiveDataBufferPool");
Ensure.NotNull(messageArrivedHandler, "messageArrivedHandler");
_listeningEndPoint = listeningEndPoint;
_setting = setting;
_receiveDataBufferPool = receiveDataBufferPool;
_connectionEventListeners = new List<IConnectionEventListener>();
_messageArrivedHandler = messageArrivedHandler;
_socket = SocketUtils.CreateSocket(_setting.SendBufferSize, _setting.ReceiveBufferSize);
_acceptSocketArgs = new SocketAsyncEventArgs();
_acceptSocketArgs.Completed += AcceptCompleted;
_logger = ObjectContainer.Resolve<ILoggerFactory>().Create(GetType().FullName);
}
public DocumentsStorageActions(IUuidGenerator uuidGenerator,
OrderedPartCollection<AbstractDocumentCodec> documentCodecs,
IDocumentCacher documentCacher,
Reference<WriteBatch> writeBatch,
Reference<SnapshotReader> snapshot,
TableStorage tableStorage,
IBufferPool bufferPool)
: base(snapshot, bufferPool)
{
this.uuidGenerator = uuidGenerator;
this.documentCodecs = documentCodecs;
this.documentCacher = documentCacher;
this.writeBatch = writeBatch;
this.tableStorage = tableStorage;
metadataIndex = tableStorage.Documents.GetIndex(Tables.Documents.Indices.Metadata);
}
public AttachmentsStorageActions(Table attachmentsTable,
Reference<WriteBatch> writeBatch,
Reference<SnapshotReader> snapshot,
IUuidGenerator uuidGenerator,
TableStorage tableStorage,
Raven.Storage.Voron.TransactionalStorage transactionalStorage,
IBufferPool bufferPool)
:base(snapshot, bufferPool)
{
this.attachmentsTable = attachmentsTable;
this.writeBatch = writeBatch;
this.uuidGenerator = uuidGenerator;
this.tableStorage = tableStorage;
this.transactionalStorage = transactionalStorage;
metadataIndex = tableStorage.Attachments.GetIndex(Tables.Attachments.Indices.Metadata);
}
public ClientSocket(EndPoint serverEndPoint, EndPoint localEndPoint, SocketSetting setting, IBufferPool receiveDataBufferPool, Action<ITcpConnection, byte[]> messageArrivedHandler)
{
Ensure.NotNull(serverEndPoint, "serverEndPoint");
Ensure.NotNull(setting, "setting");
Ensure.NotNull(receiveDataBufferPool, "receiveDataBufferPool");
Ensure.NotNull(messageArrivedHandler, "messageArrivedHandler");
_connectionEventListeners = new List<IConnectionEventListener>();
_serverEndPoint = serverEndPoint;
_localEndPoint = localEndPoint;
_setting = setting;
_receiveDataBufferPool = receiveDataBufferPool;
_messageArrivedHandler = messageArrivedHandler;
_waitConnectHandle = new ManualResetEvent(false);
_socket = SocketUtils.CreateSocket(_setting.SendBufferSize, _setting.ReceiveBufferSize);
_logger = ObjectContainer.Resolve<ILoggerFactory>().Create(GetType().FullName);
}
public SocketRemotingClient(EndPoint serverEndPoint, SocketSetting setting = null, EndPoint localEndPoint = null)
{
Ensure.NotNull(serverEndPoint, "serverEndPoint");
_serverEndPoint = serverEndPoint;
_localEndPoint = localEndPoint;
_setting = setting ?? new SocketSetting();
_receiveDataBufferPool = new BufferPool(_setting.ReceiveDataBufferSize, _setting.ReceiveDataBufferPoolSize);
_clientSocket = new ClientSocket(_serverEndPoint, _localEndPoint, _setting, _receiveDataBufferPool, HandleReplyMessage);
_responseFutureDict = new ConcurrentDictionary<long, ResponseFuture>();
_replyMessageQueue = new BlockingCollection<byte[]>(new ConcurrentQueue<byte[]>());
_responseHandlerDict = new Dictionary<int, IResponseHandler>();
_connectionEventListeners = new List<IConnectionEventListener>();
_scheduleService = ObjectContainer.Resolve<IScheduleService>();
_logger = ObjectContainer.Resolve<ILoggerFactory>().Create(GetType().FullName);
RegisterConnectionEventListener(new ConnectionEventListener(this));
}
public TsMediaParser(ITsDecoder tsDecoder, ITsPesPacketPool tsPesPacketPool, IBufferPool bufferPool, ITsTimestamp tsTimemestamp, IPesHandlers pesHandlers)
{
if (null == tsDecoder)
throw new ArgumentNullException(nameof(tsDecoder));
if (null == tsPesPacketPool)
throw new ArgumentNullException(nameof(tsPesPacketPool));
if (null == bufferPool)
throw new ArgumentNullException(nameof(bufferPool));
if (null == tsTimemestamp)
throw new ArgumentNullException(nameof(tsTimemestamp));
if (null == pesHandlers)
throw new ArgumentNullException(nameof(pesHandlers));
_tsPesPacketPool = tsPesPacketPool;
_bufferPool = bufferPool;
_tsDecoder = tsDecoder;
_tsTimemestamp = tsTimemestamp;
_pesHandlers = pesHandlers;
}
/// <summary>
/// Adapts a <see cref="Stream"/> into a <see cref="IPipelineWriter"/>.
/// </summary>
/// <param name="stream"></param>
/// <param name="pool"></param>
/// <returns></returns>
public static IPipelineWriter AsPipelineWriter(this Stream stream, IBufferPool pool)
{
var writer = new PipelineReaderWriter(pool);
writer.CopyToAsync(stream).ContinueWith((task, state) =>
{
var innerWriter = (PipelineReaderWriter)state;
if (task.IsFaulted)
{
innerWriter.CompleteReader(task.Exception.InnerException);
}
else
{
innerWriter.CompleteReader();
}
},
writer, CancellationToken.None, TaskContinuationOptions.ExecuteSynchronously, TaskScheduler.Default);
return writer;
}
public GeneralStorageActions(TableStorage storage, Reference <WriteBatch> writeBatch, Reference <SnapshotReader> snapshot, IBufferPool bufferPool)
: base(snapshot, bufferPool)
{
this.storage = storage;
this.writeBatch = writeBatch;
this.snapshot = snapshot;
}
/// <summary>
/// Initializes a new instance of the <see cref="SessionEventArgsBase" /> class.
/// </summary>
private SessionEventArgsBase(ProxyServer server)
{
BufferPool = server.BufferPool;
ExceptionFunc = server.ExceptionFunc;
TimeLine["Session Created"] = DateTime.Now;
}
public TasksStorageActions(TableStorage tableStorage, IUuidGenerator generator, Reference <SnapshotReader> snapshot, Reference <WriteBatch> writeBatch, IBufferPool bufferPool)
: base(snapshot, bufferPool)
{
this.tableStorage = tableStorage;
this.generator = generator;
this.writeBatch = writeBatch;
}
public IndexingStorageActions(TableStorage tableStorage, IUuidGenerator generator, Reference <SnapshotReader> snapshot, Reference <WriteBatch> writeBatch, IStorageActionsAccessor storageActionsAccessor, IBufferPool bufferPool)
: base(snapshot, bufferPool)
{
this.tableStorage = tableStorage;
this.generator = generator;
this.writeBatch = writeBatch;
this.currentStorageActionsAccessor = storageActionsAccessor;
}
