Changeset 431 for ModularSystem/UModularSystem.pas

Timestamp:

Oct 25, 2012, 2:11:02 PM (12 years ago)

Author:

chronos

Message:

• Added: ModuleManager modules updating notification using Update, BeginUpdate, EndUpdate.
• Added: Module state Enabled and methods Enable and Disable.
• Modified: Generalized dependency enumeration.
• Added: Generalized module list forms for user control.

File:

• ModularSystem/UModularSystem.pas (modified) (20 diffs)

ModularSystem/UModularSystem.pas

@@ -6 +6 @@
 
 uses
-  Classes, SysUtils, Contnrs, URegistry;
+  Classes, SysUtils, URegistry, SpecializedList;
 
 type
   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 }
@@ -19 +28 @@
   TModule = class(TComponent)
   private
+    FCategory: string;
     FEnabled: Boolean;
+    FReleaseTime: TDateTime;
     FRunning: Boolean;
     FInstalled: Boolean;
@@ -28 +39 @@
     FLicense: string;
     FAuthor: string;
-    FDependencies: TStringList;
-    FDescription: TStringList;
+    FDependencies: TListString;
+    FDescription: TListString;
+    FFileName: string;
+    FWebSite: string;
     procedure SetEnabled(AValue: Boolean);
     procedure SetInstalled(AValue: Boolean);
+    procedure SetManager(AValue: TModuleManager);
     procedure SetRunning(AValue: Boolean);
   protected
@@ -41 +55 @@
   public
     API: TAPI;
+    procedure Enable;
+    procedure Disable;
     procedure Start;
     procedure Stop;
+    procedure Restart;
     procedure Install;
     procedure Uninstall;
+    procedure Reinstall;
     procedure Upgrade;
-    procedure EnumModulesStart(ModuleList: TStringList);
-    procedure EnumModulesStop(ModuleList: TStringList);
-    procedure EnumModulesInstall(ModuleList: TStringList);
-    procedure EnumModulesUninstall(ModuleList: TStringList);
+    procedure EnumDependenciesCascade(ModuleList: TListModule;
+      Conditions: TModuleConditions = [mcAll]);
+    procedure EnumSuperiorDependenciesCascade(ModuleList: TListModule;
+      Conditions: TModuleConditions = [mcAll]);
     procedure SetInstalledState(Value: Boolean);
     constructor Create(Owner: TComponent); override;
@@ -57 +75 @@
     property Enabled: Boolean read FEnabled write SetEnabled;
   published
-    property Manager: TModuleManager read FManager;
+    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 Identification: string read FIdentification write FIdentification;
+    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: TStringList read FDependencies write FDependencies;
-    property Description: TStringList read FDescription write FDescription;
-  end;
-
-  TModuleEvent = procedure (Sender: TObject; Module: TModule) of object;
-
+    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 }
 
@@ -74 +106 @@
   private
     FAPI: TAPI;
-    FOnModuleChange: TModuleEvent;
+    FOnUpdate: TNotifyEvent;
+    FUpdateCount: Integer;
+    FOptions: TModuleManagerOptions;
     procedure SetAPI(AValue: TAPI);
+    procedure DoUpdate;
   public
-    Modules: TObjectList; // TObjectList<TModule>
-    function FindModuleByName(Name: string): TModule;
+    Modules: TListModule; // TObjectList<TModule>
     function ModuleRunning(Name: string): Boolean;
-    procedure StartDependencies(ModuleName: string; Dependencies: TStringList);
-    procedure StopDependencies(ModuleName: string);
-    procedure EnumModulesStart(Dependencies, ModuleList: TStringList);
-    procedure EnumModulesStop(ModuleName: string; ModuleList: TStringList);
-    procedure InstallDependencies(ModuleName: string; Dependencies: TStringList);
-    procedure UninstallDependencies(ModuleName: string);
-    procedure EnumModulesInstall(Dependencies, ModuleList: TStringList);
-    procedure EnumModulesUninstall(ModuleName: string; ModuleList: TStringList);
-    procedure RegisterModule(Module: TModule; Enabled: Boolean = True);
+    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 StartInstalled;
-    procedure InstallEnabled;
-    procedure StopAll;
-    procedure UninstallAll;
     procedure LoadFromRegistry(Context: TRegistryContext);
     procedure SaveToRegistry(Context: TRegistryContext);
+    procedure BeginUpdate;
+    procedure EndUpdate;
+    procedure Update;
     constructor Create(AOwner: TComponent); override;
     destructor Destroy; override;
     property API: TAPI read FAPI write SetAPI;
-    property OnModuleChange: TModuleEvent read FOnModuleChange write FOnModuleChange;
+  published
+    property OnUpdate: TNotifyEvent read FOnUpdate write FOnUpdate;
+    property Options: TModuleManagerOptions read FOptions write FOptions;
   end;
 
@@ -113 +144 @@
 begin
   RegisterComponents('ModularSystem', [TModuleManager, TModule]);
+end;
+
+{ TListModule }
+
+procedure TListModule.Perform(Actions:  array of TModuleAction;
+  Conditions: TModuleConditions = [mcAll]);
+var
+  I: Integer;
+  A: Integer;
+begin
+  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 Enabled := True;
+      if Actions[A] = maDisable then Enabled := False;
+    end;
+end;
+
+function TListModule.FindByName(Name: string): TModule;
+var
+  I: Integer;
+begin
+  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;
 
@@ -127 +196 @@
 end;
 
-function TModuleManager.FindModuleByName(Name: string): TModule;
-var
-  I: Integer;
-begin
-  I := 0;
-  while (I < Modules.Count) and (TModule(Modules[I]).Identification <> Name) do Inc(I);
-  if I < Modules.Count then Result := TModule(Modules[I])
-    else Result := nil;
+procedure TModuleManager.DoUpdate;
+begin
+  if Assigned(FOnUpdate) then FOnUpdate(Self);
 end;
 
@@ -141 +205 @@
   Module: TModule;
 begin
-  Module := FindModuleByName(Name);
+  Module := Modules.FindByName(Name);
   if Assigned(Module) then begin
     Result := Module.Running;
@@ -147 +211 @@
 end;
 
-procedure TModuleManager.StartDependencies(ModuleName: string; Dependencies: TStringList);
-var
-  Module: TModule;
-  I: Integer;
-begin
-  for I := 0 to Dependencies.Count - 1 do begin
-    Module := FindModuleByName(Dependencies[I]);
-    if Assigned(Module) and Module.Enabled then begin
-      if not Module.Running then Module.Start;
-    end else raise Exception.CreateFmt(SModuleNotFound, [ModuleName, Dependencies[I]]);
-  end;
-end;
-
-procedure TModuleManager.StopDependencies(ModuleName: string);
+procedure TModuleManager.EnumDependenciesCascade(Module: TModule;
+  ModuleList: TListModule; Conditions: TModuleConditions = [mcAll]);
+var
+  DepModule: TModule;
+  I: Integer;
+begin
+  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]);
 var
   I: Integer;
@@ -166 +243 @@
   for I := 0 to Modules.Count - 1 do
   with TModule(Modules[I]) do begin
-    if (Dependencies.IndexOf(ModuleName) <> - 1) and Running then Stop;
-  end;
-end;
-
-procedure TModuleManager.EnumModulesStart(Dependencies,
-  ModuleList: TStringList);
-var
-  Module: TModule;
-  I: Integer;
-begin
-  for I := 0 to Dependencies.Count - 1 do begin
-    Module := FindModuleByName(Dependencies[I]);
-    if Assigned(Module) then begin
-      if not Module.Running and (ModuleList.IndexOf(Module.Identification) = -1) then begin
-        ModuleList.Add(Module.Identification);
-        EnumModulesStart(Module.Dependencies, ModuleList);
-      end;
-    end else raise Exception.CreateFmt(SModuleNotFound, [Module.Identification]);
-  end;
-end;
-
-procedure TModuleManager.EnumModulesStop(ModuleName: string;
-  ModuleList: TStringList);
-var
-  I: Integer;
-begin
-  for I := 0 to Modules.Count - 1 do
-  with TModule(Modules[I]) do begin
-    if (Dependencies.IndexOf(ModuleName) <> -1) and Running and
-      (ModuleList.IndexOf(Identification) = -1) then begin
-      ModuleList.Add(Identification);
-      Self.EnumModulesStop(Identification, ModuleList);
+    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.InstallDependencies(ModuleName: string;
-  Dependencies: TStringList);
-var
-  Module: TModule;
-  I: Integer;
-begin
-  for I := 0 to Dependencies.Count - 1 do begin
-    Module := FindModuleByName(Dependencies[I]);
-    if Assigned(Module) and Module.Enabled then begin
-      if not Module.Installed then Module.Install;
-    end else raise Exception.CreateFmt(SModuleNotFound, [ModuleName, Dependencies[I]]);
-  end;
-end;
-
-procedure TModuleManager.UninstallDependencies(ModuleName: string);
-var
-  I: Integer;
-begin
-  for I := 0 to Modules.Count - 1 do
-  with TModule(Modules[I]) do begin
-    if (Dependencies.IndexOf(ModuleName) <> - 1) and Installed then Uninstall;
-  end;
-end;
-
-procedure TModuleManager.EnumModulesInstall(Dependencies,
-  ModuleList: TStringList);
-var
-  Module: TModule;
-  I: Integer;
-begin
-  for I := 0 to Dependencies.Count - 1 do begin
-    Module := FindModuleByName(Dependencies[I]);
-    if Assigned(Module) then begin
-      if not Module.Installed and (ModuleList.IndexOf(Module.Identification) = -1) then begin
-        ModuleList.Add(Module.Identification);
-        EnumModulesInstall(Module.Dependencies, ModuleList);
-      end;
-    end else raise Exception.CreateFmt(SModuleNotFound, [Module.Identification]);
-  end;
-end;
-
-procedure TModuleManager.EnumModulesUninstall(ModuleName: string;
-  ModuleList: TStringList);
-var
-  I: Integer;
-begin
-  for I := 0 to Modules.Count - 1 do
-  with TModule(Modules[I]) do begin
-    if (Dependencies.IndexOf(ModuleName) <> -1) and Installed and
-      (ModuleList.IndexOf(Identification) = -1) then begin
-      ModuleList.Add(Identification);
-      Self.EnumModulesUninstall(Identification, ModuleList);
-    end;
-  end;
-end;
-
-procedure TModuleManager.RegisterModule(Module: TModule;
-  Enabled: Boolean = True);
+procedure TModuleManager.RegisterModule(Module: TModule);
 begin
   Modules.Add(Module);
   Module.FManager := Self;
   Module.API := API;
-  Module.Enabled := Enabled;
+  Update;
 end;
 
@@ -270 +269 @@
 begin
   Modules.Remove(Module);
-end;
-
-procedure TModuleManager.StartInstalled;
-var
-  I: Integer;
-begin
-  for I := 0 to Modules.Count - 1 do
-  with TModule(Modules[I]) do
-    if not Running and Installed then Start;
-end;
-
-procedure TModuleManager.InstallEnabled;
-var
-  I: Integer;
-begin
-  for I := 0 to Modules.Count - 1 do
-  with TModule(Modules[I]) do
-    if not Installed and Enabled then Install;
-end;
-
-procedure TModuleManager.StopAll;
-var
-  I: Integer;
-begin
-  for I := 0 to Modules.Count - 1 do
-  with TModule(Modules[I]) do
-    if Running then Stop;
-end;
-
-procedure TModuleManager.UninstallAll;
-var
-  I: Integer;
-begin
-  for I := 0 to Modules.Count - 1 do
-  with TModule(Modules[I]) do
-    if Installed then Uninstall;
+  Update;
 end;
 
@@ -311 +275 @@
 begin
   inherited;
-  Modules := TObjectList.Create;
-  //Modules.OwnsObjects := False;
+  Modules := TListModule.Create;
+  Modules.OwnsObjects := False;
 end;
 
 destructor TModuleManager.Destroy;
 begin
-  StopAll;
+  Modules.Perform([maStop]);
   FreeAndNil(Modules);
   inherited;
@@ -332 +296 @@
     with TModule(Modules[I]) do begin
       OpenKey(Context.Key + '\' + Identification, True);
-      Running := ReadBoolWithDefault('Run',  Enabled);
+      Enabled := ReadBoolWithDefault('Enable', Enabled);
     end;
   finally
@@ -347 +311 @@
     RootKey := Context.RootKey;
     for I := 0 to Modules.Count - 1 do
-    with TModule(Modules[I]) do
-    if Enabled then begin
+    with TModule(Modules[I]) do begin
       OpenKey(Context.Key + '\' + Identification, True);
-      WriteBool('Run', Running);
+      WriteBool('Enable', Enabled);
     end;
   finally
     Free;
   end;
+end;
+
+procedure TModuleManager.BeginUpdate;
+begin
+  Inc(FUpdateCount);
+end;
+
+procedure TModuleManager.EndUpdate;
+begin
+  if FUpdateCount > 0 then Dec(FUpdateCount);
+  if FUpdateCount = 0 then DoUpdate;
+end;
+
+procedure TModuleManager.Update;
+begin
+  if FUpdateCount = 0 then DoUpdate;
 end;
 
@@ -390 +369 @@
 end;
 
+procedure TModule.Enable;
+var
+  List: TListModule;
+begin
+  if Enabled then Exit;
+  FEnabled := True;
+  try
+    List := TListModule.Create;
+    List.OwnsObjects := False;
+    EnumSuperiorDependenciesCascade(List);
+    List.Perform([maEnable], [mcNotEnabled]);
+  finally
+    List.Free;
+  end;
+  Start; // Auto start enabled modules
+  //Manager.Update;
+end;
+
+procedure TModule.Disable;
+var
+  List: TListModule;
+begin
+  if not Enabled then Exit;
+  if FRunning then Stop; // Auto stop running modules
+  FEnabled := False;
+  try
+    List := TListModule.Create;
+    List.OwnsObjects := False;
+    EnumSuperiorDependenciesCascade(List);
+    List.Perform([maDisable], [mcEnabled]);
+  finally
+    List.Free;
+  end;
+  Manager.Update;
+end;
+
 procedure TModule.SetInstalled(AValue: Boolean);
 begin
@@ -396 +411 @@
 end;
 
+procedure TModule.SetManager(AValue: TModuleManager);
+begin
+  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);
 begin
   if FEnabled = AValue then Exit;
-  FEnabled := AValue;
-  if not FEnabled and FInstalled then Uninstall;
+  if FEnabled then Enable else Disable;
 end;
 
 procedure TModule.Start;
+var
+  List: TListModule;
 begin
   if not Enabled or Running then Exit;
-  if not Installed then Install;
-  Manager.StartDependencies(Identification, Dependencies);
+  if not Installed then Install;  // Auto install not installed modules
+  try
+    List := TListModule.Create;
+    List.OwnsObjects := False;
+    EnumDependenciesCascade(List);
+    List.Perform([maStart], [mcNotRunning]);
+  finally
+    List.Free;
+  end;
   DoStart;
   FRunning := True;
+  Manager.Update;
 end;
 
 procedure TModule.Stop;
+var
+  List: TListModule;
 begin
   if not Running then Exit;
   FRunning := False;
-  Manager.StopDependencies(Identification);
+  try
+    List := TListModule.Create;
+    List.OwnsObjects := False;
+    EnumSuperiorDependenciesCascade(List);
+    List.Perform([maStop], [mcRunning]);
+  finally
+    List.Free;
+  end;
   DoStop;
+  Manager.Update;
+end;
+
+procedure TModule.Restart;
+begin
+  Stop;
+  Start;
 end;
 
 procedure TModule.Install;
-begin
-  if not Enabled or Installed then Exit;
-  Manager.InstallDependencies(Identification, Dependencies);
+var
+  List: TListModule;
+begin
+  if Installed then Exit;
+  try
+    List := TListModule.Create;
+    List.OwnsObjects := False;
+    EnumDependenciesCascade(List);
+    List.Perform([maInstall], [mcNotInstalled]);
+  finally
+    List.Free;
+  end;
   FInstalled := True;
-  if Assigned(Manager.FOnModuleChange) then
-    Manager.FOnModuleChange(Manager, Self);
   DoInstall;
+  Enable; // Auto enable installed module
+  Manager.Update;
 end;
 
 procedure TModule.Uninstall;
+var
+  List: TListModule;
 begin
   if not Installed then Exit;
-  if Running then Stop;
-  Manager.UninstallDependencies(Identification);
+  if Enabled then Disable; // Auto disable uninstalled module
+  try
+    List := TListModule.Create;
+    List.OwnsObjects := False;
+    EnumSuperiorDependenciesCascade(List);
+    List.Perform([maUninstall], [mcInstalled]);
+  finally
+    List.Free;
+  end;
   FInstalled := False;
   DoUninstall;
-  if Assigned(Manager.FOnModuleChange) then
-    Manager.FOnModuleChange(Manager, Self);
+  Manager.Update;
+end;
+
+procedure TModule.Reinstall;
+begin
+  Uninstall;
+  Install;
 end;
 
@@ -450 +521 @@
     Start;
   end else DoUpgrade;
-end;
-
-procedure TModule.EnumModulesStart(ModuleList: TStringList);
+  Manager.Update;
+end;
+
+procedure TModule.EnumDependenciesCascade(ModuleList: TListModule;
+  Conditions: TModuleConditions = [mcAll]);
 begin
   ModuleList.Clear;
-  Manager.EnumModulesStart(Dependencies, ModuleList);
-end;
-
-procedure TModule.EnumModulesStop(ModuleList: TStringList);
+  Manager.EnumDependenciesCascade(Self, ModuleList, Conditions);
+end;
+
+procedure TModule.EnumSuperiorDependenciesCascade(ModuleList: TListModule;
+  Conditions: TModuleConditions = [mcAll]);
 begin
   ModuleList.Clear;
-  Manager.EnumModulesStop(Identification, ModuleList);
-end;
-
-procedure TModule.EnumModulesInstall(ModuleList: TStringList);
-begin
-  ModuleList.Clear;
-  Manager.EnumModulesInstall(Dependencies, ModuleList);
-end;
-
-procedure TModule.EnumModulesUninstall(ModuleList: TStringList);
-begin
-  ModuleList.Clear;
-  Manager.EnumModulesUninstall(Identification, ModuleList);
+  Manager.EnumSuperiorDependenciesCascade(Self, ModuleList, Conditions);
 end;
 
@@ -479 +541 @@
 begin
   FInstalled := Value;
-  if Assigned(Manager.FOnModuleChange) then
-    Manager.FOnModuleChange(Manager, Self);
+  Manager.Update;
 end;
 
@@ -486 +547 @@
 begin
   inherited;
-  Dependencies := TStringList.Create;
-  Description := TStringList.Create;
+  Dependencies := TListString.Create;
+  Description := TListString.Create;
 end;