view release on metacpan or search on metacpan
examples/babel.pl view on Meta::CPAN
# open and possibly create AutoDB database
my %db_params=(create=>$OPTIONS{create},database=>$OPTIONS{database},host=>$OPTIONS{host},
user=>$OPTIONS{user},password=>$OPTIONS{password});
my $autodb=new Class::AutoDB(%db_params);
unless ($autodb->is_connected) {
my $errstr='Cannot connect to AutoDB database using supplied credentials: '.
join(', ',map {"$_=$OPTIONS{$_}"} (qw(database host user password)));
confess $errstr;
}
# set autodb class attribute in Babel
view release on metacpan or search on metacpan
lib/Data/Downloader/Feed.pm view on Meta::CPAN
my ($xp,$context,$xpath) = @_;
my $xpc = XML::LibXML::XPathContext->new($context);
$xpc->registerNs(default => $defaultNamespaceURI) if $defaultNamespaceURI;
my $value = $xpc->findvalue($xpath);
TRACE "got $value from $xpath";
LOGDIE "Got 'Bad credentials' for feed ".$self->name if $value && $value eq "Bad credentials";
return $value;
}
sub _make_unique_filename {
my $self = shift;
lib/Data/Downloader/Feed.pm view on Meta::CPAN
Refreshing a feed may also :
- remove files which are now obolete (because the feed has a urn for a different file)
- update the symlinks for files whose metadata has changed
Also if both "user" and "password" are passed, they are treated specially
and sent as HTTP Basic auth credentials for the rss feed.
=cut
sub refresh {
my $self = shift;
view release on metacpan or search on metacpan
lib/Data/Mirror.pm view on Meta::CPAN
=head2 $UA
This is an L<LWP::UserAgent> object used to retrieve remote resources. You
may wish to use this variable to configure various aspects of its behaviour,
such as credentials, user agent string, TLS options, etc.
=head2 $JSON
This is a L<JSON::XS> object used for JSON decoding. You may wish to use this
variable to change how it processes JSON data.
view release on metacpan or search on metacpan
scripts/passphrase-test view on Meta::CPAN
use Readonly;
use Test::More;
Readonly my $DEFAULT_RULES_FILE => '/etc/passphrase_rules';
# subclass of LWP::UserAgent that grabs credentials
my $Username = $ENV{LOGNAME};
my $Password;
package MyAgent;
use base qw(LWP::UserAgent);
sub get_basic_credentials { ($Username, $Password) };
package main;
# parse command line
my ($debug, $help, $location);
my $file = $DEFAULT_RULES_FILE;
view release on metacpan or search on metacpan
share/dictionary.txt view on Meta::CPAN
creatures
credence
credence's
credential
credential's
credentials
credenza
credenza's
credenzas
credibility
credibility's
view release on metacpan or search on metacpan
lib/Data/Password/zxcvbn/RankedDictionaries/English.pm view on Meta::CPAN
'creations' => 3051,
'creatively' => 17321,
'creature' => 1948,
'creatures' => 2868,
'credence' => 12853,
'credentials' => 4343,
'credenza' => 18359,
'credibility' => 4342,
'credible' => 7015,
'credit' => 945,
'credo' => 13306,
view release on metacpan or search on metacpan
lib/Data/Random/Contact/Language/EN.pm view on Meta::CPAN
creatures
credence
credence's
credential
credential's
credentials
credenza
credenza's
credenzas
credibility
credibility's
view release on metacpan or search on metacpan
lib/Data/TagDB/Tutorial/Conventions.pod view on Meta::CPAN
In contrast an entity (natural or legal) should have roles including
C<entity> (C<09ade47e-b049-436b-bf10-8357f4b6bc05>).
Entities also include some amount of profile data. However this should be limited
to such data that is directly linked to the entity and is valid indefinitely
(e.g. names, cultural background, locations, and important events).
An entity never contain any technical data such as login credentials.
Such data is a clear sign that it is in fact an account.
Legal entities are entities that are created by legal means. Most commonly
companies. In order for them to be legal entities registration and legal
documentation is needed.
view release on metacpan or search on metacpan
lib/Data/Transpose/PasswordPolicy.pm view on Meta::CPAN
=head1 SYNOPSIS
use Data::Transpose::PasswordPolicy;
my %credentials = (username => "marco",
password => "My.very.very.5strong.pzwd"
);
my $pv = Data::Transpose::PasswordPolicy->new(\%credentials)
if (my $password = $pv->is_valid) {
print "$password is OK";
}
else {
lib/Data/Transpose/PasswordPolicy.pm view on Meta::CPAN
=head1 METHODS
=cut
=head2 new(%credentials)
Create a new Data::Transpose::PasswordPolicy object using the
credentials provided to the constructor.
=cut
has username => (is => 'rw',
isa => Str);
view release on metacpan or search on metacpan
lib/Database/Abstraction.pm view on Meta::CPAN
The C<directory> argument exists on disk but is not a directory.
=item C<< I<Class>: cannot connect: I<$DBI::errstr> >>
DBI failed to connect to the given C<dsn>. Check credentials and host.
=item C<< Can't find a file called 'I<name>' for the table I<T> in I<dir> >>
None of the probe extensions (C<.sql>, C<.sqlite>, C<.sqlite3>, C<.psv>, C<.tsv>, C<.csv>, C<.xlsx>, C<.db>, C<.xml>)
matched in C<directory>.
view release on metacpan or search on metacpan
lib/Database/BI.pm view on Meta::CPAN
# any frame it holds, but writing to the clipboard, which the Copy link
# buttons do. Only names Chromium knows: it logs an error for any other.
Readonly my @PERMISSIONS_DENIED => qw(
accelerometer autoplay browsing-topics camera clipboard-read display-capture
encrypted-media fullscreen gamepad geolocation gyroscope hid
identity-credentials-get idle-detection local-fonts magnetometer microphone
midi otp-credentials payment picture-in-picture publickey-credentials-create
publickey-credentials-get screen-wake-lock serial storage-access usb
window-management xr-spatial-tracking
);
Readonly my $DEFAULT_PERMISSIONS_POLICY =>
join(', ', (map { "$_=()" } @PERMISSIONS_DENIED), 'clipboard-write=(self)');
lib/Database/BI.pm view on Meta::CPAN
=head2 Which addresses it may fetch
C</import> and a C<url:> data source make the server fetch a URL, so a page
could point it at what only the server can reach: a service on this machine, a
database on the office network, or a cloud's metadata service on
C<169.254.169.254>, which hands out its credentials. So the server refuses a
URL that leads to this machine, a private or shared network
(C<10.0.0.0/8>, C<172.16.0.0/12>, C<192.168.0.0/16>, C<100.64.0.0/10>,
C<fc00::/7>), link-local addresses, multicast or a reserved range.
It is what the name I<resolves to> that counts, not how the URL reads:
lib/Database/BI.pm view on Meta::CPAN
view_combines => [ grep { /\A(?:path|table|url|redis|mariadb):/i } @{ $c->every_param('c') } ],
view_dedup => ($c->param('d') ? 1 : 0),
# lk=/nolk= turn a stored lookup on or off for this view, as name=value
# pairs so the macro can write them back in the order they came.
view_lookups => [ map { my $k = $_; map { { name => $k, value => $_ } } grep { length } @{ $c->every_param($k) } } qw(lk nolk) ],
# Names only: the rest of an entry is credentials.
mariadb_server_names => [ sort keys %{ $c->app->config('mariadb_servers') // {} } ],
);
});
# Every page names the tutorial chapter that helps with it. The layout
view release on metacpan or search on metacpan
Sets the timeout for waiting for a response from a node. Default: 12000 milliseconds
Return: undef
=head3 cluster_set_credentials
$cass->cluster_set_credentials($username, $password);
Sets credentials for plain text authentication.
Return: undef
=head3 cluster_set_load_balance_round_robin
view release on metacpan or search on metacpan
t/mariadb_live.t view on Meta::CPAN
use Readonly;
use Scalar::Util qw(refaddr);
# ---------------------------------------------------------------------------
# Parse MARIADB_SERVER into DSN + credentials
# ---------------------------------------------------------------------------
my ($DSN, $DB_USER, $DB_PASS) = _parse_server($ENV{MARIADB_SERVER});
sub _parse_server {
my ($raw) = @_;
view release on metacpan or search on metacpan
lib/Devel/Cover/Report/Coveralls.pm view on Meta::CPAN
return $text;
}
# Turn the output of `git remote -v` into the list of remotes to send.
# Each remote is listed once (its fetch URL), and credentials are removed
# from the URL.
sub parse_git_remotes {
my $text = shift;
my @remotes;
for my $line (split /\n/, defined $text ? $text : '') {
# "<name>\t<url> (fetch)". The URL may contain spaces (a local path).
next unless $line =~ /^(\S+)\t(.*) \(fetch\)\r?$/;
push @remotes, +{ name => $1, url => strip_url_credentials($2) };
}
return \@remotes;
}
# Remove the user information from a URL with a scheme
# (https://user:pass@host/path -> https://host/path).
# scp-like URLs (git@host:path) cannot hold a password and are kept as they are.
sub strip_url_credentials {
my $url = shift;
$url =~ s!^([A-Za-z][A-Za-z0-9+.-]*://)[^/?#]*@!$1!;
return $url;
}
view release on metacpan or search on metacpan
docker/README.md view on Meta::CPAN
- `HUB_USERNAME` — your Docker Hub username
- `HUB_TOKEN` — a Personal Access Token (PAT)
These are needed because tag deletion uses the Docker Hub web API, which
authenticates separately from `docker push` (which uses `docker login`
credentials). To create a PAT:
1. Go to <https://hub.docker.com/settings/security>
2. Click **Personal access tokens** and then **Generate new token**
3. Give it **Read, Write & Delete** permissions
4. Copy the token and export it as `HUB_TOKEN`
view release on metacpan or search on metacpan
eg/cd-LWP.html view on Meta::CPAN
<table border="0" width="100%" cellpadding="5">
<tbody>
<tr>
<td class="tdOperation">
credentials
</td>
</tr>
</tbody>
</table>
view release on metacpan or search on metacpan
lib/Developer/Dashboard.pm view on Meta::CPAN
under QEMU for each target architecture; the tarball itself is still installed
and its install is verified separately in a blank Docker environment.
The workflow selects the GitHub Actions environment C<release>, whose
secrets C<DOCKER_HUB_USER> and C<DOCKER_HUB_TOKEN> provide the Docker Hub
credentials. It pushes two tags under C<DOCKER_HUB_USER/developer-dashboard>:
the distribution version read from C<dist.ini> (for example C<5.88>) and
C<latest>.
A manual workflow dispatch also builds the current C<master>
branch. The image targets C<linux/amd64> and
lib/Developer/Dashboard.pm view on Meta::CPAN
Developer Dashboard
hashes the raw secret with SHA-256, compares it to the stored digest, and
executes the saved Ajax handler when they match.
Missing or wrong credentials
for a registered API route return C<403> with the JSON body
C<{"status":"forbidden"}>.
Existing helper-session auth still works on the
same saved Ajax routes, so browser workflows and machine callers can coexist on
view release on metacpan or search on metacpan
lib/Device/Cisco/NXAPI.pm view on Meta::CPAN
my $uri = URI->new($self->uri);
croak "Only http:// or https:// supported." if !($uri->scheme eq 'http' or $uri->scheme eq 'https');
$self->http_request(HTTP::Request->new(POST => $uri->scheme()."://".$uri->host_port()."/ins"));
$self->http_request()->content_type("application/json-rpc");
$self->user_agent()->credentials($uri->host_port(), 'Secure Zone', $self->username, $self->password);
}
=head1 METHODS
=head2 tester()
view release on metacpan or search on metacpan
lib/Device/Firewall/PaloAlto.pm view on Meta::CPAN
=head2 auth
my $fw = $fw->auth;
This function authenticates the credentials passed to new against the firewall.
If successful, it returns the object itself to all method calls to be chains. If unsuccessful, it returns a L<Class::Error> object.
=head2 debug
view release on metacpan or search on metacpan
lib/Device/Neurio.pm view on Meta::CPAN
# Submit request for authentiaction token.
my $response = $self->{'ua'}->post($self->{'base_url'}.'/oauth2/token',
{ basic_authentication => $self->{'base64'},
Content_Type => 'application/x-www-form-urlencoded',
grant_type => 'client_credentials',
client_id => $self->{'key'},
client_secret => $self->{'secret'},
}
);
view release on metacpan or search on metacpan
t/000-http_errors.t view on Meta::CPAN
),
HTTP::Response->new(
403,
"403 Response",
undef,
q{<response status = 'error' code = '403'><result><msg>Invalid credentials.</msg></result></response>}
),
HTTP::Response->new(
500,
"500 Response",
undef,
view release on metacpan or search on metacpan
lib/Device/TPLink/Kasa.pm view on Meta::CPAN
unless ($self->username && $self->password) {
Carp::croak "Username and/or password not set!";
}
# We have a username, password, and UUID - everything we need to get a new token
my $credentials = {
appType => 'Kasa_Android',
cloudUserName => $self->username,
cloudPassword => $self->password,
terminalUUID => $self->uuid
};
my $request_object = {
method => 'login',
params => $credentials
};
my $user_agent = LWP::UserAgent::JSON->new;
# Uncomment the next two lines if you need to debug...
#$user_agent->add_handler("request_send", sub { shift->dump; return });
view release on metacpan or search on metacpan
lib/Dezi/Aggregator/Spider.pm view on Meta::CPAN
isa => Str,
default => sub {'dezi-spider http://dezi.org/'},
);
has 'authn_callback' => ( is => 'rw', isa => CodeRef );
has 'credential_timeout' => ( is => 'rw', isa => Int, default => sub {30} );
has 'credentials' => ( is => 'rw', isa => Str );
has 'delay' => ( is => 'rw', isa => Int, default => sub {5} );
has 'email' => (
is => 'rw',
isa => Str,
default => sub {'dezi@user.failed.to.set.email.invalid'},
lib/Dezi/Aggregator/Spider.pm view on Meta::CPAN
Get/set the number of seconds to wait before considering the remote
server unresponsive. The default is 10.
=item authn_callback I<code_ref>
CODE reference to fetch username/password credentials when necessary. See also
C<credentials>.
=item credential_timeout I<n>
Number of seconds to wait before skipping manual prompt for username/password.
=item credentials I<user:pass>
String with C<username>:C<password> pair to be used when prompted by
the server.
=item follow_redirects I<1|0>
lib/Dezi/Aggregator/Spider.pm view on Meta::CPAN
}
}
# otherwise, prompt (over and over)
if ( !$user_pass ) {
$user_pass = $self->_get_basic_credentials( $uri, $realm );
}
if ($user_pass) {
$uri->userinfo($user_pass);
$self->{cur_realm} = $realm; # save so we can cache if it's valid
lib/Dezi/Aggregator/Spider.pm view on Meta::CPAN
return 0;
}
# From spider.pl
sub _get_basic_credentials {
my ( $self, $uri, $realm ) = @_;
# Exists but undefined means don't ask.
return
if exists $self->{credential_timeout}
lib/Dezi/Aggregator/Spider.pm view on Meta::CPAN
}
=head2 get_authorized_doc( I<uri>, I<response> )
Called internally when the server returns a 401 or 403 response.
Will attempt to determine the correct credentials for I<uri>
based on the previous attempt in I<response> and what you
have configured in B<credentials>, B<authn_callback> or when
manually prompted.
=cut
sub get_authorized_doc {
my $self = shift;
my $uri = shift or croak "uri required";
my $response = shift or croak "response required";
# set up credentials
$self->_authorize( $uri, $response->http_response ) or return;
return $self->_make_request($uri);
}
lib/Dezi/Aggregator/Spider.pm view on Meta::CPAN
content => ( $encoding =~ m/utf-8/i ? to_utf8($buf) : $buf ),
size => $headers->content_length || length( pack 'C0a*', $buf ),
charset => $encoding,
);
# cache whatever credentials were used so we can re-use
if ( $self->{cur_realm} and $uri->userinfo ) {
my $key = $uri->canonical->host_port . ':' . $self->{cur_realm};
$self->{_auth_cache}->add( $key => $uri->userinfo );
# not too sure of the best logic here
lib/Dezi/Aggregator/Spider.pm view on Meta::CPAN
sub _get_user_pass {
my $self = shift;
my $uri = shift;
# Set basic auth if defined - use URI specific first, then credentials.
# this doesn't track what should have authorization
my $last_auth;
if ( $self->{last_auth} ) {
my $path = $uri->path;
$path =~ s!/[^/]*$!!;
$last_auth = $self->{last_auth}->{auth}
if $self->{last_auth}->{path} eq $path;
}
my ( $user, $pass ) = split /:/,
( $last_auth || $uri->userinfo || $self->credentials || '' );
return ( $user, $pass );
}
=head2 looks_like_feed( I<http_response> )
view release on metacpan or search on metacpan
lib/Dezi/Client.pm view on Meta::CPAN
=item username I<username>
=item password I<password>
If present, the username and password credentials will
be set in each internal HTTP::Request object for any
non-idempotent action (delete(), index(), commit(), rollback()).
=back
view release on metacpan or search on metacpan
lib/Dezi/Config.pm view on Meta::CPAN
}
else {
%args = @_;
}
# save credentials in a closure but not plain in args
my $username = delete $args{username};
my $password = delete $args{password};
my $authenticator = ( defined $username and defined $password )
? sub {
my ( $u, $p ) = @_;
lib/Dezi/Config.pm view on Meta::CPAN
server_class => 'Dezi::Server',
# authentication for non-idempotent requests.
# if both username && password are defined,
# then /index, /commit and /rollback require
# basic authentication credentials.
username => 'someone',
password => 'somesecret',
# optional
# see Dezi::Stats
view release on metacpan or search on metacpan
dcdb-query.perl view on Meta::CPAN
-ll # score by 1-sided log-likelihood ratio (Evert 2008)
-eps EPS # smoothing constant (default=0)
-diff DIFFOP # diff operation (adiff|diff|sum|min|max|avg|havg|gavg; default=adiff)
I/O Options:
-user USER[:PASSWD] # user credentials for HTTP queries
-text # use text output (default)
-json # use json output
-null # don't output profile at all
-[no]pretty # do/don't pretty-print json output (default=do)
-log-level LEVEL # set minimum DiaColloDB log-level
dcdb-query.perl view on Meta::CPAN
=over 4
=item -user USER[:PASSWD]
Specify user credentials for HTTP queries
=item -text
generate text output (default).
view release on metacpan or search on metacpan
ext/xxHash/.github/workflows/scorecard.yml view on Meta::CPAN
steps:
- name: "Checkout code"
uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with:
persist-credentials: false
- name: "Run analysis"
uses: ossf/scorecard-action@05b42c624433fc40578a4040d5cf5e36ddca8cde # v2.4.2
with:
results_file: results.sarif
view release on metacpan or search on metacpan
will have to edit your copy of the module.
The underlying object is an array containing the Net::FTP
connection object and the absolute path to
the directory, modulo any chrooting the FTP server might do
based on the provided credentials, of course.
Keys are names within the directory, values
are the contents of the files.
A leading space is used as an escape character, the empty
view release on metacpan or search on metacpan
lib/Discord/Client.pm view on Meta::CPAN
}
sub stats {
my ($self) = @_;
# Expose counters without including credentials or event payloads.
return {
rest => $self->{rest}->stats,
gateway => $self->{gateway}->stats,
callbacks => scalar( keys %{ $self->{callbacks} } ),
( $self->{cache} ? ( cache => $self->{cache}->stats ) : () )
lib/Discord/Client.pm view on Meta::CPAN
Returns the configured Cache object, or undef when disabled.
=head2 stats
Returns a hashref of REST, Gateway, pending callback and optional cache counters.
It does not include payloads or credentials.
=head1 EXAMPLES
From a source checkout, set C<DISCORD_BOT_TOKEN> and C<TEST_GUILD_ID>.
Invite the bot with C<bot> and C<applications.commands> scopes and leave the
view release on metacpan or search on metacpan
lib/Dist/Zilla/Plugin/UploadToCPAN.pm view on Meta::CPAN
my $self = shift;
$self->{'Dist::Zilla'}{plugin}->log(@_);
}
}
#pod =attr credentials_stash
#pod
#pod This attribute holds the name of a L<PAUSE stash|Dist::Zilla::Stash::Login>
#pod that will contain the credentials to be used for the upload. By default,
#pod UploadToCPAN will look for a C<%PAUSE> stash.
#pod
#pod =cut
has credentials_stash => (
is => 'ro',
isa => 'Str',
default => '%PAUSE'
);
has _credentials_stash_obj => (
is => 'ro',
isa => maybe_type( role_type('Dist::Zilla::Role::Stash::Login') ),
lazy => 1,
init_arg => undef,
default => sub { $_[0]->zilla->stash_named( $_[0]->credentials_stash ) },
);
sub _credential {
my ($self, $name) = @_;
return unless my $stash = $self->_credentials_stash_obj;
return $stash->$name;
}
sub mvp_aliases {
return { user => 'username' };
lib/Dist/Zilla/Plugin/UploadToCPAN.pm view on Meta::CPAN
},
);
#pod =attr pause_cfg_file
#pod
#pod This is the name of the file containing your pause credentials. It defaults
#pod F<.pause>. If you give a relative path, it is taken to be relative to
#pod L</pause_cfg_dir>.
#pod
#pod =cut
lib/Dist/Zilla/Plugin/UploadToCPAN.pm view on Meta::CPAN
unless File::Spec->file_name_is_absolute($file);
return {} unless -e $file && -r _;
my $cfg = try {
CPAN::Uploader->read_config_file($file)
} catch {
$self->log("Couldn't load credentials from '$file': $_");
{};
};
return $cfg;
},
);
lib/Dist/Zilla/Plugin/UploadToCPAN.pm view on Meta::CPAN
for any reason, and there is no promise that patches will be accepted to
lower the minimum required perl.
=head1 ATTRIBUTES
=head2 credentials_stash
This attribute holds the name of a L<PAUSE stash|Dist::Zilla::Stash::Login>
that will contain the credentials to be used for the upload. By default,
UploadToCPAN will look for a C<%PAUSE> stash.
=head2 username
This option supplies the user's PAUSE username.
lib/Dist/Zilla/Plugin/UploadToCPAN.pm view on Meta::CPAN
F<dist.ini>. It will be looked for in the user's PAUSE configuration; if not
found, the user will be prompted.
=head2 pause_cfg_file
This is the name of the file containing your pause credentials. It defaults
F<.pause>. If you give a relative path, it is taken to be relative to
L</pause_cfg_dir>.
=head2 pause_cfg_dir