rtyler
/
pkgsrc-wip
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
pkgsrc-wip/bup-git/Makefile

63 lines
2.0 KiB
Makefile
Raw Normal View History

Adapt to upstream merge of patches.
2015-07-15 12:53:51 +00:00
# $NetBSD: Makefile,v 1.19 2015/07/15 12:53:51 thomasklausner Exp $
Import bup git package as wip/bup-git. bup is a program that backs things up. bup has a few advantages over other backup software: It uses a rolling checksum algorithm (similar to rsync) to split large files into chunks. The most useful result of this is you can backup huge virtual machine (VM) disk images, databases, and XML files incrementally, even though they're typically all in one huge file, and not use tons of disk space for multiple versions. It uses the packfile format from git (the open source version control system), so you can access the stored data even if you don't like bup's user interface. Unlike git, it writes packfiles directly (instead of having a separate garbage collection/repacking stage) so it's fast even with gratuitously huge amounts of data. bup's improved index formats also allow you to track far more filenames than git (millions) and keep track of far more objects (hundreds or thousands of gigabytes). Data is "automagically" shared between incremental backups without having to know which backup is based on which other one - even if the backups are made from two different computers that don't even know about each other. You just tell bup to back stuff up, and it saves only the minimum amount of data needed.
2013-10-26 23:21:09 +00:00
Bump version after 0.27 release.
2015-04-28 12:02:09 +00:00
DISTNAME= bup-0.27
Import bup git package as wip/bup-git. bup is a program that backs things up. bup has a few advantages over other backup software: It uses a rolling checksum algorithm (similar to rsync) to split large files into chunks. The most useful result of this is you can backup huge virtual machine (VM) disk images, databases, and XML files incrementally, even though they're typically all in one huge file, and not use tons of disk space for multiple versions. It uses the packfile format from git (the open source version control system), so you can access the stored data even if you don't like bup's user interface. Unlike git, it writes packfiles directly (instead of having a separate garbage collection/repacking stage) so it's fast even with gratuitously huge amounts of data. bup's improved index formats also allow you to track far more filenames than git (millions) and keep track of far more objects (hundreds or thousands of gigabytes). Data is "automagically" shared between incremental backups without having to know which backup is based on which other one - even if the backups are made from two different computers that don't even know about each other. You just tell bup to back stuff up, and it saves only the minimum amount of data needed.
2013-10-26 23:21:09 +00:00
CATEGORIES= sysutils
MASTER_SITES= #
MAINTAINER= pkgsrc-users@NetBSD.org
*: switch github HOMEPAGEs to https
2017-07-30 22:30:45 +00:00
HOMEPAGE= https://github.com/bup/bup
Import bup git package as wip/bup-git. bup is a program that backs things up. bup has a few advantages over other backup software: It uses a rolling checksum algorithm (similar to rsync) to split large files into chunks. The most useful result of this is you can backup huge virtual machine (VM) disk images, databases, and XML files incrementally, even though they're typically all in one huge file, and not use tons of disk space for multiple versions. It uses the packfile format from git (the open source version control system), so you can access the stored data even if you don't like bup's user interface. Unlike git, it writes packfiles directly (instead of having a separate garbage collection/repacking stage) so it's fast even with gratuitously huge amounts of data. bup's improved index formats also allow you to track far more filenames than git (millions) and keep track of far more objects (hundreds or thousands of gigabytes). Data is "automagically" shared between incremental backups without having to know which backup is based on which other one - even if the backups are made from two different computers that don't even know about each other. You just tell bup to back stuff up, and it saves only the minimum amount of data needed.
2013-10-26 23:21:09 +00:00
COMMENT= Highly efficient file backup system based on the git packfile format
LICENSE= gnu-gpl-v2
DEPENDS+= par2-[0-9]*:../../archivers/par2
bup-git: Adapt to upstream changes.
2015-12-19 16:52:44 +00:00
DEPENDS+= ${PYPKGPREFIX}-fuse-bindings-[0-9]*:../../filesystems/py-fuse-bindings
Import bup git package as wip/bup-git. bup is a program that backs things up. bup has a few advantages over other backup software: It uses a rolling checksum algorithm (similar to rsync) to split large files into chunks. The most useful result of this is you can backup huge virtual machine (VM) disk images, databases, and XML files incrementally, even though they're typically all in one huge file, and not use tons of disk space for multiple versions. It uses the packfile format from git (the open source version control system), so you can access the stored data even if you don't like bup's user interface. Unlike git, it writes packfiles directly (instead of having a separate garbage collection/repacking stage) so it's fast even with gratuitously huge amounts of data. bup's improved index formats also allow you to track far more filenames than git (millions) and keep track of far more objects (hundreds or thousands of gigabytes). Data is "automagically" shared between incremental backups without having to know which backup is based on which other one - even if the backups are made from two different computers that don't even know about each other. You just tell bup to back stuff up, and it saves only the minimum amount of data needed.
2013-10-26 23:21:09 +00:00
DEPENDS+= ${PYPKGPREFIX}-readline-[0-9]*:../../devel/py-readline
Included copy for tornado was remove -- update PLIST and depend on py-tornado package.
2013-12-29 21:19:30 +00:00
DEPENDS+= ${PYPKGPREFIX}-tornado-[0-9]*:../../www/py-tornado
Import bup git package as wip/bup-git. bup is a program that backs things up. bup has a few advantages over other backup software: It uses a rolling checksum algorithm (similar to rsync) to split large files into chunks. The most useful result of this is you can backup huge virtual machine (VM) disk images, databases, and XML files incrementally, even though they're typically all in one huge file, and not use tons of disk space for multiple versions. It uses the packfile format from git (the open source version control system), so you can access the stored data even if you don't like bup's user interface. Unlike git, it writes packfiles directly (instead of having a separate garbage collection/repacking stage) so it's fast even with gratuitously huge amounts of data. bup's improved index formats also allow you to track far more filenames than git (millions) and keep track of far more objects (hundreds or thousands of gigabytes). Data is "automagically" shared between incremental backups without having to know which backup is based on which other one - even if the backups are made from two different computers that don't even know about each other. You just tell bup to back stuff up, and it saves only the minimum amount of data needed.
2013-10-26 23:21:09 +00:00
DEPENDS+= git-base-[0-9]*:../../devel/git-base
Changes to get more tests to succeed.
2013-10-27 09:21:51 +00:00
# actually a TEST_DEPENDS
BUILD_DEPENDS+= rsync>=3.0:../../net/rsync
Add rdiff-backup for testing, and fix import-rdiff-backup and its test.
2013-11-01 23:25:09 +00:00
BUILD_DEPENDS+= rdiff-backup-[0-9]*:../../sysutils/rdiff-backup
Changes to get more tests to succeed.
2013-10-27 09:21:51 +00:00
Changed PYTHON_VERSIONS_INCOMPATIBLE to PYTHON_VERSIONS_ACCEPTED
2019-09-02 13:00:26 +00:00
PYTHON_VERSIONS_ACCEPTED= 27 # py-fuse-bindings
Mark packages as not ready for python-3.x where applicable; either because they themselves are not ready or because a dependency isn't. This is annotated by PYTHON_VERSIONS_INCOMPATIBLE= 33 # not yet ported as of x.y.z or PYTHON_VERSIONS_INCOMPATIBLE= 33 # py-foo, py-bar respectively, please use the same style for other packages, and check during updates. Use versioned_dependencies.mk where applicable. Use REPLACE_PYTHON instead of handcoded alternatives, where applicable. Reorder Makefile sections into standard order, where applicable. Remove PYTHON_VERSIONS_INCLUDE_3X lines since that will be default with the next commit. Whitespace cleanups and other nits corrected, where necessary.
2014-01-25 10:38:08 +00:00
wip/*: make Git configuration simpler
2018-02-25 21:09:20 +00:00
GIT_REPO= git://github.com/bup/bup.git
Import bup git package as wip/bup-git. bup is a program that backs things up. bup has a few advantages over other backup software: It uses a rolling checksum algorithm (similar to rsync) to split large files into chunks. The most useful result of this is you can backup huge virtual machine (VM) disk images, databases, and XML files incrementally, even though they're typically all in one huge file, and not use tons of disk space for multiple versions. It uses the packfile format from git (the open source version control system), so you can access the stored data even if you don't like bup's user interface. Unlike git, it writes packfiles directly (instead of having a separate garbage collection/repacking stage) so it's fast even with gratuitously huge amounts of data. bup's improved index formats also allow you to track far more filenames than git (millions) and keep track of far more objects (hundreds or thousands of gigabytes). Data is "automagically" shared between incremental backups without having to know which backup is based on which other one - even if the backups are made from two different computers that don't even know about each other. You just tell bup to back stuff up, and it saves only the minimum amount of data needed.
2013-10-26 23:21:09 +00:00
TEST_TARGET= test
MAKE_FLAGS+= PREFIX=${PREFIX}
MAKE_FLAGS+= PYTHON=${PYTHONBIN}
MAKE_FLAGS+= MANDIR=${DESTDIR}${PREFIX}/${PKGMANDIR}
USE_TOOLS+= bash gmake perl
Remove patches that were accepted upstream. Help more test cases to succeed.
2013-11-05 16:17:35 +00:00
Adapt for today's git state.
2013-11-03 01:33:07 +00:00
REPLACE_BASH+= cmd/import-rdiff-backup-cmd.sh
Adapt to upstream merge of patches.
2015-07-15 12:53:51 +00:00
REPLACE_BASH+= config/configure
Import bup git package as wip/bup-git. bup is a program that backs things up. bup has a few advantages over other backup software: It uses a rolling checksum algorithm (similar to rsync) to split large files into chunks. The most useful result of this is you can backup huge virtual machine (VM) disk images, databases, and XML files incrementally, even though they're typically all in one huge file, and not use tons of disk space for multiple versions. It uses the packfile format from git (the open source version control system), so you can access the stored data even if you don't like bup's user interface. Unlike git, it writes packfiles directly (instead of having a separate garbage collection/repacking stage) so it's fast even with gratuitously huge amounts of data. bup's improved index formats also allow you to track far more filenames than git (millions) and keep track of far more objects (hundreds or thousands of gigabytes). Data is "automagically" shared between incremental backups without having to know which backup is based on which other one - even if the backups are made from two different computers that don't even know about each other. You just tell bup to back stuff up, and it saves only the minimum amount of data needed.
2013-10-26 23:21:09 +00:00
REPLACE_BASH+= t/compare-trees
REPLACE_BASH+= t/configure-sampledata
Update for latest changes.
2013-12-05 07:38:30 +00:00
REPLACE_BASH+= t/force-delete
Import bup git package as wip/bup-git. bup is a program that backs things up. bup has a few advantages over other backup software: It uses a rolling checksum algorithm (similar to rsync) to split large files into chunks. The most useful result of this is you can backup huge virtual machine (VM) disk images, databases, and XML files incrementally, even though they're typically all in one huge file, and not use tons of disk space for multiple versions. It uses the packfile format from git (the open source version control system), so you can access the stored data even if you don't like bup's user interface. Unlike git, it writes packfiles directly (instead of having a separate garbage collection/repacking stage) so it's fast even with gratuitously huge amounts of data. bup's improved index formats also allow you to track far more filenames than git (millions) and keep track of far more objects (hundreds or thousands of gigabytes). Data is "automagically" shared between incremental backups without having to know which backup is based on which other one - even if the backups are made from two different computers that don't even know about each other. You just tell bup to back stuff up, and it saves only the minimum amount of data needed.
2013-10-26 23:21:09 +00:00
REPLACE_BASH+= t/subtree-hash
REPLACE_BASH+= t/test-cat-file.sh
REPLACE_BASH+= t/test-command-without-init-fails.sh
REPLACE_BASH+= t/test-index-check-device.sh
REPLACE_BASH+= t/test-meta.sh
REPLACE_BASH+= t/test-redundant-saves.sh
REPLACE_BASH+= t/test-restore-single-file.sh
REPLACE_BASH+= t/test-rm-between-index-and-save.sh
REPLACE_BASH+= t/test-save-creates-no-unrefs.sh
REPLACE_BASH+= t/test.sh
REPLACE_BASH+= wvtest-bup.sh
bup-git: Add missing INSTALLATION_DIRS. Remove unused comments.
2015-12-29 22:19:05 +00:00
INSTALLATION_DIRS= share/doc/bup
Import bup git package as wip/bup-git. bup is a program that backs things up. bup has a few advantages over other backup software: It uses a rolling checksum algorithm (similar to rsync) to split large files into chunks. The most useful result of this is you can backup huge virtual machine (VM) disk images, databases, and XML files incrementally, even though they're typically all in one huge file, and not use tons of disk space for multiple versions. It uses the packfile format from git (the open source version control system), so you can access the stored data even if you don't like bup's user interface. Unlike git, it writes packfiles directly (instead of having a separate garbage collection/repacking stage) so it's fast even with gratuitously huge amounts of data. bup's improved index formats also allow you to track far more filenames than git (millions) and keep track of far more objects (hundreds or thousands of gigabytes). Data is "automagically" shared between incremental backups without having to know which backup is based on which other one - even if the backups are made from two different computers that don't even know about each other. You just tell bup to back stuff up, and it saves only the minimum amount of data needed.
2013-10-26 23:21:09 +00:00
post-install:
# ${INSTALL_DATA} ${DOCDIR}/*.1 ${DESTDIR}${PREFIX}/${PKGMANDIR}/man1
${INSTALL_DATA} ${WRKSRC}/DESIGN ${DESTDIR}${PREFIX}/share/doc/bup
${INSTALL_DATA} ${WRKSRC}/README ${DESTDIR}${PREFIX}/share/doc/bup
Sync with sysutils/bup: make python fuse bindings an option.
2014-07-20 08:52:16 +00:00
.include "options.mk"
Import bup git package as wip/bup-git. bup is a program that backs things up. bup has a few advantages over other backup software: It uses a rolling checksum algorithm (similar to rsync) to split large files into chunks. The most useful result of this is you can backup huge virtual machine (VM) disk images, databases, and XML files incrementally, even though they're typically all in one huge file, and not use tons of disk space for multiple versions. It uses the packfile format from git (the open source version control system), so you can access the stored data even if you don't like bup's user interface. Unlike git, it writes packfiles directly (instead of having a separate garbage collection/repacking stage) so it's fast even with gratuitously huge amounts of data. bup's improved index formats also allow you to track far more filenames than git (millions) and keep track of far more objects (hundreds or thousands of gigabytes). Data is "automagically" shared between incremental backups without having to know which backup is based on which other one - even if the backups are made from two different computers that don't even know about each other. You just tell bup to back stuff up, and it saves only the minimum amount of data needed.
2013-10-26 23:21:09 +00:00
.include "../../lang/python/application.mk"
.include "../../wip/mk/git-package.mk"
.include "../../mk/bsd.pkg.mk"