The latest milestone in the Lagniappe Programming Environment project has been reached. With this release, Lagniappe can now process packets off of the actual network. The execution environment auto-detects the ethernet devices in the system and makes these available to the programmer.
There is still more work to be done, but this release allows us to start to profile the system and analyze where performance tuning is needed. More importantly, for programmers, this release makes Lagniappe truly usable for packet processing on the network.
All of the features set out in the development plan have been implemented. Hence, our second milestone release.
Type based event handling provides a much more powerful and flexible event delivery system.
The next milestone will see modules in the Lagniappe language. This is a big new feature and after this application development using the Lagniappe system should be much easier and straightforward.
A new version of libtracetools was released today that now supports IPv6 packets in TSH format trace files.
This release is backwards compatible with the previous release.
Versions 0.1.0 of both lee and llt were released today. This is the first milestone release for the Lagniappe Programming Environment.
All of the features in the development plan were implemented. The system seems stable, even on true multi-core, SMT enabled systems. However, Lagniappe is very much still in development, and instability should be expected.
However, some exciting features and sample applications should start making there way into the project very soon.
New releases: lee v0.0.6 and llt v0.0.8
Now there are four trace driven network devices in the system. This will allow for applications that actually do some sort of routing. The devices can be sinks in an application graph; any packet sent to it gets written to a corresponding output trace file.
The other major addition in these two releases is the ability to add extra includes, data, and methods to the application. This allows for the event subscriptions provided by the programmer to be much more robust.
A programmer can now write packets out by putting "eth0" as a target in the application graph. This will allow for more throrough testing of the system.
We still need a better way of establishing several trace devices for legitimate test applications to work right.
The new version of lee and llt are 0.0.4 and 0.0.6, respectively. I almost got things working without having to change llt, but the small change made a huge difference.
Basic support for events has now been released with v0.0.5 of llt and v0.0.3 of lee. Further testing must be done on the way to milestone release v0.1.0.
This is exciting, however, as event processing is one of the major features of the Lagniappe Programming Environment. Making control and configuration flow such an integral part of programming an application allows for truly powerful packet processing to be done. This is the first step in the process!... read more
This package adds events to the syntax of Lagniappe. The llt now can recognize the event syntax and generate appropriate code. This code will not currently work with lee. Look for an update for lee by the end of the week. See the release notes and the ChangeLog for detailed comments.
Three package releases today: llt v0.0.3, lee v0.0.2, and libtracetools v1.0.0.
These three packages combine to form the first end-to-end working version of the Lagniappe Programming Environment.
Conforming C++ code combined with valid Lagniappe declarations are translated (using llt) and compiled (using lpkg to invoke g++) into a loadable .ppa file.
Using lee, one can load this .ppa file and run the application using packets from a TSH format trace file of his or her choosing.... read more
The Lagniappe Execution Engine finally has some released code behind it. I had created the CVS repository for it the other day, but I felt that having a working front end was worth a first release.
Obviously, all of the interesting code will be in the back end. That is, of course, yet to be written. What this front is does do, however, is allow for packet processing application libraries to be loaded in dynamically.... read more
This marks the second file release for the translator. All of the basic syntax for both ppf descriptions and application descriptions is recognized and translated to valid C++.
There is no support for any type of events yet. This is a feature that will be added across all components of the Lagniappe programming environment once the basic data processing is functional.
The translator will now be in bug fix mode while the execution environment is developed. Any further 0.0.x releases will be bug fix/integration releases as no new features should need to be implemented. I am sure that as the lee is worked on changes will be required in the llt, and these changes will be the focus of any 0.0.x releases from here on out.... read more
I put together the first file release this evening. This mainly stands as an initial artifact of the development of the Lagniappe system.
This first version of the Lagniappe Language Translator (llt) is very basic. It allows for a simple packet processing function specification to be translated into C++. This is good first step, and with this the syntax has started to actually take shape.
The next point release will hopefully come soon after I return. I hope to finish the basic level of PPF syntax, and start taking a shot at the application specification.... read more
Early this morning I imported the first files for the Lagniappe Programming Environment. I imported a base setup that allowed for native Java compilation using GCJ and integration with ANTLR.
This is exciting. There is a ton of work to do before Lagniappe starts to be a viable system, and I'm looking forward to it.