public void AddRoot(string ChildSegment, Engine_Path_Endpoint Child) { // Ensure the dictionary is built correctly ensure_dictionary_built(); // Does an endpoint already exist here? if (rootPathsDictionary.ContainsKey(ChildSegment)) { Engine_Path_Endpoint matchingEndpoint = rootPathsDictionary[ChildSegment]; RootPaths.Remove(matchingEndpoint); } rootPathsDictionary[ChildSegment] = Child; RootPaths.Add(Child); }
public void AddRoot(string ChildSegment, Engine_Path_Endpoint Child) { // Ensure the dictionary is built correctly ensure_dictionary_built(); // Does an endpoint already exist here? if (rootPathsDictionary.ContainsKey(ChildSegment)) { Engine_Path_Endpoint matchingEndpoint = rootPathsDictionary[ChildSegment]; RootPaths.Remove(matchingEndpoint); } rootPathsDictionary[ChildSegment] = Child; RootPaths.Add(Child); }
public void AddChild(string ChildSegment, Engine_Path_Endpoint Child) { // Ensure the collection exists if (Children == null) { Children = new List <Engine_Path_Endpoint>(); } // Ensure the dictionary is built correctly ensure_dictionary_built(); // Does an endpoint already exist here? if (childDictionary.ContainsKey(ChildSegment)) { Engine_Path_Endpoint matchingEndpoint = childDictionary[ChildSegment]; Children.Remove(matchingEndpoint); } childDictionary[ChildSegment] = Child; Children.Add(Child); }
/// <summary> Get the endpoint configuration, based on the requested path </summary> /// <param name="Paths"> Requested URL paths </param> /// <returns> Matched endpoint configuration, otherwise NULL </returns> public Engine_Path_Endpoint Get_Endpoint(List <string> Paths) { // Ensure the dictionary is built ensure_dictionary_built(); // Find a match by path if (rootPathsDictionary.ContainsKey(Paths[0])) { Engine_Path_Endpoint path = rootPathsDictionary[Paths[0]]; Paths.RemoveAt(0); do { // Did we find an endpoint? if (path.IsEndpoint) { return(path); } // Look to the next part of the path if (Paths.Count > 0) { if (!path.ContainsChildKey(Paths[0])) { return(null); } path = path.GetChild(Paths[0]); Paths.RemoveAt(0); } else { return(null); } } while (true); } return(null); }
private void recursively_write_all_endpoints( Engine_Path_Endpoint RootEndpoint , TextWriter Output , string Url ) { if (RootEndpoint.IsEndpoint) { // How many verbs are defined for this endpoint? List<Engine_VerbMapping> mappings = RootEndpoint.AllVerbMappings; if (mappings.Count == 1) { Output.WriteLine(" <tr>"); Output.WriteLine(" <td>" + Url + "</td>"); add_single_verb_mapping_in_table(mappings[0], Output); Output.WriteLine(" </tr>"); } else if (mappings.Count > 1) { Output.WriteLine(" <tr>"); Output.WriteLine(" <td rowspan=\"" + mappings.Count + "\">" + Url + "</td>"); add_single_verb_mapping_in_table(mappings[0], Output); Output.WriteLine(" </tr>"); for (int i = 1; i < mappings.Count; i++) { Output.WriteLine(" <tr>"); add_single_verb_mapping_in_table(mappings[i], Output); Output.WriteLine(" </tr>"); } } } else { foreach (Engine_Path_Endpoint childEndpoint in RootEndpoint.Children) { recursively_write_all_endpoints(childEndpoint, Output, Url + "/" + childEndpoint.Segment); } } }
public void AddChild(string ChildSegment, Engine_Path_Endpoint Child) { // Ensure the collection exists if (Children == null) Children = new List<Engine_Path_Endpoint>(); // Ensure the dictionary is built correctly ensure_dictionary_built(); // Does an endpoint already exist here? if (childDictionary.ContainsKey(ChildSegment)) { Engine_Path_Endpoint matchingEndpoint = childDictionary[ChildSegment]; Children.Remove(matchingEndpoint); } childDictionary[ChildSegment] = Child; Children.Add(Child); }
private static void engine_config_finalize_recurse_through_endpoints(Engine_Path_Endpoint pathEndpoint, Dictionary<string, Engine_Component> components, Dictionary<string, Engine_RestrictionRange> restrictionRanges) { // Handle this one first if (pathEndpoint.HasVerbMapping) { // Do the individual mappings engine_config_finalize_handle_single_mapping(pathEndpoint.GetMapping, components, restrictionRanges); engine_config_finalize_handle_single_mapping(pathEndpoint.PostMapping, components, restrictionRanges); engine_config_finalize_handle_single_mapping(pathEndpoint.PutMapping, components, restrictionRanges); engine_config_finalize_handle_single_mapping(pathEndpoint.DeleteMapping, components, restrictionRanges); } // Now, step through any children as well if ((pathEndpoint.Children != null) && (pathEndpoint.Children.Count > 0)) { foreach (Engine_Path_Endpoint childNode in pathEndpoint.Children) { engine_config_finalize_recurse_through_endpoints(childNode, components, restrictionRanges); } } }
private static void read_microservices_simple_endpoint_details(XmlReader ReaderXml, Engine_Path_Endpoint ParentSegment) { Engine_Path_Endpoint endpoint = new Engine_Path_Endpoint {IsEndpoint = true}; string componentid = String.Empty; string restrictionid = String.Empty; string method = String.Empty; bool enabled = true; Microservice_Endpoint_Protocol_Enum protocol = Microservice_Endpoint_Protocol_Enum.JSON; if (ReaderXml.MoveToAttribute("Segment")) endpoint.Segment = ReaderXml.Value.Trim(); if (ReaderXml.MoveToAttribute("ComponentID")) componentid = ReaderXml.Value.Trim(); if (ReaderXml.MoveToAttribute("Method")) method = ReaderXml.Value.Trim(); if (ReaderXml.MoveToAttribute("Enabled")) { if (String.Compare(ReaderXml.Value.Trim(), "false", StringComparison.OrdinalIgnoreCase) == 0) enabled = false; } if (ReaderXml.MoveToAttribute("RestrictionRangeID")) restrictionid = ReaderXml.Value.Trim(); if (ReaderXml.MoveToAttribute("Protocol")) { switch (ReaderXml.Value.Trim().ToUpper()) { case "JSON": protocol = Microservice_Endpoint_Protocol_Enum.JSON; break; case "JSON-P": protocol = Microservice_Endpoint_Protocol_Enum.JSON_P; break; case "PROTOBUF": protocol = Microservice_Endpoint_Protocol_Enum.PROTOBUF; break; case "SOAP": protocol = Microservice_Endpoint_Protocol_Enum.SOAP; break; case "XML": protocol = Microservice_Endpoint_Protocol_Enum.XML; break; case "TEXT": protocol = Microservice_Endpoint_Protocol_Enum.TEXT; break; default: protocol = Microservice_Endpoint_Protocol_Enum.JSON; break; } } ReaderXml.MoveToElement(); if ((componentid.Length > 0) && (endpoint.Segment.Length > 0) && (method.Length > 0)) { if (ParentSegment != null) { // Add this endpoint ParentSegment.AddChild(endpoint.Segment, endpoint); // Add the verb mapping defaulted to GET endpoint.GetMapping = new Engine_VerbMapping(method, enabled, protocol, Microservice_Endpoint_RequestType_Enum.GET, componentid, restrictionid); } } }
private static void read_microservices_details_mapping(XmlReader ReaderXml, Engine_Server_Configuration Config, Engine_Path_Endpoint ParentSegment ) { while (ReaderXml.Read()) { if (ReaderXml.NodeType == XmlNodeType.Element) { switch (ReaderXml.Name.ToLower()) { case "removeall": if (ParentSegment != null) { if (ParentSegment.Children != null) ParentSegment.Children.Clear(); } else { Config.RootPaths.Clear(); } break; case "path": if (ReaderXml.MoveToAttribute("Segment")) { Engine_Path_Endpoint path; string segment = ReaderXml.Value.Trim(); if (ParentSegment == null) { if (Config.ContainsRootKey(segment.ToLower())) path = Config.GetRoot(segment.ToLower()); else { path = new Engine_Path_Endpoint {Segment = segment}; Config.AddRoot(segment.ToLower(), path); } } else { if (ParentSegment.ContainsChildKey(segment.ToLower())) { path = ParentSegment.GetChild(segment.ToLower()); } else { path = new Engine_Path_Endpoint { Segment = segment }; ParentSegment.AddChild(path.Segment, path ); } } ReaderXml.MoveToElement(); XmlReader subTreeReader = ReaderXml.ReadSubtree(); subTreeReader.Read(); read_microservices_details_mapping(subTreeReader, Config, path); } break; case "complexendpoint": // Read the top-endpoint information, before getting to each verb mapping bool disabled_at_top = false; Engine_Path_Endpoint endpoint = new Engine_Path_Endpoint { IsEndpoint = true }; if (ReaderXml.MoveToAttribute("Segment")) endpoint.Segment = ReaderXml.Value.Trim(); if ((ReaderXml.MoveToAttribute("Enabled")) && (String.Compare(ReaderXml.Value.Trim(), "false", StringComparison.OrdinalIgnoreCase) == 0)) disabled_at_top = true; // Now, read what remains ReaderXml.MoveToElement(); XmlReader complexReader = ReaderXml.ReadSubtree(); complexReader.Read(); read_microservices_complex_endpoint_details(complexReader, endpoint, disabled_at_top); // If a verb was mapped and there was a valid segment, add this if ((!String.IsNullOrEmpty(endpoint.Segment)) && (endpoint.HasVerbMapping)) { if (ParentSegment != null) { // Add this endpoint ParentSegment.AddChild(endpoint.Segment, endpoint); } } break; case "endpoint": read_microservices_simple_endpoint_details(ReaderXml, ParentSegment); break; } } } }
private static void read_microservices_complex_endpoint_details(XmlReader ReaderXml, Engine_Path_Endpoint Endpoint, bool DisabledAtTop) { while (ReaderXml.Read()) { if (ReaderXml.NodeType == XmlNodeType.Element) { if (String.Compare(ReaderXml.Name, "verbmapping", StringComparison.OrdinalIgnoreCase) == 0) { // Ensure verb is indicated first if (ReaderXml.MoveToAttribute("Verb")) { Microservice_Endpoint_RequestType_Enum verb = Microservice_Endpoint_RequestType_Enum.ERROR; switch (ReaderXml.Value.Trim().ToUpper()) { case "DELETE": verb = Microservice_Endpoint_RequestType_Enum.DELETE; break; case "GET": verb = Microservice_Endpoint_RequestType_Enum.GET; break; case "POST": verb = Microservice_Endpoint_RequestType_Enum.POST; break; case "PUT": verb = Microservice_Endpoint_RequestType_Enum.PUT; break; } // If a valid verb found, continue if (verb != Microservice_Endpoint_RequestType_Enum.ERROR) { // Build the verb mapping Engine_VerbMapping verbMapping = new Engine_VerbMapping(null, !DisabledAtTop, Microservice_Endpoint_Protocol_Enum.JSON, verb); if (ReaderXml.MoveToAttribute("Method")) verbMapping.Method = ReaderXml.Value.Trim(); if ((!DisabledAtTop) && (ReaderXml.MoveToAttribute("Enabled")) && (String.Compare(ReaderXml.Value.Trim(), "false", StringComparison.OrdinalIgnoreCase) == 0)) verbMapping.Enabled = false; if (ReaderXml.MoveToAttribute("Protocol")) { switch (ReaderXml.Value.Trim().ToUpper()) { case "JSON": verbMapping.Protocol = Microservice_Endpoint_Protocol_Enum.JSON; break; case "JSON-P": verbMapping.Protocol = Microservice_Endpoint_Protocol_Enum.JSON_P; break; case "PROTOBUF": verbMapping.Protocol = Microservice_Endpoint_Protocol_Enum.PROTOBUF; break; case "SOAP": verbMapping.Protocol = Microservice_Endpoint_Protocol_Enum.SOAP; break; case "TEXT": verbMapping.Protocol = Microservice_Endpoint_Protocol_Enum.TEXT; break; case "XML": verbMapping.Protocol = Microservice_Endpoint_Protocol_Enum.XML; break; default: verbMapping.Protocol = Microservice_Endpoint_Protocol_Enum.JSON; break; } } // Get the mapping to componentid and restriction id if (ReaderXml.MoveToAttribute("ComponentID")) verbMapping.ComponentId = ReaderXml.Value.Trim(); if (ReaderXml.MoveToAttribute("RestrictionRangeID")) { verbMapping.RestrictionRangeSetId = ReaderXml.Value.Trim(); } // If valid, add to this endpoint if ((!String.IsNullOrEmpty(verbMapping.ComponentId)) && (!String.IsNullOrEmpty(verbMapping.Method))) { // Add the verb mapping to the right spot switch (verbMapping.RequestType) { case Microservice_Endpoint_RequestType_Enum.DELETE: Endpoint.DeleteMapping = verbMapping; break; case Microservice_Endpoint_RequestType_Enum.GET: Endpoint.GetMapping = verbMapping; break; case Microservice_Endpoint_RequestType_Enum.POST: Endpoint.PostMapping = verbMapping; break; case Microservice_Endpoint_RequestType_Enum.PUT: Endpoint.PutMapping = verbMapping; break; } } } } } } } }