CPAN::Groonga

:Commands::File;
use Rex::Commands::Download;
use Rex::Helper::Path;
use Rex::Helper::Encode;
use JSON::MaybeXS;
use Text::Glob 'glob_to_regex', 'match_glob';
use File::Basename 'basename';

@EXPORT  

 Rex::Commands;
use Rex::Interface::Fs::Base;
use Rex::Helper::Path;
use Rex::Helper::Encode;
use JSON::MaybeXS;
use base qw(Rex::Interface::Fs::Base);
use Data::Dumper;

sub new {
  my $that  = shift

      $ret{'atime'} = $atime;
      $ret{'mtime'} = $mtime;

      print to_json(\%ret);
  }

  |;

  $script .= func_to_json();

  my $rnd_file = $self->_write_to_rnd_file($script);
  ($file) = $self

 $self->unlink($rnd_file);
    }
  );

  if ( !$out ) {
    return undef;
  }

  my $tmp = decode_json($out);

  return %{$tmp};
}

sub is_readable {
  my ( $self, $file ) = @_;

  ($file) = $self->_n

ex::Interface::File;
use Rex::Interface::Fs;
use Rex::Interface::Exec;
use Rex::Helper::Path;
use JSON::MaybeXS;

use Rex::User::Base;
use base qw(Rex::User::Base);

sub new {
  my $that  = shift;
  m

 } print to_json([  map {chomp; $_ =~ s/^[^:]*:\s*(.*)\s*$/$1/; split / /, $_}  qx{$exe $ARGV[0]} ]);

  |;

  $fh->open( ">", $rnd_file );
  $fh->write($script);
  $fh->write( func_to_json() );
  $fh

", fail_ok => 1;
  if ( $? != 0 ) {
    die("Error getting group list");
  }

  my $data = decode_json($data_str);

  my $wantarray = wantarray();

  if ( defined $wantarray && !$wantarray ) {

    # 

se Rex::Interface::Fs;
use Rex::Interface::Exec;
use Rex::User::Linux;
use Rex::Helper::Path;
use JSON::MaybeXS;

use base qw(Rex::User::Linux);

sub new {
  my $that  = shift;
  my $proto = ref($that

$script   = q|
    unlink $0;
    print to_json([ getpwnam($ARGV[0]) ]);
  |;
  $fh->open( ">", $rnd_file );
  $fh->write($script);
  $fh->write( func_to_json() );
  $fh->close;

  my $data_str = i_ru

rmation for $user");
  }

  Rex::Interface::Fs->create()->unlink($rnd_file);

  my $data = decode_json($data_str);

  return (
    name     => $data->[0],
    password => $data->[1],
    uid      => $

1.16.1'; # VERSION

use Rex::Logger;

use base 'Rex::Cloud::Base';

BEGIN {
  use Rex::Require;
  JSON::MaybeXS->use;
  HTTP::Request::Common->use(qw(:DEFAULT DELETE));
  LWP::UserAgent->use;
}
use Da

indicates an error', 'warn' );
    Rex::Logger::debug( $response->content );
  }

  return decode_json( $response->content ) if $response->content;
}

sub _authenticate {
  my $self = shift;

  my $au

OST         => $self->{__endpoint} . '/tokens',
    content_type => 'application/json',
    content      => encode_json($auth_data),
  );

  $self->{auth}{tokenId} = $content->{access}{token}{id};

  

 Rex::Logger;

BEGIN {
  use Rex::Require;
  LWP::UserAgent->use;
  HTTP::Request::Common->use;
  JSON::MaybeXS->use;
}
use Data::Dumper;

use Rex::Cloud::Base;

use base qw(Rex::Cloud::Base);

sub ne

 Rex::Logger::info( $res->content );
    die("Error on request.");
  }

  my $json = JSON::MaybeXS->new;
  my $data = $json->decode( $res->decoded_content );

  Rex::Logger::debug( Dumper($data) );

 

'; # VERSION

require Exporter;
use base qw(Exporter);
use vars qw(@EXPORT);
@EXPORT = qw(func_to_json);

my %escapes;
for ( 0 .. 255 ) {
  $escapes{ chr($_) } = sprintf( "%%%02X", $_ );
}

sub url_en

 = @_;
  $txt =~ s/%([0-9A-Fa-f]{2})/chr(hex($1))/eg;
  return $txt;
}

sub func_to_json {

  return q|
  sub to_json {
    my ($ref) = @_;

    my $s = "";

    if(ref $ref eq "ARRAY") {
      $s .= 

(@{ $ref }) {
        if(substr($s, -1) ne "[") {
          $s .= ",";
        }
        $s .= to_json($itm);
      }
      return $s . "]";
    }
    elsif(ref $ref eq "HASH") {
      $s .= "{";
    

ON = '1.16.1'; # VERSION

use Rex::Interface::Connection::Base;

BEGIN {
  LWP::UserAgent->use;
  JSON::MaybeXS->use;
}

use Data::Dumper;

use base qw(Rex::Interface::Connection::Base);

sub new {
  

ltipart/form-data",
    Content      => $data
  );

  if ( $res->is_success ) {
    return decode_json( $res->decoded_content );
  }
  else {
    die("Error requesting /fs/upload.");
  }
}

sub post {

>{port}
      . "$service",
    %{$header},
    Content => encode_json($data)
  );

  if ( $res->is_success ) {
    return decode_json( $res->decoded_content );
  }
  else {
    die( "Error requesting

.4;
use warnings;

our $VERSION = '1.16.1'; # VERSION

use Rex::Logger;
use Rex::Helper::Run;
use JSON::MaybeXS;

sub execute {
  my ( $class, $arg1 ) = @_;
  my @dominfo;

  if ( !$arg1 ) {
    die('

pect $arg1", fail_ok => 1;
  if ( $? != 0 ) {
    return { running => 'off' };
  }

  my $coder = JSON::MaybeXS->new->allow_nonref;
  my $ref   = $coder->decode($ret);
  $ref = $ref->[0];
  $ref->{run

;
use Rex::Virtualization::LibVirt::info;
use Rex::Interface::File;
use Rex::Interface::Exec;
use JSON::MaybeXS;
require Rex::Commands::Run;

sub execute {
  my ( $class, $vmname ) = @_;

  unless ($v

o agent
        $info->{has_kvm_agent_on_port} = 0;
        last;
      }

      my $ref = decode_json($data);
      delete $ref->{networkconfiguration}->{lo};

      for my $net ( keys %{ $ref->{netw

se Rex::Interface::Fs;
use Rex::Interface::Exec;
use Rex::User::Linux;
use Rex::Helper::Path;
use JSON::MaybeXS;

use base qw(Rex::User::Linux);

sub new {
  my $that  = shift;
  my $proto = ref($that

$script   = q|
    unlink $0;
    print to_json([ getpwnam($ARGV[0]) ]);
  |;
  $fh->open( ">", $rnd_file );
  $fh->write($script);
  $fh->write( func_to_json() );
  $fh->close;

  my $data_str = i_ru

  if ( $? != 0 ) {
    die("Error getting user information for $user");
  }

  my $data = decode_json($data_str);

  return (
    name     => $data->[0],
    password => $data->[1],
    uid      => $