[ARVADOS-WORKBENCH2] created: 1.4.1-80-g0fc6c224

Git user git at public.curoverse.com
Thu Oct 31 18:41:22 UTC 2019


        at  0fc6c22416e1f28b3bb7825ca53f31f93605e39d (commit)


commit 0fc6c22416e1f28b3bb7825ca53f31f93605e39d
Author: Peter Amstutz <pamstutz at veritasgenetics.com>
Date:   Thu Oct 31 14:38:46 2019 -0400

    15736: "add-session" route, support tokens received from other clusters
    
    Refactor sessions to be able to handle searching remote clusters that
    the user logs in to, instead of using federated token.
    
    TODO: direct user to log in and return back when adding with "New cluster".

diff --git a/src/common/config.ts b/src/common/config.ts
index e5f7b1c6..47723ae8 100644
--- a/src/common/config.ts
+++ b/src/common/config.ts
@@ -193,5 +193,6 @@ const getDefaultConfig = (): WorkbenchConfig => {
 };
 
 export const ARVADOS_API_PATH = "arvados/v1";
-export const CLUSTER_CONFIG_URL = "arvados/v1/config";
-export const getClusterConfigURL = (apiHost: string) => `${window.location.protocol}//${apiHost}/${CLUSTER_CONFIG_URL}?nocache=${(new Date()).getTime()}`;
+export const CLUSTER_CONFIG_PATH = "arvados/v1/config";
+export const DISCOVERY_DOC_PATH = "discovery/v1/apis/arvados/v1/rest";
+export const getClusterConfigURL = (apiHost: string) => `${window.location.protocol}//${apiHost}/${CLUSTER_CONFIG_PATH}?nocache=${(new Date()).getTime()}`;
diff --git a/src/common/url.ts b/src/common/url.ts
index 1824f26a..9789b65e 100644
--- a/src/common/url.ts
+++ b/src/common/url.ts
@@ -4,3 +4,12 @@ export function getUrlParameter(search: string, name: string) {
     const results = regex.exec(search);
     return results === null ? '' : decodeURIComponent(results[1].replace(/\+/g, ' '));
 }
+
+export function normalizeURLPath(url: string) {
+    const u = new URL(url);
+    u.pathname = u.pathname.replace(/\/\//, '/');
+    if (u.pathname[u.pathname.length - 1] === '/') {
+        u.pathname = u.pathname.substr(0, u.pathname.length - 1);
+    }
+    return u.toString();
+}
diff --git a/src/index.tsx b/src/index.tsx
index f286b7be..5a941638 100644
--- a/src/index.tsx
+++ b/src/index.tsx
@@ -13,6 +13,7 @@ import { History } from "history";
 import { configureStore, RootStore } from '~/store/store';
 import { ConnectedRouter } from "react-router-redux";
 import { ApiToken } from "~/views-components/api-token/api-token";
+import { AddSession } from "~/views-components/add-session/add-session";
 import { initAuth } from "~/store/auth/auth-action";
 import { createServices } from "~/services/services";
 import { MuiThemeProvider } from '@material-ui/core/styles';
@@ -112,6 +113,7 @@ fetchConfig()
         store.dispatch(loadFileViewersConfig);
 
         const TokenComponent = (props: any) => <ApiToken authService={services.authService} config={config} loadMainApp={true} {...props} />;
+        const AddSessionComponent = (props: any) => <AddSession {...props} />;
         const FedTokenComponent = (props: any) => <ApiToken authService={services.authService} config={config} loadMainApp={false} {...props} />;
         const MainPanelComponent = (props: any) => <MainPanel {...props} />;
 
@@ -123,6 +125,7 @@ fetchConfig()
                             <Switch>
                                 <Route path={Routes.TOKEN} component={TokenComponent} />
                                 <Route path={Routes.FED_LOGIN} component={FedTokenComponent} />
+                                <Route path={Routes.ADD_SESSION} component={AddSessionComponent} />
                                 <Route path={Routes.ROOT} component={MainPanelComponent} />
                             </Switch>
                         </ConnectedRouter>
diff --git a/src/routes/routes.ts b/src/routes/routes.ts
index 08e0a03d..5cf472c3 100644
--- a/src/routes/routes.ts
+++ b/src/routes/routes.ts
@@ -19,6 +19,7 @@ export const Routes = {
     ROOT: '/',
     TOKEN: '/token',
     FED_LOGIN: '/fedtoken',
+    ADD_SESSION: '/add-session',
     PROJECTS: `/projects/:id(${RESOURCE_UUID_PATTERN})`,
     COLLECTIONS: `/collections/:id(${RESOURCE_UUID_PATTERN})`,
     PROCESSES: `/processes/:id(${RESOURCE_UUID_PATTERN})`,
@@ -159,7 +160,7 @@ export const matchTokenRoute = (route: string) =>
     matchPath(route, { path: Routes.TOKEN });
 
 export const matchFedTokenRoute = (route: string) =>
-    matchPath(route, {path: Routes.FED_LOGIN});
+    matchPath(route, { path: Routes.FED_LOGIN });
 
 export const matchUsersRoute = (route: string) =>
     matchPath(route, { path: Routes.USERS });
diff --git a/src/services/groups-service/groups-service.ts b/src/services/groups-service/groups-service.ts
index 9517e2cb..691ab8f7 100644
--- a/src/services/groups-service/groups-service.ts
+++ b/src/services/groups-service/groups-service.ts
@@ -52,6 +52,7 @@ export class GroupsService<T extends GroupResource = GroupResource> extends Tras
         const cfg: AxiosRequestConfig = { params: CommonResourceService.mapKeys(_.snakeCase)(params) };
         if (session) {
             cfg.baseURL = session.baseUrl;
+            cfg.headers = { 'Authorization': 'Bearer ' + session.token };
         }
 
         const response = await CommonResourceService.defaultResponse(
diff --git a/src/store/auth/auth-action-session.ts b/src/store/auth/auth-action-session.ts
index a23fb2ff..b3f625ef 100644
--- a/src/store/auth/auth-action-session.ts
+++ b/src/store/auth/auth-action-session.ts
@@ -9,36 +9,65 @@ import { ServiceRepository } from "~/services/services";
 import Axios from "axios";
 import { getUserFullname, User } from "~/models/user";
 import { authActions } from "~/store/auth/auth-action";
-import { Config, ClusterConfigJSON, CLUSTER_CONFIG_URL, ARVADOS_API_PATH } from "~/common/config";
+import { Config, ClusterConfigJSON, CLUSTER_CONFIG_PATH, DISCOVERY_DOC_PATH, ARVADOS_API_PATH } from "~/common/config";
+import { normalizeURLPath } from "~/common/url";
 import { Session, SessionStatus } from "~/models/session";
 import { progressIndicatorActions } from "~/store/progress-indicator/progress-indicator-actions";
 import { AuthService, UserDetailsResponse } from "~/services/auth-service/auth-service";
 import * as jsSHA from "jssha";
 
-const getRemoteHostBaseUrl = async (remoteHost: string): Promise<string | null> => {
+const getClusterInfo = async (origin: string): Promise<{ clusterId: string, baseURL: string } | null> => {
+    // Try the new public config endpoint
+    try {
+        const config = (await Axios.get<ClusterConfigJSON>(`${origin}/${CLUSTER_CONFIG_PATH}`)).data;
+        return {
+            clusterId: config.ClusterID,
+            baseURL: normalizeURLPath(`${config.Services.Controller.ExternalURL}/${ARVADOS_API_PATH}`)
+        };
+    } catch { }
+
+    // Fall back to discovery document
+    try {
+        const config = (await Axios.get<any>(`${origin}/${DISCOVERY_DOC_PATH}`)).data;
+        return {
+            clusterId: config.uuidPrefix,
+            baseURL: normalizeURLPath(config.baseUrl)
+        };
+    } catch { }
+
+    return null;
+};
+
+const getRemoteHostInfo = async (remoteHost: string): Promise<{ clusterId: string, baseURL: string } | null> => {
     let url = remoteHost;
     if (url.indexOf('://') < 0) {
         url = 'https://' + url;
     }
     const origin = new URL(url).origin;
-    let baseUrl: string | null = null;
 
+    // Maybe it is an API server URL, try fetching config and discovery doc
+    let r = getClusterInfo(origin);
+    if (r !== null) {
+        return r;
+    }
+
+    // Maybe it is a Workbench2 URL, try getting config.json
     try {
-        const resp = await Axios.get<ClusterConfigJSON>(`${origin}/${CLUSTER_CONFIG_URL}`);
-        baseUrl = `${resp.data.Services.Controller.ExternalURL}/${ARVADOS_API_PATH}`;
-    } catch (err) {
-        try {
-            const resp = await Axios.get<any>(`${origin}/status.json`);
-            baseUrl = resp.data.apiBaseURL;
-        } catch (err) {
+        r = getClusterInfo((await Axios.get<any>(`${origin}/config.json`)).data.API_HOST);
+        if (r !== null) {
+            return r;
         }
-    }
+    } catch { }
 
-    if (baseUrl && baseUrl[baseUrl.length - 1] === '/') {
-        baseUrl = baseUrl.substr(0, baseUrl.length - 1);
-    }
+    // Maybe it is a Workbench1 URL, try getting status.json
+    try {
+        r = getClusterInfo((await Axios.get<any>(`${origin}/status.json`)).data.apiBaseURL);
+        if (r !== null) {
+            return r;
+        }
+    } catch { }
 
-    return baseUrl;
+    return null;
 };
 
 const getUserDetails = async (baseUrl: string, token: string): Promise<UserDetailsResponse> => {
@@ -50,41 +79,34 @@ const getUserDetails = async (baseUrl: string, token: string): Promise<UserDetai
     return resp.data;
 };
 
-const getTokenUuid = async (baseUrl: string, token: string): Promise<string> => {
-    if (token.startsWith("v2/")) {
-        const uuid = token.split("/")[1];
-        return Promise.resolve(uuid);
+export const getSaltedToken = (clusterId: string, token: string) => {
+    const shaObj = new jsSHA("SHA-1", "TEXT");
+    const [ver, uuid, secret] = token.split("/");
+    if (ver !== "v2") {
+        throw new Error("Must be a v2 token");
+    }
+    let salted = secret;
+    if (uuid.substr(0, 5) !== clusterId) {
+        shaObj.setHMACKey(secret, "TEXT");
+        shaObj.update(clusterId);
+        salted = shaObj.getHMAC("HEX");
     }
+    return `v2/${uuid}/${salted}`;
+};
 
-    const resp = await Axios.get(`${baseUrl}api_client_authorizations`, {
-        headers: {
-            Authorization: `OAuth2 ${token}`
-        },
-        data: {
-            filters: JSON.stringify([['api_token', '=', token]])
-        }
-    });
+export const getActiveSession = (sessions: Session[]): Session | undefined => sessions.find(s => s.active);
 
-    return resp.data.items[0].uuid;
-};
+export const validateCluster = async (remoteHost: string, useToken: string):
+    Promise<{ user: User; token: string, baseUrl: string, clusterId: string }> => {
 
-export const getSaltedToken = (clusterId: string, tokenUuid: string, token: string) => {
-    const shaObj = new jsSHA("SHA-1", "TEXT");
-    let secret = token;
-    if (token.startsWith("v2/")) {
-        secret = token.split("/")[2];
+    const info = await getRemoteHostInfo(remoteHost);
+    if (!info) {
+        return Promise.reject(`Could not get config for ${remoteHost}`);
     }
-    shaObj.setHMACKey(secret, "TEXT");
-    shaObj.update(clusterId);
-    const hmac = shaObj.getHMAC("HEX");
-    return `v2/${tokenUuid}/${hmac}`;
-};
-
-const clusterLogin = async (clusterId: string, baseUrl: string, activeSession: Session): Promise<{ user: User, token: string }> => {
-    const tokenUuid = await getTokenUuid(activeSession.baseUrl, activeSession.token);
-    const saltedToken = getSaltedToken(clusterId, tokenUuid, activeSession.token);
-    const user = await getUserDetails(baseUrl, saltedToken);
+    const saltedToken = getSaltedToken(info.clusterId, useToken);
+    const user = await getUserDetails(info.baseURL, saltedToken);
     return {
+        baseUrl: info.baseURL,
         user: {
             firstName: user.first_name,
             lastName: user.last_name,
@@ -96,39 +118,38 @@ const clusterLogin = async (clusterId: string, baseUrl: string, activeSession: S
             username: user.username,
             prefs: user.prefs
         },
-        token: saltedToken
+        token: saltedToken,
+        clusterId: info.clusterId
     };
 };
 
-export const getActiveSession = (sessions: Session[]): Session | undefined => sessions.find(s => s.active);
-
-export const validateCluster = async (remoteHost: string, clusterId: string, activeSession: Session): Promise<{ user: User; token: string, baseUrl: string }> => {
-    const baseUrl = await getRemoteHostBaseUrl(remoteHost);
-    if (!baseUrl) {
-        return Promise.reject(`Could not find base url for ${remoteHost}`);
-    }
-    const { user, token } = await clusterLogin(clusterId, baseUrl, activeSession);
-    return { baseUrl, user, token };
-};
-
 export const validateSession = (session: Session, activeSession: Session) =>
     async (dispatch: Dispatch): Promise<Session> => {
         dispatch(authActions.UPDATE_SESSION({ ...session, status: SessionStatus.BEING_VALIDATED }));
         session.loggedIn = false;
-        try {
-            const { baseUrl, user, token } = await validateCluster(session.remoteHost, session.clusterId, activeSession);
+
+        const setupSession = (baseUrl: string, user: User, token: string) => {
             session.baseUrl = baseUrl;
             session.token = token;
             session.email = user.email;
             session.uuid = user.uuid;
             session.name = getUserFullname(user);
             session.loggedIn = true;
+        };
+
+        try {
+            const { baseUrl, user, token } = await validateCluster(session.remoteHost, session.token);
+            setupSession(baseUrl, user, token);
         } catch {
-            session.loggedIn = false;
-        } finally {
-            session.status = SessionStatus.VALIDATED;
-            dispatch(authActions.UPDATE_SESSION(session));
+            try {
+                const { baseUrl, user, token } = await validateCluster(session.remoteHost, activeSession.token);
+                setupSession(baseUrl, user, token);
+            } catch { }
         }
+
+        session.status = SessionStatus.VALIDATED;
+        dispatch(authActions.UPDATE_SESSION(session));
+
         return session;
     };
 
@@ -148,17 +169,20 @@ export const validateSessions = () =>
         }
     };
 
-export const addSession = (remoteHost: string) =>
+export const addSession = (remoteHost: string, token?: string) =>
     async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
         const sessions = getState().auth.sessions;
         const activeSession = getActiveSession(sessions);
-        if (activeSession) {
-            const clusterId = remoteHost.match(/^(\w+)\./)![1];
-            if (sessions.find(s => s.clusterId === clusterId)) {
-                return Promise.reject("Cluster already exists");
-            }
+        let useToken: string | null = null;
+        if (token) {
+            useToken = token;
+        } else if (activeSession) {
+            useToken = activeSession.token;
+        }
+
+        if (useToken) {
             try {
-                const { baseUrl, user, token } = await validateCluster(remoteHost, clusterId, activeSession);
+                const { baseUrl, user, token, clusterId } = await validateCluster(remoteHost, useToken);
                 const session = {
                     loggedIn: true,
                     status: SessionStatus.VALIDATED,
@@ -172,7 +196,11 @@ export const addSession = (remoteHost: string) =>
                     token
                 };
 
-                dispatch(authActions.ADD_SESSION(session));
+                if (sessions.find(s => s.clusterId === clusterId)) {
+                    dispatch(authActions.UPDATE_SESSION(session));
+                } else {
+                    dispatch(authActions.ADD_SESSION(session));
+                }
                 services.authService.saveSessions(getState().auth.sessions);
 
                 return session;
diff --git a/src/store/search-results-panel/search-results-middleware-service.ts b/src/store/search-results-panel/search-results-middleware-service.ts
index 3233525a..85f12c3f 100644
--- a/src/store/search-results-panel/search-results-middleware-service.ts
+++ b/src/store/search-results-panel/search-results-middleware-service.ts
@@ -45,6 +45,7 @@ export class SearchResultsMiddlewareService extends DataExplorerMiddlewareServic
         try {
             const params = getParams(dataExplorer, searchValue);
 
+            // TODO: if one of these fails, no results will be returned.
             const responses = await Promise.all(sessions.map(session =>
                 this.services.groupsService.contents('', params, session)
             ));
diff --git a/src/views-components/add-session/add-session.tsx b/src/views-components/add-session/add-session.tsx
new file mode 100644
index 00000000..4628e1ce
--- /dev/null
+++ b/src/views-components/add-session/add-session.tsx
@@ -0,0 +1,26 @@
+// Copyright (C) The Arvados Authors. All rights reserved.
+//
+// SPDX-License-Identifier: AGPL-3.0
+
+import { RouteProps } from "react-router";
+import * as React from "react";
+import { connect, DispatchProp } from "react-redux";
+import { getUrlParameter } from "~/common/url";
+import { navigateToSiteManager } from "~/store/navigation/navigation-action";
+import { addSession } from "~/store/auth/auth-action-session";
+
+export const AddSession = connect()(
+    class extends React.Component<RouteProps & DispatchProp<any>, {}> {
+        componentDidMount() {
+            const search = this.props.location ? this.props.location.search : "";
+            const apiToken = getUrlParameter(search, 'api_token');
+            const baseURL = getUrlParameter(search, 'baseURL');
+
+            this.props.dispatch(addSession(baseURL, apiToken));
+            this.props.dispatch(navigateToSiteManager);
+        }
+        render() {
+            return <div />;
+        }
+    }
+);
diff --git a/src/views/search-results-panel/search-results-panel-view.tsx b/src/views/search-results-panel/search-results-panel-view.tsx
index 6eac09fa..8bc5419b 100644
--- a/src/views/search-results-panel/search-results-panel-view.tsx
+++ b/src/views/search-results-panel/search-results-panel-view.tsx
@@ -127,7 +127,8 @@ export const SearchResultsPanelView = withStyles(styles, { withTheme: true })(
                     {loggedIn.length === 1 ?
                         <span>Searching local cluster <ResourceCluster uuid={props.localCluster} /></span>
                         : <span>Searching clusters: {loggedIn.map((ss) => <span key={ss.clusterId}>
-                            <a href={props.remoteHostsConfig[ss.clusterId].workbench2Url} style={{ textDecoration: 'none' }}> <ResourceCluster uuid={ss.clusterId} /></a></span>)}</span>}
+                            <a href={props.remoteHostsConfig[ss.clusterId] && props.remoteHostsConfig[ss.clusterId].workbench2Url} style={{ textDecoration: 'none' }}> <ResourceCluster uuid={ss.clusterId} /></a>
+                        </span>)}</span>}
                     {loggedIn.length === 1 && props.localCluster !== homeCluster ?
                         <span>To search multiple clusters, <a href={props.remoteHostsConfig[homeCluster] && props.remoteHostsConfig[homeCluster].workbench2Url}> start from your home Workbench.</a></span>
                         : <span style={{ marginLeft: "2em" }}>Use <Link to={Routes.SITE_MANAGER} >Site Manager</Link> to manage which clusters will be searched.</span>}
diff --git a/src/views/workbench/fed-login.tsx b/src/views/workbench/fed-login.tsx
index be543a64..7c8b87c7 100644
--- a/src/views/workbench/fed-login.tsx
+++ b/src/views/workbench/fed-login.tsx
@@ -30,7 +30,6 @@ export const FedLogin = connect(mapStateToProps)(
             if (!apiToken || !user || !user.uuid.startsWith(localCluster)) {
                 return <></>;
             }
-            const [, tokenUuid, token] = apiToken.split("/");
             return <div id={"fedtoken-iframe-div"}>
                 {Object.keys(remoteHostsConfig)
                     .map((k) => {
@@ -42,7 +41,7 @@ export const FedLogin = connect(mapStateToProps)(
                             return;
                         }
                         const fedtoken = (remoteHostsConfig[k].loginCluster === localCluster)
-                            ? apiToken : getSaltedToken(k, tokenUuid, token);
+                            ? apiToken : getSaltedToken(k, apiToken);
                         return <iframe key={k} src={`${remoteHostsConfig[k].workbench2Url}/fedtoken?api_token=${fedtoken}`} style={{
                             height: 0,
                             width: 0,

commit f4240d1ffcf1a4a96b97de86a1f3c8dad5ba8dce
Author: Peter Amstutz <pamstutz at veritasgenetics.com>
Date:   Wed Oct 30 16:30:54 2019 -0400

    15736: Add uuid column to site manager page

diff --git a/src/models/session.ts b/src/models/session.ts
index 9a942967..91a0d997 100644
--- a/src/models/session.ts
+++ b/src/models/session.ts
@@ -12,9 +12,10 @@ export interface Session {
     clusterId: string;
     remoteHost: string;
     baseUrl: string;
-    username: string;
+    name: string;
     email: string;
     token: string;
+    uuid: string;
     loggedIn: boolean;
     status: SessionStatus;
     active: boolean;
diff --git a/src/services/auth-service/auth-service.ts b/src/services/auth-service/auth-service.ts
index da96f162..d5cb4ec2 100644
--- a/src/services/auth-service/auth-service.ts
+++ b/src/services/auth-service/auth-service.ts
@@ -176,11 +176,12 @@ export class AuthService {
             clusterId: cfg.uuidPrefix,
             remoteHost: cfg.rootUrl,
             baseUrl: cfg.baseUrl,
-            username: getUserFullname(user),
+            name: getUserFullname(user),
             email: user ? user.email : '',
             token: this.getApiToken(),
             loggedIn: true,
             active: true,
+            uuid: user ? user.uuid : '',
             status: SessionStatus.VALIDATED
         } as Session;
         const localSessions = this.getSessions().map(s => ({
@@ -195,11 +196,12 @@ export class AuthService {
                 clusterId,
                 remoteHost,
                 baseUrl: '',
-                username: '',
+                name: '',
                 email: '',
                 token: '',
                 loggedIn: false,
                 active: false,
+                uuid: '',
                 status: SessionStatus.INVALIDATED
             } as Session;
         });
diff --git a/src/store/auth/auth-action-session.ts b/src/store/auth/auth-action-session.ts
index 6af72e0c..a23fb2ff 100644
--- a/src/store/auth/auth-action-session.ts
+++ b/src/store/auth/auth-action-session.ts
@@ -120,7 +120,8 @@ export const validateSession = (session: Session, activeSession: Session) =>
             session.baseUrl = baseUrl;
             session.token = token;
             session.email = user.email;
-            session.username = getUserFullname(user);
+            session.uuid = user.uuid;
+            session.name = getUserFullname(user);
             session.loggedIn = true;
         } catch {
             session.loggedIn = false;
@@ -163,7 +164,8 @@ export const addSession = (remoteHost: string) =>
                     status: SessionStatus.VALIDATED,
                     active: false,
                     email: user.email,
-                    username: getUserFullname(user),
+                    name: getUserFullname(user),
+                    uuid: user.uuid,
                     remoteHost,
                     baseUrl,
                     clusterId,
diff --git a/src/store/auth/auth-action.ts b/src/store/auth/auth-action.ts
index e273d18c..5bac6b19 100644
--- a/src/store/auth/auth-action.ts
+++ b/src/store/auth/auth-action.ts
@@ -67,10 +67,13 @@ export const initAuth = (config: Config) => (dispatch: Dispatch, getState: () =>
 const init = (config: Config) => (dispatch: Dispatch, getState: () => RootState, services: ServiceRepository) => {
     const user = services.authService.getUser();
     const token = services.authService.getApiToken();
-    const homeCluster = services.authService.getHomeCluster();
+    let homeCluster = services.authService.getHomeCluster();
     if (token) {
         setAuthorizationHeader(services, token);
     }
+    if (homeCluster && !config.remoteHosts[homeCluster]) {
+        homeCluster = undefined;
+    }
     dispatch(authActions.CONFIG({ config }));
     dispatch(authActions.SET_HOME_CLUSTER(config.loginCluster || homeCluster || config.uuidPrefix));
     if (token && user) {
diff --git a/src/views/site-manager-panel/site-manager-panel-root.tsx b/src/views/site-manager-panel/site-manager-panel-root.tsx
index e75aa1f9..a8f7439a 100644
--- a/src/views/site-manager-panel/site-manager-panel-root.tsx
+++ b/src/views/site-manager-panel/site-manager-panel-root.tsx
@@ -133,8 +133,8 @@ export const SiteManagerPanelRoot = compose(
                             <TableRow className={classes.tableRow}>
                                 <TableCell>Cluster ID</TableCell>
                                 <TableCell>Host</TableCell>
-                                <TableCell>Username</TableCell>
                                 <TableCell>Email</TableCell>
+                                <TableCell>UUID</TableCell>
                                 <TableCell>Status</TableCell>
                             </TableRow>
                         </TableHead>
@@ -146,8 +146,8 @@ export const SiteManagerPanelRoot = compose(
                                         <a href={remoteHostsConfig[session.clusterId].workbench2Url} style={{ textDecoration: 'none' }}> <ResourceCluster uuid={session.clusterId} /></a>
                                         : session.clusterId}</TableCell>
                                     <TableCell>{session.remoteHost}</TableCell>
-                                    <TableCell>{validating ? <CircularProgress size={20} /> : session.username}</TableCell>
                                     <TableCell>{validating ? <CircularProgress size={20} /> : session.email}</TableCell>
+                                    <TableCell>{validating ? <CircularProgress size={20} /> : session.uuid}</TableCell>
                                     <TableCell className={classes.statusCell}>
                                         <Button fullWidth
                                             disabled={validating || session.status === SessionStatus.INVALIDATED || session.active}

-----------------------------------------------------------------------


hooks/post-receive
-- 




More information about the arvados-commits mailing list