Elive - Elluminate Live! (c) Command Toolkit bindings

Elive documentation Contained in the Elive distribution.

Index

Code Index:

NAME

Top

Elive - Elluminate Live! (c) Command Toolkit bindings

VERSION

Top

Version 0.96

EXAMPLE

Top

The following (somewhat contrived) example sets up a meeting of selected participants:

    use Elive;
    use Elive::Entity::User;
    use Elive::Entity::Preload;
    use Elive::View::Session;

    my $meeting_name = 'Meeting of the Smiths';

    Elive->connect('http://someEllumServer.com/test',
                   'serversupport', 'mypass');

    my $participants = Elive::Entity::User->list(filter => "(lastName = 'Smith')");
    die "smithless" unless @$participants;

    my $start = time() + 15 * 60; # starts in 15 minutes
    my $end   = $start + 30 * 60; # runs for half an hour

    # upload whiteboard content
    #
    my $preload = Elive::Entity::Preload->upload('welcome.wbd');

    my $meeting = Elive::View::Session->insert({
	 name           => $meeting_name,
	 facilitatorId  => Elive->login,
	 start          => $start . '000',
	 end            => $end   . '000',
         participants   => $participants,
         add_preload    => $preload,
	 });

    Elive->disconnect;

DESCRIPTION

Top

Elive is a set of Perl bindings and entity definitions for the Elluminate Live! Command Toolkit; in particular, the entity commands.

These commands are available as a SOAP web service and can be used to automate the raising, management and connection to meetings; and other related entities, including users, groups, preloads and recordings.

BACKGROUND

Top

Elluminate Live! (c) is software for virtual online classrooms.

It is suitable for meetings, demonstrations web conferences, seminars and IT deployment, training and support.

Most actions that can be performed via the web interface can also be achieved via SOAP web services. This is known as the Command Toolkit and is detailed in chapter 4 of the Elluminate Live! Software Developers Kit (SDK).

Users, Meetings and other resources are stored in a management database. These can be accessed and manipulated via the Entity Commands in the Command Toolkit.

METHODS

Top

connect

     my $e1 = Elive->connect('http://myServer.com/test1', 'user1', 'pass1');

     Elive->connect('http://myServer.com/test2', 'user2', 'pass2');
     my $e2 = Elive->connection;

Connects to an Elluminate server instance. Dies if the connection could not be established. If, for example, the SOAP connection or user login failed.

The login user must either be an Elluminate Live! system administrator account, or a user that has been configured to access the Command Toolkit via web services.

See also: The README file; Elive::Connection::SDK.

connection

     $e1 = Elive->connection
         or warn 'no elive connection active';

Returns the default Elive connection handle.

login

Returns the login user for the default connection.

server_details

Returns the server details for the default connection.

disconnect

Disconnects the default Elluminate connection. It is recommended that you do this prior to exiting your program.

debug

    Elive->debug(1)

    Set or get the debug level.

      0 = no debugging
      1 = dump object and class information 
      2 = also enable SOAP::Lite tracing
      3 = very detailed

has_metadata

Associate an inside-out property with objects of a given class.

ERROR MESSAGES

Top

Elluminate Services Errors:

"Unable to determine a command for the key : Xxxx"

This may indicate that the particular command is is not available for your site instance. Please follow the instructions in the README file for detecting and repairing missing adapters.

"User [<username>], not permitted to access the command {<command>]"

Please ensure that the user is a system administrator account and/or the user has been configured to access commands via web services. See also the README file.

SCRIPTS

Top

elive_query

elive_query is an example simple sql-like script. It is a basic program for listing and retrieving entities. It serves as a simple demonstration script, and can be used to confirm basic operation of Elive.

It server a secondary function of querying entity metadata. For example, to show the user entity:

    % elive_query
    Elive query 0.xx  - type 'help' for help

    elive> show
    usage: show group|meeting|meetingParameters|participantList|preload|recording|serverDetails|serverParameters|session|users

    elive> show meeting
    meeting: Elive::Entity::Meeting:
      meetingId          : pkey Int        
      allModerators      : Bool      -- all participants can moderate
      deleted            : Bool            
      end                : HiResDate -- meeting end time
      facilitatorId      : Str       -- userId of facilitator
      name               : Str       -- meeting name
      password           : Str       -- meeting password
      privateMeeting     : Bool      -- don't display meeting in public schedule
      restrictedMeeting  : Bool      -- Restricted meeting
      start              : HiResDate -- meeting start time

elive_raise_meeting

This is a demonstration script to create a meeting, set options, assign participants and upload meeting preloads (whiteboard and media files to be used to used for the meeting.

For more information, type the command: elive_raise_meeting --help

elive_lint_config

A utility script that checks your Elluminate server configuration. Please see the README file.

SEE ALSO

Top

Modules in the Elive distribution

Elive::Connection::SDK - Elluminate SOAP connection
Elive::View::Session
Elive::Entity::Group
Elive::Entity::ParticipantList
Elive::Entity::Preload
Elive::Entity::Recording
Elive::Entity::Report
Elive::Entity::User

Scripts in the Elive Distribution

elive_query - simple interactive queries on Elive entities
elive_raise_meeting - sample script that create meetings via one-liners
elive_lint_config - sanity checker for Elluminate server configurations

Elive::StandardV2 - This is a separate CPAN module that implements the alternate Elluminate Live! Standard Bridge API (v2).

Elluminate Documentation

The following is either installed with Elluminate Live! Documentation, or can be obtained from Elluminate.

ELM2.5_SDK.pdf

General Description of SDK development for Elluminate Live!. In particular see section 4 - the SOAP Command Toolkit. This module concentrates on implementing the Entity Commands described in section 4.1.8.

DatabaseSchema.pdf

Elluminate Database Schema Documentation.

InstanceManager.pdf

Describes setting up multiple site instances.

AUTHOR

Top

David Warring, <david.warring at gmail.com>

BUGS AND LIMITATIONS

Top

Elive is a newish module

It has been used and tested against a number of sites running Elluminate 9.5 to 10.0.1.

So far it does not implement all SOAP calls, but concentrates on entities such as users, meetings, preloads and meeting participants.

Elive does not support hosted (SAS) systems

The Elive distribution only supports the Elluminate SDK which is implemented by ELM (Elluminate Live Manager) session manager. This SDK is not supported by SAS (Session Administration System).

Update: See also the companion CPAN module Elive::StandardV2 which is under construction and will support the alternate Elluminate Live! standard bridge (v2).

SUPPORT

Top

Please report any bugs or feature requests to bug-elive at rt.cpan.org, or through the web interface at http://rt.cpan.org/NoAuth/ReportBug.html?Queue=Elive. I will be notified, and then you'll automatically be notified of progress on your bug as I make changes.

You can find documentation for this module with the perldoc command.

    perldoc Elive

You can also look for information at:

* RT: CPAN's request tracker

http://rt.cpan.org/NoAuth/Bugs.html?Dist=Elive

* AnnoCPAN: Annotated CPAN documentation

http://annocpan.org/dist/Elive

* CPAN Ratings

http://cpanratings.perl.org/d/Elive

* Search CPAN

http://search.cpan.org/dist/Elive/

ACKNOWLEDGEMENTS

Top

Thanks to Lex Lucas and Simon Haidley for their ongoing support and assistance with the development of this module.

COPYRIGHT & LICENSE

Top

Copyright 2009-2011 David Warring, all rights reserved.

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

Elive documentation Contained in the Elive distribution. 
package Elive;
use warnings; use strict;


our $VERSION = '0.96';

use parent qw{Class::Data::Inheritable};
use Scalar::Util;

use YAML;

use Carp;


our $DEBUG;
BEGIN {
    $DEBUG = $ENV{ELIVE_DEBUG};
}


sub connect {
    my ($class, $url, $login_name, $pass, %opts) = @_;

    die "usage: ${class}->new(url, [login_name] [, pass])"
	unless ($class && $url);

    eval {require Elive::Connection};
    die $@ if $@;

    my $connection = Elive::Connection->connect(
	$url,
	$login_name,
	$pass,
	debug => $class->debug,
	%opts,
	);

    $class->connection($connection);

    return $connection;
}


__PACKAGE__->mk_classdata('connection');


sub login {
    my ($class, %opt) = @_;

    my $connection = $opt{connection} || $class->connection;

    die "not connected"
	unless $connection;

    return $connection->login;
}


sub server_details {
    my ($class, %opt) = @_;

    my $connection = $opt{connection} || $class->connection;

    die "not connected"
	unless $connection;

    return $connection->server_details;
}
    

sub disconnect {
    my ($class, %opt) = @_;

    if (my $connection = $class->connection) {
	$connection->disconnect;
	$class->connection(undef);
    }

    return;
}


sub debug {
    my ($class, $level) = @_;

    if (defined $level) {
	$DEBUG = $level;
    }

    return $DEBUG || 0;
}

our %Meta_Data;


sub has_metadata {

    my $class = shift;
    my $accessor = shift;

    my $accessor_fun = $class->can($accessor);

    unless ($accessor_fun) {

	no strict 'refs';

	$accessor_fun = sub {
	    my $self = shift;
	    my $ref = $self->_refaddr
		or return;

	    if (@_) {
		$Meta_Data{ $ref }{ $accessor } = $_[0];
	    }

	    return $Meta_Data{ $ref }{ $accessor };
	};

	*{$class.'::'.$accessor} = $accessor_fun;
    }

    return $accessor_fun;
}

sub DEMOLISH {
    my $self = shift;
    delete $Meta_Data{Scalar::Util::refaddr($self)};
    return;
}


1; # End of Elive