Setting up an OpenEmbedded build is a fairly simple process if you carefully follow the instructions. There are also a number of scripts available that automate the setup such as the OpenEmbedded Tools for Eclipse, the Angstrom setup scripts, the KaeilOS Openembedded Manager, and I’m sure there are many more (feel free to add in comments section). As we have helped a number of clients use OpenEmbedded in commercial projects, we have the following requirements for a build template:
- The build needs to be completely automated such that only one step is required to build images.
- We need to be able to lock down versions of various components.
- Needs to be as simple as possible.
As we continue to think about creating a build template, the primary reason for creating one is to get repeatable builds with very little effort. The build template serves as documentation; how did we build the 1.10 release. A good build system allows any developer to create any release on about any machine at any time. A good build system does not depend on the “golden build machine.” We have been using makefile wrappers around OpenEmbedded for several years now to accomplish much of this. These wrappers were typically stored in a Subversion repository with the rest of the project files. However, now that most open source projects have moved to Git repositories, there are significant advantages to using Git for the build system. Git has a feature called submodules which allows you to embed a git repository inside a source tree, always pointed at a particular commit. In concept, this is perfect. In practice, Git submodules are sometimes difficult to use, but considering the functionality provided, I think it is a reasonable trade-off.
The use of Git encourages a different development paradigm. Typically when people use Subversion within a company, there is one repository that stores everything. Subversion is actually quite good at this. I’ve run into a number of companies who have repositories many GB in size that have been running for many years. The stability is remarkable. Git does not scale in this way, so people tend to set up a separate repository for each component, application, etc. While there may be some disadvantages to this model, there are also significant advantages, and we can learn some of these by observing Open Source Software (OSS) development. Just as we strive for modularity in software development where each class can stand on its own and be generally useful, OSS maintains this dynamic at the project level. Each OSS project moves at its own pace, largely decoupled from other projects. This dynamic forces a level of organization that might be neglected otherwise. Likewise, in any project, if each major component is stored in its own source code repository, there will also tend to be less coupling, willy-nilly including of header files from other components, etc. It helps people think in a more modular manner at the component level. A component may be the Linux kernel, bootloader, each application in the system, etc. A similar concept may be thinking about storing documents in hierarchical filesystem directory structure versus documents in a Wiki, which are stored in a flat structure and then organized by cross linking. Yes, there are times to use a directory structure, but flexibility of a linked organization system (the essence of the Internet) is hard to beat. Git submodules (or similar concepts) provides a similar linking method of organization.
With this in mind, we look at a build system as a way to collect a number of independent components and build them in a repeatable fashion. While this may seem obvious to anyone somewhat familiar with OpenEmbedded, our vision is to extend this concept to easily facilitate product development so that we can move quickly and efficiently, but yet in a controlled and reliable way. The first step is a new build template that is available here. The following video provides a short overview of how to use the build template (can be viewed in Firefox).
The functionality provided so far is fairly simple and provides a way to quickly set up a build environment. With Git submodules, the versions of Bitbake and the OpenEmbedded are locked down. Submodules are also used to provide an array of components to choose from, and the user initializes only the submodules they are interested in using. The first example of this is providing both the recipe meta data from the OpenEmbedded project or the modified version from Gumstix. In the future, examples will be provided for doing custom application and kernel development using the OE srctree and gitver classes. Feedback is welcome; please let me know if you have questions or suggestions.