Logout method for given user
 @see Wallaby::Configuration::Security#logout_method
 @param user [Object]
 @return [String, Symbol] http method to log out
434192
def logout_method(user = current_user)
      http_method = security.logout_method
      http_method || if defined? ::Devise
                       scope = ::Devise::Mapping.find_scope! user
                       mapping = ::Devise.mappings[scope]
                       mapping.sign_out_via
                     end
    end
1204836
def _logout(self):
        """"""

        if self.auth:
            logger.debug("ZabbixAPI.logout()")

            if self.user.logout():
                self.auth = None
1259555
def logout(self):
        ''''''
        headers = {"Content-type": "application/x-www-form-urlencoded","Accept": "text/plain","User-Agent": user_agent}
        self.session.get('http://'+self.domain+'/logout.phtml',headers=headers)
215475
def disconnect_user(self):
        
        if self.session_logged_in():
            self._logger.info("User %s disconnected - %s - %s - %s", self.session_username(), self.session_realname(), self.session_email(), web.ctx.ip)
        self._destroy_session()
808551
def logout
      r = execute(make_xml('LogoutRequest', { 'sync-id' => 0 }))
      return true if r.success
      raise APIError.new(r, 'Logout failed')
    end
760593
def logout_handler(self, **args):
        
        response = make_response(
            "<html><script>window.close();</script></html>", 200,
            {'Content-Type': "text/html"})
        response.set_cookie(self.account_cookie_name, expires=0)
        response.set_cookie(self.access_cookie_name, expires=0)
        response.headers['Access-Control-Allow-Origin'] = '*'
        return response
722741
def delete_user(self, user):
        
        user_id = utils.get_id(user)
        uri = "users/%s" % user_id
        resp, resp_body = self.method_delete(uri)
        if resp.status_code == 404:
            raise exc.UserNotFound("User '%s' does not exist." % user)
        elif resp.status_code in (401, 403):
            raise exc.AuthorizationFailure("You are not authorized to delete "
                    "users.")
997265
function logout(_ref3) {
    var state = _ref3.state,
        commit = _ref3.commit;
    commit('c3s/user/SET_CURRENT_USER', null, {
      root: true
    });
    commit('SET_ANON', false);
  }
997709
def logout(self):
        """"""

        if not self.logged_in:
            raise RuntimeError("User is not logged in")
        if self.conn.connected:
            params = {"room": self.conn.room.room_id}
            resp = self.conn.make_api_call("logout", params)
            if not resp.get("success", False):
                raise RuntimeError(
                    f"Logout unsuccessful: "
                    f"{resp['error'].get('message') or resp['error']}"
                )
            self.conn.make_call("logout", params)
            self.conn.cookies.pop("session")
        self.logged_in = False
1140466
def logout(self):
        
        from flask_login import logout_user, current_user
        if not current_user.is_authenticated:
            return True

        # logout otherwise
        user = current_user
        events.logout_event.send(user)
        logout_user()

        # notify principal
        app = current_app._get_current_object()
        identity_changed.send(app, identity=AnonymousIdentity())

        return True
57771
public void doLogout( StaplerRequest req, StaplerResponse rsp ) throws IOException, ServletException {
        String user = getAuthentication().getName();
        securityRealm.doLogout(req, rsp);
        SecurityListener.fireLoggedOut(user);
    }
1216940
def logout():
    "  "
    users.logout()
    return redirect(request.referrer or url_for(users._login_manager.login_view))
493381
def logout(self):
        
        logger.debug("request backend logout")
        if not self.authenticated:
            logger.warning("Unnecessary logout ...")
            return True

        endpoint = 'logout'

        _ = self.get_response(method='POST', endpoint=endpoint)

        self.session.close()
        self.set_token(token=None)

        return True
528945
def _do_logoff(self):
        
        session_uri = '/api/sessions/this-session'
        self.delete(session_uri, logon_required=False)
        self._session_id = None
        self._session = None
        self._headers.pop('X-API-Session', None)
103437
function logout() {
    if (exports.currentLogin === null) {
        log_1.logger.debug(`[API] Already logged out`);
        return Promise.resolve();
    }
    log_1.logger.info(`[API] Logging out ${exports.currentLogin.username}`);
    return get('logout', null, true).then(() => {
        clearHeaders();
        exports.currentLogin = null;
    });
}
713323
def logout(request):
    
    auth_logout(request)
    info(request, _("Successfully logged out"))
    return redirect(next_url(request) or get_script_prefix())
1181219
def _logout(self):
        
        self.log.debug("Logging out from session ID: %s" % self._token)
        try:
            info = self._xmlrpc_server.LogOut(self._token)
            self.log.debug("Logout ended in %s with status: %s" %
                           (info['seconds'], info['status']))
        except ProtocolError as e:
            self.log.debug("error in HTTP/HTTPS transport layer")
            raise
        except Fault as e:
            self.log.debug("error in xml-rpc server")
            raise
        except:
            self.log.exception("Connection to the server failed/other error")
            raise
        finally:
            # force token reset
            self._token = None