view release on metacpan or  search on metacpan

lib/File/KDBX/Key.pm  view on Meta::CPAN

version 0.906

=head1 DESCRIPTION

A master key is one or more credentials that can protect a KDBX database. When you encrypt a database with
a master key, you will need the master key to decrypt it. B<Keep your master key safe!> If someone gains
access to your master key, they can open your database. If you forget or lose any part of your master key, all
data in the database is lost.

There are several different types of keys, each implemented as a subclass:

 view release on metacpan or  search on metacpan

lib/File/RsyncP.pm  view on Meta::CPAN

returns undef.

=item serverService(module, authUser, authPasswd, authRequired)

Specify which module to use (a "module" is the symbolic name that
appears inside "[...]" /etc/rsyncd.conf), the user's credentials
(authUser and authPasswd) and whether authorization is mandatory
(authRequired). If set to a non-zero value, authRequired ensures
that the remote Rsync daemon requires authentication.  If necessary,
this is to ensure that you don't connect to an insecure Rsync daemon.
The auth arguments are optional if the selected rsyncd module doesn't

 view release on metacpan or  search on metacpan

lib/Finance/Alpaca/DataStream.pm  view on Meta::CPAN

=item C<402>

    { T => 'error', code => 402, msg => 'auth failed' }

You have provided invalid authentication credentials.

=item C<403>

    { T => 'error', code => 403, msg => 'already authenticated' }

 view release on metacpan or  search on metacpan

lib/Finance/Bank/Bankwest/Error/NotLoggedIn/SubsequentLogin.pm  view on Meta::CPAN

=head1 DESCRIPTION

This exception may be thrown on calls to various methods of
L<Finance::Bank::Bankwest::Session> when the Bankwest Online Banking
session has been terminated due to another session being established
with the same credentials.

=head1 SEE ALSO

 view release on metacpan or  search on metacpan

lib/Finance/Bank/Cahoot.pm  view on Meta::CPAN

sub new
{
  my ($class, %opts) = @_;

  croak 'Must provide a credentials handler' if not exists $opts{credentials};

  my $self = { _mech        => new WWW::Mechanize(autocheck => 1),
	       _credentials => $opts{credentials},
	       _connected   => 0,
	     };
  $self->{_mech}->agent_alias('Mac Safari');

  bless $self, $class;
  $self->_set_credentials(%opts);
  return $self;
}

sub _set_credentials
{
  my ($self, %opts) = @_;

  croak 'Must provide either a premade credentials object or a class name together with options'
      if not exists $opts{credentials};

  if (ref $opts{credentials}) {
    croak 'Not a valid credentials object'
      if not $self->_isa_credentials($opts{credentials});

    croak 'Can\'t accept credential options if supplying a premade credentials object'
	if exists $opts{credentials_options};

    $self->{_credentials} = $opts{credentials};
  } else {
    croak 'Must provide credential options unless suppying a premade credentials object'
	if not exists $opts{credentials_options};

    $self->{_credentials} =
      $self->_new_credentials($opts{credentials}, $opts{credentials_options});
  }
  return $self;
}

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

  croak 'Invalid class name'
    if $class !~ /^(?:\w|::)+$/;

  my $full_class = 'Finance::Bank::Cahoot::CredentialsProvider::'.$class;

  eval "local \$SIG{'__DIE__'}; local \$SIG{'__WARN__'}; require $full_class;";  ## no critic
  croak 'Not a valid credentials class - not found' if $EVAL_ERROR;

  my $credentials;
  {
    local $Carp::CarpLevel = $Carp::CarpLevel + 1;   ## no critic
    $credentials = $full_class->new(credentials => [@REQUIRED_SUBS],
				    options => $options);
  }
  croak 'Not a valid credentials class - incomplete' if not $self->_isa_credentials($credentials);
  return $credentials;
}

sub _isa_credentials
{
  my ($self, $credentials) = @_;

  foreach my $sub (@REQUIRED_SUBS) {
    return unless defined eval {
      local $SIG{'__DIE__'};       ## no critic
      local $SIG{'__WARN__'};      ## no critic
      $credentials->can($sub);
    };
  }

  return 1;
}

lib/Finance/Bank/Cahoot.pm  view on Meta::CPAN

  my ($self) = @_;

  return if $self->{_connected};

  $self->_get('https://securebank.cahoot.com/AquariusSecurity/bks/web/en/core_banking/log_in/frameset_top_log_in.jsp');
  my %fields = (inputuserid => $self->{_credentials}->username());
  my $content = $self->{_mech}->content;
  foreach my $input ($self->{_mech}->find_all_inputs()) {
     my $name = $input->name();
     next if not defined $name;
     next if defined $fields{$name};
     $fields{$name} = $self->{_credentials}->place() if $content =~ /address or place:/i;
     $fields{$name} = $self->{_credentials}->date() if $content =~ /memorable year:/i;
     $fields{$name} = $self->{_credentials}->maiden() if $content =~ /maiden name:/i;
  }
  $self->_submit_form(fields => \%fields);

  my %chars;
  my $label;

lib/Finance/Bank/Cahoot.pm  view on Meta::CPAN

  {
    # We submit a form, modifying hidden fields - WWW::Mechanize does not like
    # this (see FAQ).
    local $^W = 0; ## no critic
    $self->_submit_form(fields => { passwordChar1Hidden => $self->{_credentials}->password($chars{1}),
				    passwordChar2Hidden => $self->{_credentials}->password($chars{2}),
				    passwordChar1 => q{*},
				    passwordChar2 => q{*} });
  }
  $self->{_connected} = 1;
  return $self;

lib/Finance/Bank/Cahoot.pm  view on Meta::CPAN

either C<Crypt::SSLeay> or C<IO::Socket::SSL> installed for HTTPS
support to work with WWW::Mechanize.

=head1 SYNOPSIS

  my $cahoot = Finance::Bank::Cahoot->new(credentials => 'Constant',
                                          credentials_options => {
                                             account => '12345678',
                                             password => 'verysecret',
					     place => 'London',
					     date => '01/01/1906',
					     username => 'dummy',

lib/Finance/Bank/Cahoot.pm  view on Meta::CPAN

=item B<new>

Create a new instance of a connection to the Cahoot server. 

C<new> can be called in two different ways. It can take a single parameter,
C<credentials>, which will accept an already created credentials object, of type 
C<Finance::Bank::Cahoot::CredentialsProvider::*>. Alternatively, it can take two
parameters, C<credentials> and C<credentials_options>. In this case 
C<credentials> is the name of a credentials class to create an instance of, and
C<credentials_options> is a hash of the options to pass-through to the
constructor of the chosen class.

If the second form of C<new> is being used, and the chosen class is I<not> one
of the ones supplied as standard then it will need to be C<required> first.

If any errors occur then C<new> will C<croak>.

  my $cahoot = Finance::Bank::Cahoot->new(credentials => 'Constant',
                                          credentials_options => {
                                             account => '12345678',
                                             password => 'verysecret',
					     place => 'London',
					     date => '01/01/1906',
					     username => 'dummy',
					     maiden => 'Smith' } );

  # Or create the credentials object ourselves
  my $credentials = Finance::Bank::Cahoot::CredentialsProvider::Constant->new(
     account => '12345678', password => 'verysecret', place => 'London',
     date => '01/01/1906', username => 'dummy', maiden => 'Smith' } );
  my $cahoot = Finance::Bank::Cahoot->new(credentials => $credentials);

=item B<login>

Login to the Cahoot server using the credentials supplied to C<new>. This method
is implicit for all data access methods, so typically does not need to be called
explicitly. The method takes no arguments and will only call one of memorable
place, date or mother's maiden name as expected by the Cahoot portal.

=item B<accounts>

Returns a list reference containing a summary of any accounts available from
the supplied credentials. If a login has yet to occur C<accounts> will
automatically do this.

  my $accounts = $cahoot->accounts;

Each item in the list is a hash reference that holds summary information for a

 view release on metacpan or  search on metacpan

CreateCard.pm  view on Meta::CPAN

	$self->{password} = $password;

}

sub get_basic_credentials {

	my($self, $realm, $uri) = @_;

	my $netloc = $uri->host_port;

 view release on metacpan or  search on metacpan

DeutscheBank.pm  view on Meta::CPAN

=back

=head2 login()

Closes the current session and logs in to the website using
the credentials given at construction time.

=head2 close_session()

Closes the session and invalidates it on the server.

 view release on metacpan or  search on metacpan

t/methods/live/login.t  view on Meta::CPAN

my $account = Finance::Bank::DE::NetBank->new(%config);

ok( defined($account->login()), 'login with offical demo login works');

$account->CUSTOMER_ID("broken");
ok( !defined($account->login()), 'broken credentials must not work' );
ok( !defined($account->statement()), 'statement() must not work with broken credentials' );
ok( !defined($account->saldo()), 'saldo() must not work with broken credentials' );

 view release on metacpan or  search on metacpan

lib/Finance/Bank/IE/BankOfIreland.pm  view on Meta::CPAN

}


=item * $self->_set_creds_fields( $config )

  Parse the last received page for credentials entry fields, and populate them with the data from C<$config>. Also injects the missing 'form:continue' hidden field.

=cut
sub _set_creds_fields {
    my $self = shift;
    my $confref = shift;

 view release on metacpan or  search on metacpan

lib/Finance/Bank/Natwest.pm  view on Meta::CPAN

either C<Crypt::SSLeay> or C<IO::Socket::SSL> installed for HTTPS
support to work with LWP.

=head1 SYNOPSIS

  my $nw = Finance::Bank::Natwest->new( credentials => 'Constant',
                                        credentials_options => {
					   dob => '010179',
					   uid => '0001',
					   password => 'Password',
					   pin => '4321' } );

lib/Finance/Bank/Natwest.pm  view on Meta::CPAN

=over 4 

=item B<new>

  my $nw = Finance::Bank::Natwest->new( credentials => 'Constant',
                                        credentials_options => {
					   dob => '010179',
					   uid => '0001',
					   password => 'Password',
					   pin => '4321' }
  );

  # Or create the credentials object ourselves
  my $credentials = Finance::Bank::Natwest::CredentialsProvider::Constant->new(
     dob => '010179', uid => '0001', password => 'Password', pin => '4321' );

  my $nw = Finance::Bank::Natwest->new( credentials => $credentials );


C<new> can be called in two different ways. It can take a single parameter,
C<credentials>, which will accept an already created credentials object, of type 
C<Finance::Bank::Natwest::CredentialsProvider::*>. Alternatively, it can take two
parameters, C<credentials> and C<credentials_options>. In this case 
C<credentials> is the name of a credentials class to create an instance of, and
C<credentials_options> is a hash of the options to pass-through to the
constructor of the chosen class.

If the second form of C<new> is being used, and the chosen class is I<not> one
of the ones supplied as standard then it will need to be C<required> first.

lib/Finance/Bank/Natwest.pm  view on Meta::CPAN

  # Or get a list ref instead
  my $accounts = $nw->accounts;

Returns a list containing a summary of any accounts available from the
supplied credentials. Each item in the list is a hash reference that holds
summary information for a single account, and contains this data:

=over 4

=item B<name> - the name of the account

 view release on metacpan or  search on metacpan

lib/Finance/Bank/Postbank_de.pm  view on Meta::CPAN

=back

=head2 $account->new_session

Closes the current session and logs in to the website using
the credentials given at construction time.

=head2 $account->close_session

Closes the session and invalidates it on the server.

 view release on metacpan or  search on metacpan

lib/Finance/BankVal/UK.pm  view on Meta::CPAN

	}
}

sub loadContent {
	$json =
"{'credentials':{'uname':'$uid','pin':'$pin'},'account':{'account':'$account','sortcode':'$sortcode'}}";
}

#sub to format the error message in the correct expected format with all nodes etc
sub formatErrorMsg {
	if ( substr( $responseString, 0, 7 ) eq 'INVALID' ) {

 view release on metacpan or  search on metacpan

TODO  view on Meta::CPAN

IPN.pm is not tested and likely doesnt fully work.
- find a way to test this.

Setup a test webserver so it can send fake BitPay responses when requested.
- this allows the class methods to be tested without the need for BitPay merchant credentials.

 view release on metacpan or  search on metacpan

bin/coinbasepro.pl  view on Meta::CPAN

        secret => $config->{coinbasepro}{api_secret} || $ENV{GDAX_API_SECRET} || "",
        passphrase => $config->{coinbasepro}{api_passphrase} || $ENV{GDAX_API_PASSPHRASE} || "",
        debug => 0
    );
    if ( !$creds[0]  || !$creds[1] || !$creds[2] ) {
        warn "$prog: no credentials in " . join(", ", get_possible_config_filenames()) . " or env vars GDAX_API_(KEY|SECRET|PASSPHRASE)\n";
    }

    $SIG{__DIE__}  = \&Carp::confess;
    $SIG{__WARN__} = \&Carp::confess;

 view release on metacpan or  search on metacpan

CompanyNames/TextSupport.pm  view on Meta::CPAN

crease creased creases creasing
create created creater creates creating creation creationism creations creative creatively creativeness creatives creativity creator creators
creationist creationists
creature creatures
creche creches
credential credentialed credentialing credentials
credentialled credentialling
credenza credenzas
credibility credible credibly
credit creditability creditable creditably credited crediting credits
creditor creditors

 view release on metacpan or  search on metacpan

lib/Finance/FXCM/Simple.pm  view on Meta::CPAN

Your FXCM account password

=item C<$type>

The account type the login credentials apply to. Either 'Demo' or 'Real'.


=item C<$url>

The url to connect to, typically this will be 'http://www.fxcorporate.com/Hosts.jsp'

 view release on metacpan or  search on metacpan

lib/Finance/GDAX/API.pm  view on Meta::CPAN

passphrase:andTHisiSMypassPhraSE

There can be comments ("#" beginning a line), and blank lines.

In other words, for exmple, if you cryptographically store your API
credentials, you can create a small callable program that will decrypt
them and provide them, so that they never live on disk unencrypted,
and never show up in process listings:

  my $request = Finance::GDAX::API->new;
  $request->external_secret('/path/to/my_decryptor', 1);

 view release on metacpan or  search on metacpan

Testing/test-record.pl  view on Meta::CPAN

# This file needs a valid account to do anything useful. 
# This will be your account, not mine! 
# You can hardcode here or use a credential fiie. 
# Running this script will allow you to generate 
# new canned test data for new test scripts. 
if ( eval (require "credentials.pl") ) 
{
  $ig=Finance::IG->new(cred()); 
} 
else
{ 

 view release on metacpan or  search on metacpan

lib/Finance/MtGox.pm  view on Meta::CPAN

=head1 BASIC METHODS

=head2 new

Create a new C<Finance::MtGox> object with your MtGox credentials provided
in the C<key> and C<secret> arguments.

=cut

sub new {
    my ( $class, $args ) = @_;

    $args->{key} && $args->{secret}
      or croak "You must provide 'key' and 'secret' credentials.";

    $args->{json} = JSON::Any->new;
    $args->{mech} = WWW::Mechanize->new(stack_depth => 0);

    return bless $args, $class;

 view release on metacpan or  search on metacpan

lib/Finance/PaycheckRecords/Fetcher.pm  view on Meta::CPAN

    mech     => WWW::Mechanize->new,
  }, $class;
} # end new

#---------------------------------------------------------------------
# Get a URL, automatically supplying login credentials if needed:

sub _get
{
  my ($self, $url) = @_;

 view release on metacpan or  search on metacpan

YahooQuote.pm  view on Meta::CPAN

    my $self = LWP::UserAgent::new(@_);
    $self->agent("Finance-YahooQuote/0.18");
    $self;
  }

  sub get_basic_credentials {
    my $self = @_;
    if (defined($PROXYUSER) and defined($PROXYPASSWD) and
 	$PROXYUSER ne "" and $PROXYPASSWD ne "") {
      return ($PROXYUSER, $PROXYPASSWD);
    } else {

 view release on metacpan or  search on metacpan

lib/Firefox/Marionette.pm  view on Meta::CPAN

        $authenticator = $self->webauthn_authenticator();
    }
    return $authenticator;
}

sub webauthn_credentials {
    my ( $self, $parameter_authenticator ) = @_;
    my $authenticator = $self->_get_webauthn_authenticator(
        authenticator => $parameter_authenticator );
    my $message_id = $self->_new_message_id();
    $self->_send_request(

lib/Firefox/Marionette.pm  view on Meta::CPAN

          MIME::Base64::decode_base64url( $credential->{userHandle} );
    }
    return $credential;
}

sub delete_webauthn_all_credentials {
    my ( $self, $parameter_authenticator ) = @_;
    my $authenticator = $self->_get_webauthn_authenticator(
        authenticator => $parameter_authenticator );
    my $message_id = $self->_new_message_id();
    $self->_send_request(

lib/Firefox/Marionette.pm  view on Meta::CPAN

accepts a hash of the following keys;

=over 4

=item * has_resident_key - boolean value to indicate if the authenticator will support L<client side discoverable credentials|https://www.w3.org/TR/webauthn-2/#client-side-discoverable-credential>

=item * has_user_verification - boolean value to determine if the L<authenticator|https://www.w3.org/TR/webauthn-2/#virtual-authenticators> supports L<user verification|https://www.w3.org/TR/webauthn-2/#user-verification>.

=item * is_user_consenting - boolean value to determine the result of all L<user consent|https://www.w3.org/TR/webauthn-2/#user-consent> L<authorization gestures|https://www.w3.org/TR/webauthn-2/#authorization-gesture>, and by extension, any L<test o...

lib/Firefox/Marionette.pm  view on Meta::CPAN

    $firefox->find_id('input-email')->type($user_name);
    $firefox->find_id('register-button')->click();
    $firefox->await(sub { sleep 1; $firefox->find_class('alert-success'); });
    $firefox->find_id('login-button')->click();
    $firefox->await(sub { sleep 1; $firefox->find_class('hero confetti'); });
    foreach my $credential ($firefox->webauthn_credentials()) {
        $firefox->delete_webauthn_credential($credential);

# ... time passes ...

        $firefox->add_webauthn_credential(

lib/Firefox/Marionette.pm  view on Meta::CPAN

will remove the L<User-Agent|https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/User-Agent>, L<Accept|https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Accept> and L<Accept-Encoding|https://developer.mozilla.org/en-US/docs/Web/HTTP/Hea...

This method returns L<itself|Firefox::Marionette> to aid in chaining methods.

=head2 delete_webauthn_all_credentials

This method accepts an optional L<authenticator|Firefox::Marionette::WebAuthn::Authenticator>, in which case it will delete all L<credentials|Firefox::Marionette::WebAuthn::Credential> from this authenticator.  If no parameter is supplied, the defaul...

    my $firefox = Firefox::Marionette->new();
    my $authenticator = $firefox->add_webauthn_authenticator( transport => Firefox::Marionette::WebAuthn::Authenticator::INTERNAL(), protocol => Firefox::Marionette::WebAuthn::Authenticator::CTAP2() );
    $firefox->delete_webauthn_all_credentials($authenticator);
    $firefox->delete_webauthn_all_credentials();

=head2 delete_webauthn_authenticator

This method accepts an optional L<authenticator|Firefox::Marionette::WebAuthn::Authenticator>, in which case it will delete this authenticator from the current Firefox instance.  If no parameter is supplied, the default authenticator will be deleted.

lib/Firefox/Marionette.pm  view on Meta::CPAN

    use Firefox::Marionette();

    my $firefox = Firefox::Marionette->new();
    my $authenticator = $firefox->add_webauthn_authenticator( transport => Firefox::Marionette::WebAuthn::Authenticator::INTERNAL(), protocol => Firefox::Marionette::WebAuthn::Authenticator::CTAP2() );
    foreach my $credential ($firefox->webauthn_credentials($authenticator)) {
        $firefox->delete_webauthn_credential($credential, $authenticator);
    }

just a L<credential|Firefox::Marionette::WebAuthn::Credential>, in which case it will remove the credential from the default authenticator.

    use Firefox::Marionette();

    my $firefox = Firefox::Marionette->new();
    ...
    foreach my $credential ($firefox->webauthn_credentials()) {
        $firefox->delete_webauthn_credential($credential);
    }

This method returns L<itself|Firefox::Marionette> to aid in chaining methods.

lib/Firefox/Marionette.pm  view on Meta::CPAN

=head2 webauthn_authenticator

returns the default L<WebAuthn authenticator|Firefox::Marionette::WebAuthn::Authenticator> created when the L<new|/new> method was called.

=head2 webauthn_credentials

This method accepts an optional L<authenticator|Firefox::Marionette::WebAuthn::Authenticator>, in which case it will return all the L<credentials|Firefox::Marionette::WebAuthn::Credential> attached to this authenticator.  If no parameter is supplied,...

    use Firefox::Marionette();
    use v5.10;

    my $firefox = Firefox::Marionette->new();
    foreach my $credential ($firefox->webauthn_credentials()) {
       say "Credential host is " . $credential->host();
    }

    # OR

    my $authenticator = $firefox->add_webauthn_authenticator( transport => Firefox::Marionette::WebAuthn::Authenticator::INTERNAL(), protocol => Firefox::Marionette::WebAuthn::Authenticator::CTAP2() );
    foreach my $credential ($firefox->webauthn_credentials($authenticator)) {
       say "Credential host is " . $credential->host();
    }

=head2 webauthn_set_user_verified

 view release on metacpan or  search on metacpan

lib/Firefox/Sync/Client.pm  view on Meta::CPAN

    my ($self, $url) = @_;

    # Initialize LWP
    my $ua = LWP::UserAgent->new;
    $ua->agent ("FFsyncClient/0.1 ");
    $ua->credentials ( $self->{'hostname'} . ':' . $self->{'port'}, 'Sync', $self->{'username'} => $self->{'password'} );

    # Do the request
    my $res = $ua->get($url);
    die $res->{'_msg'} if ($res->{'_rc'} != '200');

 view release on metacpan or  search on metacpan

doc/examples/petmarket/petmarket/api/userservice.pm  view on Meta::CPAN

sub methodTable
{
    return {
        "addUser" => {
            "description" => "Add a user with the given credentials",
            "access" => "remote", 
        },
        "getUser" => {
            "description" => "Add a user with the given credentials",
            "access" => "remote", 
        },
        "updateUser" => {
            "description" => "Add a user with the given credentials",
            "access" => "remote", 
        },
    };
    
}

 view release on metacpan or  search on metacpan

lib/Flickr/Upload/FireEagle.pm  view on Meta::CPAN

Aaron Straup Cope <ascope@cpan.org>

=head1 NOTES

Aside from requiring your own Flickr API key, secret and authentication token
you will also need similar FireEagle (OAuth) credentials. Since Flickr::Upload::FireEagle
already requires that you install the excellent I<Net::FireEagle> you should just
use the command line I<fireeagle> client for authorizing yourself with FireEagle.

=head1 SEE ALSO

 view release on metacpan or  search on metacpan

flickr_upload  view on Meta::CPAN

    else {
        die "Unable to initiate OAuth authorization. Response from Flickr was: '$response'\n";
    }
    my $ac_rc = $ua->oauth_access_token(\%request_token);
    if($ac_rc eq 'ok') {
        print "Saving OAuth credentials to $oauth_config\n";
        $ua->export_storable_config($oauth_config);
    }
}

if(!exists $args{'auth_token'} && -r $oauth_config) {
    $ua = Flickr::Upload->import_storable_config($oauth_config);
    bless $ua, 'Flickr::Upload';
}

die "No auth token or OAuth credentials found.\nUse --auth or --oauth to generate credentials or --auth_token to specify a token.\n"
    unless exists $args{'auth_token'} || $ua->is_oauth;

if( $check ) {
	exit( checkToken( $ua, $args{api_key}, $args{auth_token} ) );
}

flickr_upload  view on Meta::CPAN

Authentication token. You B<must> get an authentication token using
C<--auth> before you can upload images. See the L<EXAMPLES> section.

=item --oauth

Interactively perform OAuth authorization with Flickr. The user will get a URL to visit at Flickr at which Flickr::Upload must be granted write permissions. After granting permission, the user will be redirected to a dummy URL that contains an OAuth ...

=item --title <title>

Title to use on all the images. Optional.

flickr_upload  view on Meta::CPAN

Note that options unknown to Flickr will result in undefined behaviour.

=item --check

Checks the authentication token via the flickr.auth.checkToken API call.
This can be used to verify API keys and credentials without trying to
upload an image. The output is the raw results of the API call.

=item --progress, --no-progress

Display a progress bar for each upload with L<Term::ProgressBar>. That

 view release on metacpan or  search on metacpan

lib/Footprintless/Plugin/Ldap/Ldap.pm  view on Meta::CPAN

    my ( $self, $dn, %options ) = @_;
    croak('not connected') unless ( $self->{connection} );

    if ( !$dn ) {

        # binding with instance credentials
        $dn      = $self->{bind_dn};
        %options = %{ $self->{bind_options} };
    }

    if ($dn) {

 view release on metacpan or  search on metacpan

t/Footprintless.t  view on Meta::CPAN

my ($fpl);

ok( $fpl = Footprintless->new(
        config_dirs            => File::Spec->catdir( $test_dir,  'config/entities' ),
        config_properties_file => File::Spec->catfile( $test_dir, 'config/credentials.pl' )
    ),
    'load data/entities'
);

ok( $fpl->entities()->{dev}, 'root is dev' );

 view release on metacpan or  search on metacpan

TODO  view on Meta::CPAN

            t/24e-kill.t does not terminate

    _X_ have a "remote_host" option to go with "cmd" option
        _X_ remote_host => host
        _X_ remote_host => [host, user, pwd]
            to run on a remote server that requires some credentials
        _X_ remote_host => [ \@hosts ]  or  [ \@hosts, user, pwd ]
            to run on any of a cluster of available remote hosts
        _X_ allow a separate MAX_PROC-like setting to be used for
            remote hosts
        ___ remote_host_proto => 'ssh'

 view release on metacpan or  search on metacpan

lib/LWP/UserAgent/FramesReady.pm  view on Meta::CPAN

Get/set the B<$self->{'nomax'}> can be used by the included callback
routine to enforce truncation of received content even if the request
to do so is not honored by the server called for the content.

=item $ua->credent([$credentials])

Get/set the credentials for authentification if called for.

=item $ua->errors()

Get the last error encountered if a return was an undef.  This routine
has only been tested in development so there is no guarantee that it

lib/LWP/UserAgent/FramesReady.pm  view on Meta::CPAN

    }

    return 1;
}

=item $ua->get_basic_credentials()

This routine overloads the LWP::UserAgent::get_basic_credentials in
order to supply authorization if it has been pre-loaded an initial/new
or by use of the $ua->credent() routine.  Supplies a return in a list
context of a UserID and a Password to LWP::UserAgent::credentials().

=cut

sub get_basic_credentials {
    my($self, $realm, $uri) = @_;

    $self->{'errstring'} = '';
    if ($self->{credent}) {
        return split(':', $self->{credent}, 2);