/[gentoo]/xml/htdocs/proj/en/glep/glep-0033.html
Gentoo

Contents of /xml/htdocs/proj/en/glep/glep-0033.html

Parent Directory Parent Directory | Revision Log Revision Log


Revision 1.9 - (show annotations) (download) (as text)
Fri Feb 20 09:19:56 2009 UTC (5 years, 7 months ago) by antarus
Branch: MAIN
Changes since 1.8: +2 -2 lines
File MIME type: text/html
Spelling updates, 21 is Final, but keeping Genons status message to inform people that implementation does not match GLEP.

1 <?xml version="1.0" encoding="utf-8" ?>
2 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
3 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
4
5 <head>
6 <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
7 <meta name="generator" content="Docutils 0.4: http://docutils.sourceforge.net/" />
8 <title>GLEP 33 -- Eclass Restructure/Redesign</title>
9 <link rel="stylesheet" href="tools/glep.css" type="text/css" />
10 </head>
11 <body bgcolor="white">
12 <table class="navigation" cellpadding="0" cellspacing="0"
13 width="100%" border="0">
14 <tr><td class="navicon" width="150" height="35">
15 <a href="http://www.gentoo.org/" title="Gentoo Linux Home Page">
16 <img src="http://www.gentoo.org/images/gentoo-new.gif" alt="[Gentoo]"
17 border="0" width="150" height="35" /></a></td>
18 <td class="textlinks" align="left">
19 [<b><a href="http://www.gentoo.org/">Gentoo Linux Home</a></b>]
20 [<b><a href="http://www.gentoo.org/proj/en/glep">GLEP Index</a></b>]
21 [<b><a href="http://www.gentoo.org/proj/en/glep/glep-0033.txt">GLEP Source</a></b>]
22 </td></tr></table>
23 <table class="rfc2822 docutils field-list" frame="void" rules="none">
24 <col class="field-name" />
25 <col class="field-body" />
26 <tbody valign="top">
27 <tr class="field"><th class="field-name">GLEP:</th><td class="field-body">33</td>
28 </tr>
29 <tr class="field"><th class="field-name">Title:</th><td class="field-body">Eclass Restructure/Redesign</td>
30 </tr>
31 <tr class="field"><th class="field-name">Version:</th><td class="field-body">1.6</td>
32 </tr>
33 <tr class="field"><th class="field-name">Last-Modified:</th><td class="field-body"><a class="reference" href="http://www.gentoo.org/cgi-bin/viewcvs.cgi/xml/htdocs/proj/en/glep/glep-0033.txt?cvsroot=gentoo">2006/09/05 20:54:30</a></td>
34 </tr>
35 <tr class="field"><th class="field-name">Author:</th><td class="field-body">Brian Harring &lt;ferringb&#32;&#97;t&#32;gentoo.org&gt;, John Mylchreest &lt;johnm&#32;&#97;t&#32;gentoo.org&gt;</td>
36 </tr>
37 <tr class="field"><th class="field-name">Status:</th><td class="field-body">Moribound</td>
38 </tr>
39 <tr class="field"><th class="field-name">Type:</th><td class="field-body">Standards Track</td>
40 </tr>
41 <tr class="field"><th class="field-name">Content-Type:</th><td class="field-body"><a class="reference" href="glep-0002.html">text/x-rst</a></td>
42 </tr>
43 <tr class="field"><th class="field-name">Created:</th><td class="field-body">29-Jan-2005</td>
44 </tr>
45 <tr class="field"><th class="field-name">Post-History:</th><td class="field-body">29-Jan-2005 6-Mar-2005 15-Sep-2005 5-Sep-2006</td>
46 </tr>
47 </tbody>
48 </table>
49 <hr />
50 <div class="contents topic">
51 <p class="topic-title first"><a id="contents" name="contents">Contents</a></p>
52 <ul class="simple">
53 <li><a class="reference" href="#status" id="id2" name="id2">Status</a></li>
54 <li><a class="reference" href="#abstract" id="id3" name="id3">Abstract</a></li>
55 <li><a class="reference" href="#terminology" id="id4" name="id4">Terminology</a></li>
56 <li><a class="reference" href="#motivation-and-rationale" id="id5" name="id5">Motivation and Rationale</a></li>
57 <li><a class="reference" href="#specification" id="id6" name="id6">Specification</a><ul>
58 <li><a class="reference" href="#ebuild-libraries-elibs-for-short" id="id7" name="id7">Ebuild Libraries (elibs for short)</a></li>
59 <li><a class="reference" href="#the-reduced-role-of-eclasses-and-a-clarification-of-existing-eclass-requirements" id="id8" name="id8">The reduced role of Eclasses, and a clarification of existing Eclass requirements</a></li>
60 <li><a class="reference" href="#the-end-of-backwards-compatibility" id="id9" name="id9">The end of backwards compatibility...</a></li>
61 <li><a class="reference" href="#tree-restructuring" id="id10" name="id10">Tree restructuring</a></li>
62 <li><a class="reference" href="#the-start-of-a-different-phase-of-backwards-compatibility" id="id11" name="id11">The start of a different phase of backwards compatibility</a></li>
63 <li><a class="reference" href="#migrating-to-the-new-setup" id="id12" name="id12">Migrating to the new setup</a></li>
64 </ul>
65 </li>
66 <li><a class="reference" href="#backwards-compatibility" id="id13" name="id13">Backwards Compatibility</a></li>
67 <li><a class="reference" href="#copyright" id="id14" name="id14">Copyright</a></li>
68 </ul>
69 </div>
70 <div class="section">
71 <h1><a class="toc-backref" href="#id2" id="status" name="status">Status</a></h1>
72 <p>Approved by the Gentoo Council on 15 September 2005. As of Sept. 2006
73 this GLEP is on hold, pending future revisions.</p>
74 </div>
75 <div class="section">
76 <h1><a class="toc-backref" href="#id3" id="abstract" name="abstract">Abstract</a></h1>
77 <p>For any design, the transition from theoretical to applied exposes inadequacies
78 in the original design. This document is intended to document, and propose a
79 revision of the current eclass setup to address current eclass inadequacies.</p>
80 <p>This document proposes several things- the creation of ebuild libraries, 'elibs',
81 a narrowing of the focus of eclasses, a move of eclasses w/in the tree, the
82 addition of changelogs, and a way to allow for simple eclass gpg signing.
83 In general, a large scale restructuring of what eclasses are and how they're
84 implemented. Essentially version two of the eclass setup.</p>
85 </div>
86 <div class="section">
87 <h1><a class="toc-backref" href="#id4" id="terminology" name="terminology">Terminology</a></h1>
88 <p>From this point on, the proposed eclass setup will be called 'new eclasses', the
89 existing crop (as of this writing) will be referenced as 'old eclasses'. The
90 distinction is elaborated on within this document.</p>
91 </div>
92 <div class="section">
93 <h1><a class="toc-backref" href="#id5" id="motivation-and-rationale" name="motivation-and-rationale">Motivation and Rationale</a></h1>
94 <p>Eclasses within the tree currently are a bit of a mess- they're forced to
95 maintain backwards compatibility w/ all previous functionality. In effect,
96 their api is constant, and can only be added to- never changing the existing
97 functionality. This obviously is quite limiting, and leads to cruft accruing in
98 eclasses as a eclasses design is refined. This needs to be dealt with prior to
99 eclass code reaching a critical mass where they become unmanageable/fragile
100 (recent pushes for eclass versioning could be interpreted as proof of this).</p>
101 <p>Beyond that, eclasses were originally intended as a method to allow for ebuilds
102 to use a pre-existing block of code, rather then having to duplicate the code in
103 each ebuild. This is a good thing, but there are ill effects that result from
104 the current design. Eclasses inherit other eclasses to get a single function- in
105 doing so, modifying the the exported 'template' (default src_compile, default
106 src_unpack, various vars, etc). All the eclass designer was after was reusing a
107 function, not making their eclass sensitive to changes in the template of the
108 eclass it's inheriting. The eclass designer -should- be aware of changes in the
109 function they're using, but shouldn't have to worry about their default src_*
110 and pkg_* functions being overwritten, let alone the env changes.</p>
111 <p>Addressing up front why a collection of eclass refinements are being rolled into
112 a single set of changes, parts of this proposal -could- be split into multiple
113 phases. Why do it though? It's simpler for developers to know that the first
114 eclass specification was this, and that the second specification is that,
115 rather then requiring them to be aware of what phase of eclass changes is in
116 progress.</p>
117 <p>By rolling all changes into one large change, a line is intentionally drawn in
118 the sand. Old eclasses allowed for this, behaved this way. New eclasses allow
119 for that, and behave this way. This should reduce misconceptions about what is
120 allowed/possible with eclasses, thus reducing bugs that result from said
121 misconceptions.</p>
122 <p>A few words on elibs- think of them as a clear definition between behavioral
123 functionality of an eclass, and the library functionality. Eclass's modify
124 template data, and are the basis for other ebuilds- elibs, however are <em>just</em>
125 common bash functionality.</p>
126 <p>Consider the majority of the portage bin/* scripts- these all are candidates for
127 being added to the tree as elibs, as is the bulk of eutils.</p>
128 </div>
129 <div class="section">
130 <h1><a class="toc-backref" href="#id6" id="specification" name="specification">Specification</a></h1>
131 <p>The various parts of this proposal are broken down into a set of changes and
132 elaborations on why a proposed change is preferable. It's advisable to the
133 reader that this be read serially, rather then jumping around.</p>
134 <div class="section">
135 <h2><a class="toc-backref" href="#id7" id="ebuild-libraries-elibs-for-short" name="ebuild-libraries-elibs-for-short">Ebuild Libraries (elibs for short)</a></h2>
136 <p>As briefly touched upon in Motivation and Rationale, the original eclass design
137 allowed for the eclass to modify the metadata of an ebuild, metadata being the
138 DEPENDS, RDEPENDS, SRC_URI, IUSE, etc, vars that are required to be constant,
139 and used by portage for dep resolution, fetching, etc. Using the earlier
140 example, if you're after a single function from an eclass (say epatch from
141 eutils), you -don't- want the metadata modifications the eclass you're
142 inheriting might do. You want to treat the eclass you're pulling from as a
143 library, pure and simple.</p>
144 <p>A new directory named elib should be added to the top level of the tree to serve
145 as a repository of ebuild function libraries. Rather then relying on using the
146 source command, an 'elib' function should be added to portage to import that
147 libraries functionality. The reason for the indirection via the function is
148 mostly related to portage internals, but it does serve as an abstraction such
149 that (for example) zsh compatibility hacks could be hidden in the elib function.</p>
150 <p>Elib's will be collections of bash functions- they're not allowed to do anything
151 in the global scope aside from function definition, and any -minimal-
152 initialization of the library that is absolutely needed. Additionally, they
153 cannot modify any ebuild template functions- src_compile, src_unpack. Since they are
154 required to not modify the metadata keys, nor in any way affect the ebuild aside
155 from providing functionality, they can be conditionally pulled in. They also
156 are allowed to pull in other elibs, but strictly just elibs- no eclasses, just
157 other elibs. A real world example would be the eutils eclass.</p>
158 <p>Portage, since the elib's don't modify metadata, isn't required to track elibs
159 as it tracks eclasses. Thus a change in an elib doesn't result in half the tree
160 forced to be regenerated/marked stale when changed (this is more of an infra
161 benefit, although regen's that take too long due to eclass changes have been
162 known to cause rsync issues due to missing timestamps).</p>
163 <p>Elibs will not be available in the global scope of an eclass, or ebuild- nor during the
164 depends phase (basically a phase that sources the ebuild, to get its metadata). Elib
165 calls in the global scope will be tracked, but the elib will not be loaded till just before
166 the setup phase (pkg_setup). There are two reasons for this- first, it ensures elibs are
167 completely incapable of modifying metadata. There is no room for confusion, late loading
168 of elibs gives you the functionality for all phases, except for depends- depends being the
169 only phase that is capable of specifying metadata. Second, as an added bonus, late
170 loading reduces the amount of bash sourced for a regen- faster regens. This however is minor,
171 and is an ancillary benefit of the first reason.</p>
172 <p>There are a few further restrictions with elibs--mainly, elibs to load can only be specified
173 in either global scope, or in the setup, unpack, compile, test, and install phases. You can
174 not load elibs in prerm, postrm, preinst, and postinst. The reason being, for *rm phases,
175 installed pkgs will have to look to the tree for the elib, which allows for api drift to cause
176 breakage. For *inst phases, same thing, except the culprit is binpkgs.</p>
177 <p>There is a final restriction--elibs cannot change their exported api dependent on the api
178 (as some eclass do for example). The reason mainly being that elibs are loaded once--not
179 multiple times, as eclasses are.</p>
180 <p>To clarify, for example this is invalid.</p>
181 <pre class="literal-block">
182 if [[ -n ${SOME_VAR} ]]; then
183 func x() { echo &quot;I'm accessible only via tweaking some var&quot;;}
184 else
185 func x() { echo &quot;this is invalid, do not do it.&quot;; }
186 fi
187 </pre>
188 <p>Regarding maintainability of elibs, it should be a less of a load then old
189 eclasses. One of the major issues with old eclasses is that their functions are
190 quite incestuous- they're bound tightly to the env they're defined in. This
191 makes eclass functions a bit fragile- the restrictions on what can, and cannot
192 be done in elibs will address this, making functionality less fragile (thus a
193 bit more maintainable).</p>
194 <p>There is no need for backwards compatibility with elibs- they just must work
195 against the current tree. Thus elibs can be removed when the tree no longer
196 needs them. The reasons for this are explained below.</p>
197 <p>Structuring of the elibs directory will be exactly the same as that of the new
198 eclass directory (detailed below), sans a different extension.</p>
199 <p>As to why their are so many restrictions, the answer is simple- the definition of
200 what elibs are, what they are capable of, and how to use them is nailed down as much as
201 possible to avoid <em>any</em> ambiguity related to them. The intention is to make it clear,
202 such that no misconceptions occur, resulting in bugs.</p>
203 </div>
204 <div class="section">
205 <h2><a class="toc-backref" href="#id8" id="the-reduced-role-of-eclasses-and-a-clarification-of-existing-eclass-requirements" name="the-reduced-role-of-eclasses-and-a-clarification-of-existing-eclass-requirements">The reduced role of Eclasses, and a clarification of existing Eclass requirements</a></h2>
206 <p>Since elibs are now intended on holding common bash functionality, the focus of
207 eclasses should be in defining an appropriate template for ebuilds. For example,
208 defining common DEPENDS, RDEPENDS, src_compile functions, src_unpack, etc.
209 Additionally, eclasses should pull in any elibs they need for functionality.</p>
210 <p>Eclass functionality that isn't directly related to the metadata, or src_* and
211 pkg_* funcs should be shifted into elibs to allow for maximal code reuse. This
212 however isn't a hard requirement, merely a strongly worded suggestion.</p>
213 <p>Previously, it was 'strongly' suggested by developers to avoid having any code
214 executed in the global scope that wasn't required. This suggestion is now a
215 requirement. Execute only what must be executed in the global scope. Any code
216 executed in the global scope that is related to configuring/building the package
217 must be placed in pkg_setup. Metadata keys (already a rule, but now stated as
218 an absolute requirement to clarify it) <em>must</em> be constant. The results of
219 metadata keys exported from an ebuild on system A, must be <em>exactly</em> the same as
220 the keys exported on system B.</p>
221 <p>If an eclass (or ebuild for that matter) violates this constant requirement, it
222 leads to portage doing the wrong thing for rsync users- for example, wrong deps
223 pulled in, leading to compilation failure, or dud deps.</p>
224 <p>If the existing metadata isn't flexible enough for what is required for a
225 package, the parsing of the metadata is changed to address that. Cases where
226 the constant requirement is violated are known, and a select few are allowed-
227 these are exceptions to the rule that are required due to inadequacies in
228 portage. Any case where it's determined the constant requirement may need to be
229 violated the dev must make it aware to the majority of devs, along with the portage
230 devs. This should be done prior to committing.</p>
231 <p>It's quite likely there is a way to allow what you're attempting- if you just go
232 and do it, the rsync users (our user base) suffer the results of compilation
233 failures and unneeded deps being pulled in.</p>
234 <p>After that stern reminder, back to new eclasses. Defining INHERITED and ECLASS
235 within the eclass is no longer required. Portage already handles those vars if
236 they aren't defined.</p>
237 <p>As with elibs, it's no longer required that backwards compatibility be maintained
238 indefinitely- compatibility must be maintained against the current tree, but
239 just that. As such new eclasses (the true distinction of new vs old is
240 elaborated in the next section) can be removed from the tree once they're no
241 longer in use.</p>
242 </div>
243 <div class="section">
244 <h2><a class="toc-backref" href="#id9" id="the-end-of-backwards-compatibility" name="the-end-of-backwards-compatibility">The end of backwards compatibility...</a></h2>
245 <p>With current eclasses, once the eclass is in use, its api can no longer be
246 changed, nor can the eclass ever be removed from the tree. This is why we still
247 have <em>ancient</em> eclasses that are completely unused sitting in the tree, for
248 example inherit.eclass. The reason for this, not surprisingly, is a portage
249 deficiency: on unmerging an installed ebuild, portage used the eclass from the
250 current tree.</p>
251 <p>For a real world example of this, if you merged a glibc 2 years back, whatever
252 eclasses it used must still be compatible, or you may not be able to unmerge the
253 older glibc version during an upgrade to a newer version. So either the glibc
254 maintainer is left with the option of leaving people using ancient versions out
255 in the rain, or maintaining an ever increasing load of backwards compatibility
256 cruft in any used eclasses.</p>
257 <p>Binpkgs suffer a similar fate. Merging of a binpkg pulls needed eclasses from
258 the tree, so you may not be able to even merge a binpkg if the eclasses api has
259 changed. If the eclass was removed, you can't even merge the binpkg, period.</p>
260 <p>The next major release of portage will address this- the environment that the
261 ebuild was built in already contains the eclasses functions, as such the env can
262 be re-used rather then relying on the eclass. In other words, binpkgs and
263 installed ebuilds will no longer go and pull needed eclasses from the tree,
264 they'll use the 'saved' version of the eclass they were built/merged with.</p>
265 <p>So the backwards compatibility requirement for users of the next major portage
266 version (and beyond) isn't required. All the cruft can be dropped.</p>
267 <p>The problem is that there will be users using older versions of portage that don't
268 support this functionality- these older installations <em>cannot</em> use the
269 new eclasses, due to the fact that their portage version is incapable of
270 properly relying on the env- in other words, the varying api of the eclass will
271 result in user-visible failures during unmerging.</p>
272 <p>So we're able to do a clean break of all old eclasses, and api cruft, but we need
273 a means to basically disallow access to the new eclasses for all portage versions
274 incapable of properly handling the env requirements.</p>
275 <p>Unfortunately, we cannot just rely on a different grouping/naming convention within
276 the old eclass directory. The new eclasses must be inaccessible, and portage throws
277 a snag into this- the existing inherit function that is used to handle existing
278 eclasses. Basically, whatever it's passed (inherit kernel or inherit
279 kernel/kernel) it will pull in (kernel.eclass, and kernel/kernel.eclass
280 respectively). So even if the new eclasses were implemented within a
281 subdirectory of the eclass dir in the tree, all current portage versions would
282 still be able to access them.</p>
283 <p>In other words, these new eclasses would in effect, be old eclasses since older
284 portage versions could still access them.</p>
285 </div>
286 <div class="section">
287 <h2><a class="toc-backref" href="#id10" id="tree-restructuring" name="tree-restructuring">Tree restructuring</a></h2>
288 <p>There are only two way to block the existing (as of this writing) inherit
289 functionality from accessing the new eclasses- either change the extension of
290 eclasses to something other then 'eclass', or to have them stored in a separate
291 subdirectory of the tree then eclass.</p>
292 <p>The latter is preferable, and the proposed solution. Reasons are- the current
293 eclass directory is already overgrown. Structuring of the new eclass dir
294 (clarified below) will allow for easier signing, ChangeLogs, and grouping of
295 eclasses. New eclasses allow for something akin to a clean break and have new
296 capabilities/requirements, thus it's advisable to start with a clean directory,
297 devoid of all cruft from the old eclass implementation.</p>
298 <p>If it's unclear as to why the old inherit function <em>cannot</em> access the new
299 eclasses, please reread the previous section. It's unfortunately a requirement
300 to take advantage of all that the next major portage release will allow.</p>
301 <p>The proposed directory structure is ${PORTDIR}/include/{eclass,elib}.
302 Something like ${PORTDIR}/new-eclass, or ${PORTDIR}/eclass-ng could be used
303 (although many would cringe at the -ng), but such a name is unwise. Consider the
304 possibility (likely a fact) that new eclasses someday may be found lacking, and
305 refined further (version three as it were). Or perhaps we want to add yet more
306 functionality with direct relation to sourcing new files, and we would then need
307 to further populate ${PORTDIR}.</p>
308 <p>The new-eclass directory will be (at least) 2 levels deep- for example:</p>
309 <dl class="docutils">
310 <dt>::</dt>
311 <dd>kernel/
312 kernel/linux-info.eclass
313 kernel/linux-mod.eclass
314 kernel/kernel-2.6.eclass
315 kernel/kernel-2.4.eclass
316 kernel/ChangeLog
317 kernel/Manifest</dd>
318 </dl>
319 <p>No eclasses will be allowed in the base directory- grouping of new eclasses will
320 be required to help keep things tidy, and for the following reasons. Grouping
321 of eclasses allows for the addition of ChangeLogs that are specific to that
322 group of eclasses, grouping of files/patches as needed, and allows for
323 saner/easier signing of eclasses- you can just stick a signed
324 Manifest file w/in that grouping, thus providing the information portage needs
325 to ensure no files are missing, and that nothing has been tainted.</p>
326 <p>The elib directory will be structured in the same way, for the same reasons.</p>
327 <p>Repoman will have to be extended to work within new eclass and elib groups, and
328 to handle signing and committing. This is intentional, and a good thing. This
329 gives repoman the possibility of doing sanity checks on elibs/new eclasses.</p>
330 <p>Note these checks will not prevent developers from doing dumb things with eclass-
331 these checks would only be capable of doing basic sanity checks, such as syntax checks.
332 There is no way to prevent people from doing dumb things (exempting perhaps repeated
333 applications of a cattle prod)- these are strictly automatic checks, akin to repoman's
334 dependency checks.</p>
335 </div>
336 <div class="section">
337 <h2><a class="toc-backref" href="#id11" id="the-start-of-a-different-phase-of-backwards-compatibility" name="the-start-of-a-different-phase-of-backwards-compatibility">The start of a different phase of backwards compatibility</a></h2>
338 <p>As clarified above, new eclasses will exist in a separate directory that will be
339 intentionally inaccessible to the inherit function. As such, users of older
340 portage versions <em>will</em> have to upgrade to merge any ebuild that uses elibs/new
341 eclasses. A depend on the next major portage version would transparently handle
342 this for rsync users.</p>
343 <p>There still is the issue of users who haven't upgraded to the required portage
344 version. This is a minor concern frankly- portage releases include new
345 functionality, and bug fixes. If they won't upgrade, it's assumed they have
346 their reasons and are big boys, thus able to handle the complications themselves.</p>
347 <p>The real issue is broken envs, whether in binpkgs, or for installed packages.
348 Two options exist- either the old eclasses are left in the tree indefinitely, or
349 they're left for N months, then shifted out of the tree, and into a tarball that
350 can be merged.</p>
351 <p>Shifting them out of the tree is advisable for several reasons- less cruft in
352 the tree, but more importantly the fact that they are not signed (thus an angle
353 for attack). Note that the proposed method of eclass signing doesn't even try
354 to address them. Frankly, it's not worth the effort supporting two variations
355 of eclass signing, when the old eclass setup isn't designed to allow for easy
356 signing.</p>
357 <p>If this approach is taken, then either the old eclasses would have to be merged
358 to an overlay directory's eclass directory (ugly), or to a safe location that
359 portage's inherit function knows to look for (less ugly).</p>
360 <p>For users who do not upgrade within the window of N months while the old
361 eclasses are in the tree, as stated, it's assumed they know what they are doing.
362 If they specifically block the new portage version, as the ebuilds in the tree
363 migrate to the new eclasses, they will have less and less ebuilds available to
364 them. If they tried injecting the new portage version (lying to portage,
365 essentially), portage would bail since it cannot find the new eclass.
366 For ebuilds that use the new eclasses, there really isn't any way to sidestep
367 the portage version requirement- same as it has been for other portage features.</p>
368 <p>What is a bit more annoying is that once the old eclasses are out of the tree,
369 if a user has not upgraded to a portage version supporting env processing, they
370 will lose the ability to unmerge any installed ebuild that used an old
371 eclass. Same cause, different symptom being they will lose the ability to merge
372 any tbz2 that uses old eclasses also.</p>
373 <p>There is one additional case that is a rarity, but should be noted- if a user
374 has suffered significant corruption of their installed package database (vdb). This is
375 ignoring the question of whether the vdb is even usable at this point, but the possibility
376 exists for the saved envs to be non usable due to either A) missing, or B) corrupted.
377 In such a case, even with the new portage capabilities, they would need
378 the old eclass compat ebuild.</p>
379 <p>Note for this to happen requires either rather... unwise uses of root, or significant
380 fs corruption. Regardless of the cause, it's quite likely for this to even become an
381 issue, the system's vdb is completely unusable. It's a moot issue at that point.
382 If you lose your vdb, or it gets seriously damaged, it's akin to lobotomizing portage-
383 it doesn't know what's installed, it doesn't know of its own files, and in general,
384 a rebuilding of the system is about the only sane course of action. The missing env is
385 truly the least of the users concern in such a case.</p>
386 <p>Continuing with the more likely scenario, users unwilling to upgrade portage will
387 <em>not</em> be left out in the rain. Merging the old eclass compat ebuild will provide
388 the missing eclasses, thus providing that lost functionality.</p>
389 <p>Note the intention isn't to force them to upgrade, hence the ability to restore the
390 lost functionality. The intention is to clean up the existing mess, and allow us
391 to move forward. The saying &quot;you've got to break a few eggs to make an omelet&quot;
392 is akin, exempting the fact we're providing a way to make the eggs whole again
393 (the king's men would've loved such an option).</p>
394 </div>
395 <div class="section">
396 <h2><a class="toc-backref" href="#id12" id="migrating-to-the-new-setup" name="migrating-to-the-new-setup">Migrating to the new setup</a></h2>
397 <p>As has been done in the past whenever a change in the tree results in ebuilds
398 requiring a specific version of portage, as ebuilds migrate to the new eclasses,
399 they should depend on a version of portage that supports it. From the users
400 viewpoint, this transparently handles the migration.</p>
401 <p>This isn't so transparent for devs or a particular infrastructure server however.
402 Devs, due to them using cvs for their tree, lack the pregenerated cache rsync
403 users have. Devs will have to be early adopters of the new portage. Older
404 portage versions won't be able to access the new eclasses, thus the local cache
405 generation for that ebuild will fail, ergo the depends on a newer portage
406 version won't transparently handle it for them.</p>
407 <p>Additionally, prior to any ebuilds in the tree using the new eclasses, the
408 infrastructure server that generates the cache for rsync users will have to
409 either be upgraded to a version of portage supporting new eclasses, or patched.
410 The former being much more preferable then the latter for the portage devs.</p>
411 <p>Beyond that, an appropriate window for old eclasses to exist in the tree must be
412 determined, and prior to that window passing, an ebuild must be added to the tree
413 so users can get the old eclasses if needed.</p>
414 <p>For eclass devs to migrate from old to new, it is possible for them to just
415 transfer the old eclass into an appropriate grouping in the new eclass directory,
416 although it's advisable they cleanse all cruft out of the eclass. You can
417 migrate ebuilds gradually over to the new eclass, and don't have to worry about
418 having to support ebuilds from X years back.</p>
419 <p>Essentially, you have a chance to nail the design perfectly/cleanly, and have a
420 window in which to redesign it. It's humbly suggested eclass devs take
421 advantage of it. :)</p>
422 </div>
423 </div>
424 <div class="section">
425 <h1><a class="toc-backref" href="#id13" id="backwards-compatibility" name="backwards-compatibility">Backwards Compatibility</a></h1>
426 <p>All backwards compatibility issues are addressed in line, but a recap is offered-
427 it's suggested that if the a particular compatibility issue is
428 questioned/worried over, the reader read the relevant section. There should be
429 a more in depth discussion of the issue, along with a more extensive explanation
430 of the potential solutions, and reasons for the chosen solution.</p>
431 <p>To recap:</p>
432 <pre class="literal-block">
433 New eclasses and elib functionality will be tied to a specific portage
434 version. A DEPENDs on said portage version should address this for rsync
435 users who refuse to upgrade to a portage version that supports the new
436 eclasses/elibs and will gradually be unable to merge ebuilds that use said
437 functionality. It is their choice to upgrade, as such, the gradual
438 'thinning' of available ebuilds should they block the portage upgrade is
439 their responsibility.
440
441 Old eclasses at some point in the future should be removed from the tree,
442 and released in a tarball/ebuild. This will cause installed ebuilds that
443 rely on the old eclass to be unable to unmerge, with the same applying for
444 merging of binpkgs dependent on the following paragraph.
445
446 The old eclass-compat is only required for users who do not upgrade their
447 portage installation, and one further exemption- if the user has somehow
448 corrupted/destroyed their installed pkgs database (/var/db/pkg currently),
449 in the process, they've lost their saved environments. The eclass-compat
450 ebuild would be required for ebuilds that required older eclasses in such a
451 case. Note, this case is rare also- as clarified above, it's mentioned
452 strictly to be complete, it's not much of a real world scenario as elaborated
453 above.
454 </pre>
455 </div>
456 <div class="section">
457 <h1><a class="toc-backref" href="#id14" id="copyright" name="copyright">Copyright</a></h1>
458 <p>This document has been placed in the public domain.</p>
459 </div>
460
461 </div>
462 <div class="footer">
463 <hr class="footer" />
464 <a class="reference" href="glep-0033.txt">View document source</a>.
465 Generated on: 2009-02-20 09:17 UTC.
466 Generated by <a class="reference" href="http://docutils.sourceforge.net/">Docutils</a> from <a class="reference" href="http://docutils.sourceforge.net/rst.html">reStructuredText</a> source.
467
468 </div>
469 </body>
470 </html>

  ViewVC Help
Powered by ViewVC 1.1.20