Beispiel #1
0
        /// <summary>
        ///     Start a process, start the threads to read the output and send the output to the correct outputhandler
        /// </summary>
        /// <param name="executable">The executable to run</param>
        /// <param name="parameters">The parameters for the executable</param>
        /// <param name="server">The server that is being ran</param>
        /// <param name="serverDir">The directory that should be used as root for the minecraft server</param>
        /// <returns></returns>
        public static Boolean StartServer(string executable, string parameters, IMinecraftServer server,
                                          string serverDir = "")
        {
            try
            {
                if (string.IsNullOrEmpty(executable))
                {
                    return(false);
                }
                if (string.IsNullOrEmpty(parameters))
                {
                    parameters = "";
                }

                if (string.IsNullOrEmpty(serverDir))
                {
                    serverDir = Fl.SafeLocation(RequestFile.Serverdir);
                }
                FileInfo exeFileInfo = new FileInfo(executable);
                Server = server;

                RaiseServerStarting();

                ServerProcess = new Process
                {
                    StartInfo =
                        new ProcessStartInfo
                    {
                        FileName               = exeFileInfo.FullName,
                        Arguments              = parameters,
                        CreateNoWindow         = true,
                        WindowStyle            = ProcessWindowStyle.Hidden,
                        ErrorDialog            = false,
                        UseShellExecute        = false,
                        WorkingDirectory       = serverDir,
                        StandardErrorEncoding  = Encoding.Unicode,
                        StandardOutputEncoding = Encoding.Unicode,
                        RedirectStandardInput  = true,
                        RedirectStandardOutput = true,
                        RedirectStandardError  = true
                    },
                    EnableRaisingEvents = true,
                };
                // log from startinfo to ensure correct results (in case .NET would alter something)
                Logger.Log(LogLevel.Info, "ProcessHandler", "Starting new process: " + ServerProcess.StartInfo.FileName + " " + ServerProcess.StartInfo.Arguments);
                ServerProcess.Start();
                ServerProcess.Exited += HandleStop;

                StartThreads();

                RaiseServerStarted();
                return(true);
            }
            catch (Exception exception)
            {
                Logger.Log(LogLevel.Warning, "ProcessHandler", "Couldn't start server! " + executable + " " + parameters,
                           exception.Message);
                return(false);
            }
        }
Beispiel #2
0
        /// <summary>
        ///     Get a list of all available server types
        /// </summary>
        /// <returns></returns>
        internal static Dictionary <string, IMinecraftServer> GetAvailableServers()
        {
            Dictionary <string, IMinecraftServer> servers = new Dictionary <string, IMinecraftServer>();

            foreach (string entry in ListClasses())
            {
                IMinecraftServer server =
                    Activator.CreateInstance(Assembly.GetExecutingAssembly().GetType(entry)) as IMinecraftServer;

                if (server == null)
                {
                    continue;                     //if not loaded, go on
                }

                if (!servers.ContainsKey(server.Name))
                {
                    servers.Add(server.Name, server);
                }
                else
                {
                    Logger.Log(
                        LogLevel.Severe,
                        "MinecraftServerLoader",
                        "Can't add server to dictionary, duplicate name!",
                        server.Name);
                }
            }
            return(servers);
        }
        /// <summary>
        /// Handle server output, raise all events that should be raised
        /// </summary>
        /// <param name="text">output text to handle</param>
        /// <param name="server">the server that should handle the output</param>
        public static void HandleOutput(IMinecraftServer server, string text)
        {
            RaiseOutputReceivedEvent(text);

            OutputParseResult result = server.ParseOutput(text);

            RaiseOutputParsedEvent(text, result);

            switch (result.Type)
            {
            case MessageType.Info:
                RaiseInfoMessageReceivedEvent(text, result);
                break;

            case MessageType.Warning:
                RaiseWarningMessageReceivedEvent(text, result);
                break;

            case MessageType.Severe:
                RaiseSevereMessageReceivedEvent(text, result);
                break;

            case MessageType.JavaStackTrace:
                RaiseJavaStackStraceMessageReceivedEvent(text, result);
                break;

            case MessageType.JavaStatus:
                RaiseJavaStatusMessageReceivedEvent(text, result);
                break;

            case MessageType.PlayerJoin:
                RaisePlayerJoinEvent(text, result, result.Action);
                break;

            case MessageType.PlayerLeave:
                RaisePlayerLeaveEvent(text, result, result.Action);
                break;

            case MessageType.PlayerKick:
                RaisePlayerKickEvent(text, result, result.Action);
                break;

            case MessageType.PlayerBan:
                RaisePlayerBanEvent(text, result, result.Action);
                break;

            case MessageType.PlayerIpBan:
                RaisePlayerIpBanEvent(text, result, result.Action);
                break;

            case MessageType.PlayerList:
                PlayerListReceived(text, result, new Dictionary <string, string>());
                break;

            default:
                RaiseUnknownMessageReceivedEvent(text, result);
                break;
            }
        }
Beispiel #4
0
        /// <summary>
        ///     Launch a new server
        /// </summary>
        /// <param name="server">the server type that will be executed</param>
        /// <param name="customSettingsControl">The custom settings control that is filled out</param>
        public void LaunchServer(IMinecraftServer server, UserControl customSettingsControl)
        {
            server.PrepareLaunch();
            string parameters = server.GetLaunchParameters();
            string executable = server.CustomAssembly;

            ProcessHandler.StartServer(executable, parameters, server);
        }
Beispiel #5
0
        /// <summary>
        ///     Launch the server, get all settings from
        /// </summary>
        public void DoServerLaunch(Boolean automated = false)
        {
            if (InvokeRequired)
            {
                Invoke((MethodInvoker)(() => DoServerLaunch(automated)));
            }
            else
            {
                ConsoleTab.Reference.MCCOut.Clear();

                if (!ValidateInput())
                {
                    MetroMessageBox.Show(FindForm(),
                                         "The server could not be started: one or more settings are incorrect. See the starter tab for more details",
                                         "Server could not be started", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    return;
                }

                IMinecraftServer server  = GetSelectedServer();
                Starter          starter = ParentAddon as Starter;

                Logger.Log(LogLevel.Info, "StarterTab", "starting server: " + server.Name);

                // We need access to a starter object (the parent)
                if (starter == null)
                {
                    Logger.Log(LogLevel.Severe, "StarterTab", "Failed to start server", "No starter object found");
                    return;
                }

                // Auto update
                if (CBUpdateBehaviour.SelectedIndex > 0)
                {
                    CheckAutoUpdate();
                }


                if (!server.HasCustomAssembly)
                {
                    starter.LaunchServer(
                        server,
                        GetSelectedJavaVersion(),
                        TxtJarFile.Text,
                        Convert.ToUInt32(NumMinRam.Value),
                        Convert.ToUInt32(NumMaxRam.Value),
                        TxtOptArg.Text,
                        TxtOptFlag.Text,
                        automated);
                }
                else
                {
                    starter.LaunchServer(server, _customControl);
                }
            }
        }
Beispiel #6
0
        /// <summary>
        ///     Launch a new server
        /// </summary>
        /// <param name="server">the server type that will be executed</param>
        /// <param name="javaVersion">the java version to use</param>
        /// <param name="jarFile">the jar file to run</param>
        /// <param name="minMem">the minimum amount of memory to set</param>
        /// <param name="maxMem">the maximum amount of memory to set</param>
        /// <param name="defaultParameters">the parameters entered by the user (optional)</param>
        /// <param name="defaultFlags">the flags entered by the user (optional)</param>
        public void LaunchServer(IMinecraftServer server, JavaVersion javaVersion, string jarFile, UInt32 minMem,
                                 UInt32 maxMem, string defaultParameters = "", string defaultFlags = "")
        {
            server.PrepareLaunch();
            string parameters = server.GetLaunchParameters(defaultParameters);
            string flags      = server.GetLaunchFlags(defaultFlags);
            string argument   = parameters + " -Xms" + minMem + "M -Xmx" + maxMem + "M -jar \"" + jarFile + "\" " + flags;
            string executable = JavaApi.GetJavaPath(javaVersion);

            ProcessHandler.StartServer(executable, argument, server);
        }
        /// <summary>
        ///     Start a process, start the threads to read the output and send the output to the correct outputhandler
        /// </summary>
        /// <param name="executable">The executable to run</param>
        /// <param name="parameters">The parameters for the executable</param>
        /// <param name="server">The server that is being ran</param>
        /// <param name="serverDir">The directory that should be used as root for the minecraft server</param>
        /// <returns></returns>
        public static Boolean StartServer(string executable, string parameters, IMinecraftServer server, string serverDir = "")
        {
            if (string.IsNullOrEmpty(executable))
            {
                return(false);
            }

            Server = server;

            FileInfo exeFileInfo = new FileInfo(executable);

            RaiseServerStarting();

            if (string.IsNullOrEmpty(serverDir))
            {
                serverDir = Environment.CurrentDirectory;
                FileInfo guiFileInfo = new FileInfo(Share.AssemblyFullName);
                if (guiFileInfo.Directory != null)
                {
                    serverDir = guiFileInfo.Directory.FullName;
                }
            }

            ServerProcess = new Process
            {
                StartInfo =
                    new ProcessStartInfo
                {
                    FileName               = exeFileInfo.FullName,
                    Arguments              = parameters,
                    CreateNoWindow         = true,
                    WindowStyle            = ProcessWindowStyle.Hidden,
                    ErrorDialog            = false,
                    UseShellExecute        = false,
                    WorkingDirectory       = serverDir,
                    StandardErrorEncoding  = Encoding.Unicode,
                    StandardOutputEncoding = Encoding.Unicode,
                    RedirectStandardInput  = true,
                    RedirectStandardOutput = true,
                    RedirectStandardError  = true
                }
            };
            ServerProcess.EnableRaisingEvents = true;
            ServerProcess.Start();
            ServerProcess.Exited += HandleStop;

            StartThreads();

            IsRunning = true;
            RaiseServerStarted();
            return(true);
        }
Beispiel #8
0
        /// <summary>
        ///     Load all settings/buttons for a selected server
        /// </summary>
        private void LoadServer()
        {
            GBServer.UseWaitCursor = true;

            IMinecraftServer server = GetSelectedServer();

            if (server == null)
            {
                return;
            }

            Logger.Log(LogLevel.Info, "StarterTab", "Loading server: " + server.Name);

            // If this server doesn't use a custom assembly, use the java settings
            CBJavaVersion.Enabled = !server.HasCustomAssembly;
            NumMaxRam.Enabled     = !server.HasCustomAssembly;
            NumMinRam.Enabled     = !server.HasCustomAssembly;
            TBMaxRam.Enabled      = !server.HasCustomAssembly;
            TBMinRam.Enabled      = !server.HasCustomAssembly;
            TxtOptArg.Enabled     = !server.HasCustomAssembly;
            TxtOptFlag.Enabled    = !server.HasCustomAssembly;
            TxtJarFile.Enabled    = !server.HasCustomAssembly;

            // If there is a custom settings control, load it
            if (server.HasCustomSettingsControl)
            {
                _customControl = server.CustomSettingsControl;
                GBCustomSettings.Controls.Clear();
                GBCustomSettings.Controls.Add(_customControl);
                GBCustomSettings.Controls[0].Dock = DockStyle.Fill;
            }
            else
            {
                _customControl = null;
                GBCustomSettings.Controls.Clear();
            }

            GBServer.UseWaitCursor = false;
            Logger.Log(LogLevel.Info, "StarterTab", "Loaded server: " + server.Name);
        }
Beispiel #9
0
        /// <summary>
        ///     Launch the server, get all settings from
        /// </summary>
        public void DoServerLaunch()
        {
            IMinecraftServer server  = this.GetSelectedServer();
            Starter          starter = this.ParentAddon as Starter;

            Logger.Log(LogLevel.Info, "StarterTab", "starting server: " + server.Name);

            // We need access to a starter object (the parent)
            if (starter == null)
            {
                Logger.Log(LogLevel.Severe, "StarterTab", "Failed to start server", "No starter object found");
                return;
            }

            // If invalid input, stop
            if (!this.ValidateInput())
            {
                return;
            }

            if (!server.HasCustomAssembly)
            {
                starter.LaunchServer(
                    server,
                    this.GetSelectedJavaVersion(),
                    this.TxtJarFile.Text,
                    Convert.ToUInt32(this.NumMinRam.Value),
                    Convert.ToUInt32(this.NumMaxRam.Value),
                    this.TxtOptArg.Text,
                    this.TxtOptFlag.Text);
            }
            else
            {
                starter.LaunchServer(server, server.CustomAssembly, this._customControl);
            }
        }
Beispiel #10
0
 /// <summary>
 ///     Launch a new server
 /// </summary>
 /// <param name="server">the server type that will be executed</param>
 /// <param name="customAssembly">the custom assembly that will be executed, absolute path recommended</param>
 /// <param name="customSettingsControl">The custom settings control that is filled out</param>
 public void LaunchServer(IMinecraftServer server, Assembly customAssembly, UserControl customSettingsControl)
 {
 }
Beispiel #11
0
        private void CheckAutoUpdate()
        {
            try
            {
                if (InvokeRequired)
                {
                    Invoke((MethodInvoker)(CheckAutoUpdate));
                }
                else
                {
                    if (CBUpdateBehaviour.SelectedIndex < 1)
                    {
                        return;
                    }
                    if (CBUpdateBranch.SelectedItem == null ||
                        string.IsNullOrEmpty(CBUpdateBranch.SelectedItem.ToString()))
                    {
                        return;
                    }

                    ProcessHandler.SetStatusStarting();                     // already show that the server is starting
                    ConsoleTab.WriteOut("__________________________________________________________________");
                    ConsoleTab.WriteOut("Performing version check... Branch: " + CBUpdateBranch.SelectedItem);

                    IMinecraftServer server         = GetSelectedServer();
                    string           currentversion = server.GetCurrentVersion(TxtJarFile.Text);
                    ConsoleTab.WriteOut("Performing version check... Current version: " + currentversion);

                    string latestversion = "";

                    if (CBUpdateBranch.SelectedItem.ToString().ToLower().Contains("recommended"))
                    {
                        latestversion = server.FetchRecommendedVersion;
                    }
                    if (CBUpdateBranch.SelectedItem.ToString().ToLower().Contains("beta"))
                    {
                        latestversion = server.FetchBetaVersion;
                    }
                    if (CBUpdateBranch.SelectedItem.ToString().ToLower().Contains("dev"))
                    {
                        latestversion = server.FetchDevVersion;
                    }
                    ConsoleTab.WriteOut("Performing version check... Latest version: " + latestversion);

                    switch (CBUpdateBehaviour.SelectedIndex)
                    {
                    case 1:                             // Notify

                        if (int.Parse(latestversion) > int.Parse(currentversion))
                        {
                            ConsoleTab.WriteOut("A new server version is available for " + server.Name);
                            ConsoleTab.WriteOut(
                                "Download the latest version in the starter tab. The latest version is #" +
                                latestversion);

                            Thread t = new Thread(() =>
                                                  MetroMessageBox.Show(FindForm(),
                                                                       "A new server version is available for " + server.Name + "." +
                                                                       Environment.NewLine +
                                                                       "Download the latest version in the starter tab. The latest version is #" +
                                                                       latestversion,
                                                                       "Server update available",
                                                                       MessageBoxButtons.OK, MessageBoxIcon.Information)
                                                  );
                            t.Start();
                        }
                        break;

                    case 2:                             // Auto update
                        if (int.Parse(latestversion) > int.Parse(currentversion))
                        {
                            ConsoleTab.WriteOut("New server version available: #" + latestversion +
                                                ". This version will be installed automaticly. You can disable this in the starter tab.");
                            if (CBUpdateBranch.SelectedItem.ToString().ToLower().Contains("recommended"))
                            {
                                server.DownloadRecommendedVersion(TxtJarFile.Text);
                            }
                            if (CBUpdateBranch.SelectedItem.ToString().ToLower().Contains("beta"))
                            {
                                server.DownloadBetaVersion(TxtJarFile.Text);
                            }
                            if (CBUpdateBranch.SelectedItem.ToString().ToLower().Contains("dev"))
                            {
                                server.DownloadDevVersion(TxtJarFile.Text);
                            }
                            ConsoleTab.WriteOut("New server version installed.");
                        }
                        break;
                    }
                    ConsoleTab.WriteOut("Finished update check. Starting server...");
                    ConsoleTab.WriteOut("__________________________________________________________________");
                }
            }
            catch (Exception exception)
            {
                Logger.Log(LogLevel.Severe, "StarterTab",
                           "Failed to complete auto-update check for " + GetSelectedServer(), exception.Message);
            }
        }
        /// <summary>
        ///     Start a process, start the threads to read the output and send the output to the correct outputhandler
        /// </summary>
        /// <param name="executable">The executable to run</param>
        /// <param name="parameters">The parameters for the executable</param>
        /// <param name="server">The server that is being ran</param>
        /// <param name="serverDir">The directory that should be used as root for the minecraft server</param>
        /// <returns></returns>
        public static Boolean StartServer(string executable, string parameters, IMinecraftServer server,
			string serverDir = "")
        {
            try
            {
                if (string.IsNullOrEmpty(executable)) return false;
                if (string.IsNullOrEmpty(parameters)) parameters = "";

                if (string.IsNullOrEmpty(serverDir))
                {
                    serverDir = Fl.SafeLocation(RequestFile.Serverdir);
                }
                FileInfo exeFileInfo = new FileInfo(executable);
                Server = server;

                RaiseServerStarting();

                ServerProcess = new Process
                {
                    StartInfo =
                        new ProcessStartInfo
                        {
                            FileName = exeFileInfo.FullName,
                            Arguments = parameters,
                            CreateNoWindow = true,
                            WindowStyle = ProcessWindowStyle.Hidden,
                            ErrorDialog = false,
                            UseShellExecute = false,
                            WorkingDirectory = serverDir,
                            StandardErrorEncoding = Encoding.Unicode,
                            StandardOutputEncoding = Encoding.Unicode,
                            RedirectStandardInput = true,
                            RedirectStandardOutput = true,
                            RedirectStandardError = true
                        },
                    EnableRaisingEvents = true
                };
                // log from startinfo to ensure correct results (in case .NET would alter something)
                Logger.Log(LogLevel.Info, "ProcessHandler",
                    "Starting new process: " + ServerProcess.StartInfo.FileName + " " + ServerProcess.StartInfo.Arguments);
                ServerProcess.Start();
                ServerProcess.Exited += HandleStop;

                StartThreads();

                RaiseServerStarted();
                return true;
            }
            catch (Exception exception)
            {
                Logger.Log(LogLevel.Warning, "ProcessHandler", "Couldn't start server! " + executable + " " + parameters,
                    exception.Message);
                return false;
            }
        }
Beispiel #13
0
        /// <summary>
        ///     Load all settings/buttons for a selected server
        /// </summary>
        private void LoadServer()
        {
            GBServer.UseWaitCursor       = true;
            GBMaintainance.UseWaitCursor = true;

            IMinecraftServer server = GetSelectedServer();

            if (server == null)
            {
                return;
            }

            Logger.Log(LogLevel.Info, "StarterTab", "Loading server: " + server.Name);

            PBServerLogo.Image = server.Logo;
            LLblSite.Text      = "Site: " + server.Site;

            // Enable buttons as needed
            BtnDownloadRec.Enabled     = server.CanDownloadRecommendedVersion;
            BtnDownloadBeta.Enabled    = server.CanDownloadBetaVersion;
            BtnDownloadDev.Enabled     = server.CanDownloadDevVersion;
            btnGetCurrentBuild.Enabled = server.CanGetCurrentVersion;

            // If this server doesn't use a custom assembly, use the java settings
            CBJavaVersion.Enabled = !server.HasCustomAssembly;
            NumMaxRam.Enabled     = !server.HasCustomAssembly;
            NumMinRam.Enabled     = !server.HasCustomAssembly;
            TBMaxRam.Enabled      = !server.HasCustomAssembly;
            TBMinRam.Enabled      = !server.HasCustomAssembly;
            TxtOptArg.Enabled     = !server.HasCustomAssembly;
            TxtOptFlag.Enabled    = !server.HasCustomAssembly;
            TxtJarFile.Enabled    = !server.HasCustomAssembly;

            //Enable possible update settings
            //Notify needs getting the current and the latest version
            Boolean notifyRb = server.CanGetCurrentVersion && server.CanFetchRecommendedVersion;

            Boolean notifyBeta = server.CanGetCurrentVersion && server.CanFetchBetaVersion;

            Boolean notifyDev = server.CanGetCurrentVersion && server.CanFetchDevVersion;

            // Updating also needs the possibility to download
            Boolean updateRb = notifyRb && server.CanDownloadRecommendedVersion;

            Boolean updateBeta = notifyBeta && server.CanDownloadBetaVersion;

            Boolean updateDev = notifyDev && server.CanDownloadDevVersion;

            LblLatestDevValue.Text = "Not available";
            if (server.CanFetchDevVersion)
            {
                LblLatestDevValue.Text = server.FetchDevVersionUiString;
            }
            metroToolTip.SetToolTip(LblLatestDevValue, LblLatestDevValue.Text);

            LblLatestBetaValue.Text = "Not available";
            if (server.CanFetchBetaVersion)
            {
                LblLatestBetaValue.Text = server.FetchBetaVersionUiString;
            }
            metroToolTip.SetToolTip(LblLatestBetaValue, LblLatestBetaValue.Text);

            LblLatestRecommendedValue.Text = "Not available";
            if (server.CanFetchRecommendedVersion)
            {
                LblLatestRecommendedValue.Text = server.FetchRecommendedVersionUiString;
            }
            metroToolTip.SetToolTip(LblLatestRecommendedValue, LblLatestRecommendedValue.Text);

            CBUpdateBehaviour.Items.Clear();
            CBUpdateBehaviour.Items.Add("Don't check for updates");
            //
            // DO NOT TRANSLATE BELOW
            //

            if (notifyRb || notifyBeta || notifyDev)
            {
                CBUpdateBehaviour.Items.Add("Check for updates and notify me");
            }
            if (updateRb || updateBeta || updateDev)
            {
                CBUpdateBehaviour.Items.Add("Check for updates and auto update");
            }

            //
            // DO NOT TRANSLATE ABOVE
            //
            int updatebehaviour = Config.ReadInt("starter", "updatebehaviour", 0);

            CBUpdateBehaviour.SelectedIndex = 0;
            if (CBUpdateBehaviour.Items.Count > updatebehaviour)
            {
                CBUpdateBehaviour.SelectedIndex = updatebehaviour;
            }
            CBUpdateBranch.Items.Clear();

            //
            // DO NOT TRANSLATE BELOW
            //

            if (notifyRb)
            {
                CBUpdateBranch.Items.Add("Recommended builds");
            }
            if (notifyBeta)
            {
                CBUpdateBranch.Items.Add("Beta builds");
            }
            if (notifyDev)
            {
                CBUpdateBranch.Items.Add("Development builds");
            }

            //
            // DO NOT TRANSLATE ABOVE
            //
            int updatebranch = Config.ReadInt("starter", "updatebranch", 0);

            if (CBUpdateBranch.Items.Count > 0)
            {
                CBUpdateBranch.SelectedIndex = 0;
            }
            if (CBUpdateBranch.Items.Count > updatebranch)
            {
                CBUpdateBranch.SelectedIndex = updatebranch;
            }

            // If there is a custom settings control, load it
            if (server.HasCustomSettingsControl)
            {
                _customControl = server.CustomSettingsControl;
                GBCustomSettings.Controls.Clear();
                GBCustomSettings.Controls.Add(_customControl);
                GBCustomSettings.Controls[0].Dock = DockStyle.Fill;
            }
            else
            {
                _customControl = null;
                GBCustomSettings.Controls.Clear();
            }

            GBServer.UseWaitCursor       = false;
            GBMaintainance.UseWaitCursor = false;
            Logger.Log(LogLevel.Info, "StarterTab", "Loaded server: " + server.Name);
        }
Beispiel #14
0
		/// <summary>
		///     Launch a new server
		/// </summary>
		/// <param name="server">the server type that will be executed</param>
		/// <param name="javaVersion">the java version to use</param>
		/// <param name="jarFile">the jar file to run</param>
		/// <param name="minMem">the minimum amount of memory to set</param>
		/// <param name="maxMem">the maximum amount of memory to set</param>
		/// <param name="defaultParameters">the parameters entered by the user (optional)</param>
		/// <param name="defaultFlags">the flags entered by the user (optional)</param>
		/// <param name="automated">
		///     If this is an automated launch. Automated launches won't check for server updates and limit
		///     popups.
		/// </param>
		public void LaunchServer(IMinecraftServer server, JavaVersion javaVersion, string jarFile, UInt32 minMem,
			UInt32 maxMem, string defaultParameters = "", string defaultFlags = "", Boolean automated = false)
		{
			server.PrepareLaunch();
			string parameters = server.GetLaunchParameters(defaultParameters);
			string flags = server.GetLaunchFlags(defaultFlags);
			string argument = parameters + " -Xms" + minMem + "M -Xmx" + maxMem + "M -jar \"" + jarFile + "\" " + flags;
			string executable = JavaApi.GetJavaPath(javaVersion);

			ProcessHandler.StartServer(executable, argument, server);
		}
		/// <summary>
		///     Handle server output, raise all events that should be raised
		/// </summary>
		/// <param name="text">output text to handle</param>
		/// <param name="server">the server that should handle the output</param>
		/// <param name="fromStandardErrorOut">Is this message received on the error stream?</param>
		public static void HandleOutput(IMinecraftServer server, string text, Boolean fromStandardErrorOut = false)
		{
			RaiseOutputReceivedEvent(text);

			OutputParseResult result = server.ParseOutput(text);
			if (result == null) return;

			RaiseOutputParsedEvent(text, result);

			switch (result.Type)
			{
				case MessageType.Info:
					RaiseInfoMessageReceivedEvent(text, result);

					// detect an issued stop command (so the GUI knows this isn't a crash)
					if (result.Message == "[INFO] Stopping server" || result.Message == "[INFO] Stopping the server")
						ProcessHandler.ProcessHandler.MarkServerAsStopping();

					break;

				case MessageType.Warning:
					RaiseWarningMessageReceivedEvent(text, result);
					CheckErrorCause(result.Message);
					//failed to bind to port comes on standardout, so we need to check anyway
					break;

				case MessageType.Severe:
					RaiseSevereMessageReceivedEvent(text, result);
					CheckErrorCause(result.Message);
					break;

				case MessageType.JavaStackTrace:
					RaiseJavaStackStraceMessageReceivedEvent(text, result);
					if (fromStandardErrorOut) CheckErrorCause(result.Message);
					break;
				case MessageType.JavaStatus:
					RaiseJavaStatusMessageReceivedEvent(text, result);
					if (fromStandardErrorOut) CheckErrorCause(result.Message);
					break;
				case MessageType.PlayerJoin:
					RaisePlayerJoinEvent(text, result, result.Action);
					break;
				case MessageType.PlayerLeave:
					RaisePlayerLeaveEvent(text, result, result.Action);
					break;
				case MessageType.PlayerKick:
					RaisePlayerKickEvent(text, result, result.Action);
					break;
				case MessageType.PlayerBan:
					RaisePlayerBanEvent(text, result, result.Action);
					break;
				case MessageType.PlayerIpBan:
					RaisePlayerIpBanEvent(text, result, result.Action);
					break;
				case MessageType.PlayerList:
					RaisePlayerListReceivedEvent(text, result, new Dictionary<string, string>());
					break;
				default:
					RaiseUnknownMessageReceivedEvent(text, result);
					if (fromStandardErrorOut) CheckErrorCause(result.Message);
					break;
			}
		}
Beispiel #16
0
        /// <summary>
        ///     Handle server output, raise all events that should be raised
        /// </summary>
        /// <param name="text">output text to handle</param>
        /// <param name="server">the server that should handle the output</param>
        /// <param name="fromStandardErrorOut">Is this message received on the error stream?</param>
        public static void HandleOutput(IMinecraftServer server, string text, Boolean fromStandardErrorOut = false)
        {
            RaiseOutputReceivedEvent(text);

            OutputParseResult result = server.ParseOutput(text);

            if (result == null)
            {
                return;
            }

            RaiseOutputParsedEvent(text, result);

            switch (result.Type)
            {
            case MessageType.Info:
                RaiseInfoMessageReceivedEvent(text, result);

                // detect an issued stop command (so the GUI knows this isn't a crash)
                if (result.Message == "[INFO] Stopping server" || result.Message == "[INFO] Stopping the server")
                {
                    ProcessHandler.ProcessHandler.MarkServerAsStopping();
                }

                break;

            case MessageType.Warning:
                RaiseWarningMessageReceivedEvent(text, result);
                CheckErrorCause(result.Message);
                //failed to bind to port comes on standardout, so we need to check anyway
                break;

            case MessageType.Severe:
                RaiseSevereMessageReceivedEvent(text, result);
                CheckErrorCause(result.Message);
                break;

            case MessageType.JavaStackTrace:
                RaiseJavaStackStraceMessageReceivedEvent(text, result);
                if (fromStandardErrorOut)
                {
                    CheckErrorCause(result.Message);
                }
                break;

            case MessageType.JavaStatus:
                RaiseJavaStatusMessageReceivedEvent(text, result);
                if (fromStandardErrorOut)
                {
                    CheckErrorCause(result.Message);
                }
                break;

            case MessageType.PlayerJoin:
                RaisePlayerJoinEvent(text, result, result.Action);
                break;

            case MessageType.PlayerLeave:
                RaisePlayerLeaveEvent(text, result, result.Action);
                break;

            case MessageType.PlayerKick:
                RaisePlayerKickEvent(text, result, result.Action);
                break;

            case MessageType.PlayerBan:
                RaisePlayerBanEvent(text, result, result.Action);
                break;

            case MessageType.PlayerIpBan:
                RaisePlayerIpBanEvent(text, result, result.Action);
                break;

            case MessageType.PlayerList:
                RaisePlayerListReceivedEvent(text, result, new Dictionary <string, string>());
                break;

            default:
                RaiseUnknownMessageReceivedEvent(text, result);
                if (fromStandardErrorOut)
                {
                    CheckErrorCause(result.Message);
                }
                break;
            }
        }
Beispiel #17
0
        /// <summary>
        ///     Load all settings/buttons for a selected server
        /// </summary>
        private void LoadServer()
        {
            IMinecraftServer server = this.GetSelectedServer();

            Logger.Log(LogLevel.Info, "StarterTab", "Loading server: " + server.Name);

            this.PBServerLogo.Image = server.Logo;
            this.LLblSite.Text      = "Site: " + server.Site;

            // Enable buttons as needed
            this.BtnDownloadRec.Enabled  = server.CanDownloadRecommendedVersion;
            this.BtnDownloadBeta.Enabled = server.CanDownloadBetaVersion;
            this.BtnDownloadDev.Enabled  = server.CanDownloadDevVersion;

            // If this server doesn't use a custom assembly, use the java settings
            this.CBJavaVersion.Enabled = !server.HasCustomAssembly;
            this.NumMaxRam.Enabled     = !server.HasCustomAssembly;
            this.NumMinRam.Enabled     = !server.HasCustomAssembly;
            this.TBMaxRam.Enabled      = !server.HasCustomAssembly;
            this.TBMinRam.Enabled      = !server.HasCustomAssembly;
            this.TxtOptArg.Enabled     = !server.HasCustomAssembly;
            this.TxtOptFlag.Enabled    = !server.HasCustomAssembly;
            this.TxtJarFile.Enabled    = !server.HasCustomAssembly;

            //Enable possible update settings
            //Notify needs getting the current and the latest version
            Boolean notifyRb = server.CanGetCurrentVersion && server.CanFetchRecommendedVersion;

            Boolean notifyBeta = server.CanGetCurrentVersion && server.CanFetchBetaVersion;

            Boolean notifyDev = server.CanGetCurrentVersion && server.CanFetchDevVersion;

            // Updating also needs the possibility to download
            Boolean updateRb = server.CanGetCurrentVersion && server.CanDownloadRecommendedVersion &&
                               server.CanFetchRecommendedVersion;

            Boolean updateBeta = server.CanGetCurrentVersion && server.CanDownloadBetaVersion &&
                                 server.CanFetchBetaVersion;

            Boolean updateDev = server.CanGetCurrentVersion && server.CanDownloadDevVersion && server.CanFetchDevVersion;

            this.CBUpdateBehaviour.Items.Clear();
            this.CBUpdateBehaviour.Items.Add("Don't check for updates");
            this.CBUpdateBehaviour.SelectedIndex = 0;

            if (notifyRb || notifyBeta || notifyDev)
            {
                this.CBUpdateBehaviour.Items.Add("Check for updates and notify me");
            }
            if (updateRb || updateBeta || updateDev)
            {
                this.CBUpdateBehaviour.Items.Add("Check for updates and auto update");
            }

            this.CBUpdateBranch.Items.Clear();

            if (updateRb)
            {
                this.CBUpdateBranch.Items.Add("Recommended builds");
            }
            if (updateBeta)
            {
                this.CBUpdateBranch.Items.Add("Beta builds");
            }
            if (updateDev)
            {
                this.CBUpdateBranch.Items.Add("Development builds");
            }

            // If there is a custom settings control, load it
            if (server.HasCustomSettingsControl)
            {
                this._customControl = server.CustomSettingsControl;
                this.GBCustomSettings.Controls.Clear();
                this.GBCustomSettings.Controls.Add(this._customControl);
                this.GBCustomSettings.Controls[0].Dock = DockStyle.Fill;
            }
            else
            {
                this._customControl = null;
                this.GBCustomSettings.Controls.Clear();
            }

            Logger.Log(LogLevel.Info, "StarterTab", "Loaded server: " + server.Name);
        }
Beispiel #18
0
		/// <summary>
		///     Launch a new server
		/// </summary>
		/// <param name="server">the server type that will be executed</param>
		/// <param name="customSettingsControl">The custom settings control that is filled out</param>
		public void LaunchServer(IMinecraftServer server, UserControl customSettingsControl)
		{
			server.PrepareLaunch();
			string parameters = server.GetLaunchParameters();
			string executable = server.CustomAssembly;
			ProcessHandler.StartServer(executable, parameters, server);
		}