/// <summary>
/// Serialize the applet to a file
/// </summary>
private void SerializeApplet(AppletPackage pkg, string target, String csproj = null)
{
Emit.Message("INFO", "Slipsteam {0} -> {1}", pkg.Meta.Id, target);
// Add the file
using (var fs = File.Create(Path.Combine(target, pkg.Meta.Id) + ".pak"))
pkg.Save(fs);
// Save the CSPROJ info
if (!String.IsNullOrEmpty(csproj))
{
XmlDocument doc = new XmlDocument();
doc.Load(csproj);
// Get Android Assets - Do they exist for this object?
var assetPath = Path.Combine(target.Replace(Path.GetDirectoryName(csproj), "").Substring(1), pkg.Meta.Id + ".pak");
var node = doc.SelectSingleNode($"//*[local-name() = 'AndroidAsset'][@Include = '{assetPath}']");
if (node == null)
{
var itemElement = doc.CreateElement("ItemGroup", "http://schemas.microsoft.com/developer/msbuild/2003")
.AppendChild(doc.CreateElement("AndroidAsset", "http://schemas.microsoft.com/developer/msbuild/2003"))
.Attributes.Append(doc.CreateAttribute("Include"));
itemElement.Value = assetPath;
doc.DocumentElement.AppendChild(itemElement.OwnerElement.ParentNode);
doc.Save(csproj);
}
}
}
/// <summary>
/// Install the specified package
/// </summary>
public void Install(string packageId)
{
try
{
if (ApplicationContext.Current.GetService <INetworkInformationService>().IsNetworkAvailable)
{
var amiClient = new AmiServiceClient(ApplicationContext.Current.GetRestClient("ami"));
amiClient.Client.Credentials = this.GetCredentials(amiClient.Client);
amiClient.Client.ProgressChanged += (o, e) => ApplicationContext.Current.SetProgress(String.Format(Strings.locale_downloading, packageId), e.Progress);
amiClient.Client.Description.Endpoint[0].Timeout = 30000;
// Fetch the applet package
using (var ms = amiClient.DownloadApplet(packageId))
{
var package = AppletPackage.Load(ms);
this.m_tracer.TraceInfo("Upgrading {0}...", package.Meta.ToString());
ApplicationContext.Current.GetService <IAppletManagerService>().Install(package, true);
// ApplicationContext.Current.Exit(); // restart
}
}
else
{
return;
}
}
catch (Exception ex)
{
this.m_tracer.TraceError("Error contacting AMI: {0}", ex.Message);
throw new InvalidOperationException(Strings.err_updateFailed);
}
}
/// <summary>
/// Publish to the specified service
/// </summary>
public static AppletInfo Publish(String serverUrl, AppletPackage package)
{
try
{
if (String.IsNullOrEmpty(serverUrl))
{
foreach (var c in s_configuration.Repository)
{
c.GetRepository().Put(package);
}
return(package.Meta);
}
else
{
var config = s_configuration.Repository.Find(o => o.Path == serverUrl);
if (config == null)
{
throw new KeyNotFoundException($"Configuration for {serverUrl} not found");
}
return(config.GetRepository().Put(package));
}
}
catch (RestClientException e)
{
throw new Exception($"PUT Failed - {e.Status} - {e.Message} - {e.Result?.Message}");
}
catch (Exception e)
{
throw new Exception($"PUT Failed - {e.Message}", e);
}
}
public object Create(object data, bool updateIfExists)
{
var pkg = AppletPackage.Load((Stream)data);
ApplicationServiceContext.Current.GetService <IAppletManagerService>().Install(pkg);
X509Certificate2 cert = null;
if (pkg.PublicKey != null)
{
cert = new X509Certificate2(pkg.PublicKey);
}
else if (pkg.Meta.PublicKeyToken != null)
{
X509Store store = new X509Store(StoreName.TrustedPublisher, StoreLocation.LocalMachine);
try
{
store.Open(OpenFlags.ReadOnly);
var results = store.Certificates.Find(X509FindType.FindByThumbprint, pkg.Meta.PublicKeyToken, false);
if (results.Count > 0)
{
cert = results[0];
}
}
finally
{
store.Close();
}
}
return(new AppletManifestInfo(pkg.Meta, new X509Certificate2Info(cert?.Issuer, cert?.NotBefore, cert?.NotAfter, cert?.Subject, cert?.Thumbprint)));
}
/// <summary>
/// Starts the daemon service
/// </summary>
public bool Start()
{
this.m_tracer.TraceInformation("Starting applet manager service...");
this.Starting?.Invoke(this, EventArgs.Empty);
try
{
// Load packages from applets/ filesystem directory
var appletDir = Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), "applets");
if (!Directory.Exists(appletDir))
{
this.m_tracer.TraceWarning("Applet directory {0} doesn't exist, no applets will be loaded", appletDir);
}
else
{
this.m_tracer.TraceEvent(TraceEventType.Verbose, 0, "Scanning {0} for applets...", appletDir);
foreach (var f in Directory.GetFiles(appletDir))
{
// Try to open the file
this.m_tracer.TraceInformation("Loading {0}...", f);
using (var fs = File.OpenRead(f))
{
var pkg = AppletPackage.Load(fs);
if (this.m_fileDictionary.ContainsKey(pkg.Meta.Id))
{
this.m_tracer.TraceEvent(TraceEventType.Critical, 1096, "Duplicate package {0} is not permitted", pkg.Meta.Id);
throw new DuplicateKeyException(pkg.Meta.Id);
}
else if (this.Install(pkg, true))
{
//this.m_appletCollection.Add(pkg.Unpack());
//this.m_fileDictionary.Add(pkg.Meta.Id, f);
}
else
{
this.m_tracer.TraceEvent(TraceEventType.Critical, 1098, "Cannot proceed while untrusted applets are present");
throw new SecurityException("Cannot proceed while untrusted applets are present");
}
}
}
}
}
catch (SecurityException e)
{
this.m_tracer.TraceEvent(TraceEventType.Error, e.HResult, "Error loading applets: {0}", e);
throw new InvalidOperationException("Cannot proceed while untrusted applets are present");
}
catch (Exception ex)
{
this.m_tracer.TraceEvent(TraceEventType.Error, ex.HResult, "Error loading applets: {0}", ex);
throw;
}
this.Started?.Invoke(this, EventArgs.Empty);
return(true);
}
/// <summary>
/// Updates an applet.
/// </summary>
/// <param name="appletId">The id of the applet to be updated.</param>
/// <param name="appletPackage">The applet containing the updated information.</param>
/// <returns>Returns the updated applet.</returns>
public AppletManifestInfo UpdateApplet(Guid appletId, AppletPackage appletPackage)
{
using (var ms = new MemoryStream())
{
appletPackage.Save(ms);
ms.Flush();
return(this.Client.Put <byte[], AppletManifestInfo>($"Applet/{appletId}", "application/octet-stream", ms.ToArray()));
}
}
/// <summary>
/// Creates an applet.
/// </summary>
/// <returns>Returns the created applet manifest info.</returns>
public AppletManifestInfo CreateApplet(AppletPackage appletPackage)
{
using (MemoryStream ms = new MemoryStream())
{
appletPackage.Save(ms);
ms.Flush();
return(this.Client.Post <byte[], AppletManifestInfo>("Applet", "application/octet-stream", ms.ToArray()));
}
}
/// <summary>
/// Starts the application context using in-memory default configuration for the purposes of
/// configuring the software
/// </summary>
/// <returns><c>true</c>, if temporary was started, <c>false</c> otherwise.</returns>
public static bool StartTemporary(IDialogProvider dialogProvider, String appContextName = "OpenIZDC")
{
try
{
var retVal = new DcApplicationContext(dialogProvider);
retVal.SetProgress("Run setup", 0);
retVal.m_configurationManager = new DcConfigurationManager(DcConfigurationManager.GetDefaultConfiguration(appContextName), appContextName);
ApplicationContext.Current = retVal;
ApplicationServiceContext.Current = ApplicationContext.Current;
ApplicationServiceContext.HostType = OpenIZHostType.OtherClient;
retVal.ConfigurationManager.Configuration.GetSection <ApplicationConfigurationSection>().AppSettings.RemoveAll(o => o.Key == "http.index");
retVal.ConfigurationManager.Configuration.GetSection <ApplicationConfigurationSection>().AppSettings.Add(new AppSettingKeyValuePair()
{
Key = "http.index", Value = "/org.openiz.core/views/settings/index.html"
});
retVal.m_tracer = Tracer.GetTracer(typeof(DcApplicationContext));
retVal.ThreadDefaultPrincipal = AuthenticationContext.SystemPrincipal;
var appletService = retVal.GetService <IAppletManagerService>();
retVal.SetProgress("Loading configuration", 0.2f);
// Load all user-downloaded applets in the data directory
foreach (var appPath in Directory.GetFiles(Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), "applets")))
{
try
{
retVal.m_tracer.TraceInfo("Installing applet {0}", appPath);
using (var fs = File.OpenRead(appPath))
{
AppletPackage package = AppletPackage.Load(fs);
appletService.Install(package, true);
}
}
catch (Exception e)
{
retVal.m_tracer.TraceError("Loading applet {0} failed: {1}", appPath, e.ToString());
throw;
}
}
retVal.Start();
return(true);
}
catch (Exception e)
{
Console.WriteLine("OpenIZ FATAL: {0}", e.ToString());
return(false);
}
}
/// <summary>
/// Starts the application context using in-memory default configuration for the purposes of
/// configuring the software
/// </summary>
/// <returns><c>true</c>, if temporary was started, <c>false</c> otherwise.</returns>
public static bool StartTemporary(IDialogProvider dialogProvider, String instanceName, SecurityApplication applicationId, SanteDBHostType hostType)
{
try
{
var retVal = new DcApplicationContext(dialogProvider, instanceName, applicationId, hostType);
retVal.SetProgress("Run setup", 0);
//retVal.AddServiceProvider(typeof(ConfigurationManager));
ApplicationServiceContext.Current = DcApplicationContext.Current = retVal;
retVal.m_tracer = Tracer.GetTracer(typeof(DcApplicationContext));
var configuration = retVal.Configuration.GetSection <DiagnosticsConfigurationSection>();
foreach (var tr in configuration.TraceWriter)
{
Tracer.AddWriter(Activator.CreateInstance(tr.TraceWriter, tr.Filter, tr.InitializationData, configuration.Sources.ToDictionary(o => o.SourceName, o => o.Filter)) as TraceWriter, tr.Filter);
}
retVal.GetService <IServiceManager>().AddServiceProvider(typeof(DefaultBackupService));
var appletService = retVal.GetService <IAppletManagerService>();
retVal.SetProgress("Loading configuration", 0.2f);
// Load all user-downloaded applets in the data directory
foreach (var appPath in Directory.GetFiles(Path.Combine(Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), "applets")))
{
try
{
retVal.m_tracer.TraceInfo("Installing applet {0}", appPath);
using (var fs = File.OpenRead(appPath))
{
AppletPackage package = AppletPackage.Load(fs);
appletService.Install(package, true);
}
}
catch (Exception e)
{
retVal.m_tracer.TraceError("Loading applet {0} failed: {1}", appPath, e.ToString());
throw;
}
}
retVal.GetService <IThreadPoolService>().QueueUserWorkItem((o) => retVal.Start());
return(true);
}
catch (Exception e)
{
Console.WriteLine("SanteDB FATAL: {0}", e.ToString());
return(false);
}
}
/// <summary>
/// Install the specified package
/// </summary>
public void Install(string packageId)
{
try
{
if (ApplicationContext.Current.GetService <INetworkInformationService>().IsNetworkAvailable)
{
var amiClient = new AmiServiceClient(ApplicationContext.Current.GetRestClient("ami"));
using (this.Authenticate(amiClient.Client, out Credentials credentials))
{
amiClient.Client.Credentials = credentials;
amiClient.Client.ProgressChanged += (o, e) => ApplicationContext.Current.SetProgress(string.Format(Strings.locale_downloading, packageId), e.Progress);
amiClient.Client.Description.Endpoint[0].Timeout = 30000;
// Fetch the applet package
if (string.IsNullOrEmpty(this.m_configuration.AppletSolution))
{
using (var ms = amiClient.DownloadApplet(packageId))
{
var package = AppletPackage.Load(ms);
this.m_tracer.TraceInfo("Upgrading {0}...", package.Meta.ToString());
ApplicationContext.Current.GetService <IAppletManagerService>().Install(package, true);
ApplicationServiceContext.Current.GetService <ITickleService>().SendTickle(new Tickle(Guid.Empty, TickleType.Information, string.Format(Strings.locale_updateInstalled, package.Meta.Id, package.Meta.Version)));
// ApplicationContext.Current.Exit(); // restart
}
}
else
{
using (var ms = new MemoryStream(amiClient.Client.Get($"AppletSolution/{this.m_configuration.AppletSolution}/applet/{packageId}")))
{
var package = AppletPackage.Load(ms);
this.m_tracer.TraceInfo("Upgrading {0}...", package.Meta.ToString());
ApplicationContext.Current.GetService <IAppletManagerService>().Install(package, true);
ApplicationServiceContext.Current.GetService <ITickleService>().SendTickle(new Tickle(Guid.Empty, TickleType.Information, string.Format(Strings.locale_updateInstalled, package.Meta.Id, package.Meta.Version)));
// ApplicationContext.Current.Exit(); // restart
}
}
}
}
}
catch (Exception ex)
{
this.m_tracer.TraceError("Error contacting AMI: {0}", ex.Message);
throw new InvalidOperationException(Strings.err_updateFailed);
}
}
/// <summary>
/// Downloads the applet.
/// </summary>
/// <param name="appletId">The applet identifier.</param>
/// <returns>Stream.</returns>
public Stream DownloadApplet(string appletId)
{
var appletService = ApplicationContext.Current.GetService <IAppletManagerService>();
var appletData = appletService.GetPackage(appletId);
if (appletData == null)
{
throw new FileNotFoundException(appletId);
}
else
{
var appletManifest = AppletPackage.Load(appletData);
this.SetAppletHeaders(appletManifest.Meta);
return(new MemoryStream(appletData));
}
}
/// <summary>
/// Install the package
/// </summary>
public AppletInfo Put(AppletPackage package)
{
// Locate the specified package
try
{
using (var ms = new MemoryStream())
{
package.Save(ms);
return(this.m_client.Put <MemoryStream, AppletInfo>("pak", new MemoryStream(ms.ToArray())));
}
}
catch (RestClientException e)
{
this.m_traceSource.TraceEvent(TraceEventType.Error, e.HResult, "Error pushing package {0}: {1}", package.Meta, e);
throw;
}
}
/// <summary>
/// Put the application into the file repository
/// </summary>
public AppletInfo Put(Stream body)
{
var package = AppletPackage.Load(body);
try
{
this.m_configuration.Repository.GetRepository().Get(package.Meta.Id, new Version(package.Meta.Version), true);
throw new FaultException(409, $"Package {package.Meta.Id} version {package.Meta.Version} already exists");
}
catch (KeyNotFoundException)
{
return(this.m_configuration.Repository.GetRepository().Put(package));
}
finally
{
}
}
/// <summary>
/// Package the assets
/// </summary>
/// <returns></returns>
public int Package()
{
using (FileStream fs = File.OpenRead(this.m_parameters.Output))
this.m_package = AppletSolution.Load(fs);
// Package the android APK project
if (this.m_parameters.DcdrAssets.Contains("android"))
{
this.PackageApk();
}
// Package the DCG project
if (this.m_parameters.DcdrAssets.Contains("gateway"))
{
this.PackageDcg();
}
return(1);
}
public object Update(object data)
{
var appletMgr = ApplicationServiceContext.Current.GetService <IAppletSolutionManagerService>();
var pkg = AppletPackage.Load((Stream)data) as AppletSolution;
if (!appletMgr.Solutions.Any(o => pkg.Meta.Id == o.Meta.Id))
{
this.m_tracer.TraceError($"File not found: {pkg.Meta.Id}");
throw new FileNotFoundException(this.m_localizationService.FormatString("error.rest.ami.FileNotFoundParam", new
{
param = pkg.Meta.Id
}));
}
appletMgr.Install(pkg, true);
X509Certificate2 cert = null;
if (pkg.PublicKey != null)
{
cert = new X509Certificate2(pkg.PublicKey);
}
else if (pkg.Meta.PublicKeyToken != null)
{
X509Store store = new X509Store(StoreName.TrustedPublisher, StoreLocation.LocalMachine);
try
{
store.Open(OpenFlags.ReadOnly);
var results = store.Certificates.Find(X509FindType.FindByThumbprint, pkg.Meta.PublicKeyToken, false);
if (results.Count > 0)
{
cert = results[0];
}
}
finally
{
store.Close();
}
}
return(new AppletSolutionInfo(pkg, new X509Certificate2Info(cert?.Issuer, cert?.NotBefore, cert?.NotAfter, cert?.Subject, cert?.Thumbprint)));
}
public object Get(Object appletId, Object versionId)
{
var appletService = ApplicationServiceContext.Current.GetService <IAppletManagerService>();
var appletData = appletService.GetPackage(appletId.ToString());
if (appletData == null)
{
this.m_tracer.TraceError($"File not found: {appletId}");
throw new FileNotFoundException(this.m_localizationService.FormatString("error.rest.ami.FileNotFoundParam", new
{
param = appletId.ToString()
}));
}
else
{
var appletManifest = AppletPackage.Load(appletData);
this.SetAppletHeaders(appletManifest.Meta);
return(new MemoryStream(appletData));
}
}
/// <summary>
/// Sign an existing package
/// </summary>
private static int Sign(ConsoleParameters parameters)
{
try
{
AppletPackage pkg = null;
using (FileStream fs = File.OpenRead(parameters.Source))
pkg = AppletPackage.Load(fs);
Console.WriteLine("Will sign package {0}", pkg.Meta);
pkg = CreateSignedPackage(pkg.Unpack(), parameters);
using (FileStream fs = File.Create(parameters.Output ?? Path.ChangeExtension(parameters.Source, ".signed.pak")))
pkg.Save(fs);
return(0);
}
catch (Exception e)
{
Console.Error.WriteLine("Cannot sign package: {0}", e);
return(-0232);
}
}
/// <summary>
/// Get the specified package contents
/// </summary>
public AppletPackage Get(string id, Version version, bool exactVersion = false)
{
// Locate the specified package
try
{
var path = $"pak/{id}";
if (version != null)
{
path += $"/{version}";
}
using (var inStream = this.m_client.Get <MemoryStream>(path))
return(AppletPackage.Load(inStream));
}
catch (RestClientException e)
{
this.m_traceSource.TraceEvent(TraceEventType.Error, e.HResult, "Error fetching package {0} v{1}: {2}", id, version, e);
throw;
}
}
/// <summary>
/// Sign an existing package
/// </summary>
public int Sign()
{
try
{
AppletPackage pkg = null;
using (FileStream fs = File.OpenRead(this.m_parms.Source))
pkg = AppletPackage.Load(fs);
Emit.Message("INFO", "Will sign package {0}", pkg.Meta);
pkg = this.CreateSignedPackage(pkg.Unpack());
using (FileStream fs = File.Create(this.m_parms.Output ?? Path.ChangeExtension(this.m_parms.Source, ".signed.pak")))
pkg.Save(fs);
return(0);
}
catch (Exception e)
{
Emit.Message("ERROR", "Cannot sign package: {0}", e);
return(-0232);
}
}
/// <summary>
/// Get specified package from any package repository
/// </summary>
public static AppletPackage GetFromAny(String packageId, Version packageVersion)
{
AppletPackage retVal = null;
try
{
return(s_localCache.GetRepository().Get(packageId, packageVersion, true));
}
catch
{
foreach (var rep in s_configuration.Repository)
{
try
{
retVal = rep.GetRepository().Get(packageId, packageVersion);
if (retVal == null)
{
continue;
}
if (packageVersion == null || retVal.Version == packageVersion.ToString())
{
if (!LocalCachePath.Equals(rep.Path))
{
PackageRepositoryUtil.InstallCache(retVal);
}
break;
}
}
catch
{
}
}
}
return(retVal);
}
/// <summary>
/// Installs a package into the package repository
/// </summary>
public AppletInfo Put(AppletPackage package)
{
if (this.m_packageInfos == null)
{
throw new InvalidOperationException("Package repository is not initialized");
}
else if (String.IsNullOrEmpty(package.Meta?.Id))
{
throw new ArgumentNullException("Package must have ID");
}
else if (String.IsNullOrEmpty(package.Meta?.Version))
{
throw new ArgumentNullException("Package must have version");
}
try
{
var targetPath = Path.Combine(this.GetRepositoryPath(), $"{package.Meta.Id}-{package.Meta.Version}.pak");
if (!Directory.Exists(Path.GetDirectoryName(targetPath)))
{
Directory.CreateDirectory(Path.GetDirectoryName(targetPath));
}
using (var fs = System.IO.File.Create(targetPath))
package.Save(fs);
// Add the file to the repository
lock (this.m_lockObject)
if (!this.m_packageInfos.ContainsKey(targetPath))
{
this.m_packageInfos.Add(targetPath, package.Meta);
}
return(package.Meta);
}
catch (System.Exception e)
{
throw new System.Exception($"Could not install package {package.Meta.Id} v {package.Meta.Version}", e);
}
}
/// <summary>
/// Updates an applet.
/// </summary>
/// <param name="appletId">The id of the applet to be updated.</param>
/// <param name="appletData">The applet containing the updated information.</param>
/// <returns>Returns the updated applet.</returns>
/// <exception cref="System.ArgumentException">Applet not found.</exception>
public AppletManifestInfo UpdateApplet(string appletId, Stream appletData)
{
var appletMgr = ApplicationContext.Current.GetService <IAppletManagerService>();
if (!appletMgr.Applets.Any(o => o.Info.Id == appletId))
{
throw new FileNotFoundException(appletId);
}
var pkg = AppletPackage.Load(appletData);
ApplicationContext.Current.GetService <IAppletManagerService>().Install(pkg, true);
X509Certificate2 cert = null;
if (pkg.PublicKey != null)
{
cert = new X509Certificate2(pkg.PublicKey);
}
else if (pkg.Meta.PublicKeyToken != null)
{
X509Store store = new X509Store(StoreName.TrustedPublisher, StoreLocation.LocalMachine);
try
{
store.Open(OpenFlags.ReadOnly);
var results = store.Certificates.Find(X509FindType.FindByThumbprint, pkg.Meta.PublicKeyToken, false);
if (results.Count > 0)
{
cert = results[0];
}
}
finally
{
store.Close();
}
}
return(new AppletManifestInfo(pkg.Meta, new X509Certificate2Info(cert?.Issuer, cert?.NotBefore, cert?.NotAfter, cert?.Subject, cert?.Thumbprint)));
}
/// <summary>
/// Get specific applet
/// </summary>
public object Get(Type scopingType, object scopingKey, object key)
{
var appletData = this.m_solutionManager.GetPackage(scopingKey.ToString(), key.ToString());
if (appletData == null)
{
throw new FileNotFoundException(key.ToString());
}
else
{
var appletManifest = AppletPackage.Load(appletData);
RestOperationContext.Current.OutgoingResponse.SetETag(appletManifest.Meta.Version);
RestOperationContext.Current.OutgoingResponse.Headers.Add("X-SanteDB-PakID", appletManifest.Meta.Id);
if (appletManifest.Meta.Hash != null)
{
RestOperationContext.Current.OutgoingResponse.AppendHeader("X-SanteDB-Hash", Convert.ToBase64String(appletManifest.Meta.Hash));
}
RestOperationContext.Current.OutgoingResponse.AppendHeader("Content-Type", "application/octet-stream");
RestOperationContext.Current.OutgoingResponse.ContentType = "application/octet-stream";
RestOperationContext.Current.OutgoingResponse.AppendHeader("Content-Disposition", $"attachment; filename=\"{appletManifest.Meta.Id}.pak.gz\"");
RestOperationContext.Current.OutgoingResponse.AppendHeader("Location", $"/ami/Applet/{appletManifest.Meta.Id}");
return(new MemoryStream(appletData));
}
}
public object Create(object data, bool updateIfExists)
{
var pkg = AppletPackage.Load((Stream)data) as AppletSolution;
if (pkg == null)
{
this.m_tracer.TraceError("Package does not appear to be a solution");
throw new InvalidOperationException(this.m_localizationService.GetString("error.rest.ami.packageNotASolution"));
}
ApplicationServiceContext.Current.GetService <IAppletSolutionManagerService>().Install(pkg);
X509Certificate2 cert = null;
if (pkg.PublicKey != null)
{
cert = new X509Certificate2(pkg.PublicKey);
}
else if (pkg.Meta.PublicKeyToken != null)
{
X509Store store = new X509Store(StoreName.TrustedPublisher, StoreLocation.LocalMachine);
try
{
store.Open(OpenFlags.ReadOnly);
var results = store.Certificates.Find(X509FindType.FindByThumbprint, pkg.Meta.PublicKeyToken, false);
if (results.Count > 0)
{
cert = results[0];
}
}
finally
{
store.Close();
}
}
return(new AppletSolutionInfo(pkg, new X509Certificate2Info(cert?.Issuer, cert?.NotBefore, cert?.NotAfter, cert?.Subject, cert?.Thumbprint)));
}
/// <summary>
/// Start the application context
/// </summary>
public static bool Start(ConsoleParameters consoleParms)
{
var retVal = new MiniApplicationContext();
retVal.m_configurationManager = new MiniConfigurationManager();
// Not configured
if (!retVal.ConfigurationManager.IsConfigured)
{
return(false);
}
else
{ // load configuration
try
{
// Set master application context
ApplicationContext.Current = retVal;
retVal.ConfigurationManager.Load();
retVal.AddServiceProvider(typeof(XamarinBackupService));
retVal.m_tracer = Tracer.GetTracer(typeof(MiniApplicationContext), retVal.ConfigurationManager.Configuration);
var appService = retVal.GetService <IAppletManagerService>();
retVal.SetProgress("Loading configuration", 0.2f);
if (consoleParms.References != null)
{
// Load references
foreach (var appletInfo in consoleParms.References)// Directory.GetFiles(this.m_configuration.GetSection<AppletConfigurationSection>().AppletDirectory)) {
{
try
{
retVal.m_tracer.TraceInfo("Loading applet {0}", appletInfo);
String appletPath = appletInfo;
if (!Path.IsPathRooted(appletInfo))
{
appletPath = Path.Combine(Environment.CurrentDirectory, appletPath);
}
using (var fs = File.OpenRead(appletPath))
{
var package = AppletPackage.Load(fs);
retVal.m_tracer.TraceInfo("Loading {0} v{1}", package.Meta.Id, package.Meta.Version);
// Is this applet in the allowed applets
appService.LoadApplet(package.Unpack());
}
}
catch (Exception e)
{
retVal.m_tracer.TraceError("Loading applet {0} failed: {1}", appletInfo, e.ToString());
throw;
}
}
}
// Does openiz.js exist as an asset?
var oizJs = appService.Applets.ResolveAsset("/org.openiz.core/js/openiz.js");
// Load all user-downloaded applets in the data directory
foreach (var appletDir in consoleParms.AppletDirectories)// Directory.GetFiles(this.m_configuration.GetSection<AppletConfigurationSection>().AppletDirectory)) {
{
try
{
if (!Directory.Exists(appletDir) || !File.Exists(Path.Combine(appletDir, "manifest.xml")))
{
continue;
}
retVal.m_tracer.TraceInfo("Loading applet {0}", appletDir);
String appletPath = Path.Combine(appletDir, "manifest.xml");
using (var fs = File.OpenRead(appletPath))
{
AppletManifest manifest = AppletManifest.Load(fs);
(appService as MiniAppletManagerService).m_appletBaseDir.Add(manifest, appletDir);
// Is this applet in the allowed applets
// public key token match?
appService.LoadApplet(manifest);
}
}
catch (Exception e)
{
retVal.m_tracer.TraceError("Loading applet {0} failed: {1}", appletDir, e.ToString());
throw;
}
}
if (oizJs?.Content != null)
{
oizJs.Content = oizJs.Content.ToString() + (appService as MiniAppletManagerService).GetShimMethods();
}
// Ensure data migration exists
try
{
// If the DB File doesn't exist we have to clear the migrations
if (!File.Exists(retVal.Configuration.GetConnectionString(retVal.Configuration.GetSection <DataConfigurationSection>().MainDataSourceConnectionStringName).Value))
{
retVal.m_tracer.TraceWarning("Can't find the OpenIZ database, will re-install all migrations");
retVal.Configuration.GetSection <DataConfigurationSection>().MigrationLog.Entry.Clear();
}
retVal.SetProgress("Migrating databases", 0.6f);
DataMigrator migrator = new DataMigrator();
migrator.Ensure();
// Set the entity source
EntitySource.Current = new EntitySource(retVal.GetService <IEntitySourceProvider>());
// Prepare clinical protocols
//retVal.GetService<ICarePlanService>().Repository = retVal.GetService<IClinicalProtocolRepositoryService>();
ApplicationServiceContext.Current = ApplicationContext.Current;
ApplicationServiceContext.HostType = OpenIZHostType.OtherClient;
}
catch (Exception e)
{
retVal.m_tracer.TraceError(e.ToString());
throw;
}
finally
{
retVal.ConfigurationManager.Save();
}
if (!retVal.Configuration.GetSection <DiagnosticsConfigurationSection>().TraceWriter.Any(o => o.TraceWriterClassXml.Contains("Console")))
{
retVal.Configuration.GetSection <DiagnosticsConfigurationSection>().TraceWriter.Add(new TraceWriterConfiguration()
{
TraceWriter = new ConsoleTraceWriter(EventLevel.Warning, "")
});
}
// Set the tracer writers for the PCL goodness!
foreach (var itm in retVal.Configuration.GetSection <DiagnosticsConfigurationSection>().TraceWriter)
{
OpenIZ.Core.Diagnostics.Tracer.AddWriter(itm.TraceWriter, itm.Filter);
}
// Start daemons
retVal.GetService <IThreadPoolService>().QueueUserWorkItem(o => { retVal.Start(); });
//retVal.Start();
}
catch (Exception e)
{
retVal.m_tracer?.TraceError(e.ToString());
//ApplicationContext.Current = null;
retVal.m_configurationManager = new MiniConfigurationManager(MiniConfigurationManager.GetDefaultConfiguration());
throw;
}
return(true);
}
}
/// <summary>
/// Starts the application context using in-memory default configuration for the purposes of
/// configuring the software
/// </summary>
/// <returns><c>true</c>, if temporary was started, <c>false</c> otherwise.</returns>
public static bool StartTemporary(ConsoleParameters consoleParms)
{
try
{
var retVal = new MiniApplicationContext();
retVal.SetProgress("Run setup", 0);
retVal.m_configurationManager = new MiniConfigurationManager(MiniConfigurationManager.GetDefaultConfiguration());
ApplicationContext.Current = retVal;
ApplicationServiceContext.Current = ApplicationContext.Current;
ApplicationServiceContext.HostType = OpenIZHostType.OtherClient;
retVal.m_tracer = Tracer.GetTracer(typeof(MiniApplicationContext));
retVal.ThreadDefaultPrincipal = AuthenticationContext.SystemPrincipal;
retVal.SetProgress("Loading configuration", 0.2f);
var appService = retVal.GetService <IAppletManagerService>();
if (consoleParms.References != null)
{
// Load references
foreach (var appletInfo in consoleParms.References)// Directory.GetFiles(this.m_configuration.GetSection<AppletConfigurationSection>().AppletDirectory)) {
{
try
{
retVal.m_tracer.TraceInfo("Loading applet {0}", appletInfo);
String appletPath = appletInfo;
if (!Path.IsPathRooted(appletInfo))
{
appletPath = Path.Combine(Environment.CurrentDirectory, appletPath);
}
using (var fs = File.OpenRead(appletPath))
{
var package = AppletPackage.Load(fs);
retVal.m_tracer.TraceInfo("Loading {0} v{1}", package.Meta.Id, package.Meta.Version);
// Is this applet in the allowed applets
appService.LoadApplet(package.Unpack());
}
}
catch (Exception e)
{
retVal.m_tracer.TraceError("Loading applet {0} failed: {1}", appletInfo, e.ToString());
throw;
}
}
}
// Does openiz.js exist as an asset?
var oizJs = appService.Applets.ResolveAsset("/org.openiz.core/js/openiz.js");
// Load all user-downloaded applets in the data directory
foreach (var appletDir in consoleParms.AppletDirectories)// Directory.GetFiles(this.m_configuration.GetSection<AppletConfigurationSection>().AppletDirectory)) {
{
try
{
if (!Directory.Exists(appletDir) || !File.Exists(Path.Combine(appletDir, "manifest.xml")))
{
continue;
}
retVal.m_tracer.TraceInfo("Loading applet {0}", appletDir);
String appletPath = Path.Combine(appletDir, "manifest.xml");
using (var fs = File.OpenRead(appletPath))
{
AppletManifest manifest = AppletManifest.Load(fs);
(appService as MiniAppletManagerService).m_appletBaseDir.Add(manifest, appletDir);
// Is this applet in the allowed applets
// public key token match?
appService.LoadApplet(manifest);
}
}
catch (Exception e)
{
retVal.m_tracer.TraceError("Loading applet {0} failed: {1}", appletDir, e.ToString());
throw;
}
}
if (oizJs?.Content != null)
{
oizJs.Content = oizJs.Content.ToString() + (appService as MiniAppletManagerService).GetShimMethods();
}
retVal.Start();
return(true);
}
catch (Exception e)
{
Console.WriteLine("OpenIZ FATAL: {0}", e.ToString());
return(false);
}
}
/// <summary>
/// Performs an installation
/// </summary>
public virtual bool Install(AppletPackage package, bool isUpgrade = false)
{
this.m_tracer.TraceWarning("Installing {0}", package.Meta);
// TODO: Verify package hash / signature
if (!this.VerifyPackage(package))
{
throw new SecurityException("Applet failed validation");
}
else if (!this.m_appletCollection.VerifyDependencies(package.Meta))
{
this.m_tracer.TraceWarning($"Applet {package.Meta} depends on : [{String.Join(", ", package.Meta.Dependencies.Select(o => o.ToString()))}] which are missing or incompatible");
}
var appletSection = ApplicationContext.Current.Configuration.GetSection <AppletConfigurationSection>();
String appletPath = Path.Combine(appletSection.AppletDirectory, package.Meta.Id);
try
{
// Desearialize an prep for install
this.m_tracer.TraceInfo("Installing applet {0} (IsUpgrade={1})", package.Meta, isUpgrade);
ApplicationContext.Current.SetProgress(package.Meta.GetName("en"), 0.0f);
// TODO: Verify the package
// Copy
if (!Directory.Exists(appletSection.AppletDirectory))
{
Directory.CreateDirectory(appletSection.AppletDirectory);
}
if (File.Exists(appletPath))
{
if (!isUpgrade)
{
throw new InvalidOperationException(Strings.err_duplicate_package_name);
}
// Unload the loaded applet version
var existingApplet = this.m_appletCollection.FirstOrDefault(o => o.Info.Id == package.Meta.Id);
if (existingApplet != null)
{
this.UnInstallInternal(existingApplet);
}
}
var mfst = package.Unpack();
// Migrate data.
if (mfst.DataSetup != null)
{
foreach (var itm in mfst.DataSetup.Action)
{
Type idpType = typeof(IDataPersistenceService <>);
idpType = idpType.MakeGenericType(new Type[] { itm.Element.GetType() });
var svc = ApplicationContext.Current.GetService(idpType);
idpType.GetMethod(itm.ActionName).Invoke(svc, new object[] { itm.Element, TransactionMode.Commit, AuthenticationContext.SystemPrincipal });
}
}
// Now export all the binary files out
var assetDirectory = Path.Combine(appletSection.AppletDirectory, "assets", mfst.Info.Id);
if (!Directory.Exists(assetDirectory))
{
Directory.CreateDirectory(assetDirectory);
}
else
{
Directory.Delete(assetDirectory, true);
}
for (int i = 0; i < mfst.Assets.Count; i++)
{
var itm = mfst.Assets[i];
var itmPath = Path.Combine(assetDirectory, itm.Name);
ApplicationContext.Current.SetProgress($"Installing {package.Meta.GetName("en")}", 0.1f + (float)(0.8 * (float)i / mfst.Assets.Count));
// Get dir name and create
if (!Directory.Exists(Path.GetDirectoryName(itmPath)))
{
Directory.CreateDirectory(Path.GetDirectoryName(itmPath));
}
// Extract content
if (itm.Content is byte[])
{
if (Encoding.UTF8.GetString(itm.Content as byte[], 0, 4) == "LZIP")
{
using (var fs = File.Create(itmPath))
using (var ms = new MemoryStream(itm.Content as byte[]))
using (var lzs = new LZipStream(new NonDisposingStream(ms), SharpCompress.Compressors.CompressionMode.Decompress))
lzs.CopyTo(fs);
}
else
{
File.WriteAllBytes(itmPath, itm.Content as byte[]);
}
itm.Content = null;
}
else if (itm.Content is String)
{
File.WriteAllText(itmPath, itm.Content as String);
itm.Content = null;
}
}
// Serialize the data to disk
using (FileStream fs = File.Create(appletPath))
mfst.Save(fs);
// For now sign with SHA256
SHA256 sha = SHA256.Create();
package.Meta.Hash = sha.ComputeHash(File.ReadAllBytes(appletPath));
// HACK: Re-re-remove
appletSection.Applets.RemoveAll(o => o.Id == package.Meta.Id);
appletSection.Applets.Add(package.Meta.AsReference());
ApplicationContext.Current.SetProgress(package.Meta.GetName("en"), 0.98f);
if (ApplicationContext.Current.ConfigurationPersister.IsConfigured)
{
ApplicationContext.Current.ConfigurationPersister.Save(ApplicationContext.Current.Configuration);
}
this.LoadApplet(mfst);
}
catch (Exception e)
{
this.m_tracer.TraceError("Error installing applet {0} : {1}", package.Meta.ToString(), e);
// Remove
if (File.Exists(appletPath))
{
File.Delete(appletPath);
}
throw;
}
return(true);
}
/// <summary>
/// Compile
/// </summary>
static int Compile(ConsoleParameters parameters)
{
int retVal = 0;
// First is there a Manifest.xml?
if (!Path.IsPathRooted(parameters.Source))
{
parameters.Source = Path.Combine(Environment.CurrentDirectory, parameters.Source);
}
// Applet collection
AppletCollection ac = new AppletCollection();
XmlSerializer xsz = new XmlSerializer(typeof(AppletManifest));
XmlSerializer xpz = new XmlSerializer(typeof(AppletPackage));
if (parameters.References != null)
{
foreach (var itm in parameters.References)
{
if (File.Exists(itm))
{
using (var fs = File.OpenRead(itm))
{
if (Path.GetExtension(itm) == ".pak")
{
using (var gzs = new GZipStream(fs, CompressionMode.Decompress))
{
var pack = xpz.Deserialize(gzs) as AppletPackage;
var mfst = pack.Unpack();
mfst.Initialize();
ac.Add(mfst);
Console.WriteLine("Added reference to {0}; v={1}", mfst.Info.Id, mfst.Info.Version);
}
}
else
{
var mfst = xsz.Deserialize(fs) as AppletManifest;
mfst.Initialize();
ac.Add(mfst);
Console.WriteLine("Added reference to {0}; v={1}", mfst.Info.Id, mfst.Info.Version);
}
}
}
}
}
Console.WriteLine("Processing {0}...", parameters.Source);
String manifestFile = Path.Combine(parameters.Source, "manifest.xml");
if (!File.Exists(manifestFile))
{
Console.WriteLine("Directory must have manifest.xml");
}
else
{
Console.WriteLine("\t Reading Manifest...", parameters.Source);
using (var fs = File.OpenRead(manifestFile))
{
AppletManifest mfst = xsz.Deserialize(fs) as AppletManifest;
mfst.Assets.AddRange(ProcessDirectory(parameters.Source, parameters.Source, parameters));
foreach (var i in mfst.Assets)
{
i.Name = i.Name.Substring(1);
}
if (mfst.Info.Version.Contains("*"))
{
mfst.Info.Version = mfst.Info.Version.Replace("*", (((DateTime.Now.Subtract(new DateTime(DateTime.Now.Year, 1, 1)).Ticks >> 24) % 10000)).ToString("0000"));
}
if (!Directory.Exists(Path.GetDirectoryName(parameters.Output)) && !String.IsNullOrEmpty(Path.GetDirectoryName(parameters.Output)))
{
Directory.CreateDirectory(Path.GetDirectoryName(parameters.Output));
}
AppletPackage pkg = null;
// Is there a signature?
if (!String.IsNullOrEmpty(parameters.SignKey))
{
pkg = CreateSignedPackage(mfst, parameters);
if (pkg == null)
{
return(-102);
}
}
else
{
Console.WriteLine("WARNING:>>> THIS PACKAGE IS NOT SIGNED - MOST OPEN IZ TOOLS WILL NOT LOAD IT");
mfst.Info.PublicKeyToken = null;
pkg = mfst.CreatePackage(parameters.Compression);
//pkg.Meta.PublicKeyToken = null;
}
pkg.Meta.Hash = SHA256.Create().ComputeHash(pkg.Manifest);
using (var ofs = File.Create(Path.ChangeExtension(parameters.Output ?? "out.pak", ".pak")))
{
pkg.Save(ofs);
}
// Render the build directory
if (!String.IsNullOrEmpty(parameters.Deploy))
{
var bindir = Path.Combine(Path.GetDirectoryName(parameters.Output), "bin");
if (String.IsNullOrEmpty(parameters.Deploy))
{
if (Directory.Exists(bindir) && parameters.Clean)
{
Directory.Delete(bindir, true);
}
bindir = Path.Combine(bindir, mfst.Info.Id);
Directory.CreateDirectory(bindir);
}
else
{
bindir = parameters.Deploy;
}
mfst.Initialize();
ac.Add(mfst);
foreach (var lang in mfst.Strings)
{
string wd = Path.Combine(bindir, lang.Language);
if (String.IsNullOrEmpty(parameters.Lang))
{
Directory.CreateDirectory(wd);
}
else if (parameters.Lang == lang.Language)
{
wd = bindir;
}
else
{
continue;
}
foreach (var m in ac)
{
foreach (var itm in m.Assets)
{
try
{
String fn = Path.Combine(wd, m.Info.Id, itm.Name.Replace("/", "\\"));
Console.WriteLine("\tRendering {0}...", fn);
if (!Directory.Exists(Path.GetDirectoryName(fn)))
{
Directory.CreateDirectory(Path.GetDirectoryName(fn));
}
File.WriteAllBytes(fn, ac.RenderAssetContent(itm, lang.Language));
}
catch (Exception e)
{
Console.WriteLine("E: {0}: {1} {2}", itm, e.GetType().Name, e);
retVal = -1000;
}
}
}
}
}
}
}
return(retVal);
}
/// <summary>
/// Compose multiple PAK files into a solution
/// </summary>
public int Compose()
{
try
{
AppletManifest mfst = null;
using (FileStream fs = File.OpenRead(this.m_parms.Source))
mfst = AppletManifest.Load(fs);
var slnPak = mfst.CreatePackage();
AppletSolution sln = new AppletSolution();
sln.Meta = slnPak.Meta;
sln.PublicKey = slnPak.PublicKey;
sln.Manifest = slnPak.Manifest;
if (sln.Meta.Uuid == Guid.Empty)
{
Emit.Message("WARN", "The package does not carry a UUID! You should add a UUID to your solution manifest");
}
sln.Include = new List <AppletPackage>();
foreach (var pfile in sln.Meta.Dependencies.ToArray())
{
AppletPackage pkg = null;
if (!String.IsNullOrEmpty(pfile.Version)) // specific version
{
pkg = PackageRepositoryUtil.GetFromAny(pfile.Id, new Version(pfile.Version));
}
else if (!String.IsNullOrEmpty(m_parms.Version))
{
pkg = PackageRepositoryUtil.GetFromAny(pfile.Id, new Version(m_parms.Version))
?? PackageRepositoryUtil.GetFromAny(pfile.Id, null);
}
else
{
pkg = PackageRepositoryUtil.GetFromAny(pfile.Id, null);
}
if (pkg == null)
{
throw new KeyNotFoundException($"Package {pfile.Id} ({pfile.Version ?? m_parms.Version ?? "latest"}) not found");
}
else
{
Emit.Message("INFO", "Including {0} version {1}..", pkg.Meta.Id, pkg.Meta.Version);
sln.Meta.Dependencies.RemoveAll(o => o.Id == pkg.Meta.Id);
if (this.m_parms.Sign && pkg.Meta.Signature == null)
{
Emit.Message("WARN", "Package {0} is not signed, but you're signing your package. We'll sign it using your key", pkg.Meta.Id);
pkg = new Signer(this.m_parms).CreateSignedPackage(pkg.Unpack());
}
sln.Include.Add(pkg);
}
}
// Emit i18n file?
if (!String.IsNullOrEmpty(this.m_parms.InternationalizationFile))
{
Emit.Message("INFO", $"Writing string manifest to {this.m_parms.InternationalizationFile}");
using (var fs = File.Create(this.m_parms.InternationalizationFile))
using (var tw = new StreamWriter(fs, System.Text.Encoding.UTF8))
{
// tx translations
var mfsts = sln.Include.Select(o => o.Unpack()).ToList();
var appletStrings = mfsts.SelectMany(o => o.Strings).ToArray();
var stringKeys = appletStrings.SelectMany(o => o.String).Select(o => o.Key).Distinct();
var langs = appletStrings.Select(o => o.Language).Distinct().ToArray();
tw.Write("key,");
tw.WriteLine(String.Join(",", langs));
foreach (var str in stringKeys)
{
tw.Write($"{str},");
foreach (var lang in langs)
{
tw.Write($"\"{appletStrings.Where(o => o.Language == lang).SelectMany(s => s.String).FirstOrDefault(o => o.Key == str)?.Value}\",");
}
tw.WriteLine();
}
}
}
sln.Meta.Hash = SHA256.Create().ComputeHash(sln.Include.SelectMany(o => o.Manifest).ToArray());
// Sign the signature package
if (this.m_parms.Sign)
{
new Signer(this.m_parms).CreateSignedSolution(sln);
}
// Now save
using (FileStream fs = File.Create(this.m_parms.Output ?? Path.ChangeExtension(sln.Meta.Id, ".sln.pak")))
sln.Save(fs);
return(0);
}
catch (System.Exception e)
{
Emit.Message("ERROR", e.Message);
//Console.Error.WriteLine("Cannot compose solution {0}: {1}", this.m_parms.Source, e);
return(-1);
}
}
/// <summary>
/// Start the application context
/// </summary>
public static bool Start(A.Content.Context launcherActivity, A.Content.Context context, A.App.Application application)
{
var retVal = new AndroidApplicationContext();
retVal.Context = context;
retVal.m_configurationManager = new ConfigurationManager();
retVal.AndroidApplication = application;
// Not configured
if (!retVal.ConfigurationManager.IsConfigured)
{
NoConfiguration?.Invoke(null, EventArgs.Empty);
return(false);
}
else
{ // load configuration
try
{
// Set master application context
ApplicationContext.Current = retVal;
retVal.CurrentActivity = launcherActivity;
try
{
retVal.ConfigurationManager.Load();
retVal.ConfigurationManager.Backup();
}
catch
{
if (retVal.ConfigurationManager.HasBackup() &&
retVal.Confirm(Strings.err_configuration_invalid_restore_prompt))
{
retVal.ConfigurationManager.Restore();
retVal.ConfigurationManager.Load();
}
else
{
throw;
}
}
retVal.AddServiceProvider(typeof(AndroidBackupService));
retVal.m_tracer = Tracer.GetTracer(typeof(AndroidApplicationContext), retVal.ConfigurationManager.Configuration);
// Is there a backup, and if so, does the user want to restore from that backup?
var backupSvc = retVal.GetService <IBackupService>();
if (backupSvc.HasBackup(BackupMedia.Public) &&
retVal.Configuration.GetAppSetting("ignore.restore") == null &&
retVal.Confirm(Strings.locale_confirm_restore))
{
backupSvc.Restore(BackupMedia.Public);
}
// Ignore restoration
if (!retVal.Configuration.GetSection <ApplicationConfigurationSection>().AppSettings.Any(o => o.Key == "ignore.restore"))
{
retVal.Configuration.GetSection <ApplicationConfigurationSection>().AppSettings.Add(new AppSettingKeyValuePair()
{
Key = "ignore.restore",
Value = "true"
});
}
// HACK: For some reason the PCL doesn't do this automagically
//var connectionString = retVal.Configuration.GetConnectionString("openIzWarehouse");
//if (!File.Exists(connectionString.Value))
//{
// retVal.m_tracer.TraceInfo("HAX: Creating warehouse file since PCL can't... {0}", connectionString.Value);
// SqliteConnection.CreateFile(connectionString.Value);
//}
// Load configured applets
var configuredApplets = retVal.Configuration.GetSection <AppletConfigurationSection>().Applets;
retVal.SetProgress(context.GetString(Resource.String.startup_configuration), 0.2f);
var appletManager = retVal.GetService <IAppletManagerService>();
// Load all user-downloaded applets in the data directory
foreach (var appletInfo in configuredApplets)// Directory.GetFiles(this.m_configuration.GetSection<AppletConfigurationSection>().AppletDirectory)) {
{
try
{
retVal.m_tracer.TraceInfo("Loading applet {0}", appletInfo);
String appletPath = Path.Combine(retVal.Configuration.GetSection <AppletConfigurationSection>().AppletDirectory, appletInfo.Id);
if (!File.Exists(appletPath)) // reinstall
{
retVal.Configuration.GetSection <AppletConfigurationSection>().Applets.Clear();
retVal.SaveConfiguration();
retVal.Alert(Strings.locale_restartRequired);
throw new AppDomainUnloadedException();
}
// Load
using (var fs = File.OpenRead(appletPath))
{
AppletManifest manifest = AppletManifest.Load(fs);
// Is this applet in the allowed applets
// public key token match?
if (appletInfo.PublicKeyToken != manifest.Info.PublicKeyToken)
{
retVal.m_tracer.TraceWarning("Applet {0} failed validation", appletInfo);
; // TODO: Raise an error
}
appletManager.LoadApplet(manifest);
}
}
catch (AppDomainUnloadedException) { throw; }
}
catch (Exception e)
{
retVal.m_tracer.TraceError("Applet Load Error: {0}", e);
if (retVal.Confirm(String.Format(Strings.err_applet_corrupt_reinstall, appletInfo.Id)))
{
String appletPath = Path.Combine(retVal.Configuration.GetSection <AppletConfigurationSection>().AppletDirectory, appletInfo.Id);
if (File.Exists(appletPath))
{
File.Delete(appletPath);
}
}
else
{
retVal.m_tracer.TraceError("Loading applet {0} failed: {1}", appletInfo, e.ToString());
throw;
}
}
// Are we going to deploy applets
// Upgrade applets from our app manifest
foreach (var itm in context.Assets.List("Applets"))
{
try
{
retVal.m_tracer.TraceVerbose("Loading {0}", itm);
AppletPackage pkg = AppletPackage.Load(context.Assets.Open(String.Format("Applets/{0}", itm)));
// Write data to assets directory
#if !DEBUG
if (appletManager.GetApplet(pkg.Meta.Id) == null || new Version(appletManager.GetApplet(pkg.Meta.Id).Info.Version) < new Version(pkg.Meta.Version))
#endif
appletManager.Install(pkg, true);
}
catch (Exception e)
{
retVal.m_tracer?.TraceError(e.ToString());
}
}
// Ensure data migration exists
try
{
// If the DB File doesn't exist we have to clear the migrations
if (!File.Exists(retVal.Configuration.GetConnectionString(retVal.Configuration.GetSection <DataConfigurationSection>().MainDataSourceConnectionStringName).Value))
{
retVal.m_tracer.TraceWarning("Can't find the OpenIZ database, will re-install all migrations");
retVal.Configuration.GetSection <DataConfigurationSection>().MigrationLog.Entry.Clear();
}
retVal.SetProgress(context.GetString(Resource.String.startup_data), 0.6f);
DataMigrator migrator = new DataMigrator();
migrator.Ensure();
// Set the entity source
EntitySource.Current = new EntitySource(retVal.GetService <IEntitySourceProvider>());
ApplicationServiceContext.Current = ApplicationContext.Current;
ApplicationServiceContext.HostType = OpenIZHostType.MobileClient;
}
catch (Exception e)
{
retVal.m_tracer.TraceError(e.ToString());
throw;
}
finally
{
retVal.ConfigurationManager.Save();
}
// Is there a backup manager? If no then we will use the default backup manager
// Start daemons
ApplicationContext.Current.GetService <IUpdateManager>().AutoUpdate();
retVal.GetService <IThreadPoolService>().QueueNonPooledWorkItem(o => { retVal.Start(); }, null);
// Set the tracer writers for the PCL goodness!
foreach (var itm in retVal.Configuration.GetSection <DiagnosticsConfigurationSection>().TraceWriter)
{
OpenIZ.Core.Diagnostics.Tracer.AddWriter(itm.TraceWriter, itm.Filter);
}
}
