build.sh 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287
  1. #!/bin/bash
  2. # (c) 2014-2016 Freifunk Hochstift <kontakt@hochstift.freifunk.net>
  3. #
  4. # This script builds the firmware by the environment variables given, the
  5. # first two being mandatory:
  6. #
  7. # BASE = Gluon Version (tag or commit, i.e. v2014.4)
  8. # BRANCH = Firmware Branch (stable/testing/experimental)
  9. # VERSION = the version tag (can only be empty if BRANCH=experimental)
  10. #
  11. # optional:
  12. # AUTOUPDATER = force Autoupdater Branch (stable/testing/experimental/off)
  13. # BROKEN = 0 (default) or 1, build the untested hardware model firmwares, too
  14. # BUILD_TS = build timestamp (format: %Y-%m-%d %H:%M:%S)
  15. # DIRCLEAN = 1 perform "make dirclean" before build (BRANCH==stable/testing) or 0 perform "make clean" (BRANCH==experimental)
  16. # FAKETIME_LIB = path to libfaketime.so.1 if it is not in the standard location
  17. # KEY_DIR = specify directory for gluon-opkg-key
  18. # MAKEJOBS = number of compiler processes running in parallel (default: number of CPUs/Cores)
  19. # NO_FAKETIME = 0 (default) or 1, disables the use of Faketime
  20. # PRIORITY = determines the number of day a rollout phase should last at most
  21. # SITE_ID = specific site repository commit-id (leave blank to use HEAD)
  22. # SITE_REPO_FETCH_METHOD = http, everything except "git" will use the HTTP method for fetchting site repo
  23. # TARGETS = a space separated list of target platforms (if unset, all platforms will be build)
  24. # VERBOSE = 0 (default) or 1, call the make commands with 'V=s' to see actual errors better
  25. #
  26. ### includes
  27. . functions.sh
  28. ### static variables
  29. MY_DIR=$(dirname $0)
  30. MY_DIR=$(readlink -f "${MY_DIR}")
  31. DEFAULT_KEY_DIR="${MY_DIR}/opkg-keys"
  32. CODE_DIR="${MY_DIR}/src"
  33. GLUON_BUILD_DIR="${CODE_DIR}/build"
  34. SITE_DIR="${CODE_DIR}/site"
  35. PATCH_DIR="${SITE_DIR}/patches"
  36. OUTPUT_DIR="${MY_DIR}/output"
  37. IMAGE_DIR="${CODE_DIR}/output/images"
  38. MODULE_DIR="${CODE_DIR}/output/modules"
  39. VERSIONS_INFO_DIR="${MY_DIR}/versions"
  40. BUILD_INFO_FILENAME="build-info.txt"
  41. SITE_REPO_URL="git.c3pb.de/freifunk-pb/site-ffho.git"
  42. LANG=C
  43. pushd ${MY_DIR} > /dev/null
  44. ### ERROR handling
  45. [ -n "${BASE}" ] || abort "Please specify BASE environment variable (Gluon, i.e. 'v2014.3' or commit-id)."
  46. [ -n "${BRANCH}" ] || abort "Please specify BRANCH environment variable."
  47. [ "${BRANCH}" == "experimental" -o "${BASE}" != "HEAD" ] || abort "HEAD is not an allowed BASE-identifier for non-experimental builds. Either use a tagged commit or the commit-SHA itself."
  48. [ -n "${VERSION}" -o "${BRANCH}" == "experimental" ] || abort "Please specify VERSION environment variable (not necessary for experimental branch)."
  49. [ "${BRANCH}" == "experimental" -o ! -r "${VERSIONS_INFO_DIR}/${VERSION}" ] || abort "There exists a version file for '${VERSION}' ... you are trying to do something really stupid, aren't you?"
  50. ### set reasonable defaults for unset environment variables
  51. [ -n "${AUTOUPDATER}" ] || AUTOUPDATER=${BRANCH}
  52. # TODO: [ "${BASE}" == "master" ] && BASE="origin/master"
  53. if [ -n "${BROKEN}" ]; then
  54. if [ "${BROKEN}" -eq "1" ]; then
  55. export BROKEN
  56. else
  57. unset BROKEN
  58. fi
  59. fi
  60. [ -n "${BUILD_TS}" ] || BUILD_TS=$(date +"%Y-%m-%d %H:%M:%S")
  61. if [ -z "${DIRCLEAN}" ]; then
  62. if [ "${BRANCH}" == "experimental" ]; then
  63. DIRCLEAN=0
  64. else
  65. DIRCLEAN=1
  66. fi
  67. fi
  68. if [ -n "${KEY_DIR}" ]; then
  69. KEY_DIR=$(readlink -f "${KEY_DIR}")
  70. else
  71. KEY_DIR="${DEFAULT_KEY_DIR}"
  72. fi
  73. [ -e "${KEY_DIR}" ] || mkdir -p ${KEY_DIR}
  74. [ "$?" -eq "0" ] || abort "Unable to create output directory: ${KEY_DIR}"
  75. [ -n "${MAKEJOBS}" ] || MAKEJOBS=$(grep -c "^processor" /proc/cpuinfo)
  76. [ -n "${NO_FAKETIME}" ] || NO_FAKETIME=0
  77. [ -n "${PRIORITY}" ] || PRIORITY=0
  78. [ -n "${SITE_REPO_FETCH_METHOD}" ] || SITE_REPO_FETCH_METHOD="http"
  79. [ -n "${VERBOSE}" ] || VERBOSE=0
  80. if [ "${SITE_REPO_FETCH_METHOD}" != "git" ]; then
  81. SITE_REPO_URL="https://${SITE_REPO_URL}"
  82. else
  83. SITE_REPO_URL="git@${SITE_REPO_URL}"
  84. fi
  85. MAKE_PARAM=""
  86. [ "${VERBOSE}" -eq "1" ] && MAKE_PARAM="${MAKE_PARAM} V=s"
  87. ### INIT /src IF NECESSARY
  88. if [ ! -d "${CODE_DIR}" ]; then
  89. info "Code directory does not exist yet - fetching Gluon ..."
  90. git clone https://github.com/freifunk-gluon/gluon.git "${CODE_DIR}"
  91. [ "$?" -eq "0" ] || abort "Failed to fetch Gluon repository."
  92. fi
  93. ### INIT /src/site IF NECESSARY
  94. if [ ! -d "${SITE_DIR}" ]; then
  95. info "Site repository does not exist, fetching it ..."
  96. git clone "${SITE_REPO_URL}" "${SITE_DIR}"
  97. [ "$?" -eq "0" ] || abort "Failed to fetch SITE repository."
  98. fi
  99. pushd ${CODE_DIR} > /dev/null
  100. ### CHECKOUT GLUON
  101. progress "Checking out GLUON '${BASE}' ..."
  102. # TODO: check if gluon got modified and bail out if necessary
  103. git fetch
  104. git checkout -q ${BASE}
  105. [ "$?" -eq "0" ] || abort "Failed to checkout '${BASE}' gluon base version, mimimi." >&2
  106. GLUON_COMMIT=$(git rev-list --max-count=1 HEAD)
  107. ### CHECKOUT SITE REPO
  108. progress "Checking out SITE REPO ..."
  109. pushd ${SITE_DIR} > /dev/null
  110. # TODO: check if site got modified locally and bail out if necessary
  111. if [ -z "${SITE_ID}" ]; then
  112. # no specific site given - get the most current one
  113. git checkout -q ${BRANCH} ; git pull
  114. [ "$?" -eq "0" ] || abort "Failed to get newest '${BRANCH}' in site repository, mimimi."
  115. else
  116. # fetch site repo updates
  117. git fetch || true
  118. # commit given - use this one
  119. git checkout -q ${SITE_ID}
  120. [ "$?" -eq "0" ] || abort "Failed to checkout requested site commit '${SITE_ID}', mimimi."
  121. fi
  122. SITE_COMMIT=$(git rev-list --max-count=1 HEAD)
  123. popd > /dev/null #${SITE_DIR}
  124. ### APPLY PATCHES TO GLUON
  125. progress "Applying Patches ..."
  126. git checkout -B patching "${BASE}"
  127. if [ -d "${PATCH_DIR}" -a "$(echo ${PATCH_DIR}/*.patch)" ]; then
  128. git am ${PATCH_DIR}/*.patch || (
  129. git am --abort
  130. git checkout patched
  131. git branch -D patching
  132. false
  133. )
  134. [ "$?" -eq "0" ] || abort "Failed to apply patches, mimimi."
  135. fi
  136. git branch -M patched
  137. ### DIRCLEAN
  138. if [ -d "./build/" -a "${DIRCLEAN}" -eq "1" ]; then
  139. progress "Cleaning your build environment ..."
  140. make dirclean
  141. fi
  142. ### PREPARE
  143. progress "Preparing the build environment (make update) ..."
  144. make update
  145. [ "$?" -eq "0" ] || abort "Failed to update the build environment, mimimi."
  146. popd > /dev/null #${CODE_DIR}
  147. ### set reasonable defaults for ${TARGETS} and ${BRANCH} if unset
  148. if [ -z "${TARGETS}" ]; then
  149. TARGETS=$(make list-targets | sed -e 's/^[[:space:]]*//' -e 's/[[:space:]]*$//')
  150. info "building all tagets: '${TARGETS}'"
  151. fi
  152. if [ "${BRANCH}" == "experimental" -a -z "${VERSION}" ] ; then
  153. VERSION=$(make default-release)
  154. info "EXPERIMENTAL FIRMWARE: using version tag '${VERSION}'"
  155. fi
  156. # we are now ready to produce the firmware images, so let's "save" our state
  157. build_info_path="${OUTPUT_DIR}/${BRANCH}/${BUILD_INFO_FILENAME}"
  158. progress "Saving build information to: ${build_info_path}"
  159. [ -n "${build_info_path}" -a -f "${build_info_path}" ] && rm -f ${build_info_path}
  160. mkdir -p $(dirname ${build_info_path})
  161. [ "$?" -eq "0" ] || abort "Unable to create output directory: $(dirname ${build_info_path})"
  162. touch $(dirname ${build_info_path})
  163. [ "$?" -eq "0" ] || abort "Cannot create build information file: ${build_info_path}"
  164. echo "VERSION=${VERSION}" >> ${build_info_path}
  165. echo "GLUON=${GLUON_COMMIT} # ${BASE}" >> ${build_info_path}
  166. echo "BRANCH=${BRANCH}" >> ${build_info_path}
  167. echo "SITE=${SITE_COMMIT} # ${VERSION}" >> ${build_info_path}
  168. echo "TARGETS=${TARGETS}" >> ${build_info_path}
  169. echo "TS=${BUILD_TS}" >> ${build_info_path}
  170. ### SETUP FAKETIME (consistent build)
  171. if [ "${NO_FAKETIME}" -eq "0" ]; then
  172. [ -z "${FAKETIME_LIB}" ] && FAKETIME_LIB="/usr/lib/${MACHTYPE}-${OSTYPE}/faketime/libfaketime.so.1"
  173. export LD_PRELOAD="${FAKETIME_LIB}"
  174. export FAKETIME="${BUILD_TS}"
  175. fi
  176. ### restore gluon-opkg-key, if already exists
  177. if [ -e "${KEY_DIR}/gluon-opkg-key" -a -e "${KEY_DIR}/gluon-opkg-key.pub" ]; then
  178. info "gluon-opkg-key already exists, restoring it."
  179. mkdir -p ${GLUON_BUILD_DIR}/
  180. [ "$?" -eq "0" ] || abort "Unable to create directory: ${GLUON_BUILD_DIR}/"
  181. cp -f ${KEY_DIR}/gluon-opkg-key* ${GLUON_BUILD_DIR}/
  182. [ "$?" -eq "0" ] || abort "Unable to copy gluon-opkg-key."
  183. fi
  184. ### BUILD FIRMWARE
  185. progress "Building the firmware - please stand by!"
  186. pushd ${CODE_DIR} > /dev/null
  187. for target in ${TARGETS} ; do
  188. # configure build environment for our current target
  189. export GLUON_TARGET="${target}"
  190. export GLUON_RELEASE="${VERSION}"
  191. [ "${AUTOUPDATER}" != "off" ] && export GLUON_BRANCH="${AUTOUPDATER}"
  192. # prepare build environment for our current target
  193. progress "Preparing build environment for target ${target}."
  194. [ "${DIRCLEAN}" -eq "1" ] || make clean
  195. [ "$?" -eq "0" ] || abort "Unable to clean environment for target-platform ${target}."
  196. make -j ${MAKEJOBS} prepare-target ${MAKE_PARAM}
  197. [ "$?" -eq "0" ] || abort "Unable to build environment for target-platform ${target}."
  198. # need to have a toolchain for the particular target
  199. progress "Building toolchain for target ${target}."
  200. make -j ${MAKEJOBS} toolchain/install ${MAKE_PARAM}
  201. [ "$?" -eq "0" ] || abort "Unable to build toolchain for target-platform ${target}."
  202. # now we can start building the images for the target platform
  203. progress "Building FFHO-flavoured Gluon firmware for target ${target}. You'd better go and fetch some c0ffee!"
  204. make -j ${MAKEJOBS} prepare ${MAKE_PARAM}
  205. [ "$?" -eq "0" ] || abort "Failed to build firmware for target-platform ${target}."
  206. # finally compile the firmware binaries
  207. progress "Compiling binary firmware images."
  208. make -j ${MAKEJOBS} images ${MAKE_PARAM}
  209. [ "$?" -eq "0" ] || abort "Failed to assemble images for target-platform ${target}."
  210. # compile the modules
  211. progress "Compiling modules."
  212. make -j ${MAKEJOBS} modules ${MAKE_PARAM}
  213. [ "$?" -eq "0" ] || abort "Failed to build modules for target-platform ${target}."
  214. done
  215. popd > /dev/null #${CODE_DIR}
  216. # compress all binaries into 7z archive
  217. progress "Assembling images.7z ..."
  218. pushd ${IMAGE_DIR} > /dev/null
  219. [ -e "${OUTPUT_DIR}/${BRANCH}/images.7z" ] && rm "${OUTPUT_DIR}/${BRANCH}/images.7z"
  220. 7z a -mmt=on -xr!*.manifest "${OUTPUT_DIR}/${BRANCH}/images.7z" ./sysupgrade/* ./factory/*
  221. [ "$?" -eq "0" ] || abort "Failed to assemble images (did you install p7zip-full?)."
  222. popd > /dev/null #${IMAGE_DIR}
  223. # compress modules into 7z archive
  224. progress "Assembling modules.7z ..."
  225. pushd ${MODULE_DIR} > /dev/null
  226. [ -e "${OUTPUT_DIR}/${BRANCH}/modules.7z" ] && rm "${OUTPUT_DIR}/${BRANCH}/modules.7z"
  227. 7z a -mmt=on "${OUTPUT_DIR}/${BRANCH}/modules.7z" ./* > /dev/null
  228. [ "$?" -eq "0" ] || abort "Failed to assemble modules."
  229. popd > /dev/null #${MODULE_DIR}
  230. # generate and copy manifests
  231. progress "Generating and copying manifest ..."
  232. pushd ${CODE_DIR} > /dev/null
  233. GLUON_PRIORITY=${PRIORITY} GLUON_BRANCH=${BRANCH} make manifest
  234. [ "$?" -eq "0" ] || abort "Failed to generate the manifest, try running 'make manifest' in '$CODE_DIR' directory manually."
  235. cp "${CODE_DIR}/output/images/sysupgrade/${BRANCH}.manifest" "${OUTPUT_DIR}/${BRANCH}/"
  236. popd > /dev/null #${CODE_DIR}
  237. # Saving a copy of the build info file as reference
  238. progress "Building a greater and brighter firmware finished successfully. Saving build information at: ${VERSIONS_INFO_DIR}/${VERSION}"
  239. cp -p "${build_info_path}" "${VERSIONS_INFO_DIR}/${VERSION}"
  240. # Saving a copy of gluon-opkg-key
  241. [ -e "${KEY_DIR}/gluon-opkg-key" -a -e "${KEY_DIR}/gluon-opkg-key.pub" ] || cp ${GLUON_BUILD_DIR}/gluon-opkg-key* ${KEY_DIR}/
  242. [ "$?" -eq "0" ] || abort "Failed to save gluon-opkg-key, try to execute 'cp ${GLUON_BUILD_DIR}/gluon-opkg-key* ${KEY_DIR}/' manually"
  243. # The end. Finally.
  244. success "We're done, go and enjoy your new firmware (${VERSION}) in ${OUTPUT_DIR}/${BRANCH}!"
  245. popd > /dev/null #${MY_DIR}