unit UModularSystem;

Classes, SysUtils, URegistry, SpecializedList;

TModuleManager = class;

TModule = class;

TListModule = class;

TAPI = class(TComponent)

end;

TModuleCondition = (mcAll, mcEnabled, mcNotEnabled, mcInstalled, mcNotInstalled,

mcRunning, mcNotRunning);

TModuleConditions = set of TModuleCondition;

TModuleAction = (maStart, maStop, maInstall, maUninstall, maUpgrade, maEnable,

maDisable);

TModuleActions = array of TModuleAction;

{ TModule }

TModule = class(TComponent)

private

FCategory: string;

FEnabled: Boolean;

FReleaseTime: TDateTime;

FRunning: Boolean;

FInstalled: Boolean;

FManager: TModuleManager;

FVersion: string;

FIdentification: string;

FTitle: string;

FLicense: string;

FAuthor: string;

FDependencies: TListString;

FDescription: TListString;

FFileName: string;

FWebSite: string;

FStartUpTime: TDateTime;

procedure SetEnabled(AValue: Boolean);

procedure SetInstalled(AValue: Boolean);

procedure SetManager(AValue: TModuleManager);

procedure SetRunning(AValue: Boolean);

protected

procedure DoStart; virtual;

procedure DoStop; virtual;

procedure DoInstall; virtual;

procedure DoUninstall; virtual;

procedure DoUpgrade; virtual;

public

API: TAPI;

procedure Enable;

procedure Disable;

procedure Start;

procedure Stop;

procedure Restart;

procedure Install;

procedure Uninstall;

procedure Reinstall;

procedure Upgrade;

procedure EnumDependenciesCascade(ModuleList: TListModule;

Conditions: TModuleConditions = [mcAll]);

procedure EnumSuperiorDependenciesCascade(ModuleList: TListModule;

Conditions: TModuleConditions = [mcAll]);

procedure SetInstalledState(Value: Boolean);

constructor Create(Owner: TComponent); override;

destructor Destroy; override;

property Running: Boolean read FRunning write SetRunning;

property Installed: Boolean read FInstalled write SetInstalled;

property Enabled: Boolean read FEnabled write SetEnabled;

property StartUpTime: TDateTime read FStartUpTime;

published

property Identification: string read FIdentification write FIdentification; // Unique system name

property Manager: TModuleManager read FManager write SetManager;

property Version: string read FVersion write FVersion;

property ReleaseTime: TDateTime read FReleaseTime write FReleaseTime;

property Title: string read FTitle write FTitle;

property License: string read FLicense write FLicense;

property Author: string read FAuthor write FAuthor;

property Dependencies: TListString read FDependencies write FDependencies;

property Description: TListString read FDescription write FDescription;

property FileName: string read FFileName write FFileName;

property Category: string read FCategory write FCategory;

property WebSite: string read FWebSite write FWebSite;

// Screenshots, reviews, icon, weak dependencies, ...

end;

{ TListModule }

TListModule = class(TListObject)

private

public

procedure Perform(Actions: array of TModuleAction; Conditions: TModuleConditions = [mcAll]);

function FindByName(Name: string): TModule;

end;

TModuleManagerOption = (moAutoInstallOnRun, moAuto);

TModuleManagerOptions = set of TModuleManagerOption;

{ TModuleManager }

TModuleManager = class(TComponent)

private

FAPI: TAPI;

FOnUpdate: TNotifyEvent;

FUpdateCount: Integer;

FOptions: TModuleManagerOptions;

procedure SetAPI(AValue: TAPI);

procedure DoUpdate(Sender: TObject);

public

Modules: TListModule; // TObjectList<TModule>

function ModuleRunning(Name: string): Boolean;

procedure EnumDependenciesCascade(Module: TModule; ModuleList: TListModule;

Conditions: TModuleConditions = [mcAll]);

procedure EnumSuperiorDependenciesCascade(Module: TModule;

ModuleList: TListModule; Conditions: TModuleConditions = [mcAll]);

procedure RegisterModule(Module: TModule);

procedure UnregisterModule(Module: TModule);

procedure LoadFromRegistry(Context: TRegistryContext);

procedure SaveToRegistry(Context: TRegistryContext);

constructor Create(AOwner: TComponent); override;

destructor Destroy; override;

property API: TAPI read FAPI write SetAPI;

published

property OnUpdate: TNotifyEvent read FOnUpdate write FOnUpdate;

property Options: TModuleManagerOptions read FOptions write FOptions;

end;

procedure Register;

resourcestring

SModuleNotFound = 'Module "%1:s" not found as dependency for module "%0:s"';

procedure Register;

RegisterComponents('ModularSystem', [TModuleManager, TModule]);

end;

procedure TListModule.Perform(Actions: array of TModuleAction;

Conditions: TModuleConditions = [mcAll]);

I: Integer;

A: Integer;

try

BeginUpdate;

for I := 0 to Count - 1 do

with TModule(Items[I]) do

if (mcAll in Conditions) or

(Running and (mcRunning in Conditions)) or

(not Running and (mcNotRunning in Conditions)) or

(Installed and (mcInstalled in Conditions)) or

(not Installed and (mcNotInstalled in Conditions)) or

(Enabled and (mcEnabled in Conditions)) or

(not Enabled and (mcNotEnabled in Conditions)) then

for A := 0 to High(Actions) do begin

if Actions[A] = maStart then Start;

if Actions[A] = maStop then Stop;

if Actions[A] = maInstall then Install;

if Actions[A] = maUninstall then Uninstall;

if Actions[A] = maUpgrade then Upgrade;

if Actions[A] = maEnable then Enable;

if Actions[A] = maDisable then Disable;

end;

finally

EndUpdate;

end;

end;

function TListModule.FindByName(Name: string): TModule;

I: Integer;

I := 0;

while (I < Count) and (TModule(Items[I]).Identification <> Name) do Inc(I);

if I < Count then Result := TModule(Items[I])

else Result := nil;

end;

procedure TModuleManager.SetAPI(AValue: TAPI);

I: Integer;

if FAPI = AValue then Exit;

FAPI := AValue;

for I := 0 to Modules.Count - 1 do

TModule(Modules[I]).API := FAPI;

end;

procedure TModuleManager.DoUpdate(Sender: TObject);

if Assigned(FOnUpdate) then FOnUpdate(Self);

end;

function TModuleManager.ModuleRunning(Name: string): Boolean;

Module: TModule;

Module := Modules.FindByName(Name);

if Assigned(Module) then begin

Result := Module.Running;

end else Result := False;

end;

procedure TModuleManager.EnumDependenciesCascade(Module: TModule;

ModuleList: TListModule; Conditions: TModuleConditions = [mcAll]);

DepModule: TModule;

I: Integer;

for I := 0 to Module.Dependencies.Count - 1 do begin

DepModule := Modules.FindByName(Module.Dependencies[I]);

if Assigned(DepModule) then

with DepModule do begin

if (ModuleList.IndexOf(DepModule) = -1) and

((mcAll in Conditions) or

(Running and (mcRunning in Conditions)) or

(not Running and (mcNotRunning in Conditions)) or

(Installed and (mcInstalled in Conditions)) or

(not Installed and (mcNotInstalled in Conditions)) or

(Enabled and (mcEnabled in Conditions)) or

(not Enabled and (mcNotEnabled in Conditions))) then begin

ModuleList.Add(DepModule);

Self.EnumDependenciesCascade(DepModule, ModuleList);

end;

end else raise Exception.CreateFmt(SModuleNotFound, [DepModule.Identification]);

end;

end;

procedure TModuleManager.EnumSuperiorDependenciesCascade(Module: TModule;

ModuleList: TListModule; Conditions: TModuleConditions = [mcAll]);

I: Integer;

for I := 0 to Modules.Count - 1 do

with TModule(Modules[I]) do begin

if (Dependencies.IndexOf(Module.Identification) <> -1) and

(ModuleList.IndexOf(TModule(Modules[I])) = -1) and

((mcAll in Conditions) or

(Running and (mcRunning in Conditions)) or

(not Running and (mcNotRunning in Conditions)) or

(Installed and (mcInstalled in Conditions)) or

(not Installed and (mcNotInstalled in Conditions)) or

(Enabled and (mcEnabled in Conditions)) or

(not Enabled and (mcNotEnabled in Conditions))) then begin

ModuleList.Add(TModule(Modules[I]));

Self.EnumSuperiorDependenciesCascade(TModule(Modules[I]), ModuleList);

end;

end;

end;

procedure TModuleManager.RegisterModule(Module: TModule);

Modules.Add(Module);

Module.FManager := Self;

Module.API := API;

Modules.Update;

end;

procedure TModuleManager.UnregisterModule(Module: TModule);

Modules.Remove(Module);

Modules.Update;

end;

constructor TModuleManager.Create(AOwner: TComponent);

inherited;

Modules := TListModule.Create;

Modules.OwnsObjects := False;

Modules.OnUpdate := DoUpdate;

end;

destructor TModuleManager.Destroy;

Modules.Perform([maStop]);

FreeAndNil(Modules);

inherited;

end;

procedure TModuleManager.LoadFromRegistry(Context: TRegistryContext);

I: Integer;

with TRegistryEx.Create do

try

RootKey := Context.RootKey;

for I := 0 to Modules.Count - 1 do

with TModule(Modules[I]) do begin

OpenKey(Context.Key + '\' + Identification, True);

Installed := ReadBoolWithDefault('Installed', Installed);

Enabled := ReadBoolWithDefault('Enabled', Enabled);

end;

finally

Free;

end;

end;

procedure TModuleManager.SaveToRegistry(Context: TRegistryContext);

I: Integer;

with TRegistryEx.Create do

try

RootKey := Context.RootKey;

for I := 0 to Modules.Count - 1 do

with TModule(Modules[I]) do begin

OpenKey(Context.Key + '\' + Identification, True);

WriteBool('Enabled', Enabled);

WriteBool('Installed', Installed);

end;

finally

Free;

end;

end;

procedure TModule.SetRunning(AValue: Boolean);

if FRunning = AValue then Exit;

if AValue then Start else Stop;

end;

procedure TModule.DoStart;

end;

procedure TModule.DoStop;

end;

procedure TModule.DoInstall;

end;

procedure TModule.DoUninstall;

end;

procedure TModule.DoUpgrade;

end;

procedure TModule.Enable;

List: TListModule;

if Enabled then Exit;

FEnabled := True;

try

List := TListModule.Create;

List.OwnsObjects := False;

EnumDependenciesCascade(List, [mcNotEnabled]);

List.Perform([maEnable], [mcNotEnabled]);

finally

List.Free;

end;

Start; // Auto start enabled modules

//Manager.Update;

end;

procedure TModule.Disable;

List: TListModule;

if not Enabled then Exit;

if FRunning then Stop; // Auto stop running modules

FEnabled := False;

try

List := TListModule.Create;

List.OwnsObjects := False;

EnumSuperiorDependenciesCascade(List, [mcEnabled]);

List.Perform([maDisable], [mcEnabled]);

finally

List.Free;

end;

Manager.Modules.Update;

end;

procedure TModule.SetInstalled(AValue: Boolean);

if FInstalled = AValue then Exit;

if AValue then Install else Uninstall;

end;

procedure TModule.SetManager(AValue: TModuleManager);

if FManager = AValue then Exit;

if Assigned(FManager) then FManager.UnregisterModule(Self);

FManager := AValue;

if Assigned(FManager) then AValue.RegisterModule(Self);

end;

procedure TModule.SetEnabled(AValue: Boolean);

if FEnabled = AValue then Exit;

if AValue then Enable else Disable;

end;

procedure TModule.Start;

List: TListModule;

StartTime: TDateTime;

if not Enabled or Running then Exit;

if not Installed then Install; // Auto install not installed modules

try

List := TListModule.Create;

List.OwnsObjects := False;

EnumDependenciesCascade(List, [mcNotRunning]);

List.Perform([maStart], [mcNotRunning]);

finally

List.Free;

end;

StartTime := Now;

DoStart;

FStartUpTime := Now - StartTime;

FRunning := True;

Manager.Modules.Update;

end;

procedure TModule.Stop;

List: TListModule;

if not Running then Exit;

FRunning := False;

try

List := TListModule.Create;

List.OwnsObjects := False;

EnumSuperiorDependenciesCascade(List, [mcRunning]);

List.Perform([maStop], [mcRunning]);

finally

List.Free;

end;

DoStop;

Manager.Modules.Update;

end;

procedure TModule.Restart;

Stop;

Start;

end;

procedure TModule.Install;

List: TListModule;

if Installed then Exit;

try

List := TListModule.Create;

List.OwnsObjects := False;

EnumDependenciesCascade(List, [mcNotInstalled]);

List.Perform([maInstall], [mcNotInstalled]);

finally

List.Free;

end;

FInstalled := True;

DoInstall;

//Enable; // Auto enable installed module

Manager.Modules.Update;

end;

procedure TModule.Uninstall;

List: TListModule;

if not Installed then Exit;

if Enabled then Disable; // Auto disable uninstalled module

try

List := TListModule.Create;

List.OwnsObjects := False;

EnumSuperiorDependenciesCascade(List, [mcInstalled]);

List.Perform([maUninstall], [mcInstalled]);

finally

List.Free;

end;

FInstalled := False;

DoUninstall;

Manager.Modules.Update;

end;

procedure TModule.Reinstall;

Uninstall;

Install;

end;

procedure TModule.Upgrade;

if not Enabled or not Installed then Exit;

if Running then try

Stop;

DoUpgrade;

finally

Start;

end else DoUpgrade;

Manager.Modules.Update;

end;

procedure TModule.EnumDependenciesCascade(ModuleList: TListModule;

Conditions: TModuleConditions = [mcAll]);

ModuleList.Clear;

Manager.EnumDependenciesCascade(Self, ModuleList, Conditions);

end;

procedure TModule.EnumSuperiorDependenciesCascade(ModuleList: TListModule;

Conditions: TModuleConditions = [mcAll]);

ModuleList.Clear;

Manager.EnumSuperiorDependenciesCascade(Self, ModuleList, Conditions);

end;

procedure TModule.SetInstalledState(Value: Boolean);

FInstalled := Value;

Manager.Modules.Update;

end;

constructor TModule.Create(Owner: TComponent);

inherited;

Dependencies := TListString.Create;

Description := TListString.Create;

end;

destructor TModule.Destroy;

Running := False;

FreeAndNil(FDescription);

FreeAndNil(FDependencies);

inherited;

end;

end.