//--- Methods ---
public XDoc ToXml()
{
XDoc result = new XDoc("group");
result.Attr("name", Name);
if (HasCustom)
{
foreach (KeyValuePair <string, string> custom in ArrayUtil.AllKeyValues(Custom))
{
result.Elem(custom.Key, custom.Value);
}
}
return(result);
}
//--- Methods ---
public XDoc ToXml()
{
XDoc result = new XDoc("user");
result.Attr("name", Name);
if (Email != null)
{
result.Elem("email", Email);
}
if (HasCustom)
{
foreach (KeyValuePair <string, string> custom in ArrayUtil.AllKeyValues(Custom))
{
result.Elem(custom.Key, custom.Value);
}
}
result.Start("groups");
foreach (Group group in Groups)
{
result.Add(group.ToXml());
}
result.End();
return(result);
}
//--- Class Methods ---
public static ServiceBE StartService(ServiceBE service, bool forceRefresh, bool disableOnFailure)
{
// create subordinate request id for service start
var dreamContext = DreamContext.Current;
var requestId = dreamContext.GetState <string>(DreamHeaders.DREAM_REQUEST_ID);
dreamContext.SetState(DreamHeaders.DREAM_REQUEST_ID, requestId + "-service_" + service.Id);
try {
var stopwatch = Stopwatch.StartNew();
service.ServiceLastStatus = string.Empty;
StopService(service.Id, service, ServiceStopType.Restart);
DekiContext context = DekiContext.Current;
bool dirtyServiceEntity = false;
XUri location;
ServiceRepository.IServiceInfo serviceInfo = null;
try {
// check if service is local
if (service.ServiceLocal)
{
if (string.IsNullOrEmpty(service.SID))
{
throw new Exception("missing SID");
}
// start service
if (IsLocalAuthService(service))
{
// this service is the built-in authentication provider; no need to start it
location = context.Deki.Self;
}
else
{
// convert local service configuration into an xdoc
XDoc config = new XDoc("config");
foreach (KeyValuePair <string, string> configEntry in ArrayUtil.AllKeyValues(service.Config))
{
config.InsertValueAt(configEntry.Key, configEntry.Value);
}
// if no apikey was provided, create a random one so that CreateService doesn't inject the parent one
if (config["apikey"].IsEmpty)
{
config.Elem("apikey", StringUtil.CreateAlphaNumericKey(16));
}
// add information for service to callback into deki
if (config["uri.deki"].IsEmpty)
{
config.Elem("uri.deki", context.Deki.Self);
config.Elem("wikiid.deki", context.Instance.Id);
// Providing master apikey to service for setups that don't use per instance keys
config.Elem("apikey.deki", context.Instance.ApiKey.IfNullOrEmpty(context.Deki.MasterApiKey));
}
// the service location must use the service ID and the instance ID
string servicePath = string.Format("services/{0}/{1}", context.Instance.Id, service.Id);
_log.DebugFormat("starting service '{0}' at path {1} w/ namespace {2}", service.SID, servicePath, service.Preferences["namespace"]);
serviceInfo = context.Instance.CreateLocalService(service, servicePath, config);
location = serviceInfo.ServiceUri;
}
// check if the service uri has changed since last invocation (happens when service is started for the first time or server GUID has changed)
if (!service.Uri.EqualsInvariantIgnoreCase(location.ToString()))
{
dirtyServiceEntity = true;
service.Uri = location.ToString();
}
}
else
{
_log.DebugFormat("registering remote service '{0}'", service.SID);
if (string.IsNullOrEmpty(service.Uri))
{
throw new Exception("missing URI");
}
location = new XUri(service.Uri);
serviceInfo = context.Instance.RegisterRemoteService(service, location);
}
// check if service is an Extension service
if (service.Type == ServiceType.EXT)
{
if (service.ServiceLocal)
{
_log.DebugFormat("registering service '{0}' as extension", service.SID);
}
ExtensionBL.StartExtensionService(context, service, serviceInfo, forceRefresh);
}
//Successfully starting a service enables it.
if (!service.ServiceEnabled)
{
dirtyServiceEntity = true;
service.ServiceEnabled = true;
}
} catch (Exception e) {
dirtyServiceEntity = true;
DreamMessage dm = null;
if (e is DreamResponseException)
{
dm = ((DreamResponseException)e).Response;
string message = dm.HasDocument ? dm.ToDocument()[".//message"].AsText.IfNullOrEmpty(e.Message) : dm.ToText();
service.ServiceLastStatus = string.Format("unable to initialize service ({0})", message);
}
else
{
service.ServiceLastStatus = e.GetCoroutineStackTrace();
}
if (serviceInfo != null)
{
try {
context.Instance.DeregisterService(service.Id);
} catch { }
}
// A service that fails to start becomes disabled if it's started explicitly (not during deki startup)
if (disableOnFailure)
{
service.ServiceEnabled = false;
}
_log.ErrorExceptionMethodCall(e, "StartService", string.Format("Unable to start local service id '{0}' with SID '{1}' Error: '{2}'", service.Id, service.SID, service.ServiceLastStatus));
if (dm != null)
{
throw new ExternalServiceResponseException(dm);
}
else
{
throw;
}
} finally {
// don't update remote services that haven't changed
if (dirtyServiceEntity)
{
service = UpdateService(service);
}
}
stopwatch.Stop();
_log.InfoFormat("Service '{0}' ({1}) started in {2}ms", service.Description, service.SID, stopwatch.ElapsedMilliseconds);
return(service);
} finally {
// restore the request id
dreamContext.SetState(DreamHeaders.DREAM_REQUEST_ID, requestId);
}
}
