You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

416 lines
18 KiB

  1. /** @page releases Release Processes
  2. This page provides an introduction to the OpenOCD Release Processes:
  3. - @ref releasewhy - Explain the motivations for producing
  4. releases on a regular basis.
  5. - @ref releasewho - Describes the responsibilities and
  6. authority required to produce official OpenOCD releases.
  7. - @ref releasewhen - Provides guidelines for scheduling
  8. activities for each release cycle.
  9. - @ref releasehow - Outlines all of the steps for the
  10. processes used to produce and release the package source archives.
  11. - @ref releasescript - Introduces the automated @c release.sh script.
  12. @section releasewhy Why Produce Releases?
  13. The OpenOCD maintainers produce <i>releases</i> periodically for many
  14. reasons. This section provides the key reasons for making releases on a
  15. regular basis and why a set of <i>release processes</i> should be used
  16. to produce them.
  17. At any time, <i>source archives</i> can be produced by running
  18. <code>make dist</code> in the OpenOCD project tree. With the 0.2.0
  19. release, this command will package the tree into several popular archive
  20. formats: <code>openocd-\<version\>.{tar.gz,tar.bz2,zip}</code>. If
  21. produced properly, these files are suitable for release to the public.
  22. When properly versioned and released for users, these archives present
  23. several important advantages compared to using the source repository
  24. (including snapshots downloaded from that repository using gitweb):
  25. -# They allow others to package and distribute the code using
  26. consistent version labels. Users won't normally need to care
  27. whose package they use, just the version of OpenOCD.
  28. -# They contain a working configure script and makefiles, which
  29. were produced as part of creating the archive.
  30. -# Because they have been formally released by the project, users
  31. don't need to try a random work-in-process revision. Releasing
  32. involves spending some time specifically on quality improvments,
  33. including bugfixing source code and documentation.
  34. -# They provide developers with the flexibility needed to address
  35. larger issues, which sometimes involves temporary breakage.
  36. Hopefully, this shows several good reasons to produce regular releases,
  37. but the release processes were developed with some additional design
  38. goals in mind. Specifically, the releases processes should have the
  39. following properties:
  40. -# Produce successive sets of archives cleanly and consistently.
  41. -# Implementable as a script that automates the critical steps.
  42. -# Prevent human operators from producing broken packages, when possible.
  43. -# Allow scheduling and automation of building and publishing milestones.
  44. The current release processes are documented in the following sections.
  45. They attempt to meet these design goals, but improvements may still
  46. need to be made.
  47. @subsection version_labels Version Labels
  48. Users can display the OpenOCD version string in at least two
  49. ways. The command line <code>openocd -v</code> invocation
  50. displays it; as does the Tcl <code>version</code> command.
  51. Labels for released versions look like <em>0.3.0</em>, or
  52. <em>0.3.0-rc1</em> for a preliminary release.
  53. Non-released (developer) versions look like <em>0.3.0-dev</em>,
  54. or <em>0.3.0-rc1-dev</em>.
  55. In all cases, additional tags may be appended to those base
  56. release version labels.
  57. The <code>tools/release/version.sh</code> script is used to
  58. manipulate version IDs found in the source tree.
  59. @subsubsection releaseversions Release Versions and Tags
  60. The OpenOCD version string is composed of three numeric components
  61. separated by two decimal points: @c x.y.z, where @c x is the @a major
  62. version number, @c y is the @a minor number, and @c z is the @a micro.
  63. For any <em>bug-fix</em> release, the micro version number will be non-zero
  64. (<code>z > 0</code>). For a <i>minor release</i>, the micro version
  65. number will be zero (<code>z = 0</code>). For a <i>major releases</i>,
  66. the minor version will @a also be zero (<code>y = 0, z = 0</code>).
  67. After these required numeric components, release version strings
  68. may contain tags such as as <em>-rc1</em> or <em>-rc2</em>.
  69. These 'rc' tags indicate "release candidate" versions of the package.
  70. Like the major/minor/micro numbers, these tags will be manipulated
  71. by the automated release process.
  72. The release process includes version number manipulations to the tree
  73. being released, ensuring that all numbers are incremented (or rolled
  74. over) at the right time and in the proper locations of the repository.
  75. One of those manipulations creates a repository tag matching that
  76. release's version label.
  77. @subsubsection releaseversionsdist Packager Versions
  78. Distributors of patched versions of OpenOCD are encouraged to extend the
  79. version string with a unique version tag when producing external
  80. releases, as this helps to identify your particular distribution series.
  81. Knowing that a release has such patches can be essential to tracking
  82. down and fixing bugs.
  83. Packager version tags should always be suffixes to the version
  84. code from the OpenOCD project, signifying modifications to the
  85. original code base. Each packager release should have a unique
  86. version.
  87. For example, the following command will add a 'foo' tag to the
  88. configure.in script of a local copy of the source tree, giving
  89. a version label like <em>0.3.0-foo</em>:
  90. @code
  91. tools/release/version.sh version tag add foo
  92. @endcode
  93. This command will modify the configure.in script in your working copy
  94. only. After running the @c bootstrap sequence, the tree can be patched
  95. and used to produce your own derived versions. You might check that
  96. change into a private branch of your git tree, along with the other
  97. patches you are providing.
  98. You can also "bump" those tags (so "foo1" becomes "foo2" etc)
  99. each time a derived package is released, incrementing the tag's
  100. version to facilitate tracking the changes you have distributed.
  101. @code
  102. tools/release/version.sh version bump tag foo
  103. @endcode
  104. Of course, any patches in your branches must be provided to
  105. your customers, and be in conformance with the GPL. In most
  106. cases you should also work to merge your improvements to the
  107. mainline tree.
  108. @subsubsection version_tags Development Versions and Tags
  109. Everything except formal releases should have the tag <em>-dev</em>
  110. in their version number. This helps developers identify reports
  111. created from non-release versions, and it can be detected and
  112. manipulated by the release script. Specifically, this tag will be
  113. removed and re-added during the release process; it should never be
  114. manipulated by developers in submitted patches.
  115. Versions built from developer trees may have additional tags.
  116. Trees built from git snapshots have <em>snapshot</em> tags.
  117. When built from a "live" git tree, tags specify
  118. specific git revisions:
  119. 0.3.0-rc1-dev-00015-gf37c9b8-dirty
  120. indicates a development tree based on git revison f37c9b8
  121. (a truncated version of a SHA1 hash) with some non-git
  122. patches applied (the <em>dirty</em> tag). This information
  123. can be useful when tracking down bugs.
  124. (Note that at this writing, the tags do not directly
  125. correspond to <code>git describe</code> output. The
  126. hash ID can be used with <code>git show</code>, but
  127. the preceding segments can't.)
  128. @section releasewho Release Manager
  129. OpenOCD archive releases will be produced by an individual filling the
  130. role of <i>Release Manager</i>, hereafter abbreviated as <i>RM</i>. This
  131. individual determines the schedule and executes the release processes
  132. for the community.
  133. @subsection releasewhohow RM Authority
  134. Each release requires one individual to fulfill the RM role; however,
  135. graceful transitions of this authority may take place at any time. The
  136. current RM may transfer their authority to another contributor in a post
  137. to the OpenOCD development mailing list. Such delegation of authority
  138. must be approved by the individual that will receive it and the
  139. community of maintainers. Initial arrangements with the new RM should
  140. be made off-list, as not every contributor wants these responsibilities.
  141. @subsection releasewhowhat RM Responsibilities
  142. In addition to the actual process of producing the releases, the RM is
  143. responsible for keeping the community informed of all progress through
  144. the release cycle(s) being managed. The RM is responsible for managing
  145. the changes to the package version, though the release tools should
  146. manage the tasks of adding or removing any required development branch
  147. tags and incrementing the version.
  148. These responsibilities matter most towards the end of the release
  149. cycle, when the RM creates the first RC and all contributors enter
  150. a quality-improvement mode. The RM works with other contributors
  151. to make sure everyone knows what kinds of fixes should merge, the
  152. status of major issues, and the release timetable.
  153. In particular, the RM has the final decision on whether a given
  154. bug should block the release.
  155. @section releasewhen Release Schedule
  156. The OpenOCD release process must be carried out on a periodic basis, so
  157. the project can realize the benefits presented in answer to the question,
  158. @ref releasewhy.
  159. Starting with the 0.2.0 release, the OpenOCD project expects to produce
  160. new releases every few months.
  161. Bug fix releases could be provided more frequently. These release
  162. schedule goals may be adjusted in the future, after the project
  163. maintainers and distributors receive feedback and experience.
  164. More importantly, the statements made in this section do not create an
  165. obligation by any member of the OpenOCD community to produce new
  166. releases on regular schedule, now or in the future.
  167. @subsection releasewhenexample Sample Schedule
  168. The RM must pro-actively communicate with the community from the
  169. beginning of the development cycle through the delivery of the new
  170. release. This section presents guidelines for scheduling key points
  171. where the community must be informed of changing conditions.
  172. If Tn is the time of release n, then the following schedule
  173. might describe some key T0-to-T1 release cycle milestones.
  174. - T0 ... End of T0 release cycle. T1 cycle starts, with merge
  175. window opening. Developers begin to merge queued work.
  176. - <em>... several weeks of merge window ...</em>
  177. - RC1 ... Close mainline to new work. Produce RC1
  178. release, begin testing phase; developers are in "bugfix mode",
  179. all other work is queued; send out planned endgame schedule.
  180. - RC2 ... Produce RC2 and send schedule update to
  181. mailing list, listing priorities for remaining fixes
  182. - <em>... more RC milestones, until ready ...</em>
  183. - T1: End of T1 release cycle. T2 cycle starts, with merge
  184. window opening. Developers begin to merge queued work.
  185. Note that until it happens, any date for T1 is just a goal.
  186. Critical bugs prevent releases from happening. We are just
  187. beginning to use this window-plus-RCs process, so the lengths
  188. of the merge windows versus the RC phase is subject to change.
  189. Most projects have RC phases of a month or more.
  190. Some additional supplemental communication will be desirable. The above
  191. list omits the step-by-step instructions to daily release management.
  192. Individuals performing release management need to have the ability to
  193. interact proactively with the community as a whole, anticipating when
  194. such interaction will be required and giving ample notification.
  195. The next section explains why the OpenOCD project allows significant
  196. flexibility in the part of the development that precedes the release
  197. process.
  198. @subsection releasewhenflex Schedule Flexibility
  199. The Release Manager should attempt to follow the guidelines in this
  200. document, but the process of scheduling each release milestone should be
  201. community driven at the start. Features that don't complete before
  202. the merge window closes can be held (perhaps in some branch) until
  203. the next merge window opens, rather than delaying the release cycle.
  204. The Release
  205. Manager cannot schedule the work that will be done on the project,
  206. when it will be submitted, reviewed, and deemed suitable to be committed.
  207. That is, the RM cannot act as a priest in a cathedral; OpenOCD uses
  208. the bazaar development model. The release schedule must adapt
  209. continuously in response to changes in the rate of work.
  210. Fewer releases may be
  211. required if developers contribute less patches, and more releases may be
  212. desirable if the project continues to grow and experience high rates of
  213. community contribution. During each cycle, the RM should be tracking
  214. the situation and gathering feedback from the community.
  215. @section releasehow Release Process: Step-by-Step
  216. The release process is not final; it may need more iterations
  217. to work out bugs.
  218. While there are release scripts, key steps require community
  219. support; the Release Manager isn't the only participant.
  220. The following steps should be followed to produce each release:
  221. -# Produce final patches to mainline (or a release branch). Nobody
  222. except the RM should be committing anything.
  223. -# Finalize @c NEWS file to describe the changes in the release
  224. - This file is used to automatically post "blurbs" about the project.
  225. - This material should be produced during the development cycle.
  226. - Add a new item for each @c NEWS-worthy contribution, when committed.
  227. -# Bump library version if our API changed (not yet required)
  228. -# Update and commit the final package version in @c configure.in:
  229. <code>tools/release/version.sh</code> may help ensure the versions
  230. are named consistently:
  231. -# Remove @c -dev tag.
  232. -# Update the @c -rc tag:
  233. - If producing the final release from an -rc series, remove it
  234. - If producing the first RC in a series, add rc1
  235. - If producing the next RC in a series, bump the rc number
  236. -# Commit that version change.
  237. -# Create a git tag for the final commit, with a tag name matching
  238. the version string in <code>configure.in</code>:
  239. @verbatim
  240. PACKAGE_VERSION="x.y.z"
  241. PACKAGE_TAG="v${PACKAGE_VERSION}"
  242. git tag -m "The openocd-${PACKAGE_VERSION} release." "${PACKAGE_TAG}"
  243. @endverbatim
  244. -# Prepare to resume normal development on mainline:
  245. - Restore @c -dev version tag.
  246. - To start a new major (or minor) release cycle on the @c master branch:
  247. - Archive @c NEWS file as "<code>doc/news/NEWS-${PACKAGE_VERSION}</code>".
  248. - Create a new @c NEWS file for the next release
  249. - Commit those changes, and push the commit and the release tag
  250. to mainline.
  251. -# Produce the package source archives:
  252. -# <em>Start with a new clone of the source tree</em>, with the
  253. release's tag. This is used only for producing these packages.
  254. -# Checkout the appropriate tag:
  255. <code>git checkout "${PACKAGE_VERSION}"</code>
  256. -# Produce a ChangeLog for the release (using @c git2cl).
  257. -# @c bootstrap, @c configure, and @c make the package.
  258. -# Run <code>make distcheck</code> to produce the distribution archives.
  259. -# Run <code>make maintainer-clean</code> verify the repository is empty.
  260. -# Create signature files using @c md5sum, @c sha1sum, etc.
  261. -# Publish documentation for the release:
  262. - Allow users to access the documentation for each of our releases.
  263. - Place static copies of the following files on the project website:
  264. - @c NEWS: to provide a blurb for each release
  265. - @c ChangeLog: to show exactly what has been changed
  266. - User's Guide, Developer Manual: to allow easy on-line viewing
  267. -# Upload packages and post announcements of their availability:
  268. -# Release packages into files section of project sites:
  269. - SF.net:
  270. -# Create a new folder named "${PACKAGE_VERSION}"
  271. -# Select new folder as the target for uploads.
  272. -# Upload files via Web interface into new
  273. -# Set platform types for each archive:
  274. - .tar.bz2: Linux, Mac
  275. - .tar.gz: BSD, Solaris, Others
  276. - .zip: Windows
  277. - Berlios:
  278. -# Create the new release for the new version.
  279. -# Provide @c NEWS and ChangeLog files, as requested.
  280. -# Upload files via FTP to ftp://ftp.berlios.de/incoming/
  281. -# Edit descriptions for each file.
  282. -# Click button to send E-mail Release Notice.
  283. -# Post announcement e-mail to the openocd-development list.
  284. -# Announce updates on freshmeat.net and other trackers.
  285. -# Submit big updates to news feeds (e.g. Digg, Reddit, etc.).
  286. To start a bug-fix release branch:
  287. -# Create a new branch, starting from a major or
  288. minor release tag
  289. -# Restore @c -dev version tag.
  290. -# Bump micro version number in configure.in
  291. -# Backport bugfix patches from mainline into that branch.
  292. (Always be sure mainline has the fix first, so it's hard
  293. to just lose a bugfix.)
  294. -# Commit and push those patches.
  295. -# When desired, release as above ... except note that the next
  296. release of a bugfix branch is never a new major or minor release
  297. @subsection releasescriptcmds Release Script Commands
  298. The @c release.sh script automates some of the steps involved
  299. in making releases, simplifying the Release Manager's work.
  300. The release script can be used for two tasks:
  301. - Creating releases and starting a new release cycle:
  302. @code
  303. git checkout master
  304. tools/release.sh --type=minor --final --start-rc release
  305. @endcode
  306. - Creating a development branch from a tagged release:
  307. @code
  308. git checkout 'v0.2.0'
  309. tools/release.sh --type=micro branch
  310. @endcode
  311. Both of these variations make automatic commits and tags in your
  312. repository, so you should be sure to run it on a cloned copy before
  313. proceding with a live release.
  314. @subsection releasescriptopts Release Script Options
  315. The @c release.sh script recognizes some command-line options that
  316. affect its behavior:
  317. - The @c --start-rc indicates that the new development release cycle
  318. should start with @c -rc0. Without this, the @c -rc tag will be omitted,
  319. leading to non-monotonic versioning of the in-tree version numbers.
  320. - The @c --final indicates that the release should drop the @c -rc tag,
  321. to going from @c x.y.z-rcN-dev to x.y.z.
  322. @subsection releasescriptenv Release Script Environment
  323. The @c release.sh script recognizes some environment variables which
  324. affect its behavior:
  325. - @c CONFIG_OPTS : Passed as options to the configure script.
  326. - @c MAKE_OPTS : Passed as options to the 'make' processes.
  327. @section releasetutorial Release Tutorials
  328. This section should contain a brief tutorial for using the Release
  329. Script to perform release tasks, but the new script needs to be
  330. used for 0.3.0.
  331. @section releasetodo Release Script Shortcomings
  332. Improved automated packaging and distribution of OpenOCD requires more
  333. patching of the configure script. The final release script should be
  334. able to manage most steps of the processes. The steps requiring user
  335. input could be guided by an "assistant" that walks the Release Manager
  336. through the process from beginning to end, performing basic sanity
  337. checks on their various inputs (e.g. the @c NEWS blurb).
  338. */
  339. /** @file
  340. This file contains the @ref releases page.
  341. */