void Start()
{
try
{
if (!Directory.Exists(DefaultPath))
{
Directory.CreateDirectory(DefaultPath);
}
if (!Directory.Exists(LoggingPath))
{
Directory.CreateDirectory(LoggingPath);
}
if (!Directory.Exists(PluginPath))
{
Directory.CreateDirectory(PluginPath);
}
ExtensionLoader.Load();
DataStore.GetInstance().Save();
PluginCollector.GetCollector();
}
catch (Exception ex)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(string.Format("[Error] Failed to load Redox, Error: {0}", ex));
}
}
public void UnloadPlugin(string name, PluginContainer pc = null)
{
if (Plugins.TryGetValue(name, out CSPlugin plugin))
{
PluginCollector.GetCollector().GetContainer(name).Disable();
Plugins.Remove(name);
logger.LogInfo("[CSharp] Succesfully unloaded plugin " + plugin.Title);
}
}
// This method gets called by the runtime. Use this method to add services to the container.
public void ConfigureServices(IServiceCollection services)
{
services.AddControllersWithViews();
// In production, the React files will be served from this directory
services.AddSpaStaticFiles(configuration =>
{
configuration.RootPath = "ClientApp/build";
});
var pt = new PluginTable();
services.AddSingleton <PluginTable>(pt);
services.AddSingleton <PluginServiceCollection>();
var plugin = new PluginCollector(pt);
}
public void CheckCalcOfYValuesOfDataPoints()
{
PluginCollector coll = new PluginCollector();
MonitoringPluginPageModel model = new MonitoringPluginPageModel(coll);
model.BloodSugarDataPoints.Add(new ChartDataPoint(new DateTime(2016, 6, 12, 10, 0, 0), 50));
model.BloodSugarDataPoints.Add(new ChartDataPoint(new DateTime(2016, 6, 12, 14, 0, 0), 150));
//model.BloodSugarDataPoints.Add(new ChartDataPoint(new DateTime(2016, 6, 12, 10, 0, 0), 50));
var result1 = model.calcDataPointsYValue(new ChartDataPoint(new DateTime(2016, 6, 12, 11, 0, 0), 0));
var result2 = model.calcDataPointsYValue(new ChartDataPoint(new DateTime(2016, 6, 12, 12, 0, 0), 0));
var result3 = model.calcDataPointsYValue(new ChartDataPoint(new DateTime(2016, 6, 12, 13, 0, 0), 0));
Assert.True(result1 == 75 && result2 == 100 && result3 == 125);
}
public static void LoadPlugin(string dir)
{
FileInfo info = null;
try
{
foreach (var file in Directory.GetFiles(dir, Expression))
{
Stopwatch sw = new Stopwatch();
sw.Start();
info = new FileInfo(file);
string name = info.Name.Replace(".dll", string.Empty);
Assembly assembly;
if (!Plugins.TryGetValue(name, out assembly))
{
assembly = Assembly.Load(File.ReadAllBytes(file));
Plugins.Add(name, assembly);
}
foreach (Type type in assembly.GetExportedTypes())
{
if (type.IsSubclassOf(typeof(RedoxPlugin)) && type.IsPublic && !type.IsAbstract)
{
object instance = Activator.CreateInstance(type);
RedoxPlugin plugin = (RedoxPlugin)instance;
PluginContainer container = new PluginContainer(plugin, instance);
PluginCollector.GetCollector().AddPlugin(container);
container.Plugin.Path = Path.GetDirectoryName(info.Directory.FullName);
logger.LogInfo(string.Format("[Redox] Succesfully loaded plugin {0}, {1}, Author {2} ({3}", plugin.Title, plugin.Version, plugin.Author, plugin.Description));
}
}
sw.Stop();
int time = sw.Elapsed.Milliseconds;
if (time > 500)
{
logger.LogSpeed(string.Format("[Redox] Plugin {0} took {1} milliseconds to load", name, time));
}
}
}
catch (Exception ex)
{
logger.LogError(string.Format("An exception has thrown while trying to load plugin {0}, Error: {1}", info.FullName, ex));
}
}
public static void StartAll()
{
foreach (var engine in _engines)
{
var instance = (IPluginEngine)Activator.CreateInstance(engine);
if (!_instances.Contains(instance))
{
Logger.LogInfo(string.Format("[Redox] Loading {0} Engine..", instance.Language));
_instances.Add(instance);
instance.LoadPlugins();
}
else
{
Logger.LogWarning(string.Format("[Redox] Skipping engine {0} because its already loaded!", engine.Name));
}
}
Logger.LogInfo($"[Redox] Succesfully loaded {PluginCollector.GetCollector().GetPlugins().Count} Plugins");
}
public void CheckAddBloodSugarDataPoint()
{
PluginCollector coll = new PluginCollector();
MonitoringPluginPageModel model = new MonitoringPluginPageModel(coll);
model.AddDatapoints(DataPoints.BloodSugar);
AddBloodSugarPageModel bmodel = new AddBloodSugarPageModel(coll);
bmodel.BloodSugarValue = 40;
DateTime tmpDate = DateTime.Now;
bmodel.Date = tmpDate;
var x = bmodel.AddDataPoint;
model.LoadData();
ChartDataPoint bsPoint = (from ChartDataPoint poi in model.BloodSugarDataPoints where (DateTime)poi.XValue == tmpDate select poi).ToList().FirstOrDefault();
Assert.True((DateTime)bsPoint.XValue == tmpDate);
}
public static void LoadPlugin(string dir)
{
foreach (var file in Directory.GetFiles(dir, Expression))
{
FileInfo info = new FileInfo(file);
string name = info.Name.Replace(".dll", string.Empty);
Assembly assembly;
if (!Plugins.TryGetValue(name, out assembly))
{
assembly = Assembly.Load(File.ReadAllBytes(file));
Plugins.Add(name, assembly);
}
if (ValidPlugin(assembly))
{
foreach (Type type in assembly.GetExportedTypes())
{
if (type.IsSubclassOf(typeof(RedoxPlugin)) && type.IsPublic && !type.IsAbstract)
{
RedoxPlugin plugin = (RedoxPlugin)Activator.CreateInstance(type);
PluginContainer container = new PluginContainer(plugin);
PluginCollector.GetCollector().AddPlugin(container);
foreach (var method in type.GetMethods(BindingFlags.Public | BindingFlags.Instance | BindingFlags.DeclaredOnly))
{
container.Methods.Add(method.Name, method);
}
Debug.Log(string.Format("[Redox] Succesfully loaded plugin {0}, {1}, {2} ({3})", plugin.Title, plugin.Author, plugin.Version, plugin.Description));
}
}
}
else
{
Debug.LogWarning(string.Format("[Redox] Denied plugin {0} because of forbidden references", assembly.FullName));
}
}
}
private static int Plugins(PluginsOptions pluginsOptions)
{
var action = pluginsOptions.Action.ToLower();
if (action == "list")
{
using (var collector = new PluginCollector())
{
_logger.Info($"Plugins found: { collector.Plugins.Count }");
foreach (var plugin in collector.Plugins)
{
_logger.Info($"- { plugin.Name } v.{ plugin.Version }: { plugin.Description }");
}
}
}
else if (action == "help")
{
using (var collector = new PluginCollector())
{
var plugin = collector.Plugins.SingleOrDefault((p) => p.Name.Equals(pluginsOptions.PluginName, StringComparison.InvariantCultureIgnoreCase));
if (plugin != null)
{
plugin.Initialize(_logger.Factory);
_logger.Info($"{ plugin.Name } v.{ plugin.Version }");
_logger.Info($"by { plugin.Author }");
_logger.Info(plugin.Description);
_logger.Info(plugin.Help);
plugin.Shutdown();
}
}
}
return(0);
}
public void LoadPlugin(string dir)
{
FileInfo info = null;
foreach (var file in Directory.GetFiles(dir, Pattern))
{
try
{
Stopwatch sw = new Stopwatch();
sw.Start();
info = new FileInfo(file);
string name = Path.GetFileNameWithoutExtension(info.Name);
if (Plugins.TryGetValue(name, out CSPlugin p))
{
if (p.Container.Running)
{
logger.LogWarning(string.Format("[CSharp] Failed to load {0} because its already initialized", p.Title));
break;
}
logger.LogInfo(string.Format("[CSharp] Succesfully loaded plugin {0}, {1}, Author {2} ({3})", p.Title, p.Version, p.Author, p.Description));
p.Container.Start();
break;
}
if (!Assemblies.TryGetValue(name, out Assembly assembly))
{
assembly = Assembly.Load(File.ReadAllBytes(file));
Assemblies.Add(name, assembly);
}
if (this.IsSecure(assembly, out ViolationType violationType))
{
foreach (Type type in assembly.GetExportedTypes())
{
if (type.IsSubclassOf(typeof(CSPlugin)) && type.IsPublic && !type.IsAbstract)
{
object instance = Activator.CreateInstance(type);
CSPlugin plugin = (CSPlugin)instance;
if (name != plugin.Title)
{
logger.LogWarning($"[CSharp] Failed to load plugin {plugin.Title} because the file name is not the same as the title");
return;
}
if (((plugin.CoreVersion.ToString() == "0.0.0.0") || (plugin.CoreVersion >= Redox.Version)) || Bootstrap.RedoxMod.Config.LoadIncompitablePlugins)
{
plugin.FileInfo = info;
PluginContainer container = new PluginContainer(plugin, instance, Language);
PluginCollector.GetCollector().AddPlugin(container);
Plugins.Add(plugin.Title, plugin);
logger.LogInfo(string.Format("[CSharp] Succesfully loaded plugin {0}, {1}, Author {2} ({3})", plugin.Title, plugin.Version, plugin.Author, plugin.Description));
}
else
{
logger.LogWarning($"[Redox] Plugin \"{plugin.Title}\" is not compitable with the current redox version!");
}
}
}
sw.Stop();
int time = sw.Elapsed.Milliseconds;
if (time > 500)
{
logger.LogSpeed(string.Format("[CSharp] Plugin {0} took {1} milliseconds to load", name, time));
}
}
else
{
logger.LogWarning(string.Format("[CSharp] {0} has been blocked due security violation: {1}", assembly.GetName().Name, violationType));
}
}
catch (Exception ex)
{
logger.LogError(string.Format("[CSharp] Failed to load {0}, Error: {1}", info.Name, ex));
}
}
}
/// <summary>
/// Syntax $$Run-Plugin::PluginName['arg1', 'arg2', 'argN']
/// </summary>
public static JObject ResolvePluginExpressions(this JObject json, ref int warnings)
{
var expressionRegex = new Regex(@"(?<expression>\$\$Run-Plugin::(?<name>[^\[]*)\[(?<arguments>[^\]]*)\])", RegexOptions.Compiled);
var pluginExpressions = expressionRegex.Matches(json.ToString()).Cast <Match>()
.Select((m) => new
{
Expression = m.Groups["expression"].Value,
Name = m.Groups["name"].Value,
Arguments = Regex.Unescape(m.Groups["arguments"].Value)
.Split(',') // do not use StringSplitOptions.RemoveEmptyEntries
.Select((a) => a.Trim(new[] { ' ', '\'' }))
.ToArray()
})
.Distinct()
.ToList();
#region Print debug expressions
_logger.Debug($"Plugin expressions found '{ pluginExpressions.Count }'");
foreach (var plugin in pluginExpressions)
{
_logger.Debug($"\tExpression '{ plugin.Expression }'");
_logger.Debug($"\t\tPlugin '{ plugin.Name }'");
foreach (var argument in plugin.Arguments)
{
_logger.Debug($"\t\tArgument '{ argument }'");
}
}
#endregion
_logger.Info("Collecting plugins");
using (var collector = new PluginCollector())
{
_logger.Info($"Plugins found '{ collector.Plugins.Count }'");
foreach (var plugin in collector.Plugins)
{
_logger.Debug($"\tPlugin '{ plugin.Name }' - '{ plugin.Version }' - '{ plugin.Description }'");
}
string resolvedJson = json.ToString();
foreach (var expression in pluginExpressions)
{
var plugin = collector.Plugins.SingleOrDefault((p) => p.Name.Equals(expression.Name, StringComparison.InvariantCultureIgnoreCase));
if (plugin == null)
{
_logger.Warn($"Plugin not found for expression '{ expression.Expression }'");
warnings++;
continue;
}
dynamic pluginResult;
#region Execute plugin
_logger.Info($"Executing plugin '{ plugin.Name }' - '{ plugin.Version }' - '{ plugin.Description }'");
plugin.Initialize(_logger.Factory);
try
{
if (plugin is IMetadataCompilerPlugin)
{
pluginResult = (plugin as IMetadataCompilerPlugin).Compile(expression.Arguments);
}
/*
* else if (plugin is I<MyCustom>CompilerPlugin)
* {
* pluginResult = (plugin as I<MyCustom>CompilerPlugin).Compile(expression.Arguments);
* }
*/
else
{
throw new ApplicationException($"Invalid plugin type in expression '{ expression.Expression }'");
}
}
finally
{
plugin.Shutdown();
}
#endregion
_logger.Debug($"Resolved plugin expression type is '{ pluginResult.GetType() }' => '{ pluginResult }'");
var replaceExpression = expression.Expression;
// Add beginning and trailing quotes, since we're replacing a json value fragment with raw string json object.
if (!(pluginResult is JValue))
{
replaceExpression = "\"" + expression.Expression + "\"";
}
resolvedJson = resolvedJson.Replace(replaceExpression, pluginResult.ToString());
}
_logger.Info("Parsing resolved plugin metadata");
_logger.Debug(resolvedJson);
return(JObject.Parse(resolvedJson));
}
}
public async void Initialize()
{
try
{
if (!string.IsNullOrEmpty(CustomPath))
{
RootPath = CustomPath;
}
else
{
RootPath = Directory.GetCurrentDirectory() + "\\Redox\\";
}
PluginPath = Path.Combine(RootPath, "Plugins\\");
ExtensionPath = Path.Combine(RootPath, "Extensions\\");
DependencyPath = Path.Combine(RootPath, "Dependencies\\");
DataPath = Path.Combine(RootPath, "Data\\");
LoggingPath = Path.Combine(RootPath, "Logs\\");
AssemblePath = Path.GetDirectoryName(assembly.Location);
if (!Directory.Exists(RootPath))
{
Directory.CreateDirectory(RootPath);
}
if (!Directory.Exists(LoggingPath))
{
Directory.CreateDirectory(LoggingPath);
}
if (!Directory.Exists(ExtensionPath))
{
Directory.CreateDirectory(ExtensionPath);
}
if (!Directory.Exists(DependencyPath))
{
Directory.CreateDirectory(DependencyPath);
}
if (!Directory.Exists(PluginPath))
{
Directory.CreateDirectory(PluginPath);
}
if (!Directory.Exists(DataPath))
{
Directory.CreateDirectory(DataPath);
}
Config = new RedoxConfig();
string path = Path.Combine(RootPath, "Redox.json");
if (File.Exists(path))
{
Config = Utility.Json.FromFile <RedoxConfig>(path);
}
else
{
Utility.Json.ToFile(path, Config.Init());
}
this.EnableCertificates();
this.LoadDependencies();
ExtensionLoader.Load();
this.Container = ContainerConfig.Configure();
this.BuildContainer();
Logger = Container.Resolve <ILogger>();
Logger.LogInfo("[Redox] Initializing RedoxMod..");
PluginEngineManager.Register <CSPluginEngine>();
Logger.LogInfo("[Redox] Loading data...");
await PermissionManager.LoadAsync();
await GroupManager.LoadAsync();
await RoleManager.LoadAsync();
await RoleManager.CreateRoleAsync(new Role("default", "default role", 0, false));
await GroupManager.CreateGroupAsync(new Group("default", "default group for players.", "default", 0, true, false));
await RoleManager.AddGroupAsync("default", "default");
Logger.LogInfo("[Redox] Loading standard library..");
LocalStorage.Load();
PluginCollector.GetCollector();
Logger.LogInfo($"[Redox] RedoxMod V{Version} has been initialized.");
}
catch (Exception ex)
{
Console.Clear();
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine(string.Format("[Error] Failed to load Redox, Error: {0}", ex));
}
LifeTimeWatch = Stopwatch.StartNew();
WebRequestTimer = Timers.Create(5, TimerType.Repeat, WebRequestUpdate);
}
