CertificateHttpWebRequestFactory.cs

using System;
using System.Net;
using System.Security.Cryptography.X509Certificates;
using HttpWebAdapters;
using HttpWebAdapters.Adapters;

namespace Company.Communication.Solr.Helpers
{
    /// <summary>
    ///     Creates a web request that uses a custom 509 cert to make the web request
    /// </summary>
    public class CertificateHttpWebRequestFactory : IHttpWebRequestFactory
    {
        private readonly X509Certificate _certificate;

        /// <summary>
        ///     Creates a web request using a client side 509 certificate
        /// </summary>
        /// <param name="certificate">509 Certificate to make secure request</param>
        public CertificateHttpWebRequestFactory(X509Certificate certificate)
        {
            _certificate = certificate;
        }

        public IHttpWebRequest Create(Uri url)
        {
            var req = (HttpWebRequest) WebRequest.Create(url);
            req.ClientCertificates.Add(_certificate);
            return new HttpWebRequestAdapter(req);
        }

        public IHttpWebRequest Create(string url)
        {
            return Create(new Uri(url));
        }
    }
}

SolrConnections.cs

using Company.Communication.Solr.Models;
using Castle.Facilities.SolrNetIntegration;
using Castle.MicroKernel.Registration;
using Castle.Windsor;
using HttpWebAdapters;
using SolrNet;
using SolrNet.Exceptions;
using SolrNet.Impl;
using Utilities;
using log4net;

namespace Company.Communication.Solr.Helpers
{
    public class SolrConnections
    {
        private static readonly ILog Log = LogManager.GetLogger(typeof (SolrConnections));
        private readonly ISolrOperations<SolrIOLog> _session;

        private readonly string _solrServerURL;

        /// <summary>
        ///     Creates the solr connection using Castle Windosr IoC containers and Facilities.
        /// </summary>
        /// <param name="solrServerURL">The solr server URL.</param>
        public SolrConnections(string solrServerURL)
        {
            Log.DebugFormat("CreateSolrConnection for Solr URL: {0}", solrServerURL);
            try
            {
                var solrFacility = new SolrNetFacility(solrServerURL);
                var container = new WindsorContainer();

                container.AddFacility(solrServerURL, solrFacility);
                // override core1 components
                const string core1Connection = "core1.connection";
                container.Register(Component.For<ISolrConnection>()
                                            .ImplementedBy<LoggingConnection>()
                                            .Named(core1Connection)
                                            .DependsOn(
                                                Property.ForKey<IHttpWebRequestFactory>()
                                                        .Eq(
                                                            new CertificateHttpWebRequestFactory(
                                                                CertificateCreator.GetMyX509Certificate("client cert common name"))))
                                            .Parameters(Parameter.ForKey("serverURL").Eq(solrServerURL)));
                container.Register(Component.For(typeof (ISolrBasicOperations<SolrIOLog>),
                                                 typeof (ISolrBasicReadOnlyOperations<SolrIOLog>))
                                            .ImplementedBy<SolrBasicServer<SolrIOLog>>()
                                            .ServiceOverrides(ServiceOverride.ForKey("connection").Eq(core1Connection)));
                container.Register(Component.For<ISolrQueryExecuter<SolrIOLog>>()
                                            .ImplementedBy<SolrQueryExecuter<SolrIOLog>>()
                                            .ServiceOverrides(ServiceOverride.ForKey("connection").Eq(core1Connection)));
                _session = container.Resolve<ISolrOperations<SolrIOLog>>();
                _solrServerURL = solrServerURL;
            }
            catch (SolrConnectionException ex)
            {
                Log.Error("Failed to connect to Solr instance");
                Log.Error(ex);
                throw;
            }
        }

        public ISolrOperations<SolrIOLog> Session
        {
            get { return _session; }
        }

        public string SolrServerURL
        {
            get { return _solrServerURL; }
        }
    }
}