credentials results from the CPAN

lib/Catalyst/Authentication/Realm/Adaptor.pm view on Meta::CPAN

The Catalyst::Authentication::Realm::Adaptor allows for modification of
authentication parameters within the catalyst application. It's basically a
filter used to adjust authentication parameters globally within the
application or to adjust user retrieval parameters provided by the credential
in order to be compatible with a different store. It provides for better
control over interaction between credentials and stores. This is particularly
useful when working with external authentication such as OpenID or OAuth.

 __PACKAGE__->config(
    'Plugin::Authentication' => {
            'default' => {

view all matches for this distribution

Catalyst-Authentication-Store-LDAP

5 results

lib/Catalyst/Authentication/Store/LDAP.pm view on Meta::CPAN

wide variation of LDAP directories and schemas from one system to another.

It authenticates users in two steps:

1) A search of the directory is performed, looking for a user object that
   matches the username you pass.  This is done with the bind credentials
   supplied in the "binddn" and "bindpw" configuration options.

2) If that object is found, we then re-bind to the directory as that object.
   Assuming this is successful, the user is Authenticated.

view all matches for this distribution

Catalyst-Authentication-Store-UserXML

2 results

lib/Catalyst/Authentication/Store/UserXML.pm view on Meta::CPAN

            }
        },
        'authentication' => {
            'userxml' => {
                'folder' => 'members',
                'user_folder_file' => 'index.xml',   # optional if credentials stored one per folder
            }
        },
    );

    # later in controller (login)

view all matches for this distribution

Catalyst-Controller-Atompub

1 match

inc/Test/WWW/Mechanize/Catalyst.pm view on Meta::CPAN

    $self->_set_host_header($request);

    my $res = $self->_check_external_request($request);
    return $res if $res;

    my @creds = $self->get_basic_credentials( "Basic", $uri );
    $request->authorization_basic( @creds ) if @creds;

    require Catalyst;
    my $response = $Catalyst::VERSION >= 5.89000 ?
      Catalyst::Test::_local_request($self->{catalyst_app}, $request) :

view all matches for this distribution

Catalyst-Helper-AuthDBIC

2 results

script/auth_bootstrap.pl view on Meta::CPAN

         help => \$help);

pod2usage(1) if ( $help || !$credential );

if  ($credential !~ /^(http|password)$/) {
    die "Valid credentials are 'http' for basic auth or 'password' for web based auth";
}

Catalyst::Helper::AuthDBIC::make_model();
Catalyst::Helper::AuthDBIC::mk_auth_controller() if $credential eq 'password';
Catalyst::Helper::AuthDBIC::add_plugins();

view all matches for this distribution

Catalyst-Manual

1 match

lib/Catalyst/Manual/Components.pod view on Meta::CPAN

config hash. Great for testing or getting up and running quickly.

=head4 L<Catalyst::Authentication::Store::Null>

The Null store is a transparent store where any supplied user data is
accepted.  This is mainly useful for remotely authenticating credentials
(e.g. OpenID) which may not be tied to any local storage.

=head4 L<Catalyst::Authentication::Store::RDBO>

Allows access to authentication information stored in a database via a L<Rose::DB::Object> class.

view all matches for this distribution

Catalyst-Model-LDAP

1 match

lib/Catalyst/Model/LDAP/Connection.pm view on Meta::CPAN


On connection failure, an error is thrown using L<Carp/croak>.

=head2 bind

Bind to the configured LDAP server using the specified credentials.

    $conn->bind(
        dn       => 'uid=dwc,ou=People,dc=ufl,dc=edu',
        password => 'secret',
    );

view all matches for this distribution

Catalyst-Model-MultiAdaptor

1 match

inc/Test/WWW/Mechanize/Catalyst.pm view on Meta::CPAN

    }
 
    my $res = $self->_check_external_request($request);
    return $res if $res;

    my @creds = $self->get_basic_credentials( "Basic", $uri );
    $request->authorization_basic( @creds ) if @creds;

    my $response =Catalyst::Test::local_request($self->{catalyst_app}, $request);

    # LWP would normally do this, but we dont get down that far.

view all matches for this distribution

Catalyst-Model-SCP

1 match

lib/Catalyst/Model/SCP.pm view on Meta::CPAN


=head1 SUBROUTINES/METHODS

=head2 is_connection_success

C<is_connection_success()> - Returns true when it able to make connection using specified credentials.

=cut

has is_connection_success => (
    isa => 'Bool',

view all matches for this distribution

Catalyst-Plugin-AtomServer

2 results

lib/Catalyst/Plugin/Authentication/Credential/Atom.pm view on Meta::CPAN

use constant NS_WSSE => 'http://schemas.xmlsoap.org/ws/2002/07/secext';
use constant NS_WSU => 'http://schemas.xmlsoap.org/ws/2002/07/utility';

sub login_atom {
    my $c = shift;
    my($username, $cred) = $c->_extract_credentials;
    unless ($username) {
        return $c->_atom_auth_error(401);
    }

    if (my $user = $c->get_user($username)) {
        if ($c->_validate_credentials($user, $cred)) {
            $c->set_authenticated($user);
            return $username;
        }
    }
    return $c->_atom_auth_error(403);

lib/Catalyst/Plugin/Authentication/Credential/Atom.pm view on Meta::CPAN

    $c->response->header('WWW-Authenticate',
        'WSSE profile="UsernameToken", Basic');
    return 0;
}

sub _extract_credentials {
    my $c = shift;
    my $req = $c->request;
    my($tokens, $username, %cred);
    ## SOAP wrapper only supports WSSE?
    if ($req->is_soap) {

lib/Catalyst/Plugin/Authentication/Credential/Atom.pm view on Meta::CPAN

        $username = delete $cred{Username};
    }
    ($username, \%cred);
}

sub _validate_credentials {
    my $c = shift;
    my($user, $cred) = @_;
    if ($cred->{password}) {
        return $c->_check_password($user, $cred->{password})
    } elsif ($cred->{PasswordDigest}) {

view all matches for this distribution

Catalyst-Plugin-Authentication-Credential-HTTP-Proxy

2 results

lib/Catalyst/Plugin/Authentication/Credential/HTTP/Proxy.pm view on Meta::CPAN

    croak "url setting required for authentication" 
        unless $c->config->{authentication}{http_proxy}{url};
    if ( my ( $user, $password ) = $headers->authorization_basic ) {

        my $ua=Catalyst::Plugin::Authentication::Credential::HTTP::User->new;
        $ua->credentials($user,$password);
        my $resp= $ua->get($c->config->{authentication}{http_proxy}{url});
        if ( $resp->is_success ) {
            if ( my $store = $c->config->{authentication}{http_proxy}{store} ) {
                $user = $store->get_user($user);
            } elsif ( my $user_obj = $c->get_user($user) ) {

lib/Catalyst/Plugin/Authentication/Credential/HTTP/Proxy.pm view on Meta::CPAN

        } elsif ( $c->debug ) {
            $c->log->info('Remote authentication failed:'.$resp->message);
            return 0;
        }
    } elsif ( $c->debug ) {
        $c->log->info('No credentials provided for basic auth');
        return 0;
    }
}

sub authorization_required {

view all matches for this distribution

Catalyst-Plugin-Authentication-Credential-TypeKey

3 results

lib/Catalyst/Plugin/Authentication/Credential/TypeKey.pm view on Meta::CPAN


    my %ret;

    if ( @params % 2 == 1 ) {

        # either it's a user object or a hash ref of credentials
        # if it's a user object the credentials are pulled out of it
        # otherwise a user will be found/made for the credentials
        if ( Scalar::Util::blessed( $params[0] ) ) {
            my $user = $ret{user_object} = shift @params;

            croak "Attempted to authenticate user object, but "
              . "user doesnt't support 'typekey_credentials'"
              unless $user->supports(qw/typekey_credentials/);

            $ret{credentials} = $user->typekey_credentials;

        } elsif ( @params == 1 and ref( $params[0] ) eq "HASH" ) {
            $ret{credentials} = shift @params;
        } else {
            croak "Invalid parameters";
        }
    }

lib/Catalyst/Plugin/Authentication/Credential/TypeKey.pm view on Meta::CPAN

    foreach my $key (@config_fields) {
        # if it was passed as a parameter then move it to the right place
        $ret{$key} = delete $params{$key} || $config->{$key};
    }

    # separate TypeKey's config from credentials
    # these options override config
    $ret{typekey_config} = {};
    foreach my $key (grep { exists $params{$_} } @typekey_config_fields) {
        $ret{typekey_config}{$key} = delete $params{$key};
    }

lib/Catalyst/Plugin/Authentication/Credential/TypeKey.pm view on Meta::CPAN

    # get the object from config and apply local overrides
    $ret{typekey_object} = delete $params{typekey_object} || $c->get_typekey_object( %{ $ret{typekey_config} } );

    # Authen::TypeKey can also take CGI compatible objects
    if ( keys %params ) {
        $ret{credentials} = \%params;
    } else {
        $ret{credentials} = $c->request if not($ret{credentials}) or not( keys %{ $ret{credentials} } );
    }

    return \%ret;
}

lib/Catalyst/Plugin/Authentication/Credential/TypeKey.pm view on Meta::CPAN

    my ( $c, @params ) = @_;

    my $params = $c->_munge_typekey_params(@params);

    my $typekey    = $params->{typekey_object};
    my $cred       = $params->{credentials};
    my $user       = $params->{user_object};      # probably undef
    my $user_class = $params->{user_class};
    my $auth_store = $params->{auth_store};

    $c->last_typekey_object($typekey);

lib/Catalyst/Plugin/Authentication/Credential/TypeKey.pm view on Meta::CPAN

Any configuration field (this plugin's configuration, e.g. C<user_class>, as
well as any L<Authen::TypeKey> configuration fields, e.g. C<token>, etc) can
be in %parameters. This will clone the configured typekey object if needed and
set the fields locally for this call only.

All other fields are assumed to be typekey credentials.

If a user object is provided it will be asked for it's typekey credentials and
then authenticated against the server keys.

If there are no typekey credentials in the paramters or the user object, the
credentials will be taken from C<< $c->request >>.

If a user object exists and is authenticated correctly it will be marked as
authenticated. If no such object exists but C<auth_store> is provided (or
configured) then it will attempt to retrieve a user from that store using the
C<name> typekey credential field. If no C<auth_store> is configured or a user

view all matches for this distribution

Catalyst-Plugin-Authentication-Store-HTTP

4 results

lib/Catalyst/Plugin/Authentication/Store/HTTP.pm view on Meta::CPAN


=head1 DESCRIPTION

This module is Catalyst authentication storage plugin that
authenticates based on a URL HTTP HEAD fetch using the supplied
credentials.  If the fetch succeeds then the authentication succeeds.

L<LWP::UserAgent> is used to fetch the URL which requires authentication,
so any authentication method supported by that module can be used.

Remote authentication methods known to work are:-

lib/Catalyst/Plugin/Authentication/Store/HTTP.pm view on Meta::CPAN


=over 4

=item auth_url

The URL that is fetched to demonstrate that the supplied credentials
work.  This can be any URL that L<LWP::UserAgent> will support and
that will support a C<HEAD> method.  This item must be supplied.

=item keep_alive

view all matches for this distribution

Catalyst-Plugin-Authentication

9 results

lib/Catalyst/Authentication/Credential/NoPassword.pm view on Meta::CPAN


=head1 DESCRIPTION

This authentication credential checker takes authentication information 
(most often a username) and retrieves the user from the store. No validation
of any credentials is done. This is intended for administrative backdoors,
SAML logins and so on when you have identified the new user by other means.

=head1 CONFIGURATION

    # example

view all matches for this distribution

Catalyst-Plugin-OpenIDConnect

4 results

example/app.pl view on Meta::CPAN

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

    if ( $c->request->method eq 'POST' ) {
        my $username = $c->request->params->{username};

        # In a real application, validate credentials here
        if ( $username && length($username) > 0 ) {
            # Create a mock user object
            my $user = _create_mock_user($username);
            
            $c->session->{user_id} = $user->{id};

view all matches for this distribution

Catalyst-View-Reproxy

1 match

inc/Test/WWW/Mechanize/Catalyst.pm view on Meta::CPAN

    {
        return $self->SUPER::_make_request($request);
    }

    $request->authorization_basic(
        LWP::UserAgent->get_basic_credentials(
            undef, "Basic", $request->uri
        )
        )
        if LWP::UserAgent->get_basic_credentials( undef, "Basic",
        $request->uri );

    my $response = Test::WWW::Mechanize::Catalyst::Aux::request($request);
    $response->header( 'Content-Base', $request->uri );
    $response->request($request);

view all matches for this distribution

CatalystX-OAuth2

1 match

lib/Catalyst/Authentication/Credential/OAuth2.pm view on Meta::CPAN

      }
    );

=head1 DESCRIPTION

This module implements authentication via OAuth2 credentials, giving you a
user object which stores tokens for accessing protected resources.

=head1 ATTRIBUTES

=head2 grant_uri

view all matches for this distribution

Catmandu-Adlib

1 match

lib/Catmandu/Adlib/API/Login.pm view on Meta::CPAN

has username => (is => 'ro', required => 1);
has password => (is => 'ro', required => 1);

# login => moet helemaal anders!

sub get_basic_credentials {
    my ($self, $realm, $url) = @_;
    return $self->username, $self->password;
}

1;

view all matches for this distribution

Catmandu-OAI

1 match

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

sub _build_oai {
    my ($self) = @_;
    my $agent = HTTP::OAI::Harvester->new(baseURL => $self->url, resume => 0, keep_alive => 1);
    if( $self->has_username && $self->has_password ) {
        my $uri = URI->new( $self->url );
        my @credentials = (
            $uri->host_port,
            $self->realm || undef,
            $self->username,
            $self->password
        );
        $agent->credentials( @credentials );
    }
    $agent->env_proxy;
    $agent;
}

view all matches for this distribution

Chandra

2 results

examples/pack_example/pack.pl view on Meta::CPAN

#   cd examples/pack_example
#   perl pack.pl                       # builds for current platform
#   perl pack.pl --platform=linux      # cross-target
#   perl pack.pl --distribute          # build + sign/notarize/DMG (macOS) or AppImage (Linux)
#
# For distribution on macOS, configure signing credentials first:
#   Chandra::Pack->config(
#       identity  => 'Developer ID Application: ...',
#       apple_id  => 'your@email.com',
#       team_id   => 'TEAM123',
#   );

view all matches for this distribution

Chart-Plotly

1 match

share/plotly.js/plotly.min.js view on Meta::CPAN

 * The buffer module from node.js, for the browser.
 *
 * @author   Feross Aboukhadijeh <https://feross.org>
 * @license  MIT
 */
"use strict";var e=t("base64-js"),n=t("ieee754");r.Buffer=a,r.SlowBuffer=function(t){+t!=t&&(t=0);return a.alloc(+t)},r.INSPECT_MAX_BYTES=50;function i(t){if(t>2147483647)throw new RangeError('The value "'+t+'" is invalid for option "size"');var e=ne...
/*! Native Promise Only
    v0.8.1 (c) Kyle Simpson
    MIT License: http://getify.mit-license.org
*/
!function(t,r,n){r[t]=r[t]||n(),void 0!==e&&e.exports&&(e.exports=r[t])}("Promise",void 0!==t?t:this,(function(){"use strict";var t,e,n,i=Object.prototype.toString,a=void 0!==r?function(t){return r(t)}:setTimeout;try{Object.defineProperty({},"x",{}),...

view all matches for this distribution

Cisco-UCS

3 results

lib/Cisco/UCS.pm view on Meta::CPAN

Expires the current authentication token.  This method should always be called 
on completion of a script to expire the authentication token and free the 
current session for use by others.  The UCS XML API has a maximum number of 
available connections, and a maximum number of sessions per user.  In order to 
ensure that the session remain available (especially if using common 
credentials), you should always call this method on completion of a script, as 
an argument to die, or in any eval where a script may fail and exit before 
logging out;

=head3 cookie ()

view all matches for this distribution

Class-AutoDB

1 match

t/autodb.000.reqs.t view on Meta::CPAN

  $errstr or $errstr=DBI->errstr;
  my $diag=<<DIAG

These tests require that MySQL be running on 'localhost', that the user 
running the tests can access MySQL without a password, and with these
credentials, has sufficient privileges to (1) create a 'test' database, 
(2) create, alter, and drop tables in the 'test' database, (3) create and
drop views, and (4) run queries and updates on the database.

When verifying these capabilities, the test driver got the following
error message:

view all matches for this distribution

Class-User-DBI

13 results

    my $sth = $self->_db_run( $USER_QUERY{SQL_exists_user}, $self->userid );
    return defined $sth->fetchrow_array ? 1 : 0;
}

# Fetch user's salt_hex, pass_hex, ip_required, and valid ip's from database.
sub get_credentials {
    my $self = shift;
    my $sth = $self->_db_run( $USER_QUERY{SQL_get_credentials}, $self->userid );
    my ( $salt_hex, $pass_hex, $ip_required ) = $sth->fetchrow_array;
    return if not defined $salt_hex;    # User wasn't found.
    my @valid_ips = $self->get_valid_ips;
    return {
        userid      => $self->userid,


    # Save ourselves work if user is already authenticated.
    if ( !$force_revalidate && $self->validated ) {
        return 1;
    }
    my $credentials = $self->get_credentials;
    my $auth        = Authen::Passphrase::SaltedSHA512->new(
        salt_hex => $credentials->{salt_hex},
        hash_hex => $credentials->{pass_hex}
    );

    if ( !$auth->match($password) ) {
        $self->validated(0);
        return 0;
    }

    # Return 0 if an IP is required, and IP param is not in whitelist,
    # or no IP parameter passed.
    if ( $credentials->{ip_required} ) {
        if (   !defined $ip
            || !any { $ip eq $_ } @{ $credentials->{valid_ips} } )
        {
            $self->validated(0);
            return 0;
        }
    }


    return if !$self->exists_user;

    # If an old passphrase is supplied, only update if it validates.
    if ( defined $oldpass ) {
        my $credentials = $self->get_credentials;
        my $auth        = Authen::Passphrase::SaltedSHA512->new(
            salt_hex => $credentials->{salt_hex},
            hash_hex => $credentials->{pass_hex}
        );

        # Return undef if password doesn't authenticate for the user.
        return unless $auth->match($oldpass);    ## no critic (postfix)
    }


__END__

=head1 NAME

Class::User::DBI - A User class: Login credentials, roles, privileges, domains.

=head1 VERSION

Version 0.10

=head1 SYNOPSIS

This module models a "User" class, with login credentials, and Roles Based
Access Control.  Additionally, IP whitelists may be used as an additional
validation measure. Domain (locality) based access control is also provided
independently of role based access control.

A brief description of authentication:  Passphrases are stored as randomly

    my $validated   = $user->validated;
    my $invalidated = $user->validated(0);           # Cancel authentication.
    my $is_valid    = $user->validate( $pass, $ip ); # Validate including IP.
    my $is_valid    = $user->validate( $pass );      # Validate without IP.
    my $info_href   = $user->load_profile;
    my $credentials = $user->get_credentials;        # Returns a useful hashref.
    my @valid_ips   = $user->get_valid_ips;
    my $ip_required = $user->get_ip_required;
    my $success     = $user->set_ip_required(1);
    my $ exists     = $user->exists_user;
    my $success     = $user->delete_user;


The module is designed to simplify user logins, authentication, role based
access control (authorization), as well as domain (locality) constraint access
control.

It stores user credentials, roles, and basic user information in a database via
a DBIx::Connector database connection.

User passphrases are salted with a 512 bit random salt (unique per user) using
a cryptographically strong random number generator, and converted to a SHA2-512
digest before being stored in the database.  All subsequent passphrase


Use L<Class::User::DBI::Domains> to create a list of domains (localities), along
with their descriptions.

Use L<Class::User::DBI> (This module) to create a set of users, establish
login credentials such as passphrases and optional IP whitelists, and assign
them roles.

Use L<Class::User::DBI::UserDomains> to associate one or more localities
(domains) with each user.

database, such as C<< $user->delete_user >> will remove the cache entry, and
subsequent tests will access the database on each call to C<exists_user()>,
until such time that the result flips to positive again.


=head2  get_credentials

    my $credentials_href = $user->get_credentials;
    my @fields = qw( userid salt_hex pass_hex ip_required );
    foreach my $field ( @fields ) {
        print "$field => $credentials_href->{$field}\n";
    }
    my @valid_ips = @{$valid_ips};
    foreach my $ip ( @valid_ips ) {
        print "Whitelisted IP: $ip\n";
    }

Accepts no parameters.  Returns a hashref holding a small datastructure that
describes the user's credentials.  The structure looks like this:

    $href = {
        userid      => $userid,     # The target user's userid.

        salt_hex    => $salt,       # A 128 hex-character representation of

A typical usage probably won't require calling this function directly very
often, if at all.  In most cases where it would be useful to look at the salt,
the passphrase digest, and IP whitelists, the
C<< $user->validate( $passphrase, $ip ) >> method is easier to use and less
prone to error.  But for those cases I haven't considered, the
C<get_credentials()> method exists.


=head2 get_role

    my $user_role = $user->get_role;


=head1 DIAGNOSTICS

If you find that your particular database engine is not playing nicely with the
test suite from this module, it may be necessary to provide the database login 
credentials for a test database using the same engine that your application 
will actually be using.  You may do this by setting C<$ENV{CUDBI_TEST_DSN}>,
C<$ENV{CUDBI_TEST_DATABASE}>, C<$ENV{CUDBI_TEST_USER}>, 
and C<$ENV{CUDBI_TEST_PASS}>.

Currently the test suite tests against a SQLite database since it's such a
lightweight dependency for the testing.  The author also uses this module
with several MySQL databases.  As you're configuring your database, providing
its credentials to the tests and running the test scripts will offer really 
good diagnostics if some aspect of your database tables proves to be at odds 
with what this module needs.

Be advised that the the test suite drops its tables after completion, so be sure
to run the test suite only against a database set up explicitly for testing

view all matches for this distribution

Class-Usul

4 results

   }

   return OK;
}

sub create_schema : method { # Create databases and edit credentials
   my $self    = shift;
   my $default = $self->yes;
   my $text    = 'Schema creation requires a database, id and password. '
               . 'For Postgres the driver is Pg and the port 5432. For '
               . 'MySQL the driver is mysql and the port 3306';

   $self->output( $text, AS_PARA );
   $self->yorn( '+Create database schema', $default, TRUE, 0 ) or return OK;
   $self->edit_credentials;
   $self->connect_options;
   $self->drop_database;
   $self->drop_user;
   $self->create_user;
   $self->create_database;


   $self->debug and $self->dumper( $r );
   return OK;
}

sub edit_credentials : method {
   my $self      = shift;
   my $self_cfg  = $self->config;
   my $db        = $self->database;
   my $bootstrap = $self->options->{bootstrap};
   my $cfg_data  = $bootstrap ? {} : $self->load_config_data( $self_cfg, $db );

      $field ne 'name' and $self->$setter( $value // NUL );
      $is_pw and $value = encrypt_for_config $self_cfg, $value, $stored_pw;
      $copts->{ $field } = $value // NUL;
   }

   $cfg_data->{credentials}->{ $copts->{name} } = $copts;
   $self->dry_run and $self->dumper( $cfg_data ) and return OK;
   $self->dump_config_data( $self_cfg, $copts->{name}, $cfg_data );
   return OK;
}


=head2 create_schema - Creates a database then deploys and populates the schema

   $self->create_schema;

Calls L<edit_credentials>, L<create_database>, L<create_user>, and
L<deploy_and_populate>

=head2 create_user - Creates a database user

   $self->create_user;

   $self->dsn;

Returns the DSN from the call to
L<get_connect_info|Class::Usul::TraitFor::ConnectInfo/get_connect_info>

=head2 edit_credentials - Edits the database login information

   $self->edit_credentials;

Encrypts the database connection password before storage

=head2 execute_ddl

view all matches for this distribution

ClearPress

9 results

lib/ClearPress/authenticator/db.pm view on Meta::CPAN

  }

  return $DEFAULT_CIPHER;
}

sub authen_credentials {
  my ($self, $ref) = @_;

  if(!$ref ||
     !$ref->{username} ||
     !$ref->{password} ) {

lib/ClearPress/authenticator/db.pm view on Meta::CPAN

=head2 dbh - get/set accessor for database handle to use for query

  $oDBAuth->dbh($oDBH);
  my $oDBH = $oDBAuth->dbh();

=head2 authen_credentials - attempt to authenticate against database using given username & password

  my $hrAuthenticated = $oDBAuth->authen_credentials({username => $sUsername, password => $sPassword});

  returns undef or hashref

=head1 DIAGNOSTICS

view all matches for this distribution

ClickHouse-Encoder

1 match

lib/ClickHouse/Encoder/TCP.pm view on Meta::CPAN

# subs (pack_varint, unpack_varint, pack_string, unpack_string)
# live in PACKAGE = ClickHouse::Encoder::TCP inside Encoder.xs.

# ----- client packets ------------------------------------------------

# Hello packet: announces our protocol revision and credentials.
#
#   pack_hello(
#       client_name => 'ClickHouse::Encoder',  # default
#       major       => 1,                       # default
#       minor       => 0,                       # default

view all matches for this distribution

CloudApp-REST

2 results

lib/CloudApp/REST.pm view on Meta::CPAN

    my $params = shift;

    my $email = $params->{email} || $params->{username} || $params->{user} || $self->email || die "You have to provide an email address";
    my $pass  = $params->{password} || $params->{pass} || $self->password || die "You have to provide a password";

    $self->useragent->credentials($self->auth_netloc, $self->auth_realm, $email, $pass);

    return 1;
}

=head2 account_register

view all matches for this distribution

CloudDeploy

1 match