15240232617

Committed 28 Feb 2025 09:08AM UTC coverage: 50.961% (+10.2%) from 40.73%

Build # 15240232617

Build Type

push

github

Committed by

ferki

Commit Message

Use placeholders for template hints

Run Details

10072 of 19764 relevant lines covered (50.96%)

101.57 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

10.29

/lib/Rex/Interface/Connection/HTTP.pm

#
# (c) Jan Gehring <jan.gehring@gmail.com>
#

package Rex::Interface::Connection::HTTP;

use v5.12.5;
use warnings;

our $VERSION = '9999.99.99_99'; # 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 {
  my $that  = shift;
  my $proto = ref($that) || $that;
  my $self  = $that->SUPER::new(@_);

  bless( $self, $proto );

  # activate caching
  Rex::Config->set_use_cache(1);

  return $self;
}

sub error { }

sub connect {
  my ( $self, %option ) = @_;
  my ( $user, $pass, $server, $port, $timeout );

  $user    = $option{user};
  $pass    = $option{password};
  $server  = $option{server};
  $port    = $self->_get_port( $option{port} );
  $timeout = $option{timeout};

  $self->{server} = $server;
  $self->{port}   = $port;

  if ( $server =~ m/([^:]+):(\d+)/ ) {
    $server = $self->{server} = $1;
    $port   = $self->{port}   = $2;
  }

  $self->{__user} = $user;
  $self->{__pass} = $pass;

  if (!Rex::Config->has_user
    && Rex::Config->get_ssh_config_username( server => $server ) )
  {
    $user = Rex::Config->get_ssh_config_username( server => $server );
  }

  $self->ua->credentials( "$server:$port", "Rex::Endpoint::HTTP",
    $user => $pass, );

  my $resp = $self->post("/login");
  if ( $resp->{ok} ) {
    Rex::Logger::info("Connected to $server, trying to authenticate.");
  }
  else {
    Rex::Logger::info( "Can't connect to $server", "warn" );
    $self->{connected} = 0;
    return;
  }

  Rex::Logger::info( "Connecting to $server:$port (" . $user . ")" );

}

sub disconnect               { }
sub get_connection_object    { my ($self) = @_; return $self; }
sub get_fs_connection_object { my ($self) = @_; return $self; }
sub is_connected             { return 1; }
sub is_authenticated         { return 1; }

sub exec {
  my ( $self, $cmd ) = @_;
}

sub ua {
  my ($self) = @_;
  return $self->{ua} if $self->{ua};

  $self->{ua} = LWP::UserAgent->new;
}

sub upload {
  my ( $self, $data ) = @_;

  my $res = $self->ua->post(
    $self->_get_proto . "://"
      . $self->{server} . ":"
      . $self->{port}
      . "/fs/upload",
    Content_Type => "multipart/form-data",
    Content      => $data
  );

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

sub post {
  my ( $self, $service, $data, $header ) = @_;

  $header ||= {};
  $data   ||= {};

  if ( !ref($data) ) {
    die(
      "Invalid 2nd argument. must be arrayRef or hashRef!\npost(\$service, \$ref)"
    );
  }

  my $res = $self->ua->post(
    $self->_get_proto . "://"
      . $self->{server} . ":"
      . $self->{port}
      . "$service",
    %{$header},
    Content => encode_json($data)
  );

  if ( $res->is_success ) {
    return decode_json( $res->decoded_content );
  }
  else {
    die( "Error requesting $service.\n\nError: " . $res->{_content} );
  }

}

sub get {
  my ( $self, $service ) = @_;

  my $res =
    $self->ua->get( $self->_get_proto . "://"
      . $self->{server} . ":"
      . $self->{port}
      . "$service" );

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

}

sub get_connection_type { return "HTTP"; }

sub _get_proto {
  return "http";
}

sub _get_port {
  my ( $self, $port ) = @_;
  return $port || 8080;
}

1;

1	#
2	# (c) Jan Gehring <jan.gehring@gmail.com>
3	#
4
5	package Rex::Interface::Connection::HTTP;
6
7	use v5.12.5;	1✔
8	use warnings;	1✔
9
10	our $VERSION = '9999.99.99_99'; # VERSION
11
12	use Rex::Interface::Connection::Base;	1✔
13
14	BEGIN {
15	LWP::UserAgent->use;	1✔
16	JSON::MaybeXS->use;	1✔
17	}
18
19	use Data::Dumper;	1✔
20
21	use base qw(Rex::Interface::Connection::Base);	1✔
22
23	sub new {
24	my $that = shift;	×
25	my $proto = ref($that) \|\| $that;	×
26	my $self = $that->SUPER::new(@_);	×
27
28	bless( $self, $proto );	×
29
30	# activate caching
31	Rex::Config->set_use_cache(1);	×
32
33	return $self;	×
34	}
35
36	sub error { }
37
38	sub connect {
39	my ( $self, %option ) = @_;	×
40	my ( $user, $pass, $server, $port, $timeout );	×
41
42	$user = $option{user};	×
43	$pass = $option{password};	×
44	$server = $option{server};	×
45	$port = $self->_get_port( $option{port} );	×
46	$timeout = $option{timeout};	×
47
48	$self->{server} = $server;	×
49	$self->{port} = $port;	×
50
51	if ( $server =~ m/([^:]+):(\d+)/ ) {	×
52	$server = $self->{server} = $1;	×
53	$port = $self->{port} = $2;	×
54	}
55
56	$self->{__user} = $user;	×
57	$self->{__pass} = $pass;	×
58
59	if (!Rex::Config->has_user	×
60	&& Rex::Config->get_ssh_config_username( server => $server ) )
61	{
62	$user = Rex::Config->get_ssh_config_username( server => $server );	×
63	}
64
65	$self->ua->credentials( "$server:$port", "Rex::Endpoint::HTTP",	×
66	$user => $pass, );
67
68	my $resp = $self->post("/login");	×
69	if ( $resp->{ok} ) {	×
70	Rex::Logger::info("Connected to $server, trying to authenticate.");	×
71	}
72	else {
73	Rex::Logger::info( "Can't connect to $server", "warn" );	×
74	$self->{connected} = 0;	×
75	return;	×
76	}
77
78	Rex::Logger::info( "Connecting to $server:$port (" . $user . ")" );	×
79
80	}
81
82	sub disconnect { }
83	sub get_connection_object { my ($self) = @_; return $self; }	×
84	sub get_fs_connection_object { my ($self) = @_; return $self; }	×
85	sub is_connected { return 1; }	×
86	sub is_authenticated { return 1; }	×
87
88	sub exec {
89	my ( $self, $cmd ) = @_;	×
90	}
91
92	sub ua {
93	my ($self) = @_;	×
94	return $self->{ua} if $self->{ua};	×
95
96	$self->{ua} = LWP::UserAgent->new;	×
97	}
98
99	sub upload {
100	my ( $self, $data ) = @_;	×
101
102	my $res = $self->ua->post(
103	$self->_get_proto . "://"
104	. $self->{server} . ":"
105	. $self->{port}
106	. "/fs/upload",	×
107	Content_Type => "multipart/form-data",
108	Content => $data
109	);
110
111	if ( $res->is_success ) {	×
112	return decode_json( $res->decoded_content );	×
113	}
114	else {
115	die("Error requesting /fs/upload.");	×
116	}
117	}
118
119	sub post {
120	my ( $self, $service, $data, $header ) = @_;	×
121
122	$header \|\|= {};	×
123	$data \|\|= {};	×
124
125	if ( !ref($data) ) {	×
126	die(	×
127	"Invalid 2nd argument. must be arrayRef or hashRef!\npost(\$service, \$ref)"
128	);
129	}
130
131	my $res = $self->ua->post(
132	$self->_get_proto . "://"
133	. $self->{server} . ":"
134	. $self->{port}
135	. "$service",
136	%{$header},	×
137	Content => encode_json($data)
138	);
139
140	if ( $res->is_success ) {	×
141	return decode_json( $res->decoded_content );	×
142	}
143	else {
144	die( "Error requesting $service.\n\nError: " . $res->{_content} );	×
145	}
146
147	}
148
149	sub get {
150	my ( $self, $service ) = @_;	×
151
152	my $res =
153	$self->ua->get( $self->_get_proto . "://"
154	. $self->{server} . ":"
155	. $self->{port}
156	. "$service" );	×
157
158	if ( $res->is_success ) {	×
159	return decode_json( $res->decoded_content );	×
160	}
161	else {
162	die("Error requesting $service.");	×
163	}
164
165	}
166
167	sub get_connection_type { return "HTTP"; }	×
168
169	sub _get_proto {
170	return "http";	×
171	}
172
173	sub _get_port {
174	my ( $self, $port ) = @_;	×
175	return $port \|\| 8080;	×
176	}
177
178	1;

ferki / Rex / 15240232617

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous