From rPath Wiki
<hunter> honestly, I'm not sure I follow all the terminology in the white paper
<hunter> Has the termnology issue come up, and has there been any thought given to trying to simplfy it?
<hunter> It just looks like a little bit of a steep learning curve.
<mkj_wk> there's not a piece of new terminology without a good reason
<Tybstar> it's a complex system, really
<mkj_wk> when we're doing things in a fundamentally different way, it's going to feel a bit unfamiliar
<Tybstar> especially when you combine the build & repository systems into one piece
<hunter> I like the "shadow" facility for instance, but I'm really not sure I've got packages, components and troves figured out
<mkj_wk> the reason we're doing things in a fundamentally different way is to solve fundamental problems with packaging
<mkj_wk> hunter: read the table near the end of the paper
<hunter> hmm.
<hunter> nope, clear as mud still
<hunter> components are collections of files
<hunter> packages are solely collections of components?
<hunter> troves are ... files and packages?
<mkj_wk> trove is any collection
<mkj_wk> a package is a trove
<mkj_wk> a component is a trove
<mkj_wk> a fileset is a trove
<mkj_wk> a group is a trove
<mkj_wk> package, component, fileset, and group are types of troves
<mkj_wk> many operations can operate on any trove, not just (say) a package
<hunter> why call them troves rather than collections?
<hunter> What sematics did I miss there?
<Tybstar> trove is shorter? :)
<hunter> ok
<mkj_wk> more than that...
<mkj_wk> collection is such a generic word that you'd never know if you were using the specific jargon with specific meaning, or the general noun
<mkj_wk> we actually tried that, and it was horribly confusing
<mkj_wk> even when we were in a room talking to each other
<mkj_wk> or writing
<hunter> see, thats a good enough reason for me
<mkj_wk> we *needed* jargon to be clear; it was impossible with something as generic as collection
<hunter> groups are like package lists in anaconda
<hunter> So "Document Utils" or soemthing
<hunter> filesets are said to be fairly embedded specific - since the paper was written, have you seen any desire to use filesets outside the embedded space?
<Tybstar> they can serve that purpose, anyway
<Tybstar> i think there's more to groups than just a package list. someone else would have to explain that further. :)
<hunter> its versioned, which the anaconda ones aren't
<hunter> I don't see another difference
<hunter> flavors too
<hunter> at least I don't see "color" anywhere
<Tybstar> ohh, good idea
<mkj_wk> yes, the versioning is very important
<hunter> a conary package is pretty much like an rpm package
<mkj_wk> also, if you have installed (say) group-gnome (which doesn't exist yet, but never mind) and then erase one of the packages contained in group-gnome, that erasure shows up as part of the local changeset describing group-gnome
<mkj_wk> no, conary package is very different
<hunter> a component is the "collections" of various kinds of files in a package
<mkj_wk> a conary package doesn't contain (by reference) files
<hunter> binaies, docs, sources.
<mkj_wk> a conary package contains components; components contain files
<mkj_wk> there's not direct analog in rpm for a conary package
<hunter> I was doing ok till you said that... :)
<mkj_wk> conary breaks packages up into components mostly automatically
<hunter> at a 500 ft level, conary packages and rpm packages look _about_ the same to me
<mkj_wk> eh, they are the same in that you can install them :-)
<hunter> a repository is a collection of .. packages? or troves?
<mkj_wk> hunter: remember, though, that an RPM package is a *file* containing stuff
<mkj_wk> hunter: in conary, a package is a database entry
<hunter> thats an important question for me, actually.
<mkj_wk> repository is a versioned database that contains files (listed by fileid) and troves
<hunter> Gentoo around here is out of the question - I'm not building the same shit more than once
<mkj_wk> the closest analog to an rpm package, if you are thinking about a *file* that you can ship around, is an "absolute changeset"
<hunter> does conary allow me to ... collect up all the parts of a built "python-2.3" and send just the binary bits (and doc and .py etc files) to some other machine?
<mkj_wk> but a changeset can contain any set of changes --- changes to multiple packages, a single package, a single component, etc.
<hunter> crpa
<mkj_wk> hunter: if I understand you correctly, yes
<hunter> is it easy to see that an "absolute changeset" contains just the "python" bits, not some config changes to postfix ?
<mkj_wk> conary showchangeset shows the contents of a changeset
<mkj_wk> (abbreviatable to conary scs)
<hunter> at what level?
<mkj_wk> everything but the actual file contents
<hunter> hmm. that might serve
<mkj_wk> whether it's absolute or relative, all the filenames, the dependency information, etc.
<hunter> troves are just collections of other things
<hunter> can you have a component outside of a package?
<mkj_wk> yes
<mkj_wk> foo:source is not in any package
<hunter> why?
<hunter> oh
<mkj_wk> foo:source is simply treated differently, for one thing
<hunter> foo:source being roughly equivalent to src.rpms?
<mkj_wk> well...
<mkj_wk> it's more like how RH now maintains its source in cvs
<hunter> I said roughly
<mkj_wk> but it's the closest thing -- as long as you remember that a component is a database entry rather than a file :-)
<hunter> Ok, so lets say I've sat down with the latest pain in the universe, a new version of wu-blast (bad bioinformatics program)
<hunter> taken the original tar balls, the patches, the modified makes files etc.
<hunter> All the crap to turn wu-blast.latest.tar.Z into something somewhat useful.
<hunter> Can I bundle that into a file? Is that another example of an "absolute changeset"?
<mkj_wk> yes
<mkj_wk> two things
<hunter> shoot
<mkj_wk> you can bundle everything you need into one absolute changeset; that's enough to install on any machine with conary
<mkj_wk> you can *also* create a relative changeset, which is only what you need to *update* from one version to another
<hunter> Ah. Rpm "patches"
<hunter> excellent
<mkj_wk> furthermore, the client conary can talk to the repository directly and request the changeset from one version to another
