Resources are grouped by feature or network entity.

You can create a socket interface for receiving asynchronous event notifications on the following objects, using the restNotifications-v2 namespace.

socketIO = SocketIO(serverURL, 8443,verify=False,headers= headers)
ns = socketIO.define(NSNotificationNamespace, '/restNotifications-v2')
            

Notification events:

• Add

• Remove

• Update

Dynamic topology acquisition Use the IS-IS, OSPF, and BGP-LS routing protocols to get real-time topology updates.

Label-switched path reporting Label edge routers (LERs) use PCEP reports to report PCC-controlled, PCC-delegated, and PCE-initiated LSPs to the NorthStar Controller. To provide dynamic path provisioning, every ingress LER must be configured as a Path Computation Client (PCC).

LSP provisioning Create LSPs using the NorthStar Controller or update LSPs delegated to the NorthStar Controller.

High availability (active/standby) The high availability (HA) implementation provides an active/standby solution, where the active node in the cluster runs the active NorthStar PCE, Toposerver, Path Computation, and REST components, and the standby nodes run those processes needed only to maintain database and BGP-LS connectivity unless the active node fails. HA is an optional, licensed, feature.

The NorthStar Controller is an active stateful PCE that utilizes PCEP to get LSP state for centralized control and optimization of network resources to compute network paths or routes based on a network graph and to apply computational constraints.

The figure shows the active stateful PCE architecture:

The PCE entity in the NorthStar Controller calculates paths in the network on behalf of the PCCs, which request path computation services. The PCCs receive and apply the paths in the network.  A PCC is a client application that requests the PCE perform path computations for the PCC external LSPs. The PCE can actively install and modify network paths based on user input using the GUI or by using input from the RESTful API northbound interface. The PCE provides these functions:

• On-line and off-line LSP path computation

• LSP reroute triggering when the network needs to be re-optimized

• LSP bandwidth modification when an application demands an increase in bandwidth

• Other LSP attributes modification, such as explicit route object (ERO), setup priority, and hold priority

The PCEP enables communication between a PCC and the NorthStar Controller to learn about the network and LSP path state, and to communicate with the PCCs.  Through the PCEP, every PCC informs the PCE server (NorthStar Controller), asynchronously, about the state of LSPs, including LSP operational state, admin state, and protection in-use events. PCEP functions include:

• LSP tunnel state synchronization between a PCC and a stateful PCE. When an active PCE connection is detected, a PCC synchronizes an LSP state with the PCE. The PCEP enables a fast and timely synchronization of the LSP state to the PCE.

• Delegation of control over LSP tunnels to a stateful PCE. An active stateful PCE controls one or more LSP attributes for computing paths, such as bandwidth, path (ERO), and priority (setup and hold). The PCEP enables such delegation of LSPs.

• Stateful PCE control of timing and sequence of path computations within and across PCEP sessions. An active stateful PCE modifies one or more LSP attributes, such as bandwidth, path (ERO), and priority (setup and hold). The PCEP communicates these new LSP attributes from the PCE to the PCC, after which the PCC re-signals the LSP in the specified path.

The NorthStar Controller is a software application running on a suitable third-party x86 hardware platform. The PCC runs in a new Junos OS daemon called the Path Computation Client Process (PCCD), which interacts with the PCE and with the Routing Protocol Process (RPD) through a Junos OS IPC mechanism. The figure shows the PCE, PCCD, and RPD interaction:

The stateless PCCD does not keep state information other than current outstanding requests, and does not remember established LSP state.

The PCCD requests the state after the response PCE responds and forwards the response to the RPD. Because the PCCD is stateless, the RPD needs to communicate only with the PCCD when the LSP is first created. After the RPD receives the results from the PCCD, the results are stored, including across RPD restarts, and the RPD does not need to communicate with the PCCD until the LSP is rerouted and the LSP configuration changes, or the LSP fails.

A TCP-based PCEP session connects a PCC to an external PCE. The PCC starts the PCEP session and stays connected to the PCE for the duration of the PCEP session.  During the PCEP session, the PCC requests LSP parameters from the stateful PCE. When receiving one or more LSP parameters from the PCE, the PCC re-signals the TE LSP.

LSP state update and provisioning depend on the TCP/PCEP connection state. After the PCEP session terminates, the underlying TCP connection is closed immediately and the PCC attempts to reestablish the PCEP session. If the TCP connection terminates due to connection or PCC failure, the NorthStar Controller waits approximately 60 seconds for PCC reconnection before removing the LSP state.

Juniper Networks Junos operating system integrates the PCC, permitting the NorthStar Controller to get the LSP state from a Juniper platform running a suitable Junos OS release, and third-party routers supporting RFC5440. NorthStar Controller peers with the network to get a global view of the network topology, typically using BGP-LS by importing the traffic engineering database (TED). Alternatively, it can also learn the network topology using OSPF/ISIS-TE. The combined visibility of the network topology and complete LSP state in the network permits the NorthStar Controller to provide optimized TE, which enables a diverse range of use cases such as diverse path computation, premium path computation, maintenance mode rerouting, bandwidth scheduling/calendaring, and bin packing or network defragmentation. The interface between the NorthStar Controller and one or more transport layer SDN controllers extends NorthStar Controller visibility into the transport layer and addresses multilayer coordination and optimization use cases.

The NorthStar Controller provides GUI and API interfaces for monitoring and managing controller resources.

This document focus on the NorthStar API.

The following documentation is available on the NorthStar Controller documentation page:

• Release Notes for NorthStar Controller

• NorthStar Controller Getting Started Guide

• NorthStar Controller User Guide

• Working with NorthStar RESTful APIs

Send a POST, PUT, GET, or DELETE request to the NorthStar server.

• The request is sent with a URL address, which identifies the resource for a specific tenant ID and topology ID, as applicable. Specify parameters in the URL, as supported by the endpoint.

• You must have previously authenticated with the NorthStar Controller and set your access token in the request header:

  Authorization: 'Bearer <accessToken>'

• Include required JSON-formatted data in the request body, as specified in the API reference. If data are passed with the request, specify the JSON content type in the request header:

  Content-Type: application/json

Example (GET request):

curl -H "Authorization: Bearer zRApShiOxoCcBiFGPRhISKAbaUACWQBRqMPmaq40/NU=" -H "Content-Type: application/json" northstar.example.net:8443/NorthStar/API/v2/tenant/1/topology/1/nodes

Example (POST request):

curl -X POST -H "Authorization: Bearer zRApShiOxoCcBiFGPRhISKAbaUACWQBRqMPmaq40/NU=" -H "Content-Type: application/json" -d '{"name":"testNode", "topologyIndex":"1", "topoObjectType":"node"}' northstar.example.net:8443/NorthStar/API/v2/tenant/1/topology/1/nodes

The server returns an HTTP return status and error message, if an error occurred. On a successful request, data associated with the endpoint is also returned in the response body, in JSON format.

In a command window, enter curl -v to see if the cURL command-line utility is installed on your system. cURL is installed by default on Mac and *nix systems. For Windows, you need to download the applicable version from https://curl.haxx.se/download.html and set your PATH environment variable so cURL can be executed from the command-line. For a description of cURL syntax and command-line options, enter man curl or see https://curl.haxx.se/docs/manpage.html.

You can now use cURL to send HTTP requests to the server. Before sending a request, you need to authenticate with the authentication server, as described in the Authentication section. Following authenticated, simply include the Bearer authentication code with subsequent requests.

This example to get the full topology shows how to send an HTTP GET request:

curl -H "Authorization: Bearer zRApShiOxoCcBiFGPRhISKAbaUACWQBRqMPmaq40/NU=" -H "Content-Type: application/json" northstar.example.net:8443/NorthStar/API/v2/tenant/1/topology/1
                

This example to set node name, index, and object type shows how to send an HTTP POST request:

curl -X POST -H "Authorization: Bearer zRApShiOxoCcBiFGPRhISKAbaUACWQBRqMPmaq40/NU=" -H "Content-Type: application/json" -d '{"name":"testNode", "topologyIndex":"1", "topoObjectType":"node"}' northstar.example.net:8443/NorthStar/API/v2/tenant/1/topology/1/nodes
                

Both examples specify the destination REST endpoint in the URL of the NorthStar server, identified by hostname and port number. Notice how the examples include the required authorization code previously returned by the authentication server: zRApShiOxoCcBiFGPRhISKAbaUACWQBRqMPmaq40/NU=.

A successful request returns an HTTP status code of 200 and an unsuccessful requests returns a non-200 status code with an error description.

The -H option defines the HTTP header sent with the request, which includes the authorization code, a JSON-formatted content type, and data associated with the POST request.

The -X option specifies a non-default request type, which is POST. The default request type is GET.

Numerous REST clients are available as browser add-ons, making it easy to sent HTTP requests by providing URL and request body and header formatting assistance, HTTP method selection, and better visualization of returned status and data.

Popular Chrome REST clients include Postman and Advanced REST Client.

RESTClient is available for Firefox.

You can also use the native Postman app, which can be downloaded at: https://www.getpostman.com/apps

https://www.juniper.net/documentation/en_US/junos15.1/topics/example/rest-api-explorer-example.html

All NorthStar API request data are JSON-formatted so it can be helpful to use a JSON viewer, whether to help find formatting errors in transmitted data or to help visualize data returned by the NorthStar server, using syntax highlighting and pretty-print formatting.

Your text editor and IDE likely have built-in or add-on support for viewing JSON data, and several online JSON viewers are available.

• https://<PCS_addr>:8443/NorthStar/API/v1/tenant/1/topology/1/status/pce

• https://<vRR_addr>:3000/rpc/get-system-information@format=json

• https://<PCS_addr>:8443/NorthStar/API/v2/tenant/1/topology/1/status/topologyAcquisition

• http://<vRR_addr>:3000/rpc/get-bgp-summary-information@format=json

• http://<vRR_addr>:3000/rpc/get-bgp-neighbor-information@format=json

• https://<PCS_addr>:8443/NorthStar/API/v2/tenant/1/topology/1/te-lsps

• https://<PCS_addr>:8443/NorthStar/API/v2/tenant/1/topology/1/nodes

To collect BGP-LS session state information,

mount the package:

root@vrr% /packages/mnt/jroute/mount.post /packages/mnt/jroute
root@vrr% ln -s /packages/mnt/jroute/web-api /var/chroot/rest-api
                

configure rest service:

set system services rest http port 3000
                

(optional) include Junos commands:

set system services rest http addresses <vrr address from ‘vmm ip vrr’>
set system services rest control allowed-sources <ip address of node making REST call>
set system services rest control connection-limit 100
                

Script arguments specify the information you want display and whether or not to enable Junos vRR for REST services (by default, the Junos vRR REST interface is not enabled):

• --host (default: 127.0.0.1) The address of NorthStar PCE.

• --user (default: none)

• --password (default: none)

• --vrr (default: none) – this is the address of the NorthStar vRR

• --vrrUser (default: root)

• --vrrPassword (default: Embe1mpls)

• --verbose (default: none)

To run the script, enter the following on the command line as an example:

python pce-health-statusv2.py --host 10.92.38.38 --vrr 10.92.38.39
                

S Health Report
Executed(Date & Time): Wed Jan 27 11:51:41 2016

Northstar PCE Status: PCE is up.
Northstar Topology Aquisition Status: Connected to NTAD: 11.105.199.2 port: 450

BGP neighbor Count: 5
BGP neighbor List:
------------------
Peer State
11.0.0.101 Established
11.0.0.102 Established
11.0.0.103 Established
11.0.0.104 Established
11.105.199.1 Established

PCEP session count: 5
PCEP Session List:
------------------
PCEP IP Node
11.0.0.101 0110.0000.0101
11.0.0.102 0110.0000.0102
11.0.0.103 0110.0000.0103
11.0.0.104 0110.0000.0104
11.0.0.105 0110.0000.0105

LSP Tunnel list Summary:
------------------------
Total LSP Count: 24
LSPs in opStatus Active: 23
LSPs in opStatus Down: 1

LSP Tunnel List:
----------------
lspName from-address to-address controlType opStatus
Always_Down_LSP 11.0.0.101 11.0.0.254 PCC Down
LP_101_103 11.0.0.101 11.0.0.103 Delegated Active
LSP_VMX101_VMX102 11.0.0.101 11.0.0.102 Delegated Active
LSP_VMX101_VMX103 11.0.0.101 11.0.0.103 Delegated Active
LSP_VMX101_VMX104 11.0.0.101 11.0.0.104 Delegated Active
NLP_101_103 11.0.0.101 11.0.0.103 Delegated Active
XX_101_103 11.0.0.101 11.0.0.103 Delegated Active
vmx101-vmx107-autobw1 11.0.0.101 11.0.0.107 Delegated Active
LSP_VMX102_VMX101 11.0.0.102 11.0.0.101 Delegated Active
LSP_VMX102_VMX103 11.0.0.102 11.0.0.103 Delegated Active
LSP_VMX102_VMX104 11.0.0.102 11.0.0.104 Delegated Active
LP_VMX103_VMX101 11.0.0.103 11.0.0.101 Delegated Active
LSP_VMX103_VMX101 11.0.0.103 11.0.0.101 Delegated Active
LSP_VMX103_VMX102 11.0.0.103 11.0.0.102 Delegated Active
LSP_VMX103_VMX104 11.0.0.103 11.0.0.104 Delegated Active
NLP_VMX103_VMX101 11.0.0.103 11.0.0.101 Delegated Active
XX_VMX103_VMX101 11.0.0.103 11.0.0.101 Delegated Active
LSP_VMX104_VMX101 11.0.0.104 11.0.0.101 Delegated Active
LSP_VMX104_VMX102 11.0.0.104 11.0.0.102 Delegated Active
LSP_VMX104_VMX103 11.0.0.104 11.0.0.103 Delegated Active
DiverseA-102-104 11.0.0.102 11.0.0.104 PCEInitiated Active
DiverseB-102-104 11.0.0.102 11.0.0.104 PCEInitiated Act
                

#!/usr/bin/env python
import functools
import requests
import time
import json
import re
# For parsing options
import argparse
parser = argparse.ArgumentParser(description="Monitor NorthStar Health")
parser.add_argument("--host", dest="host",help="specify the REST Server to connect to, default 127.0.0.1 ",default="127.0.0.1")
parser.add_argument("--user", dest="user",help="The username for REST authentication",default=None)
parser.add_argument("--password", dest="password",help="The password for REST authentication ",default=None)
parser.add_argument("--vrr", dest="vrr",help="IP address of BGP-LS Topology",default=None)
parser.add_argument("--vrrUser", dest="vrrUser",help="The username for REST VRR authentication",default='root')
parser.add_argument("--vrrPassword", dest="vrrPassword",help="The password for REST REST authentication",default='Embe1mpls')

parser.add_argument("-v", "--verbose", dest="verbose",action="store_true",help="be verbose")
options = parser.parse_args()

authHeaders=None

session=requests.Session()
if (None is not options.user) and (None is not options.password):

    x=session.request('POST', "https://{server}:8443/oauth2/token".format(server=options.host),
                      headers={'content-type':'application/json'},json={'grant_type':'password','username':options.user,'password':options.password},auth=(options.user,options.password))
    j=json.loads(x.text)
    authHeaders={'Authorization':"{token_type} {access_token}".format(**j)}

    # Base NS url for all the requests
    url="https://{server}:8443/NorthStar/API/v2/tenant/1/topology/1".format(server=options.host)

    #
    # Small helper to retrieve a key (or a list of key) in the form a/b/c
    #
    def getValue(obj, key, default=None):
      if isinstance(key, list):
          for k in key:
              v = getValue(obj, k)
              if v is not None:
                  return v
          return default
      for ki in re.split("[/|]",key):
          obj = obj.get(ki)
          if obj is None:
              return default
      if obj is not None:
        return obj
      return default

    print("\n")
    print("Northstar Health Report")
    print("Executed(Date & Time): " + time.strftime("%c"))
    print("\n")

    # Make a REST call to Northstar to get the PCE status
    # Put the returned data into a list with a json format
    # Parse the list for the status field

    pce_status_req = session.get(url+"/status/pce",headers=authHeaders)
    pce_status_list = pce_status_req.json()
    print("Northstar PCE Status: " + (pce_status_list['status']))

    # Make a REST call to Northstar to get Topo Acquisition status
    # Put the returned data into a list with a json format
    # Parse the list for the status field

    ntad_status = session.get(url+"/status/topologyAcquisition",headers=authHeaders)
    ntad_status_list = ntad_status.json()
    print("Northstar Topology Aquisition Status: " + ntad_status_list['status'])
    print("\n")

    # Make a REST call to the vRR with authentication header
    # Put the returned data into a list with a json format
    # parse the list for the BGP peer data & peer-state data fields
    # Print the neighbor count and list each neighbor & its session state
    if options.vrr is not None:
        vrr_status = session.get("http://{vrr}:3000/rpc/get-bgp-summary-information@format=json".format(vrr=options.vrr), auth=(options.vrrUser, options.vrrPassword))
        vrr_status_list = vrr_status.json()

        i = int(vrr_status_list['bgp-information'][0]['peer-count'][0]['data'])
        peer_count = (vrr_status_list['bgp-information'][0]['peer-count'][0]['data'])

        print("BGP neighbor Count: " + peer_count)
        print("BGP neighbor List:")
        print("------------------")
        print("  Peer                   State")

        for i in range (0, i):
            print("  " + (vrr_status_list['bgp-information'][0]['bgp-peer'][i]['peer-address'][0]['data']) + "\t\t" + (vrr_status_list['bgp-information'][0]['bgp-peer'][i]['peer-state'][0]['data']))
        print("\n")

    nodes_list=session.get(url+"/nodes",headers=authHeaders)
    nodes_json = nodes_list.json()
    # There is no filter server side, so we need to do it
    nodesWithPCEP = [x for x in nodes_json if ("protocols" in x) and ("PCEP" in x["protocols"])]
    print("PCEP session count: {:d}".format(len(nodesWithPCEP)))
    print("PCEP Session List:")
    print("------------------")
    print("  PCEP IP\tNode\n")
    for node in nodesWithPCEP:
        print("{}\t{}".format(getValue(node,"protocols/PCEP/pccAddress"),getValue(node,['hostName',"name"])))

    print("\n")

    # Summary of LSPs (total, Up, Down) & count each

    lsp_list_req = session.get(url+'/te-lsps',headers=authHeaders)
    lsp_list_all = lsp_list_req.json()
    lsp_list_json = json.dumps(lsp_list_all)

    lsp_list_down   = [x for x in lsp_list_all if x.get("operationalStatus") == "Down"]
    lsp_list_active = [x for x in lsp_list_all if x.get("operationalStatus") == "Active"]

    print("LSP Tunnel list Summary:")
    print("------------------------")
    print("  Total LSP Count: {:d}".format(len(lsp_list_all)))
    print("  LSPs in opStatus Active: {:d}".format(len(lsp_list_active)))
    print("  LSPs in opStatus Down: {:d}".format(len(lsp_list_down)))

    # List each LSP who is in opStatus down
    # formatting: get the longest name
    #
    def max(x,y):
        if y>x:
            return y
        return x

    width=functools.reduce(max,map(lambda x:len(x.get('name','')),lsp_list_all),0)

    print("\n")
    print("LSP Tunnel List:")
    print("----------------")
    print("   {name:{width}s}\tfrom-address\tto-address\tcontrolType\toperationalStatus".format(width=width,name='lspName'))
    print("\n")
    for l in lsp_list_all:
        print("   {name:{width}s}\t{from[address]}\t{to[address]}\t{controlType:12s}\t{operationalStatus}".format(width=width,**l))

            

• http://<serverURL>:8443/NorthStar/API/v2/tenant/1/topology/1/te-lsps

• http://<serverURL>:8443/NorthStar/API/v2/tenant/1/statistics/te-lsps/bulk

To run the script, enter the following on the command line:

python changeLSPBwFromStats.py
                

serverURL = 'northstar.example.net'
username = 'resUser'
password = 'restPassword'
                

We use the Python requests HTTP library and the json JSON encode and decode package to work with REST request/response body data. We also import sys, re, and numpy to help with computations on the LSP statistical data.

import requests,json,sys,re,numpy
                

As you saw in previous tutorials, the first step is to authenticate with the server to get an access token that you send with subsequent REST requests. For convenience, we use an authenticate function that constructs the authentication part of the request header, and call the function with the server address and our username and password credentials.

def authenticate(serverURL,username, password):
    payload = {'grant_type': 'password','username': username,'password': password}
    r = requests.post('https://'+serverURL + ':8443/oauth2/token',data=payload,verify=False,auth=(username, password))
    data =r.json()
    if "token_type" not in data or "access_token" not in data:
        sys.exit(1)
    return  {'Authorization': "{token_type} {access_token}".format(**data)}

auth_headers = authenticate(serverURL, username, password)
                

Because all REST data are JSON-formatted, we update the request header with the application/json content type.

auth_headers.update({"Content-Type":"application/json"})
                

Now we can look for LSPs that exceeded planned bandwidth utilization.

A GET request to the te-lsps endpoint returns a list of all LSPs and their properties. We iterate through the list and select LSPs whose controller property is NorthStar, building a dictionary of only NorthStar LSPs. For those LSPs, we also save the tunnel name, source IP address, and primary path type.

lspUrl="https://{}:8443/NorthStar/API/v2/tenant/1/topology/1/te-lsps".format(serverURL)
lsps =  requests.get(lspUrl,verify=False,headers=auth_headers).json()

controlledLSPs =  dict([("%s %s %s"%(x["from"]["address"],x["name"],x.get("pathType","primary")),x) for x in filter(lambda x : (x["controller"] == "NorthStar"),lsps)])
                

Now that we have a list of LSPs we are interested in, we do a bulk query of those LSPs to get their statistical data.

We set up the query request to get bandwidth utilization over the previous two days.

query= {
  "endTime": "now",
  "aggregation": "avg",
  "startTime": "now-2d",
  "interval": "1h",
  "lsp": [
  ],
  "counter": ["lsp_stats.bps"]
}
                

We now iterate over the previously created list of NorthStar LSPs and build a list of those LSPs to query in the bulk request, using the LSP server name and address.

for l in controlledLSPs.itervalues():
    query["lsp"].append({"name":l["name"],"node":{'address':l["from"]["address"]}})
                

We use the te-lsps/bulk endpoint to POST a request to multiple LSPs, and include the previously constructed query data and request header.

statUrl="https://{}:8443/NorthStar/API/v2/tenant/1/statistics/te-lsps/bulk".format(serverURL)
stats =  requests.post(statUrl,json=query,verify=False,headers=auth_headers).json()
                

In the response, we iterate throught the returned statistics for each LSP. Using name and IP address to index into the previously built list of controlled LSPs, controlledLSPs, for LSPs that include lspPlannedPathProperties and have bandwidth specified, we:

• Set the _planned:bwInt temporary variable to the planned bandwidth returned by the query: ["plannedProperties"]["bandwidth"].

• Set the _lsp_stats.bps temporary variable to the actual bandwidth utilization returned by the query: lsp_stats.bps.

• Calculate 90 percentile value of the actual bandwidth utilization.

for st in iter(stats.values()):
    key = "%s %s %s"%(nodeHostNames[st["id"]["node"]["hostName"]], st["id"]["name"],"primary")
    l = controlledLSPs.get(key)
    if not l:
        continue
    if "plannedProperties" not in l or "bandwidth" not in l["plannedProperties"]:
        continue
    l["_planned:bwInt"] =  getBWInteger(l["plannedProperties"]["bandwidth"])
    l["_lsp_stats.bps"] = st["lsp_stats.bps"]
    a = numpy.array(l["_lsp_stats.bps"])
    p =int( numpy.percentile(a, 90))
    cross=[ x for x in l["_lsp_stats.bps"] if x > l["_planned:bwInt"]]
    print("LSP %s : threshold crossed %d times, 90 percentile is %d"%(key,len(cross),p))

If the 90-percentile bandwidth utilization value is larger than the current planned bandwidth value, we add the LSP to a list of LSPs to be updated. We construct the update request for those LSPs from properties returned in the query, changing only the planned bandwidth value, ["plannedProperties"]["bandwidth"], to the newly computed 90th-percentile value.

lspsToUpdate = []
lspOperationalAttributes = "controlType initiator tunnelId liveProperties operationalStatus".split()
lspPlannedOperationalAttributes = "calculatedEro operationalStatus lastStatusString correlatedRROHopCount controllerStatus".split()
             
if p > l["_planned:bwInt"]:
    sp = dict([(x,l[x]) for x in iter(l.keys()) if (x[0] != '_'  and x not in lspOperationalAttributes) ])
    lsp["plannedProperties"] = dict([(x,l["plannedProperties"][x]) for x in iter(l["plannedProperties"].keys()) if (x[0] !='_'  and x not in  lspPlannedOperationalAttributes)])
    lsp["plannedProperties"]["bandwidth"] = p
    lspsToUpdate.append(lsp)
        
                

Finally, we POST the bulk update request again using the te-lsps/bulk endpoint, which includes the list of LSPs to update, lspsToUpdate, and the new planned bandwidth value.

lspUpdateUrl="https://{}:8443/NorthStar/API/v2/tenant/1/topology/1/te-lsps/bulk".format(serverURL)
stats =  requests.post(lspUpdateUrl,json=lspsToUpdate,verify=False,headers=auth_headers).json()
                

#!/usr/bin/env python
import requests, json, sys, re, numpy

serverURL = 'northstar.example.net'
username = 'resUser'
password = 'restPassword'

def getBWInteger(string):
    if not isinstance(string, str):
        return string
    parse = re.split('[mMgGbkK]', str)
    f = float(parse[0])
    if "M" in string or "m" in string or 'Mbps' in string:
        return int(f * 1000000)
    elif "G" in string or 'Gbps' in string or 'g' in string:
        return int(f * 1000000000)
    elif "K" in string or 'Kbps' in string or 'k' in string:
        return int(f * 1000)
    elif "bps" in string:
        return int(f)
    return int(f)

def authenticate(serverURL, username, password):
    payload = {'grant_type': 'password','username': username,'password': password}
    r = requests.post('https://'+serverURL + ':8443/oauth2/token',data=payload,verify=False,auth=(username, password))
    data =r.json()
    if "token_type" not in data or "access_token" not in data:
        print("Error: Invalid credentials")
        sys.exit(1)
    return  {'Authorization': "{token_type} {access_token}".format(**data)}

auth_headers = authenticate(serverURL, username, password)
auth_headers.update({"Content-Type":"application/json"})

lspUrl = "https://{}:8443/NorthStar/API/v2/tenant/1/topology/1/te-lsps".format(serverURL)
lsps =  requests.get(lspUrl, verify=False, headers=auth_headers).json()
print("NS Monitors %d LSP"%len(lsps))

controlledLSPs =  dict([("%s %s %s"%(x["from"]["address"], x["name"], x.get("pathType", "primary")), x) for x in lsps if x.get("controller") == "NorthStar"])
print("NS manages %d LSP: "%len(controlledLSPs))

nodeUrl = "https://{}:8443/NorthStar/API/v2/tenant/1/topology/1/nodes".format(serverURL)
nodes =  requests.get(nodeUrl, verify=False, headers=auth_headers).json()
nodeHostNames={ x["hostName"]: x["routerId"] for x in nodes if x.get("hostName")}

query= {
  "endTime": "now",
  "aggregation": "avg",
  "startTime": "now-2d",
  "interval": "1h",
  "lsp": [
  ],
  "counter": ["lsp_stats.bps"]
}

for l in iter(controlledLSPs.values()):
    query["lsp"].append({"name":l["name"],"node":{'address':l["from"]["address"]}})

statUrl="https://{}:8443/NorthStar/API/v2/tenant/1/statistics/te-lsps/bulk".format(serverURL)
stats =  requests.post(statUrl,json=query,verify=False,headers=auth_headers).json()

startTime = stats.pop("startTime")
lspsToUpdate = []
lspOperationalAttributes = "controlType initiator tunnelId liveProperties operationalStatus".split()
lspPlannedOperationalAttributes = "calculatedEro operationalStatus lastStatusString correlatedRROHopCount controllerStatus".split()

for st in iter(stats.values()):
    key = "%s %s %s"%(nodeHostNames[st["id"]["node"]["hostName"]], st["id"]["name"],"primary")
    l = controlledLSPs.get(key)
    if not l:
        continue
    if "plannedProperties" not in l or "bandwidth" not in l["plannedProperties"]:
        continue
    l["_planned:bwInt"] =  getBWInteger(l["plannedProperties"]["bandwidth"])
    l["_lsp_stats.bps"] = st["lsp_stats.bps"]
    a = numpy.array(l["_lsp_stats.bps"])
    p =int( numpy.percentile(a, 90))
    cross=[ x for x in l["_lsp_stats.bps"] if x > l["_planned:bwInt"]]
    print("LSP %s : threshold crossed %d times, 90 percentile is %d"%(key,len(cross),p))

    if p > l["_planned:bwInt"]:
        lsp = dict([(x,l[x]) for x in iter(l.keys()) if (x[0] != '_'  and x not in lspOperationalAttributes) ])
        lsp["plannedProperties"] = dict([(x,l["plannedProperties"][x]) for x in iter(l["plannedProperties"].keys()) if (x[0] !='_'  and x not in  lspPlannedOperationalAttributes)])
        lsp["plannedProperties"]["bandwidth"] = p
        lspsToUpdate.append(lsp)

if len(lspsToUpdate) > 0:
    print("updates %s"%(json.dumps(lspsToUpdate, sort_keys=True, indent=4, separators=(',', ': '))))

    lspUpdateUrl="https://{}:8443/NorthStar/API/v2/tenant/1/topology/1/te-lsps/bulk".format(serverURL)
    stats =  requests.post(lspUpdateUrl,json=lspsToUpdate,verify=False,headers=auth_headers).json()
    print("Updated %d lsps"%(len(stats)))


              
            

• https://<PCS_addr>:8443/NorthStar/API/v1/tenant/1/topology/1/nodes

• https://<PCS_addr>:8443/NorthStar/API/v1/tenant/1/topology/1/te-lsps/bulk

Script arguments specify the information you want to display and whether or not the Junos vRR is enabled for REST services.

• --host (default: 127.0.0.1) The address of Northstar PCE.

• --user (default: none)

• --password (default: none)

• --bandwidth (default: 0)

• --LSPs (default:1) The number of LSPs between two pairs of PCCs in the mesh.

• --verbose (default: none)

To run the script, enter in a command window, for example:

python createLspv2.py --host 10.92.38.38 --LSPs 5 --bandwidth 50m
                

NorthStar LSP Mesh Utility
Executed(Date & Time): Thu Jan 28 17:59:36 2016

PCEP session count: 4
PCEP Session List:
------------------
PCEP IP Node
11.0.0.103 vmx103-11
11.0.0.104 vmx104-11
11.0.0.105 vmx105-11
11.0.0.102 vmx102-11

Do you want to create a full mesh of LSPs between:
5x50m LSPs from vmx103-11 to vmx104-11
5x50m LSPs from vmx103-11 to vmx105-11
5x50m LSPs from vmx103-11 to vmx102-11
5x50m LSPs from vmx104-11 to vmx103-11
5x50m LSPs from vmx104-11 to vmx105-11
5x50m LSPs from vmx104-11 to vmx102-11
5x50m LSPs from vmx105-11 to vmx103-11
5x50m LSPs from vmx105-11 to vmx104-11
5x50m LSPs from vmx105-11 to vmx102-11
5x50m LSPs from vmx102-11 to vmx103-11
5x50m LSPs from vmx102-11 to vmx104-11
5x50m LSPs from vmx102-11 to vmx105-11

Confirm? [yes,no]:yes
Creating 5x50m LSPs from vmx103-11 to vmx104-11
..Created
Creating 5x50m LSPs from vmx103-11 to vmx105-11
..Created
Creating 5x50m LSPs from vmx103-11 to vmx102-11
..Created
Creating 5x50m LSPs from vmx104-11 to vmx103-11
..Created
Creating 5x50m LSPs from vmx104-11 to vmx105-11
..Created
Creating 5x50m LSPs from vmx104-11 to vmx102-11
..Created
Creating 5x50m LSPs from vmx105-11 to vmx103-11
..Created
Creating 5x50m LSPs from vmx105-11 to vmx104-11
..Created
Creating 5x50m LSPs from vmx105-11 to vmx102-11
..Created
Creating 5x50m LSPs from vmx102-11 to vmx103-11
..Created
Creating 5x50m LSPs from vmx102-11 to vmx104-11
..Created
Creating 5x50m LSPs from vmx102-11 to vmx105-11
..Created
Done
            

              #!/usr/bin/env python3
import requests
import time
import json
import re
import itertools
import sys

# For parsing options
import argparse
parser = argparse.ArgumentParser(description="Create a Full LSP Mesh")
parser.add_argument("--host", dest="host", help="specify the REST Server to connect to, default 127.0.0.1 ",default="127.0.0.1")
parser.add_argument("--user", dest="user", help="The username for REST authentication",default=None)
parser.add_argument("--password", dest="password", help="The password for REST authentication ",default=None)
parser.add_argument("--bandwidth", dest="bw", help="LSP Bandwidth",default="0")
parser.add_argument("--LSPs", dest="lspCount", type=int, help="Number of LSPs to create", default=1)
parser.add_argument("-v", "--verbose", dest="verbose", action="store_true", help="be verbose")
options = parser.parse_args()

authHeaders=None

session=requests.Session()
if (None is not options.user) and (None is not options.password):

    x=session.request('POST', "https://{server}:8443/oauth2/token".format(server=options.host), verify=False,headers={'content-type':'application/json'},json={'grant_type':'password','username':options.user,'password':options.password},auth=(options.user,options.password))
    j=json.loads(x.text)
    authHeaders={'Authorization':"{token_type} {access_token}".format(**j)}

# Base NS url for all the requests
url="https://{server}:8443/NorthStar/API/v2/tenant/1/topology/1".format(server=options.host)

#
# Small helper to retrieve a key (or a list of key) in the form a/b/c
#
def getValue(obj, key, default=None):
  if isinstance(key, list):
      for k in key:
          v=getValue(obj, k)
          if v is not None:
              return v
      return default
  for ki in re.split("[/|]",key):
      obj=obj.get(ki)
      if obj is None:
          return default
  if obj is not None:
    return obj
  return default

nodes_list=session.get(url+"/nodes",headers=authHeaders)
nodes_json = nodes_list.json()
# Only get nodes we can use, i.e : Only IP nodes, exclude pseudo node or node without protocol
nodes_json = [x for x in nodes_json if (x.get("layer",'IP') == 'IP') and not (x.get("pseudoNode",False)) and ('protocols' in x)]

# There is no filter server side, so we need to do it
nodesWithPCEP = {x['nodeIndex']:x for x in nodes_json if ("protocols" in x) and ("PCEP" in x["protocols"])}
#Full mesh of LSPs: create all permutations of nodes, then prune the one starting at non-pcep enable
nodeMap = {x['nodeIndex']:x for x in nodes_json}

print("PCEP session count: {:d}".format(len(nodesWithPCEP)))
print("PCEP Session List:")
print("------------------")
print("  PCEP IP\tNode\n")
for node in iter(nodesWithPCEP.values()):
    print("{}\t{}".format(node["protocols"]["PCEP"]["pccAddress"],getValue(node,['hostName',"name"])))

# real full mesh,
fullMesh = itertools.permutations(iter(nodeMap.keys()), 2)
# full mesh PCC <-> PCC
fullMesh = itertools.permutations(iter(nodesWithPCEP.keys()), 2)

def routerId(n):
    return getValue(n, ['protocols/ISIS/TERouterId', 'protocols/OSPF/TERouterId'])

lsps = []

print("Do you want to create a full mesh of LSPs  between:")
# permutation is a generator, we can only iterate once
for (ingress, egress) in filter(lambda x: x[0] in nodesWithPCEP, fullMesh):
    ingressIp = routerId(nodeMap[ingress])
    egressIp = routerId(nodeMap[egress])
    if not ingressIp or not egressIp:
        continue
    text = " {:d}x{:s}  LSP from  {:s} to {:s} ({:s} -> {:s})".format(options.lspCount, options.bw, getValue(nodeMap[ingress], ['hostName',"name"]), getValue(nodeMap[egress], ['hostName',"name"]), ingressIp, egressIp)
    print(text)
    lsps.append(("Creating "+text, [
        {'name' : 'AUTO_LSP_{:s}_{:s}_{:d}'.format(getValue(nodeMap[ingress],['hostName',"name"]),getValue(nodeMap[egress],['hostName',"name"]),x), "from":{"topoObjectType": "ipv4","address": ingressIp}, "to":{"topoObjectType":"ipv4","address": egressIp}, "plannedProperties": {"bandwidth": "{!s}".format(options.bw),"setupPriority": 7,"holdingPriority": 7}} for x in range(1,options.lspCount+1)]))

print("\nThis will create {:d} LSPs".format(options.lspCount*len(lsps)))

answer = None
valid = {"yes":True, "true" :True, "y":True, "n":False, "no":False, "false":False}
while answer is None:
    answer = valid.get(str(input("Confirm? [yes,no]:")).lower() ,None)
# one request per node, or collapse all the nodes in one (or more) request
per_node = True
if answer:
    if per_node:
        # create
        for (text, request) in lsps:
            print(text)
            response = session.post(url+"/te-lsps/bulk", headers=authHeaders,json=request)
            print("..Created")
    else:
        # create one big request list with all the nodes, 
        all_lsps = []
        for x in lsps:
           all_lsps.extend(x[1]) 
        # The NS REST API allows to provision LSPs in 1k chunk
        while all_lsps:
            lsps_bulk = all_lsps[0:1000]
            response = session.post(url+"/te-lsps/bulk", headers=authHeaders, json=lsps_bulk)
            print("..Created", len(lsps_bulk), "LSPs", "%r"%(response.text))
            all_lsps = all_lsps[1000:]
    print("Done")

            

This example addresses specific on-box implementation details using JET App. The application reuses the same Python library for basic REST API call handling with minor changes. The main Python file, northstard, implements a Junos daemon instead of using an off-box framework. The northstard file provides the middleware between a JET session and interaction with the NorthStar library:

The rationale for an on-box JET App is the ability to convey additional information using the NorthStar API and to complement communication that uses standard protocols, such as PCEP and BGP-LS. This enables new use cases for a solution framework, which includes a NorthStar and JET App combination deployed across Juniper devices:

The implementation is structured as daemonized JET App, using the same jsonpath, requests, urllib2, and NorthStar libraries and is depends on the Juniper development framework for JET Apps. You can develop the application using the JET environment Vagrant VM provided by Juniper engineering, which includes the Eclipse IDE and Junos Extension Toolkit (JET) plugins.

The JET Application is structured around three major components, in the form of Python scripts or libraries:

The main NorthStar Python library defines initialization, authentication and high-level CRUD (create. read, update and delete) interfaces:

• def __init__(self,**kvargs) Constructor that sets all generic variables

• def get_token(self) Issue NorthStar authentication request and get token

• def get_rest_op(self,path,params=None) Generic NorthStar API GET operation in the context of

• def post_rest_op(self,path,jsondata) Generic NorthStar API POST operation with Json data attribute

• def put_rest_op(self,path,jsondata) Generic NorthStar API PUT operation with Json data attribute

• def del_rest_op(self,path,jsondata) Generic NorthStar API DELETE operation with Json data attribute

These basic methods provide the foundation for additional methods for advanced data extraction and updates. The figure shows the library layered architecture, with the methods described below:

The northstard.py Python file is the main JET application file that interacts with specific events and JET sessions, instantiating NorthStar Python library objects. It is typically invoked in the Junos OS config as the representative file for the JET application and gathers input attributes from the router configuration for object instantiation.

The file has the following structural elements, which are described below.

• Argument Parsing and JET Session Handling Main Function

• Commit Notification Handling Session

• LSP Configuration Extraction

• NorthStar REST API Calls Driven by Routing Attributes in LSP Description

• NorthStar REST API Calls Driven by Routing Attributes in apply-macro

parser = argparse.ArgumentParser(prog=os.path.basename(__file__), description='Northstar JET application')
# Compulsory attributes identified with required=True
parser.add_argument("--northstar_address", nargs='?', help="Address of the Northstar server.", type=str, required=True)
parser.add_argument("--northstar_username", nargs='?', help="Northstar server username.", type=str, required=True)
parser.add_argument("--northstar_password", nargs='?', help="Northstar server password.", type=str, required=True)
parser.add_argument("--router_username", nargs='?', help="Router username.", type=str, required=True)
parser.add_argument("--router_password", nargs='?', help="Router password.", type=str, required=True)
parser.add_argument("--network_igp", nargs='?', help="IGP used in the network, used for data extraction from TED.", type=str, required=True)
# Optional attributes, inheriting default values otherwise
parser.add_argument("--northstar_grant_type", nargs='?', help="Authentication Grant method for Northstar server. (default: %(default)s)", type=str, default=NORTHSTAR_GRANT_TYPE)
parser.add_argument("--northstar_port", nargs='?', help="Port for Northstar server REST API. (default: %(default)s)", type=str, default=NORTHSTAR_PORT)
parser.add_argument("--northstar_tenant_id", nargs='?', help="Tenant Id used in Northstar server. (default: %(default)s)", type=str, default=NORTHSTAR_TENANT_ID)
parser.add_argument("--output", nargs='?', help="Traceoptions output file. (default: %(default)s)", type=str, default=DEFAULT_OUTPUT)
parser.add_argument("--log_level", nargs='?', help="Traceoptions logging level. (default: %(default)s)", type=str, default=DEFAULT_LOGGING)
                    

# Main threading Event
calling_thread_event = threading.Event()
global client
client = JetHandler()
evHandle = client.OpenNotificationSession(device="localhost",user=args.router_username,password=args.router_password, port=1883)

client.OpenRequestResponseSession(device="localhost",user=args.router_username,password=args.router_password,port=9090)
cutopic = evHandle.CreateConfigUpdateTopic()
logger.debug("Subscription for commit notifications")
evHandle.Subscribe(cutopic,handleCommitNotifications)
logger.debug("Thread waiting for the events")
calling_thread_event.wait()
# This part will never get executed unless an event is triggered by using calling_thread_event.set()
calling_thread_event.clear()
logger.debug("Thread finished")
# Unsubscribe events
evHandle.Unsubscribe()
logger.debug("Unsubscription for commit notifications")
client.CloseRequestResponseSession()
client.CloseNotificationSession()
                    

def handleCommitNotifications(message):
    logger.debug('Handling commit notifications for change: ' + str(message))
    try:
        if message['commit-patch']['configuration']['protocols']['mpls']:
            logger.debug("MPLS LSP config changes: " + str(message))
            extractLSPconfig()
    except:
        logger.debug("Config changes not applying to MPLS LSPs")
    return
                    

def extractLSPconfig():
    mgmt_handle = client.GetManagementService()
    conf_query = """
        <get-configuration>
        <configuration junos>
        <protocols> <mpls></mpls>
        </protocols>
        </configuration>
        </get-configuration>
        """
    op_command =
OperationCommand(conf_query,OperationFormatType.OPERATION_FORMAT_XML,OperationFormatType.OPERATION_FORMAT_JSON)
    result = mgmt_handle.ExecuteOpCommand(op_command)
    parsed_json = json.loads(result.response)
    [...]
                    

# Check and extract all descriptions from LSP configs using jsonpath
expr_description = "$..description"
# Obtain a list of available descriptions
lsp_descriptions = jsonpath.jsonpath(parsed_json,expr_description)
                    

# Check and extract all apply_macros from LSP configs using jsonpath
expr_apply_macro = "$..apply-macro"
# Obtain a list of available apply-macros
lsp_macros = jsonpath.jsonpath(parsed_json,expr_apply_macro)
                    

protocols mpls { label-switched-path <name> {
    description diversityGroup:<dg>;diversityLevel:<dl>;... [...] }}
                    

protocols mpls {
    label-switched-path <name> {
        apply-macro pce-routing-attributes {
            diversity-group "<value>";
            diversity-constraint "<site> | <link> | <srlg>";
            symmetry-group "<value>";
            routing-method "<adminWeight>"" | <delay> | <constant> | <distance> | <maxProtect>";
            max-delay "<value>";
            max-hop "<value>";
            max-cost "<value>";
                    

def UpdateLSPsInNorthStarUsingDescription(lsp_json):

    # Create northstar handle
    ns =
northstar.northstar(grant_type=args.northstar_grant_type,username=args.northstar_username,password=args.northstar_password,api_server=args.northstar_address,api_port=args.northstar_port,igp=args.network_igp,tenant_id=args.northstar_tenant_id)

    # Authenticate Northstar
    ns.get_token()

    # Get default topology index
    ns.get_topology_index()
                    

# Key_list
key_list =
['diversityGroup','diversityLevel','routingMethod','maxDelay','maxHop','maxCost']
#Extract LSPs from json file
for lsp_config in lsp_json['configuration']['protocols']['mpls']['labelswitched-path']:
[…]
                    

# Parse LSP description with ';' as delimiter
for item in str(lsp_config['description']).split(';'):
    logger.debug('Extracting LSP description item: ' + item)
    fields = item.split(':')
    if fields[0] == 'diversityGroup':
        lsp_pce_attrib['diversityGroup'] = fields[1]
    if fields[0] == 'diversityLevel':
        lsp_pce_attrib['diversityLevel'] = fields[1]
    if fields[0] == 'routingMethod':
        lsp_pce_attrib['routingMethod'] = fields[1]
    if fields[0] == 'maxDelay':
        lsp_pce_attrib['maxDelay'] = fields[1]
    if fields[0] == 'maxHop':
        lsp_pce_attrib['maxHop'] = fields[1]
    if fields[0] == 'maxCost':
        lsp_pce_attrib['maxCost'] = fields[1]
logger.debug('Updating LSP ' + lsp_config['name'] + ' with PCE routing attributes: ' + str(lsp_pce_attrib))
# Update LSP with PCE routing attributes
ns.update_lsp(old_lsp,**lsp_pce_attrib)
                    

def UpdateLSPsInNorthstarUsingMacros(lsp_json):

    # Create northstar handle
    ns =
northstar.northstar(grant_type=args.northstar_grant_type,username=args.northstar_username,password=args.northstar_password,api_server=args.northstar_address,api_port=args.northstar_port,igp=args.network_igp,tenant_id=args.northstar_tenant_id)

    # Authenticate Northstar
    ns.get_token()

    # Get default topology index
    ns.get_topology_index()
                    

#Extract LSPs from json file
for lsp_config in lsp_json['configuration']['protocols']['mpls']['labelswitched-path']:
                    

for item in lsp_macro['data']:
    logger.debug('Extracting LSP apply-macro routing-constraint: ' + str(item))
    if str(item['name']) == 'diversity-group':
        lsp_pce_attrib['diversityGroup'] = item['value']
    if str(item['name']) == 'diversity-constraint':
        lsp_pce_attrib['diversityLevel'] = item['value']
    if str(item['name']) == 'routing-method':
        lsp_pce_attrib['routingMethod'] = item['value']
    if str(item['name']) == 'max-delay':
        lsp_pce_attrib['maxDelay'] = item['value']
    if str(item['name']) == 'max-hop':
        lsp_pce_attrib['maxHop'] = item['value']
    if str(item['name']) == 'max-cost':
        lsp_pce_attrib['maxCost'] = item['value']
logger.debug('Updating LSP ' + lsp_config['name'] + ' with PCE routing attributes: ' + str(lsp_pce_attrib))
# Update LSP with PCE routing attributes
ns.update_lsp(old_lsp,**lsp_pce_attrib)
                    

The required router configuration stanzas include:

• Python as scripting language

  
  [edit system]
  scripts {
      language python;
  }
                              

• Extension services for request-response (grpc and/or thrift) and notification JET sessions (JET traceoptions enabled for troubleshooting)

  
  [edit system]
  services {
      extension-service {
          request-response {
              grpc {
                  clear-text;
              }
              thrift {
                  clear-text {
                      port 9090;
                  }
              }
          }
          notification {
              port 1883;
              max-connections 20;
              allow-clients {
                  address 0.0.0.0/0;
              }
          }
          traceoptions {
              file jet.log size 1g;
              flag all;
          }
      }
  }
                              

• Commit notification enabling

  
  [edit system]
  commit {
      notification;
  }
                              

• JET App extension with concrete input attributes

  
  [edit system]
  extensions {
      extension-service {
          application {
              file northstard.py {
                  arguments " --router_username regress --router_password MaRtInI
  --northstar_address 192.168.33.4 --northstar_username admin --
  northstar_password adminadmin --network_igp ISIS --output
  /var/log/northstar_jet.log";
                  daemonize;
                  username root;
              }
          }
      }
  }
                              

The JET notification session is required to listen to configuration change commit events and evaluate if a change has occurred within the [edit protocols mpls] stanza.

The JET request-response session is subsequently required to gather details under [edit protocols mpls] to evaluate PCE routing attributes under a label-switched-path and eventually trigger an update API request with the details. This separate session is required because all PCE routing attributes might not be in the previous commit notification message. The notification message acts as a trigger, if impacting [edit protocols mpls], for the request-response session to evaluate the configuration stanza and eventually issue an API request.

The JET application is enabled as an extension service in daemonized mode under the root user, so it is continuously running in the background. Input attributes are constant and could, conceptually, be common across the network, and cover mandatory arguments, such as local router username and password, NorthStar credentials, NorthStar PCS host IPv4 address, the network IGP (to properly extract details from the right TED) and a local log file in the router where information is traced (a-latraceoptions: with different logging levels, according to the standard Python logging library).

Note that there are more considerations for the package implementation in the router:

• The requests library is a directory, not a standalone file. This library is referrenced and used by the NorthStar library to handle API call details. Currently, even though it is compiled out of the same package, it is a requirement that you explicitly download the Python requests library and upload it to the right /var/db/scripts/jet/ directory:

  
  root@R4> file list /var/db/scripts/jet/
  /var/db/scripts/jet/:
  jsonpath.py@ -> /packages/mnt/northstar/var/db/scripts/jet/jsonpath.py
  northstar.py@ -> /packages/mnt/northstar/var/db/scripts/jet/northstar.py
  northstard.py*
  requests/
  server-extension/
  urllib2.py@ -> /packages/mnt/northstar/var/db/scripts/jet/urllib2.py
                              

• If no certificates are used, it is a requirement that you delete the symlink for the main application file, northstard.py, and copy the file from /packages/mnt/northstar/var/db/scripts/jet/ to /var/db/scripts/jet/ directory:

  
  root@R4> file list /var/db/scripts/jet/
  /var/db/scripts/jet/:
  jsonpath.py@ -> /packages/mnt/northstar/var/db/scripts/jet/jsonpath.py
  northstar.py@ -> /packages/mnt/northstar/var/db/scripts/jet/northstar.py
  northstard.py*
  requests/
  server-extension/
  urllib2.py@ -> /packages/mnt/northstar/var/db/scripts/jet/urllib2.py