private void OnSelect(object sender, EventArgs e)
{
PluginDefinition plugin = (PluginDefinition)comboBoxPlugins.SelectedItem;
Collection <VideoOS.Platform.License.LicenseInformation> lics = plugin.PluginLicenseRequest;
StringBuilder sb = new StringBuilder();
XmlWriter xw = XmlWriter.Create(sb);
xw.WriteStartDocument();
xw.WriteStartElement("MIPLicenseInformation");
xw.WriteStartElement("PluginId");
xw.WriteString(plugin.Id.ToString());
xw.WriteEndElement();
xw.WriteElementString("Name", plugin.Name);
xw.WriteStartElement("Licenses");
foreach (LicenseInformation lic in lics)
{
xw.WriteStartElement("License");
xw.WriteElementString("Name", lic.Name);
xw.WriteElementString("Type", lic.LicenseType);
xw.WriteEndElement();
}
xw.WriteEndElement();
xw.WriteEndElement();
xw.WriteEndDocument();
xw.Flush();
textBoxXML.Text = sb.ToString();
xw.Close();
}
void VerifyDummy(PluginDefinition def, string expectedName)
{
DummyPlugin plugin = null;
Assert.DoesNotThrow(() => plugin = def.Create<DummyPlugin>());
Assert.True(plugin.Settings != null);
Assert.True(plugin.Settings.FirstName == expectedName);
}
private SelectedPlugin ToSelectedPlugin(PluginDefinition plugin)
{
string[] disabledPlugins = this.settings.DisabledPlugins;
bool isEnabled = !disabledPlugins.Contains(plugin.FullPath);
return(new SelectedPlugin(plugin.Description, plugin.FullPath, isEnabled));
}
public void TestDeployAsmx()
{
try
{
LogbusServerConfiguration config = new LogbusServerConfiguration();
config.webserver = new WebServerConfiguration {
active = true
};
PluginDefinition plugDef = new PluginDefinition()
{
type = typeof(DummyPlugin).AssemblyQualifiedName
};
config.plugins = new PluginDefinition[] { plugDef };
using (LogbusService logbus = new LogbusService())
{
logbus.Configure(config);
logbus.Start();
//Test HTTP request
DummyStub stub = new DummyStub()
{
Url = "http://localhost:8065/Dummy.asmx"
};
Assert.AreEqual <int>(5, stub.Sum(3, 2));
}
}
catch (Exception ex)
{
Assert.Fail("Test failed: {0}", ex.ToString());
}
}
/// <summary>
/// For initialization as a plugin
/// </summary>
/// <param name="pluginDef">Plugin definition</param>
public void Init(PluginDefinition pluginDef)
{
MultiSourceAnchorResolverSettings settings = pluginDef.DeserializeSettings <MultiSourceAnchorResolverSettings>();
settings.Validate();
this.Init(settings);
}
private static string makeErrorMessage(Contribution c, Exception e)
{
PluginDefinition p = c.Parent;
return(string.Format("Title: {0}\tAuthor: {1}\nID={2}\n\n{3}", p.title, p.author, c.Id, e.ToString()));
//! return string.Format("タイトル： {0}\t作者： {1}\nID={2}\n\n{3}",p.title,p.author,c.id,e.ToString());
}
public WidgetDefinition LoadWidget(PluginDefinition plugin, string widgetName)
{
var directory = HostingEnvironment.MapPath(WidgetPaths.WidgetDirectoryVirtualPath(plugin.Name, widgetName));
var widget = new WidgetDefinition(Path.GetFileName(directory), plugin);
Configure(widget);
LoadViews(widget);
return widget;
}
void VerifyDummy(PluginDefinition def, string expectedName)
{
DummyPlugin plugin = null;
Assert.DoesNotThrow(() => plugin = def.Create <DummyPlugin>());
Assert.True(plugin.Settings != null);
Assert.True(plugin.Settings.FirstName == expectedName);
}
void VerifyDummy(PluginDefinition def, string expectedName)
{
DummyPlugin plugin = null;
Assert.Null(Record.Exception(() => plugin = def.Create <DummyPlugin>()));
Assert.True(plugin.Settings != null);
Assert.True(plugin.Settings.FirstName == expectedName);
}
private bool AssertLoadedPlugins(Tuple <string, string> expected, IEnumerable <PluginDefinition> loadedDefinition)
{
string message = string.Format("Loaded Plugins'{0}'", expected.Item1);
Console.WriteLine(message);
PluginDefinition definition = loadedDefinition.FirstOrDefault(d => d.Description == expected.Item1);
return(definition != null && definition.FullPath.Contains(expected.Item2));
}
/// <summary>
/// 加载
/// </summary>
private void LoadPluginDispatchServices()
{
PluginDefinition pluginDefinition;
try
{
pluginDefinition = ReadPluginDefinitions();
}
catch (Exception ex)
{
ExceptionLog("LoadPluginDefinition Failed", ex);
DebugLog("LoadPluginDefinition Failed,Create Empty Config");
//如果发生异常,创建空的内容
pluginDefinition = new PluginDefinition();
File.WriteAllText(PathUtils.PluginDefinitionPath, SerializationUtils.XmlSerialize(pluginDefinition));
}
var esClientConfig = EsClientConfigUtils.ReadEsClientConfig();
if (!esClientConfig.CustomerAgreementState.Registered)
{
DebugLog("Not Registered,Start None Plugin");
return;
}
var serverRoles = esClientConfig.ServerRoles;
//string customerCode = LicenseUtils.GetCustomerCode(esClientConfig.LicenseOperatorServiceAddress);
var hostName = Dns.GetHostName();
foreach (var pluginConfig in pluginDefinition.PluginConfigs)
{
//插件启用的服务器角色中 有当前服务器角色(之一) 启用
if (!CheckEnableByServerRole(serverRoles, pluginConfig.EnableServerRoles))
{
DebugLog(string.Format("Server Role Not Match:[{0}][{1}][{2}]",
pluginConfig.TypeKey, string.Join(",", serverRoles.ToArray()),
string.Join(",", pluginConfig.EnableServerRoles.ToArray())));
continue;
}
if (!CheckEnableByAgreement(esClientConfig.CustomerAgreementState, pluginConfig.PluginType))
{
DebugLog(string.Format("Agreement Not Match:[{0}][{1}][{2}][{3}][{4}]",
pluginConfig.TypeKey, esClientConfig.CustomerAgreementState.Registered,
esClientConfig.CustomerAgreementState.AgreeToUxImproving,
esClientConfig.CustomerAgreementState.AgreeToE10Examination,
pluginConfig.PluginType));
continue;
}
var context = new PluginExecuteContext(pluginConfig, serverRoles, null,
hostName, esClientConfig.LicenseOperatorServiceAddress);
var pluginDispatchService = new PluginDispatchService(context);
//注入服务环境
Connection(pluginDispatchService, ResourceServiceProvider, ServiceCallContext);
DebugLog("Add Plugin:" + pluginConfig.TypeKey);
_pluginDispatchServices.Add(pluginDispatchService);
}
}
public WidgetDefinition(string name, PluginDefinition plugin)
{
Require.NotNullOrEmpty(name, "name");
Require.NotNull(plugin, "plugin");
Name = name;
Plugin = plugin;
Views = new List<WidgetViewDefinition>();
EditorSettings = new WidgetEditorSettings();
ResourcesFolder = new ResourceFolder(HostingEnvironment.MapPath(ResourceFolderVirtualPath));
}
/// <summary>
/// Loads the IGraphFS
/// </summary>
/// <param name="myIGraphFSDefinition">The IGraphFS plugin definition</param>
private IGraphFS LoadGraphFsPlugin(PluginDefinition myIGraphFSDefinition)
{
if (myIGraphFSDefinition != null)
{
return(_graphDBPluginManager.GetAndInitializePlugin <IGraphFS>(myIGraphFSDefinition.NameOfPlugin, myParameter: myIGraphFSDefinition.PluginParameter));
}
//return the default fs
var defaultFSName = _applicationSettings.Get <DefaultGraphFSImplementation>();
return(_graphDBPluginManager.GetAndInitializePlugin <IGraphFS>(defaultFSName));
}
/// <summary>
/// Initialize cryptographer from <see cref="TokenSettings"/>
/// <remarks>
/// Setting the <see cref="DefaultCryptographer"/> to the Direct Project's <see cref="SMIMECryptographer"/>
/// </remarks>
/// </summary>
/// <param name="pluginDef"></param>
public void Init(PluginDefinition pluginDef)
{
try
{
var settings = pluginDef.DeserializeSettings <TokenResolverSettings>();
Init(settings);
}
catch (Exception ex)
{
ProxyError.NotifyEvent(this, ex);
// Do not remove. Exceptions here can cause the Direct Project to not bind to SMTP.
}
}
/// <summary>
/// Creates a new sones GraphDB plugins definition wrapper
/// </summary>
/// <param name="myIGraphFSDefinition">The definition of the IGraphFS plugin</param>
/// <param name="myTransactionManagerPlugin">The definition of the transaction manager plugin</param>
/// <param name="mySecurityManagerPlugin">The definition of the transaction manager plugin</param>
/// <param name="myLogicExpressionOptimizerPlugin">The definition of the logic expression optimizer plugin</param>
public GraphDBPlugins(
PluginDefinition myIGraphFSDefinition = null,
PluginDefinition myTransactionManagerPlugin = null,
PluginDefinition mySecurityManagerPlugin = null,
PluginDefinition myLogicExpressionOptimizerPlugin = null,
List <PluginDefinition> myIndexPlugins = null)
{
IGraphFSDefinition = myIGraphFSDefinition;
TransactionManagerPlugin = myTransactionManagerPlugin;
SecurityManagerPlugin = mySecurityManagerPlugin;
LogicExpressionOptimizerPlugin = myLogicExpressionOptimizerPlugin;
IndexPlugins = myIndexPlugins;
}
/// <summary>
///
/// </summary>
/// <param name="owner"></param>
/// <param name="e"></param>
/// <returns></returns>
public Contribution Load(PluginDefinition owner, XmlElement e)
{
if (e.SelectSingleNode("class") == null)
{
// default to ParamTrainImpl
return(new ParamTrainImpl(e));
}
else
{
// use the class element
return((Contribution)PluginUtil.loadObjectFromManifest(e));
}
}
/// <summary>
///
/// </summary>
/// <param name="owner"></param>
/// <param name="e"></param>
/// <returns></returns>
public Contribution Load(PluginDefinition owner, XmlElement e)
{
BGMFactoryContribution contrib =
(BGMFactoryContribution)PluginUtil.loadObjectFromManifest(e);
// let the factory load BGMs
foreach (BGMContribution bgm in contrib.ListContributions())
{
owner.contributions.Add(bgm);
bgm.init(owner, new Uri(owner.dirName));
}
return(contrib);
}
/// <summary>
///
/// </summary>
static public void loadDefaultTree()
{
PluginDefinition p = PluginManager.GetPlugin("Chiname.Generic");
baseDir = p.dirName;
string filename = Path.Combine(p.dirName, "CategoryTree.xml");
using (Stream file = p.loadStream(filename))
{
XmlDocument doc = new XmlDocument();
doc.Load(file);
new StructCategoryTree(doc);
}
}
/// <summary>
/// Loads the security manager
/// </summary>
/// <param name="mySecurityManagerPlugin">The security manager plugin definition</param>
private ISecurityManager LoadSecurityManager(PluginDefinition mySecurityManagerPlugin)
{
if (mySecurityManagerPlugin != null)
{
return(_graphDBPluginManager.GetAndInitializePlugin <ISecurityManager>(mySecurityManagerPlugin.NameOfPlugin, myParameter: mySecurityManagerPlugin.PluginParameter));
}
//so lets take the default one
var defaultSecurityManagerName = _applicationSettings.Get <DefaultSecurityManagerImplementation>();
return(_graphDBPluginManager.GetAndInitializePlugin <ISecurityManager>(defaultSecurityManagerName, myParameter: new Dictionary <string, object> {
{ "vertexStore", _transactionManager }
}));
}
/// <summary>
///
/// </summary>
/// <param name="p"></param>
/// <param name="e"></param>
/// <returns></returns>
public bool OnPluginLoadError(PluginDefinition p, Exception e)
{
if (errCount++ < errMax)
{
MessageBox.Show(makeErrorMessage(p, e),
"Plugin " + p.dirName + " can not be loaded");
//! "プラグイン"+p.dirName+"がロードできません");
return(false);
}
else
{
MessageBox.Show("There are too many plugin loading errors");
//! MessageBox.Show("プラグインのロードエラーが多すぎます");
return(true);
}
}
/// <summary>
///
/// </summary>
/// <param name="p_1st"></param>
/// <param name="p_2nd"></param>
/// <param name="e"></param>
/// <returns></returns>
public bool OnNameDuplicated(PluginDefinition p_1st, PluginDefinition p_2nd, Exception e)
{
if (errCount++ < errMax)
{
MessageBox.Show(makeErrorMessage(p_2nd, e),
"Plugin " + p_2nd.dirName + " is loaded in more than one instance");
//! "プラグイン"+p_2nd.dirName+"が二重に読み込まれました");
return(false);
}
else
{
MessageBox.Show("There are too many plugin loading errors");
//! MessageBox.Show("プラグインのロードエラーが多すぎます");
return(true);
}
}
public void GenerateManifest_GeneratesCorrectManifest()
{
// Arrange
var plugin = new PluginDefinition(typeof(Plugin));
var actions = new List <ActionDefinition>
{
new ActionDefinition(typeof(Action))
};
var sut = new ManifestGenerator(plugin, actions);
// Act
string manifestJson = sut.GenerateManifest();
// Assert
Approvals.Verify(manifestJson);
}
/// <summary>
/// Load the transaction manager
/// </summary>
/// <param name="myTransactionManagerPlugin">The transaction manager plugin definition</param>
private ITransactionManager LoadTransactionManagerPlugin(PluginDefinition myTransactionManagerPlugin)
{
if (myTransactionManagerPlugin != null)
{
return(_graphDBPluginManager.GetAndInitializePlugin <ITransactionManager>(myTransactionManagerPlugin.NameOfPlugin, myParameter: myTransactionManagerPlugin.PluginParameter));
}
//so there is no given plugin... lets try the IGraphFS
if (_iGraphFS.IsTransactional)
{
return((ITransactionManager)_iGraphFS);
}
//so lets take the default one
var defaultTransactionManagerName = _applicationSettings.Get <DefaultTransactionManagerImplementation>();
return(_graphDBPluginManager.GetAndInitializePlugin <ITransactionManager>(defaultTransactionManagerName, myParameter: new Dictionary <string, object> {
{ "vertexStore", _iGraphFS }
}));
}
private bool Equals(PluginDefinition other)
{
return(string.Equals(Id, other.Id) && string.Equals(TypeName, other.TypeName));
}
private void ConfigureManagement(PluginDefinition plugin, XElement xml)
{
var menuElement = xml.Element("management-menu");
if (menuElement != null)
{
var menu = XmlMenuLoader.LoadMenu(menuElement);
RecursivelyAdjustMenuItems(menu.Items, plugin);
plugin.Menu = menu;
}
}
private void ConfigurePermissions(PluginDefinition plugin, XElement xml)
{
var groups = new PermissionGroupCollection();
foreach (var element in xml.Elements())
{
var group = PermissionGroup.From(element, plugin);
groups.Add(group);
}
plugin.PermissionGroups = groups;
}
/// <summary>
/// Plugin initialization method
/// </summary>
/// <param name="pluginDef"></param>
public void Init(PluginDefinition pluginDef)
{
this.Initialize(pluginDef.DeserializeSettings <BundleResolverSettings>());
}
public void Init(PluginDefinition pluginDef)
{
Assert.DoesNotThrow(() => this.Settings = pluginDef.DeserializeSettings<DummySettings>());
}
public void Init(PluginDefinition pluginDef)
{
MachineCertResolverSettings settings = pluginDef.DeserializeSettings <MachineCertResolverSettings>();
m_innerResolver = settings.CreateResolver();
}
private void Configure(PluginDefinition plugin)
{
string configFilePath = Server.MapPath(UrlUtil.Combine(plugin.VirtualPath, "config.config"));
if (File.Exists(configFilePath))
{
var xml = XDocument.Load(configFilePath).Root;
var displayName = xml.ChildElementValue("display-name");
if (!String.IsNullOrEmpty(displayName))
{
plugin.DisplayName = new LocalizableText(displayName);
plugin.DisplayName.ResourceDescriptor.PluginName = plugin.Name;
}
var description = xml.ChildElementValue("description");
if (!String.IsNullOrEmpty(description))
{
plugin.Description = new LocalizableText(description);
plugin.Description.ResourceDescriptor.PluginName = plugin.Name;
}
var managementElement = xml.Element("management");
if (managementElement != null)
{
ConfigureManagement(plugin, managementElement);
}
var permissionsElement = xml.Element("permissions");
if (permissionsElement != null)
{
ConfigurePermissions(plugin, permissionsElement);
}
}
}
/// <summary>
/// Plugin initialization method
/// </summary>
/// <param name="pluginDef"></param>
public void Init(PluginDefinition pluginDef)
{
this.Initialize(pluginDef.DeserializeSettings<BundleResolverSettings>());
}
/// <summary>
/// Plugin Resolver factory method.
/// Set injected settings and load actual resolver.
/// </summary>
/// <param name="pluginDef"></param>
public void Init(PluginDefinition pluginDef)
{
var settings = pluginDef.DeserializeSettings<DnsCertResolverSettings>();
m_innerResolver = settings.CreateResolver();
}
/// <summary>
/// For initialization as a plugin
/// </summary>
/// <param name="pluginDef">Plugin definition</param>
public void Init(PluginDefinition pluginDef)
{
MultiSourceAnchorResolverSettings settings = pluginDef.DeserializeSettings<MultiSourceAnchorResolverSettings>();
settings.Validate();
this.Init(settings);
}
public void Init(PluginDefinition pluginDef)
{
Assert.Null(Record.Exception(() => this.Settings = pluginDef.DeserializeSettings <DummySettings>()));
}
public void Init(PluginDefinition pluginDef)
{
Settings = pluginDef.DeserializeSettings <StubPluginReciverSettings>();
}
public void Init(PluginDefinition pluginDef)
{
this.Settings = pluginDef.DeserializeSettings <HttpSettings>();
}
/// <summary>
/// Load the IGraphQL plugins
/// </summary>
private IGraphQL LoadIGraphQLPlugins(PluginDefinition myIGraphQLPlugin)
{
return(_pluginManager.GetAndInitializePlugin <IGraphQL>(myIGraphQLPlugin.NameOfPlugin, myParameter: myIGraphQLPlugin.PluginParameter));
}
public void Init(PluginDefinition pluginDef)
{
var settings = pluginDef.DeserializeSettings <CustomStaticDomainResolverSettings>();
m_innerResolver = settings.CreateResolver();
}
/// <summary>
/// Method triggered when the user selects a plugin to inspect
/// </summary>
private void PluginsList_SelectedIndexChanged(object sender, EventArgs e)
{
// Pick out the plugin that is to be viewed
CurrentPlugin = _core.Plugins[PluginsList.SelectedIndex];
ListPluginContent();
}
public PluginDefinition Load(string pluginName, IEnumerable<Assembly> assemblies)
{
var plugin = new PluginDefinition(pluginName);
Configure(plugin);
if (assemblies != null)
{
plugin.Assemblies = assemblies.ToList();
var extensionTypes = FindExtensionTypes(assemblies);
plugin.PluginType = extensionTypes.PluginType;
if (extensionTypes.NhMappingProviderType != null)
NhMappingProviders.Register(pluginName, extensionTypes.NhMappingProviderType);
if (extensionTypes.PageLifecycleInterceptorTypes.Count > 0)
{
PageLifecycleInterceptors.Register(pluginName,
extensionTypes.PageLifecycleInterceptorTypes.Select(t => (IPageLifecycleInterceptor)Activator.CreateInstance(t)));
}
}
var widgetBaseFolderPath = HostingEnvironment.MapPath(PluginPaths.WidgetsFolderVirtualPath(pluginName));
if (Directory.Exists(widgetBaseFolderPath))
{
foreach (var widgetFolder in Directory.GetDirectories(widgetBaseFolderPath))
{
var widget = _widgetLoader.LoadWidget(plugin, Path.GetFileName(widgetFolder));
plugin.Widgets.Add(widget);
}
}
// load widget controllers
if (assemblies != null)
{
foreach (var type in assemblies.SelectMany(asm => asm.GetTypes()))
{
if (!typeof(IWidgetController).IsAssignableFrom(type))
{
continue;
}
var attr = type.GetCustomAttribute<WidgetControllerAttribute>();
if (attr == null)
{
continue;
}
var widgetName = attr.WidgetName;
if (String.IsNullOrEmpty(widgetName))
{
widgetName = type.Name;
foreach (var suffix in _widgetControllerSuffixes)
{
if (widgetName.EndsWith(suffix) && widgetName.Length > suffix.Length)
{
widgetName = widgetName.Substring(0, widgetName.Length - suffix.Length);
break;
}
}
}
var widget = plugin.FindWidget(widgetName);
if (widget != null)
{
widget.WidgetControllerType = type;
}
}
}
return plugin;
}
public ManifestGenerator(PluginDefinition plugin, List <ActionDefinition> actions)
{
_plugin = plugin;
_actions = actions;
}
private void RecursivelyAdjustMenuItems(IEnumerable<XmlMenuItem> items, PluginDefinition plugin)
{
foreach (var item in items)
{
if (item.NavigateUrl != null && !item.NavigateUrl.StartsWith("/"))
{
item.NavigateUrl = UrlUtil.ToAbsoluteHtmlPath(UrlUtil.Combine(plugin.VirtualPath, item.NavigateUrl));
}
item.Title.ResourceDescriptor.PluginName = plugin.Name;
if (String.IsNullOrEmpty(item.Plugin))
{
item.Plugin = plugin.Name;
}
RecursivelyAdjustMenuItems(item.Items, plugin);
}
}
public void Init(PluginDefinition pluginDef)
{
//noop
}
public void Init(PluginDefinition pluginDef)
{
var settings = pluginDef.DeserializeSettings<CustomStaticDomainResolverSettings>();
m_innerResolver = settings.CreateResolver();
}
