/// <summary>
/// Initializes a new instance of the StreamRepository class.
/// </summary>
/// <param name="stream">A stream which will be used as a storage for items.</param>
/// <param name="streamMapper">Provides conversation algorithms from <see cref="TItem"/> to a bytes and from bytes to a <see cref="TItem"/> to write and read <see cref="TItem"/> from <param name="stream"/>.</param>
/// <param name="itemSize">Size of each <see cref="TItem"/> in bytes.</param>
public StreamRepository(
Stream stream,
IStreamMapper <TItem> streamMapper,
int itemSize)
{
Validate.Null(stream, "stream");
Validate.Null(streamMapper, "streamMapper");
_stream = stream;
_streamMapper = streamMapper;
_itemSize = itemSize;
// TODO: Think on smart cache that will work faster and which doesn't need to preload all elements at once.
// TODO: the first item (or some firs bytes) should be an next id and validity flag
// TODO: implement feature with FREE IDs. When the cache will be full then it should compute all free available ids.
_cache = new Dictionary <ulong, long>();
for (long index = 0; index < _stream.Length; index += IdSize + _itemSize)
{
var id = ReadId(index);
_cache.Add(id, index);
}
_disposed = false;
}
internal ConsoleStream(ProcessStartInfo startInfo, IStreamMapper <T> mapper, CancellationToken token)
{
_token = token;
_mapper = mapper;
_process = new Process
{
StartInfo = startInfo,
EnableRaisingEvents = true
};
if (CancellationToken.None != token)
{
token.Register(CancelProcess);
}
_process.OutputDataReceived += (sender, args) =>
{
var val = _mapper.OnData(args.Data, false);
if (null != val)
{
_values.Add(val);
}
Error = _mapper.Error;
};
_process.ErrorDataReceived += (sender, args) =>
{
var val = _mapper.OnData(args.Data, true);
if (null != val)
{
_values.Add(val);
}
Error = _mapper.Error;
};
_process.Exited += (sender, args) =>
{
Error = _mapper.Error;
IsSuccess = _process.ExitCode == 0;
IsFinished = true;
_values.Add(_mapper.OnProcessEnd(_process.ExitCode));
};
if (!_process.Start())
{
throw new FluentDockerException($"Could not start process {startInfo.FileName}");
}
_process.BeginOutputReadLine();
_process.BeginErrorReadLine();
}
private ChangeFeedProcessor(string name, string siloName,
CosmosDBStreamOptions options, IServiceProvider serviceProvider,
TaskScheduler scheduler, IStreamMapper mapper)
{
var loggerFactory = serviceProvider.GetRequiredService <ILoggerFactory>();
this._name = name;
this._siloName = siloName;
this._scheduler = scheduler;
this._grainFactory = serviceProvider.GetRequiredService <IGrainFactory>();
this._logger = loggerFactory.CreateLogger($"{nameof(ChangeFeedProcessor)}-{name}");
this._mapper = mapper;
this._options = options;
this._ctsClose = new CancellationTokenSource();
this._checkpointer = new ChangeFeedCheckpointer(loggerFactory, this._options);
}
private static IRepository <TItem, ulong> OpenRepository <TItem>(Package package, string path, IStreamMapper <TItem> streamMapper, int itemSize)
{
var uri = new Uri(path, UriKind.Relative);
return(new StreamRepository <TItem>(package.GetPart(uri).GetStream(), streamMapper, itemSize));
}
/// <summary>
/// Factory method to create a new IProcessor instances
/// </summary>
/// <param name="name">Name of the stream provider</param>
/// <param name="siloName">This Silo name</param>
/// <param name="options">Configuration for both the monitored and lease collections</param>
/// <param name="serviceProvider">DI container</param>
/// <param name="scheduler">Orleans Task Scheduler</param>
/// <param name="mapper">The IStreamMapper implementation</param>
/// <returns>IProcessor implementation</returns>
public static IProcessor Create(string name, string siloName, CosmosDBStreamOptions options, IServiceProvider serviceProvider, TaskScheduler scheduler, IStreamMapper mapper)
{
return(new ChangeFeedProcessor(name, siloName, options, serviceProvider, scheduler, mapper));
}
public MapProvider(IStreamMapper <MapRecord> mapMapper, int itemSize, string workDirectory)
{
_mapMapper = mapMapper;
_workDirectory = workDirectory;
_itemSize = itemSize;
}
