Skip to content

A modern, self-hosted backup solution for secure, encrypted backups across local and cloud storage.

9.7 KB
Raw Blame
import Icon from '../../common/Icon/Icon';
import SidePanel from '../../common/SidePanel/SidePanel';
import { getBackupEventActionMessage, getRestoreEventActionMessage, isWarningAction } from '../../../utils/progressHelpers';
import classes from './BackupEvents.module.scss';
import { BackupProgressData, ReplicationProgressData } from '../../../@types/backups';
import { useGetBackupProgressOnce } from '../../../services/backups';
import { useGetRestoreProgressOnce } from '../../../services/restores';
import { useMemo, useState } from 'react';
import Modal from '../../common/Modal/Modal';
import { formatDuration } from '../../../utils/helpers';

interface BackupEventsProps {
   id: string;
   planId: string;
   sourceId: string;
   sourceType: string;
   type?: 'backup' | 'restore';
   inProgress?: boolean;
   progressData?: BackupProgressData | null;
   close: () => void;
}

const BackupEvents = ({ id, type = 'backup', sourceId, sourceType, planId, inProgress, progressData, close }: BackupEventsProps) => {
   const [showError, setShowError] = useState<false | string>(false);
   const { data: fetchedProgressData, isLoading } =
      type === 'backup'
         ? useGetBackupProgressOnce({ id, sourceId, sourceType, planId })
         : useGetRestoreProgressOnce({ id, sourceId, sourceType, planId });

   const progressDataToUse: BackupProgressData | null = progressData || fetchedProgressData;

   console.log('progressDataToUse :', progressDataToUse);
   const hasFinished = useMemo(() => {
      if (!progressDataToUse || !progressDataToUse.events) return '';
      let finishedEvent = '';
      progressDataToUse.events.forEach((event) => {
         if (event.action === 'TASK_COMPLETED') {
            finishedEvent = 'Completed';
         } else if (event.action === 'TASK_CANCELLED') {
            finishedEvent = 'Cancelled';
         } else if (event.action === 'FAILED_PERMANENTLY') {
            finishedEvent = 'Failed';
         }
      });
      return finishedEvent;
   }, [progressDataToUse]);

   return (
      <SidePanel title={`${type}-${id} Events`} width="1000px" icon={<Icon type={'logs'} size={18} />} footer={<></>} close={close}>
         <div className={classes.backupEventsContainer}>
            <div className={classes.header}>
               <div
                  title="Status"
                  className={`${classes.status} ${inProgress ? classes.inProgress : ''} 
               ${!inProgress && hasFinished === 'Completed' ? classes.hasCompleted : ''} ${!inProgress && hasFinished === 'Failed' ? classes.hasFailed : ''}`}
               >
                  <Icon type={inProgress ? 'loading' : hasFinished === 'Completed' ? 'check-circle-filled' : 'error-circle-filled'} size={14} />{' '}
                  {inProgress ? `${type} In Progress` : `${type} ${hasFinished}` || 'Unknown'}
               </div>
               {!inProgress && hasFinished && (
                  <div title="Duration" className={classes.duration}>
                     <Icon type="clock" size={14} /> {(progressDataToUse?.duration && formatDuration(progressDataToUse.duration / 1000)) || 'N/A'}
                  </div>
               )}
            </div>
            {isLoading && (
               <div className={classes.loading}>
                  <Icon type={'loading'} size={30} />
               </div>
            )}
            {progressDataToUse && progressDataToUse.events && progressDataToUse.events.length > 0 ? (
               <ul className={classes.eventList}>
                  {progressDataToUse.events.map((event: any, index: number) => {
                     const completed = event.phase === 'finished' && event.action === 'TASK_COMPLETED';
                     const failed = event.phase === 'finished' && event.action === 'FAILED_PERMANENTLY';
                     const retrying = event.action.includes('RETRY_ATTEMPT_');
                     const isError = event.action === 'TASK_FAILED';
                     const isWarning = isWarningAction(event.action);
                     return (
                        <li
                           key={index}
                           className={`${classes.eventItem} ${event.error ? classes.error : ''} 
                           ${completed ? classes.completed : ''} ${failed ? classes.failed : ''} 
                           ${retrying ? classes.retrying : ''} ${isError ? classes.isError : ''} 
                           ${isWarning ? classes.isWarning : ''}`}
                        >
                           <span className={classes.icon}>
                              <Icon type={event.error || isWarning ? 'error-circle-filled' : 'check-circle-filled'} size={16} />
                           </span>
                           {/* Timestamp should be converted to time only eg: 10:20:23 AM */}
                           <span className={classes.time}>{new Date(event.timestamp).toLocaleTimeString()}</span>
                           <span className={classes.phase}>{event.phase}</span>
                           <span className={classes.action}>
                              {type === 'backup' ? getBackupEventActionMessage(event.action) : getRestoreEventActionMessage(event.action)}
                              {event.error && (
                                 <span className={classes.viewError} onClick={() => setShowError(`main-${index}`)}>
                                    View Details
                                 </span>
                              )}
                           </span>
                        </li>
                     );
                  })}
               </ul>
            ) : null}
            {/* Mirror Events */}
            {progressDataToUse?.mirrors && Object.keys(progressDataToUse.mirrors).length > 0 && (
               <div className={classes.mirrorsEventsSection}>
                  {Object.entries(progressDataToUse.mirrors as Record<string, ReplicationProgressData>).map(([storageId, mirror]) => (
                     <div key={storageId} className={classes.mirrorEventsGroup}>
                        <div className={classes.mirrorEventsHeader}>
                           <img src={`/providers/${mirror.storageType}.png`} className={classes.mirrorProviderIcon} />
                           <span className={classes.mirrorEventsName}>{mirror.storageName}</span>
                           <span className={`${classes.mirrorEventsStatus} ${classes[`mirror_${mirror.status}`] || ''}`}>{mirror.status}</span>
                        </div>
                        {mirror.events && mirror.events.length > 0 ? (
                           <ul className={classes.eventList}>
                              {mirror.events.map((event: any, index: number) => {
                                 const isError = event.error;
                                 const isCompleted = event.action === 'REPLICATION_COMPLETE';
                                 const isFailed = event.action === 'REPLICATION_FAILED';
                                 return (
                                    <li
                                       key={index}
                                       className={`${classes.eventItem} ${isError ? classes.error : ''} ${isCompleted ? classes.completed : ''} ${isFailed ? classes.failed : ''}`}
                                    >
                                       <span className={classes.icon}>
                                          <Icon type={isError ? 'error-circle-filled' : 'check-circle-filled'} size={16} />
                                       </span>
                                       <span className={classes.time}>{new Date(event.timestamp).toLocaleTimeString()}</span>
                                       <span className={classes.phase}>{event.phase}</span>
                                       <span className={classes.action}>
                                          {getBackupEventActionMessage(event.action, mirror.storageName)}
                                          {event.error && (
                                             <span className={classes.viewError} onClick={() => setShowError(`mirror-${storageId}-${index}`)}>
                                                View Details
                                             </span>
                                          )}
                                       </span>
                                    </li>
                                 );
                              })}
                           </ul>
                        ) : (
                           <div className={classes.noEvents}>No events recorded</div>
                        )}
                     </div>
                  ))}
               </div>
            )}
         </div>
         {showError && (
            <Modal title="Error Details" closeModal={() => setShowError(false)} width={'400px'}>
               <div className={classes.errorDetails} data-length={showError.length}>
                  {(() => {
                     if (typeof showError === 'string') {
                        if (showError.startsWith('main-')) {
                           const idx = parseInt(showError.replace('main-', ''));
                           return progressDataToUse?.events[idx]?.error || 'Unknown error occurred.';
                        }
                        if (showError.startsWith('mirror-')) {
                           const parts = showError.replace('mirror-', '').split('-');
                           const eventIdx = parseInt(parts.pop()!);
                           const sId = parts.join('-');
                           return (progressDataToUse?.mirrors as any)?.[sId]?.events?.[eventIdx]?.error || 'Unknown error occurred.';
                        }
                     }
                     return 'Unknown error occurred.';
                  })()}
               </div>
            </Modal>
         )}
      </SidePanel>
   );
};

export default BackupEvents;