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

FreeBSD Manual Pages


home | help
git-annex-import(1)	    General Commands Manual	   git-annex-import(1)

       git-annex-import	- add a	tree of	files to the repository

       git annex import	--from remote branch[:subdir] |	[path ...]

       This  command  is  a  way to import a tree of files from	elsewhere into
       your git-annex repository. It can import	files from a git-annex special
       remote, or from a directory.

       Importing  from	a  special remote first	downloads all new content from
       it, and then constructs a git commit  that  reflects  files  that  have
       changed	on  the	special	remote since the last time git-annex looked at
       it. Merging that	commit into your repository will update	it to  reflect
       changes made on the special remote.

       This  way,  something can be using the special remote for file storage,
       adding files, modifying files, and deleting files, and  you  can	 track
       those changes using git-annex.

       You  can	combine	using git annex	import to fetch	changes	from a special
       remote with git annex export to send your local changes to the  special

       You  can	only import from special remotes that were configured with im-
       porttree=yes when set up	with git-annex-initremote(1). Only some	 kinds
       of  special  remotes  will  let	you configure them this	way. A perhaps
       non-exhastive list is the directory, s3,	and adb	special	remotes.

       To import from a	special	remote,	you must specify the name of a branch.
       A corresponding remote tracking branch will be updated by git annex im-
       port. After that	point, it's the	same as	if you had  run	 a  git	 fetch
       from  a	regular	 git  remote; you can merge the	changes	into your cur-
       rently checked out branch.

       For example:

	git annex import master	--from myremote
	git annex merge	myremote/master

       You could just as well use git  merge  myremote/master  as  the	second
       step,  but using	git-annex merge	avoids a couple	of gotchas. When using
       adjusted	branches, it adjusts the branch	before merging from it.	And it
       avoids the merge	failing	on the first merge from	an import due to unre-
       lated histories.

       If you do use git merge,	you can	pass  --allow-unrelated-histories  the
       first  time  you	 git merge from	an import. Think of this as the	remote
       being a separate	git repository with its	own files. If  you  first  git
       annex  export files to a	remote,	and then git annex import from it, you
       won't need that option.

       You can import into a subdirectory, using the  "branch:subdir"  syntax.
       For  example,  if  "camera" is a	special	remote that accesses a camera,
       and you want to import those into the photos directory, rather than  to
       the root	of your	repository:

	git annex import master:photos --from camera
	git merge camera/master

       The  git	annex sync --content command (and the git-annex	assistant) can
       also be used to import from a special remote.  To do this, you need  to
       configure  "remote.<name>.annex-tracking-branch"	to tell	it what	branch
       to track. For example:

	git config remote.myremote.annex-tracking-branch master
	git annex sync --content

       If a preferred content expression is configured for the special remote,
       it will be honored when importing from it. Files	that are not preferred
       content of the remote will not be imported from it, but will be left on
       the remote.

       However,	 preferred content expressions that relate to the key can't be
       matched when importing, because the content of the file is  not	known.
       Importing  will	fail  when such	a preferred content expression is set.
       This includes expressions containing "copies=", "metadata=", and	 other
       things that depend on the key. Preferred	content	expressions containing
       "include=", "exclude=" "smallerthan=", "largerthan=" will work.

       When run	with a path, git annex import moves files from somewhere  out-
       side the	git working copy, and adds them	to the annex.

       This  is	a legacy interface. It is still	supported, but please consider
       switching to importing from a directory special remote  instead,	 using
       the interface documented	above.

       Individual  files  to import can	be specified. If a directory is	speci-
       fied, the entire	directory is imported.

	git annex import /media/camera/DCIM/*

       When importing files, there's a possibility of importing	a duplicate of
       a  file	that  is  already  known to git-annex -- its content is	either
       present in the local repository already,	or git-annex knows of  another
       repository  that	contains it, or	it was present in the annex before but
       has been	removed	now.

       By default, importing a duplicate of a known file will result in	a  new
       filename	 being	added  to  the	repository,  so	 the duplicate file is
       present in the repository twice.	(With all checksumming	backends,  in-
       cluding the default SHA256E, only one copy of the data will be stored.)

       Several	options	can be used to adjust handling of duplicate files, see
       --duplicate, --deduplicate, --skip-duplicates, --clean-duplicates,  and
       --reinject-duplicates documentation below.


	      Do not delete files from the import location.

	      Running  with  this  option repeatedly can import	the same files
	      into different git repositories, or branches, or different loca-
	      tions in a git repository.

	      Only  import files that are not duplicates; duplicate files will
	      be deleted from the import location.

	      Only import files	that are not duplicates. Avoids	 deleting  any
	      files from the import location.

	      Does not import any files, but any files found in	the import lo-
	      cation that are duplicates are deleted.

	      Imports files that are not duplicates. Files that	are duplicates
	      have their content reinjected into the annex (similar to git-an-

	      Allow existing files to be overwritten by	newly imported files.

	      Also, causes .gitignore to not take effect when adding files.

       file matching options
	      Many of the git-annex-matching-options(1)	can be used to specify
	      files to import.

		   git annex import /dir --include='*.png'


       --jobs=N	-JN
	      Imports multiple files in	parallel. This may be faster.  For ex-
	      ample: -J4

	      Setting this to "cpus" will run one job per CPU core.

       --json Enable JSON output. This is intended to be  parsed  by  programs
	      that use git-annex. Each line of output is a JSON	object.

	      Include progress objects in JSON output.

	      Messages that would normally be output to	standard error are in-
	      cluded in	the json instead.

       Note that using --deduplicate or	--clean-duplicates with	the WORM back-
       end does	not look at file content, but filename and mtime.

       If annex.largefiles is configured, and does not match a file, git annex
       import will add the non-large file directly to the git repository,  in-
       stead of	to the annex.





       Joey Hess <>



Want to link to this manual page? Use this URL:

home | help