protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
_notifyIcon = (TaskbarIcon)FindResource("NotifyIcon");
var container = TinyIoCContainer.Current;
RegisterServices(container);
UseRepositoryMonitor(container);
UseExplorerHandler(container);
_bus = new TinyMessageBus("RepoZ-ipc");
_bus.MessageReceived += Bus_MessageReceived;
_updateTimer = new Timer(CheckForUpdatesAsync, null, 5000, Timeout.Infinite);
// We noticed that the hotkey registration causes a high CPU utilization if the window was not shown before.
// To fix this, we need to make the window visible in EnsureWindowHandle() but we set the opacity to 0.0 to prevent flickering
var window = container.Resolve <MainWindow>();
EnsureWindowHandle(window);
_hotkey = new HotKey(47110815);
_hotkey.Register(window, HotKey.VK_R, HotKey.MOD_ALT | HotKey.MOD_CTRL, OnHotKeyPressed);
}
private static void WaitTillMessageGetsPublished(TinyMessageBus bus)
{
while (bus.MessagesPublished != 1)
{
Thread.Sleep(10);
}
}
public override bool Notify(ref PluginNotification notifyData)
{
switch (notifyData.Reason)
{
case Reason.DatabaseLoaded:
Workspace = notifyData.Workspace;
_tradeClient = new TinyMessageBus("trades");
_tradeClient.MessageReceived += _tradeClient_MessageReceived;
_tickClient = new TinyMessageBus("ticks");
_tickClient.MessageReceived += _tickClient_MessageReceived;
break;
case Reason.DatabaseUnloaded:
_tradeClient.Dispose();
_tickClient.Dispose();
break;
case Reason.RightMouseClick:
break;
default:
break;
}
return(true);
}
public async Task <bool> WaitMutex(bool force, IntPtr wParam, IntPtr lParam)
{
bool exist = !WaitMutexInternal(force);
if (exist)
{
string[] originalArgs = Environment.GetCommandLineArgs();
string[] args = new string[originalArgs.Length - 1];
if (args.Length > 0)
{
args = originalArgs.Skip(1).ToArray();
}
if (args.Length > 0)
{
await SendMessageStringUtf8("SendArgs",
string.Join(" || ", args))
.ConfigureAwait(true);
}
else
{
_ = WindowNative.PostMessage((IntPtr)WindowNative.HwndBroadcast,
SingleInstanceMessage, wParam, lParam);
}
}
else
{
InstanceBus = new TinyMessageBus($"Bus_{UniqueName}");
InstanceBus.MessageReceived += InstanceBus_MessageReceived;
}
return(!exist);
}
private static void SignalFirstInstance(string channelName, IList <string> commandLineArgs)
{
var bus = new TinyMessageBus(channelName);
var serializedArgs = commandLineArgs.Serialize();
bus.PublishAsync(serializedArgs).Wait();
WaitTillMessageGetsPublished(bus);
}
public IPCHelper(string id, string targetId)
{
TargetID = targetId;
ID = id;
_messageBus = new TinyMessageBus("livewallpaper");
_messageBus.MessageReceived += _messageBus_MessageReceived;
}
private static void CreateRemoteService(ISingleInstance instance, string channelName)
{
messageBus = new TinyMessageBus(channelName);
messageBus.MessageReceived += (_, e) =>
{
instance.OnInstanceInvoked(e.Message.Deserialize <string[]>());
};
}
public static void Cleanup()
{
if (messageBus != null)
{
messageBus.Dispose();
messageBus = null;
}
if (singleMutex != null)
{
singleMutex.Close();
singleMutex = null;
}
}
public SingleInstanceApp(string uniqueName)
{
if (uniqueName == null)
{
throw new ArgumentNullException(nameof(uniqueName));
}
UniqueName = uniqueName;
LocalBus = new TinyMessageBus($"Bus_{uniqueName}");
Mutex = new Mutex(true, uniqueName);
SingleInstanceMessage = WindowNative.RegisterWindowMessage($"WM_{uniqueName}");
}
public static void messagingClient()
{
using (var messagebus1 = new TinyMessageBus("ExampleChannel"))
{
string[] args = Environment.GetCommandLineArgs();
foreach (var torrentFile in args)
{
if (!torrentFile.EndsWith(".exe")) //string message = @"X:\one.torrent";
{
messagebus1.PublishAsync(Encoding.UTF8.GetBytes(torrentFile));
}
}
}
}
public static async Task <string> messagingServer()
{
using (var messagebus1 = new TinyMessageBus("ExampleChannel"))
{
var taskCompletition = new TaskCompletionSource <string>();
messagebus1.MessageReceived +=
(sender, e) =>
{
var ret = Encoding.UTF8.GetString(e.Message);
taskCompletition.TrySetResult(ret);
};
return(await taskCompletition.Task);
}
}
public async Task All_messages_should_be_processed_even_with_multiple_buses_in_a_complex_scenario()
{
var messagesPerRound = 32;
var firstRound = 16;
var secondRound = 16;
var total = firstRound + secondRound;
var rnd = new Random();
// Start up two chatty buses talking to each other
using (var messagebus1 = new TinyMessageBus("Example"))
using (var messagebus2 = new TinyMessageBus("Example"))
{
var buses = new[] { messagebus1, messagebus2 };
for (int i = 0; i < firstRound; i++)
{
var messages = Enumerable.Range(0, messagesPerRound).Select(_ => Guid.NewGuid().ToByteArray());
await buses[rnd.Next() % buses.Length].PublishAsync(messages);
}
// Add a new bus to the mix
using (var messagebus3 = new TinyMessageBus("Example"))
{
buses = new[] { messagebus1, messagebus2, messagebus3 };
for (int i = 0; i < secondRound; i++)
{
var messages = Enumerable.Range(0, messagesPerRound).Select(_ => Guid.NewGuid().ToByteArray());
await buses[rnd.Next() % buses.Length].PublishAsync(messages);
}
// Force a final read of all messages to work around timing issuees
await messagebus1.ReadAsync();
await messagebus2.ReadAsync();
await messagebus3.ReadAsync();
// Counters should check out
Assert.Equal(total * messagesPerRound - messagebus1.MessagesPublished, messagebus1.MessagesReceived);
Assert.Equal(total * messagesPerRound - messagebus2.MessagesPublished, messagebus2.MessagesReceived);
Assert.Equal(secondRound * messagesPerRound - messagebus3.MessagesPublished, messagebus3.MessagesReceived);
}
}
}
public async Task Messages_sent_from_one_bus_should_be_received_by_the_other()
{
using var messagebus1 = new TinyMessageBus("Example");
using var messagebus2 = new TinyMessageBus("Example");
var received = "nope";
messagebus2.MessageReceived += (sender, e) => received = Encoding.UTF8.GetString(e.Message);
await messagebus1.PublishAsync(Encoding.UTF8.GetBytes("lorem"));
await messagebus2.PublishAsync(Encoding.UTF8.GetBytes("ipsum"));
await messagebus1.PublishAsync(Encoding.UTF8.GetBytes("yes"));
await messagebus2.ReadAsync();
Assert.Equal("yes", received);
}
public void Messages_sent_from_one_bus_should_be_received_by_the_other()
{
using (var messagebus1 = new TinyMessageBus("Example"))
using (var messagebus2 = new TinyMessageBus("Example"))
{
var received = "nope";
messagebus2.MessageReceived += (sender, e) => received = Encoding.UTF8.GetString(e.Message);
messagebus1.PublishAsync(Encoding.UTF8.GetBytes("lorem"));
messagebus2.PublishAsync(Encoding.UTF8.GetBytes("ipsum"));
messagebus1.PublishAsync(Encoding.UTF8.GetBytes("yes"));
messagebus1.ProcessIncomingMessages();
messagebus2.ProcessIncomingMessages();
Assert.Equal("yes", received);
}
}
public static string messagingServer0()
{
using (var messagebus1 = new TinyMessageBus("ExampleChannel"))
{
string ret = null;
messagebus1.MessageReceived +=
(sender, e) => ret = Encoding.UTF8.GetString(e.Message);
while (true)
{
if (ret != null)
{
return(ret);
}
}
}
}
public void All_messages_should_be_processed_even_with_multiple_buses_in_a_complex_scenario()
{
var rnd = new Random();
// Start up two chatty buses talking to each other
using (var messagebus1 = new TinyMessageBus("Example"))
using (var messagebus2 = new TinyMessageBus("Example"))
{
var buses = new[] { messagebus1, messagebus2 };
for (int i = 0; i < 512; i++)
{
buses[rnd.Next() % buses.Length].PublishAsync(Guid.NewGuid().ToByteArray());
}
// Wait for all messages published so far to be processed so the counters will be predictable
messagebus1.WaitAll();
messagebus2.WaitAll();
// Add a new bus to the mix
using (var messagebus3 = new TinyMessageBus("Example"))
{
buses = new[] { messagebus1, messagebus2, messagebus3 };
for (int i = 0; i < 512; i++)
{
buses[rnd.Next() % buses.Length].PublishAsync(Guid.NewGuid().ToByteArray());
}
// Force a final read of all messages to work around timing issuees
messagebus1.ProcessIncomingMessages();
messagebus2.ProcessIncomingMessages();
messagebus3.ProcessIncomingMessages();
// Counters should check out
Assert.Equal(1024 - messagebus1.MessagesSent, messagebus1.MessagesReceived);
Assert.Equal(1024 - messagebus2.MessagesSent, messagebus2.MessagesReceived);
Assert.Equal(512 - messagebus3.MessagesSent, messagebus3.MessagesReceived);
}
}
}
protected override void OnStartup(StartupEventArgs e)
{
base.OnStartup(e);
_notifyIcon = (TaskbarIcon)FindResource("NotifyIcon");
var container = TinyIoCContainer.Current;
RegisterServices(container);
UseRepositoryMonitor(container);
UseExplorerHandler(container);
_bus = new TinyMessageBus("RepoZ-ipc");
_bus.MessageReceived += Bus_MessageReceived;
_updateTimer = new Timer(CheckForUpdatesAsync, null, 5000, Timeout.Infinite);
_hotkey = new HotKey(47110815);
_hotkey.Register(container.Resolve <MainWindow>(), HotKey.VK_R, HotKey.MOD_ALT | HotKey.MOD_CTRL, OnHotKeyPressed);
}
public static void Main(string[] args)
{
using (var messagebus1 = new TinyMessageBus("Example"))
using (var messagebus2 = new TinyMessageBus("Example"))
{
messagebus1.MessageReceived +=
(sender, e) => Console.WriteLine("Received: " + Encoding.UTF8.GetString(e.Message));
while (true)
{
var message = Console.ReadLine();
if (string.IsNullOrWhiteSpace(message))
{
return;
}
messagebus2.PublishAsync(Encoding.UTF8.GetBytes(message));
}
}
}
public async Task All_primitives_should_be_configurable()
{
var name = "Example";
var maxReaderCount = TinyReadWriteLock.DefaultMaxReaderCount;
var maxFileSize = TinyMemoryMappedFile.DefaultMaxFileSize;
var waitTimeout = TinyReadWriteLock.DefaultWaitTimeout;
// Create underlying primitives first so they can be configured
var lockMutex = TinyReadWriteLock.CreateMutex(name);
var lockSemaphore = TinyReadWriteLock.CreateSemaphore(name, maxReaderCount);
var memoryMappedFile = TinyMemoryMappedFile.CreateOrOpenMemoryMappedFile(name, maxFileSize);
var eventWaitHandle = TinyMemoryMappedFile.CreateEventWaitHandle(name);
// Create the actual message bus
var tinyReadWriteLock = new TinyReadWriteLock(lockMutex, lockSemaphore, maxReaderCount, waitTimeout);
var tinyMemoryMappedFile = new TinyMemoryMappedFile(memoryMappedFile, eventWaitHandle, maxFileSize, tinyReadWriteLock, disposeLock: true);
using var messageBus = new TinyMessageBus(tinyMemoryMappedFile, disposeFile: true);
await messageBus.PublishAsync(Encoding.UTF8.GetBytes("lorem"));
await messageBus.PublishAsync(Encoding.UTF8.GetBytes("ipsum"));
}
public static async Task Main(string[] args)
{
using var messagebus1 = new TinyMessageBus("Example");
using var messagebus2 = new TinyMessageBus("Example");
Console.WriteLine("Type something and press enter. Ctrl+C to quit.");
messagebus1.MessageReceived +=
(sender, e) => Console.WriteLine("Received: " + Encoding.UTF8.GetString(e.Message));
while (true)
{
var message = Console.ReadLine();
if (string.IsNullOrWhiteSpace(message))
{
return;
}
await messagebus2.PublishAsync(Encoding.UTF8.GetBytes(message));
}
}
static void Main(string[] args)
{
Console.OutputEncoding = Encoding.UTF8;
IMessage message = null;
args = PrepareArguments(args);
if (IsHelpRequested(args))
{
ShowHelp();
}
else
{
if (CommandLine.Parser.Default.ParseArguments(args, new CommandLineOptions(),
(v, o) => ParseCommandLineOptions(v, o, out message)))
{
if (message.HasRemoteCommand)
{
_bus = new TinyMessageBus("RepoZ-ipc");
_bus.MessageReceived += _bus_MessageReceived;
byte[] load = Encoding.UTF8.GetBytes(message.GetRemoteCommand());
_bus.PublishAsync(load);
var watch = Stopwatch.StartNew();
while (_answer == null && watch.ElapsedMilliseconds <= 3000)
{ /* ... wait ... */
}
if (_answer == null)
{
Console.WriteLine("RepoZ seems not to be running :(");
}
_bus?.Dispose();
if (_repos != null && _repos.Any())
{
WriteRepositories();
}
else
{
Console.WriteLine(_answer);
}
}
message?.Execute(_repos);
WriteHistory();
}
else
{
Console.WriteLine("Could not parse command line arguments.");
}
}
if (Debugger.IsAttached)
{
Console.ReadKey();
}
}
private static void CreateRemoteService(string channelName)
{
messageBus = new TinyMessageBus(channelName);
messageBus.MessageReceived += MessageBus_MessageReceived;
}
public EventPublisher()
{
_trades = new TinyMessageBus("trades");
_ticks = new TinyMessageBus("ticks");
}
