github.com/hwaf/hwaf@v0.0.0-20140814122253-5465f73b20f1/cmd_pkg_rm.go (about)

     1  package main
     2  
     3  import (
     4  	"fmt"
     5  	"os"
     6  	"path/filepath"
     7  	"strings"
     8  
     9  	"github.com/gonuts/commander"
    10  	"github.com/gonuts/flag"
    11  	//gocfg "github.com/gonuts/config"
    12  )
    13  
    14  func hwaf_make_cmd_pkg_rm() *commander.Command {
    15  	cmd := &commander.Command{
    16  		Run:       hwaf_run_cmd_pkg_rm,
    17  		UsageLine: "rm [options] <local-pkg-name> [<pkg2> [...]]",
    18  		Short:     "remove a package from the current workarea",
    19  		Long: `
    20  rm removes a package from the current workarea.
    21  
    22  ex:
    23   $ hwaf pkg rm ./src/foo/pkg
    24   $ hwaf pkg rm Control/AthenaKernel
    25   $ hwaf pkg rm Control/AthenaKernel Control/AthenaServices
    26   $ hwaf pkg rm -f Control/AthenaKernel
    27  `,
    28  		Flag: *flag.NewFlagSet("hwaf-pkg-rm", flag.ExitOnError),
    29  	}
    30  	cmd.Flag.Bool("v", false, "enable verbose output")
    31  	cmd.Flag.Bool("f", false, "force removing the package (from disk and from internal db)")
    32  
    33  	return cmd
    34  }
    35  
    36  func hwaf_run_cmd_pkg_rm(cmd *commander.Command, args []string) error {
    37  	var err error
    38  	n := "hwaf-pkg-" + cmd.Name()
    39  	switch len(args) {
    40  	case 0:
    41  		return fmt.Errorf("%s: you need to give (at least) one package name to remove", n)
    42  	}
    43  
    44  	verbose := cmd.Flag.Lookup("v").Value.Get().(bool)
    45  	force := cmd.Flag.Lookup("f").Value.Get().(bool)
    46  
    47  	cfg, err := g_ctx.LocalCfg()
    48  	if err != nil {
    49  		return err
    50  	}
    51  
    52  	srcdir := "src"
    53  	if cfg.HasOption("hwaf-cfg", "cmtpkgs") {
    54  		srcdir, err = cfg.String("hwaf-cfg", "cmtpkgs")
    55  		if err != nil {
    56  			return err
    57  		}
    58  	}
    59  
    60  	do_rm := func(pkgname string) error {
    61  		var err error
    62  
    63  		pkgname = os.ExpandEnv(pkgname)
    64  		pkgname = filepath.Clean(pkgname)
    65  		if verbose {
    66  			fmt.Printf("%s: remove package [%s]...\n", n, pkgname)
    67  		}
    68  
    69  		pkg := pkgname
    70  		if !g_ctx.PkgDb.HasPkg(pkg) {
    71  			pkg = filepath.Join(srcdir, pkgname)
    72  		}
    73  		if !g_ctx.PkgDb.HasPkg(pkg) {
    74  			return fmt.Errorf("%s: no such package [%s] in db", n, pkg)
    75  		}
    76  
    77  		// people may have already removed it via a simple 'rm -rf foo'...
    78  		if !path_exists(pkg) && !force {
    79  			err = fmt.Errorf(
    80  				`%s: no such package [%s]
    81  %s: did you remove it by hand ? (re-try with 'hwaf pkg rm -f %s')`,
    82  				n, pkgname,
    83  				n, pkgname,
    84  			)
    85  			return err
    86  		}
    87  
    88  		vcspkg, err := g_ctx.PkgDb.GetPkg(pkg)
    89  		if err != nil {
    90  			return err
    91  		}
    92  
    93  		switch vcspkg.Type {
    94  
    95  		case "svn", "git":
    96  			if path_exists(vcspkg.Path) {
    97  				err = os.RemoveAll(vcspkg.Path)
    98  				if err != nil {
    99  					return err
   100  				}
   101  				path := vcspkg.Path
   102  				// clean-up dir if empty...
   103  				for {
   104  					path = filepath.Dir(path)
   105  					if path == srcdir {
   106  						break
   107  					}
   108  					content, err := filepath.Glob(filepath.Join(path, "*"))
   109  					if err != nil {
   110  						return err
   111  					}
   112  					if len(content) > 0 {
   113  						break
   114  					}
   115  					err = os.RemoveAll(path)
   116  					if err != nil {
   117  						return err
   118  					}
   119  				}
   120  			}
   121  
   122  		case "local":
   123  			if path_exists(vcspkg.Path) {
   124  				err = os.RemoveAll(vcspkg.Path)
   125  				if err != nil {
   126  					return err
   127  				}
   128  				path := vcspkg.Path
   129  				// clean-up dir if empty...
   130  				for {
   131  					path = filepath.Dir(path)
   132  					if path == srcdir {
   133  						break
   134  					}
   135  					content, err := filepath.Glob(filepath.Join(path, "*"))
   136  					if err != nil {
   137  						return err
   138  					}
   139  					if len(content) > 0 {
   140  						break
   141  					}
   142  					err = os.RemoveAll(path)
   143  					if err != nil {
   144  						return err
   145  					}
   146  				}
   147  			}
   148  
   149  		default:
   150  			return fmt.Errorf("%s: VCS of type [%s] is not handled", n, vcspkg.Type)
   151  		}
   152  
   153  		err = g_ctx.PkgDb.Remove(pkg)
   154  		if err != nil {
   155  			if !force {
   156  				return err
   157  			}
   158  		}
   159  
   160  		if verbose {
   161  			fmt.Printf("%s: remove package [%s]... [ok]\n", n, pkgname)
   162  		}
   163  		return nil
   164  	}
   165  
   166  	errs := []error{}
   167  	for _, pkgname := range args {
   168  		err := do_rm(pkgname)
   169  		if err != nil {
   170  			errs = append(errs, err)
   171  		}
   172  	}
   173  
   174  	if len(errs) > 0 {
   175  		for _, err := range errs {
   176  			fmt.Printf("%s\n", err.Error())
   177  		}
   178  		npkgs := ""
   179  		if len(args) > 1 {
   180  			npkgs = "s"
   181  		}
   182  		sargs := make([]string, len(args))
   183  		for i, s := range args {
   184  			sargs[i] = fmt.Sprintf("%q", s)
   185  		}
   186  		return fmt.Errorf(
   187  			"removing package%s %s failed.",
   188  			npkgs, strings.Join(sargs, ", "),
   189  		)
   190  	}
   191  
   192  	return err
   193  }
   194  
   195  // EOF