/// <summary>
 /// Setups the specified root config.
 /// </summary>
 /// <param name="bootstrap">The bootstrap.</param>
 /// <param name="config">The socket server instance config.</param>
 /// <param name="factories">The factories.</param>
 /// <returns></returns>
 public bool Setup(IBootstrap bootstrap, IServerConfig config, ProviderFactoryInfo[] factories)
 {
     m_Bootstrap = bootstrap;
     m_ServerConfig = config;
     m_Factories = factories;
     return true;
 }

        public virtual bool Setup(IBootstrap bootstrap, IServerConfig config)
        {
            Bootstrap = bootstrap;

            var loggerProvider = bootstrap as ILoggerProvider;

            if (loggerProvider != null)
                Logger = loggerProvider.Logger;

            State = ServerState.Initializing;
            Config = config;
            Name = config.Name;            
            State = ServerState.NotStarted;

            AppWorkingDir = config.Options.Get("appWorkingDir") ?? GetAppWorkingDir(Name);

            if (!Directory.Exists(AppWorkingDir))
                Directory.CreateDirectory(AppWorkingDir);

            var appConfigFilePath = GetAppConfigFile();

            // use the application's own config file if it has
            //AppRoot\AppName\App.config
            if (!string.IsNullOrEmpty(appConfigFilePath))
                StartupConfigFile = appConfigFilePath;

            m_NotStartedStatus = new Lazy<StatusInfoCollection>(() =>
                {
                    var status = new StatusInfoCollection(m_Metadata.Name);
                    status[StatusInfoKeys.IsRunning] = false;
                    return status;
                });

            return true;
        }

 protected IConfigurationSource CreateBootstrap(string configFile)
 {
     IBootstrap newBootstrap;
     var configSrc = CreateBootstrap(configFile, out newBootstrap);
     m_BootStrap = newBootstrap;
     return configSrc;
 }

        static bool ListCommand(IBootstrap bootstrap, string[] arguments)
        {
            foreach (var s in bootstrap.AppServers)
            {
                Console.WriteLine("{0} - {1}", s.Name, s.State);
            }

            return false;
        }

        public bool Setup(IBootstrap bootstrap, IServerConfig config)
        {
            Config = config;

            foreach (var item in Items)
            {
                if (!item.Setup(bootstrap, config))
                    return false;
            }

            return true;
        }

        public RemoteBootstrapProxy()
        {
            m_Bootstrap = (IBootstrap)AppDomain.CurrentDomain.GetData("Bootstrap");

            foreach (var s in m_Bootstrap.AppServers)
            {
                if (s is MarshalByRefObject)
                    m_Servers.Add(s);
                else
                    m_Servers.Add(new ServerProxy(s));
            }
        }

        public override bool Setup(IBootstrap bootstrap, IServerConfig config)
        {
            if (!base.Setup(bootstrap, config))
                return false;

            var metadata = GetMetadata() as ExternalProcessAppServerMetadata;

            var appFile = metadata.AppFile;

            if(string.IsNullOrEmpty(appFile))
            {
                OnExceptionThrown(new ArgumentNullException("appFile"));
                return false;
            }

            var workDir = AppWorkingDir;

            if (!string.IsNullOrEmpty(metadata.AppDir))
                appFile = Path.Combine(metadata.AppDir, appFile);

            if(!Path.IsPathRooted(appFile))
            {
                appFile = Path.GetFullPath(Path.Combine(AppDomain.CurrentDomain.BaseDirectory, appFile));
            }

            if (!File.Exists(appFile))
            {
                OnExceptionThrown(new FileNotFoundException("The app file was not found.", appFile));
                return false;
            }

            workDir = Path.GetDirectoryName(appFile);

            m_ExternalAppDir = workDir;

            var args = metadata.AppArgs;

            var startInfo = new ProcessStartInfo(appFile, args);
            startInfo.WorkingDirectory = workDir;
            startInfo.CreateNoWindow = true;
            startInfo.WindowStyle = ProcessWindowStyle.Hidden;
            startInfo.UseShellExecute = false;
            startInfo.RedirectStandardError = true;
            startInfo.RedirectStandardInput = true;

            m_StartInfo = startInfo;

            m_ExitCommand = config.Options.Get("exitCommand");

            m_Status = new StatusInfoCollection { Name = config.Name };

            return true;
        }

        public RemoteBootstrapProxy(IBootstrap innerBootstrap)
        {
            m_Bootstrap = innerBootstrap;
            m_ManagedApps = new List<IManagedApp>();

            foreach (var s in m_Bootstrap.AppServers)
            {
                if (s is MarshalByRefObject)
                    m_ManagedApps.Add(s);
                else
                    m_ManagedApps.Add(new ServerProxy(s));
            }
        }

        private static void OnConfigFileUpdated(string filePath, string sectionName, IBootstrap bootstrap)
        {
            var fileMap = new ExeConfigurationFileMap();
            fileMap.ExeConfigFilename = filePath;

            System.Configuration.Configuration config;

            try
            {
                config = ConfigurationManager.OpenMappedExeConfiguration(fileMap, ConfigurationUserLevel.None);
            }
            catch (Exception e)
            {
                var loggerProvider = bootstrap as ILoggerProvider;

                if (loggerProvider != null)
                {
                    var logger = loggerProvider.Logger;

                    if (logger != null)
                        logger.Error("Configuraton loading error.", e);
                }

                return;
            }

            var configSource = config.GetSection(sectionName) as IConfigurationSource;

            if (configSource == null)
                return;

            foreach (var serverConfig in configSource.Servers)
            {
                var server = bootstrap.AppServers.FirstOrDefault(x =>
                        x.Name.Equals(serverConfig.Name, StringComparison.OrdinalIgnoreCase));

                if (server == null)
                    continue;

                server.ReportPotentialConfigChange(serverConfig);
            }
        }

        public void TestActiveConnect()
        {
            StartBootstrap(DefaultServerConfig);

            IBootstrap activeServerBootstrap;
            var activeTargetServerConfig = CreateBootstrap("ActiveConnectServer.config", out activeServerBootstrap);

            Assert.IsTrue(activeServerBootstrap.Initialize());

            var serverConfig = activeTargetServerConfig.Servers.FirstOrDefault();
            var serverAddress = new IPEndPoint(IPAddress.Parse("127.0.0.1"), serverConfig.Port);

            m_ActiveServerBootstrap = AppDomain.CurrentDomain.GetData("Bootstrap") as IBootstrap;

            Assert.AreEqual(StartResult.Success, m_ActiveServerBootstrap.Start());

            var appServer = BootStrap.AppServers.FirstOrDefault() as TestServer;

            var task = appServer.ActiveConnectRemote(serverAddress);

            if (!task.Wait(5000))
            {
                Assert.Fail("Active connect the server timeout");
            }

            Assert.AreEqual(TaskStatus.RanToCompletion, task.Status);

            Assert.AreEqual(true, task.Result.Result);
            Assert.IsNotNull(task.Result.Session);

            Assert.AreEqual(1, m_ActiveServerBootstrap.AppServers.FirstOrDefault().SessionCount);

            var session = task.Result.Session as TestSession;

            var rd = new Random();
            var a = rd.Next(1, 1000);
            var b = rd.Next(1, 1000);
            session.Send("ADDR " + a + " " + b);
            Thread.Sleep(500);

            Assert.AreEqual((a + b).ToString(), RESU.Result);
        }

 public IsolationBootstrap(IConfigSource configSource)
     : base(GetSerializableConfigSource(configSource)) // make the configuration source serializable
 {
     HandleConfigSource(configSource);
     m_RemoteBootstrapWrap = new RemoteBootstrapProxy(this);
     m_RecycleTriggers = AppDomain.CurrentDomain.GetCurrentAppDomainExportProvider().GetExports<IRecycleTrigger, IProviderMetadata>();
 }

 public void Setup()
 {
     m_Bootstrap = BootstrapFactory.CreateBootstrapFromConfigFile("SuperSocket.config");
     Assert.IsTrue(m_Bootstrap.Initialize());
     m_Port = ((IAppServer) m_Bootstrap.AppServers.FirstOrDefault()).Config.Port;
     Assert.AreEqual(StartResult.Success, m_Bootstrap.Start());
 }

 public ICollection<IPointToLaceProvider> GetResponses(ICollection<IPointToLaceRequest> request)
 {
     _buildSourceChain = new CreateSourceChain();
     _bootstrap = new Initialize(new Collection<IPointToLaceProvider>(), request, _bus, _buildSourceChain);
     _bootstrap.Execute(ChainType.All);
     return _bootstrap.DataProviderResponses ?? EmptyResponse;
 }

 public void ClearBootstrap()
 {
     if(m_BootStrap != null)
     {
         m_BootStrap.Stop();
         m_BootStrap = null;
     }
 }

 protected override void OnBootstrapCleared()
 {
     if (m_ActiveServerBootstrap != null)
     {
         m_ActiveServerBootstrap.Stop();
         m_ActiveServerBootstrap = null;
         AppDomain.CurrentDomain.SetData("Bootstrap", null);
     }
 }

 public when_initializing_lace_handlers_for_ivid_request()
 {
     _command = BusFactory.WorkflowBus();
     _request = new LicensePlateRequestBuilder().ForIvid();
     _buildSourceChain = new CreateSourceChain();
     //_buildSourceChain = new CreateSourceChain(_request.GetFromRequest<IPointToLaceRequest>().Package);
     //_buildSourceChain.Build();
     _initialize = new Initialize(new Collection<IPointToLaceProvider>(),  _request, _command, _buildSourceChain);
 }

        public ICollection<IPointToLaceProvider> GetResponsesForCarId(ICollection<IPointToLaceRequest> request)
        {
            _buildSourceChain = new FakeSourceChain();
            if (_checkForDuplicateRequests.IsRequestDuplicated(request.First())) return null;

            _bootstrap = new Initialize(new Collection<IPointToLaceProvider>(), request, _bus, _buildSourceChain);
            _bootstrap.Execute(ChainType.CarId);

            return _bootstrap.DataProviderResponses;
        }

 public void ClearBootstrap()
 {
     if (m_BootStrap != null)
     {
         m_BootStrap.Stop();
         (m_BootStrap as IDisposable).Dispose();
         m_BootStrap = null;
         OnBootstrapCleared();
         GC.Collect();
         GC.WaitForFullGCComplete();
     }
 }

        public NotifyWinService()
        {
            //File.AppendAllText(@"D:\345.txt", "aa");
            InitializeComponent();
            InitConfig();
            logger.Debug("OO");
            m_Bootstrap = BootstrapFactory.CreateBootstrap();
            serviceHelper = new WcfServiceHelper();
            m_Dispacher = new System.Timers.Timer();
            m_Dispacher.Interval = 500;
            m_Dispacher.Elapsed += M_Dispacher_Elapsed;

        }

 public static void Start()
 {
     bootstrap = BootstrapFactory.CreateBootstrap();
     if (!bootstrap.Initialize())
     {
         Console.WriteLine("Failed to initialize!");
         return;
     }
     ouSrv = (OpcUserServer)bootstrap.AppServers.First();
     ouSrv.NewSessionConnected += new SessionHandler<OpcUserSession>(SessionConnected);
     ouSrv.SessionClosed += new SessionHandler<OpcUserSession, CloseReason>(SessionClosed);
     StartResult result = bootstrap.Start();
 }