private void OnControlPlanCancel(object sender, ServerCommandEventArgs e)
{
string planType = e.Command.GetArgumentValue <string>("planType");
Int32 planId = e.Command.GetArgumentValue <Int32>("planId");
if (!IsPlanRunning(planType, planId))
{
string msg = Commands.ReportError(0, "{0} plan #{1} is not running", planType.ToTitleCase(), planId);
Handler.Send(e.Context, msg);
return;
}
// Send to executor
string executorClientName = Commands.BuildClientName(planType, planId);
ClientState executor = Handler.GetClientState(executorClientName);
if (executor == null)
{
string msg = Commands.ReportError(0, "Executor for {0} plan #{1} doesn't seem to be running",
planType.ToTitleCase(), planId);
Handler.Send(e.Context, msg);
return;
}
Handler.Send(executor.Context, Commands.ExecutorCancelPlan());
}
public void HandleConsoleCommand(string msg)
{
CommandSender sender = new ConsoleSender();
ServerCommandEventArgs serverCommandEvent = new ServerCommandEventArgs(sender, msg);
ServerEvents.OnServerCommand(serverCommandEvent);
if (serverCommandEvent.IsCancel)
{
return;
}
string[] args = serverCommandEvent.Message.Split(' ');
string cmd = args[0];
if (args.Length != 1)
{
List <string> tmp = new List <string>(args);
tmp.RemoveAt(0);
args = tmp.ToArray();
}
else
{
args = new string[0];
}
this.CommandHandler.CommandHandle(sender, cmd, args);
}
private void OnControlPlanResume(object sender, ServerCommandEventArgs e)
{
string planType = e.Command.GetArgumentValue <string>("planType");
Int32 planId = e.Command.GetArgumentValue <Int32>("planId");
if (IsPlanRunning(planType, planId))
{
string msg = Commands.ReportError(0, "{0} plan #{1} is already running", planType.ToTitleCase(), planId);
Handler.Send(e.Context, msg);
return;
}
bool isBackup = planType.Equals(PlanTypeEnum.BACKUP.ToString().ToLowerInvariant());
bool isRestore = planType.Equals(PlanTypeEnum.RESTORE.ToString().ToLowerInvariant());
const bool isResume = true;
bool didRun = false;
if (isBackup)
{
didRun = RunBackupPlan(e.Context, planId, isResume);
}
else if (isRestore)
{
didRun = RunRestorePlan(e.Context, planId, isResume);
}
}
public void OnCommandExecute(CommandData data)
{
data.SplitText();
if (data.Sender.IsPlayer)
{
PlayerCommandEventArgs ev = new PlayerCommandEventArgs(data);
Server.Instance.Event.Player.OnPlayerCommand(this, ev);
if (ev.IsCancel)
{
return;
}
}
else
{
ServerCommandEventArgs ev = new ServerCommandEventArgs(data);
Server.Instance.Event.Server.OnServerCommand(this, ev);
if (ev.IsCancel)
{
return;
}
}
Command command = this.Manager.GetCommand(data.Command);
if (command != null)
{
command.OnExecute(data.Sender, data.Command, data.Args);
}
else
{
data.Sender.SendMessage(new TranslationContainer(TextFormat.RED, "commands.generic.unknown", data.Command));
}
}
private void OnCommand(ServerCommandEventArgs e)
{
foreach (EventListener el in Plugins)
{
ServerListener sl = (ServerListener)el.Listener;
if (el.Event == Event.ServerCommand)
{
sl.OnCommand(e);
}
}
}
private void OnControlPlanKill(object sender, ServerCommandEventArgs e)
{
string planType = e.Command.GetArgumentValue <string>("planType");
Int32 planId = e.Command.GetArgumentValue <Int32>("planId");
Process processToBeKilled = null;
bool isBackup = planType.Equals(PlanTypeEnum.BACKUP.ToString().ToLowerInvariant());
bool isRestore = planType.Equals(PlanTypeEnum.RESTORE.ToString().ToLowerInvariant());
if (isBackup)
{
RunningBackups.TryGetValue(planId, out processToBeKilled);
}
else if (isRestore)
{
RunningRestores.TryGetValue(planId, out processToBeKilled);
}
if (processToBeKilled == null)
{
string msg = Commands.ReportError(0, "{0} plan #{1} is not running", planType.ToTitleCase(), planId);
Handler.Send(e.Context, msg);
return;
}
processToBeKilled.Kill();
if (isBackup)
{
RunningBackups.Remove(planId);
}
else if (isRestore)
{
RunningRestores.Remove(planId);
}
}
public void Run(string[] args)
{
AppDomain.CurrentDomain.UnhandledException += UnhandledException_Handler;
//Configure service current directory and managers
Environment.CurrentDirectory = AppDomain.CurrentDomain.BaseDirectory;
if (!Directory.Exists("Converter"))
{
Directory.CreateDirectory("Converter");
}
//run as service
if (args.Any(a => a.Equals("-service", StringComparison.InvariantCultureIgnoreCase)))
{
Run(this);
}
else
{
Version version = Assembly.GetExecutingAssembly().GetName().Version;
if (!IsRunningInMono)
{
Console.Title = "C#raft v" + version;
}
Console.WriteLine("C#raft v{0}", version);
PlayerNBTConverter a = new PlayerNBTConverter();
foreach (var s in Directory.GetFiles("Converter", "*.dat", SearchOption.TopDirectoryOnly))
{
Console.WriteLine("Converting {0} to C#raft format", s);
a.ConvertPlayerNBT(s);
}
OnStart(args);
while (true)
{
string input = Console.ReadLine();
if (string.IsNullOrEmpty(input) || string.IsNullOrEmpty(input.Trim()))
{
continue;
}
if (Server == null)
{
return;
}
string[] inputParts = input.Split();
var cleanedtokens = inputParts.Skip(1).ToArray();
try
{
var cmd = Server.ServerCommandHandler.Find(inputParts[0]) as IServerCommand;
if (cmd == null)
{
return;
}
//todo - make this better
if (cmd is CmdStop)
{
Server.Stop();
}
//Event Start
ServerCommandEventArgs e = new ServerCommandEventArgs(Server, cmd, inputParts);
Server.PluginManager.CallEvent(Event.ServerCommand, e);
if (e.EventCanceled)
{
return;
}
//Event End
cmd.Use(Server, inputParts[0], cleanedtokens);
}
catch (CommandNotFoundException e) { Server.Logger.Log(LogLevel.Info, e.Message); }
catch (Exception e)
{
Server.Logger.Log(LogLevel.Error, "There was an error while executing the command.");
Server.Logger.Log(e);
}
}
OnStop();
}
}
public virtual void OnCommand(ServerCommandEventArgs e)
{
}
public static void OnServerCommand(ServerCommandEventArgs args)
{
ServerCommand?.Invoke(args);
}
private void OnControlPlanQuery(object sender, ServerCommandEventArgs e)
{
string planType = e.Command.GetArgumentValue <string>("planType");
Int32 planId = e.Command.GetArgumentValue <Int32>("planId");
ValidatePlanType(planType);
bool isRunning = IsPlanRunning(planType, planId);
bool needsResume = false;
bool isFinished = false;
bool isBackup = planType.Equals(PlanTypeEnum.BACKUP.ToString().ToLowerInvariant());
bool isRestore = planType.Equals(PlanTypeEnum.RESTORE.ToString().ToLowerInvariant());
// Report to GUI.
Commands.GuiReportPlanStatus report = new Commands.GuiReportPlanStatus();
if (isBackup)
{
BackupRepository daoBackup = new BackupRepository();
Models.Backup latest = daoBackup.GetLatestByPlan(new Models.BackupPlan {
Id = planId
});
needsResume = latest != null && latest.NeedsResume();
isFinished = latest != null && latest.IsFinished();
if (isRunning)
{
report.StartedAt = latest.StartedAt;
}
else if (isFinished)
{
report.FinishedAt = latest.FinishedAt;
}
}
else if (isRestore)
{
RestoreRepository daoRestore = new RestoreRepository();
Models.Restore latest = daoRestore.GetLatestByPlan(new Models.RestorePlan {
Id = planId
});
needsResume = latest != null && latest.NeedsResume();
isFinished = latest != null && latest.IsFinished();
if (isRunning)
{
report.StartedAt = latest.StartedAt;
}
else if (isFinished)
{
report.FinishedAt = latest.FinishedAt;
}
}
bool isInterrupted = !isRunning && needsResume;
Commands.OperationStatus status;
// The condition order below is important because more than one flag might be true.
if (isInterrupted)
{
status = Commands.OperationStatus.INTERRUPTED;
}
else if (needsResume)
{
status = Commands.OperationStatus.RESUMED;
}
else if (isRunning)
{
status = Commands.OperationStatus.STARTED;
}
else
{
status = Commands.OperationStatus.NOT_RUNNING;
}
report.Status = status;
Handler.Send(e.Context, Commands.GuiReportOperationStatus(planType, planId, report));
}
