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
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
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/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
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/Dist/Zilla/Plugin/Authority.pm view on Meta::CPAN
}
}
close $fh or $self->log_fatal( "Unable to close $file - $!" );
$self->log_fatal( 'PAUSE user not found in ~/.pause' );
} else {
$self->log_fatal( 'PAUSE credentials not found in "config.ini" or "dist.ini" or "~/.pause"! Please set it or specify an authority for this plugin.' );
}
}
},
);
view release on metacpan or search on metacpan
lib/Dist/Zilla/Plugin/Bitbucket.pm view on Meta::CPAN
die "Unknown local repository type!";
}
},
);
sub _get_credentials {
my ($self, $nopass) = @_;
# TODO I'm so lazy...
## no critic (InputOutput::ProhibitBacktickOperators)
lib/Dist/Zilla/Plugin/Bitbucket.pm view on Meta::CPAN
}
}
# Make sure we return full path including user
if ($repo !~ /.*\/.*/) {
($login, undef) = $self->_get_credentials(1);
$repo = "$login/$repo";
}
} else {
# Get it from .hgrc
if ( -f '.hg/hgrc' ) {
lib/Dist/Zilla/Plugin/Bitbucket.pm view on Meta::CPAN
=back
=head2 Configuration
Configure git with your Bitbucket credentials:
$ git config --global bitbucket.user LoginName
$ git config --global bitbucket.password MySecretPassword
Alternatively you can install L<Config::Identity> and write your credentials
in the (optionally GPG-encrypted) C<~/.bitbucket> file as follows:
login LoginName
password MySecretPassword
view release on metacpan or search on metacpan
lib/Dist/Zilla/Plugin/GitHub/CreateRelease.pm view on Meta::CPAN
There are numerous combinations of Dist::Zilla plugins that can perform those
functions.
=head1 GITHUB API AUTHENTICATION
This module uses Config::Identity::GitHub to access the GitHub API credentials.
You need to create a file in your home directory named B<.github-identity>. It
requires the following fields:
login github_username OR github_organization
view release on metacpan or search on metacpan
lib/Dist/Zilla/Plugin/GitHub/UploadRelease.pm view on Meta::CPAN
$self->log_debug("$method $url");
$headers //= {};
my ($login, $pass, $otp) = $self->_get_credentials(0);
if ($pass) {
my $basic = encode_base64("$login:$pass", '');
$headers->{Authorization} = "Basic $basic";
}
lib/Dist/Zilla/Plugin/GitHub/UploadRelease.pm view on Meta::CPAN
sub after_release {
my ($self, $archive) = @_;
my $dist_name = $self->zilla->name;
my ($login) = $self->_get_credentials(1);
return unless $login;
my $repo_name = $self->_get_repo_name($login);
my $git_tag_plugin = $self->zilla->plugin_named('Git::Tag') // $self->log_fatal('Plugin Git::Tag not found');
lib/Dist/Zilla/Plugin/GitHub/UploadRelease.pm view on Meta::CPAN
version 0.002
=head1 SYNOPSIS
Configure git with your GitHub credentials:
git config --global github.user LoginName
git config --global github.password GitHubPassword
Alternatively you can install L<Config::Identity> and write your credentials in the (optionally GPG-encrypted) C<~/.github> file as follows:
login LoginName
password GitHubpassword
(if only the login name is set, the password will be asked interactively)
view release on metacpan or search on metacpan
lib/Dist/Zilla/Plugin/GitHub.pm view on Meta::CPAN
isa => 'Maybe[Str]',
lazy => 1,
builder => '_build_login',
);
has _credentials => (
is => 'ro',
isa => 'HashRef',
lazy => 1,
builder => '_build_credentials',
);
#pod =head1 DESCRIPTION
#pod
#pod B<Dist-Zilla-Plugin-GitHub> is a set of plugins for L<Dist::Zilla> intended
lib/Dist/Zilla/Plugin/GitHub.pm view on Meta::CPAN
}
return $login;
}
sub _build_credentials {
my $self = shift;
my ($login, $pass, $token);
$login = $self->_login;
lib/Dist/Zilla/Plugin/GitHub.pm view on Meta::CPAN
}
return { login => $login, pass => $pass, token => $token };
}
sub _has_credentials {
my $self = shift;
return keys %{$self->_credentials};
}
sub _auth_headers {
my $self = shift;
my $credentials = $self->_credentials;
my %headers = ( Accept => 'application/vnd.github.v3+json' );
if ($credentials->{pass}) {
require MIME::Base64;
my $basic = MIME::Base64::encode_base64("$credentials->{login}:$credentials->{pass}", '');
$headers{Authorization} = "Basic $basic";
}
elsif ($credentials->{token}) {
$headers{Authorization} = "token $credentials->{token}";
}
# This can't be done at object creation because we autodetect the
# need for 2FA when GitHub says we need it, so we won't know to
# prompt at object creation time.
if ($self->prompt_2fa) {
my $otp = $self->zilla->chrome->prompt_str(
"GitHub two-factor authentication code for '$credentials->{login}'",
{ noecho => 1 },
);
$headers{'X-GitHub-OTP'} = $otp;
$self->log([ "Using two-factor authentication" ]);
view release on metacpan or search on metacpan
lib/Dist/Zilla/Plugin/NexusRelease.pm view on Meta::CPAN
$self->{'Dist::Zilla'}{plugin}->log(@_);
}
}
has credentials_stash => (
is => 'ro',
isa => 'Str',
default => '%Nexus'
);
has _credentials_stash_obj => (
is => 'ro',
isa => maybe_type( class_type('Dist::Zilla::Stash::Nexus') ),
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;
}
has username => (
lib/Dist/Zilla/Plugin/NexusRelease.pm view on Meta::CPAN
The Nexus Artefact is set to the Perl distribution name (C<name> in F<dist.ini>, and the version is set to the Perl distribution version.
=head1 ATTRIBUTES
=head2 credentials_stash
This attribute holds the name of a L<Nexus stash|Dist::Zilla::Stash::Nexus>
that will contain the credentials to be used for the upload. By default,
NexusRelease will look for a C<%Nexus> stash.
=head2 username
This is the Nexus user to log in with.
view release on metacpan or search on metacpan
lib/Dist/Zilla/Plugin/PERLANCAR/Authority.pm view on Meta::CPAN
}
}
close $fh or $self->log_fatal( "Unable to close $file - $!" );
$self->log_fatal( 'PAUSE user not found in ~/.pause' );
} else {
$self->log( 'PAUSE credentials not found in "config.ini" or "dist.ini" or "~/.pause", will be using "cpan:<none>" as the AUTHORITY' );
return 'cpan:<none>';
}
}
},
);
lib/Dist/Zilla/Plugin/PERLANCAR/Authority.pm view on Meta::CPAN
=head1 DESCRIPTION
B<Fork note>: This plugin is a fork of L<Dist::Zilla::Plugin::Authority>. When
PAUSE credential is not found, this plugin will set C<$AUTHORITY> to C<<
cpan:<none> >> instead of bailing out. TODO: bail if PAUSE credentials is not
found and we are doing a release (instead of just 'dzil test' or 'dzil build').
The rest is Dist::Zilla::Plugin::Authority's documentation.
This plugin adds the authority data to your distribution. It adds the data to
your modules and metadata. Normally it looks for the PAUSE author id in your
view release on metacpan or search on metacpan
before, you'll need to replace it with "recurse = 0" in your
dist.ini file.
[BUG FIXES]
- The plugin was ignoring your authentication credentials when
using a remote repository [GitHub #7]. Thanks @hstaugaard.
0.085 2014-01-13 14:48:42 America/Los_Angeles
[BUG FIXES]
view release on metacpan or search on metacpan
lib/Dist/Zilla/Role/Subversion.pm view on Meta::CPAN
=head1 ATTRIBUTES
=head2 svn_user
Your Subversion user ID. Defaults to the cached credentials for your
distribution's working copy.
=head2 svn_password
Your Subversion password. Defaults to the cached credentials for your
distribution's working copy.
=head2 working_url
URL for the directory currently holding your distribution. Defaults to your
view release on metacpan or search on metacpan
lib/Dist/Zilla/Plugin/UploadToCPAN/WWWPAUSESimple.pm view on Meta::CPAN
use Scalar::Util qw(weaken);
use Try::Tiny;
use namespace::autoclean;
has credentials_stash => (
is => 'ro',
isa => 'Str',
default => '%PAUSE'
);
has _credentials_stash_obj => (
is => 'ro',
isa => maybe_type( class_type('Dist::Zilla::Stash::PAUSE') ),
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' };
view release on metacpan or search on metacpan
lib/Dist/Zilla/Plugin/UploadToGoogleCode.pm view on Meta::CPAN
If loaded, this plugin will allow the F<release> command to upload to Google Code.
=head1 DESCRIPTION
This plugin looks for the Google Code project name in F<dist.ini>, and gets your
Google Code credentials from F<~/.googlecode-identity> (which can be
GnuPG-encrypted; see L<Config::Identity>).
If any configuration is missing, it will prompt you to enter your
username and password during the BeforeRelease phase. Entering a
blank username or password will abort the release.
view release on metacpan or search on metacpan
0.28 2012-06-14
- Only do post-release stuff if it was a real release
- Require @GitHub 0.22
- bug related to finding a fork's parent repo
- Now uses Config::Identity to get credentials
0.27 2012-05-25
- Add SchwartzRatio plugin
- Allow setting github = 0 to disable GitHub::Meta and GitHub::Update
view release on metacpan or search on metacpan
lib/Dist/Zilla/PluginBundle/Author/ETHER.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 {
warn "[\@Author::ETHER] Couldn't load credentials from '$file': $_";
{};
};
return $cfg;
}
view release on metacpan or search on metacpan
lib/Dist/Zilla/PluginBundle/Author/GSG.pm view on Meta::CPAN
local $git_tag_plugin->{plugin_name} = 'Git::Tag';
return $self->$orig(@args);
};
sub _get_credentials {
my ($self, $login_only) = @_;
my $creds = $self->_credentials;
# return $creds->{login} if $login_only;
my $otp;
$otp = $self->zilla->chrome->prompt_str(
"GitHub two-factor authentication code for '$creds->{login}'",
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