Re: doc compilations: build-time or pre-built?
[EMAIL PROTECTED] writes: Hi. My dillema: 1) compile docs pre-build-time; or 2) compile docs in build-time Pros of 1: build-time and Build-Depends Pros of 2: diff.gz and unnecessary manual intervention of downstream maintainer (me :) ) So, what are best practices about this? [cut] Rewriting dillema, after answers: (re)buildability versus maintenance cost. (Re)buildability wins :). If in doubt, compile build-time docs. Rebuildability is important per se, since is condition of better softwares. So, build-time doc compiles is better option (generally). I'm a newbie and I'm learning. Fix me if I am wrong about something, please. Thanks all. Regards, -- Marcio Roberto Teixeira ___ I use newsreader (nntp). Don't send messages directly to my email, please (even replies or follow-ups); keep all threads here and only here. ^^^ keys: hkp://wwwkeys.pgp.net http://marciotex.googlepages.com/keypub_8709626B.asc home page (building): http://marciotex.googlepages.com tchê Debian/GNULinux user Porto Alegre - RS - Brasil -- To UNSUBSCRIBE, email to [EMAIL PROTECTED] with a subject of unsubscribe. Trouble? Contact [EMAIL PROTECTED]
Re: doc compilations: build-time or pre-built?
[EMAIL PROTECTED] writes: Hi. My dillema: 1) compile docs pre-build-time; or 2) compile docs in build-time Pros of 1: build-time and Build-Depends Cons: - Docs that can be unbuildable or out of sync with the source. - Binary files in the diff.gz (have fun with that one) either always or if the user changes the sources of docs and rebuilds. Pros of 2: diff.gz and unnecessary manual intervention of downstream maintainer (me :) ) You can keep the docs in orig.tar.gz and remove them in clean in many cases. Afaik that is perfectly legal. If that is not possible (unrepresentable changes to source) then renaming them and undoing that during build is an (ugly) alternative. So, what are best practices about this? If there is source then build that (with the exception of running the auto* tools). If building takes long then don't have the build target build the architecture independent files but only the build-indep / binary-indep targets and use Build-Depends-Indep. Pro: - no need for buildds to install/remove Build-Depends-Indep - no need for buildds to compile indep files even though build is called Cons: - indep files will be build as (fake)root instead of as user. Thanks in advance, MfG Goswin -- To UNSUBSCRIBE, email to [EMAIL PROTECTED] with a subject of unsubscribe. Trouble? Contact [EMAIL PROTECTED]
Re: doc compilations: build-time or pre-built?
* Junichi Uekawa | Another aspect is maintenance cost. Auto* tools and docbook toolchain, | and tex toolchain may break, which means packages no longer | build. This, I believe, shouldn't really be considered a reason not to | build-depend; because it will be the users who will suffer from a | broken package that doesn't really build. If you need to change, say, configure.ac and nobody has tried generating configure from it using the tools in the archive, this can be a serious problem when doing a security upload. -- Tollef Fog Heen,''`. UNIX is user friendly, it's just picky about who its friends are : :' : `. `' `- -- To UNSUBSCRIBE, email to [EMAIL PROTECTED] with a subject of unsubscribe. Trouble? Contact [EMAIL PROTECTED]
Re: doc compilations: build-time or pre-built?
Hi, It seems like it would be quite taxing on the autobuilders to have to pull something like docbook (and its chain of dependencies) into a pbuilder just to recompile a manpage that doesn't change between architectures. AIUI, the autobuilders use sbuild and don't purge the installed packages unless the admins do so manually. At least, that is what I have been told on the subject. No, that's not true; packages that are installed at the beginning of a build run are removed at the end. The main difference between pbuilder and sbuild is the fact that sbuild uses an existing chroot on which it works (or even builds in your main system if you have no chroot configured), while pbuilder creates a clean chroot environment based on a tarball with the required files before beginning a build, which it removes entirely afterwards. I now know quite well that package installation time is a big bottleneck. My recent interests are in improving speed of pbuilder, and I have been profiling execution times of cowbuilder. If I can eliminate the installation time altogether, I can make the time overhead of using pbuilder over a normal 'debuild' pretty much like 2 seconds on a modern hardware). I'm thinking about 1. caching chroots with some common packages installed (there is a trade-off with accuracy) 2. improving speed of package installations through improving dpkg/apt execution time. However, I'm not sure if I will have a good consolidated time to work on this stuff before the next debconf :P. regards, junichi -- [EMAIL PROTECTED],netfort.gr.jp} Debian Project -- To UNSUBSCRIBE, email to [EMAIL PROTECTED] with a subject of unsubscribe. Trouble? Contact [EMAIL PROTECTED]
Re: doc compilations: build-time or pre-built?
Steinar H. Gunderson skrev: On Tue, Jul 04, 2006 at 07:25:16PM -0300, [EMAIL PROTECTED] wrote: 1) compile docs pre-build-time; or 2) compile docs in build-time Definitely the latter. We build stuff at build time for a reason, architecture-specific or -independent alike. That depends a bit on the stuff. A lot of maintainers think running auto* to generate configure and Makefile.in at build-time is to be avoided. Another lot of maintainers disagree with them. - tfheen -- To UNSUBSCRIBE, email to [EMAIL PROTECTED] with a subject of unsubscribe. Trouble? Contact [EMAIL PROTECTED]
Re: doc compilations: build-time or pre-built?
[EMAIL PROTECTED] wrote: tony mancill [EMAIL PROTECTED] writes: Steinar H. Gunderson wrote: On Tue, Jul 04, 2006 at 07:25:16PM -0300, [EMAIL PROTECTED] wrote: 1) compile docs pre-build-time; or 2) compile docs in build-time Definitely the latter. We build stuff at build time for a reason, architecture-specific or -independent alike. Is this the consensus/best-practice on this question? It seems like it would be quite taxing on the autobuilders to have to pull something like docbook (and its chain of dependencies) into a pbuilder just to recompile a manpage that doesn't change between architectures. I'm interested in this because I've typically done (2), but have recently started to think that (1) is more appropriate, particularly for packages where the documentation is a simple manpage. And It's exactly this the case in question, for me. I think that if upstream ships pre-built docs, then it is not necessary to rebuild them (but you should verify that it's possible...). In all other cases, I would argue for generating the docs at build-time. Regards, Frank -- Frank Küster Single Molecule Spectroscopy, Protein Folding @ Inst. f. Biochemie, Univ. Zürich Debian Developer (teTeX)
Re: doc compilations: build-time or pre-built?
1) compile docs pre-build-time; or 2) compile docs in build-time Definitely the latter. We build stuff at build time for a reason, architecture-specific or -independent alike. That depends a bit on the stuff. A lot of maintainers think running auto* to generate configure and Makefile.in at build-time is to be avoided. Another lot of maintainers disagree with them. Really, someone should actually start talking with numbers, to answer the following question: How much time is used installing/running those auto* toolchain, and docbook toolchain. It's not too difficult to use oprofile, it just needs some work. Another aspect is maintenance cost. Auto* tools and docbook toolchain, and tex toolchain may break, which means packages no longer build. This, I believe, shouldn't really be considered a reason not to build-depend; because it will be the users who will suffer from a broken package that doesn't really build. regards, junichi -- [EMAIL PROTECTED],netfort.gr.jp} Debian Project -- To UNSUBSCRIBE, email to [EMAIL PROTECTED] with a subject of unsubscribe. Trouble? Contact [EMAIL PROTECTED]
Re: doc compilations: build-time or pre-built?
On Tue, Jul 04, 2006 at 09:04:48PM -0300, [EMAIL PROTECTED] wrote: tony mancill [EMAIL PROTECTED] writes: Steinar H. Gunderson wrote: On Tue, Jul 04, 2006 at 07:25:16PM -0300, [EMAIL PROTECTED] wrote: 1) compile docs pre-build-time; or 2) compile docs in build-time Definitely the latter. We build stuff at build time for a reason, architecture-specific or -independent alike. Is this the consensus/best-practice on this question? It seems like it would be quite taxing on the autobuilders to have to pull something like docbook (and its chain of dependencies) into a pbuilder just to recompile a manpage that doesn't change between architectures. I'm interested in this because I've typically done (2), but have recently started to think that (1) is more appropriate, particularly for packages where the documentation is a simple manpage. And It's exactly this the case in question, for me. The SGML template for manpage is there to help producing decent usable manpage for novice packager. I think it is useful only for intial packaging. I usually erase SGML file and update groff source of the manpage. NM guide states; 5.8 manpage.1.ex, manpage.sgml.ex Your program(s) should have a manual page. If they don't, each of these files is a template that you can fill out. Manual pages are normally written in nroff(1). The manpage.1.ex example is written in nroff, too. See the man(7) manual page for a brief description of how to edit such a file. If on the other hand you prefer writing SGML instead of nroff, you can use the manpage.sgml.ex template. If you do this, you have to: * install the docbook-to-man package * add docbook-to-man to the Build-Depends line in the control file * remove the comment from the docbook-to-man invocation in the * `build' rule of your rules file Note here of normally written in nroff. So use of nroff source is better. Osamu PS: This section was not touched by me :-) -- To UNSUBSCRIBE, email to [EMAIL PROTECTED] with a subject of unsubscribe. Trouble? Contact [EMAIL PROTECTED]
Re: doc compilations: build-time or pre-built?
On Tue, Jul 04, 2006 at 04:45:21PM -0700, tony mancill wrote: -BEGIN PGP SIGNED MESSAGE- Hash: SHA1 Steinar H. Gunderson wrote: On Tue, Jul 04, 2006 at 07:25:16PM -0300, [EMAIL PROTECTED] wrote: 1) compile docs pre-build-time; or 2) compile docs in build-time Definitely the latter. We build stuff at build time for a reason, architecture-specific or -independent alike. Is this the consensus/best-practice on this question? It seems like it would be quite taxing on the autobuilders to have to pull something like docbook (and its chain of dependencies) into a pbuilder just to recompile a manpage that doesn't change between architectures. autobuilders don't use pbuilder :-) I'm interested in this because I've typically done (2), but have recently started to think that (1) is more appropriate, particularly for packages where the documentation is a simple manpage. That's not the issue. If someone updates the code for a local change, then the sgml source file of the manpage, they want to be able to use dpkg-buildpackage to produce a working package with the included fixes. Pulling in docbook isn't really much of a problem; if many packages start doing it, we can easily preinstall that particular package in the buildd chroot (e.g., I do this for debhelper already on my buildd hosts). -- Fun will now commence -- Seven Of Nine, Ashes to Ashes, stardate 53679.4 signature.asc Description: Digital signature
Re: doc compilations: build-time or pre-built?
On Tue, Jul 04, 2006 at 09:18:20PM -0400, Roberto C. Sanchez wrote: tony mancill wrote: It seems like it would be quite taxing on the autobuilders to have to pull something like docbook (and its chain of dependencies) into a pbuilder just to recompile a manpage that doesn't change between architectures. AIUI, the autobuilders use sbuild and don't purge the installed packages unless the admins do so manually. At least, that is what I have been told on the subject. No, that's not true; packages that are installed at the beginning of a build run are removed at the end. The main difference between pbuilder and sbuild is the fact that sbuild uses an existing chroot on which it works (or even builds in your main system if you have no chroot configured), while pbuilder creates a clean chroot environment based on a tarball with the required files before beginning a build, which it removes entirely afterwards. -- Fun will now commence -- Seven Of Nine, Ashes to Ashes, stardate 53679.4 signature.asc Description: Digital signature
Re: doc compilations: build-time or pre-built?
On Wed, Jul 05, 2006 at 09:45:16PM +0900, Junichi Uekawa wrote: Another aspect is maintenance cost. Auto* tools and docbook toolchain, and tex toolchain may break, which means packages no longer build. This, I believe, shouldn't really be considered a reason not to build-depend; because it will be the users who will suffer from a broken package that doesn't really build. So do compilers. And libraries. And kernel-header packages. It's not much of an argument to avoid running arch-indep toolchains at package build time, IMO. -- Fun will now commence -- Seven Of Nine, Ashes to Ashes, stardate 53679.4 -- To UNSUBSCRIBE, email to [EMAIL PROTECTED] with a subject of unsubscribe. Trouble? Contact [EMAIL PROTECTED]
Re: doc compilations: build-time or pre-built?
Wouter Verhelst wrote: No, that's not true; packages that are installed at the beginning of a build run are removed at the end. The main difference between pbuilder and sbuild is the fact that sbuild uses an existing chroot on which it works (or even builds in your main system if you have no chroot configured), while pbuilder creates a clean chroot environment based on a tarball with the required files before beginning a build, which it removes entirely afterwards. Thanks for the further clarification. -Roberto -- Roberto C. Sanchez http://familiasanchez.net/~roberto signature.asc Description: OpenPGP digital signature
Re: doc compilations: build-time or pre-built?
On Tue, Jul 04, 2006 at 07:25:16PM -0300, [EMAIL PROTECTED] wrote: 1) compile docs pre-build-time; or 2) compile docs in build-time Definitely the latter. We build stuff at build time for a reason, architecture-specific or -independent alike. /* Steinar */ -- Homepage: http://www.sesse.net/ -- To UNSUBSCRIBE, email to [EMAIL PROTECTED] with a subject of unsubscribe. Trouble? Contact [EMAIL PROTECTED]
Re: doc compilations: build-time or pre-built?
-BEGIN PGP SIGNED MESSAGE- Hash: SHA1 Steinar H. Gunderson wrote: On Tue, Jul 04, 2006 at 07:25:16PM -0300, [EMAIL PROTECTED] wrote: 1) compile docs pre-build-time; or 2) compile docs in build-time Definitely the latter. We build stuff at build time for a reason, architecture-specific or -independent alike. Is this the consensus/best-practice on this question? It seems like it would be quite taxing on the autobuilders to have to pull something like docbook (and its chain of dependencies) into a pbuilder just to recompile a manpage that doesn't change between architectures. I'm interested in this because I've typically done (2), but have recently started to think that (1) is more appropriate, particularly for packages where the documentation is a simple manpage. Thanks, tony -BEGIN PGP SIGNATURE- Version: GnuPG v1.4.3 (GNU/Linux) Comment: Using GnuPG with Mozilla - http://enigmail.mozdev.org iD8DBQFEqv2QpdwBkPlyvgMRAkBmAJ9KcON1gjVHvxoxOmFyq1ZEDbIW7QCaAu6+ nhExtIr+1x+oQIR1ft7Ah38= =3/Ia -END PGP SIGNATURE- -- To UNSUBSCRIBE, email to [EMAIL PROTECTED] with a subject of unsubscribe. Trouble? Contact [EMAIL PROTECTED]
Re: doc compilations: build-time or pre-built?
tony mancill [EMAIL PROTECTED] writes: Steinar H. Gunderson wrote: On Tue, Jul 04, 2006 at 07:25:16PM -0300, [EMAIL PROTECTED] wrote: 1) compile docs pre-build-time; or 2) compile docs in build-time Definitely the latter. We build stuff at build time for a reason, architecture-specific or -independent alike. Is this the consensus/best-practice on this question? It seems like it would be quite taxing on the autobuilders to have to pull something like docbook (and its chain of dependencies) into a pbuilder just to recompile a manpage that doesn't change between architectures. I'm interested in this because I've typically done (2), but have recently started to think that (1) is more appropriate, particularly for packages where the documentation is a simple manpage. And It's exactly this the case in question, for me. Thanks, tony -- Marcio Roberto Teixeira ___ I use newsreader (nntp). Don't send messages directly to my email, please (even replies or follow-ups); keep all threads here and only here. ^^^ keys: hkp://wwwkeys.pgp.net http://marciotex.googlepages.com/keypub_8709626B.asc home page (building): http://marciotex.googlepages.com tchê Debian/GNULinux user Porto Alegre - RS - Brasil -- To UNSUBSCRIBE, email to [EMAIL PROTECTED] with a subject of unsubscribe. Trouble? Contact [EMAIL PROTECTED]
Re: doc compilations: build-time or pre-built?
tony mancill wrote: It seems like it would be quite taxing on the autobuilders to have to pull something like docbook (and its chain of dependencies) into a pbuilder just to recompile a manpage that doesn't change between architectures. AIUI, the autobuilders use sbuild and don't purge the installed packages unless the admins do so manually. At least, that is what I have been told on the subject. I'm interested in this because I've typically done (2), but have recently started to think that (1) is more appropriate, particularly for packages where the documentation is a simple manpage. -Roberto -- Roberto C. Sanchez http://familiasanchez.net/~roberto signature.asc Description: OpenPGP digital signature
