protected override async Task BeforeSaving(IRedisTransaction transaction, IDataKey key, SimpleItem entity)
{
var identity = new Identity();
identity.InstanceId = "One";
await inner.Save(identity, transaction).ConfigureAwait(false);
}
private async Task EntityEventSubscription(IDataKey key, CancellationToken token, IObserver <ChannelMessage> observer)
{
ChannelMessageQueue subscriber = null;
try
{
subscriber = await repository.Redis.Multiplexer.SubscribeKeyEvents(key.FullKey).ConfigureAwait(false);
do
{
var result = await subscriber.ReadAsync(token).ConfigureAwait(false);
observer.OnNext(result);
while (subscriber.TryRead(out result))
{
observer.OnNext(result);
}
} while (!token.IsCancellationRequested);
}
catch (OperationCanceledException)
{
}
finally
{
if (subscriber != null)
{
await subscriber.UnsubscribeAsync().ConfigureAwait(false);
}
}
}
public IObservable <T> GetRecords(IDatabaseAsync database, IDataKey dataKey, long fromRecord = 0, long toRecord = -1)
{
if (database == null)
{
throw new ArgumentNullException(nameof(database));
}
if (dataKey == null)
{
throw new ArgumentNullException(nameof(dataKey));
}
if (typeof(T) != typeof(SortedSetEntry))
{
throw new ArgumentOutOfRangeException(nameof(T));
}
var key = link.GetKey(dataKey);
return(Observable.Create <T>(
async observer =>
{
var items = await link.Resilience.AsyncRetryPolicy.ExecuteAsync(
async() =>
await database.SortedSetRangeByScoreWithScoresAsync(key, skip: fromRecord, take: toRecord)
.ConfigureAwait(false))
.ConfigureAwait(false);
foreach (var value in items)
{
observer.OnNext((T)(object)value);
}
observer.OnCompleted();
}));
}
public void Load(XmlElement xmlElem)
{
string type = xmlElem.GetAttribute("datatype");
if ("kline".Equals(type))
{
dataKey = new KLineKey();
((KLineKey)dataKey).Load(xmlElem);
}
else if ("timeline".Equals(type))
{
dataKey = new TimeLineKey();
((TimeLineKey)dataKey).Load(xmlElem);
}
XmlNode node = xmlElem.ChildNodes[0];
if (node is XmlElement)
{
XmlElement elem = (XmlElement)node;
this.title = new StrategyGraphicTitle();
this.title.Load(elem);
}
this.priceShapes = new PriceShapeContainer();
this.priceShapes.Load(xmlElem);
}
public PacketBase Get(IDataKey key)
{
if (key is DoubleHeightKey heightKey)
{
TransactionsRegistryBlock transactionsRegistryBlock = DataAccessService.Instance.GetTransactionsRegistryBlock(heightKey.Height1, heightKey.Height2);
PacketBase blockBase = _translatorsRepository.GetInstance <TransactionsRegistryBlock, PacketBase>().Translate(transactionsRegistryBlock);
return(blockBase);
}
else if (key is SyncHashKey syncTransactionKey)
{
List <TransactionsRegistryBlock> transactionsRegistryBlocks = DataAccessService.Instance.GetTransactionsRegistryBlocks(syncTransactionKey.SyncBlockHeight);
TransactionsRegistryBlock transactionsRegistryBlock = transactionsRegistryBlocks.FirstOrDefault(t => syncTransactionKey.Hash.Equals32(t.Hash));
if (transactionsRegistryBlock == null)
{
transactionsRegistryBlocks = DataAccessService.Instance.GetTransactionsRegistryBlocks(syncTransactionKey.SyncBlockHeight - 1);
transactionsRegistryBlock = transactionsRegistryBlocks.FirstOrDefault(t => syncTransactionKey.Hash.Equals32(t.Hash));
}
PacketBase blockBase = null;
if (transactionsRegistryBlock != null)
{
blockBase = _translatorsRepository.GetInstance <TransactionsRegistryBlock, PacketBase>().Translate(transactionsRegistryBlock);
}
return(blockBase);
}
return(null);
}
public Task AddRecord(IDatabaseAsync database, IDataKey objectKey, params T[] instances)
{
if (database == null)
{
throw new ArgumentNullException(nameof(database));
}
if (objectKey == null)
{
throw new ArgumentNullException(nameof(objectKey));
}
if (instances == null)
{
throw new ArgumentNullException(nameof(instances));
}
log.LogDebug("AddRecords: {0}", instances.Length);
if (instances.Length > 1)
{
throw new ArgumentOutOfRangeException();
}
var instance = instances[0];
var tasks = new List <Task>();
var actualKey = link.GetKey(objectKey);
var entries = objectSerialization.GetEntries(instance).ToArray();
tasks.Add(database.HashSetAsync(actualKey, entries));
tasks.AddRange(mainIndexManager.Add(database, objectKey));
return(Task.WhenAll(tasks));
}
public IEnumerable <BlockBase> GetAll(IDataKey key)
{
if (key is BlockTypeLowHeightKey blockTypeLowHeightKey)
{
if (blockTypeLowHeightKey.BlockType == BlockTypes.Synchronization_ConfirmedBlock)
{
return(DataAccessService.Instance.GetAllLastSynchronizationBlocks(blockTypeLowHeightKey.Height).Select(b => _translatorsRepository.GetInstance <SynchronizationBlock, BlockBase>().Translate(b)));
}
else if (blockTypeLowHeightKey.BlockType == BlockTypes.Synchronization_RegistryCombinationBlock)
{
return(DataAccessService.Instance.GetAllLastRegistryCombinedBlocks(blockTypeLowHeightKey.Height).Select(b => _translatorsRepository.GetInstance <RegistryCombinedBlock, BlockBase>().Translate(b)));
}
}
else if (key is BlockTypeKey blockTypeKey)
{
if (blockTypeKey.BlockType == BlockTypes.Synchronization_ConfirmedBlock)
{
return(DataAccessService.Instance.GetAllSynchronizationBlocks().Select(b => _translatorsRepository.GetInstance <SynchronizationBlock, BlockBase>().Translate(b)));
}
else if (blockTypeKey.BlockType == BlockTypes.Synchronization_RegistryCombinationBlock)
{
return(DataAccessService.Instance.GetAllRegistryCombinedBlocks().Select(b => _translatorsRepository.GetInstance <RegistryCombinedBlock, BlockBase>().Translate(b)));
}
}
return(null);
}
public IObservable <T> GetRecords(IDatabaseAsync database, IDataKey dataKey, long fromRecord = 0, long toRecord = -1)
{
if (database == null)
{
throw new ArgumentNullException(nameof(database));
}
if (dataKey == null)
{
throw new ArgumentNullException(nameof(dataKey));
}
var key = link.GetKey(dataKey);
return(Observable.Create <T>(
async observer =>
{
var items = await link.Resilience.AsyncRetryPolicy.ExecuteAsync(async() => await redisSetList.GetRedisValues(database, key, fromRecord, toRecord).ConfigureAwait(false))
.ConfigureAwait(false);
var values = GetValues(key, items);
foreach (var value in values)
{
observer.OnNext(value);
}
observer.OnCompleted();
}));
}
public Task DeleteAll(IDatabaseAsync database, IDataKey key)
{
log.LogDebug("DeleteAll: [{0}]", key);
var tasks = new List <Task>(mainIndexManager.Delete(database, key));
tasks.Add(link.DeleteAll(database, key));
return(Task.WhenAll(tasks));
}
public Task RemoveIndex(IDatabaseAsync database, IDataKey key, IIndexKey indexes)
{
if (key?.RecordId == null)
{
throw new ArgumentNullException(nameof(key));
}
return(RemoveRawIndex(database, indexes, key.RecordId));
}
public Task AddIndex(IDatabaseAsync database, IDataKey key, IIndexKey indexes)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
return(AddRawIndex(database, key.RecordId, indexes));
}
public IObservable <T> GetRecords <T>(IDataKey dataKey)
{
if (dataKey == null)
{
throw new ArgumentNullException(nameof(dataKey));
}
return(link.GetSpecific <T>().GetRecords(GetDatabase(), dataKey));
}
protected override Task BeforeSaving(IRedisTransaction transaction, IDataKey key, T entity)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
key.AddIndex(Active);
return(base.BeforeSaving(transaction, key, entity));
}
public Task <bool> ContainsRecord <T>(IDataKey key)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
return(link.Resilience
.AsyncRetryPolicy
.ExecuteAsync(async() => await link.ContainsRecord(GetDatabase(), key).ConfigureAwait(false)));
}
public Task DeleteAll <T>(IDataKey key)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
return(link.Resilience
.AsyncRetryPolicy
.ExecuteAsync(async() => await link.GetSpecific <T>().DeleteAll(GetDatabase(), key).ConfigureAwait(false)));
}
public static string GetCurrentValue(this IDataKey dataKey, IValueProvider valueProvider)
{
var value = valueProvider.GetValue(dataKey.RouteKey);
if (value != null)
{
return(value.AttemptedValue);
}
return(null);
}
public Task SetExpire <T>(IDataKey key, TimeSpan span)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
return(link.Resilience
.AsyncRetryPolicy
.ExecuteAsync(async() => await link.GetSpecific <T>().SetExpire(GetDatabase(), key, span).ConfigureAwait(false)));
}
public BlockBase Get(IDataKey key)
{
if (key is SyncHashKey syncHashKey)
{
UtxoConfidentialBlock utxoConfidential = DataAccessService.Instance.GetUtxoConfidentialBySyncAndHash(syncHashKey.SyncBlockHeight, syncHashKey.Hash);
return _mapperFactory.GetInstance<UtxoConfidentialBlock, BlockBase>().Translate(utxoConfidential);
}
return null;
}
public PacketBase Get(IDataKey key)
{
if (key is SyncHashKey syncHashKey)
{
TransactionalBlock transactionalBlock = DataAccessService.Instance.GetTransactionalBySyncAndHash(syncHashKey.SyncBlockHeight, syncHashKey.Hash);
return(_mapperFactory.GetInstance <TransactionalBlock, PacketBase>().Translate(transactionalBlock));
}
return(null);
}
public IPriceShapeContainer GetShapeContainer(IDataKey graphicKey)
{
if (graphicKey == null)
{
return(null);
}
if (dic_GraphicKey_Container.ContainsKey(graphicKey))
{
return(dic_GraphicKey_Container[graphicKey]);
}
return(null);
}
private IEnumerable <(IIndexManager Manager, IIndexKey Index)> GetManagers(IDataKey dataKey)
{
if (dataKey == null)
{
throw new ArgumentNullException(nameof(dataKey));
}
foreach (var index in dataKey.Indexes)
{
yield return(GetManager(index), index);
}
}
public IStrategyGraphic GetGraphic(IDataKey graphicKey)
{
if (graphicKey == null)
{
return(null);
}
if (dic_GraphicKey_Container.ContainsKey(graphicKey))
{
return(dic_GraphicKey_Container[graphicKey]);
}
return(null);
}
public static RedisKey GetKey(this IRedisLink link, IDataKey key)
{
if (link == null)
{
throw new ArgumentNullException(nameof(link));
}
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
return(GetKey(link, key.FullKey));
}
public PacketBase Get(IDataKey key)
{
if (key is SyncHashKey syncHashKey)
{
UtxoConfidentialBlock utxoConfidential = DataAccessService.Instance.GetUtxoConfidentialBySyncAndHash(syncHashKey.SyncBlockHeight, syncHashKey.Hash);
if (utxoConfidential != null)
{
return(_mapperFactory.GetInstance <UtxoConfidentialBlock, PacketBase>().Translate(utxoConfidential));
}
}
return(null);
}
public Task AddRecord <T>(IDataKey key, params T[] instances)
{
if (key == null)
{
throw new ArgumentNullException(nameof(key));
}
if (instances == null)
{
throw new ArgumentNullException(nameof(instances));
}
return(link.Resilience
.AsyncRetryPolicy
.ExecuteAsync(async() => await link.GetSpecific <T>().AddRecord(GetDatabase(), key, instances).ConfigureAwait(false)));
}
public Task[] Delete(IDatabaseAsync database, IDataKey dataKey)
{
if (dataKey == null)
{
throw new ArgumentNullException(nameof(dataKey));
}
var tasks = new List <Task>(dataKey.Indexes.Length);
foreach (var indexManager in GetManagers(dataKey))
{
tasks.Add(indexManager.Manager.RemoveIndex(database, dataKey, indexManager.Index));
}
return(tasks.ToArray());
}
public Task SaveItems(IDatabaseAsync database, IDataKey key, params RedisValue[] redisValues)
{
var redisKey = link.GetKey(key);
logger.LogTrace("SaveItems: <{0}>", key);
var time = DateTime.UtcNow.ToUnixTime();
var saveTask = database.SortedSetAddAsync(
redisKey,
redisValues.Select(item => new SortedSetEntry(item, time)).ToArray());
List <Task> tasks = new List <Task>(indexManager.Add(database, key));
tasks.Add(saveTask);
return(Task.WhenAll(tasks));
}
public IObservable <T> GetRecords(IDatabaseAsync database, IDataKey dataKey, long fromRecord = 0, long toRecord = -1)
{
if (database == null)
{
throw new ArgumentNullException(nameof(database));
}
if (dataKey == null)
{
throw new ArgumentNullException(nameof(dataKey));
}
var key = link.GetKey(dataKey);
log.LogTrace("GetRecords: {0}", key);
if (fromRecord != 0 &&
toRecord != -1)
{
log.LogWarning("Selecting index is not supported for single item");
}
return(Observable.Create <T>(
async observer =>
{
var exist = await link.Resilience.AsyncRetryPolicy.ExecuteAsync(
async() => await database.KeyExistsAsync(key).ConfigureAwait(false))
.ConfigureAwait(false);
if (!exist)
{
log.LogWarning("Key doesn't exist: {0}", key);
observer.OnCompleted();
return;
}
var result = await link.Resilience.AsyncRetryPolicy.ExecuteAsync(
async() => await database.HashGetAllAsync(key).ConfigureAwait(false))
.ConfigureAwait(false);
var actualValues = ConstructActualValues(result);
foreach (var value in actualValues)
{
observer.OnNext(value);
}
observer.OnCompleted();
}));
}
public void RemoveGraphic(IStrategyGraphic graphic)
{
this.graphics.Remove(graphic);
IDataKey dataKey = graphic.DataKey;
if (dataKey == null)
{
return;
}
if (dataKey is KLineKey)
{
klineKeies.Remove((KLineKey)dataKey);
}
else if (dataKey is TimeLineKey)
{
timeLineKeies.Remove((TimeLineKey)dataKey);
}
}
public void RemoveContainer(IPriceShapeContainer priceShapeContainer)
{
this.containers.Remove(priceShapeContainer);
IDataKey dataKey = priceShapeContainer.GraphicKey;
if (dataKey == null)
{
return;
}
if (dataKey is KLineKey)
{
klineKeies.Remove((KLineKey)dataKey);
}
else if (dataKey is TimeLineKey)
{
timeLineKeies.Remove((TimeLineKey)dataKey);
}
}
