public IMessageBusSpecifier DeclareExchange(string exchangeName, ExchangeTypes exchangeType)
{
try
{
var exchanges = _client.OpenTable <MessageExchangeDeclaration>(AMQPDeclarations.MessageExchange);
using (_client.BeginTransaction())
{
var check = exchanges.Fetch(exchangeName);
if (!check.Any(d => d.Key == exchangeName))
{
exchanges.AddNew(exchangeName,
new MessageExchangeDeclaration {
Name = exchangeName, Type = exchangeType
});
_client.Commit();
}
}
}
catch (AggregateException aex)
{
if (!(aex.InnerExceptions.Any(ex => ex is DBConcurrencyException)))
{
throw;
}
}
return(this);
}
/// <summary>
/// Returns the correct exchange api for the specified exchange.
/// </summary>
/// <returns>api for communicating with the exchange.</returns>
/// <param name="exchangeType">The exchange.</param>
public static ExchangeAPI Create(ExchangeTypes exchangeType)
{
switch (exchangeType)
{
case ExchangeTypes.Binance:
return(new ExchangeBinanceAPI());
case ExchangeTypes.Bittrex:
return(new ExchangeBittrexAPI());
case ExchangeTypes.Gdax:
return(new ExchangeGdaxAPI());
case ExchangeTypes.Okex:
return(new ExchangeOkexAPI());
case ExchangeTypes.Gemini:
return(new ExchangeGeminiAPI());
case ExchangeTypes.Kraken:
return(new ExchangeKrakenAPI());
case ExchangeTypes.Bithumb:
return(new ExchangeBithumbAPI());
case ExchangeTypes.Bitfinex:
return(new ExchangeBitfinexAPI());
case ExchangeTypes.Poloniex:
return(new ExchangePoloniexAPI());
}
return(null);
}
public BaseProducer(ExchangeTypes type, RabbitMQConnectionModel server, RabbitMQChannelModel queue)
{
//1.创建连接
_connection = server.Factory.CreateConnection();
//2.创建通道
_channel = _connection.CreateModel();
//队列配置
_queue = queue;
switch (type)
{
case ExchangeTypes.direct:
//3.声明一个交换机
_channel.ExchangeDeclare(queue.ExchangeName, ExchangeType.Direct, true, false);
break;
case ExchangeTypes.topic:
break;
}
if (type != ExchangeTypes.topic)
{
//4.声明一个队列
_channel.QueueDeclare(_queue.QueueName,
queue.Durable, _queue.Exclusive,
queue.AutoDelete);
//5.将队列绑定到交换机
_channel.QueueBind(queue.QueueName, queue.ExchangeName, queue.ExchangeName, null);
}
}
public IMessageBusSpecifier DeclareExchange(string exchangeName, ExchangeTypes exchangeType)
{
var exchangePath = GetExchangePath(exchangeName);
var mtx = GetExchangeMutex(exchangeName);
var di = new DirectoryInfo(exchangePath);
using (mtx)
{
if (mtx.Wait(TimeSpan.FromSeconds(30)))
{
if (di.Exists)
{
return(this);
}
di.Create();
using (
var sw =
File.CreateText(Path.Combine(exchangePath,
string.Format("{0}.type", exchangeType.EnumName()))))
{
sw.Flush();
sw.Close();
}
mtx.Release();
}
}
return(this);
}
public IMessageBusSpecifier DeclareExchange(string exchangeName, ExchangeTypes exchangeType)
{
var rep = DataRepositoryServiceFactory.CreateSimple <MessageExchangeDeclaration>();
rep.CreateNew(new MessageExchangeDeclaration {
Name = exchangeName, Type = exchangeType
});
return(this);
}
public IMessageBusSpecifier DeclareExchange(string exchangeName, ExchangeTypes exchangeType)
{
if (!Exchanges.ContainsKey(exchangeName))
{
Exchanges.TryAdd(exchangeName,
new MemExchange(this,
new MessageExchangeDeclaration
{
Name = exchangeName, Type = exchangeType
}));
}
return(this);
}
private void RefreshQueues()
{
var ex = _bus.SpecifyExchange(_exchangeName);
if (null != ex)
{
_queues = ex.Queues.ToList();
_exchangeType = ex.ExchangeType;
}
else
{
_queues = new List <IQueueSpecifier>();
}
}
public static IEnumerable <string> BindMessageToQueues(string key, ExchangeTypes ex,
IEnumerable <IQueueSpecifier> qs)
{
switch (ex)
{
case ExchangeTypes.Direct:
{
var routeBound =
qs.Where(
q =>
!q.Bindings.Any() ||
q.Bindings.Any(k => string.Compare(key, k, true, CultureInfo.InvariantCulture) == 0));
if (routeBound.Count() == 1)
{
return(EnumerableEx.OfOne(routeBound.First().Name));
}
if (routeBound.Any())
{
var matches = (from q in routeBound
select q.Name).Distinct().Shuffle(GoodSeedRandom.Create());
return(matches.Take(1));
}
return(Enumerable.Empty <string>());
}
//break;
case ExchangeTypes.Fanout:
{
return(qs.Select(q => q.Name));
}
//break;
case ExchangeTypes.Topic:
{
return((from q in qs
where q.Bindings.Any(k => TopicMatch(key, k))
select q.Name).Distinct());
}
//break;
}
return(Enumerable.Empty <string>());
}
public IMessageBusSpecifier DeclareExchange(string exchangeName, ExchangeTypes exchangeType)
{
using (var session = DocumentStoreLocator.ResolveOrRoot(MessageBusSpecifierLocalConfig.HostConnectionString))
{
var exNameObject = session.Load <MessageExchangeDeclaration>(exchangeName);
if (exNameObject == null)
{
var newExchange = new MessageExchangeDeclaration {
Name = exchangeName, Type = exchangeType
};
session.Store(newExchange);
session.SaveChanges();
}
}
return(this);
}
/// <summary>
/// 创建生产者
/// </summary>
/// <param name="type"></param>
/// <param name="server"></param>
/// <param name="queue"></param>
/// <returns></returns>
public static BaseProducer CreateProducer(ExchangeTypes type, RabbitMQConnectionModel server, RabbitMQChannelModel queue)
{
return(new RabbitMQDefaultProducer(server, queue));
/*var producer = new RabbitMQProducerModel();
* //创建连接
* producer.Connection = server.Factory.CreateConnection();
* //创建通道
* producer.Channel = producer.Connection.CreateModel();
* //队列配置
* producer.Queue = queue;
* switch (type)
* {
* case ExchangeTypes.topic:
* //声明一个队列
* producer.Channel.QueueDeclare(queue.QueueName, queue.Durable, queue.Exclusive, queue.AutoDelete);
* break;
* }
* return producer;*/
}
public MessageEntry(ICoreDispatcher dispatcher, ReceivedMessageEventArgs receivedMessage)
{
ReceivedMessage = receivedMessage;
Dispatcher = dispatcher;
if (receivedMessage != null)
{
_via = receivedMessage.GetVia();
IsRequest = receivedMessage.GetHeaderValue(MessageBasicPropertiesHeaders.DIRECTION) != MessageBasicPropertiesHeaders.DIRECTION_VALUE_RESPONSE;
if (_via == null)
{
_via = new ViaContainer()
{
queue = new Stack <ViaElement>()
};
if (receivedMessage.Properties != null)
{
_via.queue.Push(new ViaElement()
{
appId = receivedMessage.Properties.AppId,
messageId = receivedMessage.Properties.MessageId,
mqWorkKind = ExchangeTypes.Get(receivedMessage.GetHeaderValue(MessageBasicPropertiesHeaders.WORKKIND)) ?? ExchangeTypes.EXCHANGETYPE_FANOUT,
priority = receivedMessage.Properties.Priority,
queryHandlerName = receivedMessage.Properties.ContentType,
replyTo = receivedMessage.Properties.ReplyTo
});
}
}
}
else
{
_via = new ViaContainer()
{
queue = new Stack <ViaElement>()
};
}
}
public void SendExchange(QsoInProgress q, ExchangeTypes exc, bool withAck, QsoSequencer.MessageSent ms)
{
callbacks.SendMessage(callbacks.GetExchangeMessage(q, withAck, exc), q, ms);
}
public CandleFactory(ExchangeTypes exchangeType, ExchangeAPI api, PriceDbContext dbContext)
{
_api = api;
_dbContext = dbContext;
_exchangeType = exchangeType;
}
public Scanner(ExchangeTypes exchangeType)
{
_exchangeType = exchangeType;
}
internal static string Translate(ExchangeTypes exchangeTypes)
{
return(exchangeTypes.EnumName());
}
public IMessageBusSpecifier DeclareExchange(Enum exchangeName, ExchangeTypes exchangeType)
{
return(DeclareExchange(exchangeName.EnumName(), exchangeType));
}
/// <summary>
/// Returns the candles for a specific exchange & symbol.
/// When present candles are returned from the database
/// and if needed database is updated with new candles from the exchange
/// </summary>
/// <returns>Candles for the exchange / symbol</returns>
/// <param name="exchangeType">Exchange.</param>
/// <param name="symbolName">Symbol.</param>
public List <Candle> Get(ExchangeTypes exchangeType, string symbolName)
{
// open database
using (var db = new PriceDbContext())
{
// get exchange from database
var exchange = db.Exchanges.FirstOrDefault(e => e.Name == exchangeType);
if (exchange == null)
{
Debug.WriteLine($"Add {exchangeType}");
// new exchange.. add record in database
exchange = new Exchange()
{
Name = exchangeType
};
db.Exchanges.Add(exchange);
db.SaveChanges();
}
// get symbol from database
var symbol = db.Symbols.FirstOrDefault(e => e.Name == symbolName && e.ExchangeId == exchange.ExchangeId);
if (symbol == null)
{
Debug.WriteLine($"Add {symbolName} on {exchangeType}");
// new symbol.. add record in database
symbol = new Symbol()
{
Name = symbolName,
ExchangeId = exchange.ExchangeId,
LastUpdate = new DateTime(2018, 1, 1),
LastCandle = new DateTime(2018, 1, 1)
};
db.Symbols.Add(symbol);
db.SaveChanges();
}
// Check if we need to get new candles from the exchange
var now = DateTime.Now;
if (now.Day != symbol.LastUpdate.Day || now.Month != symbol.LastUpdate.Month || now.Year != symbol.LastUpdate.Year)
{
// yes... then get all (new) candles from the exchange
Debug.WriteLine($"update {symbol.Name} Last Update:{symbol.LastUpdate} ");
var api = ExchangeFactory.Create(exchangeType);
for (int i = 0; i < 2; ++i)
{
var newCandles = api.GetCandles(symbol.Name, TIMEFRAME_H1, symbol.LastCandle).ToList();
// add new candles to the database for next time
foreach (var candle in newCandles)
{
// only add new candles
if (candle.Timestamp > symbol.LastCandle)
{
symbol.LastCandle = candle.Timestamp;
db.Candles.Add(new Candle()
{
SymbolId = symbol.SymbolId,
Date = candle.Timestamp,
Open = candle.OpenPrice,
Close = candle.ClosePrice,
Low = candle.LowPrice,
High = candle.HighPrice
});
}
}
var ts = DateTime.Now - symbol.LastCandle;
if (ts.TotalDays <= 1)
{
break;
}
}
// set lastupdate for this symbol
symbol.LastUpdate = now;
Debug.WriteLine($" set lastupdate {symbol.Name} to :{symbol.LastUpdate} ");
db.SaveChanges();
}
// return candles for this symbol;
var startDate = DateTime.Now.AddMonths(-2);
var candles = db.Candles
.Where(e => e.SymbolId == symbol.SymbolId && e.Date >= startDate)
.OrderBy(e => e.Date)
.ToList();
return(candles);
}
}
private Task <DataArgs <ViaElement> > Push(ViaElement via, bool requestResolve, string link, string service, string exchangeName, string routingKey, string exchangeType, string queryData, IBasicProperties properties)
{
DataArgs <ViaElement> messageEventArgs = new DataArgs <ViaElement>();
if (requestResolve)
{
//Для начала надо узнать в какие очереди посылать запросы
return(this.Dispatcher.Resolve(service, link)
.ContinueWith(resolver_link =>
{
//try
//{
if (resolver_link.Exception != null)
{
messageEventArgs.SetException(resolver_link.Exception);
}
var link_str = resolver_link.Result;
var exchange = ExchangeTypes.GetExchangeName(link_str, null, exchangeType);
bool isFanout = ExchangeType.Fanout.Equals(exchangeType, StringComparison.CurrentCultureIgnoreCase);
var rk = isFanout ? exchange : routingKey;
var options = new ProducerParam()
{
RoutingKey = rk
};
if (!isFanout)
{
options.ExchangeParam = new ChannelExchangeParam()
{
Name = exchange,
Type = exchangeType ?? ExchangeTypes.EXCHANGETYPE_FANOUT
};
}
var data = Encoding.UTF8.GetBytes(queryData);
//посылаем сообщение
Dispatcher.Connection.Publish(options, data, properties);
messageEventArgs.result = true;
messageEventArgs.data = via;
//}
//catch (Exception ex)
//{
// messageEventArgs.SetException(ex);
//}
return messageEventArgs;
}));
}
else
{
return(Task.Run(() =>
{
//try
//{
//для запросов, где очереди известны
var options = new ProducerParam()
{
RoutingKey = routingKey
};
if (!string.IsNullOrEmpty(exchangeName))
{
options.ExchangeParam = new ChannelExchangeParam()
{
Name = exchangeName,
Type = exchangeType ?? ExchangeTypes.EXCHANGETYPE_FANOUT
};
}
var data = Encoding.UTF8.GetBytes(queryData);
//посылаем сообщение
Dispatcher.Connection.Publish(options, data, properties);
//}
//catch (Exception ex)
//{
// messageEventArgs.result = false;
// messageEventArgs.SetException(ex);
//}
return messageEventArgs;
}));
}
}
public Scanner(PriceDbContext dbContext, ExchangeTypes exchangeType)
{
_exchangeType = exchangeType;
_dbContext = dbContext;
}
private void Resolver_Started(string obj)
{
Trace.TraceInformation("Resolver started");
//Self resolving timeout, exiting ...
int timeout = Config.Starter.registerselftimeout ?? 10000;
var register = Resolver.RegisterSelf();
if (Task.WhenAny(register, Task.Delay(timeout)).Result != register)
{
throw new CoreException("Resolver self register timeout expired!");
}
var links = register.Result;
Trace.TraceInformation("Self links resolved");
int queueInc = 2;
if (links != null)
{
foreach (var link in links)
{
var exchangeName = ExchangeTypes.GetExchangeName(link.name, link.type, null);
Trace.TraceInformation($"Bind {exchangeName} start..");
ConsumerParam options = new ConsumerParam();
options.QueueParam = new ChannelQueueParam()
{
AutoDelete = Config.MQ.autodelete ?? false,
};
if (Config.MQ.queue.ttl.HasValue)
{
options.QueueParam.SetExpiresMs(Config.MQ.queue.ttl.Value);
}
switch (link.type)
{
case LinkTypes.LINK_EXCHANGE:
{
ExchangeConnectionString = exchangeName;
options.QueueParam.Name = $"{exchangeName}.{AppId}";
options.ExchangeParam = new ChannelExchangeParam()
{
Name = exchangeName,
AutoDelete = Config.MQ.autodelete ?? false
};
if (Config.MQ.exchange.ttl.HasValue)
{
options.ExchangeParam.SetExpiresMs(Config.MQ.exchange.ttl.Value);
}
}
break;
case LinkTypes.LINK_QUEUE:
{
QueueConnectionString = exchangeName;
options.QueueParam.Name = exchangeName;
}
break;
default: { Trace.TraceWarning($"Unknow link type: [{link.type}]"); continue; }
}
//Максимальный пул одновременных сообщений контролируется параметром ru:spinosa:mq:prefetch
//т.е. максимальным числом полученных сообщений оставленных без ответа
Connection.Listen(options, (ea) =>
{
Task.Run(() => this.HandleMessage(ea))
.ContinueWith(res => { this.HandleMessageErrors?.Invoke(ea, res.Exception); }, TaskContinuationOptions.OnlyOnFaulted);
});
Trace.TraceInformation($"Bind {exchangeName} successed");
queueInc--;
}
}
if (queueInc == 0)
{
this.running = true;
//запускаем обновление кэша только если удалось получить собственные ссылки т.к. это подтверждает, что оператор запущен и имеет смысл к нему обращаться
//
if (Config.Starter.pingperiod_ms.HasValue)
{
Trace.TraceInformation($"RunRefreshCache started {Config.Starter.pingperiod_ms.Value}ms");
Resolver.RunRefreshCache();
}
Started?.Invoke(AppId);
}
else
{
throw new CoreException("Self links bind error: queueInc!=0 ");
}
}
internal FDExchange(FDMessageBus parent, string exchangeName, ExchangeTypes exchangeType)
{
_parent = parent;
_exchangeName = exchangeName;
_exchangeType = exchangeType;
}
public ExchangeConfiguration(ExchangeTypes type, string name)
{
Type = type;
Name = name;
}
private Task <DataArgs <ViaElement> > RequestAsync <T>(string serviceName, string exchangeType, string queryName, DataArgs <T> queryData, string responceHandlerName, string responseHandlerData, Action <string> callback, MessageEntryParam parameters)
{
var responseResolve = parameters?.NeedResponseResolve ?? false;
//TODO: подумать ExchangeTypes.EXCHANGETYPE_DIRECT для responceHandlers?
var responseKind = callback == null ? ExchangeTypes.EXCHANGETYPE_FANOUT : ExchangeTypes.EXCHANGETYPE_DIRECT;
var replayTo = responseResolve ? Dispatcher.SelfServiceName : Dispatcher.GetConnectionByExchangeType(responseKind);
var queryDataJson = queryData.ToJson();
//записываем текущее состояние запроса
var currentViaElement = new ViaElement()
{
replyTo = replayTo,
mqWorkKind = responseKind,
messageId = Guid.NewGuid().ToString(),
queryHandlerName = queryName,
appId = Dispatcher.AppId,
priority = parameters?.Priority ?? 0,
doResolve = responseResolve,
responseHandlerName = responceHandlerName,
responseHandlerData = responseHandlerData
};
this._via.queue.Push(currentViaElement);
var properties = Dispatcher.Connection.CreateChannelProperties();
properties.CorrelationId = ReceivedMessage?.Properties?.CorrelationId ?? parameters?.TransactionId ?? Guid.NewGuid().ToString();
properties.ContentType = currentViaElement.queryHandlerName;
properties.MessageId = currentViaElement.messageId;
properties.ReplyTo = currentViaElement.replyTo;
properties.Priority = currentViaElement.priority == 0 ? (byte)1 : currentViaElement.priority;
properties.Headers = new Dictionary <string, object>();
properties.Headers.TryAdd(MessageBasicPropertiesHeaders.VIA, this._via.ToJson());
properties.Headers.TryAdd(MessageBasicPropertiesHeaders.DIRECTION, MessageBasicPropertiesHeaders.DIRECTION_VALUE_REQUEST);
properties.Headers.TryAdd(MessageBasicPropertiesHeaders.WORKKIND, responseKind);
properties.Headers.TryAdd(MessageBasicPropertiesHeaders.WORKKIND_TYPE, MessageBasicPropertiesHeaders.WORKKIND_TYPE_VALUE);
properties.Headers.TryAdd(MessageBasicPropertiesHeaders.VIA_TYPE, MessageBasicPropertiesHeaders.VIA_TYPE_VALUE);
exchangeType = ExchangeTypes.Get(exchangeType);
var link = LinkTypes.GetLinkByExchangeType(exchangeType);
var routingKey = string.Empty;
if (exchangeType == ExchangeTypes.EXCHANGETYPE_FANOUT)
{
routingKey = serviceName;
}
else if (responseKind == ExchangeTypes.EXCHANGETYPE_DIRECT)
{
routingKey = parameters?.AppId;
if (string.IsNullOrEmpty(routingKey))
{
throw new CoreException("Relation [Direct to Direct] - AppId must be initialized");
}
}
var exchangeName = exchangeType == ExchangeTypes.EXCHANGETYPE_FANOUT ? "" : serviceName;
return(Push(currentViaElement, parameters?.NeedRequestResolve ?? true, link, serviceName, exchangeName, routingKey, exchangeType, queryDataJson, properties)
.ContinueWith((result) =>
{
if (callback != null)
{
if (result.Exception != null)
{
callback(new DataArgs <object>(result.Exception).ToJson());
}
else
{
Dispatcher.DeclareResponseCallback(currentViaElement.messageId, callback, parameters?.Timeout);
}
}
return result.Result;
}));
}
public void SendExchange(ExchangeTypes ext, bool withAck, QsoSequencer.MessageSent ms)
{
qsoQueue.SendExchange(qso, ext, withAck, ms);
}
public static string GetLinkByExchangeType(string kind)
{
return(ExchangeTypes.Get(kind) == ExchangeTypes.EXCHANGETYPE_DIRECT ? LINK_EXCHANGE : LINK_QUEUE);
}
public static IServiceCollection AddMessageBusPublisher <T>(this IServiceCollection services, string exchangeName, string queueName, ExchangeTypes exchangeType, string routingKey = "", bool exclusive = false) where T : class => AddMessageBusPublisher <T>(services, new ExchangeConfiguration(exchangeType, exchangeName), new QueueConfiguration(queueName, exclusive, routingKey));
