tazwok: 1dc5d972d44b tazwok

531 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."

532 fi

533 fi

534 fi

535

536 if [ "$repack_src" = yes ]; then

537 report step "Repacking sources in .tar.lzma format"

538 [ "$TARBALL" ] && rm -f $SOURCES_REPOSITORY/$TARBALL

539 TARBALL=${SOURCE:-$PACKAGE}-$VERSION.tar.lzma

540 cd $tmp_src

541 tar -c * | lzma e $SOURCES_REPOSITORY/$TARBALL -si

542 fi

543

544 # Remove previous tarball if no other package needs it. We take care to

545 # keep tarball if the same package uses it in the main repository.

546 if [ "$TARBALL" ]; then

547 previous_tarball=$(grep ^$PACKAGE:incoming $SOURCES_REPOSITORY/sources.list | cut -f2)

548 if [ "$previous_tarball" ]; then

549 sed "/^$PACKAGE:incoming/ s/.*/$PACKAGE:incoming\t$TARBALL/" \

550 -i $SOURCES_REPOSITORY/sources.list

551 grep -q $'\t'$previous_tarball$ $SOURCES_REPOSITORY/sources.list || \

552 rm -f $SOURCES_REPOSITORY/$previous_tarball

553 else

554 echo -e "$PACKAGE:incoming\t$TARBALL" >> $SOURCES_REPOSITORY/sources.list

555 fi

556 fi

557

558 if [ "$nounpack" ]; then

559 [ -d "$tmp_src" ] && rm -r $tmp_src

560 report end-step

561 return

562 fi

563 if [ ! -d "$src" ]|| [ "$target" ]; then

564 # Permissions settings.

565 chown -R root.root "$tmp_src"

566 if [ -d "$src" ]; then

567 mkdir -p $src

568 for f in $tmp_src/*/*; do

569 cp -a $f $src || { report end-step; rm -r $tmp_src; return 1; }

570 done

571 else

572 if ! check_for_var_modification src _pkg && ! [ "$target" ]; then

573 src="${src%/*}/$(ls $tmp_src)"

574 fi

575 mv $(echo $tmp_src/*) "$src" || { report end-step; rm -r $tmp_src; return 1; }

576 fi

577 rm -r $tmp_src

578 else

579 [ -d "$tmp_src" ] && rm -r $tmp_src

580 echo "There's already something at $src. Abort." >&2

581 fi

582 report end-step

583 }

584

585 # help gen sources.list file from scranch

586 gen_sources_list()

587 {

588 local src_repository=$1

589 [ -f $src_repository/sources.list ] && rm -f $src_repository/sources.list

590 for i in $WOK/*; do

591 unset PACKAGE SOURCE VERSION WGET_URL TARBALL WANTED

592 [ -f $i/receipt ] && source $i/receipt

593 [ "$WGET_URL" ] || continue

594 if grep -q "^$PACKAGE | $VERSION" $PACKAGES_REPOSITORY/packages.desc; then

595 main_version="$VERSION"

596 if [ -f $src_repository/${SOURCE:-$PACKAGE}-$VERSION.tar.lzma ]; then

597 echo -e "$PACKAGE:main\t${SOURCE:-$PACKAGE}-$VERSION.tar.lzma" >> $src_repository/sources.list

598 elif [ -f "$src_repository/$TARBALL" ]; then

599 echo -e "$PACKAGE:main\t$TARBALL" >> $src_repository/sources.list

600 fi

601 else

602 # May not works if package use extraversion.

603 main_version=$(grep -m1 -A1 -sh ^$PACKAGE$ $PACKAGES_REPOSITORY/packages.txt | tail -1 | sed 's/ *//')

604 if [ -f $src_repository/${SOURCE:-$PACKAGE}-$main_version.tar.lzma ]; then

605 echo -e "$PACKAGE:main\t${SOURCE:-$PACKAGE}-$main_version.tar.lzma" >> $src_repository/sources.list

606 else

607 unset main_version

608 fi

609 fi

610 if [ ! "$main_version" ] || [ $(grep -q "^$PACKAGE | $VERSION" $INCOMING_REPOSITORY/packages.desc 2>/dev/null) ]; then

611 if [ -f $src_repository/${SOURCE:-$PACKAGE}-$VERSION.tar.lzma ]; then

612 echo -e "$PACKAGE:incoming\t${SOURCE:-$PACKAGE}-$VERSION.tar.lzma" >> $src_repository/sources.list

613 elif [ -f "$src_repository/$TARBALL" ]; then

614 echo -e "$PACKAGE:incoming\t$TARBALL" >> $src_repository/sources.list

615 fi

616 fi

617 done

618 }

619

620 # Log and execute compile_rules function if it exists, to configure and

621 # make the package if it exists.

622 check_for_compile_rules()

623 {

624 if grep -q ^compile_rules $RECEIPT; then

625 echo "executing compile_rules" >> $LOG

626 report step "Executing compile_rules"

627 cd $WOK/$PACKAGE

628 rm -f /tmp/config.site

629 ulimit -d unlimited

630 ulimit -m unlimited

631

632 # Free some RAM by cleaning cache if option is enabled.

633 freeram=$(free | fgrep '/+ buffers' | tr -s ' ' | cut -f 4 -d ' ')

634

635 # Disable -pipe in CFLAGS/CXXFLAGS if less than 512Mb of free

636 # RAM are available.

637 if [ "$freeram" -lt 524288 ] && [ "$CFLAGS" != "${CFLAGS/-pipe}" -o \

638 "$CXXFLAGS" != "${CXXFLAGS/-pipe}" ]; then

639 tazwok_warning "Disabling -pipe compile flag because only ${freeram}b of RAM is available."

640 CFLAGS="${CFLAGS/-pipe}"

641 CXXFLAGS="${CXXFLAGS/-pipe}"

642 fi

643 unset freeram

644

645 # Set cook environement variables.

646 [ "$src" ] || set_src_path

647 [ "$DESTDIR" ] || DESTDIR="$WOK/$PACKAGE/install"

648 [ "$CONFIG_SITE" ] || CONFIG_SITE=/etc/config.site

649 export CFLAGS=$(echo "$CFLAGS" | tr -s ' ') \

650 CXXFLAGS=$(echo "$CXXFLAGS" | tr -s ' ') \

651 MAKEFLAGS DESTDIR BUILD_HOST CONFIG_SITE default_prefix \

652 default_datarootdir default_datadir default_localedir \

653 default_infodir default_mandir default_build default_host

654 local LC_ALL=POSIX LANG=POSIX

655 compile_rules

656

657 # Check if config.site has been used.

658 # /!\ disabled since it screws the return_code of the step.

659 #if [ -f /tmp/config.site ]; then

660 # rm /tmp/config.site

661 #else

662 # tazwok_warning "config.site hasn't been used during \

663 #the configuration process."

664 #fi

665 report end-step

666 fi

667 }

668

669 # Check for loop in deps tree. /!\ can be removed.

670 check_for_deps_loop()

671 {

672 local list

673 local pkg

674 local deps

675 pkg=$1

676 shift

677 [ -n "$1" ] || return

678 list=""

679

680 # Filter out already processed deps.

681 for i in $@; do

682 case " $ALL_DEPS" in

683 *\ $i\ *);;

684 *) list="$list $i";;

685 esac

686 done

687 ALL_DEPS="$ALL_DEPS$list "

688 for i in $list; do

689 [ -f $i/receipt ] || continue

690 deps="$(DEPENDS=""; . $i/receipt; echo $DEPENDS)"

691 case " $deps " in

692 *\ $pkg\ *) echo -e "$MSG $i"; MSG="";;

693 *) check_for_deps_loop $pkg $deps;;

694 esac

695 done

696 }

697

698 # Function used by download().

699 revert_vcs_failure()

700 {

701 cd $SOURCES_REPOSITORY

702 rm -r $tmp_src

703 }

704

705 download()

706 {

707 if [ "$COMMAND" = get-src ]; then

708 if [ "${DEPENDS/tar}" != "$DEPENDS" ] || [ "${BUILD_DEPENDS/tar}" != "$BUILD_DEPENDS" ]; then

709 [ -f $INSTALLED/tar/receipt ] || tazpkg get-install tar --forced

710 fi

711 fi

712 for file in $@; do

713 echo "Downloading from ${file#*|}..."

714 case "$file" in

715 git\|*)

716 file=${file#git|}

717 [ "$COMMAND" = get-src ] && [ ! -f $INSTALLED/git/receipt ] && tazpkg get-install git --forced

718 if [ -f $INSTALLED/git/receipt ]; then

719 mkdir $tmp_src

720 cd $tmp_src

721 if [ "$BRANCH" ]; then

722 git clone $file ${src##*/} && cd ${src##*/} && \

723 git checkout $BRANCH && rm -rf .git* && break

724 else

725 git clone $file ${src##*/} && rm -rf ${src##*/}/.git* && break

726 fi

727 revert_vcs_failure

728 else

729 tazwok_warning "Needs git to download the source tarball from $file, please add it as a build-depend."

730 continue

731 fi

732 ;;

733 bazaar\|*)

734 file=${file#bazaar|}

735 [ "$COMMAND" = get-src ] && [ ! -f $INSTALLED/bazaar/receipt ] && tazpkg get-install bazaar --forced

736 if [ -f $INSTALLED/bazaar/receipt ]; then

737 mkdir $tmp_src

738 cd $tmp_src

739 if [ "$BRANCH" ]; then

740 bzr co $file -r $BRANCH ${src##*/} && rm -rf ${src##*/}/.bzr* && break

741 else

742 bzr co $file ${src##*/} && rm -rf ${src##*/}/.bzr* && break

743 fi

744 revert_vcs_failure

745 else

746 tazwok_warning "Needs bazaar to download the source tarball from $file, please add it as a build-depend."

747 continue

748 fi

749 ;;

750 svn*|subversion*)

751 if $(echo "$WGET_URL" | fgrep -q svn); then

752 file=${WGET_URL#svn|}

753 else

754 file=${WGET_URL#subversion|}

755 fi

756 [ "$COMMAND" = get-src ] && [ ! -f $INSTALLED/subversion/receipt ] && tazpkg get-install subversion --forced

757 if [ -f $INSTALLED/subversion/receipt ]; then

758 mkdir $tmp_src

759 cd $tmp_src

760 if [ "$BRANCH" ]; then

761 echo t | svn co $file -r $BRANCH ${src##*/} && rm -rf ${src##*/}/.svn* && break

762 else

763 echo t | svn co $file ${src##*/} && rm -rf ${src##*/}/.svn* && break

764 fi

765 revert_vcs_failure

766 else

767 tazwok_warning "Needs subversion to download the source tarball from $file, please add it as a build-depend."

768 continue

769 fi

770 ;;

771 hg*|mercurial*)

772 if $(echo "$WGET_URL" | fgrep -q hg); then

773 file=${WGET_URL#hg|}

774 else

775 file=${WGET_URL#mercurial|}

776 fi

777 [ "$COMMAND" = get-src ] && [ ! -f $INSTALLED/mercurial/receipt ] && tazpkg get-install mercurial --forced

778 if [ -f $INSTALLED/mercurial/receipt ]; then

779 mkdir $tmp_src

780 cd $tmp_src

781 if [ "$BRANCH" ]; then

782 hg clone $file --rev $BRANCH ${src##*/} && rm -rf ${src##*/}/.hg* && break

783 else

784 hg clone $file ${src##*/} && rm -rf ${src##*/}/.hg* && break

785 fi

786 revert_vcs_failure

787 else

788 tazwok_warning "Needs mercurial to download the source tarball from $file, please add it as a build-depend."

789 continue

790 fi

791 ;;

792 https*)

793 [ "$COMMAND" = get-src ] && [ ! -f $INSTALLED/wget/receipt ] && tazpkg get-install wget --forced

794 if [ -d $INSTALLED/wget ]; then

795 if [ "${WGET_URL%$TARBALL}" = "$WGET_URL" ] && [ "$file" = "$WGET_URL" ]; then

796 wget -q --no-check-certificate -O $TARBALL $file && break

797 else

798 wget -q --no-check-certificate $file && break

799 fi

800 else

801 tazwok_warning "Needs wget to download the source tarball from $file, please add it as a build-depend."

802 continue

803 fi

804 ;;

805 http*|ftp*)

806 # Handle crappy URL.

807 if [ "$COMMAND" = get-src ]; then

808 if [ "${DEPENDS/wget}" != "$DEPENDS" ] || [ "${BUILD_DEPENDS/wget}" != "$BUILD_DEPENDS" ]; then

809 [ -f $INSALLED/wget/receipt ] || tazpkg get-install wget --forced

810 fi

811 fi

812 if [ "${WGET_URL%$TARBALL}" = "$WGET_URL" ] && [ "$file" = "$WGET_URL" ]; then

813 wget -q -O $TARBALL $file && break

814 else

815 wget -q $file && break

816 fi

817 ;;

818 esac

819 done

820 }

821

822 # Regenerate every package that wants a PACKAGE compiled.

823 refresh_packages_from_compile()

824 {

825 # make tazwok genpkg happy.

826 mkdir $WOK/$PACKAGE/taz

827

828 # Cook rwanted in default or specied order.

829 genlist=" $(look_for_rwanted | tr '\n' ' ') "

830 for i in $(look_for_cookopt genpkg | tac); do

831 [ "${genlist/ $i }" = "$genlist" ] && continue

832 genlist=" $i${genlist/ $i / }"

833 done

834 if [ "$genlist" ]; then

835 local PACKAGE SOURCE VERSION EXTRAVERSION CATEGORY SHORT_DESC \

836 MAINTAINER WEB_SITE WGET_URL DEPENDS BUILD_DEPENDS WANTED \

837 PACKED_SIZE UNPACKED_SIZE COOK_OPT PROVIDE CONFIG_FILES TAGS \

838 src _pkg DESTDIR CONFIG_SITE RECEIPT LOG stuff wanted_stuff

839 for PACKAGE in $genlist; do

840 set_common_path

841 gen_package

842 done

843 fi

844 }

845

846 # Copy all generic files (locale, pixmaps, .desktop). We use standard paths,

847 # so some packages need to copy these files with the receipt and genpkg_rules.

848 # This function is executed by gen_package when 'tazwok genpkg'.

849 copy_generic_files()

850 {

851 # In most cases, locales are in $_pkg/usr/share/locale so we copy files

852 # using generic variables and $LOCALE from Tazwok config file.

853 if [ "$LOCALE" ]; then

854 if [ -d "$_pkg/usr/share/locale" ]; then

855 for i in $LOCALE

856 do

857 if [ -d "$_pkg/usr/share/locale/$i" ]; then

858 mkdir -p $fs/usr/share/locale

859 cp -a $_pkg/usr/share/locale/$i $fs/usr/share/locale

860 fi

861 done

862 fi

863 fi

864

865 # Pixmaps (PNG or/and XPM only). Some icons/images can be added through

866 # genpkg_rules and generic copy can be disabled with GENERIC_PIXMAPS="no"

867 # in pkg receipt.

868 if [ "$GENERIC_PIXMAPS" != "no" ]; then

869 if [ -d "$_pkg/usr/share/pixmaps" ]; then

870 mkdir -p $fs/usr/share/pixmaps

871 cp -a $_pkg/usr/share/pixmaps/$PACKAGE.png \

872 $fs/usr/share/pixmaps 2>/dev/null

873 cp -a $_pkg/usr/share/pixmaps/$PACKAGE.xpm \

874 $fs/usr/share/pixmaps 2>/dev/null

875 fi

876

877 # Custom or homemade PNG pixmap can be in stuff.

878 if [ -f "stuff/$PACKAGE.png" ]; then

879 mkdir -p $fs/usr/share/pixmaps

880 cp -a stuff/$PACKAGE.png $fs/usr/share/pixmaps

881 fi

882 fi

883

884 # Desktop entry (.desktop).

885 if [ -d "$_pkg/usr/share/applications" ]; then

886 cp -a $_pkg/usr/share/applications $fs/usr/share

887 fi

888

889 # Homemade desktop file(s) can be in stuff.

890 if [ -d "stuff/applications" ]; then

891 mkdir -p $fs/usr/share

892 cp -a stuff/applications $fs/usr/share

893 fi

894 if [ -f "stuff/$PACKAGE.desktop" ]; then

895 mkdir -p $fs/usr/share/applications

896 cp -a stuff/$PACKAGE.desktop $fs/usr/share/applications

897 fi

898 }

899

900 # Find and strip : --strip-all (-s) or --strip-debug on static libs.

901 strip_package()

902 {

903 report step "Executing strip on all files"

904

905 # Binaries.

906 for dir in $fs/bin $fs/sbin $fs/usr/bin $fs/usr/sbin $fs/usr/games

907 do

908 if [ -d "$dir" ]; then

909 find $dir -type f -exec strip -s '{}' 2>/dev/null \;

910 fi

911 done

912

913 # Libraries.

914 find $fs -name "*.so*" -exec strip -s '{}' 2>/dev/null \;

915 find $fs -name "*.a" -exec strip --strip-debug '{}' 2>/dev/null \;

916 report end-step

917 }

918

919 # Remove .pyc, .pyo, perllocal.pod and .packlist files from packages.

920 py_compiled_files_remove()

921 {

922 report step "Removing all .pyc, .pyo, perllocal.pod, and .packlist files from package"

923 find $fs -type f -name "*.pyc" -delete 2>/dev/null

924 find $fs -type f -name "*.pyo" -delete 2>/dev/null

925 find $fs -type f -name "perllocal.pod" -delete 2>/dev/null

926 find $fs -type f -name ".packlist" -delete 2>/dev/null

927 report end-step

928 }

929

930 # Check FSH in a slitaz package (Path: /:/usr)

931 check_fsh()

932 {

933 cd $WOK/$PACKAGE/taz/*/fs

934 if [ -z "$(find * ! -type d)" ] && [ "$CATEGORY" != meta ]; then

935 echo "$PACKAGE fs is empty." >&2

936 cd $WOK/$PACKAGE && rm -rf taz

937 return 1

938 fi

939 [ -n "$FSH" ] || FSH="bin boot dev etc home init lib media mnt proc \

940 root sbin share sys tmp usr var vz usr/bin usr/games usr/include usr/lib \

941 usr/local usr/sbin usr/share usr/src"

942 error=0

943 for i in `ls -d * usr/* 2>/dev/null`

944 do

945 if ! echo $FSH | fgrep -q $i; then

946 echo "Wrong path: /$i" >&2

947 error=1

948 fi

949 done

950 if [ "$error" = "1" ]; then

951 cat << _EOT_

952

953 Package will install files in a non standard directory and won't be generated.

954 You may have a wrong copy path in genpkg_rules or need to add some options to

955 configure in compile_rules. Some valid options for SliTaz (Linux FSH):

956

957 --prefix=/usr

958 --sysconfdir=/etc

959 --libexecdir=/usr/lib/(pkgname)

960 --localstatedir=/var

961 --mandir=/usr/share/man

962 --infodir=/usr/share/info

963

964 For more information please read SliTaz docs and run: ./configure --help

965 ================================================================================

966 $PACKAGE package generation aborted.

967

968 _EOT_

969

970 # Dont generate a corrupted package.

971 cd $WOK/$PACKAGE && rm -rf taz

972 return 1

973 fi

974 return 0

975 }

976

977 gen_cookmd5()

978 {

979 # md5sum of cooking stuff make tazwok able to check for changes

980 # without hg.

981 cd $WOK/$PACKAGE

982 md5sum receipt > md5

983 [ -f description.txt ] && md5sum description.txt >> md5

984 if [ -d stuff ]; then

985 find stuff | while read file; do

986 md5sum $file >> md5

987 done

988 fi

989 }

990

991 set_pkg_broken()

992 {

993 if ! grep -q ^$PACKAGE$ $PACKAGES_REPOSITORY/broken; then

994 echo $PACKAGE >> $PACKAGES_REPOSITORY/broken

995 fi

996

997 # Remove pkg from cooklist to avoid re-cook it if no changes happen

998 # in the cook stuff.

999 sed "/^$PACKAGE$/d" -i $PACKAGES_REPOSITORY/cooklist

1000 sed "/^$PACKAGE$/d" -i $PACKAGES_REPOSITORY/commit

1001

1002 gen_cookmd5

1003

1004 # Return 1 to make report know that its mother-function failed.

1005 return 1

1006 }

1007

1008 # Create a package tree and build the gziped cpio archive

1009 # to make a SliTaz (.tazpkg) package.

1010 gen_package()

1011 {

1012 check_root

1013 check_for_package_on_cmdline

1014 check_for_receipt

1015 source_receipt

1016

1017 # May compute VERSION

1018 if grep -q ^get_version $RECEIPT; then

1019 get_version

1020 fi

1021 check_for_wanted

1022 cd $WOK/$PACKAGE

1023

1024 # Remove old Tazwok package files.

1025 [ -d "taz" ] && rm -rf taz

1026

1027 # Create the package tree and set useful variables.

1028 fs=$WOK/$PACKAGE/taz/$PACKAGE-$VERSION/fs

1029 mkdir -p $fs

1030

1031 # Set $src for standard package and $_pkg variables.

1032 set_src_path

1033 set_pkg_path

1034

1035 # Execute genpkg_rules, check package and copy generic files to build

1036 # the package.

1037 report step "Building $PACKAGE with the receipt"

1038 report open-bloc

1039 if look_for_cookopt !fs; then

1040 :

1041 elif grep -q ^genpkg_rules $RECEIPT; then

1042

1043 # Log process.

1044 echo "executing genpkg_rules" >> $LOG

1045 report step "Executing genpkg_rules"

1046 ( set -e; genpkg_rules ) || { set_pkg_broken; report close-bloc; return 1; }

1047 check_fsh || { set_pkg_broken; report close-bloc; return 1; }

1048 cd $WOK/$PACKAGE

1049 report end-step

1050

1051 # Skip generic files for packages with a WANTED variable

1052 # (dev and split pkgs).

1053 if [ ! "$WANTED" ]; then

1054 copy_generic_files

1055 fi

1056 look_for_cookopt !strip || strip_package

1057 py_compiled_files_remove

1058 else

1059 echo "No package rules to gen $PACKAGE..." >&2

1060 set_pkg_broken

1061 report close-bloc

1062 return 1

1063 fi

1064

1065 # Copy the receipt and description (if exists) into the binary package tree.

1066 cd $WOK/$PACKAGE

1067 report step "Copying the receipt"

1068 cp receipt taz/$PACKAGE-$VERSION

1069 report end-step

1070 if grep -q ^get_version $RECEIPT; then

1071 report step "Updating version in receipt"

1072 sed -i "s/^VERSION=.*/VERSION=\"$VERSION\"/" \

1073 taz/$PACKAGE-$VERSION/receipt

1074 report end-step

1075 fi

1076 if [ -f "description.txt" ]; then

1077 report step "Copying the description file"

1078 cp description.txt taz/$PACKAGE-$VERSION

1079 report end-step

1080 fi

1081

1082 # Generate md5 of cooking stuff to look for commit later.

1083 gen_cookmd5

1084 echo -e "\n# md5sum of cooking stuff :" >> taz/$PACKAGE-$VERSION/receipt

1085 cat md5 | sed 's/^/# /' >> taz/$PACKAGE-$VERSION/receipt

1086

1087 # Create the files.list by redirecting find output.

1088 report step "Creating the list of files"

1089 cd taz/$PACKAGE-$VERSION

1090 LAST_FILE=""

1091 { find fs -print; echo; } | while read file; do

1092 if [ "$LAST_FILE" ]; then

1093 case "$file" in

1094 $LAST_FILE/*)

1095 case "$(ls -ld "$LAST_FILE")" in

1096 drwxr-xr-x\ *\ root\ *\ root\ *);;

1097 *) echo ${LAST_FILE#fs};;

1098 esac;;

1099 *) echo ${LAST_FILE#fs};;

1100 esac

1101 fi

1102 LAST_FILE="$file"

1103 done > files.list

1104

1105 # Next, check if something has changed in lib files.

1106 if fgrep -q '.so' files.list; then

1107 for rep in $INCOMING_REPOSITORY $PACKAGES_REPOSITORY \

1108 $([ "$undigest" ] && echo $SLITAZ_DIR/$SLITAZ_VERSION/packages-incoming && \

1109 echo $SLITAZ_DIR/$SLITAZ_VERSION/packages); do

1110 prev_VERSION=$(get_pkg_version $rep)

1111 [ "$prev_VERSION" ] && pkg_file=$rep/$PACKAGE-$prev_VERSION.tazpkg && break

1112 done

1113 if [ "$pkg_file" ]; then

1114 report step "Looking for major/minor updates in libraries"

1115 get_pkg_files $pkg_file

1116 cd $WOK/$PACKAGE/taz/$PACKAGE-$VERSION

1117 fgrep ".so" files.list | egrep -v "[0-9][0-9]*\.[0-9][0-9]*\.[0-9][0-9]*" | \

1118 while read lib; do

1119 fgrep -q "$lib" $pkg_files_dir/files.list && continue

1120 echo "A minor/major update in libraries is detected, planning re-cook of reverse-depends of $PACKAGE."

1121 for rdep in $(scan $PACKAGE --look_for=rdep | use_wanted); do

1122 [ "$rdep" = "${WANTED:-$PACKAGE}" ] && continue

1123 grep -q ^$rdep$ $PACKAGES_REPOSITORY/blocked \

1124 $PACKAGES_REPOSITORY/cooklist && continue

1125 echo $rdep >> $PACKAGES_REPOSITORY/cooklist

1126 done

1127 regen_cooklist=yes

1128 break

1129 done

1130 rm -r $pkg_files_dir

1131 unset pkg_file

1132 report end-step

1133 fi

1134 fi

1135 if [ ! "$EXTRAVERSION" ]; then

1136 case "$PACKAGE" in

1137 linux*);;

1138 *) EXTRAVERSION="$(grep '/lib/modules/.*-slitaz/' files.list |\

1139 head -1 | sed 's|/lib/modules/$.*$-slitaz/.*|_\1|')";;

1140 esac

1141 fi

1142 rm -f $INCOMING_REPOSITORY/$PACKAGE-$VERSION$EXTRAVERSION.tazpkg 2> /dev/null

1143 report step "Creating md5sum of files"

1144 while read file; do

1145 [ -L "fs$file" ] && continue

1146 [ -f "fs$file" ] || continue

1147 md5sum "fs$file" | sed 's/ fs/ /'

1148 done < files.list > md5sum

1149 report end-step

1150 UNPACKED_SIZE=$(du -chs fs receipt files.list md5sum description.txt \

1151 2> /dev/null | awk '{ sz=$1 } END { print sz }')

1152

1153 # Build cpio archives. Find, cpio and gzip the fs, finish by

1154 # removing the fs tree.

1155 # Don't log this because compression always outputs error messages.

1156 find fs -print | cpio -o -H newc | case "$PACKAGE-$COMPRESSION" in

1157 tazpkg-lzma) gzip > fs.cpio.gz;;

1158 *-lzma) lzma e fs.cpio.lzma -si;;

1159 *) gzip > fs.cpio.gz;;

1160 esac && rm -rf fs

1161 PACKED_SIZE=$(du -chs fs.cpio.* receipt files.list md5sum \

1162 description.txt 2> /dev/null | awk '{ sz=$1 } END { print sz }')

1163 report step "Updating receipt sizes"

1164 sed -i '/^PACKED_SIZE/d' receipt

1165 sed -i '/^UNPACKED_SIZE/d' receipt

1166 sed -i "s/^PACKAGE=/PACKED_SIZE=\"$PACKED_SIZE\"\nUNPACKED_SIZE=\"$UNPACKED_SIZE\"\nPACKAGE=/" receipt

1167 sed -i "s/^VERSION=$/VERSION=\"$VERSION\"/" receipt

1168 report end-step

1169 if [ "$EXTRAVERSION" ]; then

1170 report step "Updating receipt EXTRAVERSION"

1171 sed -i s/^EXTRAVERSION.*$// receipt

1172 sed -i "s/^VERSION=/EXTRAVERSION=\"$EXTRAVERSION\"\nVERSION=/" receipt

1173 fi

1174 prev_VERSION=$(get_pkg_version $INCOMING_REPOSITORY)

1175 remove_previous_package $INCOMING_REPOSITORY

1176 report step "Creating full cpio archive"

1177 find . -print | cpio -o -H newc > $INCOMING_REPOSITORY/$PACKAGE-$VERSION$EXTRAVERSION.tazpkg

1178

1179 # Restore package tree in case we want to browse it.

1180 report step "Restoring original package tree"

1181 { zcat fs.cpio.gz 2> /dev/null || unlzma -c fs.cpio.lzma; } | cpio --quiet -id

1182 rm fs.cpio.* && cd ..

1183

1184 # Recook of reverse-depends if package was broken.

1185 if grep -q "^$PACKAGE$" $PACKAGES_REPOSITORY/broken; then

1186 report step "Planning a re-try cook of reverse depends"

1187 sed "/^$PACKAGE$/d" -i $PACKAGES_REPOSITORY/broken

1188 for rdep in $(look_for_rdep); do

1189 grep -q "^$rdep$" $PACKAGES_REPOSITORY/broken || continue

1190 grep -q "^$rdep$" $PACKAGES_REPOSITORY/cooklist && continue

1191 echo "Adding $rdep to the cooklist"

1192 echo $rdep >> $PACKAGES_REPOSITORY/cooklist

1193 regen_cooklist=t

1194 done

1195 report end-step

1196 fi

1197 sed "/^$PACKAGE$/d" -i $PACKAGES_REPOSITORY/commit

1198 sed "/^$PACKAGE$/d" -i $PACKAGES_REPOSITORY/cooklist

1199

1200 # Log process.

1201 echo "$PACKAGE-$VERSION$EXTRAVERSION.tazpkg (done)" >> $LOG

1202 report close-bloc

1203 echo "Package $PACKAGE ($VERSION$EXTRAVERSION) generated."

1204 echo "Size : `du -sh $INCOMING_REPOSITORY/$PACKAGE-$VERSION$EXTRAVERSION.tazpkg`"

1205 echo ""

1206 }

1207

1208 ########################################################################

1209 # This section contains functions used by several other functions

1210 # below.

1211 ########################

1212

1213 # Look for receipt/files.list in wok. If they can't be found, get them

1214 # from package. Accept one argument : absolute path to package.

1215 get_pkg_files()

1216 {

1217 pkg_files_dir=$tmp/$(basename ${1%.tazpkg})

1218 mkdir -p $pkg_files_dir && \

1219 cd $pkg_files_dir && \

1220 cpio --quiet -idm receipt < $1 && \

1221 cpio --quiet -idm files.list < $1

1222 }

1223

1224 ########################################################################

1225 # This section contains functions to generate packages databases.

1226 ########################

1227

1228

1229 gen_packages_db()

1230 {

1231 # pkg_repository can be $PACKAGES_REPOSITORY or $INCOMING_REPOSITORY.

1232 [ "$pkg_repository" ] || pkg_repository=$PACKAGES_REPOSITORY

1233 cd $pkg_repository

1234 report step "Generating packages lists: $pkg_repository"

1235 report open-bloc

1236 report step "Removing old files"

1237 for file in files.list.lzma packages.list packages.txt \

1238 packages.desc packages.equiv packages.md5; do

1239 [ -f $file ] && rm $file

1240 done

1241 touch files.list

1242

1243 packages_db_start

1244 unset RECEIPT

1245 report step "Reading data from all packages"

1246 for pkg in $(echo $pkg_repository/*.tazpkg | fgrep -v '*'); do

1247 get_packages_info

1248 done

1249 report end-step

1250 packages_db_end

1251 report close-bloc

1252 }

1253

1254 update_packages_db()

1255 {

1256 [ "$pkg_repository" ] || pkg_repository=$PACKAGES_REPOSITORY

1257 cd $pkg_repository

1258 for file in packages.list packages.equiv packages.md5 packages.desc \

1259 packages.txt; do

1260 if [ ! -f "$file" ]; then

1261 gen_packages_db

1262 return

1263 fi

1264 done

1265 if [ -f files.list.lzma ]; then

1266 lzma d files.list.lzma files.list

1267 else

1268 gen_packages_db

1269 return

1270 fi

1271 report step "Updating packages lists: $pkg_repository"

1272 packages_db_start

1273

1274 # Look for removed/update packages.

1275 touch stamp -r packages.list

1276 for PACKAGE in $(grep ^[0-9,a-z,A-Z] packages.txt); do

1277 pkg="$pkg_repository/$(grep -m1 ^$PACKAGE- packages.list).tazpkg"

1278 if ! [ -f "$pkg" ]; then

1279 erase_package_info

1280 else

1281 if [ "$pkg" -nt "stamp" ]; then

1282 updated_pkg="$updated_pkg

1283 $PACKAGE $pkg"

1284 elif [ ! -f $WOK/$PACKAGE/receipt ] && \

1285 [ "$COMMAND" = check-incoming -o "$pkg_repository" = "$INCOMING_REPOSITORY" ]; then

1286 erase_package_info

1287 echo "Removing $PACKAGE from $pkg_repository."

1288 rm $pkg

1289 [ -d $WOK/$PACKAGE ] && rm -r $WOK/$PACKAGE

1290 sed "/^$PACKAGE\t/d" -i $wan_db $dep_db

1291 for i in cookorder.txt cooklist commit blocked broken; do

1292 sed "/^$PACKAGE$/d" -i $PACKAGES_REPOSITORY/$i

1293 done

1294 rm -f $LOCAL_REPOSITORY/log/$PACKAGE.html

1295 if [ "$pkg_repository" = "$INCOMING_REPOSITORY" ] && \

1296 [ "$(sed 1!d $PACKAGES_REPOSITORY/cookorder.txt)" != "#PlanSort" ] ; then

1297 sed 1i"#PlanSort" -i $PACKAGES_REPOSITORY/cookorder.txt

1298 regen_cooklist=yes

1299 else

1300 echo "$PACKAGE" >> $PACKAGES_REPOSITORY/removed

1301 sed -n '1,10p' -i $PACKAGES_REPOSITORY/removed

1302 fi

1303 fi

1304 fi

1305 done

1306 rm stamp

1307 echo "$updated_pkg" | sed 1d | while read PACKAGE pkg; do

1308 erase_package_info

1309 get_packages_info

1310 done

1311 unset updated_pkg

1312

1313 # Look for new packages.

1314 for pkg in $(echo $pkg_repository/*.tazpkg | fgrep -v '*'); do

1315 if ! fgrep -q " ${pkg##*/}" $pkg_repository/packages.md5; then

1316 get_packages_info

1317 fi

1318 done

1319 report end-step

1320 packages_db_end

1321 }

1322

1323 packages_db_start()

1324 {

1325 if [ ! -s packages.txt ]; then

1326 echo "# SliTaz GNU/Linux - Packages list

1327 #

1328 # Packages : unknown

1329 # Date : $(date +%Y-%m-%d\ \%H:%M:%S)

1330 #

1331 " > packages.txt

1332 else

1333 sed -e 's/^# Packages :.*/# Packages : unknown/' \

1334 -e "s/# Date :.*/# Date : $(date +%Y-%m-%d\ \%H:%M:%S)/" \

1335 -i packages.txt

1336 fi

1337

1338 # Needed in some cases as tazwok defines RECEIPT at configuration time

1339 # in this particular case it can break the script.

1340 unset RECEIPT

1341 }

1342

1343 erase_package_info()

1344 {

1345 cd $pkg_repository

1346 sed "/^$PACKAGE$/,/^$/d" -i packages.txt

1347 sed "/^$PACKAGE /d" -i packages.desc

1348 sed -e "s/=$PACKAGE /= /" -e "s/ $PACKAGE / /" -e "s/ $PACKAGE$//" \

1349 -e "/=$PACKAGE$/d" -e "s/=[0-9,a-z,A-Z]:$PACKAGE /= /" \

1350 -e "s/ [0-9,a-z,A-Z]:$PACKAGE / /" -e "s/ [0-9,a-z,A-Z]:$PACKAGE$/ /" \

1351 -e "/=[0-9,a-z,A-Z]:$PACKAGE$/d" \

1352 -i packages.equiv

1353 sed "/^$PACKAGE:/d" -i files.list

1354 sed "/^$(basename ${pkg%.tazpkg})$/d" -i packages.list

1355 sed "/ $(basename $pkg)$/d" -i packages.md5

1356 }

1357

1358 get_packages_info()

1359 {

1360 # If there's no taz folder in the wok, extract info from the

1361 # package.

1362 get_pkg_files $pkg

1363 source_receipt

1364 echo "Getting data from $PACKAGE"

1365

1366 cat >> $pkg_repository/packages.txt << _EOT_

1367 $PACKAGE

1368 $VERSION$EXTRAVERSION

1369 $SHORT_DESC

1370 _EOT_

1371 if [ "$PACKED_SIZE" ]; then

1372 cat >> $pkg_repository/packages.txt << _EOT_

1373 $PACKED_SIZE ($UNPACKED_SIZE installed)

1374

1375 _EOT_

1376 else

1377 echo "" >> $pkg_repository/packages.txt

1378 fi

1379

1380 # Packages.desc is used by Tazpkgbox <tree>.

1381 echo "$PACKAGE | $VERSION$EXTRAVERSION | $SHORT_DESC | $CATEGORY | $WEB_SITE" >> $pkg_repository/packages.desc

1382

1383 # Packages.equiv is used by tazpkg install to check depends.

1384 for i in $PROVIDE; do

1385 DEST=""

1386 echo $i | fgrep -q : && DEST="${i#*:}:"

1387 if grep -qs ^${i%:*}= $pkg_repository/packages.equiv; then

1388 sed -i "s/^${i%:*}=/${i%:*}=$DEST$PACKAGE /" $pkg_repository/packages.equiv

1389 else

1390 echo "${i%:*}=$DEST$PACKAGE" >> $pkg_repository/packages.equiv

1391 fi

1392 done

1393

1394 if [ -f files.list ]; then

1395 { echo "$PACKAGE"; cat files.list; } | awk '

1396 BEGIN { name="" } { if (name == "") name=$0; else printf("%s: %s\n",name,$0); }' >> $pkg_repository/files.list

1397 fi

1398

1399 cd .. && rm -r "$pkg_files_dir"

1400

1401 cd $pkg_repository

1402 echo $(basename ${pkg%.tazpkg}) >> packages.list

1403 [ ! "$package_md5" ] && package_md5=$(md5sum $(basename $pkg))

1404 echo "$package_md5" >> packages.md5

1405 unset package_md5

1406 }

1407

1408 source_receipt()

1409 {

1410 unset PACKAGE SOURCE VERSION EXTRAVERSION CATEGORY SHORT_DESC \

1411 MAINTAINER WEB_SITE WGET_URL DEPENDS BUILD_DEPENDS WANTED \

1412 PACKED_SIZE UNPACKED_SIZE COOK_OPT PROVIDE CONFIG_FILES TAGS \

1413 src _pkg DESTDIR CONFIG_SITE BRANCH TARBALL stuff wanted_stuff

1414 . ${RECEIPT:-$PWD/receipt}

1415 }

1416

1417 packages_db_end()

1418 {

1419 cd $pkg_repository

1420 pkgs=$(wc -l packages.list | sed 's/ .*//')

1421 sed "s/# Packages : .*/# Packages : $pkgs/" -i packages.txt

1422

1423 # If lists were updated it's generally needed to sort them well.

1424 if ! sort -c packages.list 2> /dev/null; then

1425 report step "Sorting packages lists"

1426 for file in packages.list packages.desc packages.equiv; do

1427 [ -f $file ] || continue

1428 sort -o $file $file

1429 done

1430 report end-step

1431 fi

1432

1433 # Dont log this because lzma always output errors.

1434 lzma e files.list files.list.lzma

1435 rm -f files.list

1436 [ -f packages.equiv ] || touch packages.equiv

1437 }

1438

1439 ########################################################################

1440 # This section contains functions to generate wok database.

1441 ########################

1442

1443 gen_wok_db()

1444 {

1445 report step "Generating wok database"

1446 report open-bloc

1447 report step "Removing old files"

1448 for file in $wan_db $dep_db $PACKAGES_REPOSITORY/cookorder.txt; do

1449 [ -f $file ] && rm $file

1450 done

1451 report step "Generating wok-wanted.txt"

1452 gen_wan_db

1453 report step "Generating wok-depends.txt"

1454 for PACKAGE in $(cut -f1 -d '|' $PACKAGES_REPOSITORY/packages.desc \

1455 $INCOMING_REPOSITORY/packages.desc | sort -u); do

1456 RECEIPT=$WOK/$PACKAGE/receipt

1457 if [ -s $RECEIPT ]; then

1458 source_receipt

1459 echo -e $PACKAGE"\t "$DEPENDS" \t "$BUILD_DEPENDS' ' >> $dep_db

1460 fi

1461 done

1462 sort_db

1463 report close-bloc

1464 }

1465

1466 gen_wan_db()

1467 {

1468 rm -f $wan_db

1469 for RECEIPT in $(fgrep -l WANTED $WOK/*/receipt); do

1470 WANTED=

1471 source $RECEIPT

1472 [ "$WANTED" ] || continue

1473 echo -e $PACKAGE"\t"$WANTED >> $wan_db

1474 done

1475 }

1476

1477 update_wan_db()

1478 {

1479 local PACKAGE=$PACKAGE

1480 wanted_list=$(fgrep WANTED=\"$PACKAGE\" $WOK/*/receipt | cut -f1 -d ':')

1481 grep $'\t'$PACKAGE $wan_db | cut -f 1 | while read wan; do

1482 echo "$wanted_list" | fgrep -q /$wan/receipt && continue

1483 sed "/^$wan\t/d" -i $wan_db

1484 done

1485 for RECEIPT in $wanted_list; do

1486 unset WANTED PACKAGE

1487 source $RECEIPT

1488 [ "$WANTED" ] || continue

1489 sed "/^$PACKAGE\t/d" -i $wan_db

1490 echo -e $PACKAGE"\t"$WANTED >> $wan_db

1491 done

1492 unset wanted_list

1493 }

1494

1495 update_dep_db()

1496 {

1497 sed "/^$PACKAGE\t/d" -i $dep_db

1498 echo -e $PACKAGE"\t "$DEPENDS" \t "$BUILD_DEPENDS' ' >> $dep_db

1499 }

1500

1501 sort_db()

1502 {

1503 report step "Generating cookorder.txt"

1504 cat $dep_db | sed 's/ \t / /' | while read PACKAGE BUILD_DEPENDS; do

1505 grep -q ^$PACKAGE$'\t' $wan_db && continue

1506

1507 # Replace each BUILD_DEPENDS with a WANTED package by it's

1508 # WANTED package.

1509 replace_by_wanted()

1510 {

1511 for p in $BUILD_DEPENDS; do

1512 if grep -q ^$p$'\t' $wan_db; then

1513 echo -n $(grep ^$p$'\t' $wan_db | cut -f 2)' '

1514 else

1515 echo -n $p' '

1516 fi

1517 done | tr ' ' '\n' | sort -u | sed "/^$PACKAGE$/d" | tr '\n' ' '

1518 }

1519 echo -e $PACKAGE"\t $(replace_by_wanted) "

1520 done > $tmp/db

1521 while [ -s "$tmp/db" ]; do

1522 status=start

1523 for pkg in $(cut -f 1 $tmp/db); do

1524 if ! fgrep -q ' '$pkg' ' $tmp/db; then

1525 echo $pkg >> $tmp/cookorder

1526 sed -e "/^$pkg\t/d" -e "s/ $pkg / /g" -i $tmp/db

1527 status=proceed

1528 fi

1529 done

1530 if [ "$status" = start ]; then

1531 cp -f $tmp/db /tmp/remain-depends.txt

1532 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

1533 for blocked in $(cut -f 1 $tmp/db); do

1534 echo "$blocked" >> $PACKAGES_REPOSITORY/blocked

1535 done

1536 break

1537 fi

1538 done

1539 [ -s $tmp/cookorder ] || touch $tmp/cookorder

1540

1541 # The toolchain packages are moved in first position.

1542 grep $(for pkg in `scan "$SLITAZ_TOOLCHAIN $SLITAZ_TOOLCHAIN_EXTRA" \

1543 --look_for=all --with_args`; do echo " -e ^$pkg$"; done) \

1544 $tmp/cookorder | tac > $PACKAGES_REPOSITORY/cookorder.txt

1545 for pkg in $(cat $PACKAGES_REPOSITORY/cookorder.txt); do

1546 sed "/^$pkg$/d" -i $tmp/cookorder

1547 done

1548

1549 tac $tmp/cookorder >> $PACKAGES_REPOSITORY/cookorder.txt

1550 report end-step

1551 }

1552

1553 ########################################################################

1554 # SCAN CORE

1555 ########################

1556 # Includes various scan core-functions. It's not intended to be used

1557 # directly : prefer scan wrappers in next section.

1558

1559 look_for_dep()

1560 {

1561 if [ "$undigest" ] && [ ! -f "$WOK/$PACKAGE/receipt" ]; then

1562 grep -m1 ^$PACKAGE$'\t' $SLITAZ_DIR/$SLITAZ_VERSION/packages-incoming/wok-depends.txt \

1563 | cut -f 2

1564 else

1565 grep -m1 ^$PACKAGE$'\t' $INCOMING_REPOSITORY/wok-depends.txt | \

1566 cut -f 2

1567 fi

1568 }

1569

1570 look_for_bdep()

1571 {

1572 look_for_all

1573 }

1574

1575 look_for_all()

1576 {

1577 if [ "$undigest" ] && [ ! -f "$WOK/$PACKAGE/receipt" ]; then

1578 grep -m1 ^$PACKAGE$'\t' $SLITAZ_DIR/$SLITAZ_VERSION/packages-incoming/wok-depends.txt \

1579 | cut -f 2,3 | sed 's/ / /'

1580 else

1581 grep -m1 ^$PACKAGE$'\t' $INCOMING_REPOSITORY/wok-depends.txt | \

1582 cut -f 2,3 | sed 's/ / /'

1583 fi

1584 }

1585

1586 look_for_rdep()

1587 {

1588 fgrep ' '$PACKAGE' ' $INCOMING_REPOSITORY/wok-depends.txt | cut -f 1

1589 if [ "$undigest" ]; then

1590 for rdep in $(fgrep ' '$PACKAGE' ' $SLITAZ_DIR/$SLITAZ_VERSION/packages-incoming/wok-depends.txt | cut -f 1); do

1591 if [ ! -f "WOK$/$rdep/receipt" ]; then

1592 echo "$rdep"

1593 fi

1594 done

1595 fi

1596 }

1597

1598 look_for_rbdep()

1599 {

1600 fgrep ' '$PACKAGE' ' $INCOMING_REPOSITORY/wok-depends.txt | \

1601 cut -f 1,3 | fgrep ' '$PACKAGE' ' | cut -f 1

1602 if [ "$undigest" ]; then

1603 for rdep in $(fgrep ' '$PACKAGE' ' $SLITAZ_DIR/$SLITAZ_VERSION/packages-incoming/wok-depends.txt \

1604 | cut -f 1,3 | fgrep ' '$PACKAGE' ' | cut -f 1); do

1605 if [ ! -f "WOK$/$rdep/receipt" ]; then

1606 echo "$rdep"

1607 fi

1608 done

1609 fi

1610 }

1611

1612 # Return WANTED if it exists.

1613 look_for_wanted()

1614 {

1615 if [ "$undigest" ] && [ ! -f "$WOK/$PACKAGE/receipt" ]; then

1616 grep -m1 ^$PACKAGE$'\t' $SLITAZ_DIR/$SLITAZ_VERSION/packages-incoming/wok-wanted.txt | cut -f 2

1617 else

1618 grep -m1 ^$PACKAGE$'\t' $INCOMING_REPOSITORY/wok-wanted.txt | cut -f 2

1619 fi

1620 }

1621

1622 # Return packages which wants PACKAGE.

1623 look_for_rwanted()

1624 {

1625 grep $'\t'$PACKAGE$ $INCOMING_REPOSITORY/wok-wanted.txt | cut -f 1

1626 if [ "$undigest" ]; then

1627 for rwanted in $(grep $'\t'$PACKAGE$ $SLITAZ_DIR/$SLITAZ_VERSION/packages-incoming/wok-wanted.txt | cut -f 1); do

1628 if [ ! -f "$WOK/$rwanted/receipt" ]; then

1629 echo "$rwanted"

1630 fi

1631 done

1632 fi

1633 }

1634

1635 look_for_dev()

1636 {

1637 WANTED=$(look_for_wanted)

1638 if [ "$WANTED" ]; then

1639 if [ "$undigest" ] && [ ! -f "$WOK/$WANTED/receipt" ]; then

1640 [ -f "$SLITAZ_DIR/$SLITAZ_VERSION/wok/$WANTED-dev/receipt" ] && echo $WANTED-dev

1641 else

1642 [ -f "$WOK/$WANTED-dev/receipt" ] && echo $WANTED-dev

1643 fi

1644 fi

1645 if [ "$undigest" ] && [ ! -f "$WOK/$PACKAGE/receipt" ]; then

1646 [ -f "$SLITAZ_DIR/$SLITAZ_VERSION/wok/$PACKAGE-dev/receipt" ] && echo $PACKAGE-dev

1647 else

1648 [ -f "$WOK/$PACKAGE-dev/receipt" ] && echo $PACKAGE-dev

1649 fi

1650 }

1651

1652 with_dev()

1653 {

1654 for PACKAGE in $(cat); do

1655 echo $PACKAGE

1656 look_for_dev

1657 done

1658 }

1659

1660 with_wanted()

1661 {

1662 for PACKAGE in $(cat); do

1663 echo $PACKAGE

1664 look_for_wanted

1665 done

1666 }

1667

1668 use_wanted()

1669 {

1670 for input in $(cat); do

1671 { grep ^$input$'\t' $wan_db || echo $input

1672 } | sed 's/.*\t//'

1673 done

1674 }

1675

1676 ########################################################################

1677 # SCAN

1678 ########################

1679 # Use wok-wanted.txt and wok-depeds.txt to scan depends.

1680 # Option in command line (must be first arg) :

1681 # --look_for=bdep/rbdep - Look for depends or reverse depends.

1682 # --with_dev - Add development packages (*-dev) in the result.

1683 # --with_wanted - Add package+reverse wanted in the result.

1684 # --with_args - Include packages in argument in the result.

1685

1686 scan()

1687 {

1688 # Get packages in argument.

1689 local PACKAGE=$PACKAGE WANTED=$WANTED pkg_list=

1690 for arg in $@; do

1691 [ "$arg" = "${arg#--}" ] || continue

1692 pkg_list="$pkg_list $arg"

1693 done

1694

1695 # Get options.

1696 [ "$pkg_list" ] || return

1697 local cooklist= look_for= with_dev= with_wanted= with_args= log_command="$0 $@" \

1698 get_options_list="look_for with_dev with_wanted with_args cooklist use_wanted"

1699 get_options

1700

1701 # Get db md5 to be able to check for changes latter.

1702 db_md5=$(md5sum $dep_db $wan_db)

1703

1704 # Cooklist is a special case where we need to modify a little

1705 # scan behavior

1706 if [ "$cooklist" ]; then

1707 gen_wan_db

1708 look_for=all && with_args=yes && with_dev= && with_wanted=

1709 filter=use_wanted

1710 if [ "$COMMAND" = gen-cooklist ]; then

1711 for PACKAGE in $pkg_list; do

1712 grep -q ^$PACKAGE$'\t' $dep_db && continue

1713 [ -d "$WOK/$p" ] || continue

1714 check_for_missing

1715 done

1716 append_to_dep()

1717 {

1718 if ! grep -q ^$PACKAGE$'\t' $dep_db; then

1719 check_for_missing && echo $PACKAGE >> $tmp/dep

1720 else

1721 echo $PACKAGE >> $tmp/dep

1722 fi

1723 }

1724 else

1725 append_to_dep()

1726 {

1727 check_for_commit && echo $PACKAGE >> $tmp/dep

1728 }

1729 fi

1730 else

1731 append_to_dep()

1732 {

1733 echo $PACKAGE >> $tmp/dep

1734 }

1735 # If requested packages are not in dep_db, partial generation of this db is needed.

1736 for PACKAGE in $pkg_list; do

1737 grep -q ^$PACKAGE$'\t' $dep_db && continue

1738 [ -d "$WOK/$p" ] || continue

1739 plan_check_for_missing=yes

1740 check_for_missing

1741 done

1742 if [ "$plan_check_for_missing" ]; then

1743 append_to_dep()

1744 {

1745 if ! grep -q ^$PACKAGE$'\t' $dep_db; then

1746 check_for_missing && echo $PACKAGE >> $tmp/dep

1747 else

1748 echo $PACKAGE >> $tmp/dep

1749 fi

1750 }

1751 unset plan_check_for_missing

1752 fi

1753 fi

1754

1755 [ "$with_dev" ] && filter=with_dev

1756 [ "$with_wanted" ] && filter=with_wanted

1757 if [ "$filter" ]; then

1758 pkg_list=$(echo $pkg_list | $filter | sort -u)

1759 scan_pkg()

1760 {

1761 look_for_$look_for | $filter

1762 }

1763 else

1764 scan_pkg()

1765 {

1766 look_for_$look_for

1767 }

1768 fi

1769 touch $tmp/dep

1770 for PACKAGE in $pkg_list; do

1771 [ "$with_args" ] && append_to_dep

1772 scan_pkg

1773 done | tr ' ' '\n' | sort -u > $tmp/list

1774 [ "$look_for" = bdep ] && look_for=dep

1775 while [ -s $tmp/list ]; do

1776 PACKAGE=$(sed 1!d $tmp/list)

1777 sed 1d -i $tmp/list

1778 append_to_dep

1779 for pkg in $(scan_pkg); do

1780 if ! grep -q ^$pkg$ $tmp/list $tmp/dep; then

1781 echo $pkg >> $tmp/list

1782 fi

1783 done

1784 done

1785 if [ "$cooklist" ]; then

1786 mv $tmp/dep $tmp/cooklist

1787 else

1788 cat $tmp/dep | sort -u

1789 fi

1790 rm -f $tmp/dep $tmp/list

1791 sort -o $dep_db $dep_db

1792 sort -o $wan_db $wan_db

1793 if [ "$db_md5" != "$(md5sum $dep_db $wan_db)" ]; then

1794 grep -q "^#" $PACKAGES_REPOSITORY/cookorder.txt ||

1795 sed 1i"#PlanSort" -i $PACKAGES_REPOSITORY/cookorder.txt

1796 fi

1797 }

1798

1799 ########################################################################

1800 # This section contains functions to check the package repository and

1801 # find which packages to cook.

1802 ########################

1803

1804 check_for_missing()

1805 {

1806 local PACKAGE=$PACKAGE

1807 if ! check_for_pkg_in_wok; then

1808 [ "$?" = 2 ] && return 1

1809 return

1810 fi

1811 RECEIPT=$WOK/$PACKAGE/receipt

1812 source_receipt

1813 PACKAGE=${WANTED:-$PACKAGE}

1814 update_wan_db

1815 for PACKAGE in $(look_for_rwanted) $PACKAGE; do

1816 RECEIPT=$WOK/$PACKAGE/receipt

1817 source_receipt

1818 update_dep_db

1819 done

1820 }

1821

1822 check_for_commit()

1823 {

1824 if ! check_for_pkg_in_wok; then

1825 [ "$?" = 2 ] && return 1

1826 return

1827 fi

1828 for PACKAGE in $(look_for_rwanted) $PACKAGE; do

1829 RECEIPT=$WOK/$PACKAGE/receipt

1830 source_receipt

1831

1832 # We use md5 of cooking stuff in the packaged receipt to check

1833 # commit. We look consecutively in 3 different locations :

1834 # - in the wok/PACKAGE/taz/* folder

1835 # - in the receipt in the package in incoming repository

1836 # - in the receipt in the package in packages repository

1837 # If md5sums match, there's no commit.

1838 check_for_commit_using_md5sum()

1839 {

1840 if [ ! -f $WOK/$PACKAGE/md5 ]; then

1841 sed -n '/# md5sum of cooking stuff :/,$p' receipt | \

1842 sed -e 1d -e 's/^# //' > $WOK/$PACKAGE/md5

1843 cd $WOK/$PACKAGE

1844 fi

1845

1846 if [ -s md5 ]; then

1847 if md5sum -cs md5; then

1848

1849 # If md5sum check if ok, check for new/missing files in

1850 # cooking stuff.

1851 for file in $([ -f receipt ] && echo receipt; \

1852 [ -f description.txt ] && echo description.txt; \

1853 [ -d stuff ] && find stuff); do

1854 if ! fgrep -q " $file" md5; then

1855 set_commited

1856 fi

1857 done

1858 else

1859 set_commited

1860 fi

1861 else

1862 set_commited

1863 fi

1864 }

1865 set_commited()

1866 {

1867 ! grep -q ^$PACKAGE$ $PACKAGES_REPOSITORY/commit &&

1868 echo $PACKAGE >> $PACKAGES_REPOSITORY/commit

1869 gen_cookmd5

1870 update_dep_db

1871 }

1872 taz_dir=$(echo $WOK/$PACKAGE/taz/$PACKAGE-* | fgrep -v '*')

1873 if [ -f $WOK/$PACKAGE/md5 ]; then

1874 cd $WOK/$PACKAGE

1875 check_for_commit_using_md5sum

1876 elif [ "$taz_dir" ]; then

1877 cd $taz_dir

1878 check_for_commit_using_md5sum

1879 else

1880 pkg=$(echo $INCOMING_REPOSITORY/$PACKAGE-$VERSION*.tazpkg | fgrep -v '*')

1881 [ "$pkg" ] || pkg=$(echo $PACKAGES_REPOSITORY/$PACKAGE-$VERSION*.tazpkg | fgrep -v '*')

1882 if [ "$pkg" ]; then

1883 get_pkg_files $pkg

1884 check_for_commit_using_md5sum

1885 rm -r $pkg_files_dir

1886 else

1887 set_commited

1888 fi

1889 fi

1890 [ "$forced" ] || echo $PACKAGE >> $tmp/checked

1891 done

1892 return

1893 }

1894

1895 gen_cook_list()

1896 {

1897 report step "Scanning wok"

1898 if [ "$pkg" ]; then

1899 scan $pkg --cooklist

1900 else

1901 scan `cat $cooklist` --cooklist

1902 fi

1903 report end-step

1904

1905 [ -s $tmp/checked ] || [ -s $tmp/cooklist ] || return

1906

1907 # Core toolchain should not be cooked unless cook-toolchain is used.

1908 if ! [ -f /etc/config.site.tmptoolchain ] ; then

1909 for PACKAGE in $(scan gcc --look_for=all --with_args --with_wanted); do

1910 grep -q ^$PACKAGE$ $PACKAGES_REPOSITORY/blocked || \

1911 echo $PACKAGE >> $PACKAGES_REPOSITORY/blocked

1912 done

1913 fi

1914

1915 if [ -s $PACKAGES_REPOSITORY/commit ] && [ "$COMMAND" != gen-cooklist ]; then

1916 cd $PACKAGES_REPOSITORY

1917 for PACKAGE in $(cat commit); do

1918 WANTED="$(look_for_wanted)"

1919 if [ "$WANTED" ]; then

1920 grep -q ^$WANTED$ broken cooklist blocked commit && continue

1921 fi

1922 grep -q ^$PACKAGE$ blocked cooklist && continue

1923 echo $PACKAGE >> cooklist

1924 done

1925 fi

1926 sort_cooklist

1927 }

1928

1929 sort_cooklist()

1930 {

1931 if [ "$(sed 1!d $PACKAGES_REPOSITORY/cookorder.txt)" = "#PlanSort" ]; then

1932 sed 1d -i $PACKAGES_REPOSITORY/cookorder.txt

1933 sort_db

1934 fi

1935 report step "Generating cooklist"

1936 if [ -f "$tmp/checked" ]; then

1937 rm -f $tmp/cooklist

1938 cat $tmp/checked | while read PACKAGE; do

1939 grep -q ^$PACKAGE$ $PACKAGES_REPOSITORY/cooklist && \

1940 echo $PACKAGE >> $tmp/cooklist

1941 done

1942 elif ! [ "$COMMAND" = gen-cooklist ]; then

1943 cat $PACKAGES_REPOSITORY/blocked | while read PACKAGE; do

1944 sed "/^$PACKAGE/d" -i $tmp/cooklist

1945 done

1946 fi

1947 report end-step

1948 [ -s $tmp/cooklist ] || return

1949

1950 report step "Sorting cooklist"

1951 for PACKAGE in $(cat $tmp/cooklist); do

1952 WANTED="$(look_for_wanted)"

1953 [ "$WANTED" ] || continue

1954 if grep -q ^$WANTED$ $PACKAGES_REPOSITORY/broken $tmp/cooklist; then

1955 sed "/^$PACKAGE$/d" -i $tmp/cooklist

1956 elif [ ! -d $WOK/$WANTED/install ]; then

1957 sed "/^$PACKAGE$/d" -i $tmp/cooklist

1958 echo $WANTED >> $tmp/cooklist

1959 fi

1960 done

1961

1962 # Use cookorder.txt to sort cooklist.

1963 if [ -s $tmp/cooklist ]; then

1964 cat $PACKAGES_REPOSITORY/cookorder.txt | while read PACKAGE; do

1965 if grep -q ^$PACKAGE$ $tmp/cooklist; then

1966 sed "/^$PACKAGE$/d" -i $tmp/cooklist

1967 echo $PACKAGE >> $tmp/cooklist.tmp

1968 fi

1969 done

1970

1971 # Remaining packages in cooklist are those without compile_rules.

1972 # They can be cooked first in any order.

1973 if [ -f $tmp/cooklist.tmp ]; then

1974 cat $tmp/cooklist.tmp >> $tmp/cooklist

1975 rm $tmp/cooklist.tmp

1976 fi

1977

1978 cat $tmp/cooklist

1979 [ "$cooklist" = "$PACKAGES_REPOSITORY/cooklist" ] && \

1980 cat $tmp/cooklist > $cooklist

1981 fi

1982

1983 report end-step

1984 }

1985

1986 look_for_missing_pkg()

1987 {

1988 for pkg in $(cat $PACKAGES_REPOSITORY/$1); do

1989 grep -q ^$pkg$ $INCOMING_REPOSITORY/packages.txt \

1990 $PACKAGES_REPOSITORY/packages.txt || \

1991 continue

1992 echo $pkg

1993 done

1994 }

1995

1996 check_for_incoming()

1997 {

1998 report step "Checking that all packages were cooked OK"

1999 [ -s $INCOMING_REPOSITORY/packages.desc ] || {

2000 echo "No packages in $INCOMING_REPOSITORY."

2001 report end-step; return; }

2002 if [ -s $PACKAGES_REPOSITORY/broken ]; then

2003 missingpkg=$(look_for_missing_pkg broken)

2004 if [ "$missingpkg" ]; then

2005 echo "Don't move incoming packages to main repository because these ones are broken:" >&2

2006 echo "$missingpkg"

2007 report end-step

2008 return 1

2009 fi

2010 fi

2011 if [ -s $PACKAGES_REPOSITORY/cooklist ]; then

2012 missingpkg=$(look_for_missing_pkg cooklist)

2013 if [ "$missingpkg" ]; then

2014 echo "Don't move incoming packages to main repository because these ones need to be cooked:" >&2

2015 echo "$missingpkg"

2016 report end-step

2017 return 1

2018 fi

2019 fi

2020 incoming_pkgs="$(cut -f 1 -d '|' $INCOMING_REPOSITORY/packages.desc)"

2021 if ! [ "$forced" ]; then

2022 cooklist=$PACKAGES_REPOSITORY/cooklist

2023 pkg="$incoming_pkgs"

2024 gen_cook_list

2025 if [ -s $PACKAGES_REPOSITORY/cooklist ]; then

2026 missingpkg=$(look_for_missing_pkg cooklist)

2027 if [ "$missingpkg" ]; then

2028 echo "Don't move incoming packages to main repository because these ones need to be cooked:" >&2

2029 echo "$missingpkg"

2030 report end-step

2031 return 1

2032 fi

2033 fi

2034 fi

2035

2036 report step "Moving incoming packages to main repository"

2037 unset EXTRAVERSION

2038 for PACKAGE in $incoming_pkgs; do

2039 prev_VERSION=$(get_pkg_version $PACKAGES_REPOSITORY)

2040 VERSION=$(get_pkg_version $INCOMING_REPOSITORY)

2041 remove_previous_package $PACKAGES_REPOSITORY

2042 echo "Moving $PACKAGE..."

2043 mv -f $INCOMING_REPOSITORY/$PACKAGE-$VERSION.tazpkg $PACKAGES_REPOSITORY

2044 touch $PACKAGES_REPOSITORY/$PACKAGE-$VERSION.tazpkg

2045 previous_tarball=$(grep ^$PACKAGE:main $SOURCES_REPOSITORY/sources.list | cut -f2)

2046 sed -e "/^$PACKAGE:main/d" \

2047 -e "s/^$PACKAGE:incoming/$PACKAGE:main/" \

2048 -i $SOURCES_REPOSITORY/sources.list

2049 if [ "$previous_tarball" ]; then

2050 grep -q $'\t'$previous_tarball$ $SOURCES_REPOSITORY/sources.list || \

2051 rm -f $SOURCES_REPOSITORY/$previous_tarball

2052 fi

2053 done

2054 for file in packages.list packages.equiv packages.md5 packages.desc \

2055 packages.txt; do

2056 echo -n "" > $INCOMING_REPOSITORY/$file

2057 done

2058 rm -r $INCOMING_REPOSITORY/files.list.lzma

2059 pkg_repository=$PACKAGES_REPOSITORY && update_packages_db

2060

2061 report step "Updating flavors"

2062 if [ -x /usr/bin/tazlito ] || [ -x /usr/bin/clean-chroot ]; then

2063 if ! [ -x /usr/bin/tazlito ]; then

2064 tazpkg get-install tazlito

2065 fi

2066

2067 # Handle cases where tazwok is used into main system;

2068 # Handle cases where SLITAZ_DIR is not /home/slitaz.

2069 [ -L /home/slitaz/flavors ] && rm /home/slitaz/flavors

2070 mkdir -p /home/slitaz

2071 ln -s $LOCAL_REPOSITORY/flavors /home/slitaz/flavors

2072 cd /home/slitaz/flavors

2073 [ -d .hg ] && hg pull -u

2074

2075 cd $LOCAL_REPOSITORY/packages

2076 for i in $LOCAL_REPOSITORY/flavors/*; do

2077 [ -d "$i" ] || continue

2078 tazlito pack-flavor ${i##*/}

2079 done

2080

2081 noheader=""

2082 for i in *.flavor; do

2083 tazlito show-flavor $i --brief $noheader

2084 noheader="--noheader"

2085 done > flavors.list

2086 [ -x /usr/bin/clean-chroot ] && clean-chroot

2087 else

2088 echo "Can't create up-to-date flavors because the tazlito package is missing." >&2

2089 fi

2090 report end-step

2091 }

2092

2093 ########################################################################

2094 # TAZWOK MAIN FUNCTIONS

2095 ########################

2096

2097 clean()

2098 {

2099 cd $WOK/$PACKAGE

2100 ls -A $WOK/$PACKAGE | grep -q -v -e ^receipt$ -e ^description.txt$ \

2101 -e ^stuff$ || return

2102

2103 [ "$COMMAND" = clean-wok ] || report step "Cleaning $PACKAGE"

2104 # Check for clean_wok function.

2105 if grep -q ^clean_wok $RECEIPT; then

2106 clean_wok

2107 fi

2108 # Clean should only have a receipt, stuff and optional desc.

2109 for f in `ls .`

2110 do

2111 case $f in

2112 receipt|stuff|description.txt|md5)

2113 continue ;;

2114 *)

2115 rm -rf $f ;;

2116 esac

2117 done

2118 [ "$COMMAND" != clean-wok ] && report end-step

2119 }

2120

2121 # Configure and make a package with the receipt.

2122 compile_package()

2123 {

2124 check_for_package_on_cmdline

2125

2126 # Include the receipt to get all needed variables and functions

2127 # and cd into the work directory to start the work.

2128 check_for_receipt

2129 source_receipt

2130

2131 # Log the package name and date.

2132 echo "date `date +%Y%m%d\ \%H:%M:%S`" >> $LOG

2133 echo "package $PACKAGE (compile)" >> $LOG

2134

2135 # Set wanted $src variable to help compiling.

2136 [ ! "$src" ] && set_src_path

2137 check_for_build_depends || return 1

2138 check_for_wanted

2139 unset target

2140 check_for_tarball && check_for_compile_rules

2141 }

2142

2143 # Cook command also include all features to manage lists which keep

2144 # track of wok/packages state.

2145 cook()

2146 {

2147 cook_code=

2148 set_common_path

2149 check_for_receipt

2150 source_receipt

2151

2152 # Define log path and start report.

2153 [ -f $LOCAL_REPOSITORY/log/$PACKAGE.html ] && rm $LOCAL_REPOSITORY/log/$PACKAGE.html

2154 report sublog $LOCAL_REPOSITORY/log/$PACKAGE.html

2155 echo "$PACKAGE" > $LOCAL_REPOSITORY/log/package

2156 report step "Cooking $PACKAGE"

2157 report open-bloc

2158

2159 clean $PACKAGE

2160 [ -s $tmp/cooklist ] && sed "/^$PACKAGE$/d" -i $tmp/cooklist

2161

2162 if compile_package; then

2163 remove_src

2164 refresh_packages_from_compile

2165 gen_package

2166

2167 # Update packages-incoming repository.

2168 store_pkgname=$PACKAGE

2169 pkg_repository=$INCOMING_REPOSITORY

2170 update_packages_db

2171

2172 PACKAGE=$store_pkgname

2173 unset store_pkgname

2174

2175 # Upgrade to cooked packages if it was previously installed.

2176 report step "Looking for package(s) to upgrade"

2177 for pkg in $(look_for_rwanted) $PACKAGE; do

2178 if [ -d $INSTALLED/$pkg ]; then

2179 tazpkg get-install $pkg --forced

2180 fi

2181 done

2182 report end-step

2183 else

2184 for PACKAGE in $(look_for_wanted) $PACKAGE; do

2185 set_pkg_broken

2186 done

2187 cook_code=1

2188 fi

2189

2190 # Remove build_depends in cook mode (if in cooklist, it's done when

2191 # checking build_depends of next package and we remove only unneeded

2192 # packages to keep chroot minimal and gain some time).

2193 if [ "$COMMAND" = cook ]; then

2194 remove_build_depends $MISSING_PACKAGE

2195 [ -x /usr/bin/clean-chroot ] && clean-chroot

2196 fi

2197

2198 # Regen the cooklist if it was planned and command is not cook.

2199 [ "$regen_cooklist" ] && unset regen_cooklist && \

2200 [ "$COMMAND" != cook ] && sort_cooklist

2201

2202 # Some hacks to set the bloc & function status as failed if cook has

2203 # failed.

2204 report_return_code=$cook_code

2205 report close-bloc

2206 report end-sublog

2207 rm -f $LOCAL_REPOSITORY/log/package

2208 return $cook_code

2209 }

2210

2211 cook_list()

2212 {

2213 if [ -s $tmp/cooklist ]; then

2214 if [ -f /usr/bin/tazchroot ]; then

2215 # Note : options -main variables- are automatically kept by

2216 # the sub-applications tazchroot/tazwok; as well as report data.

2217 cd $LOCAL_REPOSITORY

2218 [ ! -f tazchroot.conf ] && configure_tazchroot

2219 tazchroot tazwok cook-list --SLITAZ_DIR=$SLITAZ_DIR --SLITAZ_VERSION=$SLITAZ_VERSION ${undigest:+ --undigest=$undigest}

2220 return

2221 fi

2222 while [ -s $tmp/cooklist ]; do

2223 PACKAGE=$(sed 1!d $tmp/cooklist)

2224 cook

2225 done

2226 remove_build_depends $MISSING_PACKAGE $remove_later

2227 [ -x /usr/bin/clean-chroot ] && clean-chroot

2228 else

2229 echo "Nothing to cook."

2230 return

2231 fi

2232 }

2233

2234 configure_tazchroot()

2235 {

2236 cat > $LOCAL_REPOSITORY/tazchroot.conf << EOF

2237 # Tazchroot configuration file - created by tazwok.

2238

2239 # Default chroot path.

2240 SLITAZ_DIR=$SLITAZ_DIR

2241 SLITAZ_VERSION=$SLITAZ_VERSION

2242 $( [ "$undigest" ] && echo "undigest=$undigest" )

2243 LOCAL_REPOSITORY=$SLITAZ_DIR/$(if [ "$undigest" ]; then echo '$undigest'; else echo '$SLITAZ_VERSION'; fi)

2244 chroot_dir=\$LOCAL_REPOSITORY/chroot

2245

2246 # Default scripts path (these scripts are added to the

2247 # $chroot_dir/usr/bin and can be called with tazchroot script).

2248 script_dir=/usr/lib/slitaz/chroot-scripts/tazwok

2249

2250 # List of directories to mount.

2251 list_dir="$(for dir in packages wok src packages-incoming log flavors iso clean-wok; do echo $LOCAL_REPOSITORY/$dir; done)

2252 $SLITAZ_LOG$( [ "$undigest" ] && echo -e "\n$SLITAZ_DIR/$SLITAZ_VERSION/packages" )"

2253

2254 create_chroot()

2255 {

2256 mkdir -p \$chroot_dir

2257 for pkg in \$(tazwok build-depends toolchain --SLITAZ_DIR=\$SLITAZ_DIR --SLITAZ_VERSION=\$SLITAZ_VERSION${undigest:+ --undigest=\$undigest}); do

2258 tazpkg get-install \$pkg --root="\$chroot_dir"

2259 done

2260

2261 # Store list of installed packages needed by cleanchroot.

2262 ls -1 \$chroot_dir/\$INSTALLED > \$chroot_dir/\$LOCALSTATE/chroot-pkgs

2263

2264 sed -e "s~^SLITAZ_DIR=.*~SLITAZ_DIR=\$SLITAZ_DIR~" \\

2265 -e "s/^SLITAZ_VERSION=.*/SLITAZ_VERSION=\$SLITAZ_VERSION/" \\

2266 -i \$chroot_dir/etc/slitaz/slitaz.conf

2267 echo \$SLITAZ_VERSION > \$chroot_dir/etc/slitaz-release

2268 $( [ "$undigest" ] && echo ' echo "undigest='"$undigest"'" >> $chroot_dir/etc/slitaz/tazwok.conf')

2269 sed 's/LC_ALL/LC_ALL=POSIX/' -i \$chroot_dir/etc/profile

2270 # The build bot may run in a sandbox: link sandbox lockfile.

2271 [ -d \$LOCAL_REPOSITORY/sandbox ] && ln -s \$LOCAL_REPOSITORY/sandbox/proc/1 \$chroot_dir/proc/1

2272 }

2273

2274 mount_chroot()

2275 {

2276 cp -a /etc/resolv.conf \$chroot_dir/etc/resolv.conf

2277 echo "\$LOCAL_REPOSITORY/packages" > \$chroot_dir\$LOCALSTATE/mirror

2278 mkdir -p \$chroot_dir\$LOCALSTATE/undigest/\${LOCAL_REPOSITORY##*/}-incoming

2279 echo "\$LOCAL_REPOSITORY/packages-incoming" > \$chroot_dir\$LOCALSTATE/undigest/\${LOCAL_REPOSITORY##*/}-incoming/mirror

2280 $( [ "$undigest" ] && echo ' mkdir -p $chroot_dir$LOCALSTATE/undigest/$SLITAZ_VERSION

2281 echo "$SLITAZ_DIR/$SLITAZ_VERSION/packages" > $chroot_dir$LOCALSTATE/undigest/$SLITAZ_VERSION/mirror' )

2282 echo -e "\${LOCAL_REPOSITORY##*/}-incoming\nmain" > \$chroot_dir\$LOCALSTATE/priority

2283 mount -o bind /proc \$chroot_dir/proc

2284 mount -o bind /sys \$chroot_dir/sys

2285 mount -o bind /dev/pts \$chroot_dir/dev/pts

2286 mount -o bind /dev/shm \$chroot_dir/dev/shm

2287 for dir in \$list_dir; do

2288 mkdir -p \$dir \$chroot_dir\$dir

2289 mount \$dir \$chroot_dir\$dir

2290 done

2291 }

2292

2293 umount_chroot()

2294 {

2295 for dir in \$list_dir; do

2296 umount \$chroot_dir\$dir

2297 done

2298 umount \$chroot_dir/dev/shm

2299 umount \$chroot_dir/dev/pts

2300 umount \$chroot_dir/sys

2301 umount \$chroot_dir/proc

2302 }

2303 EOF

2304 }

2305

2306 ########################################################################

2307 ######################### END OF NEW FUNCTIONS #########################

2308 ########################################################################

2309

2310 # List packages providing a virtual package.

2311 whoprovide()

2312 {

2313 local i;

2314 for i in $(fgrep -l PROVIDE $WOK/*/receipt); do

2315 . $i

2316 case " $PROVIDE " in

2317 *\ $1\ *|*\ $1:*) echo $(basename $(dirname $i));;

2318 esac

2319 done

2320 }

2321

2322 ########################################################################

2323 # TAZWOK COMMANDS

2324 ########################

2325

2326 case "$COMMAND" in

2327 stats)

2328 # Tazwok general statistics from the wok config file.

2329 #

2330 get_tazwok_config

2331 echo -e "\n\033[1mTazwok configuration statistics\033[0m

2332 ================================================================================

2333 Wok directory : $WOK

2334 Packages repository : $PACKAGES_REPOSITORY

2335 Incoming repository : $INCOMING_REPOSITORY

2336 Sources repository : $SOURCES_REPOSITORY

2337 Log directory : $LOCAL_REPOSITORY/log

2338 Packages in the wok : `ls -1 $WOK | wc -l`

2339 Cooked packages : `ls -1 $PACKAGES_REPOSITORY/*.tazpkg 2>/dev/null | wc -l`

2340 Incoming packages : `ls -1 $INCOMING_REPOSITORY/*.tazpkg 2>/dev/null | wc -l`

2341 ================================================================================\n"

2342 ;;

2343 edit)

2344 get_tazwok_config

2345 check_for_package_on_cmdline

2346 check_for_receipt

2347 $EDITOR $WOK/$PACKAGE/receipt

2348 ;;

2349 build-depends)

2350 # List dependencies to rebuild wok, or only a package.

2351 get_tazwok_config

2352 report(){ : ; }

2353 if [ ! "$PACKAGE" ] || [ "$PACKAGE" = toolchain ]; then

2354 scan "$SLITAZ_TOOLCHAIN $SLITAZ_TOOLCHAIN_EXTRA" \

2355 --look_for=dep --with_dev --with_args

2356 else

2357 check_for_package_on_cmdline

2358 scan $PACKAGE --look_for=bdep --with_dev

2359 fi

2360 ;;

2361 gen-cooklist)

2362 check_root

2363 get_options_list="pkg"

2364 get_tazwok_config

2365 report(){ : ; }

2366 if ! [ "$pkg" ]; then

2367 if [ ! "$LIST" ] || [ "$LIST" = toolchain ]; then

2368 pkg="$SLITAZ_TOOLCHAIN $SLITAZ_TOOLCHAIN_EXTRA"

2369 else

2370 cooklist=${LIST:-$PACKAGES_REPOSITORY/cooklist}

2371 fi

2372 fi

2373 gen_cook_list

2374 ;;

2375 check-depends)

2376 # Check package depends /!\.

2377 get_tazwok_config

2378 echo ""

2379 echo -e "\033[1mCheck every receipt for DEPENDS - doesn't scan ELF files\033[0m

2380 ================================================================================"

2381 TMPDIR=/tmp/tazwok$$

2382 DEFAULT_DEPENDS="glibc-base gcc-lib-base"

2383

2384 # Build ALL_DEPENDS variable.

2385 scan_dep()

2386 {

2387 local i

2388 ALL_DEPENDS="$ALL_DEPENDS$PACKAGE "

2389 for i in $DEPENDS $SUGGESTED ; do

2390 case " $ALL_DEPENDS " in

2391 *\ $i\ *) continue;;

2392 esac

2393 [ -d $WOK/$i ] || {

2394 ALL_DEPENDS="$ALL_DEPENDS$i "

2395 continue

2396 }

2397 DEPENDS=""

2398 SUGGESTED=""

2399 . $WOK/$i/receipt

2400 scan_dep

2401 done

2402 }

2403

2404 # Check for ELF file.

2405 is_elf()

2406 {

2407 [ "$(dd if=$1 bs=1 skip=1 count=3 2> /dev/null)" = "ELF" ]

2408 }

2409

2410 # Print shared library dependencies.

2411 ldd()

2412 {

2413 LD_TRACE_LOADED_OBJECTS=1 /lib/ld*.so $1 2> /dev/null

2414 }

2415

2416 mkdir $TMPDIR

2417 cd $TMPDIR

2418 for i in $LOCALSTATE/files.list.lzma \

2419 $LOCALSTATE/undigest/*/files.list.lzma ; do

2420 [ -f $i ] && lzma d $i -so >> files.list

2421 done

2422 for pkg in $PACKAGES_REPOSITORY/*.tazpkg ; do

2423 tazpkg extract $pkg > /dev/null 2>&1

2424 . */receipt

2425 ALL_DEPENDS="$DEFAULT_DEPENDS "

2426 scan_dep

2427 find */fs -type f | while read file ; do

2428 is_elf $file || continue

2429 case "$file" in

2430 *.o|*.ko|*.ko.gz) continue;;

2431 esac

2432 ldd $file | while read lib rem; do

2433 case "$lib" in

2434 statically|linux-gate.so*|ld-*.so|*/ld-*.so)

2435 continue;;

2436 esac

2437 for dep in $(fgrep $lib files.list | cut -d: -f1); do

2438 case " $ALL_DEPENDS " in

2439 *\ $dep\ *) continue 2;;

2440 esac

2441 for vdep in $(fgrep $dep $LOCALSTATE/packages.equiv | cut -d= -f1); do

2442 case " $ALL_DEPENDS " in

2443 *\ $vdep\ *) continue 3;;

2444 esac

2445 done

2446 done

2447 [ -n "$dep" ] || dep="UNKNOWN"

2448 echo "$(basename $pkg): ${file#*fs} depends on package $dep for the shared library $lib"

2449 done

2450 done

2451 rm -rf */

2452 done

2453 cd /tmp

2454 rm -rf $TMPDIR

2455 ;;

2456 check)

2457 # Check wok consistency.

2458 get_tazwok_config

2459 echo ""

2460 echo -e "\033[1mWok and packages checking\033[0m

2461 ================================================================================"

2462 cd $WOK

2463 for pkg in $(ls)

2464 do

2465 [ -f $pkg/receipt ] || continue

2466 RECEIPT= $pkg/receipt

2467 source_receipt

2468 [ "$PACKAGE" = "$pkg" ] || echo "Package $PACKAGE should be $pkg" >&2

2469 [ -n "$VERSION" ] || echo "Package $PACKAGE has no VERSION" >&2

2470 [ -n "$PACKED_SIZE" ] && echo "Package $PACKAGE has hardcoded PACKED_SIZE" >&2

2471 [ -n "$UNPACKED_SIZE" ] && echo "Package $PACKAGE has hardcoded UNPACKED_SIZE" >&2

2472 [ -n "$EXTRAVERSION" ] && echo "Package $PACKAGE has hardcoded EXTRAVERSION" >&2

2473 if [ -n "$WANTED" ]; then

2474 if [ ! -f $WANTED/receipt ]; then

2475 echo "Package $PACKAGE wants unknown $WANTED package" >&2

2476 else

2477 BASEVERSION=$(. $WANTED/receipt ; echo $VERSION)

2478 if [ "$VERSION" = "$WANTED" ]; then

2479 # BASEVERSION is computed in receipt

2480 fgrep -q '_pkg=' $pkg/receipt &&

2481 BASEVERSION=$VERSION

2482 fi

2483 if [ "$VERSION" != "$BASEVERSION" ]; then

2484 echo "Package $PACKAGE ($VERSION) wants $WANTED ($BASEVERSION)" >&2

2485 fi

2486 fi

2487 fi

2488

2489 if [ -n "$CATEGORY" ]; then

2490 case " $(echo $CATEGORIES) " in

2491 *\ $CATEGORY\ *);;

2492 *) echo "Package $PACKAGE has an invalid CATEGORY" >&2;;

2493 esac

2494 else

2495 echo"Package $PACKAGE has no CATEGORY" >&2

2496 fi

2497 [ -n "$SHORT_DESC" ] || echo "Package $PACKAGE has no SHORT_DESC" >&2

2498 [ -n "$MAINTAINER" ] || echo "Package $PACKAGE has no MAINTAINER" >&2

2499 case "$WGET_URL" in

2500 ftp*|http*) busybox wget -s $WGET_URL 2> /dev/null ||

2501 echo "Package $PACKAGE has a wrong WGET_URL" >&2;;

2502 '') ;;

2503 *) echo "Package $PACKAGE has an invalid WGET_URL" >&2;;

2504 esac

2505 case "$WEB_SITE" in

2506 ftp*|http*);;

2507 '') echo "Package $PACKAGE has no WEB_SITE" >&2;;

2508 *) echo "Package $PACKAGE has an invalid WEB_SITE" >&2;;

2509 esac

2510 case "$MAINTAINER" in

2511 *\<*|*\>*) echo "Package $PACKAGE has an invalid MAINTAINER: $MAINTAINER" >&2;;

2512 esac

2513 case "$MAINTAINER" in

2514 *@*);;

2515 *) echo "Package $PACKAGE MAINTAINER is not an email address" >&2;;

2516 esac

2517 MSG="Missing dependencies for $PACKAGE $VERSION$EXTRAVERSION :\n" >&2

2518 for i in $DEPENDS; do

2519 [ -d $i ] && continue

2520 [ -n "$(whoprovide $i)" ] && continue

2521 echo -e "$MSG $i"

2522 MSG=""

2523 done

2524 MSG="Missing build dependencies for $PACKAGE $VERSION$EXTRAVERSION :\n" >&2

2525 for i in $BUILD_DEPENDS; do

2526 [ -d $i ] && continue

2527 [ -n "$(whoprovide $i)" ] && continue

2528 echo -e "$MSG $i"

2529 MSG=""

2530 done

2531 MSG="Dependency loop between $PACKAGE and :\n"

2532 ALL_DEPS=""

2533 check_for_deps_loop $PACKAGE $DEPENDS

2534 [ -d $WOK/$pkg/taz ] && for i in $BUILD_DEPENDS; do

2535 [ $WOK/$pkg/taz -nt $INSTALLED/$i/files.list ] && continue

2536 echo "$pkg should be rebuilt after $i installation"

2537 done

2538 done

2539 ;;

2540 list)

2541 # List packages in wok directory. User can specify a category.

2542 #

2543 get_tazwok_config

2544 if [ "$2" = "category" ]; then

2545 echo -e "\033[1m\nPackages categories :\033[0m $CATEGORIES\n"

2546 exit 0

2547 fi

2548 # Check for an asked category.

2549 if [ -n "$2" ]; then

2550 ASKED_CATEGORY=$2

2551 echo ""

2552 echo -e "\033[1mPackages in category :\033[0m $ASKED_CATEGORY"

2553 horizontal_line

2554 for pkg in $WOK/*

2555 do

2556 [ ! -f $pkg/receipt ] && continue

2557 . $pkg/receipt

2558 if [ "$CATEGORY" == "$ASKED_CATEGORY" ]; then

2559 echo -n "$PACKAGE"

2560 echo -e "\033[28G $VERSION"

2561 packages=$(($packages+1))

2562 fi

2563 done

2564 horizontal_line

2565 echo -e "$packages packages in category $ASKED_CATEGORY.\n"

2566 else

2567 # By default list all packages and version.

2568 echo ""

2569 echo -e "\033[1mList of packages in the wok\033[0m"

2570 horizontal_line

2571 for pkg in $WOK/*

2572 do

2573 [ ! -f $pkg/receipt ] && continue

2574 . $pkg/receipt

2575 echo -n "$PACKAGE"

2576 echo -en "\033[28G $VERSION"

2577 echo -e "\033[42G $CATEGORY"

2578 packages=$(($packages+1))

2579 done

2580 horizontal_line

2581 echo -e "$packages packages available in the wok.\n"

2582 fi

2583 ;;

2584 info)

2585 # Information about a package.

2586 #

2587 get_tazwok_config

2588 check_for_package_on_cmdline

2589 check_for_receipt

2590 . $WOK/$PACKAGE/receipt

2591 echo ""

2592 echo -e "\033[1mTazwok package information\033[0m

2593 ================================================================================

2594 Package : $PACKAGE

2595 Version : $VERSION

2596 Category : $CATEGORY

2597 Short desc : $SHORT_DESC

2598 Maintainer : $MAINTAINER"

2599 if [ ! "$WEB_SITE" = "" ]; then

2600 echo "Web site : $WEB_SITE"

2601 fi

2602 if [ ! "$DEPENDS" = "" ]; then

2603 echo "Depends : $DEPENDS"

2604 fi

2605 if [ ! "$WANTED" = "" ]; then

2606 echo "Wanted src : $WANTED"

2607 fi

2608 horizontal_line

2609 echo ""

2610 ;;

2611 check-log)

2612 # We just cat the file log to view process info.

2613 #

2614 get_tazwok_config

2615 if [ ! -f "$LOG" ]; then

2616 echo -e "\nNo process log found. The package is probably not cooked.\n" >&2

2617 exit 1

2618 else

2619 echo ""

2620 echo -e "\033[1mPackage process log for :\033[0m $PACKAGE"

2621 horizontal_line

2622 cat $LOG

2623 horizontal_line

2624 echo ""

2625 if [ -s "$WOK/$PACKAGE/warning.txt" ]; then

2626 echo -e "\033[1mCook warning(s) for :\033[0m $PACKAGE"

2627 horizontal_line

2628 cat "$WOK/$PACKAGE/warning.txt"

2629 horizontal_line

2630 echo ""

2631 fi

2632 fi

2633 ;;

2634 search)

2635 # Search for a package by pattern or name.

2636 #

2637 get_tazwok_config

2638 if [ -z "$2" ]; then

2639 echo -e "\nPlease specify a pattern or a package name to search." >&2

2640 echo -e "Example : 'tazwok search gcc'.\n" >&2

2641 exit 1

2642 fi

2643 echo ""

2644 echo -e "\033[1mSearch result for :\033[0m $2"

2645 horizontal_line

2646 list=`ls -1 $WOK | fgrep $2`

2647 for pkg in $list

2648 do

2649 . $WOK/$pkg/receipt

2650 echo -n "$PACKAGE "

2651 echo -en "\033[24G $VERSION"

2652 echo -e "\033[42G $CATEGORY"

2653 packages=$(($PACKAGEs+1))

2654 done

2655 horizontal_line

2656 echo "$packages packages found for : $2"

2657 echo ""

2658 ;;

2659 compile)

2660 # Configure and make a package with the receipt.

2661 #

2662 get_tazwok_config

2663 source_lib report

2664 report start

2665 compile_package

2666 ;;

2667 genpkg)

2668 # Generate a package.

2669 #

2670 get_tazwok_config

2671 source_lib report

2672 report start

2673 gen_package

2674 ;;

2675 cook)

2676 # Compile and generate a package. Just execute tazwok with

2677 # the good commands.

2678 #

2679 check_root

2680 get_tazwok_config

2681 source_lib report

2682 report start

2683 db_md5=$(md5sum $dep_db $wan_db)

2684 update_wan_db

2685 check_for_commit

2686 sort -o $dep_db $dep_db

2687 sort -o $wan_db $wan_db

2688 if [ "$db_md5" != "$(md5sum $dep_db $wan_db)" ]; then

2689 grep -q "^#" $PACKAGES_REPOSITORY/cookorder.txt ||

2690 sed 1i"#PlanSort" -i $PACKAGES_REPOSITORY/cookorder.txt

2691 fi

2692 cook

2693 ;;

2694 sort-cooklist)

2695 if [ ! -f "$LIST" ]; then

2696 echo "Usage : tazwok sort-cooklist cooklist" >&2

2697 exit 1

2698 fi

2699 check_root

2700 get_tazwok_config

2701 report(){ : ; }

2702 # When using sort-cooklist, the script should behave as for gen-cooklist

2703 # The only difference between these two is where the output is sent.

2704 COMMAND=gen-cooklist

2705 cooklist=$LIST

2706 gen_cook_list

2707 cp -af $tmp/cooklist $cooklist

2708 ;;

2709 cook-list)

2710 # Cook all packages listed in a file or in default cooklist.

2711 check_root

2712 get_options_list="pkg forced"

2713 get_tazwok_config

2714 source_lib report

2715 report start

2716 if ! [ "$pkg" ]; then

2717 cooklist=${LIST:-$PACKAGES_REPOSITORY/cooklist}

2718 fi

2719 gen_cook_list

2720 cook_list

2721 ;;

2722 clean)

2723 # Clean up a package work directory + those which want it.

2724 #

2725 get_tazwok_config

2726 check_for_package_on_cmdline

2727 check_for_receipt

2728 source_lib report

2729 report start

2730 . $RECEIPT

2731 clean

2732 ;;

2733 gen-clean-wok)

2734 # Generate a clean wok from the current wok by copying all receipts

2735 # and stuff directory.

2736 #

2737 get_tazwok_config

2738 source_lib report

2739 report start

2740 if [ -z "$ARG" ]; then

2741 echo -e "\nPlease specify the destination for the new clean wok.\n" >&2

2742 exit 1

2743 else

2744 dest=$ARG

2745 mkdir -p $dest

2746 fi

2747 report step "Creating clean wok in : $dest"

2748 for pkg in `ls -1 $WOK`

2749 do

2750 mkdir -p $dest/$pkg

2751 cp -a $WOK/$pkg/receipt $dest/$pkg

2752 [ -f $WOK/$pkg/description.txt ] && \

2753 cp -a $WOK/$pkg/description.txt $dest/$pkg

2754 if [ -d "$WOK/$pkg/stuff" ]; then

2755 cp -a $WOK/$pkg/stuff $dest/$pkg

2756 fi

2757 done

2758 [ -d $WOK/.hg ] && cp -a $WOK/.hg $dest

2759 report end-step

2760 echo "Packages cleaned : `ls -1 $dest | wc -l`"

2761 echo ""

2762 ;;

2763 clean-wok)

2764 # Clean all packages in the work directory.

2765 #

2766 get_tazwok_config

2767 source_lib report

2768 report start

2769 report step "Cleaning wok"

2770 for PACKAGE in `ls -1 $WOK`

2771 do

2772 set_common_path

2773 source_receipt

2774 clean

2775 done

2776 echo "`ls -1 $WOK | wc -l` packages cleaned."

2777 ;;

2778 clean-src)

2779 # Remove tarball unrelated to wok receipts from src repo.

2780 check_root

2781 get_options_list="forced"

2782 get_tazwok_config

2783 cd $SOURCES_REPOSITORY

2784 echo -n "Checking $SOURCES_REPOSITORY..."

2785 for TARBALL in *; do

2786 [ "$TARBALL" = sources.list ] && continue

2787 grep -q $'\t'$TARBALL$ $SOURCES_REPOSITORY/sources.list || \

2788 echo $TARBALL >> $tmp/obsolete

2789 done

2790 status

2791 if ! [ -f $tmp/obsolete ]; then

2792 echo "No sources need to be removed."

2793 exit 1

2794 fi

2795 echo ""

2796 echo -e "\033[1mObsolete/unrelated-to-wok sources :\033[0m"

2797 horizontal_line

2798 cat $tmp/obsolete

2799 horizontal_line

2800 echo "$(wc -l $tmp/obsolete | cut -f1 -d' ') tarballs to remove."

2801 echo ""

2802 echo -n "Please confirm before removing (type uppercase YES): "

2803 read answer

2804 if [ "$answer" = YES ]; then

2805 echo -n "Removing old sources..."

2806 cat $tmp/obsolete | while read i; do

2807 rm -f $SOURCES_REPOSITORY/$i

2808 done

2809 status

2810 fi

2811 ;;

2812 gen-list)

2813 get_tazwok_config

2814 if [ "$2" ]; then

2815 if [ -d "$2" ]; then

2816 pkg_repository=$2

2817 else

2818 echo -e "\nUnable to find directory : $2\n" >&2

2819 exit 1

2820 fi

2821 fi

2822

2823 source_lib report

2824 report start

2825 if [ "$pkg_repository" ]; then

2826 gen_packages_db

2827 else

2828 pkg_repository=$PACKAGES_REPOSITORY && gen_packages_db

2829 pkg_repository=$INCOMING_REPOSITORY && gen_packages_db

2830 fi

2831 ;;

2832 check-list)

2833 # The directory to move into by default is the repository,

2834 # if $2 is not empty cd into $2.

2835 #

2836 get_tazwok_config

2837 if [ "$2" ]; then

2838 if [ -d "$2" ]; then

2839 pkg_repository=$2

2840 else

2841 echo -e "\nUnable to find directory : $2\n" >&2

2842 exit 1

2843 fi

2844 fi

2845

2846 source_lib report

2847 report start

2848 if [ "$pkg_repository" ]; then

2849 update_packages_db

2850 else

2851 pkg_repository=$PACKAGES_REPOSITORY && update_packages_db

2852 pkg_repository=$INCOMING_REPOSITORY && update_packages_db

2853 fi

2854 ;;

2855 new-tree)

2856 # Just create a few directories and generate an empty receipt to prepare

2857 # the creation of a new package.

2858 #

2859 get_tazwok_config

2860 check_for_package_on_cmdline

2861 clean_wok=$LOCAL_REPOSITORY/clean-wok

2862 if [ -d $clean_wok/$PACKAGE ]; then

2863 echo -e "\n$PACKAGE package tree already exists.\n" >&2

2864 exit 1

2865 fi

2866 echo "Creating : $clean_wok/$PACKAGE"

2867 mkdir $clean_wok/$PACKAGE

2868 cd $clean_wok/$PACKAGE

2869 echo -n "Preparing the receipt..."

2870 #

2871 # Default receipt begin.

2872 #

2873 echo "# SliTaz package receipt." > receipt

2874 echo "" >> receipt

2875 echo "PACKAGE=\"$PACKAGE\"" >> receipt

2876 # Finish the empty receipt.

2877 cat >> receipt << "EOF"

2878 VERSION=""

2879 CATEGORY=""

2880 SHORT_DESC=""

2881 MAINTAINER=""

2882 DEPENDS=""

2883 TARBALL="$PACKAGE-$VERSION.tar.gz"

2884 WEB_SITE=""

2885 WGET_URL=""

2886

2887 # Rules to configure and make the package.

2888 compile_rules()

2889 {

2890 cd $src

2891 ./configure && make && make install

2892 }

2893

2894 # Rules to gen a SliTaz package suitable for Tazpkg.

2895 genpkg_rules()

2896 {

2897 mkdir -p $fs/usr

2898 cp -a $_pkg/usr/bin $fs/usr

2899 }

2900

2901 EOF

2902 #

2903 # Default receipt end.

2904 #

2905 status

2906 # Interactive mode, asking and seding.

2907 if [ "$3" = "--interactive" ]; then

2908 echo "Entering interactive mode..."

2909 horizontal_line

2910 echo "Package : $PACKAGE"

2911 # Version.

2912 echo -n "Version : " ; read anser

2913 sed -i s/'VERSION=\"\"'/"VERSION=\"$anser\""/ receipt

2914 # Category.

2915 echo -n "Category : " ; read anser

2916 sed -i s/'CATEGORY=\"\"'/"CATEGORY=\"$anser\""/ receipt

2917 # Short description.

2918 echo -n "Short desc : " ; read anser

2919 sed -i s/'SHORT_DESC=\"\"'/"SHORT_DESC=\"$anser\""/ receipt

2920 # Maintainer.

2921 echo -n "Maintainer : " ; read anser

2922 sed -i s/'MAINTAINER=\"\"'/"MAINTAINER=\"$anser\""/ receipt

2923 # Web site.

2924 echo -n "Web site : " ; read anser

2925 sed -i s#'WEB_SITE=\"\"'#"WEB_SITE=\"$anser\""# receipt

2926 echo ""

2927 # Wget URL.

2928 echo "Wget URL to download source tarball."

2929 echo "Example : \$GNU_MIRROR/\$PACKAGE/\$TARBALL"

2930 echo -n "Wget url : " ; read anser

2931 sed -i s#'WGET_URL=\"\"'#"WGET_URL=\"$anser\""# receipt

2932 # Ask for a stuff dir.

2933 echo -n "Do you need a stuff directory ? (y/N) : " ; read anser

2934 if [ "$anser" = "y" ]; then

2935 echo -n "Creating the stuff directory..."

2936 mkdir stuff && status

2937 fi

2938 # Ask for a description file.

2939 echo -n "Are you going to write a description ? (y/N) : " ; read anser

2940 if [ "$anser" = "y" ]; then

2941 echo -n "Creating the description.txt file..."

2942 echo "" > description.txt && status

2943 fi

2944 horizontal_line

2945 echo ""

2946 fi

2947 ;;

2948 remove)

2949 # Remove a package from the wok.

2950 #

2951 get_tazwok_config

2952 check_for_package_on_cmdline

2953 echo ""

2954 echo -n "Please confirm deletion (y/N) : "; read anser

2955 if [ "$anser" = "y" ]; then

2956 echo -n "Removing $PACKAGE..."

2957 rm -rf $WOK/$PACKAGE && status

2958 echo ""

2959 fi

2960 ;;

2961 update-wok)

2962 # Pull and update a Hg wok.

2963 get_options_list="local"

2964 get_tazwok_config

2965 source_lib report

2966 report start

2967 clean_wok=$LOCAL_REPOSITORY/clean-wok

2968 cd $clean_wok

2969 if ! [ "$local" ]; then

2970 if [ "$WOK_UPDATE_METHOD" = hg ]; then

2971 if ! [ -f "$INSTALLED/mercurial/receipt" ]; then

2972

2973 # Auto-install only if we are in a cook chroot.

2974 if [ -x /usr/bin/clean-chroot ]; then

2975 tazpkg get-install mercurial

2976 else

2977 echo "" >&2

2978 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

2979 echo "">&2

2980 exit 1

2981 fi

2982 fi

2983

2984 report step "Getting wok changes using hg"

2985 if [ -d .hg ]; then

2986 hg pull -u || exit 1

2987 else

2988 hg clone $HG_WOK . || exit 1

2989 fi

2990 report end-step

2991 [ -x /usr/bin/clean-chroot ] && clean-chroot

2992 else

2993 report step "Getting wok changes using tarball"

2994 { mkdir .tmp && cd .tmp

2995 wget "$TARBALL_WOK" &&

2996 case $TARBALL_WOK in

2997 *bz2) tar xjf *.bz2 -C wok; rm *.bz2;;

2998 *lzma) unlzma -c *.lzma | tar xf - -C wok; rm *.lzma ;;

2999 *gz) tar xzf *.gz -C wok; rm*.gz ;;

3000 esac &&

3001 rm -r $(ls -d $clean_wok/*) &&

3002 cp -a wok/* $clean_wok &&

3003 cd .. &&

3004 rm -r .tmp

3005 } || { echo "That's not cool: it fails!" >&2

3006 report end-step

3007 exit 1; }

3008 report end-step

3009 fi

3010 fi

3011 report step "Appending changes to wok"

3012

3013 # Handle removed files/dir.

3014 cd $WOK

3015 for dir in *; do

3016 [ -d "$clean_wok/$dir" ] || rm -rf $dir

3017 done

3018 for file in */receipt */description.txt; do

3019 [ -f "$clean_wok/$file" ] || rm -rf $file

3020 done

3021 for i in $(find */stuff 2>/dev/null); do

3022 [ -e "$clean_wok/$i" ] || rm -rf $i

3023 done

3024

3025 cp -a $clean_wok/* $WOK

3026 report end-step

3027 ;;

3028 maintainers)

3029 get_tazwok_config

3030 echo ""

3031 echo "List of maintainers for: $WOK"

3032 horizontal_line

3033 touch /tmp/slitaz-maintainers

3034 for pkg in $WOK/*

3035 do

3036 . $pkg/receipt

3037 if ! fgrep -q "$MAINTAINER" /tmp/slitaz-maintainers; then

3038 echo "$MAINTAINER" >> /tmp/slitaz-maintainers

3039 echo "$MAINTAINER"

3040 fi

3041 done

3042 horizontal_line

3043 echo "Maintainers: `cat /tmp/slitaz-maintainers | wc -l`"

3044 echo ""

3045 # Remove tmp files

3046 rm -f /tmp/slitaz-maintainers

3047 ;;

3048 maintained-by)

3049 # Search for packages maintained by a contributor.

3050 get_tazwok_config

3051 if [ ! -n "$2" ]; then

3052 echo "Specify a name or email of a maintainer." >&2

3053 exit 1

3054 fi

3055 echo "Maintainer packages"

3056 horizontal_line

3057 for pkg in $WOK/*

3058 do

3059 . $pkg/receipt

3060 if echo "$MAINTAINER" | fgrep -q "$2"; then

3061 echo "$PACKAGE"

3062 packages=$(($PACKAGEs+1))

3063 fi

3064 done

3065 horizontal_line

3066 echo "Packages maintained by $2: $PACKAGEs"

3067 echo ""

3068 ;;

3069 tags)

3070 get_tazwok_config

3071 echo -e "\n\033[1mTags list :\033[0m"

3072 horizontal_line

3073 cd $WOK

3074 for i in */receipt; do

3075 unset TAGS

3076 source $i

3077 for t in $TAGS; do

3078 grep -q ^$t$ $tmp/tags && continue

3079 echo $t | tee -a $tmp/tags

3080 done

3081 done

3082 horizontal_line

3083 echo "$(wc -l $tmp/tags | cut -f1 -d ' ') tags listed."

3084 ;;

3085 check-src)

3086 # Verify if upstream package is still available.

3087 #

3088 get_tazwok_config

3089 check_for_package_on_cmdline

3090 check_for_receipt

3091 source_receipt

3092 check_src()

3093 {

3094 for url in $@; do

3095 busybox wget -s $url 2>/dev/null && break

3096 done

3097 }

3098 if [ "$WGET_URL" ];then

3099 echo -n "$PACKAGE : "

3100 check_src $WGET_URL

3101 status

3102 else

3103 echo "No tarball to check for $PACKAGE"

3104 fi

3105 ;;

3106 gen-src)

3107 get_tazwok_config

3108 if [ "$2" ]; then

3109 if [ -d "$2" ]; then

3110 src_repository=$2

3111 else

3112 echo -e "\nUnable to find directory : $2\n" >&2

3113 exit 1

3114 fi

3115 fi

3116 echo -n "Rebuilding sources.list file"

3117 [ $src_repository ] || src_repository="$SOURCES_REPOSITORY"

3118 gen_sources_list $src_repository

3119 status

3120 ;;

3121 get-src)

3122 check_root

3123 get_options_list="target nounpack"

3124 get_tazwok_config

3125 check_for_package_on_cmdline

3126 check_for_receipt

3127 source_receipt

3128 if [ "$WGET_URL" ];then

3129 source_lib report

3130 report start

3131 check_for_tarball

3132 else

3133 echo "No tarball to download for $PACKAGE"

3134 fi

3135 ;;

3136 check-commit)

3137 check_root

3138 get_options_list="missing forced"

3139 get_tazwok_config

3140 source_lib report

3141 report start

3142 if [ "$forced" ]; then

3143 rm -f $WOK/*/md5

3144 unset forced

3145 fi

3146 if [ "$missing" ]; then

3147 pkg=$(ls -1 $WOK)

3148 else

3149 pkg="$({ grep ^[a-zA-Z0-9] $PACKAGES_REPOSITORY/packages.txt

3150 grep ^[a-zA-Z0-9] $INCOMING_REPOSITORY/packages.txt

3151 } | sort -u)"

3152 fi

3153 cooklist=$PACKAGES_REPOSITORY/cooklist

3154 gen_cook_list

3155 ;;

3156 cook-commit)

3157 check_root

3158 get_options_list="missing forced"

3159 get_tazwok_config

3160 source_lib report

3161 report start

3162 if [ "$forced" ]; then

3163 rm -f $WOK/*/md5

3164 unset forced

3165 fi

3166 if [ "$missing" ]; then

3167 pkg=$(ls -1 $WOK)

3168 else

3169 pkg="$({ grep ^[a-zA-Z0-9] $PACKAGES_REPOSITORY/packages.txt

3170 grep ^[a-zA-Z0-9] $INCOMING_REPOSITORY/packages.txt

3171 } | sort -u)"

3172 fi

3173 cooklist=$PACKAGES_REPOSITORY/cooklist

3174 gen_cook_list

3175 cook_list

3176 ;;

3177 cook-all)

3178 check_root

3179 get_options_list="forced missing"

3180 get_tazwok_config

3181 source_lib report

3182 report start

3183 if [ "$missing" ]; then

3184 pkg=$(ls -1 $WOK)

3185 else

3186 pkg="$({ grep ^[a-zA-Z0-9] $PACKAGES_REPOSITORY/packages.txt

3187 grep ^[a-zA-Z0-9] $INCOMING_REPOSITORY/packages.txt

3188 } | sort -u)"

3189 fi

3190 cooklist=$PACKAGES_REPOSITORY/cooklist

3191 gen_cook_list

3192 cook_list

3193 ;;

3194 gen-wok-db)

3195 check_root

3196 get_tazwok_config

3197 source_lib report

3198 report start

3199 gen_wok_db

3200 ;;

3201 report)

3202 get_tazwok_config

3203 cd $PACKAGES_REPOSITORY

3204 if [ "$2" ]; then

3205 case $2 in

3206 commit|cooklist|incoming|broken|blocked)

3207 show="$2"

3208 ;;

3209 *)

3210 echo "usage : tazwok report [commit|cooklist|incoming|broken|blocked]" >&2

3211 exit 1

3212 ;;

3213 esac

3214 else

3215 show="commit cooklist incoming broken blocked"

3216 fi

3217 for i in $show; do

3218 if [ -s $i ]; then

3219 echo ""

3220 echo -e "\033[1m$i\033[0m"

3221 horizontal_line

3222 cat $i

3223 horizontal_line

3224 echo ""

3225 fi

3226 done

3227 ;;

3228 check-incoming)

3229 check_root

3230 get_options_list="forced"

3231 get_tazwok_config

3232 source_lib report

3233 report start

3234 [ -f $LOCAL_RESOSITORY/incoming ] && rm [ -f $LOCAL_REPOSITORY/incoming ]

3235 report step "Checking $INCOMING_REPOSITORY"

3236 report open-bloc

3237 [ -f $LOCAL_REPOSITORY/log/incoming.html ] && rm $LOCAL_REPOSITORY/log/incoming.html

3238 report sublog $LOCAL_REPOSITORY/log/incoming.html

3239 echo "incoming" > $LOCAL_REPOSITORY/log/package

3240 check_for_incoming

3241 report end-sublog

3242 report close-bloc

3243 ;;

3244 configure-chroot)

3245 check_root

3246 get_tazwok_config

3247 if [ -f /usr/bin/tazchroot ]; then

3248 cd $LOCAL_REPOSITORY

3249 configure_tazchroot

3250 else

3251 echo "The package tazchroot needs to be installed" >&2

3252 exit 1

3253 fi

3254 ;;

3255 chroot)

3256 check_root

3257 get_tazwok_config

3258 # Merge this and the other chroot function ?.

3259 if [ -f /usr/bin/tazchroot ]; then

3260 cd $LOCAL_REPOSITORY

3261 [ ! -f tazchroot.conf ] && configure_tazchroot

3262 tazchroot

3263 else

3264 echo "The package tazchroot needs to be installed" >&2

3265 exit 1

3266 fi

3267 ;;

3268 cook-toolchain)

3269 check_root

3270 get_tazwok_config

3271 echo -n "" > $PACKAGES_REPOSITORY/broken

3272 if [ -f /usr/bin/tazchroot ]; then

3273 cd $LOCAL_REPOSITORY

3274 [ ! -f tazchroot.conf ] && configure_tazchroot

3275 tazchroot cook-toolchain

3276 # Buggy : chroot can be elsewhere.

3277 rm -r $LOCAL_REPOSITORY/chroot

3278 # /!\ to be written :

3279 # next rm chroot and plan cook-all by pushing all packages

3280 # in cooklist.

3281 else

3282 echo "The package tazchroot needs to be installed" >&2

3283 exit 1

3284 fi

3285 ;;

3286 webserver)

3287 check_root

3288 get_tazwok_config

3289 if [ "$ARG" = on ]; then

3290 if [ "$WEBSERVER" ] && [ -f "$WEBSERVER/repositories.list" ] && \

3291 grep -q ^"${undigest:-$SLITAZ_VERSION}"$ $WEBSERVER/repositories.list; then

3292 echo "Webserver is already enabled at $WEBSERVER for ${undigest:-$SLITAZ_VERSION}." >&2

3293 exit 1

3294 fi

3295 if ! [ -f $LOCAL_REPOSITORY/tazchroot.conf ]; then

3296 tazwok configure-chroot ${undigest:+--undigest=$undigest} --SLITAZ_VERSION=$SLITAZ_VERSION --SLITAZ_DIR=$SLITAZ_DIR

3297 fi

3298 for pkg in php lighttpd; do

3299 [ -d $INSTALLED/$pkg ] || missing="$missing $pkg"

3300 done

3301 if [ "$missing" ]; then

3302 echo "You need to install these packages to start webserver: $missing." >&2

3303 exit 1

3304 fi

3305 if [ ! -f "$LOCAL_REPOSITORY/tazwok.conf" ]; then

3306 echo "Copying /etc/slitaz/tazwok.conf to $LOCAL_REPOSITORY/tazwok.conf: webserver is configured repository-by-repository."

3307 cp /etc/slitaz/tazwok.conf $LOCAL_REPOSITORY

3308 fi

3309 if ! [ "$WEBSERVER" ]; then

3310 echo -n "Where to store php pages (default: /var/www/vhosts/bb)? "

3311 read WEBSERVER

3312 [ "$WEBSERVER" ] || WEBSERVER="/var/www/vhosts/bb"

3313 fi

3314 if [ -f "$WEBSERVER/repositories.list" ] && \

3315 grep -q ^"${undigest:-$SLITAZ_VERSION}"$ $WEBSERVER/repositories.list; then

3316 echo "Webserver is already enabled at $WEBSERVER for ${undigest:-$SLITAZ_VERSION}." >&2

3317 exit 1

3318 fi

3319 mkdir -p $WEBSERVER

3320 echo "${undigest:-$SLITAZ_VERSION}" >> $WEBSERVER/repositories.list

3321 for file in index.php log.php download.php; do

3322 [ -f "$WEBSERVER/$file" ] || ln -s /usr/share/slitaz/web-bb/$file $WEBSERVER

3323 done

3324 for dir in $PACKAGES_REPOSITORY $INCOMING_REPOSITORY; do

3325 ln -s $dir $WEBSERVER/${undigest:-$SLITAZ_VERSION}-${dir##*/}

3326 done

3327 source $LOCAL_REPOSITORY/tazchroot.conf

3328 echo "<?php

3329

3330 // Web interface configuration

3331

3332 \$version=\"${undigest:-$SLITAZ_VERSION}\";

3333 \$chroot=\"$chroot_dir\";

3334 \$lockfile=\"\$chroot/proc/1/status\";

3335 \$db_dir=\"$PACKAGES_REPOSITORY\";

3336 \$log_dir=\"$LOCAL_REPOSITORY/log\";

3337 \$packages=\"$PACKAGES_REPOSITORY\";

3338 \$incoming=\"$INCOMING_REPOSITORY\";

3339 \$wok=\"$WOK\";

3340

3341 ?>" > $WEBSERVER/conf-${undigest:-$SLITAZ_VERSION}.php

3342 [ -L "$WEBSERVER/web" ] || ln -s /usr/share/slitaz/web $WEBSERVER

3343 echo "WEBSERVER=\"$WEBSERVER\"" >> $LOCAL_REPOSITORY/tazwok.conf

3344 if [ -L "$WEBSERVER/conf.php" ]; then

3345 echo "Do you want to make ${undigest:-$SLITAZ_VERSION} the default page (y/N) ? "

3346 read answer

3347 if [ "$answer" = y ]; then

3348 rm $WEBSERVER/conf.php

3349 ln -s $WEBSERVER/conf-${undigest:-$SLITAZ_VERSION}.php $WEBSERVER/conf.php

3350 fi

3351 else

3352 ln -s $WEBSERVER/conf-${undigest:-$SLITAZ_VERSION}.php $WEBSERVER/conf.php

3353 fi

3354 elif [ "$ARG" = off ]; then

3355 if ! [ "$WEBSERVER" ]; then

3356 echo "No webserver running for ${undigest:-$SLITAZ_VERSION}" >&2

3357 exit 1

3358 fi

3359 sed '/^WEBSERVER/d' -i $LOCAL_REPOSITORY/tazwok.conf

3360 sed "/^${undigest:-$SLITAZ_VERSION}$/d" -i $WEBSERVER/repositories.list

3361 rm $WEBSERVER/conf-${undigest:-$SLITAZ_VERSION}.php

3362 for dir in $PACKAGES_REPOSITORY $INCOMING_REPOSITORY; do

3363 rm $WEBSERVER/${undigest:-$SLITAZ_VERSION}-${dir##*/}

3364 done

3365 if ! [ -s "$WEBSERVER/repositories.list" ]; then

3366 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"

3367 rm $WEBSERVER/conf.php

3368 elif [ "$(readlink $WEBSERVER/conf.php)" = "$WEBSERVER/conf-${undigest:-$SLITAZ_VERSION}.php" ]; then

3369 echo "${undigest:-$SLITAZ_VERSION} was the default version to use; switched to : $(sed 1!d $WEBSERVER/repositories.list)"

3370 rm $WEBSERVER/conf.php

3371 ln -s $WEBSERVER/conf-$(sed 1!d $WEBSERVER/repositories.list).php $WEBSERVER/conf.php

3372 fi

3373 else

3374 echo "Usage: tazwok webserver on/off" >&2

3375 exit 1

3376 fi

3377 ;;

3378 block)

3379 # Add a pkg name to the list of blocked packages.

3380 get_tazwok_config

3381 check_root

3382 check_for_package_on_cmdline

3383 if ! [ -f $WOK/$PACKAGE/receipt ]; then

3384 echo "Can't find $PACKAGE in wok." >&2

3385 echo ""

3386 exit 1

3387 fi

3388 echo ""

3389 if grep -qs "^$PACKAGE$" $PACKAGES_REPOSITORY/blocked; then

3390 echo "$PACKAGE is already in the blocked packages list." >&2

3391 echo ""

3392 exit 1

3393 else

3394 echo -n "Adding $PACKAGE to : $PACKAGES_REPOSITORY/blocked... "

3395 echo "$PACKAGE" >> $PACKAGES_REPOSITORY/blocked

3396 status

3397 if grep -q "^$PACKAGE$" $PACKAGES_REPOSITORY/cooklist; then

3398 echo -n "Removing $PACKAGE from : $PACKAGES_REPOSITORY/cooklist... "

3399 sed -i /"^$PACKAGE$"/d $PACKAGES_REPOSITORY/cooklist

3400 status

3401 fi

3402 fi

3403 echo "" ;;

3404 unblock)

3405 # Remove a pkg name from the list of blocked packages.

3406 get_tazwok_config

3407 check_root

3408 check_for_package_on_cmdline

3409 if ! [ -f $WOK/$PACKAGE/receipt ]; then

3410 echo "Can't find $PACKAGE in wok." >&2

3411 echo ""

3412 exit 1

3413 fi

3414 echo ""

3415 if grep -qs "^$PACKAGE$" $PACKAGES_REPOSITORY/blocked; then

3416 echo -n "Removing $PACKAGE from : $PACKAGES_REPOSITORY/blocked... "

3417 sed -i /"^$PACKAGE$"/d $PACKAGES_REPOSITORY/blocked

3418 sed -i '/^$/d' $PACKAGES_REPOSITORY/blocked

3419 status

3420 else

3421 echo "$PACKAGE is not in the blocked packages list." >&2

3422 echo ""

3423 exit 1

3424 fi

3425 echo "" ;;

3426 usage|*)

3427 # Print usage also for all unknown commands.

3428 #

3429 usage

3430 ;;

3431 esac

3432

3433 report stop 2>/dev/null

3434 exit 0

SliTaz Repositories

tazwok view tazwok @ rev 516