tazwok view tazwok @ rev 455
tazwok: fix FSH check
| author | Pascal Bellard <pascal.bellard@slitaz.org> |
|---|---|
| date | Wed Mar 16 09:58:08 2011 +0100 (2011-03-16) |
| parents | 7e7265ac0dc0 |
| children | 8b6dc81c4967 |
line source
1 #!/bin/sh
2 # Tazwok - SliTaz source compiler and binary packages generator/cooker.
3 #
4 # Tazwok can compile source packages and create binary packages suitable for
5 # Tazpkg (Tiny Autonomous zone package manager). You can build individual
6 # packages or a list of packages with one command, rebuild the full distro,
7 # generate a packages repository and also list and get info about packages.
8 #
9 # (C) 2007-2009 SliTaz - GNU General Public License.
10 #
12 VERSION=4.2.8
13 . /usr/lib/slitaz/libtaz
14 source_lib commons
16 # Use text instead of numbers, don't get $2 here if it's an option.
17 [ "$2" = "${2#--}" ] && PACKAGE=$2 && LIST=$2 && ARG=$2
18 COMMAND=$1
20 ########################################################################
21 # TAZWOK USAGE
22 ########################
23 # Print the usage (English).
25 usage()
26 {
27 echo -e "\nSliTaz sources compiler and packages generator - Version: $VERSION\n
28 \033[1mUsage: \033[0m `basename $0` [command] [package|list|category|dir|id] [--option]
29 \033[1mCommands: \033[0m\n
30 usage Print this short usage.
31 stats Print Tazwok statistics from the config file and the wok.
32 edit Edit a package receipt in the current wok.
33 build-depends Generate a list of packages to build a wok.
34 list List all packages in the wok tree or by category.
35 info Get information about a package in the wok.
36 report Display commit/cooklist/broken/blocked.
37 check Check every receipt for common errors.
38 check-log Check the process log file of a package.
39 check-depends* Check every receipt for DEPENDS - doesn't scan ELF files.
40 check-src Check upstream tarball for package in the wok.
41 search Search for a package in the wok by pattern or name.
42 compile Configure and build a package using the receipt rules.
43 genpkg Generate a suitable package for Tazpkg with the rules.
44 cook Compile and generate a package directly.
45 cook-list Cook all packages specified in the list by order.
46 cook-commit Cook all modified receipts.
47 cook-all Cook all packages except toolchain.
48 cook-toolchain Cook the toolchain packages.
49 gen-cooklist Generate a sorted cooklist using packages or list.
50 sort-cooklist Sort the cooklist given in argument.
51 get-src Download the tarball of the package given in argument.
52 clean Clean all generated files in the package tree.
53 new-tree Prepare a new package tree and receipt (--interactive).
54 gen-list (Re-)Generate a packages list for a repository.
55 check-list Update packages lists for a repository.
56 gen-wok-db (Re-)Generate wok lists with depends and wanted data.
57 gen-clean-wok Generate a clean wok in a dir.
58 clean-wok Clean entirely the wok.
59 clean-src Remove old/unrelated-to-wok sources.
60 remove Remove a package from the wok.
61 webserver Enable/disable webserver on localhost.
62 update-wok Update the wok.
63 maintainers List all maintainers in the wok.
64 maintained-by List packages maintained by a contributor.
65 tags List all tags used in wok receipts.
66 block Add package from the blocked list to prevent cooking it.
67 unblock Remove package from the blocked list.\n
69 You can use `basename $0` command --help to list available options.
70 \033[1mImportant - *: \033[0m Commands which need a rewrite."
71 }
73 # This function displays an error message without returning any error code.
74 # It also logs the message in source package's warnings.txt; this file can be
75 # used on an eventual package page on website to display cooking warnings.
76 tazwok_warning()
77 {
78 echo -e "tazwok: $1" >&2
79 echo -e "$1" >> $WOK/${WANTED:-$PACKAGE}/warning.txt
80 return
81 }
83 ########################################################################
84 # TAZWOK VARIABLES & INITIAL CONFIGURATION
85 ########################
87 get_tazwok_config()
88 {
89 # Get configuration file.
90 get_config
92 # Define & get options.
93 get_options_list="$get_options_list SLITAZ_DIR SLITAZ_VERSION undigest"
94 get_options
96 LOCAL_REPOSITORY=$SLITAZ_DIR/${undigest:-$SLITAZ_VERSION}
98 if ! [ "$save_dir" ]; then
99 if [ -f $LOCAL_REPOSITORY/tazwok.conf ] || [ -f $LOCAL_REPOSITORY/slitaz.conf ]; then
100 save_dir=$LOCAL_REPOSITORY
101 [ -f $LOCAL_REPOSITORY/slitaz.conf ] && source $LOCAL_REPOSITORY/slitaz.conf
102 cd $save_dir
103 get_tazwok_config
104 unset save_dir
105 return
106 fi
107 fi
109 # The path to the most important files/dir used by Tazwok.
110 PACKAGES_REPOSITORY=$LOCAL_REPOSITORY/packages
111 WOK=$LOCAL_REPOSITORY/wok
112 INCOMING_REPOSITORY=$LOCAL_REPOSITORY/packages-incoming
113 SOURCES_REPOSITORY=$LOCAL_REPOSITORY/src
114 set_common_path
116 # /!\ This part needs some changes.
117 # Basically, get these files from the net if they are missing.
118 dep_db=$INCOMING_REPOSITORY/wok-depends.txt
119 wan_db=$INCOMING_REPOSITORY/wok-wanted.txt
121 # Check commons directories, create them if user is root.
122 if test $(id -u) = 0 ; then
123 check_dir $WOK || chmod 777 $WOK
124 check_dir $LOCAL_REPOSITORY/clean-wok || chmod 777 $LOCAL_REPOSITORY/clean-wok
125 check_dir $PACKAGES_REPOSITORY
126 check_dir $SOURCES_REPOSITORY
127 check_dir $INCOMING_REPOSITORY
128 check_dir $LOCAL_REPOSITORY/log
129 [ -f $dep_db ] || touch $dep_db
130 [ -f $wan_db ] || touch $wan_db
131 [ -f $PACKAGES_REPOSITORY/cookorder.txt ] || touch $PACKAGES_REPOSITORY/cookorder.txt
132 for file in broken blocked commit incoming cooklist; do
133 [ ! -f $PACKAGES_REPOSITORY/$file ] && touch $PACKAGES_REPOSITORY/$file
134 done
135 touch $SOURCES_REPOSITORY/sources.list
136 fi
138 # Limit memory usage.
139 ulimit -v $(awk '/MemTotal|SwapTotal/ { n+=$2 } END { print int((n*80)/100) }' < /proc/meminfo)
141 # log steps for webserver.
142 log_step="$LOCAL_REPOSITORY/log/step"
143 run_on_exit="$run_on_exit
144 rm -f $LOCAL_REPOSITORY/log/step
145 rm -f $LOCAL_REPOSITORY/log/package"
146 }
148 # Used in several functions.
149 set_common_path()
150 {
151 # The receipt is used to compile the source code and
152 # generate suitable packages for Tazpkg.
153 RECEIPT="$WOK/$PACKAGE/receipt"
155 # The path to the process log file.
156 LOG="$WOK/$PACKAGE/process.log"
157 }
159 ########################################################################
160 # TAZWOK CHECK FUNCTIONS
161 ########################
163 # Check for a package name on cmdline.
164 check_for_package_on_cmdline()
165 {
166 if [ ! "$PACKAGE" ]; then
167 echo -e "\nYou must specify a package name on the command line." >&2
168 echo -e "Example : tazwok $COMMAND package\n" >&2
169 exit 1
170 fi
171 }
173 # Check for the receipt of a package used to cook.
174 check_for_receipt()
175 {
176 if [ ! -f "$RECEIPT" ]; then
177 echo -e "\nUnable to find the receipt : $RECEIPT\n" >&2
178 exit 1
179 fi
180 }
182 # Check for a specified file list on cmdline.
183 check_for_list()
184 {
185 if [ ! "$LIST" ]; then
186 echo -e "\nPlease specify the path to the list of packages to cook.\n" >&2
187 exit 1
188 fi
190 # Check if the list of packages exists.
191 if [ -f "$LIST" ]; then
192 LIST=`cat $LIST`
193 else
194 echo -e "\nUnable to find $LIST packages list.\n" >&2
195 exit 1
196 fi
198 if [ ! "$LIST" ]; then
199 echo -e "\nList is empty.\n" >&2
200 exit 1
201 fi
202 }
204 check_for_pkg_in_wok()
205 {
206 [ -f $WOK/$PACKAGE/receipt ] && return
207 if [ "$undigest" ]; then
208 [ -f "$SLITAZ_VERSION/wok/$PACKAGE/receipt" ] && return 1
209 grep -q ^$PACKAGE$ $SLITAZ_DIR/$SLITAZ_VERSION/packages/packages.txt && return 1
210 fi
211 echo "Can't find $PACKAGE in wok or mirror" >&2
212 return 2
213 }
215 ########################################################################
216 # TAZWOK CORE FUNCTIONS
217 ########################
219 remove_src()
220 {
221 [ "$WANTED" ] && return
222 look_for_cookopt !remove_src && return
223 if [ ! -d $WOK/$PACKAGE/install ] && [ "$src" ] && [ -d "$src/_pkg" ]; then
224 check_for_var_modification _pkg src || return
225 mv "$src/_pkg" $WOK/$PACKAGE/install
226 fi
228 # Don't remove sources if a package uses src variable in its
229 # genpkg_rules: it maybe needs something inside.
230 for i in $PACKAGE $(look_for_rwanted); do
231 sed -n '/^genpkg_rules\(\)/','/}/'p $WOK/$i/receipt | \
232 fgrep -q '$src' && tazwok_warning "Sources will not be removed \
233 because $i uses \$src in its receipt." && return
234 done
236 report step "Removing sources directory"
237 rm -fr "$src"
238 report end-step
239 }
241 # Check $COOK_OPT; usage : get_cookopt particular_opt
242 # Return error if not found
243 # Return args if the opt is in the format opt=arg1:arg2:etc
244 look_for_cookopt()
245 {
246 for arg in $COOK_OPT; do
247 case $arg in
248 $1=*)
249 arg=${arg#$1=}
250 while [ "$arg" ]; do
251 echo "${arg%%:*}"
252 [ "${arg/:}" = "$arg" ] && return
253 arg=${arg#*:}
254 done
255 ;;
256 $1)
257 return
258 ;;
259 esac
260 done
261 return 1
262 }
264 # Check for the wanted package if specified in WANTED
265 # receipt variable. Set the $src/$_pkg variable to help compile
266 # and generate packages.
267 check_for_wanted()
268 {
269 if [ "$WANTED" ]; then
270 report "Checking for the wanted package"
271 if [ ! -d "$WOK/$WANTED" ]; then
272 report exit "\nWanted package is missing in the work directory.\n"
273 fi
275 # Checking for buildtree of Wanted package
276 if [ ! -d "$WOK/$WANTED/taz" ]; then
277 echo -e "\n\nSource files of wanted package is missing in the work directory."
278 echo -n "Would you like to build the missing package (y/N) ? " ; read anser
279 if [ "$anser" == "y" ]; then
280 tazwok cook $WANTED
281 else
282 report exit "\nWanted package source tree is missing in the work directory.\n"
283 fi
284 fi
285 report end-step
287 # Set wanted src path.
288 set_src_path && set_pkg_path
290 fi
291 }
293 # Check for build dependencies, notify user and install if specified.
294 check_for_build_depends()
295 {
296 [ "$WANTED" ] && return
297 [ "$CATEGORY" = meta ] && ! fgrep -q compile_rules $RECEIPT && return
298 [ ! "$BUILD_DEPENDS" ] && ! fgrep -q compile_rules $RECEIPT && return
299 report step "Looking for build dependencies"
301 # Keep the list of previously installed build_depends then compare
302 # it with new build_depends to know what to install and what to
303 # what to remove.
304 plan_remove=" $MISSING_PACKAGE $remove_later "
305 [ ! "${plan_remove// }" ] && unset plan_remove
306 unset MISSING_PACKAGE remove_later
307 rwanted=$(look_for_rwanted)
309 for pkg in $(scan $PACKAGE --look_for=bdep --with_dev | \
310 grep -v $(for i in $(look_for_rwanted) $PACKAGE; do echo " -e ^$i$"; done))
311 do
313 # Delay the removing of previous cook depends if they are needed
314 # for next cook too.
315 if [ ! -d "$INSTALLED/$pkg" ] ; then
316 MISSING_PACKAGE="$MISSING_PACKAGE $pkg"
317 fi
318 if [ "$plan_remove" != "${plan_remove/ $pkg }" ]; then
319 plan_remove="${plan_remove/ $pkg / }"
320 remove_later="$remove_later $pkg"
321 fi
322 if grep -q ^$pkg$ $PACKAGES_REPOSITORY/broken; then
323 broken="$broken$pkg "
324 fi
325 done
327 # Don't cook if a depend is broken.
328 if [ "$broken" ]; then
329 MISSING_PACKAGE=$plan_remove
330 echo "Can't cook $PACKAGE because of broken depend(s) : $broken" >&2
331 unset plan_remove broken
333 # Set report step to failed.
334 report_return_code=1
335 report end-step
336 return 1
337 fi
338 if [ "$MISSING_PACKAGE" ]; then
339 install_missing()
340 {
341 echo "Installing missing packages : $MISSING_PACKAGE"
342 for pkg in $MISSING_PACKAGE; do
343 [ -d "$INSTALLED/$pkg" ] || tazpkg get-install $pkg
344 done
345 }
346 if [ "$auto_install" = yes ]; then
347 install_missing
348 else
349 echo "================================================================================"
350 for pkg in $MISSING_PACKAGE
351 do
352 echo "Missing : $pkg"
353 done
354 echo "================================================================================"
355 echo "You can continue, exit or install missing dependencies."
356 echo -n "Install, continue or exit (install/y/N) ? "; read answer
357 case $answer in
358 install)
359 install_missing ;;
360 y|yes)
361 unset MISSING_PACKAGE;;
362 *)
363 report stop
364 exit 0 ;;
365 esac
366 fi
367 fi
368 report end-step
369 remove_build_depends $plan_remove
370 unset plan_remove
371 }
373 remove_build_depends()
374 {
375 [ "$1" ] || return
376 report step "Removing previous build dependencies"
377 echo "Removing these packages : $@"
378 for pkg in $@; do
379 [ -f "$INSTALLED/$pkg/receipt" ] && tazpkg remove $pkg --auto
380 done
381 cd $PWD
382 report end-step
383 }
385 # Check if we can use the new way to handle tarball
386 # or if we keep the previous method by checking for
387 # _pkg=/src= in receipt and reverse-wanted.
388 check_for_var_modification()
389 {
390 for var in $@; do
391 for pkg in $PACKAGE $(look_for_wanted) $(look_for_rwanted); do
392 [ -f $WOK/$pkg/receipt ] || continue
393 fgrep -q "$var=" $WOK/$pkg/receipt && return 1
394 done
395 done
397 # Tweak to make if; then...; fi function working with this one.
398 echo -n ""
399 }
401 set_src_path()
402 {
403 if check_for_var_modification src _pkg; then
404 src=$WOK/${WANTED:-$PACKAGE}/${WANTED:-$PACKAGE}-$VERSION
405 else
406 tazwok_warning "Use original name or tarball root directory because src/_pkg is defined in the receipt (this is no longer needed!)."
407 src=$WOK/${WANTED:-$PACKAGE}/${SOURCE:-${WANTED:-$PACKAGE}}-$VERSION
408 fi
409 stuff=$WOK/$PACKAGE/stuff
410 [ "$WANTED" ] && wanted_stuff=$WOK/$WANTED/stuff
411 }
413 set_pkg_path()
414 {
415 if [ -d $WOK/${WANTED:-$PACKAGE}/install ] ; then
416 _pkg=$WOK/${WANTED:-$PACKAGE}/install
417 else
418 _pkg=$src/_pkg
419 fi
420 }
422 # Output $VERSION-$EXTRAVERSION using packages.txt
423 get_pkg_version()
424 {
425 [ "$PACKAGE" ] || return
426 grep -m1 -A1 -sh ^$PACKAGE$ $1/packages.txt | tail -1 | sed 's/ *//'
427 }
429 remove_previous_package()
430 {
431 [ "$prev_VERSION" ] || return
432 if [ "$VERSION$EXTRAVERSION" != "$prev_VERSION" ]; then
433 rm -f $1/$PACKAGE-$prev_VERSION.tazpkg
434 fi
435 return 0
436 }
438 # Check for src tarball and wget if needed.
439 check_for_tarball()
440 {
441 [ "$WGET_URL" ] || return 0
442 look_for_cookopt !unpack && nounpack=yes
443 report step "Checking for source tarball: $PACKAGE"
444 local repack_src=$repack_src TARBALL=$TARBALL
445 if [ "$repack_src" = yes ] && look_for_cookopt !repack_src; then
446 repack_src=no
447 fi
448 if [ "$target" ]; then
449 src="$target"
450 else
451 set_src_path
452 fi
453 tmp_src=$tmp/tarball-$$
454 if [ ! -f "$SOURCES_REPOSITORY/$TARBALL" ] && \
455 [ ! -f "$SOURCES_REPOSITORY/${SOURCE:-$PACKAGE}-$VERSION.tar.lzma" ] ; then
456 cd $SOURCES_REPOSITORY
457 if [ "$SOURCE" ]; then
458 alt_url="http://mirror.slitaz.org/sources/packages/${SOURCE:0:1}/$SOURCE-$VERSION.tar.lzma"
459 else
460 alt_url="http://mirror.slitaz.org/sources/packages/${PACKAGE:0:1}/$PACKAGE-$VERSION.tar.lzma"
461 fi
462 download $WGET_URL $alt_url http://mirror.slitaz.org/sources/packages/${TARBALL:0:1}/$TARBALL
463 unset alt_url
464 if [ ! -f "$SOURCES_REPOSITORY/$TARBALL" ] && \
465 [ ! -f "$SOURCES_REPOSITORY/${SOURCE:-$PACKAGE}-$VERSION.tar.lzma" ] && \
466 [ ! -d $tmp_src ]; then
467 echo -e "\nDownload failed, exiting. Please check WGET_URL variable.\n" >&2
468 report end-step
469 return 1
470 fi
471 fi
472 report end-step
473 if { [ -f "$SOURCES_REPOSITORY/${SOURCE:-$PACKAGE}-$VERSION.tar.lzma" ] && [ "$nounpack" ] ; } || \
474 { [ -f "$SOURCES_REPOSITORY/$TARBALL" ] && [ "$repack_src" != yes ] && [ "$nounpack" ] ; }; then
475 [ -d "$tmp_src" ] && rm -r $tmp_src
476 return 0
477 fi
479 # Untaring source if necessary. We don't need to extract source if
480 # the package is built with a wanted source package.
481 if [ "$WANTED" ]; then
482 [ -d "$tmp_src" ] && rm -r $tmp_src
483 return
484 fi
486 report step "Untaring source tarball"
488 # Log process.
489 echo "untaring source tarball" >> $LOG
491 # If $tmp_src exists, there's already a unpacked tarball in it.
492 if ! [ -d $tmp_src ]; then
493 mkdir $tmp_src
494 if [ -f "$SOURCES_REPOSITORY/${SOURCE:-$PACKAGE}-$VERSION.tar.lzma" ] && [ "$repack_src" = yes ]; then
495 lzma d $SOURCES_REPOSITORY/${SOURCE:-$PACKAGE}-$VERSION.tar.lzma -so | \
496 tar xf - -C $tmp_src
497 repack_src=no
498 TARBALL=${SOURCE:-$PACKAGE}-$VERSION.tar.lzma
499 elif [ -f "$SOURCES_REPOSITORY/$TARBALL" ]; then
500 case "$TARBALL" in
501 *zip|*xpi) cd $tmp_src && unzip -o $SOURCES_REPOSITORY/$TARBALL ;;
502 *bz2|*tbz|*gem) tar xjf $SOURCES_REPOSITORY/$TARBALL -C $tmp_src;;
503 *tar) tar xf $SOURCES_REPOSITORY/$TARBALL -C $tmp_src;;
504 *lzma|*lz) unlzma -c $SOURCES_REPOSITORY/$TARBALL | tar xf - -C $tmp_src;;
505 *xz) unxz -c $SOURCES_REPOSITORY/$TARBALL | tar xf - -C $tmp_src;;
506 *Z|*taz) uncompress -c $SOURCES_REPOSITORY/$TARBALL | tar xf - -C $tmp_src;;
507 *gz) tar xzf $SOURCES_REPOSITORY/$TARBALL -C $tmp_src;;
508 *rpm) cd $tmp_src && rpm2cpio $SOURCES_REPOSITORY/$TARBALL | cpio -idm --quiet;;
510 # It's a plain file or something receipt unpack itself.
511 *)
512 mkdir $tmp_src/${SOURCE:-$PACKAGE}-$VERSION
513 cp $SOURCES_REPOSITORY/$TARBALL $tmp_src/${src##*/}
514 ;;
516 esac || { report end-step
517 rm -f $SOURCES_REPOSITORY/$TARBALL
518 rm -r $tmp_src
519 return 1
520 }
521 fi
523 # Check if uncompressed tarball is in a root dir or not.
524 if [ "$(ls -A $tmp_src | wc -l)" -gt 1 ] || [ -f $(echo $tmp_src/*) ]; then
525 if check_for_var_modification src _pkg; then
526 mv $tmp_src $tmp_src-1
527 mkdir $tmp_src
528 mv $tmp_src-1 $tmp_src/${SOURCE:-$PACKAGE}-$VERSION
529 else
530 mv $tmp_src/* $WOK/$PACKAGE
531 repack_src=no
532 rm -r $tmp_src
533 tazwok_warning "Putting all files in $WOK/$PACKAGE; not sure about how to handle this tarball (no root dir)... Please try to remove src/_pkg definition from the receipt if you encounter any problems."
534 fi
535 fi
536 fi
538 if [ "$repack_src" = yes ]; then
539 report step "Repacking sources in .tar.lzma format"
540 [ "$TARBALL" ] && rm -f $SOURCES_REPOSITORY/$TARBALL
541 TARBALL=${SOURCE:-$PACKAGE}-$VERSION.tar.lzma
542 cd $tmp_src
543 tar -c * | lzma e $SOURCES_REPOSITORY/$TARBALL -si
544 fi
546 # Remove previous tarball if no other package needs it. We take care to
547 # keep tarball if the same package uses it in the main repository.
548 if [ "$TARBALL" ]; then
549 previous_tarball=$(grep ^$PACKAGE:incoming $SOURCES_REPOSITORY/sources.list | cut -f2)
550 if [ "$previous_tarball" ]; then
551 sed "/^$PACKAGE:incoming/ s/.*/$PACKAGE:incoming\t$TARBALL/" \
552 -i $SOURCES_REPOSITORY/sources.list
553 grep -q $'\t'$previous_tarball$ $SOURCES_REPOSITORY/sources.list || \
554 rm -f $SOURCES_REPOSITORY/$previous_tarball
555 else
556 echo -e "$PACKAGE:incoming\t$TARBALL" >> $SOURCES_REPOSITORY/sources.list
557 fi
558 fi
560 if [ "$nounpack" ]; then
561 [ -d "$tmp_src" ] && rm -r $tmp_src
562 report end-step
563 return
564 fi
565 if [ ! -d "$src" ]|| [ "$target" ]; then
566 # Permissions settings.
567 chown -R root.root "$tmp_src"
568 if [ -d "$src" ]; then
569 mkdir -p $src
570 for f in $tmp_src/*/*; do
571 cp -a $f $src || { report end-step; rm -r $tmp_src; return 1; }
572 done
573 else
574 if ! check_for_var_modification src _pkg && ! [ "$target" ]; then
575 src="${src%/*}/$(ls $tmp_src)"
576 fi
577 mv $(echo $tmp_src/*) "$src" || { report end-step; rm -r $tmp_src; return 1; }
578 fi
579 rm -r $tmp_src
580 else
581 [ -d "$tmp_src" ] && rm -r $tmp_src
582 echo "There's already something at $src. Abort." >&2
583 fi
584 report end-step
585 }
587 # Log and execute compile_rules function if it exists, to configure and
588 # make the package if it exists.
589 check_for_compile_rules()
590 {
591 if grep -q ^compile_rules $RECEIPT; then
592 echo "executing compile_rules" >> $LOG
593 report step "Executing compile_rules"
594 cd $WOK/$PACKAGE
595 rm -f /tmp/config.site
596 ulimit -d unlimited
597 ulimit -m unlimited
599 # Free some RAM by cleaning cache if option is enabled.
600 freeram=$(free | fgrep '/+ buffers' | tr -s ' ' | cut -f 4 -d ' ')
602 # Disable -pipe in CFLAGS/CXXFLAGS if less than 512Mb of free
603 # RAM are available.
604 if [ "$freeram" -lt 524288 ] && [ "$CFLAGS" != "${CFLAGS/-pipe}" -o \
605 "$CXXFLAGS" != "${CXXFLAGS/-pipe}" ]; then
606 tazwok_warning "Disabling -pipe compile flag because only ${freeram}b of RAM is available."
607 CFLAGS="${CFLAGS/-pipe}"
608 CXXFLAGS="${CXXFLAGS/-pipe}"
609 fi
610 unset freeram
612 # Set cook environement variables.
613 [ "$src" ] || set_src_path
614 [ "$DESTDIR" ] || DESTDIR="$WOK/$PACKAGE/install"
615 [ "$CONFIG_SITE" ] || CONFIG_SITE=/etc/config.site
616 export CFLAGS CXXFLAGS MAKEFLAGS DESTDIR BUILD_HOST \
617 CONFIG_SITE default_prefix \
618 default_datarootdir default_datadir default_localedir \
619 default_infodir default_mandir default_build default_host
620 local LC_ALL=POSIX LANG=POSIX
621 compile_rules
623 # Check if config.site has been used.
624 # /!\ disabled since it screws the return_code of the step.
625 #if [ -f /tmp/config.site ]; then
626 # rm /tmp/config.site
627 #else
628 # tazwok_warning "config.site hasn't been used during \
629 #the configuration process."
630 #fi
631 report end-step
632 fi
633 }
635 # Check for loop in deps tree. /!\ can be removed.
636 check_for_deps_loop()
637 {
638 local list
639 local pkg
640 local deps
641 pkg=$1
642 shift
643 [ -n "$1" ] || return
644 list=""
646 # Filter out already processed deps.
647 for i in $@; do
648 case " $ALL_DEPS" in
649 *\ $i\ *);;
650 *) list="$list $i";;
651 esac
652 done
653 ALL_DEPS="$ALL_DEPS$list "
654 for i in $list; do
655 [ -f $i/receipt ] || continue
656 deps="$(DEPENDS=""; . $i/receipt; echo $DEPENDS)"
657 case " $deps " in
658 *\ $pkg\ *) echo -e "$MSG $i"; MSG="";;
659 *) check_for_deps_loop $pkg $deps;;
660 esac
661 done
662 }
664 # Function used by download().
665 revert_vcs_failure()
666 {
667 cd $SOURCES_REPOSITORY
668 rm -r $tmp_src
669 }
671 download()
672 {
673 if [ "$COMMAND" = get-src ]; then
674 if [ "${DEPENDS/tar}" != "$DEPENDS" ] || [ "${BUILD_DEPENDS/tar}" != "$BUILD_DEPENDS" ]; then
675 [ -f $INSTALLED/tar/receipt ] || tazpkg get-install tar --forced
676 fi
677 fi
678 for file in $@; do
679 echo "Downloading from ${file#*|}..."
680 case "$file" in
681 git\|*)
682 file=${file#git|}
683 [ "$COMMAND" = get-src ] && [ ! -f $INSTALLED/git/receipt ] && tazpkg get-install git --forced
684 if [ -f $INSTALLED/git/receipt ]; then
685 mkdir $tmp_src
686 cd $tmp_src
687 if [ "$BRANCH" ]; then
688 git clone $file ${src##*/} && cd ${src##*/} && \
689 git checkout $BRANCH && rm -rf .git* && break
690 else
691 git clone $file ${src##*/} && rm -rf ${src##*/}/.git* && break
692 fi
693 revert_vcs_failure
694 else
695 tazwok_warning "Needs git to download the source tarball from $file, please add it as a build-depend."
696 continue
697 fi
698 ;;
699 bazaar\|*)
700 file=${file#bazaar|}
701 [ "$COMMAND" = get-src ] && [ ! -f $INSTALLED/bazaar/receipt ] && tazpkg get-install bazaar --forced
702 if [ -f $INSTALLED/bazaar/receipt ]; then
703 mkdir $tmp_src
704 cd $tmp_src
705 if [ "$BRANCH" ]; then
706 bzr co $file -r $BRANCH ${src##*/} && rm -rf ${src##*/}/.bzr* && break
707 else
708 bzr co $file ${src##*/} && rm -rf ${src##*/}/.bzr* && break
709 fi
710 revert_vcs_failure
711 else
712 tazwok_warning "Needs bazaar to download the source tarball from $file, please add it as a build-depend."
713 continue
714 fi
715 ;;
716 subversion\|*)
717 file=${file#subversion|}
718 [ "$COMMAND" = get-src ] && [ ! -f $INSTALLED/subversion/receipt ] && tazpkg get-install subversion --forced
719 if [ -f $INSTALLED/subversion/receipt ]; then
720 mkdir $tmp_src
721 cd $tmp_src
722 if [ "$BRANCH" ]; then
723 echo t | svn co $file -r $BRANCH ${src##*/} && rm -rf ${src##*/}/.svn* && break
724 else
725 echo t | svn co $file ${src##*/} && rm -rf ${src##*/}/.svn* && break
726 fi
727 revert_vcs_failure
728 else
729 tazwok_warning "Needs subversion to download the source tarball from $file, please add it as a build-depend."
730 continue
731 fi
732 ;;
733 mercurial\|*)
734 file=${file#mercurial|}
735 [ "$COMMAND" = get-src ] && [ ! -f $INSTALLED/mercurial/receipt ] && tazpkg get-install mercurial --forced
736 if [ -f $INSTALLED/mercurial/receipt ]; then
737 mkdir $tmp_src
738 cd $tmp_src
739 if [ "$BRANCH" ]; then
740 hg clone $file --rev $BRANCH ${src##*/} && rm -rf ${src##*/}/.hg* && break
741 else
742 hg clone $file ${src##*/} && rm -rf ${src##*/}/.hg* && break
743 fi
744 revert_vcs_failure
745 else
746 tazwok_warning "Needs mercurial to download the source tarball from $file, please add it as a build-depend."
747 continue
748 fi
749 ;;
750 https*)
751 [ "$COMMAND" = get-src ] && [ ! -f $INSTALLED/wget/receipt ] && tazpkg get-install wget --forced
752 if [ -d $INSTALLED/wget ]; then
753 if [ "${WGET_URL%$TARBALL}" = "$WGET_URL" ] && [ "$file" = "$WGET_URL" ]; then
754 wget -q --no-check-certificate -O $TARBALL $file && break
755 else
756 wget -q --no-check-certificate $file && break
757 fi
758 else
759 tazwok_warning "Needs wget to download the source tarball from $file, please add it as a build-depend."
760 continue
761 fi
762 ;;
763 http*|ftp*)
764 # Handle crappy URL.
765 if [ "$COMMAND" = get-src ]; then
766 if [ "${DEPENDS/wget}" != "$DEPENDS" ] || [ "${BUILD_DEPENDS/wget}" != "$BUILD_DEPENDS" ]; then
767 [ -f $INSALLED/wget/receipt ] || tazpkg get-install wget --forced
768 fi
769 fi
770 if [ "${WGET_URL%$TARBALL}" = "$WGET_URL" ] && [ "$file" = "$WGET_URL" ]; then
771 wget -q -O $TARBALL $file && break
772 else
773 wget -q $file && break
774 fi
775 ;;
776 esac
777 done
778 }
780 # Regenerate every package that wants a PACKAGE compiled.
781 refresh_packages_from_compile()
782 {
783 # make tazwok genpkg happy.
784 mkdir $WOK/$PACKAGE/taz
786 # Cook rwanted in default or specied order.
787 genlist=" $(look_for_rwanted | tr '\n' ' ') "
788 for i in $(look_for_cookopt genpkg | tac); do
789 [ "${genlist/ $i }" = "$genlist" ] && continue
790 genlist=" $i${genlist/ $i / }"
791 done
792 if [ "$genlist" ]; then
793 local PACKAGE SOURCE VERSION EXTRAVERSION CATEGORY SHORT_DESC \
794 MAINTAINER WEB_SITE WGET_URL DEPENDS BUILD_DEPENDS WANTED \
795 PACKED_SIZE UNPACKED_SIZE COOK_OPT PROVIDE CONFIG_FILES TAGS \
796 src _pkg DESTDIR CONFIG_SITE RECEIPT LOG stuff wanted_stuff
797 for PACKAGE in $genlist; do
798 set_common_path
799 gen_package
800 done
801 fi
802 }
804 # Copy all generic files (locale, pixmaps, .desktop). We use standard paths,
805 # so some packages need to copy these files with the receipt and genpkg_rules.
806 # This function is executed by gen_package when 'tazwok genpkg'.
807 copy_generic_files()
808 {
809 # In most cases, locales are in $_pkg/usr/share/locale so we copy files
810 # using generic variables and $LOCALE from Tazwok config file.
811 if [ "$LOCALE" ]; then
812 if [ -d "$_pkg/usr/share/locale" ]; then
813 for i in $LOCALE
814 do
815 if [ -d "$_pkg/usr/share/locale/$i" ]; then
816 mkdir -p $fs/usr/share/locale
817 cp -a $_pkg/usr/share/locale/$i $fs/usr/share/locale
818 fi
819 done
820 fi
821 fi
823 # Pixmaps (PNG or/and XPM only). Some icons/images can be added through
824 # genpkg_rules and generic copy can be disabled with GENERIC_PIXMAPS="no"
825 # in pkg receipt.
826 if [ "$GENERIC_PIXMAPS" != "no" ]; then
827 if [ -d "$_pkg/usr/share/pixmaps" ]; then
828 mkdir -p $fs/usr/share/pixmaps
829 cp -a $_pkg/usr/share/pixmaps/$PACKAGE.png \
830 $fs/usr/share/pixmaps 2>/dev/null
831 cp -a $_pkg/usr/share/pixmaps/$PACKAGE.xpm \
832 $fs/usr/share/pixmaps 2>/dev/null
833 fi
835 # Custom or homemade PNG pixmap can be in stuff.
836 if [ -f "stuff/$PACKAGE.png" ]; then
837 mkdir -p $fs/usr/share/pixmaps
838 cp -a stuff/$PACKAGE.png $fs/usr/share/pixmaps
839 fi
840 fi
842 # Desktop entry (.desktop).
843 if [ -d "$_pkg/usr/share/applications" ]; then
844 cp -a $_pkg/usr/share/applications $fs/usr/share
845 fi
847 # Homemade desktop file(s) can be in stuff.
848 if [ -d "stuff/applications" ]; then
849 mkdir -p $fs/usr/share
850 cp -a stuff/applications $fs/usr/share
851 fi
852 if [ -f "stuff/$PACKAGE.desktop" ]; then
853 mkdir -p $fs/usr/share/applications
854 cp -a stuff/$PACKAGE.desktop $fs/usr/share/applications
855 fi
856 }
858 # Find and strip : --strip-all (-s) or --strip-debug on static libs.
859 strip_package()
860 {
861 report step "Executing strip on all files"
863 # Binaries.
864 for dir in $fs/bin $fs/sbin $fs/usr/bin $fs/usr/sbin $fs/usr/games
865 do
866 if [ -d "$dir" ]; then
867 find $dir -type f -exec strip -s '{}' 2>/dev/null \;
868 fi
869 done
871 # Libraries.
872 find $fs -name "*.so*" -exec strip -s '{}' 2>/dev/null \;
873 find $fs -name "*.a" -exec strip --strip-debug '{}' 2>/dev/null \;
874 report end-step
875 }
877 # Remove .pyc and .pyo files from packages.
878 py_compiled_files_remove()
879 {
880 report step "Removing all .pyc and .pyo files from package"
881 find $fs -type f -name "*.pyc" -delete 2>/dev/null
882 find $fs -type f -name "*.pyo" -delete 2>/dev/null
883 report end-step
884 }
886 # Check FSH in a slitaz package (Path: /:/usr)
887 check_fsh()
888 {
889 cd $WOK/$PACKAGE/taz/*/fs
890 if [ -z "$(find * ! -type d)" ] && [ "$CATEGORY" != meta ]; then
891 echo "$PACKAGE fs is empty." >&2
892 cd $WOK/$PACKAGE && rm -rf taz
893 return 1
894 fi
895 [ -n "$FSH" ] || FSH="bin boot dev etc home init lib media mnt proc \
896 root sbin share sys tmp usr var vz usr/bin usr/games usr/include usr/lib \
897 usr/local usr/sbin usr/share usr/src"
898 error=0
899 for i in `ls -d * usr/* 2>/dev/null`
900 do
901 if ! echo $FSH | fgrep -q $i; then
902 echo "Wrong path: /$i" >&2
903 error=1
904 fi
905 done
906 if [ "$error" = "1" ]; then
907 cat << _EOT_
909 Package will install files in a non standard directory and won't be generated.
910 You may have a wrong copy path in genpkg_rules or need to add some options to
911 configure in compile_rules. Some valid options for SliTaz (Linux FSH):
913 --prefix=/usr
914 --sysconfdir=/etc
915 --libexecdir=/usr/lib/(pkgname)
916 --localstatedir=/var
917 --mandir=/usr/share/man
918 --infodir=/usr/share/info
920 For more information please read SliTaz docs and run: ./configure --help
921 ================================================================================
922 $PACKAGE package generation aborted.
924 _EOT_
926 # Dont generate a corrupted package.
927 cd $WOK/$PACKAGE && rm -rf taz
928 return 1
929 fi
930 return 0
931 }
933 gen_cookmd5()
934 {
935 # md5sum of cooking stuff make tazwok able to check for changes
936 # without hg.
937 cd $WOK/$PACKAGE
938 md5sum receipt > md5
939 [ -f description.txt ] && md5sum description.txt >> md5
940 if [ -d stuff ]; then
941 find stuff | while read file; do
942 md5sum $file >> md5
943 done
944 fi
945 }
947 set_pkg_broken()
948 {
949 if ! grep -q ^$PACKAGE$ $PACKAGES_REPOSITORY/broken; then
950 echo $PACKAGE >> $PACKAGES_REPOSITORY/broken
951 fi
953 # Remove pkg from cooklist to avoid re-cook it if no changes happen
954 # in the cook stuff.
955 sed "/^$PACKAGE$/d" -i $PACKAGES_REPOSITORY/cooklist
956 sed "/^$PACKAGE$/d" -i $PACKAGES_REPOSITORY/commit
958 gen_cookmd5
960 # Return 1 to make report know that its mother-function failed.
961 return 1
962 }
964 # Create a package tree and build the gziped cpio archive
965 # to make a SliTaz (.tazpkg) package.
966 gen_package()
967 {
968 check_root
969 check_for_package_on_cmdline
970 check_for_receipt
971 source_receipt
973 # May compute VERSION
974 if grep -q ^get_version $RECEIPT; then
975 get_version
976 fi
977 check_for_wanted
978 cd $WOK/$PACKAGE
980 # Remove old Tazwok package files.
981 [ -d "taz" ] && rm -rf taz
983 # Create the package tree and set useful variables.
984 fs=$WOK/$PACKAGE/taz/$PACKAGE-$VERSION/fs
985 mkdir -p $fs
987 # Set $src for standard package and $_pkg variables.
988 set_src_path
989 set_pkg_path
991 # Execute genpkg_rules, check package and copy generic files to build
992 # the package.
993 report step "Building $PACKAGE with the receipt"
994 report open-bloc
995 if look_for_cookopt !fs; then
996 :
997 elif grep -q ^genpkg_rules $RECEIPT; then
999 # Log process.
1000 echo "executing genpkg_rules" >> $LOG
1001 report step "Executing genpkg_rules"
1002 ( set -e; genpkg_rules ) || { set_pkg_broken; report close-bloc; return 1; }
1003 check_fsh || { set_pkg_broken; report close-bloc; return 1; }
1004 cd $WOK/$PACKAGE
1005 report end-step
1007 # Skip generic files for packages with a WANTED variable
1008 # (dev and split pkgs).
1009 if [ ! "$WANTED" ]; then
1010 copy_generic_files
1011 fi
1012 look_for_cookopt !strip || strip_package
1013 py_compiled_files_remove
1014 else
1015 echo "No package rules to gen $PACKAGE..." >&2
1016 set_pkg_broken
1017 report close-bloc
1018 return 1
1019 fi
1021 # Copy the receipt and description (if exists) into the binary package tree.
1022 cd $WOK/$PACKAGE
1023 report step "Copying the receipt"
1024 cp receipt taz/$PACKAGE-$VERSION
1025 report end-step
1026 if grep -q ^get_version $RECEIPT; then
1027 report step "Updating version in receipt"
1028 sed -i "s/^VERSION=.*/VERSION=\"$VERSION\"/" \
1029 taz/$PACKAGE-$VERSION/receipt
1030 report end-step
1031 fi
1032 if [ -f "description.txt" ]; then
1033 report step "Copying the description file"
1034 cp description.txt taz/$PACKAGE-$VERSION
1035 report end-step
1036 fi
1038 # Generate md5 of cooking stuff to look for commit later.
1039 gen_cookmd5
1040 echo -e "\n# md5sum of cooking stuff :" >> taz/$PACKAGE-$VERSION/receipt
1041 cat md5 | sed 's/^/# /' >> taz/$PACKAGE-$VERSION/receipt
1043 # Create the files.list by redirecting find output.
1044 report step "Creating the list of files"
1045 cd taz/$PACKAGE-$VERSION
1046 LAST_FILE=""
1047 { find fs -print; echo; } | while read file; do
1048 if [ "$LAST_FILE" ]; then
1049 case "$file" in
1050 $LAST_FILE/*)
1051 case "$(ls -ld "$LAST_FILE")" in
1052 drwxr-xr-x\ *\ root\ *\ root\ *);;
1053 *) echo ${LAST_FILE#fs};;
1054 esac;;
1055 *) echo ${LAST_FILE#fs};;
1056 esac
1057 fi
1058 LAST_FILE="$file"
1059 done > files.list
1061 # Next, check if something has changed in lib files.
1062 if fgrep -q '.so' files.list; then
1063 for rep in $INCOMING_REPOSITORY $PACKAGES_REPOSITORY \
1064 $([ "$undigest" ] && echo $SLITAZ_DIR/$SLITAZ_VERSION/packages-incoming && \
1065 echo $SLITAZ_DIR/$SLITAZ_VERSION/packages); do
1066 prev_VERSION=$(get_pkg_version $rep)
1067 [ "$prev_VERSION" ] && pkg_file=$rep/$PACKAGE-$prev_VERSION.tazpkg && break
1068 done
1069 if [ "$pkg_file" ]; then
1070 report step "Looking for major/minor updates in libraries"
1071 get_pkg_files $pkg_file
1072 cd $WOK/$PACKAGE/taz/$PACKAGE-$VERSION
1073 fgrep ".so" files.list | egrep -v "[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*" | \
1074 while read lib; do
1075 fgrep -q "$lib" $pkg_files_dir/files.list && continue
1076 echo "A minor/major update in libraries is detected, planning re-cook of reverse-depends of $PACKAGE."
1077 for rdep in $(scan $PACKAGE --look_for=rdep | use_wanted); do
1078 [ "$rdep" = "${WANTED:-$PACKAGE}" ] && continue
1079 grep -q ^$rdep$ $PACKAGES_REPOSITORY/blocked \
1080 $PACKAGES_REPOSITORY/cooklist && continue
1081 echo $rdep >> $PACKAGES_REPOSITORY/cooklist
1082 done
1083 regen_cooklist=yes
1084 break
1085 done
1086 rm -r $pkg_files_dir
1087 unset pkg_file
1088 report end-step
1089 fi
1090 fi
1091 if [ ! "$EXTRAVERSION" ]; then
1092 case "$PACKAGE" in
1093 linux*);;
1094 *) EXTRAVERSION="$(grep '/lib/modules/.*-slitaz/' files.list |\
1095 head -1 | sed 's|/lib/modules/\(.*\)-slitaz/.*|_\1|')";;
1096 esac
1097 fi
1098 rm -f $INCOMING_REPOSITORY/$PACKAGE-$VERSION$EXTRAVERSION.tazpkg 2> /dev/null
1099 report step "Creating md5sum of files"
1100 while read file; do
1101 [ -L "fs$file" ] && continue
1102 [ -f "fs$file" ] || continue
1103 md5sum "fs$file" | sed 's/ fs/ /'
1104 done < files.list > md5sum
1105 report end-step
1106 UNPACKED_SIZE=$(du -chs fs receipt files.list md5sum description.txt \
1107 2> /dev/null | awk '{ sz=$1 } END { print sz }')
1109 # Build cpio archives. Find, cpio and gzip the fs, finish by
1110 # removing the fs tree.
1111 # Don't log this because compression always outputs error messages.
1112 find fs -print | cpio -o -H newc | case "$PACKAGE-$COMPRESSION" in
1113 tazpkg-lzma) gzip > fs.cpio.gz;;
1114 *-lzma) lzma e fs.cpio.lzma -si;;
1115 *) gzip > fs.cpio.gz;;
1116 esac && rm -rf fs
1117 PACKED_SIZE=$(du -chs fs.cpio.* receipt files.list md5sum \
1118 description.txt 2> /dev/null | awk '{ sz=$1 } END { print sz }')
1119 report step "Updating receipt sizes"
1120 sed -i '/^PACKED_SIZE/d' receipt
1121 sed -i '/^UNPACKED_SIZE/d' receipt
1122 sed -i "s/^PACKAGE=/PACKED_SIZE=\"$PACKED_SIZE\"\nUNPACKED_SIZE=\"$UNPACKED_SIZE\"\nPACKAGE=/" receipt
1123 sed -i "s/^VERSION=$/VERSION=\"$VERSION\"/" receipt
1124 report end-step
1125 if [ "$EXTRAVERSION" ]; then
1126 report step "Updating receipt EXTRAVERSION"
1127 sed -i s/^EXTRAVERSION.*$// receipt
1128 sed -i "s/^VERSION=/EXTRAVERSION=\"$EXTRAVERSION\"\nVERSION=/" receipt
1129 fi
1130 prev_VERSION=$(get_pkg_version $INCOMING_REPOSITORY)
1131 remove_previous_package $INCOMING_REPOSITORY
1132 report step "Creating full cpio archive"
1133 find . -print | cpio -o -H newc > $INCOMING_REPOSITORY/$PACKAGE-$VERSION$EXTRAVERSION.tazpkg
1135 # Restore package tree in case we want to browse it.
1136 report step "Restoring original package tree"
1137 { zcat fs.cpio.gz 2> /dev/null || unlzma -c fs.cpio.lzma; } | cpio --quiet -id
1138 rm fs.cpio.* && cd ..
1140 # Recook of reverse-depends if package was broken.
1141 if grep -q "^$PACKAGE$" $PACKAGES_REPOSITORY/broken; then
1142 report step "Planning a re-try cook of reverse depends"
1143 sed "/^$PACKAGE$/d" -i $PACKAGES_REPOSITORY/broken
1144 for rdep in $(look_for_rdep); do
1145 grep -q "^$rdep$" $PACKAGES_REPOSITORY/broken || continue
1146 grep -q "^$rdep$" $PACKAGES_REPOSITORY/cooklist && continue
1147 echo "Adding $rdep to the cooklist"
1148 echo $rdep >> $PACKAGES_REPOSITORY/cooklist
1149 regen_cooklist=t
1150 done
1151 report end-step
1152 fi
1153 sed "/^$PACKAGE$/d" -i $PACKAGES_REPOSITORY/commit
1154 sed "/^$PACKAGE$/d" -i $PACKAGES_REPOSITORY/cooklist
1156 # Log process.
1157 echo "$PACKAGE-$VERSION$EXTRAVERSION.tazpkg (done)" >> $LOG
1158 report close-bloc
1159 echo "Package $PACKAGE ($VERSION$EXTRAVERSION) generated."
1160 echo "Size : `du -sh $INCOMING_REPOSITORY/$PACKAGE-$VERSION$EXTRAVERSION.tazpkg`"
1161 echo ""
1162 }
1164 ########################################################################
1165 # This section contains functions used by several other functions
1166 # below.
1167 ########################
1169 # Look for receipt/files.list in wok. If they can't be found, get them
1170 # from package. Accept one argument : absolute path to package.
1171 get_pkg_files()
1172 {
1173 pkg_files_dir=$tmp/$(basename ${1%.tazpkg})
1174 mkdir -p $pkg_files_dir && \
1175 cd $pkg_files_dir && \
1176 cpio --quiet -idm receipt < $1 && \
1177 cpio --quiet -idm files.list < $1
1178 }
1180 ########################################################################
1181 # This section contains functions to generate packages databases.
1182 ########################
1185 gen_packages_db()
1186 {
1187 # pkg_repository can be $PACKAGES_REPOSITORY or $INCOMING_REPOSITORY.
1188 [ "$pkg_repository" ] || pkg_repository=$PACKAGES_REPOSITORY
1189 cd $pkg_repository
1190 report step "Generating packages lists: $pkg_repository"
1191 report open-bloc
1192 report step "Removing old files"
1193 for file in files.list.lzma packages.list packages.txt \
1194 packages.desc packages.equiv packages.md5; do
1195 [ -f $file ] && rm $file
1196 done
1197 touch files.list
1199 packages_db_start
1200 unset RECEIPT
1201 report step "Reading data from all packages"
1202 for pkg in $(echo $pkg_repository/*.tazpkg | fgrep -v '*'); do
1203 get_packages_info
1204 done
1205 report end-step
1206 packages_db_end
1207 report close-bloc
1208 }
1210 update_packages_db()
1211 {
1212 [ "$pkg_repository" ] || pkg_repository=$PACKAGES_REPOSITORY
1213 cd $pkg_repository
1214 for file in packages.list packages.equiv packages.md5 packages.desc \
1215 packages.txt; do
1216 if [ ! -f "$file" ]; then
1217 gen_packages_db
1218 return
1219 fi
1220 done
1221 if [ -f files.list.lzma ]; then
1222 lzma d files.list.lzma files.list
1223 else
1224 gen_packages_db
1225 return
1226 fi
1227 report step "Updating packages lists: $pkg_repository"
1228 packages_db_start
1230 # Look for removed/update packages.
1231 touch stamp -r packages.list
1232 for PACKAGE in $(grep ^[0-9,a-z,A-Z] packages.txt); do
1233 pkg="$pkg_repository/$(grep -m1 ^$PACKAGE- packages.list).tazpkg"
1234 if ! [ -f "$pkg" ]; then
1235 erase_package_info
1236 else
1237 if [ "$pkg" -nt "stamp" ]; then
1238 updated_pkg="$updated_pkg
1239 $PACKAGE $pkg"
1240 elif [ ! -f $WOK/$PACKAGE/receipt ] && \
1241 [ "$COMMAND" = check-incoming -o "$pkg_repository" = "$INCOMING_REPOSITORY" ]; then
1242 erase_package_info
1243 echo "Removing $PACKAGE from $pkg_repository."
1244 rm $pkg
1245 [ -d $WOK/$PACKAGE ] && rm -r $WOK/$PACKAGE
1246 sed "/^$PACKAGE\t/d" -i $wan_db $dep_db
1247 for i in cookorder.txt cooklist commit blocked broken; do
1248 sed "/^$PACKAGE$/d" -i $PACKAGES_REPOSITORY/$i
1249 done
1250 rm -f $LOCAL_REPOSITORY/log/$PACKAGE.html
1251 if [ "$pkg_repository" = "$INCOMING_REPOSITORY" ] && \
1252 [ "$(sed 1!d $PACKAGES_REPOSITORY/cookorder.txt)" != "#PlanSort" ] ; then
1253 sed 1i"#PlanSort" -i $PACKAGES_REPOSITORY/cookorder.txt
1254 regen_cooklist=yes
1255 else
1256 echo "$PACKAGE" >> $PACKAGES_REPOSITORY/removed
1257 sed -n '1,10p' -i $PACKAGES_REPOSITORY/removed
1258 fi
1259 fi
1260 fi
1261 done
1262 rm stamp
1263 echo "$updated_pkg" | sed 1d | while read PACKAGE pkg; do
1264 erase_package_info
1265 get_packages_info
1266 done
1267 unset updated_pkg
1269 # Look for new packages.
1270 for pkg in $(echo $pkg_repository/*.tazpkg | fgrep -v '*'); do
1271 if ! fgrep -q " ${pkg##*/}" $pkg_repository/packages.md5; then
1272 get_packages_info
1273 fi
1274 done
1275 report end-step
1276 packages_db_end
1277 }
1279 packages_db_start()
1280 {
1281 if [ ! -s packages.txt ]; then
1282 echo "# SliTaz GNU/Linux - Packages list
1283 #
1284 # Packages : unknown
1285 # Date : $(date +%Y-%m-%d\ \%H:%M:%S)
1286 #
1287 " > packages.txt
1288 else
1289 sed -e 's/^# Packages :.*/# Packages : unknown/' \
1290 -e "s/# Date :.*/# Date : $(date +%Y-%m-%d\ \%H:%M:%S)/" \
1291 -i packages.txt
1292 fi
1294 # Needed in some cases as tazwok defines RECEIPT at configuration time
1295 # in this particular case it can break the script.
1296 unset RECEIPT
1297 }
1299 erase_package_info()
1300 {
1301 cd $pkg_repository
1302 sed "/^$PACKAGE$/,/^$/d" -i packages.txt
1303 sed "/^$PACKAGE /d" -i packages.desc
1304 sed -e "s/=$PACKAGE /= /" -e "s/ $PACKAGE / /" -e "s/ $PACKAGE$//" \
1305 -e "/=$PACKAGE$/d" -e "s/=[0-9,a-z,A-Z]:$PACKAGE /= /" \
1306 -e "s/ [0-9,a-z,A-Z]:$PACKAGE / /" -e "s/ [0-9,a-z,A-Z]:$PACKAGE$/ /" \
1307 -e "/=[0-9,a-z,A-Z]:$PACKAGE$/d" \
1308 -i packages.equiv
1309 sed "/^$PACKAGE:/d" -i files.list
1310 sed "/^$(basename ${pkg%.tazpkg})$/d" -i packages.list
1311 sed "/ $(basename $pkg)$/d" -i packages.md5
1312 }
1314 get_packages_info()
1315 {
1316 # If there's no taz folder in the wok, extract info from the
1317 # package.
1318 get_pkg_files $pkg
1319 source_receipt
1320 echo "Getting data from $PACKAGE"
1322 cat >> $pkg_repository/packages.txt << _EOT_
1323 $PACKAGE
1324 $VERSION$EXTRAVERSION
1325 $SHORT_DESC
1326 _EOT_
1327 if [ "$PACKED_SIZE" ]; then
1328 cat >> $pkg_repository/packages.txt << _EOT_
1329 $PACKED_SIZE ($UNPACKED_SIZE installed)
1331 _EOT_
1332 else
1333 echo "" >> $pkg_repository/packages.txt
1334 fi
1336 # Packages.desc is used by Tazpkgbox <tree>.
1337 echo "$PACKAGE | $VERSION$EXTRAVERSION | $SHORT_DESC | $CATEGORY | $WEB_SITE" >> $pkg_repository/packages.desc
1339 # Packages.equiv is used by tazpkg install to check depends.
1340 for i in $PROVIDE; do
1341 DEST=""
1342 echo $i | fgrep -q : && DEST="${i#*:}:"
1343 if grep -qs ^${i%:*}= $pkg_repository/packages.equiv; then
1344 sed -i "s/^${i%:*}=/${i%:*}=$DEST$PACKAGE /" $pkg_repository/packages.equiv
1345 else
1346 echo "${i%:*}=$DEST$PACKAGE" >> $pkg_repository/packages.equiv
1347 fi
1348 done
1350 if [ -f files.list ]; then
1351 { echo "$PACKAGE"; cat files.list; } | awk '
1352 BEGIN { name="" } { if (name == "") name=$0; else printf("%s: %s\n",name,$0); }' >> $pkg_repository/files.list
1353 fi
1355 cd .. && rm -r "$pkg_files_dir"
1357 cd $pkg_repository
1358 echo $(basename ${pkg%.tazpkg}) >> packages.list
1359 [ ! "$package_md5" ] && package_md5=$(md5sum $(basename $pkg))
1360 echo "$package_md5" >> packages.md5
1361 unset package_md5
1362 }
1364 source_receipt()
1365 {
1366 unset PACKAGE SOURCE VERSION EXTRAVERSION CATEGORY SHORT_DESC \
1367 MAINTAINER WEB_SITE WGET_URL DEPENDS BUILD_DEPENDS WANTED \
1368 PACKED_SIZE UNPACKED_SIZE COOK_OPT PROVIDE CONFIG_FILES TAGS \
1369 src _pkg DESTDIR CONFIG_SITE BRANCH TARBALL stuff wanted_stuff
1370 . ${RECEIPT:-$PWD/receipt}
1371 }
1373 packages_db_end()
1374 {
1375 cd $pkg_repository
1376 pkgs=$(wc -l packages.list | sed 's/ .*//')
1377 sed "s/# Packages : .*/# Packages : $pkgs/" -i packages.txt
1379 # If lists were updated it's generally needed to sort them well.
1380 if ! sort -c packages.list 2> /dev/null; then
1381 report step "Sorting packages lists"
1382 for file in packages.list packages.desc packages.equiv; do
1383 [ -f $file ] || continue
1384 sort -o $file $file
1385 done
1386 report end-step
1387 fi
1389 # Dont log this because lzma always output errors.
1390 lzma e files.list files.list.lzma
1391 rm -f files.list
1392 [ -f packages.equiv ] || touch packages.equiv
1393 }
1395 ########################################################################
1396 # This section contains functions to generate wok database.
1397 ########################
1399 gen_wok_db()
1400 {
1401 report step "Generating wok database"
1402 report open-bloc
1403 report step "Removing old files"
1404 for file in $wan_db $dep_db $PACKAGES_REPOSITORY/cookorder.txt; do
1405 [ -f $file ] && rm $file
1406 done
1407 report step "Generating wok-wanted.txt"
1408 gen_wan_db
1409 report step "Generating wok-depends.txt"
1410 for PACKAGE in $(cut -f1 -d '|' $PACKAGES_REPOSITORY/packages.desc \
1411 $INCOMING_REPOSITORY/packages.desc | sort -u); do
1412 RECEIPT=$WOK/$PACKAGE/receipt
1413 if [ -s $RECEIPT ]; then
1414 source_receipt
1415 echo -e $PACKAGE"\t "$DEPENDS" \t "$BUILD_DEPENDS' ' >> $dep_db
1416 fi
1417 done
1418 sort_db
1419 report close-bloc
1420 }
1422 gen_wan_db()
1423 {
1424 for RECEIPT in $(fgrep -l WANTED $WOK/*/receipt); do
1425 WANTED=
1426 source $RECEIPT
1427 [ "$WANTED" ] || continue
1428 echo -e $PACKAGE"\t"$WANTED >> $tmp/wan_db
1429 done
1430 if ! [ -f $wan_db ] || [ "$(diff -q $tmp/wan_db $wan_db)" ]; then
1431 mv -f $tmp/wan_db $wan_db
1432 plan_regen_cookorder=yes
1433 else
1434 rm $tmp/wan_db
1435 fi
1436 }
1438 update_wan_db()
1439 {
1440 local PACKAGE=$PACKAGE
1441 wanted_list=$(fgrep WANTED=\"$PACKAGE\" $WOK/*/receipt | cut -f1 -d ':')
1442 grep $'\t'$PACKAGE $wan_db | cut -f 1 | while read wan; do
1443 echo "$wanted_list" | fgrep -q /$wan/receipt && continue
1444 sed "/^$wan\t/d" -i $wan_db
1445 plan_regen_cookorder=yes
1446 done
1447 for RECEIPT in $wanted_list; do
1448 WANTED=
1449 source $RECEIPT
1450 [ "$WANTED" ] || continue
1451 wan_info=$(echo -e $PACKAGE"\t"$WANTED)
1452 [ "$wan_info" = "$(grep -m1 ^$PACKAGE$'\t' $wan_db 2>/dev/null)" ] && continue
1453 sed "/^$PACKAGE\t/d" -i $wan_db
1454 echo "$wan_info" >> $wan_db
1455 plan_regen_cookorder=yes
1456 plan_sort_wandb=yes
1457 done
1458 unset wanted_list
1459 }
1461 update_dep_db()
1462 {
1463 dep_info=$(echo -e $PACKAGE"\t "$DEPENDS" \t "$BUILD_DEPENDS' ')
1464 [ "$dep_info" = "$(grep -m1 ^$PACKAGE$'\t' $dep_db 2>/dev/null)" ] && return
1465 sed "/^$PACKAGE\t/d" -i $dep_db
1466 echo "$dep_info" >> $dep_db
1467 plan_regen_cookorder=yes
1468 plan_sort_depdb=yes
1469 }
1471 sort_db()
1472 {
1473 report step "Generating cookorder.txt"
1474 cat $dep_db | sed 's/ \t / /' | while read PACKAGE BUILD_DEPENDS; do
1475 grep -q ^$PACKAGE$'\t' $wan_db && continue
1477 # Replace each BUILD_DEPENDS with a WANTED package by it's
1478 # WANTED package.
1479 replace_by_wanted()
1480 {
1481 for p in $BUILD_DEPENDS; do
1482 if grep -q ^$p$'\t' $wan_db; then
1483 echo -n $(grep ^$p$'\t' $wan_db | cut -f 2)' '
1484 else
1485 echo -n $p' '
1486 fi
1487 done | tr ' ' '\n' | sort -u | sed "/^$PACKAGE$/d" | tr '\n' ' '
1488 }
1489 echo -e $PACKAGE"\t $(replace_by_wanted) "
1490 done > $tmp/db
1491 while [ -s "$tmp/db" ]; do
1492 status=start
1493 for pkg in $(cut -f 1 $tmp/db); do
1494 if ! fgrep -q ' '$pkg' ' $tmp/db; then
1495 echo $pkg >> $tmp/cookorder
1496 sed -e "/^$pkg\t/d" -e "s/ $pkg / /g" -i $tmp/db
1497 status=proceed
1498 fi
1499 done
1500 if [ "$status" = start ]; then
1501 cp -f $tmp/db /tmp/remain-depends.txt
1502 echo "Can't go further because of dependency loop(s). The remaining packages will be commented in the cookorder and will be unbuilt in case of major updates until the problem is solved." >&2
1503 for blocked in $(cut -f 1 $tmp/db); do
1504 echo "$blocked" >> $PACKAGES_REPOSITORY/blocked
1505 done
1506 break
1507 fi
1508 done
1509 [ -s $tmp/cookorder ] || touch $tmp/cookorder
1511 # The toolchain packages are moved in first position.
1512 grep $(for pkg in `scan "$SLITAZ_TOOLCHAIN $SLITAZ_TOOLCHAIN_EXTRA" \
1513 --look_for=all --with_args`; do echo " -e ^$pkg$"; done) \
1514 $tmp/cookorder | tac > $PACKAGES_REPOSITORY/cookorder.txt
1515 for pkg in $(cat $PACKAGES_REPOSITORY/cookorder.txt); do
1516 sed "/^$pkg$/d" -i $tmp/cookorder
1517 done
1519 tac $tmp/cookorder >> $PACKAGES_REPOSITORY/cookorder.txt
1520 unset plan_regen_cookorder
1521 report end-step
1522 }
1524 ########################################################################
1525 # SCAN CORE
1526 ########################
1527 # Includes various scan core-functions. It's not intended to be used
1528 # directly : prefer scan wrappers in next section.
1530 look_for_dep()
1531 {
1532 if [ "$undigest" ] && [ ! -f "$WOK/$PACKAGE/receipt" ]; then
1533 grep -m1 ^$PACKAGE$'\t' $SLITAZ_DIR/$SLITAZ_VERSION/packages-incoming/wok-depends.txt \
1534 | cut -f 2
1535 else
1536 grep -m1 ^$PACKAGE$'\t' $INCOMING_REPOSITORY/wok-depends.txt | \
1537 cut -f 2
1538 fi
1539 }
1541 look_for_bdep()
1542 {
1543 look_for_all
1544 }
1546 look_for_all()
1547 {
1548 if [ "$undigest" ] && [ ! -f "$WOK/$PACKAGE/receipt" ]; then
1549 grep -m1 ^$PACKAGE$'\t' $SLITAZ_DIR/$SLITAZ_VERSION/packages-incoming/wok-depends.txt \
1550 | cut -f 2,3 | sed 's/ / /'
1551 else
1552 grep -m1 ^$PACKAGE$'\t' $INCOMING_REPOSITORY/wok-depends.txt | \
1553 cut -f 2,3 | sed 's/ / /'
1554 fi
1555 }
1557 look_for_rdep()
1558 {
1559 fgrep ' '$PACKAGE' ' $INCOMING_REPOSITORY/wok-depends.txt | cut -f 1
1560 if [ "$undigest" ]; then
1561 for rdep in $(fgrep ' '$PACKAGE' ' $SLITAZ_DIR/$SLITAZ_VERSION/packages-incoming/wok-depends.txt | cut -f 1); do
1562 if [ ! -f "WOK$/$rdep/receipt" ]; then
1563 echo "$rdep"
1564 fi
1565 done
1566 fi
1567 }
1569 look_for_rbdep()
1570 {
1571 fgrep ' '$PACKAGE' ' $INCOMING_REPOSITORY/wok-depends.txt | \
1572 cut -f 1,3 | fgrep ' '$PACKAGE' ' | cut -f 1
1573 if [ "$undigest" ]; then
1574 for rdep in $(fgrep ' '$PACKAGE' ' $SLITAZ_DIR/$SLITAZ_VERSION/packages-incoming/wok-depends.txt \
1575 | cut -f 1,3 | fgrep ' '$PACKAGE' ' | cut -f 1); do
1576 if [ ! -f "WOK$/$rdep/receipt" ]; then
1577 echo "$rdep"
1578 fi
1579 done
1580 fi
1581 }
1583 # Return WANTED if it exists.
1584 look_for_wanted()
1585 {
1586 if [ "$undigest" ] && [ ! -f "$WOK/$PACKAGE/receipt" ]; then
1587 grep -m1 ^$PACKAGE$'\t' $SLITAZ_DIR/$SLITAZ_VERSION/packages-incoming/wok-wanted.txt | cut -f 2
1588 else
1589 grep -m1 ^$PACKAGE$'\t' $INCOMING_REPOSITORY/wok-wanted.txt | cut -f 2
1590 fi
1591 }
1593 # Return packages which wants PACKAGE.
1594 look_for_rwanted()
1595 {
1596 grep $'\t'$PACKAGE$ $INCOMING_REPOSITORY/wok-wanted.txt | cut -f 1
1597 if [ "$undigest" ]; then
1598 for rwanted in $(grep $'\t'$PACKAGE$ $SLITAZ_DIR/$SLITAZ_VERSION/packages-incoming/wok-wanted.txt | cut -f 1); do
1599 if [ ! -f "$WOK/$rwanted/receipt" ]; then
1600 echo "$rwanted"
1601 fi
1602 done
1603 fi
1604 }
1606 look_for_dev()
1607 {
1608 WANTED=$(look_for_wanted)
1609 if [ "$WANTED" ]; then
1610 if [ "$undigest" ] && [ ! -f "$WOK/$WANTED/receipt" ]; then
1611 [ -f "$SLITAZ_DIR/$SLITAZ_VERSION/wok/$WANTED-dev/receipt" ] && echo $WANTED-dev
1612 else
1613 [ -f "$WOK/$WANTED-dev/receipt" ] && echo $WANTED-dev
1614 fi
1615 fi
1616 if [ "$undigest" ] && [ ! -f "$WOK/$PACKAGE/receipt" ]; then
1617 [ -f "$SLITAZ_DIR/$SLITAZ_VERSION/wok/$PACKAGE-dev/receipt" ] && echo $PACKAGE-dev
1618 else
1619 [ -f "$WOK/$PACKAGE-dev/receipt" ] && echo $PACKAGE-dev
1620 fi
1621 }
1623 with_dev()
1624 {
1625 for PACKAGE in $(cat); do
1626 echo $PACKAGE
1627 look_for_dev
1628 done
1629 }
1631 with_wanted()
1632 {
1633 for PACKAGE in $(cat); do
1634 echo $PACKAGE
1635 look_for_wanted
1636 done
1637 }
1639 use_wanted()
1640 {
1641 for input in $(cat); do
1642 { grep ^$input$'\t' $wan_db || echo $input
1643 } | sed 's/.*\t//'
1644 done
1645 }
1647 ########################################################################
1648 # SCAN
1649 ########################
1650 # Use wok-wanted.txt and wok-depeds.txt to scan depends.
1651 # Option in command line (must be first arg) :
1652 # --look_for=bdep/rbdep - Look for depends or reverse depends.
1653 # --with_dev - Add development packages (*-dev) in the result.
1654 # --with_wanted - Add package+reverse wanted in the result.
1655 # --with_args - Include packages in argument in the result.
1657 scan()
1658 {
1659 # Get packages in argument.
1660 local PACKAGE=$PACKAGE WANTED=$WANTED pkg_list=
1661 for arg in $@; do
1662 [ "$arg" = "${arg#--}" ] || continue
1663 pkg_list="$pkg_list $arg"
1664 done
1666 # Get options.
1667 [ "$pkg_list" ] || return
1668 local cooklist= look_for= with_dev= with_wanted= with_args= log_command="$0 $@" \
1669 get_options_list="look_for with_dev with_wanted with_args cooklist use_wanted"
1670 get_options
1672 # Cooklist is a special case where we need to modify a little
1673 # scan behavior
1674 if [ "$cooklist" ]; then
1675 gen_wan_db
1676 look_for=all && with_args=yes && with_dev= && with_wanted=
1677 filter=use_wanted
1678 if [ "$COMMAND" = gen-cooklist ]; then
1679 for PACKAGE in $pkg_list; do
1680 grep -q ^$PACKAGE$'\t' $dep_db && continue
1681 [ -d "$WOK/$p" ] || continue
1682 check_for_missing
1683 done
1684 append_to_dep()
1685 {
1686 if ! grep -q ^$PACKAGE$'\t' $dep_db; then
1687 check_for_missing && echo $PACKAGE >> $tmp/dep
1688 else
1689 echo $PACKAGE >> $tmp/dep
1690 fi
1691 }
1692 else
1693 append_to_dep()
1694 {
1695 check_for_commit && echo $PACKAGE >> $tmp/dep
1696 }
1697 fi
1698 else
1699 append_to_dep()
1700 {
1701 echo $PACKAGE >> $tmp/dep
1702 }
1703 # If requested packages are not in dep_db, partial generation of this db is needed.
1704 for PACKAGE in $pkg_list; do
1705 grep -q ^$PACKAGE$'\t' $dep_db && continue
1706 [ -d "$WOK/$p" ] || continue
1707 plan_check_for_missing=yes
1708 check_for_missing
1709 done
1710 if [ "$plan_check_for_missing" ]; then
1711 append_to_dep()
1712 {
1713 if ! grep -q ^$PACKAGE$'\t' $dep_db; then
1714 check_for_missing && echo $PACKAGE >> $tmp/dep
1715 else
1716 echo $PACKAGE >> $tmp/dep
1717 fi
1718 }
1719 check_db_status=yes
1720 unset plan_check_for_missing
1721 fi
1722 fi
1724 [ "$with_dev" ] && filter=with_dev
1725 [ "$with_wanted" ] && filter=with_wanted
1726 if [ "$filter" ]; then
1727 pkg_list=$(echo $pkg_list | $filter | sort -u)
1728 scan_pkg()
1729 {
1730 look_for_$look_for | $filter
1731 }
1732 else
1733 scan_pkg()
1734 {
1735 look_for_$look_for
1736 }
1737 fi
1738 touch $tmp/dep
1739 for PACKAGE in $pkg_list; do
1740 [ "$with_args" ] && append_to_dep
1741 scan_pkg
1742 done | tr ' ' '\n' | sort -u > $tmp/list
1743 [ "$look_for" = bdep ] && look_for=dep
1744 while [ -s $tmp/list ]; do
1745 PACKAGE=$(sed 1!d $tmp/list)
1746 sed 1d -i $tmp/list
1747 append_to_dep
1748 for pkg in $(scan_pkg); do
1749 if ! grep -q ^$pkg$ $tmp/list $tmp/dep; then
1750 echo $pkg >> $tmp/list
1751 fi
1752 done
1753 done
1754 if [ "$cooklist" ]; then
1755 mv $tmp/dep $tmp/cooklist
1756 else
1757 cat $tmp/dep | sort -u
1758 fi
1759 rm -f $tmp/dep $tmp/list
1760 if [ "$check_db_status" ]; then
1761 [ "$plan_sort_depdb" ] && sort -o $dep_db $dep_db && unset plan_sort_depdb
1762 [ "$plan_sort_wandb" ] && sort -o $wan_db $wan_db && unset plan_sort_wandb
1763 if [ "$plan_regen_cookorder" ] && \
1764 [ "$(sed 1!d $PACKAGES_REPOSITORY/cookorder.txt)" != "#PlanSort" ]; then
1765 grep -q "^#" $PACKAGES_REPOSITORY/cookorder.txt || \
1766 sed 1i"#PlanSort" -i $PACKAGES_REPOSITORY/cookorder.txt
1767 fi
1768 fi
1769 }
1771 ########################################################################
1772 # This section contains functions to check the package repository and
1773 # find which packages to cook.
1774 ########################
1776 check_for_missing()
1777 {
1778 local PACKAGE=$PACKAGE
1779 if ! check_for_pkg_in_wok; then
1780 [ "$?" = 2 ] && return 1
1781 return
1782 fi
1783 RECEIPT=$WOK/$PACKAGE/receipt
1784 source_receipt
1785 PACKAGE=${WANTED:-$PACKAGE}
1786 update_wan_db
1787 for PACKAGE in $(look_for_rwanted) $PACKAGE; do
1788 RECEIPT=$WOK/$PACKAGE/receipt
1789 source_receipt
1790 update_dep_db
1791 done
1792 }
1794 check_for_commit()
1795 {
1796 if ! check_for_pkg_in_wok; then
1797 [ "$?" = 2 ] && return 1
1798 return
1799 fi
1800 for PACKAGE in $(look_for_rwanted) $PACKAGE; do
1801 RECEIPT=$WOK/$PACKAGE/receipt
1802 source_receipt
1804 # We use md5 of cooking stuff in the packaged receipt to check
1805 # commit. We look consecutively in 3 different locations :
1806 # - in the wok/PACKAGE/taz/* folder
1807 # - in the receipt in the package in incoming repository
1808 # - in the receipt in the package in packages repository
1809 # If md5sums match, there's no commit.
1810 check_for_commit_using_md5sum()
1811 {
1812 if [ ! -f $WOK/$PACKAGE/md5 ]; then
1813 sed -n '/# md5sum of cooking stuff :/,$p' receipt | \
1814 sed -e 1d -e 's/^# //' > $WOK/$PACKAGE/md5
1815 cd $WOK/$PACKAGE
1816 fi
1818 if [ -s md5 ]; then
1819 if md5sum -cs md5; then
1821 # If md5sum check if ok, check for new/missing files in
1822 # cooking stuff.
1823 for file in $([ -f receipt ] && echo receipt; \
1824 [ -f description.txt ] && echo description.txt; \
1825 [ -d stuff ] && find stuff); do
1826 if ! fgrep -q " $file" md5; then
1827 set_commited
1828 fi
1829 done
1830 else
1831 set_commited
1832 fi
1833 else
1834 set_commited
1835 fi
1836 }
1837 set_commited()
1838 {
1839 ! grep -q ^$PACKAGE$ $PACKAGES_REPOSITORY/commit &&
1840 echo $PACKAGE >> $PACKAGES_REPOSITORY/commit
1841 gen_cookmd5
1842 update_dep_db
1843 }
1844 taz_dir=$(echo $WOK/$PACKAGE/taz/$PACKAGE-* | fgrep -v '*')
1845 if [ -f $WOK/$PACKAGE/md5 ]; then
1846 cd $WOK/$PACKAGE
1847 check_for_commit_using_md5sum
1848 elif [ "$taz_dir" ]; then
1849 cd $taz_dir
1850 check_for_commit_using_md5sum
1851 else
1852 pkg=$(echo $INCOMING_REPOSITORY/$PACKAGE-$VERSION*.tazpkg | fgrep -v '*')
1853 [ "$pkg" ] || pkg=$(echo $PACKAGES_REPOSITORY/$PACKAGE-$VERSION*.tazpkg | fgrep -v '*')
1854 if [ "$pkg" ]; then
1855 get_pkg_files $pkg
1856 check_for_commit_using_md5sum
1857 rm -r $pkg_files_dir
1858 else
1859 set_commited
1860 fi
1861 fi
1862 [ "$forced" ] || echo $PACKAGE >> $tmp/checked
1863 done
1864 return
1865 }
1867 gen_cook_list()
1868 {
1869 report step "Scanning wok"
1870 if [ "$pkg" ]; then
1871 scan $pkg --cooklist
1872 else
1873 scan `cat $cooklist` --cooklist
1874 fi
1875 report end-step
1877 [ -s $tmp/checked ] || [ -s $tmp/cooklist ] || return
1879 # Core toolchain should not be cooked unless cook-toolchain is used.
1880 if ! [ -f /etc/config.site.tmptoolchain ] ; then
1881 for PACKAGE in $(scan gcc --look_for=all --with_args --with_wanted); do
1882 grep -q ^$PACKAGE$ $PACKAGES_REPOSITORY/blocked || \
1883 echo $PACKAGE >> $PACKAGES_REPOSITORY/blocked
1884 done
1885 fi
1887 if [ -s $PACKAGES_REPOSITORY/commit ] && [ "$COMMAND" != gen-cooklist ]; then
1888 cd $PACKAGES_REPOSITORY
1889 for PACKAGE in $(cat commit); do
1890 WANTED="$(look_for_wanted)"
1891 if [ "$WANTED" ]; then
1892 grep -q ^$WANTED$ broken cooklist blocked commit && continue
1893 fi
1894 grep -q ^$PACKAGE$ blocked cooklist && continue
1895 echo $PACKAGE >> cooklist
1896 done
1897 fi
1898 sort_cooklist
1899 }
1901 sort_cooklist()
1902 {
1903 if [ "$(sed 1!d $PACKAGES_REPOSITORY/cookorder.txt)" = "#PlanSort" ]; then
1904 sed 1d -i $PACKAGES_REPOSITORY/cookorder.txt
1905 plan_regen_cookorder=yes
1906 fi
1907 [ "$plan_sort_depdb" ] && sort -o $dep_db $dep_db && unset plan_sort_depdb
1908 [ "$plan_regen_cookorder" ] && sort_db
1909 report step "Generating cooklist"
1910 if [ -f "$tmp/checked" ]; then
1911 rm -f $tmp/cooklist
1912 cat $tmp/checked | while read PACKAGE; do
1913 grep -q ^$PACKAGE$ $PACKAGES_REPOSITORY/cooklist && \
1914 echo $PACKAGE >> $tmp/cooklist
1915 done
1916 elif ! [ "$COMMAND" = gen-cooklist ]; then
1917 cat $PACKAGES_REPOSITORY/blocked | while read PACKAGE; do
1918 sed "/^$PACKAGE/d" -i $tmp/cooklist
1919 done
1920 fi
1921 report end-step
1922 [ -s $tmp/cooklist ] || return
1924 report step "Sorting cooklist"
1925 for PACKAGE in $(cat $tmp/cooklist); do
1926 WANTED="$(look_for_wanted)"
1927 [ "$WANTED" ] || continue
1928 if grep -q ^$WANTED$ $PACKAGES_REPOSITORY/broken $tmp/cooklist; then
1929 sed "/^$PACKAGE$/d" -i $tmp/cooklist
1930 elif [ ! -d $WOK/$WANTED/install ]; then
1931 sed "/^$PACKAGE$/d" -i $tmp/cooklist
1932 echo $WANTED >> $tmp/cooklist
1933 fi
1934 done
1936 # Use cookorder.txt to sort cooklist.
1937 if [ -s $tmp/cooklist ]; then
1938 cat $PACKAGES_REPOSITORY/cookorder.txt | while read PACKAGE; do
1939 if grep -q ^$PACKAGE$ $tmp/cooklist; then
1940 sed "/^$PACKAGE$/d" -i $tmp/cooklist
1941 echo $PACKAGE >> $tmp/cooklist.tmp
1942 fi
1943 done
1945 # Remaining packages in cooklist are those without compile_rules.
1946 # They can be cooked first in any order.
1947 if [ -f $tmp/cooklist.tmp ]; then
1948 cat $tmp/cooklist.tmp >> $tmp/cooklist
1949 rm $tmp/cooklist.tmp
1950 fi
1952 cat $tmp/cooklist
1953 [ "$cooklist" = "$PACKAGES_REPOSITORY/cooklist" ] && \
1954 cat $tmp/cooklist > $cooklist
1955 fi
1957 report end-step
1958 }
1960 look_for_missing_pkg()
1961 {
1962 for pkg in $(cat $PACKAGES_REPOSITORY/$1); do
1963 grep -q ^$pkg$ $INCOMING_REPOSITORY/packages.txt \
1964 $PACKAGES_REPOSITORY/packages.txt || \
1965 continue
1966 echo $pkg
1967 done
1968 }
1970 check_for_incoming()
1971 {
1972 report step "Checking that all packages were cooked OK"
1973 [ -s $INCOMING_REPOSITORY/packages.desc ] || {
1974 echo "No packages in $INCOMING_REPOSITORY."
1975 report end-step; return; }
1976 if [ -s $PACKAGES_REPOSITORY/broken ]; then
1977 missingpkg=$(look_for_missing_pkg broken)
1978 if [ "$missingpkg" ]; then
1979 echo "Don't move incoming packages to main repository because these ones are broken:" >&2
1980 echo "$missingpkg"
1981 report end-step
1982 return 1
1983 fi
1984 fi
1985 if [ -s $PACKAGES_REPOSITORY/cooklist ]; then
1986 missingpkg=$(look_for_missing_pkg cooklist)
1987 if [ "$missingpkg" ]; then
1988 echo "Don't move incoming packages to main repository because these ones need to be cooked:" >&2
1989 echo "$missingpkg"
1990 report end-step
1991 return 1
1992 fi
1993 fi
1994 incoming_pkgs="$(cut -f 1 -d '|' $INCOMING_REPOSITORY/packages.desc)"
1995 if ! [ "$forced" ]; then
1996 cooklist=$PACKAGES_REPOSITORY/cooklist
1997 pkg="$incoming_pkgs"
1998 gen_cook_list
1999 if [ -s $PACKAGES_REPOSITORY/cooklist ]; then
2000 missingpkg=$(look_for_missing_pkg cooklist)
2001 if [ "$missingpkg" ]; then
2002 echo "Don't move incoming packages to main repository because these ones need to be cooked:" >&2
2003 echo "$missingpkg"
2004 report end-step
2005 return 1
2006 fi
2007 fi
2008 fi
2010 report step "Moving incoming packages to main repository"
2011 unset EXTRAVERSION
2012 for PACKAGE in $incoming_pkgs; do
2013 prev_VERSION=$(get_pkg_version $PACKAGES_REPOSITORY)
2014 VERSION=$(get_pkg_version $INCOMING_REPOSITORY)
2015 remove_previous_package $PACKAGES_REPOSITORY
2016 echo "Moving $PACKAGE..."
2017 mv -f $INCOMING_REPOSITORY/$PACKAGE-$VERSION.tazpkg $PACKAGES_REPOSITORY
2018 touch $PACKAGES_REPOSITORY/$PACKAGE-$VERSION.tazpkg
2019 previous_tarball=$(grep ^$PACKAGE:main $SOURCES_REPOSITORY/sources.list | cut -f2)
2020 sed -e "/^$PACKAGE:main/d" \
2021 -e "s/^$PACKAGE:incoming/$PACKAGE:main/" \
2022 -i $SOURCES_REPOSITORY/sources.list
2023 if [ "$previous_tarball" ]; then
2024 grep -q $'\t'$previous_tarball$ $SOURCES_REPOSITORY/sources.list || \
2025 rm -f $SOURCES_REPOSITORY/$previous_tarball
2026 fi
2027 done
2028 for file in packages.list packages.equiv packages.md5 packages.desc \
2029 packages.txt; do
2030 echo -n "" > $INCOMING_REPOSITORY/$file
2031 done
2032 rm -r $INCOMING_REPOSITORY/files.list.lzma
2033 pkg_repository=$PACKAGES_REPOSITORY && update_packages_db
2035 report step "Updating flavors"
2036 if [ -x /usr/bin/tazlito ] || [ -x /usr/bin/clean-chroot ]; then
2037 if ! [ -x /usr/bin/tazlito ]; then
2038 tazpkg get-install tazlito
2039 fi
2041 # Handle cases where tazwok is used into main system;
2042 # Handle cases where SLITAZ_DIR is not /home/slitaz.
2043 [ -L /home/slitaz/flavors ] && rm /home/slitaz/flavors
2044 mkdir -p /home/slitaz
2045 ln -s $LOCAL_REPOSITORY/flavors /home/slitaz/flavors
2047 cd $LOCAL_REPOSITORY/packages
2048 for i in $LOCAL_REPOSITORY/flavors/*; do
2049 [ -d "$i" ] || continue
2050 tazlito pack-flavor ${i##*/}
2051 done
2053 noheader=""
2054 for i in *.flavor; do
2055 tazlito show-flavor $i --brief $noheader
2056 noheader="--noheader"
2057 done > flavors.list
2058 [ -x /usr/bin/clean-chroot ] && clean-chroot
2059 else
2060 echo "Can't create up-to-date flavors because the tazlito package is missing." >&2
2061 fi
2062 report end-step
2063 }
2065 ########################################################################
2066 # TAZWOK MAIN FUNCTIONS
2067 ########################
2069 clean()
2070 {
2071 cd $WOK/$PACKAGE
2072 ls -A $WOK/$PACKAGE | grep -q -v -e ^receipt$ -e ^description.txt$ \
2073 -e ^stuff$ || return
2075 [ "$COMMAND" = clean-wok ] || report step "Cleaning $PACKAGE"
2076 # Check for clean_wok function.
2077 if grep -q ^clean_wok $RECEIPT; then
2078 clean_wok
2079 fi
2080 # Clean should only have a receipt, stuff and optional desc.
2081 for f in `ls .`
2082 do
2083 case $f in
2084 receipt|stuff|description.txt|md5)
2085 continue ;;
2086 *)
2087 rm -rf $f ;;
2088 esac
2089 done
2090 [ "$COMMAND" != clean-wok ] && report end-step
2091 }
2093 # Configure and make a package with the receipt.
2094 compile_package()
2095 {
2096 check_for_package_on_cmdline
2098 # Include the receipt to get all needed variables and functions
2099 # and cd into the work directory to start the work.
2100 check_for_receipt
2101 source_receipt
2103 # Log the package name and date.
2104 echo "date `date +%Y%m%d\ \%H:%M:%S`" >> $LOG
2105 echo "package $PACKAGE (compile)" >> $LOG
2107 # Set wanted $src variable to help compiling.
2108 [ ! "$src" ] && set_src_path
2109 check_for_build_depends || return 1
2110 check_for_wanted
2111 unset target
2112 check_for_tarball && check_for_compile_rules
2113 }
2115 # Cook command also include all features to manage lists which keep
2116 # track of wok/packages state.
2117 cook()
2118 {
2119 cook_code=
2120 set_common_path
2121 check_for_receipt
2122 source_receipt
2124 # Define log path and start report.
2125 [ -f $LOCAL_REPOSITORY/log/$PACKAGE.html ] && rm $LOCAL_REPOSITORY/log/$PACKAGE.html
2126 report sublog $LOCAL_REPOSITORY/log/$PACKAGE.html
2127 echo "$PACKAGE" > $LOCAL_REPOSITORY/log/package
2128 report step "Cooking $PACKAGE"
2129 report open-bloc
2131 clean $PACKAGE
2132 [ -s $tmp/cooklist ] && sed "/^$PACKAGE$/d" -i $tmp/cooklist
2134 if compile_package; then
2135 remove_src
2136 refresh_packages_from_compile
2137 gen_package
2139 # Update packages-incoming repository.
2140 store_pkgname=$PACKAGE
2141 pkg_repository=$INCOMING_REPOSITORY
2142 update_packages_db
2144 PACKAGE=$store_pkgname
2145 unset store_pkgname
2147 # Upgrade to cooked packages if it was previously installed.
2148 report step "Looking for package(s) to upgrade"
2149 for pkg in $(look_for_rwanted) $PACKAGE; do
2150 if [ -d $INSTALLED/$pkg ]; then
2151 tazpkg get-install $pkg --forced
2152 fi
2153 done
2154 report end-step
2155 else
2156 set_pkg_broken
2157 cook_code=1
2158 fi
2160 # Remove build_depends in cook mode (if in cooklist, it's done when
2161 # checking build_depends of next package and we remove only unneeded
2162 # packages to keep chroot minimal and gain some time).
2163 if [ "$COMMAND" = cook ]; then
2164 remove_build_depends $MISSING_PACKAGE
2165 [ -x /usr/bin/clean-chroot ] && clean-chroot
2166 fi
2168 # Regen the cooklist if it was planned and command is not cook.
2169 [ "$regen_cooklist" ] && unset regen_cooklist && \
2170 [ "$COMMAND" != cook ] && sort_cooklist
2172 # Some hacks to set the bloc & function status as failed if cook has
2173 # failed.
2174 report_return_code=$cook_code
2175 report close-bloc
2176 report end-sublog
2177 rm -f $LOCAL_REPOSITORY/log/package
2178 return $cook_code
2179 }
2181 cook_list()
2182 {
2183 if [ -s $tmp/cooklist ]; then
2184 if [ -f /usr/bin/tazchroot ]; then
2185 # Note : options -main variables- are automatically kept by
2186 # the sub-applications tazchroot/tazwok; as well as report data.
2187 cd $LOCAL_REPOSITORY
2188 [ ! -f tazchroot.conf ] && configure_tazchroot
2189 tazchroot tazwok cook-list --SLITAZ_DIR=$SLITAZ_DIR --SLITAZ_VERSION=$SLITAZ_VERSION ${undigest:+ --undigest=$undigest}
2190 return
2191 fi
2192 while [ -s $tmp/cooklist ]; do
2193 PACKAGE=$(sed 1!d $tmp/cooklist)
2194 cook
2195 done
2196 remove_build_depends $MISSING_PACKAGE $remove_later
2197 [ -x /usr/bin/clean-chroot ] && clean-chroot
2198 else
2199 echo "Nothing to cook."
2200 return
2201 fi
2202 }
2204 configure_tazchroot()
2205 {
2206 cat > $LOCAL_REPOSITORY/tazchroot.conf << EOF
2207 # Tazchroot configuration file - created by tazwok.
2209 # Default chroot path.
2210 SLITAZ_DIR=$SLITAZ_DIR
2211 SLITAZ_VERSION=$SLITAZ_VERSION
2212 $( [ "$undigest" ] && echo "undigest=$undigest" )
2213 LOCAL_REPOSITORY=$SLITAZ_DIR/$(if [ "$undigest" ]; then echo '$undigest'; else echo '$SLITAZ_VERSION'; fi)
2214 chroot_dir=\$LOCAL_REPOSITORY/chroot
2216 # Default scripts path (these scripts are added to the
2217 # $chroot_dir/usr/bin and can be called with tazchroot script).
2218 script_dir=/usr/lib/slitaz/chroot-scripts/tazwok
2220 # List of directories to mount.
2221 list_dir="$(for dir in packages wok src packages-incoming log flavors iso clean-wok; do echo $LOCAL_REPOSITORY/$dir; done)
2222 $SLITAZ_LOG$( [ "$undigest" ] && echo -e "\n$SLITAZ_DIR/$SLITAZ_VERSION/packages" )"
2224 create_chroot()
2225 {
2226 mkdir -p \$chroot_dir
2227 for pkg in \$(tazwok build-depends toolchain --SLITAZ_DIR=\$SLITAZ_DIR --SLITAZ_VERSION=\$SLITAZ_VERSION${undigest:+ --undigest=\$undigest}); do
2228 tazpkg get-install \$pkg --root="\$chroot_dir"
2229 done
2231 # Store list of installed packages needed by cleanchroot.
2232 ls -1 \$chroot_dir/\$INSTALLED > \$chroot_dir/\$LOCALSTATE/chroot-pkgs
2234 sed -e "s~^SLITAZ_DIR=.*~SLITAZ_DIR=\$SLITAZ_DIR~" \\
2235 -e "s/^SLITAZ_VERSION=.*/SLITAZ_VERSION=\$SLITAZ_VERSION/" \\
2236 -i \$chroot_dir/etc/slitaz/slitaz.conf
2237 echo \$SLITAZ_VERSION > \$chroot_dir/etc/slitaz-release
2238 $( [ "$undigest" ] && echo ' echo "undigest='"$undigest"'" >> $chroot_dir/etc/slitaz/tazwok.conf')
2239 sed 's/LC_ALL/LC_ALL=POSIX/' -i \$chroot_dir/etc/profile
2240 # The build bot may run in a sandbox: link sandbox lockfile.
2241 ln -s \$LOCAL_REPOSITORY/sandbox/proc/1 \$chroot_dir/proc/1
2242 }
2244 mount_chroot()
2245 {
2246 cp -a /etc/resolv.conf \$chroot_dir/etc/resolv.conf
2247 echo "\$LOCAL_REPOSITORY/packages" > \$chroot_dir\$LOCALSTATE/mirror
2248 mkdir -p \$chroot_dir\$LOCALSTATE/undigest/\${LOCAL_REPOSITORY##*/}-incoming
2249 echo "\$LOCAL_REPOSITORY/packages-incoming" > \$chroot_dir\$LOCALSTATE/undigest/\${LOCAL_REPOSITORY##*/}-incoming/mirror
2250 $( [ "$undigest" ] && echo ' mkdir -p $chroot_dir$LOCALSTATE/undigest/$SLITAZ_VERSION
2251 echo "$SLITAZ_DIR/$SLITAZ_VERSION/packages" > $chroot_dir$LOCALSTATE/undigest/$SLITAZ_VERSION/mirror' )
2252 echo -e "\${LOCAL_REPOSITORY##*/}-incoming\nmain" > \$chroot_dir\$LOCALSTATE/priority
2253 mount -o bind /proc \$chroot_dir/proc
2254 mount -o bind /sys \$chroot_dir/sys
2255 mount -o bind /dev/pts \$chroot_dir/dev/pts
2256 mount -o bind /dev/shm \$chroot_dir/dev/shm
2257 for dir in \$list_dir; do
2258 mkdir -p \$dir \$chroot_dir\$dir
2259 mount \$dir \$chroot_dir\$dir
2260 done
2261 }
2263 umount_chroot()
2264 {
2265 for dir in \$list_dir; do
2266 umount \$chroot_dir\$dir
2267 done
2268 umount \$chroot_dir/dev/shm
2269 umount \$chroot_dir/dev/pts
2270 umount \$chroot_dir/sys
2271 umount \$chroot_dir/proc
2272 }
2273 EOF
2274 }
2276 ########################################################################
2277 ######################### END OF NEW FUNCTIONS #########################
2278 ########################################################################
2280 # List packages providing a virtual package.
2281 whoprovide()
2282 {
2283 local i;
2284 for i in $(fgrep -l PROVIDE $WOK/*/receipt); do
2285 . $i
2286 case " $PROVIDE " in
2287 *\ $1\ *|*\ $1:*) echo $(basename $(dirname $i));;
2288 esac
2289 done
2290 }
2292 ########################################################################
2293 # TAZWOK COMMANDS
2294 ########################
2296 case "$COMMAND" in
2297 stats)
2298 # Tazwok general statistics from the wok config file.
2299 #
2300 get_tazwok_config
2301 echo -e "\n\033[1mTazwok configuration statistics\033[0m
2302 ================================================================================
2303 Wok directory : $WOK
2304 Packages repository : $PACKAGES_REPOSITORY
2305 Incoming repository : $INCOMING_REPOSITORY
2306 Sources repository : $SOURCES_REPOSITORY
2307 Log directory : $LOCAL_REPOSITORY/log
2308 Packages in the wok : `ls -1 $WOK | wc -l`
2309 Cooked packages : `ls -1 $PACKAGES_REPOSITORY/*.tazpkg 2>/dev/null | wc -l`
2310 Incoming packages : `ls -1 $INCOMING_REPOSITORY/*.tazpkg 2>/dev/null | wc -l`
2311 ================================================================================\n"
2312 ;;
2313 edit)
2314 get_tazwok_config
2315 check_for_package_on_cmdline
2316 check_for_receipt
2317 $EDITOR $WOK/$PACKAGE/receipt
2318 ;;
2319 build-depends)
2320 # List dependencies to rebuild wok, or only a package.
2321 get_tazwok_config
2322 report(){ : ; }
2323 if [ ! "$PACKAGE" ] || [ "$PACKAGE" = toolchain ]; then
2324 scan "$SLITAZ_TOOLCHAIN $SLITAZ_TOOLCHAIN_EXTRA" \
2325 --look_for=dep --with_dev --with_args
2326 else
2327 check_for_package_on_cmdline
2328 scan $PACKAGE --look_for=bdep --with_dev
2329 fi
2330 ;;
2331 gen-cooklist)
2332 check_root
2333 get_options_list="pkg"
2334 get_tazwok_config
2335 report(){ : ; }
2336 if ! [ "$pkg" ]; then
2337 if [ ! "$LIST" ] || [ "$LIST" = toolchain ]; then
2338 pkg="$SLITAZ_TOOLCHAIN $SLITAZ_TOOLCHAIN_EXTRA"
2339 else
2340 cooklist=${LIST:-$PACKAGES_REPOSITORY/cooklist}
2341 fi
2342 fi
2343 gen_cook_list
2344 ;;
2345 check-depends)
2346 # Check package depends /!\.
2347 get_tazwok_config
2348 echo ""
2349 echo -e "\033[1mCheck every receipt for DEPENDS - doesn't scan ELF files\033[0m
2350 ================================================================================"
2351 TMPDIR=/tmp/tazwok$$
2352 DEFAULT_DEPENDS="glibc-base gcc-lib-base"
2354 # Build ALL_DEPENDS variable.
2355 scan_dep()
2356 {
2357 local i
2358 ALL_DEPENDS="$ALL_DEPENDS$PACKAGE "
2359 for i in $DEPENDS $SUGGESTED ; do
2360 case " $ALL_DEPENDS " in
2361 *\ $i\ *) continue;;
2362 esac
2363 [ -d $WOK/$i ] || {
2364 ALL_DEPENDS="$ALL_DEPENDS$i "
2365 continue
2366 }
2367 DEPENDS=""
2368 SUGGESTED=""
2369 . $WOK/$i/receipt
2370 scan_dep
2371 done
2372 }
2374 # Check for ELF file.
2375 is_elf()
2376 {
2377 [ "$(dd if=$1 bs=1 skip=1 count=3 2> /dev/null)" = "ELF" ]
2378 }
2380 # Print shared library dependencies.
2381 ldd()
2382 {
2383 LD_TRACE_LOADED_OBJECTS=1 /lib/ld*.so $1 2> /dev/null
2384 }
2386 mkdir $TMPDIR
2387 cd $TMPDIR
2388 for i in $LOCALSTATE/files.list.lzma \
2389 $LOCALSTATE/undigest/*/files.list.lzma ; do
2390 [ -f $i ] && lzma d $i -so >> files.list
2391 done
2392 for pkg in $PACKAGES_REPOSITORY/*.tazpkg ; do
2393 tazpkg extract $pkg > /dev/null 2>&1
2394 . */receipt
2395 ALL_DEPENDS="$DEFAULT_DEPENDS "
2396 scan_dep
2397 find */fs -type f | while read file ; do
2398 is_elf $file || continue
2399 case "$file" in
2400 *.o|*.ko|*.ko.gz) continue;;
2401 esac
2402 ldd $file | while read lib rem; do
2403 case "$lib" in
2404 statically|linux-gate.so*|ld-*.so|*/ld-*.so)
2405 continue;;
2406 esac
2407 for dep in $(fgrep $lib files.list | cut -d: -f1); do
2408 case " $ALL_DEPENDS " in
2409 *\ $dep\ *) continue 2;;
2410 esac
2411 for vdep in $(fgrep $dep $LOCALSTATE/packages.equiv | cut -d= -f1); do
2412 case " $ALL_DEPENDS " in
2413 *\ $vdep\ *) continue 3;;
2414 esac
2415 done
2416 done
2417 [ -n "$dep" ] || dep="UNKNOWN"
2418 echo "$(basename $pkg): ${file#*fs} depends on package $dep for the shared library $lib"
2419 done
2420 done
2421 rm -rf */
2422 done
2423 cd /tmp
2424 rm -rf $TMPDIR
2425 ;;
2426 check)
2427 # Check wok consistency.
2428 get_tazwok_config
2429 echo ""
2430 echo -e "\033[1mWok and packages checking\033[0m
2431 ================================================================================"
2432 cd $WOK
2433 for pkg in $(ls)
2434 do
2435 [ -f $pkg/receipt ] || continue
2436 RECEIPT= $pkg/receipt
2437 source_receipt
2438 [ "$PACKAGE" = "$pkg" ] || echo "Package $PACKAGE should be $pkg" >&2
2439 [ -n "$VERSION" ] || echo "Package $PACKAGE has no VERSION" >&2
2440 [ -n "$PACKED_SIZE" ] && echo "Package $PACKAGE has hardcoded PACKED_SIZE" >&2
2441 [ -n "$UNPACKED_SIZE" ] && echo "Package $PACKAGE has hardcoded UNPACKED_SIZE" >&2
2442 [ -n "$EXTRAVERSION" ] && echo "Package $PACKAGE has hardcoded EXTRAVERSION" >&2
2443 if [ -n "$WANTED" ]; then
2444 if [ ! -f $WANTED/receipt ]; then
2445 echo "Package $PACKAGE wants unknown $WANTED package" >&2
2446 else
2447 BASEVERSION=$(. $WANTED/receipt ; echo $VERSION)
2448 if [ "$VERSION" = "$WANTED" ]; then
2449 # BASEVERSION is computed in receipt
2450 fgrep -q '_pkg=' $pkg/receipt &&
2451 BASEVERSION=$VERSION
2452 fi
2453 if [ "$VERSION" != "$BASEVERSION" ]; then
2454 echo "Package $PACKAGE ($VERSION) wants $WANTED ($BASEVERSION)" >&2
2455 fi
2456 fi
2457 fi
2459 if [ -n "$CATEGORY" ]; then
2460 case " $(echo $CATEGORIES) " in
2461 *\ $CATEGORY\ *);;
2462 *) echo "Package $PACKAGE has an invalid CATEGORY" >&2;;
2463 esac
2464 else
2465 echo"Package $PACKAGE has no CATEGORY" >&2
2466 fi
2467 [ -n "$SHORT_DESC" ] || echo "Package $PACKAGE has no SHORT_DESC" >&2
2468 [ -n "$MAINTAINER" ] || echo "Package $PACKAGE has no MAINTAINER" >&2
2469 case "$WGET_URL" in
2470 ftp*|http*) busybox wget -s $WGET_URL 2> /dev/null ||
2471 echo "Package $PACKAGE has a wrong WGET_URL" >&2;;
2472 '') ;;
2473 *) echo "Package $PACKAGE has an invalid WGET_URL" >&2;;
2474 esac
2475 case "$WEB_SITE" in
2476 ftp*|http*);;
2477 '') echo "Package $PACKAGE has no WEB_SITE" >&2;;
2478 *) echo "Package $PACKAGE has an invalid WEB_SITE" >&2;;
2479 esac
2480 case "$MAINTAINER" in
2481 *\<*|*\>*) echo "Package $PACKAGE has an invalid MAINTAINER: $MAINTAINER" >&2;;
2482 esac
2483 case "$MAINTAINER" in
2484 *@*);;
2485 *) echo "Package $PACKAGE MAINTAINER is not an email address" >&2;;
2486 esac
2487 MSG="Missing dependencies for $PACKAGE $VERSION$EXTRAVERSION :\n" >&2
2488 for i in $DEPENDS; do
2489 [ -d $i ] && continue
2490 [ -n "$(whoprovide $i)" ] && continue
2491 echo -e "$MSG $i"
2492 MSG=""
2493 done
2494 MSG="Missing build dependencies for $PACKAGE $VERSION$EXTRAVERSION :\n" >&2
2495 for i in $BUILD_DEPENDS; do
2496 [ -d $i ] && continue
2497 [ -n "$(whoprovide $i)" ] && continue
2498 echo -e "$MSG $i"
2499 MSG=""
2500 done
2501 MSG="Dependency loop between $PACKAGE and :\n"
2502 ALL_DEPS=""
2503 check_for_deps_loop $PACKAGE $DEPENDS
2504 [ -d $WOK/$pkg/taz ] && for i in $BUILD_DEPENDS; do
2505 [ $WOK/$pkg/taz -nt $INSTALLED/$i/files.list ] && continue
2506 echo "$pkg should be rebuilt after $i installation"
2507 done
2508 done
2509 ;;
2510 list)
2511 # List packages in wok directory. User can specify a category.
2512 #
2513 get_tazwok_config
2514 if [ "$2" = "category" ]; then
2515 echo -e "\033[1m\nPackages categories :\033[0m $CATEGORIES\n"
2516 exit 0
2517 fi
2518 # Check for an asked category.
2519 if [ -n "$2" ]; then
2520 ASKED_CATEGORY=$2
2521 echo ""
2522 echo -e "\033[1mPackages in category :\033[0m $ASKED_CATEGORY"
2523 echo "================================================================================"
2524 for pkg in $WOK/*
2525 do
2526 [ ! -f $pkg/receipt ] && continue
2527 . $pkg/receipt
2528 if [ "$CATEGORY" == "$ASKED_CATEGORY" ]; then
2529 echo -n "$PACKAGE"
2530 echo -e "\033[28G $VERSION"
2531 packages=$(($packages+1))
2532 fi
2533 done
2534 echo "================================================================================"
2535 echo -e "$packages packages in category $ASKED_CATEGORY.\n"
2536 else
2537 # By default list all packages and version.
2538 echo ""
2539 echo -e "\033[1mList of packages in the wok\033[0m"
2540 echo "================================================================================"
2541 for pkg in $WOK/*
2542 do
2543 [ ! -f $pkg/receipt ] && continue
2544 . $pkg/receipt
2545 echo -n "$PACKAGE"
2546 echo -en "\033[28G $VERSION"
2547 echo -e "\033[42G $CATEGORY"
2548 packages=$(($packages+1))
2549 done
2550 echo "================================================================================"
2551 echo -e "$packages packages available in the wok.\n"
2552 fi
2553 ;;
2554 info)
2555 # Information about a package.
2556 #
2557 get_tazwok_config
2558 check_for_package_on_cmdline
2559 check_for_receipt
2560 . $WOK/$PACKAGE/receipt
2561 echo ""
2562 echo -e "\033[1mTazwok package information\033[0m
2563 ================================================================================
2564 Package : $PACKAGE
2565 Version : $VERSION
2566 Category : $CATEGORY
2567 Short desc : $SHORT_DESC
2568 Maintainer : $MAINTAINER"
2569 if [ ! "$WEB_SITE" = "" ]; then
2570 echo "Web site : $WEB_SITE"
2571 fi
2572 if [ ! "$DEPENDS" = "" ]; then
2573 echo "Depends : $DEPENDS"
2574 fi
2575 if [ ! "$WANTED" = "" ]; then
2576 echo "Wanted src : $WANTED"
2577 fi
2578 echo "================================================================================"
2579 echo ""
2580 ;;
2581 check-log)
2582 # We just cat the file log to view process info.
2583 #
2584 get_tazwok_config
2585 if [ ! -f "$LOG" ]; then
2586 echo -e "\nNo process log found. The package is probably not cooked.\n" >&2
2587 exit 1
2588 else
2589 echo ""
2590 echo -e "\033[1mPackage process log for :\033[0m $PACKAGE"
2591 echo "================================================================================"
2592 cat $LOG
2593 echo "================================================================================"
2594 echo ""
2595 if [ -s "$WOK/$PACKAGE/warning.txt" ]; then
2596 echo -e "\033[1mCook warning(s) for :\033[0m $PACKAGE"
2597 echo "================================================================================"
2598 cat "$WOK/$PACKAGE/warning.txt"
2599 echo "================================================================================"
2600 echo ""
2601 fi
2602 fi
2603 ;;
2604 search)
2605 # Search for a package by pattern or name.
2606 #
2607 get_tazwok_config
2608 if [ -z "$2" ]; then
2609 echo -e "\nPlease specify a pattern or a package name to search." >&2
2610 echo -e "Example : 'tazwok search gcc'.\n" >&2
2611 exit 1
2612 fi
2613 echo ""
2614 echo -e "\033[1mSearch result for :\033[0m $2"
2615 echo "================================================================================"
2616 list=`ls -1 $WOK | fgrep $2`
2617 for pkg in $list
2618 do
2619 . $WOK/$pkg/receipt
2620 echo -n "$PACKAGE "
2621 echo -en "\033[24G $VERSION"
2622 echo -e "\033[42G $CATEGORY"
2623 packages=$(($PACKAGEs+1))
2624 done
2625 echo "================================================================================"
2626 echo "$packages packages found for : $2"
2627 echo ""
2628 ;;
2629 compile)
2630 # Configure and make a package with the receipt.
2631 #
2632 get_tazwok_config
2633 source_lib report
2634 report start
2635 compile_package
2636 ;;
2637 genpkg)
2638 # Generate a package.
2639 #
2640 get_tazwok_config
2641 source_lib report
2642 report start
2643 gen_package
2644 ;;
2645 cook)
2646 # Compile and generate a package. Just execute tazwok with
2647 # the good commands.
2648 #
2649 check_root
2650 get_tazwok_config
2651 source_lib report
2652 report start
2653 update_wan_db
2654 check_for_commit
2655 [ "$plan_sort_depdb" ] && sort -o $dep_db $dep_db && unset plan_sort_depdb
2656 [ "$plan_sort_wandb" ] && sort -o $wan_db $wan_db && unset plan_sort_wandb
2657 if [ "$plan_regen_cookorder" ]; then
2658 [ "$(sed 1!d $PACKAGES_REPOSITORY/cookorder.txt)" = "#PlanSort" ] || \
2659 sed 1i"#PlanSort" -i $PACKAGES_REPOSITORY/cookorder.txt
2660 fi
2661 cook
2662 ;;
2663 sort-cooklist)
2664 if [ ! -f "$LIST" ]; then
2665 echo "Usage : tazwok sort-cooklist cooklist" >&2
2666 exit 1
2667 fi
2668 check_root
2669 get_tazwok_config
2670 report(){ : ; }
2671 # When using sort-cooklist, the script should behave as for gen-cooklist
2672 # The only difference between these two is where the output is sent.
2673 COMMAND=gen-cooklist
2674 cooklist=$LIST
2675 gen_cook_list
2676 cp -af $tmp/cooklist $cooklist
2677 ;;
2678 cook-list)
2679 # Cook all packages listed in a file or in default cooklist.
2680 check_root
2681 get_options_list="pkg forced"
2682 get_tazwok_config
2683 source_lib report
2684 report start
2685 if ! [ "$pkg" ]; then
2686 cooklist=${LIST:-$PACKAGES_REPOSITORY/cooklist}
2687 fi
2688 gen_cook_list
2689 cook_list
2690 ;;
2691 clean)
2692 # Clean up a package work directory + those which want it.
2693 #
2694 get_tazwok_config
2695 check_for_package_on_cmdline
2696 check_for_receipt
2697 source_lib report
2698 report start
2699 . $RECEIPT
2700 clean
2701 ;;
2702 gen-clean-wok)
2703 # Generate a clean wok from the current wok by copying all receipts
2704 # and stuff directory.
2705 #
2706 get_tazwok_config
2707 source_lib report
2708 report start
2709 if [ -z "$ARG" ]; then
2710 echo -e "\nPlease specify the destination for the new clean wok.\n" >&2
2711 exit 1
2712 else
2713 dest=$ARG
2714 mkdir -p $dest
2715 fi
2716 report step "Creating clean wok in : $dest"
2717 for pkg in `ls -1 $WOK`
2718 do
2719 mkdir -p $dest/$pkg
2720 cp -a $WOK/$pkg/receipt $dest/$pkg
2721 [ -f $WOK/$pkg/description.txt ] && \
2722 cp -a $WOK/$pkg/description.txt $dest/$pkg
2723 if [ -d "$WOK/$pkg/stuff" ]; then
2724 cp -a $WOK/$pkg/stuff $dest/$pkg
2725 fi
2726 done
2727 [ -d $WOK/.hg ] && cp -a $WOK/.hg $dest
2728 report end-step
2729 echo "Packages cleaned : `ls -1 $dest | wc -l`"
2730 echo ""
2731 ;;
2732 clean-wok)
2733 # Clean all packages in the work directory.
2734 #
2735 get_tazwok_config
2736 source_lib report
2737 report start
2738 report step "Cleaning wok"
2739 for PACKAGE in `ls -1 $WOK`
2740 do
2741 set_common_path
2742 source_receipt
2743 clean
2744 done
2745 echo "`ls -1 $WOK | wc -l` packages cleaned."
2746 ;;
2747 clean-src)
2748 # Remove tarball unrelated to wok receipts from src repo.
2749 check_root
2750 get_options_list="forced"
2751 get_tazwok_config
2752 cd $SOURCES_REPOSITORY
2753 echo -n "Checking $SOURCES_REPOSITORY..."
2754 for TARBALL in *; do
2755 [ "$TARBALL" = sources.list ] && continue
2756 grep -q $'\t'$TARBALL$ $SOURCES_REPOSITORY/sources.list || \
2757 echo $TARBALL >> $tmp/obsolete
2758 done
2759 status
2760 if ! [ -f $tmp/obsolete ]; then
2761 echo "No sources need to be removed."
2762 exit 1
2763 fi
2764 echo ""
2765 echo -e "\033[1mObsolete/unrelated-to-wok sources :\033[0m"
2766 horizontal_line
2767 cat $tmp/obsolete
2768 horizontal_line
2769 echo "$(wc -l $tmp/obsolete | cut -f1 -d' ') tarballs to remove."
2770 echo ""
2771 echo -n "Please confirm before removing (type uppercase YES): "
2772 read answer
2773 if [ "$answer" = YES ]; then
2774 echo -n "Removing old sources..."
2775 cat $tmp/obsolete | while read i; do
2776 rm -f $SOURCES_REPOSITORY/$i
2777 done
2778 status
2779 fi
2780 ;;
2781 gen-list)
2782 get_tazwok_config
2783 if [ "$2" ]; then
2784 if [ -d "$2" ]; then
2785 pkg_repository=$2
2786 else
2787 echo -e "\nUnable to find directory : $2\n" >&2
2788 exit 1
2789 fi
2790 fi
2792 source_lib report
2793 report start
2794 if [ "$pkg_repository" ]; then
2795 gen_packages_db
2796 else
2797 pkg_repository=$PACKAGES_REPOSITORY && gen_packages_db
2798 pkg_repository=$INCOMING_REPOSITORY && gen_packages_db
2799 fi
2800 ;;
2801 check-list)
2802 # The directory to move into by default is the repository,
2803 # if $2 is not empty cd into $2.
2804 #
2805 get_tazwok_config
2806 if [ "$2" ]; then
2807 if [ -d "$2" ]; then
2808 pkg_repository=$2
2809 else
2810 echo -e "\nUnable to find directory : $2\n" >&2
2811 exit 1
2812 fi
2813 fi
2815 source_lib report
2816 report start
2817 if [ "$pkg_repository" ]; then
2818 update_packages_db
2819 else
2820 pkg_repository=$PACKAGES_REPOSITORY && update_packages_db
2821 pkg_repository=$INCOMING_REPOSITORY && update_packages_db
2822 fi
2823 ;;
2824 new-tree)
2825 # Just create a few directories and generate an empty receipt to prepare
2826 # the creation of a new package.
2827 #
2828 get_tazwok_config
2829 check_for_package_on_cmdline
2830 clean_wok=$LOCAL_REPOSITORY/clean-wok
2831 if [ -d $clean_wok/$PACKAGE ]; then
2832 echo -e "\n$PACKAGE package tree already exists.\n" >&2
2833 exit 1
2834 fi
2835 echo "Creating : $clean_wok/$PACKAGE"
2836 mkdir $clean_wok/$PACKAGE
2837 cd $clean_wok/$PACKAGE
2838 echo -n "Preparing the receipt..."
2839 #
2840 # Default receipt begin.
2841 #
2842 echo "# SliTaz package receipt." > receipt
2843 echo "" >> receipt
2844 echo "PACKAGE=\"$PACKAGE\"" >> receipt
2845 # Finish the empty receipt.
2846 cat >> receipt << "EOF"
2847 VERSION=""
2848 CATEGORY=""
2849 SHORT_DESC=""
2850 MAINTAINER=""
2851 DEPENDS=""
2852 TARBALL="$PACKAGE-$VERSION.tar.gz"
2853 WEB_SITE=""
2854 WGET_URL=""
2856 # Rules to configure and make the package.
2857 compile_rules()
2858 {
2859 cd $src
2860 ./configure && make && make install
2861 }
2863 # Rules to gen a SliTaz package suitable for Tazpkg.
2864 genpkg_rules()
2865 {
2866 mkdir -p $fs/usr
2867 cp -a $_pkg/usr/bin $fs/usr
2868 }
2870 EOF
2871 #
2872 # Default receipt end.
2873 #
2874 status
2875 # Interactive mode, asking and seding.
2876 if [ "$3" = "--interactive" ]; then
2877 echo "Entering interactive mode..."
2878 echo "================================================================================"
2879 echo "Package : $PACKAGE"
2880 # Version.
2881 echo -n "Version : " ; read anser
2882 sed -i s/'VERSION=\"\"'/"VERSION=\"$anser\""/ receipt
2883 # Category.
2884 echo -n "Category : " ; read anser
2885 sed -i s/'CATEGORY=\"\"'/"CATEGORY=\"$anser\""/ receipt
2886 # Short description.
2887 echo -n "Short desc : " ; read anser
2888 sed -i s/'SHORT_DESC=\"\"'/"SHORT_DESC=\"$anser\""/ receipt
2889 # Maintainer.
2890 echo -n "Maintainer : " ; read anser
2891 sed -i s/'MAINTAINER=\"\"'/"MAINTAINER=\"$anser\""/ receipt
2892 # Web site.
2893 echo -n "Web site : " ; read anser
2894 sed -i s#'WEB_SITE=\"\"'#"WEB_SITE=\"$anser\""# receipt
2895 echo ""
2896 # Wget URL.
2897 echo "Wget URL to download source tarball."
2898 echo "Example : \$GNU_MIRROR/\$PACKAGE/\$TARBALL"
2899 echo -n "Wget url : " ; read anser
2900 sed -i s#'WGET_URL=\"\"'#"WGET_URL=\"$anser\""# receipt
2901 # Ask for a stuff dir.
2902 echo -n "Do you need a stuff directory ? (y/N) : " ; read anser
2903 if [ "$anser" = "y" ]; then
2904 echo -n "Creating the stuff directory..."
2905 mkdir stuff && status
2906 fi
2907 # Ask for a description file.
2908 echo -n "Are you going to write a description ? (y/N) : " ; read anser
2909 if [ "$anser" = "y" ]; then
2910 echo -n "Creating the description.txt file..."
2911 echo "" > description.txt && status
2912 fi
2913 echo "================================================================================"
2914 echo ""
2915 fi
2916 ;;
2917 remove)
2918 # Remove a package from the wok.
2919 #
2920 get_tazwok_config
2921 check_for_package_on_cmdline
2922 echo ""
2923 echo -n "Please confirm deletion (y/N) : "; read anser
2924 if [ "$anser" = "y" ]; then
2925 echo -n "Removing $PACKAGE..."
2926 rm -rf $WOK/$PACKAGE && status
2927 echo ""
2928 fi
2929 ;;
2930 update-wok)
2931 # Pull and update a Hg wok.
2932 get_options_list="local"
2933 get_tazwok_config
2934 source_lib report
2935 report start
2936 clean_wok=$LOCAL_REPOSITORY/clean-wok
2937 cd $clean_wok
2938 if ! [ "$local" ]; then
2939 if [ "$WOK_UPDATE_METHOD" = hg ]; then
2940 if ! [ -f "$INSTALLED/mercurial/receipt" ]; then
2942 # Auto-install only if we are in a cook chroot.
2943 if [ -x /usr/bin/clean-chroot ]; then
2944 tazpkg get-install mercurial
2945 else
2946 echo "" >&2
2947 echo "You need to install mercurial to get wok from hg (recommended). Otherwise, you can switch wok get method to \"tarball\" into $LOCAL_REPOSITORY/tazwok.conf (per-repository configuration, if it doesn't exist) or /etc/slitaz/tazwok.conf (global configuration)." | fold -s >&2
2948 echo "">&2
2949 exit 1
2950 fi
2951 fi
2953 report step "Getting wok changes using hg"
2954 if [ -d .hg ]; then
2955 hg pull -u || exit 1
2956 else
2957 hg clone $HG_WOK . || exit 1
2958 fi
2959 report end-step
2960 [ -x /usr/bin/clean-chroot ] && clean-chroot
2961 else
2962 report step "Getting wok changes using tarball"
2963 { mkdir .tmp && cd .tmp
2964 wget "$TARBALL_WOK" &&
2965 case $TARBALL_WOK in
2966 *bz2) tar xjf *.bz2 -C wok; rm *.bz2;;
2967 *lzma) unlzma -c *.lzma | tar xf - -C wok; rm *.lzma ;;
2968 *gz) tar xzf *.gz -C wok; rm*.gz ;;
2969 esac &&
2970 rm -r $(ls -d $clean_wok/*) &&
2971 cp -a wok/* $clean_wok &&
2972 cd .. &&
2973 rm -r .tmp
2974 } || { echo "That's not cool: it fails!" >&2
2975 report end-step
2976 exit 1; }
2977 report end-step
2978 fi
2979 fi
2980 report step "Appending changes to wok"
2982 # Handle removed files/dir.
2983 cd $WOK
2984 for dir in *; do
2985 [ -d "$clean_wok/$dir" ] || rm -rf $dir
2986 done
2987 for file in */receipt */description.txt; do
2988 [ -f "$clean_wok/$file" ] || rm -rf $file
2989 done
2990 for i in $(find */stuff 2>/dev/null); do
2991 [ -e "$clean_wok/$i" ] || rm -rf $i
2992 done
2994 cp -a $clean_wok/* $WOK
2995 report end-step
2996 ;;
2997 maintainers)
2998 get_tazwok_config
2999 echo ""
3000 echo "List of maintainers for: $WOK"
3001 echo "================================================================================"
3002 touch /tmp/slitaz-maintainers
3003 for pkg in $WOK/*
3004 do
3005 . $pkg/receipt
3006 if ! fgrep -q "$MAINTAINER" /tmp/slitaz-maintainers; then
3007 echo "$MAINTAINER" >> /tmp/slitaz-maintainers
3008 echo "$MAINTAINER"
3009 fi
3010 done
3011 echo "================================================================================"
3012 echo "Maintainers: `cat /tmp/slitaz-maintainers | wc -l`"
3013 echo ""
3014 # Remove tmp files
3015 rm -f /tmp/slitaz-maintainers
3016 ;;
3017 maintained-by)
3018 # Search for packages maintained by a contributor.
3019 get_tazwok_config
3020 if [ ! -n "$2" ]; then
3021 echo "Specify a name or email of a maintainer." >&2
3022 exit 1
3023 fi
3024 echo "Maintainer packages"
3025 echo "================================================================================"
3026 for pkg in $WOK/*
3027 do
3028 . $pkg/receipt
3029 if echo "$MAINTAINER" | fgrep -q "$2"; then
3030 echo "$PACKAGE"
3031 packages=$(($PACKAGEs+1))
3032 fi
3033 done
3034 echo "================================================================================"
3035 echo "Packages maintained by $2: $PACKAGEs"
3036 echo ""
3037 ;;
3038 tags)
3039 get_tazwok_config
3040 echo -e "\n\033[1mTags list :\033[0m"
3041 horizontal_line
3042 cd $WOK
3043 for i in */receipt; do
3044 unset TAGS
3045 source $i
3046 for t in $TAGS; do
3047 grep -q ^$t$ $tmp/tags && continue
3048 echo $t | tee -a $tmp/tags
3049 done
3050 done
3051 horizontal_line
3052 echo "$(wc -l $tmp/tags | cut -f1 -d ' ') tags listed."
3053 ;;
3054 check-src)
3055 # Verify if upstream package is still available.
3056 #
3057 get_tazwok_config
3058 check_for_package_on_cmdline
3059 check_for_receipt
3060 source_receipt
3061 check_src()
3062 {
3063 for url in $@; do
3064 busybox wget -s $url 2>/dev/null && break
3065 done
3066 }
3067 if [ "$WGET_URL" ];then
3068 echo -n "$PACKAGE : "
3069 check_src $WGET_URL
3070 status
3071 else
3072 echo "No tarball to check for $PACKAGE"
3073 fi
3074 ;;
3075 get-src)
3076 check_root
3077 get_options_list="target nounpack"
3078 get_tazwok_config
3079 check_for_package_on_cmdline
3080 check_for_receipt
3081 source_receipt
3082 if [ "$WGET_URL" ];then
3083 source_lib report
3084 report start
3085 check_for_tarball
3086 else
3087 echo "No tarball to download for $PACKAGE"
3088 fi
3089 ;;
3090 check-commit)
3091 check_root
3092 get_options_list="missing forced"
3093 get_tazwok_config
3094 source_lib report
3095 report start
3096 if [ "$forced" ]; then
3097 rm -f $WOK/*/md5
3098 unset forced
3099 fi
3100 if [ "$missing" ]; then
3101 pkg=$(ls -1 $WOK)
3102 else
3103 pkg="$({ grep ^[a-zA-Z0-9] $PACKAGES_REPOSITORY/packages.txt
3104 grep ^[a-zA-Z0-9] $INCOMING_REPOSITORY/packages.txt
3105 } | sort -u)"
3106 fi
3107 cooklist=$PACKAGES_REPOSITORY/cooklist
3108 gen_cook_list
3109 ;;
3110 cook-commit)
3111 check_root
3112 get_options_list="missing forced"
3113 get_tazwok_config
3114 source_lib report
3115 report start
3116 if [ "$forced" ]; then
3117 rm -f $WOK/*/md5
3118 unset forced
3119 fi
3120 if [ "$missing" ]; then
3121 pkg=$(ls -1 $WOK)
3122 else
3123 pkg="$({ grep ^[a-zA-Z0-9] $PACKAGES_REPOSITORY/packages.txt
3124 grep ^[a-zA-Z0-9] $INCOMING_REPOSITORY/packages.txt
3125 } | sort -u)"
3126 fi
3127 cooklist=$PACKAGES_REPOSITORY/cooklist
3128 gen_cook_list
3129 cook_list
3130 ;;
3131 cook-all)
3132 check_root
3133 get_options_list="forced missing"
3134 get_tazwok_config
3135 source_lib report
3136 report start
3137 if [ "$missing" ]; then
3138 pkg=$(ls -1 $WOK)
3139 else
3140 pkg="$({ grep ^[a-zA-Z0-9] $PACKAGES_REPOSITORY/packages.txt
3141 grep ^[a-zA-Z0-9] $INCOMING_REPOSITORY/packages.txt
3142 } | sort -u)"
3143 fi
3144 cooklist=$PACKAGES_REPOSITORY/cooklist
3145 gen_cook_list
3146 cook_list
3147 ;;
3148 gen-wok-db)
3149 check_root
3150 get_tazwok_config
3151 source_lib report
3152 report start
3153 gen_wok_db
3154 ;;
3155 report)
3156 get_tazwok_config
3157 cd $PACKAGES_REPOSITORY
3158 if [ "$2" ]; then
3159 case $2 in
3160 commit|cooklist|incoming|broken|blocked)
3161 show="$2"
3162 ;;
3163 *)
3164 echo "usage : tazwok report [commit|cooklist|incoming|broken|blocked]" >&2
3165 exit 1
3166 ;;
3167 esac
3168 else
3169 show="commit cooklist incoming broken blocked"
3170 fi
3171 for i in $show; do
3172 if [ -s $i ]; then
3173 echo ""
3174 echo -e "\033[1m$i\033[0m"
3175 echo "================================================================================"
3176 cat $i
3177 echo "================================================================================"
3178 echo ""
3179 fi
3180 done
3181 ;;
3182 check-incoming)
3183 check_root
3184 get_options_list="forced"
3185 get_tazwok_config
3186 source_lib report
3187 report start
3188 [ -f $LOCAL_RESOSITORY/incoming ] && rm [ -f $LOCAL_REPOSITORY/incoming ]
3189 report step "Checking $INCOMING_REPOSITORY"
3190 report open-bloc
3191 [ -f $LOCAL_REPOSITORY/log/incoming.html ] && rm $LOCAL_REPOSITORY/log/incoming.html
3192 report sublog $LOCAL_REPOSITORY/log/incoming.html
3193 echo "incoming" > $LOCAL_REPOSITORY/log/package
3194 check_for_incoming
3195 report end-sublog
3196 report close-bloc
3197 ;;
3198 configure-chroot)
3199 check_root
3200 get_tazwok_config
3201 if [ -f /usr/bin/tazchroot ]; then
3202 cd $LOCAL_REPOSITORY
3203 configure_tazchroot
3204 else
3205 echo "The package tazchroot needs to be installed" >&2
3206 exit 1
3207 fi
3208 ;;
3209 chroot)
3210 check_root
3211 get_tazwok_config
3212 # Merge this and the other chroot function ?.
3213 if [ -f /usr/bin/tazchroot ]; then
3214 cd $LOCAL_REPOSITORY
3215 [ ! -f tazchroot.conf ] && configure_tazchroot
3216 tazchroot
3217 else
3218 echo "The package tazchroot needs to be installed" >&2
3219 exit 1
3220 fi
3221 ;;
3222 cook-toolchain)
3223 check_root
3224 get_tazwok_config
3225 echo -n "" > $PACKAGES_REPOSITORY/broken
3226 if [ -f /usr/bin/tazchroot ]; then
3227 cd $LOCAL_REPOSITORY
3228 [ ! -f tazchroot.conf ] && configure_tazchroot
3229 tazchroot cook-toolchain
3230 # Buggy : chroot can be elsewhere.
3231 rm -r $LOCAL_REPOSITORY/chroot
3232 # /!\ to be written :
3233 # next rm chroot and plan cook-all by pushing all packages
3234 # in cooklist.
3235 else
3236 echo "The package tazchroot needs to be installed" >&2
3237 exit 1
3238 fi
3239 ;;
3240 webserver)
3241 check_root
3242 get_tazwok_config
3243 if [ "$ARG" = on ]; then
3244 if [ "$WEBSERVER" ] && [ -f "$WEBSERVER/repositories.list" ] && \
3245 grep -q ^"${undigest:-$SLITAZ_VERSION}"$ $WEBSERVER/repositories.list; then
3246 echo "Webserver is already enabled at $WEBSERVER for ${undigest:-$SLITAZ_VERSION}." >&2
3247 exit 1
3248 fi
3249 if ! [ -f $LOCAL_REPOSITORY/tazchroot.conf ]; then
3250 tazwok configure-chroot ${undigest:+--undigest=$undigest} --SLITAZ_VERSION=$SLITAZ_VERSION --SLITAZ_DIR=$SLITAZ_DIR
3251 fi
3252 for pkg in php lighttpd; do
3253 [ -d $INSTALLED/$pkg ] || missing="$missing $pkg"
3254 done
3255 if [ "$missing" ]; then
3256 echo "You need to install these packages to start webserver: $missing." >&2
3257 exit 1
3258 fi
3259 if [ ! -f "$LOCAL_REPOSITORY/tazwok.conf" ]; then
3260 echo "Copying /etc/slitaz/tazwok.conf to $LOCAL_REPOSITORY/tazwok.conf: webserver is configured repository-by-repository."
3261 cp /etc/slitaz/tazwok.conf $LOCAL_REPOSITORY
3262 fi
3263 if ! [ "$WEBSERVER" ]; then
3264 echo -n "Where to store php pages (default: /var/www/vhosts/bb)? "
3265 read WEBSERVER
3266 [ "$WEBSERVER" ] || WEBSERVER="/var/www/vhosts/bb"
3267 fi
3268 if [ -f "$WEBSERVER/repositories.list" ] && \
3269 grep -q ^"${undigest:-$SLITAZ_VERSION}"$ $WEBSERVER/repositories.list; then
3270 echo "Webserver is already enabled at $WEBSERVER for ${undigest:-$SLITAZ_VERSION}." >&2
3271 exit 1
3272 fi
3273 mkdir -p $WEBSERVER
3274 echo "${undigest:-$SLITAZ_VERSION}" >> $WEBSERVER/repositories.list
3275 for file in index.php log.php download.php; do
3276 [ -f "$WEBSERVER/$file" ] || ln -s /usr/share/slitaz/web-bb/$file $WEBSERVER
3277 done
3278 for dir in $PACKAGES_REPOSITORY $INCOMING_REPOSITORY; do
3279 ln -s $dir $WEBSERVER/${undigest:-$SLITAZ_VERSION}-${dir##*/}
3280 done
3281 source $LOCAL_REPOSITORY/tazchroot.conf
3282 echo "<?php
3284 // Web interface configuration
3286 \$version=\"${undigest:-$SLITAZ_VERSION}\";
3287 \$chroot=\"$chroot_dir\";
3288 \$lockfile=\"\$chroot/proc/1/status\";
3289 \$db_dir=\"$PACKAGES_REPOSITORY\";
3290 \$log_dir=\"$LOCAL_REPOSITORY/log\";
3291 \$packages=\"$PACKAGES_REPOSITORY\";
3292 \$incoming=\"$INCOMING_REPOSITORY\";
3293 \$wok=\"$WOK\";
3295 ?>" > $WEBSERVER/conf-${undigest:-$SLITAZ_VERSION}.php
3296 [ -L "$WEBSERVER/web" ] || ln -s /usr/share/slitaz/web $WEBSERVER
3297 echo "WEBSERVER=\"$WEBSERVER\"" >> $LOCAL_REPOSITORY/tazwok.conf
3298 if [ -L "$WEBSERVER/conf.php" ]; then
3299 echo "Do you want to make ${undigest:-$SLITAZ_VERSION} the default page (y/N) ? "
3300 read answer
3301 if [ "$answer" = y ]; then
3302 rm $WEBSERVER/conf.php
3303 ln -s $WEBSERVER/conf-${undigest:-$SLITAZ_VERSION}.php $WEBSERVER/conf.php
3304 fi
3305 else
3306 ln -s $WEBSERVER/conf-${undigest:-$SLITAZ_VERSION}.php $WEBSERVER/conf.php
3307 fi
3308 elif [ "$ARG" = off ]; then
3309 if ! [ "$WEBSERVER" ]; then
3310 echo "No webserver running for ${undigest:-$SLITAZ_VERSION}" >&2
3311 exit 1
3312 fi
3313 sed '/^WEBSERVER/d' -i $LOCAL_REPOSITORY/tazwok.conf
3314 sed "/^${undigest:-$SLITAZ_VERSION}$/d" -i $WEBSERVER/repositories.list
3315 rm $WEBSERVER/conf-${undigest:-$SLITAZ_VERSION}.php
3316 for dir in $PACKAGES_REPOSITORY $INCOMING_REPOSITORY; do
3317 rm $WEBSERVER/${undigest:-$SLITAZ_VERSION}-${dir##*/}
3318 done
3319 if ! [ -s "$WEBSERVER/repositories.list" ]; then
3320 echo "$WEBSERVER/repositories.list is empty; tazwok doesn't remove the server automatically in case you have important stuff in it. If that's not the case, you can remove it using: rm -r $WEBSERVER"
3321 rm $WEBSERVER/conf.php
3322 elif [ "$(readlink $WEBSERVER/conf.php)" = "$WEBSERVER/conf-${undigest:-$SLITAZ_VERSION}.php" ]; then
3323 echo "${undigest:-$SLITAZ_VERSION} was the default version to use; switched to : $(sed 1!d $WEBSERVER/repositories.list)"
3324 rm $WEBSERVER/conf.php
3325 ln -s $WEBSERVER/conf-$(sed 1!d $WEBSERVER/repositories.list).php $WEBSERVER/conf.php
3326 fi
3327 else
3328 echo "Usage: tazwok webserver on/off" >&2
3329 exit 1
3330 fi
3331 ;;
3332 block)
3333 # Add a pkg name to the list of blocked packages.
3334 get_tazwok_config
3335 check_root
3336 check_for_package_on_cmdline
3337 if ! [ -f $WOK/$PACKAGE/receipt ]; then
3338 echo "Can't find $PACKAGE in wok." >&2
3339 echo ""
3340 exit 1
3341 fi
3342 echo ""
3343 if grep -qs "^$PACKAGE$" $PACKAGES_REPOSITORY/blocked; then
3344 echo "$PACKAGE is already in the blocked packages list." >&2
3345 echo ""
3346 exit 1
3347 else
3348 echo -n "Adding $PACKAGE to : $PACKAGES_REPOSITORY/blocked... "
3349 echo "$PACKAGE" >> $PACKAGES_REPOSITORY/blocked
3350 status
3351 if grep -q "^$PACKAGE$" $PACKAGES_REPOSITORY/cooklist; then
3352 echo -n "Removing $PACKAGE from : $PACKAGES_REPOSITORY/cooklist... "
3353 sed -i /"^$PACKAGE$"/d $PACKAGES_REPOSITORY/cooklist
3354 status
3355 fi
3356 fi
3357 echo "" ;;
3358 unblock)
3359 # Remove a pkg name from the list of blocked packages.
3360 get_tazwok_config
3361 check_root
3362 check_for_package_on_cmdline
3363 if ! [ -f $WOK/$PACKAGE/receipt ]; then
3364 echo "Can't find $PACKAGE in wok." >&2
3365 echo ""
3366 exit 1
3367 fi
3368 echo ""
3369 if grep -qs "^$PACKAGE$" $PACKAGES_REPOSITORY/blocked; then
3370 echo -n "Removing $PACKAGE from : $PACKAGES_REPOSITORY/blocked... "
3371 sed -i /"^$PACKAGE$"/d $PACKAGES_REPOSITORY/blocked
3372 sed -i '/^$/d' $PACKAGES_REPOSITORY/blocked
3373 status
3374 else
3375 echo "$PACKAGE is not in the blocked packages list." >&2
3376 echo ""
3377 exit 1
3378 fi
3379 echo "" ;;
3380 usage|*)
3381 # Print usage also for all unknown commands.
3382 #
3383 usage
3384 ;;
3385 esac
3387 report stop 2>/dev/null
3388 exit 0