paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-11-01 20:49:29 +01:00
Code Issues Packages Projects Releases Wiki Activity

* split repository in InstalledRepository and AvailableRepository

Browse Source 
* replace CurrentPackage by PackageName
  * remove obsolete execute arguments

git-svn-id: trunk@10610 -
This commit is contained in:
peter 2008-04-06 21:00:24 +00:00
parent 347ae5a3bf
commit 85250cca06
9 changed files with 467 additions and 561 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
utils/fppkg/fppkg.pp
View File

@ -30,7 +30,6 @@ Type
TMakeTool = Class(TCustomApplication) TMakeTool = Class(TCustomApplication)
Private Private
ActionStack : TActionStack;
ParaAction : string; ParaAction : string;
ParaPackages : TStringList; ParaPackages : TStringList;
procedure MaybeCreateLocalDirs; procedure MaybeCreateLocalDirs;
@ -174,13 +173,11 @@ Constructor TMakeTool.Create;
begin begin
inherited Create(nil); inherited Create(nil);
ParaPackages:=TStringList.Create; ParaPackages:=TStringList.Create;
ActionStack:=TActionStack.Create;
end; end;
Destructor TMakeTool.Destroy; Destructor TMakeTool.Destroy;
begin begin
FreeAndNil(ActionStack);
FreeAndNil(ParaPackages); FreeAndNil(ParaPackages);
inherited Destroy; inherited Destroy;
end; end;
@ -275,7 +272,6 @@ procedure TMakeTool.DoRun;
var var
ActionPackage : TFPPackage; ActionPackage : TFPPackage;
OldCurrDir : String; OldCurrDir : String;
Res : Boolean;
i : Integer; i : Integer;
SL : TStringList; SL : TStringList;
begin begin
@ -292,14 +288,14 @@ begin
if not FileExists(GlobalOptions.LocalPackagesFile) then if not FileExists(GlobalOptions.LocalPackagesFile) then
begin begin
try try
pkghandler.ExecuteAction(nil,'update'); pkghandler.ExecuteAction('','update');
except except
on E: Exception do on E: Exception do
Log(vlWarning,E.Message); Log(vlWarning,E.Message);
end; end;
end; end;
LoadLocalMirrors; LoadLocalAvailableMirrors;
LoadLocalRepository; LoadLocalAvailableRepository;
FindInstalledPackages(FPMakeCompilerOptions,true); FindInstalledPackages(FPMakeCompilerOptions,true);
CheckFPMakeDependencies; CheckFPMakeDependencies;
// We only need to reload the status when we use a different // We only need to reload the status when we use a different
@ -319,8 +315,8 @@ begin
if ParaPackages.Count=0 then if ParaPackages.Count=0 then
begin begin
Log(vlDebug,SLogCommandLineAction,['[<currentdir>]',ParaAction]); ActionPackage:=InstalledRepository.AddPackage(CurrentDirPackageName);
res:=pkghandler.ExecuteAction(nil,ParaAction); pkghandler.ExecuteAction(CurrentDirPackageName,ParaAction);
end end
else else
begin begin
@ -329,26 +325,21 @@ begin
begin begin
if FileExists(ParaPackages[i]) then if FileExists(ParaPackages[i]) then
begin begin
ActionPackage:=LoadOrCreatePackage(ChangeFileExt(ExtractFileName(ParaPackages[i]),'')); ActionPackage:=InstalledRepository.AddPackage(CmdLinePackageName);
ActionPackage.FileName:=ExpandFileName(ParaPackages[i]); ActionPackage.LocalFileName:=ExpandFileName(ParaPackages[i]);
ActionPackage.IsLocalPackage:=true; pkghandler.ExecuteAction(CmdLinePackageName,ParaAction);
res:=pkghandler.ExecuteAction(ActionPackage,ParaAction);
FreeAndNil(ActionPackage);
end end
else else
begin begin
ActionPackage:=CurrentRepository.PackageByName(ParaPackages[i]); Log(vlDebug,SLogCommandLineAction,['['+ParaPackages[i]+']',ParaAction]);
Log(vlDebug,SLogCommandLineAction,['['+ActionPackage.Name+']',ParaAction]); pkghandler.ExecuteAction(ParaPackages[i],ParaAction);
res:=pkghandler.ExecuteAction(ActionPackage,ParaAction);
end; end;
if not res then
break;
end; end;
end; end;
// Recompile all packages dependent on this package // Recompile all packages dependent on this package
if res and (ParaAction='install') then if (ParaAction='install') then
pkghandler.ExecuteAction(nil,'fixbroken'); pkghandler.ExecuteAction('','fixbroken');
Terminate; Terminate;

107
utils/fppkg/fprepos.pp
View File

@ -122,9 +122,8 @@ type
FOSes : TOSES; FOSes : TOSES;
FCPUs : TCPUS; FCPUs : TCPUS;
// Installation info // Installation info
FInstalledVersion : TFPVersion; FChecksum : cardinal;
FInstalledChecksum : cardinal; FLocalFileName : String;
FIsLocalPackage : Boolean;
function GetFileName: String; function GetFileName: String;
procedure SetName(const AValue: String); procedure SetName(const AValue: String);
procedure SetVersion(const AValue: TFPVersion); procedure SetVersion(const AValue: TFPVersion);
@ -134,7 +133,7 @@ type
Procedure LoadFromStream(Stream : TStream; Streamversion : Integer); override; Procedure LoadFromStream(Stream : TStream; Streamversion : Integer); override;
Procedure SaveToStream(Stream : TStream); override; Procedure SaveToStream(Stream : TStream); override;
Procedure Assign(Source : TPersistent); override; Procedure Assign(Source : TPersistent); override;
Function AddDependency(Const APackageName : String; AMinVersion : String = '') : TFPDependency; Function AddDependency(Const APackageName : String; const AMinVersion : String = '') : TFPDependency;
Property Dependencies : TFPDependencies Read FDependencies; Property Dependencies : TFPDependencies Read FDependencies;
Published Published
Property Name : String Read FName Write SetName; Property Name : String Read FName Write SetName;
@ -147,10 +146,9 @@ type
Property Email : String Read FEmail Write FEmail; Property Email : String Read FEmail Write FEmail;
Property OSes : TOSes Read FOSes Write FOses; Property OSes : TOSes Read FOSes Write FOses;
Property CPUs : TCPUs Read FCPUs Write FCPUs; Property CPUs : TCPUs Read FCPUs Write FCPUs;
Property InstalledVersion : TFPVersion Read FInstalledVersion Write FInstalledVersion; Property Checksum : Cardinal Read FChecksum Write FChecksum;
Property InstalledChecksum : Cardinal Read FInstalledChecksum Write FInstalledChecksum;
// Manual package from commandline not in official repository // Manual package from commandline not in official repository
Property IsLocalPackage : Boolean Read FIsLocalPackage Write FIsLocalPackage; Property LocalFileName : String Read FLocalFileName Write FLocalFileName;
end; end;
{ TFPPackages } { TFPPackages }
@ -194,14 +192,6 @@ type
Procedure LoadFromFile(const AFileName : String); Procedure LoadFromFile(const AFileName : String);
Procedure SaveToFile(const AFileName : String); Procedure SaveToFile(const AFileName : String);
Procedure Save; Procedure Save;
// Loading and Saving version numbers: List of Name=Value pairs.
procedure ClearStatus;
{$ifdef STATUSFILE}
Procedure LoadStatusFromStream(Stream : TStream); virtual;
Procedure SaveStatusToStream(Stream : TStream); virtual;
Procedure LoadStatusFromFile(const AFileName : String);
Procedure SaveStatusToFile(const AFileName : String);
{$endif STATUSFILE}
// Package management // Package management
Function IndexOfPackage(const APackageName : String) : Integer; Function IndexOfPackage(const APackageName : String) : Integer;
Function FindPackage(const APackageName : String) : TFPPackage; Function FindPackage(const APackageName : String) : TFPPackage;
@ -484,8 +474,7 @@ constructor TFPPackage.Create(ACollection: TCollection);
begin begin
inherited Create(ACollection); inherited Create(ACollection);
FVersion:=TFPVersion.Create; FVersion:=TFPVersion.Create;
FInstalledVersion:=TFPVersion.Create; FChecksum:=$ffffffff;
FInstalledChecksum:=$ffffffff;
FOSes:=AllOSes; FOSes:=AllOSes;
FCPUs:=AllCPUs; FCPUs:=AllCPUs;
FDependencies:=TFPDependencies.Create(TFPDependency); FDependencies:=TFPDependencies.Create(TFPDependency);
@ -496,7 +485,6 @@ destructor TFPPackage.Destroy;
begin begin
FreeAndNil(FDependencies); FreeAndNil(FDependencies);
FreeAndNil(FVersion); FreeAndNil(FVersion);
FreeAndNil(FInstalledVersion);
inherited Destroy; inherited Destroy;
end; end;
@ -621,7 +609,7 @@ begin
Description:=P.Description; Description:=P.Description;
ExternalURL:=P.ExternalURL; ExternalURL:=P.ExternalURL;
FileName:=P.FileName; FileName:=P.FileName;
InstalledVersion.Assign(P.Installedversion); Checksum:=P.Checksum;
Dependencies.Clear; Dependencies.Clear;
Dependencies.Assign(P.Dependencies); Dependencies.Assign(P.Dependencies);
end end
@ -630,7 +618,7 @@ begin
end; end;
function TFPPackage.AddDependency(const APackageName: String;AMinVersion: String): TFPDependency; function TFPPackage.AddDependency(Const APackageName : String; const AMinVersion : String = ''): TFPDependency;
begin begin
Result:=Dependencies.AddDependency(APackageName,AMinVersion); Result:=Dependencies.AddDependency(APackageName,AMinVersion);
end; end;
@ -808,85 +796,6 @@ begin
end; end;
procedure TFPRepository.ClearStatus;
Var
I : Integer;
begin
For I:=0 to PackageCount-1 do
With Packages[i] do
InstalledVersion.Clear;
end;
{$ifdef STATUSFILE}
procedure TFPRepository.LoadStatusFromStream(Stream: TStream);
Var
L : TStrings;
I : Integer;
N,V : String;
begin
L:=TStringList.Create;
Try
L.LoadFromStream(Stream);
For I:=0 to L.Count-1 do
begin
L.GetNameValue(I,N,V);
If (N<>'') and (V<>'') then
PackageByName(N).InstalledVersion.AsString:=V;
end;
Finally
L.Free;
end;
end;
procedure TFPRepository.SaveStatusToStream(Stream: TStream);
Var
L : TStrings;
I : Integer;
begin
L:=TStringList.Create;
Try
For I:=0 to PackageCount-1 do
With Packages[i] do
if not InstalledVersion.Empty then
L.Add(Name+'='+InstalledVersion.AsString);
L.SaveToStream(Stream);
Finally
L.Free;
end;
end;
procedure TFPRepository.LoadStatusFromFile(const AFileName: String);
Var
F : TFileStream;
begin
F:=TFileStream.Create(AFileName,fmOpenRead);
Try
LoadStatusFromStream(F);
Finally
F.Free;
end;
end;
procedure TFPRepository.SaveStatusToFile(const AFileName: String);
Var
F : TFileStream;
begin
If FileExists(AFileName) and BackupFiles then
BackupFile(AFileName);
F:=TFileStream.Create(AFileName,fmCreate);
Try
SaveStatusToStream(F);
Finally
F.Free;
end;
end;
{$endif STATUSFILE}
function TFPRepository.IndexOfPackage(const APackageName: String): Integer; function TFPRepository.IndexOfPackage(const APackageName: String): Integer;
begin begin
Result:=FPackages.IndexOfPackage(APackageName); Result:=FPackages.IndexOfPackage(APackageName);

227
utils/fppkg/pkgcommands.pp
View File

@ -23,176 +23,178 @@ type
TCommandAddConfig = Class(TPackagehandler) TCommandAddConfig = Class(TPackagehandler)
Public Public
Function Execute(const Args:TActionArgs):boolean;override; Procedure Execute;override;
end; end;
{ TCommandUpdate } { TCommandUpdate }
TCommandUpdate = Class(TPackagehandler) TCommandUpdate = Class(TPackagehandler)
Public Public
Function Execute(const Args:TActionArgs):boolean;override; Procedure Execute;override;
end; end;
{ TCommandShowAll } { TCommandShowAll }
TCommandShowAll = Class(TPackagehandler) TCommandShowAll = Class(TPackagehandler)
Public Public
Function Execute(const Args:TActionArgs):boolean;override; Procedure Execute;override;
end; end;
{ TCommandShowAvail } { TCommandShowAvail }
TCommandShowAvail = Class(TPackagehandler) TCommandShowAvail = Class(TPackagehandler)
Public Public
Function Execute(const Args:TActionArgs):boolean;override; Procedure Execute;override;
end; end;
{ TCommandScanPackages } { TCommandScanPackages }
TCommandScanPackages = Class(TPackagehandler) TCommandScanPackages = Class(TPackagehandler)
Public Public
Function Execute(const Args:TActionArgs):boolean;override; Procedure Execute;override;
end; end;
{ TCommandDownload } { TCommandDownload }
TCommandDownload = Class(TPackagehandler) TCommandDownload = Class(TPackagehandler)
Public Public
Function Execute(const Args:TActionArgs):boolean;override; Procedure Execute;override;
end; end;
{ TCommandUnzip } { TCommandUnzip }
TCommandUnzip = Class(TPackagehandler) TCommandUnzip = Class(TPackagehandler)
Public Public
Function Execute(const Args:TActionArgs):boolean;override; Procedure Execute;override;
end; end;
{ TCommandCompile } { TCommandCompile }
TCommandCompile = Class(TPackagehandler) TCommandCompile = Class(TPackagehandler)
Public Public
Function Execute(const Args:TActionArgs):boolean;override; Procedure Execute;override;
end; end;
{ TCommandBuild } { TCommandBuild }
TCommandBuild = Class(TPackagehandler) TCommandBuild = Class(TPackagehandler)
Public Public
Function Execute(const Args:TActionArgs):boolean;override; Procedure Execute;override;
end; end;
{ TCommandInstall } { TCommandInstall }
TCommandInstall = Class(TPackagehandler) TCommandInstall = Class(TPackagehandler)
Public Public
Function Execute(const Args:TActionArgs):boolean;override; Procedure Execute;override;
end; end;
{ TCommandClean } { TCommandClean }
TCommandClean = Class(TPackagehandler) TCommandClean = Class(TPackagehandler)
Public Public
Function Execute(const Args:TActionArgs):boolean;override; Procedure Execute;override;
end; end;
{ TCommandArchive } { TCommandArchive }
TCommandArchive = Class(TPackagehandler) TCommandArchive = Class(TPackagehandler)
Public Public
Function Execute(const Args:TActionArgs):boolean;override; Procedure Execute;override;
end; end;
{ TCommandInstallDependencies } { TCommandInstallDependencies }
TCommandInstallDependencies = Class(TPackagehandler) TCommandInstallDependencies = Class(TPackagehandler)
Public Public
Function Execute(const Args:TActionArgs):boolean;override; Procedure Execute;override;
end; end;
{ TCommandFixBroken } { TCommandFixBroken }
TCommandFixBroken = Class(TPackagehandler) TCommandFixBroken = Class(TPackagehandler)
Public Public
Function Execute(const Args:TActionArgs):boolean;override; Procedure Execute;override;
end; end;
function TCommandAddConfig.Execute(const Args:TActionArgs):boolean; procedure TCommandAddConfig.Execute;
begin begin
{ {
Log(vlInfo,SLogGeneratingCompilerConfig,[S]); Log(vlInfo,SLogGeneratingCompilerConfig,[S]);
Options.InitCompilerDefaults(Args[2]); Options.InitCompilerDefaults(Args[2]);
Options.SaveCompilerToFile(S); Options.SaveCompilerToFile(S);
} }
Result:=true;
end; end;
function TCommandUpdate.Execute(const Args:TActionArgs):boolean; procedure TCommandUpdate.Execute;
var var
PackagesURL : String; PackagesURL : String;
begin begin
// Download mirrors.xml // Download mirrors.xml
Log(vlCommands,SLogDownloading,[GlobalOptions.RemoteMirrorsURL,GlobalOptions.LocalMirrorsFile]); Log(vlCommands,SLogDownloading,[GlobalOptions.RemoteMirrorsURL,GlobalOptions.LocalMirrorsFile]);
DownloadFile(GlobalOptions.RemoteMirrorsURL,GlobalOptions.LocalMirrorsFile); DownloadFile(GlobalOptions.RemoteMirrorsURL,GlobalOptions.LocalMirrorsFile);
LoadLocalMirrors; LoadLocalAvailableMirrors;
// Download packages.xml // Download packages.xml
PackagesURL:=GetRemoteRepositoryURL(PackagesFileName); PackagesURL:=GetRemoteRepositoryURL(PackagesFileName);
Log(vlCommands,SLogDownloading,[PackagesURL,GlobalOptions.LocalPackagesFile]); Log(vlCommands,SLogDownloading,[PackagesURL,GlobalOptions.LocalPackagesFile]);
DownloadFile(PackagesURL,GlobalOptions.LocalPackagesFile); DownloadFile(PackagesURL,GlobalOptions.LocalPackagesFile);
// Read the repository again // Read the repository again
LoadLocalRepository; LoadLocalAvailableRepository;
// no need to log errors again // no need to log errors again
FindInstalledPackages(CompilerOptions,False); FindInstalledPackages(CompilerOptions,False);
Result:=true;
end; end;
function TCommandShowAll.Execute(const Args:TActionArgs):boolean; procedure TCommandShowAll.Execute;
begin begin
ListLocalRepository(true); ListInstalledPackages;
Result:=true;
end; end;
function TCommandShowAvail.Execute(const Args:TActionArgs):boolean; procedure TCommandShowAvail.Execute;
begin begin
ListLocalRepository(false); ListAvailablePackages;
Result:=true;
end; end;
function TCommandScanPackages.Execute(const Args:TActionArgs):boolean; procedure TCommandScanPackages.Execute;
begin begin
RebuildRemoteRepository; RebuildRemoteRepository;
ListRemoteRepository; ListRemoteRepository;
SaveRemoteRepository; SaveRemoteRepository;
Result:=true;
end; end;
function TCommandDownload.Execute(const Args:TActionArgs):boolean; procedure TCommandDownload.Execute;
var
P : TFPPackage;
begin begin
if not assigned(CurrentPackage) then if PackageName='' then
Error(SErrNoPackageSpecified); Error(SErrNoPackageSpecified);
if not FileExists(PackageLocalArchive) then P:=AvailableRepository.PackageByName(PackageName);
ExecuteAction(CurrentPackage,'downloadpackage',Args); if not FileExists(PackageLocalArchive(P)) then
Result:=true; ExecuteAction(PackageName,'downloadpackage');
end; end;
function TCommandUnzip.Execute(const Args:TActionArgs):boolean; procedure TCommandUnzip.Execute;
Var Var
BuildDir : string; BuildDir : string;
ArchiveFile : String; ArchiveFile : String;
P : TFPPackage;
begin begin
BuildDir:=PackageBuildPath; if PackageName='' then
ArchiveFile:=PackageLocalArchive;
if not assigned(CurrentPackage) then
Error(SErrNoPackageSpecified); Error(SErrNoPackageSpecified);
if IsLocalPackage then
P:=InstalledRepository.PackageByName(PackageName)
else
P:=AvailableRepository.PackageByName(PackageName);
BuildDir:=PackageBuildPath(P);
ArchiveFile:=PackageLocalArchive(P);
if not FileExists(ArchiveFile) then if not FileExists(ArchiveFile) then
ExecuteAction(CurrentPackage,'downloadpackage'); ExecuteAction(PackageName,'downloadpackage');
{ Create builddir, remove it first if needed } { Create builddir, remove it first if needed }
if DirectoryExists(BuildDir) then if DirectoryExists(BuildDir) then
DeleteDir(BuildDir); DeleteDir(BuildDir);
@ -202,130 +204,141 @@ begin
With TUnZipper.Create do With TUnZipper.Create do
try try
Log(vlCommands,SLogUnzippping,[ArchiveFile]); Log(vlCommands,SLogUnzippping,[ArchiveFile]);
OutputPath:=PackageBuildPath; OutputPath:=PackageBuildPath(P);
UnZipAllFiles(ArchiveFile); UnZipAllFiles(ArchiveFile);
Finally Finally
Free; Free;
end; end;
Result:=true;
end; end;
function TCommandCompile.Execute(const Args:TActionArgs):boolean; procedure TCommandCompile.Execute;
begin begin
if assigned(CurrentPackage) then if PackageName<>'' then
begin begin
// For local files we need the information inside the zip to get the // For local files we need the information inside the zip to get the
// dependencies // dependencies
if CurrentPackage.IsLocalPackage then if IsLocalPackage then
begin begin
ExecuteAction(CurrentPackage,'unzip',Args); ExecuteAction(PackageName,'unzip');
ExecuteAction(CurrentPackage,'installdependencies',Args); ExecuteAction(PackageName,'installdependencies');
end end
else else
begin begin
ExecuteAction(CurrentPackage,'installdependencies',Args); ExecuteAction(PackageName,'installdependencies');
ExecuteAction(CurrentPackage,'unzip',Args); ExecuteAction(PackageName,'unzip');
end; end;
end; end;
ExecuteAction(CurrentPackage,'fpmakecompile',Args); ExecuteAction(PackageName,'fpmakecompile');
Result:=true;
end; end;
function TCommandBuild.Execute(const Args:TActionArgs):boolean; procedure TCommandBuild.Execute;
begin begin
if assigned(CurrentPackage) then if PackageName<>'' then
begin begin
// For local files we need the information inside the zip to get the // For local files we need the information inside the zip to get the
// dependencies // dependencies
if CurrentPackage.IsLocalPackage then if IsLocalPackage then
begin begin
ExecuteAction(CurrentPackage,'unzip',Args); ExecuteAction(PackageName,'unzip');
ExecuteAction(CurrentPackage,'installdependencies',Args); ExecuteAction(PackageName,'installdependencies');
end end
else else
begin begin
ExecuteAction(CurrentPackage,'installdependencies',Args); ExecuteAction(PackageName,'installdependencies');
ExecuteAction(CurrentPackage,'unzip',Args); ExecuteAction(PackageName,'unzip');
end; end;
end; end;
ExecuteAction(CurrentPackage,'fpmakebuild',Args); ExecuteAction(PackageName,'fpmakebuild');
Result:=true;
end; end;
function TCommandInstall.Execute(const Args:TActionArgs):boolean; procedure TCommandInstall.Execute;
var var
S : String; UFN,S : String;
P : TFPPackage;
begin begin
if assigned(CurrentPackage) then if PackageName<>'' then
ExecuteAction(CurrentPackage,'build',Args);
ExecuteAction(CurrentPackage,'fpmakeinstall',Args);
// Update version information from generated fpunits.conf
if assigned(CurrentPackage) then
begin begin
if GlobalOptions.InstallGlobal then ExecuteAction(PackageName,'build');
S:=CompilerOptions.GlobalUnitDir ExecuteAction(PackageName,'fpmakeinstall');
if IsLocalPackage then
begin
// Load package name from manifest
if not FileExists(ManifestFileName) then
ExecuteAction(PackageName,'fpmakemanifest');
P:=LoadManifestFromFile(ManifestFileName);
S:=P.Name;
FreeAndNil(P);
end
else else
S:=CompilerOptions.LocalUnitDir; S:=PackageName;
S:=IncludeTrailingPathDelimiter(S)+CurrentPackage.Name+PathDelim+UnitConfigFileName; P:=InstalledRepository.FindPackage(S);
LoadUnitConfigFromFile(CurrentPackage,S); if not assigned(P) then
end; P:=InstalledRepository.AddPackage(S);
Result:=true; if GlobalOptions.InstallGlobal then
UFN:=CompilerOptions.GlobalUnitDir
else
UFN:=CompilerOptions.LocalUnitDir;
UFN:=IncludeTrailingPathDelimiter(UFN)+S+PathDelim+UnitConfigFileName;
LoadUnitConfigFromFile(P,UFN);
end
else
ExecuteAction(PackageName,'fpmakeinstall');
end; end;
function TCommandClean.Execute(const Args:TActionArgs):boolean; procedure TCommandClean.Execute;
begin begin
ExecuteAction(CurrentPackage,'fpmakeclean',Args); ExecuteAction(PackageName,'fpmakeclean');
Result:=true;
end; end;
function TCommandArchive.Execute(const Args:TActionArgs):boolean; procedure TCommandArchive.Execute;
begin begin
ExecuteAction(CurrentPackage,'fpmakearchive',Args); ExecuteAction(PackageName,'fpmakearchive');
Result:=true;
end; end;
function TCommandInstallDependencies.Execute(const Args:TActionArgs):boolean; procedure TCommandInstallDependencies.Execute;
var var
i : Integer; i : Integer;
MissingDependency, MissingDependency,
D : TFPDependency; D : TFPDependency;
P, P,
DepPackage : TFPPackage; InstalledP,
AvailP : TFPPackage;
L : TStringList; L : TStringList;
status : string; status : string;
begin begin
if not assigned(CurrentPackage) then if PackageName='' then
Error(SErrNoPackageSpecified); Error(SErrNoPackageSpecified);
// Load dependencies for local packages // Load dependencies for local packages
if CurrentPackage.IsLocalPackage then if IsLocalPackage then
begin begin
ExecuteAction(CurrentPackage,'fpmakemanifest',Args); ExecuteAction(PackageName,'fpmakemanifest');
P:=LoadPackageManifest(ManifestFileName); P:=LoadManifestFromFile(ManifestFileName);
// Update CurrentPackage end
CurrentPackage.Assign(P); else
CurrentPackage.IsLocalPackage:=true; P:=AvailableRepository.PackageByName(PackageName);
end;
// Find and List dependencies // Find and List dependencies
MissingDependency:=nil; MissingDependency:=nil;
L:=TStringList.Create; L:=TStringList.Create;
for i:=0 to CurrentPackage.Dependencies.Count-1 do for i:=0 to P.Dependencies.Count-1 do
begin begin
D:=CurrentPackage.Dependencies[i]; D:=P.Dependencies[i];
if (CompilerOptions.CompilerOS in D.OSes) and if (CompilerOptions.CompilerOS in D.OSes) and
(CompilerOptions.CompilerCPU in D.CPUs) then (CompilerOptions.CompilerCPU in D.CPUs) then
begin begin
DepPackage:=CurrentRepository.PackageByName(D.PackageName); InstalledP:=InstalledRepository.FindPackage(D.PackageName);
// Need installation? // Need installation?
if (DepPackage.InstalledVersion.Empty) or if not assigned(InstalledP) or
(DepPackage.InstalledVersion.CompareVersion(D.MinVersion)<0) then (InstalledP.Version.CompareVersion(D.MinVersion)<0) then
begin begin
if DepPackage.Version.CompareVersion(D.MinVersion)<0 then AvailP:=AvailableRepository.FindPackage(D.PackageName);
if not assigned(AvailP) or
(AvailP.Version.CompareVersion(D.MinVersion)<0) then
begin begin
status:='Not Available!'; status:='Not Available!';
MissingDependency:=D; MissingDependency:=D;
@ -333,21 +346,22 @@ begin
else else
begin begin
status:='Updating'; status:='Updating';
L.Add(DepPackage.Name); L.Add(D.PackageName);
end; end;
end end
else else
begin begin
if PackageIsBroken(DepPackage) then if PackageIsBroken(InstalledP) then
begin begin
status:='Broken, recompiling'; status:='Broken, recompiling';
L.Add(DepPackage.Name); L.Add(D.PackageName);
end end
else else
status:='OK'; status:='OK';
end; end;
Log(vlInfo,SLogPackageDependency, Log(vlInfo,SLogPackageDependency,
[D.PackageName,D.MinVersion.AsString,DepPackage.InstalledVersion.AsString,DepPackage.Version.AsString,status]); [D.PackageName,D.MinVersion.AsString,PackageInstalledVersionStr(D.PackageName),
PackageAvailableVersionStr(D.PackageName),status]);
end end
else else
Log(vlDebug,SDbgPackageDependencyOtherTarget,[D.PackageName,MakeTargetString(CompilerOptions.CompilerCPU,CompilerOptions.CompilerOS)]); Log(vlDebug,SDbgPackageDependencyOtherTarget,[D.PackageName,MakeTargetString(CompilerOptions.CompilerCPU,CompilerOptions.CompilerOS)]);
@ -357,19 +371,16 @@ begin
Error(SErrNoPackageAvailable,[MissingDependency.PackageName,MissingDependency.MinVersion.AsString]); Error(SErrNoPackageAvailable,[MissingDependency.PackageName,MissingDependency.MinVersion.AsString]);
// Install needed updates // Install needed updates
for i:=0 to L.Count-1 do for i:=0 to L.Count-1 do
begin ExecuteAction(L[i],'install');
DepPackage:=CurrentRepository.PackageByName(L[i]);
ExecuteAction(DepPackage,'install');
end;
FreeAndNil(L); FreeAndNil(L);
Result:=true; if IsLocalPackage then
FreeAndNil(P);
end; end;
function TCommandFixBroken.Execute(const Args:TActionArgs):boolean; procedure TCommandFixBroken.Execute;
var var
i : integer; i : integer;
P : TFPPackage;
SL : TStringList; SL : TStringList;
begin begin
SL:=TStringList.Create; SL:=TStringList.Create;
@ -379,13 +390,11 @@ begin
break; break;
for i:=0 to SL.Count-1 do for i:=0 to SL.Count-1 do
begin begin
P:=CurrentRepository.PackageByName(SL[i]); ExecuteAction(SL[i],'build');
ExecuteAction(P,'build'); ExecuteAction(SL[i],'install');
ExecuteAction(P,'install');
end; end;
until false; until false;
FreeAndNil(SL); FreeAndNil(SL);
Result:=true;
end; end;

14
utils/fppkg/pkgdownload.pp
View File

@ -30,7 +30,7 @@ Type
TDownloadPackage = Class(TPackagehandler) TDownloadPackage = Class(TPackagehandler)
Public Public
Function Execute(const Args:TActionArgs):boolean;override; Procedure Execute;override;
end; end;
procedure RegisterDownloader(const AName:string;Downloaderclass:TBaseDownloaderClass); procedure RegisterDownloader(const AName:string;Downloaderclass:TBaseDownloaderClass);
@ -44,9 +44,11 @@ implementation
uses uses
contnrs, contnrs,
uriparser, uriparser,
fprepos,
pkgglobals, pkgglobals,
pkgoptions, pkgoptions,
pkgmessages; pkgmessages,
pkgrepos;
var var
DownloaderList : TFPHashList; DownloaderList : TFPHashList;
@ -157,15 +159,17 @@ end;
{ TDownloadPackage } { TDownloadPackage }
function TDownloadPackage.Execute(const Args:TActionArgs):boolean; procedure TDownloadPackage.Execute;
var var
DownloaderClass : TBaseDownloaderClass; DownloaderClass : TBaseDownloaderClass;
P : TFPPackage;
begin begin
P:=AvailableRepository.PackageByName(PackageName);
DownloaderClass:=GetDownloader(GlobalOptions.Downloader); DownloaderClass:=GetDownloader(GlobalOptions.Downloader);
with DownloaderClass.Create(nil) do with DownloaderClass.Create(nil) do
try try
Log(vlCommands,SLogDownloading,[PackageRemoteArchive,PackageLocalArchive]); Log(vlCommands,SLogDownloading,[PackageRemoteArchive(P),PackageLocalArchive(P)]);
Download(PackageRemoteArchive,PackageLocalArchive); Download(PackageRemoteArchive(P),PackageLocalArchive(P));
finally finally
Free; Free;
end; end;

77
utils/fppkg/pkgfpmake.pp
View File

@ -13,16 +13,15 @@ uses
fprepos, fprepos,
pkgoptions, pkgoptions,
pkgglobals, pkgglobals,
pkgmessages; pkgmessages,
pkgrepos;
type type
{ TFPMakeCompiler } { TFPMakeCompiler }
TFPMakeCompiler = Class(TPackagehandler) TFPMakeCompiler = Class(TPackagehandler)
Private
Procedure CompileFPMake;
Public Public
Function Execute(const Args:TActionArgs):boolean;override; Procedure Execute;override;
end; end;
@ -38,7 +37,7 @@ type
TFPMakeRunnerCompile = Class(TFPMakeRunner) TFPMakeRunnerCompile = Class(TFPMakeRunner)
Public Public
Function Execute(const Args:TActionArgs):boolean;override; Procedure Execute;override;
end; end;
@ -46,7 +45,7 @@ type
TFPMakeRunnerBuild = Class(TFPMakeRunner) TFPMakeRunnerBuild = Class(TFPMakeRunner)
Public Public
Function Execute(const Args:TActionArgs):boolean;override; Procedure Execute;override;
end; end;
@ -54,7 +53,7 @@ type
TFPMakeRunnerInstall = Class(TFPMakeRunner) TFPMakeRunnerInstall = Class(TFPMakeRunner)
Public Public
Function Execute(const Args:TActionArgs):boolean;override; Procedure Execute;override;
end; end;
@ -62,21 +61,21 @@ type
TFPMakeRunnerClean = Class(TFPMakeRunner) TFPMakeRunnerClean = Class(TFPMakeRunner)
Public Public
Function Execute(const Args:TActionArgs):boolean;override; Procedure Execute;override;
end; end;
{ TFPMakeRunnerManifest } { TFPMakeRunnerManifest }
TFPMakeRunnerManifest = Class(TFPMakeRunner) TFPMakeRunnerManifest = Class(TFPMakeRunner)
Public Public
Function Execute(const Args:TActionArgs):boolean;override; Procedure Execute;override;
end; end;
{ TFPMakeRunnerArchive } { TFPMakeRunnerArchive }
TFPMakeRunnerArchive = Class(TFPMakeRunner) TFPMakeRunnerArchive = Class(TFPMakeRunner)
Public Public
Function Execute(const Args:TActionArgs):boolean;override; Procedure Execute;override;
end; end;
TMyMemoryStream=class(TMemoryStream) TMyMemoryStream=class(TMemoryStream)
@ -120,7 +119,7 @@ end;
{ TFPMakeCompiler } { TFPMakeCompiler }
Procedure TFPMakeCompiler.CompileFPMake; Procedure TFPMakeCompiler.Execute;
var var
OOptions : string; OOptions : string;
@ -161,9 +160,11 @@ Var
FPMakeSrc : string; FPMakeSrc : string;
NeedFPMKUnitSource, NeedFPMKUnitSource,
HaveFpmake : boolean; HaveFpmake : boolean;
P : TFPPackage;
begin begin
P:=InstalledRepository.PackageByName(PackageName);
OOptions:=''; OOptions:='';
SetCurrentDir(PackageBuildPath); SetCurrentDir(PackageBuildPath(P));
// Check for fpmake source // Check for fpmake source
FPMakeBin:='fpmake'+ExeExt; FPMakeBin:='fpmake'+ExeExt;
FPMakeSrc:='fpmake.pp'; FPMakeSrc:='fpmake.pp';
@ -236,18 +237,11 @@ begin
end; end;
function TFPMakeCompiler.Execute(const Args:TActionArgs):boolean;
begin
{$warning TODO Check arguments}
CompileFPMake;
result:=true;
end;
{ TFPMakeRunner } { TFPMakeRunner }
Function TFPMakeRunner.RunFPMake(const Command:string) : Integer; Function TFPMakeRunner.RunFPMake(const Command:string) : Integer;
Var Var
P : TFPPackage;
FPMakeBin, FPMakeBin,
OOptions : string; OOptions : string;
@ -261,15 +255,18 @@ Var
begin begin
OOptions:=''; OOptions:='';
// Does the current package support this CPU-OS? // Does the current package support this CPU-OS?
if assigned(CurrentPackage) then if PackageName<>'' then
P:=InstalledRepository.PackageByName(PackageName)
else
P:=nil;
if assigned(P) then
begin begin
if not(CompilerOptions.CompilerOS in CurrentPackage.OSes) or if not(CompilerOptions.CompilerOS in P.OSes) or
not(CompilerOptions.CompilerCPU in CurrentPackage.CPUs) then not(CompilerOptions.CompilerCPU in P.CPUs) then
Error(SErrPackageDoesNotSupportTarget,[CurrentPackage.Name, Error(SErrPackageDoesNotSupportTarget,[P.Name,MakeTargetString(CompilerOptions.CompilerCPU,CompilerOptions.CompilerOS)]);
MakeTargetString(CompilerOptions.CompilerCPU,CompilerOptions.CompilerOS)]);
end; end;
{ Maybe compile fpmake executable? } { Maybe compile fpmake executable? }
ExecuteAction(CurrentPackage,'compilefpmake'); ExecuteAction(PackageName,'compilefpmake');
{ Create options } { Create options }
AddOption('--nofpccfg'); AddOption('--nofpccfg');
if vlInfo in LogLevels then if vlInfo in LogLevels then
@ -286,51 +283,49 @@ begin
AddOption('--globalunitdir='+CompilerOptions.GlobalUnitDir); AddOption('--globalunitdir='+CompilerOptions.GlobalUnitDir);
{ Run FPMake } { Run FPMake }
FPMakeBin:='fpmake'+ExeExt; FPMakeBin:='fpmake'+ExeExt;
SetCurrentDir(PackageBuildPath); SetCurrentDir(PackageBuildPath(P));
Result:=ExecuteProcess(FPMakeBin,Command+' '+OOptions); Result:=ExecuteProcess(FPMakeBin,Command+' '+OOptions);
if Result<>0 then if Result<>0 then
Error(SErrExecutionFPMake,[Command]); Error(SErrExecutionFPMake,[Command]);
end; end;
function TFPMakeRunnerCompile.Execute(const Args:TActionArgs):boolean; procedure TFPMakeRunnerCompile.Execute;
begin begin
result:=(RunFPMake('compile')=0); RunFPMake('compile');
end; end;
function TFPMakeRunnerBuild.Execute(const Args:TActionArgs):boolean; procedure TFPMakeRunnerBuild.Execute;
begin begin
result:=(RunFPMake('build')=0); RunFPMake('build');
end; end;
function TFPMakeRunnerInstall.Execute(const Args:TActionArgs):boolean; procedure TFPMakeRunnerInstall.Execute;
begin begin
result:=(RunFPMake('install')=0); RunFPMake('install');
end; end;
function TFPMakeRunnerClean.Execute(const Args:TActionArgs):boolean; procedure TFPMakeRunnerClean.Execute;
begin begin
result:=(RunFPMake('clean')=0); RunFPMake('clean');
end; end;
function TFPMakeRunnerManifest.Execute(const Args:TActionArgs):boolean; procedure TFPMakeRunnerManifest.Execute;
begin begin
result:=(RunFPMake('manifest')=0); RunFPMake('manifest');
end; end;
function TFPMakeRunnerArchive.Execute(const Args:TActionArgs):boolean; procedure TFPMakeRunnerArchive.Execute;
begin begin
result:=(RunFPMake('archive')=0); RunFPMake('archive');
end; end;
initialization initialization
RegisterPkgHandler('compilefpmake',TFPMakeCompiler); RegisterPkgHandler('compilefpmake',TFPMakeCompiler);
RegisterPkgHandler('fpmakecompile',TFPMakeRunnerCompile); RegisterPkgHandler('fpmakecompile',TFPMakeRunnerCompile);

240
utils/fppkg/pkghandler.pp
View File

@ -10,52 +10,31 @@ uses
pkgoptions, pkgoptions,
fprepos; fprepos;
const
CmdLinePackageName='<cmdline>';
CurrentDirPackageName='<currentdir>';
type type
{ TActionStack }
TActionArgs = array of string;
TActionStackItem = record
ActionPackage : TFPPackage;
Action : string;
Args : TActionArgs;
end;
PActionStackItem = ^TActionStackItem;
TActionStack = class
private
FList : TFPList;
public
constructor Create;
destructor Destroy;override;
procedure Push(APackage:TFPPackage;const AAction:string;const Args:TActionArgs);
procedure Push(APackage:TFPPackage;const AAction:string;const Args:array of string);
function Pop(out APackage:TFPPackage;out AAction:string;out Args:TActionArgs):boolean;
end;
{ TPackageHandler } { TPackageHandler }
TPackageHandler = Class(TComponent) TPackageHandler = Class(TComponent)
private private
FCurrentPackage : TFPPackage; FPackageName : string;
FIsLocalPackage : boolean;
Protected Protected
Procedure Log(Level: TLogLevel;Msg : String); Procedure Log(Level: TLogLevel;Msg : String);
Procedure Log(Level: TLogLevel;Fmt : String; const Args : array of const); Procedure Log(Level: TLogLevel;Fmt : String; const Args : array of const);
Procedure Error(Msg : String); Procedure Error(Msg : String);
Procedure Error(Fmt : String; const Args : array of const); Procedure Error(Fmt : String; const Args : array of const);
procedure ExecuteAction(APackage:TFPPackage;const AAction:string;const Args:TActionArgs=nil);
Function ExecuteProcess(Const Prog,Args:String):Integer; Function ExecuteProcess(Const Prog,Args:String):Integer;
Procedure SetCurrentDir(Const ADir:String); Procedure SetCurrentDir(Const ADir:String);
function PackageBuildPath:String;
function PackageRemoteArchive:String;
function PackageLocalArchive:String;
function PackageManifestFile:String;
Public Public
Constructor Create(AOwner:TComponent;APackage:TFPPackage); virtual; Constructor Create(AOwner:TComponent;const APackageName:string); virtual;
function PackageLogPrefix:String; function PackageLogPrefix:String;
Function Execute(const Args:TActionArgs):boolean; virtual; abstract; procedure ExecuteAction(const APackageName,AAction:string);
Property CurrentPackage:TFPPackage Read FCurrentPackage Write FCurrentPackage; procedure Execute; virtual; abstract;
Property PackageName:string Read FPackageName;
Property IsLocalPackage:boolean Read FIsLocalPackage Write FIsLocalPackage;
end; end;
TPackageHandlerClass = class of TPackageHandler; TPackageHandlerClass = class of TPackageHandler;
@ -64,7 +43,12 @@ type
// Actions/PkgHandler // Actions/PkgHandler
procedure RegisterPkgHandler(const AAction:string;pkghandlerclass:TPackageHandlerClass); procedure RegisterPkgHandler(const AAction:string;pkghandlerclass:TPackageHandlerClass);
function GetPkgHandler(const AAction:string):TPackageHandlerClass; function GetPkgHandler(const AAction:string):TPackageHandlerClass;
function ExecuteAction(APackage:TFPPackage;const AAction:string;const Args:TActionArgs=nil):Boolean; procedure ExecuteAction(const APackageName,AAction:string);
function PackageBuildPath(APackage:TFPPackage):String;
function PackageRemoteArchive(APackage:TFPPackage): String;
function PackageLocalArchive(APackage:TFPPackage): String;
function PackageManifestFile(APackage:TFPPackage): String;
Implementation Implementation
@ -99,53 +83,83 @@ begin
end; end;
function ExecuteAction(APackage:TFPPackage;const AAction:string;const Args:TActionArgs=nil):Boolean; procedure ExecuteAction(const APackageName,AAction:string);
var var
pkghandlerclass : TPackageHandlerClass; pkghandlerclass : TPackageHandlerClass;
i : integer;
logargs : string;
FullActionName : string; FullActionName : string;
begin begin
result:=false;
// Check if we have already executed or are executing the action // Check if we have already executed or are executing the action
if assigned(Apackage) then FullActionName:=APackageName+AAction;
FullActionName:=APackage.Name+AAction
else
FullActionName:=AAction;
if ExecutedActions.Find(FullActionName)<>nil then if ExecutedActions.Find(FullActionName)<>nil then
begin begin
Log(vlDebug,'Already executed or executing action '+FullActionName); Log(vlDebug,'Already executed or executing action '+FullActionName);
result:=true;
exit; exit;
end; end;
ExecutedActions.Add(FullActionName,Pointer(PtrUInt(1))); ExecutedActions.Add(FullActionName,Pointer(PtrUInt(1)));
// Create action handler class // Create action handler class
pkghandlerclass:=GetPkgHandler(AAction); pkghandlerclass:=GetPkgHandler(AAction);
With pkghandlerclass.Create(nil,APackage) do With pkghandlerclass.Create(nil,APackageName) do
try try
logargs:=''; if (APackageName=CmdLinePackageName) or
for i:=Low(Args) to High(Args) do (APackageName=CurrentDirPackageName) then
begin IsLocalPackage:=true;
if logargs='' then Log(vlDebug,SLogRunAction+' start',[AAction]);
logargs:=Args[i] Execute;
else Log(vlDebug,SLogRunAction+' end',[AAction]);
logargs:=logargs+','+Args[i];
end;
Log(vlDebug,SLogRunAction+' start',[AAction,logargs]);
result:=Execute(Args);
Log(vlDebug,SLogRunAction+' end',[AAction,logargs]);
finally finally
Free; Free;
end; end;
end; end;
function PackageBuildPath(APackage:TFPPackage):String;
begin
if APackage.Name=CurrentDirPackageName then
Result:='.'
else if APackage.Name=CmdLinePackageName then
Result:=GlobalOptions.BuildDir+ChangeFileExt(ExtractFileName(APackage.LocalFileName),'')
else
Result:=GlobalOptions.BuildDir+APackage.Name;
end;
function PackageRemoteArchive(APackage:TFPPackage): String;
begin
if APackage.Name=CurrentDirPackageName then
Error(SErrNoPackageSpecified)
else if APackage.Name=CmdLinePackageName then
Error(SErrPackageIsLocal);
if APackage.ExternalURL<>'' then
Result:=APackage.ExternalURL
else
Result:=GetRemoteRepositoryURL(APackage.FileName);
end;
function PackageLocalArchive(APackage:TFPPackage): String;
begin
if APackage.Name=CurrentDirPackageName then
Error(SErrNoPackageSpecified)
else if APackage.Name=CmdLinePackageName then
Result:=APackage.LocalFileName
else
Result:=GlobalOptions.ArchivesDir+APackage.FileName;
end;
function PackageManifestFile(APackage:TFPPackage): String;
begin
Result:=ManifestFileName;
end;
{ TPackageHandler } { TPackageHandler }
constructor TPackageHandler.Create(AOwner:TComponent;APackage:TFPPackage); constructor TPackageHandler.Create(AOwner:TComponent;const APackageName:string);
begin begin
inherited Create(AOwner); inherited Create(AOwner);
FCurrentPackage:=APackage; FPackageName:=APackageName;
end; end;
Function TPackageHandler.ExecuteProcess(Const Prog,Args:String):Integer; Function TPackageHandler.ExecuteProcess(Const Prog,Args:String):Integer;
@ -163,53 +177,22 @@ begin
end; end;
function TPackageHandler.PackageBuildPath:String;
begin
if CurrentPackage=nil then
Result:='.'
else
Result:=GlobalOptions.BuildDir+CurrentPackage.Name;
end;
function TPackageHandler.PackageRemoteArchive: String;
begin
if not assigned(CurrentPackage) then
Error(SErrNoPackageSpecified);
if CurrentPackage.IsLocalPackage then
Error(SErrPackageIsLocal);
if CurrentPackage.ExternalURL<>'' then
Result:=CurrentPackage.ExternalURL
else
Result:=GetRemoteRepositoryURL(CurrentPackage.FileName);
end;
function TPackageHandler.PackageLocalArchive: String;
begin
if not assigned(CurrentPackage) then
Error(SErrNoPackageSpecified);
if CurrentPackage.IsLocalPackage then
Result:=CurrentPackage.FileName
else
Result:=GlobalOptions.ArchivesDir+CurrentPackage.FileName;
end;
function TPackageHandler.PackageManifestFile: String;
begin
Result:=ManifestFileName;
end;
function TPackageHandler.PackageLogPrefix:String; function TPackageHandler.PackageLogPrefix:String;
begin begin
if assigned(CurrentPackage) then if PackageName<>'' then
Result:='['+CurrentPackage.Name+'] ' Result:='['+PackageName+'] '
else else
// Result:='[<currentdir>] ';
Result:=''; Result:='';
end; end;
procedure TPackageHandler.ExecuteAction(const APackageName,AAction:string);
begin
// Needed to override TComponent.ExecuteAction method
pkghandler.ExecuteAction(APackageName,AAction);
end;
Procedure TPackageHandler.Log(Level:TLogLevel; Msg:String); Procedure TPackageHandler.Log(Level:TLogLevel; Msg:String);
begin begin
pkgglobals.Log(Level,PackageLogPrefix+Msg); pkgglobals.Log(Level,PackageLogPrefix+Msg);
@ -234,71 +217,6 @@ begin
end; end;
procedure TPackageHandler.ExecuteAction(APackage: TFPPackage; const AAction: string; const Args: TActionArgs=nil);
begin
pkghandler.ExecuteAction(APackage,AAction,Args);
end;
{ TActionStack }
constructor TActionStack.Create;
begin
FList:=TFPList.Create;
end;
destructor TActionStack.Destroy;
begin
FreeAndNil(FList);
end;
procedure TActionStack.Push(APackage:TFPPackage;const AAction:string;const Args:TActionArgs);
var
ActionItem : PActionStackItem;
begin
New(ActionItem);
ActionItem^.ActionPackage:=APackage;
ActionItem^.Action:=AAction;
ActionItem^.Args:=Args;
FList.Add(ActionItem);
end;
procedure TActionStack.Push(APackage:TFPPackage;const AAction:string;const Args:array of string);
var
ActionArgs : TActionArgs;
i : integer;
begin
SetLength(ActionArgs,high(Args)+1);
for i:=low(Args) to high(Args) do
ActionArgs[i]:=Args[i];
Push(APackage,AAction,ActionArgs);
end;
function TActionStack.Pop(out APackage:TFPPackage;out AAction:string;out Args:TActionArgs):boolean;
var
ActionItem : PActionStackItem;
Idx : integer;
begin
Result:=false;
if FList.Count=0 then
exit;
// Retrieve Item from stack
Idx:=FList.Count-1;
ActionItem:=PActionStackItem(FList[Idx]);
FList.Delete(Idx);
// Copy contents and dispose stack item
APackage:=ActionItem^.ActionPackage;
AAction:=ActionItem^.Action;
Args:=ActionItem^.Args;
dispose(ActionItem);
Result:=true;
end;
initialization initialization
PkgHandlerList:=TFPHashList.Create; PkgHandlerList:=TFPHashList.Create;
ExecutedActions:=TFPHashList.Create; ExecutedActions:=TFPHashList.Create;

3
utils/fppkg/pkgmessages.pp
View File

@ -49,11 +49,12 @@ Resourcestring
SErrCWDFailed = 'FTP CWD "%s" command failed.'; SErrCWDFailed = 'FTP CWD "%s" command failed.';
SErrGETFailed = 'FTP GET "%s" command failed.'; SErrGETFailed = 'FTP GET "%s" command failed.';
SErrBrokenPackagesFound = 'Found broken packages, run "fppkg fixbroken" first'; SErrBrokenPackagesFound = 'Found broken packages, run "fppkg fixbroken" first';
SErrManifestNoSinglePackage = 'Manifest file "%s" does not contain exactly one package';
SLogGeneratingFPMake = 'Generating fpmake.pp'; SLogGeneratingFPMake = 'Generating fpmake.pp';
SLogNotCompilingFPMake = 'Skipping compiling of fpmake.pp, fpmake executable already exists'; SLogNotCompilingFPMake = 'Skipping compiling of fpmake.pp, fpmake executable already exists';
SLogCommandLineAction = 'Adding action from commandline: "%s %s"'; SLogCommandLineAction = 'Adding action from commandline: "%s %s"';
SLogRunAction = 'Action: "%s %s"'; SLogRunAction = 'Action: "%s"';
SLogExecute = 'Executing: "%s %s"'; SLogExecute = 'Executing: "%s %s"';
SLogChangeDir = 'CurrentDir: "%s"'; SLogChangeDir = 'CurrentDir: "%s"';
SLogDownloading = 'Downloading "%s" to "%s"'; SLogDownloading = 'Downloading "%s" to "%s"';

5
utils/fppkg/pkgmkconv.pp
View File

@ -42,7 +42,7 @@ Type
procedure ConvertFile(const AFileName: String; Src: TStrings; Dir,OS : String); procedure ConvertFile(const AFileName: String; Src: TStrings; Dir,OS : String);
Procedure ConvertFile(Const Source,Dest: String); Procedure ConvertFile(Const Source,Dest: String);
Public Public
Function Execute(const Args:TActionArgs):boolean;override; Procedure Execute;override;
end; end;
@ -696,13 +696,12 @@ begin
end; end;
end; end;
function TMakeFileConverter.Execute(const Args:TActionArgs):boolean; procedure TMakeFileConverter.Execute;
begin begin
if not FileExists('fpmake.pp') then if not FileExists('fpmake.pp') then
ConvertFile('Makefile.fpc','fpmake.pp') ConvertFile('Makefile.fpc','fpmake.pp')
else else
Error(SErrConvertFPMakeExists); Error(SErrConvertFPMakeExists);
result:=true;
end; end;
begin begin

322
utils/fppkg/pkgrepos.pp
View File

@ -10,24 +10,27 @@ uses
function GetRemoteRepositoryURL(const AFileName:string):string; function GetRemoteRepositoryURL(const AFileName:string):string;
procedure LoadLocalMirrors; procedure LoadLocalAvailableMirrors;
procedure LoadLocalRepository; procedure LoadLocalAvailableRepository;
function LoadOrCreatePackage(const AName:string):TFPPackage;
procedure LoadUnitConfigFromFile(APackage:TFPPackage;const AFileName: String); procedure LoadUnitConfigFromFile(APackage:TFPPackage;const AFileName: String);
function LoadPackageManifest(const AManifestFN:string):TFPPackage; function LoadManifestFromFile(const AManifestFN:string):TFPPackage;
procedure FindInstalledPackages(ACompilerOptions:TCompilerOptions;showdups:boolean=true); procedure FindInstalledPackages(ACompilerOptions:TCompilerOptions;showdups:boolean=true);
function PackageIsBroken(APackage:TFPPackage):boolean; function PackageIsBroken(APackage:TFPPackage):boolean;
function FindBrokenPackages(SL:TStrings):Boolean; function FindBrokenPackages(SL:TStrings):Boolean;
procedure CheckFPMakeDependencies; procedure CheckFPMakeDependencies;
procedure ListLocalRepository(all:boolean=false); function PackageInstalledVersionStr(const AName:String):string;
function PackageAvailableVersionStr(const AName:String):string;
procedure ListAvailablePackages;
procedure ListInstalledPackages;
procedure ListRemoteRepository; procedure ListRemoteRepository;
procedure RebuildRemoteRepository; procedure RebuildRemoteRepository;
procedure SaveRemoteRepository; procedure SaveRemoteRepository;
var var
CurrentMirrors : TFPMirrors; AvailableMirrors : TFPMirrors;
CurrentRepository : TFPRepository; AvailableRepository,
InstalledRepository : TFPRepository;
implementation implementation
@ -45,14 +48,14 @@ uses
var var
CurrentRemoteRepositoryURL : String; CurrentRemoteRepositoryURL : String;
procedure LoadLocalMirrors; procedure LoadLocalAvailableMirrors;
var var
S : String; S : String;
X : TFPXMLMirrorHandler; X : TFPXMLMirrorHandler;
begin begin
if assigned(CurrentMirrors) then if assigned(AvailableMirrors) then
CurrentMirrors.Free; AvailableMirrors.Free;
CurrentMirrors:=TFPMirrors.Create(TFPMirror); AvailableMirrors:=TFPMirrors.Create(TFPMirror);
// Repository // Repository
S:=GlobalOptions.LocalMirrorsFile; S:=GlobalOptions.LocalMirrorsFile;
@ -63,7 +66,7 @@ begin
X:=TFPXMLMirrorHandler.Create; X:=TFPXMLMirrorHandler.Create;
With X do With X do
try try
LoadFromXml(CurrentMirrors,S); LoadFromXml(AvailableMirrors,S);
finally finally
Free; Free;
end; end;
@ -86,22 +89,22 @@ var
begin begin
Result:=''; Result:='';
M:=nil; M:=nil;
if assigned(CurrentMirrors) then if assigned(AvailableMirrors) then
begin begin
// Create array for selection // Create array for selection
BucketCnt:=0; BucketCnt:=0;
for i:=0 to CurrentMirrors.Count-1 do for i:=0 to AvailableMirrors.Count-1 do
inc(BucketCnt,CurrentMirrors[i].Weight); inc(BucketCnt,AvailableMirrors[i].Weight);
// Select random entry // Select random entry
Bucket:=Random(BucketCnt); Bucket:=Random(BucketCnt);
M:=nil; M:=nil;
for i:=0 to CurrentMirrors.Count-1 do for i:=0 to AvailableMirrors.Count-1 do
begin begin
for j:=0 to CurrentMirrors[i].Weight-1 do for j:=0 to AvailableMirrors[i].Weight-1 do
begin begin
if Bucket=0 then if Bucket=0 then
begin begin
M:=CurrentMirrors[i]; M:=AvailableMirrors[i];
break; break;
end; end;
Dec(Bucket); Dec(Bucket);
@ -163,55 +166,11 @@ begin
end; end;
procedure LoadLocalRepository; function LoadManifestFromFile(const AManifestFN:string):TFPPackage;
var
S : String;
X : TFPXMLRepositoryHandler;
begin
if assigned(CurrentRepository) then
CurrentRepository.Free;
CurrentRepository:=TFPRepository.Create(Nil);
// Repository
S:=GlobalOptions.LocalPackagesFile;
Log(vlDebug,SLogLoadingPackagesFile,[S]);
if not FileExists(S) then
exit;
try
X:=TFPXMLRepositoryHandler.Create;
With X do
try
LoadFromXml(CurrentRepository,S);
finally
Free;
end;
except
on E : Exception do
begin
Log(vlError,E.Message);
Error(SErrCorruptPackagesFile,[S]);
end;
end;
end;
function LoadOrCreatePackage(const AName:string):TFPPackage;
begin
result:=CurrentRepository.FindPackage(AName);
if not assigned(result) then
begin
result:=CurrentRepository.AddPackage(AName);
result.IsLocalPackage:=true;
end;
end;
function LoadPackageManifest(const AManifestFN:string):TFPPackage;
var var
X : TFPXMLRepositoryHandler; X : TFPXMLRepositoryHandler;
i : integer;
DoAdd : Boolean;
NewP : TFPPackage;
NewPackages : TFPPackages; NewPackages : TFPPackages;
NewP,P : TFPPackage;
begin begin
result:=nil; result:=nil;
NewPackages:=TFPPackages.Create(TFPPackage); NewPackages:=TFPPackages.Create(TFPPackage);
@ -219,27 +178,19 @@ begin
try try
X.LoadFromXml(NewPackages,AManifestFN); X.LoadFromXml(NewPackages,AManifestFN);
// Update or Add packages to repository // Update or Add packages to repository
for i:=0 to NewPackages.Count-1 do if NewPackages.Count=1 then
begin begin
NewP:=NewPackages[i]; NewP:=NewPackages[0];
DoAdd:=True; // Prevent duplicate names
result:=CurrentRepository.FindPackage(NewP.Name); { P:=InstalledRepository.FindPackage(NewP.Name);
if assigned(result) then if not assigned(P) then
begin P:=InstalledRepository.AddPackage(NewP.Name); }
if NewP.Version.CompareVersion(result.Version)<0 then result:=TFPPackage.Create(nil);
begin
Writeln(Format('Ignoring package %s-%s (old %s)',[NewP.Name,NewP.Version.AsString,result.Version.AsString]));
DoAdd:=False;
end
else
Writeln(Format('Updating package %s-%s (old %s)',[NewP.Name,NewP.Version.AsString,result.Version.AsString]));
end
else
result:=CurrentRepository.PackageCollection.AddPackage(NewP.Name);
// Copy contents // Copy contents
if DoAdd then result.Assign(NewP);
result.Assign(NewP); end
end; else
Error(SErrManifestNoSinglePackage,[AManifestFN]);
finally finally
X.Free; X.Free;
NewPackages.Free; NewPackages.Free;
@ -262,12 +213,12 @@ begin
{$warning TODO Maybe check also CPU-OS} {$warning TODO Maybe check also CPU-OS}
// Read fpunits.conf // Read fpunits.conf
V:=L.Values['version']; V:=L.Values['version'];
APackage.InstalledVersion.AsString:=V; APackage.Version.AsString:=V;
V:=L.Values['checksum']; V:=L.Values['checksum'];
if V<>'' then if V<>'' then
APackage.InstalledChecksum:=StrToInt(V) APackage.Checksum:=StrToInt(V)
else else
APackage.InstalledChecksum:=$ffffffff; APackage.Checksum:=$ffffffff;
// Load dependencies // Load dependencies
V:=L.Values['depends']; V:=L.Values['depends'];
DepSL:=TStringList.Create; DepSL:=TStringList.Create;
@ -304,13 +255,16 @@ end;
procedure FindInstalledPackages(ACompilerOptions:TCompilerOptions;showdups:boolean=true); procedure FindInstalledPackages(ACompilerOptions:TCompilerOptions;showdups:boolean=true);
procedure LogDuplicatePackages(APackage:TFPPackage;const AFileName: String); function AddInstalledPackage(const AName,AFileName: String):TFPPackage;
begin begin
// Log packages found in multiple locations (local and global) ? result:=InstalledRepository.FindPackage(AName);
if not APackage.InstalledVersion.Empty then if not assigned(result) then
result:=InstalledRepository.AddPackage(AName)
else
begin begin
// Log packages found in multiple locations (local and global) ?
if showdups then if showdups then
Log(vlDebug,SDbgPackageMultipleLocations,[APackage.Name,ExtractFilePath(AFileName)]); Log(vlDebug,SDbgPackageMultipleLocations,[result.Name,ExtractFilePath(AFileName)]);
end; end;
end; end;
@ -323,7 +277,7 @@ procedure FindInstalledPackages(ACompilerOptions:TCompilerOptions;showdups:boole
Try Try
ReadIniFile(AFileName,L); ReadIniFile(AFileName,L);
V:=L.Values['version']; V:=L.Values['version'];
APackage.InstalledVersion.AsString:=V; APackage.Version.AsString:=V;
Finally Finally
L.Free; L.Free;
end; end;
@ -347,8 +301,7 @@ procedure FindInstalledPackages(ACompilerOptions:TCompilerOptions;showdups:boole
UF:=UD+UnitConfigFileName; UF:=UD+UnitConfigFileName;
if FileExistsLog(UF) then if FileExistsLog(UF) then
begin begin
P:=LoadOrCreatePackage(SR.Name); P:=AddInstalledPackage(SR.Name,UF);
LogDuplicatePackages(P,UF);
LoadUnitConfigFromFile(P,UF) LoadUnitConfigFromFile(P,UF)
end end
else else
@ -357,8 +310,7 @@ procedure FindInstalledPackages(ACompilerOptions:TCompilerOptions;showdups:boole
UF:=UD+'Package.fpc'; UF:=UD+'Package.fpc';
if FileExistsLog(UF) then if FileExistsLog(UF) then
begin begin
P:=LoadOrCreatePackage(SR.Name); P:=AddInstalledPackage(SR.Name,UF);
LogDuplicatePackages(P,UF);
LoadPackagefpcFromFile(P,UF); LoadPackagefpcFromFile(P,UF);
end; end;
end; end;
@ -368,7 +320,9 @@ procedure FindInstalledPackages(ACompilerOptions:TCompilerOptions;showdups:boole
end; end;
begin begin
CurrentRepository.ClearStatus; if assigned(InstalledRepository) then
InstalledRepository.Free;
InstalledRepository:=TFPRepository.Create(nil);
// First scan the global directory // First scan the global directory
// The local directory will overwrite the versions // The local directory will overwrite the versions
if ACompilerOptions.GlobalUnitDir<>'' then if ACompilerOptions.GlobalUnitDir<>'' then
@ -391,11 +345,11 @@ begin
if (CompilerOptions.CompilerOS in D.OSes) and if (CompilerOptions.CompilerOS in D.OSes) and
(CompilerOptions.CompilerCPU in D.CPUs) then (CompilerOptions.CompilerCPU in D.CPUs) then
begin begin
DepPackage:=CurrentRepository.FindPackage(D.PackageName); DepPackage:=InstalledRepository.FindPackage(D.PackageName);
// Don't stop on missing dependencies // Don't stop on missing dependencies
if assigned(DepPackage) then if assigned(DepPackage) then
begin begin
if (DepPackage.InstalledChecksum<>D.RequireChecksum) then if (DepPackage.Checksum<>D.RequireChecksum) then
begin begin
Log(vlInfo,SLogPackageChecksumChanged,[APackage.Name,D.PackageName]); Log(vlInfo,SLogPackageChecksumChanged,[APackage.Name,D.PackageName]);
result:=true; result:=true;
@ -415,15 +369,11 @@ var
P : TFPPackage; P : TFPPackage;
begin begin
SL.Clear; SL.Clear;
for i:=0 to CurrentRepository.PackageCount-1 do for i:=0 to InstalledRepository.PackageCount-1 do
begin begin
P:=CurrentRepository.Packages[i]; P:=InstalledRepository.Packages[i];
// Process only installed packages if PackageIsBroken(P) then
if not P.InstalledVersion.Empty then SL.Add(P.Name);
begin
if PackageIsBroken(P) then
SL.Add(P.Name);
end;
end; end;
Result:=(SL.Count>0); Result:=(SL.Count>0);
end; end;
@ -432,7 +382,8 @@ end;
procedure CheckFPMakeDependencies; procedure CheckFPMakeDependencies;
var var
i : Integer; i : Integer;
P : TFPPackage; P,AvailP : TFPPackage;
AvailVerStr : string;
ReqVer : TFPVersion; ReqVer : TFPVersion;
begin begin
// Reset availability // Reset availability
@ -445,13 +396,18 @@ begin
// Check for fpmkunit dependencies // Check for fpmkunit dependencies
for i:=1 to FPMKUnitDepCount do for i:=1 to FPMKUnitDepCount do
begin begin
P:=CurrentRepository.FindPackage(FPMKUnitDeps[i].package); P:=InstalledRepository.FindPackage(FPMKUnitDeps[i].package);
if P<>nil then if P<>nil then
begin begin
AvailP:=AvailableRepository.FindPackage(FPMKUnitDeps[i].package);
if P<>nil then
AvailVerStr:=AvailP.Version.AsString
else
AvailVerStr:='<not available>';
ReqVer:=TFPVersion.Create; ReqVer:=TFPVersion.Create;
ReqVer.AsString:=FPMKUnitDeps[i].ReqVer; ReqVer.AsString:=FPMKUnitDeps[i].ReqVer;
Log(vlDebug,SLogFPMKUnitDepVersion,[P.Name,ReqVer.AsString,P.InstalledVersion.AsString,P.Version.AsString]); Log(vlDebug,SLogFPMKUnitDepVersion,[P.Name,ReqVer.AsString,P.Version.AsString,AvailVerStr]);
if ReqVer.CompareVersion(P.InstalledVersion)<=0 then if ReqVer.CompareVersion(P.Version)<=0 then
FPMKUnitDepAvailable[i]:=true FPMKUnitDepAvailable[i]:=true
else else
Log(vlDebug,SLogFPMKUnitDepTooOld,[FPMKUnitDeps[i].package]); Log(vlDebug,SLogFPMKUnitDepTooOld,[FPMKUnitDeps[i].package]);
@ -462,7 +418,91 @@ begin
end; end;
procedure ListLocalRepository(all:boolean=false); {*****************************************************************************
Local Available Repository
*****************************************************************************}
procedure LoadLocalAvailableRepository;
var
S : String;
X : TFPXMLRepositoryHandler;
begin
if assigned(AvailableRepository) then
AvailableRepository.Free;
AvailableRepository:=TFPRepository.Create(Nil);
// Repository
S:=GlobalOptions.LocalPackagesFile;
Log(vlDebug,SLogLoadingPackagesFile,[S]);
if not FileExists(S) then
exit;
try
X:=TFPXMLRepositoryHandler.Create;
With X do
try
LoadFromXml(AvailableRepository,S);
finally
Free;
end;
except
on E : Exception do
begin
Log(vlError,E.Message);
Error(SErrCorruptPackagesFile,[S]);
end;
end;
end;
function PackageAvailableVersionStr(const AName:String):string;
var
P : TFPPackage;
begin
P:=InstalledRepository.FindPackage(AName);
if P<>nil then
result:=P.Version.AsString
else
result:='-';
end;
function PackageInstalledVersionStr(const AName:String):string;
var
P : TFPPackage;
begin
P:=InstalledRepository.FindPackage(AName);
if P<>nil then
result:=P.Version.AsString
else
result:='-';
end;
procedure ListAvailablePackages;
var
InstalledP,
AvailP : TFPPackage;
i : integer;
SL : TStringList;
begin
SL:=TStringList.Create;
SL.Sorted:=true;
for i:=0 to AvailableRepository.PackageCount-1 do
begin
AvailP:=AvailableRepository.Packages[i];
InstalledP:=InstalledRepository.FindPackage(AvailP.Name);
if not assigned(InstalledP) or
(AvailP.Version.CompareVersion(InstalledP.Version)>0) then
SL.Add(Format('%-20s %-12s %-12s',[AvailP.Name,PackageInstalledVersionStr(AvailP.Name),AvailP.Version.AsString]));
end;
Writeln(Format('%-20s %-12s %-12s',['Name','Installed','Available']));
for i:=0 to SL.Count-1 do
Writeln(SL[i]);
FreeAndNil(SL);
end;
procedure ListInstalledPackages;
var var
P : TFPPackage; P : TFPPackage;
i : integer; i : integer;
@ -470,11 +510,10 @@ var
begin begin
SL:=TStringList.Create; SL:=TStringList.Create;
SL.Sorted:=true; SL.Sorted:=true;
for i:=0 to CurrentRepository.PackageCount-1 do for i:=0 to InstalledRepository.PackageCount-1 do
begin begin
P:=CurrentRepository.Packages[i]; P:=InstalledRepository.Packages[i];
if all or (P.Version.CompareVersion(P.InstalledVersion)>0) then SL.Add(Format('%-20s %-12s %-12s',[P.Name,P.Version.AsString,PackageAvailableVersionStr(P.Name)]));
SL.Add(Format('%-20s %-12s %-12s',[P.Name,P.InstalledVersion.AsString,P.Version.AsString]));
end; end;
Writeln(Format('%-20s %-12s %-12s',['Name','Installed','Available'])); Writeln(Format('%-20s %-12s %-12s',['Name','Installed','Available']));
for i:=0 to SL.Count-1 do for i:=0 to SL.Count-1 do
@ -487,6 +526,7 @@ end;
Remote Repository Remote Repository
*****************************************************************************} *****************************************************************************}
procedure ListRemoteRepository; procedure ListRemoteRepository;
var var
P : TFPPackage; P : TFPPackage;
@ -495,9 +535,9 @@ var
begin begin
SL:=TStringList.Create; SL:=TStringList.Create;
SL.Sorted:=true; SL.Sorted:=true;
for i:=0 to CurrentRepository.PackageCount-1 do for i:=0 to InstalledRepository.PackageCount-1 do
begin begin
P:=CurrentRepository.Packages[i]; P:=InstalledRepository.Packages[i];
SL.Add(Format('%-20s %-12s %-20s',[P.Name,P.Version.AsString,P.FileName])); SL.Add(Format('%-20s %-12s %-20s',[P.Name,P.Version.AsString,P.FileName]));
end; end;
Writeln(Format('%-20s %-12s %-20s',['Name','Available','FileName'])); Writeln(Format('%-20s %-12s %-20s',['Name','Available','FileName']));
@ -509,14 +549,54 @@ end;
procedure RebuildRemoteRepository; procedure RebuildRemoteRepository;
procedure LoadPackageManifest(const AManifestFN:string);
var
X : TFPXMLRepositoryHandler;
i : integer;
DoAdd : Boolean;
P,NewP : TFPPackage;
NewPackages : TFPPackages;
begin
NewPackages:=TFPPackages.Create(TFPPackage);
X:=TFPXMLRepositoryHandler.Create;
try
X.LoadFromXml(NewPackages,AManifestFN);
// Update or Add packages to repository
for i:=0 to NewPackages.Count-1 do
begin
NewP:=NewPackages[i];
DoAdd:=True;
P:=InstalledRepository.FindPackage(NewP.Name);
if assigned(P) then
begin
if NewP.Version.CompareVersion(P.Version)<0 then
begin
Writeln(Format('Ignoring package %s-%s (old %s)',[NewP.Name,NewP.Version.AsString,P.Version.AsString]));
DoAdd:=False;
end
else
Writeln(Format('Updating package %s-%s (old %s)',[NewP.Name,NewP.Version.AsString,P.Version.AsString]));
end
else
P:=InstalledRepository.PackageCollection.AddPackage(NewP.Name);
// Copy contents
if DoAdd then
P.Assign(NewP);
end;
finally
X.Free;
NewPackages.Free;
end;
end;
var var
i : integer; i : integer;
ArchiveSL : TStringList; ArchiveSL : TStringList;
ManifestSL : TStringList; ManifestSL : TStringList;
begin begin
if assigned(CurrentRepository) then if assigned(InstalledRepository) then
CurrentRepository.Free; InstalledRepository.Free;
CurrentRepository:=TFPRepository.Create(Nil); InstalledRepository:=TFPRepository.Create(Nil);
try try
ManifestSL:=TStringList.Create; ManifestSL:=TStringList.Create;
ManifestSL.Add(ManifestFileName); ManifestSL.Add(ManifestFileName);
@ -564,7 +644,7 @@ begin
X:=TFPXMLRepositoryHandler.Create; X:=TFPXMLRepositoryHandler.Create;
With X do With X do
try try
SaveToXml(CurrentRepository,'packages.xml'); SaveToXml(InstalledRepository,'packages.xml');
finally finally
Free; Free;
end; end;