NetPacket (NetP) version 2 readme file

NetPacket is a cross-language, cross-platform wrapper around PVM for
the purpose of transparently and easily sending data from one process
to another.  It should work in C++, Python, and Java, on Linux and Mac
OS X.  If it doesn't, tell me what's wrong so I can try to fix it
(eepness@mit.edu).

Instructions given make the following assumptions (adjust for your
situation accordingly):

Your shell is tcsh.
Your OS is Linux.
Your PVM is installed in /mas/cogmac/pvm3 (most normal linux
installations put it in /usr/share/pvm3) (If you don't have pvm, go
get it from http://www.csm.ornl.gov/pvm/pvm_home.html).
You keep your working sources in ~/svn.
Your java installation is in /opt/jdk.
Also, you need swig to convert the API to Java and Python.  Check
www.swig.org.  We use swig-1.3.21.
Oh, and make sure you have "scons" installed.  That's an alternative
to the standard "make".  It's pretty straightforward to get and can
be found at www.scons.org if "which scons" says you haven't got it.

Any environment settings mentioned here should be made in your .cshrc
(or .bashrc or equivalent) if you want them to work for future logins.
In all relevant cases I assume you want to append to environment
variables, but if the given variable doesn't already exist, just set
it instead of appending.

i.e., "setenv PATH /usr/local/bin"
instead of "setenv PATH ${PATH}:/usr/local/bin"

*************************************************************************

Installation

1. Download the source

(for people at the MIT Media Lab; if you're elsewhere, you'll
hopefully have solved the downloading bit already.)
% cd ~/svn
% svn checkout file:///mas/cogmac/svn/trunk/pvm/netp2

2. Compile

% cd netp2
% setenv PVM_ROOT /mas/cogmac/pvm3
("setenv PVM_ROOT /usr/share/pvm3" for many linux distributions)
% setenv PVM_ARCH LINUX
("setenv PVM_ARCH LINUXI386" for many linux distributions)
% setenv PVM_RSH /usr/bin/ssh
% setenv JAVA_HOME /opt/jdk
% scons all

(just "scons" if you wish to skip Java and Python installation --
don't set JAVA_HOME in that case.)

3. Start PVM

(you can use a hostfile:)
% cat > hostfile.txt
host1.mit.edu lo=username1
host2.mit.edu lo=username2
host3.mit.edu
<ctrl-d>
% pvm hostfile.txt

(or you can add hosts manually:)
% pvm
pvm> add host1.mit.edu
pvm> add host2.mit.edu

Either way, make sure the path to the "pvm" executable is in your PATH
environment variable.  Notice that with the hostfile, you can specify
what username to login to each machine with.  Notice also that each
and every computer you add to your PVM list must also have PVM
installed, must have "pvm" in the default PATH variable of that
account, and must set PVM_RSH, PVM_ROOT, and PVM_ARCH appropriately as
mentioned above.

Whenever you get stuck setting up pvm, first verify that you can ssh
to each machine.  Run pvm manually on each machine to ensure that it
runs, and then do a "halt" to bring pvm on that machine down.  _All_
machines on your PVM network must be added from one single host, so
make absolutely sure you're not already running the pvm daemon on any
of your other machines already.  If pvm is having trouble running on a
single machine, do a "ps aux" and kill any pvm-related processes lying
around, and then "rm /tmp/pvm*" to remove any temporary files.  Then
try to bring up pvm again.

Sometimes you get a "host is loopback" error.  This is (iirc) because
the machine can't look up its own ip address because its /etc/hosts
has its name listed as 127.0.0.1.  Just take the machine's hostname
entry out of /etc/hosts so PVM can look up the machine's actual ip, or
else start your initial PVM daemon from another machine.

Notice also that if you happen to close the pvm console from which you
originally added all the machines (you can close the console with
"quit"), re-running pvm to add more machines may result in password
prompts showing up in weird places and non-attached consoles, meaning
you'll never be able to type the password to complete the ssh tunnel.
You're best off not closing your pvm console until you're ready to
halt pvm.

When you're done using pvm, "halt" at the pvm console will kill all
connected pvm machines simultaneously.

If you get sick of typing passwords for every added machine every
time, look into using ssh-agent and ssh-add.  Left as an exercise to
the reader.

4. Set up for your preferred languages.  Test that it's working.

C++:

% setenv LD_LIBRARY_PATH ${LD_LIBRARY_PATH}:${HOME}/svn/pvm/netp2/lib/${PVM_ARCH}
% cd tests
% xterm -e ./recvtest
% xterm -e ./sendtest

Java:

% setenv LD_LIBRARY_PATH ${LD_LIBRARY_PATH}:${HOME}/svn/pvm/netp2/lib/${PVM_ARCH}
% setenv CLASSPATH ${CLASSPATH}:${HOME}/svn/pvm/netp2/lib/${PVM_ARCH}/netp.jar
% cd tests
% xterm -e java RecvTest
% xterm -e java SendTest

Python:

% setenv LD_LIBRARY_PATH ${LD_LIBRARY_PATH}:${HOME}/svn/pvm/netp2/lib/${PVM_ARCH}
% setenv PYTHONPATH ${PYTHONPATH}:${HOME}/svn/pvm/netp2/lib/${PVM_ARCH}
% cd tests
% xterm -e python sendtest.py
% xterm -e python recvtest.py

************************************************************************

Usage

The relevant header files are in netp2/include, and the relevant
library files are in netp2/lib/${PVM_ARCH}.  If you want, you can
install these somewhere else, but I'm going to assume you can just
reference libraries from where you just compiled them to.

The basic premise: make a NetP object.  If you pass a string to the
constructor, it's a send packet, sending on that channel.  If you
don't, it's a receive packet, and you must call joinChannel() to
subscribe it to channels you want it to receive on.

On the send side, create the NetP object, put data into it, and then
run send().

On the receive side, create the NetP object, subscribe it to channels,
and then loop waiting for data to be received.  All the receive
functions return a string corresponding to the channel on which the
data was received.  nReceive() is a non-blocking receive, which
returns an empty string if nothing has been received.  bReceive() is a
blocking receive, which waits until something has been received.
tReceive() is a timed receive, which takes an argument in seconds for
how long to wait to see if a packet comes in; it returns the empty
string if nothing has been received in that amount of time.

Similarly, nReceiveNewest(), bReceiveNewest(), and tReceiveNewest()
work the same way, only they discard all older packets.  peek() tells
you if a packet is waiting to be received.

Once a packet has been received, check which channel it came in on,
and decide what to do with the included data.

Examples follow...

------------------------------------------------------

- C++

(For environment settings see the last part of the "compile" section)

-- Compile options:

g++ -o myprogram myprogram.cpp -I ${HOME}/svn/pvm/netp2/include -L ${HOME}/svn/pvm/netp2/lib/${PVM_ARCH} -lnetp

-- send code:

#include "NetP.h"

int main() {
  NetP sendp("MyChannel"); // channel argument means it's a send instance
  sendp.data() = 1; // data() is a PData; more details later
  sendp.send();
  sendp.data().eval("[1, 2, 3, 4, 5]"); // make a list PData
  sendp.send();
}

-- simplest receive code:

#include "NetP.h"

int main() {
  NetP recvp; // no argument means it's a receive instance
  recvp.joinChannel("MyChannel");
  string resp = recvp.bReceive(); // blocking receive
  cout << recvp << endl;
}

-- typical receive code:

#include "NetP.h"

int main() {
  NetP recvp; // no argument means it's a receive instance
  recvp.joinChannel("MyChannel");
  while (1) { // loop forever
    string resp = recvp.bReceive(); // blocking receive
    if (resp == "MyChannel") { // receive instances can get many channels, so check which channel
      if (recvp.data().getType() == "int") { // check type of PData
        int result = (int)recvp.data(); // PData's can print directly, or be cast to primitive types
        cout << "int: " << result << endl;
      }
      else if (recvp.data().getType() == "list") {
        for (int i=0; i<recvp.data().size(); i++) {
	  int result = (int)recvp.data()[i];
	  cout << "list: " << result << endl;
        }
      }
    }
  }
}

-------------------------------------------------------

- Java

(For environment settings see the last part of the "compile" section)

-- send code:

import netpacket.NetP;

class examplesend {
  public static void main(String[] args) {
      NetP sendp = new NetP("MyChannel"); // channel argument means it's a send instance
    sendp.data().set(1);
    sendp.send();
    sendp.data().eval("[1, 2, 3, 4, 5]");
    sendp.send();
  }
}

-- receive code:

import netpacket.NetP;

class examplerecv {
    public static void main(String[] args) {
	NetP recvp = new NetP(); // no argument means it's a receive instance
	recvp.joinChannel("MyChannel");
	while (true) {
	    String resp = recvp.bReceive(); // blocking receive
	    if (resp.equals("MyChannel")) { // receive instances can get many channels, so check which channel
		if (recvp.data().getType().equals("int")) { // check type of PData
		    int result = recvp.data().getInt();
		    System.out.println("Got: " + result);
		}
		if (recvp.data().getType().equals("list")) {
		    for (int i=0; i<recvp.data().size(); i++) {
			int result = recvp.data().get(i).getInt();
			System.out.println("List: " + result);
		    }
		}
	    }
	}
    }
}

----------------------------------------------------------------

- Python

(For environment settings see the last part of the "compile" section)

-- send code:

import netpacket

sendp = netpacket.NetP("MyChannel") # argument means it's a send instance
a = 1
sendp.data().eval(repr(a)) # efficient; data() parses only as-needed
sendp.send()
a = [1, 2, 3, 4, 5]
sendp.data().eval(repr(a))
sendp.send()

-- receive code:

import netpacket

recvp = netpacket.NetP() # no argument means it's a receive instance
recvp.joinChannel('MyChannel')
while (True):
    resp = recvp.bReceive() # blocking receive
    if resp == 'MyChannel':
        a = eval(repr(recvp))
        if type(a) is int:
            print "int", a
        if type(a) is list:
            print "list", a



**********************************************************************************

Using PData

The most involved part of NetP is the PData structure, which you
access by calling its data() function.  Below, I list a few examples
of things to do with PData's, and anywhere you see a PData type being
used, you should be able to do the same thing with a NetP's data()
field, except for constructors (since the NetP comes with data()
constructed for you).

There are five types of PData's: int, float, string, list, and map.

In general:

Primitive types can be created and initialized using operator= (C++
only) or set():

PData p;
p = 2;
p = 3.14;
p = "mystring";
p.set(2);
p.set(3.14);
p.set("mystring");

The "eval" function evaluates a Python-like string representation.
Numbers are represented literally as themselves:

PData p("eval", "2");
p.eval("2.5");

Strings are represented with single-quotes around them:

PData p("eval", "'mystring'");

Lists are represented with square brackets and commas:

PData p("eval", "[1, 2, 3, 4, 5]");

And maps are represented with braces, colons, and commas.
Furthermore, their keys have to be strings, but their values can be
any type:

PData p("eval", "{'x': 2, 'y':3.5, 'name':'aardvark', 'objects':[2, 3, 7]}");

The only places where these kinds of representation strings are
relevant are in the context of the eval function (either p.eval, or
the command constructor PData("eval", "repstring") ).  Also, they are
used as outputs for toString() and ostream<<.  

A more transparent way to initialize things is to use their type:

PData p("init", "map");
p.init("list");

This is completely equivalent to using their repstrings, though:

PData p("eval", "{}");
p.eval("[]");

In C++, to extract your data to primitive types, you can cast it, and
to extract fields from complex type, use square brackets:

PData p("mystring"); // single-string constructor just creates a string
string s = (string)p;
p.eval("[1, 2, 3, 4, 5]");
int i = (int)p[2];
p.eval("{'item1':1.5, 'item2':2.5}");
double d = (double)p["item1"];

And in other languages, use the getInt, getDouble, and getString
functions to extract primitive types, with the get() function to get
fields:

PData p = new PData("mystring");
String s = p.getString();
p.eval("[1, 2, 3, 4, 5]");
int i = p.get(2).getInt();
p.eval("{'item1':1.5, 'item2':2.5}");
double d = p.get("item1").getDouble();

Any PData can be overwritten to any arbitrary type using operator=
(C++ only), set, eval, or init.  This means you can have an int-type
PData, and if you set it to a string, it is now a string-type PData.
If you call operator[] or get() on a list with an out-of-bound value,
it returns an error.  If you call operator[] or get() on a map,
however, it automatically creates that field if it doesn't already
exist.

-------------------------------------------

Python example:
  Because PData is based on Python syntax, very little use of PData is
necessary.  Just make an arbitrary Python object consisting of ints,
floats, strings, lists, and dictionaries, and call the eval of your
PData on the repr() of the object:

import netpacket

my_object = {'a':1, 'b':2, 'c':3, 'd':[1, 2, 3, 4, 5]}
my_object['e'] = {'h':'asdfjkl;', 'k':3.78}

np = PData()
np.eval(repr(my_object))

# likewise, for the NetP:
sendp = netpacket.NetP('MyChannel')
sendp.data().eval(repr(my_object))
sendp.send()

# in the other direction:
recvp = netpacket.NetP()
recvp.joinChannel('MyChannel')
recvp.bReceive()
my_object = eval(repr(recvp))

--------------------------------------------

C++ example:

#include "NetP.h"

int main() {
  // using ints
  PData int_a(1); // make int in constructor
  PData int_b; // default constructor
  int_b = 2; // set with =
  int_a = 3;
  int_b = int_a;
  int i = int_b; // cast to int
  i = int_a;
  PData int_c("init", "int"); // use command form of constructor (two string arguments)
  int_c = 4; // set with =
  PData int_d("eval", "5"); // use "eval" command form of constructor
  int j = int_d;
  int_c = "make a string instead"; // use = to set a new type and value
  int_d.eval("[1, 2, 3, 4, 5]"); // use eval() to set a new type and value
  cout << int_a << " " << int_b << " " << int_c << " " << int_d << " " << 
    i << " " << j << endl;

  // using floats
  PData float_a(1.5); // make float in constructor
  PData float_b; // default constructor
  float_b = 2.5; // set with =
  float_a = 3.5;
  double f = float_a; // cast to double
  PData float_c("init", "float"); // use "init" command form of constructor
  float_c = 4.5;
  PData float_d("eval", "5.5"); // use "eval" command form of constructor
  double g = float_d;
  float_c = "make a string instead"; // use = to set a new type and value
  float_d.eval("'now it's a string too'"); // use eval to set a new type and value
  cout << float_a << " " << float_b << " " << float_c << " " << float_d <<
    " " << f << " " << g << endl;
    
  // using strings
  PData string_a("asdf"); // make string in constructor
  PData string_b; // default constructor
  string_b = "sdfg"; // set with =
  string_a = "dfgh";
  string s = string_a; // cast to string
  PData string_c("init", "string"); // use "init" form of constructor
  string_c = "jkl;";
  string t = string_c;
  string_c.eval("2"); // use eval() to set new type and value
  PData string_d;
  string_d.eval("'fghj'"); // use eval() to set a string
  cout << string_a << " " << string_b << " " << string_c << " " << string_d <<
    " " << s << " " << t << endl;

  // using lists
  PData list_a("eval", "[1, 2, 3, 4, 5]"); // use "eval" constructor to make list
  PData list_b("init", "list"); // use "init" constructor to make list
  list_b.append(1); // use append() to add items
  list_b.append(3.5);
  list_b.append(PData("eval", "[2, 3, 4]")); // use append() to add complex item
  list_b.append(list_a); // and another complex item
  PData list_c;
  list_c.init("list"); // use init() to make a list
  int k = list_a[0]; // extract a value from a list
  double h = list_b[1]; // extract another value
  list_c = list_b[2]; // extract a complex value into a PData
  cout << list_a << " " << list_b << " " << list_c << " " << k <<
    " " << h << endl;

  cout << "list_a.has(1):" << list_a.has(1) << endl; // demonstrate has() usage
  cout << "list_a.has(0):" << list_a.has(0) << endl;
  cout << "list_a.find(3):" << list_a.find(3) << endl; // demonstrate find() usage
  cout << "list_a.find(0):" << list_a.find(0) << endl; // returns list_a.size() if not found
  list_a.erase(list_a.find(3)); // erase index 2 out of 0...4
  cout << "list_a.find(3):" << list_a.find(3) << endl; // returns 4 (valid indices are 0...3)

  // using maps
  PData map_a("eval", "{'one': 1, 'two': 2, 'three': 3}"); // use "eval" to make map in constructor
  PData map_b("init", "map"); // use "init" to make map
  map_b["1"] = 4; // set a new value
  map_b["2"] = 5; // set another new value
  map_a["four"] = "seven"; // and another one
  map_a["one"] = 9; // change an old value
  int x, y;
  x = map_a["one"]; // get a value
  y = map_b["2"]; // get another value
  PData& node = map_b["listitem"]; // cache a node as a shortcut to add stuff
  node.init("list"); // must initialize the type of the node before doing stuff
  node.append(1); // add stuff
  node.append(2);
  PData& node2 = map_b["mapitem"].init("map"); // cache another node, initialize at the same time
  node2["3"] = 6; // set a value
  node2["4"] = 7;
  cout << map_a << " " << map_b << " " << x << " " << y << endl;
  cout << "map_a.hasKey(\"one\"):" << map_a.hasKey("one") << endl; // demonstrate hasKey()
  cout << "map_a.hasKey(\"seven\"):" << map_a.hasKey("seven") << endl;

  map_a.erase("one"); // demonstrate erase()
  cout << map_a << endl;  
}

---------------------------------

Java example:

import netpacket.NetP;
import netpacket.PData;

class examplepdata {
    public static void main(String[] args) {
	// using ints
	PData int_a = new PData(1); // make int in constructor
	PData int_b = new PData(); // default constructor
	int_b.set(2); // set with set()
	int_a.set(3);
	int_b.set(int_a);
	int i = int_b.getInt(); // get the int
	i = int_a.getInt();
	PData int_c = new PData("init", "int"); // use command form of constructor (two string arguments)
	int_c.set(4); // set with set()
	PData int_d = new PData("eval", "5"); // use "eval" command form of constructor
	int j = int_d.getInt();
	int_c.set("make a string instead"); // use = to set a new type and value
	int_d.eval("[1, 2, 3, 4, 5]"); // use eval() to set a new type and value
	System.out.println(int_a + " " + int_b + " " + int_c + " " + int_d +
			   " " + i + " " + j);

	// using floats
	PData float_a = new PData(1.5); // make float in constructor
	PData float_b = new PData(); // default constructor
	float_b.set(2.5); // set with set()
	float_a.set(3.5);
	double f = float_a.getDouble(); // get the double
	PData float_c = new PData("init", "float"); // use "init" command form of constructor
	float_c.set(4.5);
	PData float_d = new PData("eval", "5.5"); // use "eval" command form of constructor
	double g = float_d.getDouble();
	float_c.set("make a string instead"); // use set() to set a new type and value
	float_d.eval("'now it's a string too'"); // use eval() to set a new type and value
	System.out.println(float_a + " " + float_b + " " + float_c + " " + float_d + " "
			   + f + " " + g);

	// using strings
	PData string_a = new PData("asdf"); // make string in constructor
	PData string_b = new PData(); // default constructor
	string_b.set("sdfg"); // set with set()
	string_a.set("dfgh");
	String s = string_a.getString(); // get the string
	PData string_c = new PData("init", "string"); // use "init" form of constructor
	string_c.set("jkl;");
	String t = string_c.getString();
	string_c.eval("2"); // use eval() to set new type and value
	PData string_d = new PData();
	string_d.eval("'fghj'"); // use eval() to set a string
	System.out.println(string_a + " " + string_b + " " + string_c + " " + string_d +
			   " " + s + " " + t);

	// using lists
	PData list_a = new PData("eval", "[1, 2, 3, 4, 5]"); // use "eval" constructor to make list
	PData list_b = new PData("init", "list"); // use "init" constructor to make list
	list_b.append(new PData(1)); // use append() to add items
	list_b.append(new PData(3.5));
	list_b.append(new PData("eval", "[2, 3, 4]")); // use append() to add complex item
	list_b.append(list_a); // and another complex item
	PData list_c = new PData();
	list_c.init("list"); // use init() to make a list
	int k = list_a.get(0).getInt(); // extract a value from a list
	double h = list_b.get(1).getDouble(); // extract another value
	list_c = list_b.get(2); // extract a complex value into a PData
	System.out.println("list_a" + " " + list_b + " " + list_c + " " + k + " " + h);

	System.out.println("list_a.has(1):" + list_a.has(new PData(1))); // demonstrate has() usage
	System.out.println("list_a.has(0):" + list_a.has(new PData(0)));
	System.out.println("list_a.find(3):" + list_a.find(new PData(3))); // demonstrate find() usage
	System.out.println("list_a.find(0):" + list_a.find(new PData(0))); // returns list_a.size() if not found
	list_a.erase(list_a.find(new PData(3))); // erase index 2 out of 0...4
	System.out.println("list_a.find(3):" + list_a.find(new PData(3))); // returns 4 (valid indices are 0...3)

	// using maps
	PData map_a = new PData("eval", "{'one': 1, 'two': 2, 'three': 3}"); // use "eval" to make map in constructor
	PData map_b = new PData("init", "map"); // use "init" to make map
	map_b.get("1").set(4); // set a new value
	map_b.get("2").set(5); // set another new value
	map_a.get("four").set("seven"); // and another one
	map_a.get("one").set(9); // change an old value
	int x, y;
	x = map_a.get("one").getInt(); // get a value
	y = map_b.get("2").getInt(); // get another value
	PData node = map_b.get("listitem"); // cache a node as a shortcut to add stuff
	node.init("list"); // must initialize the type of the node before doing stuff
	node.append(new PData(1)); // add stuff
	node.append(new PData(2));
	PData node2 = map_b.get("mapitem").init("map"); // cache another node, initialize at the same time
	node2.get("3").set(new PData(6)); // set a value
	node2.get("4").set(new PData(7));
	System.out.println(map_a + " " + map_b + " " + x + " " + y);
	System.out.println("map_a.hasKey(\"one\"):" + map_a.hasKey("one")); // demonstrate hasKey()
	System.out.println("map_a.hasKey(\"seven\"):" + map_a.hasKey("seven"));

	map_a.erase("one"); // demonstrate erase()
	System.out.println(map_a);
    }
}


**********************************************************************************

NetP also supports the creation of a raw socket connection between
processes, for lowest-level network speed.  One process must "offer"
to accept a connection on a particular named channel (and thus starts
listening to that channel for a request), and the other process must
establish the connection.  If two processes make an offer on the same
channel, the first process will automatically disengage.

The raw socket connection offers a raw bidirectional stream of bytes.
It blocks on sending and does not block on receiving.  Only by
attempting to send will it detect a dropped connection and reset
itself; if one side only receives, it will never notice a dead
connection.

Note: if you are using network firewalls, the side that runs
DirectOffer() can be behind a firewall (counterintuitively, it's
actually the client side).  The side that runs DirectConnect() must be
on a computer without a firewall, or you should open port 51552 or
whatever port you tell it to use.

C++ example:

#include "NetP.h"

int main() {
  NetP::DirectConnect("DirectTest"); // initiate connection; blocks until something receives
  for (int i=0; i<5; i++) {
    cout << "write " << NetP::DirectWrite("DirectTest", "asdfjkl;") << endl;
    sleep(1);
    cout << "read " << NetP::DirectRead("DirectTest") << endl;
    sleep(1);
    if (NetP::GetSocketNum("DirectTest") == -1) { // if connection disappears then stop
      break;
    }
  }
  if (NetP::GetSocketNum("DirectTest") != -1) { // if socket still exists
    NetP::DirectClose("DirectTest"); // close it
  }
}


#include "NetP.h"

int main() {
  NetP::DirectOffer("DirectTest"); // prepare to receive connection; does not block
  while (NetP::GetSocketNum("DirectTest") == -1) { // sleep until connection exists
    sleep(1); // you could do other stuff here too
  }
  for (int i=0; i<10; i++) {
    cout << "read " << NetP::DirectRead("DirectTest") << endl;
    sleep(1);
    cout << "write " << NetP::DirectWrite("DirectTest", "qwertyuiop") << endl;
    sleep(1);
    if (NetP::GetSocketNum("DirectTest") == -1) { // if connection disappears then stop
      break;
    }
  }
  if (NetP::GetSocketNum("DirectTest") != -1) { // if socket still exists
    NetP::DirectClose("DirectTest"); // close it
  }
}

-----------------------------

python example:

import netpacket
import time

dread = netpacket.NetP.DirectRead
dwrite = netpacket.NetP.DirectWrite
netpacket.NetP.DirectConnect('DirectTest')
for i in range(10):
    print dwrite("DirectTest", "asdfjkl;")
    time.sleep(1)
    print dread("DirectTest")
    time.sleep(1)
netpacket.NetP.DirectClose("DirectTest")


import netpacket
import time

dread = netpacket.NetP.DirectRead
dwrite = netpacket.NetP.DirectWrite
netpacket.NetP.DirectOffer('DirectTest')
for i in range(10):
    print dread("DirectTest")
    time.sleep(1)
    print dwrite("DirectTest", "qwertyuiop")
    time.sleep(1)
netpacket.NetP.DirectClose("DirectTest")

------------------------------

java examples:

import netpacket.NetP;

class DirSendTest {
    public static void main(String[] args) {
	NetP.DirectConnect("DirectTest");
	for (int i=0; i<10; i++) {
	    System.out.println(NetP.DirectRead("DirectTest"));
	    try{Thread.sleep(1000);} catch (Exception e) {System.exit(1);}
	    System.out.println(NetP.DirectWrite("DirectTest", "qwertyuiop"));
	    try{Thread.sleep(1000);} catch (Exception e) {System.exit(1);}
	}
	NetP.DirectClose("DirectTest");
    }
}


import netpacket.NetP;

class DirRecvTest {
    public static void main(String[] args) {
	NetP.DirectOffer("DirectTest");
	for (int i=0; i<10; i++) {
	    System.out.println(NetP.DirectWrite("DirectTest", "asdfjkl;"));
	    try{Thread.sleep(1000);} catch (Exception e) {System.exit(1);}
	    System.out.println(NetP.DirectRead("DirectTest"));
	    try{Thread.sleep(1000);} catch (Exception e) {System.exit(1);}
	}
	NetP.DirectClose("DirectTest");
    }
}

**********************************************************************************

Other details

Try "scons docs" to get an API reference in ./docs.

Man pages: Use "man" or "less" to look in docs/man/man3/NetP.3 and
docs/man/man3/PData.3.

Web page: look in docs/html/index.html .  Also linked off our group's
wiki, for those of you working with us.