Oracle DB Connector (#84)

* Added connector classes for Oracle and associated health checks with unit tests.

Author: kishoreallwynraj

src/Connectors/src/Connector.EF6Autofac/OracleDbContextContainerBuilderExtensions.cs

@@ -0,0 +1,55 @@
+// Copyright 2017 the original author or authors.
+//
+// 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
+//
+// https://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 Autofac;
+using Autofac.Builder;
+using Microsoft.Extensions.Configuration;
+using Steeltoe.CloudFoundry.Connector.Oracle;
+using Steeltoe.CloudFoundry.Connector.Services;
+using System;
+
+namespace Steeltoe.CloudFoundry.Connector.EF6Autofac
+{
+    public static class OracleDbContextContainerBuilderExtensions
+    {
+        /// <summary>
+        /// Add your Oracle-based DbContext to the ContainerBuilder
+        /// </summary>
+        /// <typeparam name="TContext">Your DbContext</typeparam>
+        /// <param name="container">Autofac <see cref="ContainerBuilder" /></param>
+        /// <param name="config">Your app config</param>
+        /// <param name="serviceName">Name of service instance</param>
+        /// <returns><see cref="IRegistrationBuilder{TLimit, TActivatorData, TRegistrationStyle}"/></returns>
+        public static IRegistrationBuilder<object, SimpleActivatorData, SingleRegistrationStyle> RegisterDbContext<TContext>(this ContainerBuilder container, IConfiguration config, string serviceName = null)
+        {
+            if (container == null)
+            {
+                throw new ArgumentNullException(nameof(container));
+            }
+
+            if (config == null)
+            {
+                throw new ArgumentNullException(nameof(config));
+            }
+
+            OracleServiceInfo info = serviceName == null
+                ? config.GetSingletonServiceInfo<OracleServiceInfo>()
+                : config.GetRequiredServiceInfo<OracleServiceInfo>(serviceName);
+
+            var oracleConfig = new OracleProviderConnectorOptions(config);
+            var factory = new OracleProviderConnectorFactory(info, oracleConfig, typeof(TContext));
+            return container.Register(c => factory.Create(null)).As<TContext>();
+        }
+    }
+}

src/Connectors/src/Connector.EF6Core/OracleDbContextServiceCollectionExtensions.cs

@@ -0,0 +1,95 @@
+// Copyright 2017 the original author or authors.
+//
+// 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
+//
+// https://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 Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using Steeltoe.CloudFoundry.Connector.Oracle;
+using Steeltoe.CloudFoundry.Connector.Oracle.EF6;
+using Steeltoe.CloudFoundry.Connector.Services;
+using System;
+
+namespace Steeltoe.CloudFoundry.Connector.EF6Core
+{
+    public static class OracleDbContextServiceCollectionExtensions
+    {
+        /// <summary>
+        /// Add a Oracle-backed DbContext and Oracle health contributor to the Service Collection
+        /// </summary>
+        /// <typeparam name="TContext">Type of DbContext to add</typeparam>
+        /// <param name="services">Service Collection</param>
+        /// <param name="config">Application Configuration</param>
+        /// <param name="contextLifetime">Lifetime of the service to inject</param>
+        /// <param name="logFactory">logging factory</param>
+        /// <returns>IServiceCollection for chaining</returns>
+        public static IServiceCollection AddDbContext<TContext>(this IServiceCollection services, IConfiguration config, ServiceLifetime contextLifetime = ServiceLifetime.Scoped, ILoggerFactory logFactory = null)
+        {
+            if (services == null)
+            {
+                throw new ArgumentNullException(nameof(services));
+            }
+
+            if (config == null)
+            {
+                throw new ArgumentNullException(nameof(config));
+            }
+
+            OracleServiceInfo info = config.GetSingletonServiceInfo<OracleServiceInfo>();
+            DoAdd(services, config, info, typeof(TContext), contextLifetime);
+
+            return services;
+        }
+
+        /// <summary>
+        /// Add a Oracle-backed DbContext and Oracle health contributor to the Service Collection
+        /// </summary>
+        /// <typeparam name="TContext">Type of DbContext to add</typeparam>
+        /// <param name="services">Service Collection</param>
+        /// <param name="config">Application Configuration</param>
+        /// <param name="serviceName">Name of service binding in Cloud Foundry</param>
+        /// <param name="contextLifetime">Lifetime of the service to inject</param>
+        /// <param name="logFactory">logging factory</param>
+        /// <returns>IServiceCollection for chaining</returns>
+        public static IServiceCollection AddDbContext<TContext>(this IServiceCollection services, IConfiguration config, string serviceName, ServiceLifetime contextLifetime = ServiceLifetime.Scoped, ILoggerFactory logFactory = null)
+        {
+            if (services == null)
+            {
+                throw new ArgumentNullException(nameof(services));
+            }
+
+            if (string.IsNullOrEmpty(serviceName))
+            {
+                throw new ArgumentNullException(nameof(serviceName));
+            }
+
+            if (config == null)
+            {
+                throw new ArgumentNullException(nameof(config));
+            }
+
+            OracleServiceInfo info = config.GetRequiredServiceInfo<OracleServiceInfo>(serviceName);
+            DoAdd(services, config, info, typeof(TContext), contextLifetime);
+
+            return services;
+        }
+
+        private static void DoAdd(IServiceCollection services, IConfiguration config, OracleServiceInfo info, Type dbContextType, ServiceLifetime contextLifetime)
+        {
+            OracleProviderConnectorOptions oracleConfig = new OracleProviderConnectorOptions(config);
+
+            OracleDbContextConnectorFactory factory = new OracleDbContextConnectorFactory(info, oracleConfig, dbContextType);
+            services.Add(new ServiceDescriptor(dbContextType, factory.Create, contextLifetime));
+        }
+    }
+}

src/Connectors/src/Connector.EFCore/EntityFrameworkCoreTypeLocator.cs

@@ -68,5 +68,21 @@ public static class EntityFrameworkCoreTypeLocator
         /// </summary>
         /// <exception cref="ConnectorException">When type is not found</exception>
         public static Type SqlServerDbContextOptionsType => ConnectorHelpers.FindTypeOrThrow(SqlServerEntityAssemblies, SqlServerEntityTypeNames, "DbContextOptionsBuilder", "a Microsoft SQL Server EntityFramework Core assembly");
+
+        /// <summary>
+        /// Gets a list of supported Oracle Entity Framework Core Assemblies
+        /// </summary>
+        public static string[] OracleEntityAssemblies { get; internal set; } = new string[] { "Oracle.EntityFrameworkCore", "Devart.Data.Oracle.EFCore" };
+
+        /// <summary>
+        /// Gets a list of supported fully-qualifed names for compatible DbContextOptionsExtentions used to configure EntityFrameworkCore
+        /// </summary>
+        public static string[] OracleEntityTypeNames { get; internal set; } = new string[] { "Microsoft.EntityFrameworkCore.OracleDbContextOptionsExtensions", "Devart.Data.Oracle.Entity.OracleOptionsExtension" };
+
+        /// <summary>
+        /// Gets the type used to configure EntityFramework Core with Oracle
+        /// </summary>
+        /// <exception cref="ConnectorException">When type is not found</exception>
+        public static Type OracleDbContextOptionsType => ConnectorHelpers.FindTypeOrThrow(OracleEntityAssemblies, OracleEntityTypeNames, "DbContextOptionsBuilder", "a Oracle EntityFramework Core assembly");
     }
 }

src/Connectors/src/Connector.EFCore/OracleDbContextOptionsExtensions.cs

@@ -0,0 +1,165 @@
+// Copyright 2017 the original author or authors.
+//
+// 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
+//
+// https://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 Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.Configuration;
+using Steeltoe.CloudFoundry.Connector.EFCore;
+using Steeltoe.CloudFoundry.Connector.Services;
+using System;
+using System.Reflection;
+
+namespace Steeltoe.CloudFoundry.Connector.Oracle.EFCore
+{
+    public static class OracleDbContextOptionsExtensions
+    {
+        public static DbContextOptionsBuilder UseOracle(this DbContextOptionsBuilder optionsBuilder, IConfiguration config, object oracleOptionsAction = null)
+        {
+            if (optionsBuilder == null)
+            {
+                throw new ArgumentNullException(nameof(optionsBuilder));
+            }
+
+            if (config == null)
+            {
+                throw new ArgumentNullException(nameof(config));
+            }
+
+            var connection = GetConnection(config);
+
+            return DoUseOracle(optionsBuilder, connection, oracleOptionsAction);
+        }
+
+        public static DbContextOptionsBuilder UseOracle(this DbContextOptionsBuilder optionsBuilder, IConfiguration config, string serviceName, object oracleOptionsAction = null)
+        {
+            if (optionsBuilder == null)
+            {
+                throw new ArgumentNullException(nameof(optionsBuilder));
+            }
+
+            if (config == null)
+            {
+                throw new ArgumentNullException(nameof(config));
+            }
+
+            if (string.IsNullOrEmpty(serviceName))
+            {
+                throw new ArgumentException(nameof(serviceName));
+            }
+
+            var connection = GetConnection(config, serviceName);
+
+            return DoUseOracle(optionsBuilder, connection, oracleOptionsAction);
+        }
+
+        public static DbContextOptionsBuilder<TContext> UseOracle<TContext>(this DbContextOptionsBuilder<TContext> optionsBuilder, IConfiguration config, object oracleOptionsAction = null)
+            where TContext : DbContext
+        {
+            if (optionsBuilder == null)
+            {
+                throw new ArgumentNullException(nameof(optionsBuilder));
+            }
+
+            if (config == null)
+            {
+                throw new ArgumentNullException(nameof(config));
+            }
+
+            var connection = GetConnection(config);
+
+            return DoUseOracle<TContext>(optionsBuilder, connection, oracleOptionsAction);
+        }
+
+        public static DbContextOptionsBuilder<TContext> UseOracle<TContext>(this DbContextOptionsBuilder<TContext> optionsBuilder, IConfiguration config, string serviceName, object oracleOptionsAction = null)
+            where TContext : DbContext
+        {
+            if (optionsBuilder == null)
+            {
+                throw new ArgumentNullException(nameof(optionsBuilder));
+            }
+
+            if (config == null)
+            {
+                throw new ArgumentNullException(nameof(config));
+            }
+
+            if (string.IsNullOrEmpty(serviceName))
+            {
+                throw new ArgumentException(nameof(serviceName));
+            }
+
+            var connection = GetConnection(config, serviceName);
+
+            return DoUseOracle<TContext>(optionsBuilder, connection, oracleOptionsAction);
+        }
+
+        private static DbContextOptionsBuilder DoUseOracle(DbContextOptionsBuilder optionsBuilder, object connection, object oracleOptionsAction)
+        {
+            Type extensionType = EntityFrameworkCoreTypeLocator.OracleDbContextOptionsType;
+
+            MethodInfo useMethod = FindUseSqlMethod(extensionType, new Type[] { typeof(DbContextOptionsBuilder), typeof(string) });
+            if (extensionType == null)
+            {
+                throw new ConnectorException("Unable to find UseOracle extension, are you missing Oracle EntityFramework Core assembly");
+            }
+
+            object result = ConnectorHelpers.Invoke(useMethod, null, new object[] { optionsBuilder, connection, oracleOptionsAction });
+            if (result == null)
+            {
+                throw new ConnectorException(string.Format("Failed to invoke UseOracle extension, connection: {0}", connection));
+            }
+
+            return (DbContextOptionsBuilder)result;
+        }
+
+        private static DbContextOptionsBuilder<TContext> DoUseOracle<TContext>(DbContextOptionsBuilder<TContext> optionsBuilder, string connection, object oracleOptionsAction = null)
+            where TContext : DbContext
+        {
+            return (DbContextOptionsBuilder<TContext>)DoUseOracle((DbContextOptionsBuilder)optionsBuilder, connection, oracleOptionsAction);
+        }
+
+        private static MethodInfo FindUseSqlMethod(Type type, Type[] parameterTypes)
+        {
+            var typeInfo = type.GetTypeInfo();
+            var declaredMethods = typeInfo.DeclaredMethods;
+
+            foreach (MethodInfo ci in declaredMethods)
+            {
+                var parameters = ci.GetParameters();
+                if (parameters.Length == 3 &&
+                    ci.Name.Equals("UseOracle", StringComparison.InvariantCultureIgnoreCase) &&
+                    parameters[0].ParameterType.Equals(parameterTypes[0]) &&
+                    parameters[1].ParameterType.Equals(parameterTypes[1]) &&
+                    ci.IsPublic && ci.IsStatic)
+                {
+                    return ci;
+                }
+            }
+
+            return null;
+        }
+
+        private static string GetConnection(IConfiguration config, string serviceName = null)
+        {
+            OracleServiceInfo info = string.IsNullOrEmpty(serviceName)
+                ? config.GetSingletonServiceInfo<OracleServiceInfo>()
+                : config.GetRequiredServiceInfo<OracleServiceInfo>(serviceName);
+
+            OracleProviderConnectorOptions oracleConfig = new OracleProviderConnectorOptions(config);
+
+            OracleProviderConnectorFactory factory = new OracleProviderConnectorFactory(info, oracleConfig, null);
+
+            return factory.CreateConnectionString();
+        }
+    }
+}