Click here to Skip to main content
Click here to Skip to main content

Using a Database Over a Webservice

, 29 May 2007
Rate this:
Please Sign up or sign in to vote.
This article shows an example implementation of a database used over a Web-Service

Introduction

RemotingService project was developed as a simple proof of concept (the idea was taken from Database as a Webservice). It is just one more way to realize a remote persistence.

In fact, putting any database on a web-server and providing a remote user interface to it, will realize the same idea from a user point of view. The interesting point of this solution is in the fact that no extra interface is developed, actually database interface is just transferred over the network.

This realization is possible due to the simple object-oriented interface provided by db4o database.

A possible implementation can be in providing personal web-based databases for remote customers. Assuming that each user will use only one and his own database, this solution seems to be viable, providing the data is personally encrypted and unique database names are used.

Background

This article was inspired by Krispy Blog.

Solution Organization

RemotingXml consists of four projects:

  1. Db4objects.Db4o: db4o open-source database. Please, refer to db4o.license.html for licensing information. The code was slightly modified, which will be discussed later.
  2. Server: contains the code for a remote server. Server project is responsible for creating and starting remoting services.
  3. RemotingExample contains the code for creating persistent objects, sending them for serialization to the server and requesting the server for objects from the database.
  4. RemotingClasses project is a library containing the definitions for classes to be persisted.

Remoting Classes

RemotingClasses project contains only one test class, which will be used on the client to be stored on the server. The class must have Serializable attribute to be transferable over the network:

[Serializable]
public class TestValue
{
…
}

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, whose 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

License

This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here

Share

About the Author

Tetyana Loskutova

United Arab Emirates United Arab Emirates
No Biography provided

Comments and Discussions

 
GeneralDb4o's networking feature PinmemberBuu Nguyen30-Mar-08 18:00 
GeneralRe: Db4o's networking feature PinmemberTetyana Loskutova31-Mar-08 9:08 
QuestionLicense issue Pinmember[quad]Cowbe14-Jul-07 7:41 
AnswerRe: License issue PinmemberTetyana Loskutova14-Jul-07 21:07 
GeneralVery usefull PinmemberMartin Garmendia29-May-07 10:43 
GeneralRe: Very usefull PinmemberTetyana Loskutova29-May-07 21:02 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Mobile
Web02 | 2.8.140827.1 | Last Updated 29 May 2007
Article Copyright 2007 by Tetyana Loskutova
Everything else Copyright © CodeProject, 1999-2014
Terms of Service
Layout: fixed | fluid