Release 0.7.1 – 1/28/2002

This is a bug fix release. If you use the source release, you need to copy all files in the bin directory to the release/bin directory. This release fixes the following bugs:

• Discovery server elections are more stable as we fixed a bug in the election manager and made several other stability improvements.
• The performance of datagram I/O has been improved.
• The web server now handles large files.
• We fixed sequence numbering in AudioSource to avoid unnecessarily dropped packets.
• one.world now compiles and runs under the beta releases of Sun's JDK 1.4. The beta release did not miss a classfile; rather, one.world's class loader got confused by the newly added sun.reflect package. Note that we have not performed extensive testing and there may still be incompatabilities, especially for drag-and-drop in Emcee and sound processing in Chat.

Console output is now exposed through the Shell.console field. This field can be used instead of System.out and System.err. The new SystemFix utility rewrites existing class files to use one.world's system support classes instead of java.lang.System and java.lang.Thread.

We added a new configuration parameter, "one.world.discovery.announce.value", allowing the discovery server election score to be manually set (which is useful for testing discovery server elections).

Release 0.7 – 9/21/2001

This release includes performance improvements, bug fixes, and some API changes. If you have used a previous distribution of one.world, make sure that you rebuild from scratch and completely delete the old tuple storage files and directories before running this release. If you use the source release, you need to copy all files in the bin directory to the release/bin directory.

Known issues

The issue with Window shutting down networking when the network connection goes away has not been resolved (see release notes for 0.6).

We have not tested one.world with Sun's JDK 1.4 beta 2 release and do not know if the missing classfiles are now part of that release (see release notes for 0.6).

Tuples

The Validatable and Wrappable interfaces in the one.world.core package have been removed, since all tuples implement them anyway.

Tuple.validate() now validates both the structure and the contents of a tuple. As a result, it now throws a TupleException instead of an InvalidTupleException. The Tuple.validate(Tuple) method has been removed.

Structural validation has been moved into Type, which will be expanded in a future release to implement customized and faster tuple serialization.

Environment migration

Environment migration has been rewritten from scratch to not break down when migrating environments with lots of tuples. As a result, the MovingProtocol has been changed. The new version is incompatible with earlier releases.

Operations

Operations now use a single timer for all request/response interactions managed by one instance. This avoids out of memory errors for large numbers of events managed by the same operation.

Performance

We have profiled large parts of the core architecture and the one.radio applications and implemented many performance optimizations throughout the system. The optimiziations include:

• Improved performance of copying events between protection domains.
• Removed redundant and unnecessary tuple validations in the core.
• Improved performance of discovery resolutions.
• Improved performace of RubberPipedInputStream.
• Avoided unnecessary tuple reads in AudioSource.
• Avoided unnecessary tuple comparisons in AudioSink by first comparing tuple IDs.

Web server

The web server now supports caching, but it does not yet handle large files. To serve large files, increase the chunking threshold before importing files.

Release 0.6 – 8/30/2001

This release includes several API changes, new features, considerable bug fixes, and performance improvements. If you have used a previous distribution of one.world, make sure that you rebuild from scratch and completely delete the old tuple storage files and directories before running this release. If you use the source release, you need to copy all files in the bin directory to the release/bin directory.

Known issues

Currently, each event managed by an operation has its own timer for detecting time-outs. This causes out of memory errors when large numbers of events are sent through operations in rapid succession. In the next release, each instance of operation will use a single timer to avoid this problem.

Datagram I/O channels have some performance problems that may cause dropped packets when many packets are received in rapid succession.

For unknown reasons, Windows seems to shut down networking when the network connection goes away. This breaks REP and discovery. We are still investigating a possible work-around.

Sun's JDK 1.4 beta release seems to miss some classfiles needed for serialization and, as a result, one.world does not run on that release.

Tuples

Tuple.clone() now returns a complete shallow copy of a tuple and does not replace the ID anymore. To actually create a new tuple with the same values, a caller of this method needs to replace the ID and meta-data fields as well as copy any nested tuples. The superfluous one.world.core.Descriptor.copy() has been removed. Calls to this method have been replaced with clone(). You will need to change your components accordingly (e.g., replace SELF.copy() in getDescriptor() with SELF.clone()).

Components

Imported and exported event handlers can now be declared after a component has been created and when it is already in use. Furthermore, imported and exported event handlers can now be removed from a component by undeclaring them.

Concurrency domains

The number of threads used by a concurrency-safe concurrency domain is now dynamically adjusted by a controller based on the environment's perceived load. This means that applications that are mostly idle only use one thread and applications that are very busy can use up to 20 threads.

The root environment now contains nested concurrency domains to isolate some services from the root environment's main concurrency domain. Their use avoids breaking the root environment into several environments and thus introduces a form of lightweight environment.

Environment migration

A bug in migration was fixed and copying of environments works again.

Local migration of environments now goes through a checkpoint (just like local environment copying and remote migration) instead of just changing some internal pointers. This ensures that references to resources outside the migrated environment tree are properly released.

Tuple storage

Fixed several event handlers so that they correctly return an exceptional event when receiving an event they don't understand (rather than silently dropping it).

Fixed a concurrency problem with query iterators.

Structured I/O networking

Network I/O channels now use their own nested concurrency domains, so that all network writes occur within a single thread. This means that root environment threads will no longer block while trying to write to TCP sockets.

Remote event passing

The remote event passing system now delivers events within a single instance of one.world without serializing the events or sending them over the network. This optimization may be disabled by setting the "one.world.rep.force.network" system property to true.

Remote events are now annotated with the port number of the source remote event passing system (see Constants.REQUESTOR_PORT). This information helps in reusing bidirectional TCP connections, rather than creating a separate connection for each direction.

Also, a bug that caused REP to hang when connecting to an unresponsive port (such as port 23, the telnet port) has been fixed.

Discovery

Discovery now supports reverse queries. If the RemoteDescriptor.descriptor field for an event handler being exported to REP is a query, the query will be executed on late binding events sent through discovery and matching events will be delivered to the exported event handler. The query is executed on the inner event, not on the enclosing RemoteEvent. Bindings with reverse queries behave exactly like normal discovery bindings, though they are guaranteed to be matched after all normal forward queries. However, if the new RemoteDescriptor.snoop field is true, the corresponding reverse query will be matched against all tuples passing through discovery, even if the DiscoveredResource.matchAll field specified by the sender of the event is false.

Note that previous releases of one.world cannot interoperate with this release, because (in part) of the addition of the snoop field to RemoteDescriptor.

Applications using discovery will no longer see exceptional events containing unknown resource exceptions for events sent to stale discovery bindings.

Recovery from a discovery server failure should be faster. Among other things, when the system with the discovery server shuts down, it calls an election and waits for the result before exiting.

Discovery elections are somewhat more resilient to dropped packets.

The performance of discovery queries was improved. In particular, all discovery bindings with the same resource (as determined by Tuple.equals(Object)) are merged into a single discovery server entry. This means that id and metaData field queries do not produce reliable results.

Importing and Exporting Data

Large files, such as music, are now imported as a chain of chunks and reassembled into a single file when being exported. Constants.CHUNKING_THRESHOLD determines the threshold for breaking up a single file into many chunks. The converter interface has been modified to support mappings between a single file and several tuples.

Application Support

The new one.gui package provides support for building GUI-based applications in one.world. Notably, Application significantly simplifies the implementation of an application's main component, and GuiUtilities implements several static helper methods for managing GUIs.

The new Clock and Counter2 toy applications illustrate their use. Note that Counter2 is a much simpler and cleaner reimplementation of the counter application from the one.world tutorial, part I.

Furthermore, the RemoteCounter toy application has been rewritten as a one.gui.Application and now allows the counter value to be reset, just to make things more interesting.

one.radio

Chat has been reimplemented to use the new helper classes in one.gui.

one.radio now supports streaming audio, both from sound data stored in environments and captured from a microphone. Audio support has been integrated into Chat and is also available through three command-line applications: AudioPlayer, AudioSender, and AudioReceiver.

A bug in the Linux JavaSound implementation disables full duplex audio. Therefore, attempting to capture audio from the microphone in Chat under Linux will result in an exception.

The new Emcee application provides a simple and convenient user interface for managing users and their applications. It provides a user interface for several root shell operations (such as running an application, checkpointing an application, or restoring a checkpoint). Furthermore, it supports the moving or copying of applications between users, simply by dragging an application's flag icon () and dropping it onto the user's name. Finally, it supports migration of a user's applications between machines, by either pushing them to a remote machine (the move operation), or pulling them from a remote machine (the fetch operation). The Emcee is automatically started with one.world.

Web server

The new one.net.http package implements a web server. The web server does not yet implement caching for frequently accessed documents. Furthermore, it does not yet handle chunks. To serve large files with the web server, increase the chunking threshold before importing the files (see above under importing and exporting data).

Code cleanup

In preparation for the elimination of one.util.IOUtilities, IOUtilities.acquire() has been moved to LeaseManager and IOUtilities.cancel() has been moved to LeaseMaintainer. one.world.rep.RemoteLeaseMaintainer has been removed.

Release 0.5.1 – 7/24/2001

This is a bug fix release. If you have used a previous distribution of one.world, make sure that you rebuild from scratch and completely delete the old tuple storage files and directories before running this release. If you use the source release, you need to copy all files in the bin directory to the release/bin directory.

The following bugs are fixed:

• Migration works again. The transition to the synchronous timer interface in the last release inadvertently broke migration.
• Operation now works correctly for all events and event closures. The buggy one.world.util.RemoteOperation has been removed and its functionality has been roled into Operation.
• A rare but possible deadlock in the kernel between networking and REP has been eliminated.
• one.radio.Main has been renamed to Chat and is now more conservative in its resource consumption.

This release also adds a "User" environment, which is automatically created on each node. The intent is to hold per-user applications and data, comparable to the "usr" directory on Unix and the "Documents and Settings" directory on Windows systems.

Release 0.5 – 7/18/2001

This release includes several API changes, new features, considerable bug fixes, and performance improvements. It also includes one.radio, a chat application running in one.world. A binary distribution is now available as well, simplifying the process of installing and running one.world as well as one.radio.

If you have used a previous distribution of one.world, make sure that you rebuild from scratch and completely delete the old tuple storage files and directories before running this release.

If you use the source release, you need to copy all files in the bin directory to the release/bin directory.

Security

one.world now requires a Java SecurityManager to run (though, the regression tests in the one.fonda package still run without security). A default security policy is specified in the one.world.policy file in the root of the source tree. The policy currently grants all code loaded from the file system the same permissions, because Java does not allow the expression of permissions on a per-class basis.

As a result of enabling security, one.world now needs to be invoked through a script (one.world.bat on Windows and one.world.sh on Linux, which are also located in the root of the source tree). The root directory for storing the environment hierarchy (the "one.world.store.root" system property) needs to be specified in this script as well as in the one.world configuration file. You need to change the scripts before first running this release of one.world.

Protection domains

Protection domains are now functional. Each environment either has its own protection domain or inherits the parent environment's protection domain. The -inherit flag for the root shell's mk command and the inherit flag for a CreateRequest control whether to create a new protection domain or inherit the parent environment's protection domain.

Most operations on environments are restricted to work only on the root of a protection domain. For example, it is impossible to checkpoint or move a partial protection domain.

Each protection domain has its own class loader and events passed between protection domains are copied, resulting in true call-by-value semantics for event passing between protection domains (immutable objects are passed by reference). The class loader currently loads from the local class path. A future release will change this to load code from the environment hierarchy itself. The unload operation can be used to forcibly unload all code from a protection domain. It is thus possible to load and run recompiled application code without restarting one.world.

Note that core code, that is all code in the one.world.*, one.net, and one.util packages, is shared between all protection domains and loaded by the root environment's class loader.

Tuples

To make efficient copying of tuples passed between protection domains feasible, the valid field types for tuples have been restricted; see Tuple for details. Because of these restrictions, a box can now be used to embed arbitrary objects in tuples. The get(), set(), etc. methods have been reimplemented to be simpler and faster.

Event validation

AbstractHandler does not automatically validate events anymore before invoking the handle1() method. A new convenience method, isNotValid(), has been added to AbstractHandler, simplifying event validation when it is desired. one.world now validates events when they are passed through the request/monitor mechanism (i.e., when an event is sent to an environment's request event handler) and when they are sent to a bound resource in the root environment. one.world.util.Timer also validates events when using the asynchronous interface.

Time

Timer now implements a synchronous interface in addition to the asynchronous interface. All core code, including LeaseMaintainer, now uses the synchronous interface, because timing asynchronous interactions through an asynchronous interface does not work reliably for some boundary conditions. Each environment has a default timer, which can be conveniently accessed through Component.getTimer().

Structured I/O

Queries on the fields of nested tuples are now implemented. For example, to match tuples with a "versionNumber" meta-data field greater than a certain number, use "metaData.versionNumber" as the field name in the corresponding Query tuple.

one.world now requires Berkeley DB version 3.2 or later to run. Version 3.2 contains a fix for the Java log cleaning bug present in version 3.1. Old log files are now always deleted and the "one.world.store.removelogs" configuration option is now ignored.

OptionEvent and FlushEvent provide a new interface for relaxed durability when writing to an environment's tuple store. However, they are not yet supported by the current implementation of tuple storage.

Several changes have been made to NetworkIO to improve robustness and performance. Object streams are now buffered to reduce event passing latency. They are also reset after each tuple to ensure that objects sent repeatedly will be reserialized on each send. A timeout has been added during object stream establishment to reduce vulnerability to misbehaving clients.

Remote event passing

ExportDescriptor in the one.world.rep package has been renamed to RemoteDescriptor to avoid confusion with ExportedDescriptor in the one.world.core package. UnknownResourceException has been removed; one.world.binding.UnknownResourceException is used instead. RemoteResource has been removed, since it was an empty abstract class and served no real purpose. DiscoveredResource and LocalizedResource now extend SymbolicHandler.

RemoteEvent now includes a datagram flag, which is used to request unreliable delivery of events via UDP.

Also, two bugs were fixed, one that caused dangling leases and another that resulted in incorrect connection caching in the case of failed connection attempts.

Discovery

one.world nodes on a local network now automatically elect a discovery server amongst themselves. A node may still be manually configured as a discovery server by setting the "one.world.discovery.server" system property to true, but this manual configuration is no longer necessary for discovery to function properly.

Discovery bindings are made in all servers detected on a network, and when a new server appears on the network all existing bindings are added to that server. When the primary discovery server fails, clients will automatically switch to another discovery server for resolution if available (and elect a new one if not). However this process is slower than desired in the current release (on the order of several seconds). This will be improved in the next release.

Note that a BindingResponse when exporting an event handler to discovery does not indicate that the binding has been propagated to all discovery servers.

ResolutionEvent in the one.world.rep package has been replaced with distinct events for the request and response: ResolutionRequest and ResolutionResponse. ResolutionResponse can now return multiple resolved resources.

Root shell

The option syntax for many commands has been simplified by removing the need for an explicit "-path" flag before specifying a source environment. The "-flatten" option has been added to the import command. The clean command has been added; it removes all tuples / all checkpoints but the latest checkpoint / all class data tuples from an environment.

The logic/operation pattern

The logic/operation pattern can make it easier to develop asynchronous code. It is now supported by the ComposableHandler and Operation classes in the one.world.util package. one.radio's main component illustrates its use.

A bug in the current implementation of Operation causes an event to be silently dropped if the event is passed to an operation's handle() method and has a GUID as its closure or if an operation invokes another, nested operation. This bug will be fixed in the next release. Furthermore, this release contains RemoteOperation, which does not work outside one.world's kernel and will be dropped again in the next release.

Code cleanup

The overall goal of the code cleanup is to remove clutter from the source tree. Unused classes have been removed, small packages have been consolidated into larger ones, and classes not needed for one.world to run have been moved outside the core packages.

The one.world.security package has been consolidated into the one.world.core package. Tuple descriptors and field descriptors have been removed from this release. SymbolicReference and SymbolicWrapper have been removed from the one.world.util package. LeaseMaintainer has been moved from the one.world.util package to the one.world.binding package. RemoteLeaseMaintainer has been moved from the one.world.util package to the one.world.rep package.

Skeletor has been moved from the one.world.util package to the new one.tools package.

The one.app.* packages have been consolidated into the new one.toys package. ClientMain and SenderMain in the one.world.rep package were merged into RemoteSender in the one.toys package and, similarly, ServiceMain and ReceiverMain were merged into RemoteReceiver.

Minimum has been moved from the one.world.util package to the one.fonda package. EmptyEvent has been moved from the one.world.rep package to the one.fonda package.

Release 0.4 – 2/22/2001

Major changes are summarized by package / functional unit. This release includes important bug fixes as well as feature improvements.

Core

Several bug fixes for remote moving and copying. Event delivery to linked monitor event handlers is now working. Exceptional events indicating that an event queue is full are now correctly delivered. Check-pointing has been made more failure-resilient. Migration between several instances of one.world running on the same node is now possible.

Structured I/O

The Structured I/O interface was changed slightly in this release:

• one.world.io.QueryByIdResponse has been removed (it was never used in earlier releases). Queries returning IDs return a QueryResponse with an iterator over the IDs of matching tuples.
• A read request which matches no tuples results in an InputResponse containing a null tuple rather than an ExceptionalEvent.
• IteratorResponse has been made an abstract class with concrete children named IteratorElement and IteratorEmpty. If an IteratorRequest is sent to an iterator for a query that returned no matches, an IteratorEmpty is returned. If the iterator contains an element, an IteratorElement containing the element is returned. If an IteratorRequest is sent to an iterator that is at the end of its list of elements, an ExceptionalEvent wrapping a NoSuchElementException is still returned.
• Structured I/O now wraps and returns any exceptions seen during serialization of tuples. Exceptions during deserialization are logged.
• IOUtilities was modified to reflect these changes.

The package documentation for one.world.io has been improved.

A couple of bug fixes for tuple storage.

In release 0.3, a bug in the Linux HotSpot JVM prevented sockets used by NetworkIO.Client from being closed before the JVM exits, even if the governing lease is canceled or expires. (See the bug report for more information.) This release includes a workaround for the Linux JVM bug. The sockets at both ends of network I/O channel will be closed when the lease expires or is canceled.

Remote event passing

REP now queues remote events while waiting to establish a connection to a remote host. In the previous release, if multiple events directed to the same remote host were sent in rapid succession, a connection was established for each event.

Early- and late-binding service discovery are now supported through resolution events and discovered resources, respectively. Registration of event handlers with a discovery server is performed using export descriptors. The core now includes a DiscoveryClient component that manages DiscoveryServer interactions. A discovery server can be activated on a node by setting the "one.world.discovery.server" system property to true.

Root shell

Added the import and export commands to import and export tuples from/to the local file system. Arbitrary files are imported as binary data and arbitrary tuples are currently exported in serialized form. The format for arbitrary exported tuples will be changed to an XML-based format in a future release.

The import and export commands rely on the mapping between MIME types and file system extensions implemented by MimeTypes. This mapping is initialized by the "mime.config" file. By default, this file must be located in the current working directory. The "mime.config.name" system property can be used to specify an alternative name and directory. The source tree contains a file with reasonable mappings in the src/one/net directory.

Added the ability to telnet into one.world as an alternative to running the root shell from the local console. The "one.world.shell.port" system property specifies the telnet port, and the "one.world.shell.pwd" system property specifies the password. If the corresponding system property is not specified, the port defaults to the default telnet port (23). The root shell defaults to the local console, if the password is not specified. Note that only one telnet connection can be active at a given time.

Benchmarking

Added micro-benchmarks to compare the performance of structured I/O (networking and storage) as well as remote event passing with plain Java sockets (for networking), the Berkeley DB and T Spaces (for storage), and Java RMI (for remote event passing). The one.world benchmarks are located in the appropriate packages; their class names start with Benchmark. The corresponding comparison benchmarks are located in the one.fonda.java package.

Networking benchmarks were updated to correctly perform latency and throughput benchmarks for both Java and one.world. Known problems:

• Throughput results are printed as times in milliseconds rather than bytes/sec. The real throughput numbers can be calculated by dividing the resulting time by (numTuples * numBytes), where numTuples and numBytes are parameters specified on the command line for the benchmarks. (Java and one.world)
• Buffer overflows have been observed under Windows 2000 resulting in inaccurate results due to time spent in exception handling. (one.world only)

Three benchmarks related to tuple storage performance were added. These tests are micro-benchmarks on one.world tuple store performance, Berkeley DB performance, and IBM T Spaces performance. The Berkeley DB tests are designed to determine the overhead added by one.world to plain Berkeley DB performance. The T Spaces benchmarks are designed to provide a point of comparison with a (somewhat) similar system. Documentation for these benchmarks is in the package documentation for one.fonda.

The T Spaces benchmark is not built by default, since it requires T Spaces. To build it, you must install T Spaces, place the tspaces.jar and tspaces_client.jar files in your CLASSPATH, and uncomment the line listing BenchmarkTSpaces.java in src/one/fonda/java/Makefile.

BenchmarkREP implements latency and throughput benchmarks for remote event passing. BenchmarkRmi provides similar benchmarks for Java RMI, allowing a comparison.

Release 0.3 – 2/2/2001

Major changes are summarized by package / functional unit. This release marks the implementation of all operations on environments and a considerable increase in stability, notably for structured I/O over TCP and remote event passing, as well as usability, making small additions through-out the code base.

Core

Environments can now be moved and copied to remote nodes. The protocol to move environments is documented in MovingProtocol. Added the accept request event to make the acceptance of a moving environment tree explicit. The mover application illustrates environment migration by repeatedly moving between two or more nodes in a round-robin fashion.

Queued event handlers make it possible to give certain events priority. Changed the implementation of environments to use them, which makes one.world more stable under heavy load.

Structured I/O

Several bug fixes for tuple storage.

Cancelling a lease for tuple storage now cancels all on-going query and listen operations initiated through the same binding. Furthermore, a resource revoked excecption is sent to event handlers processing the results of such a canceled listen operation.

Added option to automatically remove old log files from the tuple store by specifying "one.world.store.removelogs=true" in the one.world.config file. If enabled, logs not needed for on-going operation or crash recovery are removed at system start-up and once a minute thereafter. This feature does not work with the standard Berkeley DB 3.1.17 distribution. A bug fix should be included in the next distribution.

Communication channels over TCP, as implemented by NetworkIO.Client, have undergone a major semantic change. Previously, tuples were silently discarded if received while no input requests were pending. Now, tuples will be consumed only while input requests are pending. That is, if a NetworkIO.Client receives a tuple while no input requests are pending, it will wait to process the tuple until it receives an input request. As a result, NetworkIO.Client now provides truly reliable delivery semantics.

Furthermore, many exceptions on the underlying socket are now correctly treated as fatal, resulting in the resource being revoked.

Finally, we have eliminated a major timing bug that caused the NetworkIO.Client to be interrupted while deserializing data from the socket.

Unfortunately, fixing this bug exposes a bug in the Linux HotSpot JVM: blocking read and accept calls on sockets are not interrupted by the socket being closed. (See the bug report for more information.) Therefore, sockets used by NetworkIO.Client are not closed until the JVM is exited, even if the lease is canceled or expires. We have started developing a work-around for NetworkIO that will be available at a later date.

Remote event passing

REP now uses retries when sending events to remote systems; several small bugs were fixed in the process of adding this feature. Important constants have been exposed in Constants, and the documentation has been improved.

Utility functionality

Added four new methods to AbstractHandler to respond to remote events. Made Synchronous.ResultHandler public and added a reset() method. Added get() to DynamicTuple to access fields with an expected type. Added convenient time constants to Duration as well as format() to format durations in human-readable form.

Node information

Added methods to SystemUtilities to access the current uptime, total and free memory, the current number of threads, and the IP address. Added support for determining the performance of the local JVM, based on the embedded CaffeineMark benchmark.

Root shell

Renamed the kill command to stop. Added the gc and info commands. mv and cp can now move and copy (respectively) environments to a remote node by using structured I/O URLs instead of a local path.

Benchmarking

Initial network benchmark code has been added to the source tree but is not yet functional. A full set of micro-benchmarks will be part of the 0.4 release.

Release 0.2 – 1/22/2001

Major changes are summarized by package / functional unit.

Core

Several bug fixes and performance improvements in the one.world.core package. Environments can now be locally copied. Moving (and copying) environments to remote notes is scheduled for the next release. The binary representation of check-points has been slightly tightened.

Application initializers may throw any Java throwable to signal that they could not properly initialize the application. The environment's imported event handlers are now properly unlinked on an exceptional condition.

Structured I/O

The directory structure for tuple storage has changed. You must remove the contents of the tuple store directory before running release 0.2.

Leases on tuple storage are now properly revoked when an environment is deleted. However, pending read, listen, and query operations are not canceled. In the next release, they will send an exceptional event wrapping a ResourceRevokedException.

For communication channels, "localhost" is now interpreted as the default IP address of the local node and not as the loopback interface.

Various bug fixes for structured I/O and its regression tests.

Remote event passing

The one.world.rep package has an entirely new API; see the one.world.rep documentation. In contrast to release 0.1, internal leases are properly managed, and distributed garbage collection is unnecessary.

Streaming media

The new one.media.streaming package implements functionality to stream sound across the network. A known bug is that the speaker component must be created before the microphone component when instantiating both on the same machine or otherwise a LineUnavailableException will be thrown.

Release 0.1 – 1/4/2001

This is the first release of one.world. It includes support for data management, based on tuples and structured I/O, and for applications, which are composed of components and execute in environments. The development setup page describes the development setup, and the FAQ answers frequently asked questions. The class documentation provides extensive documentation on one.world's features and APIs.

The following features are not implemented.

• Structured I/O
  • Queries on nested fields
  • Transactions
• The remote move operation on environments
• Protection domains
  • Class loading from environments
  • Isolation between applications
  • Forced termination of ill-behaved applications
• Resource domains

Several public methods in the core classes are privileged and perform access checks to ensure that they are not called by applications. However, the current code base has neither been tested with Java security, nor have we devised appropriate security policies.

Remote event passing

A known problem is that a remote session will cease to function after several minutes, as internal leases expire.

The system does not currently include any form of distributed garbage collection. An event handler may be destroyed by Java's local garbage collection system even if a remote node holds a reference to that event handler. The interface will be changed to incorporate some form of distributed garbage collection, possibly including the attachment of leases to the stubs packaged in events with remote sources.