139 lines
3.2 KiB
Go
139 lines
3.2 KiB
Go
package cwhub
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"slices"
|
|
)
|
|
|
|
// purge removes the actual config file that was downloaded.
|
|
func (i *Item) purge() (bool, error) {
|
|
if !i.State.Downloaded {
|
|
i.hub.logger.Debugf("removing %s: not downloaded -- no need to remove", i.Name)
|
|
return false, nil
|
|
}
|
|
|
|
src, err := i.downloadPath()
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
if err := os.Remove(src); err != nil {
|
|
if os.IsNotExist(err) {
|
|
i.hub.logger.Debugf("%s doesn't exist, no need to remove", src)
|
|
return false, nil
|
|
}
|
|
|
|
return false, fmt.Errorf("while removing file: %w", err)
|
|
}
|
|
|
|
i.State.Downloaded = false
|
|
i.hub.logger.Infof("Removed source file [%s]: %s", i.Name, src)
|
|
|
|
return true, nil
|
|
}
|
|
|
|
// disable removes the install link, and optionally the downloaded content.
|
|
func (i *Item) disable(purge bool, force bool) (bool, error) {
|
|
didRemove := true
|
|
|
|
err := i.removeInstallLink()
|
|
if os.IsNotExist(err) {
|
|
if !purge && !force {
|
|
link, _ := i.installPath()
|
|
return false, fmt.Errorf("link %s does not exist (override with --force or --purge)", link)
|
|
}
|
|
|
|
didRemove = false
|
|
} else if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
i.State.Installed = false
|
|
didPurge := false
|
|
|
|
if purge {
|
|
if didPurge, err = i.purge(); err != nil {
|
|
return didRemove, err
|
|
}
|
|
}
|
|
|
|
ret := didRemove || didPurge
|
|
|
|
return ret, nil
|
|
}
|
|
|
|
// Remove disables the item, optionally removing the downloaded content.
|
|
func (i *Item) Remove(purge bool, force bool) (bool, error) {
|
|
if i.State.IsLocal() {
|
|
i.hub.logger.Warningf("%s is a local item, please delete manually", i.Name)
|
|
return false, nil
|
|
}
|
|
|
|
if i.State.Tainted && !force {
|
|
return false, fmt.Errorf("%s is tainted, use '--force' to remove", i.Name)
|
|
}
|
|
|
|
if !i.State.Installed && !purge {
|
|
i.hub.logger.Infof("removing %s: not installed -- no need to remove", i.Name)
|
|
return false, nil
|
|
}
|
|
|
|
removed := false
|
|
|
|
descendants, err := i.descendants()
|
|
if err != nil {
|
|
return false, err
|
|
}
|
|
|
|
ancestors := i.Ancestors()
|
|
|
|
for _, sub := range i.SubItems() {
|
|
if !sub.State.Installed {
|
|
continue
|
|
}
|
|
|
|
// if the sub depends on a collection that is not a direct or indirect dependency
|
|
// of the current item, it is not removed
|
|
for _, subParent := range sub.Ancestors() {
|
|
if !purge && !subParent.State.Installed {
|
|
continue
|
|
}
|
|
|
|
// the ancestor that would block the removal of the sub item is also an ancestor
|
|
// of the item we are removing, so we don't want false warnings
|
|
// (e.g. crowdsecurity/sshd-logs was not removed because it also belongs to crowdsecurity/linux,
|
|
// while we are removing crowdsecurity/sshd)
|
|
if slices.Contains(ancestors, subParent) {
|
|
continue
|
|
}
|
|
|
|
// the sub-item belongs to the item we are removing, but we already knew that
|
|
if subParent == i {
|
|
continue
|
|
}
|
|
|
|
if !slices.Contains(descendants, subParent) {
|
|
i.hub.logger.Infof("%s was not removed because it also belongs to %s", sub.Name, subParent.Name)
|
|
continue
|
|
}
|
|
}
|
|
|
|
subRemoved, err := sub.Remove(purge, force)
|
|
if err != nil {
|
|
return false, fmt.Errorf("unable to disable %s: %w", i.Name, err)
|
|
}
|
|
|
|
removed = removed || subRemoved
|
|
}
|
|
|
|
didDisable, err := i.disable(purge, force)
|
|
if err != nil {
|
|
return false, fmt.Errorf("while removing %s: %w", i.Name, err)
|
|
}
|
|
|
|
removed = removed || didDisable
|
|
|
|
return removed, nil
|
|
}
|