} // func CreateDictionary
/// <summary></summary>
/// <param name="configItem"></param>
/// <param name="id"></param>
/// <param name="displayName"></param>
/// <param name="listDescriptor"></param>
/// <param name="comparer"></param>
/// <returns></returns>
public static DEDictionary <TKey, TItem> CreateSortedList(DEConfigItem configItem, string id, string displayName, IDEListDescriptor listDescriptor = null, IComparer <TKey> comparer = null)
{
return(new DEDictionary <TKey, TItem>(configItem, id, displayName,
listDescriptor ?? DEConfigItem.CreateListDescriptorFromType(typeof(KeyValuePair <TKey, TItem>)),
new SortedDictionary <TKey, TItem>(comparer ?? Comparer <TKey> .Default)
));
} // func CreateSortedList
} // proc CloseEventSessions
#region -- Events -----------------------------------------------------------------
public void AppendNewEvent(DEConfigItem item, string eventId, string index, XElement values = null)
{
lock (propertyChanged)
{
if (currentRevision == sendedRevision)
{
currentRevision++;
}
CleanOutdatedEvents();
var configPath = item.ConfigPath;
var key = GetEventKey(configPath, eventId, index);
FiredEvent ev;
if (propertyChanged.TryGetValue(key, out ev))
{
ev.Reset(currentRevision, values);
}
else
{
propertyChanged[key] = ev = new FiredEvent(currentRevision, configPath, eventId, index, values);
}
// web socket event handling
FireEventOnSocket(configPath, eventId, ev.GetEvent());
}
} // proc AppendNewEvent
private XElement HttpDumpAction(bool mini = false)
{
// check for the procdump.exe
var procDump = Config.Element(xnServer)?.GetAttribute("procdump", String.Empty);
if (String.IsNullOrEmpty(procDump) || !File.Exists(procDump))
{
throw new ArgumentException("procdump.exe is not available.");
}
// prepare arguments
var sbArgs = new StringBuilder();
if (!mini)
{
sbArgs.Append("-ma "); // dump all
}
sbArgs.Append("-o "); // overwrite existing dump
sbArgs.Append("-accepteula "); // accept eula
sbArgs.Append(Process.GetCurrentProcess().Id).Append(' '); // process id
// create the dump in the temp directory
DumpFileInfo fi;
using (dumpFiles.EnterWriteLock())
{
var newId = ++lastDumpFileInfoId;
dumpFiles.Add(fi = new DumpFileInfo(newId, Path.Combine(Path.GetTempPath(), $"DEServer_{newId:000}.dmp")));
}
sbArgs.Append(fi.FileName);
// prepare calling procdump
ProcessStartInfo psi = new ProcessStartInfo(procDump, sbArgs.ToString());
psi.UseShellExecute = false;
psi.RedirectStandardOutput = true;
using (var p = Process.Start(psi))
{
if (!p.WaitForExit(5 * 60 + 1000))
{
p.Kill();
}
var outputText = p.StandardOutput.ReadToEnd();
return(DEConfigItem.SetStatusAttributes(
new XElement("return",
new XAttribute("id", fi.Id),
new XAttribute("exitcode", p.ExitCode)
),
p.ExitCode > 0,
outputText
));
}
} // proc HttpDumpAction
public DEListControllerBase(DEConfigItem configItem, IDEListDescriptor descriptor, string id, string displayName)
{
this.configItem = configItem;
this.id = id;
this.displayName = displayName;
this.descriptor = descriptor;
this.listLock = new ReaderWriterLockSlim(LockRecursionPolicy.SupportsRecursion);
configItem.RegisterList(id, this);
} // ctor
public ConfigItemProperty(DEConfigItem configItem, PropertyDescriptor property)
{
var name = (PropertyNameAttribute)property.Attributes[typeof(PropertyNameAttribute)];
var format = (FormatAttribute)property.Attributes[typeof(FormatAttribute)];
Init(configItem,
name != null && !String.IsNullOrEmpty(name.Name) ? Name = name.Name : property.ComponentType.Name + "_" + property.Name,
format != null ? format.Format : null,
property
);
} // ctor
public void TestDictionaryDescriptor()
{
var descriptor = DEConfigItem.CreateListDescriptorFromType(typeof(KeyValuePair <string, IDEConfigItemProperty>));
var typeString = GetListTypeString(descriptor);
Assert.AreEqual("<?xml version=\"1.0\" encoding=\"utf-16\"?><property><attribute name=\"key\" type=\"string\" /><attribute name=\"name\" type=\"string\" /><attribute name=\"displayname\" type=\"string\" /><attribute name=\"category\" type=\"string\" /><attribute name=\"description\" type=\"string\" /><attribute name=\"format\" type=\"string\" /><attribute name=\"type\" type=\"type\" /><element type=\"object\" /></property>", typeString);
var rowString = GetListItemString(descriptor, new KeyValuePair <string, IDEConfigItemProperty>("key", new SimpleConfigItemProperty <int>(null, "Name", "DisplayName", "Category", "Description", "N0", 23)));
Assert.AreEqual("<?xml version=\"1.0\" encoding=\"utf-16\"?><property key=\"key\" name=\"Name\" displayname=\"DisplayName\" category=\"Category\" description=\"Description\" format=\"N0\" type=\"int\">23</property>", rowString);
}
} // ctor
private void Init(DEConfigItem configItem, string name, string format, PropertyDescriptor property)
{
this.configItem = configItem;
this.property = property;
this.Name = name;
this.Format = format;
this.property = property;
valueChangedHandler = ValueChangedHandler;
} // proc Init
} // proc Dispose
#endregion
#region -- Configuration ----------------------------------------------------------
private static void CollectCronJobItems(List <ICronJobItem> cronItems, DEConfigItem current)
{
if (current is ICronJobItem)
{
cronItems.Add((ICronJobItem)current);
}
else // No recursion, for nested cron jobs
{
foreach (var c in current.UnsafeChildren)
{
CollectCronJobItems(cronItems, c);
}
}
} // proc CollectCronJobItems
} // proc Disposing
private void GetFullName(DEConfigItem cur, StringBuilder sb)
{
if (cur == null)
{
return;
}
// Vorgänger
GetFullName(cur.Owner as DEConfigItem, sb);
// AKtuelle
if (sb.Length > 0)
{
sb.Append('\\');
}
sb.Append(cur.Name);
} // func GetFullName
} // ctor
/// <summary></summary>
/// <param name="item"></param>
/// <param name="context"></param>
/// <param name="log"></param>
/// <returns></returns>
public object Invoke(DEConfigItem item, IDEWebRequestScope context, LogMessageScopeProxy log = null)
{
if (action != null)
{
if (isNativeCall)
{
action(item, context, log);
return(DBNull.Value);
}
else
{
return(action(item, context, log));
}
}
else
{
return(null);
}
} // proc Invoke
} // ctor
public object Invoke(DEConfigItem item, IDEContext context)
{
if (action != null)
{
if (isNativeCall)
{
action(item, context);
return(DBNull.Value);
}
else
{
return(action(item, context));
}
}
else
{
return(null);
}
} // proc Invoke
} // proc UseNode
#endregion
#region -- List -----------------------------------------------------------------
private IEnumerable <XElement> GetNodeList(DEConfigItem current, bool recusive)
{
using (currentItem.EnterReadLock())
{
foreach (var c in current.UnsafeChildren)
{
var x = new XElement("n",
new XAttribute("name", c.Name),
new XAttribute("displayName", c.DisplayName)
);
if (recusive)
{
x.Add(GetNodeList(c, true));
}
yield return(x);
}
}
} // func GetNodeList
} // proc CloseEventSessions
#endregion
#region -- Events -------------------------------------------------------------
public void AppendNewEvent(DEConfigItem item, string securityToken, string eventId, string index, XElement values = null)
{
lock (propertyChanged)
{
if (currentRevision == sendedRevision)
{
currentRevision++;
}
CleanOutdatedEvents();
var configPath = item.ConfigPath;
var key = GetEventKey(configPath, eventId, index);
if (propertyChanged.TryGetValue(key, out var ev))
{
ev.Reset(currentRevision, values);
}
else
{
propertyChanged[key] = ev = new FiredEvent(currentRevision, configPath, eventId, index, values);
}
// use security from item as default
if (String.IsNullOrEmpty(securityToken))
{
securityToken = item.SecurityToken;
}
// internal event handling, copy the event session, because they might changed during the post
EventSession[] currentSventSessions;
using (eventSessions.EnterReadLock())
currentSventSessions = eventSessions.List.Cast <EventSession>().ToArray();
foreach (var es in currentSventSessions)
{
es.TryPostNotify(configPath, securityToken, eventId, ev.GetEvent(), CancellationToken.None);
}
}
} // proc AppendNewEvent
} // proc UseItem
private void UseNode(DEConfigItem current, string path, int offset)
{
if (offset >= path.Length)
{
currentItem = current;
return;
}
else
{
var pos = path.IndexOf('/', offset);
if (pos == offset)
{
throw new ArgumentException("Invalid path format.");
}
if (pos == -1)
{
pos = path.Length;
}
if (pos - offset == 0) // end
{
this.currentItem = current;
}
else // find node
{
var currentName = path.Substring(offset, pos - offset);
var newCurrent = current.UnsafeFind(currentName);
if (newCurrent == null)
{
throw new ArgumentException("Invalid path.");
}
UseNode(newCurrent, path, pos + 1);
}
}
} // proc UseNode
private DEDictionary(DEConfigItem configItem, string id, string displayName, IDEListDescriptor listDescriptor, IDictionary <TKey, TItem> innerDictionary)
: base(configItem, listDescriptor, id, displayName)
{
this.innerDictionary = innerDictionary;
} // ctor
} // ctor
public ConfigItemProperty(DEConfigItem configItem, string name, string format, PropertyDescriptor property)
{
Init(configItem, name, format, property);
} // ctor
public DEList(DEConfigItem configItem, string id, string displayName)
: base(configItem, DEConfigItem.CreateListDescriptorFromType(typeof(T)), id, displayName)
{
} // ctor
} // ctor
public DEDictionary(DEConfigItem configItem, string id, string displayName, IComparer <TKey> comparer)
: base(configItem, null, id, displayName)
{
this.innerDictionary = new SortedDictionary <TKey, TItem>(comparer == null ? Comparer <TKey> .Default : comparer);
} // ctor
public ConfigActionDictionary(DEConfigItem configItem)
: base(configItem, ConfigActionListDescriptor.Instance, ActionsListId, "Actions")
{
} // ctor
