public async Task <IActionResult> Get(string identifier)
{
if (!ArchiveId.Accepts(identifier))
{
return(BadRequest());
}
var archiveId = new ArchiveId(identifier);
var blobName = new BlobName(archiveId.ToString());
if (!await _client.BlobExistsAsync(blobName, HttpContext.RequestAborted))
{
return(NotFound());
}
var blob = await _client.GetBlobAsync(blobName, HttpContext.RequestAborted);
var filename = blob.Metadata
.Single(pair => pair.Key == new MetadataKey("filename"));
return(new FileCallbackResult(
new MediaTypeHeaderValue("application/zip"),
async(stream, actionContext) =>
{
using (var blobStream = await blob.OpenAsync(actionContext.HttpContext.RequestAborted))
{
await blobStream.CopyToAsync(stream, actionContext.HttpContext.RequestAborted);
}
})
{
FileDownloadName = filename.Value
});
}
/// <summary>
/// Gets the hash code
/// </summary>
/// <returns>Hash code</returns>
public override int GetHashCode()
{
unchecked // Overflow is fine, just wrap
{
var hashCode = 41;
// Suitable nullity checks etc, of course :)
if (BlobName != null)
{
hashCode = hashCode * 59 + BlobName.GetHashCode();
}
if (ContainerName != null)
{
hashCode = hashCode * 59 + ContainerName.GetHashCode();
}
if (CorrelationId != null)
{
hashCode = hashCode * 59 + CorrelationId.GetHashCode();
}
if (HostName != null)
{
hashCode = hashCode * 59 + HostName.GetHashCode();
}
if (SasToken != null)
{
hashCode = hashCode * 59 + SasToken.GetHashCode();
}
return(hashCode);
}
}
public async Task CreateBlobAsync(
BlobName name,
Metadata metadata,
ContentType contentType,
Stream content,
CancellationToken cancellationToken = default)
{
var file = new FileInfo(Path.Combine(_directory.FullName, FileName.From(name)));
if (file.Exists)
{
throw new BlobAlreadyExistsException(name);
}
using (var fileStream = file.OpenWrite())
{
using (var writer = new BinaryWriter(fileStream, Encoding.UTF8, true))
{
writer.Write(contentType.ToString()); // content type
writer.Write(metadata.Count); // count of metadatum
foreach (var metadatum in metadata)
{
writer.Write(metadatum.Key.ToString()); // key
writer.Write(metadatum.Value?.Length ?? -1); // length of value - null is indicated using -1
if (metadatum.Value != null)
{
writer.Write(metadatum.Value); // non null value
}
}
}
content.CopyTo(fileStream);
await fileStream.FlushAsync(cancellationToken);
}
}
public async Task CreateBlobAsync(BlobName name, Metadata metadata, ContentType contentType, Stream content,
CancellationToken cancellationToken = default)
{
if (cancellationToken.IsCancellationRequested)
{
await Task.FromCanceled(cancellationToken);
}
async Task <byte[]> Copy(Stream input, CancellationToken ct)
{
using (var output = new MemoryStream())
{
await input.CopyToAsync(output, 1024, ct);
return(output.ToArray());
}
}
var buffer = await Copy(content, cancellationToken);
if (!_storage.TryAdd(name, new BlobObject(name, metadata, contentType,
ct =>
{
if (_storage.ContainsKey(name))
{
return(Task.FromResult <Stream>(new ForwardOnlyStream(new MemoryStream(buffer, false))));
}
throw new BlobNotFoundException(name);
})))
{
throw new BlobAlreadyExistsException(name);
}
}
public async Task DeleteBlobAsync(BlobName name, CancellationToken cancellationToken = default)
{
var nameParameter = CreateSqlParameter(
"@Name",
SqlDbType.NVarChar,
BlobName.MaxLength,
name.ToString());
using (var connection = new SqlConnection(_builder.ConnectionString))
{
await connection.OpenAsync(cancellationToken);
using (var transaction = connection.BeginTransaction(IsolationLevel.Snapshot))
{
using (var command = new SqlCommand(_text.DeleteBlob(), connection, transaction)
{
CommandType = CommandType.Text,
Parameters = { nameParameter }
})
{
await command.ExecuteNonQueryAsync(cancellationToken);
}
transaction.Commit();
}
}
}
public async Task CreateBlobAsync(
BlobName name,
Metadata metadata,
ContentType contentType,
Stream content,
CancellationToken cancellationToken = default)
{
if (content == null)
{
throw new ArgumentNullException(nameof(content));
}
var nameParameter = CreateSqlParameter(
"@Name",
SqlDbType.NVarChar,
BlobName.MaxLength,
name.ToString());
var metadataParameter = CreateSqlParameter(
"@Metadata",
SqlDbType.NVarChar,
-1,
MetadataToString(metadata));
var contentTypeParameter = CreateSqlParameter(
"@ContentType",
SqlDbType.NVarChar,
ContentType.MaxLength,
contentType.ToString());
var contentParameter = CreateSqlParameter(
"@Content",
SqlDbType.VarBinary,
-1,
content);
using (var connection = new SqlConnection(_builder.ConnectionString))
{
await connection.OpenAsync(cancellationToken);
using (var transaction = connection.BeginTransaction(IsolationLevel.Snapshot))
{
using (var command = new SqlCommand(_text.CreateBlob(), connection, transaction)
{
CommandType = CommandType.Text,
Parameters = { nameParameter, metadataParameter, contentTypeParameter, contentParameter }
})
{
try
{
await command.ExecuteNonQueryAsync(cancellationToken);
}
catch (SqlException exception) when(exception.Number == 2627)
{
throw new BlobAlreadyExistsException(name, exception);
}
}
transaction.Commit();
}
}
}
public async Task DeleteBlobAsync(BlobName name, CancellationToken cancellationToken = default)
{
await _client.DeleteObjectAsync(new DeleteObjectRequest
{
BucketName = _bucket,
Key = name.ToString()
}, cancellationToken);
}
public Task <Result <TState> > ReadModifyWriteAsync <TState>(
OperationContext context,
BlobName fileName,
Func <TState, TState> transform)
where TState : new()
{
return(ReadModifyWriteAsync <TState, Unit>(context, fileName, current => (transform(current), Unit.Void)).SelectAsync(r => r.Value.NextState));
}
public Task <bool> BlobExistsAsync(BlobName name, CancellationToken cancellationToken = default)
{
if (cancellationToken.IsCancellationRequested)
{
return(Task.FromCanceled <bool>(cancellationToken));
}
return(Task.FromResult(_storage.ContainsKey(name)));
}
public Task <bool> BlobExistsAsync(BlobName name, CancellationToken cancellationToken = default)
{
if (cancellationToken.IsCancellationRequested)
{
return(Task.FromCanceled <bool>(cancellationToken));
}
var file = new FileInfo(Path.Combine(_directory.FullName, FileName.From(name)));
return(Task.FromResult(file.Exists));
}
public Task DeleteBlobAsync(BlobName name, CancellationToken cancellationToken = default)
{
var file = new FileInfo(Path.Combine(_directory.FullName, FileName.From(name)));
if (file.Exists)
{
file.Delete();
}
return(Task.CompletedTask);
}
public Task DeleteBlobAsync(BlobName name, CancellationToken cancellationToken = default)
{
if (cancellationToken.IsCancellationRequested)
{
return(Task.FromCanceled(cancellationToken));
}
_storage.TryRemove(name, out _);
return(Task.CompletedTask);
}
public string GetFileName()
{
string[] parts = BlobName.Split(':');
if (parts.Length != 2)
{
throw new ApplicationException("Invalid BlobName:" + BlobName);
}
return(parts[1]);
}
public Task <BlobObject> GetBlobAsync(BlobName name, CancellationToken cancellationToken = default)
{
if (cancellationToken.IsCancellationRequested)
{
return(Task.FromCanceled <BlobObject>(cancellationToken));
}
var file = new FileInfo(Path.Combine(_directory.FullName, FileName.From(name)));
if (!file.Exists)
{
return(Task.FromResult <BlobObject>(null));
}
using (var fileStream = file.OpenRead())
using (var reader = new BinaryReader(fileStream, Encoding.UTF8))
{
var metadata = Metadata.None;
var contentType = ContentType.Parse(reader.ReadString());
var metadatumCount = reader.ReadInt32();
for (var index = 0; index < metadatumCount; index++)
{
var key = new MetadataKey(reader.ReadString());
var valueLength = reader.ReadInt32();
var value = valueLength != -1 ? reader.ReadString() : null;
metadata = metadata.Add(new KeyValuePair <MetadataKey, string>(key, value));
}
return(Task.FromResult(new BlobObject(name, metadata, contentType, contentCancellationToken =>
{
if (!File.Exists(file.FullName))
{
throw new BlobNotFoundException(name);
}
var contentFileStream = file.OpenRead();
using (var contentReader = new BinaryReader(contentFileStream, Encoding.UTF8, true))
{
// skip over the metadata
contentReader.ReadString();
var contentMetadatumCount = contentReader.ReadInt32();
for (var index = 0; index < contentMetadatumCount; index++)
{
contentReader.ReadString();
var valueLength = contentReader.ReadInt32();
if (valueLength != -1)
{
contentReader.ReadString();
}
}
}
return Task.FromResult <Stream>(new ForwardOnlyStream(contentFileStream));
})));
}
}
public Task <BlobObject> GetBlobAsync(BlobName name, CancellationToken cancellationToken = default)
{
if (cancellationToken.IsCancellationRequested)
{
return(Task.FromCanceled <BlobObject>(cancellationToken));
}
return(_storage.TryGetValue(name, out var result)
? Task.FromResult(result)
: Task.FromResult <BlobObject>(null));
}
public static string From(BlobName name)
{
var value = name.ToString().ToCharArray();
var builder = new StringBuilder(value.Length);
for (var index = 0; index < value.Length; index++)
{
switch (value[index])
{
case '!':
builder.Append(Convert.ToByte('!').ToString("x"));
break;
case '/':
builder.Append(Convert.ToByte('/').ToString("x"));
break;
case '-':
builder.Append(Convert.ToByte('-').ToString("x"));
break;
case '_':
builder.Append(Convert.ToByte('_').ToString("x"));
break;
case '.':
builder.Append(Convert.ToByte('.').ToString("x"));
break;
case '*':
builder.Append(Convert.ToByte('*').ToString("x"));
break;
case '\'':
builder.Append(Convert.ToByte('\'').ToString("x"));
break;
case '(':
builder.Append(Convert.ToByte('(').ToString("x"));
break;
case ')':
builder.Append(Convert.ToByte(')').ToString("x"));
break;
default:
builder.Append(value[index]);
break;
}
}
return(builder.ToString());
}
public override int GetHashCode() => BlobName.GetHashCode() ^ CacheControl.GetHashCode() ^ BlobContainerName.GetHashCode() ^ ContentDisposition.GetHashCode() ^ ContentEncoding.GetHashCode() ^ ContentLanguage.GetHashCode() ^ ContentType.GetHashCode() ^ ExpiryTime.GetHashCode() ^ Identifier.GetHashCode() ^ IPRange.GetHashCode() ^ Permissions.GetHashCode() ^ Protocol.GetHashCode() ^ StartTime.GetHashCode() ^ Version.GetHashCode();
private static async Task EnrichWithArchiveInformation(string archiveId,
RoadNetworkChangesArchiveInfo archiveInfo, IBlobClient client, CancellationToken ct)
{
var blobName = new BlobName(archiveId);
if (await client.BlobExistsAsync(blobName, ct))
{
var blob = await client.GetBlobAsync(blobName, ct);
archiveInfo.Available = true;
archiveInfo.Filename = blob.Metadata.Single(pair => pair.Key == new MetadataKey("filename")).Value;
}
else
{
archiveInfo.Available = false;
archiveInfo.Filename = "";
}
}
public async Task <bool> BlobExistsAsync(BlobName name, CancellationToken cancellationToken = default)
{
try
{
await _client.GetObjectAsync(new GetObjectRequest
{
BucketName = _bucket,
Key = name.ToString(),
ByteRange = NoData
}, cancellationToken);
return(true);
}
catch (AmazonS3Exception exception) when(
exception.ErrorType == ErrorType.Sender &&
string.Equals(exception.ErrorCode, "NoSuchKey", StringComparison.OrdinalIgnoreCase))
{
return(false);
}
}
public async Task <BlobObject> GetBlobAsync(BlobName name, CancellationToken cancellationToken = default)
{
try
{
var response = await _client.GetObjectAsync(new GetObjectRequest
{
BucketName = _bucket,
Key = name.ToString(),
ByteRange = NoData
}, cancellationToken);
return(new BlobObject(
name,
ConvertMetadataFromMetadataCollection(response),
ContentType.Parse(response.Headers.ContentType),
async contentCancellationToken =>
{
try
{
var contentResponse = await _client.GetObjectAsync(new GetObjectRequest
{
BucketName = _bucket,
Key = name.ToString()
}, contentCancellationToken);
return new ForwardOnlyStream(contentResponse.ResponseStream);
}
catch (AmazonS3Exception exception) when(
exception.ErrorType == ErrorType.Sender &&
string.Equals(exception.ErrorCode, "NoSuchKey", StringComparison.OrdinalIgnoreCase))
{
throw new BlobNotFoundException(name, exception);
}
}));
}
catch (AmazonS3Exception exception) when(
exception.ErrorType == ErrorType.Sender &&
string.Equals(exception.ErrorCode, "NoSuchKey", StringComparison.OrdinalIgnoreCase))
{
return(null);
}
}
protected override void Write(LogEventInfo logEvent)
{
_client = _client ?? CloudStorageAccount.Parse(ConnectionString.Render(logEvent)).CreateCloudBlobClient();
if (_client == null)
{
return;
}
var containerName = Container.Render(logEvent);
var blobName = BlobName.Render(logEvent);
if (_container == null || _container.Name != containerName)
{
_container = _client.GetContainerReference(containerName);
_container.CreateIfNotExistsAsync().Wait();
_blob = null;
}
if (_blob == null || _blob.Name != blobName || _forceCheck)
{
_blob = _container.GetAppendBlobReference(blobName);
if (!_blob.ExistsAsync().Result)
{
try
{
_blob.Properties.ContentType = "text/plain";
_blob.CreateOrReplaceAsync().Wait();
_blob.SetPropertiesAsync().Wait();
}
catch (StorageException ex) when(ex.RequestInformation.HttpStatusCode == (int)HttpStatusCode.Conflict)
{
// to be expected
}
}
}
_blob.AppendTextAsync(Layout.Render(logEvent) + "\r\n").Wait();
}
public async Task <(Messages.RoadNetworkSnapshot snapshot, int version)> ReadSnapshot(CancellationToken cancellationToken)
{
if (!await _client.BlobExistsAsync(SnapshotHead, cancellationToken))
{
return(null, ExpectedVersion.NoStream);
}
var snapshotHeadBlob = await _client.GetBlobAsync(SnapshotHead, cancellationToken);
using (var headStream = await snapshotHeadBlob.OpenAsync(cancellationToken))
{
var snapshotHead =
await MessagePackSerializer.DeserializeAsync <Messages.RoadNetworkSnapshotHead>(
headStream,
cancellationToken : cancellationToken
);
var snapshotBlobName = new BlobName(snapshotHead.SnapshotBlobName);
if (!await _client.BlobExistsAsync(snapshotBlobName, cancellationToken))
{
return(null, ExpectedVersion.NoStream);
}
var snapshotBlob = await _client.GetBlobAsync(snapshotBlobName, cancellationToken);
if (!snapshotBlob.Metadata.TryGetAtVersion(out var version))
{
return(null, ExpectedVersion.NoStream);
}
using (var snapshotStream = await snapshotBlob.OpenAsync(cancellationToken))
{
var snapshot = await MessagePackSerializer.DeserializeAsync <Messages.RoadNetworkSnapshot>(
snapshotStream,
cancellationToken : cancellationToken);
return(snapshot, version);
}
}
}
public async Task <bool> BlobExistsAsync(BlobName name, CancellationToken cancellationToken = default)
{
var nameParameter = CreateSqlParameter(
"@Name",
SqlDbType.NVarChar,
BlobName.MaxLength,
name.ToString());
using (var connection = new SqlConnection(_builder.ConnectionString))
{
await connection.OpenAsync(cancellationToken);
using (var command = new SqlCommand(_text.BlobExists(), connection)
{
CommandType = CommandType.Text,
Parameters = { nameParameter }
})
{
return(0 != (int)await command.ExecuteScalarAsync(cancellationToken));
}
}
}
public async Task CreateBlobAsync(BlobName name, Metadata metadata, ContentType contentType, Stream content,
CancellationToken cancellationToken = default)
{
// S3 does not have real concurrency control, this is simply a best effort approach
if (await BlobExistsAsync(name, cancellationToken))
{
throw new BlobAlreadyExistsException(name);
}
var request = new PutObjectRequest
{
BucketName = _bucket,
Key = name.ToString(),
ContentType = contentType.ToString(),
InputStream = content,
AutoResetStreamPosition = false,
AutoCloseStream = false
};
CopyMetadataToMetadataCollection(metadata, request.Metadata);
await _client.PutObjectAsync(request, cancellationToken);
}
/// <summary>
/// Returns true if BlobStorageInfo instances are equal
/// </summary>
/// <param name="other">Instance of BlobStorageInfo to be compared</param>
/// <returns>Boolean</returns>
public bool Equals(BlobStorageInfo other)
{
if (ReferenceEquals(null, other))
{
return(false);
}
if (ReferenceEquals(this, other))
{
return(true);
}
return
((
BlobName == other.BlobName ||
BlobName != null &&
BlobName.Equals(other.BlobName)
) &&
(
ContainerName == other.ContainerName ||
ContainerName != null &&
ContainerName.Equals(other.ContainerName)
) &&
(
CorrelationId == other.CorrelationId ||
CorrelationId != null &&
CorrelationId.Equals(other.CorrelationId)
) &&
(
HostName == other.HostName ||
HostName != null &&
HostName.Equals(other.HostName)
) &&
(
SasToken == other.SasToken ||
SasToken != null &&
SasToken.Equals(other.SasToken)
));
}
/// <summary>Shorthand constructor.</summary>
public BlobCounter(IBlobStorageProvider provider, BlobName <decimal> fullName)
: this(provider, fullName.ContainerName, fullName.ToString())
{
}
/// <summary>Shorthand constructor.</summary>
public BlobCounter(IBlobStorageProvider provider, BlobName<decimal> fullName)
: this(provider, fullName.ContainerName, fullName.ToString())
{
}
public async Task <BlobObject> GetBlobAsync(BlobName name, CancellationToken cancellationToken = default)
{
var nameParameter = CreateSqlParameter(
"@Name",
SqlDbType.NVarChar,
BlobName.MaxLength,
name.ToString());
using (var connection = new SqlConnection(_builder.ConnectionString))
{
await connection.OpenAsync(cancellationToken);
using (var command = new SqlCommand(_text.GetBlob(), connection)
{
CommandType = CommandType.Text,
Parameters = { nameParameter }
})
{
using (var reader = await command.ExecuteReaderAsync(ReaderBehavior, cancellationToken))
{
if (!reader.IsClosed && reader.Read())
{
return(new BlobObject(
name,
MetadataFromString(reader.GetString(0)),
ContentType.Parse(reader.GetString(1)),
async contentCancellationToken =>
{
var contentConnection = new SqlConnection(_builder.ConnectionString);
await contentConnection.OpenAsync(contentCancellationToken);
var contentCommand = new SqlCommand(_text.GetBlobContent(), contentConnection)
{
CommandType = CommandType.Text,
Parameters =
{
CreateSqlParameter(
"@Name",
SqlDbType.NVarChar,
BlobName.MaxLength,
name.ToString()
)
}
};
var contentReader =
await contentCommand.ExecuteReaderAsync(ReaderBehavior,
contentCancellationToken);
if (!contentReader.IsClosed && contentReader.Read())
{
return new ForwardOnlyStream(
new DisposableStream(
contentReader.GetStream(0),
contentReader,
contentCommand,
contentConnection)
);
}
throw new BlobNotFoundException(name);
}));
}
return(null);
}
}
}
}
public NewBlobDialog()
{
InitializeComponent();
BlobName.Focus();
}