/// <summary>
/// Serializes the connection's configuration
/// </summary>
/// <param name="context">Configuration Serialization Context</param>
public void SerializeConfiguration(ConfigurationSerializationContext context)
{
INode manager = context.NextSubject;
INode rdfType = context.Graph.CreateUriNode(new Uri(RdfSpecsHelper.RdfType));
INode rdfsLabel = context.Graph.CreateUriNode(new Uri(NamespaceMapper.RDFS + "label"));
INode dnrType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType);
INode genericManager = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassGenericManager);
INode store = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyStore);
context.Graph.Assert(new Triple(manager, rdfType, genericManager));
context.Graph.Assert(new Triple(manager, rdfsLabel, context.Graph.CreateLiteralNode(this.ToString())));
context.Graph.Assert(new Triple(manager, dnrType, context.Graph.CreateLiteralNode(this.GetType().FullName)));
context.Graph.Assert(new Triple(manager, store, context.Graph.CreateLiteralNode(this._storename)));
if (this._username != null && this._password != null)
{
INode username = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyUser);
INode pwd = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyPassword);
context.Graph.Assert(new Triple(manager, username, context.Graph.CreateLiteralNode(this._username)));
context.Graph.Assert(new Triple(manager, pwd, context.Graph.CreateLiteralNode(this._password)));
}
}
/// <summary>
/// Serializes the connection's configuration
/// </summary>
/// <param name="context">Configuration Serialization Context</param>
public override void SerializeConfiguration(ConfigurationSerializationContext context)
{
//Firstly need to ensure our object factory has been referenced
context.EnsureObjectFactory(typeof(AdoObjectFactory));
//Then serialize the actual configuration
INode dnrType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType);
INode rdfType = context.Graph.CreateUriNode(new Uri(RdfSpecsHelper.RdfType));
INode manager = context.NextSubject;
INode rdfsLabel = context.Graph.CreateUriNode(new Uri(NamespaceMapper.RDFS + "label"));
INode genericManager = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassGenericManager);
INode server = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyServer);
INode db = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyDatabase);
INode encrypt = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyEncryptConnection);
context.Graph.Assert(new Triple(manager, rdfType, genericManager));
context.Graph.Assert(new Triple(manager, rdfsLabel, context.Graph.CreateLiteralNode(this.ToString())));
context.Graph.Assert(new Triple(manager, dnrType, context.Graph.CreateLiteralNode(this.GetType().FullName + ", dotNetRDF.Data.Sql")));
context.Graph.Assert(new Triple(manager, server, context.Graph.CreateLiteralNode(this._server)));
context.Graph.Assert(new Triple(manager, db, context.Graph.CreateLiteralNode(this._db)));
if (this._encrypt)
{
context.Graph.Assert(new Triple(manager, encrypt, this._encrypt.ToLiteral(context.Graph)));
}
if (this.AccessMode != AdoAccessMode.Streaming)
{
INode loadMode = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyLoadMode);
context.Graph.Assert(new Triple(manager, loadMode, context.Graph.CreateLiteralNode(this.AccessMode.ToString())));
}
if (this._user != null && this._password != null)
{
INode username = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyUser);
INode pwd = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyPassword);
context.Graph.Assert(new Triple(manager, username, context.Graph.CreateLiteralNode(this._user)));
context.Graph.Assert(new Triple(manager, pwd, context.Graph.CreateLiteralNode(this._password)));
}
}
/// <summary>
/// Serializes the connection's configuration
/// </summary>
/// <param name="context">Configuration Serialization Context</param>
public void SerializeConfiguration(ConfigurationSerializationContext context)
{
INode manager = context.NextSubject;
INode rdfType = context.Graph.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfType));
INode rdfsLabel = context.Graph.CreateUriNode(UriFactory.Create(NamespaceMapper.RDFS + "label"));
INode dnrType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType);
INode genericManager = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassGenericManager);
INode server = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyServer);
INode queryPath = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyQueryPath);
INode updatePath = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyUpdatePath);
context.Graph.Assert(new Triple(manager, rdfType, genericManager));
context.Graph.Assert(new Triple(manager, rdfsLabel, context.Graph.CreateLiteralNode(this.ToString())));
context.Graph.Assert(new Triple(manager, dnrType, context.Graph.CreateLiteralNode(this.GetType().FullName)));
context.Graph.Assert(new Triple(manager, server, context.Graph.CreateLiteralNode(this._baseUri)));
context.Graph.Assert(new Triple(manager, queryPath, context.Graph.CreateLiteralNode(this._queryService)));
if (this._updateService != null)
{
context.Graph.Assert(new Triple(manager, updatePath, context.Graph.CreateLiteralNode(this._updateService)));
}
base.SerializeProxyConfig(manager, context);
}
public void WritingCollectionCompressionComplex1()
{
SparqlConnector connector = new SparqlConnector(new VDS.RDF.Query.SparqlRemoteEndpoint(new Uri("http://dbpedia.org/sparql")));
Graph g = new Graph();
g.NamespaceMap.AddNamespace("ex", new Uri("http://example.org/"));
g.NamespaceMap.AddNamespace("dnr", new Uri(ConfigurationLoader.ConfigurationNamespace));
INode n = g.CreateBlankNode();
g.Assert(g.CreateUriNode("ex:subj"), g.CreateUriNode("dnr:genericManager"), n);
ConfigurationSerializationContext sContext = new ConfigurationSerializationContext(g);
sContext.NextSubject = n;
connector.SerializeConfiguration(sContext);
CompressingTurtleWriterContext context = new CompressingTurtleWriterContext(g, Console.Out);
WriterHelper.FindCollections(context);
Assert.Equal(2, context.Collections.Count);
this.CheckCompressionRoundTrip(g);
}
/// <summary>
/// Serializes the Configuration of the Manager
/// </summary>
/// <param name="context">Configuration Serialization Context</param>
public virtual void SerializeConfiguration(ConfigurationSerializationContext context)
{
INode manager = context.NextSubject;
INode rdfType = context.Graph.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfType));
INode rdfsLabel = context.Graph.CreateUriNode(UriFactory.Create(NamespaceMapper.RDFS + "label"));
INode dnrType = context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyType));
INode storageProvider = context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyStorageProvider));
context.Graph.Assert(manager, rdfType, context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.ClassStorageProvider)));
context.Graph.Assert(manager, dnrType, context.Graph.CreateLiteralNode(GetType().ToString()));
context.Graph.Assert(manager, rdfsLabel, context.Graph.CreateLiteralNode(ToString()));
if (_manager is IConfigurationSerializable)
{
INode managerObj = context.Graph.CreateBlankNode();
context.NextSubject = managerObj;
((IConfigurationSerializable)_manager).SerializeConfiguration(context);
context.Graph.Assert(manager, storageProvider, managerObj);
}
else
{
throw new DotNetRdfConfigurationException("Unable to serialize configuration as the underlying IStorageProvider is not serializable");
}
}
/// <summary>
/// Serializes the connection's configuration.
/// </summary>
/// <param name="context">Configuration Serialization Context.</param>
public virtual void SerializeConfiguration(ConfigurationSerializationContext context)
{
INode manager = context.NextSubject;
INode rdfType = context.Graph.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfType));
INode rdfsLabel = context.Graph.CreateUriNode(UriFactory.Create(NamespaceMapper.RDFS + "label"));
INode dnrType = context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyType));
INode storageServer = context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.ClassStorageServer));
INode server = context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyServer));
context.Graph.Assert(new Triple(manager, rdfType, storageServer));
context.Graph.Assert(new Triple(manager, rdfsLabel, context.Graph.CreateLiteralNode(ToString())));
context.Graph.Assert(new Triple(manager, dnrType, context.Graph.CreateLiteralNode(GetType().FullName)));
context.Graph.Assert(new Triple(manager, server, context.Graph.CreateLiteralNode(_baseUri)));
if (_username != null && _pwd != null)
{
INode username = context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyUser));
INode pwd = context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyPassword));
context.Graph.Assert(new Triple(manager, username, context.Graph.CreateLiteralNode(_username)));
context.Graph.Assert(new Triple(manager, pwd, context.Graph.CreateLiteralNode(_pwd)));
}
SerializeStandardConfig(manager, context);
}
/// <summary>
/// Serializes the Configuration of the Manager
/// </summary>
/// <param name="context">Configuration Serialization Context</param>
public virtual void SerializeConfiguration(ConfigurationSerializationContext context)
{
INode manager = context.NextSubject;
INode rdfType = context.Graph.CreateUriNode(new Uri(RdfSpecsHelper.RdfType));
INode rdfsLabel = context.Graph.CreateUriNode(new Uri(NamespaceMapper.RDFS + "label"));
INode dnrType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType);
INode genericManager = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyGenericManager);
context.Graph.Assert(manager, rdfType, ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassGenericManager));
context.Graph.Assert(manager, dnrType, context.Graph.CreateLiteralNode(this.GetType().ToString()));
context.Graph.Assert(manager, rdfsLabel, context.Graph.CreateLiteralNode(this.ToString()));
if (this._manager is IConfigurationSerializable)
{
INode managerObj = context.Graph.CreateBlankNode();
context.NextSubject = managerObj;
((IConfigurationSerializable)this._manager).SerializeConfiguration(context);
context.Graph.Assert(manager, genericManager, managerObj);
}
else
{
throw new DotNetRdfConfigurationException("Unable to serialize configuration as the underlying IGenericIOManager is not serializable");
}
}
/// <summary>
/// Serializes the connection's configuration
/// </summary>
/// <param name="context">Configuration Serialization Context</param>
public virtual void SerializeConfiguration(ConfigurationSerializationContext context)
{
INode manager = context.NextSubject;
INode rdfType = context.Graph.CreateUriNode(new Uri(RdfSpecsHelper.RdfType));
INode rdfsLabel = context.Graph.CreateUriNode(new Uri(NamespaceMapper.RDFS + "label"));
INode dnrType = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyType);
INode sqlManager = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.ClassSqlManager);
INode server = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyServer);
INode database = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyDatabase);
context.Graph.Assert(new Triple(manager, rdfType, sqlManager));
context.Graph.Assert(new Triple(manager, rdfsLabel, context.Graph.CreateLiteralNode(this.ToString())));
context.Graph.Assert(new Triple(manager, dnrType, context.Graph.CreateLiteralNode(this.GetType().FullName)));
context.Graph.Assert(new Triple(manager, server, context.Graph.CreateLiteralNode(this._dbserver)));
context.Graph.Assert(new Triple(manager, database, context.Graph.CreateLiteralNode(this._dbname)));
if (this._dbuser != null && this._dbpwd != null)
{
INode username = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyUser);
INode pwd = ConfigurationLoader.CreateConfigurationNode(context.Graph, ConfigurationLoader.PropertyPassword);
context.Graph.Assert(new Triple(manager, username, context.Graph.CreateLiteralNode(this._dbuser)));
context.Graph.Assert(new Triple(manager, pwd, context.Graph.CreateLiteralNode(this._dbpwd)));
}
}
/// <summary>
/// Helper method which adds standard configuration information (proxy and timeout settings) to serialized configuration
/// </summary>
/// <param name="objNode">Object Node representing the <see cref="IStorageProvider">IStorageProvider</see> whose configuration is being serialized</param>
/// <param name="context">Serialization Context</param>
protected void SerializeStandardConfig(INode objNode, ConfigurationSerializationContext context)
{
// Timeout
if (this.Timeout > 0)
{
INode timeout = context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyTimeout));
context.Graph.Assert(new Triple(objNode, timeout, this.Timeout.ToLiteral(context.Graph)));
}
#if !NO_PROXY
// Proxy configuration
if (this._proxy == null)
{
return;
}
INode proxy = context.NextSubject;
INode usesProxy = context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyProxy));
INode rdfType = context.Graph.CreateUriNode(UriFactory.Create(RdfSpecsHelper.RdfType));
INode proxyType = context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.ClassProxy));
INode server = context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyServer));
INode user = context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyUser));
INode pwd = context.Graph.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyPassword));
context.Graph.Assert(new Triple(objNode, usesProxy, proxy));
context.Graph.Assert(new Triple(proxy, rdfType, proxyType));
context.Graph.Assert(new Triple(proxy, server, context.Graph.CreateLiteralNode(this._proxy.Address.AbsoluteUri)));
if (!(this._proxy.Credentials is NetworkCredential))
{
return;
}
NetworkCredential cred = (NetworkCredential)this._proxy.Credentials;
context.Graph.Assert(new Triple(proxy, user, context.Graph.CreateLiteralNode(cred.UserName)));
context.Graph.Assert(new Triple(proxy, pwd, context.Graph.CreateLiteralNode(cred.Password)));
#endif
}
public void StorageVirtuosoConfigSerialization()
{
NTriplesFormatter formatter = new NTriplesFormatter();
VirtuosoManager manager = VirtuosoTest.GetConnection();
try
{
Assert.IsNotNull(manager);
Graph g = new Graph();
INode rdfType = g.CreateUriNode(new Uri(RdfSpecsHelper.RdfType));
INode dnrType = g.CreateUriNode(UriFactory.Create(ConfigurationLoader.PropertyType));
INode objFactory = g.CreateUriNode(UriFactory.Create(ConfigurationLoader.ClassObjectFactory));
INode virtFactory = g.CreateLiteralNode("VDS.RDF.Configuration.VirtuosoObjectFactory, dotNetRDF.Data.Virtuoso");
INode genericManager = g.CreateUriNode(UriFactory.Create(ConfigurationLoader.ClassStorageProvider));
INode virtManager = g.CreateLiteralNode("VDS.RDF.Storage.VirtuosoManager, dotNetRDF.Data.Virtuoso");
//Serialize Configuration
ConfigurationSerializationContext context = new ConfigurationSerializationContext(g);
manager.SerializeConfiguration(context);
Console.WriteLine("Serialized Configuration");
foreach (Triple t in g.Triples)
{
Console.WriteLine(t.ToString(formatter));
}
Console.WriteLine();
//Ensure that it was serialized
INode factory = g.GetTriplesWithPredicateObject(rdfType, objFactory).Select(t => t.Subject).FirstOrDefault();
Assert.IsNotNull(factory, "Should be an object factory in the serialized configuration");
Assert.IsTrue(g.ContainsTriple(new Triple(factory, dnrType, virtFactory)), "Should contain a Triple declaring the dnr:type to be the Virtuoso Object factory type");
INode objNode = g.GetTriplesWithPredicateObject(rdfType, genericManager).Select(t => t.Subject).FirstOrDefault();
Assert.IsNotNull(objNode, "Should be a generic manager in the serialized configuration");
Assert.IsTrue(g.ContainsTriple(new Triple(objNode, dnrType, virtManager)), "Should contain a Triple declaring the dnr:type to be the Virtuoso Manager type");
//Serialize again
manager.SerializeConfiguration(context);
Console.WriteLine("Serialized Configuration (after 2nd pass)");
foreach (Triple t in g.Triples)
{
Console.WriteLine(t.ToString(formatter));
}
Console.WriteLine();
//Ensure that object factory has not been serialized again
Assert.AreEqual(1, g.GetTriplesWithPredicateObject(rdfType, objFactory).Count(), "Should only be 1 Object Factory registered even after a 2nd serializer pass");
//Now try to load the object
ConfigurationLoader.AutoConfigureObjectFactories(g);
Object loadedObj = ConfigurationLoader.LoadObject(g, objNode);
if (loadedObj is VirtuosoManager)
{
Assert.AreEqual(manager.ToString(), loadedObj.ToString(), "String forms should be equal");
}
else
{
Assert.Fail("Returned an object of type '" + loadedObj.GetType().FullName + "' when deserializing");
}
}
finally
{
if (manager != null)
{
manager.Dispose();
}
}
}
private void mnuSaveConnection_Click(object sender, EventArgs e)
{
if (this.ActiveMdiChild != null)
{
if (this.ActiveMdiChild is StoreManagerForm)
{
Object manager;
if (this.ActiveMdiChild is StoreManagerForm)
{
manager = ((StoreManagerForm)this.ActiveMdiChild).Manager;
}
else
{
return;
}
if (manager is IConfigurationSerializable)
{
this.sfdConnection.Filter = MimeTypesHelper.GetFilenameFilter(true, false, false, false, false, false);
if (this.sfdConnection.ShowDialog() == DialogResult.OK)
{
//Append to existing configuration file or overwrite?
ConfigurationSerializationContext context;
if (File.Exists(this.sfdConnection.FileName))
{
DialogResult result = MessageBox.Show("The selected connection file already exists - would you like to append this connection to that file? Click Yes to append to this file, No to overwrite and Cancel to abort", "Append Connection?", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question);
switch (result)
{
case DialogResult.Yes:
Graph g = new Graph();
FileLoader.Load(g, this.sfdConnection.FileName);
context = new ConfigurationSerializationContext(g);
break;
case DialogResult.No:
context = new ConfigurationSerializationContext();
break;
default:
return;
}
}
else
{
//Create new configuration file
context = new ConfigurationSerializationContext();
}
//Save the Connection
((IConfigurationSerializable)manager).SerializeConfiguration(context);
try
{
IRdfWriter writer = MimeTypesHelper.GetWriterByFileExtension(MimeTypesHelper.GetTrueFileExtension(this.sfdConnection.FileName));
writer.Save(context.Graph, this.sfdConnection.FileName);
}
catch (RdfWriterSelectionException)
{
CompressingTurtleWriter ttlwriter = new CompressingTurtleWriter(WriterCompressionLevel.High);
ttlwriter.Save(context.Graph, this.sfdConnection.FileName);
}
}
}
else
{
MessageBox.Show("Unable to save the current connection as it does not support this feature", "Save Unavailable", MessageBoxButtons.OK, MessageBoxIcon.Information);
}
}
else
{
this.mnuSaveConnection.Enabled = false;
}
}
else
{
this.mnuSaveConnection.Enabled = false;
}
}
