Help-Site Computer Manuals
Software
Hardware
Programming
Networking
  Algorithms & Data Structures   Programming Languages   Revision Control
  Protocols
  Cameras   Computers   Displays   Keyboards & Mice   Motherboards   Networking   Printers & Scanners   Storage
  Windows   Linux & Unix   Mac

Script::Resume
State keeper for scripts that might abort in the middle of execution but need to pick up where they left off in later invocations.

Script::Resume - State keeper for scripts that might abort in the middle of execution but need to pick up where they left off in later invocations.


NAME

Script::Resume - State keeper for scripts that might abort in the middle of execution but need to pick up where they left off in later invocations.


SYNOPSIS


    use Script::Resume;

    my $state = {Robin => "Jason Todd"};

    my $rez = new Script::Resume(SCRIPT_STATE => \$state, STAGES => ["do_this", "then_that", "finally_this"]);

    $rez->addStage("oh_and_this_too", FUNC => \&this_too, ALWAYS=>1);

    $rez->runAllStages();

    print "Result: Robin = $state->{Robin}\n";

    sub do_this      { print "I'm doing this\n";}

    sub then_that    { print "I'm doing that\n"; $state->{Robin} = "Dick Grayson"; }

    sub finally_this { print "I'm finally doing this\n"; $state->{Robin} = "Tim Drake"; }

    sub this_too     { print "I'm doing this too\n";}

Here's a script that runs it with more explicit control


    use Script::Resume;

    my $robin;

    my $now = time();

    my $rez = new Script::Resume();

    $rez->addStage("my_first_stage",  FUNC => \&stage_one);

    $rez->addStage("my_second_stage", FUNC => \&stage_two);

    $rez->addStage("my_third_stage",  FUNC => \&stage_three);

    $robin = $rez->runStage("my_first_stage", "Jason Todd");

    print "Result: Robin 1 = $robin\n";

    $robin = $rez->runStage("my_second_stage", "Dick Grayson");

    print "Result: Robin 2 = $robin\n";

    $robin = $rez->runStage("my_third_stage", "Tim Drake");

    print "Result: Robin3 = $robin\n";

    sub stage_one { return shift;}

    sub stage_two { return shift;}

    sub stage_three { return shift;}


DESCRIPTION

Script::Resume Allows you to automatically break your script into stages with state such that if the script bails out in the middle somewhere, you can fix the problem, rerun the script and it'll pick up where it left off, with the previous state and all. This is useful for tasks where you can't start from the beginning again and/or you wouldn't want to, such as scripts involved in copying massive files around.

State is maintained in a plain Data::Dumper format file in $ENV{TEMP}/$0.state or /tmp/$0.state (or wherever you designate) so you can tweak it before re-running. It will store the SCRIPT_STATE you pass into the constructor along with all return values from all the stages. If the stage has already been run in a previous invocation of your script, the return value will be returned without actually re-running the stage.


METHODS

my $rez = Script::Resume->new(%config)
Construct a new object. Optional parameters include:

   $rez = new Script::Resume(DEBUG        => 1,            # Print out debug info. (Default = 0)

                             RETAIN_STATE => 1,            # Keep the state around even after the script finishes 

                                                           # (You'll want to delete this by hand before running the script again)

                                                           # For debugging only. (Default = 0)

                             RESUME       => 0,            # Continue where left off (Default = 1)

                             SCRIPT_STATE => \$my_state,   # Script specific state (reference to a reference to an 

                                                           # object or hash or array or scalar). (Default = undef)

                             STATE_FILE   => "/tmp/X",     # Filename of state file where state is to be stored

                                                           # (Default = "$ENV{TEMP}/$0.state" or "/tmp/$0.state")

                             STAGES       => ["s1", "s2"], # Reference to an array of stage names. (Default = undef)

                             STOP_AFTER   => "s2");        # Stop after state "s2" is run. For debugging only. (Default = undef)

$rez->addStage($stage_name, %config)
addStage() is where you specify the stage name and optionally map it to a function reference. If no function reference is given, it'll try to use the name as a function reference in the calling package.

    $rez->addStage("stage_name",

                   FUNC    => \&my_func_ref,               # Function reference to call for this stage

                   ALWAYS  => 1);                          # Always run this stage. (Default = 0)

$rez->addStages(@stage_names)
This is a convenience function that in turn calls addStage(). You can only call this if all of your stage_names map to function names.

$rez->setStageAttributes($stage_name, %config)
Sets a stage's attributes, such as:

    $rez->setStageAttribute("MyThirdStage", ALWAYS => 1, FUNC => \&my_func);

$rez->runStage($stage_name, @stage_parameters)
Runs the stage matching the name $stage_name passing in @stage_parameters and returning the result of running that stage. If the stage has already been run in a previous invocation, it will return that saved data.

$rez->runAllStages($stage_name, @stage_parameters)
Runs all stages in order, passing in @stage_parameters.

$rez->doneEarly()
Call this when you don't want to run the rest of the stages. Calling this function tells Script::Resume that there is no further work to be done and the state can be deleted.


LEGALESE

Copyright 2006 by Robert Powers, all rights reserved. This program is free software, you can redistribute it and/or modify it under the same terms as Perl itself.


AUTHOR

2006, Robert Powers <batman@cpan.org>

Programminig
Wy
Wy
yW
Wy
Programming
Wy
Wy
Wy
Wy