public WebApi(ConfWebApi config, CoreInjector coreInjector, TokenManager tokenManager, Stats stats)
{
this.config = config;
this.coreInjector = coreInjector;
this.tokenManager = tokenManager;
this.stats = stats;
}
public PluginManager(ConfPlugins config, CoreInjector coreInjector)
{
Util.Init(out plugins);
Util.Init(out usedIds);
this.config = config;
this.coreInjector = coreInjector;
}
public static void PerformUpgrades(CoreInjector injector)
{
var database = injector.GetModuleOrThrow <DbStore>();
var meta = database.GetMetaData(CoreTable);
void Advance(int version, string?explanation)
{
meta.Version = version;
database.UpdateMetaData(meta);
if (explanation != null)
{
Log.Info("Upgrading data to ver {0}. {1}", version, explanation);
}
}
switch (meta.Version)
{
case 0:
// Case 0 should always jump to the lastest version, since it gets created on first start.
Advance(CurrentVersion, null);
goto case CurrentVersion;
case CurrentVersion:
break;
default:
Log.Warn("It seems that you downgraded your TS3AB version. " +
"Due to automatic upgrades some stuff might not work anymore, be advised. " +
"It is recommended to backup data before upgrading to unstable/beta builds if you intend to downgrade again.");
break;
}
}
public PluginManager(ConfPlugins config, CoreInjector coreInjector, ResourceResolver resourceResolver, BotManager botManager)
{
this.config = config;
this.coreInjector = coreInjector;
this.resourceResolver = resourceResolver;
this.botManager = botManager;
}
public WebApi(ConfWebApi config, CoreInjector coreInjector, CommandManager commandManager, TokenManager tokenManager)
{
this.config = config;
this.coreInjector = coreInjector;
this.commandManager = commandManager;
this.tokenManager = tokenManager;
}
public Core(string configFilePath = null)
{
// setting defaults
this.configFilePath = configFilePath ?? DefaultConfigFileName;
injector = new CoreInjector();
}
public Core(string configFilePath = null)
{
// setting defaults
this.configFilePath = configFilePath ?? FilesConst.CoreConfig;
injector = new CoreInjector();
}
public Core(DedicatedTaskScheduler scheduler, string?configFilePath = null)
{
this.scheduler = scheduler;
// setting defaults
this.configFilePath = configFilePath ?? FilesConst.CoreConfig;
injector = new CoreInjector();
}
private void ProcessApiV1Call(Uri uri, HttpListenerResponse response, InvokerData invoker)
{
string apirequest = uri.OriginalString.Substring(uri.GetLeftPart(UriPartial.Authority).Length + "/api".Length);
var ast = CommandParser.ParseCommandRequest(apirequest, '/', '/');
UnescapeAstTree(ast);
Log.Trace(ast.ToString);
var command = CommandManager.CommandSystem.AstToCommandResult(ast);
var execInfo = new ExecutionInformation(CoreInjector.CloneRealm <CoreInjector>());
execInfo.AddDynamicObject(new CallerInfo(apirequest, true));
execInfo.AddDynamicObject(invoker);
// todo creating token usersessions is now possible
try
{
var res = command.Execute(execInfo, Array.Empty <ICommand>(), XCommandSystem.ReturnJsonOrNothing);
if (res.ResultType == CommandResultType.Empty)
{
response.StatusCode = (int)HttpStatusCode.NoContent;
}
else if (res.ResultType == CommandResultType.Json)
{
response.StatusCode = (int)HttpStatusCode.OK;
var returnJson = (JsonCommandResult)res;
var returnString = returnJson.JsonObject.Serialize();
using (var responseStream = new StreamWriter(response.OutputStream))
responseStream.Write(returnString);
}
}
catch (CommandException ex)
{
try { ReturnError(ex, response); }
catch (Exception htex) { Log.Error(htex, "Failed to respond to HTTP request."); }
}
catch (Exception ex)
{
if (ex is NotImplementedException)
{
response.StatusCode = (int)HttpStatusCode.NotImplemented;
}
else
{
response.StatusCode = (int)HttpStatusCode.InternalServerError;
}
Log.Error(ex, "Unexpected command error");
try
{
using (var responseStream = new StreamWriter(response.OutputStream))
responseStream.Write(new JsonError(ex.Message, CommandExceptionReason.Unknown).Serialize());
}
catch (Exception htex) { Log.Error(htex, "Failed to respond to HTTP request."); }
}
}
private E <string> Run(bool interactive = false)
{
var configResult = ConfRoot.OpenOrCreate(configFilePath);
if (!configResult.Ok)
{
return("Could not create config");
}
ConfRoot config = configResult.Value;
Config.Deprecated.UpgradeScript.CheckAndUpgrade(config);
var injector = new CoreInjector();
injector.RegisterType <Core>();
injector.RegisterType <ConfRoot>();
injector.RegisterType <CoreInjector>();
injector.RegisterType <DbStore>();
injector.RegisterType <PluginManager>();
injector.RegisterType <CommandManager>();
injector.RegisterType <ResourceFactoryManager>();
injector.RegisterType <WebServer>();
injector.RegisterType <RightsManager>();
injector.RegisterType <BotManager>();
injector.RegisterType <TokenManager>();
injector.RegisterModule(this);
injector.RegisterModule(config);
injector.RegisterModule(injector);
injector.RegisterModule(new DbStore(config.Db));
injector.RegisterModule(new PluginManager(config.Plugins));
injector.RegisterModule(new CommandManager(), x => x.Initialize());
injector.RegisterModule(new ResourceFactoryManager(config.Factories), x => x.Initialize());
injector.RegisterModule(new WebServer(config.Web), x => x.Initialize());
injector.RegisterModule(new RightsManager(config.Rights));
injector.RegisterModule(new BotManager());
injector.RegisterModule(new TokenManager(), x => x.Initialize());
if (!injector.AllResolved())
{
Log.Debug("Cyclic core module dependency");
injector.ForceCyclicResolve();
if (!injector.AllResolved())
{
Log.Error("Missing core module dependency");
return("Could not load all core modules");
}
}
YoutubeDlHelper.DataObj = config.Tools.YoutubeDl;
Bots.RunBots(interactive);
return(R.Ok);
}
public Plugin(CoreInjector coreInjector, ResourceResolver resourceResolver, BotManager botManager, FileInfo file, int id)
{
this.coreInjector = coreInjector;
this.resourceResolver = resourceResolver;
this.botManager = botManager;
corePlugin = null;
File = file;
Id = id;
status = PluginStatus.Off;
Type = PluginType.None;
}
public BotManager(ConfRoot confRoot, CoreInjector coreInjector)
{
this.confRoot = confRoot;
this.coreInjector = coreInjector;
}
public BotManager(ConfRoot confRoot, CoreInjector coreInjector)
{
Util.Init(out activeBots);
this.confRoot = confRoot;
this.coreInjector = coreInjector;
}
public WebServer(ConfWeb config, CoreInjector coreInjector)
{
this.config = config;
this.coreInjector = coreInjector;
}
public PluginManager(ConfPlugins config, CoreInjector coreInjector)
{
this.config = config;
this.coreInjector = coreInjector;
}
private R InitializeCore()
{
ConfigManager = ConfigFile.OpenOrCreate(configFilePath) ?? ConfigFile.CreateDummy();
// TODO: DUMMY REQUESTS
var webd = ConfigManager.GetDataStruct <WebData>("WebData", true);
var rmd = ConfigManager.GetDataStruct <RightsManagerData>("RightsManager", true);
ConfigManager.GetDataStruct <MainBotData>("MainBot", true);
YoutubeDlHelper.DataObj = ConfigManager.GetDataStruct <YoutubeFactoryData>("YoutubeFactory", true);
var pmd = ConfigManager.GetDataStruct <PluginManagerData>("PluginManager", true);
ConfigManager.GetDataStruct <MediaFactoryData>("MediaFactory", true);
var hmd = ConfigManager.GetDataStruct <HistoryManagerData>("HistoryManager", true);
ConfigManager.GetDataStruct <AudioFrameworkData>("AudioFramework", true);
ConfigManager.GetDataStruct <Ts3FullClientData>("QueryConnection", true);
ConfigManager.GetDataStruct <PlaylistManagerData>("PlaylistManager", true);
// END TODO
ConfigManager.Close();
Log.Info("[============ TS3AudioBot started =============]");
Log.Info("[=== Date/Time: {0} {1}", DateTime.Now.ToLongDateString(), DateTime.Now.ToLongTimeString());
Log.Info("[=== Version: {0}", SystemData.AssemblyData);
Log.Info("[=== Platform: {0}", SystemData.PlattformData);
Log.Info("[=== Runtime: {0}", SystemData.RuntimeData.FullName);
Log.Info("[=== Opus: {0}", TS3Client.Audio.Opus.NativeMethods.Info);
Log.Info("[==============================================]");
if (SystemData.RuntimeData.Runtime == Runtime.Mono)
{
if (SystemData.RuntimeData.SemVer == null)
{
Log.Warn("Could not find your running mono version!");
Log.Warn("This version might not work properly.");
Log.Warn("If you encounter any problems, try installing the latest mono version by following http://www.mono-project.com/download/");
}
else if (SystemData.RuntimeData.SemVer.Major < 5)
{
Log.Error("You are running a mono version below 5.0.0!");
Log.Error("This version is not supported and will not work properly.");
Log.Error("Install the latest mono version by following http://www.mono-project.com/download/");
}
}
Log.Info("[============ Initializing Modules ============]");
TS3Client.Messages.Deserializer.OnError += (s, e) => Log.Error(e.ToString());
Injector = new CoreInjector();
Injector.RegisterType <Core>();
Injector.RegisterType <ConfigFile>();
Injector.RegisterType <CoreInjector>();
Injector.RegisterType <DbStore>();
Injector.RegisterType <PluginManager>();
Injector.RegisterType <CommandManager>();
Injector.RegisterType <ResourceFactoryManager>();
Injector.RegisterType <WebManager>();
Injector.RegisterType <RightsManager>();
Injector.RegisterType <BotManager>();
Injector.RegisterType <TokenManager>();
Injector.RegisterModule(this);
Injector.RegisterModule(ConfigManager);
Injector.RegisterModule(Injector);
Injector.RegisterModule(new DbStore(hmd));
Injector.RegisterModule(new PluginManager(pmd));
Injector.RegisterModule(new CommandManager(), x => x.Initialize());
Injector.RegisterModule(new ResourceFactoryManager(), x => x.Initialize());
Injector.RegisterModule(new WebManager(webd), x => x.Initialize());
Injector.RegisterModule(new RightsManager(rmd), x => x.Initialize());
Injector.RegisterModule(new BotManager());
Injector.RegisterModule(new TokenManager(), x => x.Initialize());
if (!Injector.AllResolved())
{
Log.Debug("Cyclic core module dependency");
Injector.ForceCyclicResolve();
if (!Injector.AllResolved())
{
Log.Error("Missing core module dependency");
return("Could not load all core modules");
}
}
Log.Info("[==================== Done ====================]");
return(R.OkR);
}
private bool StartInternal(Bot bot)
{
if (CheckStatus(bot) != PluginStatus.Ready)
{
throw new InvalidOperationException("This plugin has not yet been prepared");
}
try
{
switch (Type)
{
case PluginType.None:
throw new InvalidOperationException("A 'None' plugin cannot be loaded");
case PluginType.BotPlugin:
if (bot is null)
{
Log.Error("This plugin needs to be activated on a bot instance.");
status = PluginStatus.Error;
return(false);
}
if (pluginObjectList.ContainsKey(bot))
{
throw new InvalidOperationException("Plugin is already instantiated on this bot");
}
var pluginInstance = (IBotPlugin)Activator.CreateInstance(coreType);
if (pluginObjectList.Count == 0)
{
RegisterCommands(pluginInstance, coreType);
}
pluginObjectList.Add(bot, pluginInstance);
if (!bot.Injector.TryInject(pluginInstance))
{
Log.Warn("Some dependencies are missing for this plugin");
}
pluginInstance.Initialize();
break;
case PluginType.CorePlugin:
pluginObject = (ICorePlugin)Activator.CreateInstance(coreType);
RegisterCommands(pluginObject, coreType);
if (!CoreInjector.TryInject(pluginObject))
{
Log.Warn("Some dependencies are missing for this plugin");
}
pluginObject.Initialize();
break;
case PluginType.Factory:
factoryObject = (IFactory)Activator.CreateInstance(coreType);
FactoryManager.AddFactory(factoryObject);
break;
case PluginType.Commands:
RegisterCommands(null, coreType);
break;
default:
throw Util.UnhandledDefault(Type);
}
}
catch (Exception ex)
{
if (ex is MissingMethodException)
{
Log.Error(ex, "Plugins and Factories needs a parameterless constructor.");
}
else
{
Log.Error(ex, "Plugin '{0}' failed to load: {1}.", Name, ex.Message);
}
Stop(bot);
if (Type != PluginType.BotPlugin)
{
status = PluginStatus.Error;
}
return(false);
}
if (Type != PluginType.BotPlugin)
{
status = PluginStatus.Active;
}
return(true);
}
