Rename BPM Repositories to BPM Databases

src/bpmlib/config.go

@@ -6,10 +6,10 @@ import (
 )
 
 type BPMConfigStruct struct {
-	IgnorePackages         []string      `yaml:"ignore_packages"`
-	PrivilegeEscalatorCmd  string        `yaml:"privilege_escalator_cmd"`
-	CompilationEnvironment []string      `yaml:"compilation_env"`
-	Repositories           []*Repository `yaml:"repositories"`
+	IgnorePackages         []string       `yaml:"ignore_packages"`
+	PrivilegeEscalatorCmd  string         `yaml:"privilege_escalator_cmd"`
+	CompilationEnvironment []string       `yaml:"compilation_env"`
+	Databases              []*BPMDatabase `yaml:"databases"`
 }
 
 var BPMConfig BPMConfigStruct
@@ -30,9 +30,9 @@ func ReadConfig() (err error) {
 		return err
 	}
 
-	for i := len(BPMConfig.Repositories) - 1; i >= 0; i-- {
-		if BPMConfig.Repositories[i].Disabled != nil && *BPMConfig.Repositories[i].Disabled {
-			BPMConfig.Repositories = append(BPMConfig.Repositories[:i], BPMConfig.Repositories[i+1:]...)
+	for i := len(BPMConfig.Databases) - 1; i >= 0; i-- {
+		if BPMConfig.Databases[i].Disabled != nil && *BPMConfig.Databases[i].Disabled {
+			BPMConfig.Databases = append(BPMConfig.Databases[:i], BPMConfig.Databases[i+1:]...)
 		}
 	}
 

src/bpmlib/databases.go

@@ -12,41 +12,41 @@ import (
 	"strings"
 )
 
-type Repository struct {
+type BPMDatabase struct {
 	Name            string `yaml:"name"`
 	Source          string `yaml:"source"`
 	Disabled        *bool  `yaml:"disabled"`
-	Entries         map[string]*RepositoryEntry
+	Entries         map[string]*BPMDatabaseEntry
 	VirtualPackages map[string][]string
 }
 
-type RepositoryEntry struct {
+type BPMDatabaseEntry struct {
 	Info          *PackageInfo `yaml:"info"`
 	Download      string       `yaml:"download"`
 	DownloadSize  uint64       `yaml:"download_size"`
 	InstalledSize uint64       `yaml:"installed_size"`
-	Repository    *Repository
+	Database      *BPMDatabase
 }
 
-func (repo *Repository) ContainsPackage(pkg string) bool {
-	_, ok := repo.Entries[pkg]
+func (db *BPMDatabase) ContainsPackage(pkg string) bool {
+	_, ok := db.Entries[pkg]
 	return ok
 }
 
-func (repo *Repository) ReadLocalDatabase() error {
-	repoFile := "/var/lib/bpm/repositories/" + repo.Name + ".bpmdb"
-	if _, err := os.Stat(repoFile); err != nil {
+func (db *BPMDatabase) ReadLocalDatabase() error {
+	dbFile := "/var/lib/bpm/databases/" + db.Name + ".bpmdb"
+	if _, err := os.Stat(dbFile); err != nil {
 		return nil
 	}
 
-	bytes, err := os.ReadFile(repoFile)
+	bytes, err := os.ReadFile(dbFile)
 	if err != nil {
 		return err
 	}
 
 	data := string(bytes)
 	for _, b := range strings.Split(data, "---") {
-		entry := RepositoryEntry{
+		entry := BPMDatabaseEntry{
 			Info: &PackageInfo{
 				Name:            "",
 				Description:     "",
@@ -66,14 +66,14 @@ func (repo *Repository) ReadLocalDatabase() error {
 			Download:      "",
 			DownloadSize:  0,
 			InstalledSize: 0,
-			Repository:    repo,
+			Database:      db,
 		}
 		err := yaml.Unmarshal([]byte(b), &entry)
 		if err != nil {
 			return err
 		}
 
-		// Create repository entries
+		// Create database entries
 		if entry.Info.IsSplitPackage() {
 			for _, splitPkg := range entry.Info.SplitPackages {
 				// Turn split package into json data
@@ -100,26 +100,26 @@ func (repo *Repository) ReadLocalDatabase() error {
 				splitPkgClone.Url = entry.Info.Url
 
 				// Create entry for split package
-				repo.Entries[splitPkg.Name] = &RepositoryEntry{
+				db.Entries[splitPkg.Name] = &BPMDatabaseEntry{
 					Info:          &splitPkgClone,
 					Download:      entry.Download,
 					DownloadSize:  entry.DownloadSize,
 					InstalledSize: 0,
-					Repository:    repo,
+					Database:      db,
 				}
 
-				// Add virtual packages to repository
+				// Add virtual packages to database
 				for _, p := range splitPkg.Provides {
-					repo.VirtualPackages[p] = append(repo.VirtualPackages[p], splitPkg.Name)
+					db.VirtualPackages[p] = append(db.VirtualPackages[p], splitPkg.Name)
 				}
 			}
 		} else {
 			// Create entry for package
-			repo.Entries[entry.Info.Name] = &entry
+			db.Entries[entry.Info.Name] = &entry
 
-			// Add virtual packages to repository
+			// Add virtual packages to database
 			for _, p := range entry.Info.Provides {
-				repo.VirtualPackages[p] = append(repo.VirtualPackages[p], entry.Info.Name)
+				db.VirtualPackages[p] = append(db.VirtualPackages[p], entry.Info.Name)
 			}
 		}
 
@@ -128,11 +128,11 @@ func (repo *Repository) ReadLocalDatabase() error {
 	return nil
 }
 
-func (repo *Repository) SyncLocalDatabase() error {
-	repoFile := "/var/lib/bpm/repositories/" + repo.Name + ".bpmdb"
+func (db *BPMDatabase) SyncLocalDatabaseFile() error {
+	dbFile := "/var/lib/bpm/databases/" + db.Name + ".bpmdb"
 
 	// Get URL to database
-	u, err := url.JoinPath(repo.Source, "database.bpmdb")
+	u, err := url.JoinPath(db.Source, "database.bpmdb")
 	if err != nil {
 		return err
 	}
@@ -147,20 +147,20 @@ func (repo *Repository) SyncLocalDatabase() error {
 	// Load data into byte buffer
 	buffer, err := io.ReadAll(resp.Body)
 
-	// Unmarshal data to ensure it is a valid BPM repository
-	err = yaml.Unmarshal(buffer, &Repository{})
+	// Unmarshal data to ensure it is a valid BPM database
+	err = yaml.Unmarshal(buffer, &BPMDatabase{})
 	if err != nil {
-		return fmt.Errorf("could not decode repository: %s", err)
+		return fmt.Errorf("could not decode database: %s", err)
 	}
 
-	// Create parent directories to repository file
-	err = os.MkdirAll(path.Dir(repoFile), 0755)
+	// Create parent directories to database file
+	err = os.MkdirAll(path.Dir(dbFile), 0755)
 	if err != nil {
 		return err
 	}
 
-	// Create file and save repository data
-	out, err := os.Create(repoFile)
+	// Create file and save database data
+	out, err := os.Create(dbFile)
 	if err != nil {
 		return err
 	}
@@ -171,14 +171,14 @@ func (repo *Repository) SyncLocalDatabase() error {
 	return nil
 }
 
-func ReadLocalDatabases() (err error) {
-	for _, repo := range BPMConfig.Repositories {
+func ReadLocalDatabaseFiles() (err error) {
+	for _, db := range BPMConfig.Databases {
 		// Initialize struct values
-		repo.Entries = make(map[string]*RepositoryEntry)
-		repo.VirtualPackages = make(map[string][]string)
+		db.Entries = make(map[string]*BPMDatabaseEntry)
+		db.VirtualPackages = make(map[string][]string)
 
 		// Read database
-		err = repo.ReadLocalDatabase()
+		err = db.ReadLocalDatabase()
 		if err != nil {
 			return err
 		}
@@ -187,47 +187,47 @@ func ReadLocalDatabases() (err error) {
 	return nil
 }
 
-func GetRepository(name string) *Repository {
-	for _, repo := range BPMConfig.Repositories {
-		if repo.Name == name {
-			return repo
+func GetDatabase(name string) *BPMDatabase {
+	for _, db := range BPMConfig.Databases {
+		if db.Name == name {
+			return db
 		}
 	}
 	return nil
 }
 
-func GetRepositoryEntry(str string) (*RepositoryEntry, *Repository, error) {
+func GetDatabaseEntry(str string) (*BPMDatabaseEntry, *BPMDatabase, error) {
 	split := strings.Split(str, "/")
 	if len(split) == 1 {
 		pkgName := strings.TrimSpace(split[0])
 		if pkgName == "" {
-			return nil, nil, errors.New("could not find repository entry for this package")
+			return nil, nil, errors.New("could not find database entry for this package")
 		}
-		for _, repo := range BPMConfig.Repositories {
-			if repo.ContainsPackage(pkgName) {
-				return repo.Entries[pkgName], repo, nil
+		for _, db := range BPMConfig.Databases {
+			if db.ContainsPackage(pkgName) {
+				return db.Entries[pkgName], db, nil
 			}
 		}
-		return nil, nil, errors.New("could not find repository entry for this package")
+		return nil, nil, errors.New("could not find database entry for this package")
 	} else if len(split) == 2 {
-		repoName := strings.TrimSpace(split[0])
+		dbName := strings.TrimSpace(split[0])
 		pkgName := strings.TrimSpace(split[1])
-		if repoName == "" || pkgName == "" {
-			return nil, nil, errors.New("could not find repository entry for this package")
+		if dbName == "" || pkgName == "" {
+			return nil, nil, errors.New("could not find database entry for this package")
 		}
-		repo := GetRepository(repoName)
-		if repo == nil || !repo.ContainsPackage(pkgName) {
-			return nil, nil, errors.New("could not find repository entry for this package")
+		db := GetDatabase(dbName)
+		if db == nil || !db.ContainsPackage(pkgName) {
+			return nil, nil, errors.New("could not find database entry for this package")
 		}
-		return repo.Entries[pkgName], repo, nil
+		return db.Entries[pkgName], db, nil
 	} else {
-		return nil, nil, errors.New("could not find repository entry for this package")
+		return nil, nil, errors.New("could not find database entry for this package")
 	}
 }
 
-func FindReplacement(pkg string) *RepositoryEntry {
-	for _, repo := range BPMConfig.Repositories {
-		for _, entry := range repo.Entries {
+func FindReplacement(pkg string) *BPMDatabaseEntry {
+	for _, db := range BPMConfig.Databases {
+		for _, entry := range db.Entries {
 			for _, replaced := range entry.Info.Replaces {
 				if replaced == pkg {
 					return entry
@@ -239,11 +239,11 @@ func FindReplacement(pkg string) *RepositoryEntry {
 	return nil
 }
 
-func ResolveVirtualPackage(vpkg string) *RepositoryEntry {
-	for _, repo := range BPMConfig.Repositories {
-		if v, ok := repo.VirtualPackages[vpkg]; ok {
+func ResolveVirtualPackage(vpkg string) *BPMDatabaseEntry {
+	for _, db := range BPMConfig.Databases {
+		if v, ok := db.VirtualPackages[vpkg]; ok {
 			for _, pkg := range v {
-				return repo.Entries[pkg]
+				return db.Entries[pkg]
 			}
 		}
 	}
@@ -251,12 +251,12 @@ func ResolveVirtualPackage(vpkg string) *RepositoryEntry {
 	return nil
 }
 
-func (repo *Repository) FetchPackage(pkg string) (string, error) {
-	if !repo.ContainsPackage(pkg) {
+func (db *BPMDatabase) FetchPackage(pkg string) (string, error) {
+	if !db.ContainsPackage(pkg) {
 		return "", errors.New("could not fetch package '" + pkg + "'")
 	}
-	entry := repo.Entries[pkg]
-	URL, err := url.JoinPath(repo.Source, entry.Download)
+	entry := db.Entries[pkg]
+	URL, err := url.JoinPath(db.Source, entry.Download)
 	if err != nil {
 		return "", err
 	}

src/bpmlib/dependencies.go

@@ -94,8 +94,8 @@ func resolvePackageDependenciesFromDatabase(resolved, unresolved *[]string, pkgI
 				continue
 			}
 			var err error
-			var entry *RepositoryEntry
-			entry, _, err = GetRepositoryEntry(depend)
+			var entry *BPMDatabaseEntry
+			entry, _, err = GetDatabaseEntry(depend)
 			if err != nil {
 				if entry = ResolveVirtualPackage(depend); entry == nil {
 					if !slices.Contains(*unresolved, depend) {

src/bpmlib/errors.go

@@ -10,7 +10,7 @@ type PackageNotFoundErr struct {
 }
 
 func (e PackageNotFoundErr) Error() string {
-	return "The following packages were not found in any repositories: " + strings.Join(e.packages, ", ")
+	return "The following packages were not found in any databases: " + strings.Join(e.packages, ", ")
 }
 
 type DependencyNotFoundErr struct {
@@ -18,7 +18,7 @@ type DependencyNotFoundErr struct {
 }
 
 func (e DependencyNotFoundErr) Error() string {
-	return "The following dependencies were not found in any repositories: " + strings.Join(e.dependencies, ", ")
+	return "The following dependencies were not found in any databases: " + strings.Join(e.dependencies, ", ")
 }
 
 type PackageConflictErr struct {

src/bpmlib/general.go

@@ -17,7 +17,7 @@ const (
 	ReinstallMethodAll       ReinstallMethod = iota
 )
 
-// InstallPackages installs the specified packages into the given root directory by fetching them from repositories or directly from local bpm archives
+// InstallPackages installs the specified packages into the given root directory by fetching them from databases or directly from local bpm archives
 func InstallPackages(rootDir string, installationReason InstallationReason, reinstallMethod ReinstallMethod, installOptionalDependencies, forceInstallation, verbose bool, packages ...string) (operation *BPMOperation, err error) {
 	// Setup operation struct
 	operation = &BPMOperation{
@@ -64,12 +64,12 @@ func InstallPackages(rootDir string, installationReason InstallationReason, rein
 				BpmPackage:   bpmpkg,
 			})
 		} else {
-			var entry *RepositoryEntry
+			var entry *BPMDatabaseEntry
 
-			if e, _, err := GetRepositoryEntry(pkg); err == nil {
+			if e, _, err := GetDatabaseEntry(pkg); err == nil {
 				entry = e
 			} else if isVirtual, p := IsVirtualPackage(pkg, rootDir); isVirtual {
-				entry, _, err = GetRepositoryEntry(p)
+				entry, _, err = GetDatabaseEntry(p)
 				if err != nil {
 					pkgsNotFound = append(pkgsNotFound, pkg)
 					continue
@@ -85,8 +85,8 @@ func InstallPackages(rootDir string, installationReason InstallationReason, rein
 			}
 
 			operation.AppendAction(&FetchPackageAction{
-				IsDependency:    false,
-				RepositoryEntry: entry,
+				IsDependency:  false,
+				DatabaseEntry: entry,
 			})
 		}
 	}
@@ -272,7 +272,7 @@ func CleanupCache(rootDir string, cleanupCompilationFiles, cleanupCompiledPackag
 
 // UpdatePackages fetches the newest versions of all installed packages from
 func UpdatePackages(rootDir string, syncDatabase bool, installOptionalDependencies, forceInstallation, verbose bool) (operation *BPMOperation, err error) {
-	// Sync repositories
+	// Sync databases
 	if syncDatabase {
 		err := SyncDatabase(verbose)
 		if err != nil {
@@ -287,7 +287,7 @@ func UpdatePackages(rootDir string, syncDatabase bool, installOptionalDependenci
 		if err != nil {
 			return nil, fmt.Errorf("could not read BPM config: %s", err)
 		}
-		err = ReadLocalDatabases()
+		err = ReadLocalDatabaseFiles()
 		if err != nil {
 			return nil, fmt.Errorf("could not read local databases: %s", err)
 		}
@@ -313,11 +313,11 @@ func UpdatePackages(rootDir string, syncDatabase bool, installOptionalDependenci
 		if slices.Contains(BPMConfig.IgnorePackages, pkg) {
 			continue
 		}
-		var entry *RepositoryEntry
+		var entry *BPMDatabaseEntry
 		// Check if installed package can be replaced and install that instead
 		if e := FindReplacement(pkg); e != nil {
 			entry = e
-		} else if entry, _, err = GetRepositoryEntry(pkg); err != nil {
+		} else if entry, _, err = GetDatabaseEntry(pkg); err != nil {
 			continue
 		}
 
@@ -328,8 +328,8 @@ func UpdatePackages(rootDir string, syncDatabase bool, installOptionalDependenci
 			comparison := ComparePackageVersions(*entry.Info, *installedInfo)
 			if comparison > 0 {
 				operation.AppendAction(&FetchPackageAction{
-					IsDependency:    false,
-					RepositoryEntry: entry,
+					IsDependency:  false,
+					DatabaseEntry: entry,
 				})
 			}
 		}
@@ -355,12 +355,12 @@ func UpdatePackages(rootDir string, syncDatabase bool, installOptionalDependenci
 
 // SyncDatabase syncs all databases declared in /etc/bpm.conf
 func SyncDatabase(verbose bool) (err error) {
-	for _, repo := range BPMConfig.Repositories {
+	for _, db := range BPMConfig.Databases {
 		if verbose {
-			fmt.Printf("Fetching package database for repository (%s)...\n", repo.Name)
+			fmt.Printf("Fetching package database file for database (%s)...\n", db.Name)
 		}
 
-		err := repo.SyncLocalDatabase()
+		err := db.SyncLocalDatabaseFile()
 		if err != nil {
 			return err
 		}

src/bpmlib/operations.go

@@ -26,7 +26,7 @@ func (operation *BPMOperation) ActionsContainPackage(pkg string) bool {
 				return true
 			}
 		} else if action.GetActionType() == "fetch" {
-			if action.(*FetchPackageAction).RepositoryEntry.Info.Name == pkg {
+			if action.(*FetchPackageAction).DatabaseEntry.Info.Name == pkg {
 				return true
 			}
 		} else if action.GetActionType() == "remove" {
@@ -58,7 +58,7 @@ func (operation *BPMOperation) InsertActionAt(index int, action OperationAction)
 			operation.Changes[pkgInfo.Name] = "upgrade"
 		}
 	} else if action.GetActionType() == "fetch" {
-		pkgInfo := action.(*FetchPackageAction).RepositoryEntry.Info
+		pkgInfo := action.(*FetchPackageAction).DatabaseEntry.Info
 		if !IsPackageInstalled(pkgInfo.Name, operation.RootDir) {
 			operation.Changes[pkgInfo.Name] = "install"
 		} else {
@@ -77,7 +77,7 @@ func (operation *BPMOperation) RemoveAction(pkg, actionType string) {
 		if a.GetActionType() == "install" {
 			return a.(*InstallPackageAction).BpmPackage.PkgInfo.Name == pkg
 		} else if a.GetActionType() == "fetch" {
-			return a.(*FetchPackageAction).RepositoryEntry.Info.Name == pkg
+			return a.(*FetchPackageAction).DatabaseEntry.Info.Name == pkg
 		} else if a.GetActionType() == "remove" {
 			return a.(*RemovePackageAction).BpmPackage.PkgInfo.Name == pkg
 		}
@@ -89,7 +89,7 @@ func (operation *BPMOperation) GetTotalDownloadSize() uint64 {
 	var ret uint64 = 0
 	for _, action := range operation.Actions {
 		if action.GetActionType() == "fetch" {
-			ret += action.(*FetchPackageAction).RepositoryEntry.DownloadSize
+			ret += action.(*FetchPackageAction).DatabaseEntry.DownloadSize
 		}
 	}
 	return ret
@@ -101,7 +101,7 @@ func (operation *BPMOperation) GetTotalInstalledSize() uint64 {
 		if action.GetActionType() == "install" {
 			ret += action.(*InstallPackageAction).BpmPackage.GetInstalledSize()
 		} else if action.GetActionType() == "fetch" {
-			ret += action.(*FetchPackageAction).RepositoryEntry.InstalledSize
+			ret += action.(*FetchPackageAction).DatabaseEntry.InstalledSize
 		}
 	}
 	return ret
@@ -116,7 +116,7 @@ func (operation *BPMOperation) GetFinalActionSize(rootDir string) int64 {
 				ret -= int64(GetPackage(action.(*InstallPackageAction).BpmPackage.PkgInfo.Name, rootDir).GetInstalledSize())
 			}
 		} else if action.GetActionType() == "fetch" {
-			ret += int64(action.(*FetchPackageAction).RepositoryEntry.InstalledSize)
+			ret += int64(action.(*FetchPackageAction).DatabaseEntry.InstalledSize)
 		} else if action.GetActionType() == "remove" {
 			ret -= int64(action.(*RemovePackageAction).BpmPackage.GetInstalledSize())
 		}
@@ -133,7 +133,7 @@ func (operation *BPMOperation) ResolveDependencies(reinstallDependencies, instal
 			pkgInfo = action.BpmPackage.PkgInfo
 		} else if value.GetActionType() == "fetch" {
 			action := value.(*FetchPackageAction)
-			pkgInfo = action.RepositoryEntry.Info
+			pkgInfo = action.DatabaseEntry.Info
 		} else {
 			pos++
 			continue
@@ -148,13 +148,13 @@ func (operation *BPMOperation) ResolveDependencies(reinstallDependencies, instal
 				if !reinstallDependencies && IsPackageInstalled(depend, operation.RootDir) {
 					continue
 				}
-				entry, _, err := GetRepositoryEntry(depend)
+				entry, _, err := GetDatabaseEntry(depend)
 				if err != nil {
-					return errors.New("could not get repository entry for package (" + depend + ")")
+					return errors.New("could not get database entry for package (" + depend + ")")
 				}
 				operation.InsertActionAt(pos, &FetchPackageAction{
-					IsDependency:    true,
-					RepositoryEntry: entry,
+					IsDependency:  true,
+					DatabaseEntry: entry,
 				})
 				pos++
 			}
@@ -263,7 +263,7 @@ func (operation *BPMOperation) ReplaceObsoletePackages() {
 
 		} else if value.GetActionType() == "fetch" {
 			action := value.(*FetchPackageAction)
-			pkgInfo = action.RepositoryEntry.Info
+			pkgInfo = action.DatabaseEntry.Info
 		} else {
 			continue
 		}
@@ -301,7 +301,7 @@ func (operation *BPMOperation) CheckForConflicts() (map[string][]string, error)
 			allPackages = append(allPackages, pkgInfo)
 		} else if value.GetActionType() == "fetch" {
 			action := value.(*FetchPackageAction)
-			pkgInfo := action.RepositoryEntry.Info
+			pkgInfo := action.DatabaseEntry.Info
 			allPackages = append(allPackages, pkgInfo)
 		} else if value.GetActionType() == "remove" {
 			action := value.(*RemovePackageAction)
@@ -342,7 +342,7 @@ func (operation *BPMOperation) ShowOperationSummary() {
 				pkgInfo = pkgInfo.GetSplitPackageInfo(value.(*InstallPackageAction).SplitPackageToInstall)
 			}
 		} else if value.GetActionType() == "fetch" {
-			pkgInfo = value.(*FetchPackageAction).RepositoryEntry.Info
+			pkgInfo = value.(*FetchPackageAction).DatabaseEntry.Info
 		} else {
 			pkgInfo = value.(*RemovePackageAction).BpmPackage.PkgInfo
 			fmt.Printf("%s: %s (Remove)\n", pkgInfo.Name, pkgInfo.GetFullVersion())
@@ -414,11 +414,11 @@ func (operation *BPMOperation) RunHooks(verbose bool) error {
 }
 
 func (operation *BPMOperation) Execute(verbose, force bool) (err error) {
-	// Fetch packages from repositories
+	// Fetch packages from databases
 	if slices.ContainsFunc(operation.Actions, func(action OperationAction) bool {
 		return action.GetActionType() == "fetch"
 	}) {
-		fmt.Println("Fetching packages from available repositories...")
+		fmt.Println("Fetching packages from available databases...")
 
 		// Create map for fetched packages
 		fetchedPackages := make(map[string]string)
@@ -428,16 +428,16 @@ func (operation *BPMOperation) Execute(verbose, force bool) (err error) {
 				continue
 			}
 
-			// Get repository entry
-			entry := action.(*FetchPackageAction).RepositoryEntry
+			// Get database entry
+			entry := action.(*FetchPackageAction).DatabaseEntry
 
 			// Create bpmpkg variable
 			var bpmpkg *BPMPackage
 
 			// Check if package has already been fetched from download link
 			if _, ok := fetchedPackages[entry.Download]; !ok {
-				// Fetch package from repository
-				fetchedPackage, err := entry.Repository.FetchPackage(entry.Info.Name)
+				// Fetch package from database
+				fetchedPackage, err := entry.Database.FetchPackage(entry.Info.Name)
 				if err != nil {
 					return errors.New(fmt.Sprintf("could not fetch package (%s): %s\n", entry.Info.Name, err))
 				}
@@ -596,8 +596,8 @@ func (action *InstallPackageAction) GetActionType() string {
 }
 
 type FetchPackageAction struct {
-	IsDependency    bool
-	RepositoryEntry *RepositoryEntry
+	IsDependency  bool
+	DatabaseEntry *BPMDatabaseEntry
 }
 
 func (action *FetchPackageAction) GetActionType() string {