src/store/advanced-tab/advanced-tab.ts

   1 // Copyright (C) The Arvados Authors. All rights reserved.
   2 //
   3 // SPDX-License-Identifier: AGPL-3.0
   4
   5 import { Dispatch } from 'redux';
   6 import { dialogActions } from '~/store/dialog/dialog-actions';
   7 import { RootState } from '~/store/store';
   8 import { ResourceKind, extractUuidKind } from '~/models/resource';
   9 import { getResource } from '~/store/resources/resources';
  10 import { GroupContentsResourcePrefix } from '~/services/groups-service/groups-service';
  11 import { snackbarActions, SnackbarKind } from '~/store/snackbar/snackbar-actions';
  12 import { ContainerRequestResource } from '~/models/container-request';
  13 import { CollectionResource } from '~/models/collection';
  14 import { ProjectResource } from '~/models/project';
  15 import { ServiceRepository } from '~/services/services';
  16 import { FilterBuilder } from '~/services/api/filter-builder';
  17 import { RepositoryResource } from '~/models/repositories';
  18 import { SshKeyResource } from '~/models/ssh-key';
  19 import { VirtualMachinesResource } from '~/models/virtual-machines';
  20 import { UserResource } from '~/models/user';
  21 import { ListResults } from '~/services/common-service/common-resource-service';
  22 import { LinkResource } from '~/models/link';
  23 import { KeepServiceResource } from '~/models/keep-services';
  24
  25 export const ADVANCED_TAB_DIALOG = 'advancedTabDialog';
  26
  27 interface AdvancedTabDialogData {
  28     apiResponse: any;
  29     metadata: ListResults<LinkResource> | string;
  30     user: UserResource | string;
  31     pythonHeader: string;
  32     pythonExample: string;
  33     cliGetHeader: string;
  34     cliGetExample: string;
  35     cliUpdateHeader: string;
  36     cliUpdateExample: string;
  37     curlHeader: string;
  38     curlExample: string;
  39 }
  40
  41 enum CollectionData {
  42     COLLECTION = 'collection',
  43     STORAGE_CLASSES_CONFIRMED = 'storage_classes_confirmed'
  44 }
  45
  46 enum ProcessData {
  47     CONTAINER_REQUEST = 'container_request',
  48     OUTPUT_NAME = 'output_name'
  49 }
  50
  51 enum ProjectData {
  52     GROUP = 'group',
  53     DELETE_AT = 'delete_at'
  54 }
  55
  56 enum RepositoryData {
  57     REPOSITORY = 'repository',
  58     CREATED_AT = 'created_at'
  59 }
  60
  61 enum SshKeyData {
  62     SSH_KEY = 'authorized_key',
  63     CREATED_AT = 'created_at'
  64 }
  65
  66 enum VirtualMachineData {
  67     VIRTUAL_MACHINE = 'virtual_machine',
  68     CREATED_AT = 'created_at'
  69 }
  70
  71 enum ResourcePrefix {
  72     REPOSITORIES = 'repositories',
  73     AUTORIZED_KEYS = 'authorized_keys',
  74     VIRTUAL_MACHINES = 'virtual_machines',
  75     KEEP_SERVICES = 'keep_services'
  76 }
  77
  78 enum KeepServiceData {
  79     KEEP_SERVICE = 'keep_services',
  80     CREATED_AT = 'created_at'
  81 }
  82
  83 type AdvanceResourceKind = CollectionData | ProcessData | ProjectData | RepositoryData | SshKeyData | VirtualMachineData | KeepServiceData;
  84 type AdvanceResourcePrefix = GroupContentsResourcePrefix | ResourcePrefix;
  85
  86 export const openAdvancedTabDialog = (uuid: string) =>
  87     async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
  88         const kind = extractUuidKind(uuid);
  89         switch (kind) {
  90             case ResourceKind.COLLECTION:
  91                 const { data: dataCollection, metadata: metaCollection, user: userCollection } = await dispatch<any>(getDataForAdvancedTab(uuid));
  92                 const advanceDataCollection: AdvancedTabDialogData = advancedTabData({
  93                     uuid,
  94                     metadata: metaCollection,
  95                     user: userCollection,
  96                     apiResponseKind: collectionApiResponse,
  97                     data: dataCollection,
  98                     resourceKind: CollectionData.COLLECTION,
  99                     resourcePrefix: GroupContentsResourcePrefix.COLLECTION,
 100                     resourceKindProperty: CollectionData.STORAGE_CLASSES_CONFIRMED,
 101                     property: dataCollection.storageClassesConfirmed
 102                 });
 103                 dispatch<any>(initAdvancedTabDialog(advanceDataCollection));
 104                 break;
 105             case ResourceKind.PROCESS:
 106                 const { data: dataProcess, metadata: metaProcess, user: userProcess } = await dispatch<any>(getDataForAdvancedTab(uuid));
 107                 const advancedDataProcess: AdvancedTabDialogData = advancedTabData({
 108                     uuid,
 109                     metadata: metaProcess,
 110                     user: userProcess,
 111                     apiResponseKind: containerRequestApiResponse,
 112                     data: dataProcess,
 113                     resourceKind: ProcessData.CONTAINER_REQUEST,
 114                     resourcePrefix: GroupContentsResourcePrefix.PROCESS,
 115                     resourceKindProperty: ProcessData.OUTPUT_NAME,
 116                     property: dataProcess.outputName
 117                 });
 118                 dispatch<any>(initAdvancedTabDialog(advancedDataProcess));
 119                 break;
 120             case ResourceKind.PROJECT:
 121                 const { data: dataProject, metadata: metaProject, user: userProject } = await dispatch<any>(getDataForAdvancedTab(uuid));
 122                 const advanceDataProject: AdvancedTabDialogData = advancedTabData({
 123                     uuid,
 124                     metadata: metaProject,
 125                     user: userProject,
 126                     apiResponseKind: groupRequestApiResponse,
 127                     data: dataProject,
 128                     resourceKind: ProjectData.GROUP,
 129                     resourcePrefix: GroupContentsResourcePrefix.PROJECT,
 130                     resourceKindProperty: ProjectData.DELETE_AT,
 131                     property: dataProject.deleteAt
 132                 });
 133                 dispatch<any>(initAdvancedTabDialog(advanceDataProject));
 134                 break;
 135             case ResourceKind.REPOSITORY:
 136                 const dataRepository = getState().repositories.items.find(it => it.uuid === uuid);
 137                 const advanceDataRepository: AdvancedTabDialogData = advancedTabData({
 138                     uuid,
 139                     metadata: '',
 140                     user: '',
 141                     apiResponseKind: repositoryApiResponse,
 142                     data: dataRepository,
 143                     resourceKind: RepositoryData.REPOSITORY,
 144                     resourcePrefix: ResourcePrefix.REPOSITORIES,
 145                     resourceKindProperty: RepositoryData.CREATED_AT,
 146                     property: dataRepository!.createdAt
 147                 });
 148                 dispatch<any>(initAdvancedTabDialog(advanceDataRepository));
 149                 break;
 150             case ResourceKind.SSH_KEY:
 151                 const dataSshKey = getState().auth.sshKeys.find(it => it.uuid === uuid);
 152                 const advanceDataSshKey: AdvancedTabDialogData = advancedTabData({
 153                     uuid,
 154                     metadata: '',
 155                     user: '',
 156                     apiResponseKind: sshKeyApiResponse,
 157                     data: dataSshKey,
 158                     resourceKind: SshKeyData.SSH_KEY,
 159                     resourcePrefix: ResourcePrefix.AUTORIZED_KEYS,
 160                     resourceKindProperty: SshKeyData.CREATED_AT,
 161                     property: dataSshKey!.createdAt
 162                 });
 163                 dispatch<any>(initAdvancedTabDialog(advanceDataSshKey));
 164                 break;
 165             case ResourceKind.VIRTUAL_MACHINE:
 166                 const dataVirtualMachine = getState().virtualMachines.virtualMachines.items.find(it => it.uuid === uuid);
 167                 const advanceDataVirtualMachine: AdvancedTabDialogData = advancedTabData({
 168                     uuid,
 169                     metadata: '',
 170                     user: '',
 171                     apiResponseKind: virtualMachineApiResponse,
 172                     data: dataVirtualMachine,
 173                     resourceKind: VirtualMachineData.VIRTUAL_MACHINE,
 174                     resourcePrefix: ResourcePrefix.VIRTUAL_MACHINES,
 175                     resourceKindProperty: VirtualMachineData.CREATED_AT,
 176                     property: dataVirtualMachine.createdAt
 177                 });
 178                 dispatch<any>(initAdvancedTabDialog(advanceDataVirtualMachine));
 179                 break;
 180             case ResourceKind.KEEP_SERVICE:
 181                 const dataKeepService = getState().keepServices.find(it => it.uuid === uuid);
 182                 const advanceDataKeepService: AdvancedTabDialogData = advancedTabData({
 183                     uuid,
 184                     metadata: '',
 185                     user: '',
 186                     apiResponseKind: keepServiceApiResponse,
 187                     data: dataKeepService,
 188                     resourceKind: KeepServiceData.KEEP_SERVICE,
 189                     resourcePrefix: ResourcePrefix.KEEP_SERVICES,
 190                     resourceKindProperty: KeepServiceData.CREATED_AT,
 191                     property: dataKeepService!.createdAt
 192                 });
 193                 dispatch<any>(initAdvancedTabDialog(advanceDataKeepService));
 194                 break;
 195             default:
 196                 dispatch(snackbarActions.OPEN_SNACKBAR({ message: "Could not open advanced tab for this resource.", hideDuration: 2000, kind: SnackbarKind.ERROR }));
 197         }
 198     };
 199
 200 const getDataForAdvancedTab = (uuid: string) =>
 201     async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
 202         const { resources } = getState();
 203         const data = getResource<any>(uuid)(resources);
 204         const metadata = await services.linkService.list({
 205             filters: new FilterBuilder()
 206                 .addEqual('headUuid', uuid)
 207                 .getFilters()
 208         });
 209         const user = metadata.itemsAvailable && await services.userService.get(metadata.items[0].tailUuid || '');
 210         return { data, metadata, user };
 211     };
 212
 213 const initAdvancedTabDialog = (data: AdvancedTabDialogData) => dialogActions.OPEN_DIALOG({ id: ADVANCED_TAB_DIALOG, data });
 214
 215 const advancedTabData = (args: {
 216     uuid: string, metadata: ListResults<LinkResource> | string, user: UserResource | string, apiResponseKind: any, data: any, resourceKind: AdvanceResourceKind,
 217     resourcePrefix: AdvanceResourcePrefix, resourceKindProperty: AdvanceResourceKind, property: any
 218 }) => {
 219     return {
 220         uuid: args.uuid,
 221         user: args.user,
 222         metadata: args.metadata,
 223         apiResponse: args.apiResponseKind(args.data),
 224         pythonHeader: pythonHeader(args.resourceKind),
 225         pythonExample: pythonExample(args.uuid, args.resourcePrefix),
 226         cliGetHeader: cliGetHeader(args.resourceKind),
 227         cliGetExample: cliGetExample(args.uuid, args.resourceKind),
 228         cliUpdateHeader: cliUpdateHeader(args.resourceKind, args.resourceKindProperty),
 229         cliUpdateExample: cliUpdateExample(args.uuid, args.resourceKind, args.property, args.resourceKindProperty),
 230         curlHeader: curlHeader(args.resourceKind, args.resourceKindProperty),
 231         curlExample: curlExample(args.uuid, args.resourcePrefix, args.property, args.resourceKind, args.resourceKindProperty),
 232     };
 233 };
 234
 235 const pythonHeader = (resourceKind: string) =>
 236     `An example python command to get a ${resourceKind} using its uuid:`;
 237
 238 const pythonExample = (uuid: string, resourcePrefix: string) => {
 239     const pythonExample = `import arvados
 240
 241 x = arvados.api().${resourcePrefix}().get(uuid='${uuid}').execute()`;
 242
 243     return pythonExample;
 244 };
 245
 246 const cliGetHeader = (resourceKind: string) =>
 247     `An example arv command to get a ${resourceKind} using its uuid:`;
 248
 249 const cliGetExample = (uuid: string, resourceKind: string) => {
 250     const cliGetExample = `arv ${resourceKind} get \\
 251   --uuid ${uuid}`;
 252
 253     return cliGetExample;
 254 };
 255
 256 const cliUpdateHeader = (resourceKind: string, resourceName: string) =>
 257     `An example arv command to update the "${resourceName}" attribute for the current ${resourceKind}:`;
 258
 259 const cliUpdateExample = (uuid: string, resourceKind: string, resource: string | string[], resourceName: string) => {
 260     const CLIUpdateCollectionExample = `arv ${resourceKind} update \\
 261   --uuid ${uuid} \\
 262   --${resourceKind} '{"${resourceName}":${resource}}'`;
 263
 264     return CLIUpdateCollectionExample;
 265 };
 266
 267 const curlHeader = (resourceKind: string, resource: string) =>
 268     `An example curl command to update the "${resource}" attribute for the current ${resourceKind}:`;
 269
 270 const curlExample = (uuid: string, resourcePrefix: string, resource: string | string[], resourceKind: string, resourceName: string) => {
 271     const curlExample = `curl -X PUT \\
 272   -H "Authorization: OAuth2 $ARVADOS_API_TOKEN" \\
 273   --data-urlencode ${resourceKind}@/dev/stdin \\
 274   https://$ARVADOS_API_HOST/arvados/v1/${resourcePrefix}/${uuid} \\
 275   <<EOF
 276 {
 277   "${resourceName}": ${resource}
 278 }
 279 EOF`;
 280
 281     return curlExample;
 282 };
 283
 284 const stringify = (item: string | null | number | boolean) =>
 285     JSON.stringify(item) || 'null';
 286
 287 const stringifyObject = (item: any) =>
 288     JSON.stringify(item, null, 2) || 'null';
 289
 290 const containerRequestApiResponse = (apiResponse: ContainerRequestResource) => {
 291     const { uuid, ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid, name, description, properties, state, requestingContainerUuid, containerUuid,
 292         containerCountMax, mounts, runtimeConstraints, containerImage, environment, cwd, command, outputPath, priority, expiresAt, filters, containerCount,
 293         useExisting, schedulingParameters, outputUuid, logUuid, outputName, outputTtl } = apiResponse;
 294     const response = `"uuid": "${uuid}",
 295 "owner_uuid": "${ownerUuid}",
 296 "created_at": "${createdAt}",
 297 "modified_at": ${stringify(modifiedAt)},
 298 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 299 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 300 "name": ${stringify(name)},
 301 "description": ${stringify(description)},
 302 "properties": ${stringifyObject(properties)},
 303 "state": ${stringify(state)},
 304 "requesting_container_uuid": ${stringify(requestingContainerUuid)},
 305 "container_uuid": ${stringify(containerUuid)},
 306 "container_count_max": ${stringify(containerCountMax)},
 307 "mounts": ${stringifyObject(mounts)},
 308 "runtime_constraints": ${stringifyObject(runtimeConstraints)},
 309 "container_image": "${stringify(containerImage)}",
 310 "environment": ${stringifyObject(environment)},
 311 "cwd": ${stringify(cwd)},
 312 "command": ${stringifyObject(command)},
 313 "output_path": ${stringify(outputPath)},
 314 "priority": ${stringify(priority)},
 315 "expires_at": ${stringify(expiresAt)},
 316 "filters": ${stringify(filters)},
 317 "container_count": ${stringify(containerCount)},
 318 "use_existing": ${stringify(useExisting)},
 319 "scheduling_parameters": ${stringifyObject(schedulingParameters)},
 320 "output_uuid": ${stringify(outputUuid)},
 321 "log_uuid": ${stringify(logUuid)},
 322 "output_name": ${stringify(outputName)},
 323 "output_ttl": ${stringify(outputTtl)}`;
 324
 325     return response;
 326 };
 327
 328 const collectionApiResponse = (apiResponse: CollectionResource) => {
 329     const { uuid, ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid, name, description, properties, portableDataHash, replicationDesired,
 330         replicationConfirmedAt, replicationConfirmed, manifestText, deleteAt, trashAt, isTrashed, storageClassesDesired,
 331         storageClassesConfirmed, storageClassesConfirmedAt } = apiResponse;
 332     const response = `"uuid": "${uuid}",
 333 "owner_uuid": "${ownerUuid}",
 334 "created_at": "${createdAt}",
 335 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 336 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 337 "modified_at": ${stringify(modifiedAt)},
 338 "portable_data_hash": ${stringify(portableDataHash)},
 339 "replication_desired": ${stringify(replicationDesired)},
 340 "replication_confirmed_at": ${stringify(replicationConfirmedAt)},
 341 "replication_confirmed": ${stringify(replicationConfirmed)},
 342 "manifest_text": ${stringify(manifestText)},
 343 "name": ${stringify(name)},
 344 "description": ${stringify(description)},
 345 "properties": ${stringifyObject(properties)},
 346 "delete_at": ${stringify(deleteAt)},
 347 "trash_at": ${stringify(trashAt)},
 348 "is_trashed": ${stringify(isTrashed)},
 349 "storage_classes_desired": ${JSON.stringify(storageClassesDesired, null, 2)},
 350 "storage_classes_confirmed": ${JSON.stringify(storageClassesConfirmed, null, 2)},
 351 "storage_classes_confirmed_at": ${stringify(storageClassesConfirmedAt)}`;
 352
 353     return response;
 354 };
 355
 356 const groupRequestApiResponse = (apiResponse: ProjectResource) => {
 357     const { uuid, ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid, name, description, groupClass, trashAt, isTrashed, deleteAt, properties } = apiResponse;
 358     const response = `"uuid": "${uuid}",
 359 "owner_uuid": "${ownerUuid}",
 360 "created_at": "${createdAt}",
 361 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 362 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 363 "modified_at": ${stringify(modifiedAt)},
 364 "name": ${stringify(name)},
 365 "description": ${stringify(description)},
 366 "group_class": ${stringify(groupClass)},
 367 "trash_at": ${stringify(trashAt)},
 368 "is_trashed": ${stringify(isTrashed)},
 369 "delete_at": ${stringify(deleteAt)},
 370 "properties": ${stringifyObject(properties)}`;
 371
 372     return response;
 373 };
 374
 375 const repositoryApiResponse = (apiResponse: RepositoryResource) => {
 376     const { uuid, ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid, name } = apiResponse;
 377     const response = `"uuid": "${uuid}",
 378 "owner_uuid": "${ownerUuid}",
 379 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 380 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 381 "modified_at": ${stringify(modifiedAt)},
 382 "name": ${stringify(name)},
 383 "created_at": "${createdAt}"`;
 384
 385     return response;
 386 };
 387
 388 const sshKeyApiResponse = (apiResponse: SshKeyResource) => {
 389     const { uuid, ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid, name, authorizedUserUuid, expiresAt } = apiResponse;
 390     const response = `"uuid": "${uuid}",
 391 "owner_uuid": "${ownerUuid}",
 392 "authorized_user_uuid": "${authorizedUserUuid}",
 393 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 394 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 395 "modified_at": ${stringify(modifiedAt)},
 396 "name": ${stringify(name)},
 397 "created_at": "${createdAt}",
 398 "expires_at": "${expiresAt}"`;
 399     return response;
 400 };
 401
 402 const virtualMachineApiResponse = (apiResponse: VirtualMachinesResource) => {
 403     const { uuid, ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid, hostname } = apiResponse;
 404     const response = `"hostname": ${stringify(hostname)},
 405 "uuid": "${uuid}",
 406 "owner_uuid": "${ownerUuid}",
 407 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 408 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 409 "modified_at": ${stringify(modifiedAt)},
 410 "modified_at": ${stringify(modifiedAt)},
 411 "created_at": "${createdAt}"`;
 412
 413     return response;
 414 };
 415
 416 const keepServiceApiResponse = (apiResponse: KeepServiceResource) => {
 417     const {
 418         uuid, readOnly, serviceHost, servicePort, serviceSslFlag, serviceType,
 419         ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid
 420     } = apiResponse;
 421     const response = `"uuid": "${uuid}",
 422 "owner_uuid": "${ownerUuid}",
 423 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 424 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 425 "modified_at": ${stringify(modifiedAt)},
 426 "service_host": "${serviceHost}",
 427 "service_port": "${servicePort}",
 428 "service_ssl_flag": "${stringify(serviceSslFlag)}",
 429 "service_type": "${serviceType}",
 430 "created_at": "${createdAt}",
 431 "read_only": "${stringify(readOnly)}"`;
 432
 433     return response;
 434 };