sub\s results from the CPAN

sub\s

API-Eulerian

view release on metacpan or search on metacpan

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

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

lib/API/Eulerian/EDW/Request.pm view on Meta::CPAN

  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;

( run in 1.241 second using v1.01-cache-2.11-cpan-a5abf4f5562 )