Provided by: stow_1.3.3-2.1_all bug

NAME

       stow - software package installation manager

SYNOPSIS

       stow [options] package...

DESCRIPTION

       This  manual  page describes GNU Stow 1.3.2, a program for managing the
       installation  of  software  packages.  This  is  not   the   definitive
       documentation for stow; for that, see the info manual.

       Stow  is  a  tool  for  managing  the installation of multiple software
       packages in the same run-time directory tree. One historical difficulty
       of  this  task  has  been the need to administer, upgrade, install, and
       remove files in independent packages without confusing them with  other
       files  sharing the same filesystem space. For instance, it is common to
       install Perl and Emacs in /usr/local.  When one does so, one  winds  up
       (as  of  Perl  4.036  and  Emacs  19.22)  with  the  following files in
       /usr/local/man/man1: a2p.1; ctags.1; emacs.1; etags.1; h2ph.1;  perl.1;
       and  s2p.1.   Now  suppose it’s time to uninstall Perl. Which man pages
       get removed?  Obviously perl.1 is one of them, but it should not be the
       administrator’s  responsibility to memorize the ownership of individual
       files by separate packages.

       The approach used by Stow is to install each package into its own tree,
       then  use  symbolic  links  to  make  it appear as though the files are
       installed in the common tree. Administration can be  performed  in  the
       package’s  private  tree in isolation from clutter from other packages.
       Stow can then be used to update the symbolic links.  The  structure  of
       each  private  tree  should reflect the desired structure in the common
       tree; i.e. (in the typical  case)  there  should  be  a  bin  directory
       containing  executables,  a man/man1 directory containing section 1 man
       pages, and so on.

       Stow  was  inspired  by  Carnegie  Mellon’s  Depot  program,   but   is
       substantially  simpler and safer. Whereas Depot required database files
       to keep things in sync, Stow stores no extra  state  between  runs,  so
       there’s  no danger (as there was in Depot) of mangling directories when
       file hierarchies don’t match the database. Also unlike Depot, Stow will
       never  delete  any  files,  directories, or links that appear in a Stow
       directory (e.g., /usr/local/stow/emacs), so  it’s  always  possible  to
       rebuild the target tree (e.g., /usr/local).

TERMINOLOGY

       A ‘‘package’’ is a related collection of files and directories that you
       wish to administer as a unit--e.g., Perl or Emacs--and that needs to be
       installed in a particular directory structure--e.g., with bin, lib, and
       man subdirectories.

       A ‘‘target directory’’ is the root of a  tree  in  which  one  or  more
       packages  wish to appear to be installed. A common, but by no means the
       only such location is /usr/local.  The examples  in  this  manual  page
       will use /usr/local as the target directory.

       A ‘‘stow directory’’ is the root of a tree containing separate packages
       in private subtrees. When Stow runs, it uses the current  directory  as
       the  default  stow directory. The examples in this manual page will use
       /usr/local/stow as the stow directory, so that individual packages will
       be, for example, /usr/local/stow/perl and /usr/local/stow/emacs.

       An  ‘‘installation  image’’  is  the  layout  of  files and directories
       required by a package, relative to  the  target  directory.  Thus,  the
       installation  image  for Perl includes: a bin directory containing perl
       and  a2p  (among  others);  an  info   directory   containing   Texinfo
       documentation;  a  lib/perl  directory containing Perl libraries; and a
       man/man1 directory containing man pages.

       A  ‘‘package  directory’’  is  the  root  of  a  tree  containing   the
       installation  image  for  a  particular package. Each package directory
       must  reside  in  a  stow  directory--e.g.,   the   package   directory
       /usr/local/stow/perl must reside in the stow directory /usr/local/stow.
       The ‘‘name’’ of a package is the name of its directory within the  stow
       directory--e.g., perl.

       Thus,      the      Perl      executable      might      reside      in
       /usr/local/stow/perl/bin/perl,   where   /usr/local   is   the   target
       directory,  /usr/local/stow is the stow directory, /usr/local/stow/perl
       is  the  package  directory,  and  bin/perl  within  is  part  of   the
       installation image.

       A  ‘‘symlink’’  is  a  symbolic  link. A symlink can be ‘‘relative’’ or
       ‘‘absolute’’. An absolute symlink names  a  full  path;  that  is,  one
       starting  from  /.   A relative symlink names a relative path; that is,
       one not starting from /.  The target of a relative symlink is  computed
       starting  from  the symlink’s own directory. Stow only creates relative
       symlinks.

OPTIONS

       The stow directory is assumed to be  the  current  directory,  and  the
       target  directory  is assumed to be the parent of the current directory
       (so it is typical to execute stow from the directory  /usr/local/stow).
       Each  package given on the command line is the name of a package in the
       stow directory (e.g., perl).  By default, they are installed  into  the
       target directory (but they can be deleted instead using ‘-D’).

       -n

       --no   Do not perform any operations that modify the filesystem; merely
              show  what  would  happen.  Since  no  actual   operations   are
              performed,  stow  -n  could  report  conflicts  when  none would
              actually take place (see ‘‘Conflicts’’ in the info manual);  but
              it won’t fail to report conflicts that would take place.

       -c

       --conflicts
              Do  not  exit  immediately  when a conflict is encountered. This
              option implies ‘-n’, and is used to  search  for  all  conflicts
              that  might  arise  from an actual Stow operation. As with ‘-n’,
              however, false conflicts might be reported (see ‘‘Conflicts’’ in
              the info manual).

       -d DIR

       --dir=DIR
              Set  the stow directory to DIR instead of the current directory.
              This also has the effect of making the default target  directory
              be the parent of DIR.

       -t DIR

       --target=DIR
              Set  the  target  directory  to DIR instead of the parent of the
              stow directory.

       -v

       --verbose[=N]
              Send verbose output to standard error describing  what  Stow  is
              doing.  Verbosity  levels  are 0, 1, 2, and 3; 0 is the default.
              Using ‘-v’ or ‘--verbose’ increases the verbosity by one;  using
              ‘--verbose=N’ sets it to N.

       -D

       --delete
              Delete packages from the target directory rather than installing
              them.

       -R

       --restow
              Restow packages (first unstow, then stow again). This is  useful
              for  pruning  obsolete  symlinks  from  the  target  tree  after
              updating the software in a package.

       -V

       --version
              Show Stow version number, and exit.

       -h

       --help Show Stow command syntax, and exit.

INSTALLING PACKAGES

       The default action of Stow is to install a package. This means creating
       symlinks  in  the  target  tree that point into the package tree.  Stow
       attempts to do this with as few symlinks as possible; in  other  words,
       if  Stow  can  create a single symlink that points to an entire subtree
       within the package tree, it will choose to do that rather than create a
       directory in the target tree and populate it with symlinks.

       For  example,  suppose  that  no  packages  have  yet been installed in
       /usr/local; it’s completely empty (except for the stow subdirectory, of
       course).  Now  suppose  the  Perl package is installed.  Recall that it
       includes the following directories  in  its  installation  image:  bin;
       info;   lib/perl;   man/man1.    Rather  than  creating  the  directory
       /usr/local/bin and populating it with symlinks to ../stow/perl/bin/perl
       and  ../stow/perl/bin/a2p  (and  so  on),  Stow  will  create  a single
       symlink, /usr/local/bin, which points to stow/perl/bin.  In  this  way,
       it  still works to refer to /usr/local/bin/perl and /usr/local/bin/a2p,
       and fewer symlinks have been created. This is called ‘‘tree  folding’’,
       since an entire subtree is ‘‘folded’’ into a single symlink.

       To   complete   this   example,  Stow  will  also  create  the  symlink
       /usr/local/info pointing to stow/perl/info; the symlink  /usr/local/lib
       pointing  to  stow/perl/lib; and the symlink /usr/local/man pointing to
       stow/perl/man.

       Now suppose that instead of installing the Perl package into  an  empty
       target  tree,  the  target tree is not empty to begin with. Instead, it
       contains several files and  directories  installed  under  a  different
       system-administration philosophy. In particular, /usr/local/bin already
       exists   and   is   a   directory,   as    are    /usr/local/lib    and
       /usr/local/man/man1.    In   this   case,   Stow   will   descend  into
       /usr/local/bin  and  create  symlinks  to   ../stow/perl/bin/perl   and
       ../stow/perl/bin/a2p  (etc.),  and  it will descend into /usr/local/lib
       and   create   the    tree-folding    symlink    perl    pointing    to
       ../stow/perl/lib/perl,  and so on. As a rule, Stow only descends as far
       as necessary into the target tree when it  can  create  a  tree-folding
       symlink.

       The  time  often  comes  when  a  tree-folding symlink has to be undone
       because another package uses one or more of the  folded  subdirectories
       in  its installation image. This operation is called ‘‘splitting open’’
       a folded tree. It involves  removing  the  original  symlink  from  the
       target  tree,  creating  a  true  directory  in  its  place,  and  then
       populating the new  directory  with  symlinks  to  the  newly-installed
       package  and to the old package that used the old symlink. For example,
       suppose that after installing Perl into an empty /usr/local, we wish to
       install  Emacs.   Emacs’s  installation  image includes a bin directory
       containing the emacs and etags executables,  among  others.  Stow  must
       make  these  files  appear  to  be  installed  in  /usr/local/bin,  but
       presently /usr/local/bin is a symlink to stow/perl/bin.  Stow therefore
       takes  the  following steps: the symlink /usr/local/bin is deleted; the
       directory /usr/local/bin is created; links are made from /usr/local/bin
       to  ../stow/emacs/bin/emacs  and ../stow/emacs/bin/etags; and links are
       made    from    /usr/local/bin     to     ../stow/perl/bin/perl     and
       ../stow/perl/bin/a2p.

       When  splitting open a folded tree, Stow makes sure that the symlink it
       is about to remove points inside a valid package in  the  current  stow
       directory.   Stow will never delete anything that it doesnt own.  Stow
       ‘‘owns’’ everything living in  the  target  tree  that  points  into  a
       package  in the stow directory. Anything Stow owns, it can recompute if
       lost. Note that by this definition, Stow doesn’t  ‘‘own’’  anything  in
       the stow directory or in any of the packages.

       If Stow needs to create a directory or a symlink in the target tree and
       it cannot because that name is already in use and is not owned by Stow,
       then a conflict has arisen. See ‘‘Conflicts’’ in the info manual.

DELETING PACKAGES

       When  the  ‘-D’  option  is  given,  the  action of Stow is to delete a
       package from the target tree. Note that Stow will not  delete  anything
       it  doesn’t  ‘‘own’’. Deleting a package does not mean removing it from
       the stow directory or discarding the package tree.

       To delete a package, Stow recursively scans the target  tree,  skipping
       over  the  stow  directory (since that is usually a subdirectory of the
       target  tree)  and  any  other  stow  directories  it  encounters  (see
       ‘‘Multiple stow directories’’ in the info manual). Any symlink it finds
       that points into the package being deleted is  removed.  Any  directory
       that  contained  only symlinks to the package being deleted is removed.
       Any directory that, after removing symlinks and  empty  subdirectories,
       contains only symlinks to a single other package, is considered to be a
       previously ‘‘folded’’ tree that was ‘‘split open.’’ Stow  will  re-fold
       the  tree  by  removing the symlinks to the surviving package, removing
       the directory,  then  linking  the  directory  back  to  the  surviving
       package.

SEE ALSO

       The  info  manual  ‘‘Stow  1.3.2: Managing the installation of software
       packages’’ by Bob Glickstein, Zanshin Software, Inc.

BUGS

       Please report bugs in Stow using the Debian bug tracking system.

       Currently known bugs include:

       *      The empty-directory problem. If package FOO  includes  an  empty
              directory--say, FOO/BAR--then:

              1.   if  no  other  package has a BAR subdirectory, everything’s
              fine.

              2.  if another stowed package, QUUX,  has  a  BAR  subdirectory,
              then  when stowing, TARGETDIR/BAR will be ‘‘split open’’ and the
              contents of QUUX/BAR will be individually  stowed.  So  far,  so
              good.  But  when  unstowing QUUX, TARGETDIR/BAR will be removed,
              even though FOO/BAR needs it to remain. A  workaround  for  this
              problem  is to create a file in FOO/BAR as a placeholder. If you
              name that file .placeholder, it will be easy to find and  remove
              such files when this bug is fixed.

       *      When  using  multiple  stow  directories  (see  ‘‘Multiple  stow
              directories’’ in the info manual), Stow fails to ‘‘split  open’’
              tree-folding  symlinks  (see ‘‘Installing packages’’ in the info
              manual) that point into a stow directory which is not the one in
              use  by  the  current  Stow  command.  Before failing, it should
              search the target of the link to see whether any element of  the
              path  contains  a  .stow file. If it finds one, it can ‘‘learn’’
              about the cooperating stow directory to short-circuit the  .stow
              search the next time it encounters a tree-folding symlink.

AUTHOR

       This  man  page  was constructed by Charles Briscoe-Smith from parts of
       Stow’s info manual. That manual contained the following notice,  which,
       as  it  says, applied to this manual page, too. The text of the section
       entitled ‘‘GNU General Public  License’’  can  be  found  in  the  file
       /usr/share/common-licenses/GPL  on  any Debian GNU/Linux system. If you
       don’t have access to a Debian system, or the GPL is not there, write to
       the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston,
       MA, 02111-1307, USA.

              Software and documentation Copyright (C) 1993, 1994, 1995,  1996
              by Bob Glickstein <bobg+stow@zanshin.com>.

              Permission  is granted to make and distribute verbatim copies of
              this manual provided the copyright notice  and  this  permission
              notice are preserved on all copies.

              Permission  is  granted to copy and distribute modified versions
              of this  manual  under  the  conditions  for  verbatim  copying,
              provided  also  that  the  section entitled ‘‘GNU General Public
              License’’ is included with the  modified  manual,  and  provided
              that  the entire resulting derived work is distributed under the
              terms of a permission notice identical to this one.

              Permission is granted to copy  and  distribute  translations  of
              this  manual  into  another language, under the above conditions
              for modified versions, except that this permission notice may be
              stated   in   a   translation  approved  by  the  Free  Software
              Foundation.

                                 28 March 1998                         STOW(8)