view release on metacpan or search on metacpan
received the program in object code or executable form alone.)
Source code for a work means the preferred form of the work for making
modifications to it. For an executable file, complete source code means
all the source code for all modules it contains; but, as a special
exception, it need not include source code for modules which are standard
libraries that accompany the operating system on which the executable
file runs, or for standard header files or definitions files that
accompany that operating system.
4. You may not copy, modify, sublicense, distribute or transfer the
Program except as expressly provided under this General Public License.
Any attempt otherwise to copy, modify, sublicense, distribute or transfer
the Program is void, and will automatically terminate your rights to use
the Program under this License. However, parties who have received
copies, or rights to use copies, from you under this General Public
License will not have their licenses terminated so long as such parties
remain in full compliance.
5. By copying, distributing or modifying the Program (or any work based
on the Program) you indicate your acceptance of this license to do so,
and all its terms and conditions.
6. Each time you redistribute the Program (or any work based on the
Program), the recipient automatically receives a license from the original
licensor to copy, distribute or modify the Program subject to these
terms and conditions. You may not impose any further restrictions on the
recipients' exercise of the rights granted herein.
7. The Free Software Foundation may publish revised and/or new versions
of the General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the Program
specifies a version number of the license which applies to it and "any
may not charge a fee for this Package itself. However, you may distribute this
Package in aggregate with other (possibly commercial) programs as part of a
larger (possibly commercial) software distribution provided that you do not
advertise this Package as a product of your own.
6. The scripts and library files supplied as input to or produced as output
from the programs of this Package do not automatically fall under the copyright
of this Package, but belong to whomever generated them, and may be sold
commercially, and may be aggregated with this Package.
7. C or perl subroutines supplied by you and linked into this Package shall not
be considered part of this Package.
8. The name of the Copyright Holder may not be used to endorse or promote
products derived from this software without specific prior written permission.
9. THIS PACKAGE IS PROVIDED "AS IS" AND WITHOUT ANY EXPRESS OR IMPLIED
WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
The End
lib/API/Eulerian/EDW.pm view on Meta::CPAN
package API::Eulerian::EDW;
use strict;
use API::Eulerian::EDW::Peer::Rest();
sub new {
my $proto = shift();
my $class = ref($proto) || $proto;
return bless({}, $class);
}
sub get_csv_file {
my ($self, $rh_p, $query) = @_;
$rh_p ||= {};
$rh_p->{accept} = 'text/csv';
$rh_p->{hook} = 'API::Eulerian::EDW::Hook::Noop';
$query ||= '';
my $peer = new API::Eulerian::EDW::Peer::Rest( $rh_p );
if ( !defined $peer ) {
lib/API/Eulerian/EDW/Authority.pm view on Meta::CPAN
#
# @param $class - API::Eulerian::EDW Authority class.
# @param $kind - API::Eulerian::EDW Authority token kind.
# @param $platform - API::Eulerian::EDW Authority Platform.
# @param $grid - API::Eulerian::EDW Data Warehouse Grid.
# @param $ip - Peer IP.
# @param $token - API::Eulerian::EDW Token.
#
# @return API::Eulerian::EDW::Status
#
sub bearer
{
my ( $class, $kind, $platform, $grid, $ip, $token ) = @_;
my $response;
my $status;
my $code;
my $json;
# Get URL used to request API::Eulerian::EDW Authority for Token.
$status = $class->_url( $kind, $platform, $grid, $ip, $token );
# Handle errors
lib/API/Eulerian/EDW/Authority.pm view on Meta::CPAN
#
# @param $class - API::Eulerian::EDW::Authority Class.
# @param $kind - API::Eulerian::EDW Data Warehouse Token Kind.
# @param $platform - API::Eulerian::EDW Data Warehouse Platform name.
# @param $grid - API::Eulerian::EDW Data Warehouse Site Grid name.
# @param $ip - IP of API::Eulerian::EDW Data Warehouse Peer.
# @param $token - API::Eulerian::EDW Token.
#
# @return API::Eulerian::EDW::Status
#
sub _url
{
my ( $class, $kind, $platform, $grid, $ip, $token ) = @_;
my $domain;
#
# Sanity check mandatories arguments
#
if( ! ( defined( $grid ) && length( $grid ) > 0 ) ) {
return $class->_error(
406, "Mandatory argument 'grid' is missing or invalid"
);
lib/API/Eulerian/EDW/Authority.pm view on Meta::CPAN
}
#
# @brief Return Error on API::Eulerian::EDW Authority Services.
#
# @param $class - API::Eulerian::EDW::Authority class.
# @param $code - HTTP Error code.
# @param $message - Error message.
#
# return API::Eulerian::EDW::Status
#
sub _error
{
my ( $class, $code, $message ) = @_;
my $status = API::Eulerian::EDW::Status->new();
$status->error( 1 );
$status->code( $code );
$status->msg( $message );
return $status;
}
#
# @brief Return Success on API::Eulerian::EDW Authority Services.
#
# @param $class - API::Eulerian::EDW::Authority class.
# @param $kind - Token kind.
# @param $json - Json reply.
#
# @return API::Eulerian::EDW::Status
#
sub _success
{
my ( $class, $kind, $json ) = @_;
my $status = API::Eulerian::EDW::Status->new();
my $row = $json->{ data }->{ rows }->[ 0 ];
$status->{ bearer } = 'bearer ' . $row->{ $kind . '_token' };
return $status;
}
#
# End up perl module properly
#
lib/API/Eulerian/EDW/Bench.pm view on Meta::CPAN
# Import API::Eulerian::EDW::Chrono
#
use API::Eulerian::EDW::Chrono;
#
# @brief Allocate and initialize a new API::Eulerian::EDW::Bench instance.
#
# @param $class - API::Eulerian::EDW::Bench class.
#
# @return API::Eulerian::EDW::Bench instance.
#
sub new
{
return bless( {
_SUITE => {},
_LAST => undef,
_FIRST => undef,
}, shift );
}
#
# @brief Start chronograph.
#
# @param $self - API::Eulerian::EDW::Bench instance.
#
sub start
{
shift->last( new API::Eulerian::EDW::Chrono() );
}
#
# @brief Get/Set First Stage.
#
# @param $self - API::Eulerian::EDW::Bench instance.
# @param $first - First stage.
#
# @return First stage.
#
sub first
{
my ( $self, $first ) = @_;
$self->{ _FIRST } = $first if defined( $first );
return $self->{ _FIRST };
}
#
# @brief Get/Set Last stage.
#
# @param $self - API::Eulerian::EDW::Bench instance.
# @param $last - Last stage.
#
# @retun Last stage.
#
sub last
{
my ( $self, $last ) = @_;
my $first = $self->first();
$self->{ _LAST } = $last if defined( $last );
$self->first( $last ) if ! defined( $first );
return $self->{ _LAST };
}
#
# @brief Stop watching current Stage save elapsed time.
#
# @param $self - API::Eulerian::EDW::Bench instance.
# @param $name - Stage name.
#
# @return Stage.
#
sub stage
{
my ( $self, $name ) = @_;
$self->{ _SUITE }->{ $name } = $self->last()->elapsed();
}
#
# @brief Dump Bench stages suites.
#
# @param $self - API::Eulerian::EDW::Bench instance.
#
sub dump
{
my ( $self ) = @_;
my %suite = %{$self->{ _SUITE }};
foreach my $key ( keys %suite ) {
printf( "%15s : %s\n", $key, $suite{ $key } );
}
printf( "%15s : %s\n", 'total', $self->first()->elapsed() );
}
lib/API/Eulerian/EDW/Chrono.pm view on Meta::CPAN
use strict; use warnings;
#
# Import gettimeofday, tv_interval
#
use Time::HiRes qw( gettimeofday tv_interval );
#
# @brief Allocate and initialize a new API::Eulerian::EDW Chrono instance.
#
# @return API::Eulerian::EDW::Chrono instance.
#
sub new
{
return bless( {
_CHRONO => [ gettimeofday ],
}, shift
);
}
#
# @brief Get Elapsed time between Chrono creation and call to elapsed.
#
# @param $self - API::Eulerian::EDW::Chrono instance.
#
# @return Elapsed time ( secondes.microsecondes )
#
sub elapsed
{
return tv_interval( shift->{ _CHRONO }, [ gettimeofday ] );
}
#
# Endup module properly
#
1;
__END__
lib/API/Eulerian/EDW/File.pm view on Meta::CPAN
# Import API::Eulerian::EDW::Status
#
use API::Eulerian::EDW::Status;
#
# @brief Read file content.
#
# @param path - File path.
#
# @return API::Eulerian::EDW::Status
#
sub read
{
my $status = API::Eulerian::EDW::Status->new();
my ( $class, $path ) = @_;
my $data;
my $fd;
# Open file for reading
open $fd, "<", $path or do {
$status->error( 1 );
$status->code( -1 );
$status->msg( "Opening file : $path for reading failed. $!" );
lib/API/Eulerian/EDW/File.pm view on Meta::CPAN
}
#
# @brief Test if given path is writable.
#
# @param $class - API::Eulerian::EDW::File class.
# @param $path - Filesystem path.
#
# @return 0 - Path isnt writable.
# @return 1 - Path is writable.
#
sub writable
{
my ( $class, $path ) = @_;
return -w $path;
}
#
# End up perl module properly
#
1;
__END__
lib/API/Eulerian/EDW/Hook.pm view on Meta::CPAN
#
use strict; use warnings;
#
# @brief Allocate a new Eulerian Data Warehouse Peer Hook.
#
# @param $class - Eulerian Data Warehouse Peer Hook Class.
# @param $setup - Setup attributes.
#
# @return Eulerian Data Warehouse Peer Hook instance.
#
sub new
{
my ( $class, $setup ) = @_;
my $self = bless( {}, $class );
$self->setup( $setup );
return $self;
}
#
# @brief Setup Eulerian Data Warehouse Peer Hook.
#
# @param $self - Eulerian Data Warehouse Peer Hook.
# @param $setup - Setup entries.
#
sub setup
{
my ( $self, $setup ) = @_;
}
#
# @brief
#
# @param $self - Eulerian Data Warehouse Peer Hook.
# @param $uuid - UUID of Eulerian Analytics Analysis.
# @param $start - Timerange begin.
# @param $end - Timerange end.
# @param $columns - Array of Columns definitions.
#
sub on_headers
{
my ( $self, $uuid, $start, $end, $columns ) = @_;
}
#
# @brief
#
# @param $self - Eulerian Data Warehouse Peer Hook.
# @param $uuid - UUID of Eulerian Analytics Analysis.
# @param $rows - Array of Array of Columns values.
#
sub on_add
{
my ( $self, $uuid, $rows ) = @_;
}
#
# @brief
#
# @param $self - Eulerian Data Warehouse Peer Hook.
# @param $uuid - UUID of Eulerian Analytics Analysis.
# @param $rows - Array of Array of Columns values.
#
sub on_replace
{
my ( $self, $uuid, $rows ) = @_;
}
#
# @brief
#
# @param $self - Eulerian Data Warehouse Peer Hook.
# @param $uuid - UUID of Eulerian Analytics Analysis.
# @param $progress - Progression value.
#
sub on_progress
{
my ( $self, $uuid, $progress ) = @_;
}
#
# @brief
#
# @param $self - Eulerian Data Warehouse Peer Hook.
# @param $uuid - UUID of Eulerian Analytics Analysis.
# @param $token - AES Token or Bearer.
# @param $errnum - Error number.
# @param $err - Error description.
# @param $updated - Count of updates on server.
#
sub on_status
{
my ( $self, $uuid, $token, $errnum, $err, $updated ) = @_;
}
#
# Endup module properly
#
1;
__END__
lib/API/Eulerian/EDW/Hook/Noop.pm view on Meta::CPAN
our @ISA = qw/ API::Eulerian::EDW::Hook /;
#
# @brief Allocate a new Eulerian Data Warehouse Peer Hook.
#
# @param $class - Eulerian Data Warehouse Peer Hook Class.
# @param $setup - Setup attributes.
#
# @return Eulerian Data Warehouse Peer Hook instance.
#
sub new
{
my ( $class, $setup ) = @_;
return $class->SUPER::new( $setup );
}
#
# @brief Setup Eulerian Data Warehouse Peer Hook.
#
# @param $self - Eulerian Data Warehouse Peer Hook.
# @param $setup - Setup entries.
#
sub setup
{
my ( $self, $setup ) = @_;
return $self;
}
#
# @brief Start a new Analysis.
#
# @param $self - Eulerian Data Warehouse Peer Hook.
# @param $uuid - UUID of Eulerian Analytics Analysis.
# @param $start - Timerange begin.
# @param $end - Timerange end.
# @param $columns - Array of Columns definitions.
#
sub on_headers
{
my ( $self, $uuid, $start, $end, $columns ) = @_;
return $self;
}
#
# @brief Analysis reply rows on Row outputs analysis.
#
# @param $self - Eulerian Data Warehouse Peer Hook.
# @param $uuid - UUID of Eulerian Analytics Analysis.
# @param $rows - Array of Array of Columns values.
#
sub on_add
{
my ( $self, $uuid, $rows ) = @_;
return $self;
}
#
# @brief Analysis reply rows on Distinct/Pivot analysis.
#
# @param $self - Eulerian Data Warehouse Peer Hook.
# @param $uuid - UUID of Eulerian Analytics Analysis.
# @param $rows - Array of Array of Columns values.
#
sub on_replace
{
my ( $self, $uuid, $rows ) = @_;
return $self;
}
#
# @brief Analysis progression callback.
#
# @param $self - Eulerian Data Warehouse Peer Hook.
# @param $uuid - UUID of Eulerian Analytics Analysis.
# @param $progress - Progression value.
#
sub on_progress
{
my ( $self, $uuid, $progress ) = @_;
return $self;
}
#
# @brief End of Eulerian Data Warehouse Analysis.
#
# @param $self - Eulerian Data Warehouse Peer Hook.
# @param $uuid - UUID of Eulerian Analytics Analysis.
# @param $token - AES Token or Bearer.
# @param $errnum - Error number.
# @param $err - Error description.
# @param $updated - Count of updates on server.
#
sub on_status
{
my ( $self, $uuid, $token, $errnum, $err, $updated ) = @_;
return $self;
}
#
# Endup module properly
#
1;
lib/API/Eulerian/EDW/Hook/Print.pm view on Meta::CPAN
#
use parent 'API::Eulerian::EDW::Hook';
#
# @brief Allocate a new Eulerian Data Warehouse Peer Hook.
#
# @param $class - Eulerian Data Warehouse Peer Hook Class.
# @param $setup - Setup attributes.
#
# @return Eulerian Data Warehouse Peer Hook instance.
#
sub new
{
my ( $class, $setup ) = @_;
return $class->SUPER::new( $setup );
}
#
# @brief Setup Eulerian Data Warehouse Peer Hook.
#
# @param $self - Eulerian Data Warehouse Peer Hook.
# @param $setup - Setup entries.
#
sub setup
{
my ( $self, $setup ) = @_;
return $self;
}
#
# @brief Start a new Analysis.
#
# @param $self - Eulerian Data Warehouse Peer Hook.
# @param $uuid - UUID of Eulerian Analytics Analysis.
# @param $start - Timerange begin.
# @param $end - Timerange end.
# @param $columns - Array of Columns definitions.
#
sub on_headers
{
my ( $self, $uuid, $start, $end, $columns ) = @_;
my $string = <<string_end;
{
. UUID : $uuid
. TIMERANGE : {
begin : $start,
end : $end,
},
. HEADERS : {
lib/API/Eulerian/EDW/Hook/Print.pm view on Meta::CPAN
print( $string );
return $self;
}
#
# @brief Analysis reply rows on Row outputs analysis.
#
# @param $self - Eulerian Data Warehouse Peer Hook.
# @param $uuid - UUID of Eulerian Analytics Analysis.
# @param $rows - Array of Array of Columns values.
#
sub on_add
{
my ( $self, $uuid, $rows ) = @_;
my $string = '';
for my $row ( @$rows ) {
for my $col ( @$row ) {
$string .= defined( $col ) ? "$col | " : "NULL | ";
}
$string .= "\n";
}
print( $string );
}
#
# @brief Analysis reply rows on Distinct/Pivot analysis.
#
# @param $self - Eulerian Data Warehouse Peer Hook.
# @param $uuid - UUID of Eulerian Analytics Analysis.
# @param $rows - Array of Array of Columns values.
#
sub on_replace
{
my ( $self, $uuid, $rows ) = @_;
my $string = '';
for my $row ( @$rows ) {
for my $col ( @$row ) {
$string .= defined( $col ) ? "$col | " : "NULL | ";
}
$string .= "\n";
}
print( $string );
}
#
# @brief Analysis progression callback.
#
# @param $self - Eulerian Data Warehouse Peer Hook.
# @param $uuid - UUID of Eulerian Analytics Analysis.
# @param $progress - Progression value.
#
sub on_progress
{
my ( $self, $uuid, $progress ) = @_;
print( "PROGRESSION : $progress\n" );
return $self;
}
#
# @brief End of Eulerian Data Warehouse Analysis.
#
# @param $self - Eulerian Data Warehouse Peer Hook.
# @param $uuid - UUID of Eulerian Analytics Analysis.
# @param $token - AES Token or Bearer.
# @param $errnum - Error number.
# @param $err - Error description.
# @param $updated - Count of updates on server.
#
sub on_status
{
my ( $self, $uuid, $token, $errnum, $err, $updated ) = @_;
# my $string = <<string_end;
# $uuid : {
# error_code => $errnum,
# error_msg => $err,
# }
#string_end
#print( $string );
return $self;
lib/API/Eulerian/EDW/Parser.pm view on Meta::CPAN
use strict; use warnings;
#
# @brief Allocate and initialize a new API::Eulerian::EDW::Parser instance.
#
# @param $class - API::Eulerian::EDW::Parser class.
# @param $path - Input file path.
# @param $uuid - Eulerian Data Warehouse Analysis UUID.
#
# @return API::Eulerian::EDW::Parser instance.
#
sub new
{
my ( $class, $path, $uuid ) = @_;
return bless( {
_PATH => $path,
_UUID => $uuid,
}, $class );
}
#
# @brief Get/Set Eulerian Data Warehouse Analysis UUID.
#
# @param $self - API::Eulerian::EDW::Parser instance.
# @param $uuid - Eulerian Data Warehouse Analysis UUID.
#
# @return Eulerian Data Warehouse Analysis UUID.
#
sub uuid
{
my ( $self, $uuid ) = @_;
$self->{ _UUID } = $uuid if $uuid;
return $self->{ _UUID };
}
#
# @brief Get/Set Input file path.
#
# @parm $self - API::Eulerian::EDW::Parser instance.
#
# @return Input file path.
#
sub path
{
my ( $self, $path ) = @_;
$self->{ _PATH } = $path if $path;
return $self->{ _PATH };
}
#
# @brief Parse input file path and call user specific hook.
#
# @param $self - API::Eulerian::EDW::Parser instance.
# @param $hook - API::Eulerian::EDW::Hook instance.
#
sub do {}
#
# Endup module properly
#
1;
__END__
=pod
=head1 NAME
lib/API/Eulerian/EDW/Parser/CSV.pm view on Meta::CPAN
use Text::CSV;
#
# @brief
#
# @param $class - API::Eulerian::EDW::Parser class.
# @param $path - File Path.
# @param $uuid - Request uuid.
#
# @return API::Eulerian::EDW::Json Parser.
#
sub new
{
my ( $class, $path, $uuid ) = @_;
my $self;
my $file;
my $fd;
if( open( $file, '<:encoding(utf8)', $path ) ) {
$self = $class->SUPER::new( $path, $uuid );
$self->{ _FILE } = $file;
$self->{ _PARSER } = Text::CSV->new( {
lib/API/Eulerian/EDW/Parser/CSV.pm view on Meta::CPAN
return $self;
}
#
# @brief
#
# @param $self
#
# @return
#
sub file
{
return shift->{ _FILE };
}
#
# @brief
#
# @param $self
#
# @return
#
sub parser
{
return shift->{ _PARSER };
}
#
# @brief
#
# @param $self - API::Eulerian::EDW::Parser
#
sub do
{
my ( $self, $hooks ) = @_;
my $parser = $self->parser();
my $file = $self->file();
my $uuid = $self->uuid();
my @headers = ();
my $start = 0;
my $end = 0;
my @rows;
my $line;
lib/API/Eulerian/EDW/Parser/JSON.pm view on Meta::CPAN
use FileHandle;
#
# @brief
#
# @param $class - API::Eulerian::EDW::Parser class.
# @param $path - File Path.
# @param $uuid - Request UUID.
#
# @return API::Eulerian::EDW::Json Parser.
#
sub new
{
my ( $class, $path, $uuid ) = @_;
my $self;
my $fd;
# Setup base class instance
$self = $class->SUPER::new( $path, $uuid );
# Create a new FileHandle
$self->{ _FD } = $fd = FileHandle->new();
lib/API/Eulerian/EDW/Parser/JSON.pm view on Meta::CPAN
return $self;
}
#
# @brief
#
# @param $self
#
# @return
#
sub parser
{
return shift->{ _PARSER };
}
#
# @brief
#
# @param $self - API::Eulerian::EDW::Parser
#
use Data::Dumper;
sub do
{
my ( $self, $hooks ) = @_;
my $parser = $self->parser();
my $depth = -1;
my @in = ();
my $uuid;
my $msg;
my $key;
# Parse JSON stream
$parser->process_tokens(
# Property begin
start_property => sub
{
$key = shift;
},
# Property end
end_property => sub
{
},
# String
add_string => sub
{
my $parent = $in[ $depth ];
if( ref( $parent ) eq 'ARRAY' ) {
$parent->[ scalar( @$parent ) ] = shift;
} elsif( ref( $parent ) eq 'HASH' ) {
$parent->{ $key } = shift;
}
},
# Number
add_number => sub
{
my $parent = $in[ $depth ];
if( ref( $parent ) eq 'ARRAY' ) {
$parent->[ scalar( @$parent ) ] = shift;
} elsif( ref( $parent ) eq 'HASH' ) {
$parent->{ $key } = shift;
}
},
# Null
add_null => sub
{
my $parent = $in[ $depth ];
if( ref( $parent ) eq 'ARRAY' ) {
$parent->[ scalar( @$parent ) ] = undef;
} elsif( ref( $parent ) eq 'HASH' ) {
$parent->{ $key } = undef;
}
},
# Object begin
start_object => sub
{
$in[ ++$depth ] = {};
},
# Object end
end_object => sub
{
my $parent = $in[ $depth - 1 ] if $depth > 0;
if( ref( $parent ) eq 'ARRAY' ) {
$parent->[ scalar( @$parent ) ] = $in[ $depth ];
} elsif( ref( $parent ) eq 'HASH' ) {
$parent->{ $key } = $in[ $depth ];
}
if( $depth == 1 ) {
$msg = $in[ $depth ];
#print( Dumper( $msg ) . "\n" ); die "";
$uuid = $msg->{ uuid };
print( "UUID : $uuid\n" );
$hooks->on_headers(
$uuid, $msg->{ from }, $msg->{ to },
$msg->{ schema }
);
}
$depth--;
},
# Array begin
start_array => sub
{
$in[ ++$depth ] = [];
},
# Array end
end_array => sub
{
my $parent = $in[ $depth - 1 ] if $depth > 0;
if( ref( $parent ) eq 'ARRAY' ) {
$parent->[ scalar( @$parent ) ] = $in[ $depth ];
} elsif( ref( $parent ) eq 'HASH' ) {
$parent->{ $key } = $in[ $depth ];
}
if( $depth == 2 && $uuid ) {
$hooks->on_add( $uuid, [ $in[ $depth ] ] );
}
lib/API/Eulerian/EDW/Peer.pm view on Meta::CPAN
use API::Eulerian::EDW::Status();
#
# @brief Allocate a new Eulerian Data Warehouse Peer.
#
# @param $class - Eulerian Data Warehouse Peer Class.
# @param $setup - Setup attributes.
#
# @return Eulerian Data Warehouse Peer instance.
#
sub new
{
my $proto = shift();
my $class = ref($proto) || $proto;
my $setup = shift() || {};
return bless({
_CLASS => $class,
_KIND => 'access',
_PLATFORM => 'fr',
_HOOKS => undef,
_TOKEN => undef,
lib/API/Eulerian/EDW/Peer.pm view on Meta::CPAN
});
}
#
# @brief Class attribute getter.
#
# @param $self - Eulerian Data Warehouse Peer.
#
# @return Eulerian Data Warehouse Peer Class name.
#
sub class
{
return shift->{ _CLASS };
}
# @brief Token Kind attribute accessors.
#
# @param $self - Eulerian Data Warehouse Peer.
# @param $kind - Token kind.
#
# @return Token Kind.
#
sub kind
{
my ( $self, $kind ) = @_;
$self->{ _KIND } = $kind if defined( $kind );
return $self->{ _KIND };
}
#
# @brief Host attribute accessors.
#
# @param $self - Eulerian Data Warehouse Peer.
# @param $host - Eulerian Data Warehouse Host name.
#
# @return Eulerian Data Warehouse Host Name.
#
sub host
{
my ( $self, $host ) = @_;
$self->{ _HOST } = $host if defined( $host );
return $self->{ _HOST };
}
#
# @brief Ports attribute accessors.
#
# @param $self - Eulerian Data Warehouse Peer.
# @param $ports - Eulerian Data Warehouse Host Ports.
#
# @return Eulerian Data Warehouse Host Ports.
#
sub ports
{
my ( $self, $ports ) = @_;
$self->{ _PORTS } = $ports if defined( $ports );
return $self->{ _PORTS };
}
#
# @brief Platform attribute accessors.
#
# @param $self - Eulerian Data Warehouse Peer.
# @param $platform - Eulerian Data Warehouse Platform.
#
# @return Eulerian Data Warehouse Platform.
#
sub platform
{
my ( $self, $platform ) = @_;
$self->{ _PLATFORM } = $platform if defined( $platform );
return $self->{ _PLATFORM };
}
#
# @brief Hook attribute accessors.
#
# @param $self - Eulerian Data Warehouse Peer.
# @param $hook - Eulerian Data Warehouse Peer Hook.
#
# @return Eulerian Data Warehouse Peer Hook.
#
sub hook
{
my ( $self, $hook ) = @_;
$self->{ _HOOKS } = $hook if defined( $hook );
return $self->{ _HOOKS };
}
#
# @brief Grid attribute accessors.
#
# @param $self - Eulerian Data Warehouse Peer.
# @param $grid - Eulerian Data Warehouse Grid.
#
# @return Eulerian Data Warehouse Grid.
#
sub grid
{
my ( $self, $grid ) = @_;
$self->{ _GRID } = $grid if defined( $grid );
return $self->{ _GRID };
}
#
# @brief Secure attribute accessors.
#
# @param $self - Eulerian Data Warehouse Peer.
# @param $secure - Secure mode flag.
#
# @return Secure mode flag.
#
sub secure
{
my ( $self, $secure ) = @_;
$self->{ _SECURE } = $secure if defined( $secure );
return $self->{ _SECURE };
}
#
# @brief IP attribute accessors.
#
# @param $self - Eulerian Data Warehouse Peer.
# @param $ip - Eulerian Data Warehouse Peer IP.
#
# @return Secure mode flag.
#
sub ip
{
my ( $self, $ip ) = @_;
$self->{ _IP } = $ip if defined( $ip );
return $self->{ _IP };
}
#
# @brief Token attribute accessors.
#
# @param $self - Eulerian Data Warehouse Peer.
# @param $token - Eulerian Token.
#
# @return Eulerian Token.
#
sub token
{
my ( $self, $token ) = @_;
$self->{ _TOKEN } = $token if defined( $token );
return $self->{ _TOKEN };
}
#
# @brief Setup Eulerian Data Warehouse Peer.
#
# @param $self - Eulerian Data Warehouse Peer.
# @param $setup - Setup entries.
#
sub setup
{
my ( $self, $setup ) = @_;
foreach my $param ( qw/
kind platform hook secure token grid ip host ports / ) {
if ( $self->can($param) && exists $setup->{ $param } ) {
$self->$param( $setup->{$param} );
}
}
return $self;
}
#
# @brief Dump Eulerian Data Warehouse Peer settings.
#
# @param $self - Eulerian Data Warehouse Peer.
#
sub dump
{
my ( $self ) = @_;
my $hook = $self->hook() ? 'Set' : 'Unset';
my $secure = $self->secure() ? 'True' : 'False';
my $ports = $self->ports();
my $dump = "\n";
$ports = $ports ? $ports->[ 0 ] . ',' . $ports->[ 1 ] : undef;
$dump .= 'Host : ' . $self->host() . "\n" if $self->host();
$dump .= 'Ports : ' . $ports . "\n" if $ports;
lib/API/Eulerian/EDW/Peer.pm view on Meta::CPAN
return $self;
}
#
# @brief Get Authorization bearer value from Eulerian Authority Services.
#
# @param $self - Eulerian Data Warehouse Peer.
#
# @return API::Eulerian::EDW::Status. On success a new entry 'bearer' is inserted into
# the Status.
#
sub _bearer
{
my $self = shift;
my $bearer = $self->{ _BEARER };
my $status;
if( ! defined( $bearer ) ) {
# Request Authority Services for a valid bearer
$status = API::Eulerian::EDW::Authority->bearer(
$self->kind(), $self->platform(),
$self->grid(), $self->ip(),
lib/API/Eulerian/EDW/Peer.pm view on Meta::CPAN
return $status;
}
#
# @brief Create HTTP Request Headers.
#
# @param $self - Eulerian Data Warehouse Peer.
#
# @return API::Eulerian::EDW::Status. On success a new entry 'headers' is inserted into
# the status.
#
sub headers
{
my $self = shift;
my $status = $self->_bearer();
my $headers;
if( ! $status->error() ) {
# Create a new Object Headers
$headers = API::Eulerian::EDW::Request->headers();
# Setup Authorization Header value
$headers->push_header( 'Authorization', $status->{ bearer } );
lib/API/Eulerian/EDW/Peer/Rest.pm view on Meta::CPAN
'csv' => 'API::Eulerian::EDW::Parser::CSV',
);
#
# @brief Allocate and initialize a new Eulerian Data Warehouse Rest Peer.
#
# @param $class - Eulerian Data Warehouse Rest Peer class.
# @param $setup - Setup attributes.
#
# @return Eulerian Data Warehouse Peer.
#
sub new
{
my $proto = shift();
my $class = ref($proto) || $proto;
my $setup = shift() || {};
my $self = $class->SUPER::new();
# Setup Rest Peer Default attributes values
$self->{ _ACCEPT } = $setup->{accept} || 'application/json';
$self->{ _ENCODING } = 'gzip';
lib/API/Eulerian/EDW/Peer/Rest.pm view on Meta::CPAN
return bless($self, $class);
}
#
# @brief UUID attribute accessors.
#
# @param $self - Eulerian Data Warehouse Peer.
# @param $uuid - Request UUID.
#
# @return UUID.
#
sub uuid
{
my ( $self, $uuid ) = @_;
$self->{ _UUID } = $uuid if defined( $uuid );
return $self->{ _UUID };
}
#
# @brief Encoding attribute accessors.
#
# @param $self - Eulerian Data Warehouse Peer.
# @param $encoding - Encoding.
#
# @return Encoding.
#
sub encoding
{
my ( $self, $encoding ) = @_;
$self->{ _ENCODING } = $encoding if defined( $encoding );
return $self->{ _ENCODING };
}
#
# @brief Accept attribute accessors.
#
# @param $self - Eulerian Data Warehouse Peer.
# @param $accept - Accept.
#
# @return Accept.
#
sub accept
{
my ( $self, $accept ) = @_;
$self->{ _ACCEPT } = $accept if defined( $accept );
return $self->{ _ACCEPT };
}
#
# @brief Working directory attribute accessors.
#
# @param $self - Eulerian Data Warehouse Peer.
# @param $wdir - Working directory.
#
# @return Working Directory.
#
sub wdir
{
my ( $self, $wdir ) = @_;
$self->{ _WDIR } = $wdir if defined( $wdir );
return $self->{ _WDIR };
}
#
# @brief Setup Eulerian Data Warehouse Peer.
#
# @param $self - Eulerian Data Warehouse Peer.
# @param $setup - Setup entries.
#
sub setup
{
my ( $self, $setup ) = @_;
# Setup base interface values
$self->SUPER::setup( $setup );
# Setup Rest specifics options
$self->accept( $setup->{ accept } ) if exists( $setup->{ accept } );
$self->encoding( $setup->{ encoding } ) if exists( $setup->{ encoding } );
$self->wdir( $setup->{ wdir } ) if exists( $setup->{ wdir } );
return $self;
}
#
# @brief Dump Eulerian Data Warehouse Peer setup.
#
# @param $self - Eulerian Data Warehouse Peer.
#
sub dump
{
my $self = shift;
my $dump = '';
$self->SUPER::dump();
$dump .= 'Accept : ' . $self->accept() . "\n";
$dump .= 'Encoding : ' . $self->encoding() . "\n";
$dump .= 'WorkDir : ' . $self->wdir() . "\n\n";
print( $dump );
return $self;
}
#
# @brief Get remote URL to Eulerian Data Warehouse Platform.
#
# @param $self - Eulerian Data Warehouse Peer.
#
# @return Remote URL to Eulerian Data Warehouse Platform.
#
sub url
{
my $self = shift;
my $platform;
my $host;
my $url;
$url = $self->secure() ? 'https://' : 'http://';
$platform = $self->platform();
$host = $self->host();
if( $host ) {
lib/API/Eulerian/EDW/Peer/Rest.pm view on Meta::CPAN
}
#
# @brief Get HTTP Request Body used to send command to Eulerian Data Warehouse
# Platform.
#
# @param $self - Eulerian Data Warehouse Rest Peer.
# @param $command - Eulerian Data Warehouse Command.
#
# @return HTTP Request Body.
#
sub body
{
my ( $self, $command ) = @_;
$command =~ s/\n//gm;
return JSON::encode_json({
kind => 'edw#request',
query => $command,
creationTime => POSIX::strftime( '%d/%m/%Y %H:%M:%S', gmtime() ),
location => Sys::Hostname::hostname(),
expiration => undef,
});
};
#
# @brief Setup HTTP Request Headers.
#
# @param $self - Eulerian Data Warehouse Peer.
#
# @return HTTP Headers.
#
sub headers
{
my $self = shift;
my $status = $self->SUPER::headers();
my $headers;
if( ! $status->error() ) {
$headers = $status->{ headers };
$headers->push_header( 'Content-Type', 'application/json' );
$headers->push_header( 'Accept', $self->accept() );
$headers->push_header( 'Accept-Encoding', $self->encoding() );
lib/API/Eulerian/EDW/Peer/Rest.pm view on Meta::CPAN
return $status;
}
#
# @brief Create a new JOB on Eulerian Data Warehouse Rest Platform.
#
# @param $self - Eulerian Data Warehouse Peer.
# @param $command - Eulerian Data Warehouse Command.
#
# @return Reply content.
#
sub create
{
my ( $self, $command ) = @_;
my $response;
my $status;
# Create headers
$status = $self->headers();
if( ! $status->error() ) {
my $url = $self->url() . '/edw/jobs';
lib/API/Eulerian/EDW/Peer/Rest.pm view on Meta::CPAN
return $status;
}
#
# @brief Get Eulerian Data Warehouse Job Status.
#
# @param $self - Eulerian Data Warehouse Rest Peer.
# @param $reply - Eulerian Data Warehouse Platform Reply.
#
# @return Job Reply status.
#
sub status
{
my ( $self, $status ) = @_;
my $response = $status->{ response };
my $url = API::Eulerian::EDW::Request->json(
$response )->{ data }->[ 1 ];
$status = $self->headers();
if( ! $status->error() ) {
$status = API::Eulerian::EDW::Request->get(
$url, $status->{ headers }
lib/API/Eulerian/EDW/Peer/Rest.pm view on Meta::CPAN
}
#
# @brief Test if Job status is 'Running';
#
# @param $self - API::Eulerian::EDW::Rest instance.
# @param $rc - Return context.
#
# @return 0 - Not running.
# @return 1 - Running.
#
sub running
{
my ( $self, $status ) = @_;
return API::Eulerian::EDW::Request->json(
$status->{ response }
)->{ status } eq 'Running';
}
#
# @brief Test if Job status is 'Done'.
#
# @param $self - API::Eulerian::EDW::Rest instance.
# @param $rc - Return context.
#
# @return 0 - Not Done.
# @return 1 - Done.
#
sub done
{
my ( $self, $status ) = @_;
return ! $status->{ error } ?
API::Eulerian::EDW::Request->json(
$status->{ response }
)->{ status } eq 'Done' :
0;
}
#
# @brief Get Path to local filepath.
#
# @param $self - API::Eulerian::EDW::Rest instance.
#
# @return Local file path.
#
sub path
{
my ( $self, $response ) = @_;
my $encoding = $self->encoding();
my $json = API::Eulerian::EDW::Request->json( $response );
my $pattern = '([0-9]*)\.(json|csv|parquet)';
my $status = API::Eulerian::EDW::Status->new();
my $url = $json->{ data }->[ 1 ];
my $wdir = $self->wdir();
my %rc = ();
lib/API/Eulerian/EDW/Peer/Rest.pm view on Meta::CPAN
return $status;
}
#
# @brief Unzip given file.
#
# @param $self - API::Eulerian::EDW::Rest instance.
# @param $zipped - Path to zipped file.
#
# @return Path to unzipped file.
#
sub unzip
{
my( $self, $zipped ) = @_;
my $unzipped;
# Parse zipped file
$zipped =~ /(.*)\.gz/;
# Unzipped file name
$unzipped = $1;
lib/API/Eulerian/EDW/Peer/Rest.pm view on Meta::CPAN
return $unzipped;
}
#
# @brief Download Job reply file.
#
# @param $self - Eulerian Data Warehouse Rest Peer.
# @param $rc - Reply context.
#
# @return Reply context
#
sub download
{
my ( $self, $status ) = @_;
# From Last status message compute local file path
$status = $self->path( $status->{ response } );
# If no error
if( ! $status->{ error } ) {
my $path = $status->{ path };
my $url = $status->{ url };
lib/API/Eulerian/EDW/Peer/Rest.pm view on Meta::CPAN
return $status;
}
#
# @brief Parse local file path and invoke hook handlers.
#
# @param $self - API::Eulerian::EDW::Rest instance.
# @param $rc - Reply context.
#
# @return Reply context.
#
sub parse
{
my ( $self, $status ) = @_;
my $path = $status->{ path };
my $parser;
my $name;
my %rc;
my $pattern = '[0-9]*\.(json|csv|parquet)';
# Parse file path, get file type
lib/API/Eulerian/EDW/Peer/Rest.pm view on Meta::CPAN
return $status;
}
#
# @brief Do Request on Eulerian Data Warehouse Platform.
#
# @param $self - Eulerian Data Warehouse Peer.
# @param $command - Eulerian Data Warehouse Command.
#
use Data::Dumper;
sub request
{
my ( $self, $command ) = @_;
my $bench = new API::Eulerian::EDW::Bench();
my $response;
my $status;
my $json;
# Create Job on Eulerian Data Warehouse Platform
$bench->start();
$status = $self->create( $command );
lib/API/Eulerian/EDW/Peer/Rest.pm view on Meta::CPAN
}
return $status;
}
#
# @brief Cancel Job on Eulerian Data Warehouse Platform.
#
# @param $self - API::Eulerian::EDW::Rest instance.
# @param $rc - Reply context.
#
sub cancel
{
my ( $self ) = @_;
my $status;
# Get HTTP request headers
$status = $self->headers();
if( ! $status->error() ) {
my $headers = $status->{ headers };
delete $status->{ headers };
lib/API/Eulerian/EDW/Peer/Rest.pm view on Meta::CPAN
}
#
# @brief Drop Eulerian Data Warehouse Object Events.
#
# @param $self - Peer.
# @param $what - Object Path.
# @param $site - Site.
# @param $from - Day begin.
# @param $end - Day end.
#
sub drop
{
my ( $self, $what, $site, $from, $to ) = @_;
my $status;
# Get HTTP request headers
$status = $self->headers();
if( ! $status->error() ) {
my $headers = $status->{ headers };
my $url = $self->url() . '/edw/store';
my $cmd = "DROP $what\@$site FROM $from TO $to;";
lib/API/Eulerian/EDW/Peer/Thin.pm view on Meta::CPAN
#
our @ISA = qw/ API::Eulerian::EDW::Peer /;
#
# @brief Allocate and initialize a new Eulerian Data Warehouse Thin Peer.
#
# @param $class - Eulerian Data Warehouse Thin Peer class.
# @param $setup - Setup attributes.
#
# @return Eulerian Data Warehouse Peer.
#
sub new
{
my $proto = shift;
my $class = ref( $proto ) || $proto;
my $setup = shift() || {};
my $self = $class->SUPER::new();
# Setup Default host value
$self->host( 'edwaro' );
# Setup Default ports value
lib/API/Eulerian/EDW/Peer/Thin.pm view on Meta::CPAN
$self->setup( $setup );
return bless( $self, $class );
}
#
# @brief Setup Eulerian Data Warehouse Peer.
#
# @param $self - Eulerian Data Warehouse Peer.
# @param $setup - Setup entries.
#
sub setup
{
my ( $self, $setup ) = @_;
# Setup base interface values
$self->SUPER::setup( $setup );
# Setup Thin Peer specifics options
}
#
# @brief Dump Eulerian Data Warehouse Peer setup.
#
# @param $self - Eulerian Data Warehouse Peer.
#
sub dump
{
my $self = shift;
my $dump = "\n";
$self->SUPER::dump();
print( $dump );
}
#
# @brief Get remote URL to Eulerian Data Warehouse Platform.
#
# @param $self - Eulerian Data Warehouse Peer.
#
# @return Remote URL to Eulerian Data Warehouse Platform.
#
sub url
{
my $self = shift;
my $aes = shift;
my $secure = $self->secure();
my $ports = $self->ports();
my $url;
$url = defined( $aes ) ?
$secure ? 'wss://' : 'ws://' :
$secure ? 'https://' : 'http://';
lib/API/Eulerian/EDW/Peer/Thin.pm view on Meta::CPAN
}
#
# @brief Create a new JOB on Eulerian Data Warehouse Rest Platform.
#
# @param $self - Eulerian Data Warehouse Peer.
# @param $command - Eulerian Data Warehouse Command.
#
# @return Reply context.
#
use Data::Dumper;
sub create
{
my ( $self, $command ) = @_;
my $response;
my $status;
# Get Valid Headers
$status = $self->headers();
if( ! $status->error() ) {
# Post new JOB to Eulerian Data Warehouse Platform
$status = API::Eulerian::EDW::Request->post(
lib/API/Eulerian/EDW/Peer/Thin.pm view on Meta::CPAN
return $status;
}
#
# @brief Dispatch Eulerian Data Warehouse Analytics Analysis result messages to
# their matching callback hook.
#
# @param $ws - Eulerian WebSocket.
# @param $buf - Received buffer.
#
sub dispatcher
{
my ( $ws, $buf ) = @_;
$buf = encode( 'utf-8', $buf );
my $json = decode_json( $buf );
my $type = $json->{ message };
my $uuid = $json->{ uuid };
my $self = $ws->{ _THIN };
my $hook = $self->hook();
my $rows = $json->{ rows };
lib/API/Eulerian/EDW/Peer/Thin.pm view on Meta::CPAN
}
#
# @brief Join Websocket stream, raise callback hook accordingly to received
# messages types.
#
# @param $self - API::Eulerian::EDW::Peer:Thin instance.
# @param $rc - Reply context of JOB creation.
#
# @return Reply context.
#
sub join
{
my ( $self, $status ) = @_;
my $json = API::Eulerian::EDW::Request->json( $status->{ response } );
my $ws = API::Eulerian::EDW::WebSocket->new(
$self->host(), $self->ports()->[ $self->secure() ]
);
my $url = $self->url( $json->{ aes } );
$ws->{ _THIN } = $self;
return $ws->join( $url, \&dispatcher );
}
#
# @brief Do Request on Eulerian Data Warehouse Platform.
#
# @param $self - Eulerian Data Warehouse Peer.
# @param $command - Eulerian Data Warehouse Command.
#
sub request
{
my ( $self, $command ) = @_;
my $bench = new API::Eulerian::EDW::Bench();
my $response;
my $status;
my $json;
# Create Job on Eulerian Data Warehouse Platform
$bench->start();
$status = $self->create( $command );
lib/API/Eulerian/EDW/Peer/Thin.pm view on Meta::CPAN
}
return $status;
}
#
# @brief Cancel Job on Eulerian Data Warehouse Platform.
#
# @param $self - API::Eulerian::EDW::Peer::Rest instance.
# @param $rc - Reply context.
#
sub cancel
{
my ( $self ) = @_;
my $status;
# Get Valid Headers
$status = $self->headers();
if( ! $status->error() && exists( $self->{ uuid } ) ) {
my $uuid = $self->{ uuid };
my $command = "KILL $uuid;";
lib/API/Eulerian/EDW/Request.pm view on Meta::CPAN
# Import Encode
#
use Encode;
#
# @brief Create new HTTP Headers.
#
# @param $class - API::Eulerian::EDW::HTTP class.
#
# @return HTTP Headers.
#
sub headers
{
return HTTP::Headers->new();
}
#
# @brief Test if the content type of given HTTP response is a
# JSON format.
#
# @param $class - API::Eulerian::EDW::Request Class.
# @param $response - HTTP response.
#
# @return 1 - Content type is JSON.
# @return 0 - Content type isnt JSON.
#
sub is_json
{
my ( $class, $response ) = @_;
my $type;
# Get content type value from HTTP response
$type = $response->header( 'content-type' );
if( defined( $type ) ) {
# Split content type into an array.
my @subtypes = split( '; ', $type );
# Iterate on subtypes entries
foreach my $subtype ( @subtypes ) {
# Test if subtype is JSON format
if( $subtype eq 'application/json' ) {
return 1;
}
}
}
return 0;
}
#
# @brief Get JSON object from HTTP response.
#
# @param $class - API::Eulerian::EDW::Request class.
# @param $response - HTTP response.
#
# @return JSON object.
#
sub json
{
my ( $class, $response ) = @_;
my $data = undef;
if( $class->is_json( $response ) ) {
$data = $response->decoded_content;
if( defined( $data ) ) {
chomp( $data );
if( length( $data ) > 0 ) {
$data = encode( 'utf-8', $data );
lib/API/Eulerian/EDW/Request.pm view on Meta::CPAN
#
# @brief Do HTTP Get on given URL.
#
# @param $class - API::Eulerian::EDW::HTTP class.
# @param $url - Remote URL.
# @param $headers - HTTP::Headers.
# @param $file - Local file path.
#
# @return API::Eulerian::EDW::Status instance.
#
sub get
{
my ( $class, $url, $headers, $file ) = @_;
return $class->_request( 'GET', $url, $headers, undef, undef, $file );
}
#
# @brief Do HTTP Post on given URL.
#
# @param $class - API::Eulerian::EDW::HTTP class.
# @param $url - Remote URL.
# @param $headers - HTTP::Headers.
# @param $what - Request Data.
# @param $type - Request Data Type.
#
# @return API::Eulerian::EDW::Status instance.
#
sub post
{
my ( $class, $url, $headers, $what, $type ) = @_;
return $class->_request( 'POST', $url, $headers, $what, $type );
}
#
# @brief Send HTTP request on given url.
#
# @param $class - API::Eulerian::EDW Request class.
# @param $method - HTTP method.
# @param $url - Remote URL.
# @param $headers - HTTP headers.
# @param $what - Data of POST request.
# @param $type - Data type of POST request
# @param $file - Local file path used to store HTTP reply.
#
# @return API::Eulerian::EDW::Status instance.
#
use Data::Dumper;
sub _request
{
my ( $class, $method, $url, $headers, $what, $type, $file ) = @_;
my $status = API::Eulerian::EDW::Status->new();
my $endpoint;
my $request;
# Ensure default type
$type = $type || 'application/json';
# Sanity check POST arguments
lib/API/Eulerian/EDW/Status.pm view on Meta::CPAN
# Enforce compilor rules
#
use strict; use warnings;
#
# @brief Allocate and initialize a new API::Eulerian::EDW::Status instance.
#
# @param $class - API::Eulerian::EDW::Status class.
#
# @return API::Eulerian::EDW::Status instance.
#
sub new
{
my ( $class ) = @_;
return bless( {
_ERROR => 0,
_MSG => '',
_CODE => 0,
}, $class
);
}
#
# @brief Get/Set error message.
#
# @param $self - API::Eulerian::EDW::Status instance.
# @param $msg - Error message.
#
# @return Error message.
#
sub msg
{
my ( $self, $msg ) = @_;
$self->{ _MSG } = $msg if defined( $msg );
return $self->{ _MSG };
}
#
# @brief Get/Set error code.
#
# @param $self - API::Eulerian::EDW::Status instance.
# @param $code - Error code.
#
# @return Error code.
#
sub code
{
my ( $self, $code ) = @_;
$self->{ _CODE } = $code if defined( $code );
return $self->{ _CODE };
}
#
# @brief Get/Set error.
#
# @param $self - API::Eulerian::EDW::Status instance.
# @param $error - Error.
#
# @return Error flag.
#
sub error
{
my ( $self, $error ) = @_;
$self->{ _ERROR } = $error if defined( $error );
return $self->{ _ERROR };
}
sub path
{
my $self = shift;
return $self->{ path };
}
#
# @brief Dump status.
#
# @param $self - API::Eulerian::EDW::Status.
#
sub dump
{
my ( $self ) = @_;
my $error = $self->error() ? 'Yes' : 'No';
my $code = $self->code();
my $msg = $self->msg();
my $string = <<string_end;
Error : $error
Code : $code
Message : $msg
string_end
lib/API/Eulerian/EDW/WebSocket.pm view on Meta::CPAN
use API::Eulerian::EDW::Status;
#
# @brief Allocate and initialize a new API::Eulerian::EDW Websocket.
#
# @param $class - API::Eulerian::EDW::WebSocket class.
# @param $host - Remote host.
# @param $port - Remote port.
#
# @return API::Eulerian::EDW WebSocket instance.
#
sub new
{
my ( $class, $host, $port ) = @_;
return bless( {
_HOOK => undef,
_SELECT => undef,
_RFDS => undef,
_SOCKET => IO::Socket::INET->new(
PeerAddr => $host, PeerPort => $port,
Blocking => 1, Proto => 'tcp'
),
}, $class
);
}
#
# @brief Get Socket.
#
# @param $self - API::Eulerian::EDW::WebSocket instance.
#
# @return Socket.
#
sub _socket
{
return shift->{ _SOCKET };
}
#
# @brief Get API::Eulerian::EDW Websocket Remote Host.
#
# @param $self - API::Eulerian::EDW::WebSocket instance.
#
# @return Remote Host.
#
sub host
{
return shift->socket()->peerhost();
}
#
# @brief Get API::Eulerian::EDW Websocket Remote Port.
#
# @param $self - API::Eulerian::EDW::WebSocket instance.
#
# @return Remote Port.
#
sub port
{
return shift->socket()->peerport();
}
#
# @brief On write Websocket handler.
#
# @param $self - WebSocket.
# @param $data - Data to be writen
#
# @return Writen Size.
#
sub _on_write
{
my ( $peer, $buf ) = @_;
$peer->{ _WS }->{ _SOCKET }->syswrite( $buf );
}
#
# @brief On read Websocket handler.
#
# @param $self - Websocket.
#
# @return
#
sub _on_read
{
my ( $peer, $buf ) = @_;
my $ws = $peer->{ _WS };
$ws->{ _HOOK }( $ws, $buf );
}
#
# @brief On error Websocket handler.
#
# @param $self - Websocket.
#
# @return
#
sub _on_error
{
my ( $self, $error ) = @_;
print STDERR "Websocket error : $error\n";
}
#
# @brief On connect Websocket handler.
#
# @param $self - Websocket.
#
# @return
#
sub _on_connect
{
}
#
# @brief Join given url in Websocket mode, call hook for each received buffer.
#
# @param $self - API::Eulerian::EDW::WebSocket instance.
# @param $url - Remote url.
# @param $hooks - User specific hook callback.
#
# @return API::Eulerian::EDW::Status instance.
#
sub join
{
my ( $self, $url, $hook ) = @_;
my $status = API::Eulerian::EDW::Status->new();
my $socket = $self->_socket();
my $bufsize = 4 * 1024 * 1024;
my $offset = 0;
my $buf = '';
my $read;
my $rfds;
my $peer;