ConnectionClient.cs

Go to the documentation of this file.

// 
//  Copyright 2010-2015 Deveel
// 
//    Licensed under the Apache License, Version 2.0 (the "License");
//    you may not use this file except in compliance with the License.
//    You may obtain a copy of the License at
// 
//        http://www.apache.org/licenses/LICENSE-2.0
// 
//    Unless required by applicable law or agreed to in writing, software
//    distributed under the License is distributed on an "AS IS" BASIS,
//    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
//    See the License for the specific language governing permissions and
//    limitations under the License.
//

using System;
using System.Collections;
using System.Collections.Generic;
using System.Data;

using Deveel.Data.Configuration;
using Deveel.Data.Protocol;
using Deveel.Data.Sql;
using Deveel.Data.Transactions;

using IsolationLevel = Deveel.Data.Transactions.IsolationLevel;

namespace Deveel.Data.Client {
    internal class ConnectionClient : IDisposable {
        public DeveelDbConnectionStringBuilder Settings { get; private set; }

        private ConnectionEndPoint remoteEndPoint;

        public IClientConnector Connector { get; private set; }

        private bool OwnsConnector { get; set; }

        public IMessageProcessor Processor { get; private set; }

        private IDictionary<string, object> serverMetadata;

        public ConnectionClient(DeveelDbConnectionStringBuilder settings) {
            Settings = settings;
        }

        public ConnectionClient(IClientConnector connector, DeveelDbConnectionStringBuilder settings) {
            if (connector == null)
                throw new ArgumentNullException("connector");

            Settings = settings;
            Connector = connector;
            Processor = connector.CreateProcessor();
            OwnsConnector = false;
        }

        ~ConnectionClient() {
            Dispose(false);
        }

        public bool IsClosed { get; private set; }

        public string ServerVersion { get; private set; }

        private IClientConnector CreateNetworkConnector() {
            throw new NotSupportedException();
        }

        private IClientConnector CreateConnector() {
            if (Connector != null)
                return Connector;

            IConfiguration configuration = null;

            /*
            TODO:
            if (IsInMemory(Settings.DataSource) && controlDatabase == null) {
                if (controlSystem == null)
                    controlSystem = CreateEmbeddedControlSystem();

                // TODO: handle the case the connection string does not specify a database name
                var databaseName = Settings.Database;
                if (String.IsNullOrEmpty(databaseName))
                    throw new InvalidOperationException();

                Configuration = new Configuration(controlSystem.Config);
                Configuration.DatabaseName(databaseName);

                var defaultSchema = Settings.Schema;
                if (!String.IsNullOrEmpty(defaultSchema))
                    Configuration.DefaultSchema(defaultSchema);

                controlDatabase = controlSystem.ControlDatabase(databaseName);
            } else if (IsInFileSystem(Settings) && controlDatabase == null) {
                if (controlSystem == null)
                    controlSystem = CreateEmbeddedControlSystem();

                // TODO: handle the case the connection string does not specify a database name
                var databaseName = Settings.Database;
                if (String.IsNullOrEmpty(databaseName))
                    throw new InvalidOperationException();

                Configuration = new Configuration(controlSystem.Config);
                Configuration.StorageSystem(ConfigDefaultValues.FileStorageSystem);

                var dbPath = settings.DataSource;
                if (String.Equals(dbPath, "local", StringComparison.OrdinalIgnoreCase))
                    dbPath = settings.Path;
                if (String.IsNullOrEmpty(dbPath))
                    dbPath = databaseName;

                Configuration.DatabasePath(dbPath);

                var defaultSchema = settings.Schema;
                if (!String.IsNullOrEmpty(defaultSchema))
                    Configuration.DefaultSchema(defaultSchema);


                controlDatabase = controlSystem.ControlDatabase(databaseName);
            } else if (controlDatabase == null) {
                return CreateNetworkConnector();
            }

            if (controlDatabase != null)
                return CreateLocalDatabaseConnector(Configuration);

            throw new InvalidOperationException("Unable to create a connector to the database");
            */

            throw new NotImplementedException();
        }

        private IMessage SendMessage(IMessage message) {
            var envelope = Connector.CreateEnvelope(serverMetadata, message);
            var response = Processor.ProcessMessage(envelope);
            if (response == null)
                throw new InvalidOperationException("The processor returned no response.");

            if (response.Error != null)
                throw new DeveelDbServerException(response.Error.ErrorMessage, response.Error.ErrorClass, response.Error.ErrorCode);

            serverMetadata = response.Metadata;
            return response.Message;
        }

        private ConnectionEndPoint MakeRemoteEndPoint() {
            var properties = new Dictionary<string, object>();
            var en = ((IDictionary)Settings).GetEnumerator();
            while (en.MoveNext()) {
                var current = en.Entry;
                properties.Add((string)current.Key, current.Value);
            }

            return Connector.MakeEndPoint(properties);
        }

        public void Connect() {
            if (Connector == null) {
                Connector = CreateConnector();
                Processor = Connector.CreateProcessor();
            }

            remoteEndPoint = MakeRemoteEndPoint();

            var request = new ConnectRequest(Connector.LocalEndPoint, remoteEndPoint) {
                DatabaseName = Settings.Database,
                Timeout = Settings.QueryTimeout,
                IgnoreIdentifiersCase = Settings.IgnoreIdentifiersCase,
                ParameterStyle = Settings.ParameterStyle,
                AutoCommit = Settings.AutoCommit
            };

            var response = SendMessage(request) as ConnectResponse;
            if (response == null)
                throw new ProtocolException("The returned message is invalid");

            if (!response.Opened)
                throw new DeveelDbServerException("Was not able to open the connection on the server.", -1, -1);

            if (response.IsEncryted)
                Connector.SetEncrypton(response.EncryptionData);

            IsClosed = false;
            ServerVersion = response.Version;
        }

        public void Disconnect() {
            try {
                var response = SendMessage(new CloseRequest())
                    as AcknowledgeResponse;

                if (response == null)
                    throw new InvalidOperationException();

                if (!response.State)
                    throw new DeveelDbServerException("Unable to close the connection on the server.", -1, -1);
            } finally {
                IsClosed = true;
            }
        }

        public bool Authenticate() {
            var response = SendMessage(new AuthenticateRequest(Settings.Schema, Settings.UserName, Settings.Password))
                as AuthenticateResponse;

            if (response == null)
                throw new InvalidOperationException();

            return response.Authenticated;
        }

        public IQueryResponse[] ExecuteQuery(int commitId, SqlQuery query) {
            var response = SendMessage(new QueryExecuteRequest(commitId, query))
                as QueryExecuteResponse;

            if (response == null)
                throw new InvalidOperationException();

            return response.QueryResponse;
        }

        public QueryResultPart GetResultPart(int resultId, int rowIndex, int count) {
            var response = SendMessage(new QueryResultPartRequest(resultId, rowIndex, count))
                as QueryResultPartResponse;

            if (response == null)
                throw new InvalidOperationException();

            return response.Part;
        }

        public void DisposeResult(int resultId) {
            var response = SendMessage(new DisposeResultRequest(resultId))
                as AcknowledgeResponse;

            if (response == null)
                throw new InvalidOperationException();

            if (!response.State)
                throw new DeveelDbServerException(null, -1, -1);
        }

        public int BeginTransaction(System.Data.IsolationLevel isolationLevel) {
            var isolation = MapIsolationLevel(isolationLevel);
            return BeginTransaction(isolation);
        }

        private IsolationLevel MapIsolationLevel(System.Data.IsolationLevel isolationLevel) {
            if (isolationLevel == System.Data.IsolationLevel.Serializable)
                return IsolationLevel.Serializable;
            if (isolationLevel == System.Data.IsolationLevel.Snapshot)
                return IsolationLevel.Snapshot;
            if (isolationLevel == System.Data.IsolationLevel.ReadCommitted)
                return IsolationLevel.ReadCommitted;
            if (isolationLevel == System.Data.IsolationLevel.ReadUncommitted)
                return IsolationLevel.ReadUncommitted;

            throw new NotSupportedException(String.Format("Isolation Level '{0}' not supported by DeveelDB", isolationLevel));
        }

        public int BeginTransaction(IsolationLevel isolationLevel) {
            var response = SendMessage(new BeginRequest(isolationLevel))
                as BeginResponse;

            if (response == null)
                throw new InvalidOperationException();

            return response.CommitId;
        }

        public void CommitTransaction(int transactionId) {
            var response = SendMessage(new CommitRequest(transactionId))
                as AcknowledgeResponse;

            if (response == null)
                throw new InvalidOperationException();

            if (!response.State)
                throw new DeveelDbServerException("Unable to commit the transaction on the server.", -1, -1);
        }

        public void RollbackTransaction(int transactionId) {
            var response = SendMessage(new RollbackRequest(transactionId))
                as AcknowledgeResponse;

            if (response == null)
                throw new InvalidOperationException();

            if (!response.State)
                throw new DeveelDbServerException("Unable to rollback the transaction on the server.", -1, -1);

        }

        public void DisposeLargeObject(long objId) {
            var response = SendMessage(new LargeObjectDisposeRequest(objId))
                as AcknowledgeResponse;

            if (response == null)
                throw new InvalidOperationException();

            if (!response.State)
                throw new InvalidOperationException("Unable to dispose the large object on the server.");
        }

        public void Dispose() {
            Dispose(true);
            GC.SuppressFinalize(this);
        }

        private void Dispose(bool disposing) {
            if (disposing) {
                if (OwnsConnector && Connector != null) {
                    Connector.Dispose();
                }
            }

            Connector = null;
        }
    }
}