Hot, Warm, and Cold Storage

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

Object Restore Lifecycle
═══════════════════════════════════════════════════════════════════════════
 
Phase 1: Object in Archive (Normal State)
┌─────────────────────────────────────────────────────────────────────────┐
│  Object: reports/2020/annual-report.pdf                                 │
│  Storage Class: GLACIER                                                 │
│  Status: ARCHIVED                                                       │
│  Access: ✗ Cannot read - must restore first                            │
└─────────────────────────────────────────────────────────────────────────┘
                           │
                           │ Restore Request (RestoreObject API)
                           │ Specify: retrieval tier (Standard/Expedited/Bulk)
                           │          restore duration (days)
                           ▼
Phase 2: Restore In Progress
┌─────────────────────────────────────────────────────────────────────────┐
│  Object: reports/2020/annual-report.pdf                                 │
│  Storage Class: GLACIER                                                 │
│  Status: RESTORE_IN_PROGRESS                                            │
│  Access: ✗ Cannot read - restore not yet complete                      │
│  Estimated completion: ~3-5 hours (Standard tier)                       │
└─────────────────────────────────────────────────────────────────────────┘
                           │
                           │ Restore completes (async, check via HeadObject)
                           │ Or receive S3 Event Notification "Restore Completed"
                           ▼
Phase 3: Restored Copy Available
┌─────────────────────────────────────────────────────────────────────────┐
│  Object: reports/2020/annual-report.pdf                                 │
│  Storage Class: GLACIER (unchanged - archival copy remains)             │
│  Status: RESTORED                                                       │
│  Access: ✓ Can read normally via GetObject                             │
│  Temporary copy expires: In 7 days (as configured)                      │
│  x-amz-restore header: ongoing-request="false", expiry-date="..."       │
└─────────────────────────────────────────────────────────────────────────┘
                           │
                           │ Expiration period elapses (configurable 1-30 days)
                           │ Or: another restore extends expiration
                           ▼
Phase 4: Restored Copy Expires
┌─────────────────────────────────────────────────────────────────────────┐
│  Object: reports/2020/annual-report.pdf                                 │
│  Storage Class: GLACIER                                                 │
│  Status: ARCHIVED (back to Phase 1)                                     │
│  Access: ✗ Cannot read - restore expired                               │
└─────────────────────────────────────────────────────────────────────────┘

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113

import { 
  S3Client, 
  RestoreObjectCommand, 
  HeadObjectCommand,
  GetObjectCommand
} from '@aws-sdk/client-s3';
 
interface RestoreResult {
  status: 'already_restored' | 'restore_initiated' | 'restore_in_progress' | 'error';
  estimatedCompletionTime?: Date;
  expirationTime?: Date;
}
 
async function restoreGlacierObject(
  bucket: string,
  key: string,
  restoreDays: number = 7,
  retrievalTier: 'Expedited' | 'Standard' | 'Bulk' = 'Standard'
): Promise<RestoreResult> {
  const s3 = new S3Client({});
  
  // First, check current restore status
  const headResponse = await s3.send(new HeadObjectCommand({
    Bucket: bucket,
    Key: key
  }));
  
  // Parse restore header if present
  const restoreHeader = headResponse.Restore;
  
  if (restoreHeader) {
    if (restoreHeader.includes('ongoing-request="true"')) {
      // Restore already in progress
      return { status: 'restore_in_progress' };
    }
    
    if (restoreHeader.includes('ongoing-request="false"')) {
      // Object already restored; extract expiration
      const expiryMatch = restoreHeader.match(/expiry-date="([^"]+)"/);
      const expirationTime = expiryMatch ? new Date(expiryMatch[1]) : undefined;
      
      return { 
        status: 'already_restored',
        expirationTime 
      };
    }
  }
  
  // Initiate restore
  try {
    await s3.send(new RestoreObjectCommand({
      Bucket: bucket,
      Key: key,
      RestoreRequest: {
        Days: restoreDays,
        GlacierJobParameters: {
          Tier: retrievalTier
        }
      }
    }));
    
    // Estimate completion based on tier
    const estimatedHours = {
      'Expedited': 0.1,   // ~5 minutes
      'Standard': 4,       // 3-5 hours
      'Bulk': 8            // 5-12 hours
    };
    
    const estimatedCompletionTime = new Date(
      Date.now() + estimatedHours[retrievalTier] * 60 * 60 * 1000
    );
    
    return {
      status: 'restore_initiated',
      estimatedCompletionTime
    };
    
  } catch (error: any) {
    if (error.name === 'RestoreAlreadyInProgressException') {
      return { status: 'restore_in_progress' };
    }
    throw error;
  }
}
 
// Usage in application
async function accessArchivedReport(reportId: string): Promise<{
  ready: boolean;
  url?: string;
  estimatedWait?: number;
}> {
  const key = `reports/${reportId}.pdf`;
  
  const restoreResult = await restoreGlacierObject('my-bucket', key);
  
  switch (restoreResult.status) {
    case 'already_restored':
      // Data is ready - generate presigned URL
      const url = await generatePresignedUrl('my-bucket', key, 3600);
      return { ready: true, url };
      
    case 'restore_initiated':
    case 'restore_in_progress':
      // Data not ready - inform user of wait time
      const waitMs = restoreResult.estimatedCompletionTime 
        ? restoreResult.estimatedCompletionTime.getTime() - Date.now()
        : 4 * 60 * 60 * 1000;  // Default 4 hours
      return { ready: false, estimatedWait: waitMs };
      
    default:
      throw new Error('Failed to restore archived data');
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36

┌─────────┐         ┌─────────────┐         ┌─────────────┐         ┌─────────┐
│  User   │         │  API/App    │         │  Job Queue  │         │  S3     │
└────┬────┘         └──────┬──────┘         └──────┬──────┘         └────┬────┘
     │                     │                       │                     │
     │  1. Request Report  │                       │                     │
     │────────────────────▶│                       │                     │
     │                     │  2. Check storage class                     │
     │                     │────────────────────────────────────────────▶│
     │                     │                       │     GLACIER         │
     │                     │◀────────────────────────────────────────────│
     │                     │  3. Initiate restore  │                     │
     │                     │────────────────────────────────────────────▶│
     │                     │                       │     202 Accepted    │
     │                     │◀────────────────────────────────────────────│
     │                     │  4. Queue notification job                  │
     │                     │──────────────────────▶│                     │
     │  5. Response: "Request received,            │                     │
     │     will notify when ready (~4 hours)"      │                     │
     │◀────────────────────│                       │                     │
     │                     │                       │                     │
     │    ~~~~~ 4 hours pass ~~~~~                 │                     │
     │                     │                       │                     │
     │                     │       6. S3 Event: "Restore Completed"      │
     │                     │◀──────────────────────────────────────────── │
     │                     │  7. Pick up job       │                     │
     │                     │◀──────────────────────│                     │
     │  8. Email/Push: "Your report is ready"      │                     │
     │◀────────────────────│                       │                     │
     │                     │                       │                     │
     │  9. Access report   │                       │                     │
     │────────────────────▶│                       │                     │
     │                     │  10. Get object       │                     │
     │                     │────────────────────────────────────────────▶│
     │     Report PDF      │                       │     Report PDF      │
     │◀────────────────────│◀────────────────────────────────────────────│
     │                     │                       │                     │

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

interface DataAccessResult {
  source: 'hot_cache' | 'warm_storage' | 'cold_pending';
  data?: Buffer;
  estimatedAvailability?: Date;
}
 
class TieredDataAccessor {
  private hotCache: Map<string, { data: Buffer; expiry: Date }> = new Map();
  private pendingRestores: Map<string, Date> = new Map();
  
  async getData(key: string): Promise<DataAccessResult> {
    // Level 1: Check hot in-memory cache
    const cached = this.hotCache.get(key);
    if (cached && cached.expiry > new Date()) {
      return { source: 'hot_cache', data: cached.data };
    }
    
    // Level 2: Check if restore is pending
    const pendingRestore = this.pendingRestores.get(key);
    if (pendingRestore) {
      return { 
        source: 'cold_pending', 
        estimatedAvailability: pendingRestore 
      };
    }
    
    // Level 3: Try to read from S3 (might be hot/warm/cold)
    try {
      const headResult = await this.headObject(key);
      
      // Check if object is in Glacier
      if (headResult.StorageClass?.includes('GLACIER') || 
          headResult.StorageClass?.includes('DEEP_ARCHIVE')) {
        
        // Check if already restored
        if (this.isRestored(headResult.Restore)) {
          // Restored - fetch it
          const data = await this.getObject(key);
          this.cacheHot(key, data);
          return { source: 'warm_storage', data };
        }
        
        // Not restored - initiate restore and track
        const estimatedReady = await this.initiateRestore(key);
        this.pendingRestores.set(key, estimatedReady);
        
        return { 
          source: 'cold_pending', 
          estimatedAvailability: estimatedReady 
        };
      }
      
      // Object is in hot/warm storage - read directly
      const data = await this.getObject(key);
      this.cacheHot(key, data);
      return { source: 'warm_storage', data };
      
    } catch (error) {
      throw new Error(`Failed to access data: ${key}`);
    }
  }
  
  private cacheHot(key: string, data: Buffer) {
    // Cache for 1 hour
    const expiry = new Date(Date.now() + 60 * 60 * 1000);
    this.hotCache.set(key, { data, expiry });
  }
  
  private isRestored(restoreHeader?: string): boolean {
    return restoreHeader?.includes('ongoing-request="false"') ?? false;
  }
  
  async getOrWait(key: string, maxWaitMs: number = 60000): Promise<Buffer> {
    const result = await this.getData(key);
    
    if (result.data) {
      return result.data;
    }
    
    if (result.source === 'cold_pending' && result.estimatedAvailability) {
      const waitTime = result.estimatedAvailability.getTime() - Date.now();
      
      if (waitTime > maxWaitMs) {
        throw new Error(
          `Data not available. ` +
                                `Estimated availability: ${result.estimatedAvailability.toISOString()}`
        );
      }
      
      // Poll until ready or timeout
      return this.pollUntilReady(key, maxWaitMs);
    }
    
    throw new Error('Data access failed');
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

interface PrefetchRule {
  id: string;
  name: string;
  triggerType: 'schedule' | 'access' | 'event';
  trigger: ScheduleTrigger | AccessTrigger | EventTrigger;
  prefetchTargets: PrefetchTarget[];
  costBudgetPerMonth: number;  // Maximum restore cost
  enabled: boolean;
}
 
interface ScheduleTrigger {
  cronExpression: string;  // e.g., "0 0 1 * *" for monthly
}
 
interface AccessTrigger {
  objectPattern: string;  // e.g., "reports/2024/*"
  relatedPattern: string; // e.g., "reports/2023/*"  
}
 
interface EventTrigger {
  eventType: 'user_login' | 'navigation' | 'search' | 'custom';
  matchCriteria: Record<string, string>;
}
 
interface PrefetchTarget {
  objectPattern: string;
  limit?: number;  // Max objects to prefetch
  restoreDays: number;
  retrievalTier: 'Expedited' | 'Standard' | 'Bulk';
}
 
class PredictivePrefetcher {
  private prefetchRules: PrefetchRule[];
  private monthlyBudgetUsed: number = 0;
  
  async handleAccessEvent(accessedKey: string): Promise<void> {
    // Find rules triggered by this access
    const triggeredRules = this.prefetchRules.filter(rule => 
      rule.enabled &&
      rule.triggerType === 'access' &&
      this.matchesPattern(accessedKey, (rule.trigger as AccessTrigger).objectPattern)
    );
    
    for (const rule of triggeredRules) {
      await this.executePrefetch(rule);
    }
  }
  
  async handleScheduledPrefetch(ruleId: string): Promise<void> {
    const rule = this.prefetchRules.find(r => r.id === ruleId);
    if (rule) {
      await this.executePrefetch(rule);
    }
  }
  
  private async executePrefetch(rule: PrefetchRule): Promise<void> {
    for (const target of rule.prefetchTargets) {
      // List objects matching pattern that are in Glacier
      const glacierObjects = await this.findGlacierObjects(target.objectPattern);
      
      // Limit to target.limit
      const limitedObjects = glacierObjects.slice(0, target.limit);
      
      // Estimate cost
      const estimatedCost = await this.estimateRestoreCost(
        limitedObjects,
        target.retrievalTier
      );
      
      // Check budget
      if (this.monthlyBudgetUsed + estimatedCost > rule.costBudgetPerMonth) {
        console.log(`Skipping prefetch for ${rule.name}: budget exceeded`);
        continue;
      }
      
      // Execute restores
      for (const obj of limitedObjects) {
        await this.initiateRestore(obj.key, target.restoreDays, target.retrievalTier);
        console.log(`Prefetched: ${obj.key}`);
      }
      
      this.monthlyBudgetUsed += estimatedCost;
      await this.recordPrefetchMetric(rule.id, limitedObjects.length, estimatedCost);
    }
  }
}
 
// Example rules
const prefetchRules: PrefetchRule[] = [
  {
    id: 'quarterly-reports',
    name: 'Pre-restore quarterly reports before earnings',
    triggerType: 'schedule',
    trigger: { 
      cronExpression: '0 0 1 1,4,7,10 *'  // 1st of Jan, Apr, Jul, Oct
    },
    prefetchTargets: [{
      objectPattern: 'reports/quarterly/*',
      restoreDays: 14,
      retrievalTier: 'Standard'
    }],
    costBudgetPerMonth: 100,
    enabled: true
  },
  {
    id: 'related-year-prefetch',
    name: 'When accessing 2024, prefetch 2023',
    triggerType: 'access',
    trigger: {
      objectPattern: 'documents/2024/*',
      relatedPattern: 'documents/2023/*'
    },
    prefetchTargets: [{
      objectPattern: 'documents/2023/*',
      limit: 50,
      restoreDays: 7,
      retrievalTier: 'Standard'
    }],
    costBudgetPerMonth: 200,
    enabled: true
  }
];

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94

interface ArchiveAccessUIState {
  status: 'available' | 'archived' | 'restoring' | 'restored' | 'error';
  estimatedReadyTime?: Date;
  progress?: number;  // 0-100
  notificationPreference?: 'email' | 'push' | 'sms' | 'none';
  alternativeContent?: {
    type: 'thumbnail' | 'summary' | 'metadata';
    content: any;
  };
}
 
// React component example (conceptual)
function ArchiveDataAccess({ dataId, state }: { 
  dataId: string; 
  state: ArchiveAccessUIState; 
}) {
  return (
    <div className="archive-access-container">
      {state.status === 'available' && (
        <Button onClick={() => downloadData(dataId)}>
          Download Now
        </Button>
      )}
      
      {state.status === 'archived' && (
        <div className="archive-notice">
          <InfoIcon />
          <p>This file is in long-term storage.</p>
          <p>Retrieval typically takes 3-5 hours.</p>
          
          <div className="notification-preferences">
            <label>Notify me when ready:</label>
            <Select 
              options={['Email', 'Push Notification', 'SMS', 'No notification']}
              defaultValue="Email"
            />
          </div>
          
          <Button onClick={() => initiateRestore(dataId)}>
            Request File
          </Button>
        </div>
      )}
      
      {state.status === 'restoring' && (
        <div className="restore-progress">
          <Spinner />
          <p>Retrieving from archive...</p>
          {state.estimatedReadyTime && (
            <p>
              Estimated ready: {formatRelativeTime(state.estimatedReadyTime)}
            </p>
          )}
          {state.progress && (
            <ProgressBar value={state.progress} />
          )}
          
          {state.alternativeContent && (
            <div className="alternative-content">
              <p>While you wait, here's a preview:</p>
              <AlternativePreview content={state.alternativeContent} />
            </div>
          )}
        </div>
      )}
      
      {state.status === 'restored' && (
        <div className="restore-complete">
          <SuccessIcon />
          <p>Your file is ready!</p>
          <p className="expiry-notice">
            Available for the next 7 days.
          </p>
          <Button onClick={() => downloadData(dataId)}>
            Download Now
          </Button>
        </div>
      )}
      
      {state.status === 'error' && (
        <div className="restore-error">
          <ErrorIcon />
          <p>Unable to retrieve this file.</p>
          <Button onClick={() => retryRestore(dataId)}>
            Try Again
          </Button>
          <Button variant="secondary" onClick={contactSupport}>
            Contact Support
          </Button>
        </div>
      )}
    </div>
  );
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46

Tier Selection Based on Latency Requirements
═══════════════════════════════════════════════════════════════════════════
 
                        What is the maximum acceptable
                         retrieval latency for users?
                                    │
          ┌─────────────────────────┼─────────────────────────┐
          ▼                         ▼                         ▼
    Milliseconds              Seconds/Minutes              Hours/Days
          │                         │                         │
          ▼                         ▼                         ▼
   ┌──────────────┐         ┌──────────────┐          ┌──────────────┐
   │   S3 STANDARD │         │    TIER BY   │          │   GLACIER    │
   │   No choice   │         │   FREQUENCY  │          │   TIER BY    │
   │               │         │              │          │   URGENCY    │
   └──────────────┘         └───────┬──────┘          └───────┬──────┘
                                    │                         │
                        Access > 1x/week?           Sometimes need 
                                    │                 urgent access?
                    ┌───────YES─────┴─────NO───────┐        │
                    ▼                              ▼        │
             S3 STANDARD-IA              Access > 1x/month? │
             ($0.0125/GB)                          │        │
                                   ┌────────YES────┴────NO──┤
                                   ▼                        ▼
                            GLACIER INSTANT          ┌──────────────┐
                            ($0.004/GB)              │   YES → GLACIER │
                            Millisecond access       │   FLEXIBLE      │
                                                     │   ($0.0036/GB)  │
                                                     │   + Provisioned │
                                                     │   Capacity for  │
                                                     │   expedited     │
                                                     ├────────────────┤
                                                     │   NO → DEEP     │
                                                     │   ARCHIVE       │
                                                     │   ($0.00099/GB) │
                                                     │   Batch only    │
                                                     └────────────────┘
 
OVERRIDE CONDITIONS:
─────────────────────────────────────────────────────────────────────────────
• Regulatory requirement for rapid access → Use Glacier Instant maximum
• Object size < 128KB → Stay in Standard (tiering overhead not worthwhile)
• Highly variable access patterns → Use S3 Intelligent-Tiering
• Multi-year retention only → Deep Archive regardless of occasional access
• Business-critical & unpredictable → Standard (cost of latency > storage)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

interface DocumentViewState {
  phase: 'loading' | 'metadata' | 'preview' | 'full';
  metadata?: DocumentMetadata;
  preview?: {
    thumbnail?: string;
    firstPageText?: string;
    summary?: string;
  };
  fullContent?: Buffer;
  archiveRestoreStatus?: {
    initiated: boolean;
    estimatedReady?: Date;
  };
}
 
async function* loadDocumentProgressive(
  documentId: string
): AsyncGenerator<DocumentViewState> {
  // Phase 1: Show loading state immediately
  yield { phase: 'loading' };
  
  // Phase 2: Load metadata (always hot, instant)
  const metadata = await loadMetadata(documentId);
  yield { 
    phase: 'metadata', 
    metadata 
  };
  
  // Phase 3: Load preview from hot cache/CDN
  const preview = await loadPreviewFromCache(documentId);
  if (preview) {
    yield { 
      phase: 'preview', 
      metadata, 
      preview 
    };
  }
  
  // Phase 4: Attempt to load full content
  const storageInfo = await getStorageInfo(documentId);
  
  if (storageInfo.tier === 'STANDARD' || storageInfo.tier === 'STANDARD_IA') {
    // Full content is accessible
    const fullContent = await downloadContent(documentId);
    yield { 
      phase: 'full', 
      metadata, 
      preview, 
      fullContent 
    };
  } else if (storageInfo.tier.includes('GLACIER')) {
    // Content is archived
    const restoreStatus = await checkOrInitiateRestore(documentId);
    
    if (restoreStatus.ready) {
      // Already restored - download it
      const fullContent = await downloadContent(documentId);
      yield { 
        phase: 'full', 
        metadata, 
        preview, 
        fullContent 
      };
    } else {
      // Still restoring - return preview with restore status
      yield { 
        phase: 'preview', 
        metadata, 
        preview,
        archiveRestoreStatus: {
          initiated: true,
          estimatedReady: restoreStatus.estimatedReady
        }
      };
      
      // Optionally: continue polling and yield when ready
      // (In practice, you'd handle this via notifications)
    }
  }
}
 
// Usage in a React component
function DocumentViewer({ documentId }: { documentId: string }) {
  const [state, setState] = useState<DocumentViewState>({ phase: 'loading' });
  
  useEffect(() => {
    const loader = loadDocumentProgressive(documentId);
    
    (async () => {
      for await (const viewState of loader) {
        setState(viewState);
      }
    })();
    
    return () => loader.return(undefined);
  }, [documentId]);
  
  return (
    <div>
      {state.phase === 'loading' && <Spinner />}
      
      {state.metadata && <MetadataHeader metadata={state.metadata} />}
      
      {state.preview && <PreviewPane preview={state.preview} />}
      
      {state.fullContent && <FullDocumentViewer content={state.fullContent} />}
      
      {state.archiveRestoreStatus && (
        <ArchiveNotice 
          estimatedReady={state.archiveRestoreStatus.estimatedReady}
          onNotifyMe={(method) => setupNotification(documentId, method)}
        />
      )}
    </div>
  );
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82

interface EmergencyRetrievalBudget {
  monthlyBudgetUSD: number;
  usedThisMonth: number;
  alertThreshold: number;  // Percentage to alert
}
 
async function emergencyRetrieve(
  objectKey: string,
  userId: string,
  justification: string,
  budget: EmergencyRetrievalBudget
): Promise<{ success: boolean; message: string }> {
  
  // Estimate cost
  const objectSize = await getObjectSize(objectKey);
  const estimatedCostUSD = (objectSize / (1024 ** 3)) * 0.03;  // $0.03/GB expedited
  const totalAfterThis = budget.usedThisMonth + estimatedCostUSD;
  
  // Check budget
  if (totalAfterThis > budget.monthlyBudgetUSD) {
    // Over budget - reject or escalate
    await notifyAdmin({
      type: 'emergency_retrieval_budget_exceeded',
      objectKey,
      userId,
      justification,
      estimatedCost: estimatedCostUSD,
      currentUsage: budget.usedThisMonth,
      monthlyBudget: budget.monthlyBudgetUSD
    });
    
    return { 
      success: false, 
      message: 'Emergency retrieval budget exceeded. Request escalated to admin.'
    };
  }
  
  // Hit alert threshold?
  const percentUsed = (totalAfterThis / budget.monthlyBudgetUSD) * 100;
  if (percentUsed > budget.alertThreshold) {
    await notifyAdmin({
      type: 'emergency_retrieval_budget_warning',
      percentUsed,
      remainingBudget: budget.monthlyBudgetUSD - totalAfterThis
    });
  }
  
  // Execute expedited retrieval
  try {
    await initiateRestore(objectKey, {
      tier: 'Expedited',
      days: 1  // Minimum restore duration
    });
    
    // Log for audit
    await logEmergencyRetrieval({
      objectKey,
      userId,
      justification,
      cost: estimatedCostUSD,
      timestamp: new Date()
    });
    
    // Update budget tracking
    budget.usedThisMonth += estimatedCostUSD;
    await saveBudget(budget);
    
    return {
      success: true,
      message: 'Expedited retrieval initiated. Data available in 1-5 minutes.'
    };
    
  } catch (error) {
    if (error.name === 'InsufficientCapacityException') {
      return {
        success: false,
        message: 'Expedited capacity unavailable. Using standard retrieval (3-5 hours).'
      };
    }
    throw error;
  }
}