private IDictionary <string, object> RpcGetConfiguration(string uuid)
{
IUserObject instance = m_mot.GetInstance(Guid.Parse(uuid));
if (instance == null)
{
throw new ArgumentException("No such object.");
}
IDictionary <string, object> config = m_mot.GetConfiguration(instance.UUID);
if (config == null)
{
throw new ArgumentException("Object does not have a configuration.");
}
// Set up the result
Dictionary <string, object> result = new Dictionary <string, object>();
result["active"] = config;
IConfigurationDescription configDescription = m_mot.GetConfigurationDescription(instance.UUID);
List <IDictionary <string, object> > details = new List <IDictionary <string, object> >();
foreach (IConfigurationValue value in configDescription)
{
details.Add(value.Pack());
}
result["details"] = details;
return(result);
}
private IDictionary <string, string> RpcSetConfiguration(string uuid, IDictionary <string, object> config)
{
// Make sure the object ID is valid
IUserObject instance = m_mot.GetInstance(Guid.Parse(uuid));
if (instance == null)
{
throw new ArgumentException("No such object.");
}
// Make sure it is an object and it is configurable
if (instance.ObjectType.IsFactory() || !(instance is IConfigurable))
{
throw new ArgumentException("Cannot apply configuration to this type of object.");
}
// Get the matching configuration description
IConfigurationDescription desc = m_mot.GetConfigurationDescription(instance.UUID);
if (desc == null)
{
throw new ArgumentException("No configuration description available for object.");
}
// Verify the configuration
Dictionary <string, string> failures = new Dictionary <string, string>();
config = desc.Verify(config, failures);
if (config != null)
{
IConfigurable configurable = instance as IConfigurable;
if (configurable.ValidateConfiguration(desc, config, failures))
{
configurable.ApplyConfiguration(desc, config);
}
}
return(failures);
}
public override AbstractAction CreateInstance(Guid id, IConfigurationDescription description, IDictionary <string, object> values)
{
ScriptAction action = new ScriptAction(id);
action.ApplyConfiguration(description, values);
return(action);
}
/// <summary>
/// Extract information for a class.
/// </summary>
/// <param name="assembly"></param>
/// <param name="className"></param>
/// <param name="defaultLang"></param>
/// <param name="element"></param>
private static void ProcessClass(Assembly resources, string assembly, string className, string defaultLang, XElement element)
{
MasterObjectTable mot = Locator.Current.GetService <MasterObjectTable>();
// Get the descriptions
IEnumerable <XElement> nodes =
from node in element.Descendants(DescriptionTag)
select node;
if (nodes.Count() > 0)
{
// Process the description
LogHost.Default.Debug("Loading description definition for class '{0}'", className);
ObjectDescription description = ProcessDescription(defaultLang, nodes.First());
if ((description.Icon != null) && (description.Icon.Length > 0))
{
description.Icon = CopyIconImage(resources, assembly, description.Icon);
}
mot.AddDescription(className, description);
}
// Get the configurations
nodes =
from node in element.Descendants(ConfigurationTag)
select node;
if (nodes.Count() > 0)
{
// Process the configuration
LogHost.Default.Debug("Loading configuration definition for class '{0}'", className);
IConfigurationDescription config = ProcessConfiguration(defaultLang, nodes.First());
if (config != null)
{
mot.AddConfigurationDescription(className, config);
}
}
}
/// <summary>
/// Constructor
/// </summary>
public ServiceManager()
{
// Add ourselves to the MOT
MasterObjectTable mot = Locator.Current.GetService <MasterObjectTable>();
mot.AddMetaData(Utilities.GetContainingAssembly <ServiceManager>());
mot.AddInstance(this);
// Load and apply our configuration (IFolder must be available by now)
IConfigurationDescription serverConfigDescription = mot.GetConfigurationDescription(UUID);
IDictionary <string, object> serverConfig = mot.GetConfigurationFromFile(UUID, "SensHub.json");
ApplyConfiguration(serverConfigDescription, serverConfig);
}
/// <summary>
/// Add a configuration description for a given class name
/// </summary>
/// <param name="clsName"></param>
/// <param name="configuration"></param>
internal void AddConfigurationDescription(string clsName, IConfigurationDescription configuration)
{
lock (m_configinfo)
{
if (m_configinfo.ContainsKey(clsName))
{
this.Log().Warn("Configuration information already registered for class '{0}'", clsName);
}
else
{
m_configinfo[clsName] = configuration;
}
}
}
/// <summary>
/// Apply the configuration values
/// </summary>
/// <param name="description"></param>
/// <param name="values"></param>
public void ApplyConfiguration(IConfigurationDescription description, IDictionary <string, object> values)
{
// Get the logging level
LogLevel logLevel;
if (!Enum.TryParse <LogLevel>(description.GetAppliedValue(values, "logLevel").ToString(), out logLevel))
{
logLevel = LogLevel.Warn;
}
LogLevel = logLevel;
// Get the HTTP port
HttpPort = (int)description.GetAppliedValue(values, "httpPort");
// Get the server password
Password = (string)description.GetAppliedValue(values, "password");
}
public override void ApplyConfiguration(IConfigurationDescription description, IDictionary<string, object> values)
{
throw new NotImplementedException();
}
public override AbstractAction CreateInstance(Guid id, IConfigurationDescription description, IDictionary<string, object> values)
{
ScriptAction action = new ScriptAction(id);
action.ApplyConfiguration(description, values);
return action;
}
public bool ValidateConfiguration(IConfigurationDescription description, IDictionary<string, object> values, IDictionary<string, string> failures)
{
// TODO: Implement this
return true;
}
/// <summary>
/// Apply the configuration values
/// </summary>
/// <param name="description"></param>
/// <param name="values"></param>
public void ApplyConfiguration(IConfigurationDescription description, IDictionary<string, object> values)
{
// Get the logging level
LogLevel logLevel;
if (!Enum.TryParse<LogLevel>(description.GetAppliedValue(values, "logLevel").ToString(), out logLevel))
logLevel = LogLevel.Warn;
LogLevel = logLevel;
// Get the HTTP port
HttpPort = (int)description.GetAppliedValue(values, "httpPort");
// Get the server password
Password = (string)description.GetAppliedValue(values, "password");
}
/// <summary>
/// Get information about an object.
/// </summary>
/// <param name="forInstance"></param>
/// <param name="instance"></param>
/// <param name="description"></param>
/// <returns></returns>
private bool GetObjectInformation(Guid forInstance, out IUserObject instance, out IConfigurationDescription description)
{
description = null;
instance = GetInstance(forInstance);
if (instance == null)
{
this.Log().Warn("Requested configuration for non-existant object '{0}'", forInstance);
return(false);
}
IConfigurable configurable = instance as IConfigurable;
if (configurable == null)
{
this.Log().Warn("Requested configuration for unconfigurable object '{0}' (Class {1}.{2})", forInstance, instance.GetType().Namespace, instance.GetType().Name);
return(false);
}
description = GetConfigurationDescription(forInstance);
if (description == null)
{
this.Log().Warn("No configuration description for object '{0}' (Class {1}.{2})", forInstance, instance.GetType().Namespace, instance.GetType().Name);
return(false);
}
return(true);
}
public abstract AbstractAction CreateInstance(Guid id, IConfigurationDescription description, IDictionary <string, object> values);
public abstract void ApplyConfiguration(IConfigurationDescription description, System.Collections.Generic.IDictionary <string, object> values);
public virtual bool ValidateConfiguration(IConfigurationDescription description, System.Collections.Generic.IDictionary <string, object> values, System.Collections.Generic.IDictionary <string, string> failures)
{
// Default is to do nothing
return(true);
}
public bool ValidateConfiguration(IConfigurationDescription description, IDictionary <string, object> values, IDictionary <string, string> failures)
{
// TODO: Implement this
return(true);
}
/// <summary>
/// Enable the plugin
/// </summary>
/// <returns></returns>
public bool EnablePlugin()
{
// Add the plugin to the MOT on the assumption it will work
MasterObjectTable mot = Locator.Current.GetService <MasterObjectTable>();
mot.AddInstance(m_plugin);
// If the plugin supports configuration we need to give it one before
// initialisation
IConfigurable configurable = m_plugin as IConfigurable;
if (configurable != null)
{
IConfigurationDescription description = mot.GetConfigurationDescription(m_plugin.UUID);
IDictionary <string, object> values = mot.GetConfiguration(m_plugin.UUID);
Dictionary <string, string> failures = new Dictionary <string, string>();
if (!configurable.ValidateConfiguration(description, values, failures))
{
StringBuilder sb = new StringBuilder();
string separator = "";
foreach (KeyValuePair <string, string> message in failures)
{
sb.Append(separator);
separator = ", ";
sb.Append(String.Format("'{0}' - {1}", message.Key, message.Value));
}
this.Log().Error("One or more configuration values are not applicable - " + sb.ToString());
mot.RemoveInstance(m_plugin.UUID);
return(false);
}
try
{
configurable.ApplyConfiguration(description, values);
}
catch (Exception ex)
{
this.Log().Error("Unable to apply configuration to plugin - {0}.", ex.ToString());
mot.RemoveInstance(m_plugin.UUID);
return(false);
}
}
// Now try and initialise it
bool initialised = false;
try
{
initialised = m_plugin.Initialise(this);
if (initialised)
{
this.Log().Info("Initialised plugin");
}
else
{
this.Log().Error("Failed to initialise plugin.");
}
}
catch (Exception ex)
{
this.Log().Error("Failed to initialise plugin - {0}", ex.Message);
}
if (!initialised)
{
mot.RemoveInstance(m_plugin.UUID);
}
return(initialised);
}
public override void ApplyConfiguration(IConfigurationDescription description, IDictionary <string, object> values)
{
throw new NotImplementedException();
}
