Juniper Extension Toolkit Developer Guide: Release

Juniper Extension Toolkit Developer Guide
Release
1.0
Modified: 2016-07-28
Copyright © 2016, Juniper Networks, Inc.

Juniper Networks, Inc.
1133 Innovation Way
Sunnyvale, California 94089
USA
408-745-2000
www.juniper.net
Copyright © 2016, Juniper Networks, Inc. All rights reserved.
Juniper Networks, Junos, Steel-Belted Radius, NetScreen, and ScreenOS are registered trademarks of Juniper Networks, Inc. in the United
States and other countries. The Juniper Networks Logo, the Junos logo, and JunosE are trademarks of Juniper Networks, Inc. All other
trademarks, service marks, registered trademarks, or registered service marks are the property of their respective owners.
Juniper Networks assumes no responsibility for any inaccuracies in this document. Juniper Networks reserves the right to change, modify,
transfer, or otherwise revise this publication without notice.

1.0
Copyright © 2016, Juniper Networks, Inc.
All rights reserved.
The information in this document is current as of the date on the title page.
YEAR 2000 NOTICE
Juniper Networks hardware and software products are Year 2000 compliant. Junos OS has no known time-related limitations through the
year 2038. However, the NTP application is known to have some difficulty in the year 2036.
END USER LICENSE AGREEMENT
The Juniper Networks product that is the subject of this technical documentation consists of (or is intended for use with) Juniper Networks
software. Use of such software is subject to the terms and conditions of the End User License Agreement (“EULA”) posted at
http://www.juniper.net/support/eula.html. By downloading, installing or using such software, you agree to the terms and conditions of
that EULA.
ii Copyright © 2016, Juniper Networks, Inc.

Table of Contents
About the Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ix
Documentation and Release Notes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ix
Supported Platforms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ix
Documentation Conventions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ix
Documentation Feedback . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xi
Requesting Technical Support . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xii
Self-Help Online Tools and Resources . . . . . . . . . . . . . . . . . . . . . . . . . . . xii
Opening a Case with JTAC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . xii
Chapter 1 JET Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
Juniper Extension Toolkit Overview . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
JET Interaction with Junos OS . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
JET Application Development . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
JET Application Deployment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Junos OS Automation Tools . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
JET Developer Tasks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
JET Packages . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
MIB Support for JET Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
Chapter 2 Developing JET Applications Using the JET VM and IDE . . . . . . . . . . . . . . . . 21
Overview of Developing a JET Application Using a VM . . . . . . . . . . . . . . . . . . . . . . 21
Setting Up the JET Virtual Machine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Downloading the Packages You Need . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Downloading Vagrant . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Downloading VirtualBox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Downloading the JET Files from the Juniper Networks Download
Site . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Launching the JET VM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
Updating the Build Environment . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Stopping the JET VM . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Juniper Extension Toolkit Menu . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
Developing an Application Using the JET IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Requesting the Certificate Using the JET IDE . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
Building and Creating a Package by Using the JET IDE . . . . . . . . . . . . . . . . . . . . . . 31
JSON File Format for JET Application Packaging . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Main Section Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Mandatory Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Optional Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Source Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Dependent Libraries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Dependent Python Modules . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Copyright © 2016, Juniper Networks, Inc. iii

JSON File with All Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

Chapter 3 Developing JET Applications Manually Using the JET VM . . . . . . . . . . . . . . . 39
Working Manually in the Virtual Machine . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
Setting the PATH Environment Variable . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Executing the Certificate Request Script . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
Creating a Development Sandbox . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Developing an Application by Manual Workflow . . . . . . . . . . . . . . . . . . . . . . . . . . 43
Building and Creating a JET Application Package Without Using an IDE . . . . . . . 44
Chapter 4 Developing JET Applications Using Python . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
Overview of Developing a JET Application Using Python . . . . . . . . . . . . . . . . . . . . 47
Downloading and Installing the JET Python Client Package . . . . . . . . . . . . . . . . . 48
Developing an Application by Using the JET Python Client Package . . . . . . . . . . 49
Creating an Unsigned Package by Using the Python Packaging Tool . . . . . . . . . . . 51
Deploying a JET Python Application . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
Chapter 5 Developing Applications Using Other Languages . . . . . . . . . . . . . . . . . . . . . . 53
Overview of Developing a JET Application Using IDL . . . . . . . . . . . . . . . . . . . . . . . 53
Downloading and Compiling the IDL File . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
Chapter 6 Debugging JET Applications . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Debugging Tips . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
Debugging JET Applications on a Device Running Junos OS . . . . . . . . . . . . . . . . . 56
iv Copyright © 2016, Juniper Networks, Inc.

List of Figures
Figure 1: JET Request-Response and Notification Services . . . . . . . . . . . . . . . . . . . 16
Figure 2: Developing an Application Using a VM . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
Figure 3: Developing a JET Application Using Python . . . . . . . . . . . . . . . . . . . . . . . 47
Figure 4: Developing a JET Application Using IDL . . . . . . . . . . . . . . . . . . . . . . . . . . 53
Copyright © 2016, Juniper Networks, Inc. v

vi Copyright © 2016, Juniper Networks, Inc.

List of Tables
About the Documentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . ix
Table 1: Notice Icons . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . x
Table 2: Text and Syntax Conventions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . x
Table 3: JET Developer Tasks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
Table 4: Steps Involved in Developing a JET Application Using a VM . . . . . . . . . . . 22
Table 5: Juniper Extension Toolkit Menu Options . . . . . . . . . . . . . . . . . . . . . . . . . . 26
Table 6: Mandatory Attributes in the JSON File Main Section . . . . . . . . . . . . . . . . 33
Table 7: Optional Attributes in the JSON File Main Section . . . . . . . . . . . . . . . . . . 34
Table 8: Source Attributes You Can Use in a JSON File . . . . . . . . . . . . . . . . . . . . . . 35
Table 9: Steps Involved in Developing a JET Application Using Python . . . . . . . . 48
Table 10: Steps Involved in Developing a JET Application Using IDL . . . . . . . . . . . 53
Copyright © 2016, Juniper Networks, Inc. vii

viii Copyright © 2016, Juniper Networks, Inc.

About the Documentation
• Documentation and Release Notes on page ix

• Supported Platforms on page ix
• Documentation Conventions on page ix
• Documentation Feedback on page xi
• Requesting Technical Support on page xii
Documentation and Release Notes

®
To obtain the most current version of all Juniper Networks technical documentation,
see the product documentation page on the Juniper Networks website at
http://www.juniper.net/techpubs/.
If the information in the latest release notes differs from the information in the
documentation, follow the product Release Notes.
Juniper Networks Books publishes books by Juniper Networks engineers and subject
matter experts. These books go beyond the technical documentation to explore the
nuances of network architecture, deployment, and administration. The current list can
be viewed at http://www.juniper.net/books.
Supported Platforms
For the features described in this document, the following platforms are supported:
• MX104
• MX2010
• MX2020
• MX240
• MX480
• MX80
• MX960
Documentation Conventions
Table 1 on page x defines notice icons used in this guide.
Copyright © 2016, Juniper Networks, Inc. ix

Table 1: Notice Icons

Icon Meaning Description
Informational note Indicates important features or instructions.
Caution Indicates a situation that might result in loss of data or hardware damage.
Warning Alerts you to the risk of personal injury or death.
Laser warning Alerts you to the risk of personal injury from a laser.
Tip Indicates helpful information.
Best practice Alerts you to a recommended use or implementation.
Table 2 on page x defines the text and syntax conventions used in this guide.
Table 2: Text and Syntax Conventions

Convention Description Examples
Bold text like this Represents text that you type. To enter configuration mode, type the
configure command:
user@host> configure
Fixed-width text like this Represents output that appears on the user@host> show chassis alarms
terminal screen.
No alarms currently active
Italic text like this • Introduces or emphasizes important • A policy term is a named structure
new terms. that defines match conditions and
• Identifies guide names. actions.
• Junos OS CLI User Guide
• Identifies RFC and Internet draft titles.
• RFC 1997, BGP Communities Attribute
Italic text like this Represents variables (options for which Configure the machine’s domain name:
you substitute a value) in commands or
configuration statements. [edit]
root@# set system domain-name
domain-name
x Copyright © 2016, Juniper Networks, Inc.

Table 2: Text and Syntax Conventions (continued)

Convention Description Examples
Text like this Represents names of configuration • To configure a stub area, include the
statements, commands, files, and stub statement at the [edit protocols
directories; configuration hierarchy levels; ospf area area-id] hierarchy level.
or labels on routing platform • The console port is labeled CONSOLE.
components.
< > (angle brackets) Encloses optional keywords or variables. stub <default-metric metric>;
| (pipe symbol) Indicates a choice between the mutually broadcast | multicast

exclusive keywords or variables on either
side of the symbol. The set of choices is (string1 | string2 | string3)
often enclosed in parentheses for clarity.
# (pound sign) Indicates a comment specified on the rsvp { # Required for dynamic MPLS only
same line as the configuration statement
to which it applies.
[ ] (square brackets) Encloses a variable for which you can community name members [
substitute one or more values. community-ids ]
Indention and braces ( { } ) Identifies a level in the configuration [edit]

hierarchy. routing-options {
static {
route default {
; (semicolon) Identifies a leaf statement at a
nexthop address;
configuration hierarchy level.
retain;
}
}
}
GUI Conventions
Bold text like this Represents graphical user interface (GUI) • In the Logical Interfaces box, select
items you click or select. All Interfaces.
• To cancel the configuration, click
Cancel.
> (bold right angle bracket) Separates levels in a hierarchy of menu In the configuration editor hierarchy,
selections. select Protocols>Ospf.
Documentation Feedback
We encourage you to provide feedback, comments, and suggestions so that we can

improve the documentation. You can provide feedback by using either of the following
methods:
• Online feedback rating system—On any page of the Juniper Networks TechLibrary site
at http://www.juniper.net/techpubs/index.html, simply click the stars to rate the content,
and use the pop-up form to provide us with information about your experience.
Alternately, you can use the online feedback form at
http://www.juniper.net/techpubs/feedback/.
Copyright © 2016, Juniper Networks, Inc. xi

• E-mail—Send your comments to techpubs-comments@juniper.net. Include the document

or topic name, URL or page number, and software version (if applicable).
Requesting Technical Support
Technical product support is available through the Juniper Networks Technical Assistance
Center (JTAC). If you are a customer with an active J-Care or Partner Support Service
support contract, or are covered under warranty, and need post-sales technical support,
you can access our tools and resources online or open a case with JTAC.
• JTAC policies—For a complete understanding of our JTAC procedures and policies,

review the JTAC User Guide located at
http://www.juniper.net/us/en/local/pdf/resource-guides/7100059-en.pdf.
• Product warranties—For product warranty information, visit

http://www.juniper.net/support/warranty/.
• JTAC hours of operation—The JTAC centers have resources available 24 hours a day,
7 days a week, 365 days a year.
Self-Help Online Tools and Resources

For quick and easy problem resolution, Juniper Networks has designed an online
self-service portal called the Customer Support Center (CSC) that provides you with the
following features:
• Find CSC offerings: http://www.juniper.net/customers/support/
• Search for known bugs: http://www2.juniper.net/kb/
• Find product documentation: http://www.juniper.net/techpubs/
• Find solutions and answer questions using our Knowledge Base: http://kb.juniper.net/
• Download the latest versions of software and review release notes:

http://www.juniper.net/customers/csc/software/
• Search technical bulletins for relevant hardware and software notifications:

http://kb.juniper.net/InfoCenter/
• Join and participate in the Juniper Networks Community Forum:

http://www.juniper.net/company/communities/
• Open a case online in the CSC Case Management tool: http://www.juniper.net/cm/
To verify service entitlement by product serial number, use our Serial Number Entitlement
(SNE) Tool: https://tools.juniper.net/SerialNumberEntitlementSearch/
Opening a Case with JTAC

You can open a case with JTAC on the Web or by telephone.
• Use the Case Management tool in the CSC at http://www.juniper.net/cm/.
• Call 1-888-314-JTAC (1-888-314-5822 toll-free in the USA, Canada, and Mexico).
xii Copyright © 2016, Juniper Networks, Inc.

For international or direct-dial options in countries without toll-free numbers, see

http://www.juniper.net/support/requesting-support.html.
Copyright © 2016, Juniper Networks, Inc. xiii

xiv Copyright © 2016, Juniper Networks, Inc.

CHAPTER 1
JET Overview
• Juniper Extension Toolkit Overview on page 15

• JET Packages on page 18
• MIB Support for JET Applications on page 19
Juniper Extension Toolkit Overview
Juniper Extension Toolkit (JET), an evolution of the Junos SDK, provides a modern,
programmatic interface for developers of third-party applications. It focuses on providing
®
a standards-based interface to the Juniper Networks Junos operating system (Junos
OS) for management and control plane functionality.
JET supports the following:
• Multiple languages for applications that run off-box
• Python for applications that run on a device running Junos OS
• Applications written in C to run on devices that do not use the JET APIs
• An event notification method that enables the applications to respond to selected

system events
JET does not use Junos OS APIs, which makes it independent of any Junos OS release.
The JET API release model supports installation of a JET service process (jsd) image
other than the base image from the Junos OS release. A corresponding JET client API
package is released for each jsd image.
JET APIs are synchronous in nature.
See the following sections for more developer overview information. For information on
configuring JET applications to run on a device running Junos OS, see the
Administration Guide for Juniper Extension Toolkit Applications.
• JET Interaction with Junos OS on page 16

• JET Application Development on page 16
• JET Application Deployment on page 17
• Junos OS Automation Tools on page 17
• JET Developer Tasks on page 18
Copyright © 2016, Juniper Networks, Inc. 15

JET Interaction with Junos OS

JET uses the Apache Thrift framework for cross-language services (see
http://thrift.apache.org/) as a mechanism to enable request-response service. Thrift
provides an interface definition language (IDL) that enables you to define APIs. These
IDL files (with .thrift as the file extension) are compiled using the Thrift compiler to
generate source code to be used for the server and client applications. The Thrift server
is part of the JET service process (jsd), which runs on Junos OS.
For event notification, JET uses the Message Queue Telemetry Transport (MQTT) protocol
(see http://mqtt.org/). Event notification is implemented through the mosquitto
notification broker (see http://mosquitto.org/).
Figure 1 on page 16 illustrates the request-response and notification services.
Figure 1: JET Request-Response and Notification Services
JET Application Development

JET includes a virtual machine (VM) package as a vagrant file that includes its own Eclipse
integrated development environment (IDE), plug-ins, and other tools and libraries. There
is also a Python client package.
This developer guide covers a few JET application development scenarios using the
supplied packages; however, JET APIs function within any framework (for example,
Twisted). You can use any programming framework that you prefer to develop
applications. You can use any IDE (such as PyCharm IDE or Eclipse) while developing
against the Python library JET supplies, or you can use your preferred editor. You can use
a text editor (such as vi) to directly write a Python file.
16 Copyright © 2016, Juniper Networks, Inc.

Chapter 1: JET Overview
This guide covers the following JET application development scenarios:
• Application development workflow using the JET VM and the IDE
• Application development workflow using the JET VM with manual workflow
• Application development workflow using the Python client package
• Application development workflow using the interface definition language (IDL) and
the MQTT library
JET Application Deployment

The following deployments for Python applications on Junos OS are supported:
• Regular Junos OS (veriexec-enabled Junos OS) with the python configuration enabled
at the [edit system scripts language] hierarchy level. In this scenario, the system will
not perform veriexec checks for a Python application as long as the application is
located under the /var/db/scripts/jet directory and configured at the [edit system
extensions] hierarchy level. In this scenario, an unsigned package for a Python-only
application (a Python script with no dependencies on unsigned shared libraries) will
work. Any application in a signed package will also work.
• Regular Junos OS (veriexec-enabled Junos OS) with the python configuration disabled
at the [edit system scripts language] hierarchy level. In this environment, only those
Python scripts that are part of a signed package can be executed. Therefore, only a
signed package will work for this scenario.
NOTE: Junos OS supports using symbolic links for files in the

/var/db/scripts/jet directory, but the device will only execute the script at the
target location if it is signed.
Junos OS Automation Tools

JET is one of the Junos OS automation tools. Other automation tools for Junos OS include
the following:
• Junos PyEZ — A microframework for Python that enables you to remotely manage and
automate devices running Junos OS.
• Automation scripts (see the Automation Scripting Feature Guide).
• Commit scripts—Manage the configuration process.
• Operational scripts—Perform operational tasks and network troubleshooting.
• Event scripts and event policy—Instruct the operating system to perform actions in
response to system events.
• SNMP scripts—Support custom MIBs until they are implemented in Junos OS.

JET Developer Tasks

This guide describes the developer tasks necessary to produce third-party applications.
See Table 3 on page 18 for a list of the JET developer tasks and where to find details
about them in this guide.
Table 3: JET Developer Tasks

JET Developer Task Find Details Here
Workflows for developing a JET • Overview of Developing a JET Application Using a

application VM on page 21
• Overview of Developing a JET Application Using
Python on page 47
• Overview of Developing a JET Application Using IDL
on page 53
Debugging JET applications • Debugging Tips on page 55

• debugging“Debugging JET Applications on a Device
Running Junos OS” on page 56
For more information on developing applications, see Building Your First JET Application
and the following example applications in the Juniper Extension Toolkit Getting Started
Guide:
• JET Interfaces Application
• JET Firewall and Policer Application
• JET Notification Application
Related • http://thrift.apache.org/
Documentation
• Junos PyEZ
• Automation Scripting Feature Guide
JET Packages
Juniper Extension Toolkit (JET) packages support JET applications on the device and
provide the framework for application development.
There is a difference in packaging of client APIs between development for on-device

applications and development for off-box applications. By default, a set of JET client
package modules is installed on-device. These modules provide a set of wrapper Python
APIs for developing JET applications. To develop applications to run off-box, developers
need to download and install the JET client API package.

Chapter 1: JET Overview
On-device packages:
• Junos PyEZ—A microframework for Python that comes installed on the device. The
PyEZ microframework enables you to remotely manage and automate devices running
Junos OS. Junos PyEZ is designed to provide the capabilities that a user would have
on the Junos OS command-line interface (CLI) in an environment built for automation
tasks. For more information, see Junos PyEZ.
• jsd package—The JET service process (jsd) runs on Junos OS. On the TCP port (default
port 9090), jsd listens for and receives requests from JET applications to execute APIs.
Off-box packages:
• JET client API package—For every release of the jsd image, a corresponding API bundle
image is also released. The API bundle package naming is independent of Junos OS
so that one API bundle can be used across multiple jsd releases.
Related • Junos PyEZ

Documentation
• Automation Scripting Feature Guide
MIB Support for JET Applications
In Junos OS, the SNMP functionality is implemented as a distributed agent using RFC
2741, Agent Extensibility (AgentX) Protocol Version 1. The AgentX protocol allows a master
agent to be extended by independent subagents, so you can have many subagents, and
the communication between master agent and subagents is through the AgentX protocol.
In Junos OS, the master agent process (snmpd) listens for external requests on a standard
port.
An SNMP MIB is a collection of information organized hierarchically. MIBs define the

managed objects that an SNMP manager monitors on SNMP agent or subagents. When
an SNMP manager requests information from an SNMP agent, the SNMP agent retrieves
the current value of the requested information from the MIB.
Object identifiers (OIDs) uniquely identify manged objects in a MIB hierarchy.
Whenever a request for a given OID is received, the master agent forwards the request
to the connected subagent that is responsible for the given OID. For example, if a get or
get-next is received for an OID (let us say, bgpPeerLocalAddr, for example), on receiving
the request, snmpd forwards the request to the Routing process (rpd) subagent to get
the value for the OID. After receiving the value, snmpd sends the response with the
standard response protocol data unit (PDU) to the network management system.
SNMP agent functionality is supported for JET applications as well, by extension. The
JET agent application can run as a SNMP subagent, and it can register its own MIB OIDs
with snmpd. Whenever there is a request for the application-hosted OID, the request will
be forwarded to the application through the AgentX protocol, and the application then
has to respond back with the value requested.
You can also create a JET subagent as an offbox agent application.

NOTE:
To implement MIB handlers, you must follow open source net-snmp subagent
guidelines.
To implement a JET subagent as an offbox agent application:
1. Download the open source net-snmp from http://www.net-snmp.org/download.html.
2. Build the open source net-snmp to the required native machine.
3. Write the MIB and the subagent method handlers as per the net-snmp specification.
4. Build the application.
5. Add the configuration on the device running Junos OS to allow external SNMP subagent
connections.
usser@host# set snmp subagent tcp routing-instance default
6. Run the application to register the OIDs being served.
After the application registration is successful, the application’s registered OIDs can be
polled similar to how other Junos OS supported OIDs are polled.
Related • Juniper Extension Toolkit Overview on page 15

Documentation

CHAPTER 2
Developing JET Applications Using the JET

VM and IDE
• Overview of Developing a JET Application Using a VM on page 21

• Setting Up the JET Virtual Machine on page 23
• Juniper Extension Toolkit Menu on page 25
• Developing an Application Using the JET IDE on page 27
• Requesting the Certificate Using the JET IDE on page 29
• Building and Creating a Package by Using the JET IDE on page 31
• JSON File Format for JET Application Packaging on page 32
Overview of Developing a JET Application Using a VM
If an application that you want to develop has a dependency on C or C++ modules or the
application needs to be signed, then you must use the Juniper Extension Toolkit (JET)
virtual machine (VM) for application development.
The JET VM is a 64-bit Ubuntu 12.04 long-term support release. Application developers
can use the JET IDE provided with the VM to develop applications. To set up the developer
environment, you must download the JET bundle and client package from the Juniper
Networks download site, and then, once the VM is up, install the JET toolchain, Eclipse
integrated development environment (IDE), plug-ins, and other tools and libraries that
are required for developing on-device or off-box applications. For more details on the
installing the VM, see “Setting Up the JET Virtual Machine” on page 23.
For a diagram of the JET workflow using the JET VM, see Figure 2 on page 22.
Table 4 on page 22 provides topics relating to the workflow steps in Figure 2 on page 22.

Figure 2: Developing an Application Using a VM
A
Download
and set up JET VM
Linux (Ubuntu)
WIll B
Develop app application
using PvDEV project NO run on a device YES Develop app
Python apps running using JET project
Junos OS?
C
Use Python
packaging tool
Set up signing
to create unsigned
cert keys
package
D
Deploy application
package on external Create the signed
server or run the app package using
directly from VM JET sandbox
E
Deploy application
package on a device
External server running Junos OS
g043325
Veriexec Junos
Table 4: Steps Involved in Developing a JET Application Using a VM

Workflow Step Link to Workflow Step
A “Setting Up the JET Virtual Machine” on page 23
B “Developing an Application Using the JET IDE” on page 27
C “Requesting the Certificate Using the JET IDE” on page 29
D “Building and Creating a Package by Using the JET IDE” on page 31
E Deploying an Application Package on a Device Running Junos OS
Related • Setting Up the JET Virtual Machine on page 23

Documentation
• Overview of Developing a JET Application Using Python on page 47
• Overview of Developing a JET Application Using IDL on page 53

Chapter 2: Developing JET Applications Using the JET VM and IDE
Setting Up the JET Virtual Machine
Three packages are used from the Juniper Networks download site to set up the JET
virtual machine (VM): a vagrant zip file, a JET bundle containing a backing sandbox and
toolchain, and the Python library client.
To be ready to use the JET VM and integrated development environment (IDE) to create
applications, complete the following tasks:
• Downloading the Packages You Need on page 23

• Launching the JET VM on page 24
• Updating the Build Environment on page 25
• Stopping the JET VM on page 25
Downloading the Packages You Need

Installing the JET VM on your development machine provides a complete development
environment with tools for building and packaging applications. It also provides the JET
IDE.
Download and install the following packages:
• Downloading Vagrant on page 23

• Downloading VirtualBox on page 23
• Downloading the JET Files from the Juniper Networks Download Site on page 24
Downloading Vagrant
Vagrant (https://www.vagrantup.com/) is a software that creates and configures virtual

development environments. You can think of it as a higher-level wrapper around
virtualization software such as VirtualBox (https://www.virtualbox.org/wiki/Downloads).
You can use Vagrant to manage the JET development virtual machine (VM).
To download Vagrant:
• Go to https://www.vagrantup.com/ and download Vagrant for your system’s platform

(Windows, Mac, or Linux).
Downloading VirtualBox
NOTE: For the JET VM, Juniper Networks supports only the VirtualBox
hypervisor.

To download and install VirtualBox:
1. Go to https://www.virtualbox.org/wiki/Downloads.
2. Download and install the VirtualBox package for your platform and the VirtualBox
extension package.
3. Enable hardware virtualization support on your machine BIOS if it is not already

enabled.
Downloading the JET Files from the Juniper Networks Download Site
The JET VM is downloaded from the Juniper Networks download website at

http://www.juniper.net/support/downloads/?p=jet#sw in the form of three packages:
• JET sandbox and toolchain file
• Python client library file
• JET-vagrant.zip file
Launching the JET VM

The vagrant zip file is started first.
To launch the JET VM:
1. Create a jet-vagrant directory and extract the JET-vagrant.zip file you downloaded
from the Juniper Networks download site to that directory.
2. Change to the jet-vagrant directory where you have extracted the JET-vagrant.zip file.
3. Issue the vagrant up command.
If needed, use the following default login credentials:
username: vagrant
password: vagrant
Wait for the Ubuntu desktop screen to come up in Oracle VM VirtualBox. You will see
the Eclipse icon. This is the icon you use for the JET IDE.
4. Double-click the Eclipse icon to start the JET IDE.
Next, before starting to use the JET IDE, you must install the JET bundle containing backing
sandbox and toolchain and the Python client library.

Updating the Build Environment

To download and install the Python client library, you can either use the following
procedure or extract and run install.sh script.
To update the build environment:
1. Start the JET IDE.
See the procedure “Launching the JET VM” on page 24 for details.
2. Change the perspective by selecting Juniper Extension Toolkit from the Window > Open
perspective -> Other menu.
3. Once the perspective is change, select Juniper Extension Toolkit > Update build
environment.
4. Point the input fields to downloaded JET bundle and client library and install them.
Stopping the JET VM

When you are done using the VM, stop and exit Vagrant.
To stop and exit Vagrant and the IDE:
1. Go to the command-line prompt for your system.
2. In the jet-vagrant directory, issue the vagrant halt command.

Documentation
• Juniper Extension Toolkit Menu on page 25
Juniper Extension Toolkit Menu
The Juniper Extension Toolkit menu is the integrated development environment (IDE)
menu that provides the options you need to create projects and sandboxes for developing
and testing your applications.
To get directions on how to open the JET IDE, see “Setting Up the JET Virtual Machine”
on page 23.
To view the Juniper Extension Toolkit options (Table 5 on page 26), open the JET IDE and
click the Juniper Extension Toolkit menu.
The default perspective of the Juniper Extension Toolkit (JET) IDE has four panes: two
top panes and two bottom panes. The top left-side pane has two windows controlled
by tabs: the Sandbox Explorer (Sandbox) tab and the Remote Systems (Remote) tab.
By default, the Sandbox Explorer window is active.

Table 5: Juniper Extension Toolkit Menu Options

Menu Description
JET Project Create a new project and sandbox for developing

applications or select an existing project.
Build Sandbox Launch a build of the application based on the configuration

that was provided in Build Configuration.
Build Directory Compile and build the application by running the make
command in the directory that was selected in the Sandbox
Explorer window.
Build Configuration Configure your build settings and launch a build for the
current sandbox. In the Build Configuration window, you can
configure the following settings:
• Select the packages that will be included in the build.

• Select the targeted architecture.
• Select the packaging type (operating system).
Export Application Launch and export a build based on the configuration you
provide in Export Configuration.
Export Configuration Configure your build and export settings, build your
application, and export your application.
In the Export Configuration window, you can configure the

following settings:
• Select the directory location for the application once it

has been built.
• Select the packages to include in the build.
• Select the targeted architecture.
• Select the packaging type (operating system).
Run JET Workflow Build, install, and test the application based on the settings
configured in Run JET Configuration.

Table 5: Juniper Extension Toolkit Menu Options (continued)

Menu Description
Run JET Configuration Configure your build settings, configure the router setting,
launch a build, and execute operational commands needed
to install and test the application.
In the JET Configuration window, you can configure the

following:
• In the Export Configuration tab, select the packages to

include in the build, select the targeted architecture, and
select packaging type.
• In the Device Details tab, specify the router on which you
want to test your application by entering in the router
name, login ID, password, and pathname where you want
to install the application.
• In the Operational Commands tab, enter operational
commands to run on the router prior to and after installing
the application.
• In the Device Configuration window, enter a configuration
in curly bracket ({}) format to run on the router prior to
and after installing the application.
Update Build Environment Update your JET development environment by installing JET
bundle packages and JET Python Client packages that you
have downloaded.
Certificate Install a certificate, request the signing of a certificate, and

generate a certificate request. See “Requesting the Certificate
Using the JET IDE” on page 29.
Generate Build Files Generate makefiles based on input entered in a JSON file.
For more information on JSON files, see “JSON File Format
for JET Application Packaging” on page 32.
“Developing an Application Using the JET IDE” on page 27 provides more information
and shows you how and when to use some of these Juniper Extension Toolkit menu
options.
Related • JSON File Format for JET Application Packaging on page 32

Documentation
• Developing an Application Using the JET IDE on page 27
Developing an Application Using the JET IDE
Application developers can use the integrated development environment (IDE) provided
with the Juniper Extension Toolkit (JET) virtual machine (VM) to develop applications.

To develop an application by using the JET IDE:
1. Start the JET IDE and select Juniper Extension Toolkit > JET Project.
2. Type in a project name, select an item from the Applications List, and click Finish.
The new project name appears in the Sandbox Explorer window (top left pane). You
can expand the new project name and see several directories, including the src
directory. Expand the src directory to see several more directories, among them the
python, lib, and bin directories. These are the directories you use to create new
application components.
3. Highlight the appropriate directory for your applications files (choose from among
the python, lib, and bin directories), either select File > New > Folder or right-click and
select New > Folder, type a folder name, and click Finish.
• To develop applications in Python, create a new application directory in the python

directory and develop the application inside the newly created directory.
• To create a C/C++ library, create a new library directory in the lib directory and
develop the library inside the newly created directory.
• To create a C/C++ executable, create a new application directory in the bin directory
and develop the application inside the newly created directory.
For example, for a C/C++ application, you can put some libraries in the lib directory
and other application components in the bin directory.
4. Create files for your application code.
Highlight the appropriate subdirectory, either select File > New > File or right-click and
select New > File, type a filename, and click Finish.
5. Create the code in the application files and do one of the following to save: select File
> Save, press Ctrl+s, or click the diskette icon.
Makefiles and the manifest file are created automatically once you have created the
JSON file.
Related • Juniper Extension Toolkit Menu on page 25

Documentation
• Building and Creating a Package by Using the JET IDE on page 31

Requesting the Certificate Using the JET IDE
In order to develop and distribute JET applications, you must install a package signing
certificate onto the virtual machine (VM). You do this by creating a certificate request
and sending it to Juniper Networks. When you receive the certificate, you install it in the
VM.
CAUTION: Never send your signing key to anyone, including Juniper Networks.
The key enables anyone to sign applications that your router will trust.
Therefore, it should be treated with the same level of security as the root
password for the routers. Once you obtain your signing key, save it in a file
outside of the VM.
Before you can create a certificate request, you must have the provider prefix—a uniquely
identifying prefix that represents the name of your organization. This prefix should have
been provided to a contact at your organization. If you do not know this prefix, you must
request it before running the jet-certificate-request command. Contact JET Certificate
Processing at jet-cert@juniper.net.
To create a signed application, request certificates and copy them as explained in the
following procedure. This procedure is optional if you want to create an unsigned
application.
To create a certificate request using the IDE:
1. Select Juniper Extension Toolkit > Certificate > Generate Certificate.
2. Complete the fields in the Generate Certificate Request pane.
The script prompts for the following data:
• ISO Code
• State
• Municipality
• Organization Name
• Organization Provider Prefix
• User String
This is an additional specification of your choosing. It could be a string specifying

the development team or project name. The user string can consist of a lowercase
letter followed by one or more lowercase letters or numbers.
• Deployment Scope

• Index number
This number is known as a certificate generations number. It is 1 for your initial

certificate. When a certificate expires and a new one is requested, you must
increment the number.
• E-mail address
We recommend against using a personal e-mail address for the certificate contact.
3. Click Browse to select a directory in which to create the cert files.
This is usually the /usr/local/junos-jet/certs directory.
4. Click Finish.
To send a certificate request to Juniper Networks:
NOTE: Alternatively, you can use an existing e-mail server to send e-mail to
jet-cert@juniper.net with the certificate request file attached.
1. Select Juniper Extension Toolkit > Certificate > Request Signing.
2. Set up local e-mail SMTP server details and your e-mail details.
3. Fill in the subject of the e-mail.
4. Attach the certificate request file to the e-mail.
5. Send the e-mail.
To install a certificate on the VM:
1. Select Juniper Extension Toolkit > Certificate > Install Certificate.
2. Navigate to the location where the certificate resides and click Finish.
3. Check that the certificates foo_key.pem and foo.pem are both in the directory.

Documentation
• Developing an Application by Using the JET Python Client Package on page 49

Building and Creating a Package by Using the JET IDE
After writing your application, write the JSON file by providing details about your
application, which the system uses to autogenerate the makefiles and manifest file.
NOTE: If you are not using the JET IDE, write the application JSON file inside
your sandbox. For more details, see “JSON File Format for JET Application
Packaging” on page 32.
To create the JSON file and the JET package using the JET IDE:
1. Highlight the src directory in the Sandbox Explorer pane, either select File > New > File
or right-click and select New > File, type the filename (use the .json extension), and
click Finish.
The JSON file is placed under the python directory in the Sandbox Explorer pane, and
the JSON Editor is opened and ready for you to create the JSON file. If the JSON Editor
does not open, right-click the .json file and select Open With > JSON Editor.
2. Provide the necessary information about the application and save the file.
• Application Name—Specify the path to the application's implementation directory.

If the application is a binary, the application name is treated as a binary name. The
package name created is based on the value in this field.
• Application Path—Specify the path to the application directory.
• Language—Select the language used for developing the application.
• Main scripts—This is a list attribute and is generally applicable for Python

applications. For binary applications, this item is optional. Main scripts are searched
under the application path.
Specify the filename or filenames of the main script or scripts that run on the device.
Click Add to add a filename and path. Select a file and click Remove to remove a
file.
• Application type—Select whether an application is to be a standalone program or

a daemon.
• Signed application—Select yes or no.
• Target OS—Select BSD 6 for legacy Junos OS or BSD 10 for Junos OS with updated
FreeBSD.
• Target architecture—Specify the target architecture on which the application is to

be deployed.
• Application description—Specify a brief (one-line) description about the application.

This description will be displayed in the CLI show version operational command.
• Specify the list of C compiler flags, the list of C++ compiler flags, and the list of
linker flags, if any.

Use linker flags to specify additional libraries to link with or additional link-specific
flags that are required during linking,
• Source files and modules—Select a category and click Add to add a filename and
path.
Click Preview at any point to see the JSON file format in code.
3. Do one of the following to save the JSON file: select File > Save, press Ctrl+s, or click
the diskette icon.
4. Select the JSON file and click Juniper Extension Toolkit > Generate Build Files from the
menu bar.
The makefiles and manifest file are generated automatically..
5. Select the project directory in the left pane and then select one of the following:
• Juniper Extension Toolkit > Build Sandbox—Build the applications using the
configuration provided in Build Configuration.
• Juniper Extension Toolkit > Build Configuration—Select which applications to build,

which targets to build for, and build once you click Finish.
• Juniper Extension Toolkit > Run JET Configuration—Specify which device to load the
application on and what commands and configurations to include.
Once the build is successful, the package is created in the project ship directory. The
ship directory is in the project directory under the junos-jet-sb-obj directory. You can
see the ship directory in the left pane once the package has been built.

Documentation
• JSON File Format for JET Application Packaging on page 32
• Juniper Extension Toolkit Overview on page 15
JSON File Format for JET Application Packaging
JSON (JavaScript Object Notation) is a lightweight data-interchange format. It is easy

for humans to read and write, and also easy for machines to parse and generate. For
more details, see http://www.json.org.
After application development is complete, write the JSON file describing the content
to be built and packaged for deployment on the device. JSON files consist of a collection
of attributes. Attributes use two structures:
• A collection of key-value pairs
• An ordered list of values
These attributes are included inside a set of curly braces.

The following subtopics describe each of the attributes contained in the JSON format
for application packaging:
• Main Section Attributes on page 33

• Source Attributes on page 35
• Dependent Libraries on page 35
• Dependent Python Modules on page 36
• JSON File with All Attributes on page 37
Main Section Attributes

The top block of the JSON file is the main section of the file. It consists of mandatory and
optional attributes.
• Mandatory Attributes on page 33

• Optional Attributes on page 34
Mandatory Attributes
Table 6 on page 33 describes the mandatory attributes that all JSON files for application
packaging must have in the main section.
Table 6: Mandatory Attributes in the JSON File Main Section

Attribute Description Example Values
"app-name" Specify the name of the application. "sample_pyapp"
"app-path" Specify the path to the application’s implementation directory. All "python/sample_pyapp"
paths should be relative to sandbox src.
"language" Specify the language used for developing the application. "python", "c", "c++"
"main-scripts" This is a list attributes. Specify the filename or filenames of the main ["foo.py", "bar.py"]
script or scripts that run on the device (do not specify the module
here). The main script files will be deployed under the
/var/db/scripts/jet path on the device.
"app-type" Specify whether an application is to be a standalone program or a "standalone" or "daemon"

daemon.
"sign" Indicate whether the application is to be signed or unsigned. "yes" or "no"
"os-type" Specify whether the application is to be deployed on legacy Junos "bsd6" or "bsd10"
OS (bsd6) or Junos OS with upgraded FreeBSD (bsd10).
"target-arch" Specify the target architecture on which the application is to be "i386", "powerpc", "octeon",
deployed. "xlr", or "arm"
"description" Write a brief (one-line) description about the application. This will "Simple Python test app"
be displayed in the show version operational command output.

The following is an example of a simple application JSON file containing only the
mandatory attributes:
{
"app-name": "sample_pyapp",
"app-path": "python/sample_pyapp",
"language": "python",
"main-scripts": ["foo.py", "bar.py"],
"app-type": "standalone",
"sign": "no",
"os-type": "bsd6",
"target-arch": "i386",
"description": "Simple Python test app"
}
Optional Attributes
Table 7 on page 34 describes the optional attributes you can include in the main section
of the JSON file for application packaging.
Table 7: Optional Attributes in the JSON File Main Section

"c-compiler-flags" Specify the list of C compiler flags, if any. Compilation "flag1 flag2 flag3"
flags can be defined for the main section, dependent
libraries (dep-libs), or dependent Python modules
(dep-py-modules).
"c++-compiler-flags" Specify the list of C++ compiler flags, if any. "flag1 flag2 flag3"
Compilation flags can be defined for the main section,
dependent libraries (dep-libs), or dependent Python
modules (dep-py-modules).
"linker-flags" Specify the list of linker flags, if any. Use these flags to "flag1 flag2 flag3"
specify additional libraries to link to or additional
link-specific flags that are required during linking, You
can define linker-specific flags either in the main
section or in the dep-py-modules section.
The following is an example main section with mandatory and optional attributes:
{
"sign": "no",
"os-type": "bsd6",
"description": "Simple Python test app",
"c-compiler-flags": "-DFOO -DBAR",
"c++-compiler-flags": "-DAPP_CHECK –DSOMETHING_ON",
"linker-flags": "-lstdc++ -lfoo" }

Source Attributes
Table 8 on page 35 shows two source attributes you can use to specify source files for
the application package.
Table 8: Source Attributes You Can Use in a JSON File

"srcs" Specify the list of additional source files. For Python "srcs": {
applications, these source files are the additional "python/sample_pyapp": ["a.py", "b.py"],
module files. For C or C++ applications, these source "python/sample_pyapp/temp": ["temp1.py",
files are the source files to be compiled to generate "temp2.py"]
lib/binary. Each entry should be a key-value pair, }
where the key is the path of the source files and the
value is an array of source filenames.
"extn-srcs" This section is applicable only for Python. Specify "extn-srcs": {

the list of C or C++ module files to be compiled. Each "python/sample_pyapp": ["foo.c", "bar.c"],
entry should be a key-value pair, where the key is the "python/sample_pyapp/temp": ["1.cpp", "2.cpp"]
path of the source files and the value is an array of }
source filenames.
The following is an example Python application with additional module files to be

deployed, along with the main script file:
{
"sign": "no",
"os-type": "bsd6",
"srcs": {
"python/sample_pyapp": ["a.py", "b.py"],
"python/sample_pyapp/temp": ["temp1.py", "temp2.py"]
},
"extn-srcs": {
"python/sample_pyapp": ["foo.c", "bar.c"],
"python/sample_pyapp/temp": ["1.cpp", "2.cpp"]
}
}
Dependent Libraries
The dependent libraries (dep-libs) section contains any dependent libraries that must
be compiled. The library generated from this JSON code is packaged with the application.
The dep-libs section is an array of multiple library dependencies, each composed of the
following key-name pairs:

• "lib-name" is the name of the library.
• "lib-path" is the path of the library source code in the development sandbox.
• "srcs" is a key-value pair in which the path is the key and its value is a list of source
files.
The following is an example of a dep-libs attribute:
"dep-libs": [
{
"lib-name": "xyz",
"lib-path": "lib/xyz",
"srcs": {
"lib/xyz": ["foo.c", "bar.c"]
}
}
]
Dependent Python Modules

The dependent Python modules (dep-py-modules) attribute is used only for Python
applications. This attribute contains any dependent Python modules that need to be
compiled and packaged with the application. The dep-py-modules attribute is an array
in which you can specify multiple Python module dependencies. Each dependency is
composed of the following objects:
• "py-module-name" is the name of the Python module.
• "py-module-path" is the path of the Python module source code in the development
sandbox.
• "srcs" is a key-value pair in which the path is the key and its value is a list of source
files.
• "extn-srcs" is a key-value pair in which the path is the key and its value is a list of Python
extension source files.
The following is an example of a dep-py-modules attribute:
"dep-py-modules": [
{
"py-module-name": "module_a",
"py-module-path": "python/module_a",
"srcs": {
"python/module_a": ["foo.py", "bar.py"]
},
"extn-srcs": {
"python/module_a": ["foo.c", "bar.c"],
"python/module_a/sub_mod": ["lmn.cpp"]
}
}
]

JSON File with All Attributes

The following is an example of a JSON file containing all possible attributes:
{
"sign": "no",
"os-type": "bsd6",
"c-compiler-flags": "-DFOO -DBAR",
"c++-compiler-flags": "-DAPP_CHECK –DSOMETHING_ON",
"linker-flags": "-lstdc++ -lfoo",
"srcs": {
"python/sample_pyapp": ["a.py", "b.py"],
"python/sample_pyapp/temp": ["temp1.py", "temp2.py"]
},
"extn-srcs": {
"python/sample_pyapp": ["foo.c", "bar.c"],
"python/sample_pyapp/temp": ["1.cpp", "2.cpp"]
},
"dep-libs": [
{
"lib-name": "xyz",
"lib-path": "lib/xyz",
"srcs": {
"lib/xyz": ["foo.c", "bar.c"]
}
},
{
"lib-name": "bar",
"lib-path": "lib/bar",
"srcs": {
"lib/bar": ["zoo.c", "zoom.c"],
"lib/bar/temp": ["test1.c", "test2.c"]
}
}
],
"dep-py-modules": [
{
"py-module-name": "module_a",
"py-module-path": "python/module_a",
"srcs": {
"python/module_a": ["foo.py", "bar.py"]
},
"extn-srcs": {
"python/module_a": ["foo.c", "bar.c"],
"python/module_a/sub_mod": ["lmn.cpp"]
}
},
{
"py-module-name": "module_b",

"py-module-path": "python/module_b",
"c-compiler-flags": "-DSOMEMACRO",
"c++-compiler-flags": "-DSOMEMACRO",
"linker-flags": "-lfoo",
"srcs": {
"python/module_b": ["yyy.py", "zoo.py"],
"python/module_b/sub_mod": ["1.py", "2.py"]
},
"extn-srcs": {
"python/module_b": ["xyz.c", "temp.c"],
"python/module_b/sub_mod": ["y.cpp", "z.cpp"]
}
}
]
}
Related • Building and Creating a Package by Using the JET IDE on page 31
Documentation

CHAPTER 3
Developing JET Applications Manually

Using the JET VM
• Working Manually in the Virtual Machine on page 39

• Setting the PATH Environment Variable on page 40
• Executing the Certificate Request Script on page 41
• Creating a Development Sandbox on page 42
• Developing an Application by Manual Workflow on page 43
• Building and Creating a JET Application Package Without Using an IDE on page 44
Working Manually in the Virtual Machine
For those developers who prefer to work outside of the integrated design environment
(IDE), this chapter covers how to do certain developer tasks in the terminal part of the
virtual machine (VM).
To work manually on developing JET applications, you still need to download the JET
VM. See Downloading the Packages You Need.
To access a terminal in the VM:
1. Start the JET VM.
See “Setting Up the JET Virtual Machine” on page 23.
2. On the Ubuntu Desktop, click the Dash Home icon.

The Dash Home icon is in the upper left corner of the Ubuntu Desktop and appears
as a circle with three dots arranged around it.
3. Click the Terminal icon.
The terminal window appears with the prompt vagrant@jet-vm:~$.
Related • Setting the PATH Environment Variable on page 40

Documentation
• Downloading the Packages You Need
• Setting Up the JET Virtual Machine on page 23
Setting the PATH Environment Variable
Before setting the PATH environment variable, download the virtual machine (VM)
environment for developing applications. For details on this download, see Downloading
the Packages You Need.
PATH is the system variable that your operating system uses to locate needed executables
from the command line or terminal window. Using this procedure eliminates the need to
specify the entire path to executables located in your sandbox.
To set the PATH variable:
1. Open a terminal in the VM.
2. Locate the .bashrc file in the /home/vagrant directory.
vagrant@jet-vm:~$ pwd
/home/vagrant
vagrant@jet-vm:~$ ls -a
3. Add the path from /root to the /junos-jet-sb/bin directory to the PATH variable in
.bashrc.
For example:
vagrant@jet-vm:~$ echo
'PATH=$PATH:/usr/local/junos-jet/16.1R1.3/junos-jet-sb/bin'>>~/.bashrc

Chapter 3: Developing JET Applications Manually Using the JET VM
4. Issue the env command to ensure the PATH variable contains the directory path you
just added.
vagrant@jet-vm:~$ env
PATH=/usr/lib/lightdm/lightdm:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:
/bin:/usr/games:/usr/local/junos-jet/16.1R1.3/junos-jet-sb/bin
Related • Downloading the Packages You Need

Documentation
Executing the Certificate Request Script
In order to develop and distribute JET applications, you must install a package signing
certificate onto the virtual machine (VM). You do this by executing the certificate request
script. This script assists you in creating a signing key and a certificate request for use
with JET.
CAUTION: Never send your signing key to anyone, including Juniper Networks.
The key enables anyone to sign applications that your router will trust.
Therefore, it should be treated with the same level of security as the root
password for the routers. Once you obtain your signing key, save it in a file
outside of the VM.
Before you can run the certificate request script, you must have the provider prefix, which
is a uniquely identifying prefix that represents the name of your organization. This prefix
should have been provided to a contact at your organization. If you do not know this
prefix, request it before running the jet-certificate-request command. Contact JET
Certificate Processing at jet-cert@juniper.net.
Information the script asks for includes the following data:
• City, state, and country
• Your organization and unit
• Provider prefix
Obtain from JET Certificate Processing at jet-cert@juniper.net.
• User string
This is an additional specification of your choosing. It could be a string specifying the

development team or project name. The user string can consist of a lowercase letter
followed by one or more lowercase letters or numbers.
• Deployment scope
This the string assigned by Juniper to differentiate multiple certificates for the same
partner. Leave empty if none was assigned to you.
• Index number

This number is known as a certificate generations number. It will be 1 for your initial
certificate. When a certificate expires and a new one is requested, this number will be
incremented.
• E-mail address
We recommend against using a personal e-mail address for the certificate contact.
To create a signed application, request certificates and copy them as explained in the
following procedure. This procedure is optional if you want to create an unsigned
application.
To create a certificate request manually:
1. In a VM terminal, issue the jet-certificate-request command.
The script leads you through a series of questions.
2. Answer the questions, and press Enter after each answer.
A certificate name is synthesized from this information. The certificate name appears
as the stem of the filenames for two files the script creates in the
/usr/local/junos-jet/certs directory: filename_key.pem and filename_req.pem.
3. Save the filename_key.pem file outside the VM.
Ensure that no one outside of your development organization has access to it. Do not
send this file to Juniper Networks.
4. Send the filename_req.pem file to JET Certificate Processing at jet-cert@juniper.net.
JET Certificate Processing immediately sends your certificate to you.
To copy your certificate:
• Copy the certificate file to the /usr/local/junos-jet/certs directory.
Related • Setting the PATH Environment Variable on page 40

Documentation
• Creating a Development Sandbox on page 42
Creating a Development Sandbox
The two example applications you can include in your sandbox are echoclient and
echoserver.
First, set up the virtual machine (VM) on your system. See Downloading the Packages
You Need. Once the VM is set up, the following tools are pre-installed and available for
use:
• Supporting files and libraries
• Toolchain
• JET client package

Now you are ready to create the development sandbox in the VM and start developing
applications.
To create a development sandbox:
1. In the VM, go to the /home/vagrant directory.
2. If you have not already done so, set your PATH variable.
For details, see “Setting the PATH Environment Variable” on page 40.
3. Create a sandbox by using the mksb command, for example:
vagrant@jet-vm:~$ mksb -n mysandbox
% mksb -n mysandbox
where mysandbox is the name of the sandbox.
NOTE: You can also check out an example application, for example,
vagrant@jet-vm:~$ mksb -n mysandbox echoclient
where echoclient is an example application. The source code and makefiles

of echoclient are also checked out.
You are now ready to start developing an application for a specific language.
Related • Downloading the Packages You Need

Documentation
• Developing an Application by Manual Workflow on page 43
Developing an Application by Manual Workflow
To develop your application, create subdirectories in your sandbox for components of

your application. Then develop the code. Lastly, autogenerate the application makefile.
To develop an application:
NOTE: In this procedure, the sandbox directory might be referred to as $SB

for short. That is, $SB is equivalent to /home/vagrant/sandbox-name.
1. Go to the directory in which you keep your sandboxes.
vagrant@jet-vm:~$ cd /home/vagrant
2. Create subdirectories in the sandbox.
a. Use the workon command to go into your sandbox.
vagrant@jet-vm$ workon sandbox-name

The workon command takes you directly to the $SB/src directory and sets the
sandbox correctly.
Alternatively, you can cd to the src directory of your sandbox.
b. Create subdirectories for application code in $SB/src/python or $SB/src/lib or

$SB/src/bin, based on whether you need Python, library, or bin (executable) files.
3. Develop the code.
4. Write an application JSON file.
For details, see “JSON File Format for JET Application Packaging” on page 32.
5. Autogenerate the appropriate makefiles by running the jet-pkg-gen.py command.
The jet-pkg-gen.py command takes two options:
• The -i option is followed by the path and filename of the JSON file.
• The -p option is followed by the path to the src directory of the sandbox.
For example, if you had a sandbox named demo:
vagrant@jet-vm:~/demo/src$ jet-pkg-gen.py -i /home/vagrant/demo/src/demo.json

-p /home/vagrant/demo/src
This command assumes that you have added the path to jet-pkg-gen.py to your .bashrc
file. If not, you need to include the path to jet-pkg-gen.py:
vagrant@jet-vm:~/demo/src$
/usr/local/junos-jet/16.1R1.3/junos-jet-sb/src/junos/host-utils/scripts/jet-pkg-gen.py
-i /home/vagrant/demo/src/demo.json -p /home/vagrant/demo/src
NOTE: The autogenerated application makefile will be correct for most

cases; if there are any external library dependencies, the makefile must
be adjusted accordingly.
Related • Creating a Development Sandbox on page 42

Documentation
• Building and Creating a JET Application Package Without Using an IDE on page 44
Building and Creating a JET Application Package Without Using an IDE
After development of the application is complete and all the makefiles and manifest file
are ready, the application can be built and packaged.
To build the JET application package:
1. In the directory in which you keep your sandboxes, use the workon command to go
into your sandbox.
vagrant@jet-vm:~$ workon sandbox-name

2. (Optional) Test individual pieces of the application by going to subdirectories and

running mk-i386.
3. Build the entire package.
a. Return to the src directory ($SB/src).
b. Run the mk-i386 package-name command, where package-name is the "app-name"

from the JSON file.
For more on the JSON file, see “JSON File Format for JET Application Packaging”
on page 32.
4. Verify the package is in the $SB/junos-jet-sb-obj/ship/ directory.
vagrant@jet-vm:~/sandbox-name/src$cd
/home/vagrant/sandbox-name/junos-jet-sb-obj/ship
vagrant@jet-vm:~/sandbox-name/junos-jet-sb-obj/ship$ ls
For example, if your application is called demo, you would see the following files:
demo-16.1.R1.1.tgz
demo-16.1.R1.1.tgz.sha1
Related • Developing an Application by Manual Workflow on page 43

Documentation


CHAPTER 4
Developing JET Applications Using Python

• Downloading and Installing the JET Python Client Package on page 48
• Creating an Unsigned Package by Using the Python Packaging Tool on page 51
• Deploying a JET Python Application on page 51
Overview of Developing a JET Application Using Python
You can use Python to develop an application in either of the following circumstances:
• If the application has no dependency on C or C++ modules
• If the application is not required to be signed
The Juniper Extension Toolkit (JET) Python client package provides easy-to-use Python
classes and methods that implement the JET APIs and simplifies the process of using
the Message Queue Telemetry Transport (MQTT) protocol to receive JET notifications.
We recommend that you use the Python client package for Python application
development, but it is not mandatory. You can still directly interact with the interface
definition language (IDL) APIs and use any MQTT library to develop a JET application
using Python.
Figure 3 on page 47 shows the workflow for using JET to develop Python applications.
Table 9 on page 48 links each part of the workflow in Figure 3 on page 47 to a topic in
this chapter.
Figure 3: Developing a JET Application Using Python
A B C D
Download Use the Python Deploy an
Develop
and install the packaging tool application package
an application
JET API package to create an on the external server
by using an IDE
from juniper.net unsigned package
Any OS
Linux, FreeBSD, etc.
g043243
External
server

Table 9: Steps Involved in Developing a JET Application Using Python

A “Downloading and Installing the JET Python Client Package” on page 48
B “Developing an Application by Using the JET Python Client Package” on

page 49
C “Creating an Unsigned Package by Using the Python Packaging Tool” on

page 51
D “Deploying a JET Python Application” on page 51
Related • Downloading and Installing the JET Python Client Package on page 48
Documentation
Downloading and Installing the JET Python Client Package
Python version 2.7 should be available in the development environment.
To download and install the JET Python client package:
1. Download the JET Python client package from the Juniper Networks website at
http://www.juniper.net/support/downloads/?p=jet#sw to your development machine.
2. Go to the directory where you want to install the JET Python client package.
This is the python-install-path.
3. Install the JET Python client package on the development machine.
You can install the JET Python client package in one of the following ways:
• Use the pip install command—This is the recommended way to install the JET
Python client package. For example, where jet-1.0.1.dev.tgz is the JET Python client
package name:
pip install jet-1.0.1.dev.tgz
• Use the python setup.py install command—Use this command when the pip install
command is not available.
a. Extract files from the JET Python client package.
For example, where jet-1.0.1.dev.tgz is the JET Python client package name:
% tar –xvzf jet-1.0.1.dev.tgz
b. Go to the JET Python client package directory.
% cd jet-1.0.1.dev
c. Issue the python setup.py install command.

Chapter 4: Developing JET Applications Using Python
% python setup.py install
After installing the client package, you should see the following directory structure in
the python-install-path/site-packages/jnpr/jet/ directory:
Related • Developing an Application by Using the JET Python Client Package on page 49
Documentation
Developing an Application by Using the JET Python Client Package
You can choose any editor for developing the JET application. For example, you can use
the PyCharm IDE or Eclipse to develop and debug Python applications, or use a text editor
(such as vi) to write a Python file. Also, you can use any programming framework that
you prefer.
For a tutorial on building a JET application that has no dependency on C or C++ modules
and does not have to be signed, see the Juniper Extension Toolkit Getting Started Guide.
For more information on JET notification APIs, see the Juniper Extension Toolkit API Guide.
The JET Python client package provides wrapper APIs to simplify using Thrift and the
Message Queue Telemetry Transport (MQTT) protocol. With the JET client package, you
can interact with Python classes and methods provided by the JET Python package.
JetHandler is the main class that you will use to interact with a device running a JET
application. The JetHandler class contains methods to establish connections with a
device running Junos OS, execute APIs, and subscribe to notifications.
When you write a JET application for request-response interactions using the JET Python
client package, the application typically creates one instance of the JetHandler class for
each device. The application then uses one of the following methods to connect to the
device:
• OpenRequestResponseSession() to establish a request-response connection
• OpenNotificationSession() to establish a notifications connection
Once connected in request-response service, an application can use a method such as

OpenRequestResponseSession() to obtain objects that allow the application to make
API calls.

Once connected in notification service, an application can use a method such as

OpenNotificationSession() to create topics to which the application subscribes.
When the application has completed its communications with the device, it will call the
CloseRequestResponseSession() or CloseNotificationSession() method to close its
connection to the device.
For JET applications that support notification subscription, you can choose the appropriate
create method and subscribe to it.
For running JET Python applications on a device running Junos OS, you can configure
command-line arguments for the file. For example, if you had the following script, you
can supply the arguments from the Junos CLI using the arguments configuration statement
at the [edit system extensions extension-service application file filename hierarchy level:
import argparse
def main():
parser = argparse.ArgumentParser(description='This is a demo script.')
parser.add_argument('-arg1', required=True)
parser.add_argument('-arg2', required=True)
args = parser.parse_args()
print args.arg1
print args.arg2
if __name__ == '__main__':
main()
To configure the arguments in the CLI:
1. Enter configuration mode.
user@device> configure
Entering configuration mode
[edit]
user@device#
2. Configure the command-line arguments.
user@device# set system extensions extension-service application file cmdline_args.py

argument “-arg1 foo -arg2 goo”
3. Commit.
user@device# commit
4. Start the application.
user@device# exit
user@device> request extension-service start cmdline_args.py
Extension-service application 'cmdline_args.py' started with pid: 99418
foo
goo

Chapter 4: Developing JET Applications Using Python
Related • Building Your First JET Application

Documentation
• Creating an Unsigned Package by Using the Python Packaging Tool on page 51
Creating an Unsigned Package by Using the Python Packaging Tool
If you do not include the language python statement, you cannot execute unsigned Python
scripts on a device running Junos OS.
To create an unsigned JET Python application package:
1. Write the script setup.py.
The setup.py file is a Python file that usually tells you that the module or package you
are about to install has been packaged and distributed with distutils, which is the
standard way to distribute Python modules.
2. Use the sdist command to create a source distribution and to create a tar gzip package
file.
% python setup.py sdist –formats=gztar
Related • Building Your First JET Application

Documentation
• Deploying a JET Python Application on page 51
Deploying a JET Python Application
You can deploy Python applications on an external server or on a device running Junos
OS.
To deploy a Python JET application on an external server, we recommend that you install
the JET Client package on the server. To verify the installation, you should run the sample
applications provided in the JET Client package.
The following deployments of Python applications on devices running Junos OS are

supported:
• Regular Junos OS (veriexec-enabled Junos OS) with the python configuration enabled
at the [edit system scripts language] hierarchy level. In this scenario, the system will
not perform veriexec checks for a Python application as long as the application is
located under the /var/db/scripts/jet directory and configured at the [edit system
extensions] hierarchy level. In this scenario, an unsigned package for a Python-only
application (a Python script with no dependencies on unsigned shared libraries) will
work. Any application in a signed package will also work.
• Regular Junos OS (veriexec-enabled Junos OS) with the python configuration disabled
at the [edit system scripts language] hierarchy level. In this environment, only those

Python scripts that are part of a signed package can be executed. Therefore, only a
signed package will work for this scenario.
NOTE: Junos OS supports using symbolic links for files in the

/var/db/scripts/jet directory, but the device will only execute the script at the
target location if it is signed.
Related • Overview of Developing a JET Application Using Python on page 47

Documentation

CHAPTER 5
Developing Applications Using Other

Languages

• Downloading and Compiling the IDL File on page 54
Overview of Developing a JET Application Using IDL
To develop JET applications in languages other than Python, you need the interface
definition language (IDL) APIs and a Message Queue Telemetry Transport (MQTT) library.
IDL is a language-agnostic way of defining APIs.
The MQTT protocol is used to notify clients about Junos OS events. MQTT is a
publish-subscribe based messaging protocol for use on top of the TCP/IP protocol. The
publish-subscribe messaging pattern requires a message broker. The message broker is
responsible for distributing messages to the interested clients based on the topic of a
message. Clients register with the message broker and inform the message broker about
the topics for which they are interested in receiving messages. For more details, see
http://mqtt.org/.
Figure 4: Developing a JET Application Using IDL
Table 10: Steps Involved in Developing a JET Application Using IDL

A and B “Downloading and Compiling the IDL File” on page 54
C “Developing an Application by Using the JET Python Client Package” on

page 49

Table 10: Steps Involved in Developing a JET Application Using

IDL (continued)
D “Creating an Unsigned Package by Using the Python Packaging Tool”

on page 51

Documentation
Downloading and Compiling the IDL File
For developing applications in languages other than Python, you need the interface
definition language (IDL) APIs and a Message Queue Telemetry Transport (MQTT) library.
The application developer can use any operating system (OS), for example, Linux or
Windows, for the development environment.
Before you begin, install the Thrift compiler and dependent libraries.
NOTE: For information about installing the Thrift complier and dependent
libraries, see https://thrift.apache.org/docs/BuildingFromSource.
For the application to receive notifications, install an MQTT library for the
specific language. For more details, see http://mqtt.org/.
To download and compile the IDL file:
1. Download the IDL file from the Juniper Networks website at

www.juniper.net/support/downloads/.
2. Compile the IDL file by using the Thrift compiler.
The following is an example command that is specific for generating Java code, but
the thrift -r -gen command can be used for other languages as well:
% thrift –r –gen java RouteService.thrift
For the application to receive notifications, install an MQTT library for the specific
language. For more information, see the Juniper Extension Toolkit API Guide.
Related • Overview of Developing a JET Application Using IDL on page 53

Documentation

CHAPTER 6
Debugging JET Applications
• Debugging Tips on page 55

• Debugging JET Applications on a Device Running Junos OS on page 56
Debugging Tips
You must enable the extension-service traceoptions on the Junos OS device before writing
the sample applications.
In case your application is not able to connect to the Junos service process (jsd):
1. Check whether jsd is up and running on the Junos OS device using the following
command:
ps aux | grep jsd
If not, then restart jsd.
2. If jsd is up, verify the configuration is present on the device using the following CLI
command in configuration mode:
user@device# show system services extension-service
3. If the configuration is present, verify if jsd is listening on configured port 9090:
nestat -a | grep ‘9090’
You should see a matching entry. If you do not, then restart jsd.
To eliminate any firewall issues, use an on-device application to test.
In case of notification applications, verify that your client IP source address (the address
from which the connect is happening) is added to the list of allowed clients in the jsd
notification configuration.
Ensure that dual Routing Engines on devices running Junos OS have master mode running.
We do not support jsd on backup Routing Engines.
Ensure that the maximum number of notification connections as configured on the device
are not exceeded. Use the following command to see the clients:
netstat -a | grep 1883

Debugging JET Applications on a Device Running Junos OS
For debugging applications on a device running Junos OS, you can configure the trace
file and trace option with the system extension-service statement.
For non-daemonized applications that run on the router, you can invoke the debugger at
the same time that you install the application.
To load your application along with the debugger:
1. Use the request extension-service start invoke-debugger cli command.
user@device> request extension-service start invoke-debugger cli application-name.py

Extension-service application 'application-name.py' started with pid: 71246
2. Enter help to display a list of the supported commands.
(Pdb) help
Documented commands (type help <topic>):
========================================
EOF bt cont enable jump pp run unt
a c continue exit l q s until
alias cl d h list quit step up
args clear debug help n r tbreak w
b commands disable ignore next restart u whatis
break condition down j p return unalias where
Miscellaneous help topics:
==========================
exec pdb
Undocumented commands:
======================
retval rv

Juniper Extension Toolkit Developer Guide: Release

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Juniper Extension Toolkit Developer Guide: Release

Uploaded by

Copyright:

Available Formats

Juniper Extension Toolkit Developer Guide

Copyright © 2016, Juniper Networks, Inc.

Juniper Extension Toolkit Developer Guide

YEAR 2000 NOTICE

END USER LICENSE AGREEMENT

ii Copyright © 2016, Juniper Networks, Inc.

Copyright © 2016, Juniper Networks, Inc. iii

JSON File with All Attributes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

iv Copyright © 2016, Juniper Networks, Inc.

Copyright © 2016, Juniper Networks, Inc. v

vi Copyright © 2016, Juniper Networks, Inc.

Copyright © 2016, Juniper Networks, Inc. vii

viii Copyright © 2016, Juniper Networks, Inc.

• Documentation and Release Notes on page ix

Documentation and Release Notes

Table 1 on page x defines notice icons used in this guide.

Copyright © 2016, Juniper Networks, Inc. ix

Table 1: Notice Icons

Informational note Indicates important features or instructions.

Warning Alerts you to the risk of personal injury or death.

Tip Indicates helpful information.

Best practice Alerts you to a recommended use or implementation.

Table 2: Text and Syntax Conventions

x Copyright © 2016, Juniper Networks, Inc.

Table 2: Text and Syntax Conventions (continued)

| (pipe symbol) Indicates a choice between the mutually broadcast | multicast

Indention and braces ( { } ) Identifies a level in the configuration [edit]

We encourage you to provide feedback, comments, and suggestions so that we can

Copyright © 2016, Juniper Networks, Inc. xi

• E-mail—Send your comments to techpubs-comments@juniper.net. Include the document

Requesting Technical Support

• JTAC policies—For a complete understanding of our JTAC procedures and policies,

• Product warranties—For product warranty information, visit

Self-Help Online Tools and Resources

• Find CSC offerings: http://www.juniper.net/customers/support/

• Search for known bugs: http://www2.juniper.net/kb/

• Find product documentation: http://www.juniper.net/techpubs/

• Download the latest versions of software and review release notes:

• Search technical bulletins for relevant hardware and software notifications:

• Join and participate in the Juniper Networks Community Forum:

• Open a case online in the CSC Case Management tool: http://www.juniper.net/cm/

Opening a Case with JTAC

• Use the Case Management tool in the CSC at http://www.juniper.net/cm/.

• Call 1-888-314-JTAC (1-888-314-5822 toll-free in the USA, Canada, and Mexico).

xii Copyright © 2016, Juniper Networks, Inc.

For international or direct-dial options in countries without toll-free numbers, see

Copyright © 2016, Juniper Networks, Inc. xiii

xiv Copyright © 2016, Juniper Networks, Inc.

• Juniper Extension Toolkit Overview on page 15

Juniper Extension Toolkit Overview

JET supports the following:

• Multiple languages for applications that run off-box

• Python for applications that run on a device running Junos OS

• An event notification method that enables the applications to respond to selected

JET APIs are synchronous in nature.

• JET Interaction with Junos OS on page 16

Copyright © 2016, Juniper Networks, Inc. 15

JET Interaction with Junos OS

Figure 1 on page 16 illustrates the request-response and notification services.

Figure 1: JET Request-Response and Notification Services

JET Application Development

16 Copyright © 2016, Juniper Networks, Inc.

This guide covers the following JET application development scenarios: