Start the authenticator process.
359588
def _start_auth_proc(self):
        '''
        
        '''
        log.debug('Computing the signing key hex')
        verify_key = self.__signing_key.verify_key
        sgn_verify_hex = verify_key.encode(encoder=nacl.encoding.HexEncoder)
        log.debug('Starting the authenticator subprocess')
        auth = NapalmLogsAuthProc(self.certificate,
                                  self.keyfile,
                                  self.__priv_key,
                                  sgn_verify_hex,
                                  self.auth_address,
                                  self.auth_port)
        proc = Process(target=auth.start)
        proc.start()
        proc.description = 'Auth process'
        log.debug('Started auth process as %s with PID %s', proc._name, proc.pid)
        return proc
1341162
def authenticate_credentials(self, userid, password, request=None):
        """"""

        user = auth.authenticate(username=userid, password=password)

        if user is None or (user and not user.is_active):
            raise exceptions.AuthenticationFailed("Invalid username/password.")

        return (user, None)
74603
@Override
    public void start(final BaseCallback<Authentication, AuthenticationException> callback) {
        credentialsRequest.start(new BaseCallback<Credentials, AuthenticationException>() {
            @Override
            public void onSuccess(final Credentials credentials) {
                userInfoRequest
                        .addHeader(HEADER_AUTHORIZATION, "Bearer " + credentials.getAccessToken())
                        .start(new BaseCallback<UserProfile, AuthenticationException>() {
                            @Override
                            public void onSuccess(UserProfile profile) {
                                callback.onSuccess(new Authentication(profile, credentials));
                            }

                            @Override
                            public void onFailure(AuthenticationException error) {
                                callback.onFailure(error);
                            }
                        });
            }

            @Override
            public void onFailure(AuthenticationException error) {
                callback.onFailure(error);
            }
        });
    }
884004
async def start_authentication(self):
        
        _, code = await self.http.post_data(
            'pair-pin-start', headers=_AIRPLAY_HEADERS)
        if code != 200:
            raise DeviceAuthenticationError('pair start failed')
1171048
def _start(self):
        '''

        '''
        if self.whoami is None:
            me = self.get_me()
            if me.get('ok', False):
                self.whoami = me['result']
            else:
                raise ValueError('Bot Cannot request information, check '
                                 'api_key')
512960
def authenticate(self):
        
        if self._auth_token is None or self._token_expiry < time.time():
            self._perform_auth()

        yield self._auth_token
594378
@InterfaceAudience.Public
    public void setAuthenticator(Authenticator authenticator) {
        properties.put(ReplicationField.AUTHENTICATOR, authenticator);
        replicationInternal.setAuthenticator(authenticator);
    }
53426
private void startupAcceptor() {
        if (!selectable) {
            registerQueue.clear();
            cancelQueue.clear();
            flushingSessions.clear();
        }

        synchronized (lock) {
            if (acceptor == null) {
                acceptor = new Acceptor();
                executeWorker(acceptor);
            }
        }
    }
55939
protected function authenticate()
    {
        $this->ch = curl_init();

        $headers = array(
            'Accept-Version: v10',
            'Accept: application/json',
        );

        if (!empty($this->auth_string)) {
            $headers[] = 'Authorization: Basic ' . base64_encode($this->auth_string);
        }

        $options = array(
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_SSL_VERIFYPEER => true,
            CURLOPT_HTTPAUTH => CURLAUTH_BASIC,
            CURLOPT_HTTPHEADER => $headers
        );

        curl_setopt_array($this->ch, $options);
    }
759500
def authenticate(self):
        
        # Make sure we've stored uri for use
        predix.config.set_env_value(self.use_class, 'uri', self._get_uri())

        self.uaac = predix.security.uaa.UserAccountAuthentication()
        self.uaac.authenticate('admin', self._get_admin_secret(),
                use_cache=False)
        self.is_admin = True
245414
def authenticate(self, user, password):
        """"""
        assert user['password_hash'] == '_'.join((password, 'hash'))
        self.logger.debug('User %s has been successfully authenticated',
                          user['uid'])
179426
async def start(self):
        """"""
        _LOGGER.debug('Initializing pyEight Version: %s', __version__)
        await self.fetch_token()
        if self._token is not None:
            await self.fetch_device_list()
            await self.assign_users()
            return True
        else:
            # We couldn't authenticate
            return False
666650
protected boolean startAuthentication(final C context, final List<Client> currentClients) {
        return isNotEmpty(currentClients) && currentClients.get(0) instanceof IndirectClient;
    }
415068
def start(self):
        """"""
        if not self._started:
            self.sig_started.emit(self)
            self._started = True
818834
def authenticate(self, request, **credentials):
        """"""
        from allauth.account.auth_backends import AuthenticationBackend

        self.pre_authenticate(request, **credentials)
        AuthenticationBackend.unstash_authenticated_user()
        user = authenticate(request, **credentials)
        alt_user = AuthenticationBackend.unstash_authenticated_user()
        user = user or alt_user
        if user and app_settings.LOGIN_ATTEMPTS_LIMIT:
            cache_key = self._get_login_attempts_cache_key(
                request, **credentials)
            cache.delete(cache_key)
        else:
            self.authentication_failed(request, **credentials)
        return user
276010
def authenticate(self):
        """"""
        if request.headers.get('Authorization', '').startswith('Negotiate '):
            in_token = base64.b64decode(request.headers['Authorization'][10:])

            try:
                creds = current_app.extensions['gssapi']['creds']
            except KeyError:
                raise RuntimeError('flask-gssapi not configured for this app')

            ctx = gssapi.SecurityContext(creds=creds, usage='accept')

            out_token = ctx.step(in_token)

            if ctx.complete:
                username = ctx._inquire(initiator_name=True).initiator_name
                return str(username), out_token

        return None, None
456176
public void register(Authenticator authenticator) {
		if (this.authenticator == null) {
			this.authenticator = authenticator;
		} else if (!authenticator.getClass().getSimpleName().equals(this.authenticator.getClass().getSimpleName())) {
			throw new ConfigurationException("attempt to replace authenticator " +
					this.authenticator.getClass().getSimpleName() + " by " +
					authenticator.getClass().getSimpleName());
		}
	}