Hey,
as mentioned in my earlier email I'm working on oVirt Node.
One special thing about Node is that we deploy an image, forming the rootfs, and not packages which then form the rootfs.
Currently we have our own installer carrying all the necessary bits to do this.
I now wonder if we could probably add some features to anaconda to deploy an image, instead of packages.
The basic idea is that the rootfs is rolled out (as in dd'ed) using an existing image, and not yum (or the other file based solutions).
Note: Important to note here is that the image should be copied/dd'ed as is, not file-wise copied into a new FS (liek it's happening with the liveimg payload IIUIC).
The idea is to roll out the image into a LV, then create a write-able snapshot or thin volume and use that as the rootfs.
Form that point on there shouldn't be a to big difference between a file based deployment and the image based one. Ok - Granted. There will surely be some more details which need to be addressed, e.g. the bootloader.
Any thoughts on this and can someone maybe tell if this is doable with anaconda?
Thanks fabian
On Wed, 2014-04-09 at 17:05 +0200, Fabian Deutsch wrote:
Hey,
as mentioned in my earlier email I'm working on oVirt Node.
One special thing about Node is that we deploy an image, forming the rootfs, and not packages which then form the rootfs.
Currently we have our own installer carrying all the necessary bits to do this.
I now wonder if we could probably add some features to anaconda to deploy an image, instead of packages.
The basic idea is that the rootfs is rolled out (as in dd'ed) using an existing image, and not yum (or the other file based solutions).
Note: Important to note here is that the image should be copied/dd'ed as is, not file-wise copied into a new FS (liek it's happening with the liveimg payload IIUIC).
The idea is to roll out the image into a LV, then create a write-able snapshot or thin volume and use that as the rootfs.
Form that point on there shouldn't be a to big difference between a file based deployment and the image based one. Ok - Granted. There will surely be some more details which need to be addressed, e.g. the bootloader.
Any thoughts on this and can someone maybe tell if this is doable with anaconda?
Maybe a stupid idea, but: What do you need/expect from the installer? If there is an image that should be dd'ed somewhere, I somehow cannot see any place where the installer could bring some benefits.
Am Mittwoch, den 09.04.2014, 17:25 +0200 schrieb Vratislav Podzimek:
On Wed, 2014-04-09 at 17:05 +0200, Fabian Deutsch wrote:
Hey,
as mentioned in my earlier email I'm working on oVirt Node.
One special thing about Node is that we deploy an image, forming the rootfs, and not packages which then form the rootfs.
Currently we have our own installer carrying all the necessary bits to do this.
I now wonder if we could probably add some features to anaconda to deploy an image, instead of packages.
The basic idea is that the rootfs is rolled out (as in dd'ed) using an existing image, and not yum (or the other file based solutions).
Note: Important to note here is that the image should be copied/dd'ed as is, not file-wise copied into a new FS (liek it's happening with the liveimg payload IIUIC).
The idea is to roll out the image into a LV, then create a write-able snapshot or thin volume and use that as the rootfs.
Form that point on there shouldn't be a to big difference between a file based deployment and the image based one. Ok - Granted. There will surely be some more details which need to be addressed, e.g. the bootloader.
Any thoughts on this and can someone maybe tell if this is doable with anaconda?
Maybe a stupid idea, but: What do you need/expect from the installer? If there is an image that should be dd'ed somewhere, I somehow cannot see any place where the installer could bring some benefits.
Hey,
much of th ework between our installer and anaconda is redundant, think of storage discovery and enumeration (also partitioning), iSCSI initialization, multipath, and EFI support ... Just to name the big items.
Node is somewhere between embedded and a minimal install. It is not embedded, because we don't make assumptions about the hardware where Node get's installed, thus we don't know e.g. what kind of disks and how many disks are there (which you typically know in an embedded world).
Further more we could use the functionality present in anaconda to do the post-deployed configuration, e.g. adding a user or configure the network (using the user and network ks directives).
Greetings fabian
The basic idea is that the rootfs is rolled out (as in dd'ed) using an existing image, and not yum (or the other file based solutions).
Note: Important to note here is that the image should be copied/dd'ed as is, not file-wise copied into a new FS (liek it's happening with the liveimg payload IIUIC).
Why?
- Chris
Am Mittwoch, den 09.04.2014, 11:50 -0400 schrieb Chris Lumens:
The basic idea is that the rootfs is rolled out (as in dd'ed) using an existing image, and not yum (or the other file based solutions).
Note: Important to note here is that the image should be copied/dd'ed as is, not file-wise copied into a new FS (liek it's happening with the liveimg payload IIUIC).
Why?
Because we'd like to keep one and the same image from the start until the end. We'd like to kepe one and the same image, to minimize the amount of changes between the point where the image has been tested and runtime.
- fabian
----- Original Message -----
From: "Fabian Deutsch" fabiand@redhat.com To: anaconda-devel-list@redhat.com Sent: Wednesday, April 9, 2014 11:05:28 AM Subject: Installing image payloads
Hey,
as mentioned in my earlier email I'm working on oVirt Node.
One special thing about Node is that we deploy an image, forming the rootfs, and not packages which then form the rootfs.
Currently we have our own installer carrying all the necessary bits to do this.
I now wonder if we could probably add some features to anaconda to deploy an image, instead of packages.
Support for this already exists. All you have to do is create a new class based on pyanaconda.packaging.ImagePayload. See the classes in livepayload.py for examples.
The basic idea is that the rootfs is rolled out (as in dd'ed) using an existing image, and not yum (or the other file based solutions).
Note: Important to note here is that the image should be copied/dd'ed as is, not file-wise copied into a new FS (liek it's happening with the liveimg payload IIUIC).
This may introduce limitations on the possible storage layouts, which is the main reason we switched from copying the image ala dd to using rsync.
The idea is to roll out the image into a LV, then create a write-able snapshot or thin volume and use that as the rootfs.
Form that point on there shouldn't be a to big difference between a file based deployment and the image based one. Ok - Granted. There will surely be some more details which need to be addressed, e.g. the bootloader.
Any thoughts on this and can someone maybe tell if this is doable with anaconda?
It is definitely doable. You will have to write your own Payload class and you may have to do some hacking to pull off the snapshot bit you described.
Thanks fabian
Anaconda-devel-list mailing list Anaconda-devel-list@redhat.com https://www.redhat.com/mailman/listinfo/anaconda-devel-list
Am Mittwoch, den 09.04.2014, 17:14 -0400 schrieb David Lehman:
----- Original Message -----
From: "Fabian Deutsch" fabiand@redhat.com To: anaconda-devel-list@redhat.com Sent: Wednesday, April 9, 2014 11:05:28 AM Subject: Installing image payloads
Hey,
as mentioned in my earlier email I'm working on oVirt Node.
One special thing about Node is that we deploy an image, forming the rootfs, and not packages which then form the rootfs.
Currently we have our own installer carrying all the necessary bits to do this.
I now wonder if we could probably add some features to anaconda to deploy an image, instead of packages.
Support for this already exists. All you have to do is create a new class based on pyanaconda.packaging.ImagePayload. See the classes in livepayload.py for examples.
Hey David,
thanks. Yes, I think that class goes much into the direction we also want.
The basic idea is that the rootfs is rolled out (as in dd'ed) using an existing image, and not yum (or the other file based solutions).
Note: Important to note here is that the image should be copied/dd'ed as is, not file-wise copied into a new FS (liek it's happening with the liveimg payload IIUIC).
This may introduce limitations on the possible storage layouts, which is the main reason we switched from copying the image ala dd to using rsync.
True. The storage layout is not as "free" as it is when you do it file based. We'd have to add those constraints to the logic.
The idea is to roll out the image into a LV, then create a write-able snapshot or thin volume and use that as the rootfs.
Form that point on there shouldn't be a to big difference between a file based deployment and the image based one. Ok - Granted. There will surely be some more details which need to be addressed, e.g. the bootloader.
Any thoughts on this and can someone maybe tell if this is doable with anaconda?
It is definitely doable. You will have to write your own Payload class and you may have to do some hacking to pull off the snapshot bit you described.
Great. I also had that impression, but it's nice to see that someone else is judging it this way too.
Oh - Is there somewhere a document describing how I can create the anaconda boot image?
Thanks and greetings fabian
On Thu, Apr 10, 2014 at 9:28 AM, Fabian Deutsch fabiand@redhat.com wrote:
Oh - Is there somewhere a document describing how I can create the anaconda boot image?
I used:
anaconda-devel@lists.stg.fedoraproject.org