public Topology.MPLS.Topology LoadMPLSTopology()
        {
            Topology.MPLS.Topology topology = new Topology.MPLS.Topology();

            foreach (var record in GetMPLSTopology())
            {
                var path = record.Values["p"].As <IPath>();

                Dictionary <long, string> nodeIPv4RouterIdentifiersByDatabaseId = new Dictionary <long, string>();
                Dictionary <long, string> nodePCCByDatabaseId = new Dictionary <long, string>();

                foreach (var node in path.Nodes)
                {
                    string ipv4RouterIdentifier = TryGetNodePropertyAsString(node, "IPv4_Router_Identifier");
                    string pcc = TryGetNodePropertyAsString(node, "PCC");

                    if (!string.IsNullOrWhiteSpace(ipv4RouterIdentifier))
                    {
                        nodeIPv4RouterIdentifiersByDatabaseId.Add(node.Id, ipv4RouterIdentifier);
                        nodePCCByDatabaseId.Add(node.Id, pcc);

                        Topology.Node.Node n = new Topology.Node.Node()
                        {
                            IPv4RouterIdentifier = TryGetNodePropertyAsString(node, "IPv4_Router_Identifier"),
                            PCC = pcc,
                            //NodeName = TryGetNodePropertyAsString(node, "Node_Name"),
                            FirstSeen = TryGetNodeProperty <long>(node, "First_Seen"),
                            //LastEvent = TryGetNodeProperty<long>(node, "Last_Event"),
                            OperationalStatus = true
                        };

                        n.IsPseudonode = false;
                        n.NodeCost     = 1;

                        topology.Update(n);
                    }
                }

                foreach (var lsp in path.Relationships)
                {
                    var symbolicPathName = TryGetRelPropertyAsString(lsp, "Symbolic_Path_Name");

                    if (symbolicPathName.Contains("/"))
                    {
                        var hierarchicalSymbolicPathName = symbolicPathName.Split("/".ToCharArray());

                        Topology.MPLS.HierarchicalLabelSwitchedPath.HierarchicalLabelSwitchedPath parent = new Topology.MPLS.HierarchicalLabelSwitchedPath.HierarchicalLabelSwitchedPath(hierarchicalSymbolicPathName[0])
                        {
                            IPv4TunnelSenderAddress   = nodeIPv4RouterIdentifiersByDatabaseId[lsp.StartNodeId],
                            IPv4TunnelEndpointAddress = nodeIPv4RouterIdentifiersByDatabaseId[lsp.EndNodeId]
                        };

                        topology.Update(parent);

                        Topology.MPLS.LabelSwitchedPath.LabelSwitchedPath child = new Topology.MPLS.LabelSwitchedPath.LabelSwitchedPath(parent.Id)
                        {
                            PCC = nodePCCByDatabaseId[lsp.StartNodeId], // Gets the PCC parameter from the StartNode instead of the LSP property, SHIFT PCEP listener is behind Docker Swarm NAT(PAT).
                            IPv4TunnelSenderAddress          = nodeIPv4RouterIdentifiersByDatabaseId[lsp.StartNodeId],
                            IPv4TunnelEndpointAddress        = nodeIPv4RouterIdentifiersByDatabaseId[lsp.EndNodeId],
                            SymbolicPathName                 = symbolicPathName,
                            TunnelIdentifier                 = TryGetRelPropertyAsString(lsp, "Tunnel_Identifier"),
                            ExtendedTunnelIdentifier         = TryGetRelPropertyAsString(lsp, "Extended_Tunnel_Identifier"),
                            ExtendedTunnelIdentifierTunnelId = TryGetRelPropertyAsString(lsp, "Extended_Tunnel_Identifier_tunnel_id"),
                            LspIdentifier     = TryGetRelPropertyAsString(lsp, "LSP_Identifier"),
                            ReservedBandwidth = TryGetRelProperty <long>(lsp, "Reserved_Bandwidth"),
                            Administrative    = TryGetRelProperty <bool>(lsp, "Administrative"),
                            Delegate          = TryGetRelProperty <bool>(lsp, "Delegate"),
                            Operational       = TryGetRelProperty <bool>(lsp, "Operational"),
                            Remove            = TryGetRelProperty <bool>(lsp, "Remove"),
                            Sync = TryGetRelProperty <bool>(lsp, "Sync"),
                            RecordRouteObject = TryGetRelPropertyAsArray <string>(lsp, "Record_Route_Object"),
                            FirstSeen         = TryGetRelProperty <long>(lsp, "First_Seen"),
                            LastEvent         = TryGetRelProperty <long>(lsp, "Last_Event")
                        };

                        topology.Update(child);
                    }
                    else
                    {
                        Topology.MPLS.LabelSwitchedPath.LabelSwitchedPath l = new Topology.MPLS.LabelSwitchedPath.LabelSwitchedPath(null)
                        {
                            PCC = TryGetRelPropertyAsString(lsp, "PCC"),
                            IPv4TunnelSenderAddress          = nodeIPv4RouterIdentifiersByDatabaseId[lsp.StartNodeId],
                            IPv4TunnelEndpointAddress        = nodeIPv4RouterIdentifiersByDatabaseId[lsp.EndNodeId],
                            SymbolicPathName                 = symbolicPathName,
                            TunnelIdentifier                 = TryGetRelPropertyAsString(lsp, "Tunnel_Identifier"),
                            ExtendedTunnelIdentifier         = TryGetRelPropertyAsString(lsp, "Extended_Tunnel_Identifier"),
                            ExtendedTunnelIdentifierTunnelId = TryGetRelPropertyAsString(lsp, "Extended_Tunnel_Identifier_tunnel_id"),
                            LspIdentifier     = TryGetRelPropertyAsString(lsp, "LSP_Identifier"),
                            ReservedBandwidth = TryGetRelProperty <long>(lsp, "Reserved_Bandwidth"),
                            Administrative    = TryGetRelProperty <bool>(lsp, "Administrative"),
                            Delegate          = TryGetRelProperty <bool>(lsp, "Delegate"),
                            Operational       = TryGetRelProperty <bool>(lsp, "Operational"),
                            Remove            = TryGetRelProperty <bool>(lsp, "Remove"),
                            Sync = TryGetRelProperty <bool>(lsp, "Sync"),
                            RecordRouteObject = TryGetRelPropertyAsArray <string>(lsp, "Record_Route_Object"),
                            FirstSeen         = TryGetRelProperty <long>(lsp, "First_Seen"),
                            LastEvent         = TryGetRelProperty <long>(lsp, "Last_Event")
                        };

                        topology.Update(l);
                    }
                }
            }

            return(topology);
        }
        public bool UpdateLabelSwitchedPath(Topology.MPLS.LabelSwitchedPath.LabelSwitchedPath LabelSwitchedPath)
        {
            // Fill PCC property if empty
            if (string.IsNullOrWhiteSpace(LabelSwitchedPath.PCC))
            {
                LabelSwitchedPath.PCC = LabelSwitchedPath.IPv4TunnelSenderAddress;
            }

            // Parse the template:
            var contents = File.ReadAllText(Path.Combine(AppDomain.CurrentDomain.BaseDirectory,
                                                         "Controller", "OpenDayLight", "Nitrogen", "Templates", "pcep-update-lsp-objects.odlt"));

            // Combine the model with the template to get content:
            var content = StaticStubbleRenderer.Render(contents, LabelSwitchedPath);


            var client = new RestClient();

            client.BaseUrl       = this.ControllerURI;
            client.Authenticator = new HttpBasicAuthenticator(this.ControllerUsername, this.ControllerPassword);

            var request = new RestRequest(Method.POST);

            request.AddParameter("application/xml", content, ParameterType.RequestBody);
            request.Resource = "restconf/operations/network-topology-pcep:update-lsp";

            IRestResponse response = client.Execute(request);



            if (response.StatusCode == System.Net.HttpStatusCode.OK)
            {
                var result = JObject.Parse(response.Content);

                JToken output;
                if (result.TryGetValue("output", out output))
                {
                    if (!output.HasValues)
                    {
                        Console.WriteLine("SUCCESS: PCC {0} --> Updated LSP {1}/{2}", LabelSwitchedPath.PCC, LabelSwitchedPath.ParentId, LabelSwitchedPath.SymbolicPathName);

                        return(true);
                    }
                    else
                    {
                        if (output["failure"] != null)
                        {
                            Console.WriteLine("FAILURE: PCC {0} --> {1}", LabelSwitchedPath.PCC, output["failure"].ToString());

                            if (output["error"] != null)
                            {
                                Console.WriteLine("ERROR: PCC {0} --> {1}", LabelSwitchedPath.PCC, output["error"].ToString());
                            }

                            return(false);
                        }
                        else
                        {
                            Console.WriteLine("FAILURE: PCC {0} --> UNKNOWN FAILURE", LabelSwitchedPath.PCC);

                            return(false);
                        }
                    }
                }
                else
                {
                    Console.WriteLine("FAILURE: PCC {0} --> UNKNOWN FAILURE", LabelSwitchedPath.PCC);

                    return(false);
                }
            }
            else
            {
                Console.WriteLine("FAILURE: PCC {0} --> ODL: REST FAILURE", LabelSwitchedPath.PCC);

                return(false);
            }
        }