Free instance software for linux

Class::StrongSingleton is a stronger and more secure Singleton base class.

SYNOPSIS

package My::Singleton::Class;

use base qw(Class::StrongSingleton);

sub new {
my ($class, %my_params) = @_;
# create our object instance
my $instance = { %my_params };
bless($instance, $class);
# and initialize it as a singleton
$instance->_init_StrongSingleton();
return $instance;
}

1;

# later in your code ...

# create the first instance of our class
my $instance = My::Singleton::Class->new(param => "value");

# try to create a new one again, and
# you end up with the same instance, not
# a new one
my $instance2 = My::Singleton::Class->new(param => "other value");

# calling instance returns the singleton
# instance expected
my $instance3 = My::Singleton::Class->instance();

# although rarely needed, if you have to
# you can destroy the singleton

# either through the instance
$instance->DESTROY();
# or through the class
My::Singleton::Class->DESTROY();

# of course, this is assuming you
# did not override DESTORY yourself

# Also calling instance before calling new
# will returns a new singleton instance
my $instance = My::Singleton::Class->instance();

This module is an alternative to Class::Singleton and Class::WeakSingleton, and provides a more secure Singleton class in that it takes steps to prevent the possibility of accidental creation of multiple instances and/or the overwriting of existsing Singleton instances. For a detailed comparison please see the "SEE ALSO" section.

Here is a description of how it all works. First, the user creates the first Singleton instance of the class in the normal way.

my $obj = My::Singleton::Class->new("variable", "parameter");

This instance is then stored inside a lexically scoped variable within the Class::StrongSingleton package. This prevents the variable from being accessed by anything but methods from the Class::StrongSingleton package. At this point as well, the new method to the class is overridden so that it will always return the Singleton instance. This prevents any accidental overwriting of the Singleton instance. This means that any of the follow lines of code all produce the same instance:

my $instance = $obj->instance();
my $instance = My::Singleton::Class->instance();
my $instance = $obj->new();
my $instance = My::Singleton::Class->new();

Personally, I see this an an improvement over the usual Gang of Four style Singletons which discourages the use of the new method entirely. Through this method, a user can be able to use the Singleton class in a normal way, not having to know its actually a Singleton. This can be handy if your design changes and you no longer need the class as a Singleton.

Net::Amazon::EC2 is a Perl interface to the Amazon Elastic Compute Cloud (EC2) environment.

SYNOPSIS

use Net::Amazon::EC2;

my $ec2 = Net::Amazon::EC2->new(
AWSAccessKeyId => PUBLIC_KEY_HERE,
SecretAccessKey => SECRET_KEY_HERE
);

# Start 1 new instance from AMI: ami-XXXXXXXX
my $instance = $ec2->run_instances(ImageId => ami-XXXXXXXX, MinCount => 1, MaxCount => 1);

my $running_instances = $ec2->describe_instances();

foreach my $inst (@{$running_instances}) {
print "$inst->{instance}[0]{instanceId}n";
}

# Terminate instance

my $result = $ec2->terminate_instances(InstanceId => $instance->{instance}[0]{instanceId});

If an error occurs in communicating with EC2, the return value will be undef and $ec2->{error} will be populated with the message.

Java::Import is Perl module to use Java classes in Perl.

SYNOPSIS

use Java::Import qw(
some.package.SomeClass
);

my $instance = new some.package.SomeClass();
$instance->someMethod();

my $ret_val = some::package::SomeClass::someStaticMethod();
$ret_val->someMethod();

$ret_val2 = $instance->someOtherMethod($ret_val);
$ret_val2->someMethod();

my $java_array_ref $instance->someMethod2();
foreach my $obj ( @$java_array_ref ) {
$obj->someMethod();
}

The purpose of this module is to provide a simple method for using Java classes from a Perl program while using the latest in Open Source Java Technology. Thus, this module makes great use of the GNU Compiler Tools for Java in its implimentation.

ZopeMon application is a GNOME applet to manage multiple Zope instances on your filesystem, created using the mkzopeinstance.py utility.

Essentially, it is a frontend to the zopectl utility for each Zope instance - but provides the convenience of having a list of all your Zope instances available to you, with the ability to start or stop any one of them from a click of a button.

libCIM is a collection of Perl modules which serves as a basis for an implementation of the CIM (Common Information Model).

libCIM provides classes which "mirror" corresponding CIM entities (such as CIM::Class, CIM::Instance) and an API for use in CIM clients.

DocBook to LaTeX/ConTeXt Publishing project is splitted in two instances working on the same principles. Both instances are intended to produce DVI, PostScript, PDF documents from DocBook SGML or XML sources, by converting first to a high level set of TeX macros.

Even if close, each instance is provided as an independent package and works alone. The available instances are:

dblatex

Publishing is done by using LaTeX.

dbcontext

Publishing is done by using ConTeXt.

xen-shell is a simple console application which allows you to easily allow the owner of a single Xen instance to control it, without the overhead of a web-based control panel.
Using this shell users may:
- Boot/Shutodwn their Xen guest.
- Reboot their Xen guest.
- Connect to the serial console of their runing Xen guest.
- Reimage their system to a pristine state, via xen-tools.
- Manipulate their reverse DNS information
The shell features command history, command completion, and integrated help.
It is ideal for a hosting company who wishes to over "virtual machine" hosting to their customers, and allow them to control their own instance.