Using a Database Over a Webservice

db4o Database Amendments

In order to send the persistent classes from the client to the server we will need a Marshal-By-Reference object. This can be any class providing access to an ObjectContainer (can be modified ObjectContainer itself). The requirements to the transport object:

• the transport object should open a database file on request (filename should be provided somehow);
• the transport object must have zero-parameters constructor.

With the first implementation I tried to modify the ObjectContainer interface and the implementing classes. However it resulted in quite a lot of modifications as the hierarchy is deep. Moreover, I could not find a logical place to pass a filename to the object container (default implementation requires it in the constructor, and our rules need a parameterless constructor).

In the implementation, provided in this example, I use a version of Db4oFactory class, which can work over the network and can provide ObjectContainers for client requests:

using System;
using System.IO;
using Db4objects.Db4o;
using Db4objects.Db4o.Config;
using Db4objects.Db4o.Ext;
using Db4objects.Db4o.Foundation;
using Db4objects.Db4o.Foundation.Network;
using Db4objects.Db4o.Internal;
using Db4objects.Db4o.Internal.CS;
using Db4objects.Db4o.Reflect;

namespace Db4objects.Db4o
{
    /// <summary>

    /// This class simply duplicates Db4oFactory with 

    /// instance methods, thus allowing Marshalling to

    /// access them

    /// </summary>

    public class Db4oRemoteFactory: MarshalByRefObject
    {
        internal static readonly Config4Impl i_config = new Config4Impl();
        
        public  IConfiguration NewConfiguration()
        {
                    return Db4oFactory.NewConfiguration();
        }

        public IConfiguration CloneConfiguration()
        {
            return (Config4Impl)((IDeepClone)Db4oFactory.Configure()).DeepClone(null);
        }

        public  IObjectContainer OpenFile(string databaseFileName)
        {
            return OpenFile(CloneConfiguration(), databaseFileName);
        }

        public IObjectContainer OpenFile(IConfiguration config, string databaseFileName
            )
        {
            return ObjectContainerFactory.OpenObjectContainer(config, databaseFileName);
        }

    }
}

    

This implementation is convenient for clients working separately. However, it is not suitable for concurrent collaborative work on the same database file.

Another important change to the db4o sources: some of the internal classes representing persistent objects were marked [Serializable] to be suitable for over-network transmission.

Server

The Server project is presented by a single Program class, which role is to start Db4oRemoteFactory service

    class Program
    {
        static void Main(string[] args)
        {
            // Setting up tcp channel

            BinaryClientFormatterSinkProvider clientProvider = null;

            BinaryServerFormatterSinkProvider serverProvider =
                new BinaryServerFormatterSinkProvider();

            serverProvider.TypeFilterLevel =
                System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;

            IDictionary props = new Hashtable();

            /*
             * Client and server must use the SAME port
             * */
            props["port"] = 65101;
            props["typeFilterLevel"] = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;

            TcpChannel chan =
                new TcpChannel(props, clientProvider, serverProvider);


            ChannelServices.RegisterChannel(chan);


            Type TestFactory = Type.GetType("Db4objects.Db4o.Db4oRemoteFactory, Db4objects.Db4o");
            RemotingConfiguration.RegisterWellKnownServiceType(
                    TestFactory,
                    "TestFactoryEndPoint",
                    WellKnownObjectMode.Singleton
                );
            Console.WriteLine("TestFactory is ready.");

            // Keep the server running until the user presses

            // the Enter key.

            Console.WriteLine("Services are running. Press Enter to end...");
            Console.ReadLine();
        }
        // end Main


    }

Client

Client project contains Program class. In the constructor a connection to the Db4oRemoteFactory service is established:

      public Program()
        {
            string url;

            // Setup a client channel to our services.

            url = @"tcp://LocalHost:65101/";
            BinaryClientFormatterSinkProvider clientProvider =
                new BinaryClientFormatterSinkProvider();

            BinaryServerFormatterSinkProvider serverProvider =
                new BinaryServerFormatterSinkProvider();

            serverProvider.TypeFilterLevel =
                System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;

            IDictionary props = new Hashtable();
            props["port"] = 0;
            props["name"] = System.Guid.NewGuid().ToString();
            props["typeFilterLevel"] = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full;

            TcpChannel chan =
                new TcpChannel(props, clientProvider, serverProvider);
            ChannelServices.RegisterChannel(chan);


            // Set an access to the remote proxy

            factory = (Db4oRemoteFactory)RemotingServices.Connect(
                typeof(Db4oRemoteFactory), url + "TestFactoryEndPoint"
                );
        }
        // end Program

The RunTest method creates a test object, sends it to the server using factory and retrieves it from the database on the server:

        private void RunTest()
        {
            // Remote persistent class 

            TestValue testValue;
            testValue = new TestValue();
            // Modify local TestValue object

            testValue.ChangeData("Test value");
            // Pass testValue to the server through testServer

            // and store the testValue object

            IObjectContainer testServer = factory.OpenFile("test.db4o");
            testServer.Set(testValue);
            // Test what is stored to the database

            IList result = testServer.Get(typeof(TestValue));
            //TestValue test;

            foreach (TestValue test in result) {
                System.Console.WriteLine(test);   
            }
        }
        // end RunTest

Points of Interest

• The most interesting TO-DO on this project is, of course, its performance. How much information is transferred over the network for a single request? How is it comparable to the client-server version of db4o?
• Are there any advantages over client-server version of db4o?
• This implementation can only work over tcp-channel. Is it possible to realize the same functionality over html-channel?
• How to realize concurrency control?

History

2007-05-28 First version.