public MainForm(IFormOpener formManager, IMainFormPresenter presenter, MainFormStyler mainFormStyler, IPubSub pubsub, IPropertiesRepository propertiesRepository)
{
InitializeComponent();
_mainFormStyler = mainFormStyler;
_pubsub = pubsub;
RenderTheme();
if (propertiesRepository.GetValue <bool>(Constants.AppProperties.UpdateSettings))
{
propertiesRepository.Upgrade();
propertiesRepository.SetValue(Constants.AppProperties.UpdateSettings, false);
propertiesRepository.Save();
}
_formManager = formManager;
presenter.InitializePresenter(new
{
MainForm = this,
PubSub = _pubsub
});
var selectedPath = propertiesRepository.GetValue <string>(Constants.AppProperties.SelectedPath);
if (!string.IsNullOrEmpty(selectedPath))
{
Presenter.PopulateTreeView(selectedPath);
}
_propertiesRepository = propertiesRepository;
}
/// <summary>
/// Publishes a message with a topic.
/// When used with publisher confirms the task completes when the publish is confirmed.
/// Task will throw an exception if the confirm is NACK'd or times out.
/// </summary>
/// <typeparam name="T">The message type</typeparam>
/// <param name="pubSub">The pubSub instance</param>
/// /// <param name="message">The message to publish</param>
/// <param name="topic">The topic string</param>
/// <param name="cancellationToken">The cancellation token</param>
/// <returns></returns>
public static Task PublishAsync <T>(this IPubSub pubSub, T message, string topic, CancellationToken cancellationToken = default)
{
Preconditions.CheckNotNull(pubSub, "pubSub");
Preconditions.CheckNotNull(topic, "topic");
return(pubSub.PublishAsync(message, c => c.WithTopic(topic), cancellationToken));
}
public static async Task <TResponse> RequestAsync <TRequest, TResponse>(this IPubSub pubsub, TRequest message, TimeSpan timeout, bool self = true)
{
var request = new Request <TRequest> {
Body = message, CorrelationId = Guid.NewGuid()
};
IDisposable subscription = null;
try
{
var receiveTask = new TaskCompletionSource <TResponse>(TaskCreationOptions.RunContinuationsAsynchronously);
subscription = pubsub.Subscribe <Response <TResponse> >(response =>
{
if (response.CorrelationId == request.CorrelationId)
{
receiveTask.SetResult(response.Body);
}
});
Task.Run(() => pubsub.Publish(request, self));
using (var cts = new CancellationTokenSource(timeout))
{
return(await receiveTask.Task.WithCancellation(cts.Token));
}
}
finally
{
subscription?.Dispose();
}
}
public GamblingConfigService(IConfigSeria serializer, IPubSub pubSub)
: base(FilePath, serializer, pubSub, changeKey)
{
AddParsedProp("currency.name", gs => gs.Currency.Name, ConfigParsers.String, ConfigPrinters.ToString);
AddParsedProp("currency.sign", gs => gs.Currency.Sign, ConfigParsers.String, ConfigPrinters.ToString);
AddParsedProp("minbet", gs => gs.MinBet, int.TryParse, ConfigPrinters.ToString, val => val >= 0);
AddParsedProp("maxbet", gs => gs.MaxBet, int.TryParse, ConfigPrinters.ToString, val => val >= 0);
AddParsedProp("gen.min", gs => gs.Generation.MinAmount, int.TryParse, ConfigPrinters.ToString, val => val >= 1);
AddParsedProp("gen.max", gs => gs.Generation.MaxAmount, int.TryParse, ConfigPrinters.ToString, val => val >= 1);
AddParsedProp("gen.cd", gs => gs.Generation.GenCooldown, int.TryParse, ConfigPrinters.ToString, val => val > 0);
AddParsedProp("gen.chance", gs => gs.Generation.Chance, decimal.TryParse, ConfigPrinters.ToString, val => val >= 0 && val <= 1);
AddParsedProp("gen.has_pw", gs => gs.Generation.HasPassword, bool.TryParse, ConfigPrinters.ToString);
AddParsedProp("bf.multi", gs => gs.BetFlip.Multiplier, decimal.TryParse, ConfigPrinters.ToString, val => val >= 1);
AddParsedProp("waifu.min_price", gs => gs.Waifu.MinPrice, int.TryParse, ConfigPrinters.ToString, val => val >= 0);
AddParsedProp("waifu.multi.reset", gs => gs.Waifu.Multipliers.WaifuReset, int.TryParse, ConfigPrinters.ToString, val => val >= 0);
AddParsedProp("waifu.multi.crush_claim", gs => gs.Waifu.Multipliers.CrushClaim, decimal.TryParse, ConfigPrinters.ToString, val => val >= 0);
AddParsedProp("waifu.multi.normal_claim", gs => gs.Waifu.Multipliers.NormalClaim, decimal.TryParse, ConfigPrinters.ToString, val => val > 0);
AddParsedProp("waifu.multi.divorce_value", gs => gs.Waifu.Multipliers.DivorceNewValue, decimal.TryParse, ConfigPrinters.ToString, val => val > 0);
AddParsedProp("waifu.multi.all_gifts", gs => gs.Waifu.Multipliers.AllGiftPrices, decimal.TryParse, ConfigPrinters.ToString, val => val > 0);
AddParsedProp("waifu.multi.gift_effect", gs => gs.Waifu.Multipliers.GiftEffect, decimal.TryParse, ConfigPrinters.ToString, val => val >= 0);
AddParsedProp("decay.percent", gs => gs.Decay.Percent, decimal.TryParse, ConfigPrinters.ToString, val => val >= 0 && val <= 1);
AddParsedProp("decay.maxdecay", gs => gs.Decay.MaxDecay, int.TryParse, ConfigPrinters.ToString, val => val >= 0);
AddParsedProp("decay.threshold", gs => gs.Decay.MinThreshold, int.TryParse, ConfigPrinters.ToString, val => val >= 0);
}
public When_autosubscribing_with_subscription_configuration_action()
{
pubSub = Substitute.For <IPubSub>();
bus = Substitute.For <IBus>();
bus.PubSub.Returns(pubSub);
var autoSubscriber = new AutoSubscriber(bus, "my_app")
{
ConfigureSubscriptionConfiguration =
c => c.WithAutoDelete()
.WithExpires(10)
.WithPrefetchCount(10)
.WithPriority(10)
};
pubSub.SubscribeAsync(
Arg.Is("MyActionTest"),
Arg.Any <Func <MessageA, CancellationToken, Task> >(),
Arg.Any <Action <ISubscriptionConfiguration> >()
)
.Returns(Task.FromResult(Substitute.For <ISubscriptionResult>()).ToAwaitableDisposable())
.AndDoes(a => capturedAction = (Action <ISubscriptionConfiguration>)a.Args()[2]);
autoSubscriber.Subscribe(new[] { typeof(MyConsumerWithAction) });
}
/// <summary>
/// Publishes a message.
/// </summary>
/// <typeparam name="T">The message type</typeparam>
/// <param name="pubSub">The pubSub instance</param>
/// <param name="message">The message to publish</param>
/// <param name="configure">
/// Fluent configuration e.g. x => x.WithTopic("*.brighton").WithPriority(2)
/// </param>
/// <param name="cancellationToken">The cancellation token</param>
public static void Publish <T>(this IPubSub pubSub, T message, Action <IPublishConfiguration> configure, CancellationToken cancellationToken = default)
{
Preconditions.CheckNotNull(pubSub, "pubSub");
pubSub.PublishAsync(message, configure, cancellationToken)
.GetAwaiter()
.GetResult();
}
public void InitializePresenter(dynamic context)
{
_context = context;
_view = (IPreferencesForm)context.PreferencesForm;
_view.Presenter = this;
_mainFormPresenter = (IMainFormPresenter)context.MainFormPresenter;
_pubsub = context.PubSub;
}
public PubSubCache(IPubSub pubSubProvider, string cacheInstanceKey = null)
{
this.pubSub = pubSubProvider;
this.memoryCacheInstance = new MemoryCache(this.pubSub.GetType().Name + (cacheInstanceKey ?? ""));
this.subscription = pubSub.CreateEmptySubscription();
this.filter = new InvalidationFilter();
this.subscription.OnMessage += filter.OnMessageReceived;
}
public override void InitializePresenter(dynamic context)
{
_view = (IQueryWindowControl)context.QueryWindowControl;
_view.Presenter = this;
_pubsub = context.PubSub;
_pubsub.Subscribe(this, Constants.SubscriptionTypes.THEME_CHANGE);
TabIndexReference = (int)context.TabIndexReference;
}
public GamesConfigService(IConfigSeria serializer, IPubSub pubSub)
: base(FilePath, serializer, pubSub, changeKey)
{
AddParsedProp("trivia.min_win_req", gs => gs.Trivia.MinimumWinReq, int.TryParse,
ConfigPrinters.ToString, val => val > 0);
AddParsedProp("trivia.currency_reward", gs => gs.Trivia.CurrencyReward, long.TryParse,
ConfigPrinters.ToString, val => val >= 0);
}
public ChatHub(IMessageService messageService, IClaimsService claimsService, ICacheService cacheService, IPubSub pubSub, INotificationService notificationService)
{
_messageService = messageService;
_claimsService = claimsService;
_cacheService = cacheService;
_pubSub = pubSub;
_notificationService = notificationService;
}
public StreamReaderAdapter(string source, IPubSub pubSub, IPrecentageCalculator precentageCalculator)
{
_reader = new StreamReader(source);
_source = source;
_pubSub = pubSub;
_precentageCalculator = precentageCalculator;
_prevProgress = -1;
}
public Socket(ISocketTransport transport, IPubSub pubSub, Channel channel, string topic, string id = null)
{
Transport = transport;
PubSub = pubSub;
Channel = channel;
Topic = topic;
Id = id;
_assigns = new ConcurrentDictionary<string, string>();
}
public void InitializePresenter(dynamic context)
{
_context = context;
_view = (IActionLogForm)context.ActionLogForm;
_view.Presenter = this;
_pubsub = context.PubSub;
_pubsub.Subscribe(this, Constants.SubscriptionTypes.THEME_CHANGE);
}
public BlacklistService(DbService db, IPubSub pubSub, IBotCredentials creds)
{
_db = db;
_pubSub = pubSub;
_creds = creds;
Reload(false);
_pubSub.Sub(blPubKey, OnReload);
}
public ReplicatedCache(IMemoryCache memoryCache, IPubSub pubSub)
{
Guard.NotNull(memoryCache, nameof(memoryCache));
Guard.NotNull(pubSub, nameof(pubSub));
this.memoryCache = memoryCache;
this.pubSub = pubSub;
this.pubSub.Subscribe(OnMessage);
}
public MessageHandler(Func <PunchyMessage, Task> onMessageAsync, IPubSub pubSub, ILogger logger,
SubscriberConfiguration configuration, string groupId)
{
this.onMessageAsync = onMessageAsync ?? throw new ArgumentNullException(nameof(onMessageAsync));
this.pubSub = pubSub ?? throw new ArgumentNullException(nameof(pubSub));
this.logger = logger ?? throw new ArgumentNullException(nameof(logger));
this.configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
this.groupId = groupId ?? throw new ArgumentNullException(nameof(groupId));
badMessageMaxLevels = configuration.LevelDelaysInSeconds.Length;
}
public StateFactory(IPubSub pubSub, IMemoryCache statesCache, IServiceProvider services)
{
Guard.NotNull(pubSub, nameof(pubSub));
Guard.NotNull(services, nameof(services));
Guard.NotNull(statesCache, nameof(statesCache));
this.pubSub = pubSub;
this.services = services;
this.statesCache = statesCache;
}
public void InitializePresenter(dynamic context)
{
_context = context;
_view = (IMainForm)context.MainForm;
_view.Presenter = this;
_pubsub = context.PubSub;
_pubsub.Subscribe(this, Constants.SubscriptionTypes.THEME_CHANGE);
InitializeTransactionCache();
}
public InvalidatingMemoryCache(IMemoryCache inner, IPubSub invalidator)
{
Guard.NotNull(inner, nameof(inner));
Guard.NotNull(invalidator, nameof(invalidator));
this.inner = inner;
this.invalidator = invalidator;
invalidator.Subscribe(ChannelName, inner.Remove);
}
public EventConsumerGrainManager(IEnumerable <IEventConsumer> consumers, IPubSub pubSub, IStateFactory factory)
{
Guard.NotNull(pubSub, nameof(pubSub));
Guard.NotNull(factory, nameof(factory));
Guard.NotNull(consumers, nameof(consumers));
this.pubSub = pubSub;
this.factory = factory;
this.consumers = consumers.ToList();
}
public UsersController(
IUserService userService,
IMapper mapper,
IOptions <AppSettings> appSettings,
IPubSub pubSub)
{
this.userService = userService;
this.mapper = mapper;
this.appSettings = appSettings.Value;
this.pubSub = pubSub;
}
public static IDisposable ReceiveAsync <TRequest, TResponse>(this IPubSub pubsub, Func <TRequest, Task <TResponse> > callback, bool self = true)
{
return(pubsub.Subscribe <Request <TRequest> >(async x =>
{
var response = await callback(x.Body);
pubsub.Publish(new Response <TResponse> {
CorrelationId = x.CorrelationId, Body = response
}, true);
}));
}
public DefaultRemoteActorChannel(IPubSub pubSub, TypeNameRegistry typeNameRegistry, JsonSerializerSettings serializerSettings = null)
{
Guard.NotNull(pubSub, nameof(pubSub));
Guard.NotNull(typeNameRegistry, nameof(typeNameRegistry));
this.pubSub = pubSub;
this.typeNameRegistry = typeNameRegistry;
serializer = JsonSerializer.Create(serializerSettings ?? new JsonSerializerSettings());
}
/// <summary>
/// Initialized an instance of <see cref="ConfigServiceBase{TSettings}"/>
/// </summary>
/// <param name="filePath">Path to the file where the settings are serialized/deserialized to and from</param>
/// <param name="serializer">Serializer which will be used</param>
/// <param name="pubSub">Pubsub implementation for signaling when settings are updated</param>
/// <param name="changeKey">Key used to signal changed event</param>
protected ConfigServiceBase(string filePath, IConfigSeria serializer, IPubSub pubSub,
TypedKey <TSettings> changeKey)
{
_filePath = filePath;
_serializer = serializer;
_pubSub = pubSub;
_changeKey = changeKey;
Load();
_pubSub.Sub(_changeKey, OnChangePublished);
}
public static DomainObject Create(IPubSub pubSub)
{
var domainObject = new DomainObject(
new ReplicatedCache(
new MemoryCache(Options.Create(new MemoryCacheOptions())),
pubSub,
Options.Create(new ReplicatedCacheOptions {
Enable = true
})));
return(domainObject);
}
public void Connect(IPEndPoint ipEndPoint, DelegateConnected connected_callback)
{
if (connected)
throw new ArgumentException("Connect already called");
else
{
connected = true;
client = new TcpTopicClientIAR(
ipEndPoint, connected_callback, completion_queue);
ThreadPool.QueueUserWorkItem(FlushProc);
}
}
/// <summary>
/// Publishes a message with a topic
/// </summary>
/// <param name="pubSub">The pubSub instance</param>
/// <param name="message">The message to publish</param>
/// <param name="messageType">The message type</param>
/// <param name="topic">The topic string</param>
/// <param name="cancellationToken">The cancellation token</param>
public static void Publish(
this IPubSub pubSub,
object message,
Type messageType,
string topic,
CancellationToken cancellationToken = default
)
{
Preconditions.CheckNotNull(pubSub, "pubSub");
pubSub.Publish(message, messageType, c => c.WithTopic(topic), cancellationToken);
}
public static async Task PublishBatchAsync <T>(
this IPubSub pubSub,
IEnumerable <T> messages,
Action <IPublishConfiguration> configuration,
CancellationToken cancellationToken = default
)
{
foreach (var message in messages)
{
await pubSub.PublishAsync(message, configuration, cancellationToken).ConfigureAwait(false);
}
}
public static async Task PublishBatchInParallelAsync <T>(
this IPubSub pubSub, IEnumerable <T> messages, CancellationToken cancellationToken = default
)
{
var publishTasks = new List <Task>();
foreach (var message in messages)
{
publishTasks.Add(pubSub.PublishAsync(message, cancellationToken));
}
await Task.WhenAll(publishTasks).ConfigureAwait(false);
}
public InvalidatingMemoryCache(IMemoryCache inner, IPubSub invalidator)
{
Guard.NotNull(inner, nameof(inner));
Guard.NotNull(invalidator, nameof(invalidator));
this.inner = inner;
this.invalidator = invalidator;
subscription = invalidator.Subscribe <InvalidateMessage>(m =>
{
inner.Remove(m.CacheKey);
});
}
public WeatherForecastController(
ILogger <WeatherForecastController> logger,
IHttpContextAccessor httpContextAccessor,
ICacheService cacheService,
IHubContext <NotificationHub> notificationHub,
IPubSub pubSub)
{
_logger = logger;
_httpContextAccessor = httpContextAccessor;
_cacheService = cacheService;
_notificationHub = notificationHub;
_pubSub = pubSub;
}
public BaseSocketTransport(IPubSub pubSub, ISocketSerializer socketSerializer)
{
_pubSub = pubSub;
_socketSerializer = socketSerializer;
}
public TestTcpTopicClientIAR(IPEndPoint ipEndPoint, CompletionQueue completion_queue)
{
this.client = new TcpTopicClientIAR(ipEndPoint, Connected,
completion_queue);
}
public HomeController(IPubSub pubSub)
{
_pubSub = pubSub;
}
