view release on metacpan or search on metacpan
lib/AsposeThreeDCloud/ApiClient.pm view on Meta::CPAN
$self->{get_access_token_time} = time();
return $_response_object;
}
# make the HTTP request
# @param string $resourcePath path to method endpoint
# @param string $method method to call
# @param array $queryParams parameters to be place in query URL
# @param array $postData parameters to be placed in POST body
# @param array $headerParams parameters to be place in request header
# @return mixed
lib/AsposeThreeDCloud/ApiClient.pm view on Meta::CPAN
my ($self, $header_params, $query_params, $auth_settings) = @_;
return $self->_global_auth_setup($header_params, $query_params)
unless $auth_settings && @$auth_settings;
# one endpoint can have more than 1 auth settings
foreach my $auth (@$auth_settings) {
# determine which one to use
if (!defined($auth)) {
# TODO show warning about auth setting not defined
}
lib/AsposeThreeDCloud/ApiClient.pm view on Meta::CPAN
# TODO show warning about security definition not found
}
}
}
# The endpoint API class has not found any settings for auth. This may be deliberate,
# in which case update_params_for_auth() will be a no-op. But it may also be that the
# OpenAPI Spec does not describe the intended authorization. So we check in the config for any
# auth tokens and if we find any, we use them for all endpoints;
sub _global_auth_setup {
my ($self, $header_params, $query_params) = @_;
my $tokens = $self->{config}->get_tokens;
return unless keys %$tokens;
view all matches for this distribution
view release on metacpan or search on metacpan
lib/AsposeWordsCloud/ApiClient.pm view on Meta::CPAN
}
$self->{http_timeout} = $seconds;
}
# make the HTTP request
# @param string $resourcePath path to method endpoint
# @param string $method method to call
# @param array $queryParams parameters to be place in query URL
# @param array $postData parameters to be placed in POST body
# @param array $headerParams parameters to be place in request header
# @return mixed
view all matches for this distribution
view release on metacpan or search on metacpan
lib/Astro/ADS/Search.pm view on Meta::CPAN
package Astro::ADS::Search;
# ABSTRACT: Queries the ADS Search endpoint and collects the results
$Astro::ADS::Search::VERSION = '1.90';
use Moo;
extends 'Astro::ADS';
with 'Astro::ADS::Role::ResultMapper';
lib/Astro/ADS/Search.pm view on Meta::CPAN
=encoding UTF-8
=head1 NAME
Astro::ADS::Search - Queries the ADS Search endpoint and collects the results
=head1 VERSION
version 1.90
view all matches for this distribution
view release on metacpan or search on metacpan
lib/Astro/Catalog/Query/Sesame.pm view on Meta::CPAN
my $self = shift;
# clean out buffer
$self->_set_raw("");
my $endpoint = $self->endpoint();
my %options = $self->_translate_options();
# return unless we haev a target, set it otherwise
return undef unless $self->query_options("object");
# make sesame query
my $service = SOAP::Lite->service($self->endpoint());
my $ident = $self->query_options("object");
$ident =~ s/\+/ /g;
my $buffer;
lib/Astro/Catalog/Query/Sesame.pm view on Meta::CPAN
These methods are for internal use only.
=over 4
=item B<_default_endpoint>
=cut
sub _default_endpoint {
return "http://cdsws.u-strasbg.fr/axis/services/Sesame?wsdl";
}
=item B<_default_urn>
view all matches for this distribution
view release on metacpan or search on metacpan
lib/Astro/DSS/JPEG.pm view on Meta::CPAN
ua => $ua # Optional
);
All parameters are optional. The constructor by default creates an L<LWP::UserAgent>,
but you can pass your own with C<ua>, while the URL to the L<STScI|https://archive.stsci.edu/dss/copyright.html>
JPEG endpoint and the L<SIMBAD|http://simbad.u-strasbg.fr/simbad/> simple identifier query
interface can be redefined (e.g. if they change in the future) from the above shown defaults.
=head1 METHODS
=head2 C<get_image>
lib/Astro/DSS/JPEG.pm view on Meta::CPAN
=back
=head1 NOTES
Some artifacts can be seen at the borders of separate "stripes" of the survey and
also the particular JPEG endpoint used sometimes can leave the corners as plain black
squares (depending on the selected frame size, as it is to do with the way it does
segmentation), so if you want to make sure you have a frame with no corner gaps,
request some more angular size than you want and crop.
Note that the module test suite won't actually fetch data from either DSS or SIMBAD.
This is mainly to ensure it will not fail even if the DSS & SIMBAD endpoints change,
as you can still use the module by passing the updated urls to the constructor. It
also avoids unneeded strain to those free services.
=cut
view all matches for this distribution
view release on metacpan or search on metacpan
lib/Astro/SIMBAD/Client/WSQueryInterfaceService.pm view on Meta::CPAN
our $VERSION = '0.047';
## TRW ^^^^
my %methods = (
queryObjectById => {
## endpoint => 'http://simweb.u-strasbg.fr:8080/axis/services/WSQuery',
endpoint => 'axis/services/WSQuery',
soapaction => '',
namespace => 'http://uif.simbad.cds',
parameters => [
SOAP::Data->new(name => 'in0', type => 'soapenc:string', attr => {}),
SOAP::Data->new(name => 'in1', type => 'soapenc:string', attr => {}),
SOAP::Data->new(name => 'in2', type => 'soapenc:string', attr => {}),
], # end parameters
}, # end queryObjectById
queryObjectByBib => {
## endpoint => 'http://simweb.u-strasbg.fr:8080/axis/services/WSQuery',
endpoint => 'axis/services/WSQuery',
soapaction => '',
namespace => 'http://uif.simbad.cds',
parameters => [
SOAP::Data->new(name => 'in0', type => 'soapenc:string', attr => {}),
SOAP::Data->new(name => 'in1', type => 'soapenc:string', attr => {}),
SOAP::Data->new(name => 'in2', type => 'soapenc:string', attr => {}),
], # end parameters
}, # end queryObjectByBib
queryObjectByCoord => {
## endpoint => 'http://simweb.u-strasbg.fr:8080/axis/services/WSQuery',
endpoint => 'axis/services/WSQuery',
soapaction => '',
namespace => 'http://uif.simbad.cds',
parameters => [
SOAP::Data->new(name => 'in0', type => 'soapenc:string', attr => {}),
SOAP::Data->new(name => 'in1', type => 'soapenc:string', attr => {}),
lib/Astro/SIMBAD/Client/WSQueryInterfaceService.pm view on Meta::CPAN
## my $name = UNIVERSAL::isa($method => 'SOAP::Data') ? $method->name : $method;
my $name = eval {$method->isa('SOAP::Data')} ? $method->name : $method;
## TRW ^^^^
my %method = %{$methods{$name}};
## TRW vvvv
$method{endpoint} or Carp::croak "No server address (proxy) specified";
my $endpoint = $simbad->__build_url( $method{endpoint} );
## $self->proxy($method{endpoint} || Carp::croak "No server address (proxy) specified")
$self->proxy( $endpoint )
unless $self->proxy;
## TRW ^^^^
my @templates = @{$method{parameters}};
my @parameters = ();
## TRW foreach my $param (@_) {
lib/Astro/SIMBAD/Client/WSQueryInterfaceService.pm view on Meta::CPAN
} else {
push(@parameters, $param);
}
}
## TRW $self->endpoint($method{endpoint})
## TRW ->ns($method{namespace})
## TRW ->on_action(sub{qq!"$method{soapaction}"!});
## vvv TRW
if ($self->can ('ns')) {
$self->endpoint($endpoint)
->ns($method{namespace})
->on_action (sub{$method{soapaction}});
} else {
$self->endpoint($endpoint)
->envprefix ('soap')
->uri($method{namespace})
->on_action (sub{$method{soapaction}});
}
view all matches for this distribution
view release on metacpan or search on metacpan
lib/Async/Template.pm view on Meta::CPAN
tt $vars, << 'END',
USE timeout = Second;
AWAIT timeout.start(10)
r = AWAIT api.call('endpoint', {param = 'val'});
error = ERROR(r);
result = RESULT(r);
RETURN IF ERROR(r);
p2 = ASYNC some_async_fn('param');
p1 = ASYNC api.call('endpoint', {});
AWAIT p1;
AWAIT p2;
RETURN IF RESULT(r);
END
sub{
view all matches for this distribution
view release on metacpan or search on metacpan
=over
=item C<identifier> - required
Lexicon endpoint.
=item C<content>
This will be passed along to the endpoint as query parameters.
=back
On success, the content is returned. If the lexicon is known, the returned data is coerced into simple (blessed)
objects.
=over
=item C<identifier> - required
Lexicon endpoint.
=item C<content>
This will be passed along to the endpoint as encoded JSON.
=back
On success, the content is returned. If the lexicon is known, the returned data is coerced into simple (blessed)
objects.
view all matches for this distribution
view release on metacpan or search on metacpan
lib/Attean/Algebra.pm view on Meta::CPAN
use Types::Standard qw(ConsumerOf Bool);
use namespace::clean;
with 'Attean::API::Algebra', 'Attean::API::UnaryQueryTree', 'Attean::API::UnionScopeVariables';
has 'endpoint' => (is => 'ro', isa => ConsumerOf['Attean::API::TermOrVariable'], required => 1);
has 'silent' => (is => 'ro', isa => Bool, default => 0);
sub algebra_as_string {
my $self = shift;
my $endpoint = $self->endpoint->as_sparql;
chomp($endpoint);
return sprintf('Service %s', $endpoint);
}
sub tree_attributes { return qw(endpoint) };
sub sparql_tokens {
my $self = shift;
my $service = AtteanX::SPARQL::Token->keyword('SERVICE');
my $l = AtteanX::SPARQL::Token->lbrace;
lib/Attean/Algebra.pm view on Meta::CPAN
my @tokens;
push(@tokens, $service);
if ($self->silent) {
push(@tokens, AtteanX::SPARQL::Token->keyword('SILENT'));
}
push(@tokens, $self->endpoint->sparql_tokens->elements);
push(@tokens, $l);
push(@tokens, $child->sparql_subtokens->elements);
push(@tokens, $r);
return Attean::ListIterator->new( values => \@tokens, item_type => 'AtteanX::SPARQL::Token' );
}
view all matches for this distribution
view release on metacpan or search on metacpan
lib/AtteanX/Endpoint.pm view on Meta::CPAN
}
sub prepare_app {
my $self = shift;
my $config = $self->{config};
$self->{endpoint} = eval { AtteanX::Endpoint->new( $config ) };
if ($@) {
warn $@;
}
}
lib/AtteanX/Endpoint.pm view on Meta::CPAN
my $req = Plack::Request->new($env);
unless ($req->method =~ /^(GET|HEAD|POST)$/) {
return [ 405, [ 'Content-type', 'text/plain' ], [ 'Method not allowed' ] ];
}
my $ep = $self->{endpoint};
my $resp = $ep->run( $req );
return $resp->finalize;
}
}
lib/AtteanX/Endpoint.pm view on Meta::CPAN
use v5.14;
use Attean;
=head1 DESCRIPTION
The AtteanX::Endpoint class implements a PSGI SPARQL Protocol endpoint.
=head1 ATTRIBUTES
=over 4
lib/AtteanX/Endpoint.pm view on Meta::CPAN
=item C<< model >>
=item C<< conf >>
A hash reference containing configuration data for the endpoint. For example:
{
endpoint => {
service_description => {
named_graphs => 1,
default => 1,
},
html => {
lib/AtteanX/Endpoint.pm view on Meta::CPAN
sub _run {
my $self = shift;
my $req = shift;
my $config = $self->{conf};
my $endpoint_path = $config->{endpoint}{endpoint_path} || '/sparql';
my $model = $self->{model};
my $response = Plack::Response->new;
our $VERSION;
my $server = "AtteanX::Endpoint/$VERSION";
$server .= " " . $response->headers->header('Server') if defined($response->headers->header('Server'));
$response->headers->header('Server' => $server);
unless ($req->path eq $endpoint_path) {
my $content;
my $path = $req->path_info;
$path =~ s#^/##;
my $dir = $ENV{ATTEAN_ENDPOINT_SHAREDIR} || File::Spec->catdir((eval { dist_dir('AtteanX-Endpoint') } || 'share'), 'endpoint');
my $abs = File::Spec->rel2abs($dir);
my $file = File::Spec->catfile($abs, 'www', $path);
if (-r $file) {
open( my $fh, '<', $file ) or croak $!;
$response->status(200);
lib/AtteanX/Endpoint.pm view on Meta::CPAN
if ($req->method !~ /^(GET|POST)$/i) {
my $method = uc($req->method);
$content = "Unexpected method $method (expecting GET or POST)";
$self->log_error( $req, $content );
$response->header('Allow' => 'GET, POST');
die AtteanX::Endpoint::ClientError->new(code => 405, message => 'Method not allowed', uri => 'http://id.kasei.us/rdf-endpoint/error/bad_http_method');
} elsif (defined($ct) and $ct eq 'application/sparql-query') {
$sparql = $req->content;
} elsif (defined($ct) and $ct eq 'application/sparql-update') {
if ($config->{endpoint}{update} and $req->method eq 'POST') {
$sparql = $req->content;
}
} elsif ($req->param('query')) {
my @sparql = $req->param('query');
if (scalar(@sparql) > 1) {
$content = "More than one query string submitted";
$self->log_error( $req, $content );
die AtteanX::Endpoint::ClientError->new(code => 400, message => 'Multiple query strings not allowed', uri => 'http://id.kasei.us/rdf-endpoint/error/multiple_queries');
} else {
$sparql = $sparql[0];
}
} elsif ($req->param('update')) {
my @sparql = $req->param('update');
if (scalar(@sparql) > 1) {
$content = "More than one update string submitted";
$self->log_error( $req, $content );
die AtteanX::Endpoint::ClientError->new(code => 400, message => 'Multiple update strings not allowed', uri => 'http://id.kasei.us/rdf-endpoint/error/multiple_updates');
}
if ($config->{endpoint}{update} and $req->method eq 'POST') {
$sparql = $sparql[0];
} elsif ($req->method ne 'POST') {
my $method = $req->method;
$content = "Update operations must use POST";
$self->log_error( $req, $content );
$response->header('Allow' => 'POST');
die AtteanX::Endpoint::ClientError->new(code => 405, message => "$method Not Allowed for Update Operation", uri => 'http://id.kasei.us/rdf-endpoint/error/bad_http_method_update');
}
}
if ($sparql) {
my %args;
$args{ update } = 1 if ($config->{endpoint}{update} and $req->method eq 'POST');
$args{ load_data } = 1 if ($config->{endpoint}{load_data});
my $protocol_specifies_update_dataset = 0;
{
my @default = $req->param('default-graph-uri');
my @named = $req->param('named-graph-uri');
lib/AtteanX/Endpoint.pm view on Meta::CPAN
my $error = $@ || 'Internal error';
$self->log_error( $req, $error );
my $eclass = ($error =~ /Syntax/) ? 'AtteanX::Endpoint::ClientError' : 'AtteanX::Endpoint::ServerError';
if ($req->method ne 'POST' and $error =~ /read-only queries/sm) {
$error = 'Updates must use a HTTP POST request.';
die $eclass->new(message => 'Updates must use a HTTP POST request', uri => 'http://id.kasei.us/rdf-endpoint/error/bad_http_method_update');
} else {
die $eclass->new(message => 'SPARQL query/update parse error', uri => 'http://id.kasei.us/rdf-endpoint/error/parse_error', details => { error => $error, sparql => $sparql });
}
} else {
$self->log_query( $req, $sparql );
# TODO: handle case where query specifies update dataset
# if ($protocol_specifies_update_dataset and $query->specifies_update_dataset) {
# my $method = $req->method;
# $content = "Update operations cannot specify a dataset in both the query and with protocol parameters";
# $self->log_error( $req, $content );
# die AtteanX::Endpoint::ClientError->new(code => 400, message => 'Multiple datasets specified for update', uri => 'http://id.kasei.us/rdf-endpoint/error/update_specifies_multiple_datasets');
# }
if ($self->log->is_trace) {
$self->log->trace("Algebra:\n" . $algebra->as_string);
}
my $graph = $self->graph;
lib/AtteanX/Endpoint.pm view on Meta::CPAN
$response->headers->content_type($stype);
};
if ($@) {
my $error = $@;
$self->log->fatal($error);
die AtteanX::Endpoint::ServerError->new(code => 500, message => 'SPARQL query/update execution error', uri => 'http://id.kasei.us/rdf-endpoint/error/execution_error', details => { error => $@, sparql => $sparql });
}
}
} elsif ($req->method eq 'POST') {
$content = "POST without recognized query or update";
$self->log_error( $req, $content );
die AtteanX::Endpoint::ClientError->new(message => 'Missing SPARQL Query/Update String', uri => 'http://id.kasei.us/rdf-endpoint/error/missing_sparql_string');
} else {
my $stype = 'text/html';
my $dir = $ENV{ATTEAN_ENDPOINT_SHAREDIR} || File::Spec->catdir((eval { dist_dir('AtteanX-Endpoint') } || 'share'), 'endpoint');
my $template = File::Spec->catfile($dir, 'index.html');
my $parser = XML::LibXML->new(validation => 0, suppress_errors => 1, no_network => 1, recover => 2);
my $doc = $parser->parse_file( $template );
# my $gen = RDF::RDFa::Generator->new( style => 'HTML::Head');
# $gen->inject_document($doc, $sdmodel);
lib/AtteanX/Endpoint.pm view on Meta::CPAN
=back
=head1 BUGS
Please report any bugs or feature requests to through the GitHub web interface
at L<https://github.com/kasei/atteanx-endpoint/issues>.
=head1 SEE ALSO
L<http://www.perlrdf.org/>
view all matches for this distribution
view release on metacpan or search on metacpan
lib/AtteanX/Query/AccessPlan/Cache.pm view on Meta::CPAN
my $model = shift;
my $active_graphs = shift;
my $pattern = shift;
# First, add any plans coming from the original planner (which will
# include queries to the remote SPARQL endpoint
my @plans = $orig->(@params);
my @vars = $pattern->values_consuming_role('Attean::API::Variable');
my @varstrings = map { $_->value } @vars;
# Start checking the cache
view all matches for this distribution
view release on metacpan or search on metacpan
lib/AtteanX/RDFQueryTranslator.pm view on Meta::CPAN
my $s = $self->translate($a->start);
my $o = $self->translate($a->end);
my $path = $self->translate_path($a->path);
return Attean::Algebra::Path->new( subject => $s, path => $path, object => $o );
} elsif ($a->isa('RDF::Query::Algebra::Service')) {
my $endpoint = $self->translate($a->endpoint);
my $p = $self->translate($a->pattern);
return Attean::Algebra::Service->new( children => [$p], endpoint => $endpoint );
} elsif ($a->isa('RDF::Query::Algebra::NamedGraph')) {
my $graph = $self->translate($a->graph);
my $p = $self->translate($a->pattern);
return Attean::Algebra::Graph->new( children => [$p], graph => $graph );
} elsif ($a->isa('RDF::Query::Algebra::Filter')) {
view all matches for this distribution
view release on metacpan or search on metacpan
lib/AtteanX/Query/AccessPlan/LDF.pm view on Meta::CPAN
my $model = shift;
my $active_graphs = shift;
my $pattern = shift;
# First, add any plans coming from the original planner (which will
# include queries to the remote SPARQL endpoint
my @plans = $orig->(@params);
# Add my plans
push(@plans, AtteanX::Plan::LDF::Triple->new(subject => $pattern->subject,
predicate => $pattern->predicate,
object => $pattern->object,
view all matches for this distribution
view release on metacpan or search on metacpan
lib/AtteanX/Model/SPARQL.pm view on Meta::CPAN
AtteanX::Model::SPARQL - Attean SPARQL Model
=head1 SYNOPSIS
my $store = Attean->get_store('SPARQL')->new(endpoint_url => $url);
my $model = AtteanX::Model::SPARQL->new( store => $store );
=head1 DESCRIPTION
This model is in practice a thin wrapper around the underlying SPARQL
view all matches for this distribution
view release on metacpan or search on metacpan
t/30-utf8.t view on Meta::CPAN
my $test = Plack::Test->create($app);
my $json = JSON::MaybeXS->new->utf8->allow_nonref;
my $res = $test->request(POST "/faces");
ok $res->is_success, "request to endpoint succeeded";
is $json->decode($res->content), $faces, "request returned expected response";
done_testing;
view all matches for this distribution
view release on metacpan or search on metacpan
lib/Audio/Nama.pm view on Meta::CPAN
add_mark: _add_mark ident { Audio::Nama::drop_mark $item{ident}; 1}
add_mark: _add_mark { Audio::Nama::drop_mark(); 1}
next_mark: _next_mark { Audio::Nama::next_mark(); 1}
previous_mark: _previous_mark { Audio::Nama::previous_mark(); 1}
loop: _loop someval(s) {
my @new_endpoints = @{ $item{"someval(s)"}};
$Audio::Nama::mode->{loop_enable} = 1;
@{$Audio::Nama::setup->{loop_endpoints}} = (@new_endpoints, @{$Audio::Nama::setup->{loop_endpoints}});
@{$Audio::Nama::setup->{loop_endpoints}} = @{$Audio::Nama::setup->{loop_endpoints}}[0,1];
1;}
noloop: _noloop { $Audio::Nama::mode->{loop_enable} = 0; 1}
name_mark: _name_mark ident {$Audio::Nama::this_mark->set_name( $item{ident}); 1}
list_marks: _list_marks {
my $i = 0;
view all matches for this distribution
view release on metacpan or search on metacpan
#
# Authen::Challenge::Basic: Provides a trivial challenge/response protocol
# to assist in authentication tasks. It provides for time-window
# challenge/response sessions.
#
# Using this module, it's possible to autenticate both endpoints of
# a transaction provided that a shared-secret was exchanged prior to
# the session among the endpoints. As timestamps are part of the
# protocol, some restrictions can be applied to the timing, to help
# prevent hijacked connections.
#
# This is free software. You can use at will provided that proper
# credit is given to the author(s). This module requires MD5.
The following functions are provided by this class.
new()
Creates a new instance of a challenge/response endpoint. It has three
parameters that influence its behavior. Those can be seen next
$server = Authen::Challenge::Basic->new ('Secret' => 'known2us',
'Timeout' => 30,
'Sync' => 10);
view all matches for this distribution
view release on metacpan or search on metacpan
t/10-metadata.t view on Meta::CPAN
# Extract a bit of iCMS metadata
my $method = eval { $sp->_icms_method_data('Validate'); } || {};
is($@, '', "parsed iCMS config without error");
is($method->{url}, 'https://ws.test.logon.fakeme.govt.nz/icms/Validate_v1_1',
'got iCMS endpoint for FLT resolution');
done_testing();
view all matches for this distribution
view release on metacpan or search on metacpan
lib/Authen/Tcpdmatch/Tcpdmatch.pm view on Meta::CPAN
=back
=head2 LIMITATIONS
It does not support shell commands, client lookups, endpoint patterns, spoofing attacks,
and expansions. If these features are important to you,
perhaps you should be using libwarp.so with Authen::Libwrap .
=head2 EXPORT
view all matches for this distribution
view release on metacpan or search on metacpan
lib/Autodia/Diagram.pm view on Meta::CPAN
[% FOREACH inheritance = inheritances %]
[%- IF inheritance.Parent >0 AND inheritance.Child >0 -%]
<assocwidget totalcounta="2" indexa="1" totalcountb="2" indexb="1" widgetbid="[% inheritance.Parent %]" widgetaid="[% inheritance.Child %]" xmi.id="[% inheritance.Id %]" >
<linepath>
<startpoint startx="[% inheritance.left_x %]" starty="[% inheritance.top_y %]" />
<endpoint endx="[% inheritance.right_x %]" endy="[% inheritance.bottom_y %]" />
</linepath>
</assocwidget>
[%- END %]
[% END %]
[% SET dependencies = diagram.Dependancies %]
[% FOREACH dependency = dependencies %]
[%- IF dependency.Parent >0 AND dependency.Child >0 -%]
<assocwidget totalcounta="2" indexa="1" totalcountb="2" indexb="1" widgetbid="[% dependency.Parent %]" widgetaid="[% dependency.Child %]" xmi.id="[% dependency.Id %]" >
<linepath>
<startpoint startx="[% dependency.left_x %]" starty="[% dependency.top_y %]" />
<endpoint endx="[% dependency.right_x %]" endy="[% dependency.bottom_y %]" />
</linepath>
</assocwidget>
[%- END %]
[% END %]
</associations>
view all matches for this distribution
view release on metacpan or search on metacpan
lib/Avatica/Client.pm view on Meta::CPAN
// Generic metadata for the server to return with each response.
message RpcMetadata {
string server_address = 1; // The host:port of the server
}
// Message which encapsulates another message to support a single RPC endpoint
message WireMessage {
string name = 1;
bytes wrapped_message = 2;
}
view all matches for this distribution
view release on metacpan or search on metacpan
lib/Azure/AD/ClientCredentials.pm view on Meta::CPAN
default => sub {
'https://login.microsoftonline.com'
},
);
has token_endpoint => (
is => 'ro',
isa => Str,
lazy => 1,
default => sub {
my $self = shift;
lib/Azure/AD/ClientCredentials.pm view on Meta::CPAN
}
return if $self->expiration >= time;
my $auth_response = $self->ua->post_form(
$self->token_endpoint,
{
grant_type => 'client_credentials',
client_id => $self->client_id,
client_secret => $self->secret_id,
resource => $self->resource_id,
lib/Azure/AD/ClientCredentials.pm view on Meta::CPAN
A Key assigned to the Client Id.
=head2 ad_url
This defaults to C<https://login.microsoftonline.com>, and generally doesn't need to
be specified. Azure AD has more endpoints for some clouds:
C<https://login.chinacloudapi.cn> China Cloud
C<https://login.microsoftonline.us> US Gov Cloud
view all matches for this distribution
view release on metacpan or search on metacpan
lib/Azure/Storage/Blob/Client/Call.pm view on Meta::CPAN
package Azure::Storage::Blob::Client::Call;
use Moose::Role;
requires 'endpoint';
requires 'method';
requires 'operation';
sub serialize_uri_parameters {
my $self = shift;
view all matches for this distribution
view release on metacpan or search on metacpan
etc/bgp_monitor_2_00.xsd view on Meta::CPAN
<xsd:element name="BGP_MONITOR_MESSAGE" type="bgpm:bgp_monitor_message_type" />
<xsd:complexType name="bgp_monitor_message_type">
<xsd:sequence>
<xsd:element name="SOURCE" type="bgpm:endpoint_type" minOccurs="0" maxOccurs="1"/>
<xsd:element name="DEST" type="bgpm:endpoint_type" minOccurs="0" maxOccurs="1" />
<xsd:element name="MONITOR" type="bgpm:endpoint_type" minOccurs="1" maxOccurs="1"/>
<xsd:element name="RELAY" type="bgpm:endpoint_type" minOccurs="0" maxOccurs="1"/>
<xsd:element name="OBSERVED_TIME" type="bgpm:observed_time_type" minOccurs="1" maxOccurs="1" />
<xsd:element name="SEQUENCE_NUMBER" type="xsd:unsignedLong" minOccurs="1" maxOccurs="1"/>
<xsd:element name="COLLECTION" type="xsd:string" minOccurs="0" maxOccurs="1"/>
<xsd:element name="PARSE_ERROR" type="xfb:parse_error_type" maxOccurs="1" minOccurs="0" />
<xsd:choice minOccurs="1" maxOccurs="1">
etc/bgp_monitor_2_00.xsd view on Meta::CPAN
<xsd:element minOccurs="1" maxOccurs="1" name="NODE_PATH" type="xsd:string"/>
<xsd:element minOccurs="1" maxOccurs="1" name="ANNOTATION" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="endpoint_type">
<xsd:sequence>
<xsd:element name="ADDRESS" type="ne:network_address_type" />
<xsd:element name="PORT" type="ne:port_type" />
<xsd:choice minOccurs="1" maxOccurs="1">
<xsd:element name="ASN2" type="ne:asn2_type" />
view all matches for this distribution
view release on metacpan or search on metacpan
etc/bgp_monitor_2_00.xsd view on Meta::CPAN
<xsd:element name="BGP_MONITOR_MESSAGE" type="bgpm:bgp_monitor_message_type" />
<xsd:complexType name="bgp_monitor_message_type">
<xsd:sequence>
<xsd:element name="SOURCE" type="bgpm:endpoint_type" minOccurs="0" maxOccurs="1"/>
<xsd:element name="DEST" type="bgpm:endpoint_type" minOccurs="0" maxOccurs="1" />
<xsd:element name="MONITOR" type="bgpm:endpoint_type" minOccurs="1" maxOccurs="1"/>
<xsd:element name="RELAY" type="bgpm:endpoint_type" minOccurs="0" maxOccurs="1"/>
<xsd:element name="OBSERVED_TIME" type="bgpm:observed_time_type" minOccurs="1" maxOccurs="1" />
<xsd:element name="SEQUENCE_NUMBER" type="xsd:unsignedLong" minOccurs="1" maxOccurs="1"/>
<xsd:element name="COLLECTION" type="xsd:string" minOccurs="0" maxOccurs="1"/>
<xsd:element name="PARSE_ERROR" type="xfb:parse_error_type" maxOccurs="1" minOccurs="0" />
<xsd:choice minOccurs="1" maxOccurs="1">
etc/bgp_monitor_2_00.xsd view on Meta::CPAN
<xsd:element minOccurs="1" maxOccurs="1" name="NODE_PATH" type="xsd:string"/>
<xsd:element minOccurs="1" maxOccurs="1" name="ANNOTATION" type="xsd:string"/>
</xsd:sequence>
</xsd:complexType>
<xsd:complexType name="endpoint_type">
<xsd:sequence>
<xsd:element name="ADDRESS" type="ne:network_address_type" />
<xsd:element name="PORT" type="ne:port_type" />
<xsd:choice minOccurs="1" maxOccurs="1">
<xsd:element name="ASN2" type="ne:asn2_type" />
view all matches for this distribution
view release on metacpan or search on metacpan
lib/Backblaze/B2/v1/AnyEvent.pm view on Meta::CPAN
my( $self, %options) = @_;
$options{ method } ||= 'GET';
#my $completed = delete $options{ cb };
my $method = delete $options{ method };
my $endpoint = delete $options{ api_endpoint };
my $headers = delete $options{ headers } || {};
$headers = { $self->get_headers, %$headers };
my $body = delete $options{ _body };
my $url;
if( ! $options{url} ) {
croak "Don't know the api_endpoint for the request"
unless $endpoint;
$url = URI->new( join( "/b2api/v1/",
$self->apiUrl,
$endpoint)
);
} else {
$url = delete $options{ url };
$url = URI->new( $url )
if( ! ref $url );
lib/Backblaze/B2/v1/AnyEvent.pm view on Meta::CPAN
croak "Need a bucket name"
unless defined $options{ bucketName };
$options{ accountId } ||= $self->accountId;
$options{ bucketType } ||= 'allPrivate'; # let's be defensive here...
$self->json_request(api_endpoint => 'b2_create_bucket',
accountId => $options{ accountId },
bucketName => $options{ bucketName },
bucketType => $options{ bucketType },
%options
)
lib/Backblaze/B2/v1/AnyEvent.pm view on Meta::CPAN
croak "Need a bucketId"
unless defined $options{ bucketId };
$options{ accountId } ||= $self->accountId;
my $res = AnyEvent->condvar;
$self->json_request(api_endpoint => 'b2_delete_bucket',
accountId => $options{ accountId },
bucketId => $options{ bucketId },
%options
);
}
lib/Backblaze/B2/v1/AnyEvent.pm view on Meta::CPAN
sub list_buckets {
my( $self, %options ) = @_;
$options{ accountId } ||= $self->accountId;
$self->json_request(api_endpoint => 'b2_list_buckets',
accountId => $options{ accountId },
%options
)
}
lib/Backblaze/B2/v1/AnyEvent.pm view on Meta::CPAN
my( $self, %options ) = @_;
croak "Need a bucketId"
unless defined $options{ bucketId };
$self->json_request(api_endpoint => 'b2_get_upload_url',
%options
)
}
=head2 C<< $b2->upload_file >>
lib/Backblaze/B2/v1/AnyEvent.pm view on Meta::CPAN
croak "Need a bucket id"
unless defined $options{ bucketId };
$self->json_request(
api_endpoint => 'b2_list_file_names',
%options
);
}
=head2 C<< $b2->list_all_file_names >>
lib/Backblaze/B2/v1/AnyEvent.pm view on Meta::CPAN
unless defined $options{ fileNamePrefix };
croak "Need a duration for the token"
unless defined $options{ validDurationInSeconds };
$self->json_request(
api_endpoint => 'b2_get_download_authorization',
%options
);
}
view all matches for this distribution
view release on metacpan or search on metacpan
lib/Backblaze/B2V2Client.pm view on Meta::CPAN
return $self->{current_status};
}
# no need to proceed if we already have done for this bucket this during this session
# return if $self->{bucket_info}{$bucket_name}{upload_url};
# COMMENTED OUT: It seems like B2 wants a new upload_url endpoint for each upload,
# and we may want to upload multiple files into each bucket...so this won't work
# if we don't have the info for the bucket name, retrieve the bucket's ID
if (ref($self->{buckets}{$bucket_name}) ne 'HASH') {
$self->b2_list_buckets($bucket_name);
lib/Backblaze/B2V2Client.pm view on Meta::CPAN
# generic method to handle communication to B2
sub b2_talker {
my $self = shift;
# args hash must include 'url' for the target API endpoint URL
# most other requests will also include a 'post_params' hashref, and 'authorization' value for the header
# for the b2_upload_file function, there will be several other headers + a file_contents arg
my (%args) = @_;
if (!$args{url}) {
$self->error_tracker('Can not use b2_talker() without an endpoint URL.');
}
# if they sent an Authorization header, set that value
if ($args{authorization}) {
$self->{mech}->delete_header( 'Authorization' );
view all matches for this distribution
view release on metacpan or search on metacpan
lib/BankDetails/India.pm view on Meta::CPAN
print $fh $xml;
close($fh);
}
sub get_response {
my ($self, $endpoint, $ifsc) = @_;
return if ( !$self->ping_api || !defined $endpoint || length $endpoint <= 0);
$ifsc = uc($ifsc);
my $request_url = $endpoint.$ifsc;
my $cache_key = md5_hex(encode_sereal($ifsc));
my $response_data;
my $cache_response_data = $self->cache_data->get($cache_key);
if (defined $cache_response_data) {
$response_data = decode_sereal($cache_response_data);
lib/BankDetails/India.pm view on Meta::CPAN
=head3 api_url
The URL of the API resource is read only attribute.
# get the API endpoint.
$api->api_url;
=head3 cache_data
The cache engine used to cache the web service API calls. By default, it uses
lib/BankDetails/India.pm view on Meta::CPAN
# get cache engine.
$api->cache_data
=head2 ping_api()
Checks whether the API endpoint is currently up.
# Returns 1 if up or 0 if not.
$api->ping_api();
=head2 get_all_data_by_ifsc
view all matches for this distribution
view release on metacpan or search on metacpan
lib/Bb/Collaborate/V3/Connection.pm view on Meta::CPAN
use Elive;
use Elive::Util;
=head1 NAME
Bb::Collaborate::V3::Connection - Manage Collaborate SOAP V3 endpoint connections.
=head1 DESCRIPTION
This module handles logical connections to the C<.../webservice.event> endpoint
on the Collaborate server. This endpoint implements the Standard Bridge API.
=cut
our %KnownCommands = (
view all matches for this distribution
view release on metacpan or search on metacpan
share/SpamAssassin/easy_ham/00606.9733a34d34069bbc9671b0292068449d view on Meta::CPAN
very visible.
[1] That is to say, rates will
be exponential in the free
energy differences between
endpoints and a transition
state. We can ignore that
complication in this model.
view all matches for this distribution