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     USERS = 'users'
  77 }
  78
  79 enum KeepServiceData {
  80     KEEP_SERVICE = 'keep_services',
  81     CREATED_AT = 'created_at'
  82 }
  83
  84 enum UserData {
  85     USER = 'user',
  86     USERNAME = 'username'
  87 }
  88
  89 type AdvanceResourceKind = CollectionData | ProcessData | ProjectData | RepositoryData | SshKeyData | VirtualMachineData | KeepServiceData | UserData;
  90 type AdvanceResourcePrefix = GroupContentsResourcePrefix | ResourcePrefix;
  91 type AdvanceResponseData = ContainerRequestResource | ProjectResource | CollectionResource | RepositoryResource | SshKeyResource | VirtualMachinesResource | KeepServiceResource | UserResource | undefined;
  92
  93 export const openAdvancedTabDialog = (uuid: string) =>
  94     async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
  95         const kind = extractUuidKind(uuid);
  96         switch (kind) {
  97             case ResourceKind.COLLECTION:
  98                 const { data: dataCollection, metadata: metaCollection, user: userCollection } = await dispatch<any>(getDataForAdvancedTab(uuid));
  99                 const advanceDataCollection = advancedTabData({
 100                     uuid,
 101                     metadata: metaCollection,
 102                     user: userCollection,
 103                     apiResponseKind: collectionApiResponse,
 104                     data: dataCollection,
 105                     resourceKind: CollectionData.COLLECTION,
 106                     resourcePrefix: GroupContentsResourcePrefix.COLLECTION,
 107                     resourceKindProperty: CollectionData.STORAGE_CLASSES_CONFIRMED,
 108                     property: dataCollection.storageClassesConfirmed
 109                 });
 110                 dispatch<any>(initAdvancedTabDialog(advanceDataCollection));
 111                 break;
 112             case ResourceKind.PROCESS:
 113                 const { data: dataProcess, metadata: metaProcess, user: userProcess } = await dispatch<any>(getDataForAdvancedTab(uuid));
 114                 const advancedDataProcess = advancedTabData({
 115                     uuid,
 116                     metadata: metaProcess,
 117                     user: userProcess,
 118                     apiResponseKind: containerRequestApiResponse,
 119                     data: dataProcess,
 120                     resourceKind: ProcessData.CONTAINER_REQUEST,
 121                     resourcePrefix: GroupContentsResourcePrefix.PROCESS,
 122                     resourceKindProperty: ProcessData.OUTPUT_NAME,
 123                     property: dataProcess.outputName
 124                 });
 125                 dispatch<any>(initAdvancedTabDialog(advancedDataProcess));
 126                 break;
 127             case ResourceKind.PROJECT:
 128                 const { data: dataProject, metadata: metaProject, user: userProject } = await dispatch<any>(getDataForAdvancedTab(uuid));
 129                 const advanceDataProject = advancedTabData({
 130                     uuid,
 131                     metadata: metaProject,
 132                     user: userProject,
 133                     apiResponseKind: groupRequestApiResponse,
 134                     data: dataProject,
 135                     resourceKind: ProjectData.GROUP,
 136                     resourcePrefix: GroupContentsResourcePrefix.PROJECT,
 137                     resourceKindProperty: ProjectData.DELETE_AT,
 138                     property: dataProject.deleteAt
 139                 });
 140                 dispatch<any>(initAdvancedTabDialog(advanceDataProject));
 141                 break;
 142             case ResourceKind.REPOSITORY:
 143                 const dataRepository = getState().repositories.items.find(it => it.uuid === uuid);
 144                 const advanceDataRepository = advancedTabData({
 145                     uuid,
 146                     metadata: '',
 147                     user: '',
 148                     apiResponseKind: repositoryApiResponse,
 149                     data: dataRepository,
 150                     resourceKind: RepositoryData.REPOSITORY,
 151                     resourcePrefix: ResourcePrefix.REPOSITORIES,
 152                     resourceKindProperty: RepositoryData.CREATED_AT,
 153                     property: dataRepository!.createdAt
 154                 });
 155                 dispatch<any>(initAdvancedTabDialog(advanceDataRepository));
 156                 break;
 157             case ResourceKind.SSH_KEY:
 158                 const dataSshKey = getState().auth.sshKeys.find(it => it.uuid === uuid);
 159                 const advanceDataSshKey = advancedTabData({
 160                     uuid,
 161                     metadata: '',
 162                     user: '',
 163                     apiResponseKind: sshKeyApiResponse,
 164                     data: dataSshKey,
 165                     resourceKind: SshKeyData.SSH_KEY,
 166                     resourcePrefix: ResourcePrefix.AUTORIZED_KEYS,
 167                     resourceKindProperty: SshKeyData.CREATED_AT,
 168                     property: dataSshKey!.createdAt
 169                 });
 170                 dispatch<any>(initAdvancedTabDialog(advanceDataSshKey));
 171                 break;
 172             case ResourceKind.VIRTUAL_MACHINE:
 173                 const dataVirtualMachine = getState().virtualMachines.virtualMachines.items.find(it => it.uuid === uuid);
 174                 const advanceDataVirtualMachine = advancedTabData({
 175                     uuid,
 176                     metadata: '',
 177                     user: '',
 178                     apiResponseKind: virtualMachineApiResponse,
 179                     data: dataVirtualMachine,
 180                     resourceKind: VirtualMachineData.VIRTUAL_MACHINE,
 181                     resourcePrefix: ResourcePrefix.VIRTUAL_MACHINES,
 182                     resourceKindProperty: VirtualMachineData.CREATED_AT,
 183                     property: dataVirtualMachine.createdAt
 184                 });
 185                 dispatch<any>(initAdvancedTabDialog(advanceDataVirtualMachine));
 186                 break;
 187             case ResourceKind.KEEP_SERVICE:
 188                 const dataKeepService = getState().keepServices.find(it => it.uuid === uuid);
 189                 const advanceDataKeepService = advancedTabData({
 190                     uuid,
 191                     metadata: '',
 192                     user: '',
 193                     apiResponseKind: keepServiceApiResponse,
 194                     data: dataKeepService,
 195                     resourceKind: KeepServiceData.KEEP_SERVICE,
 196                     resourcePrefix: ResourcePrefix.KEEP_SERVICES,
 197                     resourceKindProperty: KeepServiceData.CREATED_AT,
 198                     property: dataKeepService!.createdAt
 199                 });
 200                 dispatch<any>(initAdvancedTabDialog(advanceDataKeepService));
 201                 break;
 202             case ResourceKind.USER:
 203                 const { resources } = getState();
 204                 const data = getResource<UserResource>(uuid)(resources);
 205                 const metadata = await services.linkService.list({
 206                     filters: new FilterBuilder()
 207                         .addEqual('headUuid', uuid)
 208                         .getFilters()
 209                 });
 210                 const advanceDataUser = advancedTabData({
 211                     uuid,
 212                     metadata,
 213                     user: '',
 214                     apiResponseKind: userApiResponse,
 215                     data,
 216                     resourceKind: UserData.USER,
 217                     resourcePrefix: ResourcePrefix.USERS,
 218                     resourceKindProperty: UserData.USERNAME,
 219                     property: data!.username
 220                 });
 221                 dispatch<any>(initAdvancedTabDialog(advanceDataUser));
 222                 break;
 223             default:
 224                 dispatch(snackbarActions.OPEN_SNACKBAR({ message: "Could not open advanced tab for this resource.", hideDuration: 2000, kind: SnackbarKind.ERROR }));
 225         }
 226     };
 227
 228 const getDataForAdvancedTab = (uuid: string) =>
 229     async (dispatch: Dispatch<any>, getState: () => RootState, services: ServiceRepository) => {
 230         const { resources } = getState();
 231         const data = getResource<any>(uuid)(resources);
 232         const metadata = await services.linkService.list({
 233             filters: new FilterBuilder()
 234                 .addEqual('headUuid', uuid)
 235                 .getFilters()
 236         });
 237         const user = metadata.itemsAvailable && await services.userService.get(metadata.items[0].tailUuid || '');
 238         return { data, metadata, user };
 239     };
 240
 241 const initAdvancedTabDialog = (data: AdvancedTabDialogData) => dialogActions.OPEN_DIALOG({ id: ADVANCED_TAB_DIALOG, data });
 242
 243 interface AdvancedTabData {
 244     uuid: string;
 245     metadata: ListResults<LinkResource> | string;
 246     user: UserResource | string;
 247     apiResponseKind: (apiResponse: AdvanceResponseData) => string;
 248     data: AdvanceResponseData;
 249     resourceKind: AdvanceResourceKind;
 250     resourcePrefix: AdvanceResourcePrefix;
 251     resourceKindProperty: AdvanceResourceKind;
 252     property: any;
 253 }
 254
 255 const advancedTabData = ({ uuid, user, metadata, apiResponseKind, data, resourceKind, resourcePrefix, resourceKindProperty, property }: AdvancedTabData) => {
 256     return {
 257         uuid,
 258         user,
 259         metadata,
 260         apiResponse: apiResponseKind(data),
 261         pythonHeader: pythonHeader(resourceKind),
 262         pythonExample: pythonExample(uuid, resourcePrefix),
 263         cliGetHeader: cliGetHeader(resourceKind),
 264         cliGetExample: cliGetExample(uuid, resourceKind),
 265         cliUpdateHeader: cliUpdateHeader(resourceKind, resourceKindProperty),
 266         cliUpdateExample: cliUpdateExample(uuid, resourceKind, property, resourceKindProperty),
 267         curlHeader: curlHeader(resourceKind, resourceKindProperty),
 268         curlExample: curlExample(uuid, resourcePrefix, property, resourceKind, resourceKindProperty),
 269     };
 270 };
 271
 272 const pythonHeader = (resourceKind: string) =>
 273     `An example python command to get a ${resourceKind} using its uuid:`;
 274
 275 const pythonExample = (uuid: string, resourcePrefix: string) => {
 276     const pythonExample = `import arvados
 277
 278 x = arvados.api().${resourcePrefix}().get(uuid='${uuid}').execute()`;
 279
 280     return pythonExample;
 281 };
 282
 283 const cliGetHeader = (resourceKind: string) =>
 284     `An example arv command to get a ${resourceKind} using its uuid:`;
 285
 286 const cliGetExample = (uuid: string, resourceKind: string) => {
 287     const cliGetExample = `arv ${resourceKind} get \\
 288   --uuid ${uuid}`;
 289
 290     return cliGetExample;
 291 };
 292
 293 const cliUpdateHeader = (resourceKind: string, resourceName: string) =>
 294     `An example arv command to update the "${resourceName}" attribute for the current ${resourceKind}:`;
 295
 296 const cliUpdateExample = (uuid: string, resourceKind: string, resource: string | string[], resourceName: string) => {
 297     const CLIUpdateCollectionExample = `arv ${resourceKind} update \\
 298   --uuid ${uuid} \\
 299   --${resourceKind} '{"${resourceName}":${resource}}'`;
 300
 301     return CLIUpdateCollectionExample;
 302 };
 303
 304 const curlHeader = (resourceKind: string, resource: string) =>
 305     `An example curl command to update the "${resource}" attribute for the current ${resourceKind}:`;
 306
 307 const curlExample = (uuid: string, resourcePrefix: string, resource: string | string[], resourceKind: string, resourceName: string) => {
 308     const curlExample = `curl -X PUT \\
 309   -H "Authorization: OAuth2 $ARVADOS_API_TOKEN" \\
 310   --data-urlencode ${resourceKind}@/dev/stdin \\
 311   https://$ARVADOS_API_HOST/arvados/v1/${resourcePrefix}/${uuid} \\
 312   <<EOF
 313 {
 314   "${resourceName}": ${resource}
 315 }
 316 EOF`;
 317
 318     return curlExample;
 319 };
 320
 321 const stringify = (item: string | null | number | boolean) =>
 322     JSON.stringify(item) || 'null';
 323
 324 const stringifyObject = (item: any) =>
 325     JSON.stringify(item, null, 2) || 'null';
 326
 327 const containerRequestApiResponse = (apiResponse: ContainerRequestResource) => {
 328     const { uuid, ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid, name, description, properties, state, requestingContainerUuid, containerUuid,
 329         containerCountMax, mounts, runtimeConstraints, containerImage, environment, cwd, command, outputPath, priority, expiresAt, filters, containerCount,
 330         useExisting, schedulingParameters, outputUuid, logUuid, outputName, outputTtl } = apiResponse;
 331     const response = `"uuid": "${uuid}",
 332 "owner_uuid": "${ownerUuid}",
 333 "created_at": "${createdAt}",
 334 "modified_at": ${stringify(modifiedAt)},
 335 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 336 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 337 "name": ${stringify(name)},
 338 "description": ${stringify(description)},
 339 "properties": ${stringifyObject(properties)},
 340 "state": ${stringify(state)},
 341 "requesting_container_uuid": ${stringify(requestingContainerUuid)},
 342 "container_uuid": ${stringify(containerUuid)},
 343 "container_count_max": ${stringify(containerCountMax)},
 344 "mounts": ${stringifyObject(mounts)},
 345 "runtime_constraints": ${stringifyObject(runtimeConstraints)},
 346 "container_image": "${stringify(containerImage)}",
 347 "environment": ${stringifyObject(environment)},
 348 "cwd": ${stringify(cwd)},
 349 "command": ${stringifyObject(command)},
 350 "output_path": ${stringify(outputPath)},
 351 "priority": ${stringify(priority)},
 352 "expires_at": ${stringify(expiresAt)},
 353 "filters": ${stringify(filters)},
 354 "container_count": ${stringify(containerCount)},
 355 "use_existing": ${stringify(useExisting)},
 356 "scheduling_parameters": ${stringifyObject(schedulingParameters)},
 357 "output_uuid": ${stringify(outputUuid)},
 358 "log_uuid": ${stringify(logUuid)},
 359 "output_name": ${stringify(outputName)},
 360 "output_ttl": ${stringify(outputTtl)}`;
 361
 362     return response;
 363 };
 364
 365 const collectionApiResponse = (apiResponse: CollectionResource) => {
 366     const { uuid, ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid, name, description, properties, portableDataHash, replicationDesired,
 367         replicationConfirmedAt, replicationConfirmed, manifestText, deleteAt, trashAt, isTrashed, storageClassesDesired,
 368         storageClassesConfirmed, storageClassesConfirmedAt } = apiResponse;
 369     const response = `"uuid": "${uuid}",
 370 "owner_uuid": "${ownerUuid}",
 371 "created_at": "${createdAt}",
 372 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 373 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 374 "modified_at": ${stringify(modifiedAt)},
 375 "portable_data_hash": ${stringify(portableDataHash)},
 376 "replication_desired": ${stringify(replicationDesired)},
 377 "replication_confirmed_at": ${stringify(replicationConfirmedAt)},
 378 "replication_confirmed": ${stringify(replicationConfirmed)},
 379 "manifest_text": ${stringify(manifestText)},
 380 "name": ${stringify(name)},
 381 "description": ${stringify(description)},
 382 "properties": ${stringifyObject(properties)},
 383 "delete_at": ${stringify(deleteAt)},
 384 "trash_at": ${stringify(trashAt)},
 385 "is_trashed": ${stringify(isTrashed)},
 386 "storage_classes_desired": ${JSON.stringify(storageClassesDesired, null, 2)},
 387 "storage_classes_confirmed": ${JSON.stringify(storageClassesConfirmed, null, 2)},
 388 "storage_classes_confirmed_at": ${stringify(storageClassesConfirmedAt)}`;
 389
 390     return response;
 391 };
 392
 393 const groupRequestApiResponse = (apiResponse: ProjectResource) => {
 394     const { uuid, ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid, name, description, groupClass, trashAt, isTrashed, deleteAt, properties } = apiResponse;
 395     const response = `"uuid": "${uuid}",
 396 "owner_uuid": "${ownerUuid}",
 397 "created_at": "${createdAt}",
 398 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 399 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 400 "modified_at": ${stringify(modifiedAt)},
 401 "name": ${stringify(name)},
 402 "description": ${stringify(description)},
 403 "group_class": ${stringify(groupClass)},
 404 "trash_at": ${stringify(trashAt)},
 405 "is_trashed": ${stringify(isTrashed)},
 406 "delete_at": ${stringify(deleteAt)},
 407 "properties": ${stringifyObject(properties)}`;
 408
 409     return response;
 410 };
 411
 412 const repositoryApiResponse = (apiResponse: RepositoryResource) => {
 413     const { uuid, ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid, name } = apiResponse;
 414     const response = `"uuid": "${uuid}",
 415 "owner_uuid": "${ownerUuid}",
 416 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 417 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 418 "modified_at": ${stringify(modifiedAt)},
 419 "name": ${stringify(name)},
 420 "created_at": "${createdAt}"`;
 421
 422     return response;
 423 };
 424
 425 const sshKeyApiResponse = (apiResponse: SshKeyResource) => {
 426     const { uuid, ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid, name, authorizedUserUuid, expiresAt } = apiResponse;
 427     const response = `"uuid": "${uuid}",
 428 "owner_uuid": "${ownerUuid}",
 429 "authorized_user_uuid": "${authorizedUserUuid}",
 430 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 431 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 432 "modified_at": ${stringify(modifiedAt)},
 433 "name": ${stringify(name)},
 434 "created_at": "${createdAt}",
 435 "expires_at": "${expiresAt}"`;
 436     return response;
 437 };
 438
 439 const virtualMachineApiResponse = (apiResponse: VirtualMachinesResource) => {
 440     const { uuid, ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid, hostname } = apiResponse;
 441     const response = `"hostname": ${stringify(hostname)},
 442 "uuid": "${uuid}",
 443 "owner_uuid": "${ownerUuid}",
 444 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 445 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 446 "modified_at": ${stringify(modifiedAt)},
 447 "modified_at": ${stringify(modifiedAt)},
 448 "created_at": "${createdAt}"`;
 449
 450     return response;
 451 };
 452
 453 const keepServiceApiResponse = (apiResponse: KeepServiceResource) => {
 454     const {
 455         uuid, readOnly, serviceHost, servicePort, serviceSslFlag, serviceType,
 456         ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid
 457     } = apiResponse;
 458     const response = `"uuid": "${uuid}",
 459 "owner_uuid": "${ownerUuid}",
 460 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 461 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 462 "modified_at": ${stringify(modifiedAt)},
 463 "service_host": "${serviceHost}",
 464 "service_port": "${servicePort}",
 465 "service_ssl_flag": "${stringify(serviceSslFlag)}",
 466 "service_type": "${serviceType}",
 467 "created_at": "${createdAt}",
 468 "read_only": "${stringify(readOnly)}"`;
 469
 470     return response;
 471 };
 472
 473 const userApiResponse = (apiResponse: UserResource) => {
 474     const {
 475         uuid, ownerUuid, createdAt, modifiedAt, modifiedByClientUuid, modifiedByUserUuid,
 476         email, firstName, lastName, identityUrl, isActive, isAdmin, prefs, defaultOwnerUuid, username
 477     } = apiResponse;
 478     const response = `"uuid": "${uuid}",
 479 "owner_uuid": "${ownerUuid}",
 480 "created_at": "${createdAt}",
 481 "modified_by_client_uuid": ${stringify(modifiedByClientUuid)},
 482 "modified_by_user_uuid": ${stringify(modifiedByUserUuid)},
 483 "modified_at": ${stringify(modifiedAt)},
 484 "email": "${email}",
 485 "first_name": "${firstName}",
 486 "last_name": "${stringify(lastName)}",
 487 "identity_url": "${identityUrl}",
 488 "is_active": "${isActive},
 489 "is_admin": "${isAdmin},
 490 "prefs": "${stringifyObject(prefs)},
 491 "default_owner_uuid": "${defaultOwnerUuid},
 492 "username": "${username}"`;
 493
 494     return response;
 495 };