view release on metacpan or  search on metacpan

lib/App/gist.pm  view on Meta::CPAN

	around _request_for => sub {
		my ($orig, $self, @args) = @_;
		my $req = $self -> $orig(@args);

		my ($login, $passwd) = App::gist::_get_credentials();

		$req -> headers -> remove_header('Authorization');
		$req -> headers -> authorization_basic($login, $passwd);

		return $req;

lib/App/gist.pm  view on Meta::CPAN

			}
		}
	);
}

sub _get_credentials {
	my ($login, $pass, $token);

	my %identity = Config::Identity::GitHub -> load
		if try_load_class('Config::Identity::GitHub');

 view release on metacpan or  search on metacpan

lib/App/git/ship.pm  view on Meta::CPAN

The main focus is to automate away the boring steps, but at the same time not
get in your (or any random contributor's) way. Problems should be solved with
sane defaults according to standard rules instead of enforcing more rules.

L<App::git::ship> differs from other tools like L<dzil|Dist::Zilla> by I<NOT>
requiring any configuration except for a file containing the credentials for
uploading to CPAN.

=head2 Supported project types

Currently, only L<App::git::ship::perl> is supported.

 view release on metacpan or  search on metacpan

script/git_log_ch_usrdata  view on Meta::CPAN

my ($Old_Mail, $New_Mail, $New_User, $No_Credentials);

GetOptions('old_email|oe=s'  => \$Old_Mail,
           'new_email|ne=s'  => \$New_Mail,
           'new_user|nu=s'   => \$New_User,
           'no_credentials|nc' => \$No_Credentials
          ) or pod2usage(2);

$Old_Mail // die("'--old_email' missing.");
$New_Mail // die("'--new_email' missing.");
$New_User // die("'--new_user' missing.");

script/git_log_ch_usrdata  view on Meta::CPAN

                'git gc --prune=now --aggressive',

                'echo "--- push changes to github ---"',
                "git push --force --tags origin 'refs/heads/*'",
                $No_Credentials ? () : (
                                        'echo "--- Set credentials ---"',
                                        'git config credential.helper store',
                                        "git config user.email $New_Mail",
                                        "git config user.name \$New_User"
                                       )
               );

script/git_log_ch_usrdata  view on Meta::CPAN

=head1 SYNOPSIS

  git_log_ch_usrdata --old_email OLD_EMAIL --new_email NEW_EMAIL  \
                     --new_user NEW_USER [--no_credentials]

  git_log_ch_usrdata --help | --version

or, shorter:

script/git_log_ch_usrdata  view on Meta::CPAN

  git_log_ch_usrdata --oe OLD_EMAIL --ne NEW_EMAIL --nu NEW_USER

By default, the script also stores I<C<NEW_EMAIL>> and I<C<NEW_USER>> via
C<git config credential.helper store>. This can be switched off by specifying
the B<C<--no_credentials>> (or B<C<--nc>>) option.


=head1 SEE ALSO

L<App::ghmulti>, L<App::git_log_ch_usrdata>

 view release on metacpan or  search on metacpan

lib/App/html2wp.pm  view on Meta::CPAN

    v => 1.1,
    summary => 'Publish HTML document to WordPress as blog post',
    description => <<'_',

To use this program, first create `~/html2wp.conf` containing the API
credentials, e.g.:

    proxy=https://YOURBLOGNAME.wordpress.com/xmlrpc.php
    username=YOURUSERNAME
    password=YOURPASSWORD

You can also put multiple credentials in the configuration file using profile
sections, e.g.:

    [profile=blog1]
    proxy=https://YOURBLOG1NAME.wordpress.com/xmlrpc.php
    username=YOURUSERNAME

lib/App/html2wp.pm  view on Meta::CPAN

 html2wp(%args) -> [status, msg, payload, meta]

Publish HTML document to WordPress as blog post.

To use this program, first create C<~/html2wp.conf> containing the API
credentials, e.g.:

 proxy=https://YOURBLOGNAME.wordpress.com/xmlrpc.php
 username=YOURUSERNAME
 password=YOURPASSWORD

You can also put multiple credentials in the configuration file using profile
sections, e.g.:

 [profile=blog1]
 proxy=https://YOURBLOG1NAME.wordpress.com/xmlrpc.php
 username=YOURUSERNAME

 view release on metacpan or  search on metacpan

lib/App/karr/Foundation.pm  view on Meta::CPAN

that produced no board movement at all, which is what a rate-limited or
unauthenticated agent looks like. A pattern seen in a run that B<did> move the
board is noted in F<.karr.log> and otherwise ignored.

The default patterns are correspondingly narrow: a symptom word counts next to
a failure word on the same line ("network error", "invalid credentials",
"quota exceeded"), not on its own, and an HTTP status counts only where
something adjacent marks it as one ("API error: 429", "429 Too Many Requests"),
not in a diffstat or a line number. Before this, an agent that printed its own
board tripped the scan on a backlog title, and a diffstat of 403 changed lines
tripped it on C<403> (#160).

 view release on metacpan or  search on metacpan

lib/App/org2wp.pm  view on Meta::CPAN

This is originally a quick hack because I couldn't make
[org2blog](https://github.com/punchagan/org2blog) on my Emacs installation to
work after some update. `org2wp` uses the same format as `org2blog`, but instead
of being an Emacs package, it is a CLI script written in Perl.

First, create `~/org2wp.conf` containing the API credentials, e.g.:

    ; use INI (IOD) format for this file
    proxy=https://YOURBLOGNAME.wordpress.com/xmlrpc.php
    username=YOURUSERNAME
    password=YOURPASSWORD

lib/App/org2wp.pm  view on Meta::CPAN

server, which can be hosted on `wordpress.com` or on other server, including
your own. It has nothing to do with HTTP/HTTPS proxy; the term "proxy" is used
by the <pm:XMLRPC::Lite> and <pm:SOAP::Lite> Perl libraries and `org2wp` simply
uses the same terminology.

You can also put multiple credentials in the configuration file using profile
sections, e.g.:

    ; use INI (IOD) format for this file
    [profile=blog1]
    proxy=https://YOURBLOG1NAME.wordpress.com/xmlrpc.php

lib/App/org2wp.pm  view on Meta::CPAN

This is originally a quick hack because I couldn't make
LL<https://github.com/punchagan/org2blog> on my Emacs installation to
work after some update. C<org2wp> uses the same format as C<org2blog>, but instead
of being an Emacs package, it is a CLI script written in Perl.

First, create C<~/org2wp.conf> containing the API credentials, e.g.:

 ; use INI (IOD) format for this file
 proxy=https://YOURBLOGNAME.wordpress.com/xmlrpc.php
 username=YOURUSERNAME
 password=YOURPASSWORD

lib/App/org2wp.pm  view on Meta::CPAN

server, which can be hosted on C<wordpress.com> or on other server, including
your own. It has nothing to do with HTTP/HTTPS proxy; the term "proxy" is used
by the L<XMLRPC::Lite> and L<SOAP::Lite> Perl libraries and C<org2wp> simply
uses the same terminology.

You can also put multiple credentials in the configuration file using profile
sections, e.g.:

 ; use INI (IOD) format for this file
 [profile=blog1]
 proxy=https://YOURBLOG1NAME.wordpress.com/xmlrpc.php

 view release on metacpan or  search on metacpan

lib/App/pepper.pm  view on Meta::CPAN

my $handlers = {
    'timeout'        => \&handle_timeout,
    'ssl'            => \&handle_ssl,
    'host'            => \&handle_host,
    'port'            => \&handle_port,
    'credentials'    => \&handle_credentials,
    'id'            => \&handle_id,
    'pw'            => \&handle_pw,
    'newpw'            => \&handle_newpw,
    'connect'        => \&handle_connect,
    'login'            => \&handle_login,

lib/App/pepper.pm  view on Meta::CPAN

        }
        return $result;
    }
}

sub handle_credentials {
    if ($_[0] eq '') {
        return error('Missing client ID');

    } elsif ($_[1] eq '') {
        return error('Missing password');

lib/App/pepper.pm  view on Meta::CPAN

    } elsif ($epp->{'host'} eq '') {
        return error('No host specified');

    } elsif ($epp->{'user'} eq '' || $epp->{'pass'} eq '') {
        return error('No credentials specified');

    } else {
        note("Attempting to login as '%s'...", $epp->{'user'});
        $epp->{'quiet'} = ($verbose ? 0 : 1);
        my $result = $epp->_login;

lib/App/pepper.pm  view on Meta::CPAN

    my %map = (
        'timeout'            => 'SYNTAX/Connection Management',
        'ssl'                => 'SYNTAX/Connection Management',
        'host'                => 'SYNTAX/Connection Management',
        'port'                => 'SYNTAX/Connection Management',
        'credentials'        => 'SYNTAX/Session Management',
        'id'                => 'SYNTAX/Session Management',
        'pw'                => 'SYNTAX/Session Management',
        'newpw'                => 'SYNTAX/Session Management',
        'connect'            => 'SYNTAX/Connection Management',
        'login'                => 'SYNTAX/Session Management',

 view release on metacpan or  search on metacpan

t/features/step_definitions/basic.pl~  view on Meta::CPAN

use warnings;

use lib 't/lib';
use Test::Helper qw(testmojo create_user testschema);
use Test::StepsHelper
  qw(a_login_request_with_invalid_credentials get_result api_base );
use Test::Net::LDAP::Util qw(ldap_mockify);

use Test::More;
use Test::BDD::Cucumber::StepFile;

t/features/step_definitions/basic.pl~  view on Meta::CPAN

        create_user( context => $context );
    };
};

When qr{the client tries to login without providing a user name} => sub {
    my $request = a_login_request_with_invalid_credentials();
    delete $request->{username};
    $t->post_ok( $route => $accept_header => json => $request );
};

When qr{the client tries to login without providing a password} => sub {
    my $request = a_login_request_with_invalid_credentials();
    delete $request->{password};
    $t->post_ok( $route => $accept_header => json => $request );
};

When
qr{the client tries to log in providing correct password for this existing user}
  => sub {
    my $request = a_login_request_with_invalid_credentials();
    $request->{username} = C->stash->{scenario}->{username};
    $request->{password} = C->stash->{scenario}->{password};

    # deep within this login there's a bind() which we have to mock
    ldap_mockify {
      $t->post_ok( $route => $accept_header => json => $request );
    }
  };

When qr{the client tries to login providing name of non-existing user} => sub {
    my $request = a_login_request_with_invalid_credentials();
    $request->{username} = 'I do not exist';
    $t->post_ok( $route => $accept_header => json => $request );
};

When

 view release on metacpan or  search on metacpan

lib/App/pod2wp.pm  view on Meta::CPAN

This is like <prog:org2wp> except that instead of Org as the document format,
this program uses POD.

To use this program, first create `~/pod2wp.conf` containing the API
credentials, e.g.:

    proxy=https://YOURBLOGNAME.wordpress.com/xmlrpc.php
    username=YOURUSERNAME
    password=YOURPASSWORD

You can also put multiple credentials in the configuration file using profile
sections, e.g.:

    [profile=blog1]
    proxy=https://YOURBLOG1NAME.wordpress.com/xmlrpc.php
    username=YOURUSERNAME

lib/App/pod2wp.pm  view on Meta::CPAN

This is like L<org2wp> except that instead of Org as the document format,
this program uses POD.

To use this program, first create C<~/pod2wp.conf> containing the API
credentials, e.g.:

 proxy=https://YOURBLOGNAME.wordpress.com/xmlrpc.php
 username=YOURUSERNAME
 password=YOURPASSWORD

You can also put multiple credentials in the configuration file using profile
sections, e.g.:

 [profile=blog1]
 proxy=https://YOURBLOG1NAME.wordpress.com/xmlrpc.php
 username=YOURUSERNAME

 view release on metacpan or  search on metacpan

lib/App/rdapper.pm  view on Meta::CPAN

=item * C<--short> - omit remarks, notices, links and redactions.

=item * C<--bypass-cache> - disable local cache of RDAP objects.

=item * C<--auth=USER:PASS> - HTTP Basic Authentication credentials to be used
when accessing the specified resource. This option B<SHOULD NOT> be used unless
you explicitly specify a URL, otherwise your credentials may be sent to servers
you aren't expecting them to.

=item * C<--nocolor> - disable ANSI colors in the formatted output.

=item * C<--debug> -run in debugging mode.

 view release on metacpan or  search on metacpan

README.md  view on Meta::CPAN

## Features

- Simple CLI interface (`sdseasydyn update`)
- Clear configuration precedence: CLI > environment > config file > defaults
- Secure handling of credentials (tokens are never logged)
- Public IPv4 discovery with configurable endpoint
- Local state file to avoid redundant updates
- Bounded retry logic using `Retry::Policy`
- Suitable for unattended / scheduled execution

 view release on metacpan or  search on metacpan

tpnotify  view on Meta::CPAN

=item B<smtp://>[I<USER>[B<:>I<PASS>]B<@>]I<HOSTNAME>[B<:>I<PORT>]

Send mail using SMTP.  I<HOSTNAME> is the hostname or IP address of the mail
relay to use.  I<PORT>, if supplied, is the port number to use instead of the
default 25.  Optional I<USER> and I<PASS> provide credentials, if the relay
requires authentication.

=back

=item B<-n>, B<--dry-run>

 view release on metacpan or  search on metacpan

bin/wp-xmlrpc  view on Meta::CPAN

This document describes version 0.003 of wp-xmlrpc (from Perl distribution App-wp-xmlrpc), released on 2017-04-24.

=head1 SYNOPSIS

In C<~/wp-xmlrpc.conf>, put your API credentials:

 proxy=https://YOURBLOGNAME.wordpress.com/xmlrpc.php
 username=YOURUSERNAME
 password=YOURPASSWORD

Then:

 % wp-xmlrpc wp.getPost 13

You can also put multiple credentials in the config file via profiles:

 [profile=blog1]
 proxy=https://BLOG1NAME.wordpress.com/xmlrpc.php
 username=YOURUSERNAME
 password=YOURPASSWORD

 view release on metacpan or  search on metacpan

lib/App/wsgetmail.pm  view on Meta::CPAN

=over

=item Client Credentials

This method uses shared secrets and is preferred by Microsoft.
(See L<Client credentials|https://docs.microsoft.com/en-us/azure/active-directory/develop/msal-authentication-flows#client-credentials>)

=item Username/password

This method is more like previous connections via IMAP. It is currently
supported by Microsoft, but not recommended. (See L<Username/password|https://docs.microsoft.com/en-us/azure/active-directory/develop/msal-authentication-flows#usernamepassword>)

lib/App/wsgetmail.pm  view on Meta::CPAN

    wsgetmail --config=wsgetmail.json --options='{"folder": "Inbox"}'
    wsgetmail --config=wsgetmail.json --options='{"folder": "Other Folder"}'

NOTE: Setting C<secret> or C<user_password> with C<--options> is not secure
and may expose your credentials to other users on the local system. If you
need to set these options, or just change a lot of settings in your
configuration, just run wsgetmail with different configurations:

    wsgetmail --config=account01.json
    wsgetmail --config=account02.json

 view release on metacpan or  search on metacpan

lib/ArangoDB2.pm  view on Meta::CPAN

{
    my($self, $name) = @_;
    # default database for arango is _system
    $name ||= "_system";
    # only create one instance per ArangoDB2 per database, each ArangoDB2
    # keeps its own instances since they may have different credentials
    return $self->databases->{$name} ||= ArangoDB2::Database->new($self, $name);
}

# databases
#

 view release on metacpan or  search on metacpan

lib/Arepa/Web/Auth.pm  view on Meta::CPAN

use MojoX::Session;

# Let session cookies live one week
use constant TTL_SESSION_COOKIE => 60 * 60 * 24 * 7;

sub _check_credentials {
    my ($self, $username, $password, $auth_type) = @_;

    if (defined $auth_type && $auth_type eq 'file_md5') {
        my $user_file_path =
          $self->config->get_key('web_ui:authentication:user_file');

lib/Arepa/Web/Auth.pm  view on Meta::CPAN

        if (defined $self->param('username') &&
                defined $self->param('password')) {
            my $valid_creds;
            eval {
                $valid_creds =
                  $self->_check_credentials($self->param('username'),
                                            $self->param('password'),
                                            $auth_type);
            };
            if ($EVAL_ERROR) {
                $self->vars("error" => $EVAL_ERROR);

 view release on metacpan or  search on metacpan

lib/Armadito/Agent/HTTP/Client.pm  view on Meta::CPAN

	if ( !$result->is_success() ) {

		# authentication required
		if ( $result->code() == 401 ) {
			if ( $self->{user} && $self->{password} ) {
				$logger->debug( $log_prefix . "authentication required, submitting credentials" );

				my $header  = $result->header('www-authenticate');
				my ($realm) = $header =~ /^Basic realm="(.*)"/;
				my $host    = $url->host();
				my $port    = $url->port()
					|| ( $scheme eq 'https' ? 443 : 80 );
				$self->{ua}->credentials( "$host:$port", $realm, $self->{user}, $self->{password} );

				# replay request
				eval {
					if ( $OSNAME eq 'MSWin32' && $scheme eq 'https' ) {
						alarm $self->{ua}->{timeout};
					}
					$result = $self->{ua}->request( $request, $file );
					alarm 0;
				};
				if ( !$result->is_success() ) {
					$logger->error( $log_prefix . "authentication required, wrong credentials" );
				}
			}
			else {
				# abort
				$logger->error( $log_prefix . "authentication required, no credentials available" );
			}
		}
		else {
			$logger->error( $log_prefix . "communication error: " . $result->status_line() );
		}

 view release on metacpan or  search on metacpan

lib/ArrayData/Lingua/Word/EN/Enable.pm  view on Meta::CPAN

credentialing
credentialism
credentialisms
credentialled
credentialling
credentials
credenza
credenzas
credibilities
credibility
credible

 view release on metacpan or  search on metacpan

lib/ArrayData/Word/EN/Enable.pm  view on Meta::CPAN

credentialing
credentialism
credentialisms
credentialled
credentialling
credentials
credenza
credenzas
credibilities
credibility
credible

 view release on metacpan or  search on metacpan

lib/Articulate/Authentication.pm  view on Meta::CPAN

use warnings;

use Moo;
with 'Articulate::Role::Component';

use Articulate::Syntax qw(new_credentials instantiate_array);

=head1 NAME

Articulate::Authentication - determine if a user who they claim to be

lib/Articulate/Authentication.pm  view on Meta::CPAN

      Articulate::Authentication:
        providers:
          - Articulate::Authentication::AlwaysAllow

  # then any component can dp
  $component->authentication->login($credentials);
  $component->authentication->login($user_id, $password);

=head1 ATTRIBUTE

=head3 providers

lib/Articulate/Authentication.pm  view on Meta::CPAN

  coerce  => sub { instantiate_array(@_) },
);

=head3 login

  $authentication->login($credentials);
  $authentication->login( $user_id, $password );

Asks each provider if the credentials supplied match a known user.
Credentials may be in whatever form will satisfy the C<credentials>
function in L<Articulate::Credentials> (username and password, hashref
or credentials object).

Each provider must respond true, false, or undef. A true value means
the user is authenticated. A false value means that the user exists but
is explicitly refused access (this should only be used in exceptional
circumstances) and an undef value means the user cannot be

lib/Articulate/Authentication.pm  view on Meta::CPAN

=cut

sub login {
  my $self        = shift;
  my $credentials = new_credentials @_;
  foreach my $provider ( @{ $self->providers } ) {
    return $credentials if $provider->authenticate($credentials);
    return $credentials if $credentials->rejected;
  }
  return $credentials->deny('No provider authenticated these credentials');
}

=head3 create_user

  $authentication->create_user( $user_id, $password );

 view release on metacpan or  search on metacpan

lib/Artifactory/Client.pm  view on Meta::CPAN

}

=head2 push_docker_tag_to_bintray( dockerImage => 'jfrog/ubuntu:latest', async => 'true', ... )

Push Docker tag to Bintray.  Calculation can be synchronous (the default) or asynchronous.  You will need to enter your
Bintray credentials, for more details, please refer to Entering your Bintray credentials.

=cut

sub push_docker_tag_to_bintray {
    my ( $self, %args ) = @_;

lib/Artifactory/Client.pm  view on Meta::CPAN

    return $self->post($url);
}

=head2 retrieve_all_available_plugin_info

Retrieves all available user plugin information (subject to the permissions of the provided credentials)

=cut

sub retrieve_all_available_plugin_info {
    my $self = shift;
    return $self->_handle_plugins();
}

=head2 retrieve_plugin_info_of_a_certain_type( $type )

Retrieves all available user plugin information (subject to the permissions of the provided credentials) of the
specified type

=cut

sub retrieve_plugin_info_of_a_certain_type {

 view release on metacpan or  search on metacpan

lib/AsposeCellsCloud/ApiClient.pm  view on Meta::CPAN

        my $difference_in_seconds=time() - $self->{get_access_token_time};
        if($difference_in_seconds < 86300){
            return;
        }
    }
    my $access_token  =  $self->o_auth_post('grant_type' => "client_credentials", 'client_id' => $self->{config}->{client_id}, 'client_secret' =>$self->{config}->{client_secret})->access_token;
    $self->{config}->{access_token} = $access_token;
}

# make the HTTP request
# @param string $resourcePath path to method endpoint

 view release on metacpan or  search on metacpan

lib/AsposeDiagramCloud/DiagramApi.pm  view on Meta::CPAN

        $api_client = $_[0];
    } else {
        $api_client = AsposeDiagramCloud::ApiClient->new(@_);
    }

    my $access_token  =  $api_client->o_auth_post('grant_type' => "client_credentials", 'client_id' => $api_client->{config}->{app_sid}, 'client_secret' =>$api_client->{config}->{app_key})->access_token;
    $api_client->{config}->{access_token} = $access_token;
    my $base_url =  $api_client->{config}->{base_url};
    
    if( substr( $base_url,length($base_url)-1,1) eq '/'){
         $base_url =  $base_url . $api_client->{config}->{api_version};

 view release on metacpan or  search on metacpan

lib/AsposeSlidesCloud/ApiClient.pm  view on Meta::CPAN

# @param array $headerParams header parameters (by ref)
sub update_params_for_auth {
    my ($self, $header_params) = @_;
    if ((defined $self->{config}{app_sid} && $self->{config}{app_sid} ne "") && (!defined $self->{config}{access_token} || $self->{config}{access_token} eq "")) {
        my $_url = ($self->{config}{auth_base_url} // $self->{config}{base_url}) . "/connect/token";
        my $_request = POST($_url, {}, Content => 'grant_type=client_credentials&client_id='.$self->{config}{app_sid}.'&client_secret='.$self->{config}{app_key});
        my $_response = $self->{ua}->request($_request);
        unless ($_response->is_success) {
            my $content = sprintf("%s", $_response->content);
            croak(sprintf "API Exception(%s): %s\n%s", 401, $_response->message, $content);
        }

 view release on metacpan or  search on metacpan

share/lexicons/com/atproto/identity/getRecommendedDidCredentials.json  view on Meta::CPAN

  "lexicon": 1,
  "id": "com.atproto.identity.getRecommendedDidCredentials",
  "defs": {
    "main": {
      "type": "query",
      "description": "Describe the credentials that should be included in the DID doc of an account that is migrating to this service.",
      "output": {
        "encoding": "application/json",
        "schema": {
          "type": "object",
          "properties": {

 view release on metacpan or  search on metacpan

lib/Audio/Scrobbler2.pm  view on Meta::CPAN

=head2 new

    my $scrobbler = Audio::Scrobbler2->new($api_key, $api_secret);

Creates a client. Both credentials are required.

=head2 auth_getToken

    my $token = $scrobbler->auth_getToken;

 view release on metacpan or  search on metacpan

lib/Auth/ActiveDirectory.pm  view on Meta::CPAN

use warnings FATAL => 'all';
use Net::LDAP qw[];
use Net::LDAP::Constant qw[LDAP_INVALID_CREDENTIALS];
my $ErrorCodes = {
    '525' => { error => 'user not found' },
    '52e' => { error => 'invalid credentials' },
    '530' => { error => 'not permitted to logon at this time' },
    '531' => { error => 'not permitted to logon at this workstation' },
    '532' => { error => 'password expired' },
    '533' => { error => 'data 533' },
    '701' => { error => 'account expired' },

 view release on metacpan or  search on metacpan

lib/Authen/CAS/External.pm  view on Meta::CPAN

	# Return the last response
	return $self->previous_response;
}

sub get_cas_credentials {
	my ($self, $service) = @_;

	# This default callback stub simply returns the stored
	# credentials
	if (!$self->has_username) {
		confess 'Unable to authenticate because no username was provided';
	}

	if (!$self->has_password) {

lib/Authen/CAS/External.pm  view on Meta::CPAN

	# Splice out the variables
	my ($username, $service) = @args{qw(username service)};

	# This default callback stub simply returns the stored
	# credentials
	if (!$self->has_ticket_granting_cookie) {
		return;
	}

	# Return ticket granting ticket

lib/Authen/CAS/External.pm  view on Meta::CPAN

This is a string that specifies the service value to send to the CAS server.
The default is to not send any service parameter.

=back

=head2 get_cas_credentials

This method is not actually used, but is required for classes to consume the
L<Authen::CAS::External::UserAgent|Authen::CAS::External::UserAgent> role as
this class does. This method will return the currently set username and
password to the user agent.

 view release on metacpan or  search on metacpan

t/01-tests.t  view on Meta::CPAN

	htusers => "t/htusers",
	htgroups => "t/htgroups",
)};

ok($atest->can("check"), "load auth files");
ok($atest->check("ryan", "fuckface"), "valid credentials check");
ok(!$atest->check("ryan", "ilikecheese"), "invalid credentials check");
ok($atest->check(qw/ryan fuckface/, groups => [
	[One => qw/admin users/],
	qw/middleclass american/, ]),
	"valid groups check");
ok($atest->groupcheck("ryan", groups => [

 view release on metacpan or  search on metacpan

lib/Authen/Credential.pm  view on Meta::CPAN

  $req = HTTP::Request->new(GET => $url);
  $req->header(Authorization => $cred->prepare("HTTP.Basic"));

=head1 DESCRIPTION

This module offers abstractions of credentials, i.e. something that
can be used to authenticate. It allows the creation and manipulation of
credentials. In particular, it defines a standard string representation
(so that credentials can be given to external programs as command line
options), a standard structured representation (so that credentials can
be stored in structured configuration files or using JSON) and
"preparators" that can transform credentials into ready-to-use data for
well known targets.

Different authentication schemes (aka credential types) are supported.
This package currently supports C<none>, C<plain> and C<x509> but others
can be added by providing the supporting code in a separate module.

A Python implementation of the same credential abstractions is available
at L<https://github.com/cern-mig/python-auth-credential> so credentials
can be shared between different programming languages.

For a given scheme, a credential is represented by an object with a
fixed set of string attributes. For instance, the C<plain> scheme has
two attributes: C<name> and C<pass>. More information is provided by