public ActorSynchronizedRepository(DatabaseApplicationContext databaseContext,
MessageBus.MessageBroker messageBroker,
ILogger <IEventSynchronizer <Actor, ActorEventEntity> > logger,
ServerDescriptor descriptor) : base(
databaseContext, messageBroker, logger, descriptor)
{
}
public SyncRepository(
ServerDescriptor serverDescriptor,
IMessageBrokerServiceClient messageBrokerServiceClient)
{
this.serverDescriptor = serverDescriptor;
this.messageBrokerServiceClient = messageBrokerServiceClient;
}
public EfSynchronizedRepository(DatabaseApplicationContext databaseContext, MessageBroker messageBroker,
ILogger <IEventSynchronizer <T, TEvent> > logger, ServerDescriptor serverDescriptor)
{
_databaseContext = databaseContext;
_messageBroker = messageBroker;
_logger = logger;
_serverDescriptor = serverDescriptor;
}
public MovieSyncRepository(
IApplicationDbContext dbContext,
ServerDescriptor serverDescriptor,
IMessageBrokerServiceClient messageBrokerServiceClient) : base(
serverDescriptor, messageBrokerServiceClient)
{
this.dbContext = dbContext;
}
/// <summary>
/// Called from the skin to connect to one of the available servers.
/// </summary>
/// <param name="availableServerItem">One of the items in the <see cref="AvailableServers"/> collection</param>
public void ChooseNewHomeServerAndClose(ListItem availableServerItem)
{
ServerDescriptor sd = (ServerDescriptor)availableServerItem.AdditionalProperties[Consts.KEY_SERVER_DESCRIPTOR];
IServerConnectionManager scm = ServiceRegistration.Get <IServerConnectionManager>();
scm.SetNewHomeServer(sd.MPBackendServerUUID);
ShowAttachInformationDialogAndClose(sd);
}
/// <summary>
/// When a home server is connected, we store the connection data of the server to be able to
/// provide the home server's data also when the connection is down. We'll refresh the data each time
/// the server is connected to track changes in the server's location, name, ...
/// </summary>
protected static void SaveLastHomeServerData(ServerDescriptor serverDescriptor)
{
ISettingsManager settingsManager = ServiceRegistration.Get<ISettingsManager>();
ServerConnectionSettings settings = settingsManager.Load<ServerConnectionSettings>();
settings.LastHomeServerName = serverDescriptor.ServerName;
settings.LastHomeServerSystem = serverDescriptor.GetPreferredLink();
settingsManager.Save(settings);
}
public Bot(ServerDescriptor server, IConfig config)
: this(server)
{
this.config = config;
LoadPlugins(config.GetString("plugin-folder", "Plugins"));
MapCommands(config);
}
private async void appRegistrationService_DeviceRegistered(ServerDescriptor serverDescriptor)
{
if (DeviceRegistrationService.Instance.IsMandatoryUpdateAvailable)
{
await View.NavigateToDownloadsPageForMandatoryUpdateAsync();
return;
}
View.NavigateToHomePage();
}
public MessageBrokerServiceClient(
ServerDescriptor serverDescriptor,
IConfiguration configuration)
{
this.serverDescriptor = serverDescriptor;
AppContext.SetSwitch("System.Net.Http.SocketsHttpHandler.Http2UnencryptedSupport", true);
var channel = GrpcChannel.ForAddress($"http://{configuration.GetConnectionString("MessageBrokerGrpc")}:5000");
client = new MessageBroker.MessageBrokerClient(channel);
}
private static void BrowseFromNode(
EasyDAClient client,
ServerDescriptor serverDescriptor,
DANodeDescriptor parentNodeDescriptor)
{
Debug.Assert(client != null);
Debug.Assert(serverDescriptor != null);
Debug.Assert(parentNodeDescriptor != null);
Boolean append = false;
if (parentNodeDescriptor.ToString() == "")
{
append = false;
}
else
{
append = true;
}
// Obtain all node elements under parentNodeDescriptor
var browseParameters = new DABrowseParameters(); // no filtering whatsoever
DANodeElementCollection nodeElementCollection =
client.BrowseNodes(serverDescriptor, parentNodeDescriptor, browseParameters);
// Remark: that BrowseNodes(...) may also throw OpcException; a production code should contain handling for
// it, here omitted for brevity.
foreach (DANodeElement nodeElement in nodeElementCollection)
{
Debug.Assert(nodeElement != null);
Console.WriteLine(nodeElement);
using (StreamWriter opcfile = new System.IO.StreamWriter(@"C:\Users\kiekensk\source\repos\ConsoleAppOPCClient\ConsoleAppOPCClient\dump\Cttmt2008 OPC dump.txt", append))
{
opcfile.WriteLine(nodeElement);
}
// If the node is a branch, browse recursively into it.
if (nodeElement.IsBranch)
{
_branchCount++;
BrowseFromNode(client, serverDescriptor, nodeElement);
}
else
{
_leafCount++;
}
}
}
protected ListItem CreateServerItem(ServerDescriptor sd)
{
ListItem result = new ListItem();
SystemName system = sd.GetPreferredLink();
result.SetLabel(Consts.KEY_NAME, LocalizationHelper.Translate(Consts.RES_SERVER_FORMAT_TEXT,
sd.ServerName, system.HostName));
result.SetLabel(Consts.KEY_SERVER_NAME, sd.ServerName);
result.SetLabel(Consts.KEY_SYSTEM, system.HostName);
result.AdditionalProperties[Consts.KEY_SERVER_DESCRIPTOR] = sd;
result.Command = new MethodDelegateCommand(() => ChooseNewHomeServerAndClose(result));
return(result);
}
/// <summary>
/// Shows an info dialog that the server with the given <see cref="sd"/> was attached.
/// </summary>
/// <param name="sd">Descriptor of the server whose information should be shown.</param>
protected void ShowAttachInformationDialogAndClose(ServerDescriptor sd)
{
IScreenManager screenManager = ServiceRegistration.Get <IScreenManager>();
IDialogManager dialogManager = ServiceRegistration.Get <IDialogManager>();
_attachInfoDialogHandle = Guid.Empty; // Set this to value != null here to make the attachment dialog's close handler know we are not finished in our WF-state
screenManager.CloseTopmostDialog();
string header = LocalizationHelper.Translate(Consts.RES_ATTACH_INFO_DIALOG_HEADER);
string text = LocalizationHelper.Translate(Consts.RES_ATTACH_INFO_DIALOG_TEXT, sd.ServerName, sd.GetPreferredLink().HostName);
Guid handle = dialogManager.ShowDialog(header, text, DialogType.OkDialog, false, DialogButtonType.Ok);
lock (_syncObj)
_attachInfoDialogHandle = handle;
}
void OnUPnPRootDeviceRemoved(RootDescriptor rootDescriptor)
{
ICollection <ServerDescriptor> availableServers;
lock (_networkTracker.SharedControlPointData.SyncObj)
{
ServerDescriptor serverDescriptor = ServerDescriptor.GetMPBackendServerDescriptor(rootDescriptor);
if (serverDescriptor == null || !_availableServers.Contains(serverDescriptor))
{
return;
}
SystemName preferredLink = serverDescriptor.GetPreferredLink();
ServiceRegistration.Get <ILogger>().Debug("UPnPServerWatcher: MediaPortal 2 BackendServer '{0}' at host '{1}' (IP address: '{2}') was removed from the network",
serverDescriptor.ServerName, preferredLink.HostName, preferredLink.Address);
_availableServers.Remove(serverDescriptor);
availableServers = _availableServers;
}
InvokeAvailableBackendServersChanged(availableServers, false);
}
void OnUPnPRootDeviceAdded(RootDescriptor rootDescriptor)
{
ICollection <ServerDescriptor> availableServers;
using (_networkTracker.SharedControlPointData.Lock.EnterWrite())
{
ServerDescriptor serverDescriptor = ServerDescriptor.GetMPBackendServerDescriptor(rootDescriptor);
if (serverDescriptor == null || _availableServers.Contains(serverDescriptor))
{
return;
}
SystemName preferredLink = serverDescriptor.GetPreferredLink();
ServiceRegistration.Get <ILogger>().Debug("UPnPServerWatcher: Found MediaPortal 2 BackendServer '{0}' at host '{1}' (IP address: '{2}')",
serverDescriptor.ServerName, preferredLink.HostName, preferredLink.Address);
_availableServers.Add(serverDescriptor);
availableServers = _availableServers;
}
InvokeAvailableBackendServersChanged(availableServers, true);
}
void OnBackendServerConnected(DeviceConnection connection)
{
ServerDescriptor serverDescriptor = ServerDescriptor.GetMPBackendServerDescriptor(connection.RootDescriptor);
if (serverDescriptor == null)
{
ServiceRegistration.Get<ILogger>().Warn("ServerConnectionManager: Could not connect to home server - Unable to verify UPnP root descriptor");
return;
}
SystemName preferredLink = serverDescriptor.GetPreferredLink();
ServiceRegistration.Get<ILogger>().Info("ServerConnectionManager: Connected to home server '{0}' at host '{1}' (IP address: '{2}')", serverDescriptor.MPBackendServerUUID, preferredLink.HostName, preferredLink.Address);
lock (_syncObj)
{
_isHomeServerConnected = true;
SaveLastHomeServerData(serverDescriptor);
}
ServerConnectionMessaging.SendServerConnectionStateChangedMessage(ServerConnectionMessaging.MessageType.HomeServerConnected);
//ServiceRegistration.Get<IThreadPool>().Add(CompleteServerConnection);
_ = CompleteServerConnectionAsync();
}
/// <summary>
/// Browse recursively the address space of an OPC server.
/// </summary>
/// <param name="opc">The opc client.</param>
/// <param name="serverDescriptor">The server descriptor.</param>
/// <param name="nodeElement">The node element.</param>
/// <param name="opcParentItem">The opc parent item.</param>
private void BrowseRecursive(EasyDAClient opc, ServerDescriptor serverDescriptor, DANodeElement nodeElement, OpcItem opcParentItem)
{
if (nodeElement == null)
{
var branches = opc.BrowseBranches(serverDescriptor);
var leaves = opc.BrowseLeaves(serverDescriptor);
foreach (var branch in branches)
{
this.BrowseRecursive(opc, serverDescriptor, branch, opcParentItem);
}
foreach (var leaf in leaves)
{
this.BrowseRecursive(opc, serverDescriptor, leaf, opcParentItem);
}
}
else
{
// A node element is processed only here.
var newOpcItem = ProcessNode(nodeElement, opcParentItem);
// Go on recursively if the node element has children.
if (nodeElement.HasChildren)
{
var nodeDescriptor = new DANodeDescriptor(nodeElement);
var branches = opc.BrowseBranches(serverDescriptor, nodeDescriptor);
var leaves = opc.BrowseLeaves(serverDescriptor, nodeDescriptor);
foreach (var branch in branches)
{
this.BrowseRecursive(opc, serverDescriptor, branch, newOpcItem);
}
foreach (var leaf in leaves)
{
this.BrowseRecursive(opc, serverDescriptor, leaf, newOpcItem);
}
}
}
}
/// <summary>
/// Reads the opc address space.
/// </summary>
/// <param name="serverName">Name of the server.</param>
/// <param name="opcItem">The opc item.</param>
/// <param name="error">The error.</param>
/// <param name="exception">The exception.</param>
/// <returns><c>true</c> if the operation succeeds, <c>false</c> otherwise</returns>
public bool ReadOpcAddressSpace(string serverName, out OpcItem opcItem, out uint error, out Exception exception)
{
// The root of our tree. This is only to have a unique root in the tree.
// OPC servers do not always have a unique root.
opcItem = new OpcItem(true)
{
Name = "OPC Address Space"
};
error = ResultCodes.Success;
exception = null;
var result = true;
if (string.IsNullOrEmpty(serverName) || string.IsNullOrWhiteSpace(serverName))
{
error = ResultCodes.MissingArgument;
return(false);
}
try
{
var opc = OpcMonitor.CreateOpcClient();
var serverDescriptor = new ServerDescriptor(serverName);
this.BrowseRecursive(opc, serverDescriptor, null, opcItem);
opc.Dispose();
}
catch (Exception ex)
{
Logger.FatalException(this, "Error browsing OPC servers.", exception);
error = ResultCodes.BrowseAddressSpaceError;
exception = ex;
DiagnosticsCollection.Instance.AddMessage(string.Format("Error browsing OPC server: {0}", serverName));
DiagnosticsCollection.Instance.AddMessage(exception);
result = false;
}
return(result);
}
public static void DataType()
{
var easyDAClient = new EasyDAClient();
ServerDescriptor serverDescriptor = "AutoJet.ACPFileServerDA.1";
// Browse for all leaves under the "Simulation" branch
DANodeElementCollection nodeElementCollection = easyDAClient.BrowseLeaves(serverDescriptor, "Simulation");
// Create list of node descriptors, one for each leaf obtained
DANodeDescriptor[] nodeDescriptorArray = nodeElementCollection
.Where(element => !element.IsHint) // filter out hint leafs that do not represent real OPC items (rare)
.Select(element => new DANodeDescriptor(element))
.ToArray();
// Get the value of DataType property; it is a 16-bit signed integer
ValueResult[] valueResultArray = easyDAClient.GetMultiplePropertyValues(serverDescriptor,
nodeDescriptorArray, DAPropertyIds.DataType);
for (int i = 0; i < valueResultArray.Length; i++)
{
DANodeDescriptor nodeDescriptor = nodeDescriptorArray[i];
// Check if there has been an error getting the property value
ValueResult valueResult = valueResultArray[i];
if (valueResult.Exception != null)
{
Console.WriteLine("{0}: *** {1}", nodeDescriptor.NodeId, valueResult.Exception.Message);
continue;
}
// Convert the data type to VarType
var varType = (VarType)(short)valueResult.Value;
// Display the obtained data type
Console.WriteLine("{0}: {1}", nodeDescriptor.ItemId, varType);
}
}
/// <summary>
/// Tries to determine the server IP address from the current server connection.
/// </summary>
/// <param name="serverAddress">If successful, contains the IP address of the server.</param>
/// <returns></returns>
protected bool TryGetServerIPAddress(out IPAddress localAddress, out IPAddress serverAddress)
{
localAddress = null;
serverAddress = null;
var cp = ServiceRegistration.Get <IServerConnectionManager>().ControlPoint;
if (cp == null)
{
ServiceRegistration.Get <ILogger>().Warn("WakeOnLanClient: Could not get server IP address, UPnPControlPoint not found");
return(false);
}
if (cp.Connection == null)
{
//Don't log here, the server isn't connected (yet), we'll retry getting the address when it connects.
return(false);
}
ServerDescriptor serverDescriptor = ServerDescriptor.GetMPBackendServerDescriptor(cp.Connection.RootDescriptor);
if (serverDescriptor == null)
{
ServiceRegistration.Get <ILogger>().Warn("WakeOnLanClient: Could not get server IP address, unable to verify UPnP root descriptor");
return(false);
}
SystemName preferredLink = serverDescriptor.GetPreferredLink();
if (IPAddress.TryParse(preferredLink.Address, out serverAddress))
{
localAddress = cp.Connection.RootDescriptor.SSDPRootEntry.PreferredLink.Endpoint.EndPointIPAddress;
ServiceRegistration.Get <ILogger>().Debug("WakeOnLanClient: Got server IP address '{0}' for '{1}', local address '{2}'", serverAddress, preferredLink.HostName, localAddress);
return(true);
}
return(false);
}
/// <summary>
/// Connects to all servers according to ServerDescriptors in separate threads and suspends itself in a loop waiting for console input
/// </summary>
public static void Run(ServerDescriptor[] servers, IConfig globalSettings)
{
Bot.Run(servers.ToList(), globalSettings);
}
public Bot(ServerDescriptor server)
: this()
{
this.server = server;
}
public Bot(string host, int port, bool useSsl, string[] channels)
{
userService = new UserService(db);
server = new ServerDescriptor(host, port, useSsl, channels);
}
public DANodeElementCollection BrowseNodes([NotNull] ServerDescriptor serverDescriptor, [NotNull] DANodeDescriptor parentNodeDescriptor, [NotNull] DABrowseParameters browseParameters)
{
throw new NotImplementedException();
}
public string[] BrowseAccessPaths([NotNull] ServerDescriptor serverDescriptor, [NotNull] DANodeDescriptor nodeDescriptor)
{
throw new NotImplementedException();
}
public DAPropertyElementCollection BrowseProperties([NotNull] ServerDescriptor serverDescriptor, [NotNull] DANodeDescriptor nodeDescriptor)
{
throw new NotImplementedException();
}
/// <summary>
/// When a home server is connected, we store the connection data of the server to be able to
/// provide the home server's data also when the connection is down. We'll refresh the data each time
/// the server is connected to track changes in the server's location, name, ...
/// </summary>
protected static void SaveLastHomeServerData(ServerDescriptor serverDescriptor)
{
ISettingsManager settingsManager = ServiceRegistration.Get<ISettingsManager>();
ServerConnectionSettings settings = settingsManager.Load<ServerConnectionSettings>();
settings.LastHomeServerName = serverDescriptor.ServerName;
settings.LastHomeServerSystem = serverDescriptor.GetPreferredLink();
settingsManager.Save(settings);
}
protected ListItem CreateServerItem(ServerDescriptor sd)
{
ListItem result = new ListItem();
SystemName system = sd.GetPreferredLink();
result.SetLabel(Consts.KEY_NAME, LocalizationHelper.Translate(Consts.RES_SERVER_FORMAT_TEXT,
sd.ServerName, system.HostName));
result.SetLabel(Consts.KEY_SERVER_NAME, sd.ServerName);
result.SetLabel(Consts.KEY_SYSTEM, system.HostName);
result.AdditionalProperties[Consts.KEY_SERVER_DESCRIPTOR] = sd;
result.Command = new MethodDelegateCommand(() => ChooseNewHomeServerAndClose(result));
return result;
}
/// <summary>
/// Shows an info dialog that the server with the given <see cref="sd"/> was attached.
/// </summary>
/// <param name="sd">Descriptor of the server whose information should be shown.</param>
protected void ShowAttachInformationDialogAndClose(ServerDescriptor sd)
{
IScreenManager screenManager = ServiceRegistration.Get<IScreenManager>();
IDialogManager dialogManager = ServiceRegistration.Get<IDialogManager>();
_attachInfoDialogHandle = Guid.Empty; // Set this to value != null here to make the attachment dialog's close handler know we are not finished in our WF-state
screenManager.CloseTopmostDialog();
string header = LocalizationHelper.Translate(Consts.RES_ATTACH_INFO_DIALOG_HEADER);
string text = LocalizationHelper.Translate(Consts.RES_ATTACH_INFO_DIALOG_TEXT, sd.ServerName, sd.GetPreferredLink().HostName);
Guid handle = dialogManager.ShowDialog(header, text, DialogType.OkDialog, false, DialogButtonType.Ok);
lock (_syncObj)
_attachInfoDialogHandle = handle;
}
/// <summary>
/// Creates and sets up an IrcClient instance and connects to a server according to "server"
/// </summary>
public void Connect(ServerDescriptor server)
{
if (server == null)
throw new ArgumentNullException();
Thread.CurrentThread.Name = server.Host;
irc = new IrcClient();
// Settings
irc.Encoding = System.Text.Encoding.UTF8;
irc.SendDelay = config.GetInt("send-delay", 200);
irc.ActiveChannelSyncing = config.GetBoolean("use-active-channel-syncing", false);
irc.UseSsl = server.UseSsl;
// Bind event handlers
irc.OnQueryMessage += new IrcEventHandler(OnQueryMessage);
irc.OnChannelMessage += new IrcEventHandler(OnChannelMessage);
irc.OnError += new Meebey.SmartIrc4net.ErrorEventHandler(OnError);
irc.OnRawMessage += new IrcEventHandler(OnRawMessage);
irc.OnPart += new PartEventHandler(OnPart);
log.Info("Initializing plugins...");
foreach (var plugin in Plugins)
{
plugin.Initialize(config);
irc.OnChannelMessage += new IrcEventHandler(plugin.OnChannelMessage);
irc.OnRawMessage += new IrcEventHandler(plugin.OnRawMessage);
}
try
{
log.Info("Connecting to server " + irc.Address);
irc.Connect(server.Host, server.Port);
}
catch (ConnectionException e)
{
log.Error("Could not connect to server " + irc.Address, e);
Exit();
}
try
{
irc.Login(config.GetString("nick", "slave"),
config.GetString("realname", "slave"),
0,
config.GetString("username", "slave")
);
foreach (string channel in server.Channels)
irc.RfcJoin(channel);
irc.Listen();
irc.Disconnect();
}
catch (ThreadAbortException e)
{
log.Info("Aborting thread", e);
irc.Disconnect();
Thread.CurrentThread.Abort();
}
catch (ConnectionException e)
{
log.Error("Error", e);
Thread.CurrentThread.Abort();
}
catch (Exception e)
{
log.Error("Error", e);
Thread.CurrentThread.Abort();
}
}
