public override StorageContent CreateContent(CatalogContext context)
{
using (IGraph graph = new Graph())
{
INode entry = graph.CreateUriNode(GetItemAddress());
// catalog infrastructure fields
graph.Assert(entry, graph.CreateUriNode(Schema.Predicates.Type), graph.CreateUriNode(GetItemType()));
graph.Assert(entry, graph.CreateUriNode(Schema.Predicates.Type), graph.CreateUriNode(Schema.DataTypes.Permalink));
graph.Assert(entry, graph.CreateUriNode(Schema.Predicates.CatalogTimeStamp), graph.CreateLiteralNode(TimeStamp.ToString("O"), Schema.DataTypes.DateTime));
graph.Assert(entry, graph.CreateUriNode(Schema.Predicates.CatalogCommitId), graph.CreateLiteralNode(CommitId.ToString()));
graph.Assert(entry, graph.CreateUriNode(Schema.Predicates.Published), graph.CreateLiteralNode(_published.ToString("O"), Schema.DataTypes.DateTime));
graph.Assert(entry, graph.CreateUriNode(Schema.Predicates.Id), graph.CreateLiteralNode(_id));
graph.Assert(entry, graph.CreateUriNode(Schema.Predicates.OriginalId), graph.CreateLiteralNode(_id));
graph.Assert(entry, graph.CreateUriNode(Schema.Predicates.Version), graph.CreateLiteralNode(_version));
SetIdVersionFromGraph(graph);
// create JSON content
JObject frame = context.GetJsonLdContext("context.Catalog.json", GetItemType());
StorageContent content = new StringStorageContent(Utils.CreateArrangedJson(graph, frame), "application/json", "no-store");
return content;
}
}
/// <summary>
/// Saves the file to storage.
/// </summary>
public async virtual Task SaveAsync(CancellationToken cancellationToken)
{
// BUGBUG: When we're satisifed with this format, we should turn off indenting. We'll get perf improvement saving the file.
string json = JsonConvert.SerializeObject(this, Formatting.Indented);
using (StorageContent content = new StringStorageContent(json, "application/json", "no-store"))
{
await this.Storage.Save(this.Address, content, cancellationToken);
}
}
static async Task Test0Async()
{
StorageFactory factory = new FileStorageFactory(new Uri("https://tempuri.org/test"), @"c:\\data\\test");
Console.WriteLine(factory);
Storage storage = factory.Create();
StorageContent content = new StringStorageContent("TEST");
await storage.Save(new Uri(storage.BaseAddress, "doc1.txt"), content, CancellationToken.None);
}
static async Task Test1Async()
{
StorageCredentials credentials = new StorageCredentials("", "");
CloudStorageAccount account = new CloudStorageAccount(credentials, true);
StorageFactory factory = new AzureStorageFactory(account, "ver40", "catalog", new Uri("https://tempuri.org/test"));
Console.WriteLine(factory);
Storage storage = factory.Create();
StorageContent content = new StringStorageContent("TEST");
await storage.Save(new Uri(storage.BaseAddress, "doc1.txt"), content, CancellationToken.None);
}
public override StorageContent CreateContent(CatalogContext context)
{
IGraph catalogEntry = new Graph();
INode catalogEntrySubject = catalogEntry.CreateUriNode(GetItemAddress());
// catalog infrastructure fields
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Type), catalogEntry.CreateUriNode(GetItemType()));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Type), catalogEntry.CreateUriNode(Schema.DataTypes.Permalink));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.CatalogTimeStamp), catalogEntry.CreateLiteralNode(TimeStamp.ToString("O"), Schema.DataTypes.DateTime));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.CatalogCommitId), catalogEntry.CreateLiteralNode(CommitId.ToString()));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Published), catalogEntry.CreateLiteralNode(_publicationDetails.Published.ToString("O"), Schema.DataTypes.DateTime));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.TenantId), catalogEntry.CreateLiteralNode(_publicationDetails.TenantId));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Tenant), catalogEntry.CreateLiteralNode(_publicationDetails.TenantName));
Uri ownerUri = _publicationDetails.Owner.GetUri(GetItemAddress());
INode ownerSubject = catalogEntry.CreateUriNode(ownerUri);
catalogEntry.Assert(ownerSubject, catalogEntry.CreateUriNode(Schema.Predicates.NameIdentifier), catalogEntry.CreateLiteralNode(_publicationDetails.Owner.NameIdentifier));
catalogEntry.Assert(ownerSubject, catalogEntry.CreateUriNode(Schema.Predicates.Name), catalogEntry.CreateLiteralNode(_publicationDetails.Owner.Name));
catalogEntry.Assert(ownerSubject, catalogEntry.CreateUriNode(Schema.Predicates.GivenName), catalogEntry.CreateLiteralNode(_publicationDetails.Owner.GivenName));
catalogEntry.Assert(ownerSubject, catalogEntry.CreateUriNode(Schema.Predicates.Surname), catalogEntry.CreateLiteralNode(_publicationDetails.Owner.Surname));
catalogEntry.Assert(ownerSubject, catalogEntry.CreateUriNode(Schema.Predicates.Iss), catalogEntry.CreateLiteralNode(_publicationDetails.Owner.Iss));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Owner), ownerSubject);
string id = string.Format("{0}/{1}", _packageIdentity.Namespace, _packageIdentity.Id);
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Id), catalogEntry.CreateLiteralNode(id));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.OriginalId), catalogEntry.CreateLiteralNode(_packageIdentity.Id));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Version), catalogEntry.CreateLiteralNode(_packageIdentity.Version.ToNormalizedString()));
SetIdVersionFromGraph(catalogEntry);
// create JSON content
string json = Utils.CreateJson(catalogEntry, _context);
StorageContent content = new StringStorageContent(json, "application/json", "no-store");
return content;
}
public override StorageContent CreateContent(CatalogContext context)
{
// metadata from nuspec
using (IGraph graph = CreateContentGraph(context))
{
// catalog infrastructure fields
INode rdfTypePredicate = graph.CreateUriNode(Schema.Predicates.Type);
INode timeStampPredicate = graph.CreateUriNode(Schema.Predicates.CatalogTimeStamp);
INode commitIdPredicate = graph.CreateUriNode(Schema.Predicates.CatalogCommitId);
Triple resource = graph.GetTriplesWithPredicateObject(rdfTypePredicate, graph.CreateUriNode(GetItemType())).First();
graph.Assert(resource.Subject, timeStampPredicate, graph.CreateLiteralNode(TimeStamp.ToString("O"), Schema.DataTypes.DateTime));
graph.Assert(resource.Subject, commitIdPredicate, graph.CreateLiteralNode(CommitId.ToString()));
// create JSON content
JObject frame = context.GetJsonLdContext("context.PackageDetails.json", GetItemType());
StorageContent content = new StringStorageContent(Utils.CreateArrangedJson(graph, frame), "application/json", "no-store");
return content;
}
}
static async Task SaveSmallRegistration(Storage storage, Uri registrationBaseAddress, IDictionary<string, IGraph> items, Uri contentBaseAddress, int partitionSize, CancellationToken cancellationToken)
{
SingleGraphPersistence graphPersistence = new SingleGraphPersistence(storage);
await graphPersistence.Initialize(cancellationToken);
await SaveRegistration(storage, registrationBaseAddress, items, null, graphPersistence, contentBaseAddress, partitionSize, cancellationToken);
// now the commit has happened the graphPersistence.Graph should contain all the data
JObject frame = (new CatalogContext()).GetJsonLdContext("context.Registration.json", graphPersistence.TypeUri);
StorageContent content = new StringStorageContent(Utils.CreateJson(graphPersistence.Graph, frame), "application/json", "no-store");
await storage.Save(graphPersistence.ResourceUri, content,cancellationToken);
}
async Task Merge(KeyValuePair<Uri, IGraph> resource)
{
string existingJson;
ResolverCollectorEventSource.Log.LoadingBlob(resource.Key.ToString());
try {
existingJson = await _storage.LoadString(resource.Key);
} catch(Exception ex) {
ResolverCollectorEventSource.Log.ErrorLoadingBlob(resource.Key.ToString(), ex.ToString());
throw;
}
ResolverCollectorEventSource.Log.LoadedBlob(resource.Key.ToString());
if (existingJson != null)
{
IGraph existingGraph = Utils.CreateGraph(existingJson);
resource.Value.Merge(existingGraph);
}
UpdateIsLatest(resource);
string json = Utils.CreateJson(resource.Value, _resolverFrame);
StorageContent content = new StringStorageContent(
json,
contentType: "application/json",
cacheControl: "public, max-age=300, s-maxage=300");
// Estimate the file size and report it
ResolverCollectorEventSource.Log.EmittingBlob(resource.Key.ToString(), Encoding.UTF8.GetByteCount(json) / 1024);
try
{
await _storage.Save(resource.Key, content);
} catch(Exception ex) {
ResolverCollectorEventSource.Log.ErrorEmittingBlob(resource.Key.ToString(), ex.ToString());
throw;
}
ResolverCollectorEventSource.Log.EmittedBlob(resource.Key.ToString());
}
public override async Task Save(CancellationToken cancellationToken)
{
JObject obj = new JObject { { "value", Value.ToString("O") } };
StorageContent content = new StringStorageContent(obj.ToString(), "application/json", "no-store");
await _storage.Save(_address, content, cancellationToken);
}
public override StorageContent CreateContent(CatalogContext context)
{
IGraph catalogEntry = new Graph();
INode catalogEntrySubject = catalogEntry.CreateUriNode(GetItemAddress());
// catalog infrastructure fields
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Type), catalogEntry.CreateUriNode(GetItemType()));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Type), catalogEntry.CreateUriNode(_itemType));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Type), catalogEntry.CreateUriNode(Schema.DataTypes.Permalink));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.CatalogTimeStamp), catalogEntry.CreateLiteralNode(TimeStamp.ToString("O"), Schema.DataTypes.DateTime));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.CatalogCommitId), catalogEntry.CreateLiteralNode(CommitId.ToString()));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Published), catalogEntry.CreateLiteralNode(_publicationDetails.Published.ToString("O"), Schema.DataTypes.DateTime));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.TenantId), catalogEntry.CreateLiteralNode(_publicationDetails.TenantId));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Tenant), catalogEntry.CreateLiteralNode(_publicationDetails.TenantName));
Uri ownerUri = _publicationDetails.Owner.GetUri(GetItemAddress());
INode ownerSubject = catalogEntry.CreateUriNode(ownerUri);
catalogEntry.Assert(ownerSubject, catalogEntry.CreateUriNode(Schema.Predicates.NameIdentifier), catalogEntry.CreateLiteralNode(_publicationDetails.Owner.NameIdentifier));
//catalogEntry.Assert(ownerSubject, catalogEntry.CreateUriNode(Schema.Predicates.Name), catalogEntry.CreateLiteralNode(_publicationDetails.Owner.Name));
catalogEntry.Assert(ownerSubject, catalogEntry.CreateUriNode(Schema.Predicates.GivenName), catalogEntry.CreateLiteralNode(_publicationDetails.Owner.GivenName));
catalogEntry.Assert(ownerSubject, catalogEntry.CreateUriNode(Schema.Predicates.Surname), catalogEntry.CreateLiteralNode(_publicationDetails.Owner.Surname));
//catalogEntry.Assert(ownerSubject, catalogEntry.CreateUriNode(Schema.Predicates.Iss), catalogEntry.CreateLiteralNode(_publicationDetails.Owner.Iss));
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Owner), ownerSubject);
// visibility
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Visibility), catalogEntry.CreateLiteralNode(_publicationDetails.Visibility.Visibility.ToString()));
switch (_publicationDetails.Visibility.Visibility)
{
case PublicationVisibility.VisibilityScope.Organization:
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Organization), catalogEntry.CreateLiteralNode(_publicationDetails.Visibility.Organization));
break;
case PublicationVisibility.VisibilityScope.Subscription:
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Subscription), catalogEntry.CreateLiteralNode(_publicationDetails.Visibility.Subscription));
break;
}
// listed
catalogEntry.Assert(catalogEntrySubject, catalogEntry.CreateUriNode(Schema.Predicates.Listed), catalogEntry.CreateLiteralNode(_isListed.ToString(), Schema.DataTypes.Boolean));
// add the nuspec metadata
Uri nuspecSubject = _nuspec["@id"].ToObject<Uri>();
IGraph nuspecGraph = Utils.CreateGraph(_nuspec);
// Any statements made about this @id in the nuspec we want to make about the catalog items @id
// - catalog readers can then apply this logic in reverse
// - by so doing the catalog entry becomes an audit entry for the data
catalogEntry.Merge(nuspecGraph, false);
foreach (Triple triple in catalogEntry.GetTriplesWithSubject(catalogEntry.CreateUriNode(nuspecSubject)))
{
catalogEntry.Assert(catalogEntrySubject, triple.Predicate.CopyNode(catalogEntry), triple.Object.CopyNode(catalogEntry));
}
GraphHelpers.MaterializeInference(catalogEntry);
SetIdVersionFromGraph(catalogEntry);
// create JSON content
string json = Utils.CreateJson(catalogEntry, _context);
StorageContent content = new StringStorageContent(json, "application/json", "no-store");
return content;
}
public StorageContent CreateContent(CatalogContext context)
{
IGraph graph = new Graph();
INode rdfTypePredicate = graph.CreateUriNode(Schema.Predicates.Type);
INode timeStampPredicate = graph.CreateUriNode(Schema.Predicates.CatalogTimestamp);
INode commitIdPredicate = graph.CreateUriNode(Schema.Predicates.CatalogCommitId);
INode container = graph.CreateUriNode(_resourceUri);
graph.Assert(container, rdfTypePredicate, graph.CreateUriNode(GetContainerType()));
graph.Assert(container, timeStampPredicate, graph.CreateLiteralNode(_timeStamp.ToString("O"), Schema.DataTypes.DateTime));
graph.Assert(container, commitIdPredicate, graph.CreateLiteralNode(_commitId.ToString()));
if (_parent != null)
{
graph.Assert(container, graph.CreateUriNode(Schema.Predicates.Parent), graph.CreateUriNode(_parent));
}
AddCustomContent(container, graph);
INode itemPredicate = graph.CreateUriNode(Schema.Predicates.CatalogItem);
INode countPredicate = graph.CreateUriNode(Schema.Predicates.CatalogCount);
foreach (KeyValuePair<Uri, CatalogContainerItem> item in _items)
{
INode itemNode = graph.CreateUriNode(item.Key);
graph.Assert(container, itemPredicate, itemNode);
graph.Assert(itemNode, rdfTypePredicate, graph.CreateUriNode(item.Value.Type));
if (item.Value.PageContent != null)
{
graph.Merge(item.Value.PageContent);
}
graph.Assert(itemNode, timeStampPredicate, graph.CreateLiteralNode(item.Value.TimeStamp.ToString("O"), Schema.DataTypes.DateTime));
graph.Assert(itemNode, commitIdPredicate, graph.CreateLiteralNode(item.Value.CommitId.ToString()));
if (item.Value.Count != null)
{
graph.Assert(itemNode, countPredicate, graph.CreateLiteralNode(item.Value.Count.ToString(), Schema.DataTypes.Integer));
}
}
JObject frame = context.GetJsonLdContext("context.Container.json", GetContainerType());
// The below code could be used to compact data storage by using relative URIs.
//frame = (JObject)frame.DeepClone();
//frame["@context"]["@base"] = _resourceUri.ToString();
StorageContent content = new StringStorageContent(Utils.CreateJson(graph, frame), "application/json", "no-store");
return content;
}
//protected virtual Uri CreateIndexEntry(CatalogItem item, Uri resourceUri, Guid commitId, DateTime commitTimeStamp)
//{
// Uri tmpUri = GetTempUri("catalogindexpage", "ttl");
// using (IGraph pageContent = item.CreatePageContent(Context))
// {
// AddCatalogEntryData(pageContent, item.GetItemType(), resourceUri, commitId, commitTimeStamp);
// SaveGraph(pageContent, tmpUri).Wait();
// }
// return tmpUri;
//}
private async Task SaveGraph(IGraph graph, Uri uri, CancellationToken cancellationToken)
{
StringBuilder sb = new StringBuilder();
using (var stringWriter = new System.IO.StringWriter(sb))
{
CompressingTurtleWriter turtleWriter = new CompressingTurtleWriter();
turtleWriter.Save(graph, stringWriter);
}
StorageContent content = new StringStorageContent(sb.ToString(), "application/json", "no-store");
await Storage.Save(uri, content, cancellationToken);
}
Task SaveNuspec(XDocument nuspec, CancellationToken cancellationToken)
{
string relativeAddress = Utils.GetNuspecRelativeAddress(nuspec);
Uri resourceUri = new Uri(_storage.BaseAddress, relativeAddress);
StorageContent content = new StringStorageContent(
nuspec.ToString(),
contentType: "text/xml",
cacheControl: "public, max-age=300, s-maxage=300");
return _storage.Save(resourceUri, content, cancellationToken);
}