/// <summary> /// Rebuild the factory /// </summary> protected override void RebuildFactory() { NetGraphBuilder builder = new NetGraphBuilder(); ClientEndpointFactory client = builder.AddClient("Client", Guid.NewGuid()); client.Hidden = true; ServerEndpointFactory server = builder.AddServer("Server", Guid.NewGuid()); server.Hidden = true; SwitchNodeFactory outputSwitch = CreateBaseGraph(builder, server, client, false); SwitchNodeFactory inputSwitch = CreateBaseGraph(builder, client, server, true); AddStates(builder, outputSwitch, inputSwitch, client, server); NetGraphFactory factory = builder.Factory; factory.Properties.Add(_metaName, _defaultState); if (_factory == null) { _factory = factory; } else { _factory.UpdateGraph(factory); } Dirty = true; }
/// <summary> /// Default constructor /// </summary> public NetGraphDocument() : base() { _nodes = new BaseNodeConfig[0]; _lines = new LineConfig[0]; _properties = new Dictionary<string, string>(); _factory = new NetGraphFactory(); _lockObject = new object(); }
/// <summary> /// Constructor /// </summary> /// <param name="filter">The filter which checks for a match</param> /// <param name="factory">The graph factory to create on match</param> /// <param name="layers">The binding layers for the graph</param> /// <param name="selectionPath">Selection path to act as a discriminator</param> /// <param name="isolatedGraph">Whether to isolate the graph, only sharing global meta</param> /// <param name="filterId">The ID of the filter</param> public LayerSectionFilter(IDataFrameFilter filter, NetGraphFactory factory, INetworkLayerFactory[] layers, string selectionPath, bool isolatedGraph, Guid filterId) { Filter = filter; Factory = factory; Layers = layers; SelectionPath = selectionPath; FilterId = filterId; IsolatedGraph = isolatedGraph; }
/// <summary> /// Default constructor /// </summary> public NetGraphDocument() : base() { _nodes = new BaseNodeConfig[0]; _lines = new LineConfig[0]; _properties = new Dictionary <string, string>(); _factory = new NetGraphFactory(); _lockObject = new object(); }
/// <summary> /// Convert a netgraph to a simple dot diagram /// </summary> /// <param name="netgraph">The netgraph to convert</param> /// <returns>The graph as a dot diagram</returns> public static string ToDot(NetGraphFactory netgraph) { StringBuilder builder = new StringBuilder(); builder.AppendFormat("digraph netgraph {{").AppendLine(); builder.AppendLine("rankdir=LR;"); foreach (var node in netgraph.Nodes.Select(n => n.Factory)) { List <string> attrs = new List <string>(); if (!String.IsNullOrWhiteSpace(node.Label)) { attrs.Add(String.Format("label=\"{0}\"", node.Label)); } if (node is ServerEndpointFactory) { attrs.Add("ordering=out"); attrs.Add("rank=min"); } else if (node is ClientEndpointFactory) { attrs.Add("ordering=in"); attrs.Add("rank=max"); } else { attrs.Add("shape=box"); } if (!node.Enabled) { attrs.Add("style=dotted"); } if (attrs.Count > 0) { builder.AppendFormat("{0} [{1}];", FormatId(node.Id), String.Join(",", attrs)).AppendLine(); } } foreach (var edge in netgraph.Lines) { builder.AppendFormat("{0} -> {1}", FormatId(edge.SourceNode), FormatId(edge.DestNode)); if (!String.IsNullOrWhiteSpace(edge.PathName)) { builder.AppendFormat(" [label=\"{0}\"]", edge.PathName); } builder.AppendLine(";"); } builder.AppendLine("}"); return(builder.ToString()); }
private void AddStates(NetGraphBuilder builder, SwitchNodeFactory outputSwitch, SwitchNodeFactory inputSwitch, BaseNodeFactory outputNode, BaseNodeFactory inputNode) { foreach (StateGraphEntry entry in _entries) { BaseNodeFactory currentInput = inputSwitch; BaseNodeFactory currentOutput = outputSwitch; NetGraphFactory graph = entry.Graph == null?NetGraphBuilder.CreateDefaultProxyGraph(entry.StateName) : entry.Graph.Factory; LayerSectionMasterNodeFactory masterNode = new LayerSectionMasterNodeFactory(String.Format("{0} {1}", entry.StateName, GetDirection(false)), Guid.NewGuid(), Guid.NewGuid()); masterNode.DefaultMode = LayerSectionNodeDefaultMode.PassFrame; masterNode.Direction = LayerSectionGraphDirection.ServerToClient; builder.AddNode(masterNode); builder.AddNode(masterNode.SlaveFactory); LayerSectionFilterFactory[] filters = new LayerSectionFilterFactory[1]; LayerSectionFilterFactory filter = new LayerSectionFilterFactory(); filter.GraphFactory = graph; filter.LayerFactories = entry.GetLayerFactories(); filter.SelectionPath = ""; filter.FilterFactory = DataFrameFilterFactory.CreateDummyFactory(); filter.IsolatedGraph = false; masterNode.LayerFactories = new LayerSectionFilterFactory[1] { filter }; masterNode.SlaveFactory.Hidden = true; builder.AddLine(outputSwitch, masterNode, entry.StateName); builder.AddLine(inputSwitch, masterNode.SlaveFactory, entry.StateName); if (entry.LogPackets) { currentOutput = AddLog(builder, entry, masterNode, false); currentInput = AddLog(builder, entry, masterNode.SlaveFactory, true); } else { currentOutput = masterNode; currentInput = masterNode.SlaveFactory; } builder.AddLine(currentOutput, outputNode, null); builder.AddLine(currentInput, inputNode, null); } }
/// <summary> /// Create the netgraph for a connection /// </summary> /// <param name="factory">The netgraph factory</param> /// <param name="meta">Current meta data</param> /// <param name="properties">Property bag</param> /// <returns>The created graph</returns> private NetGraph CreateNetGraph(NetGraphFactory factory, MetaDictionary meta, PropertyBag properties) { NetGraph g = factory == null?_factory.Create(_logger, null, _globalMeta, meta, properties) : factory.Create(_logger, null, _globalMeta, meta, properties); if (g != null) { g.LogPacketEvent += new EventHandler <LogPacketEventArgs>(log_AddLogPacket); g.EditPacketEvent += new EventHandler <EditPacketEventArgs>(edit_InputReceived); g.GraphShutdown += new EventHandler(graph_GraphShutdown); } return(g); }
/// <summary> /// /// </summary> protected virtual void RebuildFactory() { List <NetGraphFactory.GraphNodeEntry> graphNodes = new List <NetGraphFactory.GraphNodeEntry>(); List <NetGraphFactory.GraphLineEntry> graphLines = new List <NetGraphFactory.GraphLineEntry>(); HashSet <Guid> createdNodes = new HashSet <Guid>(); if (_factory == null) { _factory = new NetGraphFactory(); } if (_nodes != null) { foreach (BaseNodeConfig node in _nodes) { if (!createdNodes.Contains(node.Id)) { BaseNodeFactory factory = node.CreateFactory(); ILinkedNodeConfig linkedConfig = node as ILinkedNodeConfig; if ((linkedConfig != null) && (linkedConfig.LinkedNode != null)) { BaseNodeFactory linked = linkedConfig.CreateFactory(factory); createdNodes.Add(linkedConfig.LinkedNode.Id); graphNodes.Add(new NetGraphFactory.GraphNodeEntry(linked)); } graphNodes.Add(new NetGraphFactory.GraphNodeEntry(factory)); createdNodes.Add(node.Id); } } } if (_lines != null) { foreach (LineConfig line in _lines) { graphLines.Add(new NetGraphFactory.GraphLineEntry(line.SourceNode.Id, line.DestNode.Id, line.BiDirection, line.PathName, line.WeakPath)); } } _factory.Nodes = graphNodes.ToArray(); _factory.Lines = graphLines.ToArray(); foreach (KeyValuePair <string, string> pair in _properties) { _factory.Properties.Add(pair.Key, pair.Value); } }
/// <summary> /// Constructor /// </summary> /// <param name="logger">The logger</param> /// <param name="config">Configuration for the server</param> public FullHttpProxyServer(HttpProxyServerConfig config, Logger logger) : base(logger) { _config = config; NetGraphBuilder builder = new NetGraphBuilder(); ClientEndpointFactory client = builder.AddClient("Client", Guid.NewGuid()); ServerEndpointFactory server = builder.AddServer("Server", Guid.NewGuid()); DirectNodeFactory nop = builder.AddNode(new DirectNodeFactory("NOP", Guid.NewGuid())); builder.AddLines(client, nop, server, client); _factory = builder.Factory; }
/// <summary> /// Create the netgraph for a connection /// </summary> /// <param name="factory">The netgraph factory</param> /// <param name="meta">Current meta data</param> /// <param name="properties">Property bag</param> /// <returns>The created graph</returns> private NetGraph CreateNetGraph(NetGraphFactory factory, MetaDictionary meta, PropertyBag properties) { NetGraph g = factory == null?_factory.Create(_logger, null, _globalMeta, meta, properties) : factory.Create(_logger, null, _globalMeta, meta, properties); if (g != null) { g.LogPacketEvent += new EventHandler <LogPacketEventArgs>(log_AddLogPacket); g.EditPacketEvent += new EventHandler <EditPacketEventArgs>(edit_InputReceived); g.GraphShutdown += new EventHandler(graph_GraphShutdown); // Add service to provider g.ServiceProvider.RegisterService(typeof(ProxyNetworkService), this); g.ServiceProvider.RegisterService(typeof(CredentialsManagerService), _credentialManager); } return(g); }
/// <summary> /// Create the test graph container /// </summary> /// <param name="logger">The logger to use</param> /// <param name="globals">Global meta</param> /// <returns>The new test graph container</returns> public override TestDocument.TestGraphContainer CreateTestGraph(Utils.Logger logger, MetaDictionary globals) { NetGraphFactory factory = _document.Factory; ClientEndpointFactory[] clients = factory.GetNodes <ClientEndpointFactory>(); ServerEndpointFactory[] servers = factory.GetNodes <ServerEndpointFactory>(); if ((clients.Length == 0) || (servers.Length == 0)) { throw new ArgumentException("Graph must have a one client and one server endpoint to perform a test"); } Guid inputNode = _clientToServer ? clients[0].Id : servers[0].Id; Guid outputNode = _clientToServer ? servers[0].Id : clients[0].Id; NetGraph graph = factory.Create(logger, null, globals, new MetaDictionary(), new PropertyBag("Connection")); return(new TestDocument.TestGraphContainer(graph, graph.Nodes[inputNode], graph.Nodes[outputNode])); }
/// <summary> /// Constructor. /// </summary> /// <param name="listener"></param> /// <param name="factory"></param> /// <param name="logger"></param> /// <param name="globalMeta"></param> /// <param name="proxyServer"></param> /// <param name="proxyClient"></param> /// <param name="filters"></param> /// <param name="defaultTimeout"></param> /// <param name="afterdata"></param> public ProxyNetworkService(INetworkListener listener, NetGraphFactory factory, Logger logger, MetaDictionary globalMeta, ProxyServer proxyServer, ProxyClient proxyClient, ProxyFilter[] filters, int defaultTimeout, bool afterdata) { _packetLog = new List <LogPacket>(1000); _logger = logger; Listener = listener; _factory = factory; _connections = new List <ConnectionEntry>(); _globalMeta = globalMeta; _history = new List <ConnectionHistoryEntry>(); _subServices = new List <ProxyNetworkService>(); DefaultBinding = NetworkLayerBinding.Default; _proxyClient = proxyClient; _proxyServer = proxyServer; _filters = filters; _defaultTimeout = defaultTimeout; _afterData = afterdata; }
/// <summary> /// Constructor /// </summary> /// <param name="name">Name of the factory</param> /// <param name="factory">Factory</param> /// <param name="direction">Direction of graph</param> /// <param name="containerGraph">The parent graph</param> /// <param name="logger">The logger to use</param> /// <param name="stateDictionary">Forwarded state dictionary</param> /// <param name="linked">If true then we are creating a linked master node</param> public NetGraphContainerNode(string name, NetGraphFactory factory, GraphDirection direction, NetGraph containerGraph, Logger logger, Dictionary<string, object> stateDictionary, bool linked) { var clients = factory.GetNodes<ClientEndpointFactory>(); var servers = factory.GetNodes<ServerEndpointFactory>(); if ((clients.Length > 0) && (servers.Length > 0)) { Guid outputNode = direction == GraphDirection.ClientToServer ? servers[0].Id : clients[0].Id; Guid inputNode = direction == GraphDirection.ClientToServer ? clients[0].Id : servers[0].Id; if (linked) { _graph = factory.Create(name, logger, containerGraph, containerGraph.GlobalMeta, containerGraph.Meta, containerGraph.ConnectionProperties); } else { _graph = factory.CreateFiltered(name, logger, containerGraph, containerGraph.GlobalMeta, containerGraph.Meta, inputNode, containerGraph.ConnectionProperties, stateDictionary); } _graph.BindEndpoint(outputNode, new EventDataAdapter(this)); _inputNode = (PipelineEndpoint)_graph.Nodes[inputNode]; _inputNode.Hidden = true; _outputNode = (PipelineEndpoint)_graph.Nodes[outputNode]; _outputNode.Hidden = true; } else { throw new ArgumentException(CANAPE.Properties.Resources.NetGraphContainerNode_InvalidGraph); } }
/// <summary> /// Constructor /// </summary> /// <param name="name">Name of the factory</param> /// <param name="factory">Factory</param> /// <param name="direction">Direction of graph</param> /// <param name="containerGraph">The parent graph</param> /// <param name="logger">The logger to use</param> /// <param name="stateDictionary">Forwarded state dictionary</param> /// <param name="linked">If true then we are creating a linked master node</param> public NetGraphContainerNode(string name, NetGraphFactory factory, GraphDirection direction, NetGraph containerGraph, Logger logger, Dictionary <string, object> stateDictionary, bool linked) { var clients = factory.GetNodes <ClientEndpointFactory>(); var servers = factory.GetNodes <ServerEndpointFactory>(); if ((clients.Length > 0) && (servers.Length > 0)) { Guid outputNode = direction == GraphDirection.ClientToServer ? servers[0].Id : clients[0].Id; Guid inputNode = direction == GraphDirection.ClientToServer ? clients[0].Id : servers[0].Id; if (linked) { _graph = factory.Create(name, logger, containerGraph, containerGraph.GlobalMeta, containerGraph.Meta, containerGraph.ConnectionProperties); } else { _graph = factory.CreateFiltered(name, logger, containerGraph, containerGraph.GlobalMeta, containerGraph.Meta, inputNode, containerGraph.ConnectionProperties, stateDictionary); } _graph.BindEndpoint(outputNode, new EventDataAdapter(this)); _inputNode = (PipelineEndpoint)_graph.Nodes[inputNode]; _inputNode.Hidden = true; _outputNode = (PipelineEndpoint)_graph.Nodes[outputNode]; _outputNode.Hidden = true; } else { throw new ArgumentException(CANAPE.Properties.Resources.NetGraphContainerNode_InvalidGraph); } }
/// <summary> /// Constructor /// </summary> /// <param name="packetLog"></param> /// <param name="listener"></param> /// <param name="factory"></param> /// <param name="logger"></param> /// <param name="globalMeta"></param> /// <param name="history"></param> /// <param name="credentials"></param> /// <param name="proxyServer"></param> /// <param name="proxyClient"></param> /// <param name="filters"></param> /// <param name="defaultTimeout"></param> /// <param name="afterdata"></param> public ProxyNetworkService(IList <LogPacket> packetLog, INetworkListener listener, NetGraphFactory factory, Logger logger, MetaDictionary globalMeta, IList <ConnectionHistoryEntry> history, IDictionary <SecurityPrincipal, ICredentialObject> credentials, ProxyServer proxyServer, ProxyClient proxyClient, ProxyFilter[] filters, int defaultTimeout, bool afterdata) { _packetLog = packetLog; _logger = logger; Listener = listener; _factory = factory; _connections = new List <ConnectionEntry>(); _globalMeta = globalMeta; _history = history; _subServices = new List <ProxyNetworkService>(); DefaultBinding = NetworkLayerBinding.Default; _credentials = new Dictionary <SecurityPrincipal, ICredentialObject>(credentials); _credentialManager = new CredentialsManagerService(); _credentialManager.ResolveCredentials += _credentialManager_ResolveCredentials; _proxyClient = proxyClient; _proxyServer = proxyServer; _filters = filters; _defaultTimeout = defaultTimeout; _afterData = afterdata; }
/// <summary> /// Create the netgraph for a connection /// </summary> /// <param name="factory">The netgraph factory</param> /// <param name="meta">Current meta data</param> /// <param name="properties">Property bag</param> /// <returns>The created graph</returns> private NetGraph CreateNetGraph(NetGraphFactory factory, MetaDictionary meta, PropertyBag properties) { NetGraph g = factory == null ? _factory.Create(_logger, null, _globalMeta, meta, properties) : factory.Create(_logger, null, _globalMeta, meta, properties); if (g != null) { g.LogPacketEvent += new EventHandler<LogPacketEventArgs>(log_AddLogPacket); g.EditPacketEvent += new EventHandler<EditPacketEventArgs>(edit_InputReceived); g.GraphShutdown += new EventHandler(graph_GraphShutdown); // Add service to provider g.ServiceProvider.RegisterService(typeof(ProxyNetworkService), this); g.ServiceProvider.RegisterService(typeof(CredentialsManagerService), _credentialManager); } return g; }
/// <summary> /// Constructor /// </summary> /// <param name="guid"></param> /// <param name="label"></param> /// <param name="factory"></param> /// <param name="direction"></param> public NetGraphContainerNodeFactory(string label, Guid guid, NetGraphFactory factory, NetGraphContainerNode.GraphDirection direction) : base(label, guid) { Direction = direction; Factory = factory; }
/// <summary> /// Connect client /// </summary> /// <param name="baseAdapter"></param> /// <param name="connProperties"></param> /// <returns></returns> public NetGraph ConnectClient(IDataAdapter baseAdapter, PropertyBag connProperties) { IDataAdapter server = null; IDataAdapter client = null; ProxyToken token = null; NetGraph graph = null; NetGraph retGraph = null; MetaDictionary meta = new MetaDictionary(); PropertyBag properties = new PropertyBag("Properties"); try { properties.AddBag(connProperties); token = _proxyServer.Accept(baseAdapter, meta, _globalMeta, this); if (token != null) { token = FilterToken(token); if (token.Status == NetStatusCodes.Success) { ProxyClient proxyClient = token.Client ?? _proxyClient; if (token.Bind) { client = proxyClient.Bind(token, _logger, meta, _globalMeta, properties.AddBag("Client")); } else { client = proxyClient.Connect(token, _logger, meta, _globalMeta, properties.AddBag("Client")); } server = _proxyServer.Complete(token, meta, _globalMeta, this, client); if ((token.Status == NetStatusCodes.Success) && (client != null)) { NetGraphFactory factory = token.Graph != null ? token.Graph : _factory; token.PopulateBag(properties.AddBag("Token")); // Negotiate SSL or other bespoke encryption mechanisms if (token.Layers != null) { foreach (INetworkLayer layer in token.Layers) { layer.Negotiate(ref server, ref client, token, _logger, meta, _globalMeta, properties, DefaultBinding); } } var clients = factory.GetNodes <ClientEndpointFactory>(); var servers = factory.GetNodes <ServerEndpointFactory>(); if ((clients.Length > 0) && (servers.Length > 0)) { graph = CreateNetGraph(factory, meta, properties); graph.BindEndpoint(clients[0].Id, client); graph.BindEndpoint(servers[0].Id, server); if (token.NetworkDescription != null) { graph.NetworkDescription = token.NetworkDescription; } else { graph.NetworkDescription = String.Format("{0} <=> {1}", server.Description, client.Description); } PropertyBag networkService = properties.AddBag("NetworkService"); networkService.AddValue("ClientId", clients[0].Id); networkService.AddValue("ServerId", servers[0].Id); networkService.AddValue("ClientAdapter", client); networkService.AddValue("ServerAdapter", server); networkService.AddValue("Token", token); graph.Start(); OnNewConnection(graph); retGraph = graph; } else { _logger.LogError(CANAPE.Net.Properties.Resources.ProxyNetworkService_InvalidGraph); } } } else { _logger.LogVerbose(CANAPE.Net.Properties.Resources.ProxyNetworkService_ConnectionFiltered); server = _proxyServer.Complete(token, meta, _globalMeta, this, client); } } } catch (Exception ex) { _logger.LogException(ex); } finally { if (retGraph == null) { try { if (graph != null) { ((IDisposable)graph).Dispose(); } if (server != null) { server.Dispose(); } if (client != null) { client.Dispose(); } if (token != null) { token.Dispose(); } } catch (Exception ex) { Logger.SystemLogger.LogException(ex); } } } return(retGraph); }
/// <summary> /// Constructor /// </summary> public StateGraphDocument() { _entries = new List<StateGraphEntry>(); _factory = new NetGraphFactory(); _metaName = "REPLACE ME"; }
/// <summary> /// Constructor /// </summary> public StateGraphDocument() { _entries = new List <StateGraphEntry>(); _factory = new NetGraphFactory(); _metaName = "REPLACE ME"; }
/// <summary> /// /// </summary> protected virtual void RebuildFactory() { List<NetGraphFactory.GraphNodeEntry> graphNodes = new List<NetGraphFactory.GraphNodeEntry>(); List<NetGraphFactory.GraphLineEntry> graphLines = new List<NetGraphFactory.GraphLineEntry>(); HashSet<Guid> createdNodes = new HashSet<Guid>(); if (_factory == null) { _factory = new NetGraphFactory(); } if(_nodes != null) { foreach (BaseNodeConfig node in _nodes) { if (!createdNodes.Contains(node.Id)) { BaseNodeFactory factory = node.CreateFactory(); ILinkedNodeConfig linkedConfig = node as ILinkedNodeConfig; if ((linkedConfig != null) && (linkedConfig.LinkedNode != null)) { BaseNodeFactory linked = linkedConfig.CreateFactory(factory); createdNodes.Add(linkedConfig.LinkedNode.Id); graphNodes.Add(new NetGraphFactory.GraphNodeEntry(linked)); } graphNodes.Add(new NetGraphFactory.GraphNodeEntry(factory)); createdNodes.Add(node.Id); } } } if(_lines != null) { foreach (LineConfig line in _lines) { graphLines.Add(new NetGraphFactory.GraphLineEntry(line.SourceNode.Id, line.DestNode.Id, line.BiDirection, line.PathName, line.WeakPath)); } } _factory.Nodes = graphNodes.ToArray(); _factory.Lines = graphLines.ToArray(); foreach (KeyValuePair<string, string> pair in _properties) { _factory.Properties.Add(pair.Key, pair.Value); } }
/// <summary> /// Constructor /// </summary> /// <param name="packetLog"></param> /// <param name="listener"></param> /// <param name="factory"></param> /// <param name="logger"></param> /// <param name="globalMeta"></param> /// <param name="history"></param> /// <param name="credentials"></param> /// <param name="proxyServer"></param> /// <param name="proxyClient"></param> /// <param name="filters"></param> /// <param name="defaultTimeout"></param> /// <param name="afterdata"></param> public ProxyNetworkService(IList<LogPacket> packetLog, INetworkListener listener, NetGraphFactory factory, Logger logger, MetaDictionary globalMeta, IList<ConnectionHistoryEntry> history, IDictionary<SecurityPrincipal, ICredentialObject> credentials, ProxyServer proxyServer, ProxyClient proxyClient, ProxyFilter[] filters, int defaultTimeout, bool afterdata) { _packetLog = packetLog; _logger = logger; Listener = listener; _factory = factory; _connections = new List<ConnectionEntry>(); _globalMeta = globalMeta; _history = history; _subServices = new List<ProxyNetworkService>(); DefaultBinding = NetworkLayerBinding.Default; _credentials = new Dictionary<SecurityPrincipal, ICredentialObject>(credentials); _credentialManager = new CredentialsManagerService(); _credentialManager.ResolveCredentials += _credentialManager_ResolveCredentials; _proxyClient = proxyClient; _proxyServer = proxyServer; _filters = filters; _defaultTimeout = defaultTimeout; _afterData = afterdata; }
/// <summary> /// Constructor which takes an existing factory /// </summary> /// <param name="factory">The factory</param> public NetGraphBuilder(NetGraphFactory factory) { _graphFactory = factory; }