private ServerStartStatus StartInstanceAsProcessWithExtendedStatus()

in Configurator/Core/Server/MySqlServerInstance.cs [1804:1928]
117 lines of code
30 McCabe index (conditional complexity)

    private ServerStartStatus StartInstanceAsProcessWithExtendedStatus(string additionalOptions = null, bool connectionsWaitReportStatus = false)
    {
      var startStatus = new ServerStartStatus(false);
      if (IsRunning)
      {
        startStatus.Started = true;
        return startStatus;
      }

      if (string.IsNullOrEmpty(ServerExecutableFilePath)
          || string.IsNullOrEmpty(ServerConfigFilePath))
      {
        startStatus.Started = false;
        return startStatus;
      }

      ReportStatus(string.Format(Resources.ServerConfigProcessStartingText, NameWithVersion));
      var isAdditionalOptionEmpty = string.IsNullOrEmpty(additionalOptions);
      var isSelfContainedUpgrade = !isAdditionalOptionEmpty
                                   && additionalOptions.IndexOf("--upgrade", StringComparison.InvariantCultureIgnoreCase) >= 0;
      var isInitializingDatabase = !isAdditionalOptionEmpty
                                   && additionalOptions.IndexOf("--initialize", StringComparison.InvariantCultureIgnoreCase) >= 0;
      var redirectOutputToConsole = !isSelfContainedUpgrade
                                    && ReportStatusDelegate != null;
      var coreOptionsBuilder = new StringBuilder();
      if (File.Exists(ServerConfigFilePath))
      {
        coreOptionsBuilder.Append("--defaults-file=\"");
        coreOptionsBuilder.Append(ServerConfigFilePath);
        coreOptionsBuilder.Append("\"");
      }
      else
      {
        coreOptionsBuilder.Append("--port=");
        coreOptionsBuilder.Append(Port);
        if (!string.IsNullOrEmpty(_controller.DataDirectory))
        {
          coreOptionsBuilder.Append(" --datadir=\"");
          coreOptionsBuilder.Append(Path.Combine(_controller.DataDirectory, "data"));
          coreOptionsBuilder.Append("\"");
        }
      }

      // Initialize the async task that will parse the error log in case of a self-contained upgrade or in case of parsing the error log file to determine if the server is accepting connections
      Task<ServerUpgradeStatus> parsingLogForUpgradeTask = null;
      Task<bool> parsingLogForAcceptingConnectionsTask = null;
      ServerErrorLog mySqlErrorLog = null;
      var parseErrorLog = isSelfContainedUpgrade
                          || ParseErrorLogForAcceptingConnections
                             && WaitUntilAcceptingConnections;
      if (parseErrorLog)
      {
        _controller.UseStatusesList = redirectOutputToConsole;
        mySqlErrorLog = new ServerErrorLog(_controller.ErrorLogFilePath, redirectOutputToConsole ? _controller.StatusesList : null)
        {
          ReportStatusDelegate = ReportStatus,
          ReportWaitingDelegate = _controller.ReportWaiting
        };
        if (isSelfContainedUpgrade)
        {
          parsingLogForUpgradeTask = Task.Factory.StartNew(() => mySqlErrorLog.ParseServerUpgradeMessages(_controller.ServerVersion), _controller.CancellationToken);
        }
        else
        {
          parsingLogForAcceptingConnectionsTask = Task.Factory.StartNew(() => mySqlErrorLog.ParseServerAcceptingConnectionMessage(_controller.ServerVersion, !redirectOutputToConsole), _controller.CancellationToken);
        }
      }

      var consoleOption = redirectOutputToConsole
        ? " --console"
        : string.Empty;
      if (!string.IsNullOrEmpty(additionalOptions))
      {
        additionalOptions = " " + additionalOptions;
      }

      var processResult = Base.Classes.Utilities.RunProcess(
        ServerExecutableFilePath,
        $"{coreOptionsBuilder}{consoleOption}{additionalOptions}",
        null,
        ReportStatus,
        ReportStatus,
        isInitializingDatabase);
      startStatus.Started = processResult != null
                            && (isInitializingDatabase
                              ? processResult.ExitCode == 0
                              : processResult.RunProcess != null
                                && !processResult.RunProcess.HasExited);
      ReportStatus(string.Format(startStatus.Started ? Resources.ServerConfigProcessStartedSuccessfullyText : Resources.ServerConfigProcessStartFailedText, NameWithVersion));
      if (startStatus.Started
          && parseErrorLog)
      {
        if (isSelfContainedUpgrade)
        {
          parsingLogForUpgradeTask.Wait(_controller.CancellationToken);
          startStatus.UpgradeStatus = parsingLogForUpgradeTask.IsCompleted
            ? parsingLogForUpgradeTask.Result
            : new ServerUpgradeStatus();
          startStatus.AcceptingConnections = startStatus.UpgradeStatus.AcceptingConnections;
        }
        else
        {
          parsingLogForAcceptingConnectionsTask.Wait(_controller.CancellationToken);
          startStatus.AcceptingConnections = parsingLogForAcceptingConnectionsTask.IsCompleted
                                             && parsingLogForAcceptingConnectionsTask.Result;
        }
      }
      else if (parseErrorLog)
      {
        ReportServerStartErrors(mySqlErrorLog.LogLines);
      }

      if (WaitUntilAcceptingConnections
          && startStatus.Started
          && (!parseErrorLog
              || !startStatus.AcceptingConnections))
      {
        startStatus.AcceptingConnections = WaitUntilConnectionSuccessful(connectionsWaitReportStatus);
      }

      _controller.UseStatusesList = false;
      parsingLogForUpgradeTask?.Dispose();
      parsingLogForAcceptingConnectionsTask?.Dispose();
      return startStatus;
    }