bitbake: bitbake-user-manual: Fixed porno hack for hello world example

Someone hacked the http://hambedded site or it was moved and some
links to that site in the BB manual had been hijacked to point to
an entry portal for a pornography site.  Replaced the link with an
archived version that restores the integrity of the links.

(Bitbake rev: daa0aa05a04d8d20473a05b5b5878610e40ef820)

Signed-off-by: Scott Rifenbark <srifenbark@gmail.com>
Signed-off-by: Richard Purdie <richard.purdie@linuxfoundation.org>

.gitignore

@@ -1,20 +1,19 @@
 *.pyc
 *.pyo
 /*.patch
-/build*/
+build*/
 pyshtables.py
 pstage/
 scripts/oe-git-proxy-socks
 sources/
 meta-*/
 !meta-skeleton
-!meta-selftest
+!meta-hob
 hob-image-*.bb
 *.swp
 *.orig
 *.rej
 *~
-!meta-poky
 !meta-yocto
 !meta-yocto-bsp
 !meta-yocto-imported
@@ -22,6 +21,3 @@ documentation/user-manual/user-manual.html
 documentation/user-manual/user-manual.pdf
 documentation/user-manual/user-manual.tgz
 pull-*/
-bitbake/lib/toaster/contrib/tts/backlog.txt
-bitbake/lib/toaster/contrib/tts/log/*
-bitbake/lib/toaster/contrib/tts/.cache/*

.templateconf

@@ -1,2 +1,2 @@
 # Template settings
-TEMPLATECONF=${TEMPLATECONF:-meta-poky/conf}
+TEMPLATECONF=${TEMPLATECONF:-meta-yocto/conf}

README

@@ -30,29 +30,20 @@ For information about OpenEmbedded, see the OpenEmbedded website:
 Where to Send Patches
 =====================
 
-As Poky is an integration repository (built using a tool called combo-layer),
-patches against the various components should be sent to their respective
-upstreams:
+As Poky is an integration repository, patches against the various components
+should be sent to their respective upstreams.
 
 bitbake:
-    Git repository: http://git.openembedded.org/bitbake/
-    Mailing list: bitbake-devel@lists.openembedded.org
+    bitbake-devel@lists.openembedded.org
 
-documentation:
-    Git repository: http://git.yoctoproject.org/cgit/cgit.cgi/yocto-docs/
-    Mailing list: yocto@yoctoproject.org
+meta-yocto:
+    poky@yoctoproject.org
 
-meta-poky, meta-yocto-bsp:
-    Git repository: http://git.yoctoproject.org/cgit/cgit.cgi/meta-yocto(-bsp)
-    Mailing list: poky@yoctoproject.org
-
-Everything else should be sent to the OpenEmbedded Core mailing list.  If in
-doubt, check the oe-core git repository for the content you intend to modify.
+Most everything else should be sent to the OpenEmbedded Core mailing list.  If
+in doubt, check the oe-core git repository for the content you intend to modify.
 Before sending, be sure the patches apply cleanly to the current oe-core git
 repository.
+    openembedded-core@lists.openembedded.org
 
-    Git repository: http://git.openembedded.org/openembedded-core/
-    Mailing list: openembedded-core@lists.openembedded.org
-
-Note: The scripts directory should be treated with extra care as it is a mix of
-oe-core and poky-specific files.
+Note: The scripts directory should be treated with extra care as it is a mix
+      of oe-core and poky-specific files.

README.hardware

@@ -77,26 +77,37 @@ variable value corresponding to the device is given in brackets.
                       ===============================
 
 
-Intel x86 based PCs and devices (genericx86*)
-=============================================
+Intel x86 based PCs and devices (genericx86)
+==========================================
 
-The genericx86 and genericx86-64 MACHINE are tested on the following platforms:
+The genericx86 MACHINE is tested on the following platforms:
 
 Intel Xeon/Core i-Series:
-  + Intel NUC5 Series - ix-52xx Series SOC (Broadwell)
-  + Intel NUC6 Series - ix-62xx Series SOC (Skylake)
-  + Intel Shumway Xeon Server
+  + Intel Romley Server: Sandy Bridge Xeon processor, C600 PCH (Patsburg), (Canoe Pass CRB)
+  + Intel Romley Server: Ivy Bridge Xeon processor, C600 PCH (Patsburg), (Intel SDP S2R3)
+  + Intel Crystal Forest Server: Sandy Bridge Xeon processor, DH89xx PCH (Cave Creek), (Stargo CRB)
+  + Intel Chief River Mobile: Ivy Bridge Mobile processor, QM77 PCH (Panther Point-M), (Emerald Lake II CRB, Sabino Canyon CRB)
+  + Intel Huron River Mobile: Sandy Bridge processor, QM67 PCH (Cougar Point), (Emerald Lake CRB, EVOC EC7-1817LNAR board)
+  + Intel Calpella Platform: Core i7 processor, QM57 PCH (Ibex Peak-M), (Red Fort CRB, Emerson MATXM CORE-411-B)
+  + Intel Nehalem/Westmere-EP Server: Xeon 56xx/55xx processors, 5520 chipset, ICH10R IOH (82801), (Hanlan Creek CRB)
+  + Intel Nehalem Workstation: Xeon 56xx/55xx processors, System SC5650SCWS (Greencity CRB)
+  + Intel Picket Post Server: Xeon 56xx/55xx processors (Jasper Forest), 3420 chipset (Ibex Peak), (Osage CRB)
+  + Intel Storage Platform: Sandy Bridge Xeon processor, C600 PCH (Patsburg), (Oak Creek Canyon CRB)
+  + Intel Shark Bay Client Platform: Haswell processor, LynxPoint PCH, (Walnut Canyon CRB, Lava Canyon CRB, Basking Ridge CRB, Flathead Creek CRB)
+  + Intel Shark Bay Ultrabook Platform: Haswell ULT processor, Lynx Point-LP PCH, (WhiteTip Mountain 1 CRB)
 
 Intel Atom platforms:
-  + MinnowBoard MAX - E3825 SOC (Bay Trail)
-  + MinnowBoard MAX - Turbot (ADI Engineering) - E3826 SOC (Bay Trail)
-    - These boards can be either 32bot or 64bit modes depending on firmware
-    - See minnowboard.org for details 
-  + Intel Braswell SOC
+  + Intel embedded Menlow: Intel Atom Z510/530 CPU, System Controller Hub US15W (Portwell NANO-8044)
+  + Intel Luna Pier: Intel Atom N4xx/D5xx series CPU (aka: Pineview-D & -M), 82801HM I/O Hub (ICH8M), (Advantech AIMB-212, Moon Creek CRB)
+  + Intel Queens Bay platform: Intel Atom E6xx CPU (aka: Tunnel Creek), Topcliff EG20T I/O Hub (Emerson NITX-315, Crown Bay CRB, Minnow Board)
+  + Intel Fish River Island platform: Intel Atom E6xx CPU (aka: Tunnel Creek), Topcliff EG20T I/O Hub (Kontron KM2M806)
+  + Intel Cedar Trail platform: Intel Atom N2000 & D2000 series CPU (aka: Cedarview), NM10 Express Chipset (Norco kit BIS-6630, Cedar Rock CRB)
 
 and is likely to work on many unlisted Atom/Core/Xeon based devices. The MACHINE
 type supports ethernet, wifi, sound, and Intel/vesa graphics by default in
-addition to common PC input devices, busses, and so on.
+addition to common PC input devices, busses, and so on.  Note that it does not
+included the binary-only graphic drivers used on some Atom platforms, for
+accelerated graphics on these machines please refer to meta-intel.
 
 Depending on the device, it can boot from a traditional hard-disk, a USB device,
 or over the network. Writing generated images to physical media is
@@ -127,14 +138,53 @@ USB Device:
      device, but the idea is to force BIOS to read the Cylinder/Head/Sector
      geometry from the device.
 
-  2. Use a ".wic" image with an EFI partition
+  2. Without such an option, the BIOS generally boots the device in USB-ZIP
+     mode. To write an image to a USB device that will be bootable in
+     USB-ZIP mode, carry out the following actions:
 
-     a) With a default grub-efi bootloader:
-     # dd if=core-image-minimal-genericx86-64.wic of=/dev/sdb
+     a. Determine the geometry of your USB device using fdisk:
 
-     b) Use systemd-boot instead
-     - Build an image with EFI_PROVIDER="systemd-boot" then use the above
-       dd command to write the image to a USB stick.
+     # fdisk /dev/sdb
+     Command (m for help): p
+
+     Disk /dev/sdb: 4011 MB, 4011491328 bytes
+     124 heads, 62 sectors/track, 1019 cylinders, total 7834944 sectors
+     ...
+
+     Command (m for help): q
+
+     b. Configure the USB device for USB-ZIP mode:
+     
+     # mkdiskimage -4 /dev/sdb 1019 124 62
+
+     Where 1019, 124 and 62 are the cylinder, head and sectors/track counts
+     as reported by fdisk (substitute the values reported for your device).
+     When the operation has finished and the access LED (if any) on the
+     device stops flashing, remove and reinsert the device to allow the
+     kernel to detect the new partition layout.
+
+     c. Copy the contents of the image to the USB-ZIP mode device:
+
+     # mkdir /tmp/image
+     # mkdir /tmp/usbkey
+     # mount -o loop core-image-minimal-genericx86.hddimg  /tmp/image
+     # mount /dev/sdb4 /tmp/usbkey
+     # cp -rf /tmp/image/* /tmp/usbkey
+
+     d. Install the syslinux boot loader:
+
+     # syslinux /dev/sdb4
+
+     e. Unmount everything:
+
+     # umount /tmp/image
+     # umount /tmp/usbkey
+
+  Install the boot device in the target board and configure the BIOS to boot
+  from it.
+
+  For more details on the USB-ZIP scenario, see the syslinux documentation:
+  http://git.kernel.org/?p=boot/syslinux/syslinux.git;a=blob_plain;f=doc/usbkey.txt;hb=HEAD
 
 
 Texas Instruments Beaglebone (beaglebone)
@@ -160,17 +210,59 @@ this, issue the following commands from the u-boot prompt:
 To further tailor these instructions for your board, please refer to the
 documentation at http://www.beagleboard.org/bone and http://www.beagleboard.org/black
 
-From a Linux system with access to the image files perform the following steps:
+From a Linux system with access to the image files perform the following steps
+as root, replacing mmcblk0* with the SD card device on your machine (such as sdc
+if used via a usb card reader):
 
-  1. Build an image. For example:
+  1. Partition and format an SD card:
+     # fdisk -lu /dev/mmcblk0
 
-     $ bitbake core-image-minimal
+     Disk /dev/mmcblk0: 3951 MB, 3951034368 bytes
+     255 heads, 63 sectors/track, 480 cylinders, total 7716864 sectors
+     Units = sectors of 1 * 512 = 512 bytes
 
-  2. Use the "dd" utility to write the image to the SD card. For example:
+             Device Boot      Start         End      Blocks  Id System
+     /dev/mmcblk0p1   *          63      144584       72261   c Win95 FAT32 (LBA)
+     /dev/mmcblk0p2          144585      465884      160650  83 Linux
 
-     # dd core-image-minimal-beaglebone.wic of=/dev/sdb
+     # mkfs.vfat -F 16 -n "boot" /dev/mmcblk0p1
+     # mke2fs -j -L "root" /dev/mmcblk0p2
+
+  The following assumes the SD card partitions 1 and 2 are mounted at
+  /media/boot and /media/root respectively. Removing the card and reinserting
+  it will do just that on most modern Linux desktop environments.
+
+  The files referenced below are made available after the build in
+  build/tmp/deploy/images.
+
+  2. Install the boot loaders
+     # cp MLO-beaglebone /media/boot/MLO
+     # cp u-boot-beaglebone.img /media/boot/u-boot.img
+
+  3. Install the root filesystem
+     # tar x -C /media/root -f core-image-$IMAGE_TYPE-beaglebone.tar.bz2
+
+  4. If using core-image-base or core-image-sato images, the SD card is ready
+     and rootfs already contains the kernel, modules and device tree (DTB)
+     files necessary to be booted with U-boot's default configuration, so
+     skip directly to step 8.
+     For core-image-minimal, proceed through next steps.
+
+  5. If using core-image-minimal rootfs, install the modules
+     # tar x -C /media/root -f modules-beaglebone.tgz
+
+  6. If using core-image-minimal rootfs, install the kernel uImage into /boot
+     directory of rootfs
+     # cp uImage-beaglebone.bin /media/root/boot/uImage
+
+  7. If using core-image-minimal rootfs, also install device tree (DTB) files
+     into /boot directory of rootfs
+     # cp uImage-am335x-bone.dtb /media/root/boot/am335x-bone.dtb
+     # cp uImage-am335x-boneblack.dtb /media/root/boot/am335x-boneblack.dtb
+
+  8. Unmount the SD partitions, insert the SD card into the Beaglebone, and
+     boot the Beaglebone
 
-  3. Insert the SD card into the Beaglebone and boot the board.
 
 Freescale MPC8315E-RDB (mpc8315e-rdb)
 =====================================
@@ -203,75 +295,6 @@ linux/arch/powerpc/boot/dts/mpc8315erdb.dts within the kernel source). If
 you have left them at the factory default then you shouldn't need to do
 anything here.
 
-Note: To boot from USB disk you need u-boot that supports 'ext2load usb'
-command. You need to setup TFTP server, load u-boot from there and
-flash it to NOR flash.
-
-Beware! Flashing bootloader is potentially dangerous operation that can
-brick your device if done incorrectly. Please, make sure you understand
-what below commands mean before executing them.
-
-Load the new u-boot.bin from TFTP server to memory address 200000
-=> tftp 200000 u-boot.bin
-
-Disable flash protection
-=> protect off all
-
-Erase the old u-boot from fe000000 to fe06ffff in NOR flash.
-The size is 0x70000 (458752 bytes)
-=> erase fe000000 fe06ffff
-
-Copy the new u-boot from address 200000 to fe000000
-the size is 0x70000. It has to be greater or equal to u-boot.bin size
-=> cp.b 200000 fe000000 70000
-
-Enable flash protection again
-=> protect on all
-
-Reset the board
-=> reset
-
---- Booting from USB disk ---
-
- 1. Flash partitioned image to the USB disk
-
-    # dd if=core-image-minimal-mpc8315e-rdb.wic of=/dev/sdb
-
- 2. Plug USB disk into the MPC8315 board
-
- 3. Connect the board's first serial port to your workstation and then start up
-    your favourite serial terminal so that you will be able to interact with
-    the serial console. If you don't have a favourite, picocom is suggested:
-
-  $ picocom /dev/ttyUSB0 -b 115200
-
- 4. Power up or reset the board and press a key on the terminal when prompted
-    to get to the U-Boot command line
-
- 5. Optional. Load the u-boot.bin from the USB disk:
-
- => usb start
- => ext2load usb 0:1 200000 u-boot.bin
-
-    and flash it to NOR flash as described above.
-
- 6. Set fdtaddr and loadaddr. This is not necessary if you set them before.
-
- => setenv fdtaddr a00000
- => setenv loadaddr 1000000
-
- 7. Load the kernel and dtb from first partition of the USB disk:
-
- => usb start
- => ext2load usb 0:1 $loadaddr uImage
- => ext2load usb 0:1 $fdtaddr dtb
-
- 8. Set bootargs and boot up the device
-
- => setenv bootargs root=/dev/sdb2 rw rootwait console=ttyS0,115200
- => bootm $loadaddr - $fdtaddr
-
-
 --- Booting from NFS root ---
 
 Load the kernel and dtb (device tree blob), and boot the system as follows:
@@ -329,14 +352,11 @@ Setup instructions
 ------------------
 
 You will need the following:
-* RJ45 -> serial ("rollover") cable connected from your PC to the CONSOLE
-  port on the device
-* Ethernet connected to the first ethernet port on the board
-
-If using NFS as part of the setup process, you will also need:
 * NFS root setup on your workstation
-* TFTP server installed on your workstation (if fetching the kernel from
-  TFTP, see below).
+* TFTP server installed on your workstation
+* RJ45 -> serial ("rollover") cable connected from your PC to the CONSOLE
+  port on the board
+* Ethernet connected to the first ethernet port on the board
 
 --- Preparation ---
 
@@ -344,7 +364,7 @@ Build an image (e.g. core-image-minimal) using "edgerouter" as the MACHINE.
 In the following instruction it is based on core-image-minimal. Another target
 may be similiar with it.
 
---- Booting from NFS root / kernel via TFTP ---
+--- Booting from NFS root ---
 
 Load the kernel, and boot the system as follows:
 
@@ -370,25 +390,75 @@ Load the kernel, and boot the system as follows:
  => tftp tftp $loadaddr vmlinux
  => bootoctlinux $loadaddr coremask=0x3 root=/dev/nfs rw nfsroot=<nfsroot ip>:<rootfs path> ip=<board ip>:<server ip>:<gateway ip>:<netmask>:edgerouter:eth0:off mtdparts=phys_mapped_flash:512k(boot0),512k(boot1),64k@3072k(eeprom)
 
---- Booting from USB disk ---
+--- Booting from USB root ---
 
 To boot from the USB disk, you either need to remove it from the edgerouter
 box and populate it from another computer, or use a previously booted NFS
 image and populate from the edgerouter itself.
 
-Type 1: Use partitioned image
------------------------------
+Type 1: Mounted USB disk
+------------------------
+
+To boot from the USB disk there are two available partitions on the factory
+USB storage. The rest of this guide assumes that these partitions are left
+intact. If you change the partition scheme, you must update your boot method
+appropriately.
+
+The standard partitions are:
+
+  - 1: vfat partition containing factory kernels
+  - 2: ext3 partition for the root filesystem.
+
+You can place the kernel on either partition 1, or partition 2, but the roofs
+must go on partition 2 (due to its size).
+
+Note: If you place the kernel on the ext3 partition, you must re-create the
+      ext3 filesystem, since the factory u-boot can only handle 128 byte inodes and
+      cannot read the partition otherwise.
 
 Steps:
 
  1. Remove the USB disk from the edgerouter and insert it into a computer
     that has access to your build artifacts.
 
- 2. Flash the image.
+ 2. Copy the kernel image to the USB storage (assuming discovered as 'sdb' on
+    the development machine):
 
-    # dd if=core-image-minimal-edgerouter.wic of=/dev/sdb
+    2a) if booting from vfat
+ 
+        # mount /dev/sdb1 /mnt
+        # cp tmp/deploy/images/edgerouter/vmlinux /mnt
+        # umount /mnt
 
- 3. Insert USB disk into the edgerouter and boot it.
+    2b) if booting from ext3
+
+        # mkfs.ext3 -I 128 /dev/sdb2
+        # mount /dev/sdb2 /mnt
+        # mkdir /mnt/boot
+        # cp tmp/deploy/images/edgerouter/vmlinux /mnt/boot
+        # umount /mnt
+
+ 3. Extract the rootfs to the USB storage ext3 partition
+
+        # mount /dev/sdb2 /mnt
+        # tar -xvjpf core-image-minimal-XXX.tar.bz2 -C /mnt
+        # umount /mnt
+
+ 4. Reboot the board and press a key on the terminal when prompted to get to the U-Boot
+    command line:
+
+ 5. Load the kernel and boot:
+
+    5a) vfat boot
+
+         => fatload usb 0:1 $loadaddr vmlinux
+
+    5b) ext3 boot
+
+         => ext2load usb 0:2 $loadaddr boot/vmlinux
+ 
+    => bootoctlinux $loadaddr coremask=0x3 root=/dev/sda2 rw rootwait mtdparts=phys_mapped_flash:512k(boot0),512k(boot1),64k@3072k(eeprom)
+ 
 
 Type 2: NFS
 -----------

bitbake/LICENSE

@@ -5,15 +5,6 @@ The following external components are distributed with this software:
 * The Toaster Simple UI application is based upon the Django project template, the files of which are covered by the BSD license and are copyright (c) Django Software
 Foundation and individual contributors.
 
-* Twitter Bootstrap (including Glyphicons), redistributed under the MIT license
+* Twitter Bootstrap (including Glyphicons), redistributed under the Apache License 2.0.
+
 * jQuery is redistributed under the MIT license.
-
-* Twitter typeahead.js redistributed under the MIT license. Note that the JS source has one small modification, so the full unminified file is currently included to make it obvious where this is.
-
-* jsrender is redistributed under the MIT license.
-
-* QUnit is redistributed under the MIT license.
-
-* Font Awesome fonts redistributed under the SIL Open Font License 1.1
-
-* simplediff is distributed under the zlib license.

bitbake/bin/bitbake

@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+#!/usr/bin/env python
 # ex:ts=4:sw=4:sts=4:et
 # -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
 #
@@ -23,34 +23,369 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 import os
-import sys
-
+import sys, logging
 sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(__file__)),
                                 'lib'))
+
+import optparse
+import warnings
+from traceback import format_exception
 try:
     import bb
 except RuntimeError as exc:
     sys.exit(str(exc))
-
+from bb import event
+import bb.msg
+from bb import cooker
+from bb import ui
+from bb import server
 from bb import cookerdata
-from bb.main import bitbake_main, BitBakeConfigParameters, BBMainException
 
-if sys.getfilesystemencoding() != "utf-8":
-    sys.exit("Please use a locale setting which supports utf-8.\nPython can't change the filesystem locale after loading so we need a utf-8 when python starts or things won't work.")
+__version__ = "1.24.0"
+logger = logging.getLogger("BitBake")
 
-__version__ = "1.34.0"
+# Python multiprocessing requires /dev/shm
+if not os.access('/dev/shm', os.W_OK | os.X_OK):
+    sys.exit("FATAL: /dev/shm does not exist or is not writable")
+
+# Unbuffer stdout to avoid log truncation in the event
+# of an unorderly exit as well as to provide timely
+# updates to log files for use with tail
+try:
+    if sys.stdout.name == '<stdout>':
+        sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)
+except:
+    pass
+
+
+def get_ui(config):
+    if not config.ui:
+        # modify 'ui' attribute because it is also read by cooker
+        config.ui = os.environ.get('BITBAKE_UI', 'knotty')
+
+    interface = config.ui
+
+    try:
+        # Dynamically load the UI based on the ui name. Although we
+        # suggest a fixed set this allows you to have flexibility in which
+        # ones are available.
+        module = __import__("bb.ui", fromlist = [interface])
+        return getattr(module, interface)
+    except AttributeError:
+        sys.exit("FATAL: Invalid user interface '%s' specified.\n"
+                 "Valid interfaces: depexp, goggle, ncurses, hob, knotty [default]." % interface)
+
+
+# Display bitbake/OE warnings via the BitBake.Warnings logger, ignoring others"""
+warnlog = logging.getLogger("BitBake.Warnings")
+_warnings_showwarning = warnings.showwarning
+def _showwarning(message, category, filename, lineno, file=None, line=None):
+    if file is not None:
+        if _warnings_showwarning is not None:
+            _warnings_showwarning(message, category, filename, lineno, file, line)
+    else:
+        s = warnings.formatwarning(message, category, filename, lineno)
+        warnlog.warn(s)
+
+warnings.showwarning = _showwarning
+warnings.filterwarnings("ignore")
+warnings.filterwarnings("default", module="(<string>$|(oe|bb)\.)")
+warnings.filterwarnings("ignore", category=PendingDeprecationWarning)
+warnings.filterwarnings("ignore", category=ImportWarning)
+warnings.filterwarnings("ignore", category=DeprecationWarning, module="<string>$")
+warnings.filterwarnings("ignore", message="With-statements now directly support multiple context managers")
+
+class BitBakeConfigParameters(cookerdata.ConfigParameters):
+
+    def parseCommandLine(self):
+        parser = optparse.OptionParser(
+            version = "BitBake Build Tool Core version %s, %%prog version %s" % (bb.__version__, __version__),
+            usage = """%prog [options] [recipename/target ...]
+
+    Executes the specified task (default is 'build') for a given set of target recipes (.bb files).
+    It is assumed there is a conf/bblayers.conf available in cwd or in BBPATH which
+    will provide the layer, BBFILES and other configuration information.""")
+
+        parser.add_option("-b", "--buildfile", help = "Execute tasks from a specific .bb recipe directly. WARNING: Does not handle any dependencies from other recipes.",
+                   action = "store", dest = "buildfile", default = None)
+
+        parser.add_option("-k", "--continue", help = "Continue as much as possible after an error. While the target that failed and anything depending on it cannot be built, as much as possible will be built before stopping.",
+                   action = "store_false", dest = "abort", default = True)
+
+        parser.add_option("-a", "--tryaltconfigs", help = "Continue with builds by trying to use alternative providers where possible.",
+                   action = "store_true", dest = "tryaltconfigs", default = False)
+
+        parser.add_option("-f", "--force", help = "Force the specified targets/task to run (invalidating any existing stamp file).",
+                   action = "store_true", dest = "force", default = False)
+
+        parser.add_option("-c", "--cmd", help = "Specify the task to execute. The exact options available depend on the metadata. Some examples might be 'compile' or 'populate_sysroot' or 'listtasks' may give a list of the tasks available.",
+                   action = "store", dest = "cmd")
+
+        parser.add_option("-C", "--clear-stamp", help = "Invalidate the stamp for the specified task such as 'compile' and then run the default task for the specified target(s).",
+                    action = "store", dest = "invalidate_stamp")
+
+        parser.add_option("-r", "--read", help = "Read the specified file before bitbake.conf.",
+                   action = "append", dest = "prefile", default = [])
+
+        parser.add_option("-R", "--postread", help = "Read the specified file after bitbake.conf.",
+                          action = "append", dest = "postfile", default = [])
+
+        parser.add_option("-v", "--verbose", help = "Output more log message data to the terminal.",
+                   action = "store_true", dest = "verbose", default = False)
+
+        parser.add_option("-D", "--debug", help = "Increase the debug level. You can specify this more than once.",
+                   action = "count", dest="debug", default = 0)
+
+        parser.add_option("-n", "--dry-run", help = "Don't execute, just go through the motions.",
+                   action = "store_true", dest = "dry_run", default = False)
+
+        parser.add_option("-S", "--dump-signatures", help = "Dump out the signature construction information, with no task execution. The SIGNATURE_HANDLER parameter is passed to the handler. Two common values are none and printdiff but the handler may define more/less. none means only dump the signature, printdiff means compare the dumped signature with the cached one.",
+                   action = "append", dest = "dump_signatures", default = [], metavar="SIGNATURE_HANDLER")
+
+        parser.add_option("-p", "--parse-only", help = "Quit after parsing the BB recipes.",
+                   action = "store_true", dest = "parse_only", default = False)
+
+        parser.add_option("-s", "--show-versions", help = "Show current and preferred versions of all recipes.",
+                   action = "store_true", dest = "show_versions", default = False)
+
+        parser.add_option("-e", "--environment", help = "Show the global or per-recipe environment complete with information about where variables were set/changed.",
+                   action = "store_true", dest = "show_environment", default = False)
+
+        parser.add_option("-g", "--graphviz", help = "Save dependency tree information for the specified targets in the dot syntax.",
+                    action = "store_true", dest = "dot_graph", default = False)
+
+        parser.add_option("-I", "--ignore-deps", help = """Assume these dependencies don't exist and are already provided (equivalent to ASSUME_PROVIDED). Useful to make dependency graphs more appealing""",
+                    action = "append", dest = "extra_assume_provided", default = [])
+
+        parser.add_option("-l", "--log-domains", help = """Show debug logging for the specified logging domains""",
+                    action = "append", dest = "debug_domains", default = [])
+
+        parser.add_option("-P", "--profile", help = "Profile the command and save reports.",
+                   action = "store_true", dest = "profile", default = False)
+
+        parser.add_option("-u", "--ui", help = "The user interface to use (e.g. knotty, hob, depexp).",
+                   action = "store", dest = "ui")
+
+        parser.add_option("-t", "--servertype", help = "Choose which server to use, process or xmlrpc.",
+                   action = "store", dest = "servertype")
+
+        parser.add_option("", "--token", help = "Specify the connection token to be used when connecting to a remote server.",
+                   action = "store", dest = "xmlrpctoken")
+
+        parser.add_option("", "--revisions-changed", help = "Set the exit code depending on whether upstream floating revisions have changed or not.",
+                   action = "store_true", dest = "revisions_changed", default = False)
+
+        parser.add_option("", "--server-only", help = "Run bitbake without a UI, only starting a server (cooker) process.",
+                   action = "store_true", dest = "server_only", default = False)
+
+        parser.add_option("-B", "--bind", help = "The name/address for the bitbake server to bind to.",
+                   action = "store", dest = "bind", default = False)
+
+        parser.add_option("", "--no-setscene", help = "Do not run any setscene tasks. sstate will be ignored and everything needed, built.",
+                   action = "store_true", dest = "nosetscene", default = False)
+
+        parser.add_option("", "--remote-server", help = "Connect to the specified server.",
+                   action = "store", dest = "remote_server", default = False)
+
+        parser.add_option("-m", "--kill-server", help = "Terminate the remote server.",
+                    action = "store_true", dest = "kill_server", default = False)
+
+        parser.add_option("", "--observe-only", help = "Connect to a server as an observing-only client.",
+                   action = "store_true", dest = "observe_only", default = False)
+
+        parser.add_option("", "--status-only", help = "Check the status of the remote bitbake server.",
+                   action = "store_true", dest = "status_only", default = False)
+
+        options, targets = parser.parse_args(sys.argv)
+
+        # some environmental variables set also configuration options
+        if "BBSERVER" in os.environ:
+            options.servertype = "xmlrpc"
+            options.remote_server = os.environ["BBSERVER"]
+
+        if "BBTOKEN" in os.environ:
+            options.xmlrpctoken = os.environ["BBTOKEN"]
+
+        # if BBSERVER says to autodetect, let's do that
+        if options.remote_server:
+            [host, port] = options.remote_server.split(":", 2)
+            port = int(port)
+            # use automatic port if port set to -1, means read it from
+            # the bitbake.lock file; this is a bit tricky, but we always expect
+            # to be in the base of the build directory if we need to have a
+            # chance to start the server later, anyway
+            if port == -1:
+                lock_location = "./bitbake.lock"
+                # we try to read the address at all times; if the server is not started,
+                # we'll try to start it after the first connect fails, below
+                try:
+                    lf = open(lock_location, 'r')
+                    remotedef = lf.readline()
+                    [host, port] = remotedef.split(":")
+                    port = int(port)
+                    lf.close()
+                    options.remote_server = remotedef
+                except Exception as e:
+                    sys.exit("Failed to read bitbake.lock (%s), invalid port" % str(e))
+
+        return options, targets[1:]
+
+
+def start_server(servermodule, configParams, configuration, features):
+    server = servermodule.BitBakeServer()
+    if configParams.bind:
+        (host, port) = configParams.bind.split(':')
+        server.initServer((host, int(port)))
+        configuration.interface = [ server.serverImpl.host, server.serverImpl.port ]
+    else:
+        server.initServer()
+        configuration.interface = []
+
+    try:
+        configuration.setServerRegIdleCallback(server.getServerIdleCB())
+
+        cooker = bb.cooker.BBCooker(configuration, features)
+
+        server.addcooker(cooker)
+        server.saveConnectionDetails()
+    except Exception as e:
+        exc_info = sys.exc_info()
+        while hasattr(server, "event_queue"):
+            try:
+                import queue
+            except ImportError:
+                import Queue as queue
+            try:
+                event = server.event_queue.get(block=False)
+            except (queue.Empty, IOError):
+                break
+            if isinstance(event, logging.LogRecord):
+                logger.handle(event)
+        raise exc_info[1], None, exc_info[2]
+    server.detach()
+    cooker.lock.close()
+    return server
+
+
+
+def main():
+
+    configParams = BitBakeConfigParameters()
+    configuration = cookerdata.CookerConfiguration()
+    configuration.setConfigParameters(configParams)
+
+    ui_module = get_ui(configParams)
+
+    # Server type can be xmlrpc or process currently, if nothing is specified,
+    # the default server is process
+    if configParams.servertype:
+        server_type = configParams.servertype
+    else:
+        server_type = 'process'
+
+    try:
+        module = __import__("bb.server", fromlist = [server_type])
+        servermodule = getattr(module, server_type)
+    except AttributeError:
+        sys.exit("FATAL: Invalid server type '%s' specified.\n"
+                 "Valid interfaces: xmlrpc, process [default]." % server_type)
+
+    if configParams.server_only:
+        if configParams.servertype != "xmlrpc":
+            sys.exit("FATAL: If '--server-only' is defined, we must set the servertype as 'xmlrpc'.\n")
+        if not configParams.bind:
+            sys.exit("FATAL: The '--server-only' option requires a name/address to bind to with the -B option.\n")
+        if configParams.remote_server:
+            sys.exit("FATAL: The '--server-only' option conflicts with %s.\n" % 
+                ("the BBSERVER environment variable" if "BBSERVER" in os.environ else "the '--remote-server' option" ))
+
+    if configParams.bind and configParams.servertype != "xmlrpc":
+        sys.exit("FATAL: If '-B' or '--bind' is defined, we must set the servertype as 'xmlrpc'.\n")
+
+    if configParams.remote_server and configParams.servertype != "xmlrpc":
+        sys.exit("FATAL: If '--remote-server' is defined, we must set the servertype as 'xmlrpc'.\n")
+
+    if configParams.observe_only and (not configParams.remote_server or configParams.bind):
+        sys.exit("FATAL: '--observe-only' can only be used by UI clients connecting to a server.\n")
+
+    if configParams.kill_server and not configParams.remote_server:
+        sys.exit("FATAL: '--kill-server' can only be used to terminate a remote server")
+
+    if "BBDEBUG" in os.environ:
+        level = int(os.environ["BBDEBUG"])
+        if level > configuration.debug:
+            configuration.debug = level
+
+    bb.msg.init_msgconfig(configParams.verbose, configuration.debug,
+                         configuration.debug_domains)
+
+    # Ensure logging messages get sent to the UI as events
+    handler = bb.event.LogHandler()
+    if not configParams.status_only:
+        # In status only mode there are no logs and no UI
+        logger.addHandler(handler)
+
+    # Clear away any spurious environment variables while we stoke up the cooker
+    cleanedvars = bb.utils.clean_environment()
+
+    featureset = []
+    if not configParams.server_only:
+        # Collect the feature set for the UI
+        featureset = getattr(ui_module, "featureSet", [])
+
+    if not configParams.remote_server:
+        # we start a server with a given configuration
+        server = start_server(servermodule, configParams, configuration, featureset)
+        bb.event.ui_queue = []
+    else:
+        # we start a stub server that is actually a XMLRPClient that connects to a real server
+        server = servermodule.BitBakeXMLRPCClient(configParams.observe_only, configParams.xmlrpctoken)
+        server.saveConnectionDetails(configParams.remote_server)
+
+
+    if not configParams.server_only:
+        try:
+            server_connection = server.establishConnection(featureset)
+        except Exception as e:
+            if configParams.kill_server:
+                sys.exit(0)
+            bb.fatal("Could not connect to server %s: %s" % (configParams.remote_server, str(e)))
+
+        # Restore the environment in case the UI needs it
+        for k in cleanedvars:
+            os.environ[k] = cleanedvars[k]
+
+        logger.removeHandler(handler)
+
+
+        if configParams.status_only:
+            server_connection.terminate()
+            sys.exit(0)
+
+        if configParams.kill_server:
+            server_connection.connection.terminateServer()
+            bb.event.ui_queue = []
+            sys.exit(0)
+
+        try:
+            return ui_module.main(server_connection.connection, server_connection.events, configParams)
+        finally:
+            bb.event.ui_queue = []
+            server_connection.terminate()
+    else:
+        print("server address: %s, server port: %s" % (server.serverImpl.host, server.serverImpl.port))
+        return 0
+
+    return 1
 
 if __name__ == "__main__":
-    if __version__ != bb.__version__:
-        sys.exit("Bitbake core version and program version mismatch!")
     try:
-        sys.exit(bitbake_main(BitBakeConfigParameters(sys.argv),
-                              cookerdata.CookerConfiguration()))
-    except BBMainException as err:
-        sys.exit(err)
+        ret = main()
     except bb.BBHandledException:
-        sys.exit(1)
+        ret = 1
     except Exception:
+        ret = 1
         import traceback
         traceback.print_exc()
-        sys.exit(1)
+    sys.exit(ret)
+

bitbake/bin/bitbake-diffsigs

@@ -1,9 +1,9 @@
-#!/usr/bin/env python3
+#!/usr/bin/env python
 
 # bitbake-diffsigs
 # BitBake task signature data comparison utility
 #
-# Copyright (C) 2012-2013, 2017 Intel Corporation
+# Copyright (C) 2012-2013 Intel Corporation
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 2 as
@@ -22,19 +22,28 @@ import os
 import sys
 import warnings
 import fnmatch
-import argparse
+import optparse
 import logging
-import pickle
 
 sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(sys.argv[0])), 'lib'))
 
 import bb.tinfoil
 import bb.siggen
-import bb.msg
 
-logger = bb.msg.logger_create('bitbake-diffsigs')
+def logger_create(name, output=sys.stderr):
+    logger = logging.getLogger(name)
+    console = logging.StreamHandler(output)
+    format = bb.msg.BBLogFormatter("%(levelname)s: %(message)s")
+    if output.isatty():
+        format.enable_color()
+    console.setFormatter(format)
+    logger.addHandler(console)
+    logger.setLevel(logging.INFO)
+    return logger
 
-def find_compare_task(bbhandler, pn, taskname, sig1=None, sig2=None, color=False):
+logger = logger_create('bitbake-diffsigs')
+
+def find_compare_task(bbhandler, pn, taskname):
     """ Find the most recent signature files for the specified PN/task and compare them """
 
     if not hasattr(bb.siggen, 'find_siginfo'):
@@ -44,119 +53,70 @@ def find_compare_task(bbhandler, pn, taskname, sig1=None, sig2=None, color=False
     if not taskname.startswith('do_'):
         taskname = 'do_%s' % taskname
 
-    if sig1 and sig2:
-        sigfiles = bb.siggen.find_siginfo(pn, taskname, [sig1, sig2], bbhandler.config_data)
-        if len(sigfiles) == 0:
-            logger.error('No sigdata files found matching %s %s matching either %s or %s' % (pn, taskname, sig1, sig2))
-            sys.exit(1)
-        elif not sig1 in sigfiles:
-            logger.error('No sigdata files found matching %s %s with signature %s' % (pn, taskname, sig1))
-            sys.exit(1)
-        elif not sig2 in sigfiles:
-            logger.error('No sigdata files found matching %s %s with signature %s' % (pn, taskname, sig2))
-            sys.exit(1)
-        latestfiles = [sigfiles[sig1], sigfiles[sig2]]
+    filedates = bb.siggen.find_siginfo(pn, taskname, None, bbhandler.config_data)
+    latestfiles = sorted(filedates.keys(), key=lambda f: filedates[f])[-2:]
+    if not latestfiles:
+        logger.error('No sigdata files found matching %s %s' % (pn, taskname))
+        sys.exit(1)
+    elif len(latestfiles) < 2:
+        logger.error('Only one matching sigdata file found for the specified task (%s %s)' % (pn, taskname))
+        sys.exit(1)
     else:
-        filedates = bb.siggen.find_siginfo(pn, taskname, None, bbhandler.config_data)
-        latestfiles = sorted(filedates.keys(), key=lambda f: filedates[f])[-3:]
-        if not latestfiles:
-            logger.error('No sigdata files found matching %s %s' % (pn, taskname))
-            sys.exit(1)
-        elif len(latestfiles) < 2:
-            logger.error('Only one matching sigdata file found for the specified task (%s %s)' % (pn, taskname))
-            sys.exit(1)
+        # Define recursion callback
+        def recursecb(key, hash1, hash2):
+            hashes = [hash1, hash2]
+            hashfiles = bb.siggen.find_siginfo(key, None, hashes, bbhandler.config_data)
 
-    # Define recursion callback
-    def recursecb(key, hash1, hash2):
-        hashes = [hash1, hash2]
-        hashfiles = bb.siggen.find_siginfo(key, None, hashes, bbhandler.config_data)
+            recout = []
+            if len(hashfiles) == 2:
+                out2 = bb.siggen.compare_sigfiles(hashfiles[hash1], hashfiles[hash2], recursecb)
+                recout.extend(list('  ' + l for l in out2))
+            else:
+                recout.append("Unable to find matching sigdata for %s with hashes %s or %s" % (key, hash1, hash2))
 
-        recout = []
-        if len(hashfiles) == 0:
-            recout.append("Unable to find matching sigdata for %s with hashes %s or %s" % (key, hash1, hash2))
-        elif not hash1 in hashfiles:
-            recout.append("Unable to find matching sigdata for %s with hash %s" % (key, hash1))
-        elif not hash2 in hashfiles:
-            recout.append("Unable to find matching sigdata for %s with hash %s" % (key, hash2))
-        else:
-            out2 = bb.siggen.compare_sigfiles(hashfiles[hash1], hashfiles[hash2], recursecb, color=color)
-            for change in out2:
-                for line in change.splitlines():
-                    recout.append('  ' + line)
+            return recout
 
-        return recout
-
-    # Recurse into signature comparison
-    logger.debug("Signature file (previous): %s" % latestfiles[-2])
-    logger.debug("Signature file (latest): %s" % latestfiles[-1])
-    output = bb.siggen.compare_sigfiles(latestfiles[-2], latestfiles[-1], recursecb, color=color)
-    if output:
-        print('\n'.join(output))
+        # Recurse into signature comparison
+        output = bb.siggen.compare_sigfiles(latestfiles[0], latestfiles[1], recursecb)
+        if output:
+            print '\n'.join(output)
     sys.exit(0)
 
 
 
-parser = argparse.ArgumentParser(
-    description="Compares siginfo/sigdata files written out by BitBake")
+parser = optparse.OptionParser(
+    description = "Compares siginfo/sigdata files written out by BitBake",
+    usage = """
+  %prog -t recipename taskname
+  %prog sigdatafile1 sigdatafile2
+  %prog sigdatafile1""")
 
-parser.add_argument('-d', '--debug',
-                    help='Enable debug output',
-                    action='store_true')
+parser.add_option("-t", "--task",
+        help = "find the signature data files for last two runs of the specified task and compare them",
+        action="store", dest="taskargs", nargs=2, metavar='recipename taskname')
 
-parser.add_argument('--color',
-        help='Colorize output (where %(metavar)s is %(choices)s)',
-        choices=['auto', 'always', 'never'], default='auto', metavar='color')
-
-parser.add_argument("-t", "--task",
-        help="find the signature data files for last two runs of the specified task and compare them",
-        action="store", dest="taskargs", nargs=2, metavar=('recipename', 'taskname'))
-
-parser.add_argument("-s", "--signature",
-        help="With -t/--task, specify the signatures to look for instead of taking the last two",
-        action="store", dest="sigargs", nargs=2, metavar=('fromsig', 'tosig'))
-
-parser.add_argument("sigdatafile1",
-        help="First signature file to compare (or signature file to dump, if second not specified). Not used when using -t/--task.",
-        action="store", nargs='?')
-
-parser.add_argument("sigdatafile2",
-        help="Second signature file to compare",
-        action="store", nargs='?')
-
-
-options = parser.parse_args()
-
-if options.debug:
-    logger.setLevel(logging.DEBUG)
-
-color = (options.color == 'always' or (options.color == 'auto' and sys.stdout.isatty()))
+options, args = parser.parse_args(sys.argv)
 
 if options.taskargs:
-    with bb.tinfoil.Tinfoil() as tinfoil:
-        tinfoil.prepare(config_only=True)
-        if options.sigargs:
-            find_compare_task(tinfoil, options.taskargs[0], options.taskargs[1], options.sigargs[0], options.sigargs[1], color=color)
-        else:
-            find_compare_task(tinfoil, options.taskargs[0], options.taskargs[1], color=color)
+    tinfoil = bb.tinfoil.Tinfoil()
+    tinfoil.prepare(config_only = True)
+    find_compare_task(tinfoil, options.taskargs[0], options.taskargs[1])
 else:
-    if options.sigargs:
-        logger.error('-s/--signature can only be used together with -t/--task')
-        sys.exit(1)
-    try:
-        if options.sigdatafile1 and options.sigdatafile2:
-            output = bb.siggen.compare_sigfiles(options.sigdatafile1, options.sigdatafile2, color=color)
-        elif options.sigdatafile1:
-            output = bb.siggen.dump_sigfile(options.sigdatafile1)
-        else:
-            logger.error('Must specify signature file(s) or -t/--task')
-            parser.print_help()
+    if len(args) == 1:
+        parser.print_help()
+    else:
+        import cPickle
+        try:
+            if len(args) == 2:
+                output = bb.siggen.dump_sigfile(sys.argv[1])
+            else:
+                output = bb.siggen.compare_sigfiles(sys.argv[1], sys.argv[2])
+        except IOError as e:
+            logger.error(str(e))
+            sys.exit(1)
+        except cPickle.UnpicklingError, EOFError:
+            logger.error('Invalid signature data - ensure you are specifying sigdata/siginfo files')
             sys.exit(1)
-    except IOError as e:
-        logger.error(str(e))
-        sys.exit(1)
-    except (pickle.UnpicklingError, EOFError):
-        logger.error('Invalid signature data - ensure you are specifying sigdata/siginfo files')
-        sys.exit(1)
 
-    if output:
-        print('\n'.join(output))
+        if output:
+            print '\n'.join(output)

bitbake/bin/bitbake-dumpsig

@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+#!/usr/bin/env python
 
 # bitbake-dumpsig
 # BitBake task signature dump utility
@@ -23,72 +23,43 @@ import sys
 import warnings
 import optparse
 import logging
-import pickle
 
 sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname(sys.argv[0])), 'lib'))
 
-import bb.tinfoil
 import bb.siggen
-import bb.msg
 
-logger = bb.msg.logger_create('bitbake-dumpsig')
+def logger_create(name, output=sys.stderr):
+    logger = logging.getLogger(name)
+    console = logging.StreamHandler(output)
+    format = bb.msg.BBLogFormatter("%(levelname)s: %(message)s")
+    if output.isatty():
+        format.enable_color()
+    console.setFormatter(format)
+    logger.addHandler(console)
+    logger.setLevel(logging.INFO)
+    return logger
 
-def find_siginfo_task(bbhandler, pn, taskname):
-    """ Find the most recent signature file for the specified PN/task """
-
-    if not hasattr(bb.siggen, 'find_siginfo'):
-        logger.error('Metadata does not support finding signature data files')
-        sys.exit(1)
-
-    if not taskname.startswith('do_'):
-        taskname = 'do_%s' % taskname
-
-    filedates = bb.siggen.find_siginfo(pn, taskname, None, bbhandler.config_data)
-    latestfiles = sorted(filedates.keys(), key=lambda f: filedates[f])[-1:]
-    if not latestfiles:
-        logger.error('No sigdata files found matching %s %s' % (pn, taskname))
-        sys.exit(1)
-
-    return latestfiles[0]
+logger = logger_create('bitbake-dumpsig')
 
 parser = optparse.OptionParser(
     description = "Dumps siginfo/sigdata files written out by BitBake",
     usage = """
-  %prog -t recipename taskname
   %prog sigdatafile""")
 
-parser.add_option("-D", "--debug",
-        help = "enable debug",
-        action = "store_true", dest="debug", default = False)
-
-parser.add_option("-t", "--task",
-        help = "find the signature data file for the specified task",
-        action="store", dest="taskargs", nargs=2, metavar='recipename taskname')
-
 options, args = parser.parse_args(sys.argv)
 
-if options.debug:
-    logger.setLevel(logging.DEBUG)
-
-if options.taskargs:
-    tinfoil = bb.tinfoil.Tinfoil()
-    tinfoil.prepare(config_only = True)
-    file = find_siginfo_task(tinfoil, options.taskargs[0], options.taskargs[1])
-    logger.debug("Signature file: %s" % file)
-elif len(args) == 1:
+if len(args) == 1:
     parser.print_help()
-    sys.exit(0)
 else:
-    file = args[1]
+    import cPickle
+    try:
+        output = bb.siggen.dump_sigfile(args[1])
+    except IOError as e:
+        logger.error(str(e))
+        sys.exit(1)
+    except cPickle.UnpicklingError, EOFError:
+        logger.error('Invalid signature data - ensure you are specifying a sigdata/siginfo file')
+        sys.exit(1)
 
-try:
-    output = bb.siggen.dump_sigfile(file)
-except IOError as e:
-    logger.error(str(e))
-    sys.exit(1)
-except (pickle.UnpicklingError, EOFError):
-    logger.error('Invalid signature data - ensure you are specifying a sigdata/siginfo file')
-    sys.exit(1)
-
-if output:
-    print('\n'.join(output))
+    if output:
+        print '\n'.join(output)

bitbake/bin/bitbake-layers

@@ -1,11 +1,11 @@
-#!/usr/bin/env python3
+#!/usr/bin/env python
 
 # This script has subcommands which operate against your bitbake layers, either
 # displaying useful information, or acting against them.
 # See the help output for details on available commands.
 
 # Copyright (C) 2011 Mentor Graphics Corporation
-# Copyright (C) 2011-2015 Intel Corporation
+# Copyright (C) 2012 Intel Corporation
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 2 as
@@ -20,90 +20,739 @@
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
+import cmd
 import logging
 import os
 import sys
-import argparse
-import signal
+import fnmatch
+from collections import defaultdict
+import re
 
 bindir = os.path.dirname(__file__)
 topdir = os.path.dirname(bindir)
 sys.path[0:0] = [os.path.join(topdir, 'lib')]
 
+import bb.cache
+import bb.cooker
+import bb.providers
+import bb.utils
 import bb.tinfoil
-import bb.msg
-
-logger = bb.msg.logger_create('bitbake-layers', sys.stdout)
-
-def main():
-    signal.signal(signal.SIGPIPE, signal.SIG_DFL)
-    parser = argparse.ArgumentParser(
-        description="BitBake layers utility",
-        epilog="Use %(prog)s <subcommand> --help to get help on a specific command",
-        add_help=False)
-    parser.add_argument('-d', '--debug', help='Enable debug output', action='store_true')
-    parser.add_argument('-q', '--quiet', help='Print only errors', action='store_true')
-    parser.add_argument('--color', choices=['auto', 'always', 'never'], default='auto', help='Colorize output (where %(metavar)s is %(choices)s)', metavar='COLOR')
-
-    global_args, unparsed_args = parser.parse_known_args()
-
-    # Help is added here rather than via add_help=True, as we don't want it to
-    # be handled by parse_known_args()
-    parser.add_argument('-h', '--help', action='help', default=argparse.SUPPRESS,
-                        help='show this help message and exit')
-    subparsers = parser.add_subparsers(title='subcommands', metavar='<subcommand>')
-    subparsers.required = True
-
-    if global_args.debug:
-        logger.setLevel(logging.DEBUG)
-    elif global_args.quiet:
-        logger.setLevel(logging.ERROR)
-
-    # Need to re-run logger_create with color argument
-    # (will be the same logger since it has the same name)
-    bb.msg.logger_create('bitbake-layers', output=sys.stdout, color=global_args.color)
-
-    plugins = []
-    tinfoil = bb.tinfoil.Tinfoil(tracking=True)
-    tinfoil.logger.setLevel(logger.getEffectiveLevel())
-    try:
-        tinfoil.prepare(True)
-        for path in ([topdir] +
-                    tinfoil.config_data.getVar('BBPATH').split(':')):
-            pluginpath = os.path.join(path, 'lib', 'bblayers')
-            bb.utils.load_plugins(logger, plugins, pluginpath)
-
-        registered = False
-        for plugin in plugins:
-            if hasattr(plugin, 'register_commands'):
-                registered = True
-                plugin.register_commands(subparsers)
-            if hasattr(plugin, 'tinfoil_init'):
-                plugin.tinfoil_init(tinfoil)
-
-        if not registered:
-            logger.error("No commands registered - missing plugins?")
-            sys.exit(1)
-
-        args = parser.parse_args(unparsed_args, namespace=global_args)
-
-        if getattr(args, 'parserecipes', False):
-            tinfoil.config_data.disableTracking()
-            tinfoil.parseRecipes()
-            tinfoil.config_data.enableTracking()
-
-        return args.func(args)
-    finally:
-        tinfoil.shutdown()
 
 
-if __name__ == "__main__":
-    try:
-        ret = main()
-    except bb.BBHandledException:
-        ret = 1
-    except Exception:
-        ret = 1
-        import traceback
-        traceback.print_exc()
-    sys.exit(ret)
+logger = logging.getLogger('BitBake')
+
+
+def main(args):
+    cmds = Commands()
+    if args:
+        # Allow user to specify e.g. show-layers instead of show_layers
+        args = [args[0].replace('-', '_')] + args[1:]
+        cmds.onecmd(' '.join(args))
+    else:
+        cmds.do_help('')
+    return cmds.returncode
+
+
+class Commands(cmd.Cmd):
+    def __init__(self):
+        self.bbhandler = None
+        self.returncode = 0
+        self.bblayers = []
+        cmd.Cmd.__init__(self)
+
+    def init_bbhandler(self, config_only = False):
+        if not self.bbhandler:
+            self.bbhandler = bb.tinfoil.Tinfoil()
+            self.bblayers = (self.bbhandler.config_data.getVar('BBLAYERS', True) or "").split()
+            self.bbhandler.prepare(config_only)
+
+    def default(self, line):
+        """Handle unrecognised commands"""
+        sys.stderr.write("Unrecognised command or option\n")
+        self.do_help('')
+
+    def do_help(self, topic):
+        """display general help or help on a specified command"""
+        if topic:
+            sys.stdout.write('%s: ' % topic)
+            cmd.Cmd.do_help(self, topic.replace('-', '_'))
+        else:
+            sys.stdout.write("usage: bitbake-layers <command> [arguments]\n\n")
+            sys.stdout.write("Available commands:\n")
+            procnames = list(set(self.get_names()))
+            for procname in procnames:
+                if procname[:3] == 'do_':
+                    sys.stdout.write("  %s\n" % procname[3:].replace('_', '-'))
+                    doc = getattr(self, procname).__doc__
+                    if doc:
+                        sys.stdout.write("    %s\n" % doc.splitlines()[0])
+
+    def do_show_layers(self, args):
+        """show current configured layers"""
+        self.init_bbhandler(config_only = True)
+        logger.plain("%s  %s  %s" % ("layer".ljust(20), "path".ljust(40), "priority"))
+        logger.plain('=' * 74)
+        for layerdir in self.bblayers:
+            layername = self.get_layer_name(layerdir)
+            layerpri = 0
+            for layer, _, regex, pri in self.bbhandler.cooker.recipecache.bbfile_config_priorities:
+                if regex.match(os.path.join(layerdir, 'test')):
+                    layerpri = pri
+                    break
+
+            logger.plain("%s  %s  %d" % (layername.ljust(20), layerdir.ljust(40), layerpri))
+
+
+    def version_str(self, pe, pv, pr = None):
+        verstr = "%s" % pv
+        if pr:
+            verstr = "%s-%s" % (verstr, pr)
+        if pe:
+            verstr = "%s:%s" % (pe, verstr)
+        return verstr
+
+
+    def do_show_overlayed(self, args):
+        """list overlayed recipes (where the same recipe exists in another layer)
+
+usage: show-overlayed [-f] [-s]
+
+Lists the names of overlayed recipes and the available versions in each
+layer, with the preferred version first. Note that skipped recipes that
+are overlayed will also be listed, with a " (skipped)" suffix.
+
+Options:
+  -f   instead of the default formatting, list filenames of higher priority
+       recipes with the ones they overlay indented underneath
+  -s   only list overlayed recipes where the version is the same
+"""
+        self.init_bbhandler()
+
+        show_filenames = False
+        show_same_ver_only = False
+        for arg in args.split():
+            if arg == '-f':
+                show_filenames = True
+            elif arg == '-s':
+                show_same_ver_only = True
+            else:
+                sys.stderr.write("show-overlayed: invalid option %s\n" % arg)
+                self.do_help('')
+                return
+
+        items_listed = self.list_recipes('Overlayed recipes', None, True, show_same_ver_only, show_filenames, True)
+
+        # Check for overlayed .bbclass files
+        classes = defaultdict(list)
+        for layerdir in self.bblayers:
+            classdir = os.path.join(layerdir, 'classes')
+            if os.path.exists(classdir):
+                for classfile in os.listdir(classdir):
+                    if os.path.splitext(classfile)[1] == '.bbclass':
+                        classes[classfile].append(classdir)
+
+        # Locating classes and other files is a bit more complicated than recipes -
+        # layer priority is not a factor; instead BitBake uses the first matching
+        # file in BBPATH, which is manipulated directly by each layer's
+        # conf/layer.conf in turn, thus the order of layers in bblayers.conf is a
+        # factor - however, each layer.conf is free to either prepend or append to
+        # BBPATH (or indeed do crazy stuff with it). Thus the order in BBPATH might
+        # not be exactly the order present in bblayers.conf either.
+        bbpath = str(self.bbhandler.config_data.getVar('BBPATH', True))
+        overlayed_class_found = False
+        for (classfile, classdirs) in classes.items():
+            if len(classdirs) > 1:
+                if not overlayed_class_found:
+                    logger.plain('=== Overlayed classes ===')
+                    overlayed_class_found = True
+
+                mainfile = bb.utils.which(bbpath, os.path.join('classes', classfile))
+                if show_filenames:
+                    logger.plain('%s' % mainfile)
+                else:
+                    # We effectively have to guess the layer here
+                    logger.plain('%s:' % classfile)
+                    mainlayername = '?'
+                    for layerdir in self.bblayers:
+                        classdir = os.path.join(layerdir, 'classes')
+                        if mainfile.startswith(classdir):
+                            mainlayername = self.get_layer_name(layerdir)
+                    logger.plain('  %s' % mainlayername)
+                for classdir in classdirs:
+                    fullpath = os.path.join(classdir, classfile)
+                    if fullpath != mainfile:
+                        if show_filenames:
+                            print('  %s' % fullpath)
+                        else:
+                            print('  %s' % self.get_layer_name(os.path.dirname(classdir)))
+
+        if overlayed_class_found:
+            items_listed = True;
+
+        if not items_listed:
+            logger.plain('No overlayed files found.')
+
+
+    def do_show_recipes(self, args):
+        """list available recipes, showing the layer they are provided by
+
+usage: show-recipes [-f] [-m] [pnspec]
+
+Lists the names of overlayed recipes and the available versions in each
+layer, with the preferred version first. Optionally you may specify
+pnspec to match a specified recipe name (supports wildcards). Note that
+skipped recipes will also be listed, with a " (skipped)" suffix.
+
+Options:
+  -f   instead of the default formatting, list filenames of higher priority
+       recipes with other available recipes indented underneath
+  -m   only list where multiple recipes (in the same layer or different
+       layers) exist for the same recipe name
+"""
+        self.init_bbhandler()
+
+        show_filenames = False
+        show_multi_provider_only = False
+        pnspec = None
+        title = 'Available recipes:'
+        for arg in args.split():
+            if arg == '-f':
+                show_filenames = True
+            elif arg == '-m':
+                show_multi_provider_only = True
+            elif not arg.startswith('-'):
+                pnspec = arg
+                title = 'Available recipes matching %s:' % pnspec
+            else:
+                sys.stderr.write("show-recipes: invalid option %s\n" % arg)
+                self.do_help('')
+                return
+        self.list_recipes(title, pnspec, False, False, show_filenames, show_multi_provider_only)
+
+
+    def list_recipes(self, title, pnspec, show_overlayed_only, show_same_ver_only, show_filenames, show_multi_provider_only):
+        pkg_pn = self.bbhandler.cooker.recipecache.pkg_pn
+        (latest_versions, preferred_versions) = bb.providers.findProviders(self.bbhandler.config_data, self.bbhandler.cooker.recipecache, pkg_pn)
+        allproviders = bb.providers.allProviders(self.bbhandler.cooker.recipecache)
+
+        # Ensure we list skipped recipes
+        # We are largely guessing about PN, PV and the preferred version here,
+        # but we have no choice since skipped recipes are not fully parsed
+        skiplist = self.bbhandler.cooker.skiplist.keys()
+        skiplist.sort( key=lambda fileitem: self.bbhandler.cooker.collection.calc_bbfile_priority(fileitem) )
+        skiplist.reverse()
+        for fn in skiplist:
+            recipe_parts = os.path.splitext(os.path.basename(fn))[0].split('_')
+            p = recipe_parts[0]
+            if len(recipe_parts) > 1:
+                ver = (None, recipe_parts[1], None)
+            else:
+                ver = (None, 'unknown', None)
+            allproviders[p].append((ver, fn))
+            if not p in pkg_pn:
+                pkg_pn[p] = 'dummy'
+                preferred_versions[p] = (ver, fn)
+
+        def print_item(f, pn, ver, layer, ispref):
+            if f in skiplist:
+                skipped = ' (skipped)'
+            else:
+                skipped = ''
+            if show_filenames:
+                if ispref:
+                    logger.plain("%s%s", f, skipped)
+                else:
+                    logger.plain("  %s%s", f, skipped)
+            else:
+                if ispref:
+                    logger.plain("%s:", pn)
+                logger.plain("  %s %s%s", layer.ljust(20), ver, skipped)
+
+        preffiles = []
+        items_listed = False
+        for p in sorted(pkg_pn):
+            if pnspec:
+                if not fnmatch.fnmatch(p, pnspec):
+                    continue
+
+            if len(allproviders[p]) > 1 or not show_multi_provider_only:
+                pref = preferred_versions[p]
+                preffile = bb.cache.Cache.virtualfn2realfn(pref[1])[0]
+                if preffile not in preffiles:
+                    preflayer = self.get_file_layer(preffile)
+                    multilayer = False
+                    same_ver = True
+                    provs = []
+                    for prov in allproviders[p]:
+                        provfile = bb.cache.Cache.virtualfn2realfn(prov[1])[0]
+                        provlayer = self.get_file_layer(provfile)
+                        provs.append((provfile, provlayer, prov[0]))
+                        if provlayer != preflayer:
+                            multilayer = True
+                        if prov[0] != pref[0]:
+                            same_ver = False
+
+                    if (multilayer or not show_overlayed_only) and (same_ver or not show_same_ver_only):
+                        if not items_listed:
+                            logger.plain('=== %s ===' % title)
+                            items_listed = True
+                        print_item(preffile, p, self.version_str(pref[0][0], pref[0][1]), preflayer, True)
+                        for (provfile, provlayer, provver) in provs:
+                            if provfile != preffile:
+                                print_item(provfile, p, self.version_str(provver[0], provver[1]), provlayer, False)
+                        # Ensure we don't show two entries for BBCLASSEXTENDed recipes
+                        preffiles.append(preffile)
+
+        return items_listed
+
+
+    def do_flatten(self, args):
+        """flattens layer configuration into a separate output directory.
+
+usage: flatten [layer1 layer2 [layer3]...] <outputdir>
+
+Takes the specified layers (or all layers in the current layer
+configuration if none are specified) and builds a "flattened" directory
+containing the contents of all layers, with any overlayed recipes removed
+and bbappends appended to the corresponding recipes. Note that some manual
+cleanup may still be necessary afterwards, in particular:
+
+* where non-recipe files (such as patches) are overwritten (the flatten
+  command will show a warning for these)
+* where anything beyond the normal layer setup has been added to
+  layer.conf (only the lowest priority number layer's layer.conf is used)
+* overridden/appended items from bbappends will need to be tidied up
+* when the flattened layers do not have the same directory structure (the
+  flatten command should show a warning when this will cause a problem)
+
+Warning: if you flatten several layers where another layer is intended to
+be used "inbetween" them (in layer priority order) such that recipes /
+bbappends in the layers interact, and then attempt to use the new output
+layer together with that other layer, you may no longer get the same
+build results (as the layer priority order has effectively changed).
+"""
+        arglist = args.split()
+        if len(arglist) < 1:
+            logger.error('Please specify an output directory')
+            self.do_help('flatten')
+            return
+
+        if len(arglist) == 2:
+            logger.error('If you specify layers to flatten you must specify at least two')
+            self.do_help('flatten')
+            return
+
+        outputdir = arglist[-1]
+        if os.path.exists(outputdir) and os.listdir(outputdir):
+            logger.error('Directory %s exists and is non-empty, please clear it out first' % outputdir)
+            return
+
+        self.init_bbhandler()
+        layers = self.bblayers
+        if len(arglist) > 2:
+            layernames = arglist[:-1]
+            found_layernames = []
+            found_layerdirs = []
+            for layerdir in layers:
+                layername = self.get_layer_name(layerdir)
+                if layername in layernames:
+                    found_layerdirs.append(layerdir)
+                    found_layernames.append(layername)
+
+            for layername in layernames:
+                if not layername in found_layernames:
+                    logger.error('Unable to find layer %s in current configuration, please run "%s show-layers" to list configured layers' % (layername, os.path.basename(sys.argv[0])))
+                    return
+            layers = found_layerdirs
+        else:
+            layernames = []
+
+        # Ensure a specified path matches our list of layers
+        def layer_path_match(path):
+            for layerdir in layers:
+                if path.startswith(os.path.join(layerdir, '')):
+                    return layerdir
+            return None
+
+        appended_recipes = []
+        for layer in layers:
+            overlayed = []
+            for f in self.bbhandler.cooker.collection.overlayed.iterkeys():
+                for of in self.bbhandler.cooker.collection.overlayed[f]:
+                    if of.startswith(layer):
+                        overlayed.append(of)
+
+            logger.plain('Copying files from %s...' % layer )
+            for root, dirs, files in os.walk(layer):
+                for f1 in files:
+                    f1full = os.sep.join([root, f1])
+                    if f1full in overlayed:
+                        logger.plain('  Skipping overlayed file %s' % f1full )
+                    else:
+                        ext = os.path.splitext(f1)[1]
+                        if ext != '.bbappend':
+                            fdest = f1full[len(layer):]
+                            fdest = os.path.normpath(os.sep.join([outputdir,fdest]))
+                            bb.utils.mkdirhier(os.path.dirname(fdest))
+                            if os.path.exists(fdest):
+                                if f1 == 'layer.conf' and root.endswith('/conf'):
+                                    logger.plain('  Skipping layer config file %s' % f1full )
+                                    continue
+                                else:
+                                    logger.warn('Overwriting file %s', fdest)
+                            bb.utils.copyfile(f1full, fdest)
+                            if ext == '.bb':
+                                if f1 in self.bbhandler.cooker.collection.appendlist:
+                                    appends = self.bbhandler.cooker.collection.appendlist[f1]
+                                    if appends:
+                                        logger.plain('  Applying appends to %s' % fdest )
+                                        for appendname in appends:
+                                            if layer_path_match(appendname):
+                                                self.apply_append(appendname, fdest)
+                                    appended_recipes.append(f1)
+
+        # Take care of when some layers are excluded and yet we have included bbappends for those recipes
+        for recipename in self.bbhandler.cooker.collection.appendlist.iterkeys():
+            if recipename not in appended_recipes:
+                appends = self.bbhandler.cooker.collection.appendlist[recipename]
+                first_append = None
+                for appendname in appends:
+                    layer = layer_path_match(appendname)
+                    if layer:
+                        if first_append:
+                            self.apply_append(appendname, first_append)
+                        else:
+                            fdest = appendname[len(layer):]
+                            fdest = os.path.normpath(os.sep.join([outputdir,fdest]))
+                            bb.utils.mkdirhier(os.path.dirname(fdest))
+                            bb.utils.copyfile(appendname, fdest)
+                            first_append = fdest
+
+        # Get the regex for the first layer in our list (which is where the conf/layer.conf file will
+        # have come from)
+        first_regex = None
+        layerdir = layers[0]
+        for layername, pattern, regex, _ in self.bbhandler.cooker.recipecache.bbfile_config_priorities:
+            if regex.match(os.path.join(layerdir, 'test')):
+                first_regex = regex
+                break
+
+        if first_regex:
+            # Find the BBFILES entries that match (which will have come from this conf/layer.conf file)
+            bbfiles = str(self.bbhandler.config_data.getVar('BBFILES', True)).split()
+            bbfiles_layer = []
+            for item in bbfiles:
+                if first_regex.match(item):
+                    newpath = os.path.join(outputdir, item[len(layerdir)+1:])
+                    bbfiles_layer.append(newpath)
+
+            if bbfiles_layer:
+                # Check that all important layer files match BBFILES
+                for root, dirs, files in os.walk(outputdir):
+                    for f1 in files:
+                        ext = os.path.splitext(f1)[1]
+                        if ext in ['.bb', '.bbappend']:
+                            f1full = os.sep.join([root, f1])
+                            entry_found = False
+                            for item in bbfiles_layer:
+                                if fnmatch.fnmatch(f1full, item):
+                                    entry_found = True
+                                    break
+                            if not entry_found:
+                                logger.warning("File %s does not match the flattened layer's BBFILES setting, you may need to edit conf/layer.conf or move the file elsewhere" % f1full)
+
+    def get_file_layer(self, filename):
+        for layer, _, regex, _ in self.bbhandler.cooker.recipecache.bbfile_config_priorities:
+            if regex.match(filename):
+                for layerdir in self.bblayers:
+                    if regex.match(os.path.join(layerdir, 'test')) and re.match(layerdir, filename):
+                        return self.get_layer_name(layerdir)
+        return "?"
+
+    def get_file_layerdir(self, filename):
+        for layer, _, regex, _ in self.bbhandler.cooker.recipecache.bbfile_config_priorities:
+            if regex.match(filename):
+                for layerdir in self.bblayers:
+                    if regex.match(os.path.join(layerdir, 'test')) and re.match(layerdir, filename):
+                        return layerdir
+        return "?"
+
+    def remove_layer_prefix(self, f):
+        """Remove the layer_dir prefix, e.g., f = /path/to/layer_dir/foo/blah, the
+           return value will be: layer_dir/foo/blah"""
+        f_layerdir = self.get_file_layerdir(f)
+        prefix = os.path.join(os.path.dirname(f_layerdir), '')
+        return f[len(prefix):] if f.startswith(prefix) else f
+
+    def get_layer_name(self, layerdir):
+        return os.path.basename(layerdir.rstrip(os.sep))
+
+    def apply_append(self, appendname, recipename):
+        appendfile = open(appendname, 'r')
+        recipefile = open(recipename, 'a')
+        recipefile.write('\n')
+        recipefile.write('##### bbappended from %s #####\n' % self.get_file_layer(appendname))
+        recipefile.writelines(appendfile.readlines())
+        recipefile.close()
+        appendfile.close()
+
+    def do_show_appends(self, args):
+        """list bbappend files and recipe files they apply to
+
+usage: show-appends
+
+Recipes are listed with the bbappends that apply to them as subitems.
+"""
+        self.init_bbhandler()
+        if not self.bbhandler.cooker.collection.appendlist:
+            logger.plain('No append files found')
+            return
+
+        logger.plain('=== Appended recipes ===')
+
+        pnlist = list(self.bbhandler.cooker_data.pkg_pn.keys())
+        pnlist.sort()
+        for pn in pnlist:
+            self.show_appends_for_pn(pn)
+
+        self.show_appends_for_skipped()
+
+    def show_appends_for_pn(self, pn):
+        filenames = self.bbhandler.cooker_data.pkg_pn[pn]
+
+        best = bb.providers.findBestProvider(pn,
+                                             self.bbhandler.config_data,
+                                             self.bbhandler.cooker_data,
+                                             self.bbhandler.cooker_data.pkg_pn)
+        best_filename = os.path.basename(best[3])
+
+        self.show_appends_output(filenames, best_filename)
+
+    def show_appends_for_skipped(self):
+        filenames = [os.path.basename(f)
+                    for f in self.bbhandler.cooker.skiplist.iterkeys()]
+        self.show_appends_output(filenames, None, " (skipped)")
+
+    def show_appends_output(self, filenames, best_filename, name_suffix = ''):
+        appended, missing = self.get_appends_for_files(filenames)
+        if appended:
+            for basename, appends in appended:
+                logger.plain('%s%s:', basename, name_suffix)
+                for append in appends:
+                    logger.plain('  %s', append)
+
+            if best_filename:
+                if best_filename in missing:
+                    logger.warn('%s: missing append for preferred version',
+                                best_filename)
+                    self.returncode |= 1
+
+
+    def get_appends_for_files(self, filenames):
+        appended, notappended = [], []
+        for filename in filenames:
+            _, cls = bb.cache.Cache.virtualfn2realfn(filename)
+            if cls:
+                continue
+
+            basename = os.path.basename(filename)
+            appends = self.bbhandler.cooker.collection.get_file_appends(basename)
+            if appends:
+                appended.append((basename, list(appends)))
+            else:
+                notappended.append(basename)
+        return appended, notappended
+
+    def do_show_cross_depends(self, args):
+        """figure out the dependency between recipes that crosses a layer boundary.
+
+usage: show-cross-depends [-f] [-i layer1[,layer2[,layer3...]]]
+
+Figure out the dependency between recipes that crosses a layer boundary.
+
+Options:
+  -f   show full file path
+  -i   ignore dependencies on items in the specified layer(s)
+
+NOTE:
+The .bbappend file can impact the dependency.
+"""
+        import optparse
+
+        parser = optparse.OptionParser(usage="show-cross-depends [-f] [-i layer1[,layer2[,layer3...]]]")
+        parser.add_option("-f", "",
+                action="store_true", dest="show_filenames")
+        parser.add_option("-i", "",
+                action="store", dest="ignore_layers", default="")
+
+        options, args = parser.parse_args(sys.argv)
+        ignore_layers = options.ignore_layers.split(',')
+
+        self.init_bbhandler()
+
+        pkg_fn = self.bbhandler.cooker_data.pkg_fn
+        bbpath = str(self.bbhandler.config_data.getVar('BBPATH', True))
+        self.require_re = re.compile(r"require\s+(.+)")
+        self.include_re = re.compile(r"include\s+(.+)")
+        self.inherit_re = re.compile(r"inherit\s+(.+)")
+
+        global_inherit = (self.bbhandler.config_data.getVar('INHERIT', True) or "").split()
+
+        # The bb's DEPENDS and RDEPENDS
+        for f in pkg_fn:
+            f = bb.cache.Cache.virtualfn2realfn(f)[0]
+            # Get the layername that the file is in
+            layername = self.get_file_layer(f)
+
+            # The DEPENDS
+            deps = self.bbhandler.cooker_data.deps[f]
+            for pn in deps:
+                if pn in self.bbhandler.cooker_data.pkg_pn:
+                    best = bb.providers.findBestProvider(pn,
+                            self.bbhandler.config_data,
+                            self.bbhandler.cooker_data,
+                            self.bbhandler.cooker_data.pkg_pn)
+                    self.check_cross_depends("DEPENDS", layername, f, best[3], options.show_filenames, ignore_layers)
+
+            # The RDPENDS
+            all_rdeps = self.bbhandler.cooker_data.rundeps[f].values()
+            # Remove the duplicated or null one.
+            sorted_rdeps = {}
+            # The all_rdeps is the list in list, so we need two for loops
+            for k1 in all_rdeps:
+                for k2 in k1:
+                    sorted_rdeps[k2] = 1
+            all_rdeps = sorted_rdeps.keys()
+            for rdep in all_rdeps:
+                all_p = bb.providers.getRuntimeProviders(self.bbhandler.cooker_data, rdep)
+                if all_p:
+                    if f in all_p:
+                        # The recipe provides this one itself, ignore
+                        continue
+                    best = bb.providers.filterProvidersRunTime(all_p, rdep,
+                                    self.bbhandler.config_data,
+                                    self.bbhandler.cooker_data)[0][0]
+                    self.check_cross_depends("RDEPENDS", layername, f, best, options.show_filenames, ignore_layers)
+
+            # The RRECOMMENDS
+            all_rrecs = self.bbhandler.cooker_data.runrecs[f].values()
+            # Remove the duplicated or null one.
+            sorted_rrecs = {}
+            # The all_rrecs is the list in list, so we need two for loops
+            for k1 in all_rrecs:
+                for k2 in k1:
+                    sorted_rrecs[k2] = 1
+            all_rrecs = sorted_rrecs.keys()
+            for rrec in all_rrecs:
+                all_p = bb.providers.getRuntimeProviders(self.bbhandler.cooker_data, rrec)
+                if all_p:
+                    if f in all_p:
+                        # The recipe provides this one itself, ignore
+                        continue
+                    best = bb.providers.filterProvidersRunTime(all_p, rrec,
+                                    self.bbhandler.config_data,
+                                    self.bbhandler.cooker_data)[0][0]
+                    self.check_cross_depends("RRECOMMENDS", layername, f, best, options.show_filenames, ignore_layers)
+
+            # The inherit class
+            cls_re = re.compile('classes/')
+            if f in self.bbhandler.cooker_data.inherits:
+                inherits = self.bbhandler.cooker_data.inherits[f]
+                for cls in inherits:
+                    # The inherits' format is [classes/cls, /path/to/classes/cls]
+                    # ignore the classes/cls.
+                    if not cls_re.match(cls):
+                        classname = os.path.splitext(os.path.basename(cls))[0]
+                        if classname in global_inherit:
+                            continue
+                        inherit_layername = self.get_file_layer(cls)
+                        if inherit_layername != layername and not inherit_layername in ignore_layers:
+                            if not options.show_filenames:
+                                f_short = self.remove_layer_prefix(f)
+                                cls = self.remove_layer_prefix(cls)
+                            else:
+                                f_short = f
+                            logger.plain("%s inherits %s" % (f_short, cls))
+
+            # The 'require/include xxx' in the bb file
+            pv_re = re.compile(r"\${PV}")
+            fnfile = open(f, 'r')
+            line = fnfile.readline()
+            while line:
+                m, keyword = self.match_require_include(line)
+                # Found the 'require/include xxxx'
+                if m:
+                    needed_file = m.group(1)
+                    # Replace the ${PV} with the real PV
+                    if pv_re.search(needed_file) and f in self.bbhandler.cooker_data.pkg_pepvpr:
+                        pv = self.bbhandler.cooker_data.pkg_pepvpr[f][1]
+                        needed_file = re.sub(r"\${PV}", pv, needed_file)
+                    self.print_cross_files(bbpath, keyword, layername, f, needed_file, options.show_filenames, ignore_layers)
+                line = fnfile.readline()
+            fnfile.close()
+
+        # The "require/include xxx" in conf/machine/*.conf, .inc and .bbclass
+        conf_re = re.compile(".*/conf/machine/[^\/]*\.conf$")
+        inc_re = re.compile(".*\.inc$")
+        # The "inherit xxx" in .bbclass
+        bbclass_re = re.compile(".*\.bbclass$")
+        for layerdir in self.bblayers:
+            layername = self.get_layer_name(layerdir)
+            for dirpath, dirnames, filenames in os.walk(layerdir):
+                for name in filenames:
+                    f = os.path.join(dirpath, name)
+                    s = conf_re.match(f) or inc_re.match(f) or bbclass_re.match(f)
+                    if s:
+                        ffile = open(f, 'r')
+                        line = ffile.readline()
+                        while line:
+                            m, keyword = self.match_require_include(line)
+                            # Only bbclass has the "inherit xxx" here.
+                            bbclass=""
+                            if not m and f.endswith(".bbclass"):
+                                m, keyword = self.match_inherit(line)
+                                bbclass=".bbclass"
+                            # Find a 'require/include xxxx'
+                            if m:
+                                self.print_cross_files(bbpath, keyword, layername, f, m.group(1) + bbclass, options.show_filenames, ignore_layers)
+                            line = ffile.readline()
+                        ffile.close()
+
+    def print_cross_files(self, bbpath, keyword, layername, f, needed_filename, show_filenames, ignore_layers):
+        """Print the depends that crosses a layer boundary"""
+        needed_file = bb.utils.which(bbpath, needed_filename)
+        if needed_file:
+            # Which layer is this file from
+            needed_layername = self.get_file_layer(needed_file)
+            if needed_layername != layername and not needed_layername in ignore_layers:
+                if not show_filenames:
+                    f = self.remove_layer_prefix(f)
+                    needed_file = self.remove_layer_prefix(needed_file)
+                logger.plain("%s %s %s" %(f, keyword, needed_file))
+
+    def match_inherit(self, line):
+        """Match the inherit xxx line"""
+        return (self.inherit_re.match(line), "inherits")
+
+    def match_require_include(self, line):
+        """Match the require/include xxx line"""
+        m = self.require_re.match(line)
+        keyword = "requires"
+        if not m:
+            m = self.include_re.match(line)
+            keyword = "includes"
+        return (m, keyword)
+
+    def check_cross_depends(self, keyword, layername, f, needed_file, show_filenames, ignore_layers):
+        """Print the DEPENDS/RDEPENDS file that crosses a layer boundary"""
+        best_realfn = bb.cache.Cache.virtualfn2realfn(needed_file)[0]
+        needed_layername = self.get_file_layer(best_realfn)
+        if needed_layername != layername and not needed_layername in ignore_layers:
+            if not show_filenames:
+                f = self.remove_layer_prefix(f)
+                best_realfn = self.remove_layer_prefix(best_realfn)
+
+            logger.plain("%s %s %s" % (f, keyword, best_realfn))
+
+if __name__ == '__main__':
+    sys.exit(main(sys.argv[1:]) or 0)

bitbake/bin/bitbake-prserv

@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+#!/usr/bin/env python
 import os
 import sys,logging
 import optparse
@@ -50,6 +50,6 @@ if __name__ == "__main__":
     except Exception:
         ret = 1
         import traceback
-        traceback.print_exc()
+        traceback.print_exc(5)
     sys.exit(ret)
 

bitbake/bin/bitbake-selftest

@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+#!/usr/bin/env python
 #
 # Copyright (C) 2012 Richard Purdie
 #
@@ -25,48 +25,25 @@ try:
 except RuntimeError as exc:
     sys.exit(str(exc))
 
-tests = ["bb.tests.codeparser",
-         "bb.tests.cow",
-         "bb.tests.data",
-         "bb.tests.fetch",
-         "bb.tests.parse",
-         "bb.tests.utils"]
+def usage():
+    print('usage: %s [testname1 [testname2]...]' % os.path.basename(sys.argv[0]))
+
+if len(sys.argv) > 1:
+    if '--help' in sys.argv[1:]:
+        usage()
+        sys.exit(0)
+
+    tests = sys.argv[1:]
+else:
+    tests = ["bb.tests.codeparser",
+             "bb.tests.cow",
+             "bb.tests.data",
+             "bb.tests.fetch",
+             "bb.tests.utils"]
 
 for t in tests:
     t = '.'.join(t.split('.')[:3])
     __import__(t)
 
+unittest.main(argv=["bitbake-selftest"] + tests)
 
-# Set-up logging
-class StdoutStreamHandler(logging.StreamHandler):
-    """Special handler so that unittest is able to capture stdout"""
-    def __init__(self):
-        # Override __init__() because we don't want to set self.stream here
-        logging.Handler.__init__(self)
-
-    @property
-    def stream(self):
-        # We want to dynamically write wherever sys.stdout is pointing to
-        return sys.stdout
-
-
-handler = StdoutStreamHandler()
-bb.logger.addHandler(handler)
-bb.logger.setLevel(logging.DEBUG)
-
-
-ENV_HELP = """\
-Environment variables:
-  BB_SKIP_NETTESTS      set to 'yes' in order to skip tests using network
-                        connection
-  BB_TMPDIR_NOCLEAN     set to 'yes' to preserve test tmp directories
-"""
-
-class main(unittest.main):
-    def _print_help(self, *args, **kwargs):
-        super(main, self)._print_help(*args, **kwargs)
-        print(ENV_HELP)
-
-
-if __name__ == '__main__':
-        main(defaultTest=tests, buffer=True)

bitbake/bin/bitbake-worker

@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+#!/usr/bin/env python
 
 import os
 import sys
@@ -10,14 +10,6 @@ import bb
 import select
 import errno
 import signal
-import pickle
-import traceback
-import queue
-from multiprocessing import Lock
-from threading import Thread
-
-if sys.getfilesystemencoding() != "utf-8":
-    sys.exit("Please use a locale setting which supports utf-8.\nPython can't change the filesystem locale after loading so we need a utf-8 when python starts or things won't work.")
 
 # Users shouldn't be running this code directly
 if len(sys.argv) != 2 or not sys.argv[1].startswith("decafbad"):
@@ -25,33 +17,24 @@ if len(sys.argv) != 2 or not sys.argv[1].startswith("decafbad"):
     sys.exit(1)
 
 profiling = False
-if sys.argv[1].startswith("decafbadbad"):
+if sys.argv[1] == "decafbadbad":
     profiling = True
     try:
         import cProfile as profile
     except:
         import profile
 
-# Unbuffer stdout to avoid log truncation in the event
-# of an unorderly exit as well as to provide timely
-# updates to log files for use with tail
-try:
-    if sys.stdout.name == '<stdout>':
-        import fcntl
-        fl = fcntl.fcntl(sys.stdout.fileno(), fcntl.F_GETFL)
-        fl |= os.O_SYNC 
-        fcntl.fcntl(sys.stdout.fileno(), fcntl.F_SETFL, fl)
-        #sys.stdout = os.fdopen(sys.stdout.fileno(), 'w', 0)
-except:
-    pass
-
 logger = logging.getLogger("BitBake")
 
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+    bb.msg.note(1, bb.msg.domain.Cache, "Importing cPickle failed. Falling back to a very slow implementation.")
+
+
 worker_pipe = sys.stdout.fileno()
 bb.utils.nonblockingfd(worker_pipe)
-# Need to guard against multiprocessing being used in child processes
-# and multiple processes trying to write to the parent at the same time
-worker_pipe_lock = None
 
 handler = bb.event.LogHandler()
 logger.addHandler(handler)
@@ -66,61 +49,36 @@ if 0:
     consolelog.setFormatter(conlogformat)
     logger.addHandler(consolelog)
 
-worker_queue = queue.Queue()
+worker_queue = ""
 
 def worker_fire(event, d):
-    data = b"<event>" + pickle.dumps(event) + b"</event>"
+    data = "<event>" + pickle.dumps(event) + "</event>"
     worker_fire_prepickled(data)
 
 def worker_fire_prepickled(event):
     global worker_queue
 
-    worker_queue.put(event)
+    worker_queue = worker_queue + event
+    worker_flush()
 
-#
-# We can end up with write contention with the cooker, it can be trying to send commands
-# and we can be trying to send event data back. Therefore use a separate thread for writing 
-# back data to cooker.
-#
-worker_thread_exit = False
+def worker_flush():
+    global worker_queue, worker_pipe
 
-def worker_flush(worker_queue):
-    worker_queue_int = b""
-    global worker_pipe, worker_thread_exit
+    if not worker_queue:
+        return
 
-    while True:
-        try:
-            worker_queue_int = worker_queue_int + worker_queue.get(True, 1)
-        except queue.Empty:
-            pass
-        while (worker_queue_int or not worker_queue.empty()):
-            try:
-                (_, ready, _) = select.select([], [worker_pipe], [], 1)
-                if not worker_queue.empty():
-                    worker_queue_int = worker_queue_int + worker_queue.get()
-                written = os.write(worker_pipe, worker_queue_int)
-                worker_queue_int = worker_queue_int[written:]
-            except (IOError, OSError) as e:
-                if e.errno != errno.EAGAIN and e.errno != errno.EPIPE:
-                    raise
-        if worker_thread_exit and worker_queue.empty() and not worker_queue_int:
-            return
-
-worker_thread = Thread(target=worker_flush, args=(worker_queue,))
-worker_thread.start()
+    try:
+        written = os.write(worker_pipe, worker_queue)
+        worker_queue = worker_queue[written:]
+    except (IOError, OSError) as e:
+        if e.errno != errno.EAGAIN:
+            raise
 
 def worker_child_fire(event, d):
     global worker_pipe
-    global worker_pipe_lock
 
-    data = b"<event>" + pickle.dumps(event) + b"</event>"
-    try:
-        worker_pipe_lock.acquire()
-        worker_pipe.write(data)
-        worker_pipe_lock.release()
-    except IOError:
-        sigterm_handler(None, None)
-        raise
+    data = "<event>" + pickle.dumps(event) + "</event>"
+    worker_pipe.write(data)
 
 bb.event.worker_fire = worker_fire
 
@@ -136,7 +94,7 @@ def sigterm_handler(signum, frame):
     os.killpg(0, signal.SIGTERM)
     sys.exit()
 
-def fork_off_task(cfg, data, databuilder, workerdata, fn, task, taskname, appends, taskdepdata, extraconfigdata, quieterrors=False, dry_run_exec=False):
+def fork_off_task(cfg, data, workerdata, fn, task, taskname, appends, taskdepdata, quieterrors=False):
     # We need to setup the environment BEFORE the fork, since
     # a fork() or exec*() activates PSEUDO...
 
@@ -152,10 +110,8 @@ def fork_off_task(cfg, data, databuilder, workerdata, fn, task, taskname, append
         except TypeError:
              umask = taskdep['umask'][taskname]
 
-    dry_run = cfg.dry_run or dry_run_exec
-
     # We can't use the fakeroot environment in a dry run as it possibly hasn't been built
-    if 'fakeroot' in taskdep and taskname in taskdep['fakeroot'] and not dry_run:
+    if 'fakeroot' in taskdep and taskname in taskdep['fakeroot'] and not cfg.dry_run:
         envvars = (workerdata["fakerootenv"][fn] or "").split()
         for key, value in (var.split('=') for var in envvars):
             envbackup[key] = os.environ.get(key)
@@ -183,26 +139,22 @@ def fork_off_task(cfg, data, databuilder, workerdata, fn, task, taskname, append
         pipeout = os.fdopen(pipeout, 'wb', 0)
         pid = os.fork()
     except OSError as e:
-        logger.critical("fork failed: %d (%s)" % (e.errno, e.strerror))
-        sys.exit(1)
+        bb.msg.fatal("RunQueue", "fork failed: %d (%s)" % (e.errno, e.strerror))
 
     if pid == 0:
         def child():
             global worker_pipe
-            global worker_pipe_lock
             pipein.close()
 
             signal.signal(signal.SIGTERM, sigterm_handler)
             # Let SIGHUP exit as SIGTERM
             signal.signal(signal.SIGHUP, sigterm_handler)
-            bb.utils.signal_on_parent_exit("SIGTERM")
 
             # Save out the PID so that the event can include it the
             # events
             bb.event.worker_pid = os.getpid()
             bb.event.worker_fire = worker_child_fire
             worker_pipe = pipeout
-            worker_pipe_lock = Lock()
 
             # Make the child the process group leader and ensure no
             # child process will be controlled by the current terminal
@@ -216,58 +168,37 @@ def fork_off_task(cfg, data, databuilder, workerdata, fn, task, taskname, append
             if umask:
                 os.umask(umask)
 
+            data.setVar("BB_WORKERCONTEXT", "1")
+            data.setVar("BB_TASKDEPDATA", taskdepdata)
+            data.setVar("BUILDNAME", workerdata["buildname"])
+            data.setVar("DATE", workerdata["date"])
+            data.setVar("TIME", workerdata["time"])
+            bb.parse.siggen.set_taskdata(workerdata["sigdata"])
+            ret = 0
             try:
-                bb_cache = bb.cache.NoCache(databuilder)
-                (realfn, virtual, mc) = bb.cache.virtualfn2realfn(fn)
-                the_data = databuilder.mcdata[mc]
-                the_data.setVar("BB_WORKERCONTEXT", "1")
-                the_data.setVar("BB_TASKDEPDATA", taskdepdata)
-                if cfg.limited_deps:
-                    the_data.setVar("BB_LIMITEDDEPS", "1")
-                the_data.setVar("BUILDNAME", workerdata["buildname"])
-                the_data.setVar("DATE", workerdata["date"])
-                the_data.setVar("TIME", workerdata["time"])
-                for varname, value in extraconfigdata.items():
-                    the_data.setVar(varname, value)
-
-                bb.parse.siggen.set_taskdata(workerdata["sigdata"])
-                ret = 0
-
-                the_data = bb_cache.loadDataFull(fn, appends)
+                the_data = bb.cache.Cache.loadDataFull(fn, appends, data)
                 the_data.setVar('BB_TASKHASH', workerdata["runq_hash"][task])
 
-                bb.utils.set_process_name("%s:%s" % (the_data.getVar("PN"), taskname.replace("do_", "")))
-
                 # exported_vars() returns a generator which *cannot* be passed to os.environ.update() 
                 # successfully. We also need to unset anything from the environment which shouldn't be there 
                 exports = bb.data.exported_vars(the_data)
-
                 bb.utils.empty_environment()
                 for e, v in exports:
                     os.environ[e] = v
-
                 for e in fakeenv:
                     os.environ[e] = fakeenv[e]
                     the_data.setVar(e, fakeenv[e])
                     the_data.setVarFlag(e, 'export', "1")
 
-                task_exports = the_data.getVarFlag(taskname, 'exports')
-                if task_exports:
-                    for e in task_exports.split():
-                        the_data.setVarFlag(e, 'export', '1')
-                        v = the_data.getVar(e)
-                        if v is not None:
-                            os.environ[e] = v
-
                 if quieterrors:
                     the_data.setVarFlag(taskname, "quieterrors", "1")
 
-            except Exception:
+            except Exception as exc:
                 if not quieterrors:
-                    logger.critical(traceback.format_exc())
+                    logger.critical(str(exc))
                 os._exit(1)
             try:
-                if dry_run:
+                if cfg.dry_run:
                     return 0
                 return bb.build.exec_task(fn, taskname, the_data, cfg.profile)
             except:
@@ -284,7 +215,7 @@ def fork_off_task(cfg, data, databuilder, workerdata, fn, task, taskname, append
                 bb.utils.process_profilelog(profname)
                 os._exit(ret)
     else:
-        for key, value in iter(envbackup.items()):
+        for key, value in envbackup.iteritems():
             if value is None:
                 del os.environ[key]
             else:
@@ -301,22 +232,22 @@ class runQueueWorkerPipe():
         if pipeout:
             pipeout.close()
         bb.utils.nonblockingfd(self.input)
-        self.queue = b""
+        self.queue = ""
 
     def read(self):
         start = len(self.queue)
         try:
-            self.queue = self.queue + (self.input.read(102400) or b"")
+            self.queue = self.queue + self.input.read(102400)
         except (OSError, IOError) as e:
             if e.errno != errno.EAGAIN:
                 raise
 
         end = len(self.queue)
-        index = self.queue.find(b"</event>")
+        index = self.queue.find("</event>")
         while index != -1:
             worker_fire_prepickled(self.queue[:index+8])
             self.queue = self.queue[index+8:]
-            index = self.queue.find(b"</event>")
+            index = self.queue.find("</event>")
         return (end > start)
 
     def close(self):
@@ -332,27 +263,22 @@ class BitbakeWorker(object):
     def __init__(self, din):
         self.input = din
         bb.utils.nonblockingfd(self.input)
-        self.queue = b""
+        self.queue = ""
         self.cookercfg = None
         self.databuilder = None
         self.data = None
-        self.extraconfigdata = None
         self.build_pids = {}
         self.build_pipes = {}
     
         signal.signal(signal.SIGTERM, self.sigterm_exception)
         # Let SIGHUP exit as SIGTERM
         signal.signal(signal.SIGHUP, self.sigterm_exception)
-        if "beef" in sys.argv[1]:
-            bb.utils.set_process_name("Worker (Fakeroot)")
-        else:
-            bb.utils.set_process_name("Worker")
 
     def sigterm_exception(self, signum, stackframe):
         if signum == signal.SIGTERM:
-            bb.warn("Worker received SIGTERM, shutting down...")
+            bb.warn("Worker recieved SIGTERM, shutting down...")
         elif signum == signal.SIGHUP:
-            bb.warn("Worker received SIGHUP, shutting down...")
+            bb.warn("Worker recieved SIGHUP, shutting down...")
         self.handle_finishnow(None)
         signal.signal(signal.SIGTERM, signal.SIG_DFL)
         os.kill(os.getpid(), signal.SIGTERM)
@@ -360,39 +286,34 @@ class BitbakeWorker(object):
     def serve(self):        
         while True:
             (ready, _, _) = select.select([self.input] + [i.input for i in self.build_pipes.values()], [] , [], 1)
-            if self.input in ready:
+            if self.input in ready or len(self.queue):
+                start = len(self.queue)
                 try:
-                    r = self.input.read()
-                    if len(r) == 0:
-                        # EOF on pipe, server must have terminated
-                        self.sigterm_exception(signal.SIGTERM, None)
-                    self.queue = self.queue + r
+                    self.queue = self.queue + self.input.read()
                 except (OSError, IOError):
                     pass
-            if len(self.queue):
-                self.handle_item(b"cookerconfig", self.handle_cookercfg)
-                self.handle_item(b"extraconfigdata", self.handle_extraconfigdata)
-                self.handle_item(b"workerdata", self.handle_workerdata)
-                self.handle_item(b"runtask", self.handle_runtask)
-                self.handle_item(b"finishnow", self.handle_finishnow)
-                self.handle_item(b"ping", self.handle_ping)
-                self.handle_item(b"quit", self.handle_quit)
+                end = len(self.queue)
+                self.handle_item("cookerconfig", self.handle_cookercfg)
+                self.handle_item("workerdata", self.handle_workerdata)
+                self.handle_item("runtask", self.handle_runtask)
+                self.handle_item("finishnow", self.handle_finishnow)
+                self.handle_item("ping", self.handle_ping)
+                self.handle_item("quit", self.handle_quit)
 
             for pipe in self.build_pipes:
-                if self.build_pipes[pipe].input in ready:
-                    self.build_pipes[pipe].read()
+                self.build_pipes[pipe].read()
             if len(self.build_pids):
-                while self.process_waitpid():
-                    continue
+                self.process_waitpid()
+            worker_flush()
 
 
     def handle_item(self, item, func):
-        if self.queue.startswith(b"<" + item + b">"):
-            index = self.queue.find(b"</" + item + b">")
+        if self.queue.startswith("<" + item + ">"):
+            index = self.queue.find("</" + item + ">")
             while index != -1:
                 func(self.queue[(len(item) + 2):index])
                 self.queue = self.queue[(index + len(item) + 3):]
-                index = self.queue.find(b"</" + item + b">")
+                index = self.queue.find("</" + item + ">")
 
     def handle_cookercfg(self, data):
         self.cookercfg = pickle.loads(data)
@@ -400,22 +321,18 @@ class BitbakeWorker(object):
         self.databuilder.parseBaseConfiguration()
         self.data = self.databuilder.data
 
-    def handle_extraconfigdata(self, data):
-        self.extraconfigdata = pickle.loads(data)
-
     def handle_workerdata(self, data):
         self.workerdata = pickle.loads(data)
         bb.msg.loggerDefaultDebugLevel = self.workerdata["logdefaultdebug"]
         bb.msg.loggerDefaultVerbose = self.workerdata["logdefaultverbose"]
         bb.msg.loggerVerboseLogs = self.workerdata["logdefaultverboselogs"]
         bb.msg.loggerDefaultDomains = self.workerdata["logdefaultdomain"]
-        for mc in self.databuilder.mcdata:
-            self.databuilder.mcdata[mc].setVar("PRSERV_HOST", self.workerdata["prhost"])
+        self.data.setVar("PRSERV_HOST", self.workerdata["prhost"])
 
     def handle_ping(self, _):
         workerlog_write("Handling ping\n")
 
-        logger.warning("Pong from bitbake-worker!")
+        logger.warn("Pong from bitbake-worker!")
 
     def handle_quit(self, data):
         workerlog_write("Handling quit\n")
@@ -425,10 +342,10 @@ class BitbakeWorker(object):
         sys.exit(0)
 
     def handle_runtask(self, data):
-        fn, task, taskname, quieterrors, appends, taskdepdata, dry_run_exec = pickle.loads(data)
+        fn, task, taskname, quieterrors, appends, taskdepdata = pickle.loads(data)
         workerlog_write("Handling runtask %s %s %s\n" % (task, fn, taskname))
 
-        pid, pipein, pipeout = fork_off_task(self.cookercfg, self.data, self.databuilder, self.workerdata, fn, task, taskname, appends, taskdepdata, self.extraconfigdata, quieterrors, dry_run_exec)
+        pid, pipein, pipeout = fork_off_task(self.cookercfg, self.data, self.workerdata, fn, task, taskname, appends, taskdepdata, quieterrors)
 
         self.build_pids[pid] = task
         self.build_pipes[pid] = runQueueWorkerPipe(pipein, pipeout)
@@ -441,9 +358,9 @@ class BitbakeWorker(object):
         try:
             pid, status = os.waitpid(-1, os.WNOHANG)
             if pid == 0 or os.WIFSTOPPED(status):
-                return False
+                return None
         except OSError:
-            return False
+            return None
 
         workerlog_write("Exit code of %s for pid %s\n" % (status, pid))
 
@@ -460,14 +377,12 @@ class BitbakeWorker(object):
         self.build_pipes[pid].close()
         del self.build_pipes[pid]
 
-        worker_fire_prepickled(b"<exitcode>" + pickle.dumps((task, status)) + b"</exitcode>")
-
-        return True
+        worker_fire_prepickled("<exitcode>" + pickle.dumps((task, status)) + "</exitcode>")
 
     def handle_finishnow(self, _):
         if self.build_pids:
             logger.info("Sending SIGTERM to remaining %s tasks", len(self.build_pids))
-            for k, v in iter(self.build_pids.items()):
+            for k, v in self.build_pids.iteritems():
                 try:
                     os.kill(-k, signal.SIGTERM)
                     os.waitpid(-1, 0)
@@ -477,7 +392,7 @@ class BitbakeWorker(object):
             self.build_pipes[pipe].read()
 
 try:
-    worker = BitbakeWorker(os.fdopen(sys.stdin.fileno(), 'rb'))
+    worker = BitbakeWorker(sys.stdin)
     if not profiling:
         worker.serve()
     else:
@@ -493,10 +408,8 @@ except BaseException as e:
         import traceback
         sys.stderr.write(traceback.format_exc())
         sys.stderr.write(str(e))
-
-worker_thread_exit = True
-worker_thread.join()
-
+while len(worker_queue):
+    worker_flush()
 workerlog_write("exitting")
 sys.exit(0)
 

bitbake/bin/bitdoc

@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+#!/usr/bin/env python
 # ex:ts=4:sw=4:sts=4:et
 # -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
 #
@@ -462,7 +462,7 @@ def main():
     state_group = 2
 
     for key in bb.data.keys(documentation):
-        data   = documentation.getVarFlag(key, "doc", False)
+        data   = documentation.getVarFlag(key, "doc")
         if not data:
             continue
 

bitbake/bin/image-writer

@@ -0,0 +1,122 @@
+#!/usr/bin/env python
+
+# Copyright (c) 2012 Wind River Systems, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+# See the GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+
+import os
+import sys
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.dirname( \
+                                    os.path.abspath(__file__))), 'lib'))
+try:
+    import bb
+except RuntimeError as exc:
+    sys.exit(str(exc))
+
+import gtk
+import optparse
+import pygtk
+
+from bb.ui.crumbs.hobwidget import HobAltButton, HobButton
+from bb.ui.crumbs.hig.crumbsmessagedialog import CrumbsMessageDialog
+from bb.ui.crumbs.hig.deployimagedialog import DeployImageDialog
+from bb.ui.crumbs.hig.imageselectiondialog import ImageSelectionDialog
+
+# I put all the fs bitbake supported here. Need more test.
+DEPLOYABLE_IMAGE_TYPES = ["jffs2", "cramfs", "ext2", "ext3", "btrfs", "squashfs", "ubi", "vmdk"]
+Title = "USB Image Writer"
+
+class DeployWindow(gtk.Window):
+    def __init__(self, image_path=''):
+        super(DeployWindow, self).__init__()
+
+        if len(image_path) > 0:
+            valid = True
+            if not os.path.exists(image_path):
+                valid = False
+                lbl = "<b>Invalid image file path: %s.</b>\nPress <b>Select Image</b> to select an image." % image_path
+            else:
+                image_path = os.path.abspath(image_path)
+                extend_name = os.path.splitext(image_path)[1][1:]
+                if extend_name not in DEPLOYABLE_IMAGE_TYPES:
+                    valid = False
+                    lbl = "<b>Undeployable imge type: %s</b>\nPress <b>Select Image</b> to select an image." % extend_name
+
+            if not valid:
+                image_path = ''
+                crumbs_dialog = CrumbsMessageDialog(self, lbl, gtk.STOCK_DIALOG_INFO)
+                button = crumbs_dialog.add_button("Close", gtk.RESPONSE_OK)
+                HobButton.style_button(button)
+                crumbs_dialog.run()
+                crumbs_dialog.destroy()
+
+        self.deploy_dialog = DeployImageDialog(Title, image_path, self,
+                                        gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT
+                                        | gtk.DIALOG_NO_SEPARATOR, None, standalone=True)
+        close_button = self.deploy_dialog.add_button("Close", gtk.RESPONSE_NO)
+        HobAltButton.style_button(close_button)
+        close_button.connect('clicked', gtk.main_quit)
+
+        write_button = self.deploy_dialog.add_button("Write USB image", gtk.RESPONSE_YES)
+        HobAltButton.style_button(write_button)
+
+        self.deploy_dialog.connect('select_image_clicked', self.select_image_clicked_cb)
+        self.deploy_dialog.connect('destroy', gtk.main_quit)
+        response = self.deploy_dialog.show()
+
+    def select_image_clicked_cb(self, dialog):
+        cwd = os.getcwd()
+        dialog = ImageSelectionDialog(cwd, DEPLOYABLE_IMAGE_TYPES, Title, self, gtk.FILE_CHOOSER_ACTION_SAVE )
+        button = dialog.add_button("Cancel", gtk.RESPONSE_NO)
+        HobAltButton.style_button(button)
+        button = dialog.add_button("Open", gtk.RESPONSE_YES)
+        HobAltButton.style_button(button)
+        response = dialog.run()
+
+        if response == gtk.RESPONSE_YES:
+            if not dialog.image_names:
+                lbl = "<b>No selections made</b>\nClicked the radio button to select a image."
+                crumbs_dialog = CrumbsMessageDialog(self, lbl, gtk.STOCK_DIALOG_INFO)
+                button = crumbs_dialog.add_button("Close", gtk.RESPONSE_OK)
+                HobButton.style_button(button)
+                crumbs_dialog.run()
+                crumbs_dialog.destroy()
+                dialog.destroy()
+                return
+
+            # get the full path of image
+            image_path = os.path.join(dialog.image_folder, dialog.image_names[0])
+            self.deploy_dialog.set_image_text_buffer(image_path)
+            self.deploy_dialog.set_image_path(image_path)
+
+        dialog.destroy()
+
+def main():
+    parser = optparse.OptionParser(
+                usage = """%prog [-h] [image_file]
+
+%prog writes bootable images to USB devices. You can
+provide the image file on the command line or select it using the GUI.""")
+
+    options, args = parser.parse_args(sys.argv)
+    image_file = args[1] if len(args) > 1 else ''
+    dw = DeployWindow(image_file)
+
+if __name__ == '__main__':
+    try:
+        main()
+        gtk.main()
+    except Exception:
+        import traceback
+        traceback.print_exc(3)

bitbake/bin/toaster

@@ -1,8 +1,5 @@
-#!/bin/echo ERROR: This script needs to be sourced. Please run as .
-
-# toaster - shell script to start Toaster
-
-# Copyright (C) 2013-2015 Intel Corp.
+#!/bin/bash
+# (c) 2013 Intel Corp.
 
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
@@ -15,247 +12,256 @@
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
-# along with this program. If not, see http://www.gnu.org/licenses/.
+# along with this program; if not, write to the Free Software
+# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
-HELP="
-Usage: source toaster start|stop [webport=<address:port>] [noweb]
-    Optional arguments:
-        [noweb] Setup the environment for building with toaster but don't start the development server
-        [webport] Set the development server (default: localhost:8000)
-"
 
-webserverKillAll()
+# This script can be run in two modes.
+
+# When used with "source", from a build directory,
+# it enables toaster event logging and starts the bitbake resident server.
+# use as:  source toaster [start|stop] [noweb] [noui]
+
+# When it is called as a stand-alone script, it starts just the
+# web server, and the building shall be done through the web interface.
+# As script, it will not return to the command prompt. Stop with Ctrl-C.
+
+# Helper function to kill a background toaster development server
+
+function webserverKillAll()
 {
-    local pidfile
-    for pidfile in ${BUILDDIR}/.toastermain.pid ${BUILDDIR}/.runbuilds.pid; do
-        if [ -f ${pidfile} ]; then
-            pid=`cat ${pidfile}`
-            while kill -0 $pid 2>/dev/null; do
-                kill -SIGTERM -$pid 2>/dev/null
-                sleep 1
-            done
-            rm  ${pidfile}
-        fi
-    done
+	local pidfile
+	for pidfile in ${BUILDDIR}/.toastermain.pid; do
+		if [ -f ${pidfile} ]; then
+		while kill -0 $(< ${pidfile}) 2>/dev/null; do
+			kill -SIGTERM -$(< ${pidfile}) 2>/dev/null
+			sleep 1;
+			# Kill processes if they are still running - may happen in interactive shells
+			ps fux | grep "python.*manage.py" | awk '{print $2}' | xargs kill
+		done;
+		rm  ${pidfile}
+		fi
+	done
 }
 
-webserverStartAll()
+function webserverStartAll()
 {
-    # do not start if toastermain points to a valid process
-    if ! cat "${BUILDDIR}/.toastermain.pid" 2>/dev/null | xargs -I{} kill -0 {} ; then
-        retval=1
-        rm "${BUILDDIR}/.toastermain.pid"
-    fi
+	# do not start if toastermain points to a valid process
+	if ! cat "${BUILDDIR}/.toastermain.pid" 2>/dev/null | xargs -I{} kill -0 {} ; then
+            retval=1
+            rm "${BUILDDIR}/.toastermain.pid"
+        fi
 
-    retval=0
-    # you can always add a superuser later via
-    # ../bitbake/lib/toaster/manage.py createsuperuser --username=<ME>
-    $MANAGE migrate --noinput || retval=1
-
-    if [ $retval -eq 1 ]; then
-        echo "Failed migrations, aborting system start" 1>&2
+        retval=0
+        python $BBBASEDIR/lib/toaster/manage.py syncdb || retval=1
+        python $BBBASEDIR/lib/toaster/manage.py migrate orm || retval=2
+        if [ $retval -eq 1 ]; then
+                echo "Failed db sync, stopping system start" 1>&2
+        elif [ $retval -eq 2 ]; then
+            echo -e "\nError on migration, trying to recover... \n"
+            python $BBBASEDIR/lib/toaster/manage.py migrate orm 0001_initial --fake
+            retval=0
+            python $BBBASEDIR/lib/toaster/manage.py migrate orm || retval=1
+        fi
+	if [ "x$TOASTER_MANAGED" == "x1" ]; then
+	        python $BBBASEDIR/lib/toaster/manage.py migrate bldcontrol || retval=1
+		python $BBBASEDIR/lib/toaster/manage.py checksettings  --traceback || retval=1
+	fi
+        if [ $retval -eq 0 ]; then
+	    echo "Starting webserver"
+            python $BBBASEDIR/lib/toaster/manage.py runserver 0.0.0.0:8000 </dev/null >${BUILDDIR}/toaster_web.log 2>&1 & echo $! >${BUILDDIR}/.toastermain.pid
+            sleep 1
+            if ! cat "${BUILDDIR}/.toastermain.pid" | xargs -I{} kill -0 {} ; then
+                retval=1
+                rm "${BUILDDIR}/.toastermain.pid"
+            fi
+        fi
         return $retval
-    fi
-    # Make sure that checksettings can pick up any value for TEMPLATECONF
-    export TEMPLATECONF
-    $MANAGE checksettings --traceback || retval=1
+}
 
-    if [ $retval -eq 1 ]; then
-        printf "\nError while checking settings; aborting\n"
-        return $retval
-    fi
+# Helper functions to add a special configuration file
 
-    echo "Starting webserver..."
-
-    $MANAGE runserver "$ADDR_PORT" \
-           </dev/null >>${BUILDDIR}/toaster_web.log 2>&1 \
-           & echo $! >${BUILDDIR}/.toastermain.pid
-
-    sleep 1
-
-    if ! cat "${BUILDDIR}/.toastermain.pid" | xargs -I{} kill -0 {} ; then
-        retval=1
-        rm "${BUILDDIR}/.toastermain.pid"
-    else
-        echo "Toaster development webserver started at http://$ADDR_PORT"
-        echo -e "\nYou can now run 'bitbake <target>' on the command line and monitor your build in Toaster.\nYou can also use a Toaster project to configure and run a build.\n"
-    fi
-
-    return $retval
+function addtoConfiguration()
+{
+        echo "#Created by toaster start script" > ${BUILDDIR}/conf/$2
+        echo $1 >> ${BUILDDIR}/conf/$2
 }
 
 INSTOPSYSTEM=0
 
 # define the stop command
-stop_system()
+function stop_system()
 {
     # prevent reentry
-    if [ $INSTOPSYSTEM -eq 1 ]; then return; fi
+    if [ $INSTOPSYSTEM == 1 ]; then return; fi
     INSTOPSYSTEM=1
+    if [ -f ${BUILDDIR}/.toasterui.pid ]; then
+        kill $(< ${BUILDDIR}/.toasterui.pid ) 2>/dev/null
+        rm ${BUILDDIR}/.toasterui.pid
+    fi
+    BBSERVER=0.0.0.0:8200 bitbake -m
+    unset BBSERVER
     webserverKillAll
-    # unset exported variables
-    unset TOASTER_DIR
-    unset BITBAKE_UI
-    unset BBBASEDIR
+    # force stop any misbehaving bitbake server
+    lsof bitbake.lock | awk '{print $2}' | grep "[0-9]\+" | xargs -n1 -r kill
     trap - SIGHUP
     #trap - SIGCHLD
     INSTOPSYSTEM=0
 }
 
-verify_prereq() {
-    # Verify Django version
-    reqfile=$(python3 -c "import os; print(os.path.realpath('$BBBASEDIR/toaster-requirements.txt'))")
-    exp='s/Django\([><=]\+\)\([^,]\+\),\([><=]\+\)\(.\+\)/'
-    exp=$exp'import sys,django;version=django.get_version().split(".");'
-    exp=$exp'sys.exit(not (version \1 "\2".split(".") and version \3 "\4".split(".")))/p'
-    if ! sed -n "$exp" $reqfile | python3 - ; then
-        req=`grep ^Django $reqfile`
-        echo "This program needs $req"
-        echo "Please install with pip3 install -r $reqfile"
-        return 2
-    fi
-
-    return 0
+function check_pidbyfile() {
+    [ -e $1 ] && kill -0 $(< $1) 2>/dev/null
 }
 
-# read command line parameters
-if [ -n "$BASH_SOURCE" ] ; then
-    TOASTER=${BASH_SOURCE}
-elif [ -n "$ZSH_NAME" ] ; then
-    TOASTER=${(%):-%x}
-else
-    TOASTER=$0
-fi
 
-export BBBASEDIR=`dirname $TOASTER`/..
-MANAGE="python3 $BBBASEDIR/lib/toaster/manage.py"
-OE_ROOT=`dirname $TOASTER`/../..
-
-# this is the configuraton file we are using for toaster
-# we are using the same logic that oe-setup-builddir uses
-# (based on TEMPLATECONF and .templateconf) to determine
-# which toasterconf.json to use.
-# note: There are a number of relative path assumptions
-# in the local layers that currently make using an arbitrary
-# toasterconf.json difficult.
-
-. $OE_ROOT/.templateconf
-if [ -n "$TEMPLATECONF" ]; then
-    if [ ! -d "$TEMPLATECONF" ]; then
-        # Allow TEMPLATECONF=meta-xyz/conf as a shortcut
-        if [ -d "$OE_ROOT/$TEMPLATECONF" ]; then
-            TEMPLATECONF="$OE_ROOT/$TEMPLATECONF"
-        fi
+function notify_chldexit() {
+    if [ $NOTOASTERUI == 0 ]; then
+        check_pidbyfile ${BUILDDIR}/.toasterui.pid && return
+        stop_system
     fi
+}
+
+
+BBBASEDIR=`dirname ${BASH_SOURCE}`/..
+RUNNING=0
+
+if [ -z "$ZSH_NAME" ] && [ `basename \"$0\"` = `basename \"$BASH_SOURCE\"` ]; then
+    # We are called as standalone. We refuse to run in a build environment - we need the interactive mode for that.
+    # Start just the web server, point the web browser to the interface, and start any Django services.
+
+    if [ -n "$BUILDDIR" ]; then
+        echo -e "Error: build/ directory detected. Toaster will not start in managed mode if a build environment is detected.\nUse a clean terminal to start Toaster." 1>&2;
+        exit 1;
+    fi
+
+    # Define a fake builddir where only the pid files are actually created. No real builds will take place here.
+    BUILDDIR=/tmp
+    RUNNING=1
+    function trap_ctrlc() {
+        echo "** Stopping system"
+        webserverKillAll
+        RUNNING=0
+    }
+    TOASTER_MANAGED=1
+    export TOASTER_MANAGED=1
+    if ! webserverStartAll; then
+        echo "Failed to start the web server, stopping" 1>&2;
+        exit 1;
+    fi
+    xdg-open http://0.0.0.0:8000/ >/dev/null 2>&1 &
+    trap trap_ctrlc SIGINT
+    echo "Running. Stop with Ctrl-C"
+    while [ $RUNNING -gt 0 ]; do
+	python $BBBASEDIR/lib/toaster/manage.py runbuilds
+	sleep 1
+    done
+    echo "**** Exit"
+    exit 0
 fi
 
-unset OE_ROOT
-
-
-
-WEBSERVER=1
-ADDR_PORT="localhost:8000"
-unset CMD
-for param in $*; do
-    case $param in
-    noweb )
-            WEBSERVER=0
-    ;;
-    start )
-            CMD=$param
-    ;;
-    stop )
-            CMD=$param
-    ;;
-    webport=*)
-            ADDR_PORT="${param#*=}"
-            # Split the addr:port string
-            ADDR=`echo $ADDR_PORT | cut -f 1 -d ':'`
-            PORT=`echo $ADDR_PORT | cut -f 2 -d ':'`
-            # If only a port has been speified then set address to localhost.
-            if [ $ADDR = $PORT ] ; then
-                ADDR_PORT="localhost:$PORT"
-            fi
-    ;;
-    --help)
-            echo "$HELP"
-            return 0
-    ;;
-    *)
-            echo "$HELP"
-            return 1
-    ;;
-
-    esac
-done
-
-if [ `basename \"$0\"` = `basename \"${TOASTER}\"` ]; then
-    echo "Error: This script needs to be sourced. Please run as . $TOASTER"
-    return 1
-fi
-
-verify_prereq || return 1
-
 # We make sure we're running in the current shell and in a good environment
-if [ -z "$BUILDDIR" ] ||  ! which bitbake >/dev/null 2>&1 ; then
-    echo "Error: Build environment is not setup or bitbake is not in path." 1>&2
+if [ -z "$BUILDDIR" ] || [ -z `which bitbake` ]; then
+    echo "Error: Build environment is not setup or bitbake is not in path." 1>&2;
     return 2
 fi
 
-# this defines the dir toaster will use for
-# 1) clones of layers (in _toaster_clones )
-# 2) the build dir (in build)
-# 3) the sqlite db if that is being used.
-# 4) pid's we need to clean up on exit/shutdown
-export TOASTER_DIR=`dirname $BUILDDIR`
-export BB_ENV_EXTRAWHITE="$BB_ENV_EXTRAWHITE TOASTER_DIR"
+
+
+# Verify prerequisites
+
+if ! echo "import django; print (1,) == django.VERSION[0:1] and django.VERSION[1:2][0] in (5,6)" | python 2>/dev/null | grep True >/dev/null; then
+    echo -e "This program needs Django 1.5 or 1.6. Please install with\n\npip install django==1.6"
+    return 2
+fi
+
+if ! echo "import south; print [0,8,4] ==  map(int,south.__version__.split(\".\"))" | python 2>/dev/null | grep True >/dev/null; then
+    echo -e "This program needs South 0.8.4. Please install with\n\npip install south==0.8.4"
+    return 2
+fi
+
+
+
+
 
 # Determine the action. If specified by arguments, fine, if not, toggle it
-if [ "$CMD" = "start" ] ; then
-    if [ -n "$BBSERVER" ]; then
-	echo " Toaster is already running. Exiting..."
-	return 1
-fi
-elif [ "$CMD" = "" ]; then
-    echo "No command specified"
-    echo "$HELP"
-    return 1
+if [ "x$1" == "xstart" ] || [ "x$1" == "xstop" ]; then
+    CMD="$1"
+else
+    if [ -z "$BBSERVER" ]; then
+        CMD="start"
+    else
+        CMD="stop"
+    fi;
 fi
 
+NOTOASTERUI=0
+WEBSERVER=1
+for param in $*; do
+    case $param in
+    noui )
+            NOTOASTERUI=1
+    ;;
+    noweb )
+            WEBSERVER=0
+    ;;
+    esac
+done
+
 echo "The system will $CMD."
 
+# Make sure it's safe to run by checking bitbake lock
+
+lock=1
+if [ -e $BUILDDIR/bitbake.lock ]; then
+    (flock -n 200 ) 200<$BUILDDIR/bitbake.lock || lock=0
+fi
+
+if [ ${CMD} == "start" ] && ( [ $lock -eq 0 ] || [ -e $BUILDDIR/.toastermain.pid ] ); then
+    echo "Error: bitbake lock state error. File locks show that the system is on." 2>&1
+    echo "If you see problems, stop and then start the system again." 2>&1
+    return 3
+fi
+
+
 # Execute the commands
 
 case $CMD in
     start )
-        # check if addr:port is not in use
-        if [ "$CMD" == 'start' ]; then
-            if [ $WEBSERVER -gt 0 ]; then
-                $MANAGE checksocket "$ADDR_PORT" || return 1
-            fi
-        fi
-
-        # Create configuration file
-        conf=${BUILDDIR}/conf/local.conf
-        line='INHERIT+="toaster buildhistory"'
-        grep -q "$line" $conf || echo $line >> $conf
-
+        start_success=1
+        addtoConfiguration "INHERIT+=\"toaster buildhistory\"" toaster.conf
         if [ $WEBSERVER -gt 0 ] && ! webserverStartAll; then
             echo "Failed ${CMD}."
             return 4
         fi
-        export BITBAKE_UI='toasterui'
-        $MANAGE runbuilds \
-           </dev/null >>${BUILDDIR}/toaster_runbuilds.log 2>&1 \
-           & echo $! >${BUILDDIR}/.runbuilds.pid
-
-        # set fail safe stop system on terminal exit
+        unset BBSERVER
+        bitbake --postread conf/toaster.conf --server-only -t xmlrpc -B 0.0.0.0:8200
+        if [ $? -ne 0 ]; then
+            start_success=0
+            echo "Bitbake server start failed"
+        else
+            export BBSERVER=0.0.0.0:8200
+            if [ $NOTOASTERUI == 0 ]; then        # we start the TOASTERUI only if not inhibited
+                bitbake --observe-only -u toasterui >${BUILDDIR}/toaster_ui.log 2>&1 & echo $! >${BUILDDIR}/.toasterui.pid
+            fi
+        fi
+        if [ $start_success -eq 1 ]; then
+            # set fail safe stop system on terminal exit
+            trap stop_system SIGHUP
+            echo "Successful ${CMD}."
+        else
+            # failed start, do stop
+            stop_system
+            echo "Failed ${CMD}."
+        fi
+        # stop system on terminal exit
+        set -o monitor
         trap stop_system SIGHUP
-        echo "Successful ${CMD}."
-        return 0
+        #trap notify_chldexit SIGCHLD
     ;;
     stop )
         stop_system
         echo "Successful ${CMD}."
     ;;
 esac
+
+

bitbake/bin/toaster-eventreplay

@@ -1,126 +0,0 @@
-#!/usr/bin/env python3
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-#
-# Copyright (C) 2014        Alex Damian
-#
-# This file re-uses code spread throughout other Bitbake source files.
-# As such, all other copyrights belong to their own right holders.
-#
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 2 as
-# published by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-"""
-This command takes a filename as a single parameter. The filename is read
-as a build eventlog, and the ToasterUI is used to process events in the file
-and log data in the database
-"""
-
-import os
-import sys
-import json
-import pickle
-import codecs
-
-from collections import namedtuple
-
-# mangle syspath to allow easy import of modules
-from os.path import join, dirname, abspath
-sys.path.insert(0, join(dirname(dirname(abspath(__file__))), 'lib'))
-
-import bb.cooker
-from bb.ui import toasterui
-
-class EventPlayer:
-    """Emulate a connection to a bitbake server."""
-
-    def __init__(self, eventfile, variables):
-        self.eventfile = eventfile
-        self.variables = variables
-        self.eventmask = []
-
-    def waitEvent(self, _timeout):
-        """Read event from the file."""
-        line = self.eventfile.readline().strip()
-        if not line:
-            return
-        try:
-            event_str = json.loads(line)['vars'].encode('utf-8')
-            event = pickle.loads(codecs.decode(event_str, 'base64'))
-            event_name = "%s.%s" % (event.__module__, event.__class__.__name__)
-            if event_name not in self.eventmask:
-                return
-            return event
-        except ValueError as err:
-            print("Failed loading ", line)
-            raise err
-
-    def runCommand(self, command_line):
-        """Emulate running a command on the server."""
-        name = command_line[0]
-
-        if name == "getVariable":
-            var_name = command_line[1]
-            variable = self.variables.get(var_name)
-            if variable:
-                return variable['v'], None
-            return None, "Missing variable %s" % var_name
-
-        elif name == "getAllKeysWithFlags":
-            dump = {}
-            flaglist = command_line[1]
-            for key, val in self.variables.items():
-                try:
-                    if not key.startswith("__"):
-                        dump[key] = {
-                            'v': val['v'],
-                            'history' : val['history'],
-                        }
-                        for flag in flaglist:
-                            dump[key][flag] = val[flag]
-                except Exception as err:
-                    print(err)
-            return (dump, None)
-
-        elif name == 'setEventMask':
-            self.eventmask = command_line[-1]
-            return True, None
-
-        else:
-            raise Exception("Command %s not implemented" % command_line[0])
-
-    def getEventHandle(self):
-        """
-        This method is called by toasterui.
-        The return value is passed to self.runCommand but not used there.
-        """
-        pass
-
-def main(argv):
-    with open(argv[-1]) as eventfile:
-        # load variables from the first line
-        variables = json.loads(eventfile.readline().strip())['allvariables']
-
-        params = namedtuple('ConfigParams', ['observe_only'])(True)
-        player = EventPlayer(eventfile, variables)
-
-        return toasterui.main(player, player, params)
-
-# run toaster ui on our mock bitbake class
-if __name__ == "__main__":
-    if len(sys.argv) != 2:
-        print("Usage: %s <event file>" % os.path.basename(sys.argv[0]))
-        sys.exit(1)
-
-    sys.exit(main(sys.argv))

bitbake/contrib/dump_cache.py

@@ -1,4 +1,4 @@
-#!/usr/bin/env python3
+#!/usr/bin/env python
 # ex:ts=4:sw=4:sts=4:et
 # -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
 #
@@ -29,14 +29,14 @@ import warnings
 sys.path.insert(0, os.path.join(os.path.abspath(os.path.dirname(sys.argv[0])), '../lib'))
 from bb.cache import CoreRecipeInfo
 
-import pickle as pickle
+import cPickle as pickle
 
 def main(argv=None):
     """
     Get the mapping for the target recipe.
     """
     if len(argv) != 1:
-        print("Error, need one argument!", file=sys.stderr)
+        print >>sys.stderr, "Error, need one argument!"
         return 2
 
     cachefile = argv[0]
@@ -56,7 +56,7 @@ def main(argv=None):
                     continue
 
                 # 1.0 is the default version for a no PV recipe.
-                if "pv" in val.__dict__:
+                if val.__dict__.has_key("pv"):
                     pv = val.pv
                 else:
                     pv = "1.0"

bitbake/doc/Makefile

@@ -11,7 +11,7 @@
 #    validate: validates
 #    clean:    removes files
 #
-# The Makefile generates an HTML version of every document.  The
+# The Makefile generates an HTML and PDF version of every document.  The
 # variable DOC indicates the folder name for a given manual.
 #
 # To build a manual, you must invoke 'make' with the DOC argument.
@@ -21,8 +21,8 @@
 #     make DOC=bitbake-user-manual
 #     make pdf DOC=bitbake-user-manual
 #
-# The first example generates the HTML version of the User Manual.
-# The second example generates the PDF version of the User Manual.
+# The first example generates the HTML and PDF versions of the User Manual.
+# The second example generates the HTML version only of the User Manual.
 #
 
 ifeq ($(DOC),bitbake-user-manual)
@@ -31,9 +31,9 @@ XSLTOPTS = --stringparam html.stylesheet bitbake-user-manual-style.css \
            --stringparam  section.autolabel 1 \
            --stringparam  section.label.includes.component.label 1 \
            --xinclude
-ALLPREQ = html tarball
-TARFILES = bitbake-user-manual-style.css bitbake-user-manual.html figures/bitbake-title.png
-MANUALS = $(DOC)/$(DOC).html
+ALLPREQ = html pdf tarball
+TARFILES = bitbake-user-manual-style.css bitbake-user-manual.html bitbake-user-manual.pdf figures/bitbake-title.png
+MANUALS = $(DOC)/$(DOC).html $(DOC)/$(DOC).pdf
 FIGURES = figures
 STYLESHEET = $(DOC)/*.css
 

bitbake/doc/bitbake-user-manual/bitbake-user-manual-customization.xsl

@@ -1,15 +1,7 @@
 <?xml version='1.0'?>
 <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns="http://www.w3.org/1999/xhtml" xmlns:fo="http://www.w3.org/1999/XSL/Format" version="1.0">
 
-  <xsl:import href="http://downloads.yoctoproject.org/mirror/docbook-mirror/docbook-xsl-1.76.1/xhtml/docbook.xsl" />
-
-<!--
-
-  <xsl:import href="../template/1.76.1/docbook-xsl-1.76.1/xhtml/docbook.xsl" />
-
-  <xsl:import href="http://docbook.sourceforge.net/release/xsl/1.76.1/xhtml/docbook.xsl" />
-
--->
+  <xsl:import href="http://docbook.sourceforge.net/release/xsl/current/xhtml/docbook.xsl" />
 
   <xsl:include href="../template/permalinks.xsl"/>
   <xsl:include href="../template/section.title.xsl"/>

bitbake/doc/bitbake-user-manual/bitbake-user-manual-execution.xml

@@ -21,7 +21,7 @@
         The execution process is launched using the following command
         form:
         <literallayout class='monospaced'>
-     $ bitbake <replaceable>target</replaceable>
+     $ bitbake &lt;target&gt;
         </literallayout>
         For information on the BitBake command and its options,
         see
@@ -37,16 +37,14 @@
             </para>
 
             <para>
-                A common method to determine this value for your build host is to run
-                the following:
+                A common way to determine this value for your build host is to run:
                 <literallayout class='monospaced'>
      $ grep processor /proc/cpuinfo
                 </literallayout>
-                This command returns the number of processors, which takes into
-                account hyper-threading.
-                Thus, a quad-core build host with hyper-threading most likely
-                shows eight processors, which is the value you would then assign to
-                <filename>BB_NUMBER_THREADS</filename>.
+                and count the number of processors displayed. Note that the number of
+                processors will take into account hyper-threading, so that a quad-core
+                build host with hyper-threading will most likely show eight processors,
+                which is the value you would then assign to that variable.
             </para>
 
             <para>
@@ -116,35 +114,16 @@
             Prior to parsing configuration files, Bitbake looks
             at certain variables, including:
             <itemizedlist>
-                <listitem><para>
-                    <link linkend='var-BB_ENV_WHITELIST'><filename>BB_ENV_WHITELIST</filename></link>
-                    </para></listitem>
-                <listitem><para>
-                    <link linkend='var-BB_ENV_EXTRAWHITE'><filename>BB_ENV_EXTRAWHITE</filename></link>
-                    </para></listitem>
-                <listitem><para>
-                    <link linkend='var-BB_PRESERVE_ENV'><filename>BB_PRESERVE_ENV</filename></link>
-                    </para></listitem>
-                <listitem><para>
-                    <link linkend='var-BB_ORIGENV'><filename>BB_ORIGENV</filename></link>
-                    </para></listitem>
+                <listitem><para><link linkend='var-BB_ENV_WHITELIST'><filename>BB_ENV_WHITELIST</filename></link></para></listitem>
+                <listitem><para><link linkend='var-BB_PRESERVE_ENV'><filename>BB_PRESERVE_ENV</filename></link></para></listitem>
+                <listitem><para><link linkend='var-BB_ENV_EXTRAWHITE'><filename>BB_ENV_EXTRAWHITE</filename></link></para></listitem>
                 <listitem><para>
                     <link linkend='var-BITBAKE_UI'><filename>BITBAKE_UI</filename></link>
                     </para></listitem>
             </itemizedlist>
-            The first four variables in this list relate to how BitBake treats shell
-            environment variables during task execution.
-            By default, BitBake cleans the environment variables and provides tight
-            control over the shell execution environment.
-            However, through the use of these first four variables, you can
-            apply your control regarding the
-            environment variables allowed to be used by BitBake in the shell
-            during execution of tasks.
-            See the
-            "<link linkend='passing-information-into-the-build-task-environment'>Passing Information Into the Build Task Environment</link>"
-            section and the information about these variables in the
-            variable glossary for more information on how they work and
-            on how to use them.
+            You can find information on how to pass environment variables into the BitBake
+            execution environment in the
+            "<link linkend='passing-information-into-the-build-task-environment'>Passing Information Into the Build Task Environment</link>" section.
         </para>
 
         <para>
@@ -306,8 +285,8 @@
             <link linkend='var-PN'><filename>PN</filename></link> and
             <link linkend='var-PV'><filename>PV</filename></link>:
             <literallayout class='monospaced'>
-     PN = "${@bb.parse.BBHandler.vars_from_file(d.getVar('FILE', False),d)[0] or 'defaultpkgname'}"
-     PV = "${@bb.parse.BBHandler.vars_from_file(d.getVar('FILE', False),d)[1] or '1.0'}"
+     PN = "${@bb.parse.BBHandler.vars_from_file(d.getVar('FILE'),d)[0] or 'defaultpkgname'}"
+     PV = "${@bb.parse.BBHandler.vars_from_file(d.getVar('FILE'),d)[1] or '1.0'}"
             </literallayout>
             In this example, a recipe called "something_1.2.3.bb" would set
             <filename>PN</filename> to "something" and
@@ -596,7 +575,7 @@
             "<link linkend='checksums'>Checksums (Signatures)</link>"
             section for information).
             It is also possible to append extra metadata to the stamp using
-            the <filename>[stamp-extra-info]</filename> task flag.
+            the "stamp-extra-info" task flag.
             For example, OpenEmbedded uses this flag to make some tasks machine-specific.
         </para>
 
@@ -653,8 +632,7 @@
             </itemizedlist>
             It is possible to have functions run before and after a task's main
             function.
-            This is done using the <filename>[prefuncs]</filename>
-            and <filename>[postfuncs]</filename> flags of the task
+            This is done using the "prefuncs" and "postfuncs" flags of the task
             that lists the functions to run.
         </para>
     </section>
@@ -804,13 +782,13 @@
             make some dependency and hash information available to the build.
             This information includes:
             <itemizedlist>
-                <listitem><para><filename>BB_BASEHASH_task-</filename><replaceable>taskname</replaceable>:
+                <listitem><para><filename>BB_BASEHASH_task-&lt;taskname&gt;</filename>:
                     The base hashes for each task in the recipe.
                     </para></listitem>
-                <listitem><para><filename>BB_BASEHASH_</filename><replaceable>filename</replaceable><filename>:</filename><replaceable>taskname</replaceable>:
+                <listitem><para><filename>BB_BASEHASH_&lt;filename:taskname&gt;</filename>:
                     The base hashes for each dependent task.
                     </para></listitem>
-                <listitem><para><filename>BBHASHDEPS_</filename><replaceable>filename</replaceable><filename>:</filename><replaceable>taskname</replaceable>:
+                <listitem><para><filename>BBHASHDEPS_&lt;filename:taskname&gt;</filename>:
                     The task dependencies for each task.
                     </para></listitem>
                 <listitem><para><filename>BB_TASKHASH</filename>:
@@ -828,7 +806,7 @@
             itself.
             The simplest parameter to pass is "none", which causes a
             set of signature information to be written out into
-            <filename>STAMPS_DIR</filename>
+            <filename>STAMP_DIR</filename>
             corresponding to the targets specified.
             The other currently available parameter is "printdiff",
             which causes BitBake to try to establish the closest
@@ -916,7 +894,7 @@
         <para>
             Finally, after all the setscene tasks have executed, BitBake calls the
             function listed in
-            <link linkend='var-BB_SETSCENE_VERIFY_FUNCTION2'><filename>BB_SETSCENE_VERIFY_FUNCTION2</filename></link>
+            <link linkend='var-BB_SETSCENE_VERIFY_FUNCTION'><filename>BB_SETSCENE_VERIFY_FUNCTION</filename></link>
             with the list of tasks BitBake thinks has been "covered".
             The metadata can then ensure that this list is correct and can
             inform BitBake that it wants specific tasks to be run regardless

bitbake/doc/bitbake-user-manual/bitbake-user-manual-fetching.xml

@@ -38,7 +38,7 @@
             The code to execute the first part of this process, a fetch,
             looks something like the following:
             <literallayout class='monospaced'>
-     src_uri = (d.getVar('SRC_URI') or "").split()
+     src_uri = (d.getVar('SRC_URI', True) or "").split()
      fetcher = bb.fetch2.Fetch(src_uri, d)
      fetcher.download()
             </literallayout>
@@ -52,7 +52,7 @@
         <para>
             The instantiation of the fetch class is usually followed by:
             <literallayout class='monospaced'>
-     rootdir = l.getVar('WORKDIR')
+     rootdir = l.getVar('WORKDIR', True)
      fetcher.unpack(rootdir)
             </literallayout>
             This code unpacks the downloaded files to the
@@ -157,8 +157,8 @@
             <filename>SRC_URI</filename> variable with the appropriate
             varflags as follows:
             <literallayout class='monospaced'>
-     SRC_URI[md5sum] = "<replaceable>value</replaceable>"
-     SRC_URI[sha256sum] = "<replaceable>value</replaceable>"
+     SRC_URI[md5sum] = "value"
+     SRC_URI[sha256sum] = "value"
             </literallayout>
             You can also specify the checksums as parameters on the
             <filename>SRC_URI</filename> as shown below:
@@ -268,6 +268,15 @@
                 <link linkend='var-FILESPATH'><filename>FILESPATH</filename></link>
                 variable is used in the same way
                 <filename>PATH</filename> is used to find executables.
+                Failing that,
+                <link linkend='var-FILESDIR'><filename>FILESDIR</filename></link>
+                is used to find the appropriate relative file.
+                <note>
+                    <filename>FILESDIR</filename> is deprecated and can
+                    be replaced with <filename>FILESPATH</filename>.
+                    Because <filename>FILESDIR</filename> is likely to be
+                    removed, you should not use this variable in any new code.
+                </note>
                 If the file cannot be found, it is assumed that it is available in
                 <link linkend='var-DL_DIR'><filename>DL_DIR</filename></link>
                 by the time the <filename>download()</filename> method is called.
@@ -316,25 +325,6 @@
      SRC_URI = "ftp://you@oe.handhelds.org/home/you/secret.plan"
                 </literallayout>
             </para>
-            <note>
-               Because URL parameters are delimited by semi-colons, this can
-               introduce ambiguity when parsing URLs that also contain semi-colons,
-               for example:
-                <literallayout class='monospaced'>
-     SRC_URI = "http://abc123.org/git/?p=gcc/gcc.git;a=snapshot;h=a5dd47"
-                </literallayout>
-               Such URLs should should be modified by replacing semi-colons with '&amp;' characters:
-               <literallayout class='monospaced'>
-     SRC_URI = "http://abc123.org/git/?p=gcc/gcc.git&amp;a=snapshot&amp;h=a5dd47"
-                </literallayout>
-                In most cases this should work. Treating semi-colons and '&amp;' in queries
-                identically is recommended by the World Wide Web Consortium (W3C).
-                Note that due to the nature of the URL, you may have to specify the name
-                of the downloaded file as well:
-              <literallayout class='monospaced'>
-     SRC_URI = "http://abc123.org/git/?p=gcc/gcc.git&amp;a=snapshot&amp;h=a5dd47;downloadfilename=myfile.bz2"
-                </literallayout>
-            </note>
         </section>
 
         <section id='cvs-fetcher'>
@@ -355,7 +345,7 @@
                         A special value of "now" causes the checkout to
                         be updated on every build.
                         </para></listitem>
-                    <listitem><para><emphasis><link linkend='var-CVSDIR'><filename>CVSDIR</filename></link>:</emphasis>
+                    <listitem><para><emphasis><filename>CVSDIR</filename>:</emphasis>
                         Specifies where a temporary checkout is saved.
                         The location is often <filename>DL_DIR/cvs</filename>.
                         </para></listitem>
@@ -376,8 +366,7 @@
                 The supported parameters are as follows:
                 <itemizedlist>
                     <listitem><para><emphasis>"method":</emphasis>
-                        The protocol over which to communicate with the CVS
-                        server.
+                        The protocol over which to communicate with the CVS server.
                         By default, this protocol is "pserver".
                         If "method" is set to "ext", BitBake examines the
                         "rsh" parameter and sets <filename>CVS_RSH</filename>.
@@ -405,8 +394,7 @@
                         Effectively, you are renaming the output directory
                         to which the module is unpacked.
                         You are forcing the module into a special
-                        directory relative to
-                        <link linkend='var-CVSDIR'><filename>CVSDIR</filename></link>.
+                        directory relative to <filename>CVSDIR</filename>.
                         </para></listitem>
                     <listitem><para><emphasis>"rsh"</emphasis>
                         Used in conjunction with the "method" parameter.
@@ -447,9 +435,9 @@
                 The executable used is specified by
                 <filename>FETCHCMD_svn</filename>, which defaults
                 to "svn".
-                The fetcher's temporary working directory is set by
-                <link linkend='var-SVNDIR'><filename>SVNDIR</filename></link>,
-                which is usually <filename>DL_DIR/svn</filename>.
+                The fetcher's temporary working directory is set
+                by <filename>SVNDIR</filename>, which is usually
+                <filename>DL_DIR/svn</filename>.
             </para>
 
             <para>
@@ -461,29 +449,25 @@
                         You can think of this parameter as the top-level
                         directory of the repository data you want.
                         </para></listitem>
-                    <listitem><para><emphasis>"path_spec":</emphasis>
-                        A specific directory in which to checkout the
-                        specified svn module.
-                        </para></listitem>
                     <listitem><para><emphasis>"protocol":</emphasis>
                         The protocol to use, which defaults to "svn".
-                        If "protocol" is set to "svn+ssh", the "ssh"
-                        parameter is also used.
+                        Other options are "svn+ssh" and "rsh".
+                        For "rsh", the "rsh" parameter is also used.
                         </para></listitem>
                     <listitem><para><emphasis>"rev":</emphasis>
                         The revision of the source code to checkout.
                         </para></listitem>
+                    <listitem><para><emphasis>"date":</emphasis>
+                        The date of the source code to checkout.
+                        Specific revisions are generally much safer to checkout
+                        rather than by date as they do not involve timezones
+                        (e.g. they are much more deterministic).
+                        </para></listitem>
                     <listitem><para><emphasis>"scmdata":</emphasis>
                         Causes the “.svn” directories to be available during
                         compile-time when set to "keep".
                         By default, these directories are removed.
                         </para></listitem>
-                    <listitem><para><emphasis>"ssh":</emphasis>
-                        An optional parameter used when "protocol" is set
-                        to "svn+ssh".
-                        You can use this parameter to specify the ssh
-                        program used by svn.
-                        </para></listitem>
                     <listitem><para><emphasis>"transportuser":</emphasis>
                         When required, sets the username for the transport.
                         By default, this parameter is empty.
@@ -492,11 +476,10 @@
                         command.
                         </para></listitem>
                 </itemizedlist>
-                Following are three examples using svn:
+                Following are two examples using svn:
                 <literallayout class='monospaced'>
-     SRC_URI = "svn://myrepos/proj1;module=vip;protocol=http;rev=667"
-     SRC_URI = "svn://myrepos/proj1;module=opie;protocol=svn+ssh"
-     SRC_URI = "svn://myrepos/proj1;module=trunk;protocol=http;path_spec=${MY_DIR}/proj1"
+     SRC_URI = "svn://svn.oe.handhelds.org/svn;module=vip;proto=http;rev=667"
+     SRC_URI = "svn://svn.oe.handhelds.org/svn/;module=opie;proto=svn+ssh;date=20060126"
                 </literallayout>
             </para>
         </section>
@@ -508,9 +491,8 @@
                 This fetcher submodule fetches code from the Git
                 source control system.
                 The fetcher works by creating a bare clone of the
-                remote into
-                <link linkend='var-GITDIR'><filename>GITDIR</filename></link>,
-                which is usually <filename>DL_DIR/git2</filename>.
+                remote into <filename>GITDIR</filename>, which is
+                usually <filename>DL_DIR/git2</filename>.
                 This bare clone is then cloned into the work directory during the
                 unpack stage when a specific tree is checked out.
                 This is done using alternates and by reference to
@@ -644,7 +626,7 @@
                 <literallayout class='monospaced'>
      SRC_URI = "ccrc://cc.example.org/ccrc;vob=/example_vob;module=/example_module"
      SRCREV = "EXAMPLE_CLEARCASE_TAG"
-     PV = "${@d.getVar("SRCREV", False).replace("/", "+")}"
+     PV = "${@d.getVar("SRCREV").replace("/", "+")}"
                 </literallayout>
                 The fetcher uses the <filename>rcleartool</filename> or
                 <filename>cleartool</filename> remote client, depending on
@@ -662,19 +644,13 @@
                         </para></listitem>
                     <listitem><para><emphasis><filename>module</filename></emphasis>:
                         The module, which must include the
-                        prepending "/" character, in the selected VOB.
-                        <note>
-                            The <filename>module</filename> and <filename>vob</filename>
-                            options are combined to create the <filename>load</filename> rule in
-                            the view config spec.
-                            As an example, consider the <filename>vob</filename> and
-                            <filename>module</filename> values from the
-                            <filename>SRC_URI</filename> statement at the start of this section.
-                            Combining those values results in the following:
-                            <literallayout class='monospaced'>
-     load /example_vob/example_module
-                            </literallayout>
-                        </note>
+                        prepending "/" character, in the selected VOB
+                        The <filename>module</filename> and <filename>vob</filename>
+                        options are combined to create the following load rule in
+                        the view config spec:
+                        <literallayout class='monospaced'>
+     load &lt;vob&gt;&lt;module&gt;
+                        </literallayout>
                         </para></listitem>
                     <listitem><para><emphasis><filename>proto</filename></emphasis>:
                         The protocol, which can be either <filename>http</filename> or
@@ -713,68 +689,6 @@
             </para>
         </section>
 
-        <section id='perforce-fetcher'>
-            <title>Perforce Fetcher (<filename>p4://</filename>)</title>
-
-            <para>
-                This fetcher submodule fetches code from the
-                <ulink url='https://www.perforce.com/'>Perforce</ulink>
-                source control system.
-                The executable used is specified by
-                <filename>FETCHCMD_p4</filename>, which defaults
-                to "p4".
-                The fetcher's temporary working directory is set by
-                <link linkend='var-P4DIR'><filename>P4DIR</filename></link>,
-                which defaults to "DL_DIR/p4".
-            </para>
-
-            <para>
-                To use this fetcher, make sure your recipe has proper
-                <link linkend='var-SRC_URI'><filename>SRC_URI</filename></link>,
-                <link linkend='var-SRCREV'><filename>SRCREV</filename></link>, and
-                <link linkend='var-PV'><filename>PV</filename></link> values.
-                The p4 executable is able to use the config file defined by your
-                system's <filename>P4CONFIG</filename> environment variable in
-                order to define the Perforce server URL and port, username, and
-                password if you do not wish to keep those values in a recipe
-                itself.
-                If you choose not to use <filename>P4CONFIG</filename>,
-                or to explicitly set variables that <filename>P4CONFIG</filename>
-                can contain, you can specify the <filename>P4PORT</filename> value,
-                which is the server's URL and port number, and you can
-                specify a username and password directly in your recipe within
-                <filename>SRC_URI</filename>.
-            </para>
-
-            <para>
-                Here is an example that relies on <filename>P4CONFIG</filename>
-                to specify the server URL and port, username, and password, and
-                fetches the Head Revision:
-                <literallayout class='monospaced'>
-    SRC_URI = "p4://example-depot/main/source/..."
-    SRCREV = "${AUTOREV}"
-    PV = "p4-${SRCPV}"
-    S = "${WORKDIR}/p4"
-                </literallayout>
-            </para>
-
-            <para>
-                Here is an example that specifies the server URL and port,
-                username, and password, and fetches a Revision based on a Label:
-                <literallayout class='monospaced'>
-    P4PORT = "tcp:p4server.example.net:1666"
-    SRC_URI = "p4://user:passwd@example-depot/main/source/..."
-    SRCREV = "release-1.0"
-    PV = "p4-${SRCPV}"
-    S = "${WORKDIR}/p4"
-                </literallayout>
-                <note>
-                    You should always set <filename>S</filename>
-                    to <filename>"${WORKDIR}/p4"</filename> in your recipe.
-                </note>
-            </para>
-        </section>
-
         <section id='other-fetchers'>
             <title>Other Fetchers</title>
 
@@ -784,6 +698,9 @@
                     <listitem><para>
                         Bazaar (<filename>bzr://</filename>)
                         </para></listitem>
+                    <listitem><para>
+                        Perforce (<filename>p4://</filename>)
+                        </para></listitem>
                     <listitem><para>
                         Trees using Git Annex (<filename>gitannex://</filename>)
                         </para></listitem>

bitbake/doc/bitbake-user-manual/bitbake-user-manual-hello.xml

@@ -47,6 +47,7 @@
      -rw-rw-r--. 1 wmat wmat   849 Nov 26 04:55 HEADER
      drwxrwxr-x. 5 wmat wmat  4096 Jan 31 13:44 lib
      -rw-rw-r--. 1 wmat wmat   195 Nov 26 04:55 MANIFEST.in
+     -rwxrwxr-x. 1 wmat wmat  3195 Jan 31 11:57 setup.py
      -rw-rw-r--. 1 wmat wmat  2887 Nov 26 04:55 TODO
             </literallayout>
         </para>
@@ -134,7 +135,7 @@
                     <ulink url="http://www.mail-archive.com/yocto@yoctoproject.org/msg09379.html">Mailing List post - The BitBake equivalent of "Hello, World!"</ulink>
                     </para></listitem>
                 <listitem><para>
-                    <ulink url="http://hambedded.org/blog/2012/11/24/from-bitbake-hello-world-to-an-image/">Hambedded Linux blog post - From Bitbake Hello World to an Image</ulink>
+                    <ulink url="https://web.archive.org/web/20150325165911/http://hambedded.org/blog/2012/11/24/from-bitbake-hello-world-to-an-image/">Hambedded Linux blog post - From Bitbake Hello World to an Image</ulink>
                     </para></listitem>
             </itemizedlist>
         </note>
@@ -220,7 +221,7 @@
                 <para>From your shell, enter the following commands to set and
                 export the <filename>BBPATH</filename> variable:
                 <literallayout class='monospaced'>
-     $ BBPATH="<replaceable>projectdirectory</replaceable>"
+     $ BBPATH="&lt;projectdirectory&gt;"
      $ export BBPATH
                 </literallayout>
                 Use your actual project directory in the command.
@@ -269,7 +270,7 @@
                 and define some key BitBake variables.
                 For more information on the <filename>bitbake.conf</filename>,
                 see
-                <ulink url='http://hambedded.org/blog/2012/11/24/from-bitbake-hello-world-to-an-image/#an-overview-of-bitbakeconf'></ulink>
+                <ulink url='https://web.archive.org/web/20150325165911/http://hambedded.org/blog/2012/11/24/from-bitbake-hello-world-to-an-image/#an-overview-of-bitbakeconf'></ulink>
                 </para>
                 <para>Use the following commands to create the <filename>conf</filename>
                 directory in the project directory:
@@ -354,7 +355,7 @@ ERROR: Unable to parse base: ParseError in configuration INHERITs: Could not inh
                 supporting.
                 For more information on the <filename>base.bbclass</filename> file,
                 you can look at
-                <ulink url='http://hambedded.org/blog/2012/11/24/from-bitbake-hello-world-to-an-image/#tasks'></ulink>.
+                <ulink url='https://web.archive.org/web/20150325165911/http://hambedded.org/blog/2012/11/24/from-bitbake-hello-world-to-an-image/#tasks'></ulink>.
                 </para></listitem>
             <listitem><para><emphasis>Run Bitbake:</emphasis>
                 After making sure that the <filename>classes/base.bbclass</filename>
@@ -376,7 +377,7 @@ ERROR: Unable to parse base: ParseError in configuration INHERITs: Could not inh
                 Thus, this example creates and uses a layer called "mylayer".
                 <note>
                     You can find additional information on adding a layer at
-                    <ulink url='http://hambedded.org/blog/2012/11/24/from-bitbake-hello-world-to-an-image/#adding-an-example-layer'></ulink>.
+                    <ulink url='https://web.archive.org/web/20150325165911/http://hambedded.org/blog/2012/11/24/from-bitbake-hello-world-to-an-image/#adding-an-example-layer'></ulink>.
                 </note>
                 </para>
                 <para>Minimally, you need a recipe file and a layer configuration
@@ -399,7 +400,7 @@ ERROR: Unable to parse base: ParseError in configuration INHERITs: Could not inh
      <link linkend='var-BBFILES'>BBFILES</link> += "${LAYERDIR}/*.bb"
 
      <link linkend='var-BBFILE_COLLECTIONS'>BBFILE_COLLECTIONS</link> += "mylayer"
-     <link linkend='var-BBFILE_PATTERN'>BBFILE_PATTERN_mylayer</link> := "^${LAYERDIR_RE}/"
+     <link linkend='var-BBFILE_PATTERN'>BBFILE_PATTERN_mylayer</link> := "^${LAYERDIR}/"
                 </literallayout>
                 For information on these variables, click the links
                 to go to the definitions in the glossary.</para>
@@ -470,7 +471,7 @@ ERROR: Unable to parse base: ParseError in configuration INHERITs: Could not inh
      Time: 00:00:00
      Parsing of 1 .bb files complete (0 cached, 1 parsed). 1 targets, 0 skipped, 0 masked, 0 errors.
      NOTE: Resolving any missing task queue dependencies
-     NOTE: Preparing RunQueue
+     NOTE: Preparing runqueue
      NOTE: Executing RunQueue Tasks
      ********************
      *                  *

bitbake/doc/bitbake-user-manual/bitbake-user-manual-intro.xml

@@ -471,7 +471,7 @@
                 Following is the usage and syntax for BitBake:
                 <literallayout class='monospaced'>
      $ bitbake -h
-     Usage: bitbake [options] [recipename/target recipe:do_task ...]
+     Usage: bitbake [options] [recipename/target ...]
 
          Executes the specified task (default is 'build') for a given set of target recipes (.bb files).
          It is assumed there is a conf/bblayers.conf available in cwd or in BBPATH which
@@ -504,19 +504,9 @@
                              Read the specified file before bitbake.conf.
        -R POSTFILE, --postread=POSTFILE
                              Read the specified file after bitbake.conf.
-       -v, --verbose         Enable tracing of shell tasks (with 'set -x').
-                             Also print bb.note(...) messages to stdout (in
-                             addition to writing them to ${T}/log.do_&lt;task&gt;).
-       -D, --debug           Increase the debug level. You can specify this
-                             more than once. -D sets the debug level to 1,
-                             where only bb.debug(1, ...) messages are printed
-                             to stdout; -DD sets the debug level to 2, where
-                             both bb.debug(1, ...) and bb.debug(2, ...)
-                             messages are printed; etc. Without -D, no debug
-                             messages are printed. Note that -D only affects
-                             output to stdout. All debug messages are written
-                             to ${T}/log.do_taskname, regardless of the debug
-                             level.
+       -v, --verbose         Output more log message data to the terminal.
+       -D, --debug           Increase the debug level. You can specify this more
+                             than once.
        -n, --dry-run         Don't execute, just go through the motions.
        -S SIGNATURE_HANDLER, --dump-signatures=SIGNATURE_HANDLER
                              Dump out the signature construction information, with
@@ -539,11 +529,9 @@
        -l DEBUG_DOMAINS, --log-domains=DEBUG_DOMAINS
                              Show debug logging for the specified logging domains
        -P, --profile         Profile the command and save reports.
-       -u UI, --ui=UI        The user interface to use (taskexp, knotty or
-                             ncurses - default knotty).
+       -u UI, --ui=UI        The user interface to use (e.g. knotty, hob, depexp).
        -t SERVERTYPE, --servertype=SERVERTYPE
-                             Choose which server type to use (process or xmlrpc -
-                             default process).
+                             Choose which server to use, process or xmlrpc.
        --token=XMLRPCTOKEN   Specify the connection token to be used when
                              connecting to a remote server.
        --revisions-changed   Set the exit code depending on whether upstream
@@ -553,16 +541,11 @@
        -B BIND, --bind=BIND  The name/address for the bitbake server to bind to.
        --no-setscene         Do not run any setscene tasks. sstate will be ignored
                              and everything needed, built.
-       --setscene-only       Only run setscene tasks, don't run any real tasks.
        --remote-server=REMOTE_SERVER
                              Connect to the specified server.
        -m, --kill-server     Terminate the remote server.
        --observe-only        Connect to a server as an observing-only client.
        --status-only         Check the status of the remote bitbake server.
-       -w WRITEEVENTLOG, --write-log=WRITEEVENTLOG
-                             Writes the event log of the build to a bitbake event
-                             json file. Use '' (empty string) to assign the name
-                             automatically.
                 </literallayout>
             </para>
         </section>
@@ -645,25 +628,6 @@
                 </para>
             </section>
 
-            <section id='executing-a-list-of-task-and-recipe-combinations'>
-                <title>Executing a List of Task and Recipe Combinations</title>
-
-                <para>
-                    The BitBake command line supports specifying different
-                    tasks for individual targets when you specify multiple
-                    targets.
-                    For example, suppose you had two targets (or recipes)
-                    <filename>myfirstrecipe</filename> and
-                    <filename>mysecondrecipe</filename> and you needed
-                    BitBake to run <filename>taskA</filename> for the first
-                    recipe and <filename>taskB</filename> for the second
-                    recipe:
-                    <literallayout class='monospaced'>
-     $ bitbake myfirstrecipe:do_taskA mysecondrecipe:do_taskB
-                    </literallayout>
-                </para>
-            </section>
-
             <section id='generating-dependency-graphs'>
                 <title>Generating Dependency Graphs</title>
 
@@ -676,21 +640,21 @@
                 </para>
 
                 <para>
-                    When you generate a dependency graph, BitBake writes three files
+                    When you generate a dependency graph, BitBake writes four files
                     to the current working directory:
                     <itemizedlist>
-                        <listitem><para>
-                            <emphasis><filename>recipe-depends.dot</filename>:</emphasis>
-                            Shows dependencies between recipes (i.e. a collapsed version of
-                            <filename>task-depends.dot</filename>).
+                        <listitem><para><emphasis><filename>package-depends.dot</filename>:</emphasis>
+                            Shows BitBake's knowledge of dependencies between
+                            runtime targets.
                             </para></listitem>
-                        <listitem><para>
-                            <emphasis><filename>task-depends.dot</filename>:</emphasis>
+                        <listitem><para><emphasis><filename>pn-depends.dot</filename>:</emphasis>
+                            Shows dependencies between build-time targets
+                            (i.e. recipes).
+                            </para></listitem>
+                        <listitem><para><emphasis><filename>task-depends.dot</filename>:</emphasis>
                             Shows dependencies between tasks.
-                            These dependencies match BitBake's internal task execution list.
                             </para></listitem>
-                        <listitem><para>
-                            <emphasis><filename>pn-buildlist</filename>:</emphasis>
+                        <listitem><para><emphasis><filename>pn-buildlist</filename>:</emphasis>
                             Shows a simple list of targets that are to be built.
                             </para></listitem>
                     </itemizedlist>

bitbake/doc/bitbake-user-manual/bitbake-user-manual-ref-variables.xml

@@ -43,8 +43,8 @@
        <link linkend='var-DEFAULT_PREFERENCE'>D</link>
        <link linkend='var-EXCLUDE_FROM_WORLD'>E</link>
        <link linkend='var-FAKEROOT'>F</link>
-       <link linkend='var-GITDIR'>G</link>
-       <link linkend='var-HGDIR'>H</link>
+<!--       <link linkend='var-GROUPADD_PARAM'>G</link> -->
+       <link linkend='var-HOMEPAGE'>H</link>
 <!--       <link linkend='var-ICECC_DISABLED'>I</link> -->
 <!--               <link linkend='var-glossary-j'>J</link> -->
 <!--       <link linkend='var-KARCH'>K</link> -->
@@ -52,7 +52,7 @@
        <link linkend='var-MIRRORS'>M</link>
 <!--               <link linkend='var-glossary-n'>N</link> -->
        <link linkend='var-OVERRIDES'>O</link>
-       <link linkend='var-P4DIR'>P</link>
+       <link linkend='var-PACKAGES'>P</link>
 <!--       <link linkend='var-QMAKE_PROFILES'>Q</link> -->
        <link linkend='var-RDEPENDS'>R</link>
        <link linkend='var-SECTION'>S</link>
@@ -102,56 +102,6 @@
             </glossdef>
         </glossentry>
 
-        <glossentry id='var-BB_ALLOWED_NETWORKS'><glossterm>BB_ALLOWED_NETWORKS</glossterm>
-            <glossdef>
-                <para>
-                    Specifies a space-delimited list of hosts that the fetcher
-                    is allowed to use to obtain the required source code.
-                    Following are considerations surrounding this variable:
-                    <itemizedlist>
-                        <listitem><para>
-                            This host list is only used if
-                            <link linkend='var-BB_NO_NETWORK'><filename>BB_NO_NETWORK</filename></link>
-                            is either not set or set to "0".
-                            </para></listitem>
-                        <listitem><para>
-                            Limited support for wildcard matching against the
-                            beginning of host names exists.
-                            For example, the following setting matches
-                            <filename>git.gnu.org</filename>,
-                            <filename>ftp.gnu.org</filename>, and
-                            <filename>foo.git.gnu.org</filename>.
-                            <literallayout class='monospaced'>
-     BB_ALLOWED_NETWORKS = "*.gnu.org"
-                            </literallayout>
-                            </para></listitem>
-                        <listitem><para>
-                            Mirrors not in the host list are skipped and
-                            logged in debug.
-                            </para></listitem>
-                        <listitem><para>
-                            Attempts to access networks not in the host list
-                            cause a failure.
-                            </para></listitem>
-                    </itemizedlist>
-                    Using <filename>BB_ALLOWED_NETWORKS</filename> in
-                    conjunction with
-                    <link linkend='var-PREMIRRORS'><filename>PREMIRRORS</filename></link>
-                    is very useful.
-                    Adding the host you want to use to
-                    <filename>PREMIRRORS</filename> results in the source code
-                    being fetched from an allowed location and avoids raising
-                    an error when a host that is not allowed is in a
-                    <link linkend='var-SRC_URI'><filename>SRC_URI</filename></link>
-                    statement.
-                    This is because the fetcher does not attempt to use the
-                    host listed in <filename>SRC_URI</filename> after a
-                    successful fetch from the
-                    <filename>PREMIRRORS</filename> occurs.
-                </para>
-            </glossdef>
-        </glossentry>
-
         <glossentry id='var-BB_CONSOLELOG'><glossterm>BB_CONSOLELOG</glossterm>
             <glossdef>
                 <para>
@@ -716,7 +666,7 @@
             </glossdef>
         </glossentry>
 
-        <glossentry id='var-BB_SETSCENE_VERIFY_FUNCTION2'><glossterm>BB_SETSCENE_VERIFY_FUNCTION2</glossterm>
+        <glossentry id='var-BB_SETSCENE_VERIFY_FUNCTION'><glossterm>BB_SETSCENE_VERIFY_FUNCTION</glossterm>
             <glossdef>
                 <para>
                     Specifies a function to call that verifies the list of
@@ -856,56 +806,6 @@
             </glossdef>
         </glossentry>
 
-        <glossentry id='var-BB_TASK_IONICE_LEVEL'><glossterm>BB_TASK_IONICE_LEVEL</glossterm>
-            <glossdef>
-                <para>
-                    Allows adjustment of a task's Input/Output priority.
-                    During Autobuilder testing, random failures can occur
-                    for tasks due to I/O starvation.
-                    These failures occur during various QEMU runtime timeouts.
-                    You can use the <filename>BB_TASK_IONICE_LEVEL</filename>
-                    variable to adjust the I/O priority of these tasks.
-                    <note>
-                        This variable works similarly to the
-                        <link linkend='var-BB_TASK_NICE_LEVEL'><filename>BB_TASK_NICE_LEVEL</filename></link>
-                        variable except with a task's I/O priorities.
-                    </note>
-                </para>
-
-                <para>
-                    Set the variable as follows:
-                    <literallayout class='monospaced'>
-     BB_TASK_IONICE_LEVEL = "<replaceable>class</replaceable>.<replaceable>prio</replaceable>"
-                    </literallayout>
-                    For <replaceable>class</replaceable>, the default value is
-                    "2", which is a best effort.
-                    You can use "1" for realtime and "3" for idle.
-                    If you want to use realtime, you must have superuser
-                    privileges.
-                </para>
-
-                <para>
-                    For <replaceable>prio</replaceable>, you can use any
-                    value from "0", which is the highest priority, to "7",
-                    which is the lowest.
-                    The default value is "4".
-                    You do not need any special privileges to use this range
-                    of priority values.
-                    <note>
-                        In order for your I/O priority settings to take effect,
-                        you need the Completely Fair Queuing (CFQ) Scheduler
-                        selected for the backing block device.
-                        To select the scheduler, use the following command form
-                        where <replaceable>device</replaceable> is the device
-                        (e.g. sda, sdb, and so forth):
-                        <literallayout class='monospaced'>
-      $ sudo sh -c “echo cfq > /sys/block/<replaceable>device</replaceable>/queu/scheduler
-                        </literallayout>
-                    </note>
-                </para>
-            </glossdef>
-        </glossentry>
-
         <glossentry id='var-BB_TASK_NICE_LEVEL'><glossterm>BB_TASK_NICE_LEVEL</glossterm>
             <glossdef>
                 <para>
@@ -972,7 +872,7 @@
                     that run on the target <filename>MACHINE</filename>;
                     "nativesdk", which targets the SDK machine instead of
                     <filename>MACHINE</filename>; and "mulitlibs" in the form
-                    "<filename>multilib:</filename><replaceable>multilib_name</replaceable>".
+                    "<filename>multilib:&lt;multilib_name&gt;</filename>".
                 </para>
 
                 <para>
@@ -984,31 +884,8 @@
                     metadata:
                     <literallayout class='monospaced'>
      BBCLASSEXTEND =+ "native nativesdk"
-     BBCLASSEXTEND =+ "multilib:<replaceable>multilib_name</replaceable>"
+     BBCLASSEXTEND =+ "multilib:&lt;multilib_name&gt;"
                     </literallayout>
-                    <note>
-                        <para>
-                        Internally, the <filename>BBCLASSEXTEND</filename>
-                        mechanism generates recipe variants by rewriting
-                        variable values and applying overrides such as
-                        <filename>_class-native</filename>.
-                        For example, to generate a native version of a recipe,
-                        a
-                        <link linkend='var-DEPENDS'><filename>DEPENDS</filename></link>
-                        on "foo" is rewritten to a <filename>DEPENDS</filename>
-                        on "foo-native".
-                        </para>
-
-                        <para>
-                        Even when using <filename>BBCLASSEXTEND</filename>, the
-                        recipe is only parsed once.
-                        Parsing once adds some limitations.
-                        For example, it is not possible to
-                        include a different file depending on the variant,
-                        since <filename>include</filename> statements are
-                        processed when the recipe is parsed.
-                        </para>
-                    </note>
                 </para>
              </glossdef>
         </glossentry>
@@ -1017,7 +894,7 @@
             <glossdef>
                 <para>
                     Sets the BitBake debug output level to a specific value
-                    as incremented by the <filename>-D</filename> command line
+                    as incremented by the <filename>-d</filename> command line
                     option.
                     <note>
                         You must set this variable in the external environment
@@ -1139,20 +1016,6 @@
             </glossdef>
         </glossentry>
 
-        <glossentry id='var-BBLAYERS_FETCH_DIR'><glossterm>BBLAYERS_FETCH_DIR</glossterm>
-            <glossdef>
-                <para>
-                    Sets the base location where layers are stored.
-                    By default, this location is set to
-                    <filename>${COREBASE}</filename>.
-                    This setting is used in conjunction with
-                    <filename>bitbake-layers layerindex-fetch</filename> and
-                    tells <filename>bitbake-layers</filename> where to place
-                    the fetched layers.
-                </para>
-            </glossdef>
-        </glossentry>
-
         <glossentry id='var-BBMASK'><glossterm>BBMASK</glossterm>
             <glossdef>
                 <para>
@@ -1165,14 +1028,14 @@
                     to "hide" these <filename>.bb</filename> and
                     <filename>.bbappend</filename> files.
                     BitBake ignores any recipe or recipe append files that
-                    match any of the expressions.
+                    match the expression.
                     It is as if BitBake does not see them at all.
                     Consequently, matching files are not parsed or otherwise
                     used by BitBake.</para>
                 <para>
-                    The values you provide are passed to Python's regular
+                    The value you provide is passed to Python's regular
                     expression compiler.
-                    The expressions are compared against the full paths to
+                    The expression is compared against the full paths to
                     the files.
                     For complete syntax information, see Python's
                     documentation at
@@ -1188,16 +1051,18 @@
      BBMASK = "meta-ti/recipes-misc/"
                     </literallayout>
                     If you want to mask out multiple directories or recipes,
-                    you can specify multiple regular expression fragments.
+                    use the vertical bar to separate the regular expression
+                    fragments.
                     This next example masks out multiple directories and
                     individual recipes:
                     <literallayout class='monospaced'>
-     BBMASK += "/meta-ti/recipes-misc/ meta-ti/recipes-ti/packagegroup/"
-     BBMASK += "/meta-oe/recipes-support/"
-     BBMASK += "/meta-foo/.*/openldap"
-     BBMASK += "opencv.*\.bbappend"
-     BBMASK += "lzma"
+     BBMASK = "meta-ti/recipes-misc/|meta-ti/recipes-ti/packagegroup/"
+     BBMASK .= "|.*meta-oe/recipes-support/"
+     BBMASK .= "|.*openldap"
+     BBMASK .= "|.*opencv"
+     BBMASK .= "|.*lzma"
                     </literallayout>
+                    Notice how the vertical bar is used to append the fragments.
                     <note>
                         When specifying a directory name, use the trailing
                         slash character to ensure you match just that directory
@@ -1226,9 +1091,9 @@
                     Set the variable as you would any environment variable
                     and then run BitBake:
                     <literallayout class='monospaced'>
-     $ BBPATH="<replaceable>build_directory</replaceable>"
+     $ BBPATH="&lt;build_directory&gt;"
      $ export BBPATH
-     $ bitbake <replaceable>target</replaceable>
+     $ bitbake &lt;target&gt;
                     </literallayout>
                 </para>
             </glossdef>
@@ -1244,15 +1109,6 @@
             </glossdef>
         </glossentry>
 
-        <glossentry id='var-BBTARGETS'><glossterm>BBTARGETS</glossterm>
-            <glossdef>
-                <para>
-                    Allows you to use a configuration file to add to the list
-                    of command-line target recipes you want to build.
-                </para>
-            </glossdef>
-        </glossentry>
-
         <glossentry id='var-BBVERSIONS'><glossterm>BBVERSIONS</glossterm>
             <glossdef>
                 <para>
@@ -1298,15 +1154,6 @@
             </glossdef>
         </glossentry>
 
-        <glossentry id='var-BZRDIR'><glossterm>BZRDIR</glossterm>
-            <glossdef>
-                <para>
-                    The directory in which files checked out of a Bazaar
-                    system are stored.
-                </para>
-            </glossdef>
-        </glossentry>
-
     </glossdiv>
 
     <glossdiv id='var-glossary-c'><title>C</title>
@@ -1321,15 +1168,6 @@
             </glossdef>
         </glossentry>
 
-        <glossentry id='var-CVSDIR'><glossterm>CVSDIR</glossterm>
-            <glossdef>
-                <para>
-                    The directory in which files checked out under the
-                    CVS system are stored.
-                </para>
-            </glossdef>
-        </glossentry>
-
     </glossdiv>
 
     <glossdiv id='var-glossary-d'><title>D</title>
@@ -1539,6 +1377,24 @@
             </glossdef>
         </glossentry>
 
+        <glossentry id='var-FILESDIR'><glossterm>FILESDIR</glossterm>
+            <glossdef>
+                <para>
+                    Specifies directories BitBake uses when searching for
+                    patches and files.
+                    The "local" fetcher module uses these directories when
+                    handling <filename>file://</filename> URLs if the file
+                    was not found using
+                    <link linkend='var-FILESPATH'><filename>FILESPATH</filename></link>.
+                    <note>
+                        The <filename>FILESDIR</filename> variable is
+                        deprecated and you should use
+                        <filename>FILESPATH</filename> in all new code.
+                    </note>
+                </para>
+            </glossdef>
+        </glossentry>
+
         <glossentry id='var-FILESPATH'><glossterm>FILESPATH</glossterm>
             <glossdef>
                 <para>
@@ -1556,32 +1412,13 @@
 
     </glossdiv>
 
-
+<!--
     <glossdiv id='var-glossary-g'><title>G</title>
-
-        <glossentry id='var-GITDIR'><glossterm>GITDIR</glossterm>
-            <glossdef>
-                <para>
-                    The directory in which a local copy of a Git repository
-                    is stored when it is cloned.
-                </para>
-            </glossdef>
-        </glossentry>
-
     </glossdiv>
-
+-->
 
     <glossdiv id='var-glossary-h'><title>H</title>
 
-        <glossentry id='var-HGDIR'><glossterm>HGDIR</glossterm>
-            <glossdef>
-                <para>
-                    The directory in which files checked out of a Mercurial
-                    system are stored.
-                </para>
-            </glossdef>
-        </glossentry>
-
         <glossentry id='var-HOMEPAGE'><glossterm>HOMEPAGE</glossterm>
             <glossdef>
                 <para>Website where more information about the software the recipe is building
@@ -1641,17 +1478,6 @@
             </glossdef>
         </glossentry>
 
-        <glossentry id='var-LAYERDIR_RE'><glossterm>LAYERDIR_RE</glossterm>
-            <glossdef>
-                <para>When used inside the <filename>layer.conf</filename> configuration
-                    file, this variable provides the path of the current layer,
-                    escaped for use in a regular expression
-                    (<link linkend='var-BBFILE_PATTERN'><filename>BBFILE_PATTERN</filename></link>).
-                    This variable is not available outside of <filename>layer.conf</filename>
-                    and references are expanded immediately when parsing of the file completes.</para>
-            </glossdef>
-        </glossentry>
-
         <glossentry id='var-LAYERVERSION'><glossterm>LAYERVERSION</glossterm>
             <glossdef>
                 <para>Optionally specifies the version of a layer as a single number.
@@ -1753,15 +1579,6 @@
 
     <glossdiv id='var-glossary-p'><title>P</title>
 
-        <glossentry id='var-P4DIR'><glossterm>P4DIR</glossterm>
-            <glossdef>
-                <para>
-                    The directory in which a local copy of a Perforce depot
-                    is stored when it is fetched.
-                </para>
-            </glossdef>
-        </glossentry>
-
         <glossentry id='var-PACKAGES'><glossterm>PACKAGES</glossterm>
             <glossdef>
                 <para>The list of packages the recipe creates.
@@ -1958,27 +1775,6 @@
                     The <filename>PROVIDES</filename> statement results in
                     the "libav" recipe also being known as "libpostproc".
                 </para>
-
-                <para>
-                    In addition to providing recipes under alternate names,
-                    the <filename>PROVIDES</filename> mechanism is also used
-                    to implement virtual targets.
-                    A virtual target is a name that corresponds to some
-                    particular functionality (e.g. a Linux kernel).
-                    Recipes that provide the functionality in question list the
-                    virtual target in <filename>PROVIDES</filename>.
-                    Recipes that depend on the functionality in question can
-                    include the virtual target in
-                    <link linkend='var-DEPENDS'><filename>DEPENDS</filename></link>
-                    to leave the choice of provider open.
-                </para>
-
-                <para>
-                    Conventionally, virtual targets have names on the form
-                    "virtual/function" (e.g. "virtual/kernel").
-                    The slash is simply part of the name and has no
-                    syntactical significance.
-                </para>
             </glossdef>
         </glossentry>
 
@@ -2055,7 +1851,7 @@
                     Here is the general syntax to specify versions with
                     the <filename>RDEPENDS</filename> variable:
                     <literallayout class='monospaced'>
-     RDEPENDS_${PN} = "<replaceable>package</replaceable> (<replaceable>operator</replaceable> <replaceable>version</replaceable>)"
+     RDEPENDS_${PN} = "&lt;package&gt; (&lt;operator&gt; &lt;version&gt;)"
                     </literallayout>
                     For <filename>operator</filename>, you can specify the
                     following:
@@ -2121,7 +1917,7 @@
                     Here is the general syntax to specify versions with
                     the <filename>RRECOMMENDS</filename> variable:
                     <literallayout class='monospaced'>
-     RRECOMMENDS_${PN} = "<replaceable>package</replaceable> (<replaceable>operator</replaceable> <replaceable>version</replaceable>)"
+     RRECOMMENDS_${PN} = "&lt;package&gt; (&lt;operator&gt; &lt;version&gt;)"
                     </literallayout>
                     For <filename>operator</filename>, you can specify the
                     following:
@@ -2304,15 +2100,6 @@
             </glossdef>
         </glossentry>
 
-        <glossentry id='var-SVNDIR'><glossterm>SVNDIR</glossterm>
-            <glossdef>
-                <para>
-                    The directory in which files checked out of a Subversion
-                    system are stored.
-                </para>
-            </glossdef>
-        </glossentry>
-
     </glossdiv>
 
     <glossdiv id='var-glossary-t'><title>T</title>

bitbake/doc/bitbake-user-manual/bitbake-user-manual.xml

@@ -56,7 +56,7 @@
 -->
 
         <copyright>
-            <year>2004-2016</year>
+            <year>2004-2015</year>
             <holder>Richard Purdie</holder>
             <holder>Chris Larson</holder>
             <holder>and Phil Blundell</holder>

bitbake/doc/bitbake.1

@@ -105,7 +105,7 @@ Show debug logging for the specified logging domains
 profile the command and print a report
 .TP
 .B \-uUI, \-\-ui=UI
-User interface to use. Currently, knotty, taskexp or ncurses can be specified as UI.
+User interface to use. Currently, hob, depexp, goggle or ncurses can be specified as UI.
 .TP
 .B \-tSERVERTYPE, \-\-servertype=SERVERTYPE
 Choose which server to use, none, process or xmlrpc.

bitbake/lib/bb/COW.py

@@ -23,17 +23,19 @@
 # Assign a file to __warn__ to get warnings about slow operations.
 #
 
-
+from __future__ import print_function
 import copy
 import types
 ImmutableTypes = (
+    types.NoneType,
     bool,
     complex,
     float,
     int,
+    long,
     tuple,
     frozenset,
-    str
+    basestring
 )
 
 MUTABLE = "__mutable__"
@@ -59,7 +61,7 @@ class COWDictMeta(COWMeta):
     __call__ = cow
 
     def __setitem__(cls, key, value):
-        if value is not None and not isinstance(value, ImmutableTypes):
+        if not isinstance(value, ImmutableTypes):
             if not isinstance(value, COWMeta):
                 cls.__hasmutable__ = True
             key += MUTABLE
@@ -114,7 +116,7 @@ class COWDictMeta(COWMeta):
         cls.__setitem__(key, cls.__marker__)
 
     def __revertitem__(cls, key):
-        if key not in cls.__dict__:
+        if not cls.__dict__.has_key(key):
             key += MUTABLE
         delattr(cls, key)
 
@@ -181,7 +183,7 @@ class COWSetMeta(COWDictMeta):
         COWDictMeta.__delitem__(cls, repr(hash(value)))
 
     def __in__(cls, value):
-        return repr(hash(value)) in COWDictMeta
+        return COWDictMeta.has_key(repr(hash(value)))
 
     def iterkeys(cls):
         raise TypeError("sets don't have keys")
@@ -190,10 +192,12 @@ class COWSetMeta(COWDictMeta):
         raise TypeError("sets don't have 'items'")
 
 # These are the actual classes you use!
-class COWDictBase(object, metaclass = COWDictMeta):
+class COWDictBase(object):
+    __metaclass__ = COWDictMeta
     __count__ = 0
 
-class COWSetBase(object, metaclass = COWSetMeta):
+class COWSetBase(object):
+    __metaclass__ = COWSetMeta
     __count__ = 0
 
 if __name__ == "__main__":
@@ -283,7 +287,7 @@ if __name__ == "__main__":
     except KeyError:
         print("Yay! deleted key raises error")
 
-    if 'b' in b:
+    if b.has_key('b'):
         print("Boo!")
     else:
         print("Yay - has_key with delete works!")

bitbake/lib/bb/__init__.py

@@ -21,11 +21,11 @@
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
-__version__ = "1.34.0"
+__version__ = "1.24.0"
 
 import sys
-if sys.version_info < (3, 4, 0):
-    raise RuntimeError("Sorry, python 3.4.0 or later is required for this version of bitbake")
+if sys.version_info < (2, 7, 3):
+    raise RuntimeError("Sorry, python 2.7.3 or later is required for this version of bitbake")
 
 
 class BBHandledException(Exception):
@@ -70,8 +70,6 @@ logger = logging.getLogger("BitBake")
 logger.addHandler(NullHandler())
 logger.setLevel(logging.DEBUG - 2)
 
-mainlogger = logging.getLogger("BitBake.Main")
-
 # This has to be imported after the setLoggerClass, as the import of bb.msg
 # can result in construction of the various loggers.
 import bb.msg
@@ -81,26 +79,26 @@ sys.modules['bb.fetch'] = sys.modules['bb.fetch2']
 
 # Messaging convenience functions
 def plain(*args):
-    mainlogger.plain(''.join(args))
+    logger.plain(''.join(args))
 
 def debug(lvl, *args):
-    if isinstance(lvl, str):
-        mainlogger.warning("Passed invalid debug level '%s' to bb.debug", lvl)
+    if isinstance(lvl, basestring):
+        logger.warn("Passed invalid debug level '%s' to bb.debug", lvl)
         args = (lvl,) + args
         lvl = 1
-    mainlogger.debug(lvl, ''.join(args))
+    logger.debug(lvl, ''.join(args))
 
 def note(*args):
-    mainlogger.info(''.join(args))
+    logger.info(''.join(args))
 
 def warn(*args):
-    mainlogger.warning(''.join(args))
+    logger.warn(''.join(args))
 
-def error(*args, **kwargs):
-    mainlogger.error(''.join(args), extra=kwargs)
+def error(*args):
+    logger.error(''.join(args))
 
-def fatal(*args, **kwargs):
-    mainlogger.critical(''.join(args), extra=kwargs)
+def fatal(*args):
+    logger.critical(''.join(args))
     raise BBHandledException()
 
 def deprecated(func, name=None, advice=""):

bitbake/lib/bb/build.py

@@ -31,43 +31,23 @@ import logging
 import shlex
 import glob
 import time
-import stat
 import bb
 import bb.msg
 import bb.process
-import bb.progress
-from bb import data, event, utils
+from contextlib import nested
+from bb import event, utils
 
 bblogger = logging.getLogger('BitBake')
 logger = logging.getLogger('BitBake.Build')
 
 NULL = open(os.devnull, 'r+')
 
-__mtime_cache = {}
-
-def cached_mtime_noerror(f):
-    if f not in __mtime_cache:
-        try:
-            __mtime_cache[f] = os.stat(f)[stat.ST_MTIME]
-        except OSError:
-            return 0
-    return __mtime_cache[f]
-
-def reset_cache():
-    global __mtime_cache
-    __mtime_cache = {}
-
 # When we execute a Python function, we'd like certain things
 # in all namespaces, hence we add them to __builtins__.
 # If we do not do this and use the exec globals, they will
 # not be available to subfunctions.
-if hasattr(__builtins__, '__setitem__'):
-    builtins = __builtins__
-else:
-    builtins = __builtins__.__dict__
-
-builtins['bb'] = bb
-builtins['os'] = os
+__builtins__['bb'] = bb
+__builtins__['os'] = os
 
 class FuncFailed(Exception):
     def __init__(self, name = None, logfile = None):
@@ -91,14 +71,13 @@ class TaskBase(event.Event):
 
     def __init__(self, t, logfile, d):
         self._task = t
-        self._package = d.getVar("PF")
-        self._mc = d.getVar("BB_CURRENT_MC")
-        self.taskfile = d.getVar("FILE")
+        self._package = d.getVar("PF", True)
+        self.taskfile = d.getVar("FILE", True)
         self.taskname = self._task
         self.logfile = logfile
         self.time = time.time()
         event.Event.__init__(self)
-        self._message = "recipe %s: task %s: %s" % (d.getVar("PF"), t, self.getDisplayName())
+        self._message = "recipe %s: task %s: %s" % (d.getVar("PF", True), t, self.getDisplayName())
 
     def getTask(self):
         return self._task
@@ -139,25 +118,6 @@ class TaskInvalid(TaskBase):
         super(TaskInvalid, self).__init__(task, None, metadata)
         self._message = "No such task '%s'" % task
 
-class TaskProgress(event.Event):
-    """
-    Task made some progress that could be reported to the user, usually in
-    the form of a progress bar or similar.
-    NOTE: this class does not inherit from TaskBase since it doesn't need
-    to - it's fired within the task context itself, so we don't have any of
-    the context information that you do in the case of the other events.
-    The event PID can be used to determine which task it came from.
-    The progress value is normally 0-100, but can also be negative
-    indicating that progress has been made but we aren't able to determine
-    how much.
-    The rate is optional, this is simply an extra string to display to the
-    user if specified.
-    """
-    def __init__(self, progress, rate=None):
-        self.progress = progress
-        self.rate = rate
-        event.Event.__init__(self)
-
 
 class LogTee(object):
     def __init__(self, logger, outfile):
@@ -181,27 +141,23 @@ class LogTee(object):
     def flush(self):
         self.outfile.flush()
 
-#
-# pythonexception allows the python exceptions generated to be raised
-# as the real exceptions (not FuncFailed) and without a backtrace at the 
-# origin of the failure.
-#
-def exec_func(func, d, dirs = None, pythonexception=False):
+def exec_func(func, d, dirs = None):
     """Execute a BB 'function'"""
 
-    try:
-        oldcwd = os.getcwd()
-    except:
-        oldcwd = None
+    body = d.getVar(func)
+    if not body:
+        if body is None:
+            logger.warn("Function %s doesn't exist", func)
+        return
 
     flags = d.getVarFlags(func)
-    cleandirs = flags.get('cleandirs') if flags else None
+    cleandirs = flags.get('cleandirs')
     if cleandirs:
         for cdir in d.expand(cleandirs).split():
             bb.utils.remove(cdir, True)
             bb.utils.mkdirhier(cdir)
 
-    if flags and dirs is None:
+    if dirs is None:
         dirs = flags.get('dirs')
         if dirs:
             dirs = d.expand(dirs).split()
@@ -211,13 +167,8 @@ def exec_func(func, d, dirs = None, pythonexception=False):
             bb.utils.mkdirhier(adir)
         adir = dirs[-1]
     else:
-        adir = None
-
-    body = d.getVar(func, False)
-    if not body:
-        if body is None:
-            logger.warning("Function %s doesn't exist", func)
-        return
+        adir = d.getVar('B', True)
+        bb.utils.mkdirhier(adir)
 
     ispython = flags.get('python')
 
@@ -227,17 +178,17 @@ def exec_func(func, d, dirs = None, pythonexception=False):
     else:
         lockfiles = None
 
-    tempdir = d.getVar('T')
+    tempdir = d.getVar('T', True)
 
     # or func allows items to be executed outside of the normal
     # task set, such as buildhistory
-    task = d.getVar('BB_RUNTASK') or func
+    task = d.getVar('BB_RUNTASK', True) or func
     if task == func:
         taskfunc = task
     else:
         taskfunc = "%s.%s" % (task, func)
 
-    runfmt = d.getVar('BB_RUNFMT') or "run.{func}.{pid}"
+    runfmt = d.getVar('BB_RUNFMT', True) or "run.{func}.{pid}"
     runfn = runfmt.format(taskfunc=taskfunc, task=task, func=func, pid=os.getpid())
     runfile = os.path.join(tempdir, runfn)
     bb.utils.mkdirhier(os.path.dirname(runfile))
@@ -258,30 +209,22 @@ def exec_func(func, d, dirs = None, pythonexception=False):
 
     with bb.utils.fileslocked(lockfiles):
         if ispython:
-            exec_func_python(func, d, runfile, cwd=adir, pythonexception=pythonexception)
+            exec_func_python(func, d, runfile, cwd=adir)
         else:
             exec_func_shell(func, d, runfile, cwd=adir)
 
-    try:
-        curcwd = os.getcwd()
-    except:
-        curcwd = None
-
-    if oldcwd and curcwd != oldcwd:
-        try:
-            bb.warn("Task %s changed cwd to %s" % (func, curcwd))
-            os.chdir(oldcwd)
-        except:
-            pass
-
 _functionfmt = """
+def {function}(d):
+{body}
+
 {function}(d)
 """
 logformatter = bb.msg.BBLogFormatter("%(levelname)s: %(message)s")
-def exec_func_python(func, d, runfile, cwd=None, pythonexception=False):
+def exec_func_python(func, d, runfile, cwd=None):
     """Execute a python BB 'function'"""
 
-    code = _functionfmt.format(function=func)
+    bbfile = d.getVar('FILE', True)
+    code = _functionfmt.format(function=func, body=d.getVar(func, True))
     bb.utils.mkdirhier(os.path.dirname(runfile))
     with open(runfile, 'w') as script:
         bb.data.emit_func_python(func, script, d)
@@ -289,26 +232,18 @@ def exec_func_python(func, d, runfile, cwd=None, pythonexception=False):
     if cwd:
         try:
             olddir = os.getcwd()
-        except OSError as e:
-            bb.warn("%s: Cannot get cwd: %s" % (func, e))
+        except OSError:
             olddir = None
         os.chdir(cwd)
 
     bb.debug(2, "Executing python function %s" % func)
 
     try:
-        text = "def %s(d):\n%s" % (func, d.getVar(func, False))
-        fn = d.getVarFlag(func, "filename", False)
-        lineno = int(d.getVarFlag(func, "lineno", False))
-        bb.methodpool.insert_method(func, text, fn, lineno - 1)
-
-        comp = utils.better_compile(code, func, "exec_python_func() autogenerated")
-        utils.better_exec(comp, {"d": d}, code, "exec_python_func() autogenerated", pythonexception=pythonexception)
+        comp = utils.better_compile(code, func, bbfile)
+        utils.better_exec(comp, {"d": d}, code, bbfile)
     except (bb.parse.SkipRecipe, bb.build.FuncFailed):
         raise
     except:
-        if pythonexception:
-            raise
         raise FuncFailed(func, None)
     finally:
         bb.debug(2, "Python function %s finished" % func)
@@ -316,8 +251,8 @@ def exec_func_python(func, d, runfile, cwd=None, pythonexception=False):
         if cwd and olddir:
             try:
                 os.chdir(olddir)
-            except OSError as e:
-                bb.warn("%s: Cannot restore cwd %s: %s" % (func, olddir, e))
+            except OSError:
+                pass
 
 def shell_trap_code():
     return '''#!/bin/sh\n
@@ -327,8 +262,9 @@ bb_exit_handler() {
     case $ret in
     0)  ;;
     *)  case $BASH_VERSION in
-        "") echo "WARNING: exit code $ret from a shell command.";;
-        *)  echo "WARNING: ${BASH_SOURCE[0]}:${BASH_LINENO[0]} exit $ret from '$BASH_COMMAND'";;
+        "")   echo "WARNING: exit code $ret from a shell command.";;
+        *)    echo "WARNING: ${BASH_SOURCE[0]}:${BASH_LINENO[0]} exit $ret from
+  \"$BASH_COMMAND\"";;
         esac
         exit $ret
     esac
@@ -362,14 +298,14 @@ def exec_func_shell(func, d, runfile, cwd=None):
 # cleanup
 ret=$?
 trap '' 0
-exit $ret
+exit $?
 ''')
 
-    os.chmod(runfile, 0o775)
+    os.chmod(runfile, 0775)
 
     cmd = runfile
-    if d.getVarFlag(func, 'fakeroot', False):
-        fakerootcmd = d.getVar('FAKEROOT')
+    if d.getVarFlag(func, 'fakeroot'):
+        fakerootcmd = d.getVar('FAKEROOT', True)
         if fakerootcmd:
             cmd = [fakerootcmd, runfile]
 
@@ -378,75 +314,14 @@ exit $ret
     else:
         logfile = sys.stdout
 
-    progress = d.getVarFlag(func, 'progress')
-    if progress:
-        if progress == 'percent':
-            # Use default regex
-            logfile = bb.progress.BasicProgressHandler(d, outfile=logfile)
-        elif progress.startswith('percent:'):
-            # Use specified regex
-            logfile = bb.progress.BasicProgressHandler(d, regex=progress.split(':', 1)[1], outfile=logfile)
-        elif progress.startswith('outof:'):
-            # Use specified regex
-            logfile = bb.progress.OutOfProgressHandler(d, regex=progress.split(':', 1)[1], outfile=logfile)
-        else:
-            bb.warn('%s: invalid task progress varflag value "%s", ignoring' % (func, progress))
+    bb.debug(2, "Executing shell function %s" % func)
 
-    fifobuffer = bytearray()
-    def readfifo(data):
-        nonlocal fifobuffer
-        fifobuffer.extend(data)
-        while fifobuffer:
-            message, token, nextmsg = fifobuffer.partition(b"\00")
-            if token:
-                splitval = message.split(b' ', 1)
-                cmd = splitval[0].decode("utf-8")
-                if len(splitval) > 1:
-                    value = splitval[1].decode("utf-8")
-                else:
-                    value = ''
-                if cmd == 'bbplain':
-                    bb.plain(value)
-                elif cmd == 'bbnote':
-                    bb.note(value)
-                elif cmd == 'bbwarn':
-                    bb.warn(value)
-                elif cmd == 'bberror':
-                    bb.error(value)
-                elif cmd == 'bbfatal':
-                    # The caller will call exit themselves, so bb.error() is
-                    # what we want here rather than bb.fatal()
-                    bb.error(value)
-                elif cmd == 'bbfatal_log':
-                    bb.error(value, forcelog=True)
-                elif cmd == 'bbdebug':
-                    splitval = value.split(' ', 1)
-                    level = int(splitval[0])
-                    value = splitval[1]
-                    bb.debug(level, value)
-                else:
-                    bb.warn("Unrecognised command '%s' on FIFO" % cmd)
-                fifobuffer = nextmsg
-            else:
-                break
-
-    tempdir = d.getVar('T')
-    fifopath = os.path.join(tempdir, 'fifo.%s' % os.getpid())
-    if os.path.exists(fifopath):
-        os.unlink(fifopath)
-    os.mkfifo(fifopath)
-    with open(fifopath, 'r+b', buffering=0) as fifo:
-        try:
-            bb.debug(2, "Executing shell function %s" % func)
-
-            try:
-                with open(os.devnull, 'r+') as stdin:
-                    bb.process.run(cmd, shell=False, stdin=stdin, log=logfile, extrafiles=[(fifo,readfifo)])
-            except bb.process.CmdError:
-                logfn = d.getVar('BB_LOGFILE')
-                raise FuncFailed(func, logfn)
-        finally:
-            os.unlink(fifopath)
+    try:
+        with open(os.devnull, 'r+') as stdin:
+            bb.process.run(cmd, shell=False, stdin=stdin, log=logfile)
+    except bb.process.CmdError:
+        logfn = d.getVar('BB_LOGFILE', True)
+        raise FuncFailed(func, logfn)
 
     bb.debug(2, "Shell function %s finished" % func)
 
@@ -466,7 +341,7 @@ def _exec_task(fn, task, d, quieterr):
     Execution of a task involves a bit more setup than executing a function,
     running it with its own local metadata, and with some useful variables set.
     """
-    if not d.getVarFlag(task, 'task', False):
+    if not d.getVarFlag(task, 'task'):
         event.fire(TaskInvalid(task, d), d)
         logger.error("No such task: %s" % task)
         return 1
@@ -474,29 +349,22 @@ def _exec_task(fn, task, d, quieterr):
     logger.debug(1, "Executing task %s", task)
 
     localdata = _task_data(fn, task, d)
-    tempdir = localdata.getVar('T')
+    tempdir = localdata.getVar('T', True)
     if not tempdir:
         bb.fatal("T variable not set, unable to build")
 
     # Change nice level if we're asked to
-    nice = localdata.getVar("BB_TASK_NICE_LEVEL")
+    nice = localdata.getVar("BB_TASK_NICE_LEVEL", True)
     if nice:
         curnice = os.nice(0)
         nice = int(nice) - curnice
         newnice = os.nice(nice)
         logger.debug(1, "Renice to %s " % newnice)
-    ionice = localdata.getVar("BB_TASK_IONICE_LEVEL")
-    if ionice:
-        try:
-            cls, prio = ionice.split(".", 1)
-            bb.utils.ioprio_set(os.getpid(), int(cls), int(prio))
-        except:
-            bb.warn("Invalid ionice level %s" % ionice)
 
     bb.utils.mkdirhier(tempdir)
 
     # Determine the logfile to generate
-    logfmt = localdata.getVar('BB_LOGFMT') or 'log.{task}.{pid}'
+    logfmt = localdata.getVar('BB_LOGFMT', True) or 'log.{task}.{pid}'
     logbase = logfmt.format(task=task, pid=os.getpid())
 
     # Document the order of the tasks...
@@ -527,10 +395,7 @@ def _exec_task(fn, task, d, quieterr):
             self.triggered = False
             logging.Handler.__init__(self, logging.ERROR)
         def emit(self, record):
-            if getattr(record, 'forcelog', False):
-                self.triggered = False
-            else:
-                self.triggered = True
+            self.triggered = True
 
     # Handle logfiles
     si = open('/dev/null', 'r')
@@ -563,36 +428,24 @@ def _exec_task(fn, task, d, quieterr):
 
     localdata.setVar('BB_LOGFILE', logfn)
     localdata.setVar('BB_RUNTASK', task)
-    localdata.setVar('BB_TASK_LOGGER', bblogger)
 
     flags = localdata.getVarFlags(task)
 
+    event.fire(TaskStarted(task, logfn, flags, localdata), localdata)
     try:
-        try:
-            event.fire(TaskStarted(task, logfn, flags, localdata), localdata)
-        except (bb.BBHandledException, SystemExit):
-            return 1
-        except FuncFailed as exc:
+        for func in (prefuncs or '').split():
+            exec_func(func, localdata)
+        exec_func(task, localdata)
+        for func in (postfuncs or '').split():
+            exec_func(func, localdata)
+    except FuncFailed as exc:
+        if quieterr:
+            event.fire(TaskFailedSilent(task, logfn, localdata), localdata)
+        else:
+            errprinted = errchk.triggered
             logger.error(str(exc))
-            return 1
-
-        try:
-            for func in (prefuncs or '').split():
-                exec_func(func, localdata)
-            exec_func(task, localdata)
-            for func in (postfuncs or '').split():
-                exec_func(func, localdata)
-        except FuncFailed as exc:
-            if quieterr:
-                event.fire(TaskFailedSilent(task, logfn, localdata), localdata)
-            else:
-                errprinted = errchk.triggered
-                logger.error(str(exc))
-                event.fire(TaskFailed(task, logfn, localdata, errprinted), localdata)
-            return 1
-        except bb.BBHandledException:
-            event.fire(TaskFailed(task, logfn, localdata, True), localdata)
-            return 1
+            event.fire(TaskFailed(task, logfn, localdata, errprinted), localdata)
+        return 1
     finally:
         sys.stdout.flush()
         sys.stderr.flush()
@@ -617,7 +470,7 @@ def _exec_task(fn, task, d, quieterr):
             bb.utils.remove(loglink)
     event.fire(TaskSucceeded(task, logfn, localdata), localdata)
 
-    if not localdata.getVarFlag(task, 'nostamp', False) and not localdata.getVarFlag(task, 'selfstamp', False):
+    if not localdata.getVarFlag(task, 'nostamp') and not localdata.getVarFlag(task, 'selfstamp'):
         make_stamp(task, localdata)
 
     return 0
@@ -625,11 +478,11 @@ def _exec_task(fn, task, d, quieterr):
 def exec_task(fn, task, d, profile = False):
     try:
         quieterr = False
-        if d.getVarFlag(task, "quieterrors", False) is not None:
+        if d.getVarFlag(task, "quieterrors") is not None:
             quieterr = True
 
         if profile:
-            profname = "profile-%s.log" % (d.getVar("PN") + "-" + task)
+            profname = "profile-%s.log" % (d.getVar("PN", True) + "-" + task)
             try:
                 import cProfile as profile
             except:
@@ -652,7 +505,7 @@ def exec_task(fn, task, d, profile = False):
             event.fire(failedevent, d)
         return 1
 
-def stamp_internal(taskname, d, file_name, baseonly=False, noextra=False):
+def stamp_internal(taskname, d, file_name, baseonly=False):
     """
     Internal stamp helper function
     Makes sure the stamp directory exists
@@ -666,17 +519,15 @@ def stamp_internal(taskname, d, file_name, baseonly=False, noextra=False):
         taskflagname = taskname.replace("_setscene", "")
 
     if file_name:
-        stamp = d.stamp[file_name]
+        stamp = d.stamp_base[file_name].get(taskflagname) or d.stamp[file_name]
         extrainfo = d.stamp_extrainfo[file_name].get(taskflagname) or ""
     else:
-        stamp = d.getVar('STAMP')
-        file_name = d.getVar('BB_FILENAME')
-        extrainfo = d.getVarFlag(taskflagname, 'stamp-extra-info') or ""
+        stamp = d.getVarFlag(taskflagname, 'stamp-base', True) or d.getVar('STAMP', True)
+        file_name = d.getVar('BB_FILENAME', True)
+        extrainfo = d.getVarFlag(taskflagname, 'stamp-extra-info', True) or ""
 
     if baseonly:
         return stamp
-    if noextra:
-        extrainfo = ""
 
     if not stamp:
         return
@@ -684,7 +535,7 @@ def stamp_internal(taskname, d, file_name, baseonly=False, noextra=False):
     stamp = bb.parse.siggen.stampfile(stamp, file_name, taskname, extrainfo)
 
     stampdir = os.path.dirname(stamp)
-    if cached_mtime_noerror(stampdir) == 0:
+    if bb.parse.cached_mtime_noerror(stampdir) == 0:
         bb.utils.mkdirhier(stampdir)
 
     return stamp
@@ -702,12 +553,12 @@ def stamp_cleanmask_internal(taskname, d, file_name):
         taskflagname = taskname.replace("_setscene", "")
 
     if file_name:
-        stamp = d.stampclean[file_name]
+        stamp = d.stamp_base_clean[file_name].get(taskflagname) or d.stampclean[file_name]
         extrainfo = d.stamp_extrainfo[file_name].get(taskflagname) or ""
     else:
-        stamp = d.getVar('STAMPCLEAN')
-        file_name = d.getVar('BB_FILENAME')
-        extrainfo = d.getVarFlag(taskflagname, 'stamp-extra-info') or ""
+        stamp = d.getVarFlag(taskflagname, 'stamp-base-clean', True) or d.getVar('STAMPCLEAN', True)
+        file_name = d.getVar('BB_FILENAME', True)
+        extrainfo = d.getVarFlag(taskflagname, 'stamp-extra-info', True) or ""
 
     if not stamp:
         return []
@@ -725,7 +576,7 @@ def make_stamp(task, d, file_name = None):
     for mask in cleanmask:
         for name in glob.glob(mask):
             # Preserve sigdata files in the stamps directory
-            if "sigdata" in name or "sigbasedata" in name:
+            if "sigdata" in name:
                 continue
             # Preserve taint files in the stamps directory
             if name.endswith('.taint'):
@@ -743,7 +594,7 @@ def make_stamp(task, d, file_name = None):
     # as it completes
     if not task.endswith("_setscene") and task != "do_setscene" and not file_name:
         stampbase = stamp_internal(task, d, None, True)
-        file_name = d.getVar('BB_FILENAME')
+        file_name = d.getVar('BB_FILENAME', True)
         bb.parse.siggen.dump_sigtask(file_name, task, stampbase, True)
 
 def del_stamp(task, d, file_name = None):
@@ -765,22 +616,22 @@ def write_taint(task, d, file_name = None):
     if file_name:
         taintfn = d.stamp[file_name] + '.' + task + '.taint'
     else:
-        taintfn = d.getVar('STAMP') + '.' + task + '.taint'
+        taintfn = d.getVar('STAMP', True) + '.' + task + '.taint'
     bb.utils.mkdirhier(os.path.dirname(taintfn))
     # The specific content of the taint file is not really important,
     # we just need it to be random, so a random UUID is used
     with open(taintfn, 'w') as taintf:
         taintf.write(str(uuid.uuid4()))
 
-def stampfile(taskname, d, file_name = None, noextra=False):
+def stampfile(taskname, d, file_name = None):
     """
     Return the stamp for a given task
     (d can be a data dict or dataCache)
     """
-    return stamp_internal(taskname, d, file_name, noextra=noextra)
+    return stamp_internal(taskname, d, file_name)
 
-def add_tasks(tasklist, d):
-    task_deps = d.getVar('_task_deps', False)
+def add_tasks(tasklist, deltasklist, d):
+    task_deps = d.getVar('_task_deps')
     if not task_deps:
         task_deps = {}
     if not 'tasks' in task_deps:
@@ -791,6 +642,9 @@ def add_tasks(tasklist, d):
     for task in tasklist:
         task = d.expand(task)
 
+        if task in deltasklist:
+            continue
+
         d.setVarFlag(task, 'task', 1)
 
         if not task in task_deps['tasks']:
@@ -827,12 +681,12 @@ def addtask(task, before, after, d):
         task = "do_" + task
 
     d.setVarFlag(task, "task", 1)
-    bbtasks = d.getVar('__BBTASKS', False) or []
-    if task not in bbtasks:
+    bbtasks = d.getVar('__BBTASKS') or []
+    if not task in bbtasks:
         bbtasks.append(task)
     d.setVar('__BBTASKS', bbtasks)
 
-    existing = d.getVarFlag(task, "deps", False) or []
+    existing = d.getVarFlag(task, "deps") or []
     if after is not None:
         # set up deps for function
         for entry in after.split():
@@ -842,7 +696,7 @@ def addtask(task, before, after, d):
     if before is not None:
         # set up things that depend on this func
         for entry in before.split():
-            existing = d.getVarFlag(entry, "deps", False) or []
+            existing = d.getVarFlag(entry, "deps") or []
             if task not in existing:
                 d.setVarFlag(entry, "deps", [task] + existing)
 
@@ -850,58 +704,8 @@ def deltask(task, d):
     if task[:3] != "do_":
         task = "do_" + task
 
-    bbtasks = d.getVar('__BBTASKS', False) or []
-    if task in bbtasks:
-        bbtasks.remove(task)
-        d.delVarFlag(task, 'task')
-        d.setVar('__BBTASKS', bbtasks)
+    bbtasks = d.getVar('__BBDELTASKS') or []
+    if not task in bbtasks:
+        bbtasks.append(task)
+    d.setVar('__BBDELTASKS', bbtasks)
 
-    d.delVarFlag(task, 'deps')
-    for bbtask in d.getVar('__BBTASKS', False) or []:
-        deps = d.getVarFlag(bbtask, 'deps', False) or []
-        if task in deps:
-            deps.remove(task)
-            d.setVarFlag(bbtask, 'deps', deps)
-
-def preceedtask(task, with_recrdeptasks, d):
-    """
-    Returns a set of tasks in the current recipe which were specified as
-    precondition by the task itself ("after") or which listed themselves
-    as precondition ("before"). Preceeding tasks specified via the
-    "recrdeptask" are included in the result only if requested. Beware
-    that this may lead to the task itself being listed.
-    """
-    preceed = set()
-    preceed.update(d.getVarFlag(task, 'deps') or [])
-    if with_recrdeptasks:
-        recrdeptask = d.getVarFlag(task, 'recrdeptask')
-        if recrdeptask:
-            preceed.update(recrdeptask.split())
-    return preceed
-
-def tasksbetween(task_start, task_end, d):
-    """
-    Return the list of tasks between two tasks in the current recipe,
-    where task_start is to start at and task_end is the task to end at
-    (and task_end has a dependency chain back to task_start).
-    """
-    outtasks = []
-    tasks = list(filter(lambda k: d.getVarFlag(k, "task"), d.keys()))
-    def follow_chain(task, endtask, chain=None):
-        if not chain:
-            chain = []
-        chain.append(task)
-        for othertask in tasks:
-            if othertask == task:
-                continue
-            if task == endtask:
-                for ctask in chain:
-                    if ctask not in outtasks:
-                        outtasks.append(ctask)
-            else:
-                deps = d.getVarFlag(othertask, 'deps', False)
-                if task in deps:
-                    follow_chain(othertask, endtask, chain)
-        chain.pop()
-    follow_chain(task_start, task_end)
-    return outtasks

bitbake/lib/bb/cache.py

@@ -28,16 +28,22 @@
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
+
 import os
-import sys
 import logging
-import pickle
 from collections import defaultdict
 import bb.utils
 
 logger = logging.getLogger("BitBake.Cache")
 
-__cache_version__ = "151"
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+    logger.info("Importing cPickle failed. "
+                "Falling back to a very slow implementation.")
+
+__cache_version__ = "148"
 
 def getCacheFile(path, filename, data_hash):
     return os.path.join(path, filename + "." + data_hash)
@@ -71,16 +77,16 @@ class RecipeInfoCommon(object):
 
     @classmethod
     def flaglist(cls, flag, varlist, metadata, squash=False):
-        out_dict = dict((var, metadata.getVarFlag(var, flag))
+        out_dict = dict((var, metadata.getVarFlag(var, flag, True))
                     for var in varlist)
         if squash:
-            return dict((k,v) for (k,v) in out_dict.items() if v)
+            return dict((k,v) for (k,v) in out_dict.iteritems() if v)
         else:
             return out_dict
 
     @classmethod
-    def getvar(cls, var, metadata, expand = True):
-        return metadata.getVar(var, expand) or ''
+    def getvar(cls, var, metadata):
+        return metadata.getVar(var, True) or ''
 
 
 class CoreRecipeInfo(RecipeInfoCommon):
@@ -93,7 +99,7 @@ class CoreRecipeInfo(RecipeInfoCommon):
         self.timestamp = bb.parse.cached_mtime(filename)
         self.variants = self.listvar('__VARIANTS', metadata) + ['']
         self.appends = self.listvar('__BBAPPEND', metadata)
-        self.nocache = self.getvar('BB_DONT_CACHE', metadata)
+        self.nocache = self.getvar('__BB_DONT_CACHE', metadata)
 
         self.skipreason = self.getvar('__SKIPPED', metadata)
         if self.skipreason:
@@ -123,6 +129,8 @@ class CoreRecipeInfo(RecipeInfoCommon):
         self.not_world = self.getvar('EXCLUDE_FROM_WORLD', metadata)
         self.stamp = self.getvar('STAMP', metadata)
         self.stampclean = self.getvar('STAMPCLEAN', metadata)        
+        self.stamp_base = self.flaglist('stamp-base', self.tasks, metadata)
+        self.stamp_base_clean = self.flaglist('stamp-base-clean', self.tasks, metadata)
         self.stamp_extrainfo = self.flaglist('stamp-extra-info', self.tasks, metadata)
         self.file_checksums = self.flaglist('file-checksums', self.tasks, metadata, True)
         self.packages_dynamic = self.listvar('PACKAGES_DYNAMIC', metadata)
@@ -134,11 +142,10 @@ class CoreRecipeInfo(RecipeInfoCommon):
         self.rprovides_pkg    = self.pkgvar('RPROVIDES', self.packages, metadata)
         self.rdepends_pkg     = self.pkgvar('RDEPENDS', self.packages, metadata)
         self.rrecommends_pkg  = self.pkgvar('RRECOMMENDS', self.packages, metadata)
-        self.inherits         = self.getvar('__inherit_cache', metadata, expand=False)
+        self.inherits         = self.getvar('__inherit_cache', metadata)
         self.fakerootenv      = self.getvar('FAKEROOTENV', metadata)
         self.fakerootdirs     = self.getvar('FAKEROOTDIRS', metadata)
         self.fakerootnoenv    = self.getvar('FAKEROOTNOENV', metadata)
-        self.extradepsfunc    = self.getvar('calculate_extra_depends', metadata)
 
     @classmethod
     def init_cacheData(cls, cachedata):
@@ -151,6 +158,8 @@ class CoreRecipeInfo(RecipeInfoCommon):
 
         cachedata.stamp = {}
         cachedata.stampclean = {}
+        cachedata.stamp_base = {}
+        cachedata.stamp_base_clean = {}
         cachedata.stamp_extrainfo = {}
         cachedata.file_checksums = {}
         cachedata.fn_provides = {}
@@ -174,7 +183,6 @@ class CoreRecipeInfo(RecipeInfoCommon):
         cachedata.fakerootenv = {}
         cachedata.fakerootnoenv = {}
         cachedata.fakerootdirs = {}
-        cachedata.extradepsfunc = {}
 
     def add_cacheData(self, cachedata, fn):
         cachedata.task_deps[fn] = self.task_deps
@@ -184,6 +192,8 @@ class CoreRecipeInfo(RecipeInfoCommon):
         cachedata.pkg_dp[fn] = self.defaultpref
         cachedata.stamp[fn] = self.stamp
         cachedata.stampclean[fn] = self.stampclean
+        cachedata.stamp_base[fn] = self.stamp_base
+        cachedata.stamp_base_clean[fn] = self.stamp_base_clean
         cachedata.stamp_extrainfo[fn] = self.stamp_extrainfo
         cachedata.file_checksums[fn] = self.file_checksums
 
@@ -210,8 +220,7 @@ class CoreRecipeInfo(RecipeInfoCommon):
             rprovides += self.rprovides_pkg[package]
 
         for rprovide in rprovides:
-            if fn not in cachedata.rproviders[rprovide]:
-                cachedata.rproviders[rprovide].append(fn)
+            cachedata.rproviders[rprovide].append(fn)
 
         for package in self.packages_dynamic:
             cachedata.packages_dynamic[package].append(fn)
@@ -234,7 +243,7 @@ class CoreRecipeInfo(RecipeInfoCommon):
         cachedata.universe_target.append(self.pn)
 
         cachedata.hashfn[fn] = self.hashfilename
-        for task, taskhash in self.basetaskhashes.items():
+        for task, taskhash in self.basetaskhashes.iteritems():
             identifier = '%s.%s' % (fn, task)
             cachedata.basetaskhash[identifier] = taskhash
 
@@ -242,146 +251,24 @@ class CoreRecipeInfo(RecipeInfoCommon):
         cachedata.fakerootenv[fn] = self.fakerootenv
         cachedata.fakerootnoenv[fn] = self.fakerootnoenv
         cachedata.fakerootdirs[fn] = self.fakerootdirs
-        cachedata.extradepsfunc[fn] = self.extradepsfunc
-
-def virtualfn2realfn(virtualfn):
-    """
-    Convert a virtual file name to a real one + the associated subclass keyword
-    """
-    mc = ""
-    if virtualfn.startswith('multiconfig:'):
-        elems = virtualfn.split(':')
-        mc = elems[1]
-        virtualfn = ":".join(elems[2:])
-
-    fn = virtualfn
-    cls = ""
-    if virtualfn.startswith('virtual:'):
-        elems = virtualfn.split(':')
-        cls = ":".join(elems[1:-1])
-        fn = elems[-1]
-
-    return (fn, cls, mc)
-
-def realfn2virtual(realfn, cls, mc):
-    """
-    Convert a real filename + the associated subclass keyword to a virtual filename
-    """
-    if cls:
-        realfn = "virtual:" + cls + ":" + realfn
-    if mc:
-        realfn = "multiconfig:" + mc + ":" + realfn
-    return realfn
-
-def variant2virtual(realfn, variant):
-    """
-    Convert a real filename + the associated subclass keyword to a virtual filename
-    """
-    if variant == "":
-        return realfn
-    if variant.startswith("multiconfig:"):
-        elems = variant.split(":")
-        if elems[2]:
-            return "multiconfig:" + elems[1] + ":virtual:" + ":".join(elems[2:]) + ":" + realfn
-        return "multiconfig:" + elems[1] + ":" + realfn
-    return "virtual:" + variant + ":" + realfn
-
-def parse_recipe(bb_data, bbfile, appends, mc=''):
-    """
-    Parse a recipe
-    """
-
-    chdir_back = False
-
-    bb_data.setVar("__BBMULTICONFIG", mc)
-
-    # expand tmpdir to include this topdir
-    bb_data.setVar('TMPDIR', bb_data.getVar('TMPDIR') or "")
-    bbfile_loc = os.path.abspath(os.path.dirname(bbfile))
-    oldpath = os.path.abspath(os.getcwd())
-    bb.parse.cached_mtime_noerror(bbfile_loc)
-
-    # The ConfHandler first looks if there is a TOPDIR and if not
-    # then it would call getcwd().
-    # Previously, we chdir()ed to bbfile_loc, called the handler
-    # and finally chdir()ed back, a couple of thousand times. We now
-    # just fill in TOPDIR to point to bbfile_loc if there is no TOPDIR yet.
-    if not bb_data.getVar('TOPDIR', False):
-        chdir_back = True
-        bb_data.setVar('TOPDIR', bbfile_loc)
-    try:
-        if appends:
-            bb_data.setVar('__BBAPPEND', " ".join(appends))
-        bb_data = bb.parse.handle(bbfile, bb_data)
-        if chdir_back:
-            os.chdir(oldpath)
-        return bb_data
-    except:
-        if chdir_back:
-            os.chdir(oldpath)
-        raise
 
 
 
-class NoCache(object):
-
-    def __init__(self, databuilder):
-        self.databuilder = databuilder
-        self.data = databuilder.data
-
-    def loadDataFull(self, virtualfn, appends):
-        """
-        Return a complete set of data for fn.
-        To do this, we need to parse the file.
-        """
-        logger.debug(1, "Parsing %s (full)" % virtualfn)
-        (fn, virtual, mc) = virtualfn2realfn(virtualfn)
-        bb_data = self.load_bbfile(virtualfn, appends, virtonly=True)
-        return bb_data[virtual]
-
-    def load_bbfile(self, bbfile, appends, virtonly = False):
-        """
-        Load and parse one .bb build file
-        Return the data and whether parsing resulted in the file being skipped
-        """
-
-        if virtonly:
-            (bbfile, virtual, mc) = virtualfn2realfn(bbfile)
-            bb_data = self.databuilder.mcdata[mc].createCopy()
-            bb_data.setVar("__ONLYFINALISE", virtual or "default")
-            datastores = parse_recipe(bb_data, bbfile, appends, mc)
-            return datastores
-
-        bb_data = self.data.createCopy()
-        datastores = parse_recipe(bb_data, bbfile, appends)
-
-        for mc in self.databuilder.mcdata:
-            if not mc:
-                continue
-            bb_data = self.databuilder.mcdata[mc].createCopy()
-            newstores = parse_recipe(bb_data, bbfile, appends, mc)
-            for ns in newstores:
-                datastores["multiconfig:%s:%s" % (mc, ns)] = newstores[ns]
-
-        return datastores
-
-class Cache(NoCache):
+class Cache(object):
     """
     BitBake Cache implementation
     """
 
-    def __init__(self, databuilder, data_hash, caches_array):
-        super().__init__(databuilder)
-        data = databuilder.data
-
+    def __init__(self, data, data_hash, caches_array):
         # Pass caches_array information into Cache Constructor
         # It will be used later for deciding whether we 
         # need extra cache file dump/load support 
         self.caches_array = caches_array
-        self.cachedir = data.getVar("CACHE")
+        self.cachedir = data.getVar("CACHE", True)
         self.clean = set()
         self.checked = set()
         self.depends_cache = {}
+        self.data = None
         self.data_fn = None
         self.cacheclean = True
         self.data_hash = data_hash
@@ -401,78 +288,72 @@ class Cache(NoCache):
         cache_ok = True
         if self.caches_array:
             for cache_class in self.caches_array:
-                cachefile = getCacheFile(self.cachedir, cache_class.cachefile, self.data_hash)
-                cache_ok = cache_ok and os.path.exists(cachefile)
-                cache_class.init_cacheData(self)
+                if type(cache_class) is type and issubclass(cache_class, RecipeInfoCommon):
+                    cachefile = getCacheFile(self.cachedir, cache_class.cachefile, self.data_hash)
+                    cache_ok = cache_ok and os.path.exists(cachefile)
+                    cache_class.init_cacheData(self)
         if cache_ok:
             self.load_cachefile()
         elif os.path.isfile(self.cachefile):
             logger.info("Out of date cache found, rebuilding...")
 
     def load_cachefile(self):
+        # Firstly, using core cache file information for
+        # valid checking
+        with open(self.cachefile, "rb") as cachefile:
+            pickled = pickle.Unpickler(cachefile)
+            try:
+                cache_ver = pickled.load()
+                bitbake_ver = pickled.load()
+            except Exception:
+                logger.info('Invalid cache, rebuilding...')
+                return
+
+            if cache_ver != __cache_version__:
+                logger.info('Cache version mismatch, rebuilding...')
+                return
+            elif bitbake_ver != bb.__version__:
+                logger.info('Bitbake version mismatch, rebuilding...')
+                return
+
+
         cachesize = 0
         previous_progress = 0
         previous_percent = 0
 
         # Calculate the correct cachesize of all those cache files
         for cache_class in self.caches_array:
-            cachefile = getCacheFile(self.cachedir, cache_class.cachefile, self.data_hash)
-            with open(cachefile, "rb") as cachefile:
-                cachesize += os.fstat(cachefile.fileno()).st_size
+            if type(cache_class) is type and issubclass(cache_class, RecipeInfoCommon):
+                cachefile = getCacheFile(self.cachedir, cache_class.cachefile, self.data_hash)
+                with open(cachefile, "rb") as cachefile:
+                    cachesize += os.fstat(cachefile.fileno()).st_size
 
         bb.event.fire(bb.event.CacheLoadStarted(cachesize), self.data)
         
         for cache_class in self.caches_array:
-            cachefile = getCacheFile(self.cachedir, cache_class.cachefile, self.data_hash)
-            with open(cachefile, "rb") as cachefile:
-                pickled = pickle.Unpickler(cachefile)
-                # Check cache version information
-                try:
-                    cache_ver = pickled.load()
-                    bitbake_ver = pickled.load()
-                except Exception:
-                    logger.info('Invalid cache, rebuilding...')
-                    return
+            if type(cache_class) is type and issubclass(cache_class, RecipeInfoCommon):
+                cachefile = getCacheFile(self.cachedir, cache_class.cachefile, self.data_hash)
+                with open(cachefile, "rb") as cachefile:
+                    pickled = pickle.Unpickler(cachefile)                    
+                    while cachefile:
+                        try:
+                            key = pickled.load()
+                            value = pickled.load()
+                        except Exception:
+                            break
+                        if self.depends_cache.has_key(key):
+                            self.depends_cache[key].append(value)
+                        else:
+                            self.depends_cache[key] = [value]
+                        # only fire events on even percentage boundaries
+                        current_progress = cachefile.tell() + previous_progress
+                        current_percent = 100 * current_progress / cachesize
+                        if current_percent > previous_percent:
+                            previous_percent = current_percent
+                            bb.event.fire(bb.event.CacheLoadProgress(current_progress, cachesize),
+                                          self.data)
 
-                if cache_ver != __cache_version__:
-                    logger.info('Cache version mismatch, rebuilding...')
-                    return
-                elif bitbake_ver != bb.__version__:
-                     logger.info('Bitbake version mismatch, rebuilding...')
-                     return
-
-                # Load the rest of the cache file
-                current_progress = 0
-                while cachefile:
-                    try:
-                        key = pickled.load()
-                        value = pickled.load()
-                    except Exception:
-                        break
-                    if not isinstance(key, str):
-                        bb.warn("%s from extras cache is not a string?" % key)
-                        break
-                    if not isinstance(value, RecipeInfoCommon):
-                        bb.warn("%s from extras cache is not a RecipeInfoCommon class?" % value)
-                        break
-
-                    if key in self.depends_cache:
-                        self.depends_cache[key].append(value)
-                    else:
-                        self.depends_cache[key] = [value]
-                    # only fire events on even percentage boundaries
-                    current_progress = cachefile.tell() + previous_progress
-                    if current_progress > cachesize:
-                        # we might have calculated incorrect total size because a file
-                        # might've been written out just after we checked its size
-                        cachesize = current_progress
-                    current_percent = 100 * current_progress / cachesize
-                    if current_percent > previous_percent:
-                        previous_percent = current_percent
-                        bb.event.fire(bb.event.CacheLoadProgress(current_progress, cachesize),
-                                      self.data)
-
-                previous_progress += current_progress
+                    previous_progress += current_progress
 
         # Note: depends cache number is corresponding to the parsing file numbers.
         # The same file has several caches, still regarded as one item in the cache
@@ -480,33 +361,69 @@ class Cache(NoCache):
                                                   len(self.depends_cache)),
                       self.data)
 
-    def parse(self, filename, appends):
+    
+    @staticmethod
+    def virtualfn2realfn(virtualfn):
+        """
+        Convert a virtual file name to a real one + the associated subclass keyword
+        """
+
+        fn = virtualfn
+        cls = ""
+        if virtualfn.startswith('virtual:'):
+            elems = virtualfn.split(':')
+            cls = ":".join(elems[1:-1])
+            fn = elems[-1]
+        return (fn, cls)
+
+    @staticmethod
+    def realfn2virtual(realfn, cls):
+        """
+        Convert a real filename + the associated subclass keyword to a virtual filename
+        """
+        if cls == "":
+            return realfn
+        return "virtual:" + cls + ":" + realfn
+
+    @classmethod
+    def loadDataFull(cls, virtualfn, appends, cfgData):
+        """
+        Return a complete set of data for fn.
+        To do this, we need to parse the file.
+        """
+
+        (fn, virtual) = cls.virtualfn2realfn(virtualfn)
+
+        logger.debug(1, "Parsing %s (full)", fn)
+
+        cfgData.setVar("__ONLYFINALISE", virtual or "default")
+        bb_data = cls.load_bbfile(fn, appends, cfgData)
+        return bb_data[virtual]
+
+    @classmethod
+    def parse(cls, filename, appends, configdata, caches_array):
         """Parse the specified filename, returning the recipe information"""
-        logger.debug(1, "Parsing %s", filename)
         infos = []
-        datastores = self.load_bbfile(filename, appends)
+        datastores = cls.load_bbfile(filename, appends, configdata)
         depends = []
-        variants = []
-        # Process the "real" fn last so we can store variants list
-        for variant, data in sorted(datastores.items(),
+        for variant, data in sorted(datastores.iteritems(),
                                     key=lambda i: i[0],
                                     reverse=True):
-            virtualfn = variant2virtual(filename, variant)
-            variants.append(variant)
+            virtualfn = cls.realfn2virtual(filename, variant)
             depends = depends + (data.getVar("__depends", False) or [])
             if depends and not variant:
                 data.setVar("__depends", depends)
-            if virtualfn == filename:
-                data.setVar("__VARIANTS", " ".join(variants))
+
             info_array = []
-            for cache_class in self.caches_array:
-                info = cache_class(filename, data)
-                info_array.append(info)
+            for cache_class in caches_array:
+                if type(cache_class) is type and issubclass(cache_class, RecipeInfoCommon):
+                    info = cache_class(filename, data)
+                    info_array.append(info)
             infos.append((virtualfn, info_array))
 
         return infos
 
-    def load(self, filename, appends):
+    def load(self, filename, appends, configdata):
         """Obtain the recipe information for the specified filename,
         using cached values if available, otherwise parsing.
 
@@ -520,20 +437,21 @@ class Cache(NoCache):
             # info_array item is a list of [CoreRecipeInfo, XXXRecipeInfo]
             info_array = self.depends_cache[filename]
             for variant in info_array[0].variants:
-                virtualfn = variant2virtual(filename, variant)
+                virtualfn = self.realfn2virtual(filename, variant)
                 infos.append((virtualfn, self.depends_cache[virtualfn]))
         else:
+            logger.debug(1, "Parsing %s", filename)
             return self.parse(filename, appends, configdata, self.caches_array)
 
         return cached, infos
 
-    def loadData(self, fn, appends, cacheData):
+    def loadData(self, fn, appends, cfgData, cacheData):
         """Load the recipe info for the specified filename,
         parsing and adding to the cache if necessary, and adding
         the recipe information to the supplied CacheData instance."""
         skipped, virtuals = 0, 0
 
-        cached, infos = self.load(fn, appends)
+        cached, infos = self.load(fn, appends, cfgData)
         for virtualfn, info_array in infos:
             if info_array[0].skipped:
                 logger.debug(1, "Skipping %s: %s", virtualfn, info_array[0].skipreason)
@@ -610,20 +528,7 @@ class Cache(NoCache):
 
         if hasattr(info_array[0], 'file_checksums'):
             for _, fl in info_array[0].file_checksums.items():
-                fl = fl.strip()
-                while fl:
-                    # A .split() would be simpler but means spaces or colons in filenames would break
-                    a = fl.find(":True")
-                    b = fl.find(":False")
-                    if ((a < 0) and b) or ((b > 0) and (b < a)):
-                       f = fl[:b+6]
-                       fl = fl[b+7:]
-                    elif ((b < 0) and a) or ((a > 0) and (a < b)):
-                       f = fl[:a+5]
-                       fl = fl[a+6:]
-                    else:
-                       break
-                    fl = fl.strip()
+                for f in fl.split():
                     if "*" in f:
                         continue
                     f, exist = f.split(":")
@@ -641,19 +546,16 @@ class Cache(NoCache):
 
         invalid = False
         for cls in info_array[0].variants:
-            virtualfn = variant2virtual(fn, cls)
+            virtualfn = self.realfn2virtual(fn, cls)
             self.clean.add(virtualfn)
             if virtualfn not in self.depends_cache:
                 logger.debug(2, "Cache: %s is not cached", virtualfn)
                 invalid = True
-            elif len(self.depends_cache[virtualfn]) != len(self.caches_array):
-                logger.debug(2, "Cache: Extra caches missing for %s?" % virtualfn)
-                invalid = True
 
         # If any one of the variants is not present, mark as invalid for all
         if invalid:
             for cls in info_array[0].variants:
-                virtualfn = variant2virtual(fn, cls)
+                virtualfn = self.realfn2virtual(fn, cls)
                 if virtualfn in self.clean:
                     logger.debug(2, "Cache: Removing %s from cache", virtualfn)
                     self.clean.remove(virtualfn)
@@ -690,19 +592,30 @@ class Cache(NoCache):
             logger.debug(2, "Cache is clean, not saving.")
             return
 
+        file_dict = {}
+        pickler_dict = {}
         for cache_class in self.caches_array:
-            cache_class_name = cache_class.__name__
-            cachefile = getCacheFile(self.cachedir, cache_class.cachefile, self.data_hash)
-            with open(cachefile, "wb") as f:
-                p = pickle.Pickler(f, pickle.HIGHEST_PROTOCOL)
-                p.dump(__cache_version__)
-                p.dump(bb.__version__)
+            if type(cache_class) is type and issubclass(cache_class, RecipeInfoCommon):
+                cache_class_name = cache_class.__name__
+                cachefile = getCacheFile(self.cachedir, cache_class.cachefile, self.data_hash)
+                file_dict[cache_class_name] = open(cachefile, "wb")
+                pickler_dict[cache_class_name] =  pickle.Pickler(file_dict[cache_class_name], pickle.HIGHEST_PROTOCOL)
+                   
+        pickler_dict['CoreRecipeInfo'].dump(__cache_version__)
+        pickler_dict['CoreRecipeInfo'].dump(bb.__version__)
 
-                for key, info_array in self.depends_cache.items():
-                    for info in info_array:
-                        if isinstance(info, RecipeInfoCommon) and info.__class__.__name__ == cache_class_name:
-                            p.dump(key)
-                            p.dump(info)
+        try:
+            for key, info_array in self.depends_cache.iteritems():
+                for info in info_array:
+                    if isinstance(info, RecipeInfoCommon):
+                        cache_class_name = info.__class__.__name__
+                        pickler_dict[cache_class_name].dump(key)
+                        pickler_dict[cache_class_name].dump(info)
+        finally:
+            for cache_class in self.caches_array:
+                if type(cache_class) is type and issubclass(cache_class, RecipeInfoCommon):
+                    cache_class_name = cache_class.__name__
+                    file_dict[cache_class_name].close()
 
         del self.depends_cache
 
@@ -730,13 +643,50 @@ class Cache(NoCache):
         Save data we need into the cache
         """
 
-        realfn = virtualfn2realfn(file_name)[0]
+        realfn = self.virtualfn2realfn(file_name)[0]
 
         info_array = []
         for cache_class in self.caches_array:
-            info_array.append(cache_class(realfn, data))
+            if type(cache_class) is type and issubclass(cache_class, RecipeInfoCommon):
+                info_array.append(cache_class(realfn, data))
         self.add_info(file_name, info_array, cacheData, parsed)
 
+    @staticmethod
+    def load_bbfile(bbfile, appends, config):
+        """
+        Load and parse one .bb build file
+        Return the data and whether parsing resulted in the file being skipped
+        """
+        chdir_back = False
+
+        from bb import data, parse
+
+        # expand tmpdir to include this topdir
+        data.setVar('TMPDIR', data.getVar('TMPDIR', config, 1) or "", config)
+        bbfile_loc = os.path.abspath(os.path.dirname(bbfile))
+        oldpath = os.path.abspath(os.getcwd())
+        parse.cached_mtime_noerror(bbfile_loc)
+        bb_data = data.init_db(config)
+        # The ConfHandler first looks if there is a TOPDIR and if not
+        # then it would call getcwd().
+        # Previously, we chdir()ed to bbfile_loc, called the handler
+        # and finally chdir()ed back, a couple of thousand times. We now
+        # just fill in TOPDIR to point to bbfile_loc if there is no TOPDIR yet.
+        if not data.getVar('TOPDIR', bb_data):
+            chdir_back = True
+            data.setVar('TOPDIR', bbfile_loc, bb_data)
+        try:
+            if appends:
+                data.setVar('__BBAPPEND', " ".join(appends), bb_data)
+            bb_data = parse.handle(bbfile, bb_data)
+            if chdir_back:
+                os.chdir(oldpath)
+            return bb_data
+        except:
+            if chdir_back:
+                os.chdir(oldpath)
+            raise
+
 
 def init(cooker):
     """
@@ -766,9 +716,8 @@ class CacheData(object):
     def __init__(self, caches_array):
         self.caches_array = caches_array
         for cache_class in self.caches_array:
-            if not issubclass(cache_class, RecipeInfoCommon):
-                bb.error("Extra cache data class %s should subclass RecipeInfoCommon class" % cache_class)
-            cache_class.init_cacheData(self)
+            if type(cache_class) is type and issubclass(cache_class, RecipeInfoCommon):
+                cache_class.init_cacheData(self)        
 
         # Direct cache variables
         self.task_queues = {}
@@ -795,14 +744,13 @@ class MultiProcessCache(object):
         self.cachedata = self.create_cachedata()
         self.cachedata_extras = self.create_cachedata()
 
-    def init_cache(self, d, cache_file_name=None):
-        cachedir = (d.getVar("PERSISTENT_DIR") or
-                    d.getVar("CACHE"))
+    def init_cache(self, d):
+        cachedir = (d.getVar("PERSISTENT_DIR", True) or
+                    d.getVar("CACHE", True))
         if cachedir in [None, '']:
             return
         bb.utils.mkdirhier(cachedir)
-        self.cachefile = os.path.join(cachedir,
-                                      cache_file_name or self.__class__.cache_file_name)
+        self.cachefile = os.path.join(cachedir, self.__class__.cache_file_name)
         logger.debug(1, "Using cache in '%s'", self.cachefile)
 
         glf = bb.utils.lockfile(self.cachefile + ".lock")
@@ -826,7 +774,7 @@ class MultiProcessCache(object):
         data = [{}]
         return data
 
-    def save_extras(self):
+    def save_extras(self, d):
         if not self.cachefile:
             return
 
@@ -856,7 +804,7 @@ class MultiProcessCache(object):
                 if h not in dest[j]:
                     dest[j][h] = source[j][h]
 
-    def save_merge(self):
+    def save_merge(self, d):
         if not self.cachefile:
             return
 

bitbake/lib/bb/checksum.py

@@ -15,17 +15,22 @@
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
-import glob
-import operator
 import os
 import stat
-import pickle
 import bb.utils
 import logging
 from bb.cache import MultiProcessCache
 
 logger = logging.getLogger("BitBake.Cache")
 
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+    logger.info("Importing cPickle failed. "
+                "Falling back to a very slow implementation.")
+
+
 # mtime cache (non-persistent)
 # based upon the assumption that files do not change during bitbake run
 class FileMtimeCache(object):
@@ -83,52 +88,3 @@ class FileChecksumCache(MultiProcessCache):
                     dest[0][h] = source[0][h]
             else:
                 dest[0][h] = source[0][h]
-
-    def get_checksums(self, filelist, pn):
-        """Get checksums for a list of files"""
-
-        def checksum_file(f):
-            try:
-                checksum = self.get_checksum(f)
-            except OSError as e:
-                bb.warn("Unable to get checksum for %s SRC_URI entry %s: %s" % (pn, os.path.basename(f), e))
-                return None
-            return checksum
-
-        def checksum_dir(pth):
-            # Handle directories recursively
-            dirchecksums = []
-            for root, dirs, files in os.walk(pth):
-                for name in files:
-                    fullpth = os.path.join(root, name)
-                    checksum = checksum_file(fullpth)
-                    if checksum:
-                        dirchecksums.append((fullpth, checksum))
-            return dirchecksums
-
-        checksums = []
-        for pth in filelist.split():
-            exist = pth.split(":")[1]
-            if exist == "False":
-                continue
-            pth = pth.split(":")[0]
-            if '*' in pth:
-                # Handle globs
-                for f in glob.glob(pth):
-                    if os.path.isdir(f):
-                        if not os.path.islink(f):
-                            checksums.extend(checksum_dir(f))
-                    else:
-                        checksum = checksum_file(f)
-                        if checksum:
-                            checksums.append((f, checksum))
-            elif os.path.isdir(pth):
-                if not os.path.islink(pth):
-                    checksums.extend(checksum_dir(pth))
-            else:
-                checksum = checksum_file(pth)
-                if checksum:
-                    checksums.append((pth, checksum))
-
-        checksums.sort(key=operator.itemgetter(1))
-        return checksums

bitbake/lib/bb/codeparser.py

@@ -1,39 +1,21 @@
-"""
-BitBake code parser
-
-Parses actual code (i.e. python and shell) for functions and in-line
-expressions. Used mainly to determine dependencies on other functions
-and variables within the BitBake metadata. Also provides a cache for
-this information in order to speed up processing.
-
-(Not to be confused with the code that parses the metadata itself,
-see lib/bb/parse/ for that).
-
-NOTE: if you change how the parsers gather information you will almost
-certainly need to increment CodeParserCache.CACHE_VERSION below so that
-any existing codeparser cache gets invalidated. Additionally you'll need
-to increment __cache_version__ in cache.py in order to ensure that old
-recipe caches don't trigger "Taskhash mismatch" errors.
-
-"""
-
 import ast
-import sys
 import codegen
 import logging
-import pickle
-import bb.pysh as pysh
 import os.path
 import bb.utils, bb.data
-import hashlib
 from itertools import chain
-from bb.pysh import pyshyacc, pyshlex, sherrors
+from pysh import pyshyacc, pyshlex, sherrors
 from bb.cache import MultiProcessCache
 
+
 logger = logging.getLogger('BitBake.CodeParser')
 
-def bbhash(s):
-    return hashlib.md5(s.encode("utf-8")).hexdigest()
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+    logger.info('Importing cPickle failed.  Falling back to a very slow implementation.')
+
 
 def check_indent(codestr):
     """If the code is indented, add a top level piece of code to 'remove' the indentation"""
@@ -46,10 +28,6 @@ def check_indent(codestr):
         return codestr
 
     if codestr[i-1] == "\t" or codestr[i-1] == " ":
-        if codestr[0] == "\n":
-            # Since we're adding a line, we need to remove one line of any empty padding
-            # to ensure line numbers are correct
-            codestr = codestr[1:]
         return "if 1:\n" + codestr
 
     return codestr
@@ -86,12 +64,11 @@ class SetCache(object):
         
         new = []
         for i in items:
-            new.append(sys.intern(i))
+            new.append(intern(i))
         s = frozenset(new)
-        h = hash(s)
-        if h in self.setcache:
-            return self.setcache[h]
-        self.setcache[h] = s
+        if hash(s) in self.setcache:
+            return self.setcache[hash(s)]
+        self.setcache[hash(s)] = s
         return s
 
 codecache = SetCache()
@@ -115,9 +92,6 @@ class pythonCacheLine(object):
         for c in sorted(self.contains.keys()):
             l = l + (c, hash(self.contains[c]))
         return hash(l)
-    def __repr__(self):
-        return " ".join([str(self.refs), str(self.execs), str(self.contains)]) 
-
 
 class shellCacheLine(object):
     def __init__(self, execs):
@@ -131,16 +105,10 @@ class shellCacheLine(object):
         self.__init__(execs)
     def __hash__(self):
         return hash(self.execs)
-    def __repr__(self):
-        return str(self.execs)
 
 class CodeParserCache(MultiProcessCache):
     cache_file_name = "bb_codeparser.dat"
-    # NOTE: you must increment this if you change how the parsers gather information,
-    # so that an existing cache gets invalidated. Additionally you'll need
-    # to increment __cache_version__ in cache.py in order to ensure that old
-    # recipe caches don't trigger "Taskhash mismatch" errors.
-    CACHE_VERSION = 9
+    CACHE_VERSION = 7
 
     def __init__(self):
         MultiProcessCache.__init__(self)
@@ -171,10 +139,6 @@ class CodeParserCache(MultiProcessCache):
         return cacheline
 
     def init_cache(self, d):
-        # Check if we already have the caches
-        if self.pythoncache:
-            return
-
         MultiProcessCache.init_cache(self, d)
 
         # cachedata gets re-assigned in the parent
@@ -190,11 +154,11 @@ codeparsercache = CodeParserCache()
 def parser_cache_init(d):
     codeparsercache.init_cache(d)
 
-def parser_cache_save():
-    codeparsercache.save_extras()
+def parser_cache_save(d):
+    codeparsercache.save_extras(d)
 
-def parser_cache_savemerge():
-    codeparsercache.save_merge()
+def parser_cache_savemerge(d):
+    codeparsercache.save_merge(d)
 
 Logger = logging.getLoggerClass()
 class BufferedLogger(Logger):
@@ -209,15 +173,12 @@ class BufferedLogger(Logger):
 
     def flush(self):
         for record in self.buffer:
-            if self.target.isEnabledFor(record.levelno):
-                self.target.handle(record)
+            self.target.handle(record)
         self.buffer = []
 
 class PythonParser():
     getvars = (".getVar", ".appendVar", ".prependVar")
-    getvarflags = (".getVarFlag", ".appendVarFlag", ".prependVarFlag")
-    containsfuncs = ("bb.utils.contains", "base_contains")
-    containsanyfuncs = ("bb.utils.contains_any",  "bb.utils.filter")
+    containsfuncs = ("bb.utils.contains", "base_contains", "oe.utils.contains", "bb.utils.contains_any")
     execfuncs = ("bb.build.exec_func", "bb.build.exec_task")
 
     def warn(self, func, arg):
@@ -236,37 +197,17 @@ class PythonParser():
 
     def visit_Call(self, node):
         name = self.called_node_name(node.func)
-        if name and (name.endswith(self.getvars) or name.endswith(self.getvarflags) or name in self.containsfuncs or name in self.containsanyfuncs):
+        if name and name.endswith(self.getvars) or name in self.containsfuncs:
             if isinstance(node.args[0], ast.Str):
                 varname = node.args[0].s
                 if name in self.containsfuncs and isinstance(node.args[1], ast.Str):
                     if varname not in self.contains:
                         self.contains[varname] = set()
                     self.contains[varname].add(node.args[1].s)
-                elif name in self.containsanyfuncs and isinstance(node.args[1], ast.Str):
-                    if varname not in self.contains:
-                        self.contains[varname] = set()
-                    self.contains[varname].update(node.args[1].s.split())
-                elif name.endswith(self.getvarflags):
-                    if isinstance(node.args[1], ast.Str):
-                        self.references.add('%s[%s]' % (varname, node.args[1].s))
-                    else:
-                        self.warn(node.func, node.args[1])
-                else:
-                    self.references.add(varname)
+                else:                      
+                    self.references.add(node.args[0].s)
             else:
                 self.warn(node.func, node.args[0])
-        elif name and name.endswith(".expand"):
-            if isinstance(node.args[0], ast.Str):
-                value = node.args[0].s
-                d = bb.data.init()
-                parser = d.expandWithRefs(value, self.name)
-                self.references |= parser.references
-                self.execs |= parser.execs
-                for varname in parser.contains:
-                    if varname not in self.contains:
-                        self.contains[varname] = set()
-                    self.contains[varname] |= parser.contains[varname]
         elif name in self.execfuncs:
             if isinstance(node.args[0], ast.Str):
                 self.var_execs.add(node.args[0].s)
@@ -289,7 +230,6 @@ class PythonParser():
                 break
 
     def __init__(self, name, log):
-        self.name = name
         self.var_execs = set()
         self.contains = {}
         self.execs = set()
@@ -299,11 +239,8 @@ class PythonParser():
         self.unhandled_message = "in call of %s, argument '%s' is not a string literal"
         self.unhandled_message = "while parsing %s, %s" % (name, self.unhandled_message)
 
-    def parse_python(self, node, lineno=0, filename="<string>"):
-        if not node or not node.strip():
-            return
-
-        h = bbhash(str(node))
+    def parse_python(self, node):
+        h = hash(str(node))
 
         if h in codeparsercache.pythoncache:
             self.references = set(codeparsercache.pythoncache[h].refs)
@@ -321,9 +258,7 @@ class PythonParser():
                 self.contains[i] = set(codeparsercache.pythoncacheextras[h].contains[i])
             return
 
-        # We can't add to the linenumbers for compile, we can pad to the correct number of blank lines though
-        node = "\n" * int(lineno) + node
-        code = compile(check_indent(str(node)), filename, "exec",
+        code = compile(check_indent(str(node)), "<string>", "exec",
                        ast.PyCF_ONLY_AST)
 
         for n in ast.walk(code):
@@ -348,7 +283,7 @@ class ShellParser():
         commands it executes.
         """
 
-        h = bbhash(str(value))
+        h = hash(str(value))
 
         if h in codeparsercache.shellcache:
             self.execs = set(codeparsercache.shellcache[h].execs)
@@ -371,7 +306,8 @@ class ShellParser():
         except pyshlex.NeedMore:
             raise sherrors.ShellSyntaxError("Unexpected EOF")
 
-        self.process_tokens(tokens)
+        for token in tokens:
+            self.process_tokens(token)
 
     def process_tokens(self, tokens):
         """Process a supplied portion of the syntax tree as returned by
@@ -417,24 +353,18 @@ class ShellParser():
             "case_clause": case_clause,
         }
 
-        def process_token_list(tokens):
-            for token in tokens:
-                if isinstance(token, list):
-                    process_token_list(token)
-                    continue
-                name, value = token
-                try:
-                    more_tokens, words = token_handlers[name](value)
-                except KeyError:
-                    raise NotImplementedError("Unsupported token type " + name)
+        for token in tokens:
+            name, value = token
+            try:
+                more_tokens, words = token_handlers[name](value)
+            except KeyError:
+                raise NotImplementedError("Unsupported token type " + name)
 
-                if more_tokens:
-                    self.process_tokens(more_tokens)
+            if more_tokens:
+                self.process_tokens(more_tokens)
 
-                if words:
-                    self.process_words(words)
-
-        process_token_list(tokens)
+            if words:
+                self.process_words(words)
 
     def process_words(self, words):
         """Process a set of 'words' in pyshyacc parlance, which includes

bitbake/lib/bb/command.py

@@ -28,15 +28,8 @@ and must not trigger events, directly or indirectly.
 Commands are queued in a CommandQueue
 """
 
-from collections import OrderedDict, defaultdict
-
 import bb.event
 import bb.cooker
-import bb.remotedata
-
-class DataStoreConnectionHandle(object):
-    def __init__(self, dsindex=0):
-        self.dsindex = dsindex
 
 class CommandCompleted(bb.event.Event):
     pass
@@ -62,7 +55,6 @@ class Command:
         self.cooker = cooker
         self.cmds_sync = CommandsSync()
         self.cmds_async = CommandsAsync()
-        self.remotedatastores = bb.remotedata.RemoteDatastores(cooker)
 
         # FIXME Add lock for this
         self.currentAsyncCommand = None
@@ -76,12 +68,10 @@ class Command:
                 if not hasattr(command_method, 'readonly') or False == getattr(command_method, 'readonly'):
                     return None, "Not able to execute not readonly commands in readonly mode"
             try:
-                if getattr(command_method, 'needconfig', False):
-                    self.cooker.updateCacheSync()
                 result = command_method(self, commandline)
             except CommandError as exc:
                 return None, exc.args[0]
-            except (Exception, SystemExit):
+            except Exception:
                 import traceback
                 return None, traceback.format_exc()
             else:
@@ -118,7 +108,7 @@ class Command:
             return False
         except SystemExit as exc:
             arg = exc.args[0]
-            if isinstance(arg, str):
+            if isinstance(arg, basestring):
                 self.finishAsyncCommand(arg)
             else:
                 self.finishAsyncCommand("Exited with %s" % arg)
@@ -133,20 +123,14 @@ class Command:
 
     def finishAsyncCommand(self, msg=None, code=None):
         if msg or msg == "":
-            bb.event.fire(CommandFailed(msg), self.cooker.data)
+            bb.event.fire(CommandFailed(msg), self.cooker.event_data)
         elif code:
-            bb.event.fire(CommandExit(code), self.cooker.data)
+            bb.event.fire(CommandExit(code), self.cooker.event_data)
         else:
-            bb.event.fire(CommandCompleted(), self.cooker.data)
+            bb.event.fire(CommandCompleted(), self.cooker.event_data)
         self.currentAsyncCommand = None
         self.cooker.finishcommand()
 
-def split_mc_pn(pn):
-    if pn.startswith("multiconfig:"):
-        _, mc, pn = pn.split(":", 2)
-        return (mc, pn)
-    return ('', pn)
-
 class CommandsSync:
     """
     A class of synchronous commands
@@ -193,19 +177,8 @@ class CommandsSync:
         """
         varname = params[0]
         value = str(params[1])
-        command.cooker.extraconfigdata[varname] = value
         command.cooker.data.setVar(varname, value)
 
-    def getSetVariable(self, command, params):
-        """
-        Read the value of a variable from data and set it into the datastore
-        which effectively expands and locks the value.
-        """
-        varname = params[0]
-        result = self.getVariable(command, params)
-        command.cooker.data.setVar(varname, result)
-        return result
-
     def setConfig(self, command, params):
         """
         Set the value of variable in configuration
@@ -231,7 +204,6 @@ class CommandsSync:
         postfiles = params[1].split()
         command.cooker.configuration.prefile = prefiles
         command.cooker.configuration.postfile = postfiles
-    setPrePostConfFiles.needconfig = False
 
     def getCpuCount(self, command, params):
         """
@@ -239,12 +211,10 @@ class CommandsSync:
         """
         return bb.utils.cpu_count()
     getCpuCount.readonly = True
-    getCpuCount.needconfig = False
 
     def matchFile(self, command, params):
         fMatch = params[0]
         return command.cooker.matchFile(fMatch)
-    matchFile.needconfig = False
 
     def generateNewImage(self, command, params):
         image = params[0]
@@ -258,7 +228,6 @@ class CommandsSync:
     def ensureDir(self, command, params):
         directory = params[0]
         bb.utils.mkdirhier(directory)
-    ensureDir.needconfig = False
 
     def setVarFile(self, command, params):
         """
@@ -269,7 +238,6 @@ class CommandsSync:
         default_file = params[2]
         op = params[3]
         command.cooker.modifyConfigurationVar(var, val, default_file, op)
-    setVarFile.needconfig = False
 
     def removeVarFile(self, command, params):
         """
@@ -277,7 +245,6 @@ class CommandsSync:
         """
         var = params[0]
         command.cooker.removeConfigurationVar(var)
-    removeVarFile.needconfig = False
 
     def createConfigFile(self, command, params):
         """
@@ -285,7 +252,6 @@ class CommandsSync:
         """
         name = params[0]
         command.cooker.createConfigFile(name)
-    createConfigFile.needconfig = False
 
     def setEventMask(self, command, params):
         handlerNum = params[0]
@@ -293,8 +259,6 @@ class CommandsSync:
         debug_domains = params[2]
         mask = params[3]
         return bb.event.set_UIHmask(handlerNum, llevel, debug_domains, mask)
-    setEventMask.needconfig = False
-    setEventMask.readonly = True
 
     def setFeatures(self, command, params):
         """
@@ -302,280 +266,14 @@ class CommandsSync:
         """
         features = params[0]
         command.cooker.setFeatures(features)
-    setFeatures.needconfig = False
+
     # although we change the internal state of the cooker, this is transparent since
     # we always take and leave the cooker in state.initial
     setFeatures.readonly = True
 
     def updateConfig(self, command, params):
         options = params[0]
-        environment = params[1]
-        command.cooker.updateConfigOpts(options, environment)
-    updateConfig.needconfig = False
-
-    def parseConfiguration(self, command, params):
-        """Instruct bitbake to parse its configuration
-        NOTE: it is only necessary to call this if you aren't calling any normal action
-        (otherwise parsing is taken care of automatically)
-        """
-        command.cooker.parseConfiguration()
-    parseConfiguration.needconfig = False
-
-    def getLayerPriorities(self, command, params):
-        ret = []
-        # regex objects cannot be marshalled by xmlrpc
-        for collection, pattern, regex, pri in command.cooker.bbfile_config_priorities:
-            ret.append((collection, pattern, regex.pattern, pri))
-        return ret
-    getLayerPriorities.readonly = True
-
-    def getRecipes(self, command, params):
-        try:
-            mc = params[0]
-        except IndexError:
-            mc = ''
-        return list(command.cooker.recipecaches[mc].pkg_pn.items())
-    getRecipes.readonly = True
-
-    def getRecipeDepends(self, command, params):
-        try:
-            mc = params[0]
-        except IndexError:
-            mc = ''
-        return list(command.cooker.recipecaches[mc].deps.items())
-    getRecipeDepends.readonly = True
-
-    def getRecipeVersions(self, command, params):
-        try:
-            mc = params[0]
-        except IndexError:
-            mc = ''
-        return command.cooker.recipecaches[mc].pkg_pepvpr
-    getRecipeVersions.readonly = True
-
-    def getRuntimeDepends(self, command, params):
-        ret = []
-        try:
-            mc = params[0]
-        except IndexError:
-            mc = ''
-        rundeps = command.cooker.recipecaches[mc].rundeps
-        for key, value in rundeps.items():
-            if isinstance(value, defaultdict):
-                value = dict(value)
-            ret.append((key, value))
-        return ret
-    getRuntimeDepends.readonly = True
-
-    def getRuntimeRecommends(self, command, params):
-        ret = []
-        try:
-            mc = params[0]
-        except IndexError:
-            mc = ''
-        runrecs = command.cooker.recipecaches[mc].runrecs
-        for key, value in runrecs.items():
-            if isinstance(value, defaultdict):
-                value = dict(value)
-            ret.append((key, value))
-        return ret
-    getRuntimeRecommends.readonly = True
-
-    def getRecipeInherits(self, command, params):
-        try:
-            mc = params[0]
-        except IndexError:
-            mc = ''
-        return command.cooker.recipecaches[mc].inherits
-    getRecipeInherits.readonly = True
-
-    def getBbFilePriority(self, command, params):
-        try:
-            mc = params[0]
-        except IndexError:
-            mc = ''
-        return command.cooker.recipecaches[mc].bbfile_priority
-    getBbFilePriority.readonly = True
-
-    def getDefaultPreference(self, command, params):
-        try:
-            mc = params[0]
-        except IndexError:
-            mc = ''
-        return command.cooker.recipecaches[mc].pkg_dp
-    getDefaultPreference.readonly = True
-
-    def getSkippedRecipes(self, command, params):
-        # Return list sorted by reverse priority order
-        import bb.cache
-        skipdict = OrderedDict(sorted(command.cooker.skiplist.items(),
-                                      key=lambda x: (-command.cooker.collection.calc_bbfile_priority(bb.cache.virtualfn2realfn(x[0])[0]), x[0])))
-        return list(skipdict.items())
-    getSkippedRecipes.readonly = True
-
-    def getOverlayedRecipes(self, command, params):
-        return list(command.cooker.collection.overlayed.items())
-    getOverlayedRecipes.readonly = True
-
-    def getFileAppends(self, command, params):
-        fn = params[0]
-        return command.cooker.collection.get_file_appends(fn)
-    getFileAppends.readonly = True
-
-    def getAllAppends(self, command, params):
-        return command.cooker.collection.bbappends
-    getAllAppends.readonly = True
-
-    def findProviders(self, command, params):
-        return command.cooker.findProviders()
-    findProviders.readonly = True
-
-    def findBestProvider(self, command, params):
-        (mc, pn) = split_mc_pn(params[0])
-        return command.cooker.findBestProvider(pn, mc)
-    findBestProvider.readonly = True
-
-    def allProviders(self, command, params):
-        try:
-            mc = params[0]
-        except IndexError:
-            mc = ''
-        return list(bb.providers.allProviders(command.cooker.recipecaches[mc]).items())
-    allProviders.readonly = True
-
-    def getRuntimeProviders(self, command, params):
-        rprovide = params[0]
-        try:
-            mc = params[1]
-        except IndexError:
-            mc = ''
-        all_p = bb.providers.getRuntimeProviders(command.cooker.recipecaches[mc], rprovide)
-        if all_p:
-            best = bb.providers.filterProvidersRunTime(all_p, rprovide,
-                            command.cooker.data,
-                            command.cooker.recipecaches[mc])[0][0]
-        else:
-            best = None
-        return all_p, best
-    getRuntimeProviders.readonly = True
-
-    def dataStoreConnectorFindVar(self, command, params):
-        dsindex = params[0]
-        name = params[1]
-        datastore = command.remotedatastores[dsindex]
-        value, overridedata = datastore._findVar(name)
-
-        if value:
-            content = value.get('_content', None)
-            if isinstance(content, bb.data_smart.DataSmart):
-                # Value is a datastore (e.g. BB_ORIGENV) - need to handle this carefully
-                idx = command.remotedatastores.check_store(content, True)
-                return {'_content': DataStoreConnectionHandle(idx),
-                        '_connector_origtype': 'DataStoreConnectionHandle',
-                        '_connector_overrides': overridedata}
-            elif isinstance(content, set):
-                return {'_content': list(content),
-                        '_connector_origtype': 'set',
-                        '_connector_overrides': overridedata}
-            else:
-                value['_connector_overrides'] = overridedata
-        else:
-            value = {}
-            value['_connector_overrides'] = overridedata
-        return value
-    dataStoreConnectorFindVar.readonly = True
-
-    def dataStoreConnectorGetKeys(self, command, params):
-        dsindex = params[0]
-        datastore = command.remotedatastores[dsindex]
-        return list(datastore.keys())
-    dataStoreConnectorGetKeys.readonly = True
-
-    def dataStoreConnectorGetVarHistory(self, command, params):
-        dsindex = params[0]
-        name = params[1]
-        datastore = command.remotedatastores[dsindex]
-        return datastore.varhistory.variable(name)
-    dataStoreConnectorGetVarHistory.readonly = True
-
-    def dataStoreConnectorExpandPythonRef(self, command, params):
-        config_data_dict = params[0]
-        varname = params[1]
-        expr = params[2]
-
-        config_data = command.remotedatastores.receive_datastore(config_data_dict)
-
-        varparse = bb.data_smart.VariableParse(varname, config_data)
-        return varparse.python_sub(expr)
-
-    def dataStoreConnectorRelease(self, command, params):
-        dsindex = params[0]
-        if dsindex <= 0:
-            raise CommandError('dataStoreConnectorRelease: invalid index %d' % dsindex)
-        command.remotedatastores.release(dsindex)
-
-    def dataStoreConnectorSetVarFlag(self, command, params):
-        dsindex = params[0]
-        name = params[1]
-        flag = params[2]
-        value = params[3]
-        datastore = command.remotedatastores[dsindex]
-        datastore.setVarFlag(name, flag, value)
-
-    def dataStoreConnectorDelVar(self, command, params):
-        dsindex = params[0]
-        name = params[1]
-        datastore = command.remotedatastores[dsindex]
-        if len(params) > 2:
-            flag = params[2]
-            datastore.delVarFlag(name, flag)
-        else:
-            datastore.delVar(name)
-
-    def dataStoreConnectorRenameVar(self, command, params):
-        dsindex = params[0]
-        name = params[1]
-        newname = params[2]
-        datastore = command.remotedatastores[dsindex]
-        datastore.renameVar(name, newname)
-
-    def parseRecipeFile(self, command, params):
-        """
-        Parse the specified recipe file (with or without bbappends)
-        and return a datastore object representing the environment
-        for the recipe.
-        """
-        fn = params[0]
-        appends = params[1]
-        appendlist = params[2]
-        if len(params) > 3:
-            config_data_dict = params[3]
-            config_data = command.remotedatastores.receive_datastore(config_data_dict)
-        else:
-            config_data = None
-
-        if appends:
-            if appendlist is not None:
-                appendfiles = appendlist
-            else:
-                appendfiles = command.cooker.collection.get_file_appends(fn)
-        else:
-            appendfiles = []
-        # We are calling bb.cache locally here rather than on the server,
-        # but that's OK because it doesn't actually need anything from
-        # the server barring the global datastore (which we have a remote
-        # version of)
-        if config_data:
-            # We have to use a different function here if we're passing in a datastore
-            # NOTE: we took a copy above, so we don't do it here again
-            envdata = bb.cache.parse_recipe(config_data, fn, appendfiles)['']
-        else:
-            # Use the standard path
-            parser = bb.cache.NoCache(command.cooker.databuilder)
-            envdata = parser.loadDataFull(fn, appendfiles)
-        idx = command.remotedatastores.store(envdata)
-        return DataStoreConnectionHandle(idx)
-    parseRecipeFile.readonly = True
+        command.cooker.updateConfigOpts(options)
 
 class CommandsAsync:
     """
@@ -590,12 +288,8 @@ class CommandsAsync:
         """
         bfile = params[0]
         task = params[1]
-        if len(params) > 2:
-            hidewarning = params[2]
-        else:
-            hidewarning = False
 
-        command.cooker.buildFile(bfile, task, hidewarning)
+        command.cooker.buildFile(bfile, task)
     buildFile.needcache = False
 
     def buildTargets(self, command, params):
@@ -755,11 +449,3 @@ class CommandsAsync:
         command.finishAsyncCommand()
     resetCooker.needcache = False
 
-    def clientComplete(self, command, params):
-        """
-        Do the right thing when the controlling client exits
-        """
-        command.cooker.clientComplete()
-        command.finishAsyncCommand()
-    clientComplete.needcache = False
-

bitbake/lib/bb/cookerdata.py

@@ -22,11 +22,9 @@
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
-import logging
-import os
-import re
-import sys
+import os, sys
 from functools import wraps
+import logging
 import bb
 from bb import data
 import bb.parse
@@ -35,8 +33,8 @@ logger      = logging.getLogger("BitBake")
 parselog    = logging.getLogger("BitBake.Parsing")
 
 class ConfigParameters(object):
-    def __init__(self, argv=sys.argv):
-        self.options, targets = self.parseCommandLine(argv)
+    def __init__(self):
+        self.options, targets = self.parseCommandLine()
         self.environment = self.parseEnvironment()
 
         self.options.pkgs_to_build = targets or []
@@ -48,7 +46,7 @@ class ConfigParameters(object):
         for key, val in self.options.__dict__.items():
             setattr(self, key, val)
 
-    def parseCommandLine(self, argv=sys.argv):
+    def parseCommandLine(self):
         raise Exception("Caller must implement commandline option parsing")
 
     def parseEnvironment(self):
@@ -65,21 +63,20 @@ class ConfigParameters(object):
             raise Exception("Unable to set configuration option 'cmd' on the server: %s" % error)
 
         if not self.options.pkgs_to_build:
-            bbpkgs, error = server.runCommand(["getVariable", "BBTARGETS"])
+            bbpkgs, error = server.runCommand(["getVariable", "BBPKGS"])
             if error:
-                raise Exception("Unable to get the value of BBTARGETS from the server: %s" % error)
+                raise Exception("Unable to get the value of BBPKGS from the server: %s" % error)
             if bbpkgs:
                 self.options.pkgs_to_build.extend(bbpkgs.split())
 
-    def updateToServer(self, server, environment):
+    def updateToServer(self, server):
         options = {}
         for o in ["abort", "tryaltconfigs", "force", "invalidate_stamp", 
                   "verbose", "debug", "dry_run", "dump_signatures", 
-                  "debug_domains", "extra_assume_provided", "profile",
-                  "prefile", "postfile"]:
+                  "debug_domains", "extra_assume_provided", "profile"]:
             options[o] = getattr(self.options, o)
 
-        ret, error = server.runCommand(["updateConfig", options, environment])
+        ret, error = server.runCommand(["updateConfig", options])
         if error:
                 raise Exception("Unable to update the server configuration with local parameters: %s" % error)
 
@@ -131,24 +128,17 @@ class CookerConfiguration(object):
         self.extra_assume_provided = []
         self.prefile = []
         self.postfile = []
-        self.prefile_server = []
-        self.postfile_server = []
         self.debug = 0
         self.cmd = None
         self.abort = True
         self.force = False
         self.profile = False
         self.nosetscene = False
-        self.setsceneonly = False
         self.invalidate_stamp = False
         self.dump_signatures = []
         self.dry_run = False
         self.tracking = False
         self.interface = []
-        self.writeeventlog = False
-        self.server_only = False
-        self.limited_deps = False
-        self.runall = None
 
         self.env = {}
 
@@ -182,26 +172,11 @@ def catch_parse_error(func):
     def wrapped(fn, *args):
         try:
             return func(fn, *args)
-        except IOError as exc:
+        except (IOError, bb.parse.ParseError, bb.data_smart.ExpansionError) as exc:
             import traceback
-            parselog.critical(traceback.format_exc())
+            parselog.critical( traceback.format_exc())
             parselog.critical("Unable to parse %s: %s" % (fn, exc))
             sys.exit(1)
-        except bb.data_smart.ExpansionError as exc:
-            import traceback
-
-            bbdir = os.path.dirname(__file__) + os.sep
-            exc_class, exc, tb = sys.exc_info()
-            for tb in iter(lambda: tb.tb_next, None):
-                # Skip frames in bitbake itself, we only want the metadata
-                fn, _, _, _ = traceback.extract_tb(tb, 1)[0]
-                if not fn.startswith(bbdir):
-                    break
-            parselog.critical("Unable to parse %s" % fn, exc_info=(exc_class, exc, tb))
-            sys.exit(1)
-        except bb.parse.ParseError as exc:
-            parselog.critical(str(exc))
-            sys.exit(1)
     return wrapped
 
 @catch_parse_error
@@ -215,7 +190,7 @@ def _inherit(bbclass, data):
 
 def findConfigFile(configfile, data):
     search = []
-    bbpath = data.getVar("BBPATH")
+    bbpath = data.getVar("BBPATH", True)
     if bbpath:
         for i in bbpath.split(":"):
             search.append(os.path.join(i, "conf", configfile))
@@ -240,9 +215,9 @@ class CookerDataBuilder(object):
 
         bb.utils.set_context(bb.utils.clean_context())
         bb.event.set_class_handlers(bb.event.clean_class_handlers())
-        self.basedata = bb.data.init()
+        self.data = bb.data.init()
         if self.tracking:
-            self.basedata.enableTracking()
+            self.data.enableTracking()
 
         # Keep a datastore of the initial environment variables and their
         # values from when BitBake was launched to enable child processes
@@ -253,49 +228,16 @@ class CookerDataBuilder(object):
             self.savedenv.setVar(k, cookercfg.env[k])
 
         filtered_keys = bb.utils.approved_variables()
-        bb.data.inheritFromOS(self.basedata, self.savedenv, filtered_keys)
-        self.basedata.setVar("BB_ORIGENV", self.savedenv)
+        bb.data.inheritFromOS(self.data, self.savedenv, filtered_keys)
+        self.data.setVar("BB_ORIGENV", self.savedenv)
         
         if worker:
-            self.basedata.setVar("BB_WORKERCONTEXT", "1")
-
-        self.data = self.basedata
-        self.mcdata = {}
+            self.data.setVar("BB_WORKERCONTEXT", "1")
 
     def parseBaseConfiguration(self):
         try:
-            bb.parse.init_parser(self.basedata)
-            self.data = self.parseConfigurationFiles(self.prefiles, self.postfiles)
-
-            if self.data.getVar("BB_WORKERCONTEXT", False) is None:
-                bb.fetch.fetcher_init(self.data)
-            bb.codeparser.parser_cache_init(self.data)
-
-            bb.event.fire(bb.event.ConfigParsed(), self.data)
-
-            reparse_cnt = 0
-            while self.data.getVar("BB_INVALIDCONF", False) is True:
-                if reparse_cnt > 20:
-                    logger.error("Configuration has been re-parsed over 20 times, "
-                                 "breaking out of the loop...")
-                    raise Exception("Too deep config re-parse loop. Check locations where "
-                                    "BB_INVALIDCONF is being set (ConfigParsed event handlers)")
-                self.data.setVar("BB_INVALIDCONF", False)
-                self.data = self.parseConfigurationFiles(self.prefiles, self.postfiles)
-                reparse_cnt += 1
-                bb.event.fire(bb.event.ConfigParsed(), self.data)
-
-            bb.parse.init_parser(self.data)
-            self.data_hash = self.data.get_hash()
-            self.mcdata[''] = self.data
-
-            multiconfig = (self.data.getVar("BBMULTICONFIG") or "").split()
-            for config in multiconfig:
-                mcdata = self.parseConfigurationFiles(self.prefiles, self.postfiles, config)
-                bb.event.fire(bb.event.ConfigParsed(), mcdata)
-                self.mcdata[config] = mcdata
-
-        except (SyntaxError, bb.BBHandledException):
+            self.parseConfigurationFiles(self.prefiles, self.postfiles)
+        except SyntaxError:
             raise bb.BBHandledException
         except bb.data_smart.ExpansionError as e:
             logger.error(str(e))
@@ -307,9 +249,9 @@ class CookerDataBuilder(object):
     def _findLayerConf(self, data):
         return findConfigFile("bblayers.conf", data)
 
-    def parseConfigurationFiles(self, prefiles, postfiles, mc = "default"):
-        data = bb.data.createCopy(self.basedata)
-        data.setVar("BB_CURRENT_MC", mc)
+    def parseConfigurationFiles(self, prefiles, postfiles):
+        data = self.data
+        bb.parse.init_parser(data)
 
         # Parse files for loading *before* bitbake.conf and any includes
         for f in prefiles:
@@ -323,30 +265,18 @@ class CookerDataBuilder(object):
             data.setVar("TOPDIR", os.path.dirname(os.path.dirname(layerconf)))
             data = parse_config_file(layerconf, data)
 
-            layers = (data.getVar('BBLAYERS') or "").split()
+            layers = (data.getVar('BBLAYERS', True) or "").split()
 
             data = bb.data.createCopy(data)
-            approved = bb.utils.approved_variables()
             for layer in layers:
-                if not os.path.isdir(layer):
-                    parselog.critical("Layer directory '%s' does not exist! "
-                                      "Please check BBLAYERS in %s" % (layer, layerconf))
-                    sys.exit(1)
                 parselog.debug(2, "Adding layer %s", layer)
-                if 'HOME' in approved and '~' in layer:
-                    layer = os.path.expanduser(layer)
-                if layer.endswith('/'):
-                    layer = layer.rstrip('/')
                 data.setVar('LAYERDIR', layer)
-                data.setVar('LAYERDIR_RE', re.escape(layer))
                 data = parse_config_file(os.path.join(layer, "conf", "layer.conf"), data)
                 data.expandVarref('LAYERDIR')
-                data.expandVarref('LAYERDIR_RE')
 
-            data.delVar('LAYERDIR_RE')
             data.delVar('LAYERDIR')
 
-        if not data.getVar("BBPATH"):
+        if not data.getVar("BBPATH", True):
             msg = "The BBPATH variable is not set"
             if not layerconf:
                 msg += (" and bitbake did not find a conf/bblayers.conf file in"
@@ -361,21 +291,29 @@ class CookerDataBuilder(object):
             data = parse_config_file(p, data)
 
         # Handle any INHERITs and inherit the base class
-        bbclasses  = ["base"] + (data.getVar('INHERIT') or "").split()
+        bbclasses  = ["base"] + (data.getVar('INHERIT', True) or "").split()
         for bbclass in bbclasses:
             data = _inherit(bbclass, data)
 
         # Nomally we only register event handlers at the end of parsing .bb files
         # We register any handlers we've found so far here...
-        for var in data.getVar('__BBHANDLERS', False) or []:
-            handlerfn = data.getVarFlag(var, "filename", False)
-            if not handlerfn:
-                parselog.critical("Undefined event handler function '%s'" % var)
-                sys.exit(1)
-            handlerln = int(data.getVarFlag(var, "lineno", False))
-            bb.event.register(var, data.getVar(var, False),  (data.getVarFlag(var, "eventmask") or "").split(), handlerfn, handlerln)
+        for var in data.getVar('__BBHANDLERS') or []:
+            bb.event.register(var, data.getVar(var),  (data.getVarFlag(var, "eventmask", True) or "").split())
 
+        if data.getVar("BB_WORKERCONTEXT", False) is None:
+            bb.fetch.fetcher_init(data)
+        bb.codeparser.parser_cache_init(data)
+        bb.event.fire(bb.event.ConfigParsed(), data)
+
+        if data.getVar("BB_INVALIDCONF") is True:
+            data.setVar("BB_INVALIDCONF", False)
+            self.parseConfigurationFiles(self.prefiles, self.postfiles)
+            return
+
+        bb.parse.init_parser(data)
         data.setVar('BBINCLUDED',bb.parse.get_file_depends(data))
+        self.data = data
+        self.data_hash = data.get_hash()
+
 
-        return data
 

bitbake/lib/bb/daemonize.py

@@ -178,8 +178,8 @@ def createDaemon(function, logfile):
 #    os.dup2(0, 2)                      # standard error (2)
 
 
-    si = open('/dev/null', 'r')
-    so = open(logfile, 'w')
+    si = file('/dev/null', 'r')
+    so = file(logfile, 'w')
     se = so
 
 

bitbake/lib/bb/data.py

@@ -78,6 +78,59 @@ def initVar(var, d):
     """Non-destructive var init for data structure"""
     d.initVar(var)
 
+
+def setVar(var, value, d):
+    """Set a variable to a given value"""
+    d.setVar(var, value)
+
+
+def getVar(var, d, exp = 0):
+    """Gets the value of a variable"""
+    return d.getVar(var, exp)
+
+
+def renameVar(key, newkey, d):
+    """Renames a variable from key to newkey"""
+    d.renameVar(key, newkey)
+
+def delVar(var, d):
+    """Removes a variable from the data set"""
+    d.delVar(var)
+
+def appendVar(var, value, d):
+    """Append additional value to a variable"""
+    d.appendVar(var, value)
+
+def setVarFlag(var, flag, flagvalue, d):
+    """Set a flag for a given variable to a given value"""
+    d.setVarFlag(var, flag, flagvalue)
+
+def getVarFlag(var, flag, d):
+    """Gets given flag from given var"""
+    return d.getVarFlag(var, flag)
+
+def delVarFlag(var, flag, d):
+    """Removes a given flag from the variable's flags"""
+    d.delVarFlag(var, flag)
+
+def setVarFlags(var, flags, d):
+    """Set the flags for a given variable
+
+    Note:
+        setVarFlags will not clear previous
+        flags. Think of this method as
+        addVarFlags
+    """
+    d.setVarFlags(var, flags)
+
+def getVarFlags(var, d):
+    """Gets a variable's flags"""
+    return d.getVarFlags(var)
+
+def delVarFlags(var, d):
+    """Removes a variable's flags"""
+    d.delVarFlags(var)
+
 def keys(d):
     """Return a list of keys in d"""
     return d.keys()
@@ -106,12 +159,13 @@ def expandKeys(alterdata, readdata = None):
 
     # These two for loops are split for performance to maximise the
     # usefulness of the expand cache
-    for key in sorted(todolist):
+
+    for key in todolist:
         ekey = todolist[key]
-        newval = alterdata.getVar(ekey, False)
-        if newval is not None:
-            val = alterdata.getVar(key, False)
-            if val is not None:
+        newval = alterdata.getVar(ekey, 0)
+        if newval:
+            val = alterdata.getVar(key, 0)
+            if val is not None and newval is not None:
                 bb.warn("Variable key %s (%s) replaces original key %s (%s)." % (key, val, ekey, newval))
         alterdata.renameVar(key, ekey)
 
@@ -121,7 +175,7 @@ def inheritFromOS(d, savedenv, permitted):
     for s in savedenv.keys():
         if s in permitted:
             try:
-                d.setVar(s, savedenv.getVar(s), op = 'from env')
+                d.setVar(s, getVar(s, savedenv, True), op = 'from env')
                 if s in exportlist:
                     d.setVarFlag(s, "export", True, op = 'auto env export')
             except TypeError:
@@ -129,39 +183,39 @@ def inheritFromOS(d, savedenv, permitted):
 
 def emit_var(var, o=sys.__stdout__, d = init(), all=False):
     """Emit a variable to be sourced by a shell."""
-    func = d.getVarFlag(var, "func", False)
-    if d.getVarFlag(var, 'python', False) and func:
-        return False
+    if getVarFlag(var, "python", d):
+        return 0
 
-    export = d.getVarFlag(var, "export", False)
-    unexport = d.getVarFlag(var, "unexport", False)
+    export = getVarFlag(var, "export", d)
+    unexport = getVarFlag(var, "unexport", d)
+    func = getVarFlag(var, "func", d)
     if not all and not export and not unexport and not func:
-        return False
+        return 0
 
     try:
         if all:
-            oval = d.getVar(var, False)
-        val = d.getVar(var)
+            oval = getVar(var, d, 0)
+        val = getVar(var, d, 1)
     except (KeyboardInterrupt, bb.build.FuncFailed):
         raise
     except Exception as exc:
         o.write('# expansion of %s threw %s: %s\n' % (var, exc.__class__.__name__, str(exc)))
-        return False
+        return 0
 
     if all:
-        d.varhistory.emit(var, oval, val, o, d)
+        d.varhistory.emit(var, oval, val, o)
 
     if (var.find("-") != -1 or var.find(".") != -1 or var.find('{') != -1 or var.find('}') != -1 or var.find('+') != -1) and not all:
-        return False
+        return 0
 
-    varExpanded = d.expand(var)
+    varExpanded = expand(var, d)
 
     if unexport:
         o.write('unset %s\n' % varExpanded)
-        return False
+        return 0
 
     if val is None:
-        return False
+        return 0
 
     val = str(val)
 
@@ -170,11 +224,10 @@ def emit_var(var, o=sys.__stdout__, d = init(), all=False):
         val = val[3:] # Strip off "() "
         o.write("%s() %s\n" % (varExpanded, val))
         o.write("export -f %s\n" % (varExpanded))
-        return True
+        return 1
 
     if func:
         # NOTE: should probably check for unbalanced {} within the var
-        val = val.rstrip('\n')
         o.write("%s() {\n%s\n}\n" % (varExpanded, val))
         return 1
 
@@ -187,31 +240,29 @@ def emit_var(var, o=sys.__stdout__, d = init(), all=False):
     alter = re.sub('\n', ' \\\n', alter)
     alter = re.sub('\\$', '\\\\$', alter)
     o.write('%s="%s"\n' % (varExpanded, alter))
-    return False
+    return 0
 
 def emit_env(o=sys.__stdout__, d = init(), all=False):
     """Emits all items in the data store in a format such that it can be sourced by a shell."""
 
-    isfunc = lambda key: bool(d.getVarFlag(key, "func", False))
+    isfunc = lambda key: bool(d.getVarFlag(key, "func"))
     keys = sorted((key for key in d.keys() if not key.startswith("__")), key=isfunc)
     grouped = groupby(keys, isfunc)
     for isfunc, keys in grouped:
-        for key in sorted(keys):
+        for key in keys:
             emit_var(key, o, d, all and not isfunc) and o.write('\n')
 
 def exported_keys(d):
     return (key for key in d.keys() if not key.startswith('__') and
-                                      d.getVarFlag(key, 'export', False) and
-                                      not d.getVarFlag(key, 'unexport', False))
+                                      d.getVarFlag(key, 'export') and
+                                      not d.getVarFlag(key, 'unexport'))
 
 def exported_vars(d):
-    k = list(exported_keys(d))
-    for key in k:
+    for key in exported_keys(d):
         try:
-            value = d.getVar(key)
-        except Exception as err:
-            bb.warn("%s: Unable to export ${%s}: %s" % (d.getVar("FILE"), key, err))
-            continue
+            value = d.getVar(key, True)
+        except Exception:
+            pass
 
         if value is not None:
             yield key, str(value)
@@ -219,24 +270,23 @@ def exported_vars(d):
 def emit_func(func, o=sys.__stdout__, d = init()):
     """Emits all items in the data store in a format such that it can be sourced by a shell."""
 
-    keys = (key for key in d.keys() if not key.startswith("__") and not d.getVarFlag(key, "func", False))
-    for key in sorted(keys):
-        emit_var(key, o, d, False)
+    keys = (key for key in d.keys() if not key.startswith("__") and not d.getVarFlag(key, "func"))
+    for key in keys:
+        emit_var(key, o, d, False) and o.write('\n')
 
-    o.write('\n')
     emit_var(func, o, d, False) and o.write('\n')
-    newdeps = bb.codeparser.ShellParser(func, logger).parse_shell(d.getVar(func))
-    newdeps |= set((d.getVarFlag(func, "vardeps") or "").split())
+    newdeps = bb.codeparser.ShellParser(func, logger).parse_shell(d.getVar(func, True))
+    newdeps |= set((d.getVarFlag(func, "vardeps", True) or "").split())
     seen = set()
     while newdeps:
         deps = newdeps
         seen |= deps
         newdeps = set()
         for dep in deps:
-            if d.getVarFlag(dep, "func", False) and not d.getVarFlag(dep, "python", False):
+            if d.getVarFlag(dep, "func") and not d.getVarFlag(dep, "python"):
                emit_var(dep, o, d, False) and o.write('\n')
-               newdeps |=  bb.codeparser.ShellParser(dep, logger).parse_shell(d.getVar(dep))
-               newdeps |= set((d.getVarFlag(dep, "vardeps") or "").split())
+               newdeps |=  bb.codeparser.ShellParser(dep, logger).parse_shell(d.getVar(dep, True))
+               newdeps |= set((d.getVarFlag(dep, "vardeps", True) or "").split())
         newdeps -= seen
 
 _functionfmt = """
@@ -247,7 +297,7 @@ def emit_func_python(func, o=sys.__stdout__, d = init()):
     """Emits all items in the data store in a format such that it can be sourced by a shell."""
 
     def write_func(func, o, call = False):
-        body = d.getVar(func, False)
+        body = d.getVar(func, True)
         if not body.startswith("def"):
             body = _functionfmt.format(function=func, body=body)
 
@@ -257,21 +307,21 @@ def emit_func_python(func, o=sys.__stdout__, d = init()):
 
     write_func(func, o, True)
     pp = bb.codeparser.PythonParser(func, logger)
-    pp.parse_python(d.getVar(func, False))
+    pp.parse_python(d.getVar(func, True))
     newdeps = pp.execs
-    newdeps |= set((d.getVarFlag(func, "vardeps") or "").split())
+    newdeps |= set((d.getVarFlag(func, "vardeps", True) or "").split())
     seen = set()
     while newdeps:
         deps = newdeps
         seen |= deps
         newdeps = set()
         for dep in deps:
-            if d.getVarFlag(dep, "func", False) and d.getVarFlag(dep, "python", False):
+            if d.getVarFlag(dep, "func") and d.getVarFlag(dep, "python"):
                write_func(dep, o)
                pp = bb.codeparser.PythonParser(dep, logger)
-               pp.parse_python(d.getVar(dep, False))
+               pp.parse_python(d.getVar(dep, True))
                newdeps |= pp.execs
-               newdeps |= set((d.getVarFlag(dep, "vardeps") or "").split())
+               newdeps |= set((d.getVarFlag(dep, "vardeps", True) or "").split())
         newdeps -= seen
 
 def update_data(d):
@@ -288,21 +338,19 @@ def build_dependencies(key, keys, shelldeps, varflagsexcl, d):
             deps |= parser.references
             deps = deps | (keys & parser.execs)
             return deps, value
-        varflags = d.getVarFlags(key, ["vardeps", "vardepvalue", "vardepsexclude", "exports", "postfuncs", "prefuncs", "lineno", "filename"]) or {}
+        varflags = d.getVarFlags(key, ["vardeps", "vardepvalue", "vardepsexclude", "vardepvalueexclude", "postfuncs", "prefuncs"]) or {}
         vardeps = varflags.get("vardeps")
         value = d.getVar(key, False)
 
         def handle_contains(value, contains, d):
             newvalue = ""
             for k in sorted(contains):
-                l = (d.getVar(k) or "").split()
-                for item in sorted(contains[k]):
-                    for word in item.split():
-                        if not word in l:
-                            newvalue += "\n%s{%s} = Unset" % (k, item)
-                            break
+                l = (d.getVar(k, True) or "").split()
+                for word in sorted(contains[k]):
+                    if word in l:
+                        newvalue += "\n%s{%s} = Set" %  (k, word)
                     else:
-                        newvalue += "\n%s{%s} = Set" % (k, item)
+                        newvalue += "\n%s{%s} = Unset" %  (k, word)
             if not newvalue:
                 return value
             if not value:
@@ -313,29 +361,27 @@ def build_dependencies(key, keys, shelldeps, varflagsexcl, d):
            value = varflags.get("vardepvalue")
         elif varflags.get("func"):
             if varflags.get("python"):
+                parsedvar = d.expandWithRefs(value, key)
                 parser = bb.codeparser.PythonParser(key, logger)
-                if value and "\t" in value:
-                    logger.warning("Variable %s contains tabs, please remove these (%s)" % (key, d.getVar("FILE")))
-                parser.parse_python(value, filename=varflags.get("filename"), lineno=varflags.get("lineno"))
+                if parsedvar.value and "\t" in parsedvar.value:
+                    logger.warn("Variable %s contains tabs, please remove these (%s)" % (key, d.getVar("FILE", True)))
+                parser.parse_python(parsedvar.value)
                 deps = deps | parser.references
-                deps = deps | (keys & parser.execs)
                 value = handle_contains(value, parser.contains, d)
             else:
                 parsedvar = d.expandWithRefs(value, key)
                 parser = bb.codeparser.ShellParser(key, logger)
                 parser.parse_shell(parsedvar.value)
                 deps = deps | shelldeps
-                deps = deps | parsedvar.references
-                deps = deps | (keys & parser.execs) | (keys & parsedvar.execs)
-                value = handle_contains(value, parsedvar.contains, d)
             if vardeps is None:
                 parser.log.flush()
             if "prefuncs" in varflags:
                 deps = deps | set(varflags["prefuncs"].split())
             if "postfuncs" in varflags:
                 deps = deps | set(varflags["postfuncs"].split())
-            if "exports" in varflags:
-                deps = deps | set(varflags["exports"].split())
+            deps = deps | parsedvar.references
+            deps = deps | (keys & parser.execs) | (keys & parsedvar.execs)
+            value = handle_contains(value, parsedvar.contains, d)
         else:
             parser = d.expandWithRefs(value, key)
             deps |= parser.references
@@ -359,11 +405,8 @@ def build_dependencies(key, keys, shelldeps, varflagsexcl, d):
 
         deps |= set((vardeps or "").split())
         deps -= set(varflags.get("vardepsexclude", "").split())
-    except bb.parse.SkipRecipe:
-        raise
     except Exception as e:
-        bb.warn("Exception during build_dependencies for %s" % key)
-        raise
+        raise bb.data_smart.ExpansionError(key, None, e)
     return deps, value
     #bb.note("Variable %s references %s and calls %s" % (key, str(deps), str(execs)))
     #d.setVarFlag(key, "vardeps", deps)
@@ -371,13 +414,13 @@ def build_dependencies(key, keys, shelldeps, varflagsexcl, d):
 def generate_dependencies(d):
 
     keys = set(key for key in d if not key.startswith("__"))
-    shelldeps = set(key for key in d.getVar("__exportlist", False) if d.getVarFlag(key, "export", False) and not d.getVarFlag(key, "unexport", False))
-    varflagsexcl = d.getVar('BB_SIGNATURE_EXCLUDE_FLAGS')
+    shelldeps = set(key for key in d.getVar("__exportlist", False) if d.getVarFlag(key, "export") and not d.getVarFlag(key, "unexport"))
+    varflagsexcl = d.getVar('BB_SIGNATURE_EXCLUDE_FLAGS', True)
 
     deps = {}
     values = {}
 
-    tasklist = d.getVar('__BBTASKS', False) or []
+    tasklist = d.getVar('__BBTASKS') or []
     for task in tasklist:
         deps[task], values[task] = build_dependencies(task, keys, shelldeps, varflagsexcl, d)
         newdeps = deps[task]
@@ -395,7 +438,7 @@ def generate_dependencies(d):
     return tasklist, deps, values
 
 def inherits_class(klass, d):
-    val = d.getVar('__inherit_cache', False) or []
+    val = getVar('__inherit_cache', d) or []
     needle = os.path.join('classes', '%s.bbclass' % klass)
     for v in val:
         if v.endswith(needle):

bitbake/lib/bb/data_smart.py

@@ -40,7 +40,7 @@ logger = logging.getLogger("BitBake.Data")
 
 __setvar_keyword__ = ["_append", "_prepend", "_remove"]
 __setvar_regexp__ = re.compile('(?P<base>.*?)(?P<keyword>_append|_prepend|_remove)(_(?P<add>.*))?$')
-__expand_var_regexp__ = re.compile(r"\${[^{}@\n\t :]+}")
+__expand_var_regexp__ = re.compile(r"\${[^{}@\n\t ]+}")
 __expand_python_regexp__ = re.compile(r"\${@.+?}")
 
 def infer_caller_details(loginfo, parent = False, varval = True):
@@ -54,36 +54,27 @@ def infer_caller_details(loginfo, parent = False, varval = True):
         return
     # Infer caller's likely values for variable (var) and value (value), 
     # to reduce clutter in the rest of the code.
-    above = None
-    def set_above():
+    if varval and ('variable' not in loginfo or 'detail' not in loginfo):
         try:
             raise Exception
         except Exception:
             tb = sys.exc_info()[2]
             if parent:
-                return tb.tb_frame.f_back.f_back.f_back
+                above = tb.tb_frame.f_back.f_back
             else:
-                return tb.tb_frame.f_back.f_back
-
-    if varval and ('variable' not in loginfo or 'detail' not in loginfo):
-        if not above:
-            above = set_above()
-        lcls = above.f_locals.items()
+                above = tb.tb_frame.f_back
+            lcls = above.f_locals.items()
         for k, v in lcls:
             if k == 'value' and 'detail' not in loginfo:
                 loginfo['detail'] = v
             if k == 'var' and 'variable' not in loginfo:
                 loginfo['variable'] = v
     # Infer file/line/function from traceback
-    # Don't use traceback.extract_stack() since it fills the line contents which
-    # we don't need and that hits stat syscalls
     if 'file' not in loginfo:
-        if not above:
-            above = set_above()
-        f = above.f_back
-        line = f.f_lineno
-        file = f.f_code.co_filename
-        func = f.f_code.co_name
+        depth = 3    
+        if parent:
+            depth = 4
+        file, line, func, text = traceback.extract_stack(limit = depth)[0]
         loginfo['file'] = file
         loginfo['line'] = line
         if func not in loginfo:
@@ -108,7 +99,7 @@ class VariableParse:
                 varparse = self.d.expand_cache[key]
                 var = varparse.value
             else:
-                var = self.d.getVarFlag(key, "_content")
+                var = self.d.getVarFlag(key, "_content", True)
             self.references.add(key)
             if var is not None:
                 return var
@@ -116,21 +107,13 @@ class VariableParse:
                 return match.group()
 
     def python_sub(self, match):
-            if isinstance(match, str):
-                code = match
-            else:
-                code = match.group()[3:-1]
-
-            if "_remote_data" in self.d:
-                connector = self.d["_remote_data"]
-                return connector.expandPythonRef(self.varname, code, self.d)
-
+            code = match.group()[3:-1]
             codeobj = compile(code.strip(), self.varname or "<expansion>", "eval")
 
             parser = bb.codeparser.PythonParser(self.varname, logger)
             parser.parse_python(code)
             if self.varname:
-                vardeps = self.d.getVarFlag(self.varname, "vardeps")
+                vardeps = self.d.getVarFlag(self.varname, "vardeps", True)
                 if vardeps is None:
                     parser.log.flush()
             else:
@@ -143,7 +126,7 @@ class VariableParse:
                     self.contains[k] = parser.contains[k].copy()
                 else:
                     self.contains[k].update(parser.contains[k])
-            value = utils.better_eval(codeobj, DataContext(self.d), {'d' : self.d})
+            value = utils.better_eval(codeobj, DataContext(self.d))
             return str(value)
 
 
@@ -154,8 +137,8 @@ class DataContext(dict):
         self['d'] = metadata
 
     def __missing__(self, key):
-        value = self.metadata.getVar(key)
-        if value is None or self.metadata.getVarFlag(key, 'func', False):
+        value = self.metadata.getVar(key, True)
+        if value is None or self.metadata.getVarFlag(key, 'func'):
             raise KeyError(key)
         else:
             return value
@@ -230,19 +213,6 @@ class VariableHistory(object):
         new.variables = self.variables.copy()
         return new
 
-    def __getstate__(self):
-        vardict = {}
-        for k, v in self.variables.iteritems():
-            vardict[k] = v
-        return {'dataroot': self.dataroot,
-                'variables': vardict}
-
-    def __setstate__(self, state):
-        self.dataroot = state['dataroot']
-        self.variables = COWDictBase.copy()
-        for k, v in state['variables'].items():
-            self.variables[k] = v
-
     def record(self, *kwonly, **loginfo):
         if not self.dataroot._tracking:
             return
@@ -261,37 +231,16 @@ class VariableHistory(object):
 
         if var not in self.variables:
             self.variables[var] = []
-        if not isinstance(self.variables[var], list):
-            return
-        if 'nodups' in loginfo and loginfo in self.variables[var]:
-            return
         self.variables[var].append(loginfo.copy())
 
     def variable(self, var):
-        remote_connector = self.dataroot.getVar('_remote_data', False)
-        if remote_connector:
-            varhistory = remote_connector.getVarHistory(var)
-        else:
-            varhistory = []
-
         if var in self.variables:
-            varhistory.extend(self.variables[var])
-        return varhistory
+            return self.variables[var]
+        else:
+            return []
 
-    def emit(self, var, oval, val, o, d):
+    def emit(self, var, oval, val, o):
         history = self.variable(var)
-
-        # Append override history
-        if var in d.overridedata:
-            for (r, override) in d.overridedata[var]:
-                for event in self.variable(r):
-                    loginfo = event.copy()
-                    if 'flag' in loginfo and not loginfo['flag'].startswith("_"):
-                        continue
-                    loginfo['variable'] = var
-                    loginfo['op'] = 'override[%s]:%s' % (override, loginfo['op'])
-                    history.append(loginfo)
-
         commentVal = re.sub('\n', '\n#', str(oval))
         if history:
             if len(history) == 1:
@@ -338,31 +287,6 @@ class VariableHistory(object):
                 lines.append(line)
         return lines
 
-    def get_variable_items_files(self, var, d):
-        """
-        Use variable history to map items added to a list variable and
-        the files in which they were added.
-        """
-        history = self.variable(var)
-        finalitems = (d.getVar(var) or '').split()
-        filemap = {}
-        isset = False
-        for event in history:
-            if 'flag' in event:
-                continue
-            if event['op'] == '_remove':
-                continue
-            if isset and event['op'] == 'set?':
-                continue
-            isset = True
-            items = d.expand(event['detail']).split()
-            for item in items:
-                # This is a little crude but is belt-and-braces to avoid us
-                # having to handle every possible operation type specifically
-                if item in finalitems and not item in filemap:
-                    filemap[item] = event['file']
-        return filemap
-
     def del_var_history(self, var, f=None, line=None):
         """If file f and line are not given, the entire history of var is deleted"""
         if var in self.variables:
@@ -372,23 +296,18 @@ class VariableHistory(object):
                 self.variables[var] = []
 
 class DataSmart(MutableMapping):
-    def __init__(self):
+    def __init__(self, special = COWDictBase.copy(), seen = COWDictBase.copy() ):
         self.dict = {}
 
         self.inchistory = IncludeHistory()
         self.varhistory = VariableHistory(self)
         self._tracking = False
 
-        self.expand_cache = {}
-
         # cookie monster tribute
-        # Need to be careful about writes to overridedata as
-        # its only a shallow copy, could influence other data store
-        # copies!
-        self.overridedata = {}
-        self.overrides = None
-        self.overridevars = set(["OVERRIDES", "FILE"])
-        self.inoverride = False
+        self._special_values = special
+        self._seen_overrides = seen
+
+        self.expand_cache = {}
 
     def enableTracking(self):
         self._tracking = True
@@ -398,7 +317,7 @@ class DataSmart(MutableMapping):
 
     def expandWithRefs(self, s, varname):
 
-        if not isinstance(s, str): # sanity check
+        if not isinstance(s, basestring): # sanity check
             return VariableParse(varname, self, s)
 
         if varname and varname in self.expand_cache:
@@ -410,12 +329,7 @@ class DataSmart(MutableMapping):
             olds = s
             try:
                 s = __expand_var_regexp__.sub(varparse.var_sub, s)
-                try:
-                    s = __expand_python_regexp__.sub(varparse.python_sub, s)
-                except SyntaxError as e:
-                    # Likely unmatched brackets, just don't expand the expression
-                    if e.msg != "EOL while scanning string literal":
-                        raise
+                s = __expand_python_regexp__.sub(varparse.python_sub, s)
                 if s == olds:
                     break
             except ExpansionError:
@@ -423,7 +337,7 @@ class DataSmart(MutableMapping):
             except bb.parse.SkipRecipe:
                 raise
             except Exception as exc:
-                raise ExpansionError(varname, s, exc) from exc
+                raise ExpansionError(varname, s, exc)
 
         varparse.value = s
 
@@ -435,34 +349,97 @@ class DataSmart(MutableMapping):
     def expand(self, s, varname = None):
         return self.expandWithRefs(s, varname).value
 
+
     def finalize(self, parent = False):
-        return
-
-    def internal_finalize(self, parent = False):
         """Performs final steps upon the datastore, including application of overrides"""
-        self.overrides = None
 
-    def need_overrides(self):
-        if self.overrides is not None:
-            return
-        if self.inoverride:
-            return
-        for count in range(5):
-            self.inoverride = True
-            # Can end up here recursively so setup dummy values
-            self.overrides = []
-            self.overridesset = set()
-            self.overrides = (self.getVar("OVERRIDES") or "").split(":") or []
-            self.overridesset = set(self.overrides)
-            self.inoverride = False
-            self.expand_cache = {}
-            newoverrides = (self.getVar("OVERRIDES") or "").split(":") or []
-            if newoverrides == self.overrides:
-                break
-            self.overrides = newoverrides
-            self.overridesset = set(self.overrides)
-        else:
-            bb.fatal("Overrides could not be expanded into a stable state after 5 iterations, overrides must be being referenced by other overridden variables in some recursive fashion. Please provide your configuration to bitbake-devel so we can laugh, er, I mean try and understand how to make it work.")
+        overrides = (self.getVar("OVERRIDES", True) or "").split(":") or []
+        finalize_caller = {
+            'op': 'finalize',
+        }
+        infer_caller_details(finalize_caller, parent = parent, varval = False)
+
+        #
+        # Well let us see what breaks here. We used to iterate
+        # over each variable and apply the override and then
+        # do the line expanding.
+        # If we have bad luck - which we will have - the keys
+        # where in some order that is so important for this
+        # method which we don't have anymore.
+        # Anyway we will fix that and write test cases this
+        # time.
+
+        #
+        # First we apply all overrides
+        # Then we will handle _append and _prepend and store the _remove
+        # information for later.
+        #
+
+        # We only want to report finalization once per variable overridden.
+        finalizes_reported = {}
+
+        for o in overrides:
+            # calculate '_'+override
+            l = len(o) + 1
+
+            # see if one should even try
+            if o not in self._seen_overrides:
+                continue
+
+            vars = self._seen_overrides[o].copy()
+            for var in vars:
+                name = var[:-l]
+                try:
+                    # Report only once, even if multiple changes.
+                    if name not in finalizes_reported:
+                        finalizes_reported[name] = True
+                        finalize_caller['variable'] = name
+                        finalize_caller['detail'] = 'was: ' + str(self.getVar(name, False))
+                        self.varhistory.record(**finalize_caller)
+                    # Copy history of the override over.
+                    for event in self.varhistory.variable(var):
+                        loginfo = event.copy()
+                        loginfo['variable'] = name
+                        loginfo['op'] = 'override[%s]:%s' % (o, loginfo['op'])
+                        self.varhistory.record(**loginfo)
+                    self.setVar(name, self.getVar(var, False), op = 'finalize', file = 'override[%s]' % o, line = '')
+                    self.delVar(var)
+                except Exception:
+                    logger.info("Untracked delVar")
+
+        # now on to the appends and prepends, and stashing the removes
+        for op in __setvar_keyword__:
+            if op in self._special_values:
+                appends = self._special_values[op] or []
+                for append in appends:
+                    keep = []
+                    for (a, o) in self.getVarFlag(append, op) or []:
+                        match = True
+                        if o:
+                            for o2 in o.split("_"):
+                                if not o2 in overrides:
+                                    match = False
+                        if not match:
+                            keep.append((a ,o))
+                            continue
+
+                        if op == "_append":
+                            sval = self.getVar(append, False) or ""
+                            sval += a
+                            self.setVar(append, sval)
+                        elif op == "_prepend":
+                            sval = a + (self.getVar(append, False) or "")
+                            self.setVar(append, sval)
+                        elif op == "_remove":
+                            removes = self.getVarFlag(append, "_removeactive", False) or []
+                            removes.extend(a.split())
+                            self.setVarFlag(append, "_removeactive", removes, ignore=True)
+
+                    # We save overrides that may be applied at some later stage
+                    if keep:
+                        self.setVarFlag(append, op, keep, ignore=True)
+                    else:
+                        self.delVarFlag(append, op, ignore=True)
 
     def initVar(self, var):
         self.expand_cache = {}
@@ -473,22 +450,17 @@ class DataSmart(MutableMapping):
         dest = self.dict
         while dest:
             if var in dest:
-                return dest[var], self.overridedata.get(var, None)
-
-            if "_remote_data" in dest:
-                connector = dest["_remote_data"]["_content"]
-                return connector.getVar(var)
+                return dest[var]
 
             if "_data" not in dest:
                 break
             dest = dest["_data"]
-        return None, self.overridedata.get(var, None)
 
     def _makeShadowCopy(self, var):
         if var in self.dict:
             return
 
-        local_var, _ = self._findVar(var)
+        local_var = self._findVar(var)
 
         if local_var:
             self.dict[var] = copy.copy(local_var)
@@ -498,16 +470,6 @@ class DataSmart(MutableMapping):
 
     def setVar(self, var, value, **loginfo):
         #print("var=" + str(var) + "  val=" + str(value))
-        parsing=False
-        if 'parsing' in loginfo:
-            parsing=True
-
-        if '_remote_data' in self.dict:
-            connector = self.dict["_remote_data"]["_content"]
-            res = connector.setVar(var, value)
-            if not res:
-                return
-
         if 'op' not in loginfo:
             loginfo['op'] = "set"
         self.expand_cache = {}
@@ -516,7 +478,7 @@ class DataSmart(MutableMapping):
             base = match.group('base')
             keyword = match.group("keyword")
             override = match.group('add')
-            l = self.getVarFlag(base, keyword, False) or []
+            l = self.getVarFlag(base, keyword) or []
             l.append([value, override])
             self.setVarFlag(base, keyword, l, ignore=True)
             # And cause that to be recorded:
@@ -529,119 +491,65 @@ class DataSmart(MutableMapping):
             self.varhistory.record(**loginfo)
             # todo make sure keyword is not __doc__ or __module__
             # pay the cookie monster
+            try:
+                self._special_values[keyword].add(base)
+            except KeyError:
+                self._special_values[keyword] = set()
+                self._special_values[keyword].add(base)
 
-            # more cookies for the cookie monster
-            if '_' in var:
-                self._setvar_update_overrides(base, **loginfo)
-
-            if base in self.overridevars:
-                self._setvar_update_overridevars(var, value)
             return
 
         if not var in self.dict:
             self._makeShadowCopy(var)
 
-        if not parsing:
-            if "_append" in self.dict[var]:
-                del self.dict[var]["_append"]
-            if "_prepend" in self.dict[var]:
-                del self.dict[var]["_prepend"]
-            if "_remove" in self.dict[var]:
-                del self.dict[var]["_remove"]
-            if var in self.overridedata:
-                active = []
-                self.need_overrides()
-                for (r, o) in self.overridedata[var]:
-                    if o in self.overridesset:
-                        active.append(r)
-                    elif "_" in o:
-                        if set(o.split("_")).issubset(self.overridesset):
-                            active.append(r)
-                for a in active:
-                    self.delVar(a)
-                del self.overridedata[var]
-
         # more cookies for the cookie monster
         if '_' in var:
-            self._setvar_update_overrides(var, **loginfo)
+            self._setvar_update_overrides(var)
 
         # setting var
         self.dict[var]["_content"] = value
         self.varhistory.record(**loginfo)
 
-        if var in self.overridevars:
-            self._setvar_update_overridevars(var, value)
-
-    def _setvar_update_overridevars(self, var, value):
-        vardata = self.expandWithRefs(value, var)
-        new = vardata.references
-        new.update(vardata.contains.keys())
-        while not new.issubset(self.overridevars):
-            nextnew = set()
-            self.overridevars.update(new)
-            for i in new:
-                vardata = self.expandWithRefs(self.getVar(i), i)
-                nextnew.update(vardata.references)
-                nextnew.update(vardata.contains.keys())
-            new = nextnew
-        self.internal_finalize(True)
-
-    def _setvar_update_overrides(self, var, **loginfo):
+    def _setvar_update_overrides(self, var):
         # aka pay the cookie monster
         override = var[var.rfind('_')+1:]
         shortvar = var[:var.rfind('_')]
-        while override and override.islower():
-            if shortvar not in self.overridedata:
-                self.overridedata[shortvar] = []
-            if [var, override] not in self.overridedata[shortvar]:
-                # Force CoW by recreating the list first
-                self.overridedata[shortvar] = list(self.overridedata[shortvar])
-                self.overridedata[shortvar].append([var, override])
+        while override:
+            if override not in self._seen_overrides:
+                self._seen_overrides[override] = set()
+            self._seen_overrides[override].add( var )
             override = None
             if "_" in shortvar:
                 override = var[shortvar.rfind('_')+1:]
                 shortvar = var[:shortvar.rfind('_')]
-                if len(shortvar) == 0:
-                    override = None
 
-    def getVar(self, var, expand=True, noweakdefault=False, parsing=False):
-        return self.getVarFlag(var, "_content", expand, noweakdefault, parsing)
+    def getVar(self, var, expand=False, noweakdefault=False):
+        return self.getVarFlag(var, "_content", expand, noweakdefault)
 
     def renameVar(self, key, newkey, **loginfo):
         """
         Rename the variable key to newkey
         """
-        if '_remote_data' in self.dict:
-            connector = self.dict["_remote_data"]["_content"]
-            res = connector.renameVar(key, newkey)
-            if not res:
-                return
-
-        val = self.getVar(key, 0, parsing=True)
+        val = self.getVar(key, 0)
         if val is not None:
             loginfo['variable'] = newkey
             loginfo['op'] = 'rename from %s' % key
             loginfo['detail'] = val
             self.varhistory.record(**loginfo)
-            self.setVar(newkey, val, ignore=True, parsing=True)
+            self.setVar(newkey, val, ignore=True)
 
         for i in (__setvar_keyword__):
-            src = self.getVarFlag(key, i, False)
+            src = self.getVarFlag(key, i)
             if src is None:
                 continue
 
-            dest = self.getVarFlag(newkey, i, False) or []
+            dest = self.getVarFlag(newkey, i) or []
             dest.extend(src)
             self.setVarFlag(newkey, i, dest, ignore=True)
 
-        if key in self.overridedata:
-            self.overridedata[newkey] = []
-            for (v, o) in self.overridedata[key]:
-                self.overridedata[newkey].append([v.replace(key, newkey), o])
-                self.renameVar(v, v.replace(key, newkey))
-
-        if '_' in newkey and val is None:
-            self._setvar_update_overrides(newkey, **loginfo)
+            if i in self._special_values and key in self._special_values[i]:
+                self._special_values[i].remove(key)
+                self._special_values[i].add(newkey)
 
         loginfo['variable'] = key
         loginfo['op'] = 'rename (to)'
@@ -652,53 +560,27 @@ class DataSmart(MutableMapping):
     def appendVar(self, var, value, **loginfo):
         loginfo['op'] = 'append'
         self.varhistory.record(**loginfo)
-        self.setVar(var + "_append", value, ignore=True, parsing=True)
+        newvalue = (self.getVar(var, False) or "") + value
+        self.setVar(var, newvalue, ignore=True)
 
     def prependVar(self, var, value, **loginfo):
         loginfo['op'] = 'prepend'
         self.varhistory.record(**loginfo)
-        self.setVar(var + "_prepend", value, ignore=True, parsing=True)
+        newvalue = value + (self.getVar(var, False) or "")
+        self.setVar(var, newvalue, ignore=True)
 
     def delVar(self, var, **loginfo):
-        if '_remote_data' in self.dict:
-            connector = self.dict["_remote_data"]["_content"]
-            res = connector.delVar(var)
-            if not res:
-                return
-
         loginfo['detail'] = ""
         loginfo['op'] = 'del'
         self.varhistory.record(**loginfo)
         self.expand_cache = {}
         self.dict[var] = {}
-        if var in self.overridedata:
-            del self.overridedata[var]
         if '_' in var:
             override = var[var.rfind('_')+1:]
-            shortvar = var[:var.rfind('_')]
-            while override and override.islower():
-                try:
-                    if shortvar in self.overridedata:
-                        # Force CoW by recreating the list first
-                        self.overridedata[shortvar] = list(self.overridedata[shortvar])
-                        self.overridedata[shortvar].remove([var, override])
-                except ValueError as e:
-                    pass
-                override = None
-                if "_" in shortvar:
-                    override = var[shortvar.rfind('_')+1:]
-                    shortvar = var[:shortvar.rfind('_')]
-                    if len(shortvar) == 0:
-                         override = None
+            if override and override in self._seen_overrides and var in self._seen_overrides[override]:
+                self._seen_overrides[override].remove(var)
 
     def setVarFlag(self, var, flag, value, **loginfo):
-        if '_remote_data' in self.dict:
-            connector = self.dict["_remote_data"]["_content"]
-            res = connector.setVarFlag(var, flag, value)
-            if not res:
-                return
-
-        self.expand_cache = {}
         if 'op' not in loginfo:
             loginfo['op'] = "set"
         loginfo['flag'] = flag
@@ -707,10 +589,8 @@ class DataSmart(MutableMapping):
             self._makeShadowCopy(var)
         self.dict[var][flag] = value
 
-        if flag == "_defaultval" and '_' in var:
-            self._setvar_update_overrides(var, **loginfo)
-        if flag == "_defaultval" and var in self.overridevars:
-            self._setvar_update_overridevars(var, value)
+        if flag == "defaultval" and '_' in var:
+            self._setvar_update_overrides(var)
 
         if flag == "unexport" or flag == "export":
             if not "__exportlist" in self.dict:
@@ -719,71 +599,14 @@ class DataSmart(MutableMapping):
                 self.dict["__exportlist"]["_content"] = set()
             self.dict["__exportlist"]["_content"].add(var)
 
-    def getVarFlag(self, var, flag, expand=True, noweakdefault=False, parsing=False):
-        local_var, overridedata = self._findVar(var)
+    def getVarFlag(self, var, flag, expand=False, noweakdefault=False):
+        local_var = self._findVar(var)
         value = None
-        if flag == "_content" and overridedata is not None and not parsing:
-            match = False
-            active = {}
-            self.need_overrides()
-            for (r, o) in overridedata:
-                # What about double overrides both with "_" in the name?
-                if o in self.overridesset:
-                    active[o] = r
-                elif "_" in o:
-                    if set(o.split("_")).issubset(self.overridesset):
-                        active[o] = r
-
-            mod = True
-            while mod:
-                mod = False
-                for o in self.overrides:
-                    for a in active.copy():
-                        if a.endswith("_" + o):
-                            t = active[a]
-                            del active[a]
-                            active[a.replace("_" + o, "")] = t
-                            mod = True
-                        elif a == o:
-                            match = active[a]
-                            del active[a]
-            if match:
-                value = self.getVar(match, False)
-
-        if local_var is not None and value is None:
+        if local_var is not None:
             if flag in local_var:
                 value = copy.copy(local_var[flag])
-            elif flag == "_content" and "_defaultval" in local_var and not noweakdefault:
-                value = copy.copy(local_var["_defaultval"])
-
-
-        if flag == "_content" and local_var is not None and "_append" in local_var and not parsing:
-            if not value:
-                value = ""
-            self.need_overrides()
-            for (r, o) in local_var["_append"]:
-                match = True
-                if o:
-                    for o2 in o.split("_"):
-                        if not o2 in self.overrides:
-                            match = False                            
-                if match:
-                    value = value + r
-
-        if flag == "_content" and local_var is not None and "_prepend" in local_var and not parsing:
-            if not value:
-                value = ""
-            self.need_overrides()
-            for (r, o) in local_var["_prepend"]:
-
-                match = True
-                if o:
-                    for o2 in o.split("_"):
-                        if not o2 in self.overrides:
-                            match = False                            
-                if match:
-                    value = r + value
-
+            elif flag == "_content" and "defaultval" in local_var and not noweakdefault:
+                value = copy.copy(local_var["defaultval"])
         if expand and value:
             # Only getvar (flag == _content) hits the expand cache
             cachename = None
@@ -792,38 +615,20 @@ class DataSmart(MutableMapping):
             else:
                 cachename = var + "[" + flag + "]"
             value = self.expand(value, cachename)
-
-        if value and flag == "_content" and local_var is not None and "_remove" in local_var:
-            removes = []
-            self.need_overrides()
-            for (r, o) in local_var["_remove"]:
-                match = True
-                if o:
-                    for o2 in o.split("_"):
-                        if not o2 in self.overrides:
-                            match = False                            
-                if match:
-                    removes.extend(self.expand(r).split())
-
-            if removes:
-                filtered = filter(lambda v: v not in removes,
-                                  value.split())
-                value = " ".join(filtered)
-                if expand and var in self.expand_cache:
-                    # We need to ensure the expand cache has the correct value
-                    # flag == "_content" here
-                    self.expand_cache[var].value = value
+        if value and flag == "_content" and local_var is not None and "_removeactive" in local_var:
+            removes = [self.expand(r).split()  for r in local_var["_removeactive"]]
+            removes = reduce(lambda a, b: a+b, removes, [])
+            filtered = filter(lambda v: v not in removes,
+                              value.split())
+            value = " ".join(filtered)
+            if expand:
+                 # We need to ensure the expand cache has the correct value
+                 # flag == "_content" here
+                self.expand_cache[var].value = value
         return value
 
     def delVarFlag(self, var, flag, **loginfo):
-        if '_remote_data' in self.dict:
-            connector = self.dict["_remote_data"]["_content"]
-            res = connector.delVarFlag(var, flag)
-            if not res:
-                return
-
-        self.expand_cache = {}
-        local_var, _ = self._findVar(var)
+        local_var = self._findVar(var)
         if not local_var:
             return
         if not var in self.dict:
@@ -852,7 +657,6 @@ class DataSmart(MutableMapping):
         self.setVarFlag(var, flag, newvalue, ignore=True)
 
     def setVarFlags(self, var, flags, **loginfo):
-        self.expand_cache = {}
         infer_caller_details(loginfo)
         if not var in self.dict:
             self._makeShadowCopy(var)
@@ -866,7 +670,7 @@ class DataSmart(MutableMapping):
             self.dict[var][i] = flags[i]
 
     def getVarFlags(self, var, expand = False, internalflags=False):
-        local_var, _ = self._findVar(var)
+        local_var = self._findVar(var)
         flags = {}
 
         if local_var:
@@ -882,7 +686,6 @@ class DataSmart(MutableMapping):
 
 
     def delVarFlags(self, var, **loginfo):
-        self.expand_cache = {}
         if not var in self.dict:
             self._makeShadowCopy(var)
 
@@ -900,25 +703,20 @@ class DataSmart(MutableMapping):
             else:
                 del self.dict[var]
 
+
     def createCopy(self):
         """
         Create a copy of self by setting _data to self
         """
         # we really want this to be a DataSmart...
-        data = DataSmart()
+        data = DataSmart(seen=self._seen_overrides.copy(), special=self._special_values.copy())
         data.dict["_data"] = self.dict
         data.varhistory = self.varhistory.copy()
-        data.varhistory.dataroot = data
+        data.varhistory.datasmart = data
         data.inchistory = self.inchistory.copy()
 
         data._tracking = self._tracking
 
-        data.overrides = None
-        data.overridevars = copy.copy(self.overridevars)
-        # Should really be a deepcopy but has heavy overhead.
-        # Instead, we're careful with writes.
-        data.overridedata = copy.copy(self.overridedata)
-
         return data
 
     def expandVarref(self, variable, parents=False):
@@ -939,55 +737,29 @@ class DataSmart(MutableMapping):
 
     def localkeys(self):
         for key in self.dict:
-            if key not in ['_data', '_remote_data']:
+            if key != '_data':
                 yield key
 
     def __iter__(self):
-        deleted = set()
-        overrides = set()
         def keylist(d):        
             klist = set()
             for key in d:
-                if key in ["_data", "_remote_data"]:
-                    continue
-                if key in deleted:
-                    continue
-                if key in overrides:
+                if key == "_data":
                     continue
                 if not d[key]:
-                    deleted.add(key)
                     continue
                 klist.add(key)
 
             if "_data" in d:
                 klist |= keylist(d["_data"])
 
-            if "_remote_data" in d:
-                connector = d["_remote_data"]["_content"]
-                for key in connector.getKeys():
-                    if key in deleted:
-                        continue
-                    klist.add(key)
-
             return klist
 
-        self.need_overrides()
-        for var in self.overridedata:
-            for (r, o) in self.overridedata[var]:
-                if o in self.overridesset:
-                    overrides.add(var)
-                elif "_" in o:
-                    if set(o.split("_")).issubset(self.overridesset):
-                        overrides.add(var)
-
         for k in keylist(self.dict):
              yield k
 
-        for k in overrides:
-             yield k
-
     def __len__(self):
-        return len(frozenset(iter(self)))
+        return len(frozenset(self))
 
     def __getitem__(self, item):
         value = self.getVar(item, False)
@@ -1006,8 +778,9 @@ class DataSmart(MutableMapping):
         data = {}
         d = self.createCopy()
         bb.data.expandKeys(d)
+        bb.data.update_data(d)
 
-        config_whitelist = set((d.getVar("BB_HASHCONFIG_WHITELIST") or "").split())
+        config_whitelist = set((d.getVar("BB_HASHCONFIG_WHITELIST", True) or "").split())
         keys = set(key for key in iter(d) if not key.startswith("__"))
         for key in keys:
             if key in config_whitelist:
@@ -1026,12 +799,13 @@ class DataSmart(MutableMapping):
 
         for key in ["__BBTASKS", "__BBANONFUNCS", "__BBHANDLERS"]:
             bb_list = d.getVar(key, False) or []
+            bb_list.sort()
             data.update({key:str(bb_list)})
 
             if key == "__BBANONFUNCS":
                 for i in bb_list:
-                    value = d.getVar(i, False) or ""
+                    value = d.getVar(i, True) or ""
                     data.update({i:value})
 
         data_str = str([(k, data[k]) for k in sorted(data.keys())])
-        return hashlib.md5(data_str.encode("utf-8")).hexdigest()
+        return hashlib.md5(data_str).hexdigest()

bitbake/lib/bb/event.py

@@ -24,13 +24,13 @@ BitBake build tools.
 
 import os, sys
 import warnings
-import pickle
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
 import logging
 import atexit
 import traceback
-import ast
-import threading
-
 import bb.utils
 import bb.compat
 import bb.exceptions
@@ -48,16 +48,6 @@ class Event(object):
     def __init__(self):
         self.pid = worker_pid
 
-
-class HeartbeatEvent(Event):
-    """Triggered at regular time intervals of 10 seconds. Other events can fire much more often
-       (runQueueTaskStarted when there are many short tasks) or not at all for long periods
-       of time (again runQueueTaskStarted, when there is just one long-running task), so this
-       event is more suitable for doing some task-independent work occassionally."""
-    def __init__(self, time):
-        Event.__init__(self)
-        self.time = time
-
 Registered        = 10
 AlreadyRegistered = 14
 
@@ -78,30 +68,9 @@ _ui_logfilters = {}
 _ui_handler_seq = 0
 _event_handler_map = {}
 _catchall_handlers = {}
-_eventfilter = None
-_uiready = False
-_thread_lock = threading.Lock()
-_thread_lock_enabled = False
-
-if hasattr(__builtins__, '__setitem__'):
-    builtins = __builtins__
-else:
-    builtins = __builtins__.__dict__
-
-def enable_threadlock():
-    global _thread_lock_enabled
-    _thread_lock_enabled = True
-
-def disable_threadlock():
-    global _thread_lock_enabled
-    _thread_lock_enabled = False
 
 def execute_handler(name, handler, event, d):
     event.data = d
-    addedd = False
-    if 'd' not in builtins:
-        builtins['d'] = d
-        addedd = True
     try:
         ret = handler(event)
     except (bb.parse.SkipRecipe, bb.BBHandledException):
@@ -117,8 +86,6 @@ def execute_handler(name, handler, event, d):
         raise
     finally:
         del event.data
-        if addedd:
-            del builtins['d']
 
 def fire_class_handlers(event, d):
     if isinstance(event, logging.LogRecord):
@@ -126,11 +93,8 @@ def fire_class_handlers(event, d):
 
     eid = str(event.__class__)[8:-2]
     evt_hmap = _event_handler_map.get(eid, {})
-    for name, handler in list(_handlers.items()):
+    for name, handler in _handlers.iteritems():
         if name in _catchall_handlers or name in evt_hmap:
-            if _eventfilter:
-                if not _eventfilter(name, handler, event, d):
-                    continue
             execute_handler(name, handler, event, d)
 
 ui_queue = []
@@ -139,46 +103,33 @@ def print_ui_queue():
     """If we're exiting before a UI has been spawned, display any queued
     LogRecords to the console."""
     logger = logging.getLogger("BitBake")
-    if not _uiready:
+    if not _ui_handlers:
         from bb.msg import BBLogFormatter
-        stdout = logging.StreamHandler(sys.stdout)
-        stderr = logging.StreamHandler(sys.stderr)
-        formatter = BBLogFormatter("%(levelname)s: %(message)s")
-        stdout.setFormatter(formatter)
-        stderr.setFormatter(formatter)
+        console = logging.StreamHandler(sys.stdout)
+        console.setFormatter(BBLogFormatter("%(levelname)s: %(message)s"))
+        logger.handlers = [console]
 
         # First check to see if we have any proper messages
         msgprint = False
-        for event in ui_queue[:]:
+        for event in ui_queue:
             if isinstance(event, logging.LogRecord):
                 if event.levelno > logging.DEBUG:
-                    if event.levelno >= logging.WARNING:
-                        logger.addHandler(stderr)
-                    else:
-                        logger.addHandler(stdout)
                     logger.handle(event)
                     msgprint = True
         if msgprint:
             return
 
         # Nope, so just print all of the messages we have (including debug messages)
-        logger.addHandler(stdout)
-        for event in ui_queue[:]:
+        for event in ui_queue:
             if isinstance(event, logging.LogRecord):
                 logger.handle(event)
 
 def fire_ui_handlers(event, d):
-    global _thread_lock
-    global _thread_lock_enabled
-
-    if not _uiready:
+    if not _ui_handlers:
         # No UI handlers registered yet, queue up the messages
         ui_queue.append(event)
         return
 
-    if _thread_lock_enabled:
-        _thread_lock.acquire()
-
     errors = []
     for h in _ui_handlers:
         #print "Sending event %s" % event
@@ -197,9 +148,6 @@ def fire_ui_handlers(event, d):
     for h in errors:
         del _ui_handlers[h]
 
-    if _thread_lock_enabled:
-        _thread_lock.release()
-
 def fire(event, d):
     """Fire off an Event"""
 
@@ -218,7 +166,7 @@ def fire_from_worker(event, d):
     fire_ui_handlers(event, d)
 
 noop = lambda _: None
-def register(name, handler, mask=None, filename=None, lineno=None):
+def register(name, handler, mask=[]):
     """Register an Event handler"""
 
     # already registered
@@ -227,18 +175,10 @@ def register(name, handler, mask=None, filename=None, lineno=None):
 
     if handler is not None:
         # handle string containing python code
-        if isinstance(handler, str):
+        if isinstance(handler, basestring):
             tmp = "def %s(e):\n%s" % (name, handler)
             try:
-                code = bb.methodpool.compile_cache(tmp)
-                if not code:
-                    if filename is None:
-                        filename = "%s(e)" % name
-                    code = compile(tmp, filename, "exec", ast.PyCF_ONLY_AST)
-                    if lineno is not None:
-                        ast.increment_lineno(code, lineno-1)
-                    code = compile(code, filename, "exec")
-                    bb.methodpool.compile_cache_add(tmp, code)
+                code = compile(tmp, "%s(e)" % name, "exec")
             except SyntaxError:
                 logger.error("Unable to register event handler '%s':\n%s", name,
                              ''.join(traceback.format_exc(limit=0)))
@@ -265,21 +205,7 @@ def remove(name, handler):
     """Remove an Event handler"""
     _handlers.pop(name)
 
-def get_handlers():
-    return _handlers
-
-def set_handlers(handlers):
-    global _handlers
-    _handlers = handlers
-
-def set_eventfilter(func):
-    global _eventfilter
-    _eventfilter = func
-
-def register_UIHhandler(handler, mainui=False):
-    if mainui:
-        global _uiready
-        _uiready = True
+def register_UIHhandler(handler):
     bb.event._ui_handler_seq = bb.event._ui_handler_seq + 1
     _ui_handlers[_ui_handler_seq] = handler
     level, debug_domains = bb.msg.constructLogOptions()
@@ -361,17 +287,6 @@ class RecipeEvent(Event):
 class RecipePreFinalise(RecipeEvent):
     """ Recipe Parsing Complete but not yet finialised"""
 
-class RecipeTaskPreProcess(RecipeEvent):
-    """
-    Recipe Tasks about to be finalised
-    The list of tasks should be final at this point and handlers
-    are only able to change interdependencies
-    """
-    def __init__(self, fn, tasklist):
-        self.fn = fn
-        self.tasklist = tasklist
-        Event.__init__(self)
-
 class RecipeParsed(RecipeEvent):
     """ Recipe Parsing Complete """
 
@@ -393,7 +308,7 @@ class StampUpdate(Event):
     targets = property(getTargets)
 
 class BuildBase(Event):
-    """Base class for bitbake build events"""
+    """Base class for bbmake run events"""
 
     def __init__(self, n, p, failures = 0):
         self._name = n
@@ -431,26 +346,21 @@ class BuildBase(Event):
 
 
 
-class BuildInit(BuildBase):
-    """buildFile or buildTargets was invoked"""
-    def __init__(self, p=[]):
-        name = None
-        BuildBase.__init__(self, name, p)
+
 
 class BuildStarted(BuildBase, OperationStarted):
-    """Event when builds start"""
+    """bbmake build run started"""
     def __init__(self, n, p, failures = 0):
         OperationStarted.__init__(self, "Building Started")
         BuildBase.__init__(self, n, p, failures)
 
 class BuildCompleted(BuildBase, OperationCompleted):
-    """Event when builds have completed"""
-    def __init__(self, total, n, p, failures=0, interrupted=0):
+    """bbmake build run completed"""
+    def __init__(self, total, n, p, failures = 0):
         if not failures:
             OperationCompleted.__init__(self, total, "Building Succeeded")
         else:
             OperationCompleted.__init__(self, total, "Building Failed")
-        self._interrupted = interrupted
         BuildBase.__init__(self, n, p, failures)
 
 class DiskFull(Event):
@@ -462,27 +372,10 @@ class DiskFull(Event):
         self._free = freespace
         self._mountpoint = mountpoint
 
-class DiskUsageSample:
-    def __init__(self, available_bytes, free_bytes, total_bytes):
-        # Number of bytes available to non-root processes.
-        self.available_bytes = available_bytes
-        # Number of bytes available to root processes.
-        self.free_bytes = free_bytes
-        # Total capacity of the volume.
-        self.total_bytes = total_bytes
-
-class MonitorDiskEvent(Event):
-    """If BB_DISKMON_DIRS is set, then this event gets triggered each time disk space is checked.
-       Provides information about devices that are getting monitored."""
-    def __init__(self, disk_usage):
-        Event.__init__(self)
-        # hash of device root path -> DiskUsageSample
-        self.disk_usage = disk_usage
-
 class NoProvider(Event):
     """No Provider for an Event"""
 
-    def __init__(self, item, runtime=False, dependees=None, reasons=None, close_matches=None):
+    def __init__(self, item, runtime=False, dependees=None, reasons=[], close_matches=[]):
         Event.__init__(self)
         self._item = item
         self._runtime = runtime
@@ -596,16 +489,6 @@ class TargetsTreeGenerated(Event):
         Event.__init__(self)
         self._model = model
 
-class ReachableStamps(Event):
-    """
-    An event listing all stamps reachable after parsing
-    which the metadata may use to clean up stale data
-    """
-
-    def __init__(self, stamps):
-        Event.__init__(self)
-        self.stamps = stamps
-
 class FilesMatchingFound(Event):
     """
     Event when a list of files matching the supplied pattern has
@@ -683,10 +566,7 @@ class LogHandler(logging.Handler):
             etype, value, tb = record.exc_info
             if hasattr(tb, 'tb_next'):
                 tb = list(bb.exceptions.extract_traceback(tb, context=3))
-            # Need to turn the value into something the logging system can pickle
             record.bb_exc_info = (etype, value, tb)
-            record.bb_exc_formatted = bb.exceptions.format_exception(etype, value, tb, limit=5)
-            value = str(value)
             record.exc_info = None
         fire(record, None)
 
@@ -717,33 +597,6 @@ class MetadataEvent(Event):
         self.type = eventtype
         self._localdata = eventdata
 
-class ProcessStarted(Event):
-    """
-    Generic process started event (usually part of the initial startup)
-    where further progress events will be delivered
-    """
-    def __init__(self, processname, total):
-        Event.__init__(self)
-        self.processname = processname
-        self.total = total
-
-class ProcessProgress(Event):
-    """
-    Generic process progress event (usually part of the initial startup)
-    """
-    def __init__(self, processname, progress):
-        Event.__init__(self)
-        self.processname = processname
-        self.progress = progress
-
-class ProcessFinished(Event):
-    """
-    Generic process finished event (usually part of the initial startup)
-    """
-    def __init__(self, processname):
-        Event.__init__(self)
-        self.processname = processname
-
 class SanityCheck(Event):
     """
     Event to run sanity checks, either raise errors or generate events as return status.

bitbake/lib/bb/exceptions.py

@@ -1,4 +1,4 @@
-
+from __future__ import absolute_import
 import inspect
 import traceback
 import bb.namedtuple_with_abc
@@ -86,6 +86,6 @@ def format_exception(etype, value, tb, context=1, limit=None, formatter=None):
 
 def to_string(exc):
     if isinstance(exc, SystemExit):
-        if not isinstance(exc.code, str):
+        if not isinstance(exc.code, basestring):
             return 'Exited with "%d"' % exc.code
     return str(exc)

bitbake/lib/bb/fetch2/bzr.py

@@ -27,6 +27,7 @@ import os
 import sys
 import logging
 import bb
+from bb import data
 from bb.fetch2 import FetchMethod
 from bb.fetch2 import FetchError
 from bb.fetch2 import runfetchcmd
@@ -42,14 +43,14 @@ class Bzr(FetchMethod):
         """
         # Create paths to bzr checkouts
         relpath = self._strip_leading_slashes(ud.path)
-        ud.pkgdir = os.path.join(d.expand('${BZRDIR}'), ud.host, relpath)
+        ud.pkgdir = os.path.join(data.expand('${BZRDIR}', d), ud.host, relpath)
 
-        ud.setup_revisions(d)
+        ud.setup_revisons(d)
 
         if not ud.revision:
             ud.revision = self.latest_revision(ud, d)
 
-        ud.localfile = d.expand('bzr_%s_%s_%s.tar.gz' % (ud.host, ud.path.replace('/', '.'), ud.revision))
+        ud.localfile = data.expand('bzr_%s_%s_%s.tar.gz' % (ud.host, ud.path.replace('/', '.'), ud.revision), d)
 
     def _buildbzrcommand(self, ud, d, command):
         """
@@ -57,7 +58,7 @@ class Bzr(FetchMethod):
         command is "fetch", "update", "revno"
         """
 
-        basecmd = d.expand('${FETCHCMD_bzr}')
+        basecmd = data.expand('${FETCHCMD_bzr}', d)
 
         proto =  ud.parm.get('protocol', 'http')
 
@@ -87,25 +88,28 @@ class Bzr(FetchMethod):
             bzrcmd = self._buildbzrcommand(ud, d, "update")
             logger.debug(1, "BZR Update %s", ud.url)
             bb.fetch2.check_network_access(d, bzrcmd, ud.url)
-            runfetchcmd(bzrcmd, d, workdir=os.path.join(ud.pkgdir, os.path.basename(ud.path)))
+            os.chdir(os.path.join (ud.pkgdir, os.path.basename(ud.path)))
+            runfetchcmd(bzrcmd, d)
         else:
             bb.utils.remove(os.path.join(ud.pkgdir, os.path.basename(ud.pkgdir)), True)
             bzrcmd = self._buildbzrcommand(ud, d, "fetch")
             bb.fetch2.check_network_access(d, bzrcmd, ud.url)
             logger.debug(1, "BZR Checkout %s", ud.url)
             bb.utils.mkdirhier(ud.pkgdir)
+            os.chdir(ud.pkgdir)
             logger.debug(1, "Running %s", bzrcmd)
-            runfetchcmd(bzrcmd, d, workdir=ud.pkgdir)
+            runfetchcmd(bzrcmd, d)
+
+        os.chdir(ud.pkgdir)
 
         scmdata = ud.parm.get("scmdata", "")
         if scmdata == "keep":
             tar_flags = ""
         else:
-            tar_flags = "--exclude='.bzr' --exclude='.bzrtags'"
+            tar_flags = "--exclude '.bzr' --exclude '.bzrtags'"
 
         # tar them up to a defined filename
-        runfetchcmd("tar %s -czf %s %s" % (tar_flags, ud.localpath, os.path.basename(ud.pkgdir)),
-                    d, cleanup=[ud.localpath], workdir=ud.pkgdir)
+        runfetchcmd("tar %s -czf %s %s" % (tar_flags, ud.localpath, os.path.basename(ud.pkgdir)), d, cleanup = [ud.localpath])
 
     def supports_srcrev(self):
         return True

bitbake/lib/bb/fetch2/clearcase.py

@@ -9,7 +9,7 @@ Usage in the recipe:
 
     SRC_URI = "ccrc://cc.example.org/ccrc;vob=/example_vob;module=/example_module"
     SRCREV = "EXAMPLE_CLEARCASE_TAG"
-    PV = "${@d.getVar("SRCREV", False).replace("/", "+")}"
+    PV = "${@d.getVar("SRCREV").replace("/", "+")}"
 
 The fetcher uses the rcleartool or cleartool remote client, depending on which one is available.
 
@@ -65,6 +65,7 @@ import os
 import sys
 import shutil
 import bb
+from   bb import data
 from   bb.fetch2 import FetchMethod
 from   bb.fetch2 import FetchError
 from   bb.fetch2 import runfetchcmd
@@ -107,13 +108,13 @@ class ClearCase(FetchMethod):
         else:
             ud.module = ""
 
-        ud.basecmd = d.getVar("FETCHCMD_ccrc") or spawn.find_executable("cleartool") or spawn.find_executable("rcleartool")
+        ud.basecmd = d.getVar("FETCHCMD_ccrc", True) or spawn.find_executable("cleartool") or spawn.find_executable("rcleartool")
 
-        if d.getVar("SRCREV") == "INVALID":
+        if data.getVar("SRCREV", d, True) == "INVALID":
           raise FetchError("Set a valid SRCREV for the clearcase fetcher in your recipe, e.g. SRCREV = \"/main/LATEST\" or any other label of your choice.")
 
-        ud.label = d.getVar("SRCREV", False)
-        ud.customspec = d.getVar("CCASE_CUSTOM_CONFIG_SPEC")
+        ud.label = d.getVar("SRCREV")
+        ud.customspec = d.getVar("CCASE_CUSTOM_CONFIG_SPEC", True)
 
         ud.server     = "%s://%s%s" % (ud.proto, ud.host, ud.path)
 
@@ -123,7 +124,7 @@ class ClearCase(FetchMethod):
 
         ud.viewname         = "%s-view%s" % (ud.identifier, d.getVar("DATETIME", d, True))
         ud.csname           = "%s-config-spec" % (ud.identifier)
-        ud.ccasedir         = os.path.join(d.getVar("DL_DIR"), ud.type)
+        ud.ccasedir         = os.path.join(data.getVar("DL_DIR", d, True), ud.type)
         ud.viewdir          = os.path.join(ud.ccasedir, ud.viewname)
         ud.configspecfile   = os.path.join(ud.ccasedir, ud.csname)
         ud.localfile        = "%s.tar.gz" % (ud.identifier)
@@ -143,7 +144,7 @@ class ClearCase(FetchMethod):
         self.debug("configspecfile  = %s" % ud.configspecfile)
         self.debug("localfile       = %s" % ud.localfile)
 
-        ud.localfile = os.path.join(d.getVar("DL_DIR"), ud.localfile)
+        ud.localfile = os.path.join(data.getVar("DL_DIR", d, True), ud.localfile)
 
     def _build_ccase_command(self, ud, command):
         """
@@ -201,10 +202,11 @@ class ClearCase(FetchMethod):
 
     def _remove_view(self, ud, d):
         if os.path.exists(ud.viewdir):
+            os.chdir(ud.ccasedir)
             cmd = self._build_ccase_command(ud, 'rmview');
             logger.info("cleaning up [VOB=%s label=%s view=%s]", ud.vob, ud.label, ud.viewname)
             bb.fetch2.check_network_access(d, cmd, ud.url)
-            output = runfetchcmd(cmd, d, workdir=ud.ccasedir)
+            output = runfetchcmd(cmd, d)
             logger.info("rmview output: %s", output)
 
     def need_update(self, ud, d):
@@ -239,10 +241,11 @@ class ClearCase(FetchMethod):
                 raise e
 
         # Set configspec: Setting the configspec effectively fetches the files as defined in the configspec
+        os.chdir(ud.viewdir)
         cmd = self._build_ccase_command(ud, 'setcs');
         logger.info("fetching data [VOB=%s label=%s view=%s]", ud.vob, ud.label, ud.viewname)
         bb.fetch2.check_network_access(d, cmd, ud.url)
-        output = runfetchcmd(cmd, d, workdir=ud.viewdir)
+        output = runfetchcmd(cmd, d)
         logger.info("%s", output)
 
         # Copy the configspec to the viewdir so we have it in our source tarball later

bitbake/lib/bb/fetch2/cvs.py

@@ -63,7 +63,7 @@ class Cvs(FetchMethod):
         if 'fullpath' in ud.parm:
             fullpath = '_fullpath'
 
-        ud.localfile = d.expand('%s_%s_%s_%s%s%s.tar.gz' % (ud.module.replace('/', '.'), ud.host, ud.tag, ud.date, norecurse, fullpath))
+        ud.localfile = bb.data.expand('%s_%s_%s_%s%s%s.tar.gz' % (ud.module.replace('/', '.'), ud.host, ud.tag, ud.date, norecurse, fullpath), d)
 
     def need_update(self, ud, d):
         if (ud.date == "now"):
@@ -87,10 +87,10 @@ class Cvs(FetchMethod):
             cvsroot = ud.path
         else:
             cvsroot = ":" + method
-            cvsproxyhost = d.getVar('CVS_PROXY_HOST')
+            cvsproxyhost = d.getVar('CVS_PROXY_HOST', True)
             if cvsproxyhost:
                 cvsroot += ";proxy=" + cvsproxyhost
-            cvsproxyport = d.getVar('CVS_PROXY_PORT')
+            cvsproxyport = d.getVar('CVS_PROXY_PORT', True)
             if cvsproxyport:
                 cvsroot += ";proxyport=" + cvsproxyport
             cvsroot += ":" + ud.user
@@ -110,7 +110,7 @@ class Cvs(FetchMethod):
         if ud.tag:
             options.append("-r %s" % ud.tag)
 
-        cvsbasecmd = d.getVar("FETCHCMD_cvs")
+        cvsbasecmd = d.getVar("FETCHCMD_cvs", True)
         cvscmd = cvsbasecmd + " '-d" + cvsroot + "' co " + " ".join(options) + " " + ud.module
         cvsupdatecmd = cvsbasecmd + " '-d" + cvsroot + "' update -d -P " + " ".join(options)
 
@@ -120,26 +120,25 @@ class Cvs(FetchMethod):
 
         # create module directory
         logger.debug(2, "Fetch: checking for module directory")
-        pkg = d.getVar('PN')
-        pkgdir = os.path.join(d.getVar('CVSDIR'), pkg)
+        pkg = d.getVar('PN', True)
+        pkgdir = os.path.join(d.getVar('CVSDIR', True), pkg)
         moddir = os.path.join(pkgdir, localdir)
-        workdir = None
         if os.access(os.path.join(moddir, 'CVS'), os.R_OK):
             logger.info("Update " + ud.url)
             bb.fetch2.check_network_access(d, cvsupdatecmd, ud.url)
             # update sources there
-            workdir = moddir
+            os.chdir(moddir)
             cmd = cvsupdatecmd
         else:
             logger.info("Fetch " + ud.url)
             # check out sources there
             bb.utils.mkdirhier(pkgdir)
-            workdir = pkgdir
+            os.chdir(pkgdir)
             logger.debug(1, "Running %s", cvscmd)
             bb.fetch2.check_network_access(d, cvscmd, ud.url)
             cmd = cvscmd
 
-        runfetchcmd(cmd, d, cleanup=[moddir], workdir=workdir)
+        runfetchcmd(cmd, d, cleanup = [moddir])
 
         if not os.access(moddir, os.R_OK):
             raise FetchError("Directory %s was not readable despite sucessful fetch?!" % moddir, ud.url)
@@ -148,24 +147,24 @@ class Cvs(FetchMethod):
         if scmdata == "keep":
             tar_flags = ""
         else:
-            tar_flags = "--exclude='CVS'"
+            tar_flags = "--exclude 'CVS'"
 
         # tar them up to a defined filename
-        workdir = None
         if 'fullpath' in ud.parm:
-            workdir = pkgdir
+            os.chdir(pkgdir)
             cmd = "tar %s -czf %s %s" % (tar_flags, ud.localpath, localdir)
         else:
-            workdir = os.path.dirname(os.path.realpath(moddir))
+            os.chdir(moddir)
+            os.chdir('..')
             cmd = "tar %s -czf %s %s" % (tar_flags, ud.localpath, os.path.basename(moddir))
 
-        runfetchcmd(cmd, d, cleanup=[ud.localpath], workdir=workdir)
+        runfetchcmd(cmd, d, cleanup = [ud.localpath])
 
     def clean(self, ud, d):
         """ Clean CVS Files and tarballs """
 
-        pkg = d.getVar('PN')
-        pkgdir = os.path.join(d.getVar("CVSDIR"), pkg)
+        pkg = d.getVar('PN', True)
+        pkgdir = os.path.join(d.getVar("CVSDIR", True), pkg)
 
         bb.utils.remove(pkgdir, True)
         bb.utils.remove(ud.localpath)

bitbake/lib/bb/fetch2/git.py

@@ -49,10 +49,6 @@ Supported SRC_URI options are:
    referring to commit which is valid in tag instead of branch.
    The default is "0", set nobranch=1 if needed.
 
-- usehead
-   For local git:// urls to use the current branch HEAD as the revision for use with
-   AUTOREV. Implies nobranch.
-
 """
 
 #Copyright (C) 2005 Richard Purdie
@@ -70,57 +66,13 @@ Supported SRC_URI options are:
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
-import errno
 import os
-import re
 import bb
-import errno
-import bb.progress
+from   bb    import data
 from   bb.fetch2 import FetchMethod
 from   bb.fetch2 import runfetchcmd
 from   bb.fetch2 import logger
 
-
-class GitProgressHandler(bb.progress.LineFilterProgressHandler):
-    """Extract progress information from git output"""
-    def __init__(self, d):
-        self._buffer = ''
-        self._count = 0
-        super(GitProgressHandler, self).__init__(d)
-        # Send an initial progress event so the bar gets shown
-        self._fire_progress(-1)
-
-    def write(self, string):
-        self._buffer += string
-        stages = ['Counting objects', 'Compressing objects', 'Receiving objects', 'Resolving deltas']
-        stage_weights = [0.2, 0.05, 0.5, 0.25]
-        stagenum = 0
-        for i, stage in reversed(list(enumerate(stages))):
-            if stage in self._buffer:
-                stagenum = i
-                self._buffer = ''
-                break
-        self._status = stages[stagenum]
-        percs = re.findall(r'(\d+)%', string)
-        if percs:
-            progress = int(round((int(percs[-1]) * stage_weights[stagenum]) + (sum(stage_weights[:stagenum]) * 100)))
-            rates = re.findall(r'([\d.]+ [a-zA-Z]*/s+)', string)
-            if rates:
-                rate = rates[-1]
-            else:
-                rate = None
-            self.update(progress, rate)
-        else:
-            if stagenum == 0:
-                percs = re.findall(r': (\d+)', string)
-                if percs:
-                    count = int(percs[-1])
-                    if count > self._count:
-                        self._count = count
-                        self._fire_progress(-count)
-        super(GitProgressHandler, self).write(string)
-
-
 class Git(FetchMethod):
     """Class to fetch a module or modules from git repositories"""
     def init(self, d):
@@ -156,13 +108,6 @@ class Git(FetchMethod):
 
         ud.nobranch = ud.parm.get("nobranch","0") == "1"
 
-        # usehead implies nobranch
-        ud.usehead = ud.parm.get("usehead","0") == "1"
-        if ud.usehead:
-            if ud.proto != "file":
-                 raise bb.fetch2.ParameterError("The usehead option is only for use with local ('protocol=file') git repositories", ud.url)
-            ud.nobranch = 1
-
         # bareclone implies nocheckout
         ud.bareclone = ud.parm.get("bareclone","0") == "1"
         if ud.bareclone:
@@ -173,19 +118,16 @@ class Git(FetchMethod):
         if len(branches) != len(ud.names):
             raise bb.fetch2.ParameterError("The number of name and branch parameters is not balanced", ud.url)
         ud.branches = {}
-        for pos, name in enumerate(ud.names):
-            branch = branches[pos]
+        for name in ud.names:
+            branch = branches[ud.names.index(name)]
             ud.branches[name] = branch
             ud.unresolvedrev[name] = branch
 
-        if ud.usehead:
-            ud.unresolvedrev['default'] = 'HEAD'
+        ud.basecmd = data.getVar("FETCHCMD_git", d, True) or "git -c core.fsyncobjectfiles=0"
 
-        ud.basecmd = d.getVar("FETCHCMD_git") or "git -c core.fsyncobjectfiles=0"
+        ud.write_tarballs = ((data.getVar("BB_GENERATE_MIRROR_TARBALLS", d, True) or "0") != "0") or ud.rebaseable
 
-        ud.write_tarballs = ((d.getVar("BB_GENERATE_MIRROR_TARBALLS") or "0") != "0") or ud.rebaseable
-
-        ud.setup_revisions(d)
+        ud.setup_revisons(d)
 
         for name in ud.names:
             # Ensure anything that doesn't look like a sha256 checksum/revision is translated into one
@@ -194,10 +136,7 @@ class Git(FetchMethod):
                     ud.unresolvedrev[name] = ud.revisions[name]
                 ud.revisions[name] = self.latest_revision(ud, d, name)
 
-        gitsrcname = '%s%s' % (ud.host.replace(':', '.'), ud.path.replace('/', '.').replace('*', '.'))
-        if gitsrcname.startswith('.'):
-            gitsrcname = gitsrcname[1:]
-
+        gitsrcname = '%s%s' % (ud.host.replace(':','.'), ud.path.replace('/', '.').replace('*', '.'))
         # for rebaseable git repo, it is necessary to keep mirror tar ball
         # per revision, so that even the revision disappears from the
         # upstream repo in the future, the mirror will remain intact and still
@@ -205,9 +144,9 @@ class Git(FetchMethod):
         if ud.rebaseable:
             for name in ud.names:
                 gitsrcname = gitsrcname + '_' + ud.revisions[name]
-        ud.mirrortarball = 'git2_%s.tar.gz' % gitsrcname
-        ud.fullmirror = os.path.join(d.getVar("DL_DIR"), ud.mirrortarball)
-        gitdir = d.getVar("GITDIR") or (d.getVar("DL_DIR") + "/git2/")
+        ud.mirrortarball = 'git2_%s.tar.gz' % (gitsrcname)
+        ud.fullmirror = os.path.join(d.getVar("DL_DIR", True), ud.mirrortarball)
+        gitdir = d.getVar("GITDIR", True) or (d.getVar("DL_DIR", True) + "/git2/")
         ud.clonedir = os.path.join(gitdir, gitsrcname)
 
         ud.localfile = ud.clonedir
@@ -218,8 +157,9 @@ class Git(FetchMethod):
     def need_update(self, ud, d):
         if not os.path.exists(ud.clonedir):
             return True
+        os.chdir(ud.clonedir)
         for name in ud.names:
-            if not self._contains_ref(ud, d, name, ud.clonedir):
+            if not self._contains_ref(ud, d, name):
                 return True
         if ud.write_tarballs and not os.path.exists(ud.fullmirror):
             return True
@@ -228,7 +168,7 @@ class Git(FetchMethod):
     def try_premirror(self, ud, d):
         # If we don't do this, updating an existing checkout with only premirrors
         # is not possible
-        if d.getVar("BB_FETCH_PREMIRRORONLY") is not None:
+        if d.getVar("BB_FETCH_PREMIRRORONLY", True) is not None:
             return True
         if os.path.exists(ud.clonedir):
             return False
@@ -237,69 +177,74 @@ class Git(FetchMethod):
     def download(self, ud, d):
         """Fetch url"""
 
+        if ud.user:
+            username = ud.user + '@'
+        else:
+            username = ""
+
+        ud.repochanged = not os.path.exists(ud.fullmirror)
+
         # If the checkout doesn't exist and the mirror tarball does, extract it
         if not os.path.exists(ud.clonedir) and os.path.exists(ud.fullmirror):
             bb.utils.mkdirhier(ud.clonedir)
-            runfetchcmd("tar -xzf %s" % ud.fullmirror, d, workdir=ud.clonedir)
+            os.chdir(ud.clonedir)
+            runfetchcmd("tar -xzf %s" % (ud.fullmirror), d)
 
-        repourl = self._get_repo_url(ud)
+        repourl = "%s://%s%s%s" % (ud.proto, username, ud.host, ud.path)
 
         # If the repo still doesn't exist, fallback to cloning it
         if not os.path.exists(ud.clonedir):
             # We do this since git will use a "-l" option automatically for local urls where possible
             if repourl.startswith("file://"):
                 repourl = repourl[7:]
-            clone_cmd = "LANG=C %s clone --bare --mirror %s %s --progress" % (ud.basecmd, repourl, ud.clonedir)
+            clone_cmd = "%s clone --bare --mirror %s %s" % (ud.basecmd, repourl, ud.clonedir)
             if ud.proto.lower() != 'file':
-                bb.fetch2.check_network_access(d, clone_cmd, ud.url)
-            progresshandler = GitProgressHandler(d)
-            runfetchcmd(clone_cmd, d, log=progresshandler)
+                bb.fetch2.check_network_access(d, clone_cmd)
+            runfetchcmd(clone_cmd, d)
 
+        os.chdir(ud.clonedir)
         # Update the checkout if needed
         needupdate = False
         for name in ud.names:
-            if not self._contains_ref(ud, d, name, ud.clonedir):
+            if not self._contains_ref(ud, d, name):
                 needupdate = True
         if needupdate:
             try: 
-                runfetchcmd("%s remote rm origin" % ud.basecmd, d, workdir=ud.clonedir)
+                runfetchcmd("%s remote rm origin" % ud.basecmd, d) 
             except bb.fetch2.FetchError:
                 logger.debug(1, "No Origin")
 
-            runfetchcmd("%s remote add --mirror=fetch origin %s" % (ud.basecmd, repourl), d, workdir=ud.clonedir)
-            fetch_cmd = "LANG=C %s fetch -f --prune --progress %s refs/*:refs/*" % (ud.basecmd, repourl)
+            runfetchcmd("%s remote add --mirror=fetch origin %s" % (ud.basecmd, repourl), d)
+            fetch_cmd = "%s fetch -f --prune %s refs/*:refs/*" % (ud.basecmd, repourl)
             if ud.proto.lower() != 'file':
                 bb.fetch2.check_network_access(d, fetch_cmd, ud.url)
-            progresshandler = GitProgressHandler(d)
-            runfetchcmd(fetch_cmd, d, log=progresshandler, workdir=ud.clonedir)
-            runfetchcmd("%s prune-packed" % ud.basecmd, d, workdir=ud.clonedir)
-            runfetchcmd("%s pack-redundant --all | xargs -r rm" % ud.basecmd, d, workdir=ud.clonedir)
-            try:
-                os.unlink(ud.fullmirror)
-            except OSError as exc:
-                if exc.errno != errno.ENOENT:
-                    raise
+            runfetchcmd(fetch_cmd, d)
+            runfetchcmd("%s prune-packed" % ud.basecmd, d)
+            runfetchcmd("%s pack-redundant --all | xargs -r rm" % ud.basecmd, d)
+            ud.repochanged = True
+        os.chdir(ud.clonedir)
         for name in ud.names:
-            if not self._contains_ref(ud, d, name, ud.clonedir):
+            if not self._contains_ref(ud, d, name):
                 raise bb.fetch2.FetchError("Unable to find revision %s in branch %s even from upstream" % (ud.revisions[name], ud.branches[name]))
 
     def build_mirror_data(self, ud, d):
         # Generate a mirror tarball if needed
-        if ud.write_tarballs and not os.path.exists(ud.fullmirror):
+        if ud.write_tarballs and (ud.repochanged or not os.path.exists(ud.fullmirror)):
             # it's possible that this symlink points to read-only filesystem with PREMIRROR
             if os.path.islink(ud.fullmirror):
                 os.unlink(ud.fullmirror)
 
+            os.chdir(ud.clonedir)
             logger.info("Creating tarball of git repository")
-            runfetchcmd("tar -czf %s ." % ud.fullmirror, d, workdir=ud.clonedir)
-            runfetchcmd("touch %s.done" % ud.fullmirror, d)
+            runfetchcmd("tar -czf %s %s" % (ud.fullmirror, os.path.join(".") ), d)
+            runfetchcmd("touch %s.done" % (ud.fullmirror), d)
 
     def unpack(self, ud, destdir, d):
         """ unpack the downloaded src to destdir"""
 
         subdir = ud.parm.get("subpath", "")
         if subdir != "":
-            readpathspec = ":%s" % subdir
+            readpathspec = ":%s" % (subdir)
             def_destsuffix = "%s/" % os.path.basename(subdir.rstrip('/'))
         else:
             readpathspec = ""
@@ -314,23 +259,30 @@ class Git(FetchMethod):
         if ud.bareclone:
             cloneflags += " --mirror"
 
-        runfetchcmd("%s clone %s %s/ %s" % (ud.basecmd, cloneflags, ud.clonedir, destdir), d)
-        repourl = self._get_repo_url(ud)
-        runfetchcmd("%s remote set-url origin %s" % (ud.basecmd, repourl), d, workdir=destdir)
-        if not ud.nocheckout:
-            if subdir != "":
-                runfetchcmd("%s read-tree %s%s" % (ud.basecmd, ud.revisions[ud.names[0]], readpathspec), d,
-                            workdir=destdir)
-                runfetchcmd("%s checkout-index -q -f -a" % ud.basecmd, d, workdir=destdir)
-            elif not ud.nobranch:
-                branchname =  ud.branches[ud.names[0]]
-                runfetchcmd("%s checkout -B %s %s" % (ud.basecmd, branchname, \
-                            ud.revisions[ud.names[0]]), d, workdir=destdir)
-                runfetchcmd("%s branch --set-upstream %s origin/%s" % (ud.basecmd, branchname, \
-                            branchname), d, workdir=destdir)
-            else:
-                runfetchcmd("%s checkout %s" % (ud.basecmd, ud.revisions[ud.names[0]]), d, workdir=destdir)
+        # Versions of git prior to 1.7.9.2 have issues where foo.git and foo get confused
+        # and you end up with some horrible union of the two when you attempt to clone it
+        # The least invasive workaround seems to be a symlink to the real directory to
+        # fool git into ignoring any .git version that may also be present.
+        #
+        # The issue is fixed in more recent versions of git so we can drop this hack in future
+        # when that version becomes common enough.
+        clonedir = ud.clonedir
+        if not ud.path.endswith(".git"):
+            indirectiondir = destdir[:-1] + ".indirectionsymlink"
+            if os.path.exists(indirectiondir):
+                os.remove(indirectiondir)
+            bb.utils.mkdirhier(os.path.dirname(indirectiondir))
+            os.symlink(ud.clonedir, indirectiondir)
+            clonedir = indirectiondir
 
+        runfetchcmd("%s clone %s %s/ %s" % (ud.basecmd, cloneflags, clonedir, destdir), d)
+        if not ud.nocheckout:
+            os.chdir(destdir)
+            if subdir != "":
+                runfetchcmd("%s read-tree %s%s" % (ud.basecmd, ud.revisions[ud.names[0]], readpathspec), d)
+                runfetchcmd("%s checkout-index -q -f -a" % ud.basecmd, d)
+            else:
+                runfetchcmd("%s checkout %s" % (ud.basecmd, ud.revisions[ud.names[0]]), d)
         return True
 
     def clean(self, ud, d):
@@ -343,7 +295,7 @@ class Git(FetchMethod):
     def supports_srcrev(self):
         return True
 
-    def _contains_ref(self, ud, d, name, wd):
+    def _contains_ref(self, ud, d, name):
         cmd = ""
         if ud.nobranch:
             cmd = "%s log --pretty=oneline -n 1 %s -- 2> /dev/null | wc -l" % (
@@ -352,23 +304,13 @@ class Git(FetchMethod):
             cmd =  "%s branch --contains %s --list %s 2> /dev/null | wc -l" % (
                 ud.basecmd, ud.revisions[name], ud.branches[name])
         try:
-            output = runfetchcmd(cmd, d, quiet=True, workdir=wd)
+            output = runfetchcmd(cmd, d, quiet=True)
         except bb.fetch2.FetchError:
             return False
         if len(output.split()) > 1:
             raise bb.fetch2.FetchError("The command '%s' gave output with more then 1 line unexpectedly, output: '%s'" % (cmd, output))
         return output.split()[0] != "0"
 
-    def _get_repo_url(self, ud):
-        """
-        Return the repository URL
-        """
-        if ud.user:
-            username = ud.user + '@'
-        else:
-            username = ""
-        return "%s://%s%s%s" % (ud.proto, username, ud.host, ud.path)
-
     def _revision_key(self, ud, d, name):
         """
         Return a unique key for the url
@@ -379,122 +321,38 @@ class Git(FetchMethod):
         """
         Run git ls-remote with the specified search string
         """
-        # Prevent recursion e.g. in OE if SRCPV is in PV, PV is in WORKDIR,
-        # and WORKDIR is in PATH (as a result of RSS), our call to
-        # runfetchcmd() exports PATH so this function will get called again (!)
-        # In this scenario the return call of the function isn't actually
-        # important - WORKDIR isn't needed in PATH to call git ls-remote
-        # anyway.
-        if d.getVar('_BB_GIT_IN_LSREMOTE', False):
-            return ''
-        d.setVar('_BB_GIT_IN_LSREMOTE', '1')
-        try:
-            repourl = self._get_repo_url(ud)
-            cmd = "%s ls-remote %s %s" % \
-                (ud.basecmd, repourl, search)
-            if ud.proto.lower() != 'file':
-                bb.fetch2.check_network_access(d, cmd, repourl)
-            output = runfetchcmd(cmd, d, True)
-            if not output:
-                raise bb.fetch2.FetchError("The command %s gave empty output unexpectedly" % cmd, ud.url)
-        finally:
-            d.delVar('_BB_GIT_IN_LSREMOTE')
+        if ud.user:
+            username = ud.user + '@'
+        else:
+            username = ""
+
+        cmd = "%s ls-remote %s://%s%s%s %s" % \
+              (ud.basecmd, ud.proto, username, ud.host, ud.path, search)
+        if ud.proto.lower() != 'file':
+            bb.fetch2.check_network_access(d, cmd)
+        output = runfetchcmd(cmd, d, True)
+        if not output:
+            raise bb.fetch2.FetchError("The command %s gave empty output unexpectedly" % cmd, ud.url)
         return output
 
     def _latest_revision(self, ud, d, name):
         """
         Compute the HEAD revision for the url
         """
-        output = self._lsremote(ud, d, "")
-        # Tags of the form ^{} may not work, need to fallback to other form
-        if ud.unresolvedrev[name][:5] == "refs/" or ud.usehead:
-            head = ud.unresolvedrev[name]
-            tag = ud.unresolvedrev[name]
+        if ud.unresolvedrev[name][:5] == "refs/":
+            search = "%s %s^{}" % (ud.unresolvedrev[name], ud.unresolvedrev[name])
         else:
-            head = "refs/heads/%s" % ud.unresolvedrev[name]
-            tag = "refs/tags/%s" % ud.unresolvedrev[name]
-        for s in [head, tag + "^{}", tag]:
-            for l in output.strip().split('\n'):
-                sha1, ref = l.split()
-                if s == ref:
-                    return sha1
-        raise bb.fetch2.FetchError("Unable to resolve '%s' in upstream git repository in git ls-remote output for %s" % \
-            (ud.unresolvedrev[name], ud.host+ud.path))
-
-    def latest_versionstring(self, ud, d):
-        """
-        Compute the latest release name like "x.y.x" in "x.y.x+gitHASH"
-        by searching through the tags output of ls-remote, comparing
-        versions and returning the highest match.
-        """
-        pupver = ('', '')
-
-        tagregex = re.compile(d.getVar('UPSTREAM_CHECK_GITTAGREGEX') or "(?P<pver>([0-9][\.|_]?)+)")
-        try:
-            output = self._lsremote(ud, d, "refs/tags/*")
-        except bb.fetch2.FetchError or bb.fetch2.NetworkAccess:
-            return pupver
-
-        verstring = ""
-        revision = ""
-        for line in output.split("\n"):
-            if not line:
-                break
-
-            tag_head = line.split("/")[-1]
-            # Ignore non-released branches
-            m = re.search("(alpha|beta|rc|final)+", tag_head)
-            if m:
-                continue
-
-            # search for version in the line
-            tag = tagregex.search(tag_head)
-            if tag == None:
-                continue
-
-            tag = tag.group('pver')
-            tag = tag.replace("_", ".")
-
-            if verstring and bb.utils.vercmp(("0", tag, ""), ("0", verstring, "")) < 0:
-                continue
-
-            verstring = tag
-            revision = line.split()[0]
-            pupver = (verstring, revision)
-
-        return pupver
+            search = "refs/heads/%s refs/tags/%s^{}" % (ud.unresolvedrev[name], ud.unresolvedrev[name])
+        output = self._lsremote(ud, d, search)
+        return output.split()[0]
 
     def _build_revision(self, ud, d, name):
         return ud.revisions[name]
 
-    def gitpkgv_revision(self, ud, d, name):
-        """
-        Return a sortable revision number by counting commits in the history
-        Based on gitpkgv.bblass in meta-openembedded
-        """
-        rev = self._build_revision(ud, d, name)
-        localpath = ud.localpath
-        rev_file = os.path.join(localpath, "oe-gitpkgv_" + rev)
-        if not os.path.exists(localpath):
-            commits = None
-        else:
-            if not os.path.exists(rev_file) or not os.path.getsize(rev_file):
-                from pipes import quote
-                commits = bb.fetch2.runfetchcmd(
-                        "git rev-list %s -- | wc -l" % quote(rev),
-                        d, quiet=True).strip().lstrip('0')
-                if commits:
-                    open(rev_file, "w").write("%d\n" % int(commits))
-            else:
-                commits = open(rev_file, "r").readline(128).strip()
-        if commits:
-            return False, "%s+%s" % (commits, rev[:7])
-        else:
-            return True, str(rev)
-
-    def checkstatus(self, fetch, ud, d):
+    def checkstatus(self, ud, d):
+        fetchcmd = "%s ls-remote %s" % (ud.basecmd, ud.url)
         try:
-            self._lsremote(ud, d, "")
+            runfetchcmd(fetchcmd, d, quiet=True)
             return True
-        except bb.fetch2.FetchError:
+        except FetchError:
             return False

bitbake/lib/bb/fetch2/gitannex.py

@@ -22,6 +22,7 @@ BitBake 'Fetch' git annex implementation
 
 import os
 import bb
+from   bb import data
 from   bb.fetch2.git import Git
 from   bb.fetch2 import runfetchcmd
 from   bb.fetch2 import logger
@@ -33,42 +34,43 @@ class GitANNEX(Git):
         """
         return ud.type in ['gitannex']
 
-    def uses_annex(self, ud, d, wd):
+    def uses_annex(self, ud, d):
         for name in ud.names:
             try:
-                runfetchcmd("%s rev-list git-annex" % (ud.basecmd), d, quiet=True, workdir=wd)
+                runfetchcmd("%s rev-list git-annex" % (ud.basecmd), d, quiet=True)
                 return True
             except bb.fetch.FetchError:
                 pass
 
         return False
 
-    def update_annex(self, ud, d, wd):
+    def update_annex(self, ud, d):
         try:
-            runfetchcmd("%s annex get --all" % (ud.basecmd), d, quiet=True, workdir=wd)
+            runfetchcmd("%s annex get --all" % (ud.basecmd), d, quiet=True)
         except bb.fetch.FetchError:
             return False
-        runfetchcmd("chmod u+w -R %s/annex" % (ud.clonedir), d, quiet=True, workdir=wd)
+        runfetchcmd("chmod u+w -R %s/annex" % (ud.clonedir), d, quiet=True)
 
         return True
 
     def download(self, ud, d):
         Git.download(self, ud, d)
 
-        annex = self.uses_annex(ud, d, ud.clonedir)
+        os.chdir(ud.clonedir)
+        annex = self.uses_annex(ud, d)
         if annex:
-            self.update_annex(ud, d, ud.clonedir)
+            self.update_annex(ud, d)
 
     def unpack(self, ud, destdir, d):
         Git.unpack(self, ud, destdir, d)
 
+        os.chdir(ud.destdir)
         try:
-            runfetchcmd("%s annex init" % (ud.basecmd), d, workdir=ud.destdir)
+            runfetchcmd("%s annex sync" % (ud.basecmd), d)
         except bb.fetch.FetchError:
             pass
 
-        annex = self.uses_annex(ud, d, ud.destdir)
+        annex = self.uses_annex(ud, d)
         if annex:
-            runfetchcmd("%s annex get" % (ud.basecmd), d, workdir=ud.destdir)
-            runfetchcmd("chmod u+w -R %s/.git/annex" % (ud.destdir), d, quiet=True, workdir=ud.destdir)
-
+            runfetchcmd("%s annex get" % (ud.basecmd), d)
+            runfetchcmd("chmod u+w -R %s/.git/annex" % (ud.destdir), d, quiet=True)

bitbake/lib/bb/fetch2/gitsm.py

@@ -31,6 +31,7 @@ NOTE: Switching a SRC_URI from "git://" to "gitsm://" requires a clean of your r
 
 import os
 import bb
+from   bb    import data
 from   bb.fetch2.git import Git
 from   bb.fetch2 import runfetchcmd
 from   bb.fetch2 import logger
@@ -42,10 +43,10 @@ class GitSM(Git):
         """
         return ud.type in ['gitsm']
 
-    def uses_submodules(self, ud, d, wd):
+    def uses_submodules(self, ud, d):
         for name in ud.names:
             try:
-                runfetchcmd("%s show %s:.gitmodules" % (ud.basecmd, ud.revisions[name]), d, quiet=True, workdir=wd)
+                runfetchcmd("%s show %s:.gitmodules" % (ud.basecmd, ud.revisions[name]), d, quiet=True)
                 return True
             except bb.fetch.FetchError:
                 pass
@@ -106,25 +107,30 @@ class GitSM(Git):
         os.mkdir(tmpclonedir)
         os.rename(ud.clonedir, gitdir)
         runfetchcmd("sed " + gitdir + "/config -i -e 's/bare.*=.*true/bare = false/'", d)
-        runfetchcmd(ud.basecmd + " reset --hard", d, workdir=tmpclonedir)
-        runfetchcmd(ud.basecmd + " checkout -f " + ud.revisions[ud.names[0]], d, workdir=tmpclonedir)
-        runfetchcmd(ud.basecmd + " submodule update --init --recursive", d, workdir=tmpclonedir)
+        os.chdir(tmpclonedir)
+        runfetchcmd(ud.basecmd + " reset --hard", d)
+        runfetchcmd(ud.basecmd + " submodule init", d)
+        runfetchcmd(ud.basecmd + " submodule update", d)
         self._set_relative_paths(tmpclonedir)
-        runfetchcmd("sed " + gitdir + "/config -i -e 's/bare.*=.*false/bare = true/'", d, workdir=tmpclonedir)
+        runfetchcmd("sed " + gitdir + "/config -i -e 's/bare.*=.*false/bare = true/'", d)
         os.rename(gitdir, ud.clonedir,)
         bb.utils.remove(tmpclonedir, True)
 
     def download(self, ud, d):
         Git.download(self, ud, d)
 
-        submodules = self.uses_submodules(ud, d, ud.clonedir)
+        os.chdir(ud.clonedir)
+        submodules = self.uses_submodules(ud, d)
         if submodules:
             self.update_submodules(ud, d)
 
     def unpack(self, ud, destdir, d):
         Git.unpack(self, ud, destdir, d)
         
-        submodules = self.uses_submodules(ud, d, ud.destdir)
+        os.chdir(ud.destdir)
+        submodules = self.uses_submodules(ud, d)
         if submodules:
-            runfetchcmd(ud.basecmd + " checkout " + ud.revisions[ud.names[0]], d, workdir=ud.destdir)
-            runfetchcmd(ud.basecmd + " submodule update --init --recursive", d, workdir=ud.destdir)
+            runfetchcmd("cp -r " + ud.clonedir + "/modules " + ud.destdir + "/.git/", d)
+            runfetchcmd(ud.basecmd + " submodule init", d)
+            runfetchcmd(ud.basecmd + " submodule update", d)
+

bitbake/lib/bb/fetch2/hg.py

@@ -28,7 +28,7 @@ import os
 import sys
 import logging
 import bb
-import errno
+from bb import data
 from bb.fetch2 import FetchMethod
 from bb.fetch2 import FetchError
 from bb.fetch2 import MissingParameterError
@@ -43,13 +43,6 @@ class Hg(FetchMethod):
         """
         return ud.type in ['hg']
 
-    def supports_checksum(self, urldata):
-        """
-        Don't require checksums for local archives created from
-        repository checkouts.
-        """ 
-        return False
-
     def urldata_init(self, ud, d):
         """
         init hg specific variable within url data
@@ -59,33 +52,19 @@ class Hg(FetchMethod):
 
         ud.module = ud.parm["module"]
 
-        if 'protocol' in ud.parm:
-            ud.proto = ud.parm['protocol']
-        elif not ud.host:
-            ud.proto = 'file'
-        else:
-            ud.proto = "hg"
+        # Create paths to mercurial checkouts
+        relpath = self._strip_leading_slashes(ud.path)
+        ud.pkgdir = os.path.join(data.expand('${HGDIR}', d), ud.host, relpath)
+        ud.moddir = os.path.join(ud.pkgdir, ud.module)
 
-        ud.setup_revisions(d)
+        ud.setup_revisons(d)
 
         if 'rev' in ud.parm:
             ud.revision = ud.parm['rev']
         elif not ud.revision:
             ud.revision = self.latest_revision(ud, d)
 
-        # Create paths to mercurial checkouts
-        hgsrcname = '%s_%s_%s' % (ud.module.replace('/', '.'), \
-                            ud.host, ud.path.replace('/', '.'))
-        ud.mirrortarball = 'hg_%s.tar.gz' % hgsrcname
-        ud.fullmirror = os.path.join(d.getVar("DL_DIR"), ud.mirrortarball)
-
-        hgdir = d.getVar("HGDIR") or (d.getVar("DL_DIR") + "/hg/")
-        ud.pkgdir = os.path.join(hgdir, hgsrcname)
-        ud.moddir = os.path.join(ud.pkgdir, ud.module)
-        ud.localfile = ud.moddir
-        ud.basecmd = d.getVar("FETCHCMD_hg") or "/usr/bin/env hg"
-
-        ud.write_tarballs = d.getVar("BB_GENERATE_MIRROR_TARBALLS")
+        ud.localfile = data.expand('%s_%s_%s_%s.tar.gz' % (ud.module.replace('/', '.'), ud.host, ud.path.replace('/', '.'), ud.revision), d)
 
     def need_update(self, ud, d):
         revTag = ud.parm.get('rev', 'tip')
@@ -95,21 +74,14 @@ class Hg(FetchMethod):
             return True
         return False
 
-    def try_premirror(self, ud, d):
-        # If we don't do this, updating an existing checkout with only premirrors
-        # is not possible
-        if d.getVar("BB_FETCH_PREMIRRORONLY") is not None:
-            return True
-        if os.path.exists(ud.moddir):
-            return False
-        return True
-
     def _buildhgcommand(self, ud, d, command):
         """
         Build up an hg commandline based on ud
         command is "fetch", "update", "info"
         """
 
+        basecmd = data.expand('${FETCHCMD_hg}', d)
+
         proto = ud.parm.get('protocol', 'http')
 
         host = ud.host
@@ -126,7 +98,7 @@ class Hg(FetchMethod):
                 hgroot = ud.user + "@" + host + ud.path
 
         if command == "info":
-            return "%s identify -i %s://%s/%s" % (ud.basecmd, proto, hgroot, ud.module)
+            return "%s identify -i %s://%s/%s" % (basecmd, proto, hgroot, ud.module)
 
         options = [];
 
@@ -139,22 +111,22 @@ class Hg(FetchMethod):
 
         if command == "fetch":
             if ud.user and ud.pswd:
-                cmd = "%s --config auth.default.prefix=* --config auth.default.username=%s --config auth.default.password=%s --config \"auth.default.schemes=%s\" clone %s %s://%s/%s %s" % (ud.basecmd, ud.user, ud.pswd, proto, " ".join(options), proto, hgroot, ud.module, ud.module)
+                cmd = "%s --config auth.default.prefix=* --config auth.default.username=%s --config auth.default.password=%s --config \"auth.default.schemes=%s\" clone %s %s://%s/%s %s" % (basecmd, ud.user, ud.pswd, proto, " ".join(options), proto, hgroot, ud.module, ud.module)
             else:
-                cmd = "%s clone %s %s://%s/%s %s" % (ud.basecmd, " ".join(options), proto, hgroot, ud.module, ud.module)
+                cmd = "%s clone %s %s://%s/%s %s" % (basecmd, " ".join(options), proto, hgroot, ud.module, ud.module)	      
         elif command == "pull":
             # do not pass options list; limiting pull to rev causes the local
             # repo not to contain it and immediately following "update" command
             # will crash
             if ud.user and ud.pswd:
-                cmd = "%s --config auth.default.prefix=* --config auth.default.username=%s --config auth.default.password=%s --config \"auth.default.schemes=%s\" pull" % (ud.basecmd, ud.user, ud.pswd, proto)
+                cmd = "%s --config auth.default.prefix=* --config auth.default.username=%s --config auth.default.password=%s --config \"auth.default.schemes=%s\" pull" % (basecmd, ud.user, ud.pswd, proto)
             else:
-                cmd = "%s pull" % (ud.basecmd)
+                cmd = "%s pull" % (basecmd)
         elif command == "update":
             if ud.user and ud.pswd:
-                cmd = "%s --config auth.default.prefix=* --config auth.default.username=%s --config auth.default.password=%s --config \"auth.default.schemes=%s\" update -C %s" % (ud.basecmd, ud.user, ud.pswd, proto, " ".join(options))
+                cmd = "%s --config auth.default.prefix=* --config auth.default.username=%s --config auth.default.password=%s --config \"auth.default.schemes=%s\" update -C %s" % (basecmd, ud.user, ud.pswd, proto, " ".join(options))
             else:
-                cmd = "%s update -C %s" % (ud.basecmd, " ".join(options))
+                cmd = "%s update -C %s" % (basecmd, " ".join(options))
         else:
             raise FetchError("Invalid hg command %s" % command, ud.url)
 
@@ -165,53 +137,40 @@ class Hg(FetchMethod):
 
         logger.debug(2, "Fetch: checking for module directory '" + ud.moddir + "'")
 
-        # If the checkout doesn't exist and the mirror tarball does, extract it
-        if not os.path.exists(ud.pkgdir) and os.path.exists(ud.fullmirror):
-            bb.utils.mkdirhier(ud.pkgdir)
-            runfetchcmd("tar -xzf %s" % (ud.fullmirror), d, workdir=ud.pkgdir)
-
         if os.access(os.path.join(ud.moddir, '.hg'), os.R_OK):
-            # Found the source, check whether need pull
-            updatecmd = self._buildhgcommand(ud, d, "update")
+            updatecmd = self._buildhgcommand(ud, d, "pull")
+            logger.info("Update " + ud.url)
+            # update sources there
+            os.chdir(ud.moddir)
             logger.debug(1, "Running %s", updatecmd)
-            try:
-                runfetchcmd(updatecmd, d, workdir=ud.moddir)
-            except bb.fetch2.FetchError:
-                # Runnning pull in the repo
-                pullcmd = self._buildhgcommand(ud, d, "pull")
-                logger.info("Pulling " + ud.url)
-                # update sources there
-                logger.debug(1, "Running %s", pullcmd)
-                bb.fetch2.check_network_access(d, pullcmd, ud.url)
-                runfetchcmd(pullcmd, d, workdir=ud.moddir)
-                try:
-                    os.unlink(ud.fullmirror)
-                except OSError as exc:
-                    if exc.errno != errno.ENOENT:
-                        raise
+            bb.fetch2.check_network_access(d, updatecmd, ud.url)
+            runfetchcmd(updatecmd, d)
 
-        # No source found, clone it.
-        if not os.path.exists(ud.moddir):
+        else:
             fetchcmd = self._buildhgcommand(ud, d, "fetch")
             logger.info("Fetch " + ud.url)
             # check out sources there
             bb.utils.mkdirhier(ud.pkgdir)
+            os.chdir(ud.pkgdir)
             logger.debug(1, "Running %s", fetchcmd)
             bb.fetch2.check_network_access(d, fetchcmd, ud.url)
-            runfetchcmd(fetchcmd, d, workdir=ud.pkgdir)
+            runfetchcmd(fetchcmd, d)
 
         # Even when we clone (fetch), we still need to update as hg's clone
         # won't checkout the specified revision if its on a branch
         updatecmd = self._buildhgcommand(ud, d, "update")
+        os.chdir(ud.moddir)
         logger.debug(1, "Running %s", updatecmd)
-        runfetchcmd(updatecmd, d, workdir=ud.moddir)
+        runfetchcmd(updatecmd, d)
 
-    def clean(self, ud, d):
-        """ Clean the hg dir """
+        scmdata = ud.parm.get("scmdata", "")
+        if scmdata == "keep":
+            tar_flags = ""
+        else:
+            tar_flags = "--exclude '.hg' --exclude '.hgrags'"
 
-        bb.utils.remove(ud.localpath, True)
-        bb.utils.remove(ud.fullmirror)
-        bb.utils.remove(ud.fullmirror + ".done")
+        os.chdir(ud.pkgdir)
+        runfetchcmd("tar %s -czf %s %s" % (tar_flags, ud.localpath, ud.module), d, cleanup = [ud.localpath])
 
     def supports_srcrev(self):
         return True
@@ -220,7 +179,7 @@ class Hg(FetchMethod):
         """
         Compute tip revision for the url
         """
-        bb.fetch2.check_network_access(d, self._buildhgcommand(ud, d, "info"), ud.url)
+        bb.fetch2.check_network_access(d, self._buildhgcommand(ud, d, "info"))
         output = runfetchcmd(self._buildhgcommand(ud, d, "info"), d)
         return output.strip()
 
@@ -232,38 +191,3 @@ class Hg(FetchMethod):
         Return a unique key for the url
         """
         return "hg:" + ud.moddir
-
-    def build_mirror_data(self, ud, d):
-        # Generate a mirror tarball if needed
-        if ud.write_tarballs == "1" and not os.path.exists(ud.fullmirror):
-            # it's possible that this symlink points to read-only filesystem with PREMIRROR
-            if os.path.islink(ud.fullmirror):
-                os.unlink(ud.fullmirror)
-
-            logger.info("Creating tarball of hg repository")
-            runfetchcmd("tar -czf %s %s" % (ud.fullmirror, ud.module), d, workdir=ud.pkgdir)
-            runfetchcmd("touch %s.done" % (ud.fullmirror), d, workdir=ud.pkgdir)
-
-    def localpath(self, ud, d):
-        return ud.pkgdir
-
-    def unpack(self, ud, destdir, d):
-        """
-        Make a local clone or export for the url
-        """
-
-        revflag = "-r %s" % ud.revision
-        subdir = ud.parm.get("destsuffix", ud.module)
-        codir = "%s/%s" % (destdir, subdir)
-
-        scmdata = ud.parm.get("scmdata", "")
-        if scmdata != "nokeep":
-            if not os.access(os.path.join(codir, '.hg'), os.R_OK):
-                logger.debug(2, "Unpack: creating new hg repository in '" + codir + "'")
-                runfetchcmd("%s init %s" % (ud.basecmd, codir), d)
-            logger.debug(2, "Unpack: updating source in '" + codir + "'")
-            runfetchcmd("%s pull %s" % (ud.basecmd, ud.moddir), d, workdir=codir)
-            runfetchcmd("%s up -C %s" % (ud.basecmd, revflag), d, workdir=codir)
-        else:
-            logger.debug(2, "Unpack: extracting source to '" + codir + "'")
-            runfetchcmd("%s archive -t files %s %s" % (ud.basecmd, revflag, codir), d, workdir=ud.moddir)

bitbake/lib/bb/fetch2/local.py

@@ -26,9 +26,10 @@ BitBake build tools.
 # Based on functions from the base bb module, Copyright 2003 Holger Schurig
 
 import os
-import urllib.request, urllib.parse, urllib.error
+import urllib
 import bb
 import bb.utils
+from   bb import data
 from   bb.fetch2 import FetchMethod, FetchError
 from   bb.fetch2 import logger
 
@@ -41,10 +42,9 @@ class Local(FetchMethod):
 
     def urldata_init(self, ud, d):
         # We don't set localfile as for this fetcher the file is already local!
-        ud.decodedurl = urllib.parse.unquote(ud.url.split("://")[1].split(";")[0])
+        ud.decodedurl = urllib.unquote(ud.url.split("://")[1].split(";")[0])
         ud.basename = os.path.basename(ud.decodedurl)
         ud.basepath = ud.decodedurl
-        ud.needdonestamp = False
         return
 
     def localpath(self, urldata, d):
@@ -62,11 +62,17 @@ class Local(FetchMethod):
         newpath = path
         if path[0] == "/":
             return [path]
-        filespath = d.getVar('FILESPATH')
+        filespath = data.getVar('FILESPATH', d, True)
         if filespath:
             logger.debug(2, "Searching for %s in paths:\n    %s" % (path, "\n    ".join(filespath.split(":"))))
             newpath, hist = bb.utils.which(filespath, path, history=True)
             searched.extend(hist)
+        if not newpath:
+            filesdir = data.getVar('FILESDIR', d, True)
+            if filesdir:
+                logger.debug(2, "Searching for %s in path: %s" % (path, filesdir))
+                newpath = os.path.join(filesdir, path)
+                searched.append(newpath)
         if (not newpath or not os.path.exists(newpath)) and path.find("*") != -1:
             # For expressions using '*', best we can do is take the first directory in FILESPATH that exists
             newpath, hist = bb.utils.which(filespath, ".", history=True)
@@ -74,7 +80,7 @@ class Local(FetchMethod):
             logger.debug(2, "Searching for %s in path: %s" % (path, newpath))
             return searched
         if not os.path.exists(newpath):
-            dldirfile = os.path.join(d.getVar("DL_DIR"), path)
+            dldirfile = os.path.join(d.getVar("DL_DIR", True), path)
             logger.debug(2, "Defaulting to %s for %s" % (dldirfile, path))
             bb.utils.mkdirhier(os.path.dirname(dldirfile))
             searched.append(dldirfile)
@@ -93,17 +99,20 @@ class Local(FetchMethod):
         # no need to fetch local files, we'll deal with them in place.
         if self.supports_checksum(urldata) and not os.path.exists(urldata.localpath):
             locations = []
-            filespath = d.getVar('FILESPATH')
+            filespath = data.getVar('FILESPATH', d, True)
             if filespath:
                 locations = filespath.split(":")
-            locations.append(d.getVar("DL_DIR"))
+            filesdir = data.getVar('FILESDIR', d, True)
+            if filesdir:
+                locations.append(filesdir)
+            locations.append(d.getVar("DL_DIR", True))
 
             msg = "Unable to find file " + urldata.url + " anywhere. The paths that were searched were:\n    " + "\n    ".join(locations)
             raise FetchError(msg)
 
         return True
 
-    def checkstatus(self, fetch, urldata, d):
+    def checkstatus(self, urldata, d):
         """
         Check the status of the url
         """

bitbake/lib/bb/fetch2/npm.py

@@ -1,305 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-"""
-BitBake 'Fetch' NPM implementation
-
-The NPM fetcher is used to retrieve files from the npmjs repository
-
-Usage in the recipe:
-
-    SRC_URI = "npm://registry.npmjs.org/;name=${PN};version=${PV}"
-    Suported SRC_URI options are:
-
-    - name
-    - version
-
-    npm://registry.npmjs.org/${PN}/-/${PN}-${PV}.tgz  would become npm://registry.npmjs.org;name=${PN};version=${PV}
-    The fetcher all triggers off the existence of ud.localpath. If that exists and has the ".done" stamp, its assumed the fetch is good/done
-
-"""
-
-import os
-import sys
-import urllib.request, urllib.parse, urllib.error
-import json
-import subprocess
-import signal
-import bb
-from   bb.fetch2 import FetchMethod
-from   bb.fetch2 import FetchError
-from   bb.fetch2 import ChecksumError
-from   bb.fetch2 import runfetchcmd
-from   bb.fetch2 import logger
-from   bb.fetch2 import UnpackError
-from   bb.fetch2 import ParameterError
-from   distutils import spawn
-
-def subprocess_setup():
-    # Python installs a SIGPIPE handler by default. This is usually not what
-    # non-Python subprocesses expect.
-    # SIGPIPE errors are known issues with gzip/bash
-    signal.signal(signal.SIGPIPE, signal.SIG_DFL)
-
-class Npm(FetchMethod):
-
-    """Class to fetch urls via 'npm'"""
-    def init(self, d):
-        pass
-
-    def supports(self, ud, d):
-        """
-        Check to see if a given url can be fetched with npm
-        """
-        return ud.type in ['npm']
-
-    def debug(self, msg):
-        logger.debug(1, "NpmFetch: %s", msg)
-
-    def clean(self, ud, d):
-        logger.debug(2, "Calling cleanup %s" % ud.pkgname)
-        bb.utils.remove(ud.localpath, False)
-        bb.utils.remove(ud.pkgdatadir, True)
-        bb.utils.remove(ud.fullmirror, False)
-
-    def urldata_init(self, ud, d):
-        """
-        init NPM specific variable within url data
-        """
-        if 'downloadfilename' in ud.parm:
-            ud.basename = ud.parm['downloadfilename']
-        else:
-            ud.basename = os.path.basename(ud.path)
-
-        # can't call it ud.name otherwise fetcher base class will start doing sha1stuff
-        # TODO: find a way to get an sha1/sha256 manifest of pkg & all deps
-        ud.pkgname = ud.parm.get("name", None)
-        if not ud.pkgname:
-            raise ParameterError("NPM fetcher requires a name parameter", ud.url)
-        ud.version = ud.parm.get("version", None)
-        if not ud.version:
-            raise ParameterError("NPM fetcher requires a version parameter", ud.url)
-        ud.bbnpmmanifest = "%s-%s.deps.json" % (ud.pkgname, ud.version)
-        ud.bbnpmmanifest = ud.bbnpmmanifest.replace('/', '-')
-        ud.registry = "http://%s" % (ud.url.replace('npm://', '', 1).split(';'))[0]
-        prefixdir = "npm/%s" % ud.pkgname
-        ud.pkgdatadir = d.expand("${DL_DIR}/%s" % prefixdir)
-        if not os.path.exists(ud.pkgdatadir):
-            bb.utils.mkdirhier(ud.pkgdatadir)
-        ud.localpath = d.expand("${DL_DIR}/npm/%s" % ud.bbnpmmanifest)
-
-        self.basecmd = d.getVar("FETCHCMD_wget") or "/usr/bin/env wget -O -t 2 -T 30 -nv --passive-ftp --no-check-certificate "
-        ud.prefixdir = prefixdir
-
-        ud.write_tarballs = ((d.getVar("BB_GENERATE_MIRROR_TARBALLS") or "0") != "0")
-        ud.mirrortarball = 'npm_%s-%s.tar.xz' % (ud.pkgname, ud.version)
-        ud.mirrortarball = ud.mirrortarball.replace('/', '-')
-        ud.fullmirror = os.path.join(d.getVar("DL_DIR"), ud.mirrortarball)
-
-    def need_update(self, ud, d):
-        if os.path.exists(ud.localpath):
-            return False
-        return True
-
-    def _runwget(self, ud, d, command, quiet):
-        logger.debug(2, "Fetching %s using command '%s'" % (ud.url, command))
-        bb.fetch2.check_network_access(d, command, ud.url)
-        dldir = d.getVar("DL_DIR")
-        runfetchcmd(command, d, quiet, workdir=dldir)
-
-    def _unpackdep(self, ud, pkg, data, destdir, dldir, d):
-        file = data[pkg]['tgz']
-        logger.debug(2, "file to extract is %s" % file)
-        if file.endswith('.tgz') or file.endswith('.tar.gz') or file.endswith('.tar.Z'):
-            cmd = 'tar xz --strip 1 --no-same-owner --warning=no-unknown-keyword -f %s/%s' % (dldir, file)
-        else:
-            bb.fatal("NPM package %s downloaded not a tarball!" % file)
-
-        # Change to subdir before executing command
-        if not os.path.exists(destdir):
-            os.makedirs(destdir)
-        path = d.getVar('PATH')
-        if path:
-            cmd = "PATH=\"%s\" %s" % (path, cmd)
-        bb.note("Unpacking %s to %s/" % (file, destdir))
-        ret = subprocess.call(cmd, preexec_fn=subprocess_setup, shell=True, cwd=destdir)
-
-        if ret != 0:
-            raise UnpackError("Unpack command %s failed with return value %s" % (cmd, ret), ud.url)
-
-        if 'deps' not in data[pkg]:
-            return
-        for dep in data[pkg]['deps']:
-            self._unpackdep(ud, dep, data[pkg]['deps'], "%s/node_modules/%s" % (destdir, dep), dldir, d)
-
-
-    def unpack(self, ud, destdir, d):
-        dldir = d.getVar("DL_DIR")
-        with open("%s/npm/%s" % (dldir, ud.bbnpmmanifest)) as datafile:
-            workobj = json.load(datafile)
-        dldir = "%s/%s" % (os.path.dirname(ud.localpath), ud.pkgname)
-
-        if 'subdir' in ud.parm:
-            unpackdir = '%s/%s' % (destdir, ud.parm.get('subdir'))
-        else:
-            unpackdir = '%s/npmpkg' % destdir
-
-        self._unpackdep(ud, ud.pkgname, workobj, unpackdir, dldir, d)
-
-    def _parse_view(self, output):
-        '''
-        Parse the output of npm view --json; the last JSON result
-        is assumed to be the one that we're interested in.
-        '''
-        pdata = None
-        outdeps = {}
-        datalines = []
-        bracelevel = 0
-        for line in output.splitlines():
-            if bracelevel:
-                datalines.append(line)
-            elif '{' in line:
-                datalines = []
-                datalines.append(line)
-            bracelevel = bracelevel + line.count('{') - line.count('}')
-        if datalines:
-            pdata = json.loads('\n'.join(datalines))
-        return pdata
-
-    def _getdependencies(self, pkg, data, version, d, ud, optional=False, fetchedlist=None):
-        if fetchedlist is None:
-            fetchedlist = []
-        pkgfullname = pkg
-        if version != '*' and not '/' in version:
-            pkgfullname += "@'%s'" % version
-        logger.debug(2, "Calling getdeps on %s" % pkg)
-        fetchcmd = "npm view %s --json --registry %s" % (pkgfullname, ud.registry)
-        output = runfetchcmd(fetchcmd, d, True)
-        pdata = self._parse_view(output)
-        if not pdata:
-            raise FetchError("The command '%s' returned no output" % fetchcmd)
-        if optional:
-            pkg_os = pdata.get('os', None)
-            if pkg_os:
-                if not isinstance(pkg_os, list):
-                    pkg_os = [pkg_os]
-                blacklist = False
-                for item in pkg_os:
-                    if item.startswith('!'):
-                        blacklist = True
-                        break
-                if (not blacklist and 'linux' not in pkg_os) or '!linux' in pkg_os:
-                    logger.debug(2, "Skipping %s since it's incompatible with Linux" % pkg)
-                    return
-        #logger.debug(2, "Output URL is %s - %s - %s" % (ud.basepath, ud.basename, ud.localfile))
-        outputurl = pdata['dist']['tarball']
-        data[pkg] = {}
-        data[pkg]['tgz'] = os.path.basename(outputurl)
-        if not outputurl in fetchedlist:
-            self._runwget(ud, d, "%s --directory-prefix=%s %s" % (self.basecmd, ud.prefixdir, outputurl), False)
-            fetchedlist.append(outputurl)
-
-        dependencies = pdata.get('dependencies', {})
-        optionalDependencies = pdata.get('optionalDependencies', {})
-        dependencies.update(optionalDependencies)
-        depsfound = {}
-        optdepsfound = {}
-        data[pkg]['deps'] = {}
-        for dep in dependencies:
-            if dep in optionalDependencies:
-                optdepsfound[dep] = dependencies[dep]
-            else:
-                depsfound[dep] = dependencies[dep]
-        for dep, version in optdepsfound.items():
-            self._getdependencies(dep, data[pkg]['deps'], version, d, ud, optional=True, fetchedlist=fetchedlist)
-        for dep, version in depsfound.items():
-            self._getdependencies(dep, data[pkg]['deps'], version, d, ud, fetchedlist=fetchedlist)
-
-    def _getshrinkeddependencies(self, pkg, data, version, d, ud, lockdown, manifest, toplevel=True):
-        logger.debug(2, "NPM shrinkwrap file is %s" % data)
-        if toplevel:
-            name = data.get('name', None)
-            if name and name != pkg:
-                for obj in data.get('dependencies', []):
-                    if obj == pkg:
-                        self._getshrinkeddependencies(obj, data['dependencies'][obj], data['dependencies'][obj]['version'], d, ud, lockdown, manifest, False)
-                        return
-        outputurl = "invalid"
-        if ('resolved' not in data) or (not data['resolved'].startswith('http')):
-            # will be the case for ${PN}
-            fetchcmd = "npm view %s@%s dist.tarball --registry %s" % (pkg, version, ud.registry)
-            logger.debug(2, "Found this matching URL: %s" % str(fetchcmd))
-            outputurl = runfetchcmd(fetchcmd, d, True)
-        else:
-            outputurl = data['resolved']
-        self._runwget(ud, d, "%s --directory-prefix=%s %s" % (self.basecmd, ud.prefixdir, outputurl), False)
-        manifest[pkg] = {}
-        manifest[pkg]['tgz'] = os.path.basename(outputurl).rstrip()
-        manifest[pkg]['deps'] = {}
-
-        if pkg in lockdown:
-            sha1_expected = lockdown[pkg][version]
-            sha1_data = bb.utils.sha1_file("npm/%s/%s" % (ud.pkgname, manifest[pkg]['tgz']))
-            if sha1_expected != sha1_data:
-                msg = "\nFile: '%s' has %s checksum %s when %s was expected" % (manifest[pkg]['tgz'], 'sha1', sha1_data, sha1_expected)
-                raise ChecksumError('Checksum mismatch!%s' % msg)
-        else:
-            logger.debug(2, "No lockdown data for %s@%s" % (pkg, version))
-
-        if 'dependencies' in data:
-            for obj in data['dependencies']:
-                logger.debug(2, "Found dep is %s" % str(obj))
-                self._getshrinkeddependencies(obj, data['dependencies'][obj], data['dependencies'][obj]['version'], d, ud, lockdown, manifest[pkg]['deps'], False)
-
-    def download(self, ud, d):
-        """Fetch url"""
-        jsondepobj = {}
-        shrinkobj = {}
-        lockdown = {}
-
-        if not os.listdir(ud.pkgdatadir) and os.path.exists(ud.fullmirror):
-            dest = d.getVar("DL_DIR")
-            bb.utils.mkdirhier(dest)
-            runfetchcmd("tar -xJf %s" % (ud.fullmirror), d, workdir=dest)
-            return
-
-        shwrf = d.getVar('NPM_SHRINKWRAP')
-        logger.debug(2, "NPM shrinkwrap file is %s" % shwrf)
-        if shwrf:
-            try:
-                with open(shwrf) as datafile:
-                    shrinkobj = json.load(datafile)
-            except Exception as e:
-                raise FetchError('Error loading NPM_SHRINKWRAP file "%s" for %s: %s' % (shwrf, ud.pkgname, str(e)))
-        elif not ud.ignore_checksums:
-            logger.warning('Missing shrinkwrap file in NPM_SHRINKWRAP for %s, this will lead to unreliable builds!' % ud.pkgname)
-        lckdf = d.getVar('NPM_LOCKDOWN')
-        logger.debug(2, "NPM lockdown file is %s" % lckdf)
-        if lckdf:
-            try:
-                with open(lckdf) as datafile:
-                    lockdown = json.load(datafile)
-            except Exception as e:
-                raise FetchError('Error loading NPM_LOCKDOWN file "%s" for %s: %s' % (lckdf, ud.pkgname, str(e)))
-        elif not ud.ignore_checksums:
-            logger.warning('Missing lockdown file in NPM_LOCKDOWN for %s, this will lead to unreproducible builds!' % ud.pkgname)
-
-        if ('name' not in shrinkobj):
-            self._getdependencies(ud.pkgname, jsondepobj, ud.version, d, ud)
-        else:
-            self._getshrinkeddependencies(ud.pkgname, shrinkobj, ud.version, d, ud, lockdown, jsondepobj)
-
-        with open(ud.localpath, 'w') as outfile:
-            json.dump(jsondepobj, outfile)
-
-    def build_mirror_data(self, ud, d):
-        # Generate a mirror tarball if needed
-        if ud.write_tarballs and not os.path.exists(ud.fullmirror):
-            # it's possible that this symlink points to read-only filesystem with PREMIRROR
-            if os.path.islink(ud.fullmirror):
-                os.unlink(ud.fullmirror)
-
-            dldir = d.getVar("DL_DIR")
-            logger.info("Creating tarball of npm data")
-            runfetchcmd("tar -cJf %s npm/%s npm/%s" % (ud.fullmirror, ud.bbnpmmanifest, ud.pkgname), d,
-                        workdir=dldir)
-            runfetchcmd("touch %s.done" % (ud.fullmirror), d, workdir=dldir)

bitbake/lib/bb/fetch2/osc.py

@@ -10,6 +10,7 @@ import  os
 import  sys
 import logging
 import  bb
+from    bb       import data
 from    bb.fetch2 import FetchMethod
 from    bb.fetch2 import FetchError
 from    bb.fetch2 import MissingParameterError
@@ -33,20 +34,20 @@ class Osc(FetchMethod):
 
         # Create paths to osc checkouts
         relpath = self._strip_leading_slashes(ud.path)
-        ud.pkgdir = os.path.join(d.getVar('OSCDIR'), ud.host)
+        ud.pkgdir = os.path.join(data.expand('${OSCDIR}', d), ud.host)
         ud.moddir = os.path.join(ud.pkgdir, relpath, ud.module)
 
         if 'rev' in ud.parm:
             ud.revision = ud.parm['rev']
         else:
-            pv = d.getVar("PV", False)
+            pv = data.getVar("PV", d, 0)
             rev = bb.fetch2.srcrev_internal_helper(ud, d)
             if rev and rev != True:
                 ud.revision = rev
             else:
                 ud.revision = ""
 
-        ud.localfile = d.expand('%s_%s_%s.tar.gz' % (ud.module.replace('/', '.'), ud.path.replace('/', '.'), ud.revision))
+        ud.localfile = data.expand('%s_%s_%s.tar.gz' % (ud.module.replace('/', '.'), ud.path.replace('/', '.'), ud.revision), d)
 
     def _buildosccommand(self, ud, d, command):
         """
@@ -54,7 +55,7 @@ class Osc(FetchMethod):
         command is "fetch", "update", "info"
         """
 
-        basecmd = d.expand('${FETCHCMD_osc}')
+        basecmd = data.expand('${FETCHCMD_osc}', d)
 
         proto = ud.parm.get('protocol', 'ocs')
 
@@ -83,25 +84,27 @@ class Osc(FetchMethod):
 
         logger.debug(2, "Fetch: checking for module directory '" + ud.moddir + "'")
 
-        if os.access(os.path.join(d.getVar('OSCDIR'), ud.path, ud.module), os.R_OK):
+        if os.access(os.path.join(data.expand('${OSCDIR}', d), ud.path, ud.module), os.R_OK):
             oscupdatecmd = self._buildosccommand(ud, d, "update")
             logger.info("Update "+ ud.url)
             # update sources there
+            os.chdir(ud.moddir)
             logger.debug(1, "Running %s", oscupdatecmd)
             bb.fetch2.check_network_access(d, oscupdatecmd, ud.url)
-            runfetchcmd(oscupdatecmd, d, workdir=ud.moddir)
+            runfetchcmd(oscupdatecmd, d)
         else:
             oscfetchcmd = self._buildosccommand(ud, d, "fetch")
             logger.info("Fetch " + ud.url)
             # check out sources there
             bb.utils.mkdirhier(ud.pkgdir)
+            os.chdir(ud.pkgdir)
             logger.debug(1, "Running %s", oscfetchcmd)
             bb.fetch2.check_network_access(d, oscfetchcmd, ud.url)
-            runfetchcmd(oscfetchcmd, d, workdir=ud.pkgdir)
+            runfetchcmd(oscfetchcmd, d)
 
+        os.chdir(os.path.join(ud.pkgdir + ud.path))
         # tar them up to a defined filename
-        runfetchcmd("tar -czf %s %s" % (ud.localpath, ud.module), d,
-                    cleanup=[ud.localpath], workdir=os.path.join(ud.pkgdir + ud.path))
+        runfetchcmd("tar -czf %s %s" % (ud.localpath, ud.module), d, cleanup = [ud.localpath])
 
     def supports_srcrev(self):
         return False
@@ -111,7 +114,7 @@ class Osc(FetchMethod):
         Generate a .oscrc to be used for this run.
         """
 
-        config_path = os.path.join(d.getVar('OSCDIR'), "oscrc")
+        config_path = os.path.join(data.expand('${OSCDIR}', d), "oscrc")
         if (os.path.exists(config_path)):
             os.remove(config_path)
 
@@ -120,8 +123,8 @@ class Osc(FetchMethod):
         f.write("apisrv = %s\n" % ud.host)
         f.write("scheme = http\n")
         f.write("su-wrapper = su -c\n")
-        f.write("build-root = %s\n" % d.getVar('WORKDIR'))
-        f.write("urllist = %s\n" % d.getVar("OSCURLLIST"))
+        f.write("build-root = %s\n" % data.expand('${WORKDIR}', d))
+        f.write("urllist = http://moblin-obs.jf.intel.com:8888/build/%(project)s/%(repository)s/%(buildarch)s/:full/%(name)s.rpm\n")
         f.write("extra-pkgs = gzip\n")
         f.write("\n")
         f.write("[%s]\n" % ud.host)

bitbake/lib/bb/fetch2/perforce.py

@@ -1,12 +1,14 @@
 # ex:ts=4:sw=4:sts=4:et
 # -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
 """
-BitBake 'Fetch' implementation for perforce
+BitBake 'Fetch' implementations
+
+Classes for obtaining upstream sources for the
+BitBake build tools.
 
 """
 
 # Copyright (C) 2003, 2004  Chris Larson
-# Copyright (C) 2016 Kodak Alaris, Inc.
 #
 # This program is free software; you can redistribute it and/or modify
 # it under the terms of the GNU General Public License version 2 as
@@ -23,187 +25,163 @@ BitBake 'Fetch' implementation for perforce
 #
 # Based on functions from the base bb module, Copyright 2003 Holger Schurig
 
+from future_builtins import zip
 import os
+import subprocess
 import logging
 import bb
+from   bb import data
 from   bb.fetch2 import FetchMethod
 from   bb.fetch2 import FetchError
 from   bb.fetch2 import logger
 from   bb.fetch2 import runfetchcmd
 
 class Perforce(FetchMethod):
-    """ Class to fetch from perforce repositories """
     def supports(self, ud, d):
-        """ Check to see if a given url can be fetched with perforce. """
         return ud.type in ['p4']
 
-    def urldata_init(self, ud, d):
-        """
-        Initialize perforce specific variables within url data.  If P4CONFIG is
-        provided by the env, use it.  If P4PORT is specified by the recipe, use
-        its values, which may override the settings in P4CONFIG.
-        """
-        ud.basecmd = d.getVar('FETCHCMD_p4')
-        if not ud.basecmd:
-            ud.basecmd = "/usr/bin/env p4"
-
-        ud.dldir = d.getVar('P4DIR')
-        if not ud.dldir:
-            ud.dldir = '%s/%s' % (d.getVar('DL_DIR'), 'p4')
-
-        path = ud.url.split('://')[1]
-        path = path.split(';')[0]
-        delim = path.find('@');
+    def doparse(url, d):
+        parm = {}
+        path = url.split("://")[1]
+        delim = path.find("@");
         if delim != -1:
-            (ud.user, ud.pswd) = path.split('@')[0].split(':')
-            ud.path = path.split('@')[1]
+            (user, pswd, host, port) = path.split('@')[0].split(":")
+            path = path.split('@')[1]
         else:
-            ud.path = path
+            (host, port) = d.getVar('P4PORT').split(':')
+            user = ""
+            pswd = ""
 
-        ud.usingp4config = False
-        p4port = d.getVar('P4PORT')
+        if path.find(";") != -1:
+            keys=[]
+            values=[]
+            plist = path.split(';')
+            for item in plist:
+                if item.count('='):
+                    (key, value) = item.split('=')
+                    keys.append(key)
+                    values.append(value)
 
-        if p4port:
-            logger.debug(1, 'Using recipe provided P4PORT: %s' % p4port)
-            ud.host = p4port
-        else:
-            logger.debug(1, 'Trying to use P4CONFIG to automatically set P4PORT...')
-            ud.usingp4config = True
-            p4cmd = '%s info | grep "Server address"' % ud.basecmd
-            bb.fetch2.check_network_access(d, p4cmd, ud.url)
-            ud.host = runfetchcmd(p4cmd, d, True)
-            ud.host = ud.host.split(': ')[1].strip()
-            logger.debug(1, 'Determined P4PORT to be: %s' % ud.host)
-            if not ud.host:
-                raise FetchError('Could not determine P4PORT from P4CONFIG')
-	
-        if ud.path.find('/...') >= 0:
-            ud.pathisdir = True
-        else:
-            ud.pathisdir = False
+            parm = dict(zip(keys, values))
+        path = "//" + path.split(';')[0]
+        host += ":%s" % (port)
+        parm["cset"] = Perforce.getcset(d, path, host, user, pswd, parm)
 
-        cleanedpath = ud.path.replace('/...', '').replace('/', '.')
-        cleanedhost = ud.host.replace(':', '.')
-        ud.pkgdir = os.path.join(ud.dldir, cleanedhost, cleanedpath)
+        return host, path, user, pswd, parm
+    doparse = staticmethod(doparse)
 
-        ud.setup_revisions(d)
-
-        ud.localfile = d.expand('%s_%s_%s.tar.gz' % (cleanedhost, cleanedpath, ud.revision))
-
-    def _buildp4command(self, ud, d, command, depot_filename=None):
-        """
-        Build a p4 commandline.  Valid commands are "changes", "print", and
-        "files".  depot_filename is the full path to the file in the depot
-        including the trailing '#rev' value.
-        """
+    def getcset(d, depot, host, user, pswd, parm):
         p4opt = ""
+        if "cset" in parm:
+            return parm["cset"];
+        if user:
+            p4opt += " -u %s" % (user)
+        if pswd:
+            p4opt += " -P %s" % (pswd)
+        if host:
+            p4opt += " -p %s" % (host)
 
-        if ud.user:
-            p4opt += ' -u "%s"' % (ud.user)
+        p4date = d.getVar("P4DATE", True)
+        if "revision" in parm:
+            depot += "#%s" % (parm["revision"])
+        elif "label" in parm:
+            depot += "@%s" % (parm["label"])
+        elif p4date:
+            depot += "@%s" % (p4date)
 
-        if ud.pswd:
-            p4opt += ' -P "%s"' % (ud.pswd)
+        p4cmd = d.getVar('FETCHCMD_p4', True) or "p4"
+        logger.debug(1, "Running %s%s changes -m 1 %s", p4cmd, p4opt, depot)
+        p4file, errors = bb.process.run("%s%s changes -m 1 %s" % (p4cmd, p4opt, depot))
+        cset = p4file.strip()
+        logger.debug(1, "READ %s", cset)
+        if not cset:
+            return -1
 
-        if ud.host and not ud.usingp4config:
-            p4opt += ' -p %s' % (ud.host)
+        return cset.split(' ')[1]
+    getcset = staticmethod(getcset)
 
-        if hasattr(ud, 'revision') and ud.revision:
-            pathnrev = '%s@%s' % (ud.path, ud.revision)
+    def urldata_init(self, ud, d):
+        (host, path, user, pswd, parm) = Perforce.doparse(ud.url, d)
+
+        base_path = path.replace('/...', '')
+        base_path = self._strip_leading_slashes(base_path)
+        
+        if "label" in parm:
+            version = parm["label"]
         else:
-            pathnrev = '%s' % (ud.path)
+            version = Perforce.getcset(d, path, host, user, pswd, parm)
 
-        if depot_filename:
-            if ud.pathisdir: # Remove leading path to obtain filename
-                filename = depot_filename[len(ud.path)-1:]
-            else:
-                filename = depot_filename[depot_filename.rfind('/'):]
-            filename = filename[:filename.find('#')] # Remove trailing '#rev'
-
-        if command == 'changes':
-            p4cmd = '%s%s changes -m 1 //%s' % (ud.basecmd, p4opt, pathnrev)
-        elif command == 'print':
-            if depot_filename != None:
-                p4cmd = '%s%s print -o "p4/%s" "%s"' % (ud.basecmd, p4opt, filename, depot_filename)
-            else:
-                raise FetchError('No depot file name provided to p4 %s' % command, ud.url)
-        elif command == 'files':
-            p4cmd = '%s%s files //%s' % (ud.basecmd, p4opt, pathnrev)
-        else:
-            raise FetchError('Invalid p4 command %s' % command, ud.url)
-
-        return p4cmd
-
-    def _p4listfiles(self, ud, d):
-        """
-        Return a list of the file names which are present in the depot using the
-        'p4 files' command, including trailing '#rev' file revision indicator
-        """
-        p4cmd = self._buildp4command(ud, d, 'files')
-        bb.fetch2.check_network_access(d, p4cmd, ud.url)
-        p4fileslist = runfetchcmd(p4cmd, d, True)
-        p4fileslist = [f.rstrip() for f in p4fileslist.splitlines()]
-
-        if not p4fileslist:
-            raise FetchError('Unable to fetch listing of p4 files from %s@%s' % (ud.host, ud.path))
-
-        count = 0
-        filelist = []
-
-        for filename in p4fileslist:
-            item = filename.split(' - ')
-            lastaction = item[1].split()
-            logger.debug(1, 'File: %s Last Action: %s' % (item[0], lastaction[0]))
-            if lastaction[0] == 'delete':
-                continue
-            filelist.append(item[0])
-
-        return filelist
+        ud.localfile = data.expand('%s+%s+%s.tar.gz' % (host, base_path.replace('/', '.'), version), d)
 
     def download(self, ud, d):
-        """ Get the list of files, fetch each one """
-        filelist = self._p4listfiles(ud, d)
-        if not filelist:
-            raise FetchError('No files found in depot %s@%s' % (ud.host, ud.path))
+        """
+        Fetch urls
+        """
 
-        bb.utils.remove(ud.pkgdir, True)
-        bb.utils.mkdirhier(ud.pkgdir)
+        (host, depot, user, pswd, parm) = Perforce.doparse(ud.url, d)
 
-        for afile in filelist:
-            p4fetchcmd = self._buildp4command(ud, d, 'print', afile)
-            bb.fetch2.check_network_access(d, p4fetchcmd, ud.url)
-            runfetchcmd(p4fetchcmd, d, workdir=ud.pkgdir)
+        if depot.find('/...') != -1:
+            path = depot[:depot.find('/...')]
+        else:
+            path = depot
 
-        runfetchcmd('tar -czf %s p4' % (ud.localpath), d, cleanup=[ud.localpath], workdir=ud.pkgdir)
+        module = parm.get('module', os.path.basename(path))
 
-    def clean(self, ud, d):
-        """ Cleanup p4 specific files and dirs"""
-        bb.utils.remove(ud.localpath)
-        bb.utils.remove(ud.pkgdir, True)
+        # Get the p4 command
+        p4opt = ""
+        if user:
+            p4opt += " -u %s" % (user)
 
-    def supports_srcrev(self):
-        return True
+        if pswd:
+            p4opt += " -P %s" % (pswd)
 
-    def _revision_key(self, ud, d, name):
-        """ Return a unique key for the url """
-        return 'p4:%s' % ud.pkgdir
+        if host:
+            p4opt += " -p %s" % (host)
 
-    def _latest_revision(self, ud, d, name):
-        """ Return the latest upstream scm revision number """
-        p4cmd = self._buildp4command(ud, d, "changes")
-        bb.fetch2.check_network_access(d, p4cmd, ud.url)
-        tip = runfetchcmd(p4cmd, d, True)
+        p4cmd = d.getVar('FETCHCMD_p4', True) or "p4"
 
-        if not tip:
-            raise FetchError('Could not determine the latest perforce changelist')
+        # create temp directory
+        logger.debug(2, "Fetch: creating temporary directory")
+        bb.utils.mkdirhier(d.expand('${WORKDIR}'))
+        mktemp = d.getVar("FETCHCMD_p4mktemp", True) or d.expand("mktemp -d -q '${WORKDIR}/oep4.XXXXXX'")
+        tmpfile, errors = bb.process.run(mktemp)
+        tmpfile = tmpfile.strip()
+        if not tmpfile:
+            raise FetchError("Fetch: unable to create temporary directory.. make sure 'mktemp' is in the PATH.", ud.url)
 
-        tipcset = tip.split(' ')[1]
-        logger.debug(1, 'p4 tip found to be changelist %s' % tipcset)
-        return tipcset
+        if "label" in parm:
+            depot = "%s@%s" % (depot, parm["label"])
+        else:
+            cset = Perforce.getcset(d, depot, host, user, pswd, parm)
+            depot = "%s@%s" % (depot, cset)
 
-    def sortable_revision(self, ud, d, name):
-        """ Return a sortable revision number """
-        return False, self._build_revision(ud, d)
+        os.chdir(tmpfile)
+        logger.info("Fetch " + ud.url)
+        logger.info("%s%s files %s", p4cmd, p4opt, depot)
+        p4file, errors = bb.process.run("%s%s files %s" % (p4cmd, p4opt, depot))
+        p4file = [f.rstrip() for f in p4file.splitlines()]
 
-    def _build_revision(self, ud, d):
-        return ud.revision
+        if not p4file:
+            raise FetchError("Fetch: unable to get the P4 files from %s" % depot, ud.url)
 
+        count = 0
+
+        for file in p4file:
+            list = file.split()
+
+            if list[2] == "delete":
+                continue
+
+            dest = list[0][len(path)+1:]
+            where = dest.find("#")
+
+            subprocess.call("%s%s print -o %s/%s %s" % (p4cmd, p4opt, module, dest[:where], list[0]), shell=True)
+            count = count + 1
+
+        if count == 0:
+            logger.error()
+            raise FetchError("Fetch: No files gathered from the P4 fetch", ud.url)
+
+        runfetchcmd("tar -czf %s %s" % (ud.localpath, module), d, cleanup = [ud.localpath])
+        # cleanup
+        bb.utils.prunedir(tmpfile)

bitbake/lib/bb/fetch2/repo.py

@@ -25,6 +25,7 @@ BitBake "Fetch" repo (git) implementation
 
 import os
 import bb
+from   bb    import data
 from   bb.fetch2 import FetchMethod
 from   bb.fetch2 import runfetchcmd
 
@@ -50,17 +51,17 @@ class Repo(FetchMethod):
         if not ud.manifest.endswith('.xml'):
             ud.manifest += '.xml'
 
-        ud.localfile = d.expand("repo_%s%s_%s_%s.tar.gz" % (ud.host, ud.path.replace("/", "."), ud.manifest, ud.branch))
+        ud.localfile = data.expand("repo_%s%s_%s_%s.tar.gz" % (ud.host, ud.path.replace("/", "."), ud.manifest, ud.branch), d)
 
     def download(self, ud, d):
         """Fetch url"""
 
-        if os.access(os.path.join(d.getVar("DL_DIR"), ud.localfile), os.R_OK):
+        if os.access(os.path.join(data.getVar("DL_DIR", d, True), ud.localfile), os.R_OK):
             logger.debug(1, "%s already exists (or was stashed). Skipping repo init / sync.", ud.localpath)
             return
 
         gitsrcname = "%s%s" % (ud.host, ud.path.replace("/", "."))
-        repodir = d.getVar("REPODIR") or os.path.join(d.getVar("DL_DIR"), "repo")
+        repodir = data.getVar("REPODIR", d, True) or os.path.join(data.getVar("DL_DIR", d, True), "repo")
         codir = os.path.join(repodir, gitsrcname, ud.manifest)
 
         if ud.user:
@@ -68,23 +69,24 @@ class Repo(FetchMethod):
         else:
             username = ""
 
-        repodir = os.path.join(codir, "repo")
-        bb.utils.mkdirhier(repodir)
-        if not os.path.exists(os.path.join(repodir, ".repo")):
+        bb.utils.mkdirhier(os.path.join(codir, "repo"))
+        os.chdir(os.path.join(codir, "repo"))
+        if not os.path.exists(os.path.join(codir, "repo", ".repo")):
             bb.fetch2.check_network_access(d, "repo init -m %s -b %s -u %s://%s%s%s" % (ud.manifest, ud.branch, ud.proto, username, ud.host, ud.path), ud.url)
-            runfetchcmd("repo init -m %s -b %s -u %s://%s%s%s" % (ud.manifest, ud.branch, ud.proto, username, ud.host, ud.path), d, workdir=repodir)
+            runfetchcmd("repo init -m %s -b %s -u %s://%s%s%s" % (ud.manifest, ud.branch, ud.proto, username, ud.host, ud.path), d)
 
         bb.fetch2.check_network_access(d, "repo sync %s" % ud.url, ud.url)
-        runfetchcmd("repo sync", d, workdir=repodir)
+        runfetchcmd("repo sync", d)
+        os.chdir(codir)
 
         scmdata = ud.parm.get("scmdata", "")
         if scmdata == "keep":
             tar_flags = ""
         else:
-            tar_flags = "--exclude='.repo' --exclude='.git'"
+            tar_flags = "--exclude '.repo' --exclude '.git'"
 
         # Create a cache
-        runfetchcmd("tar %s -czf %s %s" % (tar_flags, ud.localpath, os.path.join(".", "*") ), d, workdir=codir)
+        runfetchcmd("tar %s -czf %s %s" % (tar_flags, ud.localpath, os.path.join(".", "*") ), d)
 
     def supports_srcrev(self):
         return False

bitbake/lib/bb/fetch2/s3.py

@@ -1,98 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-"""
-BitBake 'Fetch' implementation for Amazon AWS S3.
-
-Class for fetching files from Amazon S3 using the AWS Command Line Interface.
-The aws tool must be correctly installed and configured prior to use.
-
-"""
-
-# Copyright (C) 2017, Andre McCurdy <armccurdy@gmail.com>
-#
-# Based in part on bb.fetch2.wget:
-#    Copyright (C) 2003, 2004  Chris Larson
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 2 as
-# published by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-#
-# Based on functions from the base bb module, Copyright 2003 Holger Schurig
-
-import os
-import bb
-import urllib.request, urllib.parse, urllib.error
-from bb.fetch2 import FetchMethod
-from bb.fetch2 import FetchError
-from bb.fetch2 import runfetchcmd
-
-class S3(FetchMethod):
-    """Class to fetch urls via 'aws s3'"""
-
-    def supports(self, ud, d):
-        """
-        Check to see if a given url can be fetched with s3.
-        """
-        return ud.type in ['s3']
-
-    def recommends_checksum(self, urldata):
-        return True
-
-    def urldata_init(self, ud, d):
-        if 'downloadfilename' in ud.parm:
-            ud.basename = ud.parm['downloadfilename']
-        else:
-            ud.basename = os.path.basename(ud.path)
-
-        ud.localfile = d.expand(urllib.parse.unquote(ud.basename))
-
-        ud.basecmd = d.getVar("FETCHCMD_s3") or "/usr/bin/env aws s3"
-
-    def download(self, ud, d):
-        """
-        Fetch urls
-        Assumes localpath was called first
-        """
-
-        cmd = '%s cp s3://%s%s %s' % (ud.basecmd, ud.host, ud.path, ud.localpath)
-        bb.fetch2.check_network_access(d, cmd, ud.url)
-        runfetchcmd(cmd, d)
-
-        # Additional sanity checks copied from the wget class (although there
-        # are no known issues which mean these are required, treat the aws cli
-        # tool with a little healthy suspicion).
-
-        if not os.path.exists(ud.localpath):
-            raise FetchError("The aws cp command returned success for s3://%s%s but %s doesn't exist?!" % (ud.host, ud.path, ud.localpath))
-
-        if os.path.getsize(ud.localpath) == 0:
-            os.remove(ud.localpath)
-            raise FetchError("The aws cp command for s3://%s%s resulted in a zero size file?! Deleting and failing since this isn't right." % (ud.host, ud.path))
-
-        return True
-
-    def checkstatus(self, fetch, ud, d):
-        """
-        Check the status of a URL
-        """
-
-        cmd = '%s ls s3://%s%s' % (ud.basecmd, ud.host, ud.path)
-        bb.fetch2.check_network_access(d, cmd, ud.url)
-        output = runfetchcmd(cmd, d)
-
-        # "aws s3 ls s3://mybucket/foo" will exit with success even if the file
-        # is not found, so check output of the command to confirm success.
-
-        if not output:
-            raise FetchError("The aws ls command for s3://%s%s gave empty output" % (ud.host, ud.path))
-
-        return True

bitbake/lib/bb/fetch2/sftp.py

@@ -61,11 +61,14 @@ SRC_URI = "sftp://user@host.example.com/dir/path.file.txt"
 
 import os
 import bb
-import urllib.request, urllib.parse, urllib.error
+import urllib
+import commands
+from bb import data
 from bb.fetch2 import URI
 from bb.fetch2 import FetchMethod
 from bb.fetch2 import runfetchcmd
 
+
 class SFTP(FetchMethod):
     """Class to fetch urls via 'sftp'"""
 
@@ -90,19 +93,19 @@ class SFTP(FetchMethod):
         else:
             ud.basename = os.path.basename(ud.path)
 
-        ud.localfile = d.expand(urllib.parse.unquote(ud.basename))
+        ud.localfile = data.expand(urllib.unquote(ud.basename), d)
 
     def download(self, ud, d):
         """Fetch urls"""
 
         urlo = URI(ud.url)
-        basecmd = 'sftp -oBatchMode=yes'
+        basecmd = 'sftp -oPasswordAuthentication=no'
         port = ''
         if urlo.port:
             port = '-P %d' % urlo.port
             urlo.port = None
 
-        dldir = d.getVar('DL_DIR')
+        dldir = data.getVar('DL_DIR', d, True)
         lpath = os.path.join(dldir, ud.localfile)
 
         user = ''
@@ -118,7 +121,8 @@ class SFTP(FetchMethod):
 
         remote = '%s%s:%s' % (user, urlo.hostname, path)
 
-        cmd = '%s %s %s %s' % (basecmd, port, remote, lpath)
+        cmd = '%s %s %s %s' % (basecmd, port, commands.mkarg(remote),
+                               commands.mkarg(lpath))
 
         bb.fetch2.check_network_access(d, cmd, ud.url)
         runfetchcmd(cmd, d)

bitbake/lib/bb/fetch2/ssh.py

@@ -43,6 +43,7 @@ IETF secsh internet draft:
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 import re, os
+from   bb import data
 from   bb.fetch2 import FetchMethod
 from   bb.fetch2 import FetchError
 from   bb.fetch2 import logger
@@ -86,11 +87,10 @@ class SSH(FetchMethod):
         m = __pattern__.match(urldata.url)
         path = m.group('path')
         host = m.group('host')
-        urldata.localpath = os.path.join(d.getVar('DL_DIR'),
-                os.path.basename(os.path.normpath(path)))
+        urldata.localpath = os.path.join(d.getVar('DL_DIR', True), os.path.basename(path))
 
     def download(self, urldata, d):
-        dldir = d.getVar('DL_DIR')
+        dldir = d.getVar('DL_DIR', True)
 
         m = __pattern__.match(urldata.url)
         path = m.group('path')
@@ -113,10 +113,12 @@ class SSH(FetchMethod):
             fr = host
         fr += ':%s' % path
 
+
+        import commands
         cmd = 'scp -B -r %s %s %s/' % (
             portarg,
-            fr,
-            dldir
+            commands.mkarg(fr),
+            commands.mkarg(dldir)
         )
 
         bb.fetch2.check_network_access(d, cmd, urldata.url)

bitbake/lib/bb/fetch2/svn.py

@@ -28,6 +28,7 @@ import sys
 import logging
 import bb
 import re
+from   bb import data
 from   bb.fetch2 import FetchMethod
 from   bb.fetch2 import FetchError
 from   bb.fetch2 import MissingParameterError
@@ -49,26 +50,21 @@ class Svn(FetchMethod):
         if not "module" in ud.parm:
             raise MissingParameterError('module', ud.url)
 
-        ud.basecmd = d.getVar('FETCHCMD_svn')
+        ud.basecmd = d.getVar('FETCHCMD_svn', True)
 
         ud.module = ud.parm["module"]
 
-        if not "path_spec" in ud.parm:
-            ud.path_spec = ud.module
-        else:
-            ud.path_spec = ud.parm["path_spec"]
-
         # Create paths to svn checkouts
         relpath = self._strip_leading_slashes(ud.path)
-        ud.pkgdir = os.path.join(d.expand('${SVNDIR}'), ud.host, relpath)
+        ud.pkgdir = os.path.join(data.expand('${SVNDIR}', d), ud.host, relpath)
         ud.moddir = os.path.join(ud.pkgdir, ud.module)
 
-        ud.setup_revisions(d)
+        ud.setup_revisons(d)
 
         if 'rev' in ud.parm:
             ud.revision = ud.parm['rev']
 
-        ud.localfile = d.expand('%s_%s_%s_%s_.tar.gz' % (ud.module.replace('/', '.'), ud.host, ud.path.replace('/', '.'), ud.revision))
+        ud.localfile = data.expand('%s_%s_%s_%s_.tar.gz' % (ud.module.replace('/', '.'), ud.host, ud.path.replace('/', '.'), ud.revision), d)
 
     def _buildsvncommand(self, ud, d, command):
         """
@@ -78,9 +74,9 @@ class Svn(FetchMethod):
 
         proto = ud.parm.get('protocol', 'svn')
 
-        svn_ssh = None
-        if proto == "svn+ssh" and "ssh" in ud.parm:
-            svn_ssh = ud.parm["ssh"]
+        svn_rsh = None
+        if proto == "svn+ssh" and "rsh" in ud.parm:
+            svn_rsh = ud.parm["rsh"]
 
         svnroot = ud.host + ud.path
 
@@ -106,14 +102,14 @@ class Svn(FetchMethod):
 
             if command == "fetch":
                 transportuser = ud.parm.get("transportuser", "")
-                svncmd = "%s co %s %s://%s%s/%s%s %s" % (ud.basecmd, " ".join(options), proto, transportuser, svnroot, ud.module, suffix, ud.path_spec)
+                svncmd = "%s co %s %s://%s%s/%s%s %s" % (ud.basecmd, " ".join(options), proto, transportuser, svnroot, ud.module, suffix, ud.module)
             elif command == "update":
                 svncmd = "%s update %s" % (ud.basecmd, " ".join(options))
             else:
                 raise FetchError("Invalid svn command %s" % command, ud.url)
 
-        if svn_ssh:
-            svncmd = "SVN_SSH=\"%s\" %s" % (svn_ssh, svncmd)
+        if svn_rsh:
+            svncmd = "svn_RSH=\"%s\" %s" % (svn_rsh, svncmd)
 
         return svncmd
 
@@ -125,32 +121,35 @@ class Svn(FetchMethod):
         if os.access(os.path.join(ud.moddir, '.svn'), os.R_OK):
             svnupdatecmd = self._buildsvncommand(ud, d, "update")
             logger.info("Update " + ud.url)
+            # update sources there
+            os.chdir(ud.moddir)
             # We need to attempt to run svn upgrade first in case its an older working format
             try:
-                runfetchcmd(ud.basecmd + " upgrade", d, workdir=ud.moddir)
+                runfetchcmd(ud.basecmd + " upgrade", d)
             except FetchError:
                 pass
             logger.debug(1, "Running %s", svnupdatecmd)
             bb.fetch2.check_network_access(d, svnupdatecmd, ud.url)
-            runfetchcmd(svnupdatecmd, d, workdir=ud.moddir)
+            runfetchcmd(svnupdatecmd, d)
         else:
             svnfetchcmd = self._buildsvncommand(ud, d, "fetch")
             logger.info("Fetch " + ud.url)
             # check out sources there
             bb.utils.mkdirhier(ud.pkgdir)
+            os.chdir(ud.pkgdir)
             logger.debug(1, "Running %s", svnfetchcmd)
             bb.fetch2.check_network_access(d, svnfetchcmd, ud.url)
-            runfetchcmd(svnfetchcmd, d, workdir=ud.pkgdir)
+            runfetchcmd(svnfetchcmd, d)
 
         scmdata = ud.parm.get("scmdata", "")
         if scmdata == "keep":
             tar_flags = ""
         else:
-            tar_flags = "--exclude='.svn'"
+            tar_flags = "--exclude '.svn'"
 
+        os.chdir(ud.pkgdir)
         # tar them up to a defined filename
-        runfetchcmd("tar %s -czf %s %s" % (tar_flags, ud.localpath, ud.path_spec), d,
-                    cleanup=[ud.localpath], workdir=ud.pkgdir)
+        runfetchcmd("tar %s -czf %s %s" % (tar_flags, ud.localpath, ud.module), d, cleanup = [ud.localpath])
 
     def clean(self, ud, d):
         """ Clean SVN specific files and dirs """
@@ -172,7 +171,7 @@ class Svn(FetchMethod):
         """
         Return the latest upstream revision number
         """
-        bb.fetch2.check_network_access(d, self._buildsvncommand(ud, d, "log1"), ud.url)
+        bb.fetch2.check_network_access(d, self._buildsvncommand(ud, d, "log1"))
 
         output = runfetchcmd("LANG=C LC_ALL=C " + self._buildsvncommand(ud, d, "log1"), d, True)
 

bitbake/lib/bb/fetch2/wget.py

@@ -25,42 +25,15 @@ BitBake build tools.
 #
 # Based on functions from the base bb module, Copyright 2003 Holger Schurig
 
-import re
-import tempfile
-import subprocess
 import os
 import logging
 import bb
-import bb.progress
-import urllib.request, urllib.parse, urllib.error
+import urllib
+from   bb import data
 from   bb.fetch2 import FetchMethod
 from   bb.fetch2 import FetchError
 from   bb.fetch2 import logger
 from   bb.fetch2 import runfetchcmd
-from   bb.utils import export_proxies
-from   bs4 import BeautifulSoup
-from   bs4 import SoupStrainer
-
-class WgetProgressHandler(bb.progress.LineFilterProgressHandler):
-    """
-    Extract progress information from wget output.
-    Note: relies on --progress=dot (with -v or without -q/-nv) being
-    specified on the wget command line.
-    """
-    def __init__(self, d):
-        super(WgetProgressHandler, self).__init__(d)
-        # Send an initial progress event so the bar gets shown
-        self._fire_progress(0)
-
-    def writeline(self, line):
-        percs = re.findall(r'(\d+)%\s+([\d.]+[A-Z])', line)
-        if percs:
-            progress = int(percs[-1][0])
-            rate = percs[-1][1] + '/s'
-            self.update(progress, rate)
-            return False
-        return True
-
 
 class Wget(FetchMethod):
     """Class to fetch urls via 'wget'"""
@@ -83,19 +56,15 @@ class Wget(FetchMethod):
         else:
             ud.basename = os.path.basename(ud.path)
 
-        ud.localfile = d.expand(urllib.parse.unquote(ud.basename))
-        if not ud.localfile:
-            ud.localfile = d.expand(urllib.parse.unquote(ud.host + ud.path).replace("/", "."))
+        ud.localfile = data.expand(urllib.unquote(ud.basename), d)
 
-        self.basecmd = d.getVar("FETCHCMD_wget") or "/usr/bin/env wget -t 2 -T 30 --passive-ftp --no-check-certificate"
+        self.basecmd = d.getVar("FETCHCMD_wget", True) or "/usr/bin/env wget -t 2 -T 30 -nv --passive-ftp --no-check-certificate"
 
     def _runwget(self, ud, d, command, quiet):
 
-        progresshandler = WgetProgressHandler(d)
-
         logger.debug(2, "Fetching %s using command '%s'" % (ud.url, command))
-        bb.fetch2.check_network_access(d, command, ud.url)
-        runfetchcmd(command + ' --progress=dot -v', d, quiet, log=progresshandler)
+        bb.fetch2.check_network_access(d, command)
+        runfetchcmd(command, d, quiet)
 
     def download(self, ud, d):
         """Fetch urls"""
@@ -103,13 +72,10 @@ class Wget(FetchMethod):
         fetchcmd = self.basecmd
 
         if 'downloadfilename' in ud.parm:
-            dldir = d.getVar("DL_DIR")
+            dldir = d.getVar("DL_DIR", True)
             bb.utils.mkdirhier(os.path.dirname(dldir + os.sep + ud.localfile))
             fetchcmd += " -O " + dldir + os.sep + ud.localfile
 
-        if ud.user and ud.pswd:
-            fetchcmd += " --user=%s --password=%s --auth-no-challenge" % (ud.user, ud.pswd)
-
         uri = ud.url.split(";")[0]
         if os.path.exists(ud.localpath):
             # file exists, but we didnt complete it.. trying again..
@@ -130,485 +96,11 @@ class Wget(FetchMethod):
 
         return True
 
-    def checkstatus(self, fetch, ud, d, try_again=True):
-        import urllib.request, urllib.error, urllib.parse, socket, http.client
-        from urllib.response import addinfourl
-        from bb.fetch2 import FetchConnectionCache
+    def checkstatus(self, ud, d):
 
-        class HTTPConnectionCache(http.client.HTTPConnection):
-            if fetch.connection_cache:
-                def connect(self):
-                    """Connect to the host and port specified in __init__."""
+        uri = ud.url.split(";")[0]
+        fetchcmd = self.basecmd + " --spider '%s'" % uri
 
-                    sock = fetch.connection_cache.get_connection(self.host, self.port)
-                    if sock:
-                        self.sock = sock
-                    else:
-                        self.sock = socket.create_connection((self.host, self.port),
-                                    self.timeout, self.source_address)
-                        fetch.connection_cache.add_connection(self.host, self.port, self.sock)
+        self._runwget(ud, d, fetchcmd, True)
 
-                    if self._tunnel_host:
-                        self._tunnel()
-
-        class CacheHTTPHandler(urllib.request.HTTPHandler):
-            def http_open(self, req):
-                return self.do_open(HTTPConnectionCache, req)
-
-            def do_open(self, http_class, req):
-                """Return an addinfourl object for the request, using http_class.
-
-                http_class must implement the HTTPConnection API from httplib.
-                The addinfourl return value is a file-like object.  It also
-                has methods and attributes including:
-                    - info(): return a mimetools.Message object for the headers
-                    - geturl(): return the original request URL
-                    - code: HTTP status code
-                """
-                host = req.host
-                if not host:
-                    raise urlllib2.URLError('no host given')
-
-                h = http_class(host, timeout=req.timeout) # will parse host:port
-                h.set_debuglevel(self._debuglevel)
-
-                headers = dict(req.unredirected_hdrs)
-                headers.update(dict((k, v) for k, v in list(req.headers.items())
-                            if k not in headers))
-
-                # We want to make an HTTP/1.1 request, but the addinfourl
-                # class isn't prepared to deal with a persistent connection.
-                # It will try to read all remaining data from the socket,
-                # which will block while the server waits for the next request.
-                # So make sure the connection gets closed after the (only)
-                # request.
-
-                # Don't close connection when connection_cache is enabled,
-                if fetch.connection_cache is None: 
-                    headers["Connection"] = "close"
-                else:
-                    headers["Connection"] = "Keep-Alive" # Works for HTTP/1.0
-
-                headers = dict(
-                    (name.title(), val) for name, val in list(headers.items()))
-
-                if req._tunnel_host:
-                    tunnel_headers = {}
-                    proxy_auth_hdr = "Proxy-Authorization"
-                    if proxy_auth_hdr in headers:
-                        tunnel_headers[proxy_auth_hdr] = headers[proxy_auth_hdr]
-                        # Proxy-Authorization should not be sent to origin
-                        # server.
-                        del headers[proxy_auth_hdr]
-                    h.set_tunnel(req._tunnel_host, headers=tunnel_headers)
-
-                try:
-                    h.request(req.get_method(), req.selector, req.data, headers)
-                except socket.error as err: # XXX what error?
-                    # Don't close connection when cache is enabled.
-                    if fetch.connection_cache is None:
-                        h.close()
-                    raise urllib.error.URLError(err)
-                else:
-                    try:
-                        r = h.getresponse(buffering=True)
-                    except TypeError: # buffering kw not supported
-                        r = h.getresponse()
-
-                # Pick apart the HTTPResponse object to get the addinfourl
-                # object initialized properly.
-
-                # Wrap the HTTPResponse object in socket's file object adapter
-                # for Windows.  That adapter calls recv(), so delegate recv()
-                # to read().  This weird wrapping allows the returned object to
-                # have readline() and readlines() methods.
-
-                # XXX It might be better to extract the read buffering code
-                # out of socket._fileobject() and into a base class.
-                r.recv = r.read
-
-                # no data, just have to read
-                r.read()
-                class fp_dummy(object):
-                    def read(self):
-                        return ""
-                    def readline(self):
-                        return ""
-                    def close(self):
-                        pass
-
-                resp = addinfourl(fp_dummy(), r.msg, req.get_full_url())
-                resp.code = r.status
-                resp.msg = r.reason
-
-                # Close connection when server request it.
-                if fetch.connection_cache is not None:
-                    if 'Connection' in r.msg and r.msg['Connection'] == 'close':
-                        fetch.connection_cache.remove_connection(h.host, h.port)
-
-                return resp
-
-        class HTTPMethodFallback(urllib.request.BaseHandler):
-            """
-            Fallback to GET if HEAD is not allowed (405 HTTP error)
-            """
-            def http_error_405(self, req, fp, code, msg, headers):
-                fp.read()
-                fp.close()
-
-                newheaders = dict((k,v) for k,v in list(req.headers.items())
-                                  if k.lower() not in ("content-length", "content-type"))
-                return self.parent.open(urllib.request.Request(req.get_full_url(),
-                                                        headers=newheaders,
-                                                        origin_req_host=req.origin_req_host,
-                                                        unverifiable=True))
-
-            """
-            Some servers (e.g. GitHub archives, hosted on Amazon S3) return 403
-            Forbidden when they actually mean 405 Method Not Allowed.
-            """
-            http_error_403 = http_error_405
-
-            """
-            Some servers (e.g. FusionForge) returns 406 Not Acceptable when they
-            actually mean 405 Method Not Allowed.
-            """
-            http_error_406 = http_error_405
-
-        class FixedHTTPRedirectHandler(urllib.request.HTTPRedirectHandler):
-            """
-            urllib2.HTTPRedirectHandler resets the method to GET on redirect,
-            when we want to follow redirects using the original method.
-            """
-            def redirect_request(self, req, fp, code, msg, headers, newurl):
-                newreq = urllib.request.HTTPRedirectHandler.redirect_request(self, req, fp, code, msg, headers, newurl)
-                newreq.get_method = lambda: req.get_method()
-                return newreq
-        exported_proxies = export_proxies(d)
-
-        handlers = [FixedHTTPRedirectHandler, HTTPMethodFallback]
-        if export_proxies:
-            handlers.append(urllib.request.ProxyHandler())
-        handlers.append(CacheHTTPHandler())
-        # XXX: Since Python 2.7.9 ssl cert validation is enabled by default
-        # see PEP-0476, this causes verification errors on some https servers
-        # so disable by default.
-        import ssl
-        if hasattr(ssl, '_create_unverified_context'):
-            handlers.append(urllib.request.HTTPSHandler(context=ssl._create_unverified_context()))
-        opener = urllib.request.build_opener(*handlers)
-
-        try:
-            uri = ud.url.split(";")[0]
-            r = urllib.request.Request(uri)
-            r.get_method = lambda: "HEAD"
-
-            def add_basic_auth(login_str, request):
-                '''Adds Basic auth to http request, pass in login:password as string'''
-                import base64
-                encodeuser = base64.b64encode(login_str.encode('utf-8')).decode("utf-8")
-                authheader =  "Basic %s" % encodeuser
-                r.add_header("Authorization", authheader)
-
-            if ud.user:
-                add_basic_auth(ud.user, r)
-
-            try:
-                import netrc, urllib.parse
-                n = netrc.netrc()
-                login, unused, password = n.authenticators(urllib.parse.urlparse(uri).hostname)
-                add_basic_auth("%s:%s" % (login, password), r)
-            except (TypeError, ImportError, IOError, netrc.NetrcParseError):
-                 pass
-
-            opener.open(r)
-        except urllib.error.URLError as e:
-            if try_again:
-                logger.debug(2, "checkstatus: trying again")
-                return self.checkstatus(fetch, ud, d, False)
-            else:
-                # debug for now to avoid spamming the logs in e.g. remote sstate searches
-                logger.debug(2, "checkstatus() urlopen failed: %s" % e)
-                return False
         return True
-
-    def _parse_path(self, regex, s):
-        """
-        Find and group name, version and archive type in the given string s
-        """
-
-        m = regex.search(s)
-        if m:
-            pname = ''
-            pver = ''
-            ptype = ''
-
-            mdict = m.groupdict()
-            if 'name' in mdict.keys():
-                pname = mdict['name']
-            if 'pver' in mdict.keys():
-                pver = mdict['pver']
-            if 'type' in mdict.keys():
-                ptype = mdict['type']
-
-            bb.debug(3, "_parse_path: %s, %s, %s" % (pname, pver, ptype))
-
-            return (pname, pver, ptype)
-
-        return None
-
-    def _modelate_version(self, version):
-        if version[0] in ['.', '-']:
-            if version[1].isdigit():
-                version = version[1] + version[0] + version[2:len(version)]
-            else:
-                version = version[1:len(version)]
-
-        version = re.sub('-', '.', version)
-        version = re.sub('_', '.', version)
-        version = re.sub('(rc)+', '.1000.', version)
-        version = re.sub('(beta)+', '.100.', version)
-        version = re.sub('(alpha)+', '.10.', version)
-        if version[0] == 'v':
-            version = version[1:len(version)]
-        return version
-
-    def _vercmp(self, old, new):
-        """
-        Check whether 'new' is newer than 'old' version. We use existing vercmp() for the
-        purpose. PE is cleared in comparison as it's not for build, and PR is cleared too
-        for simplicity as it's somehow difficult to get from various upstream format
-        """
-
-        (oldpn, oldpv, oldsuffix) = old
-        (newpn, newpv, newsuffix) = new
-
-        """
-        Check for a new suffix type that we have never heard of before
-        """
-        if (newsuffix):
-            m = self.suffix_regex_comp.search(newsuffix)
-            if not m:
-                bb.warn("%s has a possible unknown suffix: %s" % (newpn, newsuffix))
-                return False
-
-        """
-        Not our package so ignore it
-        """
-        if oldpn != newpn:
-            return False
-
-        oldpv = self._modelate_version(oldpv)
-        newpv = self._modelate_version(newpv)
-
-        return bb.utils.vercmp(("0", oldpv, ""), ("0", newpv, ""))
-
-    def _fetch_index(self, uri, ud, d):
-        """
-        Run fetch checkstatus to get directory information
-        """
-        f = tempfile.NamedTemporaryFile()
-
-        agent = "Mozilla/5.0 (X11; U; Linux i686; en-US; rv:1.9.2.12) Gecko/20101027 Ubuntu/9.10 (karmic) Firefox/3.6.12"
-        fetchcmd = self.basecmd
-        fetchcmd += " -O " + f.name + " --user-agent='" + agent + "' '" + uri + "'"
-        try:
-            self._runwget(ud, d, fetchcmd, True)
-            fetchresult = f.read()
-        except bb.fetch2.BBFetchException:
-            fetchresult = ""
-
-        f.close()
-        return fetchresult
-
-    def _check_latest_version(self, url, package, package_regex, current_version, ud, d):
-        """
-        Return the latest version of a package inside a given directory path
-        If error or no version, return ""
-        """
-        valid = 0
-        version = ['', '', '']
-
-        bb.debug(3, "VersionURL: %s" % (url))
-        soup = BeautifulSoup(self._fetch_index(url, ud, d), "html.parser", parse_only=SoupStrainer("a"))
-        if not soup:
-            bb.debug(3, "*** %s NO SOUP" % (url))
-            return ""
-
-        for line in soup.find_all('a', href=True):
-            bb.debug(3, "line['href'] = '%s'" % (line['href']))
-            bb.debug(3, "line = '%s'" % (str(line)))
-
-            newver = self._parse_path(package_regex, line['href'])
-            if not newver:
-                newver = self._parse_path(package_regex, str(line))
-
-            if newver:
-                bb.debug(3, "Upstream version found: %s" % newver[1])
-                if valid == 0:
-                    version = newver
-                    valid = 1
-                elif self._vercmp(version, newver) < 0:
-                    version = newver
-                
-        pupver = re.sub('_', '.', version[1])
-
-        bb.debug(3, "*** %s -> UpstreamVersion = %s (CurrentVersion = %s)" %
-                (package, pupver or "N/A", current_version[1]))
-
-        if valid:
-            return pupver
-
-        return ""
-
-    def _check_latest_version_by_dir(self, dirver, package, package_regex,
-            current_version, ud, d):
-        """
-            Scan every directory in order to get upstream version.
-        """
-        version_dir = ['', '', '']
-        version = ['', '', '']
-
-        dirver_regex = re.compile("(?P<pfx>\D*)(?P<ver>(\d+[\.\-_])+(\d+))")
-        s = dirver_regex.search(dirver)
-        if s:
-            version_dir[1] = s.group('ver')
-        else:
-            version_dir[1] = dirver
-
-        dirs_uri = bb.fetch.encodeurl([ud.type, ud.host,
-                ud.path.split(dirver)[0], ud.user, ud.pswd, {}])
-        bb.debug(3, "DirURL: %s, %s" % (dirs_uri, package))
-
-        soup = BeautifulSoup(self._fetch_index(dirs_uri, ud, d), "html.parser", parse_only=SoupStrainer("a"))
-        if not soup:
-            return version[1]
-
-        for line in soup.find_all('a', href=True):
-            s = dirver_regex.search(line['href'].strip("/"))
-            if s:
-                sver = s.group('ver')
-
-                # When prefix is part of the version directory it need to
-                # ensure that only version directory is used so remove previous
-                # directories if exists.
-                #
-                # Example: pfx = '/dir1/dir2/v' and version = '2.5' the expected
-                # result is v2.5.
-                spfx = s.group('pfx').split('/')[-1]
-
-                version_dir_new = ['', sver, '']
-                if self._vercmp(version_dir, version_dir_new) <= 0:
-                    dirver_new = spfx + sver
-                    path = ud.path.replace(dirver, dirver_new, True) \
-                        .split(package)[0]
-                    uri = bb.fetch.encodeurl([ud.type, ud.host, path,
-                        ud.user, ud.pswd, {}])
-
-                    pupver = self._check_latest_version(uri,
-                            package, package_regex, current_version, ud, d)
-                    if pupver:
-                        version[1] = pupver
-
-                    version_dir = version_dir_new
-
-        return version[1]
-
-    def _init_regexes(self, package, ud, d):
-        """
-        Match as many patterns as possible such as:
-                gnome-common-2.20.0.tar.gz (most common format)
-                gtk+-2.90.1.tar.gz
-                xf86-input-synaptics-12.6.9.tar.gz
-                dri2proto-2.3.tar.gz
-                blktool_4.orig.tar.gz
-                libid3tag-0.15.1b.tar.gz
-                unzip552.tar.gz
-                icu4c-3_6-src.tgz
-                genext2fs_1.3.orig.tar.gz
-                gst-fluendo-mp3
-        """
-        # match most patterns which uses "-" as separator to version digits
-        pn_prefix1 = "[a-zA-Z][a-zA-Z0-9]*([-_][a-zA-Z]\w+)*\+?[-_]"
-        # a loose pattern such as for unzip552.tar.gz
-        pn_prefix2 = "[a-zA-Z]+"
-        # a loose pattern such as for 80325-quicky-0.4.tar.gz
-        pn_prefix3 = "[0-9]+[-]?[a-zA-Z]+"
-        # Save the Package Name (pn) Regex for use later
-        pn_regex = "(%s|%s|%s)" % (pn_prefix1, pn_prefix2, pn_prefix3)
-
-        # match version
-        pver_regex = "(([A-Z]*\d+[a-zA-Z]*[\.\-_]*)+)"
-
-        # match arch
-        parch_regex = "-source|_all_"
-
-        # src.rpm extension was added only for rpm package. Can be removed if the rpm
-        # packaged will always be considered as having to be manually upgraded
-        psuffix_regex = "(tar\.gz|tgz|tar\.bz2|zip|xz|tar\.lz|rpm|bz2|orig\.tar\.gz|tar\.xz|src\.tar\.gz|src\.tgz|svnr\d+\.tar\.bz2|stable\.tar\.gz|src\.rpm)"
-
-        # match name, version and archive type of a package
-        package_regex_comp = re.compile("(?P<name>%s?\.?v?)(?P<pver>%s)(?P<arch>%s)?[\.-](?P<type>%s$)"
-                                                    % (pn_regex, pver_regex, parch_regex, psuffix_regex))
-        self.suffix_regex_comp = re.compile(psuffix_regex)
-
-        # compile regex, can be specific by package or generic regex
-        pn_regex = d.getVar('UPSTREAM_CHECK_REGEX')
-        if pn_regex:
-            package_custom_regex_comp = re.compile(pn_regex)
-        else:
-            version = self._parse_path(package_regex_comp, package)
-            if version:
-                package_custom_regex_comp = re.compile(
-                    "(?P<name>%s)(?P<pver>%s)(?P<arch>%s)?[\.-](?P<type>%s)" %
-                    (re.escape(version[0]), pver_regex, parch_regex, psuffix_regex))
-            else:
-                package_custom_regex_comp = None
-
-        return package_custom_regex_comp
-
-    def latest_versionstring(self, ud, d):
-        """
-        Manipulate the URL and try to obtain the latest package version
-
-        sanity check to ensure same name and type.
-        """
-        package = ud.path.split("/")[-1]
-        current_version = ['', d.getVar('PV'), '']
-
-        """possible to have no version in pkg name, such as spectrum-fw"""
-        if not re.search("\d+", package):
-            current_version[1] = re.sub('_', '.', current_version[1])
-            current_version[1] = re.sub('-', '.', current_version[1])
-            return (current_version[1], '')
-
-        package_regex = self._init_regexes(package, ud, d)
-        if package_regex is None:
-            bb.warn("latest_versionstring: package %s don't match pattern" % (package))
-            return ('', '')
-        bb.debug(3, "latest_versionstring, regex: %s" % (package_regex.pattern))
-
-        uri = ""
-        regex_uri = d.getVar("UPSTREAM_CHECK_URI")
-        if not regex_uri:
-            path = ud.path.split(package)[0]
-
-            # search for version matches on folders inside the path, like:
-            # "5.7" in http://download.gnome.org/sources/${PN}/5.7/${PN}-${PV}.tar.gz
-            dirver_regex = re.compile("(?P<dirver>[^/]*(\d+\.)*\d+([-_]r\d+)*)/")
-            m = dirver_regex.search(path)
-            if m:
-                pn = d.getVar('PN')
-                dirver = m.group('dirver')
-
-                dirver_pn_regex = re.compile("%s\d?" % (re.escape(pn)))
-                if not dirver_pn_regex.search(dirver):
-                    return (self._check_latest_version_by_dir(dirver,
-                        package, package_regex, current_version, ud, d), '')
-
-            uri = bb.fetch.encodeurl([ud.type, ud.host, path, ud.user, ud.pswd, {}])
-        else:
-            uri = regex_uri
-
-        return (self._check_latest_version(uri, package, package_regex,
-                current_version, ud, d), '')

bitbake/lib/bb/main.py

@@ -1,552 +0,0 @@
-#!/usr/bin/env python
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-#
-# Copyright (C) 2003, 2004  Chris Larson
-# Copyright (C) 2003, 2004  Phil Blundell
-# Copyright (C) 2003 - 2005 Michael 'Mickey' Lauer
-# Copyright (C) 2005        Holger Hans Peter Freyther
-# Copyright (C) 2005        ROAD GmbH
-# Copyright (C) 2006        Richard Purdie
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 2 as
-# published by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-import os
-import sys
-import logging
-import optparse
-import warnings
-import fcntl
-
-import bb
-from bb import event
-import bb.msg
-from bb import cooker
-from bb import ui
-from bb import server
-from bb import cookerdata
-
-logger = logging.getLogger("BitBake")
-
-class BBMainException(Exception):
-    pass
-
-def present_options(optionlist):
-    if len(optionlist) > 1:
-        return ' or '.join([', '.join(optionlist[:-1]), optionlist[-1]])
-    else:
-        return optionlist[0]
-
-class BitbakeHelpFormatter(optparse.IndentedHelpFormatter):
-    def format_option(self, option):
-        # We need to do this here rather than in the text we supply to
-        # add_option() because we don't want to call list_extension_modules()
-        # on every execution (since it imports all of the modules)
-        # Note also that we modify option.help rather than the returned text
-        # - this is so that we don't have to re-format the text ourselves
-        if option.dest == 'ui':
-            valid_uis = list_extension_modules(bb.ui, 'main')
-            option.help = option.help.replace('@CHOICES@', present_options(valid_uis))
-        elif option.dest == 'servertype':
-            valid_server_types = list_extension_modules(bb.server, 'BitBakeServer')
-            option.help = option.help.replace('@CHOICES@', present_options(valid_server_types))
-
-        return optparse.IndentedHelpFormatter.format_option(self, option)
-
-def list_extension_modules(pkg, checkattr):
-    """
-    Lists extension modules in a specific Python package
-    (e.g. UIs, servers). NOTE: Calling this function will import all of the
-    submodules of the specified module in order to check for the specified
-    attribute; this can have unusual side-effects. As a result, this should
-    only be called when displaying help text or error messages.
-    Parameters:
-        pkg: previously imported Python package to list
-        checkattr: attribute to look for in module to determine if it's valid
-            as the type of extension you are looking for
-    """
-    import pkgutil
-    pkgdir = os.path.dirname(pkg.__file__)
-
-    modules = []
-    for _, modulename, _ in pkgutil.iter_modules([pkgdir]):
-        if os.path.isdir(os.path.join(pkgdir, modulename)):
-            # ignore directories
-            continue
-        try:
-            module = __import__(pkg.__name__, fromlist=[modulename])
-        except:
-            # If we can't import it, it's not valid
-            continue
-        module_if = getattr(module, modulename)
-        if getattr(module_if, 'hidden_extension', False):
-            continue
-        if not checkattr or hasattr(module_if, checkattr):
-            modules.append(modulename)
-    return modules
-
-def import_extension_module(pkg, modulename, checkattr):
-    try:
-        # Dynamically load the UI based on the ui name. Although we
-        # suggest a fixed set this allows you to have flexibility in which
-        # ones are available.
-        module = __import__(pkg.__name__, fromlist=[modulename])
-        return getattr(module, modulename)
-    except AttributeError:
-        modules = present_options(list_extension_modules(pkg, checkattr))
-        raise BBMainException('FATAL: Unable to import extension module "%s" from %s. '
-                              'Valid extension modules: %s' % (modulename, pkg.__name__, modules))
-
-# Display bitbake/OE warnings via the BitBake.Warnings logger, ignoring others"""
-warnlog = logging.getLogger("BitBake.Warnings")
-_warnings_showwarning = warnings.showwarning
-def _showwarning(message, category, filename, lineno, file=None, line=None):
-    if file is not None:
-        if _warnings_showwarning is not None:
-            _warnings_showwarning(message, category, filename, lineno, file, line)
-    else:
-        s = warnings.formatwarning(message, category, filename, lineno)
-        warnlog.warning(s)
-
-warnings.showwarning = _showwarning
-warnings.filterwarnings("ignore")
-warnings.filterwarnings("default", module="(<string>$|(oe|bb)\.)")
-warnings.filterwarnings("ignore", category=PendingDeprecationWarning)
-warnings.filterwarnings("ignore", category=ImportWarning)
-warnings.filterwarnings("ignore", category=DeprecationWarning, module="<string>$")
-warnings.filterwarnings("ignore", message="With-statements now directly support multiple context managers")
-
-class BitBakeConfigParameters(cookerdata.ConfigParameters):
-
-    def parseCommandLine(self, argv=sys.argv):
-        parser = optparse.OptionParser(
-            formatter=BitbakeHelpFormatter(),
-            version="BitBake Build Tool Core version %s" % bb.__version__,
-            usage="""%prog [options] [recipename/target recipe:do_task ...]
-
-    Executes the specified task (default is 'build') for a given set of target recipes (.bb files).
-    It is assumed there is a conf/bblayers.conf available in cwd or in BBPATH which
-    will provide the layer, BBFILES and other configuration information.""")
-
-        parser.add_option("-b", "--buildfile", action="store", dest="buildfile", default=None,
-                          help="Execute tasks from a specific .bb recipe directly. WARNING: Does "
-                               "not handle any dependencies from other recipes.")
-
-        parser.add_option("-k", "--continue", action="store_false", dest="abort", default=True,
-                          help="Continue as much as possible after an error. While the target that "
-                               "failed and anything depending on it cannot be built, as much as "
-                               "possible will be built before stopping.")
-
-        parser.add_option("-a", "--tryaltconfigs", action="store_true",
-                          dest="tryaltconfigs", default=False,
-                          help="Continue with builds by trying to use alternative providers "
-                               "where possible.")
-
-        parser.add_option("-f", "--force", action="store_true", dest="force", default=False,
-                          help="Force the specified targets/task to run (invalidating any "
-                               "existing stamp file).")
-
-        parser.add_option("-c", "--cmd", action="store", dest="cmd",
-                          help="Specify the task to execute. The exact options available "
-                               "depend on the metadata. Some examples might be 'compile'"
-                               " or 'populate_sysroot' or 'listtasks' may give a list of "
-                               "the tasks available.")
-
-        parser.add_option("-C", "--clear-stamp", action="store", dest="invalidate_stamp",
-                          help="Invalidate the stamp for the specified task such as 'compile' "
-                               "and then run the default task for the specified target(s).")
-
-        parser.add_option("-r", "--read", action="append", dest="prefile", default=[],
-                          help="Read the specified file before bitbake.conf.")
-
-        parser.add_option("-R", "--postread", action="append", dest="postfile", default=[],
-                          help="Read the specified file after bitbake.conf.")
-
-        parser.add_option("-v", "--verbose", action="store_true", dest="verbose", default=False,
-                          help="Enable tracing of shell tasks (with 'set -x'). "
-                               "Also print bb.note(...) messages to stdout (in "
-                               "addition to writing them to ${T}/log.do_<task>).")
-
-        parser.add_option("-D", "--debug", action="count", dest="debug", default=0,
-                          help="Increase the debug level. You can specify this "
-                               "more than once. -D sets the debug level to 1, "
-                               "where only bb.debug(1, ...) messages are printed "
-                               "to stdout; -DD sets the debug level to 2, where "
-                               "both bb.debug(1, ...) and bb.debug(2, ...) "
-                               "messages are printed; etc. Without -D, no debug "
-                               "messages are printed. Note that -D only affects "
-                               "output to stdout. All debug messages are written "
-                               "to ${T}/log.do_taskname, regardless of the debug "
-                               "level.")
-
-        parser.add_option("-q", "--quiet", action="count", dest="quiet", default=0,
-                          help="Output less log message data to the terminal. You can specify this more than once.")
-
-        parser.add_option("-n", "--dry-run", action="store_true", dest="dry_run", default=False,
-                          help="Don't execute, just go through the motions.")
-
-        parser.add_option("-S", "--dump-signatures", action="append", dest="dump_signatures",
-                          default=[], metavar="SIGNATURE_HANDLER",
-                          help="Dump out the signature construction information, with no task "
-                               "execution. The SIGNATURE_HANDLER parameter is passed to the "
-                               "handler. Two common values are none and printdiff but the handler "
-                               "may define more/less. none means only dump the signature, printdiff"
-                               " means compare the dumped signature with the cached one.")
-
-        parser.add_option("-p", "--parse-only", action="store_true",
-                          dest="parse_only", default=False,
-                          help="Quit after parsing the BB recipes.")
-
-        parser.add_option("-s", "--show-versions", action="store_true",
-                          dest="show_versions", default=False,
-                          help="Show current and preferred versions of all recipes.")
-
-        parser.add_option("-e", "--environment", action="store_true",
-                          dest="show_environment", default=False,
-                          help="Show the global or per-recipe environment complete with information"
-                               " about where variables were set/changed.")
-
-        parser.add_option("-g", "--graphviz", action="store_true", dest="dot_graph", default=False,
-                          help="Save dependency tree information for the specified "
-                               "targets in the dot syntax.")
-
-        parser.add_option("-I", "--ignore-deps", action="append",
-                          dest="extra_assume_provided", default=[],
-                          help="Assume these dependencies don't exist and are already provided "
-                               "(equivalent to ASSUME_PROVIDED). Useful to make dependency "
-                               "graphs more appealing")
-
-        parser.add_option("-l", "--log-domains", action="append", dest="debug_domains", default=[],
-                          help="Show debug logging for the specified logging domains")
-
-        parser.add_option("-P", "--profile", action="store_true", dest="profile", default=False,
-                          help="Profile the command and save reports.")
-
-        # @CHOICES@ is substituted out by BitbakeHelpFormatter above
-        parser.add_option("-u", "--ui", action="store", dest="ui",
-                          default=os.environ.get('BITBAKE_UI', 'knotty'),
-                          help="The user interface to use (@CHOICES@ - default %default).")
-
-        # @CHOICES@ is substituted out by BitbakeHelpFormatter above
-        parser.add_option("-t", "--servertype", action="store", dest="servertype",
-                          default=["process", "xmlrpc"]["BBSERVER" in os.environ],
-                          help="Choose which server type to use (@CHOICES@ - default %default).")
-
-        parser.add_option("", "--token", action="store", dest="xmlrpctoken",
-                          default=os.environ.get("BBTOKEN"),
-                          help="Specify the connection token to be used when connecting "
-                               "to a remote server.")
-
-        parser.add_option("", "--revisions-changed", action="store_true",
-                          dest="revisions_changed", default=False,
-                          help="Set the exit code depending on whether upstream floating "
-                               "revisions have changed or not.")
-
-        parser.add_option("", "--server-only", action="store_true",
-                          dest="server_only", default=False,
-                          help="Run bitbake without a UI, only starting a server "
-                               "(cooker) process.")
-
-        parser.add_option("", "--foreground", action="store_true",
-                          help="Run bitbake server in foreground.")
-
-        parser.add_option("-B", "--bind", action="store", dest="bind", default=False,
-                          help="The name/address for the bitbake server to bind to.")
-
-        parser.add_option("-T", "--idle-timeout", type=int,
-                          default=int(os.environ.get("BBTIMEOUT", "0")),
-                          help="Set timeout to unload bitbake server due to inactivity")
-
-        parser.add_option("", "--no-setscene", action="store_true",
-                          dest="nosetscene", default=False,
-                          help="Do not run any setscene tasks. sstate will be ignored and "
-                               "everything needed, built.")
-
-        parser.add_option("", "--setscene-only", action="store_true",
-                          dest="setsceneonly", default=False,
-                          help="Only run setscene tasks, don't run any real tasks.")
-
-        parser.add_option("", "--remote-server", action="store", dest="remote_server",
-                          default=os.environ.get("BBSERVER"),
-                          help="Connect to the specified server.")
-
-        parser.add_option("-m", "--kill-server", action="store_true",
-                          dest="kill_server", default=False,
-                          help="Terminate the remote server.")
-
-        parser.add_option("", "--observe-only", action="store_true",
-                          dest="observe_only", default=False,
-                          help="Connect to a server as an observing-only client.")
-
-        parser.add_option("", "--status-only", action="store_true",
-                          dest="status_only", default=False,
-                          help="Check the status of the remote bitbake server.")
-
-        parser.add_option("-w", "--write-log", action="store", dest="writeeventlog",
-                          default=os.environ.get("BBEVENTLOG"),
-                          help="Writes the event log of the build to a bitbake event json file. "
-                               "Use '' (empty string) to assign the name automatically.")
-
-        parser.add_option("", "--runall", action="store", dest="runall",
-                          help="Run the specified task for all build targets and their dependencies.")
-
-        options, targets = parser.parse_args(argv)
-
-        if options.quiet and options.verbose:
-            parser.error("options --quiet and --verbose are mutually exclusive")
-
-        if options.quiet and options.debug:
-            parser.error("options --quiet and --debug are mutually exclusive")
-
-        # use configuration files from environment variables
-        if "BBPRECONF" in os.environ:
-            options.prefile.append(os.environ["BBPRECONF"])
-
-        if "BBPOSTCONF" in os.environ:
-            options.postfile.append(os.environ["BBPOSTCONF"])
-
-        # fill in proper log name if not supplied
-        if options.writeeventlog is not None and len(options.writeeventlog) == 0:
-            from datetime import datetime
-            eventlog = "bitbake_eventlog_%s.json" % datetime.now().strftime("%Y%m%d%H%M%S")
-            options.writeeventlog = eventlog
-
-        # if BBSERVER says to autodetect, let's do that
-        if options.remote_server:
-            port = -1
-            if options.remote_server != 'autostart':
-                host, port = options.remote_server.split(":", 2)
-                port = int(port)
-            # use automatic port if port set to -1, means read it from
-            # the bitbake.lock file; this is a bit tricky, but we always expect
-            # to be in the base of the build directory if we need to have a
-            # chance to start the server later, anyway
-            if port == -1:
-                lock_location = "./bitbake.lock"
-                # we try to read the address at all times; if the server is not started,
-                # we'll try to start it after the first connect fails, below
-                try:
-                    lf = open(lock_location, 'r')
-                    remotedef = lf.readline()
-                    [host, port] = remotedef.split(":")
-                    port = int(port)
-                    lf.close()
-                    options.remote_server = remotedef
-                except Exception as e:
-                    if options.remote_server != 'autostart':
-                        raise BBMainException("Failed to read bitbake.lock (%s), invalid port" % str(e))
-
-        return options, targets[1:]
-
-
-def start_server(servermodule, configParams, configuration, features):
-    server = servermodule.BitBakeServer()
-    single_use = not configParams.server_only and os.getenv('BBSERVER') != 'autostart'
-    if configParams.bind:
-        (host, port) = configParams.bind.split(':')
-        server.initServer((host, int(port)), single_use=single_use,
-                          idle_timeout=configParams.idle_timeout)
-        configuration.interface = [server.serverImpl.host, server.serverImpl.port]
-    else:
-        server.initServer(single_use=single_use)
-        configuration.interface = []
-
-    try:
-        configuration.setServerRegIdleCallback(server.getServerIdleCB())
-
-        cooker = bb.cooker.BBCooker(configuration, features)
-
-        server.addcooker(cooker)
-        server.saveConnectionDetails()
-    except Exception as e:
-        while hasattr(server, "event_queue"):
-            import queue
-            try:
-                event = server.event_queue.get(block=False)
-            except (queue.Empty, IOError):
-                break
-            if isinstance(event, logging.LogRecord):
-                logger.handle(event)
-        raise
-    if not configParams.foreground:
-        server.detach()
-        cooker.shutdown()
-    cooker.lock.close()
-    return server
-
-
-def bitbake_main(configParams, configuration):
-
-    # Python multiprocessing requires /dev/shm on Linux
-    if sys.platform.startswith('linux') and not os.access('/dev/shm', os.W_OK | os.X_OK):
-        raise BBMainException("FATAL: /dev/shm does not exist or is not writable")
-
-    # Unbuffer stdout to avoid log truncation in the event
-    # of an unorderly exit as well as to provide timely
-    # updates to log files for use with tail
-    try:
-        if sys.stdout.name == '<stdout>':
-            # Reopen with O_SYNC (unbuffered)
-            fl = fcntl.fcntl(sys.stdout.fileno(), fcntl.F_GETFL)
-            fl |= os.O_SYNC
-            fcntl.fcntl(sys.stdout.fileno(), fcntl.F_SETFL, fl)
-    except:
-        pass
-
-    configuration.setConfigParameters(configParams)
-
-    if configParams.server_only:
-        if configParams.servertype != "xmlrpc":
-            raise BBMainException("FATAL: If '--server-only' is defined, we must set the "
-                                  "servertype as 'xmlrpc'.\n")
-        if not configParams.bind:
-            raise BBMainException("FATAL: The '--server-only' option requires a name/address "
-                                  "to bind to with the -B option.\n")
-        else:
-            try:
-                #Checking that the port is a number
-                int(configParams.bind.split(":")[1])
-            except (ValueError,IndexError):
-                raise BBMainException(
-                        "FATAL: Malformed host:port bind parameter")
-        if configParams.remote_server:
-            raise BBMainException("FATAL: The '--server-only' option conflicts with %s.\n" %
-                                  ("the BBSERVER environment variable" if "BBSERVER" in os.environ \
-                                   else "the '--remote-server' option"))
-
-    elif configParams.foreground:
-        raise BBMainException("FATAL: The '--foreground' option can only be used "
-                              "with --server-only.\n")
-
-    if configParams.bind and configParams.servertype != "xmlrpc":
-        raise BBMainException("FATAL: If '-B' or '--bind' is defined, we must "
-                              "set the servertype as 'xmlrpc'.\n")
-
-    if configParams.remote_server and configParams.servertype != "xmlrpc":
-        raise BBMainException("FATAL: If '--remote-server' is defined, we must "
-                              "set the servertype as 'xmlrpc'.\n")
-
-    if configParams.observe_only and (not configParams.remote_server or configParams.bind):
-        raise BBMainException("FATAL: '--observe-only' can only be used by UI clients "
-                              "connecting to a server.\n")
-
-    if configParams.kill_server and not configParams.remote_server:
-        raise BBMainException("FATAL: '--kill-server' can only be used to "
-                              "terminate a remote server")
-
-    if "BBDEBUG" in os.environ:
-        level = int(os.environ["BBDEBUG"])
-        if level > configuration.debug:
-            configuration.debug = level
-
-    bb.msg.init_msgconfig(configParams.verbose, configuration.debug,
-                          configuration.debug_domains)
-
-    server, server_connection, ui_module = setup_bitbake(configParams, configuration)
-    if server_connection is None and configParams.kill_server:
-        return 0
-
-    if not configParams.server_only:
-        if configParams.status_only:
-            server_connection.terminate()
-            return 0
-
-        try:
-            return ui_module.main(server_connection.connection, server_connection.events,
-                                  configParams)
-        finally:
-            bb.event.ui_queue = []
-            server_connection.terminate()
-    else:
-        print("Bitbake server address: %s, server port: %s" % (server.serverImpl.host,
-                                                               server.serverImpl.port))
-        if configParams.foreground:
-            server.serverImpl.serve_forever()
-        return 0
-
-    return 1
-
-def setup_bitbake(configParams, configuration, extrafeatures=None):
-    # Ensure logging messages get sent to the UI as events
-    handler = bb.event.LogHandler()
-    if not configParams.status_only:
-        # In status only mode there are no logs and no UI
-        logger.addHandler(handler)
-
-    # Clear away any spurious environment variables while we stoke up the cooker
-    cleanedvars = bb.utils.clean_environment()
-
-    if configParams.server_only:
-        featureset = []
-        ui_module = None
-    else:
-        ui_module = import_extension_module(bb.ui, configParams.ui, 'main')
-        # Collect the feature set for the UI
-        featureset = getattr(ui_module, "featureSet", [])
-
-    if configParams.server_only:
-        for param in ('prefile', 'postfile'):
-            value = getattr(configParams, param)
-            if value:
-                setattr(configuration, "%s_server" % param, value)
-                param = "%s_server" % param
-
-    if extrafeatures:
-        for feature in extrafeatures:
-            if not feature in featureset:
-                featureset.append(feature)
-
-    servermodule = import_extension_module(bb.server,
-                                            configParams.servertype,
-                                            'BitBakeServer')
-    if configParams.remote_server:
-        if os.getenv('BBSERVER') == 'autostart':
-            if configParams.remote_server == 'autostart' or \
-               not servermodule.check_connection(configParams.remote_server, timeout=2):
-                configParams.bind = 'localhost:0'
-                srv = start_server(servermodule, configParams, configuration, featureset)
-                configParams.remote_server = '%s:%d' % tuple(configuration.interface)
-                bb.event.ui_queue = []
-        # we start a stub server that is actually a XMLRPClient that connects to a real server
-        from bb.server.xmlrpc import BitBakeXMLRPCClient
-        server = servermodule.BitBakeXMLRPCClient(configParams.observe_only,
-                                                  configParams.xmlrpctoken)
-        server.saveConnectionDetails(configParams.remote_server)
-    else:
-        # we start a server with a given configuration
-        server = start_server(servermodule, configParams, configuration, featureset)
-        bb.event.ui_queue = []
-
-    if configParams.server_only:
-        server_connection = None
-    else:
-        try:
-            server_connection = server.establishConnection(featureset)
-        except Exception as e:
-            bb.fatal("Could not connect to server %s: %s" % (configParams.remote_server, str(e)))
-
-        if configParams.kill_server:
-            server_connection.connection.terminateServer()
-            bb.event.ui_queue = []
-            return None, None, None
-
-        server_connection.setupEventQueue()
-
-        # Restore the environment in case the UI needs it
-        for k in cleanedvars:
-            os.environ[k] = cleanedvars[k]
-
-        logger.removeHandler(handler)
-
-    return server, server_connection, ui_module

bitbake/lib/bb/methodpool.py

@@ -19,22 +19,11 @@
 
 from bb.utils import better_compile, better_exec
 
-def insert_method(modulename, code, fn, lineno):
+def insert_method(modulename, code, fn):
     """
     Add code of a module should be added. The methods
     will be simply added, no checking will be done
     """
-    comp = better_compile(code, modulename, fn, lineno=lineno)
+    comp = better_compile(code, modulename, fn )
     better_exec(comp, None, code, fn)
 
-compilecache = {}
-
-def compile_cache(code):
-    h = hash(code)
-    if h in compilecache:
-        return compilecache[h]
-    return None
-
-def compile_cache_add(code, compileobj):
-    h = hash(code)
-    compilecache[h] = compileobj

bitbake/lib/bb/monitordisk.py

@@ -129,7 +129,7 @@ def getDiskData(BBDirs, configuration):
             bb.utils.mkdirhier(path)
         dev = getMountedDev(path)
         # Use path/action as the key
-        devDict[(path, action)] = [dev, minSpace, minInode]
+        devDict[os.path.join(path, action)] = [dev, minSpace, minInode]
 
     return devDict
 
@@ -141,7 +141,7 @@ def getInterval(configuration):
     spaceDefault = 50 * 1024 * 1024
     inodeDefault = 5 * 1024
 
-    interval = configuration.getVar("BB_DISKMON_WARNINTERVAL")
+    interval = configuration.getVar("BB_DISKMON_WARNINTERVAL", True)
     if not interval:
         return spaceDefault, inodeDefault
     else:
@@ -179,7 +179,7 @@ class diskMonitor:
         self.enableMonitor = False
         self.configuration = configuration
 
-        BBDirs = configuration.getVar("BB_DISKMON_DIRS") or None
+        BBDirs = configuration.getVar("BB_DISKMON_DIRS", True) or None
         if BBDirs:
             self.devDict = getDiskData(BBDirs, configuration)
             if self.devDict:
@@ -205,25 +205,22 @@ class diskMonitor:
         """ Take action for the monitor """
 
         if self.enableMonitor:
-            diskUsage = {}
-            for k, attributes in self.devDict.items():
-                path, action = k
-                dev, minSpace, minInode = attributes
+            for k in self.devDict:
+                path = os.path.dirname(k)
+                action = os.path.basename(k)
+                dev = self.devDict[k][0]
+                minSpace = self.devDict[k][1]
+                minInode = self.devDict[k][2]
 
                 st = os.statvfs(path)
 
-                # The available free space, integer number
+                # The free space, float point number
                 freeSpace = st.f_bavail * st.f_frsize
 
-                # Send all relevant information in the event.
-                freeSpaceRoot = st.f_bfree * st.f_frsize
-                totalSpace = st.f_blocks * st.f_frsize
-                diskUsage[dev] = bb.event.DiskUsageSample(freeSpace, freeSpaceRoot, totalSpace)
-
                 if minSpace and freeSpace < minSpace:
                     # Always show warning, the self.checked would always be False if the action is WARN
                     if self.preFreeS[k] == 0 or self.preFreeS[k] - freeSpace > self.spaceInterval and not self.checked[k]:
-                        logger.warning("The free space of %s (%s) is running low (%.3fGB left)" % \
+                        logger.warn("The free space of %s (%s) is running low (%.3fGB left)" % \
                                 (path, dev, freeSpace / 1024 / 1024 / 1024.0))
                         self.preFreeS[k] = freeSpace
 
@@ -238,7 +235,7 @@ class diskMonitor:
                         rq.finish_runqueue(True)
                         bb.event.fire(bb.event.DiskFull(dev, 'disk', freeSpace, path), self.configuration)
 
-                # The free inodes, integer number
+                # The free inodes, float point number
                 freeInode = st.f_favail
 
                 if minInode and freeInode < minInode:
@@ -249,7 +246,7 @@ class diskMonitor:
                         continue
                     # Always show warning, the self.checked would always be False if the action is WARN
                     if self.preFreeI[k] == 0 or self.preFreeI[k] - freeInode > self.inodeInterval and not self.checked[k]:
-                        logger.warning("The free inode of %s (%s) is running low (%.3fK left)" % \
+                        logger.warn("The free inode of %s (%s) is running low (%.3fK left)" % \
                                 (path, dev, freeInode / 1024.0))
                         self.preFreeI[k] = freeInode
 
@@ -263,6 +260,4 @@ class diskMonitor:
                         self.checked[k] = True
                         rq.finish_runqueue(True)
                         bb.event.fire(bb.event.DiskFull(dev, 'inode', freeInode, path), self.configuration)
-
-            bb.event.fire(bb.event.MonitorDiskEvent(diskUsage), self.configuration)
         return

bitbake/lib/bb/msg.py

@@ -57,7 +57,7 @@ class BBLogFormatter(logging.Formatter):
     }
 
     color_enabled = False
-    BASECOLOR, BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = list(range(29,38))
+    BASECOLOR, BLACK, RED, GREEN, YELLOW, BLUE, MAGENTA, CYAN, WHITE = range(29,38)
 
     COLORS = {
         DEBUG3  : CYAN,
@@ -90,9 +90,8 @@ class BBLogFormatter(logging.Formatter):
             if self.color_enabled:
                 record = self.colorize(record)
             msg = logging.Formatter.format(self, record)
-        if hasattr(record, 'bb_exc_formatted'):
-            msg += '\n' + ''.join(record.bb_exc_formatted)
-        elif hasattr(record, 'bb_exc_info'):
+
+        if hasattr(record, 'bb_exc_info'):
             etype, value, tb = record.bb_exc_info
             formatted = bb.exceptions.format_exception(etype, value, tb, limit=5)
             msg += '\n' + ''.join(formatted)
@@ -151,7 +150,7 @@ loggerDefaultVerbose = False
 loggerVerboseLogs = False
 loggerDefaultDomains = []
 
-def init_msgconfig(verbose, debug, debug_domains=None):
+def init_msgconfig(verbose, debug, debug_domains = []):
     """
     Set default verbosity and debug levels config the logger
     """
@@ -159,10 +158,7 @@ def init_msgconfig(verbose, debug, debug_domains=None):
     bb.msg.loggerDefaultVerbose = verbose
     if verbose:
         bb.msg.loggerVerboseLogs = True
-    if debug_domains:
-        bb.msg.loggerDefaultDomains = debug_domains
-    else:
-        bb.msg.loggerDefaultDomains = []
+    bb.msg.loggerDefaultDomains = debug_domains
 
 def constructLogOptions():
     debug = loggerDefaultDebugLevel
@@ -182,12 +178,9 @@ def constructLogOptions():
         debug_domains["BitBake.%s" % domainarg] = logging.DEBUG - dlevel + 1
     return level, debug_domains
 
-def addDefaultlogFilter(handler, cls = BBLogFilter, forcelevel=None):
+def addDefaultlogFilter(handler, cls = BBLogFilter):
     level, debug_domains = constructLogOptions()
 
-    if forcelevel is not None:
-        level = forcelevel
-
     cls(handler, level, debug_domains)
 
 #
@@ -201,18 +194,3 @@ def fatal(msgdomain, msg):
         logger = logging.getLogger("BitBake")
     logger.critical(msg)
     sys.exit(1)
-
-def logger_create(name, output=sys.stderr, level=logging.INFO, preserve_handlers=False, color='auto'):
-    """Standalone logger creation function"""
-    logger = logging.getLogger(name)
-    console = logging.StreamHandler(output)
-    format = bb.msg.BBLogFormatter("%(levelname)s: %(message)s")
-    if color == 'always' or (color == 'auto' and output.isatty()):
-        format.enable_color()
-    console.setFormatter(format)
-    if preserve_handlers:
-        logger.addHandler(console)
-    else:
-        logger.handlers = [console]
-    logger.setLevel(level)
-    return logger

bitbake/lib/bb/parse/__init__.py

@@ -26,10 +26,9 @@ File parsers for the BitBake build tools.
 
 handlers = []
 
-import errno
-import logging
 import os
 import stat
+import logging
 import bb
 import bb.utils
 import bb.siggen
@@ -71,12 +70,7 @@ def cached_mtime_noerror(f):
     return __mtime_cache[f]
 
 def update_mtime(f):
-    try:
-        __mtime_cache[f] = os.stat(f)[stat.ST_MTIME]
-    except OSError:
-        if f in __mtime_cache:
-            del __mtime_cache[f]
-        return 0
+    __mtime_cache[f] = os.stat(f)[stat.ST_MTIME]
     return __mtime_cache[f]
 
 def update_cache(f):
@@ -87,7 +81,7 @@ def update_cache(f):
 def mark_dependency(d, f):
     if f.startswith('./'):
         f = "%s/%s" % (os.getcwd(), f[2:])
-    deps = (d.getVar('__depends', False) or [])
+    deps = (d.getVar('__depends') or [])
     s = (f, cached_mtime_noerror(f))
     if s not in deps:
         deps.append(s)
@@ -95,7 +89,7 @@ def mark_dependency(d, f):
 
 def check_dependency(d, f):
     s = (f, cached_mtime_noerror(f))
-    deps = (d.getVar('__depends', False) or [])
+    deps = (d.getVar('__depends') or [])
     return s in deps
    
 def supports(fn, data):
@@ -123,17 +117,17 @@ def init_parser(d):
 
 def resolve_file(fn, d):
     if not os.path.isabs(fn):
-        bbpath = d.getVar("BBPATH")
+        bbpath = d.getVar("BBPATH", True)
         newfn, attempts = bb.utils.which(bbpath, fn, history=True)
         for af in attempts:
             mark_dependency(d, af)
         if not newfn:
-            raise IOError(errno.ENOENT, "file %s not found in %s" % (fn, bbpath))
+            raise IOError("file %s not found in %s" % (fn, bbpath))
         fn = newfn
 
     mark_dependency(d, fn)
     if not os.path.isfile(fn):
-        raise IOError(errno.ENOENT, "file %s not found" % fn)
+        raise IOError("file %s not found" % fn)
 
     return fn
 
@@ -161,8 +155,8 @@ def vars_from_file(mypkg, d):
 def get_file_depends(d):
     '''Return the dependent files'''
     dep_files = []
-    depends = d.getVar('__base_depends', False) or []
-    depends = depends + (d.getVar('__depends', False) or [])
+    depends = d.getVar('__base_depends', True) or []
+    depends = depends + (d.getVar('__depends', True) or [])
     for (fn, _) in depends:
         dep_files.append(os.path.abspath(fn))
     return " ".join(dep_files)

bitbake/lib/bb/parse/ast.py

@@ -21,7 +21,8 @@
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
-
+from __future__ import absolute_import
+from future_builtins import filter
 import re
 import string
 import logging
@@ -30,6 +31,8 @@ import itertools
 from bb import methodpool
 from bb.parse import logger
 
+_bbversions_re = re.compile(r"\[(?P<from>[0-9]+)-(?P<to>[0-9]+)\]")
+
 class StatementGroup(list):
     def eval(self, data):
         for statement in self:
@@ -67,33 +70,6 @@ class ExportNode(AstNode):
     def eval(self, data):
         data.setVarFlag(self.var, "export", 1, op = 'exported')
 
-class UnsetNode(AstNode):
-    def __init__(self, filename, lineno, var):
-        AstNode.__init__(self, filename, lineno)
-        self.var = var
-
-    def eval(self, data):
-        loginfo = {
-            'variable': self.var,
-            'file': self.filename,
-            'line': self.lineno,
-        }
-        data.delVar(self.var,**loginfo)
-
-class UnsetFlagNode(AstNode):
-    def __init__(self, filename, lineno, var, flag):
-        AstNode.__init__(self, filename, lineno)
-        self.var = var
-        self.flag = flag
-
-    def eval(self, data):
-        loginfo = {
-            'variable': self.var,
-            'file': self.filename,
-            'line': self.lineno,
-        }
-        data.delVarFlag(self.var, self.flag, **loginfo)
-
 class DataNode(AstNode):
     """
     Various data related updates. For the sake of sanity
@@ -107,9 +83,9 @@ class DataNode(AstNode):
 
     def getFunc(self, key, data):
         if 'flag' in self.groupd and self.groupd['flag'] != None:
-            return data.getVarFlag(key, self.groupd['flag'], expand=False, noweakdefault=True)
+            return data.getVarFlag(key, self.groupd['flag'], noweakdefault=True)
         else:
-            return data.getVar(key, False, noweakdefault=True, parsing=True)
+            return data.getVar(key, noweakdefault=True)
 
     def eval(self, data):
         groupd = self.groupd
@@ -130,6 +106,7 @@ class DataNode(AstNode):
                 val = groupd["value"]
         elif "colon" in groupd and groupd["colon"] != None:
             e = data.createCopy()
+            bb.data.update_data(e)
             op = "immediate"
             val = e.expand(groupd["value"], key + "[:=]")
         elif "append" in groupd and groupd["append"] != None:
@@ -151,7 +128,7 @@ class DataNode(AstNode):
         if 'flag' in groupd and groupd['flag'] != None:
             flag = groupd['flag']
         elif groupd["lazyques"]:
-            flag = "_defaultval"
+            flag = "defaultval"
 
         loginfo['op'] = op
         loginfo['detail'] = groupd["value"]
@@ -159,42 +136,29 @@ class DataNode(AstNode):
         if flag:
             data.setVarFlag(key, flag, val, **loginfo)
         else:
-            data.setVar(key, val, parsing=True, **loginfo)
+            data.setVar(key, val, **loginfo)
 
 class MethodNode(AstNode):
-    tr_tbl = str.maketrans('/.+-@%&', '_______')
+    tr_tbl = string.maketrans('/.+-@%', '______')
 
-    def __init__(self, filename, lineno, func_name, body, python, fakeroot):
+    def __init__(self, filename, lineno, func_name, body):
         AstNode.__init__(self, filename, lineno)
         self.func_name = func_name
         self.body = body
-        self.python = python
-        self.fakeroot = fakeroot
 
     def eval(self, data):
         text = '\n'.join(self.body)
-        funcname = self.func_name
         if self.func_name == "__anonymous":
             funcname = ("__anon_%s_%s" % (self.lineno, self.filename.translate(MethodNode.tr_tbl)))
-            self.python = True
             text = "def %s(d):\n" % (funcname) + text
-            bb.methodpool.insert_method(funcname, text, self.filename, self.lineno - len(self.body))
-            anonfuncs = data.getVar('__BBANONFUNCS', False) or []
+            bb.methodpool.insert_method(funcname, text, self.filename)
+            anonfuncs = data.getVar('__BBANONFUNCS') or []
             anonfuncs.append(funcname)
             data.setVar('__BBANONFUNCS', anonfuncs)
-        if data.getVar(funcname, False):
-            # clean up old version of this piece of metadata, as its
-            # flags could cause problems
-            data.delVarFlag(funcname, 'python')
-            data.delVarFlag(funcname, 'fakeroot')
-        if self.python:
-            data.setVarFlag(funcname, "python", "1")
-        if self.fakeroot:
-            data.setVarFlag(funcname, "fakeroot", "1")
-        data.setVarFlag(funcname, "func", 1)
-        data.setVar(funcname, text, parsing=True)
-        data.setVarFlag(funcname, 'filename', self.filename)
-        data.setVarFlag(funcname, 'lineno', str(self.lineno - len(self.body)))
+            data.setVar(funcname, text)
+        else:
+            data.setVarFlag(self.func_name, "func", 1)
+            data.setVar(self.func_name, text)
 
 class PythonMethodNode(AstNode):
     def __init__(self, filename, lineno, function, modulename, body):
@@ -208,12 +172,31 @@ class PythonMethodNode(AstNode):
         # 'this' file. This means we will not parse methods from
         # bb classes twice
         text = '\n'.join(self.body)
-        bb.methodpool.insert_method(self.modulename, text, self.filename, self.lineno - len(self.body) - 1)
+        bb.methodpool.insert_method(self.modulename, text, self.filename)
         data.setVarFlag(self.function, "func", 1)
         data.setVarFlag(self.function, "python", 1)
-        data.setVar(self.function, text, parsing=True)
-        data.setVarFlag(self.function, 'filename', self.filename)
-        data.setVarFlag(self.function, 'lineno', str(self.lineno - len(self.body) - 1))
+        data.setVar(self.function, text)
+
+class MethodFlagsNode(AstNode):
+    def __init__(self, filename, lineno, key, m):
+        AstNode.__init__(self, filename, lineno)
+        self.key = key
+        self.m = m
+
+    def eval(self, data):
+        if data.getVar(self.key):
+            # clean up old version of this piece of metadata, as its
+            # flags could cause problems
+            data.setVarFlag(self.key, 'python', None)
+            data.setVarFlag(self.key, 'fakeroot', None)
+        if self.m.group("py") is not None:
+            data.setVarFlag(self.key, "python", "1")
+        else:
+            data.delVarFlag(self.key, "python")
+        if self.m.group("fr") is not None:
+            data.setVarFlag(self.key, "fakeroot", "1")
+        else:
+            data.delVarFlag(self.key, "fakeroot")
 
 class ExportFuncsNode(AstNode):
     def __init__(self, filename, lineno, fns, classname):
@@ -226,28 +209,26 @@ class ExportFuncsNode(AstNode):
         for func in self.n:
             calledfunc = self.classname + "_" + func
 
-            if data.getVar(func, False) and not data.getVarFlag(func, 'export_func', False):
+            if data.getVar(func) and not data.getVarFlag(func, 'export_func'):
                 continue
 
-            if data.getVar(func, False):
+            if data.getVar(func):
                 data.setVarFlag(func, 'python', None)
                 data.setVarFlag(func, 'func', None)
 
             for flag in [ "func", "python" ]:
-                if data.getVarFlag(calledfunc, flag, False):
-                    data.setVarFlag(func, flag, data.getVarFlag(calledfunc, flag, False))
+                if data.getVarFlag(calledfunc, flag):
+                    data.setVarFlag(func, flag, data.getVarFlag(calledfunc, flag))
             for flag in [ "dirs" ]:
-                if data.getVarFlag(func, flag, False):
-                    data.setVarFlag(calledfunc, flag, data.getVarFlag(func, flag, False))
-            data.setVarFlag(func, "filename", "autogenerated")
-            data.setVarFlag(func, "lineno", 1)
+                if data.getVarFlag(func, flag):
+                    data.setVarFlag(calledfunc, flag, data.getVarFlag(func, flag))
 
-            if data.getVarFlag(calledfunc, "python", False):
-                data.setVar(func, "    bb.build.exec_func('" + calledfunc + "', d)\n", parsing=True)
+            if data.getVarFlag(calledfunc, "python"):
+                data.setVar(func, "    bb.build.exec_func('" + calledfunc + "', d)\n")
             else:
                 if "-" in self.classname:
                    bb.fatal("The classname %s contains a dash character and is calling an sh function %s using EXPORT_FUNCTIONS. Since a dash is illegal in sh function names, this cannot work, please rename the class or don't use EXPORT_FUNCTIONS." % (self.classname, calledfunc))
-                data.setVar(func, "    " + calledfunc + "\n", parsing=True)
+                data.setVar(func, "    " + calledfunc + "\n")
             data.setVarFlag(func, 'export_func', '1')
 
 class AddTaskNode(AstNode):
@@ -274,7 +255,7 @@ class BBHandlerNode(AstNode):
         self.hs = fns.split()
 
     def eval(self, data):
-        bbhands = data.getVar('__BBHANDLERS', False) or []
+        bbhands = data.getVar('__BBHANDLERS') or []
         for h in self.hs:
             bbhands.append(h)
             data.setVarFlag(h, "handler", 1)
@@ -294,21 +275,18 @@ def handleInclude(statements, filename, lineno, m, force):
 def handleExport(statements, filename, lineno, m):
     statements.append(ExportNode(filename, lineno, m.group(1)))
 
-def handleUnset(statements, filename, lineno, m):
-    statements.append(UnsetNode(filename, lineno, m.group(1)))
-
-def handleUnsetFlag(statements, filename, lineno, m):
-    statements.append(UnsetFlagNode(filename, lineno, m.group(1), m.group(2)))
-
 def handleData(statements, filename, lineno, groupd):
     statements.append(DataNode(filename, lineno, groupd))
 
-def handleMethod(statements, filename, lineno, func_name, body, python, fakeroot):
-    statements.append(MethodNode(filename, lineno, func_name, body, python, fakeroot))
+def handleMethod(statements, filename, lineno, func_name, body):
+    statements.append(MethodNode(filename, lineno, func_name, body))
 
 def handlePythonMethod(statements, filename, lineno, funcname, modulename, body):
     statements.append(PythonMethodNode(filename, lineno, funcname, modulename, body))
 
+def handleMethodFlags(statements, filename, lineno, key, m):
+    statements.append(MethodFlagsNode(filename, lineno, key, m))
+
 def handleExportFuncs(statements, filename, lineno, m, classname):
     statements.append(ExportFuncsNode(filename, lineno, m.group(1), classname))
 
@@ -336,34 +314,30 @@ def handleInherit(statements, filename, lineno, m):
     statements.append(InheritNode(filename, lineno, classes))
 
 def finalize(fn, d, variant = None):
-    saved_handlers = bb.event.get_handlers().copy()
-
-    for var in d.getVar('__BBHANDLERS', False) or []:
+    all_handlers = {}
+    for var in d.getVar('__BBHANDLERS') or []:
         # try to add the handler
-        handlerfn = d.getVarFlag(var, "filename", False)
-        if not handlerfn:
-            bb.fatal("Undefined event handler function '%s'" % var)
-        handlerln = int(d.getVarFlag(var, "lineno", False))
-        bb.event.register(var, d.getVar(var, False), (d.getVarFlag(var, "eventmask") or "").split(), handlerfn, handlerln)
+        bb.event.register(var, d.getVar(var), (d.getVarFlag(var, "eventmask", True) or "").split())
 
     bb.event.fire(bb.event.RecipePreFinalise(fn), d)
 
     bb.data.expandKeys(d)
+    bb.data.update_data(d)
     code = []
-    for funcname in d.getVar("__BBANONFUNCS", False) or []:
+    for funcname in d.getVar("__BBANONFUNCS") or []:
         code.append("%s(d)" % funcname)
     bb.utils.better_exec("\n".join(code), {"d": d})
+    bb.data.update_data(d)
 
-    tasklist = d.getVar('__BBTASKS', False) or []
-    bb.event.fire(bb.event.RecipeTaskPreProcess(fn, list(tasklist)), d)
-    bb.build.add_tasks(tasklist, d)
+    tasklist = d.getVar('__BBTASKS') or []
+    deltasklist = d.getVar('__BBDELTASKS') or []
+    bb.build.add_tasks(tasklist, deltasklist, d)
 
     bb.parse.siggen.finalise(fn, d, variant)
 
     d.setVar('BBINCLUDED', bb.parse.get_file_depends(d))
 
     bb.event.fire(bb.event.RecipeParsed(fn), d)
-    bb.event.set_handlers(saved_handlers)
 
 def _create_variants(datastores, names, function, onlyfinalise):
     def create_variant(name, orig_d, arg = None):
@@ -373,16 +347,37 @@ def _create_variants(datastores, names, function, onlyfinalise):
         function(arg or name, new_d)
         datastores[name] = new_d
 
-    for variant in list(datastores.keys()):
+    for variant, variant_d in datastores.items():
         for name in names:
             if not variant:
                 # Based on main recipe
-                create_variant(name, datastores[""])
+                create_variant(name, variant_d)
             else:
-                create_variant("%s-%s" % (variant, name), datastores[variant], name)
+                create_variant("%s-%s" % (variant, name), variant_d, name)
+
+def _expand_versions(versions):
+    def expand_one(version, start, end):
+        for i in xrange(start, end + 1):
+            ver = _bbversions_re.sub(str(i), version, 1)
+            yield ver
+
+    versions = iter(versions)
+    while True:
+        try:
+            version = next(versions)
+        except StopIteration:
+            break
+
+        range_ver = _bbversions_re.search(version)
+        if not range_ver:
+            yield version
+        else:
+            newversions = expand_one(version, int(range_ver.group("from")),
+                                     int(range_ver.group("to")))
+            versions = itertools.chain(newversions, versions)
 
 def multi_finalize(fn, d):
-    appends = (d.getVar("__BBAPPEND") or "").split()
+    appends = (d.getVar("__BBAPPEND", True) or "").split()
     for append in appends:
         logger.debug(1, "Appending .bbappend file %s to %s", append, fn)
         bb.parse.BBHandler.handle(append, d, True)
@@ -397,7 +392,51 @@ def multi_finalize(fn, d):
         d.setVar("__SKIPPED", e.args[0])
     datastores = {"": safe_d}
 
-    extended = d.getVar("BBCLASSEXTEND") or ""
+    versions = (d.getVar("BBVERSIONS", True) or "").split()
+    if versions:
+        pv = orig_pv = d.getVar("PV", True)
+        baseversions = {}
+
+        def verfunc(ver, d, pv_d = None):
+            if pv_d is None:
+                pv_d = d
+
+            overrides = d.getVar("OVERRIDES", True).split(":")
+            pv_d.setVar("PV", ver)
+            overrides.append(ver)
+            bpv = baseversions.get(ver) or orig_pv
+            pv_d.setVar("BPV", bpv)
+            overrides.append(bpv)
+            d.setVar("OVERRIDES", ":".join(overrides))
+
+        versions = list(_expand_versions(versions))
+        for pos, version in enumerate(list(versions)):
+            try:
+                pv, bpv = version.split(":", 2)
+            except ValueError:
+                pass
+            else:
+                versions[pos] = pv
+                baseversions[pv] = bpv
+
+        if pv in versions and not baseversions.get(pv):
+            versions.remove(pv)
+        else:
+            pv = versions.pop()
+
+            # This is necessary because our existing main datastore
+            # has already been finalized with the old PV, we need one
+            # that's been finalized with the new PV.
+            d = bb.data.createCopy(safe_d)
+            verfunc(pv, d, safe_d)
+            try:
+                finalize(fn, d)
+            except bb.parse.SkipRecipe as e:
+                d.setVar("__SKIPPED", e.args[0])
+
+        _create_variants(datastores, versions, verfunc, onlyfinalise)
+
+    extended = d.getVar("BBCLASSEXTEND", True) or ""
     if extended:
         # the following is to support bbextends with arguments, for e.g. multilib
         # an example is as follows:
@@ -415,7 +454,7 @@ def multi_finalize(fn, d):
             else:
                 extendedmap[ext] = ext
 
-        pn = d.getVar("PN")
+        pn = d.getVar("PN", True)
         def extendfunc(name, d):
             if name != extendedmap[name]:
                 d.setVar("BBEXTENDCURR", extendedmap[name])
@@ -427,13 +466,17 @@ def multi_finalize(fn, d):
         safe_d.setVar("BBCLASSEXTEND", extended)
         _create_variants(datastores, extendedmap.keys(), extendfunc, onlyfinalise)
 
-    for variant in datastores.keys():
+    for variant, variant_d in datastores.iteritems():
         if variant:
             try:
                 if not onlyfinalise or variant in onlyfinalise:
-                    finalize(fn, datastores[variant], variant)
+                    finalize(fn, variant_d, variant)
             except bb.parse.SkipRecipe as e:
-                datastores[variant].setVar("__SKIPPED", e.args[0])
+                variant_d.setVar("__SKIPPED", e.args[0])
+
+    if len(datastores) > 1:
+        variants = filter(None, datastores.iterkeys())
+        safe_d.setVar("__VARIANTS", " ".join(variants))
 
     datastores[""] = d
     return datastores

bitbake/lib/bb/parse/parse_py/BBHandler.py

@@ -25,14 +25,14 @@
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
-
+from __future__ import absolute_import
 import re, bb, os
 import logging
 import bb.build, bb.utils
 from bb import data
 
 from . import ConfHandler
-from .. import resolve_file, ast, logger, ParseError
+from .. import resolve_file, ast, logger
 from .ConfHandler import include, init
 
 # For compatibility
@@ -47,26 +47,37 @@ __addhandler_regexp__    = re.compile( r"addhandler\s+(.+)" )
 __def_regexp__           = re.compile( r"def\s+(\w+).*:" )
 __python_func_regexp__   = re.compile( r"(\s+.*)|(^$)" )
 
-__infunc__ = []
+
+__infunc__ = ""
 __inpython__ = False
 __body__   = []
 __classname__ = ""
 
 cached_statements = {}
 
+# We need to indicate EOF to the feeder. This code is so messy that
+# factoring it out to a close_parse_file method is out of question.
+# We will use the IN_PYTHON_EOF as an indicator to just close the method
+#
+# The two parts using it are tightly integrated anyway
+IN_PYTHON_EOF = -9999999999999
+
+
+
 def supports(fn, d):
     """Return True if fn has a supported extension"""
     return os.path.splitext(fn)[-1] in [".bb", ".bbclass", ".inc"]
 
 def inherit(files, fn, lineno, d):
-    __inherit_cache = d.getVar('__inherit_cache', False) or []
+    __inherit_cache = d.getVar('__inherit_cache') or []
     files = d.expand(files).split()
     for file in files:
         if not os.path.isabs(file) and not file.endswith(".bbclass"):
             file = os.path.join('classes', '%s.bbclass' % file)
 
         if not os.path.isabs(file):
-            bbpath = d.getVar("BBPATH")
+            dname = os.path.dirname(fn)
+            bbpath = "%s:%s" % (dname, d.getVar("BBPATH", True))
             abs_fn, attempts = bb.utils.which(bbpath, file, history=True)
             for af in attempts:
                 if af != abs_fn:
@@ -79,7 +90,7 @@ def inherit(files, fn, lineno, d):
             __inherit_cache.append( file )
             d.setVar('__inherit_cache', __inherit_cache)
             include(fn, file, lineno, d, "inherit")
-            __inherit_cache = d.getVar('__inherit_cache', False) or []
+            __inherit_cache = d.getVar('__inherit_cache') or []
 
 def get_statements(filename, absolute_filename, base_name):
     global cached_statements
@@ -87,20 +98,20 @@ def get_statements(filename, absolute_filename, base_name):
     try:
         return cached_statements[absolute_filename]
     except KeyError:
-        with open(absolute_filename, 'r') as f:
-            statements = ast.StatementGroup()
-
-            lineno = 0
-            while True:
-                lineno = lineno + 1
-                s = f.readline()
-                if not s: break
-                s = s.rstrip()
-                feeder(lineno, s, filename, base_name, statements)
+        file = open(absolute_filename, 'r')
+        statements = ast.StatementGroup()
 
+        lineno = 0
+        while True:
+            lineno = lineno + 1
+            s = file.readline()
+            if not s: break
+            s = s.rstrip()
+            feeder(lineno, s, filename, base_name, statements)
+        file.close()
         if __inpython__:
             # add a blank line to close out any python definition
-            feeder(lineno, "", filename, base_name, statements, eof=True)
+            feeder(IN_PYTHON_EOF, "", filename, base_name, statements)
 
         if filename.endswith(".bbclass") or filename.endswith(".inc"):
             cached_statements[absolute_filename] = statements
@@ -109,7 +120,7 @@ def get_statements(filename, absolute_filename, base_name):
 def handle(fn, d, include):
     global __func_start_regexp__, __inherit_regexp__, __export_func_regexp__, __addtask_regexp__, __addhandler_regexp__, __infunc__, __body__, __residue__, __classname__
     __body__ = []
-    __infunc__ = []
+    __infunc__ = ""
     __classname__ = ""
     __residue__ = []
 
@@ -119,13 +130,13 @@ def handle(fn, d, include):
 
     if ext == ".bbclass":
         __classname__ = root
-        __inherit_cache = d.getVar('__inherit_cache', False) or []
+        __inherit_cache = d.getVar('__inherit_cache') or []
         if not fn in __inherit_cache:
             __inherit_cache.append(fn)
             d.setVar('__inherit_cache', __inherit_cache)
 
     if include != 0:
-        oldfile = d.getVar('FILE', False)
+        oldfile = d.getVar('FILE')
     else:
         oldfile = None
 
@@ -138,7 +149,7 @@ def handle(fn, d, include):
     statements = get_statements(fn, abs_fn, base_name)
 
     # DONE WITH PARSING... time to evaluate
-    if ext != ".bbclass" and abs_fn != oldfile:
+    if ext != ".bbclass":
         d.setVar('FILE', abs_fn)
 
     try:
@@ -148,26 +159,21 @@ def handle(fn, d, include):
         if include == 0:
             return { "" : d }
 
-    if __infunc__:
-        raise ParseError("Shell function %s is never closed" % __infunc__[0], __infunc__[1], __infunc__[2])
-    if __residue__:
-        raise ParseError("Leftover unparsed (incomplete?) data %s from %s" % __residue__, fn)
-
     if ext != ".bbclass" and include == 0:
         return ast.multi_finalize(fn, d)
 
-    if ext != ".bbclass" and oldfile and abs_fn != oldfile:
+    if oldfile:
         d.setVar("FILE", oldfile)
 
     return d
 
-def feeder(lineno, s, fn, root, statements, eof=False):
+def feeder(lineno, s, fn, root, statements):
     global __func_start_regexp__, __inherit_regexp__, __export_func_regexp__, __addtask_regexp__, __addhandler_regexp__, __def_regexp__, __python_func_regexp__, __inpython__, __infunc__, __body__, bb, __residue__, __classname__
     if __infunc__:
         if s == '}':
             __body__.append('')
-            ast.handleMethod(statements, fn, lineno, __infunc__[0], __body__, __infunc__[3], __infunc__[4])
-            __infunc__ = []
+            ast.handleMethod(statements, fn, lineno, __infunc__, __body__)
+            __infunc__ = ""
             __body__ = []
         else:
             __body__.append(s)
@@ -175,7 +181,7 @@ def feeder(lineno, s, fn, root, statements, eof=False):
 
     if __inpython__:
         m = __python_func_regexp__.match(s)
-        if m and not eof:
+        if m and lineno != IN_PYTHON_EOF:
             __body__.append(s)
             return
         else:
@@ -184,7 +190,7 @@ def feeder(lineno, s, fn, root, statements, eof=False):
             __body__ = []
             __inpython__ = False
 
-            if eof:
+            if lineno == IN_PYTHON_EOF:
                 return
 
     if s and s[0] == '#':
@@ -211,7 +217,8 @@ def feeder(lineno, s, fn, root, statements, eof=False):
 
     m = __func_start_regexp__.match(s)
     if m:
-        __infunc__ = [m.group("func") or "__anonymous", fn, lineno, m.group("py") is not None, m.group("fr") is not None]
+        __infunc__ = m.group("func") or "__anonymous"
+        ast.handleMethodFlags(statements, fn, lineno, __infunc__, m)
         return
 
     m = __def_regexp__.match(s)

bitbake/lib/bb/parse/parse_py/ConfHandler.py

@@ -24,16 +24,15 @@
 # with this program; if not, write to the Free Software Foundation, Inc.,
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
-import errno
-import re
-import os
+import re, os
+import logging
 import bb.utils
-from bb.parse import ParseError, resolve_file, ast, logger, handle
+from bb.parse import ParseError, resolve_file, ast, logger
 
 __config_regexp__  = re.compile( r"""
     ^
     (?P<exp>export\s*)?
-    (?P<var>[a-zA-Z0-9\-_+.${}/~]+?)
+    (?P<var>[a-zA-Z0-9\-~_+.${}/]+?)
     (\[(?P<flag>[a-zA-Z0-9\-_+.]+)\])?
 
     \s* (
@@ -56,12 +55,10 @@ __config_regexp__  = re.compile( r"""
     """, re.X)
 __include_regexp__ = re.compile( r"include\s+(.+)" )
 __require_regexp__ = re.compile( r"require\s+(.+)" )
-__export_regexp__ = re.compile( r"export\s+([a-zA-Z0-9\-_+.${}/~]+)$" )
-__unset_regexp__ = re.compile( r"unset\s+([a-zA-Z0-9\-_+.${}/~]+)$" )
-__unset_flag_regexp__ = re.compile( r"unset\s+([a-zA-Z0-9\-_+.${}/~]+)\[([a-zA-Z0-9\-_+.]+)\]$" )
+__export_regexp__ = re.compile( r"export\s+([a-zA-Z0-9\-_+.${}/]+)$" )
 
 def init(data):
-    topdir = data.getVar('TOPDIR', False)
+    topdir = data.getVar('TOPDIR')
     if not topdir:
         data.setVar('TOPDIR', os.getcwd())
 
@@ -69,43 +66,40 @@ def init(data):
 def supports(fn, d):
     return fn[-5:] == ".conf"
 
-def include(parentfn, fn, lineno, data, error_out):
+def include(oldfn, fn, lineno, data, error_out):
     """
     error_out: A string indicating the verb (e.g. "include", "inherit") to be
     used in a ParseError that will be raised if the file to be included could
     not be included. Specify False to avoid raising an error in this case.
     """
-    if parentfn == fn: # prevent infinite recursion
+    if oldfn == fn: # prevent infinite recursion
         return None
 
+    import bb
     fn = data.expand(fn)
-    parentfn = data.expand(parentfn)
+    oldfn = data.expand(oldfn)
 
     if not os.path.isabs(fn):
-        dname = os.path.dirname(parentfn)
-        bbpath = "%s:%s" % (dname, data.getVar("BBPATH"))
+        dname = os.path.dirname(oldfn)
+        bbpath = "%s:%s" % (dname, data.getVar("BBPATH", True))
         abs_fn, attempts = bb.utils.which(bbpath, fn, history=True)
         if abs_fn and bb.parse.check_dependency(data, abs_fn):
-            logger.warning("Duplicate inclusion for %s in %s" % (abs_fn, data.getVar('FILE')))
+            bb.warn("Duplicate inclusion for %s in %s" % (abs_fn, data.getVar('FILE', True)))
         for af in attempts:
             bb.parse.mark_dependency(data, af)
         if abs_fn:
             fn = abs_fn
     elif bb.parse.check_dependency(data, fn):
-        logger.warning("Duplicate inclusion for %s in %s" % (fn, data.getVar('FILE')))
+        bb.warn("Duplicate inclusion for %s in %s" % (fn, data.getVar('FILE', True)))
 
+    from bb.parse import handle
     try:
-        bb.parse.handle(fn, data, True)
-    except (IOError, OSError) as exc:
-        if exc.errno == errno.ENOENT:
-            if error_out:
-                raise ParseError("Could not %s file %s" % (error_out, fn), parentfn, lineno)
-            logger.debug(2, "CONF file '%s' not found", fn)
-        else:
-            if error_out:
-                raise ParseError("Could not %s file %s: %s" % (error_out, fn, exc.strerror), parentfn, lineno)
-            else:
-                raise ParseError("Error parsing %s: %s" % (fn, exc.strerror), parentfn, lineno)
+        ret = handle(fn, data, True)
+    except (IOError, OSError):
+        if error_out:
+            raise ParseError("Could not %(error_out)s file %(fn)s" % vars(), oldfn, lineno)
+        logger.debug(2, "CONF file '%s' not found", fn)
+        bb.parse.mark_dependency(data, fn)
 
 # We have an issue where a UI might want to enforce particular settings such as
 # an empty DISTRO variable. If configuration files do something like assigning
@@ -121,7 +115,7 @@ def handle(fn, data, include):
     if include == 0:
         oldfile = None
     else:
-        oldfile = data.getVar('FILE', False)
+        oldfile = data.getVar('FILE')
 
     abs_fn = resolve_file(fn, data)
     f = open(abs_fn, 'r')
@@ -187,16 +181,6 @@ def feeder(lineno, s, fn, statements):
         ast.handleExport(statements, fn, lineno, m)
         return
 
-    m = __unset_regexp__.match(s)
-    if m:
-        ast.handleUnset(statements, fn, lineno, m)
-        return
-
-    m = __unset_flag_regexp__.match(s)
-    if m:
-        ast.handleUnsetFlag(statements, fn, lineno, m)
-        return
-
     raise ParseError("unparsed line: '%s'" % s, fn, lineno);
 
 # Add us to the handlers list

bitbake/lib/bb/persist_data.py

@@ -28,7 +28,11 @@ import sys
 import warnings
 from bb.compat import total_ordering
 from collections import Mapping
-import sqlite3
+
+try:
+    import sqlite3
+except ImportError:
+    from pysqlite2 import dbapi2 as sqlite3
 
 sqlversion = sqlite3.sqlite_version_info
 if sqlversion[0] < 3 or (sqlversion[0] == 3 and sqlversion[1] < 3):
@@ -88,9 +92,9 @@ class SQLTable(collections.MutableMapping):
         self._execute("DELETE from %s where key=?;" % self.table, [key])
 
     def __setitem__(self, key, value):
-        if not isinstance(key, str):
+        if not isinstance(key, basestring):
             raise TypeError('Only string keys are supported')
-        elif not isinstance(value, str):
+        elif not isinstance(value, basestring):
             raise TypeError('Only string values are supported')
 
         data = self._execute("SELECT * from %s where key=?;" %
@@ -174,7 +178,7 @@ class PersistData(object):
         """
         Return a list of key + value pairs for a domain
         """
-        return list(self.data[domain].items())
+        return self.data[domain].items()
 
     def getValue(self, domain, key):
         """
@@ -197,14 +201,13 @@ class PersistData(object):
 def connect(database):
     connection = sqlite3.connect(database, timeout=5, isolation_level=None)
     connection.execute("pragma synchronous = off;")
-    connection.text_factory = str
     return connection
 
 def persist(domain, d):
     """Convenience factory for SQLTable objects based upon metadata"""
     import bb.utils
-    cachedir = (d.getVar("PERSISTENT_DIR") or
-                d.getVar("CACHE"))
+    cachedir = (d.getVar("PERSISTENT_DIR", True) or
+                d.getVar("CACHE", True))
     if not cachedir:
         logger.critical("Please set the 'PERSISTENT_DIR' or 'CACHE' variable")
         sys.exit(1)

bitbake/lib/bb/process.py

@@ -17,7 +17,7 @@ class CmdError(RuntimeError):
         self.msg = msg
 
     def __str__(self):
-        if not isinstance(self.command, str):
+        if not isinstance(self.command, basestring):
             cmd = subprocess.list2cmdline(self.command)
         else:
             cmd = self.command
@@ -64,7 +64,7 @@ class Popen(subprocess.Popen):
         options.update(kwargs)
         subprocess.Popen.__init__(self, *args, **options)
 
-def _logged_communicate(pipe, log, input, extrafiles):
+def _logged_communicate(pipe, log, input):
     if pipe.stdin:
         if input is not None:
             pipe.stdin.write(input)
@@ -79,26 +79,10 @@ def _logged_communicate(pipe, log, input, extrafiles):
     if pipe.stderr is not None:
         bb.utils.nonblockingfd(pipe.stderr.fileno())
         rin.append(pipe.stderr)
-    for fobj, _ in extrafiles:
-        bb.utils.nonblockingfd(fobj.fileno())
-        rin.append(fobj)
-
-    def readextras(selected):
-        for fobj, func in extrafiles:
-            if fobj in selected:
-                try:
-                    data = fobj.read()
-                except IOError as err:
-                    if err.errno == errno.EAGAIN or err.errno == errno.EWOULDBLOCK:
-                        data = None
-                if data is not None:
-                    func(data)
 
     try:
         while pipe.poll() is None:
             rlist = rin
-            stdoutbuf = b""
-            stderrbuf = b""
             try:
                 r,w,e = select.select (rlist, [], [], 1)
             except OSError as e:
@@ -106,48 +90,29 @@ def _logged_communicate(pipe, log, input, extrafiles):
                     raise
 
             if pipe.stdout in r:
-                data = stdoutbuf + pipe.stdout.read()
-                if data is not None and len(data) > 0:
-                    try:
-                        data = data.decode("utf-8")
-                        outdata.append(data)
-                        log.write(data)
-                        stdoutbuf = b""
-                    except UnicodeDecodeError:
-                        stdoutbuf = data
+                data = pipe.stdout.read()
+                if data is not None:
+                    outdata.append(data)
+                    log.write(data)
 
             if pipe.stderr in r:
-                data = stderrbuf + pipe.stderr.read()
-                if data is not None and len(data) > 0:
-                    try:
-                        data = data.decode("utf-8")
-                        errdata.append(data)
-                        log.write(data)
-                        stderrbuf = b""
-                    except UnicodeDecodeError:
-                        stderrbuf = data
-
-            readextras(r)
-
+                data = pipe.stderr.read()
+                if data is not None:
+                    errdata.append(data)
+                    log.write(data)
     finally:    
         log.flush()
-
-    readextras([fobj for fobj, _ in extrafiles])
-
     if pipe.stdout is not None:
         pipe.stdout.close()
     if pipe.stderr is not None:
         pipe.stderr.close()
     return ''.join(outdata), ''.join(errdata)
 
-def run(cmd, input=None, log=None, extrafiles=None, **options):
+def run(cmd, input=None, log=None, **options):
     """Convenience function to run a command and return its output, raising an
     exception when the command fails"""
 
-    if not extrafiles:
-        extrafiles = []
-
-    if isinstance(cmd, str) and not "shell" in options:
+    if isinstance(cmd, basestring) and not "shell" in options:
         options["shell"] = True
 
     try:
@@ -159,13 +124,9 @@ def run(cmd, input=None, log=None, extrafiles=None, **options):
             raise CmdError(cmd, exc)
 
     if log:
-        stdout, stderr = _logged_communicate(pipe, log, input, extrafiles)
+        stdout, stderr = _logged_communicate(pipe, log, input)
     else:
         stdout, stderr = pipe.communicate(input)
-        if not stdout is None:
-            stdout = stdout.decode("utf-8")
-        if not stderr is None:
-            stderr = stderr.decode("utf-8")
 
     if pipe.returncode != 0:
         raise ExecutionError(cmd, pipe.returncode, stdout, stderr)

bitbake/lib/bb/progress.py

@@ -1,276 +0,0 @@
-"""
-BitBake progress handling code
-"""
-
-# Copyright (C) 2016 Intel Corporation
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 2 as
-# published by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-import sys
-import re
-import time
-import inspect
-import bb.event
-import bb.build
-
-class ProgressHandler(object):
-    """
-    Base class that can pretend to be a file object well enough to be
-    used to build objects to intercept console output and determine the
-    progress of some operation.
-    """
-    def __init__(self, d, outfile=None):
-        self._progress = 0
-        self._data = d
-        self._lastevent = 0
-        if outfile:
-            self._outfile = outfile
-        else:
-            self._outfile = sys.stdout
-
-    def _fire_progress(self, taskprogress, rate=None):
-        """Internal function to fire the progress event"""
-        bb.event.fire(bb.build.TaskProgress(taskprogress, rate), self._data)
-
-    def write(self, string):
-        self._outfile.write(string)
-
-    def flush(self):
-        self._outfile.flush()
-
-    def update(self, progress, rate=None):
-        ts = time.time()
-        if progress > 100:
-            progress = 100
-        if progress != self._progress or self._lastevent + 1 < ts:
-            self._fire_progress(progress, rate)
-            self._lastevent = ts
-            self._progress = progress
-
-class LineFilterProgressHandler(ProgressHandler):
-    """
-    A ProgressHandler variant that provides the ability to filter out
-    the lines if they contain progress information. Additionally, it
-    filters out anything before the last line feed on a line. This can
-    be used to keep the logs clean of output that we've only enabled for
-    getting progress, assuming that that can be done on a per-line
-    basis.
-    """
-    def __init__(self, d, outfile=None):
-        self._linebuffer = ''
-        super(LineFilterProgressHandler, self).__init__(d, outfile)
-
-    def write(self, string):
-        self._linebuffer += string
-        while True:
-            breakpos = self._linebuffer.find('\n') + 1
-            if breakpos == 0:
-                break
-            line = self._linebuffer[:breakpos]
-            self._linebuffer = self._linebuffer[breakpos:]
-            # Drop any line feeds and anything that precedes them
-            lbreakpos = line.rfind('\r') + 1
-            if lbreakpos:
-                line = line[lbreakpos:]
-            if self.writeline(line):
-                super(LineFilterProgressHandler, self).write(line)
-
-    def writeline(self, line):
-        return True
-
-class BasicProgressHandler(ProgressHandler):
-    def __init__(self, d, regex=r'(\d+)%', outfile=None):
-        super(BasicProgressHandler, self).__init__(d, outfile)
-        self._regex = re.compile(regex)
-        # Send an initial progress event so the bar gets shown
-        self._fire_progress(0)
-
-    def write(self, string):
-        percs = self._regex.findall(string)
-        if percs:
-            progress = int(percs[-1])
-            self.update(progress)
-        super(BasicProgressHandler, self).write(string)
-
-class OutOfProgressHandler(ProgressHandler):
-    def __init__(self, d, regex, outfile=None):
-        super(OutOfProgressHandler, self).__init__(d, outfile)
-        self._regex = re.compile(regex)
-        # Send an initial progress event so the bar gets shown
-        self._fire_progress(0)
-
-    def write(self, string):
-        nums = self._regex.findall(string)
-        if nums:
-            progress = (float(nums[-1][0]) / float(nums[-1][1])) * 100
-            self.update(progress)
-        super(OutOfProgressHandler, self).write(string)
-
-class MultiStageProgressReporter(object):
-    """
-    Class which allows reporting progress without the caller
-    having to know where they are in the overall sequence. Useful
-    for tasks made up of python code spread across multiple
-    classes / functions - the progress reporter object can
-    be passed around or stored at the object level and calls
-    to next_stage() and update() made whereever needed.
-    """
-    def __init__(self, d, stage_weights, debug=False):
-        """
-        Initialise the progress reporter.
-
-        Parameters:
-        * d: the datastore (needed for firing the events)
-        * stage_weights: a list of weight values, one for each stage.
-          The value is scaled internally so you only need to specify
-          values relative to other values in the list, so if there
-          are two stages and the first takes 2s and the second takes
-          10s you would specify [2, 10] (or [1, 5], it doesn't matter).
-        * debug: specify True (and ensure you call finish() at the end)
-          in order to show a printout of the calculated stage weights
-          based on timing each stage. Use this to determine what the
-          weights should be when you're not sure.
-        """
-        self._data = d
-        total = sum(stage_weights)
-        self._stage_weights = [float(x)/total for x in stage_weights]
-        self._stage = -1
-        self._base_progress = 0
-        # Send an initial progress event so the bar gets shown
-        self._fire_progress(0)
-        self._debug = debug
-        self._finished = False
-        if self._debug:
-            self._last_time = time.time()
-            self._stage_times = []
-            self._stage_total = None
-            self._callers = []
-
-    def _fire_progress(self, taskprogress):
-        bb.event.fire(bb.build.TaskProgress(taskprogress), self._data)
-
-    def next_stage(self, stage_total=None):
-        """
-        Move to the next stage.
-        Parameters:
-        * stage_total: optional total for progress within the stage,
-          see update() for details
-        NOTE: you need to call this before the first stage.
-        """
-        self._stage += 1
-        self._stage_total = stage_total
-        if self._stage == 0:
-            # First stage
-            if self._debug:
-                self._last_time = time.time()
-        else:
-            if self._stage < len(self._stage_weights):
-                self._base_progress = sum(self._stage_weights[:self._stage]) * 100
-                if self._debug:
-                    currtime = time.time()
-                    self._stage_times.append(currtime - self._last_time)
-                    self._last_time = currtime
-                    self._callers.append(inspect.getouterframes(inspect.currentframe())[1])
-            elif not self._debug:
-                bb.warn('ProgressReporter: current stage beyond declared number of stages')
-                self._base_progress = 100
-            self._fire_progress(self._base_progress)
-
-    def update(self, stage_progress):
-        """
-        Update progress within the current stage.
-        Parameters:
-        * stage_progress: progress value within the stage. If stage_total
-          was specified when next_stage() was last called, then this
-          value is considered to be out of stage_total, otherwise it should
-          be a percentage value from 0 to 100.
-        """
-        if self._stage_total:
-            stage_progress = (float(stage_progress) / self._stage_total) * 100
-        if self._stage < 0:
-            bb.warn('ProgressReporter: update called before first call to next_stage()')
-        elif self._stage < len(self._stage_weights):
-            progress = self._base_progress + (stage_progress * self._stage_weights[self._stage])
-        else:
-            progress = self._base_progress
-        if progress > 100:
-            progress = 100
-        self._fire_progress(progress)
-
-    def finish(self):
-        if self._finished:
-            return
-        self._finished = True
-        if self._debug:
-            import math
-            self._stage_times.append(time.time() - self._last_time)
-            mintime = max(min(self._stage_times), 0.01)
-            self._callers.append(None)
-            stage_weights = [int(math.ceil(x / mintime)) for x in self._stage_times]
-            bb.warn('Stage weights: %s' % stage_weights)
-            out = []
-            for stage_weight, caller in zip(stage_weights, self._callers):
-                if caller:
-                    out.append('Up to %s:%d: %d' % (caller[1], caller[2], stage_weight))
-                else:
-                    out.append('Up to finish: %d' % stage_weight)
-            bb.warn('Stage times:\n  %s' % '\n  '.join(out))
-
-class MultiStageProcessProgressReporter(MultiStageProgressReporter):
-    """
-    Version of MultiStageProgressReporter intended for use with
-    standalone processes (such as preparing the runqueue)
-    """
-    def __init__(self, d, processname, stage_weights, debug=False):
-        self._processname = processname
-        self._started = False
-        MultiStageProgressReporter.__init__(self, d, stage_weights, debug)
-
-    def start(self):
-        if not self._started:
-            bb.event.fire(bb.event.ProcessStarted(self._processname, 100), self._data)
-            self._started = True
-
-    def _fire_progress(self, taskprogress):
-        if taskprogress == 0:
-            self.start()
-            return
-        bb.event.fire(bb.event.ProcessProgress(self._processname, taskprogress), self._data)
-
-    def finish(self):
-        MultiStageProgressReporter.finish(self)
-        bb.event.fire(bb.event.ProcessFinished(self._processname), self._data)
-
-class DummyMultiStageProcessProgressReporter(MultiStageProgressReporter):
-    """
-    MultiStageProcessProgressReporter that takes the calls and does nothing
-    with them (to avoid a bunch of "if progress_reporter:" checks)
-    """
-    def __init__(self):
-        MultiStageProcessProgressReporter.__init__(self, "", None, [])
-
-    def _fire_progress(self, taskprogress, rate=None):
-        pass
-
-    def start(self):
-        pass
-
-    def next_stage(self, stage_total=None):
-        pass
-
-    def update(self, stage_progress):
-        pass
-
-    def finish(self):
-        pass

bitbake/lib/bb/providers.py

@@ -48,6 +48,7 @@ def findProviders(cfgData, dataCache, pkg_pn = None):
 
     # Need to ensure data store is expanded
     localdata = data.createCopy(cfgData)
+    bb.data.update_data(localdata)
     bb.data.expandKeys(localdata)
 
     preferred_versions = {}
@@ -120,14 +121,11 @@ def findPreferredProvider(pn, cfgData, dataCache, pkg_pn = None, item = None):
     preferred_file = None
     preferred_ver = None
 
-    # pn can contain '_', e.g. gcc-cross-x86_64 and an override cannot
-    # hence we do this manually rather than use OVERRIDES
-    preferred_v = cfgData.getVar("PREFERRED_VERSION_pn-%s" % pn)
-    if not preferred_v:
-        preferred_v = cfgData.getVar("PREFERRED_VERSION_%s" % pn)
-    if not preferred_v:
-        preferred_v = cfgData.getVar("PREFERRED_VERSION")
+    localdata = data.createCopy(cfgData)
+    localdata.setVar('OVERRIDES', "%s:pn-%s:%s" % (data.getVar('OVERRIDES', localdata), pn, pn))
+    bb.data.update_data(localdata)
 
+    preferred_v = localdata.getVar('PREFERRED_VERSION', True)
     if preferred_v:
         m = re.match('(\d+:)*(.*)(_.*)*', preferred_v)
         if m:
@@ -225,7 +223,7 @@ def findBestProvider(pn, cfgData, dataCache, pkg_pn = None, item = None):
 def _filterProviders(providers, item, cfgData, dataCache):
     """
     Take a list of providers and filter/reorder according to the
-    environment variables
+    environment variables and previous build results
     """
     eligible = []
     preferred_versions = {}
@@ -244,7 +242,7 @@ def _filterProviders(providers, item, cfgData, dataCache):
             pkg_pn[pn] = []
         pkg_pn[pn].append(p)
 
-    logger.debug(1, "providers for %s are: %s", item, list(pkg_pn.keys()))
+    logger.debug(1, "providers for %s are: %s", item, pkg_pn.keys())
 
     # First add PREFERRED_VERSIONS
     for pn in pkg_pn:
@@ -282,13 +280,13 @@ def _filterProviders(providers, item, cfgData, dataCache):
 def filterProviders(providers, item, cfgData, dataCache):
     """
     Take a list of providers and filter/reorder according to the
-    environment variables
+    environment variables and previous build results
     Takes a "normal" target item
     """
 
     eligible = _filterProviders(providers, item, cfgData, dataCache)
 
-    prefervar = cfgData.getVar('PREFERRED_PROVIDER_%s' % item)
+    prefervar = cfgData.getVar('PREFERRED_PROVIDER_%s' % item, True)
     if prefervar:
         dataCache.preferred[item] = prefervar
 
@@ -310,56 +308,38 @@ def filterProviders(providers, item, cfgData, dataCache):
 def filterProvidersRunTime(providers, item, cfgData, dataCache):
     """
     Take a list of providers and filter/reorder according to the
-    environment variables
+    environment variables and previous build results
     Takes a "runtime" target item
     """
 
     eligible = _filterProviders(providers, item, cfgData, dataCache)
 
-    # First try and match any PREFERRED_RPROVIDER entry
-    prefervar = cfgData.getVar('PREFERRED_RPROVIDER_%s' % item)
-    foundUnique = False
-    if prefervar:
-        for p in eligible:
-            pn = dataCache.pkg_fn[p]
-            if prefervar == pn:
-                logger.verbose("selecting %s to satisfy %s due to PREFERRED_RPROVIDER", pn, item)
-                eligible.remove(p)
-                eligible = [p] + eligible
-                foundUnique = True
-                numberPreferred = 1
+    # Should use dataCache.preferred here?
+    preferred = []
+    preferred_vars = []
+    pns = {}
+    for p in eligible:
+        pns[dataCache.pkg_fn[p]] = p
+    for p in eligible:
+        pn = dataCache.pkg_fn[p]
+        provides = dataCache.pn_provides[pn]
+        for provide in provides:
+            prefervar = cfgData.getVar('PREFERRED_PROVIDER_%s' % provide, True)
+            #logger.debug(1, "checking PREFERRED_PROVIDER_%s (value %s) against %s", provide, prefervar, pns.keys())
+            if prefervar in pns and pns[prefervar] not in preferred:
+                var = "PREFERRED_PROVIDER_%s = %s" % (provide, prefervar)
+                logger.verbose("selecting %s to satisfy runtime %s due to %s", prefervar, item, var)
+                preferred_vars.append(var)
+                pref = pns[prefervar]
+                eligible.remove(pref)
+                eligible = [pref] + eligible
+                preferred.append(pref)
                 break
 
-    # If we didn't find an RPROVIDER entry, try and infer the provider from PREFERRED_PROVIDER entries
-    # by looking through the provides of each eligible recipe and seeing if a PREFERRED_PROVIDER was set.
-    # This is most useful for virtual/ entries rather than having a RPROVIDER per entry.
-    if not foundUnique:
-        # Should use dataCache.preferred here?
-        preferred = []
-        preferred_vars = []
-        pns = {}
-        for p in eligible:
-            pns[dataCache.pkg_fn[p]] = p
-        for p in eligible:
-            pn = dataCache.pkg_fn[p]
-            provides = dataCache.pn_provides[pn]
-            for provide in provides:
-                prefervar = cfgData.getVar('PREFERRED_PROVIDER_%s' % provide)
-                #logger.debug(1, "checking PREFERRED_PROVIDER_%s (value %s) against %s", provide, prefervar, pns.keys())
-                if prefervar in pns and pns[prefervar] not in preferred:
-                    var = "PREFERRED_PROVIDER_%s = %s" % (provide, prefervar)
-                    logger.verbose("selecting %s to satisfy runtime %s due to %s", prefervar, item, var)
-                    preferred_vars.append(var)
-                    pref = pns[prefervar]
-                    eligible.remove(pref)
-                    eligible = [pref] + eligible
-                    preferred.append(pref)
-                    break
-
-        numberPreferred = len(preferred)
+    numberPreferred = len(preferred)
 
     if numberPreferred > 1:
-        logger.error("Trying to resolve runtime dependency %s resulted in conflicting PREFERRED_PROVIDER entries being found.\nThe providers found were: %s\nThe PREFERRED_PROVIDER entries resulting in this conflict were: %s. You could set PREFERRED_RPROVIDER_%s" % (item, preferred, preferred_vars, item))
+        logger.error("Trying to resolve runtime dependency %s resulted in conflicting PREFERRED_PROVIDER entries being found.\nThe providers found were: %s\nThe PREFERRED_PROVIDER entries resulting in this conflict were: %s", item, preferred, preferred_vars)
 
     logger.debug(1, "sorted runtime providers for %s are: %s", item, eligible)
 
@@ -399,32 +379,3 @@ def getRuntimeProviders(dataCache, rdepend):
             logger.debug(1, "Assuming %s is a dynamic package, but it may not exist" % rdepend)
 
     return rproviders
-
-
-def buildWorldTargetList(dataCache, task=None):
-    """
-    Build package list for "bitbake world"
-    """
-    if dataCache.world_target:
-        return
-
-    logger.debug(1, "collating packages for \"world\"")
-    for f in dataCache.possible_world:
-        terminal = True
-        pn = dataCache.pkg_fn[f]
-        if task and task not in dataCache.task_deps[f]['tasks']:
-            logger.debug(2, "World build skipping %s as task %s doesn't exist", f, task)
-            terminal = False
-
-        for p in dataCache.pn_provides[pn]:
-            if p.startswith('virtual/'):
-                logger.debug(2, "World build skipping %s due to %s provider starting with virtual/", f, p)
-                terminal = False
-                break
-            for pf in dataCache.providers[p]:
-                if dataCache.pkg_fn[pf] != pn:
-                    logger.debug(2, "World build skipping %s due to both us and %s providing %s", f, pf, p)
-                    terminal = False
-                    break
-        if terminal:
-            dataCache.world_target.add(pn)

bitbake/lib/bb/pysh/builtin.py

@@ -527,7 +527,7 @@ def utility_sed(name, args, interp, env, stdin, stdout, stderr, debugflags):
         print interp.log(' '.join([name, str(args), interp['PWD']]) + '\n')
         
     # Scan pattern arguments and append a space if necessary
-    for i in range(len(args)):
+    for i in xrange(len(args)):
         if not RE_SED.search(args[i]):
             continue
         args[i] = args[i] + ' '

bitbake/lib/bb/pysh/interp.py

@@ -474,7 +474,7 @@ class Environment:
         """
         # Save and remove previous arguments
         prevargs = []        
-        for i in range(int(self._env['#'])):
+        for i in xrange(int(self._env['#'])):
             i = str(i+1)
             prevargs.append(self._env[i])
             del self._env[i]
@@ -488,7 +488,7 @@ class Environment:
         return prevargs
         
     def get_positional_args(self):
-        return [self._env[str(i+1)] for i in range(int(self._env['#']))]
+        return [self._env[str(i+1)] for i in xrange(int(self._env['#']))]
         
     def get_variables(self):
         return dict(self._env)

bitbake/lib/bb/pysh/pyshlex.py

@@ -20,7 +20,7 @@ except NameError:
     from Set import Set as set
 
 from ply import lex
-from bb.pysh.sherrors import *
+from sherrors import *
 
 class NeedMore(Exception):
     pass

bitbake/lib/bb/pysh/pyshyacc.py

@@ -10,11 +10,11 @@
 import os.path
 import sys
 
-import bb.pysh.pyshlex as pyshlex
+import pyshlex
 tokens = pyshlex.tokens
 
 from ply import yacc
-import bb.pysh.sherrors as sherrors
+import sherrors
     
 class IORedirect:
     def __init__(self, op, filename, io_number=None):

bitbake/lib/bb/remotedata.py

@@ -1,116 +0,0 @@
-"""
-BitBake 'remotedata' module
-
-Provides support for using a datastore from the bitbake client
-"""
-
-# Copyright (C) 2016  Intel Corporation
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 2 as
-# published by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-import bb.data
-
-class RemoteDatastores:
-    """Used on the server side to manage references to server-side datastores"""
-    def __init__(self, cooker):
-        self.cooker = cooker
-        self.datastores = {}
-        self.locked = []
-        self.nextindex = 1
-
-    def __len__(self):
-        return len(self.datastores)
-
-    def __getitem__(self, key):
-        if key is None:
-            return self.cooker.data
-        else:
-            return self.datastores[key]
-
-    def items(self):
-        return self.datastores.items()
-
-    def store(self, d, locked=False):
-        """
-        Put a datastore into the collection. If locked=True then the datastore
-        is understood to be managed externally and cannot be released by calling
-        release().
-        """
-        idx = self.nextindex
-        self.datastores[idx] = d
-        if locked:
-            self.locked.append(idx)
-        self.nextindex += 1
-        return idx
-
-    def check_store(self, d, locked=False):
-        """
-        Put a datastore into the collection if it's not already in there;
-        in either case return the index
-        """
-        for key, val in self.datastores.items():
-            if val is d:
-                idx = key
-                break
-        else:
-            idx = self.store(d, locked)
-        return idx
-
-    def release(self, idx):
-        """Discard a datastore in the collection"""
-        if idx in self.locked:
-            raise Exception('Tried to release locked datastore %d' % idx)
-        del self.datastores[idx]
-
-    def receive_datastore(self, remote_data):
-        """Receive a datastore object sent from the client (as prepared by transmit_datastore())"""
-        dct = dict(remote_data)
-        d = bb.data_smart.DataSmart()
-        d.dict = dct
-        while True:
-            if '_remote_data' in dct:
-                dsindex = dct['_remote_data']['_content']
-                del dct['_remote_data']
-                if dsindex is None:
-                    dct['_data'] = self.cooker.data.dict
-                else:
-                    dct['_data'] = self.datastores[dsindex].dict
-                break
-            elif '_data' in dct:
-                idct = dict(dct['_data'])
-                dct['_data'] = idct
-                dct = idct
-            else:
-                break
-        return d
-
-    @staticmethod
-    def transmit_datastore(d):
-        """Prepare a datastore object for sending over IPC from the client end"""
-        # FIXME content might be a dict, need to turn that into a list as well
-        def copy_dicts(dct):
-            if '_remote_data' in dct:
-                dsindex = dct['_remote_data']['_content'].dsindex
-                newdct = dct.copy()
-                newdct['_remote_data'] = {'_content': dsindex}
-                return list(newdct.items())
-            elif '_data' in dct:
-                newdct = dct.copy()
-                newdata = copy_dicts(dct['_data'])
-                if newdata:
-                    newdct['_data'] = newdata
-                return list(newdct.items())
-            return None
-        main_dict = copy_dicts(d.dict)
-        return main_dict

bitbake/lib/bb/server/__init__.py

@@ -63,9 +63,6 @@ class BitBakeBaseServerConnection():
     def terminate(self):
         pass
 
-    def setupEventQueue(self):
-        pass
-
 
 """ BitBakeBaseServer class is the common ancestor to all Bitbake servers
 

bitbake/lib/bb/server/process.py

@@ -30,7 +30,7 @@ import signal
 import sys
 import time
 import select
-from queue import Empty
+from Queue import Empty
 from multiprocessing import Event, Process, util, Queue, Pipe, queues, Manager
 
 from . import BitBakeBaseServer, BitBakeBaseServerConnection, BaseImplServer
@@ -53,12 +53,10 @@ class ServerCommunicator():
         while True:
             # don't let the user ctrl-c while we're waiting for a response
             try:
-                for idx in range(0,4): # 0, 1, 2, 3
-                    if self.connection.poll(5):
-                        return self.connection.recv()
-                    else:
-                        bb.warn("Timeout while attempting to communicate with bitbake server")
-                bb.fatal("Gave up; Too many tries: timeout while attempting to communicate with bitbake server")
+                if self.connection.poll(20):
+                    return self.connection.recv()
+                else:
+                    bb.fatal("Timeout while attempting to communicate with bitbake server")
             except KeyboardInterrupt:
                 pass
 
@@ -92,8 +90,6 @@ class ProcessServer(Process, BaseImplServer):
         self.event = EventAdapter(event_queue)
         self.featurelist = featurelist
         self.quit = False
-        self.heartbeat_seconds = 1 # default, BB_HEARTBEAT_EVENT will be checked once we have a datastore.
-        self.next_heartbeat = time.time()
 
         self.quitin, self.quitout = Pipe()
         self.event_handle = multiprocessing.Value("i")
@@ -101,16 +97,8 @@ class ProcessServer(Process, BaseImplServer):
     def run(self):
         for event in bb.event.ui_queue:
             self.event_queue.put(event)
-        self.event_handle.value = bb.event.register_UIHhandler(self, True)
+        self.event_handle.value = bb.event.register_UIHhandler(self)
 
-        heartbeat_event = self.cooker.data.getVar('BB_HEARTBEAT_EVENT')
-        if heartbeat_event:
-            try:
-                self.heartbeat_seconds = float(heartbeat_event)
-            except:
-                # Throwing an exception here causes bitbake to hang.
-                # Just warn about the invalid setting and continue
-                bb.warn('Ignoring invalid BB_HEARTBEAT_EVENT=%s, must be a float specifying seconds.' % heartbeat_event)
         bb.cooker.server_main(self.cooker, self.main)
 
     def main(self):
@@ -118,7 +106,6 @@ class ProcessServer(Process, BaseImplServer):
         # the UI and communicated to us
         self.quitin.close()
         signal.signal(signal.SIGINT, signal.SIG_IGN)
-        bb.utils.set_process_name("Cooker")
         while not self.quit:
             try:
                 if self.command_channel.poll():
@@ -127,12 +114,8 @@ class ProcessServer(Process, BaseImplServer):
                 if self.quitout.poll():
                     self.quitout.recv()
                     self.quit = True
-                    try:
-                        self.runCommand(["stateForceShutdown"])
-                    except:
-                        pass
 
-                self.idle_commands(.1, [self.command_channel, self.quitout])
+                self.idle_commands(.1, [self.event_queue._reader, self.command_channel, self.quitout])
             except Exception:
                 logger.exception('Running command %s', command)
 
@@ -140,14 +123,11 @@ class ProcessServer(Process, BaseImplServer):
         bb.event.unregister_UIHhandler(self.event_handle.value)
         self.command_channel.close()
         self.cooker.shutdown(True)
-        self.quitout.close()
 
-    def idle_commands(self, delay, fds=None):
+    def idle_commands(self, delay, fds = []):
         nextsleep = delay
-        if not fds:
-            fds = []
 
-        for function, data in list(self._idlefuns.items()):
+        for function, data in self._idlefuns.items():
             try:
                 retval = function(self, data, False)
                 if retval is False:
@@ -155,7 +135,7 @@ class ProcessServer(Process, BaseImplServer):
                     nextsleep = None
                 elif retval is True:
                     nextsleep = None
-                elif isinstance(retval, float) and nextsleep:
+                elif isinstance(retval, float):
                     if (retval < nextsleep):
                         nextsleep = retval
                 elif nextsleep is None:
@@ -164,27 +144,11 @@ class ProcessServer(Process, BaseImplServer):
                     fds = fds + retval
             except SystemExit:
                 raise
-            except Exception as exc:
-                if not isinstance(exc, bb.BBHandledException):
-                    logger.exception('Running idle function')
+            except Exception:
+                logger.exception('Running idle function')
                 del self._idlefuns[function]
                 self.quit = True
 
-        # Create new heartbeat event?
-        now = time.time()
-        if now >= self.next_heartbeat:
-            # We might have missed heartbeats. Just trigger once in
-            # that case and continue after the usual delay.
-            self.next_heartbeat += self.heartbeat_seconds
-            if self.next_heartbeat <= now:
-                self.next_heartbeat = now + self.heartbeat_seconds
-            heartbeat = bb.event.HeartbeatEvent(now)
-            bb.event.fire(heartbeat, self.cooker.data)
-        if nextsleep and now + nextsleep > self.next_heartbeat:
-            # Shorten timeout so that we we wake up in time for
-            # the heartbeat.
-            nextsleep = self.next_heartbeat - now
-
         if nextsleep is not None:
             select.select(fds,[],[],nextsleep)
 
@@ -205,16 +169,12 @@ class BitBakeProcessServerConnection(BitBakeBaseServerConnection):
         self.event_queue = event_queue
         self.connection = ServerCommunicator(self.ui_channel, self.procserver.event_handle, self.procserver)
         self.events = self.event_queue
-        self.terminated = False
 
     def sigterm_terminate(self):
         bb.error("UI received SIGTERM")
         self.terminate()
 
     def terminate(self):
-        if self.terminated:
-            return
-        self.terminated = True
         def flushevents():
             while True:
                 try:
@@ -224,6 +184,7 @@ class BitBakeProcessServerConnection(BitBakeBaseServerConnection):
                 if isinstance(event, logging.LogRecord):
                     logger.handle(event)
 
+        signal.signal(signal.SIGINT, signal.SIG_IGN)
         self.procserver.stop()
 
         while self.procserver.is_alive():
@@ -233,26 +194,23 @@ class BitBakeProcessServerConnection(BitBakeBaseServerConnection):
         self.ui_channel.close()
         self.event_queue.close()
         self.event_queue.setexit()
-        # XXX: Call explicity close in _writer to avoid
-        # fd leakage because isn't called on Queue.close()
-        self.event_queue._writer.close()
 
 # Wrap Queue to provide API which isn't server implementation specific
 class ProcessEventQueue(multiprocessing.queues.Queue):
     def __init__(self, maxsize):
-        multiprocessing.queues.Queue.__init__(self, maxsize, ctx=multiprocessing.get_context())
+        multiprocessing.queues.Queue.__init__(self, maxsize)
         self.exit = False
-        bb.utils.set_process_name("ProcessEQueue")
 
     def setexit(self):
         self.exit = True
 
     def waitEvent(self, timeout):
         if self.exit:
-            return self.getEvent()
+            sys.exit(1)
         try:
             if not self.server.is_alive():
-                return self.getEvent()
+                self.setexit()
+                return None
             return self.get(True, timeout)
         except Empty:
             return None
@@ -261,14 +219,14 @@ class ProcessEventQueue(multiprocessing.queues.Queue):
         try:
             if not self.server.is_alive():
                 self.setexit()
+                return None
             return self.get(False)
         except Empty:
-            if self.exit:
-                sys.exit(1)
             return None
 
+
 class BitBakeServer(BitBakeBaseServer):
-    def initServer(self, single_use=True):
+    def initServer(self):
         # establish communication channels.  We use bidirectional pipes for
         # ui <--> server command/response pairs
         # and a queue for server -> ui event notifications

bitbake/lib/bb/server/xmlrpc.py

@@ -31,33 +31,31 @@
     in the server's main loop.
 """
 
-import os
-import sys
-
-import hashlib
-import time
-import socket
-import signal
-import threading
-import pickle
-import inspect
-import select
-import http.client
-import xmlrpc.client
-from xmlrpc.server import SimpleXMLRPCServer, SimpleXMLRPCRequestHandler
-
 import bb
+import xmlrpclib, sys
 from bb import daemonize
 from bb.ui import uievent
-from . import BitBakeBaseServer, BitBakeBaseServerConnection, BaseImplServer
+import hashlib, time
+import socket
+import os, signal
+import threading
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
 
 DEBUG = False
 
-class BBTransport(xmlrpc.client.Transport):
+from SimpleXMLRPCServer import SimpleXMLRPCServer, SimpleXMLRPCRequestHandler
+import inspect, select, httplib
+
+from . import BitBakeBaseServer, BitBakeBaseServerConnection, BaseImplServer
+
+class BBTransport(xmlrpclib.Transport):
     def __init__(self, timeout):
         self.timeout = timeout
         self.connection_token = None
-        xmlrpc.client.Transport.__init__(self)
+        xmlrpclib.Transport.__init__(self)
 
     # Modified from default to pass timeout to HTTPConnection
     def make_connection(self, host):
@@ -69,7 +67,7 @@ class BBTransport(xmlrpc.client.Transport):
         # create a HTTP connection object from a host descriptor
         chost, self._extra_headers, x509 = self.get_host_info(host)
         #store the host argument along with the connection object
-        self._connection = host, http.client.HTTPConnection(chost, timeout=self.timeout)
+        self._connection = host, httplib.HTTPConnection(chost, timeout=self.timeout)
         return self._connection[1]
 
     def set_connection_token(self, token):
@@ -78,30 +76,13 @@ class BBTransport(xmlrpc.client.Transport):
     def send_content(self, h, body):
         if self.connection_token:
             h.putheader("Bitbake-token", self.connection_token)
-        xmlrpc.client.Transport.send_content(self, h, body)
+        xmlrpclib.Transport.send_content(self, h, body)
 
 def _create_server(host, port, timeout = 60):
     t = BBTransport(timeout)
-    s = xmlrpc.client.ServerProxy("http://%s:%d/" % (host, port), transport=t, allow_none=True, use_builtin_types=True)
+    s = xmlrpclib.ServerProxy("http://%s:%d/" % (host, port), transport=t, allow_none=True)
     return s, t
 
-def check_connection(remote, timeout):
-    try:
-        host, port = remote.split(":")
-        port = int(port)
-    except Exception as e:
-        bb.warn("Failed to read remote definition (%s)" % str(e))
-        raise e
-
-    server, _transport = _create_server(host, port, timeout)
-    try:
-        ret, err =  server.runCommand(['getVariable', 'TOPDIR'])
-        if err or not ret:
-            return False
-    except ConnectionError:
-        return False
-    return True
-
 class BitBakeServerCommands():
 
     def __init__(self, server):
@@ -116,10 +97,10 @@ class BitBakeServerCommands():
 
         # we don't allow connections if the cooker is running
         if (self.cooker.state in [bb.cooker.state.parsing, bb.cooker.state.running]):
-            return None, "Cooker is busy: %s" % bb.cooker.state.get_name(self.cooker.state)
+            return None
 
-        self.event_handle = bb.event.register_UIHhandler(s, True)
-        return self.event_handle, 'OK'
+        self.event_handle = bb.event.register_UIHhandler(s)
+        return self.event_handle
 
     def unregisterEventHandler(self, handlerNum):
         """
@@ -147,7 +128,7 @@ class BitBakeServerCommands():
     def addClient(self):
         if self.has_client:
             return None
-        token = hashlib.md5(str(time.time()).encode("utf-8")).hexdigest()
+        token = hashlib.md5(str(time.time())).hexdigest()
         self.server.set_connection_token(token)
         self.has_client = True
         return token
@@ -190,14 +171,14 @@ class BitBakeXMLRPCRequestHandler(SimpleXMLRPCRequestHandler):
         self.send_header("Content-type", "text/plain")
         self.send_header("Content-length", str(len(response)))
         self.end_headers()
-        self.wfile.write(bytes(response, 'utf-8'))
+        self.wfile.write(response)
 
 
 class XMLRPCProxyServer(BaseImplServer):
     """ not a real working server, but a stub for a proxy server connection
 
     """
-    def __init__(self, host, port, use_builtin_types=True):
+    def __init__(self, host, port):
         self.host = host
         self.port = port
 
@@ -205,12 +186,13 @@ class XMLRPCServer(SimpleXMLRPCServer, BaseImplServer):
     # remove this when you're done with debugging
     # allow_reuse_address = True
 
-    def __init__(self, interface, single_use=False, idle_timeout=0):
+    def __init__(self, interface):
         """
         Constructor
         """
         BaseImplServer.__init__(self)
-        self.single_use = single_use
+        if (interface[1] == 0):     # anonymous port, not getting reused
+            self.single_use = True
         # Use auto port configuration
         if (interface[1] == -1):
             interface = (interface[0], 0)
@@ -223,10 +205,7 @@ class XMLRPCServer(SimpleXMLRPCServer, BaseImplServer):
         self.commands = BitBakeServerCommands(self)
         self.autoregister_all_functions(self.commands, "")
         self.interface = interface
-        self.time = time.time()
-        self.idle_timeout = idle_timeout
-        if idle_timeout:
-            self.register_idle_function(self.handle_idle_timeout, self)
+        self.single_use = False
 
     def addcooker(self, cooker):
         BaseImplServer.addcooker(self, cooker)
@@ -242,12 +221,6 @@ class XMLRPCServer(SimpleXMLRPCServer, BaseImplServer):
             if name.startswith(prefix):
                 self.register_function(method, name[len(prefix):])
 
-    def handle_idle_timeout(self, server, data, abort):
-        if not abort:
-            if time.time() - server.time > server.idle_timeout:
-                server.quit = True
-                print("Server idle timeout expired")
-        return []
 
     def serve_forever(self):
         # Start the actual XMLRPC server
@@ -261,8 +234,7 @@ class XMLRPCServer(SimpleXMLRPCServer, BaseImplServer):
         while not self.quit:
             fds = [self]
             nextsleep = 0.1
-            for function, data in list(self._idlefuns.items()):
-                retval = None
+            for function, data in self._idlefuns.items():
                 try:
                     retval = function(self, data, False)
                     if retval is False:
@@ -279,9 +251,6 @@ class XMLRPCServer(SimpleXMLRPCServer, BaseImplServer):
                 except:
                     import traceback
                     traceback.print_exc()
-                    if retval == None:
-                        # the function execute failed; delete it
-                        del self._idlefuns[function]
                     pass
 
             socktimeout = self.socket.gettimeout() or nextsleep
@@ -290,15 +259,13 @@ class XMLRPCServer(SimpleXMLRPCServer, BaseImplServer):
             try:
                 fd_sets = select.select(fds, [], [], socktimeout)
                 if fd_sets[0] and self in fd_sets[0]:
-                    if self.idle_timeout:
-                        self.time = time.time()
                     self._handle_request_noblock()
             except IOError:
                 # we ignore interrupted calls
                 pass
 
         # Tell idle functions we're exiting
-        for function, data in list(self._idlefuns.items()):
+        for function, data in self._idlefuns.items():
             try:
                 retval = function(self, data, True)
             except:
@@ -310,15 +277,12 @@ class XMLRPCServer(SimpleXMLRPCServer, BaseImplServer):
         self.connection_token = token
 
 class BitBakeXMLRPCServerConnection(BitBakeBaseServerConnection):
-    def __init__(self, serverImpl, clientinfo=("localhost", 0), observer_only = False, featureset = None):
+    def __init__(self, serverImpl, clientinfo=("localhost", 0), observer_only = False, featureset = []):
         self.connection, self.transport = _create_server(serverImpl.host, serverImpl.port)
         self.clientinfo = clientinfo
         self.serverImpl = serverImpl
         self.observer_only = observer_only
-        if featureset:
-            self.featureset = featureset
-        else:
-            self.featureset = []
+        self.featureset = featureset
 
     def connect(self, token = None):
         if token is None:
@@ -331,20 +295,18 @@ class BitBakeXMLRPCServerConnection(BitBakeBaseServerConnection):
             return None
 
         self.transport.set_connection_token(token)
-        return self
 
-    def setupEventQueue(self):
         self.events = uievent.BBUIEventQueue(self.connection, self.clientinfo)
         for event in bb.event.ui_queue:
             self.events.queue_event(event)
 
         _, error = self.connection.runCommand(["setFeatures", self.featureset])
         if error:
-            # disconnect the client, we can't make the setFeature work
-            self.connection.removeClient()
             # no need to log it here, the error shall be sent to the client
             raise BaseException(error)
 
+        return self
+
     def removeClient(self):
         if not self.observer_only:
             self.connection.removeClient()
@@ -363,10 +325,9 @@ class BitBakeXMLRPCServerConnection(BitBakeBaseServerConnection):
             pass
 
 class BitBakeServer(BitBakeBaseServer):
-    def initServer(self, interface = ("localhost", 0),
-                   single_use = False, idle_timeout=0):
+    def initServer(self, interface = ("localhost", 0)):
         self.interface = interface
-        self.serverImpl = XMLRPCServer(interface, single_use, idle_timeout)
+        self.serverImpl = XMLRPCServer(interface)
 
     def detach(self):
         daemonize.createDaemon(self.serverImpl.serve_forever, "bitbake-cookerdaemon.log")
@@ -411,7 +372,7 @@ class BitBakeXMLRPCClient(BitBakeBaseServer):
             bb.warn("Could not create socket for %s:%s (%s)" % (host, port, str(e)))
             raise e
         try:
-            self.serverImpl = XMLRPCProxyServer(host, port, use_builtin_types=True)
+            self.serverImpl = XMLRPCProxyServer(host, port)
             self.connection = BitBakeXMLRPCServerConnection(self.serverImpl, (ip, 0), self.observer_only, featureset)
             return self.connection.connect(self.token)
         except Exception as e:

bitbake/lib/bb/siggen.py

@@ -3,19 +3,21 @@ import logging
 import os
 import re
 import tempfile
-import pickle
 import bb.data
-import difflib
-import simplediff
-from bb.checksum import FileChecksumCache
 
 logger = logging.getLogger('BitBake.SigGen')
 
+try:
+    import cPickle as pickle
+except ImportError:
+    import pickle
+    logger.info('Importing cPickle failed.  Falling back to a very slow implementation.')
+
 def init(d):
-    siggens = [obj for obj in globals().values()
+    siggens = [obj for obj in globals().itervalues()
                       if type(obj) is type and issubclass(obj, SignatureGenerator)]
 
-    desired = d.getVar("BB_SIGNATURE_HANDLER") or "noop"
+    desired = d.getVar("BB_SIGNATURE_HANDLER", True) or "noop"
     for sg in siggens:
         if desired == sg.name:
             return sg(d)
@@ -32,11 +34,9 @@ class SignatureGenerator(object):
     name = "noop"
 
     def __init__(self, data):
-        self.basehash = {}
         self.taskhash = {}
         self.runtaskdeps = {}
         self.file_checksum_values = {}
-        self.taints = {}
 
     def finalise(self, fn, d, varient):
         return
@@ -44,8 +44,7 @@ class SignatureGenerator(object):
     def get_taskhash(self, fn, task, deps, dataCache):
         return "0"
 
-    def writeout_file_checksum_cache(self):
-        """Write/update the file checksum cache onto disk"""
+    def set_taskdata(self, hashes, deps, checksum):
         return
 
     def stampfile(self, stampbase, file_name, taskname, extrainfo):
@@ -64,10 +63,11 @@ class SignatureGenerator(object):
         return
 
     def get_taskdata(self):
-        return (self.runtaskdeps, self.taskhash, self.file_checksum_values, self.taints, self.basehash)
+       return (self.runtaskdeps, self.taskhash, self.file_checksum_values)
 
     def set_taskdata(self, data):
-        self.runtaskdeps, self.taskhash, self.file_checksum_values, self.taints, self.basehash = data
+        self.runtaskdeps, self.taskhash, self.file_checksum_values = data
+
 
 class SignatureGeneratorBasic(SignatureGenerator):
     """
@@ -80,22 +80,15 @@ class SignatureGeneratorBasic(SignatureGenerator):
         self.taskdeps = {}
         self.runtaskdeps = {}
         self.file_checksum_values = {}
-        self.taints = {}
         self.gendeps = {}
         self.lookupcache = {}
         self.pkgnameextract = re.compile("(?P<fn>.*)\..*")
-        self.basewhitelist = set((data.getVar("BB_HASHBASE_WHITELIST") or "").split())
+        self.basewhitelist = set((data.getVar("BB_HASHBASE_WHITELIST", True) or "").split())
         self.taskwhitelist = None
         self.init_rundepcheck(data)
-        checksum_cache_file = data.getVar("BB_HASH_CHECKSUM_CACHE_FILE")
-        if checksum_cache_file:
-            self.checksum_cache = FileChecksumCache()
-            self.checksum_cache.init_cache(data, checksum_cache_file)
-        else:
-            self.checksum_cache = None
 
     def init_rundepcheck(self, data):
-        self.taskwhitelist = data.getVar("BB_HASHTASK_WHITELIST") or None
+        self.taskwhitelist = data.getVar("BB_HASHTASK_WHITELIST", True) or None
         if self.taskwhitelist:
             self.twl = re.compile(self.taskwhitelist)
         else:
@@ -103,7 +96,6 @@ class SignatureGeneratorBasic(SignatureGenerator):
 
     def _build_data(self, fn, d):
 
-        ignore_mismatch = ((d.getVar("BB_HASH_IGNORE_MISMATCH") or '') == '1')
         tasklist, gendeps, lookupcache = bb.data.generate_dependencies(d)
 
         taskdeps = {}
@@ -136,11 +128,7 @@ class SignatureGeneratorBasic(SignatureGenerator):
                 var = lookupcache[dep]
                 if var is not None:
                     data = data + str(var)
-            datahash = hashlib.md5(data.encode("utf-8")).hexdigest()
-            k = fn + "." + task
-            if not ignore_mismatch and k in self.basehash and self.basehash[k] != datahash:
-                bb.error("When reparsing %s, the basehash value changed from %s to %s. The metadata is not deterministic and this needs to be fixed." % (k, self.basehash[k], datahash))
-            self.basehash[k] = datahash
+            self.basehash[fn + "." + task] = hashlib.md5(data).hexdigest()
             taskdeps[task] = alldeps
 
         self.taskdeps[fn] = taskdeps
@@ -151,21 +139,18 @@ class SignatureGeneratorBasic(SignatureGenerator):
 
     def finalise(self, fn, d, variant):
 
-        mc = d.getVar("__BBMULTICONFIG", False) or ""
-        if variant or mc:
-            fn = bb.cache.realfn2virtual(fn, variant, mc)
+        if variant:
+            fn = "virtual:" + variant + ":" + fn
 
         try:
             taskdeps = self._build_data(fn, d)
-        except bb.parse.SkipRecipe:
-            raise
         except:
-            bb.warn("Error during finalise of %s" % fn)
+            bb.note("Error during finalise of %s" % fn)
             raise
 
         #Slow but can be useful for debugging mismatched basehashes
         #for task in self.taskdeps[fn]:
-        #    self.dump_sigtask(fn, task, d.getVar("STAMP"), False)
+        #    self.dump_sigtask(fn, task, d.getVar("STAMP", True), False)
 
         for task in taskdeps:
             d.setVar("BB_BASEHASH_task-%s" % task, self.basehash[fn + "." + task])
@@ -191,11 +176,9 @@ class SignatureGeneratorBasic(SignatureGenerator):
     def get_taskhash(self, fn, task, deps, dataCache):
         k = fn + "." + task
         data = dataCache.basetaskhash[k]
-        self.basehash[k] = data
         self.runtaskdeps[k] = []
-        self.file_checksum_values[k] = []
+        self.file_checksum_values[k] = {}
         recipename = dataCache.pkg_fn[fn]
-
         for dep in sorted(deps, key=clean_basepath):
             depname = dataCache.pkg_fn[self.pkgnameextract.search(dep).group('fn')]
             if not self.rundep_check(fn, recipename, task, dep, depname, dataCache):
@@ -206,50 +189,26 @@ class SignatureGeneratorBasic(SignatureGenerator):
             self.runtaskdeps[k].append(dep)
 
         if task in dataCache.file_checksums[fn]:
-            if self.checksum_cache:
-                checksums = self.checksum_cache.get_checksums(dataCache.file_checksums[fn][task], recipename)
-            else:
-                checksums = bb.fetch2.get_file_checksums(dataCache.file_checksums[fn][task], recipename)
+            checksums = bb.fetch2.get_file_checksums(dataCache.file_checksums[fn][task], recipename)
             for (f,cs) in checksums:
-                self.file_checksum_values[k].append((f,cs))
+                self.file_checksum_values[k][f] = cs
                 if cs:
                     data = data + cs
 
-        taskdep = dataCache.task_deps[fn]
-        if 'nostamp' in taskdep and task in taskdep['nostamp']:
-            # Nostamp tasks need an implicit taint so that they force any dependent tasks to run
-            import uuid
-            taint = str(uuid.uuid4())
-            data = data + taint
-            self.taints[k] = "nostamp:" + taint
-
         taint = self.read_taint(fn, task, dataCache.stamp[fn])
         if taint:
             data = data + taint
-            self.taints[k] = taint
-            logger.warning("%s is tainted from a forced run" % k)
+            logger.warn("%s is tainted from a forced run" % k)
 
-        h = hashlib.md5(data.encode("utf-8")).hexdigest()
+        h = hashlib.md5(data).hexdigest()
         self.taskhash[k] = h
         #d.setVar("BB_TASKHASH_task-%s" % task, taskhash[task])
         return h
 
-    def writeout_file_checksum_cache(self):
-        """Write/update the file checksum cache onto disk"""
-        if self.checksum_cache:
-            self.checksum_cache.save_extras()
-            self.checksum_cache.save_merge()
-        else:
-            bb.fetch2.fetcher_parse_save()
-            bb.fetch2.fetcher_parse_done()
-
     def dump_sigtask(self, fn, task, stampbase, runtime):
-
         k = fn + "." + task
-        referencestamp = stampbase
-        if isinstance(runtime, str) and runtime.startswith("customfile"):
+        if runtime == "customfile":
             sigfile = stampbase
-            referencestamp = runtime[11:]
         elif runtime and k in self.taskhash:
             sigfile = stampbase + "." + task + ".sigdata" + "." + self.taskhash[k]
         else:
@@ -258,7 +217,6 @@ class SignatureGeneratorBasic(SignatureGenerator):
         bb.utils.mkdirhier(os.path.dirname(sigfile))
 
         data = {}
-        data['task'] = task
         data['basewhitelist'] = self.basewhitelist
         data['taskwhitelist'] = self.taskwhitelist
         data['taskdeps'] = self.taskdeps[fn][task]
@@ -274,35 +232,21 @@ class SignatureGeneratorBasic(SignatureGenerator):
 
         if runtime and k in self.taskhash:
             data['runtaskdeps'] = self.runtaskdeps[k]
-            data['file_checksum_values'] = [(os.path.basename(f), cs) for f,cs in self.file_checksum_values[k]]
+            data['file_checksum_values'] = [(os.path.basename(f), cs) for f,cs in self.file_checksum_values[k].items()]
             data['runtaskhashes'] = {}
             for dep in data['runtaskdeps']:
                 data['runtaskhashes'][dep] = self.taskhash[dep]
-            data['taskhash'] = self.taskhash[k]
 
-        taint = self.read_taint(fn, task, referencestamp)
+        taint = self.read_taint(fn, task, stampbase)
         if taint:
             data['taint'] = taint
 
-        if runtime and k in self.taints:
-            if 'nostamp:' in self.taints[k]:
-                data['taint'] = self.taints[k]
-
-        computed_basehash = calc_basehash(data)
-        if computed_basehash != self.basehash[k]:
-            bb.error("Basehash mismatch %s versus %s for %s" % (computed_basehash, self.basehash[k], k))
-        if runtime and k in self.taskhash:
-            computed_taskhash = calc_taskhash(data)
-            if computed_taskhash != self.taskhash[k]:
-                bb.error("Taskhash mismatch %s versus %s for %s" % (computed_taskhash, self.taskhash[k], k))
-                sigfile = sigfile.replace(self.taskhash[k], computed_taskhash)
-
         fd, tmpfile = tempfile.mkstemp(dir=os.path.dirname(sigfile), prefix="sigtask.")
         try:
             with os.fdopen(fd, "wb") as stream:
                 p = pickle.dump(data, stream, -1)
                 stream.flush()
-            os.chmod(tmpfile, 0o664)
+            os.chmod(tmpfile, 0664)
             os.rename(tmpfile, sigfile)
         except (OSError, IOError) as err:
             try:
@@ -311,18 +255,16 @@ class SignatureGeneratorBasic(SignatureGenerator):
                 pass
             raise err
 
-    def dump_sigfn(self, fn, dataCaches, options):
-        if fn in self.taskdeps:
+    def dump_sigs(self, dataCache, options):
+        for fn in self.taskdeps:
             for task in self.taskdeps[fn]:
-                tid = fn + ":" + task
-                (mc, _, _) = bb.runqueue.split_tid(tid)
                 k = fn + "." + task
                 if k not in self.taskhash:
                     continue
-                if dataCaches[mc].basetaskhash[k] != self.basehash[k]:
+                if dataCache.basetaskhash[k] != self.basehash[k]:
                     bb.error("Bitbake's cached basehash does not match the one we just generated (%s)!" % k)
-                    bb.error("The mismatched hashes were %s and %s" % (dataCaches[mc].basetaskhash[k], self.basehash[k]))
-                self.dump_sigtask(fn, task, dataCaches[mc].stamp[fn], True)
+                    bb.error("The mismatched hashes were %s and %s" % (dataCache.basetaskhash[k], self.basehash[k]))
+                self.dump_sigtask(fn, task, dataCache.stamp[fn], True)
 
 class SignatureGeneratorBasicHash(SignatureGeneratorBasic):
     name = "basichash"
@@ -350,71 +292,14 @@ class SignatureGeneratorBasicHash(SignatureGeneratorBasic):
 
 def dump_this_task(outfile, d):
     import bb.parse
-    fn = d.getVar("BB_FILENAME")
-    task = "do_" + d.getVar("BB_CURRENTTASK")
-    referencestamp = bb.build.stamp_internal(task, d, None, True)
-    bb.parse.siggen.dump_sigtask(fn, task, outfile, "customfile:" + referencestamp)
-
-def init_colors(enable_color):
-    """Initialise colour dict for passing to compare_sigfiles()"""
-    # First set up the colours
-    colors = {'color_title':   '\033[1;37;40m',
-              'color_default': '\033[0;37;40m',
-              'color_add':     '\033[1;32;40m',
-              'color_remove':  '\033[1;31;40m',
-             }
-    # Leave all keys present but clear the values
-    if not enable_color:
-        for k in colors.keys():
-            colors[k] = ''
-    return colors
-
-def worddiff_str(oldstr, newstr, colors=None):
-    if not colors:
-        colors = init_colors(False)
-    diff = simplediff.diff(oldstr.split(' '), newstr.split(' '))
-    ret = []
-    for change, value in diff:
-        value = ' '.join(value)
-        if change == '=':
-            ret.append(value)
-        elif change == '+':
-            item = '{color_add}{{+{value}+}}{color_default}'.format(value=value, **colors)
-            ret.append(item)
-        elif change == '-':
-            item = '{color_remove}[-{value}-]{color_default}'.format(value=value, **colors)
-            ret.append(item)
-    whitespace_note = ''
-    if oldstr != newstr and ' '.join(oldstr.split()) == ' '.join(newstr.split()):
-        whitespace_note = ' (whitespace changed)'
-    return '"%s"%s' % (' '.join(ret), whitespace_note)
-
-def list_inline_diff(oldlist, newlist, colors=None):
-    if not colors:
-        colors = init_colors(False)
-    diff = simplediff.diff(oldlist, newlist)
-    ret = []
-    for change, value in diff:
-        value = ' '.join(value)
-        if change == '=':
-            ret.append("'%s'" % value)
-        elif change == '+':
-            item = '{color_add}+{value}{color_default}'.format(value=value, **colors)
-            ret.append(item)
-        elif change == '-':
-            item = '{color_remove}-{value}{color_default}'.format(value=value, **colors)
-            ret.append(item)
-    return '[%s]' % (', '.join(ret))
+    fn = d.getVar("BB_FILENAME", True)
+    task = "do_" + d.getVar("BB_CURRENTTASK", True)
+    bb.parse.siggen.dump_sigtask(fn, task, outfile, "customfile")
 
 def clean_basepath(a):
-    mc = None
-    if a.startswith("multiconfig:"):
-        _, mc, a = a.split(":", 2)
-    b = a.rsplit("/", 2)[1] + '/' + a.rsplit("/", 2)[2]
+    b = a.rsplit("/", 2)[1] + a.rsplit("/", 2)[2]
     if a.startswith("virtual:"):
         b = b + ":" + a.rsplit(":", 1)[0]
-    if mc:
-        b = b + ":multiconfig:" + mc
     return b
 
 def clean_basepaths(a):
@@ -423,38 +308,13 @@ def clean_basepaths(a):
         b[clean_basepath(x)] = a[x]
     return b
 
-def clean_basepaths_list(a):
-    b = []
-    for x in a:
-        b.append(clean_basepath(x))
-    return b
-
-def compare_sigfiles(a, b, recursecb=None, color=False, collapsed=False):
+def compare_sigfiles(a, b, recursecb = None):
     output = []
 
-    colors = init_colors(color)
-    def color_format(formatstr, **values):
-        """
-        Return colour formatted string.
-        NOTE: call with the format string, not an already formatted string
-        containing values (otherwise you could have trouble with { and }
-        characters)
-        """
-        if not formatstr.endswith('{color_default}'):
-            formatstr += '{color_default}'
-        # In newer python 3 versions you can pass both of these directly,
-        # but we only require 3.4 at the moment
-        formatparams = {}
-        formatparams.update(colors)
-        formatparams.update(values)
-        return formatstr.format(**formatparams)
-
-    with open(a, 'rb') as f:
-        p1 = pickle.Unpickler(f)
-        a_data = p1.load()
-    with open(b, 'rb') as f:
-        p2 = pickle.Unpickler(f)
-        b_data = p2.load()
+    p1 = pickle.Unpickler(open(a, "rb"))
+    a_data = p1.load()
+    p2 = pickle.Unpickler(open(b, "rb"))
+    b_data = p2.load()
 
     def dict_diff(a, b, whitelist=set()):
         sa = set(a.keys())
@@ -502,100 +362,50 @@ def compare_sigfiles(a, b, recursecb=None, color=False, collapsed=False):
         return changed, added, removed
 
     if 'basewhitelist' in a_data and a_data['basewhitelist'] != b_data['basewhitelist']:
-        output.append(color_format("{color_title}basewhitelist changed{color_default} from '%s' to '%s'") % (a_data['basewhitelist'], b_data['basewhitelist']))
+        output.append("basewhitelist changed from '%s' to '%s'" % (a_data['basewhitelist'], b_data['basewhitelist']))
         if a_data['basewhitelist'] and b_data['basewhitelist']:
             output.append("changed items: %s" % a_data['basewhitelist'].symmetric_difference(b_data['basewhitelist']))
 
     if 'taskwhitelist' in a_data and a_data['taskwhitelist'] != b_data['taskwhitelist']:
-        output.append(color_format("{color_title}taskwhitelist changed{color_default} from '%s' to '%s'") % (a_data['taskwhitelist'], b_data['taskwhitelist']))
+        output.append("taskwhitelist changed from '%s' to '%s'" % (a_data['taskwhitelist'], b_data['taskwhitelist']))
         if a_data['taskwhitelist'] and b_data['taskwhitelist']:
             output.append("changed items: %s" % a_data['taskwhitelist'].symmetric_difference(b_data['taskwhitelist']))
 
     if a_data['taskdeps'] != b_data['taskdeps']:
-        output.append(color_format("{color_title}Task dependencies changed{color_default} from:\n%s\nto:\n%s") % (sorted(a_data['taskdeps']), sorted(b_data['taskdeps'])))
+        output.append("Task dependencies changed from:\n%s\nto:\n%s" % (sorted(a_data['taskdeps']), sorted(b_data['taskdeps'])))
 
-    if a_data['basehash'] != b_data['basehash'] and not collapsed:
-        output.append(color_format("{color_title}basehash changed{color_default} from %s to %s") % (a_data['basehash'], b_data['basehash']))
+    if a_data['basehash'] != b_data['basehash']:
+        output.append("basehash changed from %s to %s" % (a_data['basehash'], b_data['basehash']))
 
     changed, added, removed = dict_diff(a_data['gendeps'], b_data['gendeps'], a_data['basewhitelist'] & b_data['basewhitelist'])
     if changed:
         for dep in changed:
-            output.append(color_format("{color_title}List of dependencies for variable %s changed from '{color_default}%s{color_title}' to '{color_default}%s{color_title}'") % (dep, a_data['gendeps'][dep], b_data['gendeps'][dep]))
+            output.append("List of dependencies for variable %s changed from '%s' to '%s'" % (dep, a_data['gendeps'][dep], b_data['gendeps'][dep]))
             if a_data['gendeps'][dep] and b_data['gendeps'][dep]:
                 output.append("changed items: %s" % a_data['gendeps'][dep].symmetric_difference(b_data['gendeps'][dep]))
     if added:
         for dep in added:
-            output.append(color_format("{color_title}Dependency on variable %s was added") % (dep))
+            output.append("Dependency on variable %s was added" % (dep))
     if removed:
         for dep in removed:
-            output.append(color_format("{color_title}Dependency on Variable %s was removed") % (dep))
+            output.append("Dependency on Variable %s was removed" % (dep))
 
 
     changed, added, removed = dict_diff(a_data['varvals'], b_data['varvals'])
     if changed:
         for dep in changed:
-            oldval = a_data['varvals'][dep]
-            newval = b_data['varvals'][dep]
-            if newval and oldval and ('\n' in oldval or '\n' in newval):
-                diff = difflib.unified_diff(oldval.splitlines(), newval.splitlines(), lineterm='')
-                # Cut off the first two lines, since we aren't interested in
-                # the old/new filename (they are blank anyway in this case)
-                difflines = list(diff)[2:]
-                if color:
-                    # Add colour to diff output
-                    for i, line in enumerate(difflines):
-                        if line.startswith('+'):
-                            line = color_format('{color_add}{line}', line=line)
-                            difflines[i] = line
-                        elif line.startswith('-'):
-                            line = color_format('{color_remove}{line}', line=line)
-                            difflines[i] = line
-                output.append(color_format("{color_title}Variable {var} value changed:{color_default}\n{diff}", var=dep, diff='\n'.join(difflines)))
-            elif newval and oldval and (' ' in oldval or ' ' in newval):
-                output.append(color_format("{color_title}Variable {var} value changed:{color_default}\n{diff}", var=dep, diff=worddiff_str(oldval, newval, colors)))
-            else:
-                output.append(color_format("{color_title}Variable {var} value changed from '{color_default}{oldval}{color_title}' to '{color_default}{newval}{color_title}'{color_default}", var=dep, oldval=oldval, newval=newval))
-
-    if not 'file_checksum_values' in a_data:
-         a_data['file_checksum_values'] = {}
-    if not 'file_checksum_values' in b_data:
-         b_data['file_checksum_values'] = {}
+            output.append("Variable %s value changed from '%s' to '%s'" % (dep, a_data['varvals'][dep], b_data['varvals'][dep]))
 
     changed, added, removed = file_checksums_diff(a_data['file_checksum_values'], b_data['file_checksum_values'])
     if changed:
         for f, old, new in changed:
-            output.append(color_format("{color_title}Checksum for file %s changed{color_default} from %s to %s") % (f, old, new))
+            output.append("Checksum for file %s changed from %s to %s" % (f, old, new))
     if added:
         for f in added:
-            output.append(color_format("{color_title}Dependency on checksum of file %s was added") % (f))
+            output.append("Dependency on checksum of file %s was added" % (f))
     if removed:
         for f in removed:
-            output.append(color_format("{color_title}Dependency on checksum of file %s was removed") % (f))
-
-    if not 'runtaskdeps' in a_data:
-         a_data['runtaskdeps'] = {}
-    if not 'runtaskdeps' in b_data:
-         b_data['runtaskdeps'] = {}
-
-    if not collapsed:
-        if len(a_data['runtaskdeps']) != len(b_data['runtaskdeps']):
-            changed = ["Number of task dependencies changed"]
-        else:
-            changed = []
-            for idx, task in enumerate(a_data['runtaskdeps']):
-                a = a_data['runtaskdeps'][idx]
-                b = b_data['runtaskdeps'][idx]
-                if a_data['runtaskhashes'][a] != b_data['runtaskhashes'][b] and not collapsed:
-                    changed.append("%s with hash %s\n changed to\n%s with hash %s" % (clean_basepath(a), a_data['runtaskhashes'][a], clean_basepath(b), b_data['runtaskhashes'][b]))
-
-        if changed:
-            clean_a = clean_basepaths_list(a_data['runtaskdeps'])
-            clean_b = clean_basepaths_list(b_data['runtaskdeps'])
-            if clean_a != clean_b:
-                output.append(color_format("{color_title}runtaskdeps changed:{color_default}\n%s") % list_inline_diff(clean_a, clean_b, colors))
-            else:
-                output.append(color_format("{color_title}runtaskdeps changed:"))
-            output.append("\n".join(changed))
+            output.append("Dependency on checksum of file %s was removed" % (f))
 
 
     if 'runtaskhashes' in a_data and 'runtaskhashes' in b_data:
@@ -611,7 +421,7 @@ def compare_sigfiles(a, b, recursecb=None, color=False, collapsed=False):
                             #output.append("Dependency on task %s was replaced by %s with same hash" % (dep, bdep))
                             bdep_found = True
                 if not bdep_found:
-                    output.append(color_format("{color_title}Dependency on task %s was added{color_default} with hash %s") % (clean_basepath(dep), b[dep]))
+                    output.append("Dependency on task %s was added with hash %s" % (clean_basepath(dep), b[dep]))
         if removed:
             for dep in removed:
                 adep_found = False
@@ -621,69 +431,30 @@ def compare_sigfiles(a, b, recursecb=None, color=False, collapsed=False):
                             #output.append("Dependency on task %s was replaced by %s with same hash" % (adep, dep))
                             adep_found = True
                 if not adep_found:
-                    output.append(color_format("{color_title}Dependency on task %s was removed{color_default} with hash %s") % (clean_basepath(dep), a[dep]))
+                    output.append("Dependency on task %s was removed with hash %s" % (clean_basepath(dep), a[dep]))
         if changed:
             for dep in changed:
-                if not collapsed:
-                    output.append(color_format("{color_title}Hash for dependent task %s changed{color_default} from %s to %s") % (clean_basepath(dep), a[dep], b[dep]))
+                output.append("Hash for dependent task %s changed from %s to %s" % (clean_basepath(dep), a[dep], b[dep]))
                 if callable(recursecb):
+                    # If a dependent hash changed, might as well print the line above and then defer to the changes in 
+                    # that hash since in all likelyhood, they're the same changes this task also saw.
                     recout = recursecb(dep, a[dep], b[dep])
                     if recout:
-                        if collapsed:
-                            output.extend(recout)
-                        else:
-                            # If a dependent hash changed, might as well print the line above and then defer to the changes in 
-                            # that hash since in all likelyhood, they're the same changes this task also saw.
-                            output = [output[-1]] + recout
+                        output = [output[-1]] + recout
 
     a_taint = a_data.get('taint', None)
     b_taint = b_data.get('taint', None)
     if a_taint != b_taint:
-        output.append(color_format("{color_title}Taint (by forced/invalidated task) changed{color_default} from %s to %s") % (a_taint, b_taint))
+        output.append("Taint (by forced/invalidated task) changed from %s to %s" % (a_taint, b_taint))
 
     return output
 
 
-def calc_basehash(sigdata):
-    task = sigdata['task']
-    basedata = sigdata['varvals'][task]
-
-    if basedata is None:
-        basedata = ''
-
-    alldeps = sigdata['taskdeps']
-    for dep in alldeps:
-        basedata = basedata + dep
-        val = sigdata['varvals'][dep]
-        if val is not None:
-            basedata = basedata + str(val)
-
-    return hashlib.md5(basedata.encode("utf-8")).hexdigest()
-
-def calc_taskhash(sigdata):
-    data = sigdata['basehash']
-
-    for dep in sigdata['runtaskdeps']:
-        data = data + sigdata['runtaskhashes'][dep]
-
-    for c in sigdata['file_checksum_values']:
-        data = data + c[1]
-
-    if 'taint' in sigdata:
-        if 'nostamp:' in sigdata['taint']:
-            data = data + sigdata['taint'][8:]
-        else:
-            data = data + sigdata['taint']
-
-    return hashlib.md5(data.encode("utf-8")).hexdigest()
-
-
 def dump_sigfile(a):
     output = []
 
-    with open(a, 'rb') as f:
-        p1 = pickle.Unpickler(f)
-        a_data = p1.load()
+    p1 = pickle.Unpickler(open(a, "rb"))
+    a_data = p1.load()
 
     output.append("basewhitelist: %s" % (a_data['basewhitelist']))
 
@@ -712,13 +483,4 @@ def dump_sigfile(a):
     if 'taint' in a_data:
         output.append("Tainted (by forced/invalidated task): %s" % a_data['taint'])
 
-    if 'task' in a_data:
-        computed_basehash = calc_basehash(a_data)
-        output.append("Computed base hash is %s and from file %s" % (computed_basehash, a_data['basehash']))
-    else:
-        output.append("Unable to compute base hash")
-
-    computed_taskhash = calc_taskhash(a_data)
-    output.append("Computed task hash is %s" % computed_taskhash)
-
     return output

bitbake/lib/bb/taskdata.py

@@ -37,24 +37,27 @@ def re_match_strings(target, strings):
     return any(name == target or re.match(name, target)
                for name in strings)
 
-class TaskEntry:
-    def __init__(self):
-        self.tdepends = []
-        self.idepends = []
-        self.irdepends = []
-
 class TaskData:
     """
     BitBake Task Data implementation
     """
-    def __init__(self, abort = True, tryaltconfigs = False, skiplist = None, allowincomplete = False):
+    def __init__(self, abort = True, tryaltconfigs = False, skiplist = None):
+        self.build_names_index = []
+        self.run_names_index = []
+        self.fn_index = []
+
         self.build_targets = {}
         self.run_targets = {}
 
         self.external_targets = []
 
-        self.seenfns = []
-        self.taskentries = {}
+        self.tasks_fnid = []
+        self.tasks_name = []
+        self.tasks_tdepends = []
+        self.tasks_idepends = []
+        self.tasks_irdepends = []
+        # Cache to speed up task ID lookups
+        self.tasks_lookup = {}
 
         self.depids = {}
         self.rdepids = {}
@@ -63,14 +66,95 @@ class TaskData:
 
         self.failed_deps = []
         self.failed_rdeps = []
-        self.failed_fns = []
+        self.failed_fnids = []
 
         self.abort = abort
         self.tryaltconfigs = tryaltconfigs
-        self.allowincomplete = allowincomplete
 
         self.skiplist = skiplist
 
+    def getbuild_id(self, name):
+        """
+        Return an ID number for the build target name.
+        If it doesn't exist, create one.
+        """
+        if not name in self.build_names_index:
+            self.build_names_index.append(name)
+            return len(self.build_names_index) - 1
+
+        return self.build_names_index.index(name)
+
+    def getrun_id(self, name):
+        """
+        Return an ID number for the run target name.
+        If it doesn't exist, create one.
+        """
+        if not name in self.run_names_index:
+            self.run_names_index.append(name)
+            return len(self.run_names_index) - 1
+
+        return self.run_names_index.index(name)
+
+    def getfn_id(self, name):
+        """
+        Return an ID number for the filename.
+        If it doesn't exist, create one.
+        """
+        if not name in self.fn_index:
+            self.fn_index.append(name)
+            return len(self.fn_index) - 1
+
+        return self.fn_index.index(name)
+
+    def gettask_ids(self, fnid):
+        """
+        Return an array of the ID numbers matching a given fnid.
+        """
+        ids = []
+        if fnid in self.tasks_lookup:
+            for task in self.tasks_lookup[fnid]:
+                ids.append(self.tasks_lookup[fnid][task])
+        return ids
+
+    def gettask_id_fromfnid(self, fnid, task):
+        """
+        Return an ID number for the task matching fnid and task.
+        """
+        if fnid in self.tasks_lookup:
+            if task in self.tasks_lookup[fnid]:
+                return self.tasks_lookup[fnid][task]
+
+        return None
+
+    def gettask_id(self, fn, task, create = True):
+        """
+        Return an ID number for the task matching fn and task.
+        If it doesn't exist, create one by default.
+        Optionally return None instead.
+        """
+        fnid = self.getfn_id(fn)
+
+        if fnid in self.tasks_lookup:
+            if task in self.tasks_lookup[fnid]:
+                return self.tasks_lookup[fnid][task]
+
+        if not create:
+            return None
+
+        self.tasks_name.append(task)
+        self.tasks_fnid.append(fnid)
+        self.tasks_tdepends.append([])
+        self.tasks_idepends.append([])
+        self.tasks_irdepends.append([])
+
+        listid = len(self.tasks_name) - 1
+
+        if fnid not in self.tasks_lookup:
+            self.tasks_lookup[fnid] = {}
+        self.tasks_lookup[fnid][task] = listid
+
+        return listid
+
     def add_tasks(self, fn, dataCache):
         """
         Add tasks for a given fn to the database
@@ -78,60 +162,58 @@ class TaskData:
 
         task_deps = dataCache.task_deps[fn]
 
-        if fn in self.failed_fns:
+        fnid = self.getfn_id(fn)
+
+        if fnid in self.failed_fnids:
             bb.msg.fatal("TaskData", "Trying to re-add a failed file? Something is broken...")
 
         # Check if we've already seen this fn
-        if fn in self.seenfns:
+        if fnid in self.tasks_fnid:
             return
 
-        self.seenfns.append(fn)
-
-        self.add_extra_deps(fn, dataCache)
-
-        # Common code for dep_name/depends = 'depends'/idepends and 'rdepends'/irdepends
-        def handle_deps(task, dep_name, depends, seen):
-            if dep_name in task_deps and task in task_deps[dep_name]:
-                ids = []
-                for dep in task_deps[dep_name][task].split():
-                    if dep:
-                        parts = dep.split(":")
-                        if len(parts) != 2:
-                            bb.msg.fatal("TaskData", "Error for %s:%s[%s], dependency %s in '%s' does not contain exactly one ':' character.\n Task '%s' should be specified in the form 'packagename:task'" % (fn, task, dep_name, dep, task_deps[dep_name][task], dep_name))
-                        ids.append((parts[0], parts[1]))
-                        seen(parts[0])
-                depends.extend(ids)
-
         for task in task_deps['tasks']:
 
-            tid = "%s:%s" % (fn, task)
-            self.taskentries[tid] = TaskEntry()
-
             # Work out task dependencies
             parentids = []
             for dep in task_deps['parents'][task]:
                 if dep not in task_deps['tasks']:
                     bb.debug(2, "Not adding dependeny of %s on %s since %s does not exist" % (task, dep, dep))
                     continue
-                parentid = "%s:%s" % (fn, dep)
+                parentid = self.gettask_id(fn, dep)
                 parentids.append(parentid)
-            self.taskentries[tid].tdepends.extend(parentids)
+            taskid = self.gettask_id(fn, task)
+            self.tasks_tdepends[taskid].extend(parentids)
 
             # Touch all intertask dependencies
-            handle_deps(task, 'depends', self.taskentries[tid].idepends, self.seen_build_target)
-            handle_deps(task, 'rdepends', self.taskentries[tid].irdepends, self.seen_run_target)
+            if 'depends' in task_deps and task in task_deps['depends']:
+                ids = []
+                for dep in task_deps['depends'][task].split():
+                    if dep:
+                        if ":" not in dep:
+                            bb.msg.fatal("TaskData", "Error for %s, dependency %s does not contain ':' character\n. Task 'depends' should be specified in the form 'packagename:task'" % (fn, dep))
+                        ids.append(((self.getbuild_id(dep.split(":")[0])), dep.split(":")[1]))
+                self.tasks_idepends[taskid].extend(ids)
+            if 'rdepends' in task_deps and task in task_deps['rdepends']:
+                ids = []
+                for dep in task_deps['rdepends'][task].split():
+                    if dep:
+                        if ":" not in dep:
+                            bb.msg.fatal("TaskData", "Error for %s, dependency %s does not contain ':' character\n. Task 'rdepends' should be specified in the form 'packagename:task'" % (fn, dep))
+                        ids.append(((self.getrun_id(dep.split(":")[0])), dep.split(":")[1]))
+                self.tasks_irdepends[taskid].extend(ids)
+
 
         # Work out build dependencies
-        if not fn in self.depids:
-            dependids = set()
+        if not fnid in self.depids:
+            dependids = {}
             for depend in dataCache.deps[fn]:
-                dependids.add(depend)
-            self.depids[fn] = list(dependids)
+                dependids[self.getbuild_id(depend)] = None
+            self.depids[fnid] = dependids.keys()
             logger.debug(2, "Added dependencies %s for %s", str(dataCache.deps[fn]), fn)
 
         # Work out runtime dependencies
-        if not fn in self.rdepids:
-            rdependids = set()
+        if not fnid in self.rdepids:
+            rdependids = {}
             rdepends = dataCache.rundeps[fn]
             rrecs = dataCache.runrecs[fn]
             rdependlist = []
@@ -139,48 +221,33 @@ class TaskData:
             for package in rdepends:
                 for rdepend in rdepends[package]:
                     rdependlist.append(rdepend)
-                    rdependids.add(rdepend)
+                    rdependids[self.getrun_id(rdepend)] = None
             for package in rrecs:
                 for rdepend in rrecs[package]:
                     rreclist.append(rdepend)
-                    rdependids.add(rdepend)
+                    rdependids[self.getrun_id(rdepend)] = None
             if rdependlist:
                 logger.debug(2, "Added runtime dependencies %s for %s", str(rdependlist), fn)
             if rreclist:
                 logger.debug(2, "Added runtime recommendations %s for %s", str(rreclist), fn)
-            self.rdepids[fn] = list(rdependids)
+            self.rdepids[fnid] = rdependids.keys()
 
-        for dep in self.depids[fn]:
-            self.seen_build_target(dep)
+        for dep in self.depids[fnid]:
             if dep in self.failed_deps:
-                self.fail_fn(fn)
+                self.fail_fnid(fnid)
                 return
-        for dep in self.rdepids[fn]:
-            self.seen_run_target(dep)
+        for dep in self.rdepids[fnid]:
             if dep in self.failed_rdeps:
-                self.fail_fn(fn)
+                self.fail_fnid(fnid)
                 return
 
-    def add_extra_deps(self, fn, dataCache):
-        func = dataCache.extradepsfunc.get(fn, None)
-        if func:
-            bb.providers.buildWorldTargetList(dataCache)
-            pn = dataCache.pkg_fn[fn]
-            params = {'deps': dataCache.deps[fn],
-                      'world_target': dataCache.world_target,
-                      'pkg_pn': dataCache.pkg_pn,
-                      'self_pn': pn}
-            funcname = '_%s_calculate_extra_depends' % pn.replace('-', '_')
-            paramlist = ','.join(params.keys())
-            func = 'def %s(%s):\n%s\n\n%s(%s)' % (funcname, paramlist, func, funcname, paramlist)
-            bb.utils.better_exec(func, params)
-
-
     def have_build_target(self, target):
         """
         Have we a build target matching this name?
         """
-        if target in self.build_targets and self.build_targets[target]:
+        targetid = self.getbuild_id(target)
+
+        if targetid in self.build_targets:
             return True
         return False
 
@@ -188,54 +255,50 @@ class TaskData:
         """
         Have we a runtime target matching this name?
         """
-        if target in self.run_targets and self.run_targets[target]:
+        targetid = self.getrun_id(target)
+
+        if targetid in self.run_targets:
             return True
         return False
 
-    def seen_build_target(self, name):
-        """
-        Maintain a list of build targets
-        """
-        if name not in self.build_targets:
-            self.build_targets[name] = []
-
     def add_build_target(self, fn, item):
         """
         Add a build target.
         If already present, append the provider fn to the list
         """
-        if item in self.build_targets:
-            if fn in self.build_targets[item]:
-                return
-            self.build_targets[item].append(fn)
-            return
-        self.build_targets[item] = [fn]
+        targetid = self.getbuild_id(item)
+        fnid = self.getfn_id(fn)
 
-    def seen_run_target(self, name):
-        """
-        Maintain a list of runtime build targets
-        """
-        if name not in self.run_targets:
-            self.run_targets[name] = []
+        if targetid in self.build_targets:
+            if fnid in self.build_targets[targetid]:
+                return
+            self.build_targets[targetid].append(fnid)
+            return
+        self.build_targets[targetid] = [fnid]
 
     def add_runtime_target(self, fn, item):
         """
         Add a runtime target.
         If already present, append the provider fn to the list
         """
-        if item in self.run_targets:
-            if fn in self.run_targets[item]:
-                return
-            self.run_targets[item].append(fn)
-            return
-        self.run_targets[item] = [fn]
+        targetid = self.getrun_id(item)
+        fnid = self.getfn_id(fn)
 
-    def mark_external_target(self, target):
+        if targetid in self.run_targets:
+            if fnid in self.run_targets[targetid]:
+                return
+            self.run_targets[targetid].append(fnid)
+            return
+        self.run_targets[targetid] = [fnid]
+
+    def mark_external_target(self, item):
         """
         Mark a build target as being externally requested
         """
-        if target not in self.external_targets:
-            self.external_targets.append(target)
+        targetid = self.getbuild_id(item)
+
+        if targetid not in self.external_targets:
+            self.external_targets.append(targetid)
 
     def get_unresolved_build_targets(self, dataCache):
         """
@@ -243,12 +306,12 @@ class TaskData:
         are unknown.
         """
         unresolved = []
-        for target in self.build_targets:
+        for target in self.build_names_index:
             if re_match_strings(target, dataCache.ignored_dependencies):
                 continue
-            if target in self.failed_deps:
+            if self.build_names_index.index(target) in self.failed_deps:
                 continue
-            if not self.build_targets[target]:
+            if not self.have_build_target(target):
                 unresolved.append(target)
         return unresolved
 
@@ -258,12 +321,12 @@ class TaskData:
         are unknown.
         """
         unresolved = []
-        for target in self.run_targets:
+        for target in self.run_names_index:
             if re_match_strings(target, dataCache.ignored_dependencies):
                 continue
-            if target in self.failed_rdeps:
+            if self.run_names_index.index(target) in self.failed_rdeps:
                 continue
-            if not self.run_targets[target]:
+            if not self.have_runtime_target(target):
                 unresolved.append(target)
         return unresolved
 
@@ -271,26 +334,50 @@ class TaskData:
         """
         Return a list of providers of item
         """
-        return self.build_targets[item]
+        targetid = self.getbuild_id(item)
 
-    def get_dependees(self, item):
+        return self.build_targets[targetid]
+
+    def get_dependees(self, itemid):
         """
         Return a list of targets which depend on item
         """
         dependees = []
-        for fn in self.depids:
-            if item in self.depids[fn]:
-                dependees.append(fn)
+        for fnid in self.depids:
+            if itemid in self.depids[fnid]:
+                dependees.append(fnid)
         return dependees
 
-    def get_rdependees(self, item):
+    def get_dependees_str(self, item):
+        """
+        Return a list of targets which depend on item as a user readable string
+        """
+        itemid = self.getbuild_id(item)
+        dependees = []
+        for fnid in self.depids:
+            if itemid in self.depids[fnid]:
+                dependees.append(self.fn_index[fnid])
+        return dependees
+
+    def get_rdependees(self, itemid):
         """
         Return a list of targets which depend on runtime item
         """
         dependees = []
-        for fn in self.rdepids:
-            if item in self.rdepids[fn]:
-                dependees.append(fn)
+        for fnid in self.rdepids:
+            if itemid in self.rdepids[fnid]:
+                dependees.append(fnid)
+        return dependees
+
+    def get_rdependees_str(self, item):
+        """
+        Return a list of targets which depend on runtime item as a user readable string
+        """
+        itemid = self.getrun_id(item)
+        dependees = []
+        for fnid in self.rdepids:
+            if itemid in self.rdepids[fnid]:
+                dependees.append(self.fn_index[fnid])
         return dependees
 
     def get_reasons(self, item, runtime=False):
@@ -326,7 +413,7 @@ class TaskData:
         except bb.providers.NoProvider:
             if self.abort:
                 raise
-            self.remove_buildtarget(item)
+            self.remove_buildtarget(self.getbuild_id(item))
 
         self.mark_external_target(item)
 
@@ -341,14 +428,7 @@ class TaskData:
             return
 
         if not item in dataCache.providers:
-            close_matches = self.get_close_matches(item, list(dataCache.providers.keys()))
-            # Is it in RuntimeProviders ?
-            all_p = bb.providers.getRuntimeProviders(dataCache, item)
-            for fn in all_p:
-                new = dataCache.pkg_fn[fn] + " RPROVIDES " + item
-                if new not in close_matches:
-                    close_matches.append(new)
-            bb.event.fire(bb.event.NoProvider(item, dependees=self.get_dependees(item), reasons=self.get_reasons(item), close_matches=close_matches), cfgData)
+            bb.event.fire(bb.event.NoProvider(item, dependees=self.get_dependees_str(item), reasons=self.get_reasons(item), close_matches=self.get_close_matches(item, dataCache.providers.keys())), cfgData)
             raise bb.providers.NoProvider(item)
 
         if self.have_build_target(item):
@@ -357,10 +437,10 @@ class TaskData:
         all_p = dataCache.providers[item]
 
         eligible, foundUnique = bb.providers.filterProviders(all_p, item, cfgData, dataCache)
-        eligible = [p for p in eligible if not p in self.failed_fns]
+        eligible = [p for p in eligible if not self.getfn_id(p) in self.failed_fnids]
 
         if not eligible:
-            bb.event.fire(bb.event.NoProvider(item, dependees=self.get_dependees(item), reasons=["No eligible PROVIDERs exist for '%s'" % item]), cfgData)
+            bb.event.fire(bb.event.NoProvider(item, dependees=self.get_dependees_str(item), reasons=["No eligible PROVIDERs exist for '%s'" % item]), cfgData)
             raise bb.providers.NoProvider(item)
 
         if len(eligible) > 1 and foundUnique == False:
@@ -372,7 +452,8 @@ class TaskData:
             self.consider_msgs_cache.append(item)
 
         for fn in eligible:
-            if fn in self.failed_fns:
+            fnid = self.getfn_id(fn)
+            if fnid in self.failed_fnids:
                 continue
             logger.debug(2, "adding %s to satisfy %s", fn, item)
             self.add_build_target(fn, item)
@@ -396,14 +477,14 @@ class TaskData:
         all_p = bb.providers.getRuntimeProviders(dataCache, item)
 
         if not all_p:
-            bb.event.fire(bb.event.NoProvider(item, runtime=True, dependees=self.get_rdependees(item), reasons=self.get_reasons(item, True)), cfgData)
+            bb.event.fire(bb.event.NoProvider(item, runtime=True, dependees=self.get_rdependees_str(item), reasons=self.get_reasons(item, True)), cfgData)
             raise bb.providers.NoRProvider(item)
 
         eligible, numberPreferred = bb.providers.filterProvidersRunTime(all_p, item, cfgData, dataCache)
-        eligible = [p for p in eligible if not p in self.failed_fns]
+        eligible = [p for p in eligible if not self.getfn_id(p) in self.failed_fnids]
 
         if not eligible:
-            bb.event.fire(bb.event.NoProvider(item, runtime=True, dependees=self.get_rdependees(item), reasons=["No eligible RPROVIDERs exist for '%s'" % item]), cfgData)
+            bb.event.fire(bb.event.NoProvider(item, runtime=True, dependees=self.get_rdependees_str(item), reasons=["No eligible RPROVIDERs exist for '%s'" % item]), cfgData)
             raise bb.providers.NoRProvider(item)
 
         if len(eligible) > 1 and numberPreferred == 0:
@@ -425,80 +506,80 @@ class TaskData:
 
         # run through the list until we find one that we can build
         for fn in eligible:
-            if fn in self.failed_fns:
+            fnid = self.getfn_id(fn)
+            if fnid in self.failed_fnids:
                 continue
             logger.debug(2, "adding '%s' to satisfy runtime '%s'", fn, item)
             self.add_runtime_target(fn, item)
             self.add_tasks(fn, dataCache)
 
-    def fail_fn(self, fn, missing_list=None):
+    def fail_fnid(self, fnid, missing_list = []):
         """
         Mark a file as failed (unbuildable)
         Remove any references from build and runtime provider lists
 
         missing_list, A list of missing requirements for this target
         """
-        if fn in self.failed_fns:
+        if fnid in self.failed_fnids:
             return
-        if not missing_list:
-            missing_list = []
-        logger.debug(1, "File '%s' is unbuildable, removing...", fn)
-        self.failed_fns.append(fn)
+        logger.debug(1, "File '%s' is unbuildable, removing...", self.fn_index[fnid])
+        self.failed_fnids.append(fnid)
         for target in self.build_targets:
-            if fn in self.build_targets[target]:
-                self.build_targets[target].remove(fn)
+            if fnid in self.build_targets[target]:
+                self.build_targets[target].remove(fnid)
                 if len(self.build_targets[target]) == 0:
                     self.remove_buildtarget(target, missing_list)
         for target in self.run_targets:
-            if fn in self.run_targets[target]:
-                self.run_targets[target].remove(fn)
+            if fnid in self.run_targets[target]:
+                self.run_targets[target].remove(fnid)
                 if len(self.run_targets[target]) == 0:
                     self.remove_runtarget(target, missing_list)
 
-    def remove_buildtarget(self, target, missing_list=None):
+    def remove_buildtarget(self, targetid, missing_list = []):
         """
         Mark a build target as failed (unbuildable)
         Trigger removal of any files that have this as a dependency
         """
         if not missing_list:
-            missing_list = [target]
+            missing_list = [self.build_names_index[targetid]]
         else:
-            missing_list = [target] + missing_list
-        logger.verbose("Target '%s' is unbuildable, removing...\nMissing or unbuildable dependency chain was: %s", target, missing_list)
-        self.failed_deps.append(target)
-        dependees = self.get_dependees(target)
-        for fn in dependees:
-            self.fail_fn(fn, missing_list)
-        for tid in self.taskentries:
-            for (idepend, idependtask) in self.taskentries[tid].idepends:
-                if idepend == target:
-                    fn = tid.rsplit(":",1)[0]
-                    self.fail_fn(fn, missing_list)
+            missing_list = [self.build_names_index[targetid]] + missing_list
+        logger.verbose("Target '%s' is unbuildable, removing...\nMissing or unbuildable dependency chain was: %s", self.build_names_index[targetid], missing_list)
+        self.failed_deps.append(targetid)
+        dependees = self.get_dependees(targetid)
+        for fnid in dependees:
+            self.fail_fnid(fnid, missing_list)
+        for taskid in xrange(len(self.tasks_idepends)):
+            idepends = self.tasks_idepends[taskid]
+            for (idependid, idependtask) in idepends:
+                if idependid == targetid:
+                    self.fail_fnid(self.tasks_fnid[taskid], missing_list)
 
-        if self.abort and target in self.external_targets:
+        if self.abort and targetid in self.external_targets:
+            target = self.build_names_index[targetid]
             logger.error("Required build target '%s' has no buildable providers.\nMissing or unbuildable dependency chain was: %s", target, missing_list)
             raise bb.providers.NoProvider(target)
 
-    def remove_runtarget(self, target, missing_list=None):
+    def remove_runtarget(self, targetid, missing_list = []):
         """
         Mark a run target as failed (unbuildable)
         Trigger removal of any files that have this as a dependency
         """
         if not missing_list:
-            missing_list = [target]
+            missing_list = [self.run_names_index[targetid]]
         else:
-            missing_list = [target] + missing_list
+            missing_list = [self.run_names_index[targetid]] + missing_list
 
-        logger.info("Runtime target '%s' is unbuildable, removing...\nMissing or unbuildable dependency chain was: %s", target, missing_list)
-        self.failed_rdeps.append(target)
-        dependees = self.get_rdependees(target)
-        for fn in dependees:
-            self.fail_fn(fn, missing_list)
-        for tid in self.taskentries:
-            for (idepend, idependtask) in self.taskentries[tid].irdepends:
-                if idepend == target:
-                    fn = tid.rsplit(":",1)[0]
-                    self.fail_fn(fn, missing_list)
+        logger.info("Runtime target '%s' is unbuildable, removing...\nMissing or unbuildable dependency chain was: %s", self.run_names_index[targetid], missing_list)
+        self.failed_rdeps.append(targetid)
+        dependees = self.get_rdependees(targetid)
+        for fnid in dependees:
+            self.fail_fnid(fnid, missing_list)
+        for taskid in xrange(len(self.tasks_irdepends)):
+            irdepends = self.tasks_irdepends[taskid]
+            for (idependid, idependtask) in irdepends:
+                if idependid == targetid:
+                    self.fail_fnid(self.tasks_fnid[taskid], missing_list)
 
     def add_unresolved(self, cfgData, dataCache):
         """
@@ -512,68 +593,59 @@ class TaskData:
                     self.add_provider_internal(cfgData, dataCache, target)
                     added = added + 1
                 except bb.providers.NoProvider:
-                    if self.abort and target in self.external_targets and not self.allowincomplete:
+                    targetid = self.getbuild_id(target)
+                    if self.abort and targetid in self.external_targets:
                         raise
-                    if not self.allowincomplete:
-                        self.remove_buildtarget(target)
+                    self.remove_buildtarget(targetid)
             for target in self.get_unresolved_run_targets(dataCache):
                 try:
                     self.add_rprovider(cfgData, dataCache, target)
                     added = added + 1
                 except (bb.providers.NoRProvider, bb.providers.MultipleRProvider):
-                    self.remove_runtarget(target)
+                    self.remove_runtarget(self.getrun_id(target))
             logger.debug(1, "Resolved " + str(added) + " extra dependencies")
             if added == 0:
                 break
         # self.dump_data()
 
-    def get_providermap(self, prefix=None):
-        provmap = {}
-        for name in self.build_targets:
-            if prefix and not name.startswith(prefix):
-                continue
-            if self.have_build_target(name):
-                provider = self.get_provider(name)
-                if provider:
-                    provmap[name] = provider[0]
-        return provmap
-
     def dump_data(self):
         """
         Dump some debug information on the internal data structures
         """
         logger.debug(3, "build_names:")
-        logger.debug(3, ", ".join(self.build_targets))
+        logger.debug(3, ", ".join(self.build_names_index))
 
         logger.debug(3, "run_names:")
-        logger.debug(3, ", ".join(self.run_targets))
+        logger.debug(3, ", ".join(self.run_names_index))
 
         logger.debug(3, "build_targets:")
-        for target in self.build_targets:
+        for buildid in xrange(len(self.build_names_index)):
+            target = self.build_names_index[buildid]
             targets = "None"
-            if target in self.build_targets:
-                targets = self.build_targets[target]
-            logger.debug(3, " %s: %s", target, targets)
+            if buildid in self.build_targets:
+                targets = self.build_targets[buildid]
+            logger.debug(3, " (%s)%s: %s", buildid, target, targets)
 
         logger.debug(3, "run_targets:")
-        for target in self.run_targets:
+        for runid in xrange(len(self.run_names_index)):
+            target = self.run_names_index[runid]
             targets = "None"
-            if target in self.run_targets:
-                targets = self.run_targets[target]
-            logger.debug(3, " %s: %s", target, targets)
+            if runid in self.run_targets:
+                targets = self.run_targets[runid]
+            logger.debug(3, " (%s)%s: %s", runid, target, targets)
 
         logger.debug(3, "tasks:")
-        for tid in self.taskentries:
-            logger.debug(3, " %s: %s %s %s",
-                       tid,
-                       self.taskentries[tid].idepends,
-                       self.taskentries[tid].irdepends,
-                       self.taskentries[tid].tdepends)
+        for task in xrange(len(self.tasks_name)):
+            logger.debug(3, " (%s)%s - %s: %s",
+                       task,
+                       self.fn_index[self.tasks_fnid[task]],
+                       self.tasks_name[task],
+                       self.tasks_tdepends[task])
 
         logger.debug(3, "dependency ids (per fn):")
-        for fn in self.depids:
-            logger.debug(3, " %s: %s", fn, self.depids[fn])
+        for fnid in self.depids:
+            logger.debug(3, " %s %s: %s", fnid, self.fn_index[fnid], self.depids[fnid])
 
         logger.debug(3, "runtime dependency ids (per fn):")
-        for fn in self.rdepids:
-            logger.debug(3, " %s: %s", fn, self.rdepids[fn])
+        for fnid in self.rdepids:
+            logger.debug(3, " %s %s: %s", fnid, self.fn_index[fnid], self.rdepids[fnid])

bitbake/lib/bb/tests/codeparser.py

@@ -49,9 +49,6 @@ class ReferenceTest(unittest.TestCase):
     def assertExecs(self, execs):
         self.assertEqual(self.execs, execs)
 
-    def assertContains(self, contains):
-        self.assertEqual(self.contains, contains)
-
 class VariableReferenceTest(ReferenceTest):
 
     def parseExpression(self, exp):
@@ -71,7 +68,7 @@ class VariableReferenceTest(ReferenceTest):
 
     def test_python_reference(self):
         self.setEmptyVars(["BAR"])
-        self.parseExpression("${@d.getVar('BAR') + 'foo'}")
+        self.parseExpression("${@bb.data.getVar('BAR', d, True) + 'foo'}")
         self.assertReferences(set(["BAR"]))
 
 class ShellReferenceTest(ReferenceTest):
@@ -194,8 +191,8 @@ class PythonReferenceTest(ReferenceTest):
         if hasattr(bb.utils, "_context"):
             self.context = bb.utils._context
         else:
-            import builtins
-            self.context = builtins.__dict__
+            import __builtin__
+            self.context = __builtin__.__dict__
 
     def parseExpression(self, exp):
         parsedvar = self.d.expandWithRefs(exp, None)
@@ -204,7 +201,6 @@ class PythonReferenceTest(ReferenceTest):
 
         self.references = parsedvar.references | parser.references
         self.execs = parser.execs
-        self.contains = parser.contains
 
     @staticmethod
     def indent(value):
@@ -213,17 +209,17 @@ be. These unit tests are testing snippets."""
         return " " + value
 
     def test_getvar_reference(self):
-        self.parseExpression("d.getVar('foo')")
+        self.parseExpression("bb.data.getVar('foo', d, True)")
         self.assertReferences(set(["foo"]))
         self.assertExecs(set())
 
     def test_getvar_computed_reference(self):
-        self.parseExpression("d.getVar('f' + 'o' + 'o')")
+        self.parseExpression("bb.data.getVar('f' + 'o' + 'o', d, True)")
         self.assertReferences(set())
         self.assertExecs(set())
 
     def test_getvar_exec_reference(self):
-        self.parseExpression("eval('d.getVar(\"foo\")')")
+        self.parseExpression("eval('bb.data.getVar(\"foo\", d, True)')")
         self.assertReferences(set())
         self.assertExecs(set(["eval"]))
 
@@ -269,35 +265,15 @@ be. These unit tests are testing snippets."""
         self.assertExecs(set(["testget"]))
         del self.context["testget"]
 
-    def test_contains(self):
-        self.parseExpression('bb.utils.contains("TESTVAR", "one", "true", "false", d)')
-        self.assertContains({'TESTVAR': {'one'}})
-
-    def test_contains_multi(self):
-        self.parseExpression('bb.utils.contains("TESTVAR", "one two", "true", "false", d)')
-        self.assertContains({'TESTVAR': {'one two'}})
-
-    def test_contains_any(self):
-        self.parseExpression('bb.utils.contains_any("TESTVAR", "hello", "true", "false", d)')
-        self.assertContains({'TESTVAR': {'hello'}})
-
-    def test_contains_any_multi(self):
-        self.parseExpression('bb.utils.contains_any("TESTVAR", "one two three", "true", "false", d)')
-        self.assertContains({'TESTVAR': {'one', 'two', 'three'}})
-
-    def test_contains_filter(self):
-        self.parseExpression('bb.utils.filter("TESTVAR", "hello there world", d)')
-        self.assertContains({'TESTVAR': {'hello', 'there', 'world'}})
-
 
 class DependencyReferenceTest(ReferenceTest):
 
     pydata = """
-d.getVar('somevar')
+bb.data.getVar('somevar', d, True)
 def test(d):
     foo = 'bar %s' % 'foo'
 def test2(d):
-    d.getVar(foo)
+    d.getVar(foo, True)
     d.getVar('bar', False)
     test2(d)
 
@@ -309,24 +285,19 @@ def a():
 
 test(d)
 
-d.expand(d.getVar("something", False))
-d.expand("${inexpand} somethingelse")
-d.getVar(a(), False)
+bb.data.expand(bb.data.getVar("something", False, d), d)
+bb.data.expand("${inexpand} somethingelse", d)
+bb.data.getVar(a(), d, False)
 """
 
     def test_python(self):
         self.d.setVar("FOO", self.pydata)
         self.setEmptyVars(["inexpand", "a", "test2", "test"])
-        self.d.setVarFlags("FOO", {
-            "func": True,
-            "python": True,
-            "lineno": 1,
-            "filename": "example.bb",
-        })
+        self.d.setVarFlags("FOO", {"func": True, "python": True})
 
         deps, values = bb.data.build_dependencies("FOO", set(self.d.keys()), set(), set(), self.d)
 
-        self.assertEqual(deps, set(["somevar", "bar", "something", "inexpand", "test", "test2", "a"]))
+        self.assertEquals(deps, set(["somevar", "bar", "something", "inexpand", "test", "test2", "a"]))
 
 
     shelldata = """
@@ -373,7 +344,7 @@ esac
 
         deps, values = bb.data.build_dependencies("FOO", set(self.d.keys()), set(), set(), self.d)
 
-        self.assertEqual(deps, set(["somevar", "inverted"] + execs))
+        self.assertEquals(deps, set(["somevar", "inverted"] + execs))
 
 
     def test_vardeps(self):
@@ -383,7 +354,7 @@ esac
 
         deps, values = bb.data.build_dependencies("FOO", set(self.d.keys()), set(), set(), self.d)
 
-        self.assertEqual(deps, set(["oe_libinstall"]))
+        self.assertEquals(deps, set(["oe_libinstall"]))
 
     def test_vardeps_expand(self):
         self.d.setVar("oe_libinstall", "echo test")
@@ -392,31 +363,7 @@ esac
 
         deps, values = bb.data.build_dependencies("FOO", set(self.d.keys()), set(), set(), self.d)
 
-        self.assertEqual(deps, set(["oe_libinstall"]))
-
-    def test_contains_vardeps(self):
-        expr = '${@bb.utils.filter("TESTVAR", "somevalue anothervalue", d)} \
-                ${@bb.utils.contains("TESTVAR", "testval testval2", "yetanothervalue", "", d)} \
-                ${@bb.utils.contains("TESTVAR", "testval2 testval3", "blah", "", d)} \
-                ${@bb.utils.contains_any("TESTVAR", "testval2 testval3", "lastone", "", d)}'
-        parsedvar = self.d.expandWithRefs(expr, None)
-        # Check contains
-        self.assertEqual(parsedvar.contains, {'TESTVAR': {'testval2 testval3', 'anothervalue', 'somevalue', 'testval testval2', 'testval2', 'testval3'}})
-        # Check dependencies
-        self.d.setVar('ANOTHERVAR', expr)
-        self.d.setVar('TESTVAR', 'anothervalue testval testval2')
-        deps, values = bb.data.build_dependencies("ANOTHERVAR", set(self.d.keys()), set(), set(), self.d)
-        self.assertEqual(sorted(values.splitlines()),
-                         sorted([expr,
-                          'TESTVAR{anothervalue} = Set',
-                          'TESTVAR{somevalue} = Unset',
-                          'TESTVAR{testval testval2} = Set',
-                          'TESTVAR{testval2 testval3} = Unset',
-                          'TESTVAR{testval2} = Set',
-                          'TESTVAR{testval3} = Unset'
-                          ]))
-        # Check final value
-        self.assertEqual(self.d.getVar('ANOTHERVAR').split(), ['anothervalue', 'yetanothervalue', 'lastone'])
+        self.assertEquals(deps, set(["oe_libinstall"]))
 
     #Currently no wildcard support
     #def test_vardeps_wildcards(self):

bitbake/lib/bb/tests/cow.py

@@ -34,14 +34,14 @@ class COWTestCase(unittest.TestCase):
         from bb.COW import COWDictBase
         a = COWDictBase.copy()
 
-        self.assertEqual(False, 'a' in a)
+        self.assertEquals(False, a.has_key('a'))
 
         a['a'] = 'a'
         a['b'] = 'b'
-        self.assertEqual(True, 'a' in a)
-        self.assertEqual(True, 'b' in a)
-        self.assertEqual('a', a['a'] )
-        self.assertEqual('b', a['b'] )
+        self.assertEquals(True, a.has_key('a'))
+        self.assertEquals(True, a.has_key('b'))
+        self.assertEquals('a', a['a'] )
+        self.assertEquals('b', a['b'] )
 
     def testCopyCopy(self):
         """
@@ -60,31 +60,31 @@ class COWTestCase(unittest.TestCase):
         c['a'] = 30
 
         # test separation of the two instances
-        self.assertEqual(False, 'c' in c)
-        self.assertEqual(30, c['a'])
-        self.assertEqual(10, b['a'])
+        self.assertEquals(False, c.has_key('c'))
+        self.assertEquals(30, c['a'])
+        self.assertEquals(10, b['a'])
 
         # test copy
         b_2 = b.copy()
         c_2 = c.copy()
 
-        self.assertEqual(False, 'c' in c_2)
-        self.assertEqual(10, b_2['a'])
+        self.assertEquals(False, c_2.has_key('c'))
+        self.assertEquals(10, b_2['a'])
 
         b_2['d'] = 40
-        self.assertEqual(False, 'd' in c_2)
-        self.assertEqual(True, 'd' in b_2)
-        self.assertEqual(40, b_2['d'])
-        self.assertEqual(False, 'd' in b)
-        self.assertEqual(False, 'd' in c)
+        self.assertEquals(False, c_2.has_key('d'))
+        self.assertEquals(True, b_2.has_key('d'))
+        self.assertEquals(40, b_2['d'])
+        self.assertEquals(False, b.has_key('d'))
+        self.assertEquals(False, c.has_key('d'))
 
         c_2['d'] = 30
-        self.assertEqual(True, 'd' in c_2)
-        self.assertEqual(True, 'd' in b_2)
-        self.assertEqual(30, c_2['d'])
-        self.assertEqual(40, b_2['d'])
-        self.assertEqual(False, 'd' in b)
-        self.assertEqual(False, 'd' in c)
+        self.assertEquals(True, c_2.has_key('d'))
+        self.assertEquals(True, b_2.has_key('d'))
+        self.assertEquals(30, c_2['d'])
+        self.assertEquals(40, b_2['d'])
+        self.assertEquals(False, b.has_key('d'))
+        self.assertEquals(False, c.has_key('d'))
 
         # test copy of the copy
         c_3 = c_2.copy()
@@ -92,19 +92,19 @@ class COWTestCase(unittest.TestCase):
         b_3_2 = b_2.copy()
 
         c_3['e'] = 4711
-        self.assertEqual(4711, c_3['e'])
-        self.assertEqual(False, 'e' in c_2)
-        self.assertEqual(False, 'e' in b_3)
-        self.assertEqual(False, 'e' in b_3_2)
-        self.assertEqual(False, 'e' in b_2)
+        self.assertEquals(4711, c_3['e'])
+        self.assertEquals(False, c_2.has_key('e'))
+        self.assertEquals(False, b_3.has_key('e'))
+        self.assertEquals(False, b_3_2.has_key('e'))
+        self.assertEquals(False, b_2.has_key('e'))
 
         b_3['e'] = 'viel'
-        self.assertEqual('viel', b_3['e'])
-        self.assertEqual(4711, c_3['e'])
-        self.assertEqual(False, 'e' in c_2)
-        self.assertEqual(True, 'e' in b_3)
-        self.assertEqual(False, 'e' in b_3_2)
-        self.assertEqual(False, 'e' in b_2)
+        self.assertEquals('viel', b_3['e'])
+        self.assertEquals(4711, c_3['e'])
+        self.assertEquals(False, c_2.has_key('e'))
+        self.assertEquals(True, b_3.has_key('e'))
+        self.assertEquals(False, b_3_2.has_key('e'))
+        self.assertEquals(False, b_2.has_key('e'))
 
     def testCow(self):
         from bb.COW import COWDictBase
@@ -115,12 +115,12 @@ class COWTestCase(unittest.TestCase):
 
         copy = c.copy()
 
-        self.assertEqual(1027, c['123'])
-        self.assertEqual(4711, c['other'])
-        self.assertEqual({'abc':10, 'bcd':20}, c['d'])
-        self.assertEqual(1027, copy['123'])
-        self.assertEqual(4711, copy['other'])
-        self.assertEqual({'abc':10, 'bcd':20}, copy['d'])
+        self.assertEquals(1027, c['123'])
+        self.assertEquals(4711, c['other'])
+        self.assertEquals({'abc':10, 'bcd':20}, c['d'])
+        self.assertEquals(1027, copy['123'])
+        self.assertEquals(4711, copy['other'])
+        self.assertEquals({'abc':10, 'bcd':20}, copy['d'])
 
         # cow it now
         copy['123'] = 1028
@@ -128,9 +128,9 @@ class COWTestCase(unittest.TestCase):
         copy['d']['abc'] = 20
 
 
-        self.assertEqual(1027, c['123'])
-        self.assertEqual(4711, c['other'])
-        self.assertEqual({'abc':10, 'bcd':20}, c['d'])
-        self.assertEqual(1028, copy['123'])
-        self.assertEqual(4712, copy['other'])
-        self.assertEqual({'abc':20, 'bcd':20}, copy['d'])
+        self.assertEquals(1027, c['123'])
+        self.assertEquals(4711, c['other'])
+        self.assertEquals({'abc':10, 'bcd':20}, c['d'])
+        self.assertEquals(1028, copy['123'])
+        self.assertEquals(4712, copy['other'])
+        self.assertEquals({'abc':20, 'bcd':20}, copy['d'])

bitbake/lib/bb/tests/data.py

@@ -24,30 +24,6 @@ import unittest
 import bb
 import bb.data
 import bb.parse
-import logging
-
-class LogRecord():
-    def __enter__(self):
-        logs = []
-        class LogHandler(logging.Handler):
-            def emit(self, record):
-                logs.append(record)
-        logger = logging.getLogger("BitBake")
-        handler = LogHandler()
-        self.handler = handler
-        logger.addHandler(handler)
-        return logs
-    def __exit__(self, type, value, traceback):
-        logger = logging.getLogger("BitBake")
-        logger.removeHandler(self.handler)
-        return
-
-def logContains(item, logs):
-    for l in logs:
-        m = l.getMessage()
-        if item in m:
-            return True
-    return False
 
 class DataExpansions(unittest.TestCase):
     def setUp(self):
@@ -77,14 +53,9 @@ class DataExpansions(unittest.TestCase):
         self.assertEqual(str(val), "boo value_of_foo")
 
     def test_python_snippet_getvar(self):
-        val = self.d.expand("${@d.getVar('foo') + ' ${bar}'}")
+        val = self.d.expand("${@d.getVar('foo', True) + ' ${bar}'}")
         self.assertEqual(str(val), "value_of_foo value_of_bar")
 
-    def test_python_unexpanded(self):
-        self.d.setVar("bar", "${unsetvar}")
-        val = self.d.expand("${@d.getVar('foo') + ' ${bar}'}")
-        self.assertEqual(str(val), "${@d.getVar('foo') + ' ${unsetvar}'}")
-
     def test_python_snippet_syntax_error(self):
         self.d.setVar("FOO", "${@foo = 5}")
         self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
@@ -99,7 +70,7 @@ class DataExpansions(unittest.TestCase):
         self.assertRaises(bb.data_smart.ExpansionError, self.d.getVar, "FOO", True)
 
     def test_value_containing_value(self):
-        val = self.d.expand("${@d.getVar('foo') + ' ${bar}'}")
+        val = self.d.expand("${@d.getVar('foo', True) + ' ${bar}'}")
         self.assertEqual(str(val), "value_of_foo value_of_bar")
 
     def test_reference_undefined_var(self):
@@ -109,7 +80,7 @@ class DataExpansions(unittest.TestCase):
     def test_double_reference(self):
         self.d.setVar("BAR", "bar value")
         self.d.setVar("FOO", "${BAR} foo ${BAR}")
-        val = self.d.getVar("FOO")
+        val = self.d.getVar("FOO", True)
         self.assertEqual(str(val), "bar value foo bar value")
 
     def test_direct_recursion(self):
@@ -129,32 +100,26 @@ class DataExpansions(unittest.TestCase):
 
     def test_incomplete_varexp_single_quotes(self):
         self.d.setVar("FOO", "sed -i -e 's:IP{:I${:g' $pc")
-        val = self.d.getVar("FOO")
+        val = self.d.getVar("FOO", True)
         self.assertEqual(str(val), "sed -i -e 's:IP{:I${:g' $pc")
 
     def test_nonstring(self):
         self.d.setVar("TEST", 5)
-        val = self.d.getVar("TEST")
+        val = self.d.getVar("TEST", True)
         self.assertEqual(str(val), "5")
 
     def test_rename(self):
         self.d.renameVar("foo", "newfoo")
-        self.assertEqual(self.d.getVar("newfoo", False), "value_of_foo")
-        self.assertEqual(self.d.getVar("foo", False), None)
+        self.assertEqual(self.d.getVar("newfoo"), "value_of_foo")
+        self.assertEqual(self.d.getVar("foo"), None)
 
     def test_deletion(self):
         self.d.delVar("foo")
-        self.assertEqual(self.d.getVar("foo", False), None)
+        self.assertEqual(self.d.getVar("foo"), None)
 
     def test_keys(self):
-        keys = list(self.d.keys())
-        self.assertCountEqual(keys, ['value_of_foo', 'foo', 'bar'])
-
-    def test_keys_deletion(self):
-        newd = bb.data.createCopy(self.d)
-        newd.delVar("bar")
-        keys = list(newd.keys())
-        self.assertCountEqual(keys, ['value_of_foo', 'foo'])
+        keys = self.d.keys()
+        self.assertEqual(keys, ['value_of_foo', 'foo', 'bar'])
 
 class TestNestedExpansions(unittest.TestCase):
     def setUp(self):
@@ -201,28 +166,28 @@ class TestMemoize(unittest.TestCase):
     def test_memoized(self):
         d = bb.data.init()
         d.setVar("FOO", "bar")
-        self.assertTrue(d.getVar("FOO", False) is d.getVar("FOO", False))
+        self.assertTrue(d.getVar("FOO") is d.getVar("FOO"))
 
     def test_not_memoized(self):
         d1 = bb.data.init()
         d2 = bb.data.init()
         d1.setVar("FOO", "bar")
         d2.setVar("FOO", "bar2")
-        self.assertTrue(d1.getVar("FOO", False) is not d2.getVar("FOO", False))
+        self.assertTrue(d1.getVar("FOO") is not d2.getVar("FOO"))
 
     def test_changed_after_memoized(self):
         d = bb.data.init()
         d.setVar("foo", "value of foo")
-        self.assertEqual(str(d.getVar("foo", False)), "value of foo")
+        self.assertEqual(str(d.getVar("foo")), "value of foo")
         d.setVar("foo", "second value of foo")
-        self.assertEqual(str(d.getVar("foo", False)), "second value of foo")
+        self.assertEqual(str(d.getVar("foo")), "second value of foo")
 
     def test_same_value(self):
         d = bb.data.init()
         d.setVar("foo", "value of")
         d.setVar("bar", "value of")
-        self.assertEqual(d.getVar("foo", False),
-                         d.getVar("bar", False))
+        self.assertEqual(d.getVar("foo"),
+                         d.getVar("bar"))
 
 class TestConcat(unittest.TestCase):
     def setUp(self):
@@ -234,19 +199,19 @@ class TestConcat(unittest.TestCase):
     def test_prepend(self):
         self.d.setVar("TEST", "${VAL}")
         self.d.prependVar("TEST", "${FOO}:")
-        self.assertEqual(self.d.getVar("TEST"), "foo:val")
+        self.assertEqual(self.d.getVar("TEST", True), "foo:val")
 
     def test_append(self):
         self.d.setVar("TEST", "${VAL}")
         self.d.appendVar("TEST", ":${BAR}")
-        self.assertEqual(self.d.getVar("TEST"), "val:bar")
+        self.assertEqual(self.d.getVar("TEST", True), "val:bar")
 
     def test_multiple_append(self):
         self.d.setVar("TEST", "${VAL}")
         self.d.prependVar("TEST", "${FOO}:")
         self.d.appendVar("TEST", ":val2")
         self.d.appendVar("TEST", ":${BAR}")
-        self.assertEqual(self.d.getVar("TEST"), "foo:val:val2:bar")
+        self.assertEqual(self.d.getVar("TEST", True), "foo:val:val2:bar")
 
 class TestConcatOverride(unittest.TestCase):
     def setUp(self):
@@ -258,66 +223,55 @@ class TestConcatOverride(unittest.TestCase):
     def test_prepend(self):
         self.d.setVar("TEST", "${VAL}")
         self.d.setVar("TEST_prepend", "${FOO}:")
-        self.assertEqual(self.d.getVar("TEST"), "foo:val")
+        bb.data.update_data(self.d)
+        self.assertEqual(self.d.getVar("TEST", True), "foo:val")
 
     def test_append(self):
         self.d.setVar("TEST", "${VAL}")
         self.d.setVar("TEST_append", ":${BAR}")
-        self.assertEqual(self.d.getVar("TEST"), "val:bar")
+        bb.data.update_data(self.d)
+        self.assertEqual(self.d.getVar("TEST", True), "val:bar")
 
     def test_multiple_append(self):
         self.d.setVar("TEST", "${VAL}")
         self.d.setVar("TEST_prepend", "${FOO}:")
         self.d.setVar("TEST_append", ":val2")
         self.d.setVar("TEST_append", ":${BAR}")
-        self.assertEqual(self.d.getVar("TEST"), "foo:val:val2:bar")
-
-    def test_append_unset(self):
-        self.d.setVar("TEST_prepend", "${FOO}:")
-        self.d.setVar("TEST_append", ":val2")
-        self.d.setVar("TEST_append", ":${BAR}")
-        self.assertEqual(self.d.getVar("TEST"), "foo::val2:bar")
+        bb.data.update_data(self.d)
+        self.assertEqual(self.d.getVar("TEST", True), "foo:val:val2:bar")
 
     def test_remove(self):
         self.d.setVar("TEST", "${VAL} ${BAR}")
         self.d.setVar("TEST_remove", "val")
-        self.assertEqual(self.d.getVar("TEST"), "bar")
-
-    def test_remove_cleared(self):
-        self.d.setVar("TEST", "${VAL} ${BAR}")
-        self.d.setVar("TEST_remove", "val")
-        self.d.setVar("TEST", "${VAL} ${BAR}")
-        self.assertEqual(self.d.getVar("TEST"), "val bar")
-
-    # Ensure the value is unchanged if we have an inactive remove override
-    # (including that whitespace is preserved)
-    def test_remove_inactive_override(self):
-        self.d.setVar("TEST", "${VAL} ${BAR}    123")
-        self.d.setVar("TEST_remove_inactiveoverride", "val")
-        self.assertEqual(self.d.getVar("TEST"), "val bar    123")
+        bb.data.update_data(self.d)
+        self.assertEqual(self.d.getVar("TEST", True), "bar")
 
     def test_doubleref_remove(self):
         self.d.setVar("TEST", "${VAL} ${BAR}")
         self.d.setVar("TEST_remove", "val")
         self.d.setVar("TEST_TEST", "${TEST} ${TEST}")
-        self.assertEqual(self.d.getVar("TEST_TEST"), "bar bar")
+        bb.data.update_data(self.d)
+        self.assertEqual(self.d.getVar("TEST_TEST", True), "bar bar")
 
     def test_empty_remove(self):
         self.d.setVar("TEST", "")
         self.d.setVar("TEST_remove", "val")
-        self.assertEqual(self.d.getVar("TEST"), "")
+        bb.data.update_data(self.d)
+        self.assertEqual(self.d.getVar("TEST", True), "")
 
     def test_remove_expansion(self):
         self.d.setVar("BAR", "Z")
         self.d.setVar("TEST", "${BAR}/X Y")
         self.d.setVar("TEST_remove", "${BAR}/X")
-        self.assertEqual(self.d.getVar("TEST"), "Y")
+        bb.data.update_data(self.d)
+        self.assertEqual(self.d.getVar("TEST", True), "Y")
 
     def test_remove_expansion_items(self):
         self.d.setVar("TEST", "A B C D")
         self.d.setVar("BAR", "B D")
         self.d.setVar("TEST_remove", "${BAR}")
-        self.assertEqual(self.d.getVar("TEST"), "A C")
+        bb.data.update_data(self.d)
+        self.assertEqual(self.d.getVar("TEST", True), "A C")
 
 class TestOverrides(unittest.TestCase):
     def setUp(self):
@@ -326,67 +280,21 @@ class TestOverrides(unittest.TestCase):
         self.d.setVar("TEST", "testvalue")
 
     def test_no_override(self):
-        self.assertEqual(self.d.getVar("TEST"), "testvalue")
+        bb.data.update_data(self.d)
+        self.assertEqual(self.d.getVar("TEST", True), "testvalue")
 
     def test_one_override(self):
         self.d.setVar("TEST_bar", "testvalue2")
-        self.assertEqual(self.d.getVar("TEST"), "testvalue2")
-
-    def test_one_override_unset(self):
-        self.d.setVar("TEST2_bar", "testvalue2")
-
-        self.assertEqual(self.d.getVar("TEST2"), "testvalue2")
-        self.assertCountEqual(list(self.d.keys()), ['TEST', 'TEST2', 'OVERRIDES', 'TEST2_bar'])
+        bb.data.update_data(self.d)
+        self.assertEqual(self.d.getVar("TEST", True), "testvalue2")
 
     def test_multiple_override(self):
         self.d.setVar("TEST_bar", "testvalue2")
         self.d.setVar("TEST_local", "testvalue3")
         self.d.setVar("TEST_foo", "testvalue4")
-        self.assertEqual(self.d.getVar("TEST"), "testvalue3")
-        self.assertCountEqual(list(self.d.keys()), ['TEST', 'TEST_foo', 'OVERRIDES', 'TEST_bar', 'TEST_local'])
+        bb.data.update_data(self.d)
+        self.assertEqual(self.d.getVar("TEST", True), "testvalue3")
 
-    def test_multiple_combined_overrides(self):
-        self.d.setVar("TEST_local_foo_bar", "testvalue3")
-        self.assertEqual(self.d.getVar("TEST"), "testvalue3")
-
-    def test_multiple_overrides_unset(self):
-        self.d.setVar("TEST2_local_foo_bar", "testvalue3")
-        self.assertEqual(self.d.getVar("TEST2"), "testvalue3")
-
-    def test_keyexpansion_override(self):
-        self.d.setVar("LOCAL", "local")
-        self.d.setVar("TEST_bar", "testvalue2")
-        self.d.setVar("TEST_${LOCAL}", "testvalue3")
-        self.d.setVar("TEST_foo", "testvalue4")
-        bb.data.expandKeys(self.d)
-        self.assertEqual(self.d.getVar("TEST"), "testvalue3")
-
-    def test_rename_override(self):
-        self.d.setVar("ALTERNATIVE_ncurses-tools_class-target", "a")
-        self.d.setVar("OVERRIDES", "class-target")
-        self.d.renameVar("ALTERNATIVE_ncurses-tools", "ALTERNATIVE_lib32-ncurses-tools")
-        self.assertEqual(self.d.getVar("ALTERNATIVE_lib32-ncurses-tools"), "a")
-
-    def test_underscore_override(self):
-        self.d.setVar("TEST_bar", "testvalue2")
-        self.d.setVar("TEST_some_val", "testvalue3")
-        self.d.setVar("TEST_foo", "testvalue4")
-        self.d.setVar("OVERRIDES", "foo:bar:some_val")
-        self.assertEqual(self.d.getVar("TEST"), "testvalue3")
-
-class TestKeyExpansion(unittest.TestCase):
-    def setUp(self):
-        self.d = bb.data.init()
-        self.d.setVar("FOO", "foo")
-        self.d.setVar("BAR", "foo")
-
-    def test_keyexpand(self):
-        self.d.setVar("VAL_${FOO}", "A")
-        self.d.setVar("VAL_${BAR}", "B")
-        with LogRecord() as logs:
-            bb.data.expandKeys(self.d)
-            self.assertTrue(logContains("Variable key VAL_${FOO} (A) replaces original key VAL_foo (B)", logs))
-        self.assertEqual(self.d.getVar("VAL_foo"), "A")
 
 class TestFlags(unittest.TestCase):
     def setUp(self):
@@ -396,13 +304,13 @@ class TestFlags(unittest.TestCase):
         self.d.setVarFlag("foo", "flag2", "value of flag2")
 
     def test_setflag(self):
-        self.assertEqual(self.d.getVarFlag("foo", "flag1", False), "value of flag1")
-        self.assertEqual(self.d.getVarFlag("foo", "flag2", False), "value of flag2")
+        self.assertEqual(self.d.getVarFlag("foo", "flag1"), "value of flag1")
+        self.assertEqual(self.d.getVarFlag("foo", "flag2"), "value of flag2")
 
     def test_delflag(self):
         self.d.delVarFlag("foo", "flag2")
-        self.assertEqual(self.d.getVarFlag("foo", "flag1", False), "value of flag1")
-        self.assertEqual(self.d.getVarFlag("foo", "flag2", False), None)
+        self.assertEqual(self.d.getVarFlag("foo", "flag1"), "value of flag1")
+        self.assertEqual(self.d.getVarFlag("foo", "flag2"), None)
 
 
 class Contains(unittest.TestCase):
@@ -441,167 +349,3 @@ class Contains(unittest.TestCase):
 
         self.assertFalse(bb.utils.contains_any("SOMEFLAG", "x", True, False, self.d))
         self.assertFalse(bb.utils.contains_any("SOMEFLAG", "x y z", True, False, self.d))
-
-
-class Serialize(unittest.TestCase):
-
-    def test_serialize(self):
-        import tempfile
-        import pickle
-        d = bb.data.init()
-        d.enableTracking()
-        d.setVar('HELLO', 'world')
-        d.setVarFlag('HELLO', 'other', 'planet')
-        with tempfile.NamedTemporaryFile(delete=False) as tmpfile:
-            tmpfilename = tmpfile.name
-            pickle.dump(d, tmpfile)
-
-        with open(tmpfilename, 'rb') as f:
-            newd = pickle.load(f)
-
-        os.remove(tmpfilename)
-
-        self.assertEqual(d, newd)
-        self.assertEqual(newd.getVar('HELLO'), 'world')
-        self.assertEqual(newd.getVarFlag('HELLO', 'other'), 'planet')
-
-
-# Remote datastore tests
-# These really only test the interface, since in actual usage we have a
-# tinfoil connector that does everything over RPC, and this doesn't test
-# that.
-
-class TestConnector:
-    d = None
-    def __init__(self, d):
-        self.d = d
-    def getVar(self, name):
-        return self.d._findVar(name)
-    def getKeys(self):
-        return set(self.d.keys())
-    def getVarHistory(self, name):
-        return self.d.varhistory.variable(name)
-    def expandPythonRef(self, varname, expr, d):
-        localdata = self.d.createCopy()
-        for key in d.localkeys():
-            localdata.setVar(d.getVar(key))
-        varparse = bb.data_smart.VariableParse(varname, localdata)
-        return varparse.python_sub(expr)
-    def setVar(self, name, value):
-        self.d.setVar(name, value)
-    def setVarFlag(self, name, flag, value):
-        self.d.setVarFlag(name, flag, value)
-    def delVar(self, name):
-        self.d.delVar(name)
-        return False
-    def delVarFlag(self, name, flag):
-        self.d.delVarFlag(name, flag)
-        return False
-    def renameVar(self, name, newname):
-        self.d.renameVar(name, newname)
-        return False
-
-class Remote(unittest.TestCase):
-    def test_remote(self):
-
-        d1 = bb.data.init()
-        d1.enableTracking()
-        d2 = bb.data.init()
-        d2.enableTracking()
-        connector = TestConnector(d1)
-
-        d2.setVar('_remote_data', connector)
-
-        d1.setVar('HELLO', 'world')
-        d1.setVarFlag('OTHER', 'flagname', 'flagvalue')
-        self.assertEqual(d2.getVar('HELLO'), 'world')
-        self.assertEqual(d2.expand('${HELLO}'), 'world')
-        self.assertEqual(d2.expand('${@d.getVar("HELLO")}'), 'world')
-        self.assertIn('flagname', d2.getVarFlags('OTHER'))
-        self.assertEqual(d2.getVarFlag('OTHER', 'flagname'), 'flagvalue')
-        self.assertEqual(d1.varhistory.variable('HELLO'), d2.varhistory.variable('HELLO'))
-        # Test setVar on client side affects server
-        d2.setVar('HELLO', 'other-world')
-        self.assertEqual(d1.getVar('HELLO'), 'other-world')
-        # Test setVarFlag on client side affects server
-        d2.setVarFlag('HELLO', 'flagname', 'flagvalue')
-        self.assertEqual(d1.getVarFlag('HELLO', 'flagname'), 'flagvalue')
-        # Test client side data is incorporated in python expansion (which is done on server)
-        d2.setVar('FOO', 'bar')
-        self.assertEqual(d2.expand('${@d.getVar("FOO")}'), 'bar')
-        # Test overrides work
-        d1.setVar('FOO_test', 'baz')
-        d1.appendVar('OVERRIDES', ':test')
-        self.assertEqual(d2.getVar('FOO'), 'baz')
-
-
-# Remote equivalents of local test classes
-# Note that these aren't perfect since we only test in one direction
-
-class RemoteDataExpansions(DataExpansions):
-    def setUp(self):
-        self.d1 = bb.data.init()
-        self.d = bb.data.init()
-        self.d1["foo"] = "value_of_foo"
-        self.d1["bar"] = "value_of_bar"
-        self.d1["value_of_foo"] = "value_of_'value_of_foo'"
-        connector = TestConnector(self.d1)
-        self.d.setVar('_remote_data', connector)
-
-class TestRemoteNestedExpansions(TestNestedExpansions):
-    def setUp(self):
-        self.d1 = bb.data.init()
-        self.d = bb.data.init()
-        self.d1["foo"] = "foo"
-        self.d1["bar"] = "bar"
-        self.d1["value_of_foobar"] = "187"
-        connector = TestConnector(self.d1)
-        self.d.setVar('_remote_data', connector)
-
-class TestRemoteConcat(TestConcat):
-    def setUp(self):
-        self.d1 = bb.data.init()
-        self.d = bb.data.init()
-        self.d1.setVar("FOO", "foo")
-        self.d1.setVar("VAL", "val")
-        self.d1.setVar("BAR", "bar")
-        connector = TestConnector(self.d1)
-        self.d.setVar('_remote_data', connector)
-
-class TestRemoteConcatOverride(TestConcatOverride):
-    def setUp(self):
-        self.d1 = bb.data.init()
-        self.d = bb.data.init()
-        self.d1.setVar("FOO", "foo")
-        self.d1.setVar("VAL", "val")
-        self.d1.setVar("BAR", "bar")
-        connector = TestConnector(self.d1)
-        self.d.setVar('_remote_data', connector)
-
-class TestRemoteOverrides(TestOverrides):
-    def setUp(self):
-        self.d1 = bb.data.init()
-        self.d = bb.data.init()
-        self.d1.setVar("OVERRIDES", "foo:bar:local")
-        self.d1.setVar("TEST", "testvalue")
-        connector = TestConnector(self.d1)
-        self.d.setVar('_remote_data', connector)
-
-class TestRemoteKeyExpansion(TestKeyExpansion):
-    def setUp(self):
-        self.d1 = bb.data.init()
-        self.d = bb.data.init()
-        self.d1.setVar("FOO", "foo")
-        self.d1.setVar("BAR", "foo")
-        connector = TestConnector(self.d1)
-        self.d.setVar('_remote_data', connector)
-
-class TestRemoteFlags(TestFlags):
-    def setUp(self):
-        self.d1 = bb.data.init()
-        self.d = bb.data.init()
-        self.d1.setVar("foo", "value of foo")
-        self.d1.setVarFlag("foo", "flag1", "value of flag1")
-        self.d1.setVarFlag("foo", "flag2", "value of flag2")
-        connector = TestConnector(self.d1)
-        self.d.setVar('_remote_data', connector)

bitbake/lib/bb/tests/fetch.py

@@ -22,10 +22,8 @@
 import unittest
 import tempfile
 import subprocess
-import collections
 import os
 from bb.fetch2 import URI
-from bb.fetch2 import FetchMethod
 import bb
 
 class URITest(unittest.TestCase):
@@ -134,10 +132,10 @@ class URITest(unittest.TestCase):
             'userinfo': 'anoncvs:anonymous',
             'username': 'anoncvs',
             'password': 'anonymous',
-            'params': collections.OrderedDict([
-                ('tag', 'V0-99-81'),
-                ('module', 'familiar/dist/ipkg')
-            ]),
+            'params': {
+                'tag': 'V0-99-81',
+                'module': 'familiar/dist/ipkg'
+            },
             'query': {},
             'relative': False
         },
@@ -229,38 +227,7 @@ class URITest(unittest.TestCase):
             'params': {},
             'query': {},
             'relative': False
-        },
-        "http://somesite.net;someparam=1": {
-            'uri': 'http://somesite.net;someparam=1',
-            'scheme': 'http',
-            'hostname': 'somesite.net',
-            'port': None,
-            'hostport': 'somesite.net',
-            'path': '',
-            'userinfo': '',
-            'userinfo': '',
-            'username': '',
-            'password': '',
-            'params': {"someparam" : "1"},
-            'query': {},
-            'relative': False
-        },
-        "file://somelocation;someparam=1": {
-            'uri': 'file:somelocation;someparam=1',
-            'scheme': 'file',
-            'hostname': '',
-            'port': None,
-            'hostport': '',
-            'path': 'somelocation',
-            'userinfo': '',
-            'userinfo': '',
-            'username': '',
-            'password': '',
-            'params': {"someparam" : "1"},
-            'query': {},
-            'relative': True
         }
-
     }
 
     def test_uri(self):
@@ -347,7 +314,6 @@ class URITest(unittest.TestCase):
 class FetcherTest(unittest.TestCase):
 
     def setUp(self):
-        self.origdir = os.getcwd()
         self.d = bb.data.init()
         self.tempdir = tempfile.mkdtemp()
         self.dldir = os.path.join(self.tempdir, "download")
@@ -359,11 +325,7 @@ class FetcherTest(unittest.TestCase):
         self.d.setVar("PERSISTENT_DIR", persistdir)
 
     def tearDown(self):
-        os.chdir(self.origdir)
-        if os.environ.get("BB_TMPDIR_NOCLEAN") == "yes":
-            print("Not cleaning up %s. Please remove manually." % self.tempdir)
-        else:
-            bb.utils.prunedir(self.tempdir)
+        bb.utils.prunedir(self.tempdir)
 
 class MirrorUriTest(FetcherTest):
 
@@ -428,33 +390,11 @@ class MirrorUriTest(FetcherTest):
         uris, uds = bb.fetch2.build_mirroruris(fetcher, mirrors, self.d)
         self.assertEqual(uris, ['file:///someotherpath/downloads/bitbake-1.0.tar.gz'])
 
-    def test_mirror_of_mirror(self):
-        # Test if mirror of a mirror works
-        mirrorvar = self.mirrorvar + " http://.*/.* http://otherdownloads.yoctoproject.org/downloads/ \n"
-        mirrorvar = mirrorvar + " http://otherdownloads.yoctoproject.org/.* http://downloads2.yoctoproject.org/downloads/ \n"
-        fetcher = bb.fetch.FetchData("http://downloads.yoctoproject.org/releases/bitbake/bitbake-1.0.tar.gz", self.d)
-        mirrors = bb.fetch2.mirror_from_string(mirrorvar)
-        uris, uds = bb.fetch2.build_mirroruris(fetcher, mirrors, self.d)
-        self.assertEqual(uris, ['file:///somepath/downloads/bitbake-1.0.tar.gz', 
-                                'file:///someotherpath/downloads/bitbake-1.0.tar.gz', 
-                                'http://otherdownloads.yoctoproject.org/downloads/bitbake-1.0.tar.gz',
-                                'http://downloads2.yoctoproject.org/downloads/bitbake-1.0.tar.gz'])
-
-    recmirrorvar = "https://.*/[^/]*    http://AAAA/A/A/A/ \n" \
-                   "https://.*/[^/]*    https://BBBB/B/B/B/ \n"
-
-    def test_recursive(self):
-        fetcher = bb.fetch.FetchData("https://downloads.yoctoproject.org/releases/bitbake/bitbake-1.0.tar.gz", self.d)
-        mirrors = bb.fetch2.mirror_from_string(self.recmirrorvar)
-        uris, uds = bb.fetch2.build_mirroruris(fetcher, mirrors, self.d)
-        self.assertEqual(uris, ['http://AAAA/A/A/A/bitbake/bitbake-1.0.tar.gz',
-                                'https://BBBB/B/B/B/bitbake/bitbake-1.0.tar.gz',
-                                'http://AAAA/A/A/A/B/B/bitbake/bitbake-1.0.tar.gz'])
 
 class FetcherLocalTest(FetcherTest):
     def setUp(self):
         def touch(fn):
-            with open(fn, 'a'):
+            with file(fn, 'a'):
                 os.utime(fn, None)
 
         super(FetcherLocalTest, self).setUp()
@@ -486,7 +426,9 @@ class FetcherLocalTest(FetcherTest):
 
     def test_local_wildcard(self):
         tree = self.fetchUnpack(['file://a', 'file://dir/*'])
-        self.assertEqual(tree, ['a',  'dir/c', 'dir/d', 'dir/subdir/e'])
+        # FIXME: this is broken - it should return ['a', 'dir/c', 'dir/d', 'dir/subdir/e']
+        # see https://bugzilla.yoctoproject.org/show_bug.cgi?id=6128
+        self.assertEqual(tree, ['a', 'b', 'dir/c', 'dir/d', 'dir/subdir/e'])
 
     def test_local_dir(self):
         tree = self.fetchUnpack(['file://a', 'file://dir'])
@@ -494,29 +436,22 @@ class FetcherLocalTest(FetcherTest):
 
     def test_local_subdir(self):
         tree = self.fetchUnpack(['file://dir/subdir'])
-        self.assertEqual(tree, ['dir/subdir/e'])
+        # FIXME: this is broken - it should return ['dir/subdir/e']
+        # see https://bugzilla.yoctoproject.org/show_bug.cgi?id=6129
+        self.assertEqual(tree, ['subdir/e'])
 
     def test_local_subdir_file(self):
         tree = self.fetchUnpack(['file://dir/subdir/e'])
         self.assertEqual(tree, ['dir/subdir/e'])
 
     def test_local_subdirparam(self):
-        tree = self.fetchUnpack(['file://a;subdir=bar', 'file://dir;subdir=foo/moo'])
-        self.assertEqual(tree, ['bar/a', 'foo/moo/dir/c', 'foo/moo/dir/d', 'foo/moo/dir/subdir/e'])
+        tree = self.fetchUnpack(['file://a;subdir=bar'])
+        self.assertEqual(tree, ['bar/a'])
 
     def test_local_deepsubdirparam(self):
         tree = self.fetchUnpack(['file://dir/subdir/e;subdir=bar'])
         self.assertEqual(tree, ['bar/dir/subdir/e'])
 
-    def test_local_absolutedir(self):
-        # Unpacking to an absolute path that is a subdirectory of the root
-        # should work
-        tree = self.fetchUnpack(['file://a;subdir=%s' % os.path.join(self.unpackdir, 'bar')])
-
-        # Unpacking to an absolute path outside of the root should fail
-        with self.assertRaises(bb.fetch2.UnpackError):
-            self.fetchUnpack(['file://a;subdir=/bin/sh'])
-
 class FetcherNetworkTest(FetcherTest):
 
     if os.environ.get("BB_SKIP_NETTESTS") == "yes":
@@ -540,19 +475,6 @@ class FetcherNetworkTest(FetcherTest):
             fetcher.download()
             self.assertEqual(os.path.getsize(self.dldir + "/bitbake-1.0.tar.gz"), 57749)
 
-        def test_fetch_mirror_of_mirror(self):
-            self.d.setVar("MIRRORS", "http://.*/.* http://invalid2.yoctoproject.org/ \n http://invalid2.yoctoproject.org/.* http://downloads.yoctoproject.org/releases/bitbake")
-            fetcher = bb.fetch.Fetch(["http://invalid.yoctoproject.org/releases/bitbake/bitbake-1.0.tar.gz"], self.d)
-            fetcher.download()
-            self.assertEqual(os.path.getsize(self.dldir + "/bitbake-1.0.tar.gz"), 57749)
-
-        def test_fetch_file_mirror_of_mirror(self):
-            self.d.setVar("MIRRORS", "http://.*/.* file:///some1where/ \n file:///some1where/.* file://some2where/ \n file://some2where/.* http://downloads.yoctoproject.org/releases/bitbake")
-            fetcher = bb.fetch.Fetch(["http://invalid.yoctoproject.org/releases/bitbake/bitbake-1.0.tar.gz"], self.d)
-            os.mkdir(self.dldir + "/some2where")
-            fetcher.download()
-            self.assertEqual(os.path.getsize(self.dldir + "/bitbake-1.0.tar.gz"), 57749)
-
         def test_fetch_premirror(self):
             self.d.setVar("PREMIRRORS", "http://.*/.* http://downloads.yoctoproject.org/releases/bitbake")
             fetcher = bb.fetch.Fetch(["http://invalid.yoctoproject.org/releases/bitbake/bitbake-1.0.tar.gz"], self.d)
@@ -597,36 +519,6 @@ class FetcherNetworkTest(FetcherTest):
             url1 = url2 = "git://git.openembedded.org/bitbake;rev=270a05b0b4ba0959fe0624d2a4885d7b70426da5;tag=270a05b0b4ba0959fe0624d2a4885d7b70426da5"
             self.assertRaises(bb.fetch.FetchError, self.gitfetcher, url1, url2)
 
-        def test_gitfetch_localusehead(self):
-            # Create dummy local Git repo
-            src_dir = tempfile.mkdtemp(dir=self.tempdir,
-                                       prefix='gitfetch_localusehead_')
-            src_dir = os.path.abspath(src_dir)
-            bb.process.run("git init", cwd=src_dir)
-            bb.process.run("git commit --allow-empty -m'Dummy commit'",
-                           cwd=src_dir)
-            # Use other branch than master
-            bb.process.run("git checkout -b my-devel", cwd=src_dir)
-            bb.process.run("git commit --allow-empty -m'Dummy commit 2'",
-                           cwd=src_dir)
-            stdout = bb.process.run("git rev-parse HEAD", cwd=src_dir)
-            orig_rev = stdout[0].strip()
-
-            # Fetch and check revision
-            self.d.setVar("SRCREV", "AUTOINC")
-            url = "git://" + src_dir + ";protocol=file;usehead=1"
-            fetcher = bb.fetch.Fetch([url], self.d)
-            fetcher.download()
-            fetcher.unpack(self.unpackdir)
-            stdout = bb.process.run("git rev-parse HEAD",
-                                    cwd=os.path.join(self.unpackdir, 'git'))
-            unpack_rev = stdout[0].strip()
-            self.assertEqual(orig_rev, unpack_rev)
-
-        def test_gitfetch_remoteusehead(self):
-            url = "git://git.openembedded.org/bitbake;usehead=1"
-            self.assertRaises(bb.fetch.ParameterError, self.gitfetcher, url, url)
-
         def test_gitfetch_premirror(self):
             url1 = "git://git.openembedded.org/bitbake"
             url2 = "git://someserver.org/bitbake"
@@ -654,68 +546,17 @@ class FetcherNetworkTest(FetcherTest):
             os.chdir(os.path.dirname(self.unpackdir))
             fetcher.unpack(self.unpackdir)
 
-
-class TrustedNetworksTest(FetcherTest):
-    def test_trusted_network(self):
-        # Ensure trusted_network returns False when the host IS in the list.
-        url = "git://Someserver.org/foo;rev=1"
-        self.d.setVar("BB_ALLOWED_NETWORKS", "server1.org someserver.org server2.org server3.org")
-        self.assertTrue(bb.fetch.trusted_network(self.d, url))
-
-    def test_wild_trusted_network(self):
-        # Ensure trusted_network returns true when the *.host IS in the list.
-        url = "git://Someserver.org/foo;rev=1"
-        self.d.setVar("BB_ALLOWED_NETWORKS", "server1.org *.someserver.org server2.org server3.org")
-        self.assertTrue(bb.fetch.trusted_network(self.d, url))
-
-    def test_prefix_wild_trusted_network(self):
-        # Ensure trusted_network returns true when the prefix matches *.host.
-        url = "git://git.Someserver.org/foo;rev=1"
-        self.d.setVar("BB_ALLOWED_NETWORKS", "server1.org *.someserver.org server2.org server3.org")
-        self.assertTrue(bb.fetch.trusted_network(self.d, url))
-
-    def test_two_prefix_wild_trusted_network(self):
-        # Ensure trusted_network returns true when the prefix matches *.host.
-        url = "git://something.git.Someserver.org/foo;rev=1"
-        self.d.setVar("BB_ALLOWED_NETWORKS", "server1.org *.someserver.org server2.org server3.org")
-        self.assertTrue(bb.fetch.trusted_network(self.d, url))
-
-    def test_port_trusted_network(self):
-        # Ensure trusted_network returns True, even if the url specifies a port.
-        url = "git://someserver.org:8080/foo;rev=1"
-        self.d.setVar("BB_ALLOWED_NETWORKS", "someserver.org")
-        self.assertTrue(bb.fetch.trusted_network(self.d, url))
-
-    def test_untrusted_network(self):
-        # Ensure trusted_network returns False when the host is NOT in the list.
-        url = "git://someserver.org/foo;rev=1"
-        self.d.setVar("BB_ALLOWED_NETWORKS", "server1.org server2.org server3.org")
-        self.assertFalse(bb.fetch.trusted_network(self.d, url))
-
-    def test_wild_untrusted_network(self):
-        # Ensure trusted_network returns False when the host is NOT in the list.
-        url = "git://*.someserver.org/foo;rev=1"
-        self.d.setVar("BB_ALLOWED_NETWORKS", "server1.org server2.org server3.org")
-        self.assertFalse(bb.fetch.trusted_network(self.d, url))
-
 class URLHandle(unittest.TestCase):
 
     datatable = {
        "http://www.google.com/index.html" : ('http', 'www.google.com', '/index.html', '', '', {}),
        "cvs://anoncvs@cvs.handhelds.org/cvs;module=familiar/dist/ipkg" : ('cvs', 'cvs.handhelds.org', '/cvs', 'anoncvs', '', {'module': 'familiar/dist/ipkg'}),
-       "cvs://anoncvs:anonymous@cvs.handhelds.org/cvs;tag=V0-99-81;module=familiar/dist/ipkg" : ('cvs', 'cvs.handhelds.org', '/cvs', 'anoncvs', 'anonymous', collections.OrderedDict([('tag', 'V0-99-81'), ('module', 'familiar/dist/ipkg')])),
-       "git://git.openembedded.org/bitbake;branch=@foo" : ('git', 'git.openembedded.org', '/bitbake', '', '', {'branch': '@foo'}),
-       "file://somelocation;someparam=1": ('file', '', 'somelocation', '', '', {'someparam': '1'}),
+       "cvs://anoncvs:anonymous@cvs.handhelds.org/cvs;tag=V0-99-81;module=familiar/dist/ipkg" : ('cvs', 'cvs.handhelds.org', '/cvs', 'anoncvs', 'anonymous', {'tag': 'V0-99-81', 'module': 'familiar/dist/ipkg'}),
+       "git://git.openembedded.org/bitbake;branch=@foo" : ('git', 'git.openembedded.org', '/bitbake', '', '', {'branch': '@foo'})
     }
-    # we require a pathname to encodeurl but users can still pass such urls to 
-    # decodeurl and we need to handle them
-    decodedata = datatable.copy()
-    decodedata.update({
-       "http://somesite.net;someparam=1": ('http', 'somesite.net', '', '', '', {'someparam': '1'}),
-    })
 
     def test_decodeurl(self):
-        for k, v in self.decodedata.items():
+        for k, v in self.datatable.items():
             result = bb.fetch.decodeurl(k)
             self.assertEqual(result, v)
 
@@ -724,131 +565,5 @@ class URLHandle(unittest.TestCase):
             result = bb.fetch.encodeurl(v)
             self.assertEqual(result, k)
 
-class FetchLatestVersionTest(FetcherTest):
-
-    test_git_uris = {
-        # version pattern "X.Y.Z"
-        ("mx-1.0", "git://github.com/clutter-project/mx.git;branch=mx-1.4", "9b1db6b8060bd00b121a692f942404a24ae2960f", "")
-            : "1.99.4",
-        # version pattern "vX.Y"
-        ("mtd-utils", "git://git.infradead.org/mtd-utils.git", "ca39eb1d98e736109c64ff9c1aa2a6ecca222d8f", "")
-            : "1.5.0",
-        # version pattern "pkg_name-X.Y"
-        ("presentproto", "git://anongit.freedesktop.org/git/xorg/proto/presentproto", "24f3a56e541b0a9e6c6ee76081f441221a120ef9", "")
-            : "1.0",
-        # version pattern "pkg_name-vX.Y.Z"
-        ("dtc", "git://git.qemu.org/dtc.git", "65cc4d2748a2c2e6f27f1cf39e07a5dbabd80ebf", "")
-            : "1.4.0",
-        # combination version pattern
-        ("sysprof", "git://git.gnome.org/sysprof", "cd44ee6644c3641507fb53b8a2a69137f2971219", "")
-            : "1.2.0",
-        ("u-boot-mkimage", "git://git.denx.de/u-boot.git;branch=master;protocol=git", "62c175fbb8a0f9a926c88294ea9f7e88eb898f6c", "")
-            : "2014.01",
-        # version pattern "yyyymmdd"
-        ("mobile-broadband-provider-info", "git://git.gnome.org/mobile-broadband-provider-info", "4ed19e11c2975105b71b956440acdb25d46a347d", "")
-            : "20120614",
-        # packages with a valid UPSTREAM_CHECK_GITTAGREGEX
-        ("xf86-video-omap", "git://anongit.freedesktop.org/xorg/driver/xf86-video-omap", "ae0394e687f1a77e966cf72f895da91840dffb8f", "(?P<pver>(\d+\.(\d\.?)*))")
-            : "0.4.3",
-        ("build-appliance-image", "git://git.yoctoproject.org/poky", "b37dd451a52622d5b570183a81583cc34c2ff555", "(?P<pver>(([0-9][\.|_]?)+[0-9]))")
-            : "11.0.0",
-        ("chkconfig-alternatives-native", "git://github.com/kergoth/chkconfig;branch=sysroot", "cd437ecbd8986c894442f8fce1e0061e20f04dee", "chkconfig\-(?P<pver>((\d+[\.\-_]*)+))")
-            : "1.3.59",
-        ("remake", "git://github.com/rocky/remake.git", "f05508e521987c8494c92d9c2871aec46307d51d", "(?P<pver>(\d+\.(\d+\.)*\d*(\+dbg\d+(\.\d+)*)*))")
-            : "3.82+dbg0.9",
-    }
-
-    test_wget_uris = {
-        # packages with versions inside directory name
-        ("util-linux", "http://kernel.org/pub/linux/utils/util-linux/v2.23/util-linux-2.24.2.tar.bz2", "", "")
-            : "2.24.2",
-        ("enchant", "http://www.abisource.com/downloads/enchant/1.6.0/enchant-1.6.0.tar.gz", "", "")
-            : "1.6.0",
-        ("cmake", "http://www.cmake.org/files/v2.8/cmake-2.8.12.1.tar.gz", "", "")
-            : "2.8.12.1",
-        # packages with versions only in current directory
-        ("eglic", "http://downloads.yoctoproject.org/releases/eglibc/eglibc-2.18-svnr23787.tar.bz2", "", "")
-            : "2.19",
-        ("gnu-config", "http://downloads.yoctoproject.org/releases/gnu-config/gnu-config-20120814.tar.bz2", "", "")
-            : "20120814",
-        # packages with "99" in the name of possible version
-        ("pulseaudio", "http://freedesktop.org/software/pulseaudio/releases/pulseaudio-4.0.tar.xz", "", "")
-            : "5.0",
-        ("xserver-xorg", "http://xorg.freedesktop.org/releases/individual/xserver/xorg-server-1.15.1.tar.bz2", "", "")
-            : "1.15.1",
-        # packages with valid UPSTREAM_CHECK_URI and UPSTREAM_CHECK_REGEX
-        ("cups", "http://www.cups.org/software/1.7.2/cups-1.7.2-source.tar.bz2", "https://github.com/apple/cups/releases", "(?P<name>cups\-)(?P<pver>((\d+[\.\-_]*)+))\-source\.tar\.gz")
-            : "2.0.0",
-        ("db", "http://download.oracle.com/berkeley-db/db-5.3.21.tar.gz", "http://www.oracle.com/technetwork/products/berkeleydb/downloads/index-082944.html", "http://download.oracle.com/otn/berkeley-db/(?P<name>db-)(?P<pver>((\d+[\.\-_]*)+))\.tar\.gz")
-            : "6.1.19",
-    }
-    if os.environ.get("BB_SKIP_NETTESTS") == "yes":
-        print("Unset BB_SKIP_NETTESTS to run network tests")
-    else:
-        def test_git_latest_versionstring(self):
-            for k, v in self.test_git_uris.items():
-                self.d.setVar("PN", k[0])
-                self.d.setVar("SRCREV", k[2])
-                self.d.setVar("UPSTREAM_CHECK_GITTAGREGEX", k[3])
-                ud = bb.fetch2.FetchData(k[1], self.d)
-                pupver= ud.method.latest_versionstring(ud, self.d)
-                verstring = pupver[0]
-                r = bb.utils.vercmp_string(v, verstring)
-                self.assertTrue(r == -1 or r == 0, msg="Package %s, version: %s <= %s" % (k[0], v, verstring))
-
-        def test_wget_latest_versionstring(self):
-            for k, v in self.test_wget_uris.items():
-                self.d.setVar("PN", k[0])
-                self.d.setVar("UPSTREAM_CHECK_URI", k[2])
-                self.d.setVar("UPSTREAM_CHECK_REGEX", k[3])
-                ud = bb.fetch2.FetchData(k[1], self.d)
-                pupver = ud.method.latest_versionstring(ud, self.d)
-                verstring = pupver[0]
-                r = bb.utils.vercmp_string(v, verstring)
-                self.assertTrue(r == -1 or r == 0, msg="Package %s, version: %s <= %s" % (k[0], v, verstring))
 
 
-class FetchCheckStatusTest(FetcherTest):
-    test_wget_uris = ["http://www.cups.org/software/1.7.2/cups-1.7.2-source.tar.bz2",
-                      "http://www.cups.org/",
-                      "http://downloads.yoctoproject.org/releases/sato/sato-engine-0.1.tar.gz",
-                      "http://downloads.yoctoproject.org/releases/sato/sato-engine-0.2.tar.gz",
-                      "http://downloads.yoctoproject.org/releases/sato/sato-engine-0.3.tar.gz",
-                      "https://yoctoproject.org/",
-                      "https://yoctoproject.org/documentation",
-                      "http://downloads.yoctoproject.org/releases/opkg/opkg-0.1.7.tar.gz",
-                      "http://downloads.yoctoproject.org/releases/opkg/opkg-0.3.0.tar.gz",
-                      "ftp://ftp.gnu.org/gnu/autoconf/autoconf-2.60.tar.gz",
-                      "ftp://ftp.gnu.org/gnu/chess/gnuchess-5.08.tar.gz",
-                      "ftp://ftp.gnu.org/gnu/gmp/gmp-4.0.tar.gz",
-                      # GitHub releases are hosted on Amazon S3, which doesn't support HEAD
-                      "https://github.com/kergoth/tslib/releases/download/1.1/tslib-1.1.tar.xz"
-                      ]
-
-    if os.environ.get("BB_SKIP_NETTESTS") == "yes":
-        print("Unset BB_SKIP_NETTESTS to run network tests")
-    else:
-
-        def test_wget_checkstatus(self):
-            fetch = bb.fetch2.Fetch(self.test_wget_uris, self.d)
-            for u in self.test_wget_uris:
-                ud = fetch.ud[u]
-                m = ud.method
-                ret = m.checkstatus(fetch, ud, self.d)
-                self.assertTrue(ret, msg="URI %s, can't check status" % (u))
-
-
-        def test_wget_checkstatus_connection_cache(self):
-            from bb.fetch2 import FetchConnectionCache
-
-            connection_cache = FetchConnectionCache()
-            fetch = bb.fetch2.Fetch(self.test_wget_uris, self.d,
-                        connection_cache = connection_cache)
-
-            for u in self.test_wget_uris:
-                ud = fetch.ud[u]
-                m = ud.method
-                ret = m.checkstatus(fetch, ud, self.d)
-                self.assertTrue(ret, msg="URI %s, can't check status" % (u))
-
-            connection_cache.close_connections()

bitbake/lib/bb/tests/parse.py

@@ -1,164 +0,0 @@
-# ex:ts=4:sw=4:sts=4:et
-# -*- tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*-
-#
-# BitBake Test for lib/bb/parse/
-#
-# Copyright (C) 2015 Richard Purdie
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License version 2 as
-# published by the Free Software Foundation.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License along
-# with this program; if not, write to the Free Software Foundation, Inc.,
-# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-#
-
-import unittest
-import tempfile
-import logging
-import bb
-import os
-
-logger = logging.getLogger('BitBake.TestParse')
-
-import bb.parse
-import bb.data
-import bb.siggen
-
-class ParseTest(unittest.TestCase):
-
-    testfile = """
-A = "1"
-B = "2"
-do_install() {
-	echo "hello"
-}
-
-C = "3"
-"""
-
-    def setUp(self):
-        self.d = bb.data.init()
-        bb.parse.siggen = bb.siggen.init(self.d)
-
-    def parsehelper(self, content, suffix = ".bb"):
-
-        f = tempfile.NamedTemporaryFile(suffix = suffix)
-        f.write(bytes(content, "utf-8"))
-        f.flush()
-        os.chdir(os.path.dirname(f.name))
-        return f
-
-    def test_parse_simple(self):
-        f = self.parsehelper(self.testfile)
-        d = bb.parse.handle(f.name, self.d)['']
-        self.assertEqual(d.getVar("A"), "1")
-        self.assertEqual(d.getVar("B"), "2")
-        self.assertEqual(d.getVar("C"), "3")
-
-    def test_parse_incomplete_function(self):
-        testfileB = self.testfile.replace("}", "")
-        f = self.parsehelper(testfileB)
-        with self.assertRaises(bb.parse.ParseError):
-            d = bb.parse.handle(f.name, self.d)['']
-
-    unsettest = """
-A = "1"
-B = "2"
-B[flag] = "3"
-
-unset A
-unset B[flag]
-"""
-
-    def test_parse_unset(self):
-        f = self.parsehelper(self.unsettest)
-        d = bb.parse.handle(f.name, self.d)['']
-        self.assertEqual(d.getVar("A"), None)
-        self.assertEqual(d.getVarFlag("A","flag"), None)
-        self.assertEqual(d.getVar("B"), "2")
-        
-
-    overridetest = """
-RRECOMMENDS_${PN} = "a"
-RRECOMMENDS_${PN}_libc = "b"
-OVERRIDES = "libc:${PN}"
-PN = "gtk+"
-"""
-
-    def test_parse_overrides(self):
-        f = self.parsehelper(self.overridetest)
-        d = bb.parse.handle(f.name, self.d)['']
-        self.assertEqual(d.getVar("RRECOMMENDS"), "b")
-        bb.data.expandKeys(d)
-        self.assertEqual(d.getVar("RRECOMMENDS"), "b")
-        d.setVar("RRECOMMENDS_gtk+", "c")
-        self.assertEqual(d.getVar("RRECOMMENDS"), "c")
-
-    overridetest2 = """
-EXTRA_OECONF = ""
-EXTRA_OECONF_class-target = "b"
-EXTRA_OECONF_append = " c"
-"""
-
-    def test_parse_overrides(self):
-        f = self.parsehelper(self.overridetest2)
-        d = bb.parse.handle(f.name, self.d)['']
-        d.appendVar("EXTRA_OECONF", " d")
-        d.setVar("OVERRIDES", "class-target")
-        self.assertEqual(d.getVar("EXTRA_OECONF"), "b c d")
-
-    overridetest3 = """
-DESCRIPTION = "A"
-DESCRIPTION_${PN}-dev = "${DESCRIPTION} B"
-PN = "bc"
-"""
-
-    def test_parse_combinations(self):
-        f = self.parsehelper(self.overridetest3)
-        d = bb.parse.handle(f.name, self.d)['']
-        bb.data.expandKeys(d)
-        self.assertEqual(d.getVar("DESCRIPTION_bc-dev"), "A B")
-        d.setVar("DESCRIPTION", "E")
-        d.setVar("DESCRIPTION_bc-dev", "C D")
-        d.setVar("OVERRIDES", "bc-dev")
-        self.assertEqual(d.getVar("DESCRIPTION"), "C D")
-
-
-    classextend = """
-VAR_var_override1 = "B"
-EXTRA = ":override1"
-OVERRIDES = "nothing${EXTRA}"
-
-BBCLASSEXTEND = "###CLASS###"
-"""
-    classextend_bbclass = """
-EXTRA = ""
-python () {
-    d.renameVar("VAR_var", "VAR_var2")
-}
-"""
-
-    #
-    # Test based upon a real world data corruption issue. One
-    # data store changing a variable poked through into a different data
-    # store. This test case replicates that issue where the value 'B' would 
-    # become unset/disappear.
-    #
-    def test_parse_classextend_contamination(self):
-        cls = self.parsehelper(self.classextend_bbclass, suffix=".bbclass")
-        #clsname = os.path.basename(cls.name).replace(".bbclass", "")
-        self.classextend = self.classextend.replace("###CLASS###", cls.name)
-        f = self.parsehelper(self.classextend)
-        alldata = bb.parse.handle(f.name, self.d)
-        d1 = alldata['']
-        d2 = alldata[cls.name]
-        self.assertEqual(d1.getVar("VAR_var"), "B")
-        self.assertEqual(d2.getVar("VAR_var"), None)
-

bitbake/lib/bb/tests/utils.py

@@ -22,8 +22,6 @@
 import unittest
 import bb
 import os
-import tempfile
-import re
 
 class VerCmpString(unittest.TestCase):
 
@@ -38,10 +36,6 @@ class VerCmpString(unittest.TestCase):
         self.assertTrue(result < 0)
         result = bb.utils.vercmp_string('1.1', '1_p2')
         self.assertTrue(result < 0)
-        result = bb.utils.vercmp_string('1.0', '1.0+1.1-beta1')
-        self.assertTrue(result < 0)
-        result = bb.utils.vercmp_string('1.1', '1.0+1.1-beta1')
-        self.assertTrue(result > 0)
 
     def test_explode_dep_versions(self):
         correctresult = {"foo" : ["= 1.10"]}
@@ -107,497 +101,3 @@ class Path(unittest.TestCase):
         for arg1, correctresult in checkitems:
             result = bb.utils._check_unsafe_delete_path(arg1)
             self.assertEqual(result, correctresult, '_check_unsafe_delete_path("%s") != %s' % (arg1, correctresult))
-
-
-class EditMetadataFile(unittest.TestCase):
-    _origfile = """
-# A comment
-HELLO = "oldvalue"
-
-THIS = "that"
-
-# Another comment
-NOCHANGE = "samevalue"
-OTHER = 'anothervalue'
-
-MULTILINE = "a1 \\
-             a2 \\
-             a3"
-
-MULTILINE2 := " \\
-               b1 \\
-               b2 \\
-               b3 \\
-               "
-
-
-MULTILINE3 = " \\
-              c1 \\
-              c2 \\
-              c3 \\
-"
-
-do_functionname() {
-    command1 ${VAL1} ${VAL2}
-    command2 ${VAL3} ${VAL4}
-}
-"""
-    def _testeditfile(self, varvalues, compareto, dummyvars=None):
-        if dummyvars is None:
-            dummyvars = []
-        with tempfile.NamedTemporaryFile('w', delete=False) as tf:
-            tf.write(self._origfile)
-            tf.close()
-            try:
-                varcalls = []
-                def handle_file(varname, origvalue, op, newlines):
-                    self.assertIn(varname, varvalues, 'Callback called for variable %s not in the list!' % varname)
-                    self.assertNotIn(varname, dummyvars, 'Callback called for variable %s in dummy list!' % varname)
-                    varcalls.append(varname)
-                    return varvalues[varname]
-
-                bb.utils.edit_metadata_file(tf.name, varvalues.keys(), handle_file)
-                with open(tf.name) as f:
-                    modfile = f.readlines()
-                # Ensure the output matches the expected output
-                self.assertEqual(compareto.splitlines(True), modfile)
-                # Ensure the callback function was called for every variable we asked for
-                # (plus allow testing behaviour when a requested variable is not present)
-                self.assertEqual(sorted(varvalues.keys()), sorted(varcalls + dummyvars))
-            finally:
-                os.remove(tf.name)
-
-
-    def test_edit_metadata_file_nochange(self):
-        # Test file doesn't get modified with nothing to do
-        self._testeditfile({}, self._origfile)
-        # Test file doesn't get modified with only dummy variables
-        self._testeditfile({'DUMMY1': ('should_not_set', None, 0, True),
-                        'DUMMY2': ('should_not_set_again', None, 0, True)}, self._origfile, dummyvars=['DUMMY1', 'DUMMY2'])
-        # Test file doesn't get modified with some the same values
-        self._testeditfile({'THIS': ('that', None, 0, True),
-                        'OTHER': ('anothervalue', None, 0, True),
-                        'MULTILINE3': ('               c1               c2               c3 ', None, 4, False)}, self._origfile)
-
-    def test_edit_metadata_file_1(self):
-
-        newfile1 = """
-# A comment
-HELLO = "newvalue"
-
-THIS = "that"
-
-# Another comment
-NOCHANGE = "samevalue"
-OTHER = 'anothervalue'
-
-MULTILINE = "a1 \\
-             a2 \\
-             a3"
-
-MULTILINE2 := " \\
-               b1 \\
-               b2 \\
-               b3 \\
-               "
-
-
-MULTILINE3 = " \\
-              c1 \\
-              c2 \\
-              c3 \\
-"
-
-do_functionname() {
-    command1 ${VAL1} ${VAL2}
-    command2 ${VAL3} ${VAL4}
-}
-"""
-        self._testeditfile({'HELLO': ('newvalue', None, 4, True)}, newfile1)
-
-
-    def test_edit_metadata_file_2(self):
-
-        newfile2 = """
-# A comment
-HELLO = "oldvalue"
-
-THIS = "that"
-
-# Another comment
-NOCHANGE = "samevalue"
-OTHER = 'anothervalue'
-
-MULTILINE = " \\
-    d1 \\
-    d2 \\
-    d3 \\
-    "
-
-MULTILINE2 := " \\
-               b1 \\
-               b2 \\
-               b3 \\
-               "
-
-
-MULTILINE3 = "nowsingle"
-
-do_functionname() {
-    command1 ${VAL1} ${VAL2}
-    command2 ${VAL3} ${VAL4}
-}
-"""
-        self._testeditfile({'MULTILINE': (['d1','d2','d3'], None, 4, False),
-                        'MULTILINE3': ('nowsingle', None, 4, True),
-                        'NOTPRESENT': (['a', 'b'], None, 4, False)}, newfile2, dummyvars=['NOTPRESENT'])
-
-
-    def test_edit_metadata_file_3(self):
-
-        newfile3 = """
-# A comment
-HELLO = "oldvalue"
-
-# Another comment
-NOCHANGE = "samevalue"
-OTHER = "yetanothervalue"
-
-MULTILINE = "e1 \\
-             e2 \\
-             e3 \\
-             "
-
-MULTILINE2 := "f1 \\
-\tf2 \\
-\t"
-
-
-MULTILINE3 = " \\
-              c1 \\
-              c2 \\
-              c3 \\
-"
-
-do_functionname() {
-    othercommand_one a b c
-    othercommand_two d e f
-}
-"""
-
-        self._testeditfile({'do_functionname()': (['othercommand_one a b c', 'othercommand_two d e f'], None, 4, False),
-                        'MULTILINE2': (['f1', 'f2'], None, '\t', True),
-                        'MULTILINE': (['e1', 'e2', 'e3'], None, -1, True),
-                        'THIS': (None, None, 0, False),
-                        'OTHER': ('yetanothervalue', None, 0, True)}, newfile3)
-
-
-    def test_edit_metadata_file_4(self):
-
-        newfile4 = """
-# A comment
-HELLO = "oldvalue"
-
-THIS = "that"
-
-# Another comment
-OTHER = 'anothervalue'
-
-MULTILINE = "a1 \\
-             a2 \\
-             a3"
-
-MULTILINE2 := " \\
-               b1 \\
-               b2 \\
-               b3 \\
-               "
-
-
-"""
-
-        self._testeditfile({'NOCHANGE': (None, None, 0, False),
-                        'MULTILINE3': (None, None, 0, False),
-                        'THIS': ('that', None, 0, False),
-                        'do_functionname()': (None, None, 0, False)}, newfile4)
-
-
-    def test_edit_metadata(self):
-        newfile5 = """
-# A comment
-HELLO = "hithere"
-
-# A new comment
-THIS += "that"
-
-# Another comment
-NOCHANGE = "samevalue"
-OTHER = 'anothervalue'
-
-MULTILINE = "a1 \\
-             a2 \\
-             a3"
-
-MULTILINE2 := " \\
-               b1 \\
-               b2 \\
-               b3 \\
-               "
-
-
-MULTILINE3 = " \\
-              c1 \\
-              c2 \\
-              c3 \\
-"
-
-NEWVAR = "value"
-
-do_functionname() {
-    command1 ${VAL1} ${VAL2}
-    command2 ${VAL3} ${VAL4}
-}
-"""
-
-
-        def handle_var(varname, origvalue, op, newlines):
-            if varname == 'THIS':
-                newlines.append('# A new comment\n')
-            elif varname == 'do_functionname()':
-                newlines.append('NEWVAR = "value"\n')
-                newlines.append('\n')
-            valueitem = varvalues.get(varname, None)
-            if valueitem:
-                return valueitem
-            else:
-                return (origvalue, op, 0, True)
-
-        varvalues = {'HELLO': ('hithere', None, 0, True), 'THIS': ('that', '+=', 0, True)}
-        varlist = ['HELLO', 'THIS', 'do_functionname()']
-        (updated, newlines) = bb.utils.edit_metadata(self._origfile.splitlines(True), varlist, handle_var)
-        self.assertTrue(updated, 'List should be updated but isn\'t')
-        self.assertEqual(newlines, newfile5.splitlines(True))
-
-    # Make sure the orig value matches what we expect it to be
-    def test_edit_metadata_origvalue(self):
-        origfile = """
-MULTILINE = "  stuff \\
-    morestuff"
-"""
-        expected_value = "stuff morestuff"
-        global value_in_callback
-        value_in_callback = ""
-
-        def handle_var(varname, origvalue, op, newlines):
-            global value_in_callback
-            value_in_callback = origvalue
-            return (origvalue, op, -1, False)
-
-        bb.utils.edit_metadata(origfile.splitlines(True),
-                               ['MULTILINE'],
-                               handle_var)
-
-        testvalue = re.sub('\s+', ' ', value_in_callback.strip())
-        self.assertEqual(expected_value, testvalue)
-
-class EditBbLayersConf(unittest.TestCase):
-
-    def _test_bblayers_edit(self, before, after, add, remove, notadded, notremoved):
-        with tempfile.NamedTemporaryFile('w', delete=False) as tf:
-            tf.write(before)
-            tf.close()
-            try:
-                actual_notadded, actual_notremoved = bb.utils.edit_bblayers_conf(tf.name, add, remove)
-                with open(tf.name) as f:
-                    actual_after = f.readlines()
-                self.assertEqual(after.splitlines(True), actual_after)
-                self.assertEqual(notadded, actual_notadded)
-                self.assertEqual(notremoved, actual_notremoved)
-            finally:
-                os.remove(tf.name)
-
-
-    def test_bblayers_remove(self):
-        before = r"""
-# A comment
-
-BBPATH = "${TOPDIR}"
-BBFILES ?= ""
-BBLAYERS = " \
-  /home/user/path/layer1 \
-  /home/user/path/layer2 \
-  /home/user/path/subpath/layer3 \
-  /home/user/path/layer4 \
-  "
-"""
-        after = r"""
-# A comment
-
-BBPATH = "${TOPDIR}"
-BBFILES ?= ""
-BBLAYERS = " \
-  /home/user/path/layer1 \
-  /home/user/path/subpath/layer3 \
-  /home/user/path/layer4 \
-  "
-"""
-        self._test_bblayers_edit(before, after,
-                                 None,
-                                 '/home/user/path/layer2',
-                                 [],
-                                 [])
-
-
-    def test_bblayers_add(self):
-        before = r"""
-# A comment
-
-BBPATH = "${TOPDIR}"
-BBFILES ?= ""
-BBLAYERS = " \
-  /home/user/path/layer1 \
-  /home/user/path/layer2 \
-  /home/user/path/subpath/layer3 \
-  /home/user/path/layer4 \
-  "
-"""
-        after = r"""
-# A comment
-
-BBPATH = "${TOPDIR}"
-BBFILES ?= ""
-BBLAYERS = " \
-  /home/user/path/layer1 \
-  /home/user/path/layer2 \
-  /home/user/path/subpath/layer3 \
-  /home/user/path/layer4 \
-  /other/path/to/layer5 \
-  "
-"""
-        self._test_bblayers_edit(before, after,
-                                 '/other/path/to/layer5/',
-                                 None,
-                                 [],
-                                 [])
-
-
-    def test_bblayers_add_remove(self):
-        before = r"""
-# A comment
-
-BBPATH = "${TOPDIR}"
-BBFILES ?= ""
-BBLAYERS = " \
-  /home/user/path/layer1 \
-  /home/user/path/layer2 \
-  /home/user/path/subpath/layer3 \
-  /home/user/path/layer4 \
-  "
-"""
-        after = r"""
-# A comment
-
-BBPATH = "${TOPDIR}"
-BBFILES ?= ""
-BBLAYERS = " \
-  /home/user/path/layer1 \
-  /home/user/path/layer2 \
-  /home/user/path/layer4 \
-  /other/path/to/layer5 \
-  "
-"""
-        self._test_bblayers_edit(before, after,
-                                 ['/other/path/to/layer5', '/home/user/path/layer2/'], '/home/user/path/subpath/layer3/',
-                                 ['/home/user/path/layer2'],
-                                 [])
-
-
-    def test_bblayers_add_remove_home(self):
-        before = r"""
-# A comment
-
-BBPATH = "${TOPDIR}"
-BBFILES ?= ""
-BBLAYERS = " \
-  ~/path/layer1 \
-  ~/path/layer2 \
-  ~/otherpath/layer3 \
-  ~/path/layer4 \
-  "
-"""
-        after = r"""
-# A comment
-
-BBPATH = "${TOPDIR}"
-BBFILES ?= ""
-BBLAYERS = " \
-  ~/path/layer2 \
-  ~/path/layer4 \
-  ~/path2/layer5 \
-  "
-"""
-        self._test_bblayers_edit(before, after,
-                                 [os.environ['HOME'] + '/path/layer4', '~/path2/layer5'],
-                                 [os.environ['HOME'] + '/otherpath/layer3', '~/path/layer1', '~/path/notinlist'],
-                                 [os.environ['HOME'] + '/path/layer4'],
-                                 ['~/path/notinlist'])
-
-
-    def test_bblayers_add_remove_plusequals(self):
-        before = r"""
-# A comment
-
-BBPATH = "${TOPDIR}"
-BBFILES ?= ""
-BBLAYERS += " \
-  /home/user/path/layer1 \
-  /home/user/path/layer2 \
-  "
-"""
-        after = r"""
-# A comment
-
-BBPATH = "${TOPDIR}"
-BBFILES ?= ""
-BBLAYERS += " \
-  /home/user/path/layer2 \
-  /home/user/path/layer3 \
-  "
-"""
-        self._test_bblayers_edit(before, after,
-                                 '/home/user/path/layer3',
-                                 '/home/user/path/layer1',
-                                 [],
-                                 [])
-
-
-    def test_bblayers_add_remove_plusequals2(self):
-        before = r"""
-# A comment
-
-BBPATH = "${TOPDIR}"
-BBFILES ?= ""
-BBLAYERS += " \
-  /home/user/path/layer1 \
-  /home/user/path/layer2 \
-  /home/user/path/layer3 \
-  "
-BBLAYERS += "/home/user/path/layer4"
-BBLAYERS += "/home/user/path/layer5"
-"""
-        after = r"""
-# A comment
-
-BBPATH = "${TOPDIR}"
-BBFILES ?= ""
-BBLAYERS += " \
-  /home/user/path/layer2 \
-  /home/user/path/layer3 \
-  "
-BBLAYERS += "/home/user/path/layer5"
-BBLAYERS += "/home/user/otherpath/layer6"
-"""
-        self._test_bblayers_edit(before, after,
-                                 ['/home/user/otherpath/layer6', '/home/user/path/layer3'], ['/home/user/path/layer1', '/home/user/path/layer4', '/home/user/path/layer7'],
-                                 ['/home/user/path/layer3'],
-                                 ['/home/user/path/layer7'])

bitbake/lib/bb/tinfoil.py

@@ -1,6 +1,6 @@
 # tinfoil: a simple wrapper around cooker for bitbake-based command-line utilities
 #
-# Copyright (C) 2012-2017 Intel Corporation
+# Copyright (C) 2012 Intel Corporation
 # Copyright (C) 2011 Mentor Graphics Corporation
 #
 # This program is free software; you can redistribute it and/or modify
@@ -17,466 +17,88 @@
 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 
 import logging
+import warnings
 import os
 import sys
-import atexit
-import re
-from collections import OrderedDict, defaultdict
 
 import bb.cache
 import bb.cooker
 import bb.providers
-import bb.taskdata
 import bb.utils
-import bb.command
-import bb.remotedata
+from bb.cooker import state, BBCooker, CookerFeatures
 from bb.cookerdata import CookerConfiguration, ConfigParameters
-from bb.main import setup_bitbake, BitBakeConfigParameters, BBMainException
 import bb.fetch2
 
-
-# We need this in order to shut down the connection to the bitbake server,
-# otherwise the process will never properly exit
-_server_connections = []
-def _terminate_connections():
-    for connection in _server_connections:
-        connection.terminate()
-atexit.register(_terminate_connections)
-
-class TinfoilUIException(Exception):
-    """Exception raised when the UI returns non-zero from its main function"""
-    def __init__(self, returncode):
-        self.returncode = returncode
-    def __repr__(self):
-        return 'UI module main returned %d' % self.returncode
-
-class TinfoilCommandFailed(Exception):
-    """Exception raised when run_command fails"""
-
-class TinfoilDataStoreConnector:
-
-    def __init__(self, tinfoil, dsindex):
-        self.tinfoil = tinfoil
-        self.dsindex = dsindex
-    def getVar(self, name):
-        value = self.tinfoil.run_command('dataStoreConnectorFindVar', self.dsindex, name)
-        overrides = None
-        if isinstance(value, dict):
-            if '_connector_origtype' in value:
-                value['_content'] = self.tinfoil._reconvert_type(value['_content'], value['_connector_origtype'])
-                del value['_connector_origtype']
-            if '_connector_overrides' in value:
-                overrides = value['_connector_overrides']
-                del value['_connector_overrides']
-        return value, overrides
-    def getKeys(self):
-        return set(self.tinfoil.run_command('dataStoreConnectorGetKeys', self.dsindex))
-    def getVarHistory(self, name):
-        return self.tinfoil.run_command('dataStoreConnectorGetVarHistory', self.dsindex, name)
-    def expandPythonRef(self, varname, expr, d):
-        ds = bb.remotedata.RemoteDatastores.transmit_datastore(d)
-        ret = self.tinfoil.run_command('dataStoreConnectorExpandPythonRef', ds, varname, expr)
-        return ret
-    def setVar(self, varname, value):
-        if self.dsindex is None:
-            self.tinfoil.run_command('setVariable', varname, value)
-        else:
-            # Not currently implemented - indicate that setting should
-            # be redirected to local side
-            return True
-    def setVarFlag(self, varname, flagname, value):
-        if self.dsindex is None:
-            self.tinfoil.run_command('dataStoreConnectorSetVarFlag', self.dsindex, varname, flagname, value)
-        else:
-            # Not currently implemented - indicate that setting should
-            # be redirected to local side
-            return True
-    def delVar(self, varname):
-        if self.dsindex is None:
-            self.tinfoil.run_command('dataStoreConnectorDelVar', self.dsindex, varname)
-        else:
-            # Not currently implemented - indicate that setting should
-            # be redirected to local side
-            return True
-    def delVarFlag(self, varname, flagname):
-        if self.dsindex is None:
-            self.tinfoil.run_command('dataStoreConnectorDelVar', self.dsindex, varname, flagname)
-        else:
-            # Not currently implemented - indicate that setting should
-            # be redirected to local side
-            return True
-    def renameVar(self, name, newname):
-        if self.dsindex is None:
-            self.tinfoil.run_command('dataStoreConnectorRenameVar', self.dsindex, name, newname)
-        else:
-            # Not currently implemented - indicate that setting should
-            # be redirected to local side
-            return True
-
-class TinfoilCookerAdapter:
-    """
-    Provide an adapter for existing code that expects to access a cooker object via Tinfoil,
-    since now Tinfoil is on the client side it no longer has direct access.
-    """
-
-    class TinfoilCookerCollectionAdapter:
-        """ cooker.collection adapter """
-        def __init__(self, tinfoil):
-            self.tinfoil = tinfoil
-        def get_file_appends(self, fn):
-            return self.tinfoil.get_file_appends(fn)
-        def __getattr__(self, name):
-            if name == 'overlayed':
-                return self.tinfoil.get_overlayed_recipes()
-            elif name == 'bbappends':
-                return self.tinfoil.run_command('getAllAppends')
-            else:
-                raise AttributeError("%s instance has no attribute '%s'" % (self.__class__.__name__, name))
-
-    class TinfoilRecipeCacheAdapter:
-        """ cooker.recipecache adapter """
-        def __init__(self, tinfoil):
-            self.tinfoil = tinfoil
-            self._cache = {}
-
-        def get_pkg_pn_fn(self):
-            pkg_pn = defaultdict(list, self.tinfoil.run_command('getRecipes') or [])
-            pkg_fn = {}
-            for pn, fnlist in pkg_pn.items():
-                for fn in fnlist:
-                    pkg_fn[fn] = pn
-            self._cache['pkg_pn'] = pkg_pn
-            self._cache['pkg_fn'] = pkg_fn
-
-        def __getattr__(self, name):
-            # Grab these only when they are requested since they aren't always used
-            if name in self._cache:
-                return self._cache[name]
-            elif name == 'pkg_pn':
-                self.get_pkg_pn_fn()
-                return self._cache[name]
-            elif name == 'pkg_fn':
-                self.get_pkg_pn_fn()
-                return self._cache[name]
-            elif name == 'deps':
-                attrvalue = defaultdict(list, self.tinfoil.run_command('getRecipeDepends') or [])
-            elif name == 'rundeps':
-                attrvalue = defaultdict(lambda: defaultdict(list), self.tinfoil.run_command('getRuntimeDepends') or [])
-            elif name == 'runrecs':
-                attrvalue = defaultdict(lambda: defaultdict(list), self.tinfoil.run_command('getRuntimeRecommends') or [])
-            elif name == 'pkg_pepvpr':
-                attrvalue = self.tinfoil.run_command('getRecipeVersions') or {}
-            elif name == 'inherits':
-                attrvalue = self.tinfoil.run_command('getRecipeInherits') or {}
-            elif name == 'bbfile_priority':
-                attrvalue = self.tinfoil.run_command('getBbFilePriority') or {}
-            elif name == 'pkg_dp':
-                attrvalue = self.tinfoil.run_command('getDefaultPreference') or {}
-            else:
-                raise AttributeError("%s instance has no attribute '%s'" % (self.__class__.__name__, name))
-
-            self._cache[name] = attrvalue
-            return attrvalue
-
-    def __init__(self, tinfoil):
-        self.tinfoil = tinfoil
-        self.collection = self.TinfoilCookerCollectionAdapter(tinfoil)
-        self.recipecaches = {}
-        # FIXME all machines
-        self.recipecaches[''] = self.TinfoilRecipeCacheAdapter(tinfoil)
-        self._cache = {}
-    def __getattr__(self, name):
-        # Grab these only when they are requested since they aren't always used
-        if name in self._cache:
-            return self._cache[name]
-        elif name == 'skiplist':
-            attrvalue = self.tinfoil.get_skipped_recipes()
-        elif name == 'bbfile_config_priorities':
-            ret = self.tinfoil.run_command('getLayerPriorities')
-            bbfile_config_priorities = []
-            for collection, pattern, regex, pri in ret:
-                bbfile_config_priorities.append((collection, pattern, re.compile(regex), pri))
-
-            attrvalue = bbfile_config_priorities
-        else:
-            raise AttributeError("%s instance has no attribute '%s'" % (self.__class__.__name__, name))
-
-        self._cache[name] = attrvalue
-        return attrvalue
-
-    def findBestProvider(self, pn):
-        return self.tinfoil.find_best_provider(pn)
-
-
 class Tinfoil:
+    def __init__(self, output=sys.stdout, tracking=False):
+        # Needed to avoid deprecation warnings with python 2.6
+        warnings.filterwarnings("ignore", category=DeprecationWarning)
 
-    def __init__(self, output=sys.stdout, tracking=False, setup_logging=True):
+        # Set up logging
         self.logger = logging.getLogger('BitBake')
-        self.config_data = None
-        self.cooker = None
-        self.tracking = tracking
-        self.ui_module = None
-        self.server_connection = None
-        if setup_logging:
-            # This is the *client-side* logger, nothing to do with
-            # logging messages from the server
-            bb.msg.logger_create('BitBake', output)
+        console = logging.StreamHandler(output)
+        bb.msg.addDefaultlogFilter(console)
+        format = bb.msg.BBLogFormatter("%(levelname)s: %(message)s")
+        if output.isatty():
+            format.enable_color()
+        console.setFormatter(format)
+        self.logger.addHandler(console)
 
-    def __enter__(self):
-        return self
+        self.config = CookerConfiguration()
+        configparams = TinfoilConfigParameters(parse_only=True)
+        self.config.setConfigParameters(configparams)
+        self.config.setServerRegIdleCallback(self.register_idle_function)
+        features = []
+        if tracking:
+            features.append(CookerFeatures.BASEDATASTORE_TRACKING)
+        self.cooker = BBCooker(self.config, features)
+        self.config_data = self.cooker.data
+        bb.providers.logger.setLevel(logging.ERROR)
+        self.cooker_data = None
 
-    def __exit__(self, type, value, traceback):
-        self.shutdown()
-
-    def prepare(self, config_only=False, config_params=None, quiet=0):
-        if self.tracking:
-            extrafeatures = [bb.cooker.CookerFeatures.BASEDATASTORE_TRACKING]
-        else:
-            extrafeatures = []
-
-        if not config_params:
-            config_params = TinfoilConfigParameters(config_only=config_only, quiet=quiet)
-
-        cookerconfig = CookerConfiguration()
-        cookerconfig.setConfigParameters(config_params)
-
-        server, self.server_connection, ui_module = setup_bitbake(config_params,
-                            cookerconfig,
-                            extrafeatures)
-
-        self.ui_module = ui_module
-
-        # Ensure the path to bitbake's bin directory is in PATH so that things like
-        # bitbake-worker can be run (usually this is the case, but it doesn't have to be)
-        path = os.getenv('PATH').split(':')
-        bitbakebinpath = os.path.abspath(os.path.join(os.path.dirname(os.path.abspath(__file__)), '..', '..', 'bin'))
-        for entry in path:
-            if entry.endswith(os.sep):
-                entry = entry[:-1]
-            if os.path.abspath(entry) == bitbakebinpath:
-                break
-        else:
-            path.insert(0, bitbakebinpath)
-            os.environ['PATH'] = ':'.join(path)
-
-        if self.server_connection:
-            _server_connections.append(self.server_connection)
-            if config_only:
-                config_params.updateToServer(self.server_connection.connection, os.environ.copy())
-                self.run_command('parseConfiguration')
-            else:
-                self.run_actions(config_params)
-
-            self.config_data = bb.data.init()
-            connector = TinfoilDataStoreConnector(self, None)
-            self.config_data.setVar('_remote_data', connector)
-            self.cooker = TinfoilCookerAdapter(self)
-            self.cooker_data = self.cooker.recipecaches['']
-        else:
-            raise Exception('Failed to start bitbake server')
-
-    def run_actions(self, config_params):
-        """
-        Run the actions specified in config_params through the UI.
-        """
-        ret = self.ui_module.main(self.server_connection.connection, self.server_connection.events, config_params)
-        if ret:
-            raise TinfoilUIException(ret)
+    def register_idle_function(self, function, data):
+        pass
 
     def parseRecipes(self):
-        """
-        Force a parse of all recipes. Normally you should specify
-        config_only=False when calling prepare() instead of using this
-        function; this function is designed for situations where you need
-        to initialise Tinfoil and use it with config_only=True first and
-        then conditionally call this function to parse recipes later.
-        """
-        config_params = TinfoilConfigParameters(config_only=False)
-        self.run_actions(config_params)
+        sys.stderr.write("Parsing recipes..")
+        self.logger.setLevel(logging.WARNING)
 
-    def run_command(self, command, *params):
-        """
-        Run a command on the server (as implemented in bb.command).
-        Note that there are two types of command - synchronous and
-        asynchronous; in order to receive the results of asynchronous
-        commands you will need to set an appropriate event mask
-        using set_event_mask() and listen for the result using
-        wait_event() - with the correct event mask you'll at least get
-        bb.command.CommandCompleted and possibly other events before
-        that depending on the command.
-        """
-        if not self.server_connection:
-            raise Exception('Not connected to server (did you call .prepare()?)')
+        try:
+            while self.cooker.state in (state.initial, state.parsing):
+                self.cooker.updateCache()
+        except KeyboardInterrupt:
+            self.cooker.shutdown()
+            self.cooker.updateCache()
+            sys.exit(2)
 
-        commandline = [command]
-        if params:
-            commandline.extend(params)
-        result = self.server_connection.connection.runCommand(commandline)
-        if result[1]:
-            raise TinfoilCommandFailed(result[1])
-        return result[0]
+        self.logger.setLevel(logging.INFO)
+        sys.stderr.write("done.\n")
 
-    def set_event_mask(self, eventlist):
-        """Set the event mask which will be applied within wait_event()"""
-        if not self.server_connection:
-            raise Exception('Not connected to server (did you call .prepare()?)')
-        llevel, debug_domains = bb.msg.constructLogOptions()
-        ret = self.run_command('setEventMask', self.server_connection.connection.getEventHandle(), llevel, debug_domains, eventlist)
-        if not ret:
-            raise Exception('setEventMask failed')
+        self.cooker_data = self.cooker.recipecache
 
-    def wait_event(self, timeout=0):
-        """
-        Wait for an event from the server for the specified time.
-        A timeout of 0 means don't wait if there are no events in the queue.
-        Returns the next event in the queue or None if the timeout was
-        reached. Note that in order to recieve any events you will
-        first need to set the internal event mask using set_event_mask()
-        (otherwise whatever event mask the UI set up will be in effect).
-        """
-        if not self.server_connection:
-            raise Exception('Not connected to server (did you call .prepare()?)')
-        return self.server_connection.events.waitEvent(timeout)
-
-    def get_overlayed_recipes(self):
-        return defaultdict(list, self.run_command('getOverlayedRecipes'))
-
-    def get_skipped_recipes(self):
-        return OrderedDict(self.run_command('getSkippedRecipes'))
-
-    def get_all_providers(self):
-        return defaultdict(list, self.run_command('allProviders'))
-
-    def find_providers(self):
-        return self.run_command('findProviders')
-
-    def find_best_provider(self, pn):
-        return self.run_command('findBestProvider', pn)
-
-    def get_runtime_providers(self, rdep):
-        return self.run_command('getRuntimeProviders', rdep)
-
-    def get_recipe_file(self, pn):
-        """
-        Get the file name for the specified recipe/target. Raises
-        bb.providers.NoProvider if there is no match or the recipe was
-        skipped.
-        """
-        best = self.find_best_provider(pn)
-        if not best or (len(best) > 3 and not best[3]):
-            skiplist = self.get_skipped_recipes()
-            taskdata = bb.taskdata.TaskData(None, skiplist=skiplist)
-            skipreasons = taskdata.get_reasons(pn)
-            if skipreasons:
-                raise bb.providers.NoProvider('%s is unavailable:\n  %s' % (pn, '  \n'.join(skipreasons)))
+    def prepare(self, config_only = False):
+        if not self.cooker_data:
+            if config_only:
+                self.cooker.parseConfiguration()
+                self.cooker_data = self.cooker.recipecache
             else:
-                raise bb.providers.NoProvider('Unable to find any recipe file matching "%s"' % pn)
-        return best[3]
-
-    def get_file_appends(self, fn):
-        return self.run_command('getFileAppends', fn)
-
-    def parse_recipe(self, pn):
-        """
-        Parse the specified recipe and return a datastore object
-        representing the environment for the recipe.
-        """
-        fn = self.get_recipe_file(pn)
-        return self.parse_recipe_file(fn)
-
-    def parse_recipe_file(self, fn, appends=True, appendlist=None, config_data=None):
-        """
-        Parse the specified recipe file (with or without bbappends)
-        and return a datastore object representing the environment
-        for the recipe.
-        Parameters:
-            fn: recipe file to parse - can be a file path or virtual
-                specification
-            appends: True to apply bbappends, False otherwise
-            appendlist: optional list of bbappend files to apply, if you
-                        want to filter them
-            config_data: custom config datastore to use. NOTE: if you
-                         specify config_data then you cannot use a virtual
-                         specification for fn.
-        """
-        if appends and appendlist == []:
-            appends = False
-        if config_data:
-            dctr = bb.remotedata.RemoteDatastores.transmit_datastore(config_data)
-            dscon = self.run_command('parseRecipeFile', fn, appends, appendlist, dctr)
-        else:
-            dscon = self.run_command('parseRecipeFile', fn, appends, appendlist)
-        if dscon:
-            return self._reconvert_type(dscon, 'DataStoreConnectionHandle')
-        else:
-            return None
-
-    def build_file(self, buildfile, task):
-        """
-        Runs the specified task for just a single recipe (i.e. no dependencies).
-        This is equivalent to bitbake -b, except no warning will be printed.
-        """
-        return self.run_command('buildFile', buildfile, task, True)
+                self.parseRecipes()
 
     def shutdown(self):
-        if self.server_connection:
-            self.run_command('clientComplete')
-            _server_connections.remove(self.server_connection)
-            bb.event.ui_queue = []
-            self.server_connection.terminate()
-            self.server_connection = None
+        self.cooker.shutdown(force=True)
+        self.cooker.post_serve()
+        self.cooker.unlockBitbake()
 
-    def _reconvert_type(self, obj, origtypename):
-        """
-        Convert an object back to the right type, in the case
-        that marshalling has changed it (especially with xmlrpc)
-        """
-        supported_types = {
-            'set': set,
-            'DataStoreConnectionHandle': bb.command.DataStoreConnectionHandle,
-        }
+class TinfoilConfigParameters(ConfigParameters):
 
-        origtype = supported_types.get(origtypename, None)
-        if origtype is None:
-            raise Exception('Unsupported type "%s"' % origtypename)
-        if type(obj) == origtype:
-            newobj = obj
-        elif isinstance(obj, dict):
-            # New style class
-            newobj = origtype()
-            for k,v in obj.items():
-                setattr(newobj, k, v)
-        else:
-            # Assume we can coerce the type
-            newobj = origtype(obj)
-
-        if isinstance(newobj, bb.command.DataStoreConnectionHandle):
-            connector = TinfoilDataStoreConnector(self, newobj.dsindex)
-            newobj = bb.data.init()
-            newobj.setVar('_remote_data', connector)
-
-        return newobj
-
-
-class TinfoilConfigParameters(BitBakeConfigParameters):
-
-    def __init__(self, config_only, **options):
+    def __init__(self, **options):
         self.initial_options = options
-        # Apply some sane defaults
-        if not 'parse_only' in options:
-            self.initial_options['parse_only'] = not config_only
-        #if not 'status_only' in options:
-        #    self.initial_options['status_only'] = config_only
-        if not 'ui' in options:
-            self.initial_options['ui'] = 'knotty'
-        if not 'argv' in options:
-            self.initial_options['argv'] = []
-
         super(TinfoilConfigParameters, self).__init__()
 
-    def parseCommandLine(self, argv=None):
-        # We don't want any parameters parsed from the command line
-        opts = super(TinfoilConfigParameters, self).parseCommandLine([])
-        for key, val in self.initial_options.items():
-            setattr(opts[0], key, val)
-        return opts
+    def parseCommandLine(self):
+        class DummyOptions:
+            def __init__(self, initial_options):
+                for key, val in initial_options.items():
+                    setattr(self, key, val)
+
+        return DummyOptions(self.initial_options), None

bitbake/lib/bb/ui/crumbs/__init__.py

@@ -0,0 +1,17 @@
+#
+# Gtk+ UI pieces for BitBake
+#
+# Copyright (C) 2006-2007 Richard Purdie
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

bitbake/lib/bb/ui/crumbs/builddetailspage.py

@@ -0,0 +1,437 @@
+#!/usr/bin/env python
+#
+# BitBake Graphical GTK User Interface
+#
+# Copyright (C) 2012        Intel Corporation
+#
+# Authored by Dongxiao Xu <dongxiao.xu@intel.com>
+# Authored by Shane Wang <shane.wang@intel.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import gtk
+import pango
+import gobject
+import bb.process
+from bb.ui.crumbs.progressbar import HobProgressBar
+from bb.ui.crumbs.hobwidget import hic, HobNotebook, HobAltButton, HobWarpCellRendererText, HobButton, HobInfoButton
+from bb.ui.crumbs.runningbuild import RunningBuildTreeView
+from bb.ui.crumbs.runningbuild import BuildFailureTreeView
+from bb.ui.crumbs.hobpages import HobPage
+from bb.ui.crumbs.hobcolor import HobColors
+
+class BuildConfigurationTreeView(gtk.TreeView):
+    def __init__ (self):
+        gtk.TreeView.__init__(self)
+        self.set_rules_hint(False)
+        self.set_headers_visible(False)
+        self.set_property("hover-expand", True)
+        self.get_selection().set_mode(gtk.SELECTION_SINGLE)
+
+        # The icon that indicates whether we're building or failed.
+        renderer0 = gtk.CellRendererText()
+        renderer0.set_property('font-desc', pango.FontDescription('courier bold 12'))
+        col0 = gtk.TreeViewColumn ("Name", renderer0, text=0)
+        self.append_column (col0)
+
+        # The message of configuration.
+        renderer1 = HobWarpCellRendererText(col_number=1)
+        col1 = gtk.TreeViewColumn ("Values", renderer1, text=1)
+        self.append_column (col1)
+
+    def set_vars(self, key="", var=[""]):
+        d = {}
+        if type(var) == str:
+            d = {key: [var]}
+        elif type(var) == list and len(var) > 1:
+            #create the sub item line
+            l = []
+            text = ""
+            for item in var:
+                text = " - " + item
+                l.append(text)
+            d = {key: var}
+
+        return d
+
+    def set_config_model(self, show_vars):
+        listmodel = gtk.TreeStore(gobject.TYPE_STRING, gobject.TYPE_STRING)
+        parent = None
+        for var in show_vars:
+            for subitem in var.items():
+                name = subitem[0]
+                is_parent = True
+                for value in subitem[1]:
+                    if is_parent:
+                        parent = listmodel.append(parent, (name, value))
+                        is_parent = False
+                    else:
+                        listmodel.append(parent, (None, value))
+                    name = "     - "
+                parent = None
+        # renew the tree model after get the configuration messages
+        self.set_model(listmodel)
+
+    def show(self, src_config_info, src_params):
+        vars = []
+        vars.append(self.set_vars("BB version:", src_params.bb_version))
+        vars.append(self.set_vars("Target arch:", src_params.target_arch))
+        vars.append(self.set_vars("Target OS:", src_params.target_os))
+        vars.append(self.set_vars("Machine:", src_config_info.curr_mach))
+        vars.append(self.set_vars("Distro:", src_config_info.curr_distro))
+        vars.append(self.set_vars("Distro version:", src_params.distro_version))
+        vars.append(self.set_vars("SDK machine:", src_config_info.curr_sdk_machine))
+        vars.append(self.set_vars("Tune features:", src_params.tune_pkgarch))
+        vars.append(self.set_vars("Layers:", src_config_info.layers))
+
+        for path in src_config_info.layers:
+            import os, os.path
+            if os.path.exists(path):
+                branch = bb.process.run('cd %s; git branch | grep "^* " | tr -d "* "' % path)[0]
+                if branch.startswith("fatal:"):
+                    branch = "(unknown)"
+                if branch:
+                    branch = branch.strip('\n')
+                    vars.append(self.set_vars("Branch:", branch))
+                break
+
+        self.set_config_model(vars)
+
+    def reset(self):
+        self.set_model(None)
+
+#
+# BuildDetailsPage
+#
+
+class BuildDetailsPage (HobPage):
+
+    def __init__(self, builder):
+        super(BuildDetailsPage, self).__init__(builder, "Building ...")
+
+        self.num_of_issues = 0
+        self.endpath = (0,)
+        # create visual elements
+        self.create_visual_elements()
+
+    def create_visual_elements(self):
+        # create visual elements
+        self.vbox = gtk.VBox(False, 12)
+
+        self.progress_box = gtk.VBox(False, 12)
+        self.task_status = gtk.Label("\n") # to ensure layout is correct
+        self.task_status.set_alignment(0.0, 0.5)
+        self.progress_box.pack_start(self.task_status, expand=False, fill=False)
+        self.progress_hbox = gtk.HBox(False, 6)
+        self.progress_box.pack_end(self.progress_hbox, expand=True, fill=True)
+        self.progress_bar = HobProgressBar()
+        self.progress_hbox.pack_start(self.progress_bar, expand=True, fill=True)
+        self.stop_button = HobAltButton("Stop")
+        self.stop_button.connect("clicked", self.stop_button_clicked_cb)
+        self.stop_button.set_sensitive(False)
+        self.progress_hbox.pack_end(self.stop_button, expand=False, fill=False)
+
+        self.notebook = HobNotebook()
+        self.config_tv = BuildConfigurationTreeView()
+        self.scrolled_view_config = gtk.ScrolledWindow ()
+        self.scrolled_view_config.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS)
+        self.scrolled_view_config.add(self.config_tv)
+        self.notebook.append_page(self.scrolled_view_config, "Build configuration")
+
+        self.failure_tv = BuildFailureTreeView()
+        self.failure_model = self.builder.handler.build.model.failure_model()
+        self.failure_tv.set_model(self.failure_model)
+        self.scrolled_view_failure = gtk.ScrolledWindow ()
+        self.scrolled_view_failure.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS)
+        self.scrolled_view_failure.add(self.failure_tv)
+        self.notebook.append_page(self.scrolled_view_failure, "Issues")
+
+        self.build_tv = RunningBuildTreeView(readonly=True, hob=True)
+        self.build_tv.set_model(self.builder.handler.build.model)
+        self.scrolled_view_build = gtk.ScrolledWindow ()
+        self.scrolled_view_build.set_policy(gtk.POLICY_NEVER, gtk.POLICY_ALWAYS)
+        self.scrolled_view_build.add(self.build_tv)
+        self.notebook.append_page(self.scrolled_view_build, "Log")
+
+        self.builder.handler.build.model.connect_after("row-changed", self.scroll_to_present_row, self.scrolled_view_build.get_vadjustment(), self.build_tv)
+
+        self.button_box = gtk.HBox(False, 6)
+        self.back_button = HobAltButton('&lt;&lt; Back')
+        self.back_button.connect("clicked", self.back_button_clicked_cb)
+        self.button_box.pack_start(self.back_button, expand=False, fill=False)
+
+    def update_build_status(self, current, total, task):
+        recipe_path, recipe_task = task.split(", ")
+        recipe = os.path.basename(recipe_path).rstrip(".bb")
+        tsk_msg = "<b>Running task %s of %s:</b> %s\n<b>Recipe:</b> %s" % (current, total, recipe_task, recipe)
+        self.task_status.set_markup(tsk_msg)
+        self.stop_button.set_sensitive(True)
+
+    def reset_build_status(self):
+        self.task_status.set_markup("\n") # to ensure layout is correct
+        self.endpath = (0,)
+
+    def show_issues(self):
+        self.num_of_issues += 1
+        self.notebook.show_indicator_icon("Issues", self.num_of_issues)
+        self.notebook.queue_draw()
+
+    def reset_issues(self):
+        self.num_of_issues = 0
+        self.notebook.hide_indicator_icon("Issues")
+
+    def _remove_all_widget(self):
+        children = self.vbox.get_children() or []
+        for child in children:
+            self.vbox.remove(child)
+        children = self.box_group_area.get_children() or []
+        for child in children:
+            self.box_group_area.remove(child)
+        children = self.get_children() or []
+        for child in children:
+            self.remove(child)
+
+    def add_build_fail_top_bar(self, actions, log_file=None):
+        primary_action = "Edit %s" % actions
+
+        color = HobColors.ERROR
+        build_fail_top = gtk.EventBox()
+        #build_fail_top.set_size_request(-1, 200)
+        build_fail_top.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse(color))
+
+        build_fail_tab = gtk.Table(14, 46, True)
+        build_fail_top.add(build_fail_tab)
+
+        icon = gtk.Image()
+        icon_pix_buffer = gtk.gdk.pixbuf_new_from_file(hic.ICON_INDI_ERROR_FILE)
+        icon.set_from_pixbuf(icon_pix_buffer)
+        build_fail_tab.attach(icon, 1, 4, 0, 6)
+
+        label = gtk.Label()
+        label.set_alignment(0.0, 0.5)
+        label.set_markup("<span size='x-large'><b>%s</b></span>" % self.title)
+        build_fail_tab.attach(label, 4, 26, 0, 6)
+
+        label = gtk.Label()
+        label.set_alignment(0.0, 0.5)
+        # Ensure variable disk_full is defined
+        if not hasattr(self.builder, 'disk_full'):
+            self.builder.disk_full = False
+
+        if self.builder.disk_full:
+            markup = "<span size='medium'>There is no disk space left, so Hob cannot finish building your image. Free up some disk space\n"
+            markup += "and restart the build. Check the \"Issues\" tab for more details</span>"
+            label.set_markup(markup)
+        else:
+            label.set_markup("<span size='medium'>Check the \"Issues\" information for more details</span>")
+        build_fail_tab.attach(label, 4, 40, 4, 9)
+
+        # create button 'Edit packages'
+        action_button = HobButton(primary_action)
+        #action_button.set_size_request(-1, 40)
+        action_button.set_tooltip_text("Edit the %s parameters" % actions)
+        action_button.connect('clicked', self.failure_primary_action_button_clicked_cb, primary_action)
+
+        if log_file:
+            open_log_button = HobAltButton("Open log")
+            open_log_button.set_relief(gtk.RELIEF_HALF)
+            open_log_button.set_tooltip_text("Open the build's log file")
+            open_log_button.connect('clicked', self.open_log_button_clicked_cb, log_file)
+
+        attach_pos = (24 if log_file else 14)
+        file_bug_button = HobAltButton('File a bug')
+        file_bug_button.set_relief(gtk.RELIEF_HALF)
+        file_bug_button.set_tooltip_text("Open the Yocto Project bug tracking website")
+        file_bug_button.connect('clicked', self.failure_activate_file_bug_link_cb)
+
+        if not self.builder.disk_full:
+            build_fail_tab.attach(action_button, 4, 13, 9, 12)
+            if log_file:
+                build_fail_tab.attach(open_log_button, 14, 23, 9, 12)
+            build_fail_tab.attach(file_bug_button, attach_pos, attach_pos + 9, 9, 12)
+
+        else:
+            restart_build = HobButton("Restart the build")
+            restart_build.set_tooltip_text("Restart the build")
+            restart_build.connect('clicked', self.restart_build_button_clicked_cb)
+
+            build_fail_tab.attach(restart_build, 4, 13, 9, 12)
+            build_fail_tab.attach(action_button, 14, 23, 9, 12)
+            if log_file:
+                build_fail_tab.attach(open_log_button, attach_pos, attach_pos + 9, 9, 12)
+
+        self.builder.disk_full = False
+        return build_fail_top
+
+    def show_fail_page(self, title):
+        self._remove_all_widget()
+        self.title = "Hob cannot build your %s" % title
+
+        self.build_fail_bar = self.add_build_fail_top_bar(title, self.builder.current_logfile)
+
+        self.pack_start(self.group_align, expand=True, fill=True)
+        self.box_group_area.pack_start(self.build_fail_bar, expand=False, fill=False)
+        self.box_group_area.pack_start(self.vbox, expand=True, fill=True)
+
+        self.vbox.pack_start(self.notebook, expand=True, fill=True)
+        self.show_all()
+        self.notebook.set_page("Issues")
+        self.back_button.hide()
+
+    def add_build_stop_top_bar(self, action, log_file=None):
+        color = HobColors.LIGHT_GRAY
+        build_stop_top = gtk.EventBox()
+        #build_stop_top.set_size_request(-1, 200)
+        build_stop_top.modify_bg(gtk.STATE_NORMAL, gtk.gdk.color_parse(color))
+        build_stop_top.set_flags(gtk.CAN_DEFAULT)
+        build_stop_top.grab_default()
+
+        build_stop_tab = gtk.Table(11, 46, True)
+        build_stop_top.add(build_stop_tab)
+
+        icon = gtk.Image()
+        icon_pix_buffer = gtk.gdk.pixbuf_new_from_file(hic.ICON_INFO_HOVER_FILE)
+        icon.set_from_pixbuf(icon_pix_buffer)
+        build_stop_tab.attach(icon, 1, 4, 0, 6)
+
+        label = gtk.Label()
+        label.set_alignment(0.0, 0.5)
+        label.set_markup("<span size='x-large'><b>%s</b></span>" % self.title)
+        build_stop_tab.attach(label, 4, 26, 0, 6)
+
+        action_button = HobButton("Edit %s" % action)
+        action_button.set_size_request(-1, 40)
+        if action == "image":
+            action_button.set_tooltip_text("Edit the image parameters")
+        elif action == "recipes":
+            action_button.set_tooltip_text("Edit the included recipes")
+        elif action == "packages":
+            action_button.set_tooltip_text("Edit the included packages")
+        action_button.connect('clicked', self.stop_primary_action_button_clicked_cb, action)
+        build_stop_tab.attach(action_button, 4, 13, 6, 9)
+
+        if log_file:
+            open_log_button = HobAltButton("Open log")
+            open_log_button.set_relief(gtk.RELIEF_HALF)
+            open_log_button.set_tooltip_text("Open the build's log file")
+            open_log_button.connect('clicked', self.open_log_button_clicked_cb, log_file)
+            build_stop_tab.attach(open_log_button, 14, 23, 6, 9)
+
+        attach_pos = (24 if log_file else 14)
+        build_button = HobAltButton("Build new image")
+        #build_button.set_size_request(-1, 40)
+        build_button.set_tooltip_text("Create a new image from scratch")
+        build_button.connect('clicked', self.new_image_button_clicked_cb)
+        build_stop_tab.attach(build_button, attach_pos, attach_pos + 9, 6, 9)
+
+        return build_stop_top, action_button
+
+    def show_stop_page(self, action):
+        self._remove_all_widget()
+        self.title = "Build stopped"
+        self.build_stop_bar, action_button = self.add_build_stop_top_bar(action, self.builder.current_logfile)
+
+        self.pack_start(self.group_align, expand=True, fill=True)
+        self.box_group_area.pack_start(self.build_stop_bar, expand=False, fill=False)
+        self.box_group_area.pack_start(self.vbox, expand=True, fill=True)
+
+        self.vbox.pack_start(self.notebook, expand=True, fill=True)
+        self.show_all()
+        self.back_button.hide()
+        return action_button
+
+    def show_page(self, step):
+        self._remove_all_widget()
+        if step == self.builder.PACKAGE_GENERATING or step == self.builder.FAST_IMAGE_GENERATING:
+            self.title = "Building packages ..."
+        else:
+            self.title = "Building image ..."
+        self.build_details_top = self.add_onto_top_bar(None)
+        self.pack_start(self.build_details_top, expand=False, fill=False)
+        self.pack_start(self.group_align, expand=True, fill=True)
+
+        self.box_group_area.pack_start(self.vbox, expand=True, fill=True)
+
+        self.progress_bar.reset()
+        self.config_tv.reset()
+        self.vbox.pack_start(self.progress_box, expand=False, fill=False)
+
+        self.vbox.pack_start(self.notebook, expand=True, fill=True)
+
+        self.box_group_area.pack_end(self.button_box, expand=False, fill=False)
+        self.show_all()
+        self.notebook.set_page("Log")
+        self.back_button.hide()
+
+        self.reset_build_status()
+        self.reset_issues()
+
+    def update_progress_bar(self, title, fraction, status=None):
+        self.progress_bar.update(fraction)
+        self.progress_bar.set_title(title)
+        self.progress_bar.set_rcstyle(status)
+
+    def back_button_clicked_cb(self, button):
+        self.builder.show_configuration()
+
+    def new_image_button_clicked_cb(self, button):
+        self.builder.reset()
+
+    def show_back_button(self):
+        self.back_button.show()
+
+    def stop_button_clicked_cb(self, button):
+        self.builder.stop_build()
+
+    def hide_stop_button(self):
+        self.stop_button.set_sensitive(False)
+        self.stop_button.hide()
+
+    def scroll_to_present_row(self, model, path, iter, v_adj, treeview):
+        if treeview and v_adj:
+            if path[0] > self.endpath[0]: # check the event is a new row append or not
+                self.endpath = path
+                # check the gtk.adjustment position is at end boundary or not
+                if (v_adj.upper <= v_adj.page_size) or (v_adj.value == v_adj.upper - v_adj.page_size):
+                    treeview.scroll_to_cell(path)
+
+    def show_configurations(self, configurations, params):
+        self.config_tv.show(configurations, params)
+
+    def failure_primary_action_button_clicked_cb(self, button, action):
+        if "Edit recipes" in action:
+            self.builder.show_recipes()
+        elif "Edit packages" in action:
+            self.builder.show_packages()
+        elif "Edit image" in action:
+            self.builder.show_configuration()
+
+    def restart_build_button_clicked_cb(self, button):
+        self.builder.just_bake()
+
+    def stop_primary_action_button_clicked_cb(self, button, action):
+        if "recipes" in action:
+            self.builder.show_recipes()
+        elif "packages" in action:
+            self.builder.show_packages()
+        elif "image" in action:
+            self.builder.show_configuration()
+
+    def open_log_button_clicked_cb(self, button, log_file):
+        if log_file:
+            log_file = "file:///" + log_file
+            gtk.show_uri(screen=button.get_screen(), uri=log_file, timestamp=0)
+
+    def failure_activate_file_bug_link_cb(self, button):
+        button.child.emit('activate-link', "http://bugzilla.yoctoproject.org")

bitbake/lib/bb/ui/crumbs/buildmanager.py

@@ -0,0 +1,455 @@
+#
+# BitBake Graphical GTK User Interface
+#
+# Copyright (C) 2008        Intel Corporation
+#
+# Authored by Rob Bradford <rob@linux.intel.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import gtk
+import gobject
+import threading
+import os
+import datetime
+import time
+
+class BuildConfiguration:
+    """ Represents a potential *or* historic *or* concrete build. It
+    encompasses all the things that we need to tell bitbake to do to make it
+    build what we want it to build.
+
+    It also stored the metadata URL and the set of possible machines (and the
+    distros / images / uris for these. Apart from the metdata URL these are
+    not serialised to file (since they may be transient). In some ways this
+    functionality might be shifted to the loader class."""
+
+    def __init__ (self):
+        self.metadata_url = None
+
+        # Tuple of (distros, image, urls)
+        self.machine_options = {}
+
+        self.machine = None
+        self.distro = None
+        self.image = None
+        self.urls = []
+        self.extra_urls = []
+        self.extra_pkgs = []
+
+    def get_machines_model (self):
+        model = gtk.ListStore (gobject.TYPE_STRING)
+        for machine in self.machine_options.keys():
+            model.append ([machine])
+
+        return model
+
+    def get_distro_and_images_models (self, machine):
+        distro_model = gtk.ListStore (gobject.TYPE_STRING)
+
+        for distro in self.machine_options[machine][0]:
+            distro_model.append ([distro])
+
+        image_model = gtk.ListStore (gobject.TYPE_STRING)
+
+        for image in self.machine_options[machine][1]:
+            image_model.append ([image])
+
+        return (distro_model, image_model)
+
+    def get_repos (self):
+        self.urls = self.machine_options[self.machine][2]
+        return self.urls
+
+    # It might be a lot lot better if we stored these in like, bitbake conf
+    # file format.
+    @staticmethod
+    def load_from_file (filename):
+
+        conf = BuildConfiguration()
+        with open(filename, "r") as f:
+            for line in f:
+                data = line.split (";")[1]
+                if (line.startswith ("metadata-url;")):
+                    conf.metadata_url = data.strip()
+                    continue
+                if (line.startswith ("url;")):
+                    conf.urls += [data.strip()]
+                    continue
+                if (line.startswith ("extra-url;")):
+                    conf.extra_urls += [data.strip()]
+                    continue
+                if (line.startswith ("machine;")):
+                    conf.machine = data.strip()
+                    continue
+                if (line.startswith ("distribution;")):
+                    conf.distro = data.strip()
+                    continue
+                if (line.startswith ("image;")):
+                    conf.image = data.strip()
+                    continue
+
+        return conf
+
+    # Serialise to a file. This is part of the build process and we use this
+    # to be able to repeat a given build (using the same set of parameters)
+    # but also so that we can include the details of the image / machine /
+    # distro in the build manager tree view.
+    def write_to_file (self, filename):
+        f = open (filename, "w")
+
+        lines = []
+
+        if (self.metadata_url):
+            lines += ["metadata-url;%s\n" % (self.metadata_url)]
+
+        for url in self.urls:
+            lines += ["url;%s\n" % (url)]
+
+        for url in self.extra_urls:
+            lines += ["extra-url;%s\n" % (url)]
+
+        if (self.machine):
+            lines += ["machine;%s\n" % (self.machine)]
+
+        if (self.distro):
+            lines += ["distribution;%s\n" % (self.distro)]
+
+        if (self.image):
+            lines += ["image;%s\n" % (self.image)]
+
+        f.writelines (lines)
+        f.close ()
+
+class BuildResult(gobject.GObject):
+    """ Represents an historic build. Perhaps not successful. But it includes
+    things such as the files that are in the directory (the output from the
+    build) as well as a deserialised BuildConfiguration file that is stored in
+    ".conf" in the directory for the build.
+
+    This is GObject so that it can be included in the TreeStore."""
+
+    (STATE_COMPLETE, STATE_FAILED, STATE_ONGOING) = \
+        (0, 1, 2)
+
+    def __init__ (self, parent, identifier):
+        gobject.GObject.__init__ (self)
+        self.date = None
+
+        self.files = []
+        self.status = None
+        self.identifier = identifier
+        self.path = os.path.join (parent, identifier)
+
+        # Extract the date, since the directory name is of the
+        # format build-<year><month><day>-<ordinal> we can easily
+        # pull it out.
+        # TODO: Better to stat a file?
+        (_, date, revision) = identifier.split ("-")
+        print(date)
+
+        year = int (date[0:4])
+        month = int (date[4:6])
+        day = int (date[6:8])
+
+        self.date = datetime.date (year, month, day)
+
+        self.conf = None
+
+        # By default builds are STATE_FAILED unless we find a "complete" file
+        # in which case they are STATE_COMPLETE
+        self.state = BuildResult.STATE_FAILED
+        for file in os.listdir (self.path):
+            if (file.startswith (".conf")):
+                conffile = os.path.join (self.path, file)
+                self.conf = BuildConfiguration.load_from_file (conffile)
+            elif (file.startswith ("complete")):
+                self.state = BuildResult.STATE_COMPLETE
+            else:
+                self.add_file (file)
+
+    def add_file (self, file):
+        # Just add the file for now. Don't care about the type.
+        self.files += [(file, None)]
+
+class BuildManagerModel (gtk.TreeStore):
+    """ Model for the BuildManagerTreeView. This derives from gtk.TreeStore
+    but it abstracts nicely what the columns mean and the setup of the columns
+    in the model. """
+
+    (COL_IDENT, COL_DESC, COL_MACHINE, COL_DISTRO, COL_BUILD_RESULT, COL_DATE, COL_STATE) = \
+        (0, 1, 2, 3, 4, 5, 6)
+
+    def __init__ (self):
+        gtk.TreeStore.__init__ (self,
+            gobject.TYPE_STRING,
+            gobject.TYPE_STRING,
+            gobject.TYPE_STRING,
+            gobject.TYPE_STRING,
+            gobject.TYPE_OBJECT,
+            gobject.TYPE_INT64,
+            gobject.TYPE_INT)
+
+class BuildManager (gobject.GObject):
+    """ This class manages the historic builds that have been found in the
+    "results" directory but is also used for starting a new build."""
+
+    __gsignals__ = {
+        'population-finished' : (gobject.SIGNAL_RUN_LAST,
+                                 gobject.TYPE_NONE,
+                                 ()),
+        'populate-error' : (gobject.SIGNAL_RUN_LAST,
+                            gobject.TYPE_NONE,
+                            ())
+    }
+
+    def update_build_result (self, result, iter):
+        # Convert the date into something we can sort by.
+        date = long (time.mktime (result.date.timetuple()))
+
+        # Add a top level entry for the build
+
+        self.model.set (iter,
+            BuildManagerModel.COL_IDENT, result.identifier,
+            BuildManagerModel.COL_DESC, result.conf.image,
+            BuildManagerModel.COL_MACHINE, result.conf.machine,
+            BuildManagerModel.COL_DISTRO, result.conf.distro,
+            BuildManagerModel.COL_BUILD_RESULT, result,
+            BuildManagerModel.COL_DATE, date,
+            BuildManagerModel.COL_STATE, result.state)
+
+        # And then we use the files in the directory as the children for the
+        # top level iter.
+        for file in result.files:
+            self.model.append (iter, (None, file[0], None, None, None, date, -1))
+
+    # This function is called as an idle by the BuildManagerPopulaterThread
+    def add_build_result (self, result):
+        gtk.gdk.threads_enter()
+        self.known_builds += [result]
+
+        self.update_build_result (result, self.model.append (None))
+
+        gtk.gdk.threads_leave()
+
+    def notify_build_finished (self):
+        # This is a bit of a hack. If we have a running build running then we
+        # will have a row in the model in STATE_ONGOING. Find it and make it
+        # as if it was a proper historic build (well, it is completed now....)
+
+        # We need to use the iters here rather than the Python iterator
+        # interface to the model since we need to pass it into
+        # update_build_result
+
+        iter = self.model.get_iter_first()
+
+        while (iter):
+            (ident, state) = self.model.get(iter,
+                BuildManagerModel.COL_IDENT,
+                BuildManagerModel.COL_STATE)
+
+            if state == BuildResult.STATE_ONGOING:
+                result = BuildResult (self.results_directory, ident)
+                self.update_build_result (result, iter)
+            iter = self.model.iter_next(iter)
+
+    def notify_build_succeeded (self):
+        # Write the "complete" file so that when we create the BuildResult
+        # object we put into the model
+
+        complete_file_path = os.path.join (self.cur_build_directory, "complete")
+        f = file (complete_file_path, "w")
+        f.close()
+        self.notify_build_finished()
+
+    def notify_build_failed (self):
+        # Without a "complete" file then this will mark the build as failed:
+        self.notify_build_finished()
+
+    # This function is called as an idle
+    def emit_population_finished_signal (self):
+        gtk.gdk.threads_enter()
+        self.emit ("population-finished")
+        gtk.gdk.threads_leave()
+
+    class BuildManagerPopulaterThread (threading.Thread):
+        def __init__ (self, manager, directory):
+            threading.Thread.__init__ (self)
+            self.manager = manager
+            self.directory = directory
+
+        def run (self):
+            # For each of the "build-<...>" directories ..
+
+            if os.path.exists (self.directory):
+                for directory in os.listdir (self.directory):
+
+                    if not directory.startswith ("build-"):
+                        continue
+
+                    build_result = BuildResult (self.directory, directory)
+                    self.manager.add_build_result (build_result)
+
+            gobject.idle_add (BuildManager.emit_population_finished_signal,
+                self.manager)
+
+    def __init__ (self, server, results_directory):
+        gobject.GObject.__init__ (self)
+
+        # The builds that we've found from walking the result directory
+        self.known_builds = []
+
+        # Save out the bitbake server, we need this for issuing commands to
+        # the cooker:
+        self.server = server
+
+        # The TreeStore that we use
+        self.model = BuildManagerModel ()
+
+        # The results directory is where we create (and look for) the
+        # build-<xyz>-<n> directories. We need to populate ourselves from
+        # directory
+        self.results_directory = results_directory
+        self.populate_from_directory (self.results_directory)
+
+    def populate_from_directory (self, directory):
+        thread = BuildManager.BuildManagerPopulaterThread (self, directory)
+        thread.start()
+
+    # Come up with the name for the next build ident by combining "build-"
+    # with the date formatted as yyyymmdd and then an ordinal. We do this by
+    # an optimistic algorithm incrementing the ordinal if we find that it
+    # already exists.
+    def get_next_build_ident (self):
+        today = datetime.date.today ()
+        datestr = str (today.year) + str (today.month) + str (today.day)
+
+        revision = 0
+        test_name = "build-%s-%d" % (datestr, revision)
+        test_path = os.path.join (self.results_directory, test_name)
+
+        while (os.path.exists (test_path)):
+            revision += 1
+            test_name = "build-%s-%d" % (datestr, revision)
+            test_path = os.path.join (self.results_directory, test_name)
+
+        return test_name
+
+    # Take a BuildConfiguration and then try and build it based on the
+    # parameters of that configuration. S
+    def do_build (self, conf):
+        server = self.server
+
+        # Work out the build directory. Note we actually create the
+        # directories here since we need to write the ".conf" file. Otherwise
+        # we could have relied on bitbake's builder thread to actually make
+        # the directories as it proceeds with the build.
+        ident = self.get_next_build_ident ()
+        build_directory = os.path.join (self.results_directory,
+            ident)
+        self.cur_build_directory = build_directory
+        os.makedirs (build_directory)
+
+        conffile = os.path.join (build_directory, ".conf")
+        conf.write_to_file (conffile)
+
+        # Add a row to the model representing this ongoing build. It's kinda a
+        # fake entry. If this build completes or fails then this gets updated
+        # with the real stuff like the historic builds
+        date = long (time.time())
+        self.model.append (None, (ident, conf.image, conf.machine, conf.distro,
+            None, date, BuildResult.STATE_ONGOING))
+        try:
+            server.runCommand(["setVariable", "BUILD_IMAGES_FROM_FEEDS", 1])
+            server.runCommand(["setVariable", "MACHINE", conf.machine])
+            server.runCommand(["setVariable", "DISTRO", conf.distro])
+            server.runCommand(["setVariable", "PACKAGE_CLASSES", "package_ipk"])
+            server.runCommand(["setVariable", "BBFILES", \
+              """${OEROOT}/meta/packages/*/*.bb ${OEROOT}/meta-moblin/packages/*/*.bb"""])
+            server.runCommand(["setVariable", "TMPDIR", "${OEROOT}/build/tmp"])
+            server.runCommand(["setVariable", "IPK_FEED_URIS", \
+                " ".join(conf.get_repos())])
+            server.runCommand(["setVariable", "DEPLOY_DIR_IMAGE",
+                build_directory])
+            server.runCommand(["buildTargets", [conf.image], "rootfs"])
+
+        except Exception as e:
+            print(e)
+
+class BuildManagerTreeView (gtk.TreeView):
+    """ The tree view for the build manager. This shows the historic builds
+    and so forth. """
+
+    # We use this function to control what goes in the cell since we store
+    # the date in the model as seconds since the epoch (for sorting) and so we
+    # need to make it human readable.
+    def date_format_custom_cell_data_func (self, col, cell, model, iter):
+        date = model.get (iter, BuildManagerModel.COL_DATE)[0]
+        datestr = time.strftime("%A %d %B %Y", time.localtime(date))
+        cell.set_property ("text", datestr)
+
+    # This format function controls what goes in the cell. We use this to map
+    # the integer state to a string and also to colourise the text
+    def state_format_custom_cell_data_fun (self, col, cell, model, iter):
+        state = model.get (iter, BuildManagerModel.COL_STATE)[0]
+
+        if (state == BuildResult.STATE_ONGOING):
+            cell.set_property ("text", "Active")
+            cell.set_property ("foreground", "#000000")
+        elif (state == BuildResult.STATE_FAILED):
+            cell.set_property ("text", "Failed")
+            cell.set_property ("foreground", "#ff0000")
+        elif (state == BuildResult.STATE_COMPLETE):
+            cell.set_property ("text", "Complete")
+            cell.set_property ("foreground", "#00ff00")
+        else:
+            cell.set_property ("text", "")
+
+    def __init__ (self):
+        gtk.TreeView.__init__(self)
+
+        # Misc descriptiony thing
+        renderer = gtk.CellRendererText ()
+        col = gtk.TreeViewColumn (None, renderer,
+            text=BuildManagerModel.COL_DESC)
+        self.append_column (col)
+
+        # Machine
+        renderer = gtk.CellRendererText ()
+        col = gtk.TreeViewColumn ("Machine", renderer,
+            text=BuildManagerModel.COL_MACHINE)
+        self.append_column (col)
+
+        # distro
+        renderer = gtk.CellRendererText ()
+        col = gtk.TreeViewColumn ("Distribution", renderer,
+            text=BuildManagerModel.COL_DISTRO)
+        self.append_column (col)
+
+        # date (using a custom function for formatting the cell contents it
+        # takes epoch -> human readable string)
+        renderer = gtk.CellRendererText ()
+        col = gtk.TreeViewColumn ("Date", renderer,
+            text=BuildManagerModel.COL_DATE)
+        self.append_column (col)
+        col.set_cell_data_func (renderer,
+            self.date_format_custom_cell_data_func)
+
+        # For status.
+        renderer = gtk.CellRendererText ()
+        col = gtk.TreeViewColumn ("Status", renderer,
+            text = BuildManagerModel.COL_STATE)
+        self.append_column (col)
+        col.set_cell_data_func (renderer,
+            self.state_format_custom_cell_data_fun)

bitbake/lib/bb/ui/crumbs/hig/advancedsettingsdialog.py

@@ -0,0 +1,341 @@
+#
+# BitBake Graphical GTK User Interface
+#
+# Copyright (C) 2011-2012   Intel Corporation
+#
+# Authored by Joshua Lock <josh@linux.intel.com>
+# Authored by Dongxiao Xu <dongxiao.xu@intel.com>
+# Authored by Shane Wang <shane.wang@intel.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import gtk
+import hashlib
+from bb.ui.crumbs.hobwidget import HobInfoButton, HobButton
+from bb.ui.crumbs.progressbar import HobProgressBar
+from bb.ui.crumbs.hig.settingsuihelper import SettingsUIHelper
+from bb.ui.crumbs.hig.crumbsdialog import CrumbsDialog
+from bb.ui.crumbs.hig.crumbsmessagedialog import CrumbsMessageDialog
+from bb.ui.crumbs.hig.proxydetailsdialog import ProxyDetailsDialog
+
+"""
+The following are convenience classes for implementing GNOME HIG compliant
+BitBake GUI's
+In summary: spacing = 12px, border-width = 6px
+"""
+
+class AdvancedSettingsDialog (CrumbsDialog, SettingsUIHelper):
+    
+    def details_cb(self, button, parent, protocol):
+        dialog = ProxyDetailsDialog(title = protocol.upper() + " Proxy Details",
+            user = self.configuration.proxies[protocol][1],
+            passwd = self.configuration.proxies[protocol][2],
+            parent = parent,
+            flags = gtk.DIALOG_MODAL
+                    | gtk.DIALOG_DESTROY_WITH_PARENT
+                    | gtk.DIALOG_NO_SEPARATOR)
+        dialog.add_button(gtk.STOCK_CLOSE, gtk.RESPONSE_OK)
+        response = dialog.run()
+        if response == gtk.RESPONSE_OK:
+            self.configuration.proxies[protocol][1] = dialog.user
+            self.configuration.proxies[protocol][2] = dialog.passwd
+            self.refresh_proxy_components()
+        dialog.destroy()
+
+    def set_save_button(self, button):
+        self.save_button = button
+
+    def rootfs_combo_changed_cb(self, rootfs_combo, all_package_format, check_hbox):
+        combo_item = self.rootfs_combo.get_active_text()
+        modified = False
+        for child in check_hbox.get_children():
+            if isinstance(child, gtk.CheckButton):
+                check_hbox.remove(child)
+                modified = True
+        for format in all_package_format:
+            if format != combo_item:
+                check_button = gtk.CheckButton(format)
+                check_hbox.pack_start(check_button, expand=False, fill=False)
+                modified = True
+        if modified:
+            check_hbox.remove(self.pkgfmt_info)
+            check_hbox.pack_start(self.pkgfmt_info, expand=False, fill=False)
+        check_hbox.show_all()
+
+    def gen_pkgfmt_widget(self, curr_package_format, all_package_format, tooltip_combo="", tooltip_extra=""):
+        pkgfmt_vbox = gtk.VBox(False, 6)
+
+        label = self.gen_label_widget("Root file system package format")
+        pkgfmt_vbox.pack_start(label, expand=False, fill=False)
+
+        rootfs_format = ""
+        if curr_package_format:
+            rootfs_format = curr_package_format.split()[0]
+
+        rootfs_format_widget, rootfs_combo = self.gen_combo_widget(rootfs_format, all_package_format, tooltip_combo)
+        pkgfmt_vbox.pack_start(rootfs_format_widget, expand=False, fill=False)
+
+        label = self.gen_label_widget("Additional package formats")
+        pkgfmt_vbox.pack_start(label, expand=False, fill=False)
+
+        check_hbox = gtk.HBox(False, 12)
+        pkgfmt_vbox.pack_start(check_hbox, expand=False, fill=False)
+        for format in all_package_format:
+            if format != rootfs_format:
+                check_button = gtk.CheckButton(format)
+                is_active = (format in curr_package_format.split())
+                check_button.set_active(is_active)
+                check_hbox.pack_start(check_button, expand=False, fill=False)
+
+        self.pkgfmt_info = HobInfoButton(tooltip_extra, self)
+        check_hbox.pack_start(self.pkgfmt_info, expand=False, fill=False)
+
+        rootfs_combo.connect("changed", self.rootfs_combo_changed_cb, all_package_format, check_hbox)
+
+        pkgfmt_vbox.show_all()
+
+        return pkgfmt_vbox, rootfs_combo, check_hbox
+
+    def __init__(self, title, configuration, all_image_types,
+            all_package_formats, all_distros, all_sdk_machines,
+            max_threads, parent, flags, buttons=None):
+        super(AdvancedSettingsDialog, self).__init__(title, parent, flags, buttons)
+
+        # class members from other objects
+        # bitbake settings from Builder.Configuration
+        self.configuration = configuration
+        self.image_types = all_image_types
+        self.all_package_formats = all_package_formats
+        self.all_distros = all_distros[:]
+        self.all_sdk_machines = all_sdk_machines
+        self.max_threads = max_threads
+
+        # class members for internal use
+        self.distro_combo = None
+        self.dldir_text = None
+        self.sstatedir_text = None
+        self.sstatemirror_text = None
+        self.bb_spinner = None
+        self.pmake_spinner = None
+        self.rootfs_size_spinner = None
+        self.extra_size_spinner = None
+        self.gplv3_checkbox = None
+        self.sdk_checkbox = None
+        self.image_types_checkbuttons = {}
+
+        self.md5 = self.config_md5()
+        self.settings_changed = False
+
+        # create visual elements on the dialog
+        self.save_button = None
+        self.create_visual_elements()
+        self.connect("response", self.response_cb)
+
+    def _get_sorted_value(self, var):
+        return " ".join(sorted(str(var).split())) + "\n"
+
+    def config_md5(self):
+        data = ""
+        data += ("PACKAGE_CLASSES: "      + self.configuration.curr_package_format + '\n')
+        data += ("DISTRO: "               + self._get_sorted_value(self.configuration.curr_distro))
+        data += ("IMAGE_ROOTFS_SIZE: "    + self._get_sorted_value(self.configuration.image_rootfs_size))
+        data += ("IMAGE_EXTRA_SIZE: "     + self._get_sorted_value(self.configuration.image_extra_size))
+        data += ("INCOMPATIBLE_LICENSE: " + self._get_sorted_value(self.configuration.incompat_license))
+        data += ("SDK_MACHINE: "          + self._get_sorted_value(self.configuration.curr_sdk_machine))
+        data += ("TOOLCHAIN_BUILD: "      + self._get_sorted_value(self.configuration.toolchain_build))
+        data += ("IMAGE_FSTYPES: "        + self._get_sorted_value(self.configuration.image_fstypes))
+        return hashlib.md5(data).hexdigest()
+
+    def create_visual_elements(self):
+        self.nb = gtk.Notebook()
+        self.nb.set_show_tabs(True)
+        self.nb.append_page(self.create_image_types_page(), gtk.Label("Image types"))
+        self.nb.append_page(self.create_output_page(), gtk.Label("Output"))
+        self.nb.set_current_page(0)
+        self.vbox.pack_start(self.nb, expand=True, fill=True)
+        self.vbox.pack_end(gtk.HSeparator(), expand=True, fill=True)
+
+        self.show_all()
+
+    def get_num_checked_image_types(self):
+        total = 0
+        for b in self.image_types_checkbuttons.values():
+            if b.get_active():
+              total = total + 1
+        return total
+
+    def set_save_button_state(self):
+        if self.save_button:
+            self.save_button.set_sensitive(self.get_num_checked_image_types() > 0)
+
+    def image_type_checkbutton_clicked_cb(self, button):
+        self.set_save_button_state()
+        if self.get_num_checked_image_types() == 0:
+            # Show an error dialog
+            lbl = "<b>Select an image type</b>"
+            msg = "You need to select at least one image type."
+            dialog = CrumbsMessageDialog(self, lbl, gtk.MESSAGE_WARNING, msg)
+            button = dialog.add_button("OK", gtk.RESPONSE_OK)
+            HobButton.style_button(button)
+            response = dialog.run()
+            dialog.destroy()
+
+    def create_image_types_page(self):
+        main_vbox = gtk.VBox(False, 16)
+        main_vbox.set_border_width(6)
+
+        advanced_vbox = gtk.VBox(False, 6)
+        advanced_vbox.set_border_width(6)
+
+        distro_vbox = gtk.VBox(False, 6)        
+        label = self.gen_label_widget("Distro:")
+        tooltip = "Selects the Yocto Project distribution you want"
+        try:
+            i = self.all_distros.index( "defaultsetup" )
+        except ValueError:
+            i = -1
+        if i != -1:
+            self.all_distros[ i ] = "Default"
+            if self.configuration.curr_distro == "defaultsetup":
+                self.configuration.curr_distro = "Default"
+        distro_widget, self.distro_combo = self.gen_combo_widget(self.configuration.curr_distro, self.all_distros,"<b>Distro</b>" + "*" + tooltip)
+        distro_vbox.pack_start(label, expand=False, fill=False)
+        distro_vbox.pack_start(distro_widget, expand=False, fill=False)
+        main_vbox.pack_start(distro_vbox, expand=False, fill=False)
+
+
+        rows = (len(self.image_types)+1)/3
+        table = gtk.Table(rows + 1, 10, True)
+        advanced_vbox.pack_start(table, expand=False, fill=False)
+
+        tooltip = "Image file system types you want."
+        info = HobInfoButton("<b>Image types</b>" + "*" + tooltip, self)
+        label = self.gen_label_widget("Image types:")
+        align = gtk.Alignment(0, 0.5, 0, 0)
+        table.attach(align, 0, 4, 0, 1)
+        align.add(label)
+        table.attach(info, 4, 5, 0, 1)
+
+        i = 1
+        j = 1
+        for image_type in sorted(self.image_types):
+            self.image_types_checkbuttons[image_type] = gtk.CheckButton(image_type)
+            self.image_types_checkbuttons[image_type].connect("toggled", self.image_type_checkbutton_clicked_cb)
+            article = ""
+            if image_type.startswith(("a", "e", "i", "o", "u")):
+                article = "n"
+            if image_type == "live":
+                self.image_types_checkbuttons[image_type].set_tooltip_text("Build iso and hddimg images")
+            else:
+                self.image_types_checkbuttons[image_type].set_tooltip_text("Build a%s %s image" % (article, image_type))
+            table.attach(self.image_types_checkbuttons[image_type], j - 1, j + 3, i, i + 1)
+            if image_type in self.configuration.image_fstypes.split():
+                self.image_types_checkbuttons[image_type].set_active(True)
+            i += 1
+            if i > rows:
+                i = 1
+                j = j + 4
+
+        main_vbox.pack_start(advanced_vbox, expand=False, fill=False)
+        self.set_save_button_state()
+        
+        return main_vbox
+
+    def create_output_page(self):
+        advanced_vbox = gtk.VBox(False, 6)
+        advanced_vbox.set_border_width(6)
+
+        advanced_vbox.pack_start(self.gen_label_widget('<span weight="bold">Package format</span>'), expand=False, fill=False)
+        sub_vbox = gtk.VBox(False, 6)
+        advanced_vbox.pack_start(sub_vbox, expand=False, fill=False)
+        tooltip_combo = "Selects the package format used to generate rootfs."
+        tooltip_extra = "Selects extra package formats to build"
+        pkgfmt_widget, self.rootfs_combo, self.check_hbox = self.gen_pkgfmt_widget(self.configuration.curr_package_format, self.all_package_formats,"<b>Root file system package format</b>" + "*" + tooltip_combo,"<b>Additional package formats</b>" + "*" + tooltip_extra)
+        sub_vbox.pack_start(pkgfmt_widget, expand=False, fill=False)
+
+        advanced_vbox.pack_start(self.gen_label_widget('<span weight="bold">Image size</span>'), expand=False, fill=False)
+        sub_vbox = gtk.VBox(False, 6)
+        advanced_vbox.pack_start(sub_vbox, expand=False, fill=False)
+        label = self.gen_label_widget("Image basic size (in MB)")
+        tooltip = "Defines the size for the generated image. The OpenEmbedded build system determines the final size for the generated image using an algorithm that takes into account the initial disk space used for the generated image, the Image basic size value, and the Additional free space value.\n\nFor more information, check the <a href=\"http://www.yoctoproject.org/docs/current/poky-ref-manual/poky-ref-manual.html#var-IMAGE_ROOTFS_SIZE\">Yocto Project Reference Manual</a>."
+        rootfs_size_widget, self.rootfs_size_spinner = self.gen_spinner_widget(int(self.configuration.image_rootfs_size*1.0/1024), 0, 65536,"<b>Image basic size</b>" + "*" + tooltip)
+        sub_vbox.pack_start(label, expand=False, fill=False)
+        sub_vbox.pack_start(rootfs_size_widget, expand=False, fill=False)
+
+        sub_vbox = gtk.VBox(False, 6)
+        advanced_vbox.pack_start(sub_vbox, expand=False, fill=False)
+        label = self.gen_label_widget("Additional free space (in MB)")
+        tooltip = "Sets extra free disk space to be added to the generated image. Use this variable when you want to ensure that a specific amount of free disk space is available on a device after an image is installed and running."
+        extra_size_widget, self.extra_size_spinner = self.gen_spinner_widget(int(self.configuration.image_extra_size*1.0/1024), 0, 65536,"<b>Additional free space</b>" + "*" + tooltip)
+        sub_vbox.pack_start(label, expand=False, fill=False)
+        sub_vbox.pack_start(extra_size_widget, expand=False, fill=False)
+
+        advanced_vbox.pack_start(self.gen_label_widget('<span weight="bold">Licensing</span>'), expand=False, fill=False)
+        self.gplv3_checkbox = gtk.CheckButton("Exclude GPLv3 packages")
+        self.gplv3_checkbox.set_tooltip_text("Check this box to prevent GPLv3 packages from being included in your image")
+        if "GPLv3" in self.configuration.incompat_license.split():
+            self.gplv3_checkbox.set_active(True)
+        else:
+            self.gplv3_checkbox.set_active(False)
+        advanced_vbox.pack_start(self.gplv3_checkbox, expand=False, fill=False)
+
+        advanced_vbox.pack_start(self.gen_label_widget('<span weight="bold">SDK</span>'), expand=False, fill=False)
+        sub_hbox = gtk.HBox(False, 6)
+        advanced_vbox.pack_start(sub_hbox, expand=False, fill=False)
+        self.sdk_checkbox = gtk.CheckButton("Populate SDK")
+        tooltip = "Check this box to generate an SDK tarball that consists of the cross-toolchain and a sysroot that contains development packages for your image."
+        self.sdk_checkbox.set_tooltip_text(tooltip)
+        self.sdk_checkbox.set_active(self.configuration.toolchain_build)
+        sub_hbox.pack_start(self.sdk_checkbox, expand=False, fill=False)
+
+        tooltip = "Select the host platform for which you want to run the toolchain contained in the SDK tarball."
+        sdk_machine_widget, self.sdk_machine_combo = self.gen_combo_widget(self.configuration.curr_sdk_machine, self.all_sdk_machines,"<b>Populate SDK</b>" + "*" + tooltip)
+        sub_hbox.pack_start(sdk_machine_widget, expand=False, fill=False)
+
+        return advanced_vbox
+
+    def response_cb(self, dialog, response_id):
+        package_format = []
+        package_format.append(self.rootfs_combo.get_active_text())
+        for child in self.check_hbox:
+            if isinstance(child, gtk.CheckButton) and child.get_active():
+                package_format.append(child.get_label())
+        self.configuration.curr_package_format = " ".join(package_format)
+
+        distro = self.distro_combo.get_active_text()
+        if distro == "Default":
+            distro = "defaultsetup"
+        self.configuration.curr_distro = distro
+        self.configuration.image_rootfs_size = self.rootfs_size_spinner.get_value_as_int() * 1024
+        self.configuration.image_extra_size = self.extra_size_spinner.get_value_as_int() * 1024
+
+        self.configuration.image_fstypes = ""
+        for image_type in self.image_types:
+            if self.image_types_checkbuttons[image_type].get_active():
+                self.configuration.image_fstypes += (" " + image_type)
+        self.configuration.image_fstypes.strip()
+
+        if self.gplv3_checkbox.get_active():
+            if "GPLv3" not in self.configuration.incompat_license.split():
+                self.configuration.incompat_license += " GPLv3"
+        else:
+            if "GPLv3" in self.configuration.incompat_license.split():
+                self.configuration.incompat_license = self.configuration.incompat_license.split().remove("GPLv3")
+                self.configuration.incompat_license = " ".join(self.configuration.incompat_license or [])
+        self.configuration.incompat_license = self.configuration.incompat_license.strip()
+
+        self.configuration.toolchain_build = self.sdk_checkbox.get_active()
+        self.configuration.curr_sdk_machine = self.sdk_machine_combo.get_active_text()
+        md5 = self.config_md5()
+        self.settings_changed = (self.md5 != md5)

bitbake/lib/bb/ui/crumbs/hig/crumbsdialog.py

@@ -0,0 +1,44 @@
+#
+# BitBake Graphical GTK User Interface
+#
+# Copyright (C) 2011-2012   Intel Corporation
+#
+# Authored by Joshua Lock <josh@linux.intel.com>
+# Authored by Dongxiao Xu <dongxiao.xu@intel.com>
+# Authored by Shane Wang <shane.wang@intel.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import gtk
+
+"""
+The following are convenience classes for implementing GNOME HIG compliant
+BitBake GUI's
+In summary: spacing = 12px, border-width = 6px
+"""
+
+class CrumbsDialog(gtk.Dialog):
+    """
+    A GNOME HIG compliant dialog widget.
+    Add buttons with gtk.Dialog.add_button or gtk.Dialog.add_buttons
+    """
+    def __init__(self, title="", parent=None, flags=0, buttons=None):
+        super(CrumbsDialog, self).__init__(title, parent, flags, buttons)
+
+        self.set_property("has-separator", False) # note: deprecated in 2.22
+
+        self.set_border_width(6)
+        self.vbox.set_property("spacing", 12)
+        self.action_area.set_property("spacing", 12)
+        self.action_area.set_property("border-width", 6)

bitbake/lib/bb/ui/crumbs/hig/crumbsmessagedialog.py

@@ -0,0 +1,70 @@
+#
+# BitBake Graphical GTK User Interface
+#
+# Copyright (C) 2011-2012   Intel Corporation
+#
+# Authored by Joshua Lock <josh@linux.intel.com>
+# Authored by Dongxiao Xu <dongxiao.xu@intel.com>
+# Authored by Shane Wang <shane.wang@intel.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import glib
+import gtk
+from bb.ui.crumbs.hobwidget import HobIconChecker
+from bb.ui.crumbs.hig.crumbsdialog import CrumbsDialog
+
+"""
+The following are convenience classes for implementing GNOME HIG compliant
+BitBake GUI's
+In summary: spacing = 12px, border-width = 6px
+"""
+
+class CrumbsMessageDialog(gtk.MessageDialog):
+    """
+    A GNOME HIG compliant dialog widget.
+    Add buttons with gtk.Dialog.add_button or gtk.Dialog.add_buttons
+    """
+    def __init__(self, parent = None, label="", dialog_type = gtk.MESSAGE_QUESTION, msg=""):
+        super(CrumbsMessageDialog, self).__init__(None,
+                                                  gtk.DIALOG_MODAL | gtk.DIALOG_DESTROY_WITH_PARENT,
+                                                  dialog_type,
+                                                  gtk.BUTTONS_NONE,
+                                                  None)
+
+        self.set_skip_taskbar_hint(False)
+
+        self.set_markup(label)
+
+        if 0 <= len(msg) < 300:
+            self.format_secondary_markup(msg)
+        else:
+            vbox = self.get_message_area()
+            vbox.set_border_width(1)
+            vbox.set_property("spacing", 12)
+            self.textWindow = gtk.ScrolledWindow()
+            self.textWindow.set_shadow_type(gtk.SHADOW_IN)
+            self.textWindow.set_policy(gtk.POLICY_AUTOMATIC, gtk.POLICY_AUTOMATIC)
+            self.msgView = gtk.TextView()
+            self.msgView.set_editable(False)
+            self.msgView.set_wrap_mode(gtk.WRAP_WORD)
+            self.msgView.set_cursor_visible(False)
+            self.msgView.set_size_request(300, 300)
+            self.buf = gtk.TextBuffer()
+            self.buf.set_text(msg)
+            self.msgView.set_buffer(self.buf)
+            self.textWindow.add(self.msgView)
+            self.msgView.show()
+            vbox.add(self.textWindow)
+            self.textWindow.show()

bitbake/lib/bb/ui/crumbs/hig/deployimagedialog.py

@@ -0,0 +1,219 @@
+#
+# BitBake Graphical GTK User Interface
+#
+# Copyright (C) 2011-2012   Intel Corporation
+#
+# Authored by Joshua Lock <josh@linux.intel.com>
+# Authored by Dongxiao Xu <dongxiao.xu@intel.com>
+# Authored by Shane Wang <shane.wang@intel.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import glob
+import gtk
+import gobject
+import os
+import re
+import shlex
+import subprocess
+import tempfile
+from bb.ui.crumbs.hobwidget import hic, HobButton
+from bb.ui.crumbs.progressbar import HobProgressBar
+import bb.ui.crumbs.utils
+import bb.process
+from bb.ui.crumbs.hig.crumbsdialog import CrumbsDialog
+from bb.ui.crumbs.hig.crumbsmessagedialog import CrumbsMessageDialog
+
+"""
+The following are convenience classes for implementing GNOME HIG compliant
+BitBake GUI's
+In summary: spacing = 12px, border-width = 6px
+"""
+
+class DeployImageDialog (CrumbsDialog):
+
+    __dummy_usb__ = "--select a usb drive--"
+
+    def __init__(self, title, image_path, parent, flags, buttons=None, standalone=False):
+        super(DeployImageDialog, self).__init__(title, parent, flags, buttons)
+
+        self.image_path = image_path
+        self.standalone = standalone
+
+        self.create_visual_elements()
+        self.connect("response", self.response_cb)
+
+    def create_visual_elements(self):
+        self.set_size_request(600, 400)
+        label = gtk.Label()
+        label.set_alignment(0.0, 0.5)
+        markup = "<span font_desc='12'>The image to be written into usb drive:</span>"
+        label.set_markup(markup)
+        self.vbox.pack_start(label, expand=False, fill=False, padding=2)
+
+        table = gtk.Table(2, 10, False)
+        table.set_col_spacings(5)
+        table.set_row_spacings(5)
+        self.vbox.pack_start(table, expand=True, fill=True)
+
+        scroll = gtk.ScrolledWindow()
+        scroll.set_policy(gtk.POLICY_NEVER, gtk.POLICY_AUTOMATIC)
+        scroll.set_shadow_type(gtk.SHADOW_IN)
+        tv = gtk.TextView()
+        tv.set_editable(False)
+        tv.set_wrap_mode(gtk.WRAP_WORD)
+        tv.set_cursor_visible(False)
+        self.buf = gtk.TextBuffer()
+        self.buf.set_text(self.image_path)
+        tv.set_buffer(self.buf)
+        scroll.add(tv)
+        table.attach(scroll, 0, 10, 0, 1)
+
+        # There are 2 ways to use DeployImageDialog
+        # One way is that called by HOB when the 'Deploy Image' button is clicked
+        # The other way is that called by a standalone script.
+        # Following block of codes handles the latter way. It adds a 'Select Image' button and
+        # emit a signal when the button is clicked.
+        if self.standalone:
+                gobject.signal_new("select_image_clicked", self, gobject.SIGNAL_RUN_FIRST,
+                                   gobject.TYPE_NONE, ())
+                icon = gtk.Image()
+                pix_buffer = gtk.gdk.pixbuf_new_from_file(hic.ICON_IMAGES_DISPLAY_FILE)
+                icon.set_from_pixbuf(pix_buffer)
+                button = gtk.Button("Select Image")
+                button.set_image(icon)
+                #button.set_size_request(140, 50)
+                table.attach(button, 9, 10, 1, 2, gtk.FILL, 0, 0, 0)
+                button.connect("clicked", self.select_image_button_clicked_cb)
+
+        separator = gtk.HSeparator()
+        self.vbox.pack_start(separator, expand=False, fill=False, padding=10)
+
+        self.usb_desc = gtk.Label()
+        self.usb_desc.set_alignment(0.0, 0.5)
+        markup = "<span font_desc='12'>You haven't chosen any USB drive.</span>"
+        self.usb_desc.set_markup(markup)
+
+        self.usb_combo = gtk.combo_box_new_text()
+        self.usb_combo.connect("changed", self.usb_combo_changed_cb)
+        model = self.usb_combo.get_model()
+        model.clear()
+        self.usb_combo.append_text(self.__dummy_usb__)
+        for usb in self.find_all_usb_devices():
+            self.usb_combo.append_text("/dev/" + usb)
+        self.usb_combo.set_active(0)
+        self.vbox.pack_start(self.usb_combo, expand=False, fill=False)
+        self.vbox.pack_start(self.usb_desc, expand=False, fill=False, padding=2)
+
+        self.progress_bar = HobProgressBar()
+        self.vbox.pack_start(self.progress_bar, expand=False, fill=False)
+        separator = gtk.HSeparator()
+        self.vbox.pack_start(separator, expand=False, fill=True, padding=10)
+
+        self.vbox.show_all()
+        self.progress_bar.hide()
+
+    def set_image_text_buffer(self, image_path):
+        self.buf.set_text(image_path)
+
+    def set_image_path(self, image_path):
+        self.image_path = image_path
+
+    def popen_read(self, cmd):
+        tmpout, errors = bb.process.run("%s" % cmd)
+        return tmpout.strip()
+
+    def find_all_usb_devices(self):
+        usb_devs = [ os.readlink(u)
+            for u in glob.glob('/dev/disk/by-id/usb*')
+            if not re.search(r'part\d+', u) ]
+        return [ '%s' % u[u.rfind('/')+1:] for u in usb_devs ]
+
+    def get_usb_info(self, dev):
+        return "%s %s" % \
+            (self.popen_read('cat /sys/class/block/%s/device/vendor' % dev),
+            self.popen_read('cat /sys/class/block/%s/device/model' % dev))
+
+    def select_image_button_clicked_cb(self, button):
+            self.emit('select_image_clicked')
+
+    def usb_combo_changed_cb(self, usb_combo):
+        combo_item = self.usb_combo.get_active_text()
+        if not combo_item or combo_item == self.__dummy_usb__:
+            markup = "<span font_desc='12'>You haven't chosen any USB drive.</span>"
+            self.usb_desc.set_markup(markup)
+        else:
+            markup = "<span font_desc='12'>" + self.get_usb_info(combo_item.lstrip("/dev/")) + "</span>"
+            self.usb_desc.set_markup(markup)
+
+    def response_cb(self, dialog, response_id):
+        if response_id == gtk.RESPONSE_YES:
+            lbl = ''
+            msg = ''
+            combo_item = self.usb_combo.get_active_text()
+            if combo_item and combo_item != self.__dummy_usb__ and self.image_path:
+                cmdline = bb.ui.crumbs.utils.which_terminal()
+                if cmdline:
+                    tmpfile = tempfile.NamedTemporaryFile()
+                    cmdline += "\"sudo dd if=" + self.image_path + \
+                                " of=" + combo_item + " && sync; echo $? > " + tmpfile.name + "\""
+                    subprocess.call(shlex.split(cmdline))
+
+                    if int(tmpfile.readline().strip()) == 0:
+                        lbl = "<b>Deploy image successfully.</b>"
+                    else:
+                        lbl = "<b>Failed to deploy image.</b>"
+                        msg = "Please check image <b>%s</b> exists and USB device <b>%s</b> is writable." % (self.image_path, combo_item)
+                    tmpfile.close()
+            else:
+                if not self.image_path:
+                    lbl = "<b>No selection made.</b>"
+                    msg = "You have not selected an image to deploy."
+                else:
+                    lbl = "<b>No selection made.</b>"
+                    msg = "You have not selected a USB device."
+            if len(lbl):
+                crumbs_dialog = CrumbsMessageDialog(self, lbl, gtk.MESSAGE_INFO, msg)
+                button = crumbs_dialog.add_button("Close", gtk.RESPONSE_OK)
+                HobButton.style_button(button)
+                crumbs_dialog.run()
+                crumbs_dialog.destroy()
+
+    def update_progress_bar(self, title, fraction, status=None):
+        self.progress_bar.update(fraction)
+        self.progress_bar.set_title(title)
+        self.progress_bar.set_rcstyle(status)
+
+    def write_file(self, ifile, ofile):
+        self.progress_bar.reset()
+        self.progress_bar.show()
+
+        f_from = os.open(ifile, os.O_RDONLY)
+        f_to = os.open(ofile, os.O_WRONLY)
+
+        total_size = os.stat(ifile).st_size
+        written_size = 0
+
+        while True:
+            buf = os.read(f_from, 1024*1024)
+            if not buf:
+                break
+            os.write(f_to, buf)
+            written_size += 1024*1024
+            self.update_progress_bar("Writing to usb:", written_size * 1.0/total_size)
+
+        self.update_progress_bar("Writing completed:", 1.0)
+        os.close(f_from)
+        os.close(f_to)
+        self.progress_bar.hide()

bitbake/lib/bb/ui/crumbs/hig/imageselectiondialog.py

@@ -0,0 +1,172 @@
+#
+# BitBake Graphical GTK User Interface
+#
+# Copyright (C) 2011-2012   Intel Corporation
+#
+# Authored by Joshua Lock <josh@linux.intel.com>
+# Authored by Dongxiao Xu <dongxiao.xu@intel.com>
+# Authored by Shane Wang <shane.wang@intel.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License version 2 as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License along
+# with this program; if not, write to the Free Software Foundation, Inc.,
+# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+import gtk
+import gobject
+import os
+from bb.ui.crumbs.hobwidget import HobViewTable, HobInfoButton, HobButton, HobAltButton
+from bb.ui.crumbs.hig.crumbsdialog import CrumbsDialog
+from bb.ui.crumbs.hig.layerselectiondialog import LayerSelectionDialog
+
+"""
+The following are convenience classes for implementing GNOME HIG compliant
+BitBake GUI's
+In summary: spacing = 12px, border-width = 6px
+"""
+
+class ImageSelectionDialog (CrumbsDialog):
+
+    __columns__ = [{
+            'col_name' : 'Image name',
+            'col_id'   : 0,
+            'col_style': 'text',
+            'col_min'  : 400,
+            'col_max'  : 400
+        }, {
+            'col_name' : 'Select',
+            'col_id'   : 1,
+            'col_style': 'radio toggle',
+            'col_min'  : 160,
+            'col_max'  : 160
+    }]
+
+
+    def __init__(self, image_folder, image_types, title, parent, flags, buttons=None, image_extension = {}):
+        super(ImageSelectionDialog, self).__init__(title, parent, flags, buttons)
+        self.connect("response", self.response_cb)
+
+        self.image_folder = image_folder
+        self.image_types  = image_types
+        self.image_list = []
+        self.image_names = []
+        self.image_extension = image_extension
+
+        # create visual elements on the dialog
+        self.create_visual_elements()
+
+        self.image_store = gtk.ListStore(gobject.TYPE_STRING, gobject.TYPE_BOOLEAN)
+        self.fill_image_store()
+
+    def create_visual_elements(self):
+        hbox = gtk.HBox(False, 6)
+
+        self.vbox.pack_start(hbox, expand=False, fill=False)
+
+        entry = gtk.Entry()
+        entry.set_text(self.image_folder)
+        table = gtk.Table(1, 10, True)
+        table.set_size_request(560, -1)
+        hbox.pack_start(table, expand=False, fill=False)
+        table.attach(entry, 0, 9, 0, 1)
+        image = gtk.Image()
+        image.set_from_stock(gtk.STOCK_OPEN, gtk.ICON_SIZE_BUTTON)
+        open_button = gtk.Button()
+        open_button.set_image(image)
+        open_button.connect("clicked", self.select_path_cb, self, entry)
+        table.attach(open_button, 9, 10, 0, 1)
+
+        self.image_table = HobViewTable(self.__columns__, "Images")
+        self.image_table.set_size_request(-1, 300)
+        self.image_table.connect("toggled", self.toggled_cb)
+        self.image_table.connect_group_selection(self.table_selected_cb)
+        self.image_table.connect("row-activated", self.row_actived_cb)
+        self.vbox.pack_start(self.image_table, expand=True, fill=True)
+
+        self.show_all()
+
+    def change_image_cb(self, model, path, columnid):
+        if not model:
+            return
+        iter = model.get_iter_first()
+        while iter:
+            rowpath = model.get_path(iter)
+            model[rowpath][columnid] = False
+            iter = model.iter_next(iter)
+
+        model[path][columnid] = True
+
+    def toggled_cb(self, table, cell, path, columnid, tree):
+        model = tree.get_model()
+        self.change_image_cb(model, path, columnid)
+
+    def table_selected_cb(self, selection):
+        model, paths = selection.get_selected_rows()
+        if paths:
+            self.change_image_cb(model, paths[0], 1)
+
+    def row_actived_cb(self, tab, model, path):
+        self.change_image_cb(model, path, 1)
+        self.emit('response', gtk.RESPONSE_YES)
+
+    def select_path_cb(self, action, parent, entry):
+        dialog = gtk.FileChooserDialog("", parent,
+                                       gtk.FILE_CHOOSER_ACTION_SELECT_FOLDER)
+        text = entry.get_text()
+        dialog.set_current_folder(text if len(text) > 0 else os.getcwd())
+        button = dialog.add_button("Cancel", gtk.RESPONSE_NO)
+        HobAltButton.style_button(button)
+        button = dialog.add_button("Open", gtk.RESPONSE_YES)
+        HobButton.style_button(button)
+        response = dialog.run()
+        if response == gtk.RESPONSE_YES:
+            path = dialog.get_filename()
+            entry.set_text(path)
+            self.image_folder = path
+            self.fill_image_store()
+
+        dialog.destroy()
+
+    def fill_image_store(self):
+        self.image_list = []
+        self.image_store.clear()
+        imageset = set()
+        for root, dirs, files in os.walk(self.image_folder):
+            # ignore the sub directories
+            dirs[:] = []
+            for f in files:
+                for image_type in self.image_types:
+                    if image_type in self.image_extension:
+                        real_types = self.image_extension[image_type]
+                    else:
+                        real_types = [image_type]
+                    for real_image_type in real_types:
+                        if f.endswith('.' + real_image_type):
+                            imageset.add(f.rsplit('.' + real_image_type)[0].rsplit('.rootfs')[0])
+                            self.image_list.append(f)
+
+        for image in imageset:
+            self.image_store.set(self.image_store.append(), 0, image, 1, False)
+
+        self.image_table.set_model(self.image_store)
+
+    def response_cb(self, dialog, response_id):
+        self.image_names = []
+        if response_id == gtk.RESPONSE_YES:
+            iter = self.image_store.get_iter_first()
+            while iter:
+                path = self.image_store.get_path(iter)
+                if self.image_store[path][1]:
+                    for f in self.image_list:
+                        if f.startswith(self.image_store[path][0] + '.'):
+                            self.image_names.append(f)
+                    break
+                iter = self.image_store.iter_next(iter)