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) { }