public IEnumerable <BaseEntry> GetEntries(EnumerationFilter filter)
{
switch (filter)
{
case EnumerationFilter.Files:
{
return(entries.Values.OfType <FileEntry>());
}
case EnumerationFilter.Directories:
{
return(entries.Values.OfType <DirectoryEntry>());
}
case EnumerationFilter.All:
{
return(entries.Values);
}
default:
{
throw ErrorFactory.Internal.EnumValueUnsupported(filter);
}
}
}
/// <inheritdoc />
protected override IEnumerable <(ShortHash key, ContentLocationEntry entry)> EnumerateEntriesWithSortedKeysFromStorage(
CancellationToken token,
EnumerationFilter filter = null)
{
return(_map
.OrderBy(kvp => kvp.Key)
.SkipWhile(kvp => filter?.StartingPoint != null && filter.StartingPoint > kvp.Key)
.Where(kvp => filter?.ShouldEnumerate == null || filter.ShouldEnumerate?.Invoke(SerializeContentLocationEntry(kvp.Value)) == true)
.Select(kvp => (kvp.Key, kvp.Value)));
}
/// <inheritdoc />
public override IEnumerable <(ShortHash key, ContentLocationEntry entry)> EnumerateEntriesWithSortedKeys(
CancellationToken token,
EnumerationFilter filter = null)
{
foreach (var kvp in _map)
{
if (filter == null || filter(Serialize(kvp.Value)))
{
yield return(kvp.Key, kvp.Value);
}
}
}
private async Task <EnumerationResult> KvpbaseEnumerate(string prefix, string continuationToken)
{
int startIndex = 0;
int count = 1000;
if (!String.IsNullOrEmpty(continuationToken))
{
if (!KvpbaseParseContinuationToken(continuationToken, out startIndex, out count))
{
throw new ArgumentException("Unable to parse continuation token.");
}
}
ContainerMetadata cmd = null;
EnumerationResult ret = new EnumerationResult();
try
{
if (String.IsNullOrEmpty(prefix))
{
cmd = await _Kvpbase.EnumerateContainer(_KvpbaseSettings.Container, startIndex, count);
}
else
{
EnumerationFilter filter = new EnumerationFilter();
filter.Prefix = prefix;
cmd = await _Kvpbase.EnumerateContainer(filter, _KvpbaseSettings.Container, startIndex, count);
}
}
catch (Exception)
{
throw new IOException("Unable to enumerate objects.");
}
ret.NextContinuationToken = KvpbaseBuildContinuationToken(startIndex + count, count);
if (cmd.Objects != null && cmd.Objects.Count > 0)
{
foreach (ObjectMetadata curr in cmd.Objects)
{
BlobMetadata md = new BlobMetadata();
md.Key = curr.ObjectKey;
md.ETag = curr.Md5;
md.ContentLength = Convert.ToInt64(curr.ContentLength);
md.ContentType = curr.ContentType;
md.Created = curr.CreatedUtc.Value;
ret.Blobs.Add(md);
}
}
return(ret);
}
public DirectoryEnumerateEntriesArguments([NotNull] AbsolutePath path, [NotNull] string incomingPath,
[NotNull] string searchPattern, SearchOption searchOption, EnumerationFilter filter)
{
Guard.NotNull(path, nameof(path));
Guard.NotNull(incomingPath, nameof(incomingPath));
Guard.NotNull(searchPattern, nameof(searchPattern));
Path = path;
IncomingPath = incomingPath;
SearchPattern = searchPattern;
SearchOption = searchOption;
Filter = filter;
}
/// <inheritdoc />
protected override IEnumerable <(ShortHash key, ContentLocationEntry entry)> EnumerateEntriesWithSortedKeysFromStorage(
CancellationToken token,
EnumerationFilter filter = null)
{
return(_map
// Directly calling OrderBy on ConcurrentDictionary instance is not thread-safe.
// Making a copy by calling instance ToArray method first.
.ToArray()
.OrderBy(kvp => kvp.Key)
.SkipWhile(kvp => filter?.StartingPoint != null && filter.StartingPoint > kvp.Key)
.Where(kvp => filter?.ShouldEnumerate == null || filter.ShouldEnumerate?.Invoke(SerializeContentLocationEntry(kvp.Value)) == true)
.Select(kvp => (kvp.Key, kvp.Value)));
}
public IEnumerable <BaseEntry> GetEntries(EnumerationFilter filter)
{
switch (filter)
{
case EnumerationFilter.Files:
return(entries.Values.OfType <FileEntry>());
case EnumerationFilter.Directories:
return(entries.Values.OfType <DirectoryEntry>());
case EnumerationFilter.All:
return(entries.Values);
default:
throw new NotSupportedException($"Unsupported filter '{filter}'.");
}
}
/// <inheritdoc />
protected override IEnumerable <(ShortHash key, ContentLocationEntry entry)> EnumerateEntriesWithSortedKeysFromStorage(
OperationContext context,
EnumerationFilter valueFilter,
bool returnKeysOnly)
{
return(_map
// Directly calling OrderBy on ConcurrentDictionary instance is not thread-safe.
// Making a copy by calling instance ToArray method first.
.ToArray()
.OrderBy(kvp => kvp.Key)
.SkipWhile(kvp => valueFilter?.StartingPoint != null && valueFilter.StartingPoint > kvp.Key)
.Where(kvp => {
if (returnKeysOnly)
{
return true;
}
return valueFilter?.ShouldEnumerate == null || valueFilter.ShouldEnumerate?.Invoke(SerializeContentLocationEntry(kvp.Value)) == true;
})
.Select(kvp => (kvp.Key, returnKeysOnly ? null : kvp.Value)));
}
internal static async Task HttpPutContainer(RequestMetadata md)
{
string header = _Header + md.Http.Request.SourceIp + ":" + md.Http.Request.SourcePort + " ";
if (md.User == null)
{
_Logging.Warn(header + "HttpPutContainer no authentication material");
md.Http.Response.StatusCode = 401;
md.Http.Response.ContentType = "application/json";
await md.Http.Response.Send(Common.SerializeJson(new ErrorResponse(3, 401, null, null), true));
return;
}
if (md.Http.Request.RawUrlEntries.Count != 2)
{
_Logging.Warn(header + "HttpPutContainer request URL does not have two entries");
md.Http.Response.StatusCode = 400;
md.Http.Response.ContentType = "application.json";
await md.Http.Response.Send(Common.SerializeJson(new ErrorResponse(2, 400, "URL path must be of the form /[user]/[container]/[key].", null), true));
return;
}
if (!md.Params.UserGuid.ToLower().Equals(md.User.GUID.ToLower()))
{
_Logging.Warn(header + "HttpPutContainer user " + md.User.GUID + " attempting to PUT container in user " + md.Params.UserGuid);
md.Http.Response.StatusCode = 401;
md.Http.Response.ContentType = "application/json";
await md.Http.Response.Send(Common.SerializeJson(new ErrorResponse(3, 401, null, null), true));
return;
}
ContainerClient client = null;
if (!_ContainerMgr.GetContainerClient(md.Params.UserGuid, md.Params.ContainerName, out client))
{
_Logging.Warn(header + "HttpPutContainer unable to find container " + md.Params.UserGuid + "/" + md.Params.ContainerName);
md.Http.Response.StatusCode = 404;
md.Http.Response.ContentType = "application/json";
await md.Http.Response.Send(Common.SerializeJson(new ErrorResponse(5, 404, null, null), true));
return;
}
if (md.Params.AuditLog)
{
#region Audit-Log
int count = 100;
int index = 0;
if (md.Params.Count != null)
{
count = Convert.ToInt32(md.Params.Count);
}
if (md.Params.Index != null)
{
index = Convert.ToInt32(md.Params.Index);
}
List <AuditLogEntry> entries = client.GetAuditLogEntries(
md.Params.AuditKey,
md.Params.Action,
count,
index,
md.Params.CreatedBefore,
md.Params.CreatedAfter);
md.Http.Response.StatusCode = 200;
md.Http.Response.ContentType = "application/json";
await md.Http.Response.Send(Common.SerializeJson(entries, true));
return;
#endregion
}
else if (md.Params.Keys)
{
#region Update-Keys
Dictionary <string, string> keys = null;
if (md.Http.Request.Data != null && md.Http.Request.ContentLength > 0)
{
byte[] reqData = Common.StreamToBytes(md.Http.Request.Data);
try
{
keys = Common.DeserializeJson <Dictionary <string, string> >(reqData);
}
catch (Exception)
{
_Logging.Warn(header + "HttpPutContainer unable to deserialize request body");
md.Http.Response.StatusCode = 400;
md.Http.Response.ContentType = "application/json";
await md.Http.Response.Send(Common.SerializeJson(new ErrorResponse(9, 400, null, null), true));
return;
}
}
client.WriteContainerKeyValuePairs(keys);
md.Http.Response.StatusCode = 201;
await md.Http.Response.Send();
return;
#endregion
}
else if (md.Params.Search)
{
#region Search
#region Deserialize-Request-Body
EnumerationFilter filter = null;
if (md.Http.Request.Data != null && md.Http.Request.ContentLength > 0)
{
byte[] reqData = Common.StreamToBytes(md.Http.Request.Data);
try
{
filter = Common.DeserializeJson <EnumerationFilter>(reqData);
}
catch (Exception)
{
_Logging.Warn(header + "HttpPutContainer unable to deserialize request body");
md.Http.Response.StatusCode = 400;
md.Http.Response.ContentType = "application/json";
await md.Http.Response.Send(Common.SerializeJson(new ErrorResponse(9, 400, null, null), true));
return;
}
}
#endregion
#region Enumerate-and-Return
int?index = null;
if (md.Params.Index != null)
{
index = Convert.ToInt32(md.Params.Index);
}
int?count = null;
if (md.Params.Count != null)
{
count = Convert.ToInt32(md.Params.Count);
}
ContainerMetadata meta = client.Enumerate(
(int?)md.Params.Index,
(int?)md.Params.Count,
filter,
md.Params.OrderBy);
if (md.Params.Html)
{
md.Http.Response.StatusCode = 200;
md.Http.Response.ContentType = "text/html";
await md.Http.Response.Send(DirectoryListingPage(meta));
return;
}
else
{
md.Http.Response.StatusCode = 200;
md.Http.Response.ContentType = "application/json";
await md.Http.Response.Send(Common.SerializeJson(meta, true));
return;
}
#endregion
#endregion
}
else
{
#region Update
#region Deserialize-Request-Body
Container container = null;
if (md.Http.Request.Data != null && md.Http.Request.ContentLength > 0)
{
byte[] reqData = Common.StreamToBytes(md.Http.Request.Data);
try
{
container = Common.DeserializeJson <Container>(reqData);
}
catch (Exception)
{
_Logging.Warn(header + "HttpPutContainer unable to deserialize request body");
md.Http.Response.StatusCode = 400;
md.Http.Response.ContentType = "application/json";
await md.Http.Response.Send(Common.SerializeJson(new ErrorResponse(9, 400, null, null), true));
return;
}
}
if (container == null)
{
_Logging.Warn(header + "HttpPutContainer no request body");
md.Http.Response.StatusCode = 400;
md.Http.Response.ContentType = "application.json";
await md.Http.Response.Send(Common.SerializeJson(new ErrorResponse(2, 400, "No container settings found in request body.", null), true));
return;
}
#endregion
#region Update
_DatabaseMgr.Update <Container>(container);
_ContainerMgr.Delete(container.UserGUID, container.Name, false);
_ContainerMgr.Add(container);
md.Http.Response.StatusCode = 200;
await md.Http.Response.Send();
return;
#endregion
#endregion
}
}
public static async Task HttpGetContainer(RequestMetadata md)
{
string header = md.Http.Request.SourceIp + ":" + md.Http.Request.SourcePort + " ";
#region Retrieve-Container
ContainerClient client = null;
if (!_ContainerMgr.GetContainerClient(md.Params.UserGuid, md.Params.ContainerName, out client))
{
_Logging.Warn(header + "HttpGetContainer unable to find container " + md.Params.UserGuid + "/" + md.Params.ContainerName);
md.Http.Response.StatusCode = 404;
md.Http.Response.ContentType = "application/json";
await md.Http.Response.Send(Common.SerializeJson(new ErrorResponse(5, 404, null, null), true));
return;
}
#endregion
#region Authenticate-and-Authorize
if (!client.Container.IsPublicRead)
{
if (md.User == null || !(md.User.GUID.ToLower().Equals(md.Params.UserGuid.ToLower())))
{
_Logging.Warn(header + "HttpGetContainer unauthorized unauthenticated access attempt to container " + md.Params.UserGuid + "/" + md.Params.ContainerName);
md.Http.Response.StatusCode = 401;
md.Http.Response.ContentType = "application/json";
await md.Http.Response.Send(Common.SerializeJson(new ErrorResponse(3, 401, null, null), true));
return;
}
}
if (md.Perm != null)
{
if (!md.Perm.ReadContainer)
{
_Logging.Warn(header + "HttpGetContainer unauthorized access attempt to container " + md.Params.UserGuid + "/" + md.Params.ContainerName);
md.Http.Response.StatusCode = 401;
md.Http.Response.ContentType = "application/json";
await md.Http.Response.Send(Common.SerializeJson(new ErrorResponse(3, 401, null, null), true));
return;
}
}
#endregion
#region Process
if (md.Params.Config)
{
md.Http.Response.StatusCode = 200;
md.Http.Response.ContentType = "application/json";
await md.Http.Response.Send(Common.SerializeJson(client.Container, true));
return;
}
EnumerationFilter filter = EnumerationFilter.FromRequestMetadata(md);
ContainerMetadata meta = client.Enumerate(
(int?)md.Params.Index,
(int?)md.Params.Count,
filter,
md.Params.OrderBy);
if (md.Params.Keys)
{
Dictionary <string, string> vals = new Dictionary <string, string>();
client.ReadContainerKeyValues(out vals);
md.Http.Response.StatusCode = 200;
md.Http.Response.ContentType = "application/json";
await md.Http.Response.Send(Common.SerializeJson(vals, true));
return;
}
else if (md.Params.Html)
{
md.Http.Response.StatusCode = 200;
md.Http.Response.ContentType = "text/html";
await md.Http.Response.Send(DirectoryListingPage(meta));
return;
}
else
{
md.Http.Response.StatusCode = 200;
md.Http.Response.ContentType = "application/json";
await md.Http.Response.Send(Common.SerializeJson(meta, true));
return;
}
#endregion
}
private IEnumerable <string> EnumerateEntriesInDirectory([NotNull] DirectoryEntry directory, [NotNull] PathPattern pattern,
[NotNull] AbsolutePath directoryPath, SearchOption searchOption, EnumerationFilter filter)
{
PathPattern subPattern = pattern.SubPattern;
if (subPattern == null)
{
Container.ChangeTracker.NotifyContentsAccessed(directory.PathFormatter, FileAccessKinds.Read);
foreach (BaseEntry entry in directory.EnumerateEntries(filter).Where(x => pattern.IsMatch(x.Name))
.OrderBy(x => x.Name))
{
string basePath = directoryPath.GetText();
yield return(Path.Combine(basePath, entry.Name));
}
if (searchOption == SearchOption.AllDirectories)
{
foreach (DirectoryEntry subdirectory in directory.Directories)
{
AbsolutePath subdirectoryPath = directoryPath.Append(subdirectory.Name);
foreach (string nextPath in EnumerateEntriesInDirectory(subdirectory, pattern, subdirectoryPath,
searchOption, filter))
{
yield return(nextPath);
}
}
}
}
else
{
foreach (DirectoryEntry subdirectory in directory.Directories)
{
if (pattern.IsMatch(subdirectory.Name))
{
AbsolutePath subdirectoryPath = directoryPath.Append(subdirectory.Name);
foreach (string nextPath in EnumerateEntriesInDirectory(subdirectory, subPattern, subdirectoryPath,
searchOption, filter))
{
yield return(nextPath);
}
}
}
}
}
public IEnumerable <BaseEntry> EnumerateEntries(EnumerationFilter filter)
{
UpdateLastAccessTime();
return(contents.GetEntries(filter));
}
