private void step5CodeActivity_RefreshTree_ExecuteCode(object sender, EventArgs e)
{
if (this.GetBinding <bool>("ReloadConsoleOnCompletion"))
{
ConsoleMessageQueueFacade.Enqueue(new RebootConsoleMessageQueueItem(), null);
}
if (this.GetBinding <bool>("FlushOnCompletion"))
{
GlobalEventSystemFacade.FlushTheSystem();
}
SpecificTreeRefresher specificTreeRefresher = this.CreateSpecificTreeRefresher();
specificTreeRefresher.PostRefreshMesseges(new PackageElementProviderRootEntityToken());
if (this.GetBinding <bool>("ReloadConsoleOnCompletion") == false)
{
PackageElementProviderAvailablePackagesItemEntityToken castedEntityToken = (PackageElementProviderAvailablePackagesItemEntityToken)this.EntityToken;
InstalledPackageInformation installedPackage = PackageManager.GetInstalledPackages().FirstOrDefault(f => f.Id == castedEntityToken.PackageId);
var installedPackageEntityToken = new PackageElementProviderInstalledPackageItemEntityToken(
installedPackage.Id,
installedPackage.GroupName,
installedPackage.IsLocalInstalled,
installedPackage.CanBeUninstalled);
ExecuteWorklow(installedPackageEntityToken, WorkflowFacade.GetWorkflowType("Composite.Plugins.Elements.ElementProviders.PackageElementProvider.ViewInstalledPackageInfoWorkflow"));
}
}
/// <exclude />
public void UpdateDataTypeDescriptor(DataTypeDescriptor dataTypeDescriptor, bool flushTheSystem)
{
dataTypeDescriptor.Validate();
DataMetaDataFacade.PersistMetaData(dataTypeDescriptor);
if (flushTheSystem)
{
GlobalEventSystemFacade.FlushTheSystem();
}
}
private void step3CodeActivity_RefreshTree_ExecuteCode(object sender, EventArgs e)
{
if (this.GetBinding<bool>("ReloadConsoleOnCompletion"))
{
ConsoleMessageQueueFacade.Enqueue(new RebootConsoleMessageQueueItem(), null);
}
if (this.GetBinding<bool>("FlushOnCompletion"))
{
GlobalEventSystemFacade.FlushTheSystem();
}
SpecificTreeRefresher specificTreeRefresher = this.CreateSpecificTreeRefresher();
specificTreeRefresher.PostRefreshMesseges(new PackageElementProviderRootEntityToken());
}
/// <exclude />
public override void Uninstall()
{
Verify.IsNotNull(_dataTypeDescriptorsToDelete, "DynamicDataTypePackageFragmentUninstaller has not been validated");
bool flushTheSystem = false;
foreach (DataTypeDescriptor dataTypeDescriptor in _dataTypeDescriptorsToDelete)
{
Log.LogVerbose(this.GetType().Name, "Uninstalling the type '{0}'", dataTypeDescriptor);
GeneratedTypesFacade.DeleteType(dataTypeDescriptor, false);
flushTheSystem = true;
}
if (flushTheSystem)
{
GlobalEventSystemFacade.FlushTheSystem(true);
}
}
/// <exclude />
public void DropStore(string providerName, DataTypeDescriptor typeDescriptor, bool makeAFlush)
{
Verify.ArgumentNotNullOrEmpty(providerName, "providerName");
Verify.ArgumentNotNull(typeDescriptor, "typeDescriptor");
typeDescriptor.Validate();
using (var transactionScope = TransactionsFacade.CreateNewScope())
{
DataProviderPluginFacade.DropStore(providerName, typeDescriptor);
DataMetaDataFacade.DeleteMetaData(typeDescriptor.DataTypeId);
transactionScope.Complete();
}
if (makeAFlush)
{
GlobalEventSystemFacade.FlushTheSystem();
}
}
public override IEnumerable <XElement> Install()
{
if (_updates == null)
{
throw new InvalidOperationException(GetType().Name + " has not been validated");
}
foreach (var kvp in _updates)
{
var oldDataTypeDescriptor = kvp.Key;
var newDataTypeDescriptor = kvp.Value;
var updateDescriptor = new UpdateDataTypeDescriptor(oldDataTypeDescriptor, newDataTypeDescriptor);
GeneratedTypesFacade.UpdateType(updateDescriptor);
}
GlobalEventSystemFacade.FlushTheSystem();
return(Configuration);
}
/// <exclude />
public override IEnumerable <XElement> Install()
{
Verify.IsNotNull(_typesToInstall, "DataTypePackageFragmentInstaller has not been validated");
string typeNames = string.Join(", ", _typesToInstall.Select(t => t.GetFullInterfaceName()));
Log.LogVerbose(this.GetType().Name, "Installing types: '{0}'", typeNames);
DynamicTypeManager.CreateStores(_typesToInstall, false);
var typeElements = new List <XElement>();
foreach (var dataTypeDescriptor in _typesToInstall)
{
var typeElement = new XElement("Type", new XAttribute("typeId", dataTypeDescriptor.DataTypeId));
typeElements.Add(typeElement);
}
GlobalEventSystemFacade.FlushTheSystem(true);
yield return(new XElement("Types", typeElements));
}
/// <exclude />
public void CreateStores(string providerName, IReadOnlyCollection <DataTypeDescriptor> typeDescriptors, bool doFlush)
{
Verify.ArgumentNotNullOrEmpty(providerName, "providerName");
Verify.ArgumentNotNull(typeDescriptors, "typeDescriptors");
typeDescriptors.ForEach(d => d.Validate());
using (var transactionScope = TransactionsFacade.CreateNewScope())
{
foreach (var typeDescriptor in typeDescriptors)
{
DataMetaDataFacade.PersistMetaData(typeDescriptor);
}
DataProviderPluginFacade.CreateStores(providerName, typeDescriptors);
transactionScope.Complete();
}
if (doFlush)
{
GlobalEventSystemFacade.FlushTheSystem();
}
}
/// <exclude />
public static void FatalResetTheSystem()
{
Log.LogWarning(LogTitle, "Unhandled error occurred, reinitializing the system!");
ReinitializeTheSystem(delegate() { _fatalErrorFlushCount++; GlobalEventSystemFacade.FlushTheSystem(); });
}
private static void DoInitialize()
{
int startTime = Environment.TickCount;
Guid installationId = InstallationInformationFacade.InstallationId;
Log.LogVerbose(LogTitle, "Initializing the system core - installation id = " + installationId);
using (new LogExecutionTime(LogTitle, "Initialization of the static data types"))
{
DataProviderRegistry.InitializeDataTypes();
}
using (new LogExecutionTime(LogTitle, "Auto update of static data types"))
{
bool typesUpdated = AutoUpdateStaticDataTypes();
if (typesUpdated)
{
using (new LogExecutionTime(LogTitle, "Reinitialization of the static data types"))
{
SqlTableInformationStore.Flush();
DataProviderRegistry.Flush();
DataProviderPluginFacade.Flush();
DataProviderRegistry.InitializeDataTypes();
}
CodeGenerationManager.GenerateCompositeGeneratedAssembly(true);
}
}
using (new LogExecutionTime(LogTitle, "Ensure data stores"))
{
bool dataStoresCreated = DataStoreExistenceVerifier.EnsureDataStores();
if (dataStoresCreated)
{
Log.LogVerbose(LogTitle, "Initialization of the system was halted, performing a flush");
_initializing = false;
GlobalEventSystemFacade.FlushTheSystem();
return;
}
}
using (new LogExecutionTime(LogTitle, "Initializing data process controllers"))
{
ProcessControllerFacade.Initialize_PostDataTypes();
}
using (new LogExecutionTime(LogTitle, "Initializing data type references"))
{
DataReferenceRegistry.Initialize_PostDataTypes();
}
using (new LogExecutionTime(LogTitle, "Initializing data type associations"))
{
DataAssociationRegistry.Initialize_PostDataTypes();
}
using (new LogExecutionTime(LogTitle, "Initializing internal urls"))
{
InternalUrls.Initialize_PostDataTypes();
}
using (new LogExecutionTime(LogTitle, "Initializing functions"))
{
MetaFunctionProviderRegistry.Initialize_PostDataTypes();
}
Log.LogVerbose(LogTitle, "Starting initialization of administrative secondaries");
if (SystemSetupFacade.IsSystemFirstTimeInitialized && !SystemSetupFacade.SetupIsRunning)
{
using (new LogExecutionTime(LogTitle, "Initializing workflow runtime"))
{
WorkflowFacade.EnsureInitialization();
}
}
if (!RuntimeInformation.IsUnittest)
{
using (new LogExecutionTime(LogTitle, "Initializing flow system"))
{
FlowControllerFacade.Initialize();
}
using (new LogExecutionTime(LogTitle, "Initializing console system"))
{
ConsoleFacade.Initialize();
}
}
using (new LogExecutionTime(LogTitle, "Auto installing packages"))
{
DoAutoInstallPackages();
}
using (new LogExecutionTime(LogTitle, "Loading element providers"))
{
ElementProviderLoader.LoadAllProviders();
}
int executionTime = Environment.TickCount - startTime;
Log.LogVerbose(LogTitle, "Done initializing of the system core. ({0} ms)".FormatWith(executionTime));
}