public SettingsDialog(RuntimeSettings settings)
{
this.renderComplete = false;
this.settings = settings;
(
this.SubscriptionKey,
this.SubscriptionKeyRegion,
this.CustomCommandsAppId,
this.ConnectionLanguage,
this.LogFilePath,
this.CustomSpeechEndpointId,
this.CustomSpeechEnabled,
this.VoiceDeploymentIds,
this.VoiceDeploymentEnabled,
this.WakeWordEnabled,
this.UrlOverride,
this.ProxyHostName,
this.ProxyPortNumber,
this.FromId,
this.settings.CognitiveServiceKeyHistory,
this.settings.CognitiveServiceRegionHistory) = settings.Get();
this.CustomSpeechConfig = new CustomSpeechConfiguration(settings.CustomSpeechEndpointId);
this.VoiceDeploymentConfig = new VoiceDeploymentConfiguration(settings.VoiceDeploymentIds);
this.WakeWordConfig = new WakeWordConfiguration(settings.WakeWordPath);
this.InitializeComponent();
this.DataContext = this;
this.Owner = App.Current.MainWindow;
}
/// <summary>
/// Defines the Metering Topology data source. This data source contains a tree structure of persistent
/// readable and controllable devices
/// </summary>
public MeteringTopology()
{
lastChanged = RuntimeSettings.Get(MeteringTopology.SourceID + ".LastChanged", DateTime.MinValue);
if (instance is null)
{
instance = this;
}
}
public SettingsDialog(RuntimeSettings settings)
{
this.renderComplete = false;
this.settings = settings;
(
this.ConnectionProfileName,
this.connectionProfile,
this.settings.Profile) = settings.Get();
this.settings.Profile.CustomSpeechConfig = new CustomSpeechConfiguration(settings.CustomSpeechEndpointId);
this.settings.Profile.VoiceDeploymentConfig = new VoiceDeploymentConfiguration(settings.VoiceDeploymentIds);
this.settings.Profile.WakeWordConfig = new WakeWordConfiguration(settings.WakeWordPath);
this.InitializeComponent();
this.DataContext = this;
this.Owner = App.Current.MainWindow;
}
/// <summary>
/// Provides emojis from Emoji One (http://emojione.com/) stored as local files.
/// </summary>
/// <param name="SourceFileType">Type of files to use.</param>
/// <param name="Width">Desired width of emojis.</param>
/// <param name="Height">Desired height of emojis.</param>
/// <param name="ImageURL">URL for remote clients to fetch the image. If not provided, images are embedded into generated pages.
/// Include the string %FILENAME% where the name of the emoji image file is to be inserted.</param>
/// <param name="ZipFileName">Full path of the emoji1 zip file. It will be deleted after unpacking to <paramref name="ProgramDataFolder"/>.</param>
/// <param name="ProgramDataFolder">Folder to unzip emojis to.</param>
public Emoji1LocalFiles(Emoji1SourceFileType SourceFileType, int Width, int Height, string ImageURL,
string ZipFileName, string ProgramDataFolder)
{
this.sourceFileType = SourceFileType;
this.width = Width;
this.height = Height;
this.imageUrl = ImageURL;
this.zipFileName = ZipFileName;
this.programDataFolder = ProgramDataFolder;
try
{
DateTime TP = File.GetLastWriteTime(this.zipFileName);
if (File.Exists(this.zipFileName) && RuntimeSettings.Get(this.zipFileName, DateTime.MinValue) != TP)
{
if (!Directory.Exists(ProgramDataFolder))
{
Directory.CreateDirectory(ProgramDataFolder);
}
else
{
string Folder = Path.Combine(ProgramDataFolder, "Emoji1");
if (Directory.Exists(Folder))
{
Directory.Delete(Folder, true);
}
}
this.initialized = new ManualResetEvent(false);
Task.Run(this.Unpack);
}
else
{
this.initialized = new ManualResetEvent(true);
}
}
catch (Exception ex)
{
Log.Critical(ex);
}
}
internal static Task <XmppCredentials> GetXmppClientCredentialsAsService(string XmppConfigFileName)
{
XmppCredentials Result;
if (File.Exists(XmppConfigFileName))
{
Result = SimpleXmppConfiguration.Load(XmppConfigFileName);
RuntimeSettings.Set("XMPP.CONFIG", SimpleXmppConfiguration.ExportSimpleXmppConfiguration(Result));
}
else
{
string XmppConfig = RuntimeSettings.Get("XMPP.CONFIG", string.Empty);
XmlDocument Doc = new XmlDocument();
Doc.LoadXml(XmppConfig);
Result = SimpleXmppConfiguration.Load(Doc);
}
return(Task.FromResult <XmppCredentials>(Result));
}
public SettingsDialog(RuntimeSettings settings)
{
this.renderComplete = false;
this.settings = settings;
(
this.SubscriptionKey,
this.SubscriptionKeyRegion,
this.ConnectionLanguage,
this.LogFilePath,
this.WakeWordEnabled,
this.UrlOverride,
this.ProxyHostName,
this.ProxyPortNumber,
this.FromId) = settings.Get();
this.WakeWordConfig = new WakeWordConfiguration(settings.WakeWordPath);
this.InitializeComponent();
this.DataContext = this;
this.Owner = App.Current.MainWindow;
}
/// <summary>
/// Starts the gateway.
/// </summary>
/// <param name="ConsoleOutput">If console output is permitted.</param>
public static bool Start(bool ConsoleOutput)
{
gatewayRunning = new Semaphore(1, 1, "Waher.IoTGateway.Running");
if (!gatewayRunning.WaitOne(1000))
{
return(false); // Is running in another process.
}
Semaphore StartingServer = new Semaphore(1, 1, "Waher.IoTGateway.Starting");
if (!StartingServer.WaitOne(1000))
{
gatewayRunning.Release();
gatewayRunning.Dispose();
gatewayRunning = null;
StartingServer.Dispose();
return(false); // Being started in another process.
}
try
{
Initialize();
appDataFolder = Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData);
if (!appDataFolder.EndsWith(new string(Path.DirectorySeparatorChar, 1)))
{
appDataFolder += Path.DirectorySeparatorChar;
}
appDataFolder += "IoT Gateway" + Path.DirectorySeparatorChar;
Log.Register(new XmlFileEventSink("XML File Event Sink",
appDataFolder + "Events" + Path.DirectorySeparatorChar + "Event Log %YEAR%-%MONTH%-%DAY%T%HOUR%.xml",
appDataFolder + "Transforms" + Path.DirectorySeparatorChar + "EventXmlToHtml.xslt", 7));
Log.Informational("Server starting up.");
beforeUninstallCommandNr = Gateway.RegisterServiceCommand(BeforeUninstall);
rootFolder = appDataFolder + "Root" + Path.DirectorySeparatorChar;
if (!Directory.Exists(rootFolder))
{
appDataFolder = string.Empty;
rootFolder = "Root" + Path.DirectorySeparatorChar;
}
Types.SetModuleParameter("AppData", appDataFolder);
Types.SetModuleParameter("Root", rootFolder);
scheduler = new Scheduler();
rnd = RandomNumberGenerator.Create();
Task.Run(() => CodeContent.GraphViz.Init());
XmlDocument Config = new XmlDocument();
string GatewayConfigFileName = appDataFolder + "Gateway.config";
if (!File.Exists(GatewayConfigFileName))
{
GatewayConfigFileName = "Gateway.config";
}
Config.Load(GatewayConfigFileName);
XSL.Validate("Gateway.config", Config, "GatewayConfiguration", "http://waher.se/Schema/GatewayConfiguration.xsd",
XSL.LoadSchema(typeof(Gateway).Namespace + ".Schema.GatewayConfiguration.xsd", typeof(Gateway).Assembly));
domain = Config.DocumentElement["Domain"].InnerText;
XmlElement DatabaseConfig = Config.DocumentElement["Database"];
if (!CommonTypes.TryParse(DatabaseConfig.Attributes["encrypted"].Value, out bool Encrypted))
{
Encrypted = true;
}
databaseProvider = new FilesProvider(appDataFolder + DatabaseConfig.Attributes["folder"].Value,
DatabaseConfig.Attributes["defaultCollectionName"].Value,
int.Parse(DatabaseConfig.Attributes["blockSize"].Value),
int.Parse(DatabaseConfig.Attributes["blocksInCache"].Value),
int.Parse(DatabaseConfig.Attributes["blobBlockSize"].Value), Encoding.UTF8,
int.Parse(DatabaseConfig.Attributes["timeoutMs"].Value),
Encrypted, false);
Database.Register(databaseProvider);
PersistedEventLog PersistedEventLog = new PersistedEventLog(7, new TimeSpan(4, 15, 0));
Log.Register(PersistedEventLog);
PersistedEventLog.Queue(new Event(EventType.Informational, "Server starting up.", string.Empty, string.Empty, string.Empty, EventLevel.Minor, string.Empty, string.Empty, string.Empty));
xmppConfigFileName = Config.DocumentElement["XmppClient"].Attributes["configFileName"].Value;
if (!File.Exists(xmppConfigFileName))
{
xmppConfigFileName = appDataFolder + xmppConfigFileName;
}
if (ConsoleOutput)
{
xmppConfiguration = SimpleXmppConfiguration.GetConfigUsingSimpleConsoleDialog(xmppConfigFileName,
Guid.NewGuid().ToString().Replace("-", string.Empty), // Default user name.
Guid.NewGuid().ToString().Replace("-", string.Empty), // Default password.
FormSignatureKey, FormSignatureSecret, typeof(Gateway).Assembly);
}
else if (File.Exists(xmppConfigFileName))
{
xmppConfiguration = new SimpleXmppConfiguration(xmppConfigFileName);
RuntimeSettings.Set("XMPP.CONFIG", xmppConfiguration.ExportSimpleXmppConfiguration());
}
else
{
string XmppConfig = RuntimeSettings.Get("XMPP.CONFIG", string.Empty);
XmlDocument Doc = new XmlDocument();
Doc.LoadXml(XmppConfig);
xmppConfiguration = new SimpleXmppConfiguration(Doc);
}
xmppClient = xmppConfiguration.GetClient("en", typeof(Gateway).Assembly, false);
xmppClient.AllowRegistration(FormSignatureKey, FormSignatureSecret);
xmppClient.OnValidateSender += XmppClient_OnValidateSender;
Types.SetModuleParameter("XMPP", xmppClient);
if (xmppConfiguration.Sniffer)
{
ISniffer Sniffer;
if (ConsoleOutput)
{
Sniffer = new ConsoleOutSniffer(BinaryPresentationMethod.ByteCount, LineEnding.PadWithSpaces);
xmppClient.Add(Sniffer);
}
Sniffer = new XmlFileSniffer(appDataFolder + "XMPP" + Path.DirectorySeparatorChar +
"XMPP Log %YEAR%-%MONTH%-%DAY%T%HOUR%.xml",
appDataFolder + "Transforms" + Path.DirectorySeparatorChar + "SnifferXmlToHtml.xslt",
7, BinaryPresentationMethod.ByteCount);
xmppClient.Add(Sniffer);
}
if (!string.IsNullOrEmpty(xmppConfiguration.Events))
{
Log.Register(new XmppEventSink("XMPP Event Sink", xmppClient, xmppConfiguration.Events, false));
}
if (!string.IsNullOrEmpty(xmppConfiguration.ThingRegistry))
{
thingRegistryClient = new ThingRegistryClient(xmppClient, xmppConfiguration.ThingRegistry);
thingRegistryClient.Claimed += ThingRegistryClient_Claimed;
thingRegistryClient.Disowned += ThingRegistryClient_Disowned;
thingRegistryClient.Removed += ThingRegistryClient_Removed;
}
if (!string.IsNullOrEmpty(xmppConfiguration.Provisioning))
{
provisioningClient = new ProvisioningClient(xmppClient, xmppConfiguration.Provisioning);
}
DateTime Now = DateTime.Now;
int MsToNext = 60000 - (Now.Second * 1000 + Now.Millisecond);
connectionTimer = new Timer(CheckConnection, null, MsToNext, 60000);
xmppClient.OnStateChanged += XmppClient_OnStateChanged;
xmppClient.OnPresenceSubscribe += XmppClient_OnPresenceSubscribe;
xmppClient.OnPresenceUnsubscribe += XmppClient_OnPresenceUnsubscribe;
xmppClient.OnRosterItemUpdated += XmppClient_OnRosterItemUpdated;
ibbClient = new Networking.XMPP.InBandBytestreams.IbbClient(xmppClient, MaxChunkSize);
Types.SetModuleParameter("IBB", ibbClient);
socksProxy = new Networking.XMPP.P2P.SOCKS5.Socks5Proxy(xmppClient);
Types.SetModuleParameter("SOCKS5", socksProxy);
string CertificateLocalFileName = Config.DocumentElement["Certificate"].Attributes["configFileName"].Value;
string CertificateFileName;
string CertificateXml;
string CertificatePassword;
byte[] CertificateRaw;
try
{
CertificateRaw = Convert.FromBase64String(RuntimeSettings.Get("CERTIFICATE.BASE64", string.Empty));
CertificatePassword = RuntimeSettings.Get("CERTIFICATE.PWD", string.Empty);
certificate = new X509Certificate2(CertificateRaw, CertificatePassword);
}
catch (Exception)
{
certificate = null;
}
if (File.Exists(CertificateFileName = appDataFolder + CertificateLocalFileName))
{
CertificateXml = File.ReadAllText(CertificateFileName);
}
else if (File.Exists(CertificateFileName = CertificateLocalFileName) && certificate == null)
{
CertificateXml = File.ReadAllText(CertificateFileName);
}
else
{
CertificateFileName = null;
CertificateXml = null;
}
if (CertificateXml != null)
{
XmlDocument CertificateConfig = new XmlDocument();
CertificateConfig.LoadXml(CertificateXml);
XSL.Validate(CertificateLocalFileName, CertificateConfig, "CertificateConfiguration", "http://waher.se/Schema/CertificateConfiguration.xsd",
XSL.LoadSchema(typeof(Gateway).Namespace + ".Schema.CertificateConfiguration.xsd", typeof(Gateway).Assembly));
CertificateLocalFileName = CertificateConfig.DocumentElement["FileName"].InnerText;
if (File.Exists(appDataFolder + CertificateLocalFileName))
{
CertificateLocalFileName = appDataFolder + CertificateLocalFileName;
}
CertificateRaw = File.ReadAllBytes(CertificateLocalFileName);
CertificatePassword = CertificateConfig.DocumentElement["Password"].InnerText;
certificate = new X509Certificate2(CertificateRaw, CertificatePassword);
RuntimeSettings.Set("CERTIFICATE.BASE64", Convert.ToBase64String(CertificateRaw));
RuntimeSettings.Set("CERTIFICATE.PWD", CertificatePassword);
if (CertificateLocalFileName != "certificate.pfx" || CertificatePassword != "testexamplecom")
{
try
{
File.Delete(CertificateLocalFileName);
}
catch (Exception)
{
Log.Warning("Unable to delete " + CertificateLocalFileName + " after importing it into the encrypted database.");
}
try
{
File.Delete(CertificateFileName);
}
catch (Exception)
{
Log.Warning("Unable to delete " + CertificateFileName + " after importing it into the encrypted database.");
}
}
}
foreach (XmlNode N in Config.DocumentElement["Ports"].ChildNodes)
{
if (N.LocalName == "Port")
{
XmlElement E = (XmlElement)N;
string Protocol = XML.Attribute(E, "protocol");
if (!string.IsNullOrEmpty(Protocol) && int.TryParse(E.InnerText, out int Port))
{
ports.AddLast(new KeyValuePair <string, int>(Protocol, Port));
}
}
}
webServer = new HttpServer(GetConfigPorts("HTTP"), GetConfigPorts("HTTPS"), certificate);
Types.SetModuleParameter("HTTP", webServer);
StringBuilder sb = new StringBuilder();
foreach (int Port in webServer.OpenPorts)
{
sb.AppendLine(Port.ToString());
}
try
{
File.WriteAllText(appDataFolder + "Ports.txt", sb.ToString());
}
catch (Exception ex)
{
Log.Critical(ex);
}
HttpFolderResource HttpFolderResource;
HttpxProxy HttpxProxy;
webServer.Register(new HttpFolderResource("/Graphics", "Graphics", false, false, true, false)); // TODO: Add authentication mechanisms for PUT & DELETE.
webServer.Register(new HttpFolderResource("/highlight", "Highlight", false, false, true, false)); // Syntax highlighting library, provided by http://highlightjs.org
webServer.Register(HttpFolderResource = new HttpFolderResource(string.Empty, rootFolder, false, false, true, true)); // TODO: Add authentication mechanisms for PUT & DELETE.
webServer.Register(HttpxProxy = new HttpxProxy("/HttpxProxy", xmppClient, MaxChunkSize));
webServer.Register("/", (req, resp) =>
{
throw new TemporaryRedirectException(Config.DocumentElement["DefaultPage"].InnerText);
});
webServer.Register(clientEvents = new ClientEvents());
HttpFolderResource.AllowTypeConversion();
MarkdownToHtmlConverter.EmojiSource = Emoji1_24x24;
XmlElement FileFolders = Config.DocumentElement["FileFolders"];
if (FileFolders != null)
{
foreach (XmlNode N in FileFolders.ChildNodes)
{
if (N is XmlElement E && E.LocalName == "FileFolder")
{
string WebFolder = XML.Attribute(E, "webFolder");
string FolderPath = XML.Attribute(E, "folderPath");
webServer.Register(new HttpFolderResource(WebFolder, FolderPath, false, false, true, true));
}
}
}
httpxServer = new HttpxServer(xmppClient, webServer, MaxChunkSize);
Types.SetModuleParameter("HTTPX", HttpxProxy);
Types.SetModuleParameter("HTTPXS", httpxServer);
HttpxProxy.IbbClient = ibbClient;
httpxServer.IbbClient = ibbClient;
HttpxProxy.Socks5Proxy = socksProxy;
httpxServer.Socks5Proxy = socksProxy;
if (xmppConfiguration.Sniffer)
{
ISniffer Sniffer;
Sniffer = new XmlFileSniffer(appDataFolder + "HTTP" + Path.DirectorySeparatorChar +
"HTTP Log %YEAR%-%MONTH%-%DAY%T%HOUR%.xml",
appDataFolder + "Transforms" + Path.DirectorySeparatorChar + "SnifferXmlToHtml.xslt",
7, BinaryPresentationMethod.ByteCount);
webServer.Add(Sniffer);
}
coapEndpoint = new CoapEndpoint();
Types.SetModuleParameter("CoAP", coapEndpoint);
concentratorServer = new ConcentratorServer(xmppClient, provisioningClient, new MeteringTopology());
Types.SetModuleParameter("Concentrator", concentratorServer);
Types.SetModuleParameter("Sensor", concentratorServer.SensorServer);
Types.SetModuleParameter("Control", concentratorServer.ControlServer);
}
catch (Exception ex)
{
Log.Critical(ex);
gatewayRunning.Release();
gatewayRunning.Dispose();
gatewayRunning = null;
StartingServer.Release();
StartingServer.Dispose();
ExceptionDispatchInfo.Capture(ex).Throw();
}
Task.Run(async() =>
{
try
{
try
{
string BinaryFolder = AppDomain.CurrentDomain.BaseDirectory;
string[] LanguageFiles = Directory.GetFiles(BinaryFolder, "*.lng", SearchOption.AllDirectories);
string FileName;
if (LanguageFiles.Length > 0)
{
XmlSchema Schema = XSL.LoadSchema(Translator.SchemaResource, typeof(Translator).Assembly);
foreach (string LanguageFile in LanguageFiles)
{
try
{
FileName = LanguageFile;
if (FileName.StartsWith(BinaryFolder))
{
FileName = FileName.Substring(BinaryFolder.Length);
}
DateTime LastWriteTime = File.GetLastWriteTime(LanguageFile);
DateTime LastImportedTime = await RuntimeSettings.GetAsync(FileName, DateTime.MinValue);
if (LastWriteTime > LastImportedTime)
{
Log.Informational("Importing language file.", FileName);
string Xml = File.ReadAllText(LanguageFile);
XmlDocument Doc = new XmlDocument();
Doc.LoadXml(Xml);
XSL.Validate(FileName, Doc, Translator.SchemaRoot, Translator.SchemaNamespace, Schema);
using (XmlReader r = new XmlNodeReader(Doc))
{
await Translator.ImportAsync(r);
}
RuntimeSettings.Set(FileName, LastWriteTime);
}
}
catch (Exception ex)
{
Log.Critical(ex, LanguageFile);
}
}
}
Types.StartAllModules(int.MaxValue);
}
finally
{
StartingServer.Release();
StartingServer.Dispose();
}
}
catch (Exception ex)
{
Log.Critical(ex);
}
finally
{
xmppClient.Connect();
}
});
return(true);
}
/// <summary>
/// Defines the Metering Topology data source. This data source contains a tree structure of persistent
/// readable and controllable devices
/// </summary>
public MeteringTopology()
{
lastChanged = RuntimeSettings.Get(MeteringTopology.SourceID + ".LastChanged", DateTime.MinValue);
}