The Great Plains Environment for Network Innovation (GpENI) is a high-speed, international network and research testbed with nodes located around the world. There are a growing number of member institutions who host and administer the testbed and who help develop a PlanetLab-based GENI control framework. (more | wiki)
This site demonstrates a PlanetLab-based testbed running on GpENI. It querys the testbed controller for current information using a custom AJAX adapter for the PLC API. It also allows anyone to visually construct network paths and measure their latency on the live testbed. The implementation is discussed later on this page. The site's main sections are summarized below.
We expect this site to function in any modern, standards-compliant desktop browser, including the latest stable versions of Firefox, Chrome, and Safari.
The original version of this demonstration was prepared for the fourth GENI Engineering Conference in April 2009 and remains online for archival purposes.
GpENI is composed of universities and other institutions from around the world. The GpENI wiki is the best place to learn more about the project, including details about the network infrastructure, software architecture, and past and future milestones. We also publish news updates to our MyPLC website (note that sign-up is currently limited to GpENI members).
GpENI is funded in part by the National Science Foundation's GENI project. We belong to Cluster B, tasked with developing a PlanetLab-based GENI control framework.
This demonstration is composed primarily of three custom-developed components:
The AJAX adapter consists of a client-side JavaScript adapter and a server-side CGI script. Together, they provide a JSON interface for executing arbitrary PLC API calls asynchronously from a web browser.
JavaScript application code sends PLC API calls to the adapter,
along with a callback to invoke with the data returned from MyPLC.
The adapter packages each API call as an object, which is encoded (or
“stringified”) as JSON with the help of a public domain
script, and sent as the
content of an HTTP POST request to the CGI script.
Later, the CGI script responds with the JSON-encoded results, which
are decoded into a JavaScript object and passed to the callback
function provided by the application.
The CGI script, written in Python, serves two purposes. First, it
acts as a same-origin proxy for XMLHttpRequest
AJAX requests, which provide the only mechanism for asynchronously
POSTing data but which, for security reasons, cannot be
addressed to the MyPLC server
if it resides on a different domain. Second, it translates the call
from its object representation (which is simple to work with in
JavaScript) to PLC API–compliant XML-RPC, and it performs the
inverse translation for returned data.
ProbeLoop is an application that runs in a GpENI slice and is deployed on all nodes. It measures the time it takes to forward a small packet through any sequence of GpENI nodes that begins and ends at the same node.
ProbeLoop consists of two Python programs. The first is a simple relay that listens for UDP packets containing a list of addresses, moves the first address in the list to the end, and sends to that address the updated list. The second is a simple web server that listens for requests to probe a specified loop, performs the delay probe several times, and responds with a summary of the results.
Requests to ProbeLoop are HTTP GET requests with a
sequence of nodes in the query part of the URL. The sequence
of nodes specifies the interior of the loop to probe; the loop
implicitly begins and ends with the node handling the request, which
we call the anchor. The anchor generates a UDP packet with a
list of addresses such that the relay algorithm (described above) will
forward the packet through the specified loop. The anchor sends the
packet to the relay on the next node along the loop, saves the system
time, waits to receive the packet again after it has traversed the
loop, and finally measures the elapsed time, which it uses as an
estimate of “loop latency”.
The measurement described above is actually performed several times. The first result is discarded since it might be influenced by ARP requests (though no DNS lookups are performed). The others are summarized (the average, minimum, and maximum latencies are calculated) and encoded as JSON for the HTTP response from the anchor.
Since the website is making asynchronous GET requests
here, it is not restricted to same-origin-only
XMLHttpRequest-based AJAX. Instead, it uses dynamically-inserted
<script> tags and the JSONP
convention to communicate with the loop anchor directly.
The website relies heavily on the excellent jQuery library for cross-browser AJAX and DOM manipulation. It also makes use of the Google Maps API to help users visualize the loops they construct.
Click a site's name in the list or its marker on the map for details about the site. Generate and measure loops with the controls above the map.
Click a site's name in the list or its marker on the map to insert the site into the loop at the cursor position. See the loop definition to set the cursor position (the red box) and to remove sites from the loop.
The table below shows the status and main properties of all GpENI nodes. The information is obtained from the node registry on the GpENI MyPLC.
| Nickname | Status | Last contact* | Host name | IP address | Site | # Slices | Created | Model |
|---|---|---|---|---|---|---|---|---|
* Retrieved ago. Computation depends on local settings and is unreliable.
Slice statistics are available on our CoMon slice statistics page.
Slice information is collected with CoMon, an application developed by Princeton that runs within a slice but is given access to information about other slices. CoMon also reports information about GpENI nodes.
The geniwrapper module, developed by PlanetLab, implements the GENI interface in a wrapper layer around the standard PlanetLab interfaces. GpENI has installed geniwrapper on its MyPLC controller, which is an important step in the process of creating a PlanetLab-based testbed that can export resources to the worldwide GENI research network.
The sfi command line tool was developed by PlanetLab
to provide a simple UI to query the GENI interface. For demonstration
purposes, we have site-specific sfi output for each GpENI
site. See the sites map, click any site, and
maximize the resulting "bubble" in order to see site details,
including the sfi output.
The GENI User Shell (Gush) project at Williams College provides software that helps researchers deploy and manage their experiments on GENI testbeds. During GEC4, a Gush developer added GpENI support so that Gush can be used to simultaneously deploy and manage experiments on GpENI and PlanetLab. The Gush wiki has a tutorial with the details.
The PlanetLab Hello World tutorial describes a step-by-step process for deploying an application into a PlanetLab slice that reports the geographic coordinates of the node on which it is running to a central server, which generates a corresponding KML file. We duplicated the experiment on GpENI. Below, you can download the resulting KML (for Google Earth) or you can simply load it into an embedded map.
