public async Task VerifySessionExpirationForBinary(string key)
        {
            var sessionId = key.AsSessionId();

            var(_, _, expiresAt) = _memoryCache.Get <(SessionDescriptor, AuthorInfo, DateTime)>(sessionId);

            if (expiresAt == default)
            {
                GetObjectMetadataResponse response;
                try
                {
                    response = await _cephS3Client.GetObjectMetadataAsync(_filesBucketName, sessionId.AsS3ObjectKey(Tokens.SessionPostfix));
                }
                catch (AmazonS3Exception ex) when(ex.StatusCode == HttpStatusCode.NotFound)
                {
                    throw new ObjectNotFoundException($"Session '{sessionId}' does not exist");
                }
                catch (Exception ex)
                {
                    throw new S3Exception(ex);
                }

                var metadataWrapper = MetadataCollectionWrapper.For(response.Metadata);
                expiresAt = metadataWrapper.Read <DateTime>(MetadataElement.ExpiresAt);
            }

            if (SessionDescriptor.IsSessionExpired(expiresAt))
            {
                throw new SessionExpiredException(sessionId, expiresAt);
            }
        }
Beispiel #2
0
        public async Task <int> ArchiveSessionAsync(Guid sessionId, DateTime archiveDate)
        {
            var listResponse = await _cephS3Client.ListObjectsAsync(
                new ListObjectsRequest
            {
                BucketName = _filesBucketName,
                Prefix     = sessionId.ToString()
            });

            if (listResponse.S3Objects.Count == 0)
            {
                return(0);
            }

            var s3Objects = listResponse.S3Objects.OrderByDescending(x => x.Size).ToList();

            foreach (var obj in s3Objects)
            {
                var getMetadataResponse = await _cephS3Client.GetObjectMetadataAsync(_filesBucketName, obj.Key);

                var archivedFileKey = obj.Key.AsArchivedFileKey(archiveDate);
                var copyRequest     = new CopyObjectRequest
                {
                    SourceBucket      = _filesBucketName,
                    SourceKey         = obj.Key,
                    DestinationBucket = _filesBucketName,
                    DestinationKey    = archivedFileKey,
                    MetadataDirective = S3MetadataDirective.REPLACE,
                    CannedACL         = S3CannedACL.PublicRead
                };
                foreach (var metadataKey in getMetadataResponse.Metadata.Keys)
                {
                    copyRequest.Metadata.Add(metadataKey, getMetadataResponse.Metadata[metadataKey]);
                }

                await _cephS3Client.CopyObjectAsync(copyRequest);

                _logger.LogInformation(
                    "File {fileKey} copied to {archivedFileKey} while archiving session '{sessionId}'.",
                    obj.Key,
                    archivedFileKey,
                    sessionId);
            }

            var count = await DeleteSessionFilesAsync(sessionId, s3Objects);

            _logger.LogInformation("Session '{sessionId}' archived.", sessionId);

            return(count);
        }