Result:
found more than 553 distributions - search limited to the first 2001 files matching your query
( run in 2.017 )
Deplide-RFID-EPCISSubmitter
view release on metacpan or search on metacpan
lib/Deplide/RFID/EPCISSubmitter.pm view on Meta::CPAN
sub new {
my $class = shift;
my $user = shift;
my $password = shift;
my $endpointURL = shift || $Deplide::RFID::EPCISSubmitter::DEFAULT_ENDPOINT_URL;
my $ua = LWP::UserAgent->new();
$ua->agent("Deplide::RFID::EPCISSubmitter/$Deplide::RFID::EPCISSubmitter::VERSION");
my $self = {
_user => $user,
_password => $password,
_url => $endpointURL,
_ua => $ua
};
bless $self, ref($class) || $class;
return $self;
lib/Deplide/RFID/EPCISSubmitter.pm view on Meta::CPAN
Deplide::RFID::EPCISSubmitter - Perl extension for submission of EPCIS documents with RFID reading data to Deplide
=head1 SYNOPSIS
use Deplide::RFID::EPCISSubmitter;
my $submitter = Deplide::RFID::EPCISSubmitter->new($user, $password, $endpointURL);
$submitter->submit($epcisMessage);
=head1 DESCRIPTION
Deplide::RFID::EPCISSubmitter lets you submit data to the EPCIS Train RFID streams
Devel-Cover-Report-Codecov
view release on metacpan or search on metacpan
0.24 2018-08-29T15:01:51Z
- good bye Magnum CI
0.23 2018-08-28T16:31:09Z
- use https endpoint
0.22 2018-01-16T17:38:24Z
- support perl 5.8.1 or later
0.21 2017-10-01T05:36:04Z
Devel-Cover-Report-Coveralls
view release on metacpan or search on metacpan
lib/Devel/Cover/Report/Coveralls.pm view on Meta::CPAN
$json->{repo_token} = $ENV{COVERALLS_REPO_TOKEN} if $ENV{COVERALLS_REPO_TOKEN};
$json->{flag_name} = $ENV{COVERALLS_FLAG_NAME} if $ENV{COVERALLS_FLAG_NAME};
$json->{parallel} = \1 if $ENV{COVERALLS_PARALLEL};
my $is_travis;
my $endpoint = ($ENV{COVERALLS_ENDPOINT} || $API_ENDPOINT) . $API_ENDPOINT_STEM;
if ($ENV{TRAVIS}) {
$is_travis = 1;
$json->{service_name} = $config->{service_name} || 'travis-ci';
$json->{service_job_id} = $ENV{TRAVIS_JOB_ID};
if($ENV{TRAVIS_PULL_REQUEST} && $ENV{TRAVIS_PULL_REQUEST} ne 'false'){
lib/Devel/Cover/Report/Coveralls.pm view on Meta::CPAN
if (exists $ENV{COVERALLS_PERL_SERVICE_NAME} && $ENV{COVERALLS_PERL_SERVICE_NAME}) {
$json->{service_name} = $ENV{COVERALLS_PERL_SERVICE_NAME};
}
return ($json, $endpoint);
}
sub _parse_line ($) {
my $c = shift;
lib/Devel/Cover/Report/Coveralls.pm view on Meta::CPAN
my $c = $f->statement();
push @sfs, get_source( $file, _parse_line $c );
}
my ($json, $endpoint) = get_config();
$json->{git} = eval { get_git_info() } || {};
$json->{source_files} = \@sfs;
my $coder = JSON::PP->new->ascii;
my $response = HTTP::Tiny->new( verify_SSL => 1 )
->post_form( $endpoint, { json => $coder->encode($json) } );
my $res = eval { decode_json $response->{content} };
print("- Report::Coveralls --------\n");
Devel-Debug-DBGp
view release on metacpan or search on metacpan
Devel/Debug/DBGp.pm view on Meta::CPAN
DB::connectOrReconnect();
Connects to the debugger client (closes the current connection if any).
If the debugger client is not listening at the specified endpoint,
debugging is disabled (via L</disable>) and execution continues
normally.
=head2 isConnected
Devel-Probe
view release on metacpan or search on metacpan
lib/Devel/Probe.pm view on Meta::CPAN
One typical use case would be to have a signal handler associated with a
specific signal, which when triggered would disable the module, read the
configuration from a given place, reconfigure the module accordingly and then
enable it. Similarly, this kind of control can be implemented using remote
endpoints to deal with reconfiguring, disabling and enabling the module.
=head1 TODO
=over 4
Devel-StackTrace
view release on metacpan or search on metacpan
azure-pipelines.yml view on Meta::CPAN
resources:
repositories:
- repository: ci-perl-helpers
type: github
name: houseabsolute/ci-perl-helpers
endpoint: houseabsolute
stages:
- template: templates/helpers/build.yml@ci-perl-helpers
parameters:
debug: true
Device-LabJack
view release on metacpan or search on metacpan
linux-labjack/INSTALL view on Meta::CPAN
HID NOTE: If the hid module is loaded (use lsmod to view the modules and
look for "hid"), the provided labjack driver will not work correctly.
Since the Labjack is classified as a HID device, the hid driver will
claim the device. However, the hid driver does not support the "Interrupt"
out endpoint used by the Labjack and thus cannot communicate with the
Labjack. You must remove the hid driver prior to loading the labjack
driver. The following command, as root, should suffice:
# modprobe -r hid
linux-labjack/INSTALL view on Meta::CPAN
HID NOTE: If the hid module is loaded (use lsmod to view the modules and
look for "hid"), the provided labjack driver will not work correctly.
Since the Labjack is classified as a HID device, the hid driver will claim
the device. However, the hid driver does not support the "Interrupt" out
endpoint used by the Labjack and thus cannot communicate with the Labjack.
You must remove the hid driver prior to loading the labjack driver. The
following command, as root, should suffice:
# modprobe -r hid
Device-Serial-SLuRM
view release on metacpan or search on metacpan
lib/Device/Serial/MSLuRM.pm view on Meta::CPAN
This variant of L<Device::Serial::SLuRM> allows communication with a
collection of nodes using Multi-drop SLµRM over a serial port, such as over
an RS-485 bus.
The endpoint running with this module takes the role of the bus controller.
Currently this module does not support being a non-controller node.
=cut
use constant is_multidrop => 1;
Device-USB-Win32Async
view release on metacpan or search on metacpan
Win32Async.pm view on Meta::CPAN
functionality is the same as the libusb function whose name is
the method name prepended with "usb_".
Generally, define a $Context variable which the library will use to keep track of
the asynchronous call. Activate the transfer (read or write, depending on the
endpoint) using submit_async() as shown, then loop calling reap_async_nocancel()
while checking the return code.
You can have any number of async operations pending on different endpoints - just
define multiple context variables as needed (ie - $Context1, $Context2, &c).
=cut
Win32Async.pm view on Meta::CPAN
A scalar to store opaque information about the operation
=item Endpoint
The endpoint the asynchronous operation will use
=item Packetsize
The size of the isochronous packets
Win32Async.pm view on Meta::CPAN
A scalar to store opaque information about the operation
=item Endpoint
The endpoint the asynchronous operation will use
=back
Returns 0 on success, < 0 on error (consult errno.h for explanation)
Win32Async.pm view on Meta::CPAN
A scalar to store opaque information about the operation
=item Endpoint
The endpoint the asynchronous operation will use
=back
Returns 0 on success, < 0 on error (consult errno.h for explanation)
Device-USB
view release on metacpan or search on metacpan
lib/Device/USB.pm view on Meta::CPAN
=item level
0 disables debugging, 1 enables some debug messages, and 2 enables verbose
debug messages
Any other values are forced to the nearest endpoint.
=back
=cut
lib/Device/USB.pm view on Meta::CPAN
=item libusb_get_descriptor(void *dev, unsigned char type, unsigned char index, char *buf, int size)
=item libusb_get_descriptor_by_endpoint(void *dev, int ep, unsigned char type, unsigned char index, char *buf, int size)
=item libusb_bulk_write(void *dev, int ep, char *bytes, int size, int timeout)
lib/Device/USB.pm view on Meta::CPAN
int libusb_get_descriptor(void *dev, unsigned char type, unsigned char index, char *buf, int size)
{
return usb_get_descriptor((usb_dev_handle *)dev, type, index, buf, size);
}
int libusb_get_descriptor_by_endpoint(void *dev, int ep, unsigned char type, unsigned char index, char *buf, int size)
{
return usb_get_descriptor_by_endpoint((usb_dev_handle *)dev, ep, type, index, buf, size);
}
int libusb_bulk_write(void *dev, int ep, char *bytes, int size, int timeout)
{
return usb_bulk_write((usb_dev_handle *)dev, ep, bytes, size, timeout);
lib/Device/USB.pm view on Meta::CPAN
return newRV_noinc( (SV*)hash );
}
/*
* Given a pointer to a usb_endpoint_descriptor struct, create a reference
* to a Device::USB::DevEndpoint object that represents it.
*/
static SV* build_endpoint( struct usb_endpoint_descriptor* endpt )
{
HV* hash = newHV();
hashStoreInt( hash, "bDescriptorType", endpt->bDescriptorType );
hashStoreInt( hash, "bEndpointAddress", endpt->bEndpointAddress );
lib/Device/USB.pm view on Meta::CPAN
gv_stashpv( "Device::USB::DevEndpoint", 1 )
);
}
/*
* Given a pointer to an array of usb_endpoint_descriptor structs, create a
* reference to a Perl array containing the same data.
*/
static SV* list_endpoints( struct usb_endpoint_descriptor* endpt, unsigned count )
{
AV* array = newAV();
unsigned i = 0;
for(i=0; i < count; ++i)
{
av_push( array, build_endpoint( endpt+i ) );
}
return newRV_noinc( (SV*)array );
}
lib/Device/USB.pm view on Meta::CPAN
hashStoreInt( hash, "bNumEndpoints", inter->bNumEndpoints );
hashStoreInt( hash, "bInterfaceClass", inter->bInterfaceClass );
hashStoreInt( hash, "bInterfaceSubClass", inter->bInterfaceSubClass );
hashStoreInt( hash, "bInterfaceProtocol", inter->bInterfaceProtocol );
hashStoreInt( hash, "iInterface", inter->iInterface );
hashStoreSV( hash, "endpoints",
list_endpoints( inter->endpoint, inter->bNumEndpoints )
);
/* TODO: handle the 'extra' data */
return sv_bless( newRV_noinc( (SV*)hash ),
gv_stashpv( "Device::USB::DevInterface", 1 )
Device-XBee-API
view release on metacpan or search on metacpan
lib/Device/XBee/API.pm view on Meta::CPAN
};
use constant XBEE_API_TRANSMIT_STATUS_TO_STRING => {
0x00 => 'Success',
0x02 => 'CCA Failure',
0x15 => 'Invalid destination endpoint',
0x21 => 'Network ACK Failure',
0x22 => 'Not Joined to Network',
0x23 => 'Self-addressed',
0x24 => 'Address Not Found',
0x25 => 'Route Not Found',
lib/Device/XBee/API.pm view on Meta::CPAN
}
=head2 remote_at
Send an AT command to a remote module. Accepts three parameters: a hashref with
endpoint addresses, command options, frame_id; the AT command name (as
two-character string); and the third as the expected data for that command (if
any) as a string. See the XBee datasheet for a list of supported AT commands
and expected data for each.
Endpoint addresses should be specified as a hashref containing the following
lib/Device/XBee/API.pm view on Meta::CPAN
}
=head2 tx
Sends a transmit request to the XBee. Accepts three parameters, the first is the
endpoint address, the second is a scalar containing the data to be sent, and the
third is an optional flag (known as the async flag) specifying whether or not
the method should wait for an acknowledgement from the XBee.
Endpoint addresses should be specified as a hashref containing the following
keys:
DigitalOcean
view release on metacpan or search on metacpan
lib/DigitalOcean/Droplet/Upgrade.pm view on Meta::CPAN
A time value given in ISO8601 combined date and time format that represents when the migration will occur for the droplet.
=head2 url
A URL pointing to the Droplet's API endpoint. This is the endpoint to be used if you want to retrieve information about the droplet.
=head2 id
=head1 AUTHOR
Directory-Scanner
view release on metacpan or search on metacpan
instead of doing it longhand
0.03 2018-01-29
[!!BREAKING CHANGES!!]
- major re-arrangement of the internals for building
a stream, there is no longer an endpoint called
`stream` which you must call before things are
usable, instead things are just always usable.
- removed the `stream` method from `Directory::Scanner`
- moved all the builder methods from `Directory::Scanner`
to `Directory::Scanner::API::Stream` instead, so that
Dist-Zilla-Plugin-Conflicts
view release on metacpan or search on metacpan
azure-pipelines.yml view on Meta::CPAN
resources:
repositories:
- repository: ci-perl-helpers
type: github
name: houseabsolute/ci-perl-helpers
endpoint: houseabsolute
stages:
- template: templates/helpers/build.yml@ci-perl-helpers
parameters:
debug: true
Dist-Zilla-Plugin-GitHub-CreateRelease
view release on metacpan or search on metacpan
bin/createrelease.pl view on Meta::CPAN
generate_release_notes => $github_notes,
}
);
die "Unable to create release for $identity{login}\\$releases->{repo}" if ($response->code eq '404');
#die "Validation failed, or the endpoint has been spammed." if ($response->code eq '422');
die "login or token invalid for the specified repository: $identity{login}\\$releases->{repo}\n"
if ($response->code eq '403');
if ($response->code ne '201') {
my $message = $response->raw_content();
Dist-Zilla-PluginBundle-Author-GETTY
view release on metacpan or search on metacpan
lib/Pod/Weaver/PluginBundle/Author/GETTY.pm view on Meta::CPAN
Parse a configuration file and return a hashref.
=head2 =resource
Documents available resources, features, or API endpoints.
=resource servers
Cloud servers (create, delete, power on/off)
Docker-Client
view release on metacpan or search on metacpan
lib/Docker/Client.pm view on Meta::CPAN
our $VERSION = '0.1.1';
class_type 'Mojo::URL';
coerce 'Mojo::URL', from 'Str', via { Mojo::URL->new(shift) };
has 'endpoint' => (
is => 'ro',
isa => 'Mojo::URL',
default => sub {
return Mojo::URL->new('http+unix://%2Fvar%2Frun%2Fdocker.sock');
},
lib/Docker/Client.pm view on Meta::CPAN
default => sub {
my $self = shift;
## Making sure we use the correct version path
my $base_url =
$self->endpoint()->clone()->path( sprintf '/%s', $self->version() );
## Loading correct version specification from disk.
my $spec =
Mojo::File->new( dist_dir('Docker-Client') )->child('specs')
->child( sprintf '%s.yaml', $self->version() );
## Creating the OpenAPI Client instance using the defined parameters.
my $api =
OpenAPI::Client->new( $spec->to_string(),
base_url => $self->endpoint() );
## If the protocol is local we need to replace the "Host" header on each request
if ( $self->endpoint()->protocol() eq 'http+unix' ) {
$api->ua()->on(
start => sub {
my ( $ua, $tx ) = @_;
$tx->req()->headers()->header( 'Host' => 'localhost' );
Docker-Registry
view release on metacpan or search on metacpan
lib/Docker/Registry/Auth/Gitlab.pm view on Meta::CPAN
The repository you request access to.
=head2 jwt
The endpoint to request the JWT token from, defaults to
'https://gitlab.com/jwt/auth'. You can use a 'Str' or an URI object.
=head1 METHODS
=head2 get_bearer_token
Dubber-API
view release on metacpan or search on metacpan
lib/Dubber/API.pm view on Meta::CPAN
);
method _build_json_coder () { return Cpanel::JSON::XS->new->utf8; }
# ------------------------------------------------------------------------
has endpoints => (
is => 'ro',
default => sub {
{ root => { path => '/' },
# Group Methods (Group Authentication Required)
lib/Dubber/API.pm view on Meta::CPAN
};
},
);
method commands () { return $self->endpoints; }
# ------------------------------------------------------------------------
method upload_recording_mp3_file ($account_id, $call_metadata, $mp3_file_or_data) {
my @data_parts = $self->_split_recording_data($mp3_file_or_data);
ELab-Client
view release on metacpan or search on metacpan
lib/ELab/Client.pm view on Meta::CPAN
is => 'ro',
isa => 'Str',
required => 1,
);
has endpoint => (
is => 'ro',
isa => 'Str',
default => 'api/v1/'
);
lib/ELab/Client.pm view on Meta::CPAN
my (%args) = validated_hash(
\@_,
file => { isa => 'Str' },
);
my $request = HTTP::Request::Common::POST(
$self->host().$self->endpoint()."experiments/$id",
{
file => [ $args{file} ]
},
Content_Type => 'form-data',
Authorization => $self->token(),
lib/ELab/Client.pm view on Meta::CPAN
my (%args) = validated_hash(
\@_,
file => { isa => 'Str' },
);
my $request = HTTP::Request::Common::POST(
$self->host().$self->endpoint()."items/$id",
{
file => [ $args{file} ]
},
Content_Type => 'form-data',
Authorization => $self->token(),
lib/ELab/Client.pm view on Meta::CPAN
sub elab_get {
my $self = shift;
my $url = shift;
my $result = $self->GET($self->endpoint().$url);
return undef unless $result->responseCode() eq '200';
return $result->responseContent();
}
sub elab_delete {
my $self = shift;
my $url = shift;
my $result = $self->DELETE($self->endpoint().$url);
return undef unless $result->responseCode() eq '200';
return $result->responseContent();
}
lib/ELab/Client.pm view on Meta::CPAN
my $self = shift;
my $url = shift;
my $data = shift;
$data =~ s/^\?//; # buildQuery starts with "?" (makes no sense here)
my $headers = { 'Content-Type' => 'application/x-www-form-urlencoded' };
my $result = $self->POST($self->endpoint().$url, $data, $headers);
return undef unless $result->responseCode() eq '200';
return $result->responseContent();
}
EMDIS-ECS
view release on metacpan or search on metacpan
script/ecs_token view on Meta::CPAN
use LWP::UserAgent;
use Term::ReadLine;
use URI::Escape;
my $SECSTOR_LOCATION = {
auth_endpoint => 'emdis/ecs/oauth/auth_endpoint',
cached_token_response => 'emdis/ecs/oauth/cached_token_response',
cached_token_timestamp => 'emdis/ecs/oauth/cached_token_timestamp',
client_id => 'emdis/ecs/oauth/client_id',
client_secret => 'emdis/ecs/oauth/client_secret',
redirect_uri => 'emdis/ecs/oauth/redirect_uri',
refresh_token => 'emdis/ecs/oauth/refresh_token',
scope => 'emdis/ecs/oauth/scope',
token_endpoint => 'emdis/ecs/oauth/token_endpoint',
};
my $SECSTOR_TIMELIMIT = 3;
my $CACHED_TOKEN_EXPIRATION_MARGIN = 600;
# add --nocache option
script/ecs_token view on Meta::CPAN
"Usage:$/" .
" ecs_token <command> [options]$/" .
"Where:$/" .
" <command> is code, credentials, or refresh$/" .
" code [options] are:$/" .
" --auth_endpoint <auth_endpoint>$/" .
" --client_id <client_id>$/" .
" --client_secret <client_secret>$/" .
" --nocache$/" .
" --redirect_uri <redirect_uri>$/" .
" --scope <scope>$/" .
" --token_endpoint <token_endpoint>$/" .
" credentials [options] are:$/" .
" --client_id <client_id>$/" .
" --client_secret <client_secret>$/" .
" --nocache$/" .
" --scope <scope>$/" .
" --token_endpoint <token_endpoint>$/" .
" refresh [options] are:$/" .
" --client_id <client_id>$/" .
" --client_secret <client_secret>$/" .
" --nocache$/" .
" --refresh_token <refresh_token>$/" .
" --token_endpoint <token_endpoint>$/" .
" [options] not present on command line will be read from secure storage$/" .
"For details, refer to documentation:$/" .
" perldoc ecs_token$/";
my %options = ();
GetOptions(\%options, 'auth_endpoint=s', 'client_id=s', 'client_secret=s',
'nocache', 'redirect_uri=s', 'refresh_token=s', 'scope=s',
'token_endpoint=s')
or die "Error - Unrecognized command line option$/" . $USAGE;
my $command = ($#ARGV == 0 ? $ARGV[0] : '');
die "Error - unrecognized, invalid, or missing <command>$/" . $USAGE
unless $command eq 'code' or $command eq 'credentials' or $command eq 'refresh';
script/ecs_token view on Meta::CPAN
if($command eq 'code') {
# using authorization code flow ...
# get configuration parameters
my $auth_endpoint = get_config_param('auth_endpoint');
my $client_id = get_config_param('client_id');
my $client_secret = get_config_param('client_secret');
my $nocache = exists $options{nocache};
my $redirect_uri = get_config_param('redirect_uri');
my $scope = get_config_param('scope');
my $token_endpoint = get_config_param('token_endpoint');
# fail fast if command line contains unsupported options
die "Error - Option(s) unsupported for \"code\" command$/" . $USAGE
if exists $options{refresh_token};
script/ecs_token view on Meta::CPAN
or die "Error - Unable to initialize Term::ReadLine.$/";
$term->ornaments(0);
my $OUT = $term->OUT || *STDOUT;
# Construct URL to request authorization code.
# uses client id, redirect uri, scope, and auth endpoint
my $url = $auth_endpoint .
'?client_id=' . uri_escape($client_id) .
'&redirect_uri=' . uri_escape($redirect_uri) .
'&scope=' . uri_escape($scope) .
'&response_type=code' .
'&access_type=offline' .
script/ecs_token view on Meta::CPAN
my $authorization_code = $term->readline("Enter authorization code: ");
my $token_request_timestamp = time;
# use authorization code, client id, client secret, and redirect uri
# to request access token from token endpoint
my $response = $user_agent->post($token_endpoint, [
client_id => $client_id,
client_secret => $client_secret,
code => $authorization_code,
redirect_uri => $redirect_uri,
grant_type => 'authorization_code',
script/ecs_token view on Meta::CPAN
# get configuration parameters
my $client_id = get_config_param('client_id');
my $client_secret = get_config_param('client_secret');
my $nocache = exists $options{nocache};
my $scope = get_config_param('scope');
my $token_endpoint = get_config_param('token_endpoint');
# fail fast if command line contains unsupported options
die "Error - Option(s) unsupported for \"credentials\" command$/" . $USAGE
if exists $options{auth_endpoint} or exists $options{redirect_uri}
or exists $options{refresh_token};
if(not $nocache) {
# use cached token if available
my $cached_token = get_cached_token();
script/ecs_token view on Meta::CPAN
}
my $token_request_timestamp = time;
# use client id, client secret, and resource to request access token
# from token endpoint
my $response = $user_agent->post($token_endpoint, [
client_id => $client_id,
client_secret => $client_secret,
scope => $scope,
grant_type => 'client_credentials',
]);
script/ecs_token view on Meta::CPAN
# get configuration parameters
my $client_id = get_config_param('client_id');
my $client_secret = get_config_param('client_secret');
my $nocache = exists $options{nocache};
my $refresh_token = get_config_param('refresh_token');
my $token_endpoint = get_config_param('token_endpoint');
# fail fast if command line contains unsupported options
die "Error - Option(s) unsupported for \"refresh\" command$/" . $USAGE
if exists $options{auth_endpoint} or exists $options{redirect_uri}
or exists $options{scope};
if(not $nocache) {
# use cached token if available
my $cached_token = get_cached_token();
script/ecs_token view on Meta::CPAN
}
my $token_request_timestamp = time;
# use client id, client secret and refresh token to request access token
# from token endpoint
my $response = $user_agent->post($token_endpoint, [
client_id => $client_id,
client_secret => $client_secret,
refresh_token => $refresh_token,
grant_type => 'refresh_token',
]);
script/ecs_token view on Meta::CPAN
storage or by passing the value on the C<ecs_token> command line.
Example using C<pass> secure storage:
echo -n 'https://accounts.google.com/o/oauth2/auth' | \
pass insert --echo emdis/ecs/oauth/auth_endpoint
Example using command line parameter:
ecs_token code --auth_endpoint https://accounts.google.com/o/oauth2/auth
=over
=item auth_endpoint
OAuth 2.0 authorization code endpoint, for authorization code flow.
Required by the C<ecs_token code> command. Example value:
https://accounts.google.com/o/oauth2/auth
=item cached_token_response
script/ecs_token view on Meta::CPAN
C<ecs_token credentials> commands. Example values:
https://mail.google.com/
https://outlook.office365.com/.default
=item token_endpoint
OAuth 2.0 token endpoint. Required by the C<ecs_token code>,
C<ecs_token credentials>, and C<ecs_token refresh> commands. Example
values:
https://accounts.google.com/o/oauth2/token
https://login.microsoftonline.com/[tenant_id]/oauth2/v2.0/token
script/ecs_token view on Meta::CPAN
Populate the expected secure storage locations with information needed by
C<ecs_token>. E.g.:
echo -n 'https://accounts.google.com/o/oauth2/auth' | \
pass insert --echo emdis/ecs/oauth/auth_endpoint
echo -n '' | \
pass insert --echo emdis/ecs/oauth/cached_token_response
echo -n '0' | \
script/ecs_token view on Meta::CPAN
echo -n 'https://mail.google.com/' | \
pass insert --echo emdis/ecs/oauth/scope
echo -n 'https://accounts.google.com/o/oauth2/token' | \
pass insert --echo emdis/ecs/oauth/token_endpoint
=back
=head2 Environment Variables
EPFL-Net-SSLTest
view release on metacpan or search on metacpan
bin/epfl-net-ssl-test view on Meta::CPAN
while ( not $host = $labs->analyze( host => $domain )->complete() ) {
sleep $labs->previous_eta();
}
if ( $host->ready() ) {
foreach my $endpoint ( $host->endpoints() ) {
if ( $endpoint->ready() ) {
print "\n", $endpoint->ip_address(), "\n"
or croak "Couldn't write: $OS_ERROR";
print color('green'), '✔ Diode', "\n", color('clear')
or croak "Couldn't write: $OS_ERROR";
print color('green'), '✔ SSL Certificate', "\n", color('clear')
or croak "Couldn't write: $OS_ERROR";
if ( $endpoint->grade() eq 'A' or $endpoint->grade() eq 'A+' ) {
print color('green'), '✔ Grade ', $endpoint->grade(), "\n\n",
color('clear')
or croak "Couldn't write: $OS_ERROR";
}
else {
print color('red'), '✘ Grade ', $endpoint->grade(), "\n\n",
color('clear')
or croak "Couldn't write: $OS_ERROR";
}
}
else {
EV-Hiredis
view release on metacpan or search on metacpan
deps/hiredis/README.md view on Meta::CPAN
}
}
```
One can also use `redisConnectWithOptions` which takes a `redisOptions` argument
that can be configured with endpoint information as well as many different flags
to change how the `redisContext` will be configured.
```c
redisOptions opt = {0};
/* One can set the endpoint with one of our helper macros */
if (tcp) {
REDIS_OPTIONS_SET_TCP(&opt, "localhost", 6379);
} else {
REDIS_OPTIONS_SET_UNIX(&opt, "/tmp/redis.sock");
}
Eixo-Docker
view release on metacpan or search on metacpan
lib/Eixo/Docker/Container.pm view on Meta::CPAN
action=>'attach',
method=>'POST',
host=>$self->api->client->endpoint,
args=>\%args,
url_args=>[qw(logs stream stdin stdout stderr)],
Eixo-Rest
view release on metacpan or search on metacpan
lib/Eixo/Rest/Api.pm view on Meta::CPAN
sub DESTROY {}
sub initialize{
my ($self, $endpoint, %opts) = @_;
$self->client(
Eixo::Rest::Client->new($endpoint, %opts)
);
$self->SUPER::initialize(%opts);
$self;
Elive
view release on metacpan or search on metacpan
t/Elive/MockConnection.pm view on Meta::CPAN
my $self = {};
bless $self, $class;
$url ||= 'http://elive_mock_connection';
$url =~ s{/$}{}; # lose trailing '/'
$url =~ s{/webservice\.event$}{}; # lose endpoint
$url =~ s{/v[1-9]$}{}; # lose adapter path
if ($url =~ s{^(\w+)://(.*)\@}{$1://}) { # lose/capture credentials
my ($_user, $_pass) = split(':', $2, 2);
Email-ExactTarget
view release on metacpan or search on metacpan
lib/Email/ExactTarget.pm view on Meta::CPAN
sub soap_call
{
my ( $self, %args ) = @_;
my $verbose = $self->verbose();
my $use_test_environment = $self->use_test_environment();
my $endpoint = $use_test_environment
? $ENDPOINT_TEST
: $ENDPOINT_LIVE;
# Check the parameters.
confess 'You must define a SOAP action'
lib/Email/ExactTarget.pm view on Meta::CPAN
$args{'arguments'} ||= [];
# Do not forget to specify the soapaction (on_action), you will find it in the
# wsdl.
# - uri is the target namespace in the wsdl
# - proxy is the endpoint address
my $soap = SOAP::Lite
->uri( $NAMESPACE )
->on_action( sub { return '"' . $args{'action'} . '"' } )
->proxy( $endpoint )
->readable( ( $verbose ? 1 : 0 ) );
# You must define the namespace used in the wsdl, as an attribute to the
# method without namespace prefix for compatibility with .NET
# (document/literal).
lib/Email/ExactTarget.pm view on Meta::CPAN
SOAP::Header
->name( Action => $args{'action'} )
->uri( 'http://schemas.xmlsoap.org/ws/2004/08/addressing' )
->prefix( 'wsa' ),
SOAP::Header
->name( To => $endpoint )
->uri( 'http://schemas.xmlsoap.org/ws/2004/08/addressing' )
->prefix( 'wsa' ),
SOAP::Header
->name(
Security => \SOAP::Data->value(
Email-SendGrid-V3
view release on metacpan or search on metacpan
lib/Email/SendGrid/V3.pm view on Meta::CPAN
#pod =cut
sub send {
my ($self, %args) = @_;
my $api_key = $args{api_key} || $self->{api_key} or croak "API key is required to send";
my $endpoint = $args{endpoint} || $self->{endpoint} || DEFAULT_ENDPOINT;
my $payload = $self->_payload;
my $http = HTTP::Tiny->new(
keep_alive => 0,
default_headers => {
lib/Email/SendGrid/V3.pm view on Meta::CPAN
'Authorization' => "Bearer $api_key",
},
);
my $response = $http->post(
$endpoint, { content => $payload },
);
return $response;
}
Email-Sender-Transport-Mailgun
view release on metacpan or search on metacpan
lib/Email/Sender/Transport/Mailgun.pm view on Meta::CPAN
# Percent-escape anything other than alphanumeric and - _ . ~
# https://github.com/sdt/Email-Sender-Transport-Mailgun/issues/4
my $api_key = $self->api_key;
$api_key =~ s/[^-_.~0-9a-zA-Z]/sprintf('%%%02x',ord($&))/eg;
# adapt endpoint based on region setting.
$rest =~ s/(\.mailgun)/sprintf('.%s%s', $self->region, $1)/e
if defined $self->region && $self->region ne 'us';
return "$proto://api:$api_key\@$rest/$domain";
}
( run in 2.017 seconds using v1.01-cache-2.11-cpan-55a6197bec7 )