Grpc-XS
view release on metacpan or search on metacpan
#define PERL_NO_GET_CONTEXT
#include "EXTERN.h"
#include "perl.h"
#include "XSUB.h"
#include "ppport.h"
#include "util.h"
#include "ext/call.h"
#include "ext/call_credentials.h"
#include "ext/channel.h"
#include "ext/channel_credentials.h"
#include "ext/constants.h"
#include "ext/server.h"
#include "ext/server_credentials.h"
#include "ext/timeval.h"
MODULE = Grpc::XS PACKAGE = Grpc::XS
BOOT:
grpc_perl_init();
void
init()
CODE:
void
destroy()
CODE:
grpc_perl_destroy();
MODULE = Grpc::XS PACKAGE = Grpc::XS::Call
INCLUDE: ext/call.xs
MODULE = Grpc::XS PACKAGE = Grpc::XS::CallCredentials
INCLUDE: ext/call_credentials.xs
MODULE = Grpc::XS PACKAGE = Grpc::XS::Channel
INCLUDE: ext/channel.xs
MODULE = Grpc::XS PACKAGE = Grpc::XS::ChannelCredentials
INCLUDE: ext/channel_credentials.xs
MODULE = Grpc::XS PACKAGE = Grpc::XS::Constants
INCLUDE: ext/constants.xs
MODULE = Grpc::XS PACKAGE = Grpc::XS::Server
INCLUDE: ext/server.xs
MODULE = Grpc::XS PACKAGE = Grpc::XS::ServerCredentials
INCLUDE: ext/server_credentials.xs
MODULE = Grpc::XS PACKAGE = Grpc::XS::Timeval
INCLUDE: ext/timeval.xs
examples/greeter/t/01-greeter.t
examples/README.md
examples/route_guide/Makefile
examples/route_guide/README.md
examples/route_guide/route_guide.proto
examples/route_guide/t/01-get_feature.t
examples/route_guide/t/02-list_features.t
examples/route_guide/t/03-record_route.t
examples/route_guide/t/04-route_chat.t
examples/route_guide/t/route.txt
ext/call_credentials.h
ext/call_credentials.xs
ext/call.h
ext/call.xs
ext/channel_credentials.h
ext/channel_credentials.xs
ext/channel.h
ext/channel.xs
ext/constants.h
ext/constants.xs
ext/server_credentials.h
ext/server_credentials.xs
ext/server.h
ext/server.xs
ext/timeval.h
ext/timeval.xs
lib/Grpc/Client/AbstractCall.pm
lib/Grpc/Client/BaseStub.pm
lib/Grpc/Client/BidiStreamingCall.pm
lib/Grpc/Client/ClientStreamingCall.pm
lib/Grpc/Client/ServerStreamingCall.pm
lib/Grpc/Client/UnaryCall.pm
lib/Grpc/XS/CallCredentials.pm
lib/Grpc/XS/Call.pm
lib/Grpc/XS/ChannelCredentials.pm
lib/Grpc/XS/Channel.pm
lib/Grpc/XS/Constants.pm
lib/Grpc/XS.pm
lib/Grpc/XS/ServerCredentials.pm
lib/Grpc/XS/Server.pm
lib/Grpc/XS/Timeval.pm
t/00-compile.t
t/01-call_credentials.t
t/02-call.t
t/03-channel_credentials.t
t/04-channel.t
t/05-constants.t
t/06-server_credentials.t
t/07-server.t
t/08-timeval.t
t/09-abstract_call.t
t/10-base_stub.t
t/11-bidi_streaming_call.t
t/12-client_streaming_call.t
t/13-server_streaming_call.t
t/14-unary_call.t
t/15-xs_end_to_end.t
t/16-xs_secure_end_to_end.t
Makefile.PL view on Meta::CPAN
grpc_op op;
op.data.recv_status_on_client.error_string = 0;
EOT
) and ($EXTRA_DEFINES .= " -DGRPC_RECV_STATUS_ON_CLIENT_HAS_ERROR_STRING");
check_lib(
%CHECKLIB_ARGS,
header => [$CHECKLIB_ARGS{header}, "grpc/grpc_security.h"],
function => <<'EOT',
return 0;
grpc_ssl_credentials_create(0, 0, 0, 0);
EOT
) and ($EXTRA_DEFINES .= " -DGRPC_SSL_CREDENTIALS_HAS_4_ARGS");
check_lib(
%CHECKLIB_ARGS,
header => [$CHECKLIB_ARGS{header}, "grpc/grpc_security.h"],
function => <<'EOT',
grpc_metadata_credentials_plugin plugin;
return 0;
grpc_metadata_credentials_create_from_plugin(plugin, 0, NULL);
EOT
) and ($EXTRA_DEFINES .= " -DGRPC_METADATA_CREDENTIALS_CRATE_FROM_PLUGIN_HAS_3_ARGS");
check_lib(
%CHECKLIB_ARGS,
header => [$CHECKLIB_ARGS{header}, "grpc/grpc_security.h"],
function => <<'EOT',
return 0;
grpc_google_default_credentials_create(NULL);
EOT
) and ($EXTRA_DEFINES .= " -DGRPC_GOOGLE_DEFAULT_CREDENTIALS_CREATE_HAS_1_ARG");
check_lib(
%CHECKLIB_ARGS,
function => <<'EOT',
grpc_channel_credentials * cred = NULL;
return 0;
EOT
) and ($EXTRA_DEFINES .= " -DGRPC_NO_INSECURE_BUILD");
# grpc_shutdown() is async in recent versions of the library, leading
# to a race at shutdown which can cause fork to fail. See
# https://github.com/joyrex2001/grpc-perl/issues/22.
# If the library has grpc_shutdown_blocking(), use that.
check_lib(
%CHECKLIB_ARGS,
examples/greeter/t/01-greeter.t view on Meta::CPAN
use Test::More;
use ProtobufXS::helloworld;
use ProtobufXS::helloworld::Service::Greeter;
use Grpc::XS::ChannelCredentials;
plan tests => 1;
my $credentials = Grpc::XS::ChannelCredentials::createInsecure();
my $greeter = new ProtobufXS::helloworld::Service::Greeter('localhost:50051',
credentials => $credentials );
my $request = new ProtobufXS::helloworld::HelloRequest();
$request->set_name("grpc-perl");
my $call = $greeter->SayHello( argument => $request );
my $response = $call->wait();
print STDERR Dumper($response);
if ($response) {
print STDERR Dumper($response->to_hashref());
}
ok($response,"didn't receive a response from server");
examples/route_guide/t/01-get_feature.t view on Meta::CPAN
}
################
## getFeature ##
################
# Run the getFeature demo. Calls getFeature with a point known to have a
# feature and a point known not to have a feature.
my $client = new ProtobufXS::routeguide::Service::RouteGuide('localhost:10000',
credentials => undef );
my @points = (
{
latitude => 409146138,
longitude => -746188906,
},
{
latitude => 0,
longitude => 0,
},
examples/route_guide/t/02-list_features.t view on Meta::CPAN
##################
## listFeatures ##
##################
# Run the listFeatures demo. Calls listFeatures with a rectangle
# containing all of the features in the pre-generated
# database. Prints each response as it comes in.
my $client = new ProtobufXS::routeguide::Service::RouteGuide('localhost:10000',
credentials => undef );
my $lo_point = new ProtobufXS::routeguide::Point({
latitude => 400000000,
longitude => -750000000,
});
my $hi_point = new ProtobufXS::routeguide::Point({
latitude => 420000000,
longitude => -730000000,
});
examples/route_guide/t/03-record_route.t view on Meta::CPAN
#################
## recordRoute ##
#################
# Run the recordRoute demo. Sends several randomly chosen points from the
# pre-generated feature database with a variable delay in between. Prints
# the statistics when they are sent from the server.
my $client = new ProtobufXS::routeguide::Service::RouteGuide('localhost:10000',
credentials => undef );
## start the client streaming call
my $call = $client->RecordRoute();
my @db = readRouteDbFile();
my $num_points_in_db = scalar(@db);
my $num_points = 10;
for (my $i = 0; $i < $num_points; $i++) {
my $point = new ProtobufXS::routeguide::Point();
my $index = rand($num_points_in_db);
my $lat = $db[$index]->{latitude};
examples/route_guide/t/04-route_chat.t view on Meta::CPAN
}
###############
## routeChat ##
###############
# Run the routeChat demo. Send some chat messages, and print any chat
# messages that are sent from the server.
my $client = new ProtobufXS::routeguide::Service::RouteGuide('localhost:10000',
credentials => undef );
my $call = $client->RouteChat();
my @notes = (
{
longitude => 1,
latitude => 1,
message => 'first message'
},
{
longitude => 1,
ext/call.xs view on Meta::CPAN
void
cancel(Grpc::XS::Call self)
CODE:
grpc_call_cancel(self->wrapped, NULL);
OUTPUT:
int
setCredentials(Grpc::XS::Call self, Grpc::XS::CallCredentials creds)
CODE:
int error = GRPC_CALL_ERROR;
error = grpc_call_set_credentials(self->wrapped, creds->wrapped);
RETVAL = error;
OUTPUT: RETVAL
void
DESTROY(Grpc::XS::Call self)
CODE:
if (self->wrapped != NULL) {
#if defined(GRPC_VERSION_1_4)
grpc_call_unref(self->wrapped);
#else
ext/call_credentials.h view on Meta::CPAN
#ifndef GRPC_PERL_CALL_CREDENTIALS_H
#define GRPC_PERL_CALL_CREDENTIALS_H
#include <grpc/grpc.h>
#include <grpc/grpc_security.h>
typedef struct {
grpc_call_credentials *wrapped;
} CallCredentialsCTX;
typedef CallCredentialsCTX* Grpc__XS__CallCredentials;
#endif
ext/call_credentials.xs view on Meta::CPAN
Grpc::XS::CallCredentials
createComposite(Grpc::XS::CallCredentials cred1, Grpc::XS::CallCredentials cred2)
PREINIT:
CallCredentialsCTX* ctx = (CallCredentialsCTX *)malloc( sizeof(CallCredentialsCTX) );
ctx->wrapped = NULL;
CODE:
ctx->wrapped = grpc_composite_call_credentials_create(
cred1->wrapped, cred2->wrapped, NULL);
RETVAL = ctx;
OUTPUT: RETVAL
Grpc::XS::CallCredentials
createFromPlugin(SV* callback)
PREINIT:
CallCredentialsCTX* ctx = (CallCredentialsCTX *)malloc( sizeof(CallCredentialsCTX) );
ctx->wrapped = NULL;
CODE:
grpc_metadata_credentials_plugin plugin;
plugin.get_metadata = plugin_get_metadata;
plugin.destroy = plugin_destroy_state;
plugin.state = (void *)SvRV(callback);
plugin.type = "";
ctx->wrapped = grpc_metadata_credentials_create_from_plugin(plugin,
#if GRPC_METADATA_CREDENTIALS_CRATE_FROM_PLUGIN_HAS_3_ARGS
GRPC_PRIVACY_AND_INTEGRITY,
#endif
NULL);
SvREFCNT_inc(callback);
RETVAL = ctx;
OUTPUT: RETVAL
void
DESTROY(Grpc::XS::CallCredentials self)
CODE:
if (self->wrapped != NULL) {
grpc_call_credentials_release(self->wrapped);
}
Safefree(self);
ext/channel.xs view on Meta::CPAN
ChannelCTX* ctx = (ChannelCTX *)malloc( sizeof(ChannelCTX) );
ctx->wrapped = NULL;
CODE:
if ( items > 2 && ( items - 2 ) % 2 ) {
croak("Expecting a hash as input to constructor");
}
Grpc__XS__ChannelCredentials creds = NULL;
// channel, args_hash
// hash->{credentials} - credentials object (optional)
int i;
HV *hash = newHV();
if (items>2) {
for (i = 2; i < items; i += 2 ) {
SV *key = ST(i);
if (!strcmp(SvPV_nolen(key), "credentials")) {
if (!sv_isobject(ST(i+1)) ||
!sv_derived_from(ST(i+1),"Grpc::XS::ChannelCredentials")) {
croak("credentials is not a credentials object");
} else {
IV tmp = SvIV((SV*)SvRV(ST(i+1)));
creds = INT2PTR(Grpc__XS__ChannelCredentials,tmp);
}
} else {
SV *value = newSVsv(ST(i+1));
hv_store_ent(hash,key,value,0);
}
}
}
grpc_channel_args args;
perl_grpc_read_args_array(hash, &args);
if (creds == NULL) {
#ifdef GRPC_NO_INSECURE_BUILD
grpc_channel_credentials * insecure_cred = grpc_insecure_credentials_create();
ctx->wrapped = grpc_channel_create(target, insecure_cred, &args);
grpc_channel_credentials_release(insecure_cred);
#else
ctx->wrapped = grpc_insecure_channel_create(target, &args, NULL);
#endif
} else {
gpr_log(GPR_DEBUG, "Initialized secure channel");
#ifdef GRPC_NO_INSECURE_BUILD
ctx->wrapped = grpc_channel_create(target, creds->wrapped, &args);
#else
ctx->wrapped =
grpc_secure_channel_create(creds->wrapped, target, &args, NULL);
ext/channel_credentials.h view on Meta::CPAN
#ifndef GRPC_PERL_CHANNEL_CREDENTIALS_H
#define GRPC_PERL_CHANNEL_CREDENTIALS_H
#include <grpc/grpc.h>
#include <grpc/grpc_security.h>
typedef struct {
grpc_channel_credentials *wrapped;
} ChannelCredentialsCTX;
typedef ChannelCredentialsCTX* Grpc__XS__ChannelCredentials;
#endif
ext/channel_credentials.xs view on Meta::CPAN
Grpc::XS::ChannelCredentials
createDefault()
PREINIT:
ChannelCredentialsCTX* ctx = (ChannelCredentialsCTX *)malloc( sizeof(ChannelCredentialsCTX) );
CODE:
ctx->wrapped = grpc_google_default_credentials_create(
#if GRPC_GOOGLE_DEFAULT_CREDENTIALS_CREATE_HAS_1_ARG
NULL
#endif
);
RETVAL = ctx;
OUTPUT: RETVAL
Grpc::XS::ChannelCredentials
createSsl(...)
PREINIT:
ChannelCredentialsCTX* ctx = (ChannelCredentialsCTX *)malloc( sizeof(ChannelCredentialsCTX) );
CODE:
if ( items % 2 ) {
croak("Expecting a hash as input to channel credentials constructor");
}
// @param string pem_root_certs PEM encoding of the server root certificates
// @param string pem_private_key PEM encoding of the client's private key
// (optional)
// @param string pem_cert_chain PEM encoding of the client's certificate chain
// (optional)
// @return ChannelCredentials The new SSL credentials object
const char* pem_root_certs = NULL;
grpc_ssl_pem_key_cert_pair pem_key_cert_pair;
pem_key_cert_pair.private_key = pem_key_cert_pair.cert_chain = NULL;
int i;
for (i = 0; i < items; i += 2 ) {
const char *key = SvPV_nolen(ST(i));
if (!strcmp( key, "pem_root_certs")) {
ext/channel_credentials.xs view on Meta::CPAN
pem_root_certs = SvPV_nolen(ST(i+1));
} else if (!strcmp( key, "pem_private_key")) {
if (SvOK(ST(i+1)))
pem_key_cert_pair.private_key = SvPV_nolen(ST(i+1));
} else if (!strcmp( key, "pem_cert_chain")) {
if (SvOK(ST(i+1)))
pem_key_cert_pair.cert_chain = SvPV_nolen(ST(i+1));
}
}
ctx->wrapped = grpc_ssl_credentials_create(
pem_root_certs,
pem_key_cert_pair.private_key == NULL ? NULL : &pem_key_cert_pair, NULL
#ifdef GRPC_SSL_CREDENTIALS_HAS_4_ARGS
, NULL
#endif
);
RETVAL = ctx;
OUTPUT: RETVAL
Grpc::XS::ChannelCredentials
createComposite(Grpc::XS::ChannelCredentials cred1, Grpc::XS::CallCredentials cred2)
PREINIT:
ChannelCredentialsCTX* ctx = (ChannelCredentialsCTX *)malloc( sizeof(ChannelCredentialsCTX) );
CODE:
ctx->wrapped = grpc_composite_channel_credentials_create(
cred1->wrapped, cred2->wrapped, NULL);
RETVAL = ctx;
OUTPUT: RETVAL
Grpc::XS::ChannelCredentials
createInsecure()
CODE:
XSRETURN_UNDEF;
OUTPUT:
void
DESTROY(Grpc::XS::ChannelCredentials self)
CODE:
grpc_channel_credentials_release(self->wrapped);
Safefree(self);
ext/server.xs view on Meta::CPAN
grpc_call_details_destroy(&details);
grpc_metadata_array_destroy(&metadata);
RETVAL = (SV*)newRV_noinc((SV *)result);
OUTPUT: RETVAL
long
addHttp2Port(Grpc::XS::Server self, SV* addr)
CODE:
#ifdef GRPC_NO_INSECURE_BUILD
{
grpc_server_credentials * insecure_cred = grpc_insecure_server_credentials_create();
RETVAL = grpc_server_add_http2_port(self->wrapped, SvPV_nolen(addr), insecure_cred);
grpc_server_credentials_release(insecure_cred);
}
#else
RETVAL = grpc_server_add_insecure_http2_port(self->wrapped, SvPV_nolen(addr));
#endif
OUTPUT: RETVAL
long
addSecureHttp2Port(Grpc::XS::Server self, SV* addr, Grpc::XS::ServerCredentials creds)
CODE:
RETVAL =
ext/server_credentials.h view on Meta::CPAN
#ifndef GRPC_PERL_SERVER_CREDENTIALS_H
#define GRPC_PERL_SERVER_CREDENTIALS_H
#include <grpc/grpc.h>
#include <grpc/grpc_security.h>
typedef struct {
grpc_server_credentials *wrapped;
} ServerCredentialsCTX;
typedef ServerCredentialsCTX* Grpc__XS__ServerCredentials;
#endif
ext/server_credentials.xs view on Meta::CPAN
Grpc::XS::ServerCredentials
createSsl(const char *class, ...)
PREINIT:
ServerCredentialsCTX* ctx = (ServerCredentialsCTX *)malloc( sizeof(ServerCredentialsCTX) );
ctx->wrapped = NULL;
CODE:
if (items % 2) {
croak("Expecting a hash as input to server credentials constructor");
}
// @param string pem_root_certs PEM encoding of the server root certificates (optional)
// @param string pem_private_key PEM encoding of the client's private key
// @param string pem_cert_chain PEM encoding of the client's certificate chain
// @return Credentials The new SSL credentials object
const char* pem_root_certs = NULL;
grpc_ssl_pem_key_cert_pair pem_key_cert_pair;
pem_key_cert_pair.private_key = pem_key_cert_pair.cert_chain = NULL;
int i;
for (i = 0; i < items; i += 2 ) {
const char *key = SvPV_nolen(ST(i));
if (!strcmp( key, "pem_root_certs")) {
ext/server_credentials.xs view on Meta::CPAN
pem_root_certs = SvPV_nolen(ST(i+1));
} else if (!strcmp( key, "pem_private_key")) {
if (SvOK(ST(i+1)))
pem_key_cert_pair.private_key = SvPV_nolen(ST(i+1));
} else if (!strcmp( key, "pem_cert_chain")) {
if (SvOK(ST(i+1)))
pem_key_cert_pair.cert_chain = SvPV_nolen(ST(i+1));
}
}
ctx->wrapped = grpc_ssl_server_credentials_create(
pem_root_certs,
pem_key_cert_pair.private_key == NULL ? NULL : &pem_key_cert_pair,
1, 0, NULL);
RETVAL = ctx;
OUTPUT: RETVAL
void
DESTROY(Grpc::XS::ServerCredentials self)
CODE:
if (self->wrapped != NULL) {
grpc_server_credentials_release(self->wrapped);
}
Safefree(self);
lib/Grpc/Client/AbstractCall.pm view on Meta::CPAN
## @param array $options Call options (optional)
sub new {
my $proto = shift;
my $channel = shift;
my $method = shift;
my $serialize = shift;
my $deserialize = shift;
my $options = shift || {};
my $timeout = $options->{timeout};
my $call_credentials_callback = $options->{call_credentials_callback};
my $deadline;
if (defined($timeout) && $timeout =~ /^\d+$/) {
my $now = Grpc::XS::Timeval::now();
my $delta = new Grpc::XS::Timeval($timeout);
$deadline = Grpc::XS::Timeval::add($now,$delta);
} else {
$deadline = Grpc::XS::Timeval::infFuture();
}
my $call = new Grpc::XS::Call($channel, $method, $deadline);
my $call_credentials;
if (defined($call_credentials_callback)) {
$call_credentials = Grpc::XS::CallCredentials::createFromPlugin(
$call_credentials_callback);
$call->setCredentials($call_credentials);
}
my $self = {
'_call' => $call,
'_channel' => $channel, ## keep in scope together with call
'_serialize' => $serialize,
'_deserialize' => $deserialize,
'_metadata' => undef,
};
bless $self,$proto;
lib/Grpc/Client/AbstractCall.pm view on Meta::CPAN
my $self = shift;
my $value = shift;
return undef if (!defined($value));
return $value if (!$self->{_deserialize});
return $self->{_deserialize}($value);
}
## Set the CallCredentials for the underlying Call.
##
## @param CallCredentials $call_credentials The CallCredentials
## object
sub setCallCredentials {
my $self = shift;
my $call_credentials = shift;
$self->{_call}->setCredentials($call_credentials);
}
1;
lib/Grpc/Client/BaseStub.pm view on Meta::CPAN
## - 'update_metadata': (optional) a callback function which takes in a
## metadata array, and returns an updated metadata array
## - 'grpc.primary_user_agent': (optional) a user-agent string
sub new {
my $proto = shift;
my $hostname = shift;
my %param = @_;
my $update_metadata = $param{"update_metadata"};
my $primary_user_agent = $param{"grpc.primary_user_agent"};
my $credentials = $param{"credentials"};
my $timeout = $param{"timeout"};
unless (defined($primary_user_agent)) {
$primary_user_agent = "grpc-perl/".($Grpc::XS::VERSION);
}
if (!exists($param{"credentials"})) {
die("The 'credentials' key is now required. Please see one of the ".
"Grpc::XS::ChannelCredentials::create methods");
} elsif (!defined($param{"credentials"})) {
delete $param{"credentials"};
}
my $channel = new Grpc::XS::Channel($hostname,%param);
my $self = {
'_hostname' => $hostname,
'_channel' => undef,
'_update_metadata' => $update_metadata, ## a callback function
'_primary_user_agent' => $primary_user_agent,
'_credentials' => $credentials,
'_channel' => $channel,
'_timeout' => $timeout,
};
bless $self,$proto;
return $self;
}
## return string The URI of the endpoint.
t/01-call_credentials.t view on Meta::CPAN
open(F,"<".$file);
my $content = join("",<F>);
close(F);
return $content;
}
#####################################################
## setup
#####################################################
my $credentials = Grpc::XS::ChannelCredentials::createSsl(
pem_root_certs => file_get_contents($path.'/data/ca.pem'));
my $call_credentials = Grpc::XS::CallCredentials::createFromPlugin(
\&callbackFunc);
$credentials = Grpc::XS::ChannelCredentials::createComposite(
$credentials,
$call_credentials
);
my $server_credentials = Grpc::XS::ServerCredentials::createSsl(
pem_root_certs => undef,
pem_private_key => file_get_contents($path.'/data/server1.key'),
pem_cert_chain => file_get_contents($path.'/data/server1.pem'));
my $server = new Grpc::XS::Server();
my $port = $server->addSecureHttp2Port('0.0.0.0:0',$server_credentials);
$server->start();
my $host_override = 'foo.test.google.fr';
my $channel = new Grpc::XS::Channel(
'localhost:'.$port,
'grpc.ssl_target_name_override' => $host_override,
'grpc.default_authority' => $host_override,
'credentials' => $credentials,
);
#####################################################
## callback
#####################################################
sub callbackFunc {
my $context = shift;
ok($context->{service_url} =~ /google/,"call back func failed service_url");
ok($context->{method_name} =~ /dummy/,"call back func failed method_name");
t/10-base_stub.t view on Meta::CPAN
#!perl -w
use strict;
use Data::Dumper;
use Test::More;
plan tests => 2;
use_ok("Grpc::Client::BaseStub");
use_ok("Grpc::XS::ChannelCredentials");
my $credentials = Grpc::XS::ChannelCredentials::createInsecure();
print STDERR Dumper($credentials);
my $stub = new Grpc::Client::BaseStub(
'localhost:50051',
credentials => $credentials,
timeout => 1000000 );
print STDERR Dumper($stub);
my $unmarshall = sub { return $_; };
my $result = $stub->_simpleRequest(
method => "/test/timeout",
deserialize => $unmarshall,
argument => "testcall",
metadata => undef,
options => undef );
t/16-xs_secure_end_to_end.t view on Meta::CPAN
open(F,"<".$file);
my $content = join("",<F>);
close(F);
return $content;
}
#####################################################
## setup
#####################################################
my $credentials = Grpc::XS::ChannelCredentials::createSsl(
pem_root_certs => file_get_contents($path.'/data/ca.pem'));
my $server_credentials = Grpc::XS::ServerCredentials::createSsl(
pem_root_certs => undef,
pem_private_key => file_get_contents($path.'/data/server1.key'),
pem_cert_chain => file_get_contents($path.'/data/server1.pem'));
my $server = new Grpc::XS::Server();
my $port = $server->addSecureHttp2Port('0.0.0.0:0',
$server_credentials);
$server->start();
my $host_override = 'foo.test.google.fr';
my $channel = new Grpc::XS::Channel(
'localhost:'.$port,
'grpc.ssl_target_name_override' => $host_override,
'grpc.default_authority' => $host_override,
'credentials' => $credentials,
);
#####################################################
## testSimpleRequestBody
#####################################################
my $deadline = Grpc::XS::Timeval::infFuture();
my $status_text = 'xyz';
my $call = new Grpc::XS::Call($channel,
'dummy_method',
t/16-xs_secure_end_to_end.t view on Meta::CPAN
ok($reply_text eq $event->{message},"message does not equal $reply_text");
$status = $event->{status};
ok(ref($status->{metadata})=~/HASH/,"status->metadata is not a hash");
ok(!(keys %{$status->{metadata}}),"status->metadata is not an empty hash");
ok(exists($status->{code}),"status->code does not exist");
ok($status->{code} == Grpc::Constants::GRPC_STATUS_OK(),"status->code not STATUS_OK");
ok(exists($status->{details}),"status->details does not exist");
ok($status->{details} eq $status_text,"status->details does not contain ".$status_text);
# I was not able to trigger a plugin calls without ssl/composite credentials, so let's test it there
subtest "plugin credentials error handling" => sub {
my $always_die = sub {
die "HERE";
};
my $not_a_reference = sub {
return "string";
};
my $not_a_hashref = sub {
return [5, 7, 9];
t/16-xs_secure_end_to_end.t view on Meta::CPAN
[$not_a_hashref, 'not_a_hashref', qr/callback returned invalid metadata/],
[$nothing, 'nothing', qr/calback returned non-reference/],
);
for my $test (@tests) {
my ($plugin, $name, $expect_like) = @$test;
subtest $name => sub {
my $call_creds = Grpc::XS::CallCredentials::createFromPlugin($plugin);
my $credentials = Grpc::XS::ChannelCredentials::createComposite($credentials, $call_creds);
my $channel = new Grpc::XS::Channel(
'localhost:'.$port,
'grpc.ssl_target_name_override' => $host_override,
'grpc.default_authority' => $host_override,
'credentials' => $credentials,
);
my $call = new Grpc::XS::Call(
$channel,
'/dummy_method',
$deadline,
$host_override
);
my $event = $call->startBatch(
}
}
}
return TRUE;
}
/* Callback function for plugin creds API */
#if defined(GRPC_VERSION_1_7)
int plugin_get_metadata(void *ptr, grpc_auth_metadata_context context,
grpc_credentials_plugin_metadata_cb cb,
void *user_data,
grpc_metadata creds_md[GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX],
size_t *num_creds_md, grpc_status_code *status,
const char **error_details) {
#else
void plugin_get_metadata(void *ptr, grpc_auth_metadata_context context,
grpc_credentials_plugin_metadata_cb cb,
void *user_data) {
#endif
static char error_details_buf[1024];
SV* callback = (SV*)ptr;
SV* err_tmp;
int has_error = FALSE;
char *error_details_out = NULL;
grpc_metadata_array metadata;
/* Shut down the completion queue */
void grpc_perl_shutdown_completion_queue();
void perl_grpc_read_args_array(HV *hash, grpc_channel_args *args);
HV* grpc_parse_metadata_array(grpc_metadata_array *metadata_array);
bool create_metadata_array(HV *hash, grpc_metadata_array *metadata);
#if defined(GRPC_VERSION_1_7)
int plugin_get_metadata(void *ptr, grpc_auth_metadata_context context,
grpc_credentials_plugin_metadata_cb cb,
void *user_data,
grpc_metadata creds_md[GRPC_METADATA_CREDENTIALS_PLUGIN_SYNC_MAX],
size_t *num_creds_md, grpc_status_code *status,
const char **error_details);
#else
void plugin_get_metadata(void *ptr, grpc_auth_metadata_context context,
grpc_credentials_plugin_metadata_cb cb,
void *user_data);
#endif
void plugin_destroy_state(void *ptr);
#if defined(GRPC_VERSION_1_2)
SV *grpc_slice_to_sv(grpc_slice slice);
grpc_slice grpc_slice_from_sv(SV *sv);
#endif
( run in 0.610 second using v1.01-cache-2.11-cpan-fd5d4e115d8 )