private void AsyncExtractFiles(INyxMessage message, INyxBorg nyxBorg)
{
if (message.Has("fileExtract"))
{
_logger.Warn("File extration is already in progress for message {0}.", message);
return;
}
message["fileExtract"] = "1";
var files = message.Elements.Where(s => s.Key.StartsWith("file_")).Select(s => s.Key).ToList();
message.Files.Clear();
var fullExtractPath = Path.Combine(_extractPath, nyxBorg.NodeId);
foreach (var file in files)
{
var path = Path.Combine(fullExtractPath, file.Substring(5));
_logger.Debug("Extracting file {0} to {1}", file, path);
try
{
Directory.CreateDirectory(Path.GetDirectoryName(path));
}
catch (Exception ex)
{
_logger.Error("Error creating directory for extraction.", ex);
}
File.WriteAllBytes(path, Convert.FromBase64String(message[file]));
message.Remove(file);
message.Files.Add(new NyxFile {
Name = file.Substring(5), Path = path, TransferType = GetType().Name
});
}
nyxBorg.SendMessage(message.AsInternal());
}
private void AsyncLoadToMessage(INyxMessage message, INyxBorg sender)
{
if (message.Has("fileTransfer"))
{
_logger.Warn("File serialization is already in progress for message {0}.", message);
return;
}
message["fileTransfer"] = "1";
foreach (var nyxFile in message.Files)
{
if (!File.Exists(nyxFile.Path))
{
break;
}
var filename = Path.GetFileName(nyxFile.Path);
_logger.Debug("Converting file for message transfer.");
var file = Convert.ToBase64String(File.ReadAllBytes(nyxFile.Path));
message[string.Format("file_{0}", filename)] = file;
try
{
if (nyxFile.DeleteOnTransfer)
{
File.Delete(nyxFile.Path);
}
}
catch (Exception ex)
{
_logger.Error("Error deleting file.", ex);
}
}
sender.SendMessage(message, true);
}
public ConnectionStatusViewModel(
INyxBorg borg,
IEnumerable <Lazy <IStatusViewModel> > models)
{
var borg1 = borg;
borg1.InMessageStream
.ObserveOnUI()
.SubscribeOn(ThreadPoolScheduler.Instance)
.Subscribe(m => TotalReceived++);
borg1.OutMessageStream
.ObserveOnUI()
.SubscribeOn(ThreadPoolScheduler.Instance)
.Subscribe(m => TotalSent++);
borg1.ConnectionStatusStream
.ObserveOnUI()
.SubscribeOn(ThreadPoolScheduler.Instance)
.Subscribe(m => Status = m.ToString());
NyxVersion = borg1.GetType().Assembly.GetName().Version.ToString();
StatusViewModels = models?.Select(m => m.Value).ToList() ?? new List <IStatusViewModel>();
}
public async void InitCore()
{
var splash = new Splash();
splash.Show();
var pluginDir = Path.Combine(Assembly.GetExecutingAssembly().AssemblyDirectory(), "plugins");
NyxBoot.With()
.NyxBorg()
.AndPlugins(pluginDir)
.Start(RxAppAutofacExtension.UseAutofacDependencyResolver);
IConfigManager config;
try
{
config = NyxBoot.Container.Resolve <IConfigManager>();
config.Setup(Path.Combine(GetType().Assembly.AssemblyDirectory(), "nyx.cfg"));
_borg = NyxBoot.Container.Resolve <INyxBorg>();
NyxBoot.Container.Resolve <ILogger <App> >();
_borg.HostApp = "enslaver";
}
catch (Exception ex)
{
MessageBox.Show("[Nyx] Error building container ...\n" + ex);
Shutdown();
return;
}
var shellViewModel = NyxBoot.Container.Resolve <IShellViewModel>();
MainWindow = new MainWindow {
Content = new ShellView(shellViewModel)
};
await Task.Delay(TimeSpan.FromSeconds(1.5));
splash.Close();
MainWindow.Show();
// Sets the default hub.
string hubAddress;
string hubPort;
if (_commandLineArgs.TryGetValue("c", out hubAddress))
{
config.Set("borg", "hubIp", hubAddress);
}
if (_commandLineArgs.TryGetValue("p", out hubPort))
{
int port;
if (int.TryParse(hubPort, out port))
{
config.Set("hub", "port", port);
}
}
await _borg.Start();
}
public bool ExtractFiles(INyxMessage message, INyxBorg nyxBorg)
{
if (message.Has("fileExtract"))
{
return(true);
}
_taskQueue.QueueTask(() => AsyncExtractFiles(message, nyxBorg));
return(false);
}
public bool TransferFiles(INyxMessage message, INyxBorg sender)
{
if (message.Has("fileTransfer"))
{
return(true);
}
_taskQueue.QueueTask(() => AsyncLoadToMessage(message, sender));
return(false);
}
public AutoConnectToHub(IEnumerable <INyxNode> nodes,
IConfigManager config,
ILogger <AutoConnectToHub> logger)
{
var nyxNodes = nodes as IList <INyxNode> ?? nodes.ToList();
_borg = nyxNodes.FirstOrDefault(e => e is INyxBorg) as INyxBorg;
_hub = nyxNodes.FirstOrDefault(e => e is INyxHub) as INyxHub;
_config = config;
_logger = logger;
ReloadConfig(null);
_logger.Info("Auto Discovery loaded.");
_cancelationToken = new CancellationTokenSource();
}
public TestControlsViewModel(
INyxBorg borg,
IConfigManager config
)
{
PingCommand = ReactiveCommand.Create <object, Unit>(_ =>
{
for (int i = 0; i < PingCount; i++)
{
borg.SendMessage(NyxMessage.Create("nyx", BasicHubAction.Ping, borg.NodeId));
}
return(Unit.Default);
});
SendActionCommand = ReactiveCommand.Create <object, Unit>(_ =>
{
borg.SendMessage(NyxMessage.Create(ActionTarget, ActionText, string.IsNullOrWhiteSpace(ActionSource) ? borg.NodeId : ActionSource));
return(Unit.Default);
});
ConnectCommand = ReactiveCommand.Create <object, Unit>(_ =>
{
borg.Connect(ConnectionIp);
return(Unit.Default);
});
_connectionIp = config.Get("borg_hubIp", "127.0.0.1");
config.WhenConfigChanges
.Throttle(TimeSpan.FromMilliseconds(200), ThreadPoolScheduler.Instance)
.Where(k => k.Keys.Contains("borg_hubIp"))
.Select(k => k.Sender.Get("borg_hubIp", "127.0.0.1"))
.DistinctUntilChanged()
.ObserveOnDispatcher()
.Subscribe(s => ConnectionIp = s);
borg.ConnectionStatusStream
.ObserveOnDispatcher()
.Subscribe(c =>
{
IsConnected = c.HasFlag(ConnectionStatus.Connected);
});
ValidActions = PluginManager.Instance
.GetExtensions()
.OfType <INyxMessageActions>()
.SelectMany(_ => _.SupportedActions).ToList();
}
public static NodeInfo BuildInfo(INyxBorg borg)
{
var hostEntry = Dns.GetHostEntry(string.Empty);
var ipv4 = hostEntry.AddressList.Where(ip => ip.AddressFamily == AddressFamily.InterNetwork).ToList();
var ipv6 = hostEntry.AddressList.Where(ip => ip.AddressFamily == AddressFamily.InterNetworkV6);
var ipA = string.Join(";", !ipv4.Any() ? ipv6.Select(ip => ip.ToString()) : ipv4.Select(ip => ip.ToString()));
var info = new NodeInfo
(
Dns.GetHostName(),
borg.NodeId,
borg.HostApp,
borg.SubscribersChannels,
DateTime.Now,
borg.HostMode,
ipA
);
return(info);
}
/// <summary>
/// Sends a simple message to the target.
/// </summary>
/// <param name="sender">The borg that sends.</param>
/// <param name="target">The target of the message.</param>
/// <param name="action">The message action.</param>
/// <param name="skip">Skips the message if hub offline</param>
/// <param name="timeout">Timeouts the message.</param>
/// <returns></returns>
public static IObservable <MessageStatus> SendMessage(this INyxBorg sender, string target, string action, bool skip = false, double?timeout = null)
{
return(NyxMessage.Create(target, action, sender.NodeId).SendMessage(sender, skip, timeout));
}
/// <summary>
/// Sends a dummy message to the hub.
/// </summary>
/// <param name="sender">The borg to send from</param>
/// <returns></returns>
public static IObservable <MessageStatus> SendDummyMessage(this INyxBorg sender)
{
return(NyxMessage.Create("nyx", "dummy", sender.NodeId).SendMessage(sender, true));
}
/// <summary>
/// Shorthand for sending a message.
/// </summary>
/// <param name="msg">Message to send.</param>
/// <param name="borg">Borg responsable to sending the message.</param>
/// <param name="skip">Skips the message if hub offline.</param>
/// <param name="timeout">If bigger than 0 or null, a TimeoutMessage operator is added.</param>
/// <returns>Returns the obsersavle to track message status.</returns>
public static IObservable <MessageStatus> SendMessage(this INyxMessage msg, INyxBorg borg, bool skip = false, double?timeout = null)
{
return(timeout.HasValue && timeout.Value > 0
? borg.SendMessage(msg, skip).TimeoutMessage(timeout.Value, msg)
: borg.SendMessage(msg, skip));
}
public NodeManager(IEnumerable <INyxNode> runningNodes,
ILogger <NodeManager> logger,
PluginManager pluginManager)
{
Current = this;
_logger = logger;
_pluginManager = pluginManager;
_tasker = new SerialAsyncTasker();
// Find the hub if its running in this app domain.
var nyxNodes = runningNodes as IList <INyxNode> ?? runningNodes.ToList();
_hub = nyxNodes.FirstOrDefault(n => n is INyxHub) as INyxHub;
_borg = nyxNodes.FirstOrDefault(n => n is INyxBorg) as INyxBorg;
if (_borg != null)
{
_computerInfo = new ComputerInfo();
}
_messageReceivedBorg = new Subject <INyxMessage>();
_messageReceivedHub = new Subject <INyxMessage>();
SupportedActions = _hub != null
? new[] { NodesInfo, NodesUpdateSubscribe, NodesPing, NodesPingStop }
: new[] { NodesInfoReport };
// Run the cleaner in a queue with a max of 5 items in the queue.
if (_borg != null)
{
_internalHubWatch = Observable.Create <bool>(o =>
{
var disposable = new CompositeDisposable();
var synlock = new object();
var hubOnline = false;
disposable.Add(_borg.ConnectionStatusStream
.DistinctUntilChanged()
.Subscribe(c =>
{
lock (synlock)
{
var tempState = c.HasFlag(ConnectionStatus.Online);
if (tempState == hubOnline)
{
return;
}
hubOnline = tempState;
o.OnNext(tempState);
}
}));
return(disposable);
}).Publish().RefCount();
_disposables.Add(_internalHubWatch
.Where(s => !s)
.ObserveOnPool()
.Subscribe(o =>
{
lock (NodesLock)
{
var removed = new List <NodeInfo>(_nodesInfo);
_nodesInfo.Clear();
_groups.NodesByGroup.Clear();
_nodesSubject.OnNext(new NodesChanges {
Removed = removed
});
_groupSubject.OnNext(GroupsInfo.Empty);
_logger.Debug("Removed all nodes. Hub is offline or we lost connection.");
}
}));
}
if (_hub == null)
{
return;
}
_disposables.Add(Observable.Interval(TimeSpan.FromMinutes(1)).ObserveOn(new OrderedTaskScheduler(5)).Subscribe(o =>
{
lock (NodesLock)
{
var removed = new List <NodeInfo>();
_nodesInfo.RemoveAll(ni =>
{
var res = DateTime.Now.Subtract(ni.TimeStamp).TotalSeconds > 140;
if (res)
{
removed.Add(ni);
}
return(res);
});
if (removed.Count == 0)
{
return;
}
_logger.Debug("Removed {0} dead nodes.", removed.Count);
foreach (var update in _pushUpdates)
{
SendNodesInfo(null, update, new List <NodeInfo>(), removed);
}
}
}));
}
public ConnectionStatusViewModel(INyxBorg borg) : this(borg, null)
{
}