Software Specification
IPOT
Insite Process Observation Tool
insite GmbH
Introduction#
IPOT (Insite Process Observation Tool) is a modular configurable software application for monitoring, starting and controlling processes and their windows.
Purpose and Objective##
On an automation computer it is necessary to monitor and control several different programs. Even though you can fall back on Windows tools in the process, the program IPOT is much more convenient and powerful for this purpose.
Definitions, acronyms, abbreviations##
- IPOT: Insite Process Observation Tool
- PLC: Programmable Logic Controller
- GUI: graphical user interface --> user interface
- Assembly: An Assembly is a logical functional unit that is executed under the control of the Common Language Runtime (CLR) of .NET. An Assembly physically exists as a .dll or .exe file
- Process: Executed application
- Event: A signal that is fired to different places in the program, and can be reacted to by means of actions
- Action: Defines actions that can be parameterised on events
- Observer: Defines observations that, in turn, can fire events
General Description#
The special features and setting options of the software are described below.
System Environment##
The software is written with C# Visual Studio 2012 for the target framework .NET 4.
Start parameter##
IPOT can be started with different parameters. Since an IPOT is a single instance application, if an IPOT instance is already running, the parameters are transferred to the existing instance and the current instance is terminated again.
| Param | Param | Description |
|---|---|---|
| Short | Long | |
| c | config | Specifies the path to the configuration file |
| (default: IPOT.config) | ||
| g | group | Specifies which group in the GUI should be displayed. |
| If this parameter is specified, only the specified group is | ||
| displayed, and all other groups are thus disabled. | ||
| v | view | If a POTObject ID is specified, the event GUIProcessShow |
| is fired to this ID | ||
| a | arg | This parameter can be specified together with –v and |
| ensures that these arguments are given to the process to be | ||
| started. (Attention: These arguments take priority over the | ||
| configured arguments, i.e. if arguments with –a were | ||
| transferred, then the parameterised arguments will not be | ||
| transferred. Furthermore, an ongoing process will be | ||
| terminated beforehand (if a corresponding action was | ||
| parameterised to the event GUIProcessStop and the setting | ||
| ProcessHandleInstances was set to false), so that the new | ||
| process can be started with the new arguments | ||
| u | update | Sets a config value (this value must be declared in the config, |
| however, i.e. it is only possible to change but not to add | ||
| In the case of events, adding is possible, too) | ||
| s | save | Saves the config change |
| e | exit | If an POTObject ID is specified, the event GUIProcessStop is |
| fired to this ID. (the ID for IPOT itself is "$IPOT$") |
Examples:
IPOT is started (if it is not yet running) and the group is set to IH.
IPOT.exe -cD:\Data\DH\Configs\Insite\IPOT.config –gIH
IPOT is started (if it is not yet running) and the application with the ID ArchiveImages is started. (If the corresponding actions were declared.) IPOT.exe -cD:\Data\DH\Configs\Insite\IPOT.config –vArchiveImages
IPOT is started (if it is not yet running), the application with the ID ArchiveImages is started and the arguments silent and -test are transferred. (If the corresponding actions were declared.)
IPOT.exe -cD:\Data\DH\Configs\Insite\IPOT.config –vArchiveImages –a"-silent
-test"
IPOT is started (if it is not yet running) and the setting for the program ICON_ALLG is adapted (Observe is set to False) and saved.
IPOT.exe -cD:\Data\DH\Configs\Insite\IPOT.config -uICON_ALLG.Observe=false –s
IPOT is started (if it is not yet running) and the setting for the program ICON_ALLG is adapted (Observe is set to False) and saved.
IPOT.exe -cD:\Data\DH\Configs\Insite\IPOT.config
-uParasave.GUIProcessStop=FindProcessOrWindowAction;3000;ProcessStopAction
IPOT is started (if it is not yet running) and the application with the ID ArchiveImages is terminated. (If the corresponding actions were declared.)
IPOT.exe -cD:\Data\DH\Configs\Insite\IPOT.config -eArchiveImages
IPOT is started (if it is not yet running) and the application with the ID ArchiveImages is set to Obser=false, this change is saved and the application is then terminated. (If the corresponding actions were declared.)
IPOT.exe -cD:\Data\DH\Configs\Insite\IPOT.config -uArchiveImages.Observe=false –s -eArchiveImages
Runtime Mode###
The tiles represent the individual processes, if a tile is red, the process is not found, or the file to be started is not available.
Colour definition:
Process is running or is not being monitored:
Restart is currently not permitted:
Process or window not found:
Engineering Mode###
Press the button in the top left hand corner to switch over to the Engineering Mode. In this mode you can view as well as change the individual observations. Finding windows is facilitated by the search function that you can find in the bottom right-hand corner of the Engineering Mode when opening the Expander. Simply drag the target icon onto the window from which you need data and add this by selecting the IPOTObject and clicking on "Add".
The old configuration with the extension .bak is saved by pressing the Save button and your changes are written to the new configuration. Each change is active immediately, but if the Save button is not pressed, then the changes will be lost when you exit. If a new object is added, it first becomes active after restarting the Observer!
Version information of all loaded assemblies##
To obtain information about all assemblies currently loaded, you can click on the INSITE-LOG in the upper right-hand corner. By clicking, all information is collected and displayed in a list. The entries of the list can be selected and copied to the clipboard by Copy&Paste. Clicking once again closes this version display and a new standard interface of IPOT is displayed again.
Password protection##
If a password is specified, this will be requested when terminating and changing to the Engineering Mode. If the password is correct, the green icon will appear, which simultaneously functions as a logoff button. As long as the password not valid, the red icon appears, which you can also use to terminate the input.
How does IPOT work?##
IPOT works event-based. At various places in the application, defined events are fired that can be linked to actions via the parameterisation. This principle of Action --> Reaction runs through the entire application, whereby any action in the application can be controlled via the parameterisation. This results in a freely configurable and very flexible program that can be used for a wide variety of applications.
Web-Interface#
IPOT also supports a WebAPI interface, the commands which are described in start parameters can also be used via this interface. These commands are HTTP Post requests.
Example:
IPOT starts (if it's not already running) and the group is set to IH.
POST /Commandline/Execute?password=1234
Host: http://localhost:8091
-cD:\Daten\DH\Konfigs\Insite\IPOT.config –gIH
Components#
IPOT consists of several subcomponents. These are divided into two main groups (Observers and Actions).
Observers##
Observers are started from IPOT and fire events to objects. These processing events can then be configured.
ProcessObserver###
The ProcessObserver checks cyclically until all marked objects are connected with IPOT. As soon as a component loses the connection again and a MinDownTime is parameterised, the Observer is executed again on this component. As long as a connection of the component with IPOT exists, the IPOTObject assumes all functions, which also include observation.
Configuration####
<component id="PlcObserver" service="IPOT.Arch.Interfaces.IObserver, Interfaces"
type="IPOT.Components.Observers.PlcObserver, PlcObserver"
lifestyle="singleton">
<parameters>
<active>true</active>
<cycle>1000</cycle>
<asyc>true</async>
</parameters>
</component>
| Parameter | Description |
|---|---|
| cycle | Checking interval, in this interval reading takes place from the Plc |
| async | Executes the observation of all projects in parallel |
| active | Activates the observer --> Default is true |
KeyObserver###
Various HotKeys and their functions can be parameterised on objects for the KeyObserver. By pressing a key, the parameterised event is then fired to the configured IPOT object/s.
Configuration####
<component id="KeyObserver" service="IPOT.Arch.Interfaces.IObserver, Interfaces"
type="IPOT.Components.Observers.KeyObserver, KeyObserver"
lifestyle="singleton">
<parameters>
<active>true</active>
<asyc>true</async>
<hotKeys>
<dictionary>
<entry key="F9">UDKeyObserverEvent1=*</entry>
<entry key="Alt+F9">UDKeyObserverEvent2=*</entry>
</dictionary>
</hotKeys>
</parameters>
</component>
| Parameter | Description |
|---|---|
| async | Fires an event for all objects simultaneously |
| active | Activates the observer --> Default is true |
| hotkeys | Here, the key, its event, and the components that the event was |
| applied to are to be parameterised: | |
| Key = F9 (or Alt+F9/Shift+F9/Ctrl+F9) | |
| Event = UserDefinedEvent1 | |
| Object = * = all IPOTObjects; empty = IPOT; otherwise the ID |
PlcObserver###
The PlcObserver checks cyclically whether anything has changed on the Plc data specified. If a change occurs, the PlcTrigger-event is fired for the respective object. Additionally, various triggers and their functions can also be parameterised on objects. When the trigger occurs, the parameterised event is then fired to the configured IPOT object/s.
Configuration####
<component id="ProcessObserver" service="IPOT.Arch.Interfaces.IObserver, Interfaces"
type="IPOT.Components.Observers.ProcessObserver, ProcessObserver"
lifestyle="singleton">
<parameters>
<active>true</active>
<cycle>10000</cycle>
<asyc>true</async>
<plcEvents>
<dictionary>
<entry key="DB2,1.0=true">UserDefinedEvent1=*</entry>
</dictionary>
</plcEvents>
</parameters>
</component>
| Parameter | Description |
|---|---|
| cycle | Checking interval, in this interval an attempt is made to find |
| processes that are not connected | |
| async | Fires an event for all objects simultaneously |
| active | Activates the observer --> Default is true |
| plcEvents | Here, a PLCTrigger is entered that can fire user-defined events |
| Key = DB2,1.0=true | |
| Event = UserDefinedEvent1 | |
| Object = * = all IPOTObjects; empty = IPOT; otherwise the ID |
Action (Actions)##
An action can be parameterised on any events. Even a chain of actions is possible. Actions, in turn, can fire events on which further actions can be parameterised.
FindProcessOrWindowAction###
Only the process or window is searched for depending on whether a window was parameterised for the action.
Parameters used:
ProcessName, WindowTitle, WindowClass
ProcessStartAction###
If the restart is not disabled, the process is started here.
Parameters used:
WorkingDir, ExecutablePath, ExecutableName, Arguments
ProcessStopAction###
In case the process is running, a Close is searched for here, if the termination takes longer than 5000 ms, the process is terminated hard.
SetWindowPlacementAction###
This action can change the style of the window and set the size and position.
Parameters used:
RemoveWindowStyles, ShowMode, Left, Top, Right, Bottom
MinimizeWindowAction###
This action minimizes the size of the window.
RestoreShowModeAction###
Parameters used:
ShowMode
ShowWindowAction###
This action brings the window into the foreground and sets the Show Mode
Parameters used:
GUIShowMode
TaskBarHideAction###
This action hides the taskbar. (AutoHide)
TaskBarUnHideAction###
This action resets the taskbar to visible.
NotifyIPOTObjectAction###
This action sends a Notified Event to the IPOTObjects parameterised in Notify.
Parameters used:
Notify
CheckConditionAction###
This action checks an additional condition. If this condition is not met, the Autostart is deactivated by the Observer until the condition is met.
Parameters used:
Condition
NoAction###
This action has no task, its only purpose is to overwrite a default value.
PropertyKeyOverrideAction###
This action allows the extension of existing settings. Here, for example, it is possible to transfer an argument from the Plc to a program.
Parameters used:
KeyOverride
SetWindowParentAction###
This action allows the WindowParent to be changed.
Parameters used:
ParentProcessName, ParentWindowTitle, ParentWindowClass
ResetWindowParentAction###
This action allows the WindowParent to be reset to the Desktop.
Configuration in Detail#
IPOTConfiguration##
<component id="Config" service="IPOT.Arch.Interfaces.IIPOTConfiguration, Interfaces"
type="IPOT.Arch.IPOTConfiguration, IPOTConfiguration"
lifestyle="singleton">
<parameters>
<startGroup>IH</startGroup>
<showMode>Minimized</showMode>
<password>sB1rAPxfi1cDyI6JblwKDQ==</password>
<logoutTimeMs>10000</logoutTimeMs>
<writeDebugOutput>false</writeDebugOutput>
<debugOutputPath></debugOutputPath>
<plcConnctionString>Data Source=192.168.0.145,0,2;</plcConnctionString>
<groups>
<list>
<item>IH</item>
<item>Werker</item>
</list>
</groups>
<windowPosLTRB>0;129;1025;975</windowPosLTRB>
<eventActions>
<dictionary>
<entry key="UDKeyObserverEvent1">MinimizeWindowAction</entry>
<entry key="Notified">MinimizeWindowAction</entry>
</dictionary>
</eventActions>
</parameters>
</component>
| Parameter | Description |
|---|---|
| startGroup | Group program group to be displayed when starting IPOT |
| showMode | Indicates the StartMode of IPOT (Minimized, Maximized, |
| Normal) | |
| password | Entry of the password in order to terminate the |
| application and to switch to the Engineering Mode | |
| (no password = no logon necessary) | |
| logoutTimeMs | Time until the automatic logout. (0=no automatic logout) |
| writeDebugOutput | The Dynamic ViewModel is created as a .cs file |
| debugOutputPath | Path for the dynamic ViewModel |
| plcConnectionString | Specifies the Plc connection if one is required |
| (IP,Rack,Slot) | |
| Groups | Displayable program groups |
| windowPosLTRB | Window position and size Left, Top, Right, Bottom |
| eventActions | See IPOTObject |
PLCConnectionString###
We support a couple of plc access types in IPOT. You can configure these types by setting up the Access Type property in the connection string:
<plcConnctionString>Access Type=InacS7;Data Source=127.0.0.1:102,0,2;Receive Timeout=5000;Connection Type=Pg;</plcConnctionString>
Other types are only supported, if the dll is installed in the binary folder.
- InacS7 (default): Data Source [IP]:[PORT],[RACK],[SLOT]
- LibNoDave: Data Source [IP]:[PORT],[RACK],[SLOT]
- Snap7: Data Source [IP],[RACK],[SLOT]
| Parameter | DefaultValue | Description | |
|---|---|---|---|
| Connection | Type = Pg | Type of the PLC connection (used by PLC). (Pg, Op, Basic) | |
| Receive Timeout | 5000 | Maximum of time a receive could last. | |
| Connect Timeout | 5000 | Maximum of time a connect could last. | |
| Reconnect | false | If connection get's lost try reconnect. | |
| KeepAliveTime | 0u | https://technet.microsoft.com/en-us/library/cc957549.aspx | |
| KeepAliveInterval | 0u | https://technet.microsoft.com/en-us/library/cc957548.aspx | |
| PduSize | 960 | Maximum size we could handle in one datagram (will be updated while connect handshake) | |
| Sleeptime After Max Pending Calls Reached | 5 | As the name says, in ms. | |
| Maximum Parallel Jobs | 1 | Used by Simatic Manager -> best performance with 1 | |
| Maximum Parallel Calls | 4 | Used by InacS7 to controll the parallelity | |
| Use Threads | true | Used by InacS7 and means TaskCreationOptions.LongRunning if is set to true |
IPOTObject##
This object is required for parameterising and managing an application. All settings and events for the application can be parameterised here.
<component id="Parasave" service="IPOT.Arch.Interfaces.IIPOTObject, Interfaces"
type="IPOT.Arch.IPOTObject, IPOTObject" lifestyle="singleton">
<parameters>
<id>Parasave</id>
<prop>
<dictionary>
<entry key="ProcessName">ParaSave</entry>
<entry key="ExecutableName">ParaSave.exe</entry>
<entry key="ExecutablePath">d:\Programme\ParaSave</entry>
<entry key="WorkingDir">d:\Programme\ParaSave</entry>
<entry key="MinDownTime">0</entry>
<entry key="Observe">false</entry>
<entry key="Arguments"></entry>
<entry key="Icon"> d:\Programme\ParaSave\icon.ico</entry>
<entry key="WindowClass"></entry>
<entry key="WindowTitle"></entry>
<entry key="GUIShowMode">ShowNormal</entry>
<entry key="RemoveWindowStyles">MinMaxBox</entry>
<entry key="ShowMode">ShowNormal</entry>
<entry key="Left">0</entry>
<entry key="Top">129</entry>
<entry key="Right">1025</entry>
<entry key="Bottom">575</entry>
<entry key="Group">IH</entry>
<entry key="Notify"></entry>
</dictionary>
</prop>
<eventActions>
<dictionary>
<entry key="GUIProcessStart">
ProcessStartAction;0;
FindProcessOrWindowAction;500;
SetWindowPlacementAction
</entry>
</dictionary>
</eventActions>
<defaultEventActions>
<dictionary>
<entry key="GUIProcessStart">
ProcessStartAction;0;
FindProcessOrWindowAction;500;
SetWindowPlacementAction
</entry>
</dictionary>
</defaultEventActions >
</parameters>
</component>
| Parameter | Description |
|---|---|
| ProcessName | Process name that can be seen in the Task Manager |
| ExecutablePath | Path for the executable file |
| ExecutableName | Name of the executable file |
| WorkingDir | Working directory |
| ProcessHandleInstances | The process can manage several instances indepen- |
| dently and IPOT does not have to take care of it. | |
| MinDownTime | Restart of an application only after this time has |
| elapsed | |
| Observe | Observation active or not |
| Arguments | Arguments for the process start |
| Icon | Icon to be displayed in the GUI |
| (Otherwise the icon of the Exe is used.) | |
| WindowClass | Window class for identification of the correct window |
| WindowTitle | Window title for identification of the correct window |
| GUIShowMode | Display mode that the window is set to if it is started |
| from the GUI of IPOT | |
| RemoveWindowStyles | Here, the window title can be changed |
| (e.g. removal of the MinMaxBox, frame, etc.) | |
| ShowMode | Window mode that the window must be set to |
| when starting | |
| Left | Left edge of the window |
| Top | Top edge of the window |
| Right | Right edge of the window |
| Bottom | Bottom edge of the window |
| Group | Group that the application belongs to. Several groups |
| can also be declared (e.g. "Grp1;Grp2") | |
| Notify | Objects to which the Notify Event should be sent |
| Possible is: | |
| Empty= IPOT | |
| *= All IPOTObjects | |
| ID1;ID2; = specified IDs) | |
| ObserveCondition | Specifies whether a condition should be observed |
| (is only relevant in connection with Observe=True) |
| Condition | Specifies the condition. A condition is to declare |
| [Type]:[Condition][ [$OR$ or $AND$][Type]:[Condition] ] | |
| There are two types of conditions at present: | |
| 1. PlcCondition: | |
| Plc:[Selector (DB,MB,EB + Number)],[Offset(for Bits Offset.Bit)], | |
| [Length (do not specify for bits!)]=[value](The value comparison | |
| takes place with IgnoreCase) e.g.: Plc:DB2,1.0=true | |
| 2. WmiCondition: | |
| e.g.: Wmi:Select * From Win32_PnPEntity Where Caption = | |
| "WIBU - CodeMeter-Stick USB Device" | |
| Plc:WMI-Select must evaluate for Count > 0. | |
| KeyOverride | Specifies which settings should be updated. |
| [Type]:[Key]=[Selector];[ [Type]:[Key]=[Selector]]; | |
| A format ID must also still be defined in the key for this value | |
| --> {Indexbeginnendmit0} | |
| There are two types at present : | |
| 1. Plc: | |
| Plc [Key]=[Selector (DB,MB,EB + Number)], | |
| [Offset(for Bits Offset.Bit)],[Length (do not specify for bits!)] | |
| (The value comparison takes place with IgnoreCase) | |
| e.g.: Plc:Arguments=DB2,542,6 | |
| Arguments must then have the format Id 0: Arguments="-p{0}" | |
| 2. WmiCondition: | |
| e.g.: Wmi:Select Name From Win32_PnPEntity Where Caption = | |
| "WIBU - CodeMeter-Stick USB Device" | |
| PlcObserverTrigger | Here, you can specify which data change should trigger a |
| PlcTriggerEvent. e.g.: DB2,1.0=true | |
| PlcTriggerDetected | Here, you can specify that a data area should be written |
| in the Plc when a trigger is detected. | |
| e.g.: DB2,4.0=false;true | |
| Trigger = false --> 1st value in the example is therefore then false | |
| Trigger = true --> 2nd value in the example is therefore then true |
prop###
| Parameter | Description |
|---|---|
| id | Unique application ID |
| prop | Dictionary of all settings |
| eventActions | Dictionary of the events and the associated actions |
eventActions###
<entry key="[Event]">[Action];[DelayTime][;[Action][DelayTime]]</entry>
| Parameter | Description |
|---|---|
| event | See Appendix A |
| Action | See [Actions](#Action (Actions)) |
| DelayTime | Delay time for execution of the action |
defaultEventActions###
Here, default settings can be defined for all events. Therefore, if an event should not be declared in the object, this entry is used.
<entry key="[Event]">[Action];[DelayTime][;[Action][DelayTime]]</entry>
| Parameter | Description |
|---|---|
| event | See Appendix A |
| Action | See [Actions](#Action (Actions)) |
| DelayTime | Delay time for execution of the action |
Installation#
This requires that
- Microsoft .NET Framework 4.5.2
is installed and available on the destination system under Windows.
These files can be copied to any directory and IPOT.exe can then be started from there.
The directory must be a local directory and not a network drive!
Appendix A#
Events##
| Parameter | Description |
|---|---|
| ProcessNotRunning | This event is fired from the FindProcessOrWindowAction |
| if the process was not found | |
| ProcessStarted | This event is fired from the ProcessStartAction after starting the |
| process | |
| ApplicationStarted | This event is fired to each IPOTObject from the ProcessObserver |
| when starting the application | |
| ApplicationStopping | This event is fired to each IPOTObject from the ProcessObserver |
| when terminating the application | |
| ApplicationWindow- | This event is fired to the IPOTConfiguration object from IPOT |
| StateChanged | when changing the window status (maximising, minimising) |
| of the application | |
| ProcessWindowFound | This event is fired from the FindProcessOrWindowAction if the |
| process and associated window was found | |
| Find | This event is fired from the ProcessObserver for the IPOTObjects |
| which have activated during the check cycle Observe, the | |
| restart is not deactivated, the process does not run and no | |
| Condition was activated | |
| ProcessRunning | This event is fired from FindProcessOrWindowAction if the process |
| was not found. (If a window is required, this event is replaced by | |
| ProcessWindowFound) | |
| WindowPlaced | This event is fired from SetWindowPlacement if the window has |
| been placed on the specified position | |
| ProcessStartError | This event is fired from the ProcessStartAction if an |
| error has occurred after starting the process | |
| ProcessStopped | This event is fired from IPOTObject if the associated process |
| was terminated | |
| GUIProcessShow | This event is fired from IPOT if the button (tile) of the object |
| has been pressed on the surface, or if IPOT was started with the | |
| CommandlineParameter View | |
| GUIProcessStart | This event is fired from the ShowWindowAction if the process |
| does not run | |
| GUIProcessStop | This event is fired from IPOT if the button (tile) of the object has |
| been pressed on the surface with the Control button held down, | |
| or if IPOT was started with the CommandlineParameter View |
| UserDefinedEvent1 | These events are used |
| ... (2-9) | by the Observers |
| UserDefinedEvent10 | and can be parameterised freely |
| ApplicationActivated | This event is called up from IPOT as soon as the window |
| receives the focus. | |
| ApplicationDeactivated | This event is called up from IPOT as soon as the window |
| loses the focus. | |
| Notified | This event is called up from NotifyIPOTObjectAction in order+ |
| to notify other objects. | |
| CheckCondition | This event is fired when checking whether the element can be |
| restarted (only if a condition is specified) | |
| PlcTrigger | This event is fired if a data change was detected on the |
| parameterised plc data. | |
| ConditionMet | This event is fired if the condition is met. (if one was declared) |
| ConditionNoLongerMet | This event is fired if the condition was met, |
| but now is not met anymore | |
| ParentChanged | This event if fired if the parent was successfully changed |
| ParentNotFound | This event if fired if the parent was not found |
Change directory#
| Author | Date | Remarks |
|---|---|---|
| Benjamin Prömmer | 2013-08-22 | Creation |
| Benjamin Prömmer | 2013-08-26 | Extended by password entry |
| Benjamin Prömmer | 2013-09-20 | IPOT.Common to IPOT.Arch!!! / Editing function |
| Benjamin Prömmer | 2014-07-02 | Start parameter, IPOTConfigParameter |
| Benjamin Prömmer | 2014-07-07 | Start parameter, new event --> GUIProcessStop |
| Benjamin Prömmer | 2014-07-10 | Action CheckConditionAction |
| Benjamin Prömmer | 2014-07-15 | PLCObserver, UserDefinedEvent, ... |
| Benjamin Prömmer | 2014-07-17 | NoAction |
| Benjamin Prömmer | 2014-07-18 | Default Actions Parameter |
| Benjamin Prömmer | 2014-07-28 | FindWindow and Group |
| Benjamin Prömmer | 2014-08-05 | PropertyKeyOverrideAction |
| Benjamin Prömmer | 2014-09-18 | Argument –a and ProcessHandleInstances |
| Benjamin Prömmer | 2015-02-15 | SetWindowParentAction, ResetWindowParentAction |
| Benjamin Prömmer | 2015-06-01 | Webserver integration |