protected void Initialize()
{
RestService = MarketMakerRestServiceFactory.CreateMakerRestService(Url, "/oauth/token",
Authorization);
RestService.Authorize("admin", "admin");
WebSocketService = new SubscriptionFactory("wss://18.218.146.41:8990/websocket/v0", RestService.Token);
}
public void Send_Receive_Message()
{
using (IBus bus = new RabbitMQBus())
{
using (IChannelFactory <ITestContract> channelFactory = new MessageBus.Core.Proxy.ChannelFactory <ITestContract>(bus))
{
ISubscriptionFactory <ITestContract> subscriptionFactory = new SubscriptionFactory <ITestContract>(bus, c => c.SetReceiveSelfPublish());
string actual = "";
ManualResetEvent ev = new ManualResetEvent(false);
using (ISubscriptionSelector <ITestContract> selector = subscriptionFactory.Subscribe())
{
selector.Subscribe <string>(contract => contract.Foo, s =>
{
actual = s;
ev.Set();
});
ITestContract channel = channelFactory.CreateChannel();
channel.Foo("boo");
ev.WaitOne(TimeSpan.FromSeconds(5));
actual.Should().Be("boo");
}
}
}
}
public void Send_Receive_Message()
{
using (IBus bus = new RabbitMQBus())
{
using (IChannelFactory<ITestContract> channelFactory = new MessageBus.Core.Proxy.ChannelFactory<ITestContract>(bus))
{
ISubscriptionFactory<ITestContract> subscriptionFactory = new SubscriptionFactory<ITestContract>(bus, c => c.SetReceiveSelfPublish());
string actual = "";
ManualResetEvent ev = new ManualResetEvent(false);
using (ISubscriptionSelector<ITestContract> selector = subscriptionFactory.Subscribe())
{
selector.Subscribe<string>(contract => contract.Foo, s =>
{
actual = s;
ev.Set();
});
ITestContract channel = channelFactory.CreateChannel();
channel.Foo("boo");
ev.WaitOne(TimeSpan.FromSeconds(5));
actual.Should().Be("boo");
}
}
}
}
public void GetSubscriberForEvent_WhenNoSubscriptionStored_ReturnsNothing()
{
using var subscriptionFactory = new SubscriptionFactory();
var testEventSubscription = subscriptionFactory.GetSubscriberForEvent <TestEvent>();
Assert.IsNull(testEventSubscription, "testEventSubscription should be null");
}
public void Setup()
{
_logManager = Substitute.For <ILogManager>();
_blockTree = Substitute.For <IBlockTree>();
_txPool = Substitute.For <ITxPool>();
_receiptStorage = Substitute.For <IReceiptStorage>();
_filterStore = new FilterStore();
_jsonRpcDuplexClient = Substitute.For <IJsonRpcDuplexClient>();
_jsonSerializer = new EthereumJsonSerializer();
SubscriptionFactory subscriptionFactory = new SubscriptionFactory(
_logManager,
_blockTree,
_txPool,
_receiptStorage,
_filterStore);
_subscriptionManager = new SubscriptionManager(
subscriptionFactory,
_logManager);
_subscribeRpcModule = new SubscribeRpcModule(_subscriptionManager);
_subscribeRpcModule.Context = new JsonRpcContext(RpcEndpoint.WebSocket, _jsonRpcDuplexClient);
// block numbers matching filters in LogsSubscriptions with null arguments will be 33333-77777
BlockHeader fromBlock = Build.A.BlockHeader.WithNumber(33333).TestObject;
BlockHeader toBlock = Build.A.BlockHeader.WithNumber(77777).TestObject;
_blockTree.FindHeader(Arg.Any <BlockParameter>()).Returns(fromBlock);
_blockTree.FindHeader(Arg.Any <BlockParameter>(), true).Returns(toBlock);
}
public MaintananceHostedService(ILogger <MaintananceHostedService> logger, SubscriptionFactory subscriptionFactory)
{
_subscription = subscriptionFactory.Create();
_logger = logger;
_httpClient = new HttpClient();
_subscription.Add(_httpClient);
}
public AccountsHandler(ILogger <AccountsHandler> accountsHandlerLogger, ILogger <AccountSessionHandler> accountsLogger, SubscriptionFactory subscriptionFactory, IAccountsService accountsService, IChatsRepository chatsRepository)
{
this._accountsHandlerLogger = accountsHandlerLogger;
_accountsLogger = accountsLogger;
_subscriptionFactory = subscriptionFactory;
_accountsService = accountsService;
_chatsRepository = chatsRepository;
}
public void GetSubscriberForEvent_WhenSubscriptionStored_ReturnsSubscription()
{
var subscriptionFactory = new SubscriptionFactory();
var createdSubscription = subscriptionFactory.CreateSubscriberForEvent <TestEvent>();
var testEventSubscription = subscriptionFactory.GetSubscriberForEvent <TestEvent>();
Assert.AreSame(createdSubscription, testEventSubscription, "Subscription instances are not the same");
}
/// <summary>
/// Initialize Mitto with the given configuration
/// </summary>
/// <param name="pConfig"></param>
public static void Initialize(ConfigParams pConfig)
{
LoggingFactory.Initialize(pConfig.Logger);
SubscriptionFactory.Initialize();
RouterFactory.Initialize(pConfig.RouterProvider);
ConnectionFactory.Initialize(pConfig.ConnectionProvider);
MessagingFactory.Initialize(pConfig.MessageProvider, pConfig.MessageConverter, pConfig.MessageProcessor);
MessagingFactory.Provider.Load(pConfig.Assemblies);
}
public void ReactiveResourceConverter_SubscriptionFactory_Roundtrip_Parameterized_SubscriptionFactory()
{
var subscriptionFactory = new SubscriptionFactory(new Uri("test://uri"), Expression.Default(typeof(IAsyncReactiveQubscriptionFactory <int>)), null);
var serializer = new SerializationHelpers(new DataConverter[] { new ReactiveResourceConverter() });
var serialized = serializer.Serialize(subscriptionFactory);
var roundtripped = serializer.Deserialize <IAsyncReactiveSubscriptionFactoryDefinition>(serialized);
AssertEqual(subscriptionFactory, roundtripped);
Assert.IsTrue(roundtripped.IsParameterized);
}
public TelegramAccountsHandler(SubscriptionFactory subscriptionFactory, IChatsRepository chatsRepository, BotClientFactory botClientFactory, MessageFactory messageFactory, MessageSender messageSender)
{
_subscriptions = subscriptionFactory.Create();
_sessionChanges = new Subject <SessionData>();
_subscriptions.Add(_sessionChanges);
_chatsRepository = chatsRepository;
_botClientFactory = botClientFactory;
_messageFactory = messageFactory;
this._messageSender = messageSender;
}
public void CreateSubscription_SenderExist_ShouldUseCorrectSender()
{
var queueName = "126_queue";
var autoAck = false;
var model = new Mock <IModel>();
var factory = new SubscriptionFactory();
var subscription = factory.CreateSubscription(model.Object, queueName, autoAck);
Assert.AreEqual(subscription.AutoAck, autoAck);
Assert.AreEqual(subscription.QueueName, queueName);
Assert.AreEqual(subscription.Model, model.Object);
}
/// <summary>
/// Creates a new instance using the provided context and registers this instance for automatic discovery if needed.
/// </summary>
/// <param name="serviceContext"></param>
/// <param name="enableAutoDiscovery"></param>
/// <param name="brokerEventsManager"></param>
protected BrokerService(StatefulServiceContext serviceContext, bool enableAutoDiscovery = true, IBrokerEventsManager brokerEventsManager = null)
: base(serviceContext)
{
if (enableAutoDiscovery)
{
new BrokerServiceLocator(Context.ServiceName).RegisterAsync()
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
}
_brokerEventsManager = brokerEventsManager ?? new DefaultBrokerEventsManager();
_subscriptionFactory = new SubscriptionFactory(StateManager);
}
public string SubscribeToNewsletter(SubscriptionDTO subscriptionDTO)
{
if (SubscriptionRepository.Get(s => s.SubscriberEmail == subscriptionDTO.SubscriberEmail).Any(s => s.SubscriptionType == SubscriptionType.Newsletter))
{
throw new ApplicationValidationErrorsException(new List <string> {
Resources.AppMessages.Subscription_Exists
});
}
Subscription subscription = SubscriptionFactory.CreateSubscription(subscriptionDTO.SubscriberName, subscriptionDTO.SubscriberEmail, subscriptionDTO.IsConfirmed);
SubscriptionRepository.Insert(subscription);
SubscriptionRepository.UnitOfWork.Commit();
return(subscription.ConfirmationToken);
}
/// <summary>
/// Creates a new instance using the provided context and registers this instance for automatic discovery if needed.
/// </summary>
/// <param name="serviceContext"></param>
/// <param name="reliableStateManagerReplica"></param>
/// <param name="enableAutoDiscovery"></param>
/// <param name="brokerEvents"></param>
protected BrokerService(StatefulServiceContext serviceContext,
IReliableStateManagerReplica2 reliableStateManagerReplica, bool enableAutoDiscovery = true, IBrokerEventsManager brokerEvents = null, IProxyFactories proxyFactories = null)
: base(serviceContext, reliableStateManagerReplica)
{
if (enableAutoDiscovery)
{
new BrokerServiceLocator(Context.ServiceName).RegisterAsync()
.ConfigureAwait(false)
.GetAwaiter()
.GetResult();
}
_brokerEventsManager = brokerEvents ?? new DefaultBrokerEventsManager();
_subscriptionFactory = new SubscriptionFactory(StateManager);
_proxyFactories = proxyFactories ?? new ProxyFactories();
}
public void ReactiveResourceConverter_SubscriptionFactory_Roundtrip()
{
var subscriptionFactory = new SubscriptionFactory(new Uri("test://uri"), Expression.Default(typeof(object)), null);
var serializer = new SerializationHelpers(new DataConverter[] { new ReactiveResourceConverter() });
var serialized = serializer.Serialize(subscriptionFactory);
var roundtripped = serializer.Deserialize <IAsyncReactiveSubscriptionFactoryDefinition>(serialized);
AssertEqual(subscriptionFactory, roundtripped);
Assert.IsFalse(roundtripped.IsParameterized);
var unused = default(DateTimeOffset);
Assert.ThrowsException <NotImplementedException>(() => unused = roundtripped.DefinitionTime);
Assert.ThrowsException <NotImplementedException>(() => roundtripped.ToSubscriptionFactory());
Assert.ThrowsException <NotImplementedException>(() => roundtripped.ToSubscriptionFactory <object>());
}
public void GivenMultipleInstances_Check_ReturnsCorrectSubscriptionFromInstance()
{
var subscriptionFactory = new SubscriptionFactory();
var createdSubscription = subscriptionFactory.CreateSubscriberForEvent <TestEvent>();
using var newSubscriptionFactory = new SubscriptionFactory();
var newTestEventSubscription = newSubscriptionFactory.GetSubscriberForEvent <TestEvent>();
Assert.IsNull(newTestEventSubscription, "newTestEventSubscription should be null");
var newlyCreatedSubscription = newSubscriptionFactory.CreateSubscriberForEvent <TestEvent>();
var testEventSubscription = subscriptionFactory.GetSubscriberForEvent <TestEvent>();
Assert.AreSame(createdSubscription, testEventSubscription, "Subscription instances are not the same");
Assert.AreNotSame(createdSubscription, newlyCreatedSubscription, "Subscription instances should not be same");
}
static void Main(string[] args)
{
//similar Decorator
ASubscription subcription = new Occasional(new Electric(20, 3));
Console.WriteLine($"Subscription Rental Eur {subcription.Calculate()}");
//Factory from Model base for MVC
ASubscription subscriptionFromFactory = SubscriptionFactory.Create(new Library.Core.Models.Data()
{
Car = "Large",
Subscription = "Frequent",
Kilometers = 100,
Hours = 5
});
Console.WriteLine($"Subscription Rental from Factory Eur {subscriptionFromFactory.Calculate()}");
Console.ReadLine();
}
public void Send_Receive_CustomSerializationMessage()
{
using (IBus bus = new RabbitMQBus())
{
using (IChannelFactory <ITestContract> channelFactory = new MessageBus.Core.Proxy.ChannelFactory <ITestContract>(bus, c => c.UseJsonSerializerSettings(new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Auto
})))
{
ISubscriptionFactory <ITestContract> subscriptionFactory = new SubscriptionFactory <ITestContract>(bus);
Data actual = null;
ManualResetEvent ev = new ManualResetEvent(false);
Data data = new Data
{
Value = "boo"
};
using (ISubscriptionSelector <ITestContract> selector = subscriptionFactory.Subscribe(c => c.SetReceiveSelfPublish().UseJsonSerializerSettings(new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Auto
})))
{
selector.Subscribe <Data>(contract => contract.Foo, s =>
{
actual = s;
ev.Set();
});
ITestContract channel = channelFactory.CreateChannel();
channel.Foo(data);
ev.WaitOne(TimeSpan.FromSeconds(5));
actual.ShouldBeEquivalentTo(data);
}
}
}
}
public void Send_Receive_CustomSerializationMessage()
{
using (IBus bus = new RabbitMQBus())
{
using (IChannelFactory<ITestContract> channelFactory = new MessageBus.Core.Proxy.ChannelFactory<ITestContract>(bus, c => c.UseJsonSerializerSettings(new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Auto
})))
{
ISubscriptionFactory<ITestContract> subscriptionFactory = new SubscriptionFactory<ITestContract>(bus);
Data actual = null;
ManualResetEvent ev = new ManualResetEvent(false);
Data data = new Data
{
Value = "boo"
};
using (ISubscriptionSelector<ITestContract> selector = subscriptionFactory.Subscribe(c => c.SetReceiveSelfPublish().UseJsonSerializerSettings(new JsonSerializerSettings
{
TypeNameHandling = TypeNameHandling.Auto
})))
{
selector.Subscribe<Data>(contract => contract.Foo, s =>
{
actual = s;
ev.Set();
});
ITestContract channel = channelFactory.CreateChannel();
channel.Foo(data);
ev.WaitOne(TimeSpan.FromSeconds(5));
actual.ShouldBeEquivalentTo(data);
}
}
}
}
public void Execute()
{
var url = Properties.Settings.Default.RabbitMqUrl;
using (var connectionFactory = new DisposableConnectionFactory())
using (var connection = connectionFactory.Create(url))
using (var channel = connection.CreateModel())
using (var subscriptionFactory = new SubscriptionFactory())
using (var subscription = subscriptionFactory.Create(channel:channel,queueName:"TheUsableMessageQueue"))
{
foreach (var message in subscription.Messages)
{
var messageBody = message.BodyAsJson<UsableMessage>();
ProcessMessage(messageBody);
subscription.Ack(message);
}
}
}
static void Main(string[] args)
{
try
{
baseUrl = args.Length > 0 ? args[0] : null;
if (string.IsNullOrEmpty(baseUrl))
{
Console.WriteLine("String is null or empty");
return;
}
mmRestService = MarketMakerRestServiceFactory.CreateMakerRestService(baseUrl, "/oauth/token", authorization);
mmRestService.Authorize("admin", "admin");
var ws = new SubscriptionFactory("wss://18.218.146.41:8990/websocket/v0", mmRestService.Token);
// Receive instrument by ID
_instrument = mmRestService.GetInstrument(_algoId);
_originalBuyMargins = _instrument.PricerConfig.BuyMargins;
_originalSellMargins = _instrument.PricerConfig.SellMargins;
var tradeStatisticsSubs = ws.CreateTradingStatisticsSubscription();
// Subscribe for trade statistics
tradeStatisticsSubs.Subscribe(OnStatisticsMessage);
Console.ReadLine();
tradeStatisticsSubs.Unsubscribe(OnStatisticsMessage);
ws.Close();
Console.ReadLine();
/*
* Console.Clear();
* var menuItems = GetMenuItems();
* var options = GetMenuOptions();
* ShowOptions(menuItems, options);
* while (true)
* {
* Console.Write("Select option and press Enter:");
* var s = Console.ReadLine();
* if (string.IsNullOrWhiteSpace(s))
* s = " ";
* else
* s = s.ToLower();
* if (s.Contains("clear") || s.Contains("cls"))
* {
* Console.Clear();
* ShowOptions(menuItems, options);
* continue;
* }
* if (s.Contains("exit") || s.Contains("quit"))
* {
* return;
* }
* var option = GetChoice(options, s[0]);
* if (option == -1 || option >= menuItems.Length)
* {
* Console.WriteLine("Incorrect choice.");
* Console.WriteLine();
* ShowOptions(menuItems, options);
* continue;
* }
* try
* {
* Console.WriteLine($"('{menuItems[option].Item1}' was selected)");
* menuItems[option].Item2();
* }
* catch (Exception ex)
* {
* Console.WriteLine(ex.ToString());
* }
* }
*/
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
}
//响应微信平台推送消息
private void ResponseMsg(HttpContext httpContext, RequestParams requestParams)
{
BaseBLL weixin = null;
IFactory factory = null;
#region 通过微信类型生成对应的业务处理类
var application = new WApplicationInterfaceBLL(requestParams.LoggingSessionInfo);
var appEntitys = application.QueryByEntity(new WApplicationInterfaceEntity()
{
WeiXinID = requestParams.WeixinId
}, null);
if (appEntitys != null && appEntitys.Length > 0)
{
var entity = appEntitys.FirstOrDefault();
BaseService.WriteLogWeixin("通过微信类型生成对应的业务处理类");
BaseService.WriteLogWeixin("WeiXinTypeId(微信类型): " + entity.WeiXinTypeId);
switch (entity.WeiXinTypeId)
{
case WeiXinType.SUBSCRIPTION:
factory = new SubscriptionFactory();
weixin = factory.CreateWeiXin(httpContext, requestParams);
BaseService.WriteLogWeixin("订阅号");
break;
case WeiXinType.SERVICE:
factory = new ServiceFactory();
weixin = factory.CreateWeiXin(httpContext, requestParams);
BaseService.WriteLogWeixin("服务号");
break;
case WeiXinType.CERTIFICATION: //目前我们的客户一般是认证服务号，所以关注事件从这里查看
factory = new CertificationFactory();
weixin = factory.CreateWeiXin(httpContext, requestParams);
BaseService.WriteLogWeixin("认证服务号");
break;
case WeiXinType.SUBSCRIPTION_EXTEND:
BaseService.WriteLogWeixin("可扩展订阅号");
break;
case WeiXinType.SERVICE_EXTEND:
BaseService.WriteLogWeixin("可扩展服务号");
break;
case WeiXinType.CERTIFICATION_EXTEND:
BaseService.WriteLogWeixin("可扩展认证服务号");
break;
default:
factory = new SubscriptionFactory();
weixin = factory.CreateWeiXin(httpContext, requestParams);
BaseService.WriteLogWeixin("默认订阅号");
break;
}
}
#endregion
weixin.ResponseMsg();//根据消息类型，回应事件。有文本消息、图片消息、多客服、地理位置、事件
}
public AccountSessionHandler(SessionData sessionData, ILogger <AccountSessionHandler> logger, IChatsRepository chatsRepository, SubscriptionFactory subscriptionFactory)
{
_sessionData = sessionData;
_logger = logger;
_chatsRepository = chatsRepository;
_subscription = subscriptionFactory.Create();
_sessionSubject = new BehaviorSubject <SessionData>(sessionData);
_subscription.Add(_sessionSubject);
SessionChanges = _sessionSubject;
_cancelSubject = new Subject <Unit>();
_subscription.Add(_cancelSubject);
_supportedMessages = new Dictionary <string, Func <IObservable <Unit> > >(StringComparer.OrdinalIgnoreCase)
{
{ "/start", () => Observable.Empty <Unit>() },
{ "/stop", () => Observable.Empty <Unit>() },
{ "/help", () => ShowHelp() },
{ "/login", () => Login() },
{ "/username", () => RequestUsername() },
{ "/session", () => RequestSession() },
{ "/token", () => RequestAuthToken() },
{ "/cancel", () => Cancel() },
{ "/pause", () => StartPauseDialog() },
{ "/resume", () => Resume() },
{ "/mute", () => StartMuteDialog() },
{ "/unmute", () => Unmute() },
{ "/timezone", () => RequestTimezone() },
};
}
/// <summary>
/// Initialize Mitto with the default configuration
/// </summary>
public static void Initialize()
{
SubscriptionFactory.Initialize();
Initialize(new ConfigParams());
}
public ServiceBusMessageReceiver(SubscriptionFactory subscriptionFactory, ILog log, IServiceScopeFactory serviceScopeFactory)
{
_log = log;
_subscriptionFactory = subscriptionFactory;
_serviceScopeFactory = serviceScopeFactory;
}
public SpreadObserver(SubscriptionFactory subscriptions, AlgorithmInfo algo, AlgorithmInfo origQuotesAlgo)
{
OrigQuotesAlgo = origQuotesAlgo;
Algo = algo;
Subscriptions = subscriptions;
}
public CostEngine(SubscriptionFactory subscriptions, AlgorithmInfo algo) : this()
{
Subscriptions = subscriptions;
Algo = algo;
}
