/// <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; } }