Adam Kennedy

NAME

Process - Objects that represent generic computational processes

SYNOPSIS

  # Create the process
  my $object = MyProcess->new( ... )
      or die("Invalid configuration format");
  
  # Initialize it
  $object->prepare
      or die("Configuration not supportable");
  
  # Execute the process
  $object->run
      or die("Error while trying to execute the process");

DESCRIPTION

There are a great number of situations in which you may want to model a computational process as an object.

An implementation of this sort of object generally looks like the following when somebody uses it.

  my $object = MyProcessThingy->new( ... );
  
  my $rv = $object->run;
  
  if ( $rv ) {
      print "Thingy ran ok";
  } else {
      print "Failed to run thingy";
  }

The Process family of modules are intended to be used as base and role classes for these types of objects. They are used to help identify process objects, and enforce a common API on these objects.

The primary intent is to provide a common base for objects that will be able to be used with various distributed processing systems, without itself actually implementing any form of distributed system.

The scope of uses for Process includes solutions to address the following scenarios.

A single CPU on a single host
Multiple CPUs on a single host
Multiple hosts on a single network
Hosts distributed across the internet
Any processing resource accessible via any mechanism

To put it another way, this family of classes is intended to addresses the separation of concerns between the processing of something, and the results of something.

The actual ways in which the processes are run, and the handling of the results of the process are outside the scope of these classes.

The Process class itself is the root of all of these classes. In fact, it is so abstract that it contains no functionality at all, and serves primarily to indicate that an object obeys the general rules of a Process class.

Most of the basic Process modules are similar. They define how your object should behave (an API for a particular concept) without dictating a particular implementation.

However, by using them, you are confirming to some processing system that your objects will obey particular rules, and thus can interact sanely with any processing system that follows the API.

What You Can and Cannot Do

The use of Process is mainly about making guarantees. Because this is Perl, it is not necesarily about enforcing those guarantees in a strict way. These sorts of guarantees need to be implemented at a language level to be meaningful in any case (for example, Perl's tainting or Haskell's monads). You may still hang yourself, but it's your own fault if you do.

You may not alter the API of the three core methods

It's always tempting to say "This acts like Foo, but we added an extra return condition for method bar". You may not do this.

Process and a few other members of the family dictate all possible return values for new, prepare and run, and what state the objects should be in before and after these methods are called in the various cases. You may not break these rules, because larger systems will be depending on them to allow your objects to work with them flexibly and flawlessly.

You may not store data in the surrounding Perl environment

A Process object should be entirely self-contained when you are told to be. If your process is involved in creating or transforming information, then your implementation should keep these results inside the Process object. Do not store data elsewhere. This means no globals and no class-level variables. You can't leave error messages in a global $errstr variable, as some Perl modules do.

This does not mean you can't store data in files. For Process objects that generate vast quantities of data it would be unwieldy to limit you to holding all data in memory at once. However any object data that refers to files should use absolute paths.

You may not assume the timing of new and prepare.

Most uses of Process will involve scheduling, transport, or otherwise mean that once a processing system has a Process object, it won't get to it immediately.

You should not assume that prepare will be run immediately after new or in the same interpretor. You may however assume that run is run immediately after prepare, and is in the same interpreter.

You may not assume an object is unchanged after run

A Process object may be unchanged after run. Then again, it may also be completely changed, and have accumulated all sorts of data in it.

This also means that you should not assume that a Process object can be run again after it completes. A specific class Process::Repeatable will be provided at a later date for this case.

You may not interrelate with other Process objects

In the default case, all Process objects are considered to be independent and standalone. They may not have any form of dependency on other Process objects, and they should not expect to communicate with any other Process objects.

If you choose to add this type of functionality to your particular class that is fine, but any processing system will not be aware of this and thus will not be doing anything to help you out.

Process::Depends will be provided at a later date for this case.

METHODS

new

  my $object = MyClass->new( $configuration );
  if ( $object and $object->isa('Process') ) {
        print "Object created.\n";
  } else {
        print "Configuration not valid.\n";
  }

The new constructor is required for all classes. It takes zero or more arbitrary params, with the specifics of any params outside the scope of this module. The specifics of any params are to be determined by each specific class.

A default implementation which ignores any params and creates an empty object of a HASH type is provided as a convenience. However it should not be assumed that all objects will be a HASH type.

For objects that subclass only the base Process class, and are not also subclasses of things like Process::Storable, the param-checking done in new should be thorough and and objects should be correct, with problems at run-time the exception rather than the rule.

Returns a new Process object on success.

For blame-free "Cannot support process in this Perl interpreter" failure, return false.

For failure with blame, may return a string or any other value that is not itself a Process object.

However, if you need to communicate failure, you should consider putting your param-checking in a prepare method and attaching the failure messages to the object itself. You should NEVER store errors in the class, as all Process classes are forbidden to use class-level data storage.

prepare

  unless ( $object->prepare ) {
        # Failed
        die "Failed to prepare process";
  }
        

The prepare method is used to check object params and bind platform resources.

The concept of object creation in new is separated from the concept of checking and binding to support storage and transportation in some subclasses.

Because many systems that make use of Process do so through the desire to push process requests across a network and have them executed on a remote host, Process provides the prepare method as a means to separate the checking of the params for general correctness from checking of params relative to the system and interpreter the process is being run on. It additionally provides a good way to have the bulk of serious errors remain attached to the object, and have them transported back across to the requesting entity.

Execution platforms are required to call run immediately or nearly immediately after prepare. Generally the only tasks done between prepare and run will be things like starting timers, setting flags and signalling to any requestor that the process is ok, and about to start.

As a result you are encouraged to do all locking of files, socket ports, database handles and so on in prepare, as they will be used immediately. Thus the only execution errors coming from run should be due to unexpected changes, race-condition events in the short gap between prepare and run, or some error that could not possibly be detected until part way through the run.

To restate, resource binding and checking should be done in prepare if at all possible.

A default null implementation is provided for you which does nothing and returns true.

Returns true if all params check out ok, and all system resources needed for the execution are bound correctly.

Returns false if not, with any errors to be propagated via storage in the object itself, for example in a ->{errstr} attribute.

The object should not return errors via exceptions. If you expect something within your code to potentially result in an exception, you should trap the exception and return false.

You should not expect the object to be Storable or in any other way usable once the Process object is prepare'ed. The object is wound up and poised ready to run and that is the only thing you should do with it.

run

  my $rv = $object->run;
  if ( $rv ) {
        print "Process completed successfully\n";
  } else {
        print "Process interupted, or unexpected error\n";
  }

The run method is used to execute the process. It should do all appropriate processing and calculation and detach from all relevant resources before returning.

If your process has any results, they should be stored inside the Process object itself, and retrieved via an additional method of your choice after the run call.

A default implementation which does nothing and returns true is provided.

Returns true if the Process was completed fully, regardless of any results from the process.

Returns false if the process was interrupted, or an unexpected error occurs. In the default case for Process, no distinction is made between the process being interrupted legitimately and any other type of unexpected failure.

If the process returns false, it should not be assumed that the process can be restarted or rerun. It should be discarded or returned to the requestor to check for specific errors.

SUPPORT

Bugs should be reported via the CPAN bug tracker at

http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Process

For other issues, contact the author.

AUTHOR

Adam Kennedy <adamk@cpan.org>

SEE ALSO

http://ali.as/

COPYRIGHT

Copyright 2006 - 2011 Adam Kennedy.

This program is free software; you can redistribute it and/or modify it under the same terms as Perl itself.

The full text of the license can be found in the LICENSE file included with this module.




Hosting generously
sponsored by Bytemark