def update_src(self, url, dest, dirname, args=None):
     """
     git pull / git checkout
     """
     args = args or {}
     self.log.debug("Using url {0}".format(url))
     cwd = os.getcwd()
     src_dir = os.path.join(dest, dirname)
     self.log.obnoxious("Switching cwd to: {}".format(src_dir))
     os.chdir(src_dir)
     if args.get("gitrev"):
         # If we have a rev or tag specified, fetch, then checkout.
         git_cmds = [
             ["git", "fetch", "--tags", "--all", "--prune"],
             ["git", "checkout", "--force", args.get("gitrev")],
         ]
     elif args.get("gitbranch"):
         # Branch is similar, only we make sure we're up to date
         # with the remote branch
         git_cmds = [
             ["git", "fetch", "--tags", "--all", "--prune"],
             ["git", "checkout", "--force", args.get("gitbranch")],
             ["git", "reset", "--hard", "@{u}"],
         ]
     else:
         # Without a git rev, all we can do is try and pull
         git_cmds = [["git", "pull", "--rebase"]]
     o_proc = None
     if self.log.getEffectiveLevel() >= pb_logging.DEBUG:
         o_proc = output_proc.OutputProcessorMake(preamble="Updating: ")
     for cmd in git_cmds:
         subproc.monitor_process(args=cmd, o_proc=o_proc)
     self.log.obnoxious("Switching cwd back to: {0}".format(cwd))
     os.chdir(cwd)
     return True

 def update_src(self, url, dest, dirname, args=None):
     """
     - src: URL, without the <type>+ prefix.
     - dest: Store the fetched stuff into here
     - dirname: Put the result into a dir with this name, it'll be a subdir of dest
     - args: Additional args to pass to the actual fetcher
     """
     args = args or {}
     self.log.debug("Using url {0}".format(url))
     cwd = os.getcwd()
     src_dir = os.path.join(dest, dirname)
     self.log.obnoxious("Switching cwd to: {0}".format(src_dir))
     os.chdir(src_dir)
     svn_cmd = ['svn', 'up', '--force']
     if args.get('svnrev'):
         svn_cmd.append('--revision')
         svn_cmd.append(args.get('svnrev'))
     subproc.monitor_process(
         args=svn_cmd,
         throw_ex=True,
         #o_proc=foo #FIXME
     )
     self.log.obnoxious("Switching cwd back to: {0}".format(cwd))
     os.chdir(cwd)
     return True

 def graphviz(self, packages, dotfile, pngfile):
     """
     Create the graphviz file
     """
     self.log.info("Creating digraph file {0}".format(dotfile))
     f = open(dotfile, "w")
     f.write("digraph g {\n")
     for pkg in packages:
         pkg_safe = pkg.replace("-", "_")
         f.write('{pkg} [label="{pkg}"]\n'.format(pkg=pkg_safe))
         rec = recipe.get_recipe(pkg, fail_easy=True)
         if rec is None:
             continue
         for dep in rec.depends:
             if dep in packages:
                 f.write(" {pkg} -> {dep}\n".format(
                     pkg=pkg_safe,
                     dep=dep.replace("-", "_")
                 ))
     f.write("}\n")
     f.close()
     self.log.debug("{0} written".format(dotfile))
     if pngfile is None:
         return
     self.log.info("Creating png file {0}".format(pngfile))
     subproc.monitor_process(
         ['dot', dotfile, '-Tpng', '-o{0}'.format(pngfile)],
         env=os.environ,
     )

 def fetch_url(self, url, dest, dirname, args=None):
     """
     git clone
     """
     args = args or {}
     self.log.debug("Using url - {}".format(url))
     git_cmd = ["git", "clone", url, dirname]
     if args.get("gitargs"):
         for arg in args.get("gitargs").split():
             git_cmd.append(arg)
     if self.cfg.get("git-cache", False):
         git_cmd.append("--reference")
         git_cmd.append(self.cfg.get("git-cache"))
     if args.get("gitbranch"):
         git_cmd.append("-b")
         git_cmd.append(args.get("gitbranch"))
     o_proc = None
     if self.log.getEffectiveLevel() >= pb_logging.DEBUG:
         o_proc = output_proc.OutputProcessorMake(preamble="Cloning: ")
     subproc.monitor_process(args=git_cmd, o_proc=o_proc, throw_ex=True)
     # If we have a specific revision, checkout that
     if args.get("gitrev"):
         cwd = os.getcwd()
         src_dir = os.path.join(dest, dirname)
         self.log.obnoxious("Switching cwd to: {}".format(src_dir))
         os.chdir(src_dir)
         git_co_cmd = ["git", "checkout", "--force", args.get("gitrev")]
         subproc.monitor_process(args=git_co_cmd, o_proc=o_proc, throw_ex=True)
         self.log.obnoxious("Switching cwd to: {}".format(cwd))
         os.chdir(cwd)
     return True

 def _run_cmd(self, pkgname, cmd):
     try:
         subproc.monitor_process(['emerge',"--quiet-build y","--ask n", cmd, '"'+pkgname+'"'], elevate=True, shell=True )
         return True
     except Exception as e:
         self.log.error("Running `emerge {}` failed.".format(cmd))
         self.log.obnoxious(str(e))
         return False

 def update(self, pkgname):
     """
     update package with 'port upgrade'
     """
     try:
         subproc.monitor_process(["port", "upgrade", pkgname], elevate=True, throw=True)
         return True
     except Exception as ex:
         self.log.error("Running port upgrade failed.")
         self.log.obnoxious(str(ex))

 def _run_cmd(self, pkgname, cmd):
     try:
         if cmd:
             subproc.monitor_process(["emerge","--quiet-build","y","--ask","n",cmd,pkgname], elevate=True )
         else:
             subproc.monitor_process(["emerge","--quiet-build","y","--ask","n",pkgname], elevate=True )
         return True
     except Exception as e:
         self.log.error("Running `emerge {0}` failed.".format(cmd))
         self.log.obnoxious(str(e))
         return False

 def install(self, pkgname):
     """
     apt(-get) -y install pkgname
     """
     try:
         subproc.monitor_process([self.getcmd, "-y", "install", pkgname], elevate=True, throw=True)
         return True
     except Exception as ex:
         self.log.error("Running {0} install failed.".format(self.getcmd))
         self.log.obnoxious(str(ex))
         return False

 def install(self, pkgname):
     """
     Install package with 'port install'
     """
     try:
         subproc.monitor_process(["port", "install", pkgname], elevate=True, throw=True)
         return True
     except Exception as ex:
         self.log.error("Running port install failed.")
         self.log.obnoxious(str(ex))
         return False

 def _run_cmd(self, pkgname, cmd):
     """
     Call pacman with cmd.
     """
     try:
         subproc.monitor_process([self.command, "--noconfirm", cmd, pkgname], elevate=True)
         return True
     except Exception as ex:
         self.log.error("Running `{0} {1}' failed.".format(self.command, cmd))
         self.log.trace(str(ex))
         return False

 def _run_cmd(self, pkgname, cmd):
     """
     Call yum or dnf with cmd.
     """
     try:
         subproc.monitor_process([self.command, "-y", cmd, pkgname], elevate=True)
         return True
     except Exception as ex:
         self.log.error("Running `{0} install' failed.".format(self.command))
         self.log.obnoxious(str(ex))
         return False

 def deploy(self, target, prefix_dir):
     """
     docstring for deploy
     """
     prefix_content = [
         x for x in os.listdir(prefix_dir) \
         if not os.path.join(prefix_dir, x) in self.skip_names \
     ]
     os.chdir(prefix_dir)
     cmd = ['scp', '-r', '-q'] + prefix_content + [target]
     subproc.monitor_process(cmd, throw_ex=True)

 def install(self, pkgname):
     """
     apt-get -y install pkgname
     """
     try:
         subproc.monitor_process(["apt-get", "-y", "install", pkgname], elevate=True, throw=True)
         return True
     except Exception as ex:
         self.log.error("Running apt-get install failed.")
         self.log.obnoxious(str(ex))
         return False

 def _package_install(self, pkg_name, comparator=">=", required_version=None):
     """
     Call 'apt-get install pkgname' if we can satisfy the version requirements.
     """
     available_version = self.get_version_from_apt_cache(pkg_name)
     if required_version is not None and not vcompare(comparator, available_version, required_version):
         return False
     try:
         subproc.monitor_process(["apt-get", "-y", "install", pkg_name], elevate=True)
         return True
     except:
         self.log.error("Running apt-get install failed.")
     return False

 def install(self, pkgname):
     """
     Call 'brew install pkgname' if we can satisfy the version requirements.
     """
     try:
         # Need to do some better checking here. Brew does not necessarily need sudo
         #sysutils.monitor_process(["sudo", "brew", "", "install", pkg_name])
         subproc.monitor_process(["brew", "install", pkgname])
         return True
     except Exception as e:
         #self.log.obnoxious(e)
         self.log.error("Running brew install failed.")
     return False

 def _package_install(self, pkgname, comparator=">=", required_version=None, cmd="install"):
     """
     Call 'COMMAND install pkgname' if we can satisfy the version requirements.
     """
     available_version = self.get_available_version_from_pkgr(pkgname)
     if required_version is not None and not vcompare(comparator, available_version, required_version):
         return False
     try:
         subproc.monitor_process([self.command, "-y", cmd, pkgname], elevate=True)
         return True
     except Exception as ex:
         self.log.error("Running `{0} install' failed.".format(self.command))
         self.log.obnoxious(str(ex))
     return False

 def fetch_url(self, url, dest, dirname, args=None):
     """
     git clone
     """
     git_version = get_git_version()
     self.log.debug("We have git version %s", git_version)
     url, args = parse_git_url(url, args or {})
     self.log.debug("Using url - {0}".format(url))
     git_cmd = ['git', 'clone', url, dirname]
     if args.get('gitargs'):
         for arg in args.get('gitargs').split():
             git_cmd.append(arg)
     if self.cfg.get("git-cache", False):
         from pybombs import gitcache_manager
         gcm = gitcache_manager.GitCacheManager(self.cfg.get("git-cache"))
         self.log.debug("Adding remote into git ref")
         gcm.add_remote(dirname, url, True)
         git_cmd.append(
             '--reference-if-able'
             if vcompare(">=", git_version, "2.11") else '--reference'
         )
         git_cmd.append(self.cfg.get("git-cache"))
     if args.get('gitbranch'):
         git_cmd.append('-b')
         git_cmd.append(args.get('gitbranch'))
     o_proc = None
     subproc.monitor_process(
         args=git_cmd,
         o_proc=o_proc,
         throw_ex=True,
         throw=True,
     )
     # If we have a specific revision, checkout that
     if args.get('gitrev'):
         cwd = os.getcwd()
         src_dir = os.path.join(dest, dirname)
         self.log.obnoxious("Switching cwd to: {0}".format(src_dir))
         os.chdir(src_dir)
         git_co_cmd = ["git", "checkout", "--force", args.get('gitrev')]
         subproc.monitor_process(
             args=git_co_cmd,
             o_proc=o_proc,
             throw_ex=True,
         )
         self.log.obnoxious("Switching cwd to: {0}".format(cwd))
         os.chdir(cwd)
     return True

 def _install_sdk_to_prefix(self, sdkname):
     """
     Read recipe for sdkname, and install the SDK to the prefix.
     """
     from pybombs import recipe
     src_dir = self.prefix.src_dir
     cfg_file = self.prefix.cfg_file
     ### Get the recipe
     r = recipe.get_recipe(sdkname, target='sdk')
     try:
         self.log.trace("Switching CWD to {0}".format(src_dir))
         if not op.isdir(src_dir):
             os.mkdir(src_dir)
         os.chdir(src_dir)
     except:
         self.log.error("Source dir required to install SDK.")
         return False
     ### Install the actual SDK file
     self.log.debug("Fetching SDK `{sdk}'".format(sdk=sdkname))
     fetcher.Fetcher().fetch(r)
     self.log.info("Installing SDK `{sdk}'".format(sdk=sdkname))
     # Install command
     cmd = r.var_replace_all(r.get_command('install'))
     if subproc.monitor_process(cmd, shell=True, env=os.environ) == 0:
         self.log.debug("Installation successful")
     else:
         self.log.error("Error installing SDK. Aborting.")
         return False
     # Clean up
     files_to_delete = [op.normpath(op.join(src_dir, r.var_replace_all(x))) for x in r.clean]
     if len(files_to_delete):
         self.log.info("Cleaning up files...")
     for ftd in files_to_delete:
         if op.commonprefix((src_dir, ftd)) != src_dir:
             self.log.warn("Not removing {ftd} -- outside source dir!".format(ftd=ftd))
             continue
         self.log.debug("Removing {ftd}...".format(ftd=ftd))
         if op.isdir(ftd):
             shutil.rmtree(ftd)
         elif op.isfile(ftd):
             os.remove(ftd)
         else:
             self.log.error("Not sure what this is: {ftd}".format(ftd=ftd))
             return False
     ### Update the prefix-local config file
     self.log.debug("Updating config file with SDK recipe info.")
     try:
         old_cfg_data = PBConfigFile(cfg_file).get()
     except IOError:
         self.log.debug("There doesn't seem to be a config file yet for this prefix.")
         old_cfg_data = {}
     # Filter out keys we don't care about:
     sdk_recipe_keys_for_config = ('config', 'packages', 'categories', 'env')
     sdk_cfg_data = {k: v for k, v in iteritems(r.get_dict()) if k in sdk_recipe_keys_for_config}
     self.log.trace("New data: {new}".format(new=sdk_cfg_data))
     cfg_data = dict_merge(old_cfg_data, sdk_cfg_data)
     self.log.debug("Writing updated prefix config to `{0}'".format(cfg_file))
     PBConfigFile(cfg_file).save(cfg_data)
     return True

 def _run_pip_install(self, pkgname, update=False):
     """
     Run pip install [--upgrade]
     """
     try:
         command = [sysutils.which('pip'), "install"]
         if update:
             command.append('--upgrade')
         command.append(pkgname)
         self.log.debug("Calling `{cmd}'".format(cmd=" ".join(command)))
         subproc.monitor_process(command, elevate=True)
         self.load_install_cache()
         return True
     except Exception as e:
         self.log.error("Running pip install failed.")
         self.log.debug(str(e))
     return None

 def fetch_url(self, url, dest, dirname, args=None):
     """
     git clone
     """
     url, args = parse_git_url(url, args or {})
     self.log.debug("Using url - {0}".format(url))
     git_cmd = ['git', 'clone', url, dirname]
     if args.get('gitargs'):
         for arg in args.get('gitargs').split():
             git_cmd.append(arg)
     if self.cfg.get("git-cache", False):
         from pybombs import gitcache_manager
         gcm = gitcache_manager.GitCacheManager(self.cfg.get("git-cache"))
         self.log.debug("Adding remote into git ref")
         gcm.add_remote(dirname, url, True)
         git_cmd.append('--reference')
         git_cmd.append(self.cfg.get("git-cache"))
     if args.get('gitbranch'):
         git_cmd.append('-b')
         git_cmd.append(args.get('gitbranch'))
     o_proc = None
     if self.log.getEffectiveLevel() >= pb_logging.DEBUG:
         o_proc = output_proc.OutputProcessorMake(preamble="Cloning:     ")
     subproc.monitor_process(
         args=git_cmd,
         o_proc=o_proc,
         throw_ex=True,
         throw=True,
     )
     # If we have a specific revision, checkout that
     if args.get('gitrev'):
         cwd = os.getcwd()
         src_dir = os.path.join(dest, dirname)
         self.log.obnoxious("Switching cwd to: {0}".format(src_dir))
         os.chdir(src_dir)
         git_co_cmd = ["git", "checkout", "--force", args.get('gitrev')]
         subproc.monitor_process(
             args=git_co_cmd,
             o_proc=o_proc,
             throw_ex=True,
         )
         self.log.obnoxious("Switching cwd to: {0}".format(cwd))
         os.chdir(cwd)
     return True