Make federation immutable

Author: CannonLock

package-lock.json

@@ -19,9 +19,14 @@
     "@babel/preset-typescript": "^7.26.0",
     "@jest/globals": "^29.7.0",
     "@types/jest": "^29.5.8",
+    "@types/lodash-es": "^4.17.12",
+    "i": "^0.3.7",
     "jest": "^29.7.0",
     "jest-environment-jsdom": "^29.7.0",
     "ts-jest": "^29.1.1",
     "typescript": "^5.2.2"
+  },
+  "dependencies": {
+    "lodash-es": "^4.17.21"
   }
 }

package.json

@@ -1,3 +1,4 @@
+'use client';
 
 import {
 	Federation,
@@ -6,6 +7,9 @@ import {
 	ObjectList,
 	TokenPermission
 } from "./types"
+import {
+	cloneDeep
+} from 'lodash-es';
 import {
 	fetchNamespace,
 	getObjectToken,
@@ -24,14 +28,14 @@ import sessionObject, {ProxiedValue} from "./sessionObject";
 
 export default class Client {
 
-	federations: Record<string, Federation>
+	federations: ProxiedValue<Record<string, Federation>>
 	prefixToNamespace: Record<string, string>
 	requestQueue: ProxiedValue<QueuedRequest[]>
   codeVerifier: ProxiedValue<string>
 
 	constructor() {
 		// Set up and load/initialize session storage objects
-		this.federations = sessionObject<Record<string, Federation>>("federations")
+		this.federations = sessionObject<ProxiedValue<Record<string, Federation>>>("federations", {value: {}})
 		this.prefixToNamespace = sessionObject<Record<string, string>>('prefixToNamespace')
 		this.requestQueue = sessionObject<ProxiedValue<QueuedRequest[]>>("requestQueue", {value: []})
 		this.codeVerifier = sessionObject<ProxiedValue<string>>("codeVerifier", {value: generateCodeVerifier()})
@@ -48,8 +52,8 @@ export default class Client {
 
 		const {federationHostname, objectPath} = parsePelicanObjectUrl(objectUrl)
 		const federation = await this.getFederation(federationHostname)
-		const namespace = await this.getNamespace(objectPath, federation)
-		const token = await getObjectToken(objectPath, namespace)
+		const namespace = await this.getNamespace(objectUrl, federation)
+		const token = await getObjectToken(namespace)
 
 		const objectHttpUrl = new URL(`${federation.configuration.director_endpoint}${objectPath}`)
 		const response = await fetch(objectHttpUrl, {
@@ -63,17 +67,17 @@ export default class Client {
 
 			// If we get a 403, queue this request call it after getting a token
 		} else if(response.status === 403 && !token){
-			await this.queueRequestAndStartFlow(objectPath, federation)
+			await this.queueRequestAndStartFlow(objectUrl, federation)
 		} else {
 			throw new Error(`Could not get object: ${response.status} ${response.statusText}`)
 		}
 	}
 
-	async list(federationPath: string) : Promise<ObjectList[] | undefined> {
-		const {federationHostname, objectPath} = parsePelicanObjectUrl(federationPath)
+	async list(collectionUrl: string) : Promise<ObjectList[] | undefined> {
+		const {federationHostname, objectPath} = parsePelicanObjectUrl(collectionUrl)
 		const federation = await this.getFederation(federationHostname)
-		const namespace = await this.getNamespace(objectPath, federation)
-		const token = await getObjectToken(objectPath, namespace)
+		const namespace = await this.getNamespace(collectionUrl, federation)
+		const token = await getObjectToken(namespace)
 
 		const objectHttpUrl = new URL(`${federation.configuration.director_endpoint}${objectPath}`)
 		const response = await fetch(objectHttpUrl, {
@@ -89,7 +93,7 @@ export default class Client {
 
 			// If we get a 403, queue this request call it after getting a token
 		} else if(response.status === 403){
-			await this.queueRequestAndStartFlow(objectPath, federation)
+			await this.queueRequestAndStartFlow(collectionUrl, federation)
 		} else {
 			throw new Error(`Could not list directory: ${response.status} ${response.statusText}`)
 		}
@@ -99,8 +103,8 @@ export default class Client {
 
 		const { federationHostname, objectPath } = parsePelicanObjectUrl(objectUrl)
 		const federation = await this.getFederation(federationHostname)
-		const namespace = await this.getNamespace(objectPath, federation)
-		const token = await getObjectToken(objectPath, namespace)
+		const namespace = await this.getNamespace(objectUrl, federation)
+		const token = await getObjectToken(namespace)
 
 		const objectHttpUrl = new URL(`${federation.configuration.director_endpoint}${objectPath}`)
 		const response = await fetch(objectHttpUrl, {
@@ -114,7 +118,7 @@ export default class Client {
 		if (response.status === 200 || response.status === 201) {
 			return
 		} else if (response.status === 403) {
-			await this.queueRequestAndStartFlow(objectPath, federation)
+			await this.queueRequestAndStartFlow(objectUrl, federation)
 		} else {
 			throw new Error(`Could not upload object: ${response.status} ${response.statusText}`)
 		}
@@ -125,10 +129,10 @@ export default class Client {
 	 * @param objectUrl
 	 */
 	async permissions(objectUrl: string): Promise<TokenPermission[]> {
-		const { federationHostname, objectPath } = parsePelicanObjectUrl(objectUrl)
+		const { federationHostname } = parsePelicanObjectUrl(objectUrl)
 		const federation = await this.getFederation(federationHostname)
-		const namespace = await this.getNamespace(objectPath, federation)
-		const token = await getObjectToken(objectPath, namespace)
+		const namespace = await this.getNamespace(objectUrl, federation)
+		const token = await getObjectToken(namespace)
 
 		if(!token) return []
 
@@ -148,13 +152,15 @@ export default class Client {
 		try {
 			// Get the namespace and federation from the state parameter
 			const {federation: federationHostname, namespace: namespacePrefix} = parseOauthState(new URL(window.location.href))
-			const namespace = this.federations[federationHostname]?.namespaces[namespacePrefix]
+			const namespace = this.federations.value[federationHostname]?.namespaces[namespacePrefix]
 
 			// Check if we have an auth code to exchange for a token
 			const token = await getToken(namespace.oidcConfiguration, this.codeVerifier.value, namespace.clientId, namespace.clientSecret, authCode)
 
 			// Save the token to the namespace
-			this.federations[federationHostname].namespaces[namespacePrefix].token = token.accessToken
+			const federationsClone = cloneDeep(this.federations.value)
+			federationsClone[federationHostname].namespaces[namespacePrefix].token = token.accessToken
+			this.federations.value = federationsClone
 		} catch {}
 
 		// Clean up the window
@@ -166,20 +172,23 @@ export default class Client {
 	 * @param federationHostname
 	 */
 	async getFederation(federationHostname: string) : Promise<Federation> {
-		if(!this.federations?.[federationHostname]) {
-			this.federations[federationHostname] = await fetchFederationConfiguration(federationHostname)
+		if(!this.federations.value?.[federationHostname]) {
+			this.federations.value = {
+				...this.federations.value,
+				[federationHostname]: await fetchFederationConfiguration(federationHostname)
+			}
 		}
-		return this.federations[federationHostname]
+		return this.federations.value[federationHostname]
 	}
 
 	/**
 	 * Get a namespace's configuration from the federation and save it to session cache
-	 * @param objectPath
+	 * @param objectUrl
 	 * @param federation
 	 */
-	async getNamespace(objectPath: string, federation: Federation) : Promise<Namespace> {
+	async getNamespace(objectUrl: string, federation: Federation) : Promise<Namespace> {
 
-		const {objectPrefix} = parsePelicanObjectUrl(objectPath)
+		const {objectPrefix, objectPath} = parsePelicanObjectUrl(objectUrl)
 
 		// Check if we have already cached the namespace for this prefix
 		if(this.prefixToNamespace?.[objectPrefix]){
@@ -192,33 +201,37 @@ export default class Client {
 		// Fetch and save the namespace information
 		const requestNamespace = await fetchNamespace(objectPath, federation)
 		this.prefixToNamespace[objectPrefix] = requestNamespace.prefix
-		this.federations[federation.hostname].namespaces[requestNamespace.prefix] = requestNamespace
+		const federationsClone = cloneDeep(this.federations.value)
+		federationsClone[federation.hostname].namespaces[requestNamespace.prefix] = requestNamespace
+		this.federations.value = federationsClone
+
 		return requestNamespace
 	}
 
 	/**
 	 * Queue a request that needs authorization and start the authorization code flow
-	 * @param objectPath
+	 * @param objectUrl
 	 * @param federation
 	 */
-	async queueRequestAndStartFlow(objectPath: string, federation: Federation) : Promise<void> {
+	async queueRequestAndStartFlow(objectUrl: string, federation: Federation) : Promise<void> {
 
 		// Fetch and save the namespace information
-		const requestNamespace = await fetchNamespace(objectPath, federation)
-		this.federations[federation.hostname].namespaces[requestNamespace.prefix] = requestNamespace
+		const namespace = await this.getNamespace(objectUrl, federation)
+
+		const {objectPath} = parsePelicanObjectUrl(objectUrl)
 
 		// Queue the file request
 		this.requestQueue.value.push({
-			objectUrl: `pelican://${federation.hostname}${objectPath}`,
+			objectUrl,
 			federationHostname: federation.hostname,
 			path: objectPath,
-			namespace: requestNamespace.prefix,
+			namespace: namespace.prefix,
 			type: "GET",
 			createdAt: new Date().getTime()
 		})
 
 		// Start the authorization code flow
-		await this.startAuthorizationCodeFlow(objectPath, requestNamespace, federation)
+		await this.startAuthorizationCodeFlow(objectPath, namespace, federation)
 	}
 
 	/**

src/Client.ts

@@ -3,10 +3,9 @@ import {Namespace, Token} from "../types";
 /**
  * Get the best fit token for the given object path and federation or undefined if none are readily available
  *
- * @param objectPath Object path - pelican://<federation-hostname>/<object-path>
  * @param namespace Federation hosting the requested object
  */
-const getObjectToken = async (objectPath: string, namespace: Namespace) : Promise<Token | undefined> => {
+const getObjectToken = async (namespace: Namespace) : Promise<Token | undefined> => {
 
 	// Check if we have a token for this namespace and that it is not expired
 	if(namespaceTokenIsExpired(namespace)){

src/Pelican/getObjectToken.ts

@@ -4,7 +4,7 @@ import Box from "@mui/material/Box";
 import {TextField, Typography, Autocomplete, createFilterOptions} from "@mui/material";
 import { Button} from "@mui/material";
 import {Grid} from "@mui/material";
-import {useEffect, useState} from "react";
+import {useEffect, useMemo, useState} from "react";
 import Client from "../../../src/Client";
 import { ObjectList, TokenPermission } from "../../../src/types"
 import Card from "@mui/material/Card";
@@ -47,10 +47,9 @@ export default function Home() {
     } else {
       await client?.get(objectPath)
     }
-
-		setClient(new Client());
   }
 
+	const federations = useMemo(() => client?.federations.value, [client?.federations.value]);
 
   return (
       <Box minHeight={"90vh"}>
@@ -84,7 +83,7 @@ export default function Home() {
                 <Button variant="contained" onClick={submit}>{object ? 'Upload' : 'Download'}</Button>
                 <Button onClick={() => {
                   if(client) {
-                    Object.keys(client.federations).forEach(k => delete client?.federations[k]);
+                    client.federations.value = {};
                   }
                 }}>Clear Federations</Button>
               </Box>
@@ -117,7 +116,7 @@ export default function Home() {
 							<Box overflow={'auto'}>
 								<pre>
 									<code>
-										{JSON.stringify(client?.federations, null, 2)}
+										{JSON.stringify(federations, null, 2)}
 									</code>
 								</pre>
 							</Box>