Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
FPART(1)		    General Commands Manual		      FPART(1)

NAME
       fpart --	Sort and pack files into partitions

SYNOPSIS
       fpart  [-h]  [-V]  -n  num  |  -f  files	 |  -s	size  [-i infile] [-a]
	     [-o  outfile]  [-0]  [-e]	[-P]  [-v]  [-l]  [-b]	[-y   pattern]
	     [-Y  pattern]  [-x	 pattern]  [-X pattern]	[-z] [-zz] [-zzz] [-Z]
	     [-d depth]	[-D] [-E]  [-L]	 [-S]  [-w  cmd]  [-W  cmd]  [-R  cmd]
	     [-p num] [-q num] [-r num]	[FILE or DIR...]

DESCRIPTION
       The  fpart  utility  helps  you sort file trees and pack	them into bags
       (called "partitions").

GENERAL	OPTIONS
       -h, --help
	       Print help

       -V, --version
	       Print version

PARTITION CONTROL
       -n num, --parts num
	       Create exactly num partitions and try  to  generate  partitions
	       with  the same size and number of files.	 This option cannot be
	       used in conjunction with	-f, -s or -L.

       -f files, --files files
	       Create partitions containing at most files  files  or  directo-
	       ries.  This option can be used in conjunction with -s and -L.

       -s size,	--size size
	       Create partitions with a	maximum	size of	size bytes.  With this
	       option,	a special partition 0 may be used to handle files that
	       do not fit in a regular	partition,  given  the	provided  size
	       limit.	This option can	be used	in conjunction with -f and -L.
	       You can use a human-friendly unit suffix	here (k, m, g, t, p).

INPUT CONTROL
       -i infile
	       Read file list from infile.  If infile is  "-",	then  list  is
	       read from stdin.

       -a, --arbitrary
	       Input  contains	arbitrary values; just sort them (do not crawl
	       filesystem).  Input must	follow the  "size(blank)path"  scheme.
	       This option is incompatible with	crawling-related options.

OUTPUT CONTROL
       -o outfile
	       Output  partitions'  contents  to  outfile  template.  Multiple
	       files will be generated given that template.  Each outfile will
	       get partition number as a suffix.  If outfile is	"-", then par-
	       titions will be printed to stdout, with partition  number  used
	       as  a prefix (so	you can	grep partitions	you are	interested in,
	       or do whatever you want).

       -0      End filenames with a null ('\0')	character  when	 using	option
	       -o.

       -e      When  adding  directories  (see	"DIRECTORY  HANDLING" ), add a
	       trailing	"/" to each directory entry.

       -P      Add parent directories when closing  partitions.	  That	option
	       can be used in conjunction with -zzz to produce partitions that
	       can  be	synchronized  in  parallel with	tools such as cpio(1),
	       pax(1) or tar(1).  Adding parent	directories at the end of each
	       partition ensures that modification times get reapplied to  di-
	       rectories  whatever the processing order	of partitions is.  Di-
	       rectories added that way	are 0-sized and	not subject to	parti-
	       tion  counters (for example, a file limit given using option -f
	       will be exceeded	by n parent directories).  Also, they are  not
	       subject	to  inclusion/exclusion	 options ( -y, -Y, -x, -X) and
	       they always have	a trailing "/" even if option -e has not  been
	       used  (this  simplifies	symlinks handling as we	always want to
	       add targets here, never the links themselves).  That option may
	       lead to creating	duplicate directory entries when  next	parti-
	       tion  begins with a directory entry that	has already been added
	       as a parent when	closing	the previous partition.	 Only interme-
	       diate partitions	will get parent	 directories  added,  not  the
	       very  last  one which gets its parents through option -zzz when
	       fts(3) crawling finishes.  Requires live	mode (option -L).

       -v, --verbose
	       Verbose mode (may be specified more than	once).

FILESYSTEM CRAWLING CONTROL
       -l      Follow symbolic links (default: do not follow).

       -b      Do not cross filesystem boundaries (default: cross).

       -y pattern, --include pattern
	       Include files or	directories matching pattern only (and discard
	       all other files).  This option may be specified several	times.
	       Pattern	may  be	 a leaf	(file or directory) name or a specific
	       path.  Shell pattern matching characters	("[", "]",  "*",  "?")
	       may  be used.  Include patterns are ignored when	computing size
	       of directories.

       -Y pattern
	       Same as -y but case insensitive.	 This option may not be	avail-
	       able on your platform (at least FreeBSD and  GNU/Linux  support
	       it, Solaris does	not).

       -x pattern, --exclude pattern
	       Exclude files or	directories matching pattern.  This option can
	       be used in conjunction with -y and -Y.  In this case, exclusion
	       is  performed  after.   This  option  may  be specified several
	       times.  Pattern may be a	leaf (file or  directory)  name	 or  a
	       specific	 path.	 Shell	pattern	matching characters ("[", "]",
	       "*", "?") may be	used.  Exclude patterns	also apply  when  com-
	       puting size of directories.

       -X pattern
	       Same as -x but case insensitive.	 This option may not be	avail-
	       able  on	 your platform (at least FreeBSD and GNU/Linux support
	       it, Solaris does	not).

DIRECTORY HANDLING
       -z      Pack empty directories.	By default, fpart will pack files only
	       (except when using the -d or -D options).  This option  can  be
	       useful for tools	such as	rsync(1) to be able to recreate	a full
	       file tree when used with	fpart (e.g. using rsync's --files-from
	       option).	  See the -zz option to	also pack un-readable directo-
	       ries.

       -zz     Treat un-readable or  erroneous	(partly-read)  directories  as
	       empty,  causing	them  to  be packed anyway.  Partly-read (non-
	       empty) directories can end up being packed while	some of	 their
	       children	have already been packed.

       -zzz    Pack  all  directories (as empty).  Useful when 3rd party tools
	       need directory entries to update	them (e.g.  cpio(1), pax(1) or
	       tar(1) ).

       -Z      Pack un-readable/erroneous directories in dedicated partitions.
	       This option helps isolating erroneous parts  of	a  filesystem.
	       Used  in	 conjunction  with FPART_PARTERRNO variable, hooks can
	       try to handle or	work around the	 error.	  Requires  live  mode
	       (option -L) and option -zz (- or	-zzz)

       -d depth
	       After  a	 certain depth,	pack directories instead of files (di-
	       rectories themselves will be added to  partitions,  instead  of
	       their  content).	  You  can  force a specific file to be	packed
	       anyway by listing it on the command line	explicitly.

       -D, --leaf-dirs
	       Implies -z.  Pack leaf directories:  if	a  directory  contains
	       files only, it will be packed as	a single entry.	 You can force
	       a  specific  file to be packed anyway by	listing	it on the com-
	       mand line explicitly.

       -E, --dirs-only
	       Implies -D.  Pack directories only (work	on a per-directory ba-
	       sis): in	that mode, no file will	be packed.  Instead, each  di-
	       rectory	will be	packed as a single entry with a	size being the
	       sum of all top-level files' sizes.  You can  force  a  specific
	       file  to	be packed anyway by listing it on the command line ex-
	       plicitly.

LIVE MODE
       -L, --live
	       Live mode (default: disabled).  When using  this	 mode,	parti-
	       tions will be generated while crawling filesystem.  This	option
	       saves  time and memory but will never produce special partition
	       0 (see options -s and -S	).  As a consequence, it will generate
	       partitions slightly larger than the size	specified with	option
	       -s.  This option	can be used in conjunction with	options	-f and
	       -s, but not with	option -n.

       -S      Skip  big  files	(default: disabled).  In live mode, no special
	       partition 0 can be produced and big files are added to the cur-
	       rent partition as they are found	while crawling the filesystem.
	       That can	lead to	huge partitions.  That option makes fpart skip
	       files bigger than the specified maximum partition size  (option
	       -s  )  and print	them to	stdout (even when using	option -o ) as
	       belonging to a pseudo-partition S (as in	'S'kipped).  It	allows
	       a consumer  to  handle  them  immediately  through  a  separate
	       process	(no  fpart  hook  will be executed for skipped files).
	       That option can only be used in Live mode (option -L ), when  a
	       maximum partition size has been given (option -s	).

       -w cmd, --pre-part-cmd cmd
	       When using live mode, execute cmd when starting a new partition
	       (before having opened next output file, if any).	 cmd is	run in
	       a specific environment that provides several variables describ-
	       ing  the	 state	of  the	 program:  FPART_HOOKTYPE ("pre-part",
	       "post-part" or "post-run"), FPART_PARTFILENAME (current	parti-
	       tion's  output  file name), FPART_PARTNUMBER (current partition
	       number),	   FPART_PARTSIZE    (current	 partition's	size),
	       FPART_TOTALSIZE	(total	partitions'  size), FPART_PARTNUMFILES
	       (number	 of    files	packed	  in	current	   partition),
	       FPART_TOTALNUMFILES  (total  number  of	files  packed so far),
	       FPART_PARTERRNO (0 if every single partition's entry  has  been
	       read without error, else	last erroneous entry's errno.  For er-
	       ror  detection  to work properly, you may need to rebuild fpart
	       using embedded fts(3) library, depending	on the version shipped
	       with your OS), FPART_PID	(PID  of  fpart),  FPART_TOTALNUMPARTS
	       (total  number  of partitions generated so far).	 Variables may
	       or may not be defined, depending	on requested options and  cur-
	       rent  partition's  state	when the hook is triggered.  Hooks are
	       executed	in a synchronous way while crawling filesystem,	so  1)
	       avoid  executing	commands that take a long time to return as it
	       slows down filesystem crawling and 2) do	not presume cwd	 (PWD)
	       is  the	one  fpart  has	 been  started	in, as it is regularly
	       changed to speed	up crawling (i.e. use  absolute	 paths	within
	       hooks).	 Size-related  variables  are  affected	by preloading,
	       overloading and rounding	options.

       -W cmd, --post-part-cmd cmd
	       Same as -w, but executes	cmd when finishing a partition	(after
	       having closed last output file, if any).

       -R cmd, --post-run-cmd cmd
	       Same  as	 -w  and -W but	executes cmd just once before exiting.
	       Note that only FPART_TOTALSIZE and FPART_TOTALNUMFILES environ-
	       ment variables are available in post-run	hooks.

SIZE HANDLING
       -p num  Preload each partition with num bytes.  You can	use  a	human-
	       friendly	unit suffix here (k, m,	g, t, p).

       -q num  Overload	 each  file size with num bytes.  You can use a	human-
	       friendly	unit suffix here (k, m,	g, t, p).

       -r num  Round each file size up to next num bytes multiple.   This  op-
	       tion can	be used	in conjunction with overloading, which is done
	       *before*	 rounding.   You  can use a human-friendly unit	suffix
	       here (k,	m, g, t, p).

EXAMPLES
       Here are	some examples:

       fpart -n	3 -o var-parts /var
	       Produce 3 partitions, with (hopefully) the same size and	number
	       of files.   Three  files:  var-parts.1,	var-parts.2  and  var-
	       parts.3 are generated as	output.

       fpart -s	4724464025 -o music-parts /path/to/music ./*.mp3
	       Produce	partitions  of	4.4  GB,  containing  music files from
	       /path/to/music as well as MP3  files  from  current  directory;
	       with  such  a  partition	 size,	each partition content will be
	       ready to	be burnt to a  DVD.   Files  music-parts.0  to	music-
	       parts.n,	are generated as output.

       find /usr ! -type d | fpart -f 10000 -i - /home | grep '^1 '
	       Produce	partitions  containing	10000  files each by examining
	       /usr first and then /home and display only partition 1 on  std-
	       out.

       du * | fpart -n 2 -a
	       Produce	two  partitions	by using du(1) output.	Fpart will not
	       examine the  file  system  but  instead	use  arbitrary	values
	       printed by du(1)	and sort them.

SEE ALSO
       du(1), find(1), fpsync(1), grep(1), rsync(1)

AUTHOR,	AVAILABILITY
       Fpart  has  been	written	by Ganael LAPLANCHE and	is available under the
       BSD license on http://contribs.martymac.org

BUGS
       No bug known (yet).

FreeBSD	ports 15.0	       November	18, 2011		      FPART(1)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=fpart&sektion=1&manpath=FreeBSD+Ports+15.0>

home | help