We also stumbled upon a great little Word Press Plugin: Code Snippet; theoretically it’s outdated, but it is working fine in our install.  For those who post code snippets, I’d strongly encourage you to take a look at this plugin. With a simple wrapper, you will have well formatted code with syntax highlighting write within your blog post.

Example

if getattr(self.context, 'getText'):
    lst.append((num_brains and div_start or div_start2) + self.context.getText() + div_end)

*unfortunately, the syntax highlighting doesn’t get pushed over into planet.plone.org….so…a bit less effective than I originally wanted it to be.

Jon ran across this situation recently, and needed to throw a debugger into the placeless script.  I had not seen this litte code snippet before, so perhaps many others have not as well.  In the __init_.py of your Product:

from AccessControl import allow_module

allow_module(’pdb’)

Restart Zope, and debug placeless scripts to your heart’s content.

Recently I had the task of revisiting a virtual machine that was provisioned with a file based file system as outlined in the tutorial. The main task I needed to achieve was to expand the size of the filesystem. Given that the tutorial has you build the virtual machine using tools that have this capability I figured it would not be that hard.

What is not obvious is that although the filesystem is made in such a way as to easily support this, that the actual practice of making it happen is a little more complicated. Having spent a lot of time googling all the various technologies and not coming up with a solution, I thought I would share what I learned, and give a recipe to perform the same operation on your own virtual server. All the usual caveats apply (use at your own risk, etc.)

If you are attempting to do something similar, or you are using a different Linux distribution it still may be useful to look at the following, and translate the steps accordingly.

Here is the recipe, feel free to let me know if it works for you:

1. Shutdown the VM

2. Backup the disk image file:

cp /xen/client8.img /xen/client8.img.backup

3. Restart the VM so that it can continue to serve while we work

4. Okay now make a working image from the backup:

cp client8.img.backup client8ext.img

5. Use dd to append more space to the end of the file:

dd if=/dev/zero of=/xen/client8xen.img bs=1M seek=10000 count=5000

This assumes an initial filesystem that is 10G and is expanding it to 15G

6. Check to see that the disk image file has grown the correct amount

ls -l /xen/client8ext.img

Should look something like

-rw-r–r– 1 root root 15728640000 Oct 26 02:22 client8ext.img

7. Mount the disk image on the loopback device:

/sbin/losetup /dev/loop1 /xen/client8ext.img

Here I am mounting it on loop1 because my initial loop0 was already in use. Just make sure that you mount it on an unused loop device and you should be fine.

Check that it has mounted okay:

/sbin/fdisk -l -u /dev/loop1

Should look something like:

Disk /dev/loop1: 15.7 GB, 15728640000 bytes
255 heads, 63 sectors/track, 1912 cylinders, total 30720000 sectors
Units = sectors of 1 * 512 = 512 bytes

Device Boot      Start         End      Blocks   Id  System
/dev/loop1p1   *          63      208844      104391   83  Linux
/dev/loop1p2          208845    20466809    10128982+  8e  Linux LVM

7. Find the start of the primary root partition. In the above example the LVM partition starts at 208845. Use the following formula to find the offset in the file where the LVM starts.

START * 512

8. Mount the volume group using the -o parameter and the calculated start value:

/sbin/losetup -o 106928640 /dev/loop2 /dev/loop1

9. Edit lvm.conf to filter out any other devices. If you are not actively using lvm on your working server it may be easy enough to just filter out everything but the loop devices. and return it back after you have finished. Here is a good reference on how to do this. In the end I just ended up changing the filter setting to

filter = [ "a/loop.*/", "r/.*/" ]

10. Rerun vgscan and check that it finds the volumes

/sbin/vgscan

You should see something like:

Reading all physical volumes.  This may take a while…
Found volume group “VolGroup00″ using metadata type lvm2

11. Okay now to resize the physical volume. Check to see that you can see it:

/usr/sbin/pvdisplay

Should get something like:

— Physical volume —
PV Name               /dev/loop2
VG Name               VolGroup00
PV Size               9.66 GB / not usable 3.58 MB
Allocatable           yes (but full)
PE Size (KByte)       32768
Total PE              309
Free PE               0
Allocated PE          309
PV UUID               IUefv0-aFx9-iPQn-p2nb-VOGO-ioQo-4XsfUc

12. Okay now to resize the physical volume:

/usr/sbin/pvresize /dev/loop2

Check that it worked:

/usr/sbin/pvdisplay

Output should now look something like:

— Physical volume —
PV Name               /dev/loop2
VG Name               VolGroup00
PV Size               14.55 GB / not usable 17.84 MB
Allocatable           yes
PE Size (KByte)       32768
Total PE              465
Free PE               156
Allocated PE          309
PV UUID               IUefv0-aFx9-iPQn-p2nb-VOGO-ioQo-4XsfUc

13. Now to resize the logical volumes:

/usr/sbin/lvdisplay

Should get something like:

— Logical volume —
LV Name                /dev/VolGroup00/LogVol00
VG Name                VolGroup00
LV UUID                4vMcGJ-jOdo-idMa-Q3qR-31Hg-YKHs-2ppTQA
LV Write Access        read/write
LV Status              NOT available
LV Size                9.16 GB
Current LE             293
Segments               1
Allocation             inherit
Read ahead sectors     0

— Logical volume —
LV Name                /dev/VolGroup00/LogVol01
VG Name                VolGroup00
LV UUID                wRtiQA-dZX1-fKI0-4yv2-FfPw-0F3C-8RThgX
LV Write Access        read/write
LV Status              NOT available
LV Size                512.00 MB
Current LE             16
Segments               1
Allocation             inherit
Read ahead sectors     0

14. Start by extending the swap space:

/usr/sbin/lvextend -L +512M /dev/VolGroup00/LogVol01

Then extend the root partition. Let’s use all available space this time.

Look up free extents:

/usr/sbin/vgdisplay

Get Something like:

— Volume group —
VG Name               VolGroup00
System ID
Format                lvm2
Metadata Areas        1
Metadata Sequence No  5
VG Access             read/write
VG Status             resizable
MAX LV                0
Cur LV                2
Open LV               0
Max PV                0
Cur PV                1
Act PV                1
VG Size               14.53 GB
PE Size               32.00 MB
Total PE              465
Alloc PE / Size       325 / 10.16 GB
Free  PE / Size       140 / 4.38 GB
VG UUID               ecCfkb-oPKd-Tf4S-VTLj-2M9c-LJJj-BHBPh2

15. Free extents are 140. Use this to extend the root partition:

/usr/sbin/lvextend -l+140 /dev/VolGroup00/LogVol00

16. Activate the root logical volume so that we can resize it:

/usr/sbin/lvchange -ay /dev/VolGroup00/LogVol00

17. Now we need to resize the file system. The docs I found suggest that you run a filesystem check both before and after you have resized the partiion:

/sbin/e2fsck -f /dev/VolGroup00/LogVol00
/sbin/resize2fs /dev/VolGroup00/LogVol00

Check the filesystem again:

/sbin/e2fsck -f /dev/VolGroup00/LogVol00

18. Okay now deactivate the root partition:

/usr/sbin/lvchange -an /dev/VolGroup00/LogVol00

19. Activate the swap partition:

/usr/sbin/lvchange -ay /dev/VolGroup00/LogVol01

20. Run mkswap on the extended swap partition:

/sbin/mkswap /dev/VolGroup00/LogVol01

21. Everything okay, now deactivate it again:

/usr/sbin/lvchange -an /dev/VolGroup00/LogVol01

22. Change the size of the LVM partition on /dev/loop1 using fdisk. This step caught me out. The disk partition information needs to be updated to reflect the new LVM size. Just launch fdisk and find the last partition. Then change it to reflect the full size of the drive.

23. Deactivate the loop devices:

/sbin/losetup -d /dev/loop2
/sbin/losetup -d /dev/loop1

Your file based filesystem should now be ready to use with your current virtual machine. Change the appropriate line in your server’s XEN configuration and restart your server and enjoy!

“eduCommons is an OpenCourseWare management system designed specifically to support OpenCourseWare projects like USU OCW. eduCommons will help you develop and manage an open access collection of course materials.

eduCommons is built around a workflow process that guides users through the process of publishing materials in an openly accessible format. This includes uploading materials into a repository, dealing with copyright, reassembling materials into courses, providing quality assurance, and publication of materials.”

eduCommons is an open source response to MIT’s OpenCourseWare initiative.  Currently, 1/3 of the OpenCourseWare Consortium’s members utilize eduCommons as their OpenCourseWare solution. These members represent a wide cross section of institutions, from Western Governor’s University, the only accredited university in the U.S. offering competency-based, online degrees, to the United Nations University, which showcases the training and educational programmes implemented by the University in a wide range of areas relevant to the work of the United Nations, and numerous entities in between.

Back to the egg…the eduCommons egg can be found here.  We have also created an eduCommons buildout, for those interested in experimenting with the suite. One of past criticisms of eduCommons has been the complexity of deployment; buildout mitigates many of those concerns.  We’ll be working on improving the buildout even more, as this is our initial foray into this area.

• collective.zipfiletransport
• collective.imstransport
• collective.contentlicensing

We also have a functional egg working for out leftskin product, which we use as part of the eduCommons suite.  It’s name is a bit deceptive, as it not only provides a default theme, but has a handy configuration panel for setting styles/images TTW, similar to WebLion’s CSSManager.

1) Buildout is here to stay

2) Python Eggs are here to stay

We’ve been waffling on whether or not to move toward these technologies, but the research and data now show the clear benefits of utilizing them, of paramount importance is the ease at which they help the (re)deployment story.

Using Martin Aspeli’s egg cooking inroduction, Jon and I set out to convert our PloneBookmarklets AddOn into a full fledged egg, which can be found in the collective at collective.plonebookmarklets.  The entire process, form creating a buildout environment, to testing the development egg, took only 90 minutes.  Granted, it is a relatively simple product, with not many lines of codes, but it was really satisfying to see how approachable this new framework has become.

The egg can be found in the collective, for the time being; we’ll realease to the Cheese Shop once we figure out the process.

Another great factoid about this revision…it has contributions from 3 additional developers. ONE/Northwest provided numerous fixes related to browser layers and image cacheability, we have additional contributions for translations (Spanish and Basque), and some new social bookmarking tool additions as well (Facebook and Technorati). Thanks to those who are using the product, and have taken the time to make it better as well!

We are looking at potential solutions to provide an alternative front end for eduCommons, as many potential institutions may be in lower bandwidth areas, where a slimmed down front end is essential.  Perhaps presenting the serialized data from Content Mirror wrapped in a theme via Deliverance would fit the bill.

By virtue of the fact that you are reading this blog post, you are already aware that we now have a blog as well.  This will be a great tool for us to communicate what the latest happenings are in the office, as well as in the communites that we are involved in.

Brent and I will be travelling to the Plone Conference in Washington D.C. tomorrow, and should have some great items to report during our stay.