view release on metacpan or  search on metacpan

lib/Catmandu/OCLC/xID.pm  view on Meta::CPAN

    my $method  = shift;

    die "usage: query(query,type,method)" unless defined $query &&
                                                       defined $type &&
                                                       defined $method;
    my $endpoint;

    if ($type eq 'xisbn') {
    	$endpoint = 'http://xisbn.worldcat.org/webservices/xid/isbn';
    }
    elsif ($type eq 'xissn') {
    	$endpoint = 'http://xisbn.worldcat.org/webservices/xid/issn';
    }
    elsif ($type eq 'xstandardNumber') {
   		$endpoint = 'http://xisbn.worldcat.org/webservices/xid/oclcnum';
    }
    else {
    	$endpoint = 'http://xisbn.worldcat.org/webservices/xid/isbn';
    }

    my $request  = sprintf "%s/%s?method=%s&format=json&fl=*"
                            , $endpoint
                            , uri_escape($query)
                            , $method;

    my $response = get($request);
    my $json     = JSON::MaybeXS->new->utf8(0);

 view release on metacpan or  search on metacpan

lib/Catmandu/Importer/Pure.pm  view on Meta::CPAN

our $VERSION = '0.05';

with 'Catmandu::Importer';

has base     => ( is => 'ro' );
has endpoint => ( is => 'ro' );
has path     => ( is => 'ro' );
has apiKey   => ( is => 'ro' );
has user     => ( is => 'ro' );
has password => ( is => 'ro' );
has post_xml => ( is => 'ro' );

lib/Catmandu/Importer/Pure.pm  view on Meta::CPAN

sub BUILD {
    my $self = shift;

    Catmandu::BadVal->throw("Base URL, endpoint and apiKey are required")
      unless $self->base && $self->endpoint && $self->apiKey;

    Catmandu::BadVal->throw( "Password is needed for user " . $self->user )
      if $self->user && !$self->password;

    Catmandu::BadVal->throw("Invalid filter, filter should be a CODE ref")

lib/Catmandu/Importer/Pure.pm  view on Meta::CPAN

}

sub _url {
    my ( $self, $options ) = @_;

    my $url = $self->base . '/' . $self->endpoint
        . ($self->path ? '/' . $self->path : '');

    if ($options && %$options) {
        $url .= '?' . join '&',
          map { "$_=" . uri_escape( $options->{$_}, "^A-Za-z0-9\-\._~," ) }

lib/Catmandu/Importer/Pure.pm  view on Meta::CPAN

    my @result_nodes;

    if ( $xc->exists('/result/items') ) {
        @result_nodes = $xc->findnodes('/result/items/*');
    } elsif ($self->endpoint eq 'changes') {
        @result_nodes = $xc->findnodes('/result/contentChange');
    } else {
        @result_nodes = $xc->findnodes('/result/*[@uuid]');
    };

lib/Catmandu/Importer/Pure.pm  view on Meta::CPAN

=head1 SYNOPSIS

  # From the command line
  $ catmandu convert Pure \
        --base https://host/ws/api/... \
        --endpoint research-outputs \
        --apiKey "..."

  # In Perl
  use Catmandu;

  my %attrs = (
    base     => 'https://host/path',
    endpoint => 'research-outputs',
    apiKey   => '...',
    options  => { 'fields' => 'title,type,authors.*' } 
  );

  my $importer = Catmandu->importer('Pure', %attrs);

lib/Catmandu/Importer/Pure.pm  view on Meta::CPAN

  # get number of validated and approved publications
  my $count = Catmandu->importer(
    'Pure',
    base         => 'https://host/path',
    endpoint     => 'research-outputs',
    apiKey       => '...',
    fullResponse => 1,
    post_xml => '<?xml version="1.0" encoding="utf-8"?>'
      . '<researchOutputsQuery>'
      . '<size>0</size>'

lib/Catmandu/Importer/Pure.pm  view on Meta::CPAN

  )->first->{count};

=head1 DESCRIPTION

Catmandu::Importer::Pure is a Catmandu package that seamlessly imports data from Elsevier's Pure system using its REST service.
In order to use the Pure Web Service you need an API key. List of all available endpoints and further documentation can currently
be found under /ws on a webserver that is running Pure. Note that this version of the importer is tested with Pure API version
5.18 and might not work with later versions.

=head1 CONFIGURATION

lib/Catmandu/Importer/Pure.pm  view on Meta::CPAN

=item base

Base URL for the REST service is required, for example 'http://purehost.com/ws/api/518'

=item endpoint

Valid endpoint is required, like 'research-outputs'

=item apiKey

Valid API key is required for access

=item path

Path after the endpoint 

=item user

User name if basic authentication is used

 view release on metacpan or  search on metacpan

lib/Catmandu/Fix/rdf_ldf_statements.pm  view on Meta::CPAN

    $perl;
}

=head1 NAME

Catmandu::Fix::rdf_ldf_statements - lookup an object into a LDF endpoint

=head1 SYNOPSIS

    # Replace a name with an array of matching VIAF records
    # name: "\"Einstein, Albert, 1879-1955\""

lib/Catmandu/Fix/rdf_ldf_statements.pm  view on Meta::CPAN

    # name:
    #   - http://viaf.org/viaf/75121530

=head1 DESCRIPTION

This L<Catmandu::Fix> can be used to find at a Linked Data Fragments endpoint
all subject URIs for which the object has a specific value found at a path. E.g.

   rdf_ldf_statements(name,url:"http://data.linkedatafragments.org/viaf")

 means, search at the endpoint http://data.linkedatafragments.org/viaf all the
 subjects for which the object is the value found in 'name', and replace the name value
 with all the found subjects.

=head1 ARGUMENTS

lib/Catmandu/Fix/rdf_ldf_statements.pm  view on Meta::CPAN

Optional predicate URI to be used in the LDF query

=item url

Required URL to the Linked Data Fragments endpoint

=back

=head1 SEE ALSO

 view release on metacpan or  search on metacpan

lib/Catmandu/Importer/Solr.pm  view on Meta::CPAN

    )->total();
}

=head1 NAME

Catmandu::Importer::Solr - Catmandu module to import data from a Solr endpoint

=head1 SYNOPSIS

    # From the command line
    $ catmandu convert Solr --url "http://localhost:8983/solr" --query "type:book"

 view release on metacpan or  search on metacpan

lib/Catmandu/Fix/aat_match.pm  view on Meta::CPAN

      -lang: nl
  )

=head1 DESCRIPTION

Perform a direct match between a term and the L<SPARQL endpoint|http://vocab.getty.edu/sparql> of the AAT.
This fix will attempt to find a I<Subject> for which the I<prefLabel> in I<lang> (optional, default C<nl>)
equals the term. Will return a single item if one is found, or an empty hash if none was found.

Returns the following data:

 view release on metacpan or  search on metacpan

lib/Catmandu/Store/REST.pm  view on Meta::CPAN

=encoding utf-8

=head1 NAME

Catmandu::Store::REST - Store/retrieve items from a JSON REST-API endpoint

=head1 SYNOPSIS

  # From the command line
  $ catmandu export REST --id 1234 --base_url https://www.example.org/api/v1/books --query_string /page/1 to YAML

lib/Catmandu/Store/REST.pm  view on Meta::CPAN

=over

=item C<base_url>

base url of the API endpoint (the entire url before the ID) (e.g. I<https://www.example.org/api/v1/books>).

=item C<query_string>

an optional query string that comes behind the ID (e.g. I</page/1> where the complete URL is
I<https://www.example.org/api/v1/books/1/page/1>).

 view release on metacpan or  search on metacpan

cpanfile  view on Meta::CPAN

};

requires 'Catmandu', '>=0.9,!=0.9402,!=0.9401';
requires 'WWW::Zotero', '>=0.03';

# Need recent SSL to talk to https endpoint correctly
requires 'IO::Socket::SSL', '>=1.993';

 view release on metacpan or  search on metacpan

MANIFEST  view on Meta::CPAN

t/001_parse/ec2_volume.res
t/001_parse/ec2_volume2.res
t/001_parse/ec2_volumeattachment.res
t/001_parse/ec2_vpc.res
t/001_parse/ec2_vpc_dhcp_options.res
t/001_parse/ec2_vpc_endpoint.res
t/001_parse/ec2_vpc_gw_attach.res
t/001_parse/ec2_vpc_gw_vpn.res
t/001_parse/ec2_vpccidrblock.res
t/001_parse/ec2_vpn_conn.res
t/001_parse/ec2_vpn_gw.res

 view release on metacpan or  search on metacpan

lib/Chart/Plotly/Trace/Scatter.pm  view on Meta::CPAN

has fill => (
    is            => "rw",
    isa           => enum( [ "none", "tozeroy", "tozerox", "tonexty", "tonextx", "toself", "tonext" ] ),
    documentation =>
      "Sets the area to fill with a solid color. Defaults to *none* unless this trace is stacked, then it gets *tonexty* (*tonextx*) if `orientation` is *v* (*h*) Use with `fillcolor` if not *none*. *tozerox* and *tozeroy* fill to x=0 and y=0 respect...
);

has fillcolor => (
    is            => "rw",
    isa           => "Str",

lib/Chart/Plotly/Trace/Scatter.pm  view on Meta::CPAN

=item * error_y

=item * fill

Sets the area to fill with a solid color. Defaults to *none* unless this trace is stacked, then it gets *tonexty* (*tonextx*) if `orientation` is *v* (*h*) Use with `fillcolor` if not *none*. *tozerox* and *tozeroy* fill to x=0 and y=0 respectively. ...

=item * fillcolor

Sets the fill color. Defaults to a half-transparent variant of the line color, marker color, or marker line color, whichever is available.

 view release on metacpan or  search on metacpan

t/Chef/REST/cookbooks.t  view on Meta::CPAN

              'chef_client_name' => '',
              'chef_version' => '',
          );

# list cookbooks
# endpoint /cookbooks
#diag Dumper $obj->cookbooks->list;

#endpoint /cookbook/yum
#diag Dumper $obj->cookbooks('yum','_latest')->details->attributes;
diag Dumper $obj->cookbooks('yum','_latest')->details->recipes;

#diag Dumper $obj->environments( $environment_name )->details;

# endpoint POST /environments/<env_name>/cookbooks_versions
# post data run_list => [ <cookbook>@<cookbook_version> , .. ]
#___ TESTING not complete ____
#diag Dumper $obj->environments( $environment_name
#                              ,'cookbooks_versions'
#                              , {

 view release on metacpan or  search on metacpan

lib/Chess/Board.pm  view on Meta::CPAN

Takes a single scalar parameter containing the square to calculate distance
from. Returns the vertical distance in squares between the two points.

=item squares_in_line()

Takes two scalar parameters containing two distinct endpoints in a line.
Returns a list of scalars in lower-case with an entry for each square in that
line, or C<undef> if the two endpoints do not define a line. In the case where
both squares are the same, will return a list containing that square.

=back

=head2 Object methods

lib/Chess/Board.pm  view on Meta::CPAN

identical to the caller object. However, it is a I<deep copy> which allows
the clone()'d object to be manipulated separately of the caller object.

=item line_is_open()

Takes two scalar arguments, valid squares defining the endpoints of a line
on the Chess::Board. Returns true if there are no pieces on either of the
endpoints, or on any of the intervening squares. Returns false if the line
is blocked by one or more pieces, and C<undef> if the two squares do not
define endpoints of a line. In the case where both squares are equal, will
return true if the square is empty and false otherwise.

=item get_piece_at()

Takes a single scalar argument containing the square to retrieve the piece

 view release on metacpan or  search on metacpan

bin/aclmaker.pl  view on Meta::CPAN

xxxx-yyyy, or a comma separated list of any combination of those. The valid
range is 0-65535.

=item * dst_addr

As with src_addr but for the destination endpoint.

=item * dst_port

As with src_port but tor the destination endpoint.

=item * protocol

The protocol for the ACL. One of C<tcp>, C<udp> or C<ip>. For compatibility
the value C<both> is interpreted as C<ip>.

 view release on metacpan or  search on metacpan

t/autodb.020.graph/graph.010.01.thaw_nodes.t  view on Meta::CPAN

    $ok&&=_cmp_thawed(\@all_actual_objects,\@correct_thawed,
		      "$label thawed edges",__FILE__,__LINE__);
  }
  report_pass($ok,"$label thawed edges");

  # check edges' nodes (aka endpoints) - nodes should all be thawed already
  my @actual_ends=map {@{$_->nodes}} @actual_edges;
  cmp_thawed(\@actual_ends,\@actual_nodes,"$label thawed edge endpoints");

  local $SIG{__WARN__}=sub {warn @_ unless $_[0]=~/^Deep recursion/;};
  local $DB::deep=0;

  # test contents the usual way. 

 view release on metacpan or  search on metacpan

eg/clickhouse_replication.pl  view on Meta::CPAN

use File::Temp qw(tempfile);

my ($src_table, $dst_table) = @ARGV;
die "Usage: $0 <src_table> <dst_table>\n" unless $src_table && $dst_table;

my $src_endpoint = $ENV{CH_SRC} // 'localhost:8123';
my $dst_endpoint = $ENV{CH_DST} // 'localhost:8123';
my $src_url = "http://$src_endpoint/";
my $dst_url = "http://$dst_endpoint/";
my $where   = $ENV{SQL_FILTER};

my ($dst_host, $dst_port) = split /:/, $dst_endpoint, 2;
$dst_port //= 8123;

# Validate the destination schema against the actual destination server
# (not localhost). We don't use the encoder for the data path -- rows go
# server-to-server as Native bytes.

 view release on metacpan or  search on metacpan

lib/Color/Spectrum/Multi.pm  view on Meta::CPAN

    # take the first colour waypoint off:
    my $startpoint = shift @points;
    
    # How many steps do we get between each waypoint?
    my $substeps = int($steps / scalar @points);
    while(my $endpoint = shift @points) {
        if (@points == 0) {
            # there's no more points left... make sure we don't fall short
            # on the number of steps:
            if (($steps_used + $substeps) != $steps) {
                $substeps = $steps - $steps_used;

lib/Color/Spectrum/Multi.pm  view on Meta::CPAN

        # Since we start from the last colour of the previous fade, if this
        # isn't the first fade, we want to generate one extra colour, and drop
        # the first (otherwise, we'd duplicate colours)
        my @colour_set = 
            Color::Spectrum::generate(
                $steps_used ? $substeps+1 : $substeps, $startpoint,$endpoint
            );
        push @colours, $steps_used ? @colour_set[1..$substeps] : @colour_set;

        # next fade will start from last colour of this fade:
        $startpoint = $endpoint; 
                                
        $steps_used += $substeps;
    }
    return @colours;
}

 view release on metacpan or  search on metacpan

t/app/Plack/Component.t  view on Meta::CPAN

__END__

=head1 NAME

Plack::Component - Base class for PSGI endpoints

=head1 SYNOPSIS

  package Plack::App::Foo;
  use parent qw( Plack::Component );

 view release on metacpan or  search on metacpan

examples/04-session-management.pl  view on Meta::CPAN

    use Concierge::Auth;
    
    my $auth = Concierge::Auth->new({file => '/secure/path/users.db'});
    my %sessions;  # In production: use database/cache
    
    # Login endpoint
    sub handle_login {
        my ($username, $password) = @_;
        
        my ($success, $token) = create_session($username, $password);
        if ($success) {

 view release on metacpan or  search on metacpan

lib/Config/Model/models/Systemd/Section/Socket.pl  view on Meta::CPAN

        'cargo' => {
          'type' => 'leaf',
          'value_type' => 'uniline'
        },
        'description' => 'Specifies a L<USB
FunctionFS|https://docs.kernel.org/usb/functionfs.html> endpoints location to listen on, for
implementation of USB gadget functions. This expects an
absolute file system path of a FunctionFS mount point as the argument.
Behavior otherwise is very similar to the C<ListenFIFO>
directive above. Use this to open the FunctionFS endpoint
C<ep0>. When using this option, the
activated service has to have the
C<USBFunctionDescriptors> and
C<USBFunctionStrings> options set.
',

 view release on metacpan or  search on metacpan

bin/config-resolver.pl  view on Meta::CPAN

This is the mechanism you use to pass options to your plugins.

Example:

 --plugin ssm:endpoint_url=http://localhost:4566

=item -V, --parameters

You can supply key/value pairs at the command line to do simple
templating operations.

bin/config-resolver.pl  view on Meta::CPAN

=back

=head2 Plugin Configuration

Many plugins, like C<ssm>, require configuration (e.g., the AWS
region, or a custom endpoint for local testing). You can provide this
configuration in two ways, which are layered:

=head3 1. The RC File (Defaults)

On startup, the script will attempt to load a configuration file from:

bin/config-resolver.pl  view on Meta::CPAN

B<Example C<~/.config-resolverrc>:>

 {
   "ssm": {
     "region": "us-east-1",
     "endpoint_url": "http://localhost:4566"
   },
   "another_plugin": {
     "foo": "bar"
   }
 }

bin/config-resolver.pl  view on Meta::CPAN

B<Example:>

  config-resolver.pl \
      --plugin ssm:region=us-west-2 \
      --plugin ssm:endpoint_url=http://localhost:4566 \
      -t my-template.tpl

The script merges these two sources, giving command-line options final
priority, and passes the result to the resolver engine.

bin/config-resolver.pl  view on Meta::CPAN

In your plugin's documentation, define the keys a user must set in
their C<.config-resolverrc> file .

  # In .config-resolverrc
  [plugin ssm]
    endpoint_url = http://localhost:4566
    
    # --- Keys for your one-time setup ---
    seed_file = /opt/my-app/localstack-seed.json
    load_on_init = false # <-- Default to false!

 view release on metacpan or  search on metacpan

lib/Confluence/Client/XMLRPC.pm  view on Meta::CPAN

The package uses the L<RPC::XML> module to do the heavy lifting. Read the 
perldoc for this package to learn more.

L<RPC::XML> uses LWP for handling C<http>/C<https> messaging. If you are 
experiencing problems when connecting to a C<https> based API endpoint,
please make sure that the necessary modules - like, e.g. 
L<LWP::Protocol::https> - are installed.

For further information on the Confluence API itself please refer to the 
L<official documentation|https://developer.atlassian.com/display/CONFDEV/Confluence+XML-RPC+and+SOAP+APIs>

 view release on metacpan or  search on metacpan

lib/Confman/API.pm  view on Meta::CPAN

  my $self = shift;
  $self->{secret} = shift if scalar(@_) > 0;
  return $self->{secret};
}

sub endpoint_url {
  my $self = shift;
  $self->{endpoint_url} = shift if scalar(@_) > 0;
  return $self->{endpoint_url};
}

sub load_config {
  my $self = shift;
  my $config_path = shift || $self->config_path;

lib/Confman/API.pm  view on Meta::CPAN

    'Content-type' => 'application/json',
    Authorization => 'Basic ' . encode_base64($self->api_key . ':' . "$secret_hash:$timestamp"),
    HTTP_CLOUD_META => $cloud_meta
  };

  $client->setHost($self->endpoint_url);
  $client->request($method, $path, $body, $headers);

  my $response;
  if($client->responseCode eq '200') {
    $response = $self->json->decode($client->responseContent());

 view release on metacpan or  search on metacpan

lib/Connector/Iterator.pm  view on Meta::CPAN

Connector::Iterator

=head1 Description

Helper to perform a I<set> operation over a list of connector endpoints
while handing errors individually for each connector. The return value
is a hashref with the processed target names as key and an empty value
if no errors occured and the exception message if the target failed. You
must set I<skip_on_error> to enable handling of expcetions, otherwise 
they just bubble up and terminate execution of the loop. 

 view release on metacpan or  search on metacpan

lib/Consul.pm  view on Meta::CPAN

=item *

C<timeout>

Request timeout. If a request to Consul takes longer that this, the endpoint
method will fail (default: 15).

=item *

C<token>

lib/Consul.pm  view on Meta::CPAN

=item *

C<args>

A hashref containing the original arguments passed in to the endpoint method.

=back

The C<callback> function should be called with a C<Consul::Response> object
containing the values returned by the Consul server in response to the request.

lib/Consul.pm  view on Meta::CPAN

Consul itself provides a default C<request_cb> that uses L<HTTP::Tiny> to make
calls to the server. If you provide one, you should honour the value of the
C<timeout> argument.

C<request_cb> can be used in conjunction with the C<cb> option to all API method
endpoints to get asynchronous behaviour. It's recommended however that you
don't use this directly, but rather use a module like L<AnyEvent::Consul> to
take care of that for you.

If you just want to use this module to make simple calls to your Consul
cluster, you can ignore this option entirely.

lib/Consul.pm  view on Meta::CPAN

=back

=head1 ENDPOINTS

Individual API endpoints are implemented in separate modules. The following
methods will return a context objects for the named API. Alternatively, you can
request an API context directly from the Consul package. In that case,
C<Consul-E<gt>new> is called implicitly.

    # these are equivalent

lib/Consul.pm  view on Meta::CPAN

System status API. See L<Consul::API::Status>.

=head1 METHOD OPTIONS

All API methods implemented by the endpoints can take a number of arguments.
Most of those are documented in the endpoint documentation. There are however
some that are common to all methods:

=over 4

=item *

lib/Consul.pm  view on Meta::CPAN

=back

=head1 BLOCKING QUERIES

Some Consul API endpoints support a feature called a "blocking query". These
endpoints allow long-polling for changes, and support some extra information
about the server state, including the Raft index, in the response headers.

The corresponding endpoint methods, when called in array context, will return a
second value. This is an object with three methods, C<index>, C<last_contact>
and C<known_leader>, corresponding to the similarly-named header fields. You
can use these to set up state watches, CAS writes, and so on.

See the Consul API docs for more information.

 view release on metacpan or  search on metacpan

examples/fatpacked.plackup  view on Meta::CPAN

  The Plack::Middleware:: modules in the core distribution are good examples
  of such modules. It is recommended that you inherit from L<Plack::Middleware>
  for these types of modules.
  
  Not all middleware components are wrappers, but instead are more like
  endpoints in a middleware chain. These types of components should use the
  Plack::App:: namespace. Again, look in the core modules to see excellent
  examples of these (L<Plack::App::File>, L<Plack::App::Directory>, etc.).
  It is recommended that you inherit from L<Plack::Component> for these
  types of modules.
  

examples/fatpacked.plackup  view on Meta::CPAN

  
  __END__
  
  =head1 NAME
  
  Plack::Component - Base class for PSGI endpoints
  
  =head1 SYNOPSIS
  
    package Plack::App::Foo;
    use parent qw( Plack::Component );

 view release on metacpan or  search on metacpan

lib/Convos/public/packed/https___platform_twitter_com_widgets_js.js  view on Meta::CPAN

!function(){function provide(t,e){e(function(e){modules[t]=e})}function using(){for(var t,e=Array.prototype.slice.call(arguments,0,-1),i=0,n=[],r=arguments[arguments.length-1];t=e[i];i++){if(!modules[t])throw"[TWITTER] Module dependency missing: "+t;...
}function u(t){this.transportMethod="Fallback",this.options=t,this._createChild()}var l,c="__ready__",d=0;o.prototype=new e.Connection,i.aug(o.prototype,{_createChild:function(){this.options.window?this._createWindow():this._createIframe()},_createIf...
}var n={"embed/timeline.css":{"default":"embed/timeline.3fb0c4c981cd3f8f8dfb6b0ab93d6a9e.default.css","2x":"embed/timeline.3fb0c4c981cd3f8f8dfb6b0ab93d6a9e.2x.css",gif:"embed/timeline.3fb0c4c981cd3f8f8dfb6b0ab93d6a9e.gif.css","default.rtl":"embed/tim...
}),x=[])},e.afterLoad(y.fetchAndRender),t(y)})}),provide("dom/textsize",function(t){function e(t,e,i){for(var n,r=[],o=0;n=i[o];o++)r.push(n[0]),r.push(n[1]);return t+e+r.join(":")}function i(t){var e=t||"";return e.replace(/([A-Z])/g,function(t){ret...

 view release on metacpan or  search on metacpan

lib/Cookies/Roundtrip.pm  view on Meta::CPAN

# Convenience method to load any kind of cookies
# or a cookies file, into the LWP::UserAgent
# it returns the $ffmar's cookies on success or undef on failure
# NOTE: firefox marionette will not load cookies unless we visit the site
# of the cookie domain. However, some sites redirect you if you
# do not ask for a full-path endpoint URL (e.g. www.abc.com/a/b/c
# instead of cookie domain www.abc.com. If you visit www.abc.com
# it may take you to cy.abc.com)
# So, parameter $visit_cookie_domain_first controls this
# if it is undef, then no visit is made,
# if '' (empty string) then it goes to the domain https://www.abc.com above

lib/Cookies/Roundtrip.pm  view on Meta::CPAN

# It takes in the $ffmar, $filename and, optionally $verbosity (integer),
# and returns back the $ffmar's cookie jar (as HTTP::CookieJar object)
# It returns undef on failure.
# NOTE: firefox marionette will not load cookies unless we visit the site
# of the cookie domain. However, some sites redirect you if you
# do not ask for a full-path endpoint URL (e.g. www.abc.com/a/b/c
# instead of cookie domain www.abc.com. If you visit www.abc.com
# it may take you to cy.abc.com)
# So, parameter $visit_cookie_domain_first controls this
# if it is undef, then no visit is made,
# if '' (empty string) then it goes to the domain https://www.abc.com above

lib/Cookies/Roundtrip.pm  view on Meta::CPAN

# It takes in the $ffmar, $httpcookies and, optionally $verbosity (integer),
# and returns back the $ffmar's cookie jar (as HTTP::CookieJar object)
# It returns undef on failure.
# NOTE: firefox marionette will not load cookies unless we visit the site
# of the cookie domain. However, some sites redirect you if you
# do not ask for a full-path endpoint URL (e.g. www.abc.com/a/b/c
# instead of cookie domain www.abc.com. If you visit www.abc.com
# it may take you to cy.abc.com)
# So, parameter $visit_cookie_domain_first controls this
# if it is undef, then no visit is made,
# if '' (empty string) then it goes to the domain https://www.abc.com above

lib/Cookies/Roundtrip.pm  view on Meta::CPAN

# set $visit_cookie_domain_first to false in order not to visit (that means you are sure
# you are there already, otherwise this call will fail).
# Default is to visit first.
# NOTE: firefox marionette will not load cookies unless we visit the site
# of the cookie domain. However, some sites redirect you if you
# do not ask for a full-path endpoint URL (e.g. www.abc.com/a/b/c
# instead of cookie domain www.abc.com. If you visit www.abc.com
# it may take you to cy.abc.com)
# So, parameter $visit_cookie_domain_first controls this
# if it is undef, then no visit is made,
# if '' (empty string) then it goes to the domain https://www.abc.com above

lib/Cookies/Roundtrip.pm  view on Meta::CPAN

# It takes in the $ffmar, $httpcookies and, optionally $verbosity (integer),
# and returns back the $ffmar's cookie jar (as array of Firefox::Marionette::Cookie object)
# It returns undef on failure.
# NOTE: firefox marionette will not load cookies unless we visit the site
# of the cookie domain. However, some sites redirect you if you
# do not ask for a full-path endpoint URL (e.g. www.abc.com/a/b/c
# instead of cookie domain www.abc.com. If you visit www.abc.com
# it may take you to cy.abc.com)
# So, parameter $visit_cookie_domain_first controls this
# if it is undef, then no visit is made,
# if '' (empty string) then it goes to the domain https://www.abc.com above

lib/Cookies/Roundtrip.pm  view on Meta::CPAN

# first cloned and then into $ffmar.
# So the input $httpcookiejar will be independent of the one in $ffmar.
# It returns undef on failure.
# NOTE: firefox marionette will not load cookies unless we visit the site
# of the cookie domain. However, some sites redirect you if you
# do not ask for a full-path endpoint URL (e.g. www.abc.com/a/b/c
# instead of cookie domain www.abc.com. If you visit www.abc.com
# it may take you to cy.abc.com)
# So, parameter $visit_cookie_domain_first controls this
# if it is undef, then no visit is made,
# if '' (empty string) then it goes to the domain https://www.abc.com above

 view release on metacpan or  search on metacpan

ChangeLog  view on Meta::CPAN

	Improvements:
	- implemented pagination with $result->nextPage (untested)
	- many documentation fixes
	- make cross-reference page available.
	- add cross-reference table Couch::DB -> endpoint

version 0.001: Wed 29 May 18:19:12 CEST 2024

	- initial release, interface complete but mainly untested.

 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

 view release on metacpan or  search on metacpan

lib/Crypt/EAMessage.pm  view on Meta::CPAN

This will output a random key in hex format suitable for use as an AES256 key.

=head1 SECURITY

Note that this module use L<Storable>. Thus this module should only be used
when the endpoint is trusted. This module will ensure that the stored
object is received without tampering by an intermediary (and is secure even
when an untrusted third party can modify the encrypted message in transit),
because C<thaw> is not called unless the message passes authentication
checks.  But if an endpoint can create a malicious message using a valid
key, it is possible that this message could exploit some vulnerability in
the L<Storable> module.

This module does not protect against replay attacks.

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

        - Alternative certificates support.

0.36    27 June 2020
        - Updates to reflect support for other ACME-compatible CAs/servers.
        - Disabling Let's Encrypt specific shortcut when custom servers are used.
        - Support for custom ACME servers with custom named directory endpoints.
        - Support for custom ACME servers using older specifications.
        - Multi-webroot fix.
        - Documentation update.
        - Dockerfile and examples update.