Recently I had the fortune to work on a Lenovo T420 laptop that has this setup, and it works very well on MS-Windows with the Nvidia Optimus driver – you get battry life around 10 hours with the 9 cell battery.

Unfortunately I spend most of my day in Linux and because Nvidia does not support Optimus on Linux, you have the poor choice of either running everything on the Nvidia chip – decreasing battery life to around 4 hours if you’re careful, or disabling the Nvidia chip completely.

The solution comes from the Bumblebee project – a software suite to handle the switching between the Nvidia discrete graphics and the embedded Intel chip.

The setup is pretty simple to understand (though I suspect under the hood there are many problems to be solved): A service runs and waits for users to ask for 3D accelerated graphics. When a user starts a program using the special command optirun, the service loads the Nvidia driver, starts an X server using the discrete graphics (with the display disconnected from the actual screen) and runs the specified program on that “background” X server. Then it copies the visuals from the program that is rendered using the discrete graphics to a window on the main X server. When the program terminates, the service closes the secondary X server, removes the driver and powers down the graphics card – putting us back into the ~10 hours battery life.

The Bumblebee software had some problems in the past, but the current version – 3.0 – looks very good. There are a few seconds of delay when you launch the application (setting up the driver and X takes some time), but performance is about what you’d expect when running directly on the hardware. All this without any configuration – that is if you are running on the stable Ubuntu version.

As I can’t leave well enough alone, and whenever someone says “alpha”, I say – “I wants”, I’m running the current Ubuntu 12.04 alpha (which is not so bad – due to be released in a couple of months, it works very well). And of course Bumblebee doesn’t work properly here.

So this is what I had to do to get it running:

These instructions assume you are doing everything in a command line. If you are not comfortable with the command line, this guide is not for you – go away.

1. We will start by installing Bumblbee itself and its dependencies. We will need to add their PPA to the Ubuntu software sources list:
sudo add-apt-repository ppa:bumblebee/stable
Unfortunately the project has a repository for Ubuntu 12.04, but at this point in time it does not include all the needed packages. I had to edit the source list file and add the 11.10 repositories as well before installation could complete – open the file /etc/apt/sources.list.d/bumblebee-stable-precise.list for editing as root, for example:
sudo gedit /etc/apt/sources.list.d/bumblebee-stable-precise.list
and duplicate the two lines found there, changing the word precise to oneiric in the duplicates. Save and exit the editor, then run these:
sudo apt-get update
sudo apt-get install bbswitch-dkms bumblebee bumblebee-nvidia virtualgl-libs:i386 libgl1-mesa-glx:i386 libc6:i386
sudo usermod -a -G bumblebee $USER

   The last line adds the current user (the one you are logged in as) to the “bumblbee” user group – only users who are part of this group may use the Bumblebee service. If you have more users that you want to be able to play 3D games, then you need to add them as well.
2. The Bumblebee Project recommends Ubuntu users to install the “X-Swat” x-updates PPA, but this isn’t available for 12.04 users, and we are already running the latest X anyway, right? After bumblebee didn’t work for me, I went to the next best thing – the xorg-edgers repository. A word of warning – this is a set of highly experimental software – if it works for you, count yourself lucky and if it doesn’t – don’t complain. To install it, type:
sudo apt-add-repository ppa:xorg-edgers/ppa
sudo apt-get update
sudo apt-get dist-upgrade -y
At this point most likely your kernel and other important software packages have been upgraded, so its a good idea to reboot.
3. After you come back from the reboot, the standard Nvidia driver will not work, because of an incompatible ABI version. Not to worry, its time to recompile a new Nvidia driver. Start by removing your old one with:
sudo apt-get purge nvidia-current
Now to get the most up to date Nvidia driver package to rebuild a driver that works with your latest Xorg and kernel, create a new directory to hold the Nvidia package sources and change into it, and type:
sudo apt-get install build-essential checkinstall -y
sudo apt-get build-dep nvidia-current-updates -y
apt-get source nvidia-current-updates
Now with the source downloaded and all dependencies installed, we can build a new driver and install it:
cd nvidia-graphics-drivers*
dpkg-buildpackage -us -uc -nc
cd ..
sudo dpkg -i nvidia-current-updates_*.deb
If all went well, you have your new Nvidia driver instaled. Lets see if it loads Ok:
sudo modprobe nvidia_current_updates
If you get no error, then we can go to the next step.
4. The Bumblebee configuration must be modified to work with all this cutting edge stuff, so lets start by turning off the Bumblbee service:
sudo stop bumblebeed

   Now you need to edit the Bumblebee configuration file. Use your favorite text editor to open /etc/bumblebee/bumblebee.conf as root, for example:
sudo gedit /etc/bumblebee/bumblebee.conf
. This is a standard INI filewith a lot of comments to help you figure out what is going on in here, and we will need to do some changes to (a) disable auto-detection and force Nvidia mode and (b) help Bumblebee locate the drivers for the Nvidia graphics. Make these changes:
   • In the [bumblebeed] section, set Driver=nvidia
   • In the [driver-nvidia] section, set KernelDriver=nvidia_current_updates and in both LibraryPath and XorgModulePath change nvidia-current to nvidia-current-updates.

   Save the file after all the changes have been complete, and start the service again:
sudo start bumblbeed


5. At this point, Bumblebee should be ready to do some damage. The recommended way to test it is to run
optirun glxspheres
Give it a few seconds to launch the window (the screen may black out for a bit, don’t worry about it). When the window appears, it should show a graphical demo and a frame per seconds counter at the bottom left corner. On my system it shows a respectable 86 frames per seconds (vs 2 frames per seconds on the embedded Intel chip). If the glxspehere window doesn’t come up, and you get errors from the optirun command, look in the system log file /var/log/syslog for lines from bumblebeed. Also if you haven’t rebooted your computer since you built the Nvidia drivers, it might be a good idea to try that as well.

Running games with optirun is pretty straight forward – either invoke them manually or edit their .desktop files to add the optirun command. I’ve also used this in MS-Windows games running under wine (I recommend using PlayOnLinux – its a beautiful piece of work), and they work perfectly well.

Best of luck, and let me know if it works or if it doesn’t.

Related articles

• Installing Nvidia drivers on Fedora 16 – the wrong way (geek.co.il)
• Ubuntu 12.04 LTS, Codename Precise Pangolin Releases Its First Alpha (techie-buzz.com)
• How to manually install latest nvidia drivers on Ubuntu Oneiric 11.10 (neelmohile.wordpress.com)

So if you still want to authentication your Fedora installation against the company’s Active Directory – and can’t/won’t rely on Winbind’s notably flaky behaviour, you can always install NSS/PAM ldap authentication manually. Unfortunately its not as easy as it sounds, and as I learned the hard way – one must pay careful attention to SELinux. So here’s the recipe:

1. Install pam_ldap and nss_ldap: yum install -y nss_ldap (this will also install the PAM support).
2. Configure LDAP access. In Fedora the NSS and PAM configuration were broken into 2 different files. Fortunately the syntax and required configuration is identical so you can just create both files as a copy of each other or even use a link. My configuration looks like this:

   
# the Active Directory domain - this the LDAPized FQDN of your Active Directory tree
base dc=some,dc=domain,dc=com
# the CN of an unpriviliged user that is allowed to log in and search in the domain.
# we created this dummy user that is not part of the normal domain user and it is needed
# for many integration scenarios
binddn CN=authuser,CN=Users,dc=some,dc=domain,dc=com
bindpw 123456
scope sub
timelimit 120
bind_timelimit 120
bind_polict soft
idle_timelimit 3600
# this is the default set up for SBS directory installation
nss_base_passwd ou=SBSUsers,ou=Users,ou=MyBusiness,dc=some,dc=domain,dc=com
nss_base_shadow ou=SBSUsers,ou=Users,ou=MyBusiness,dc=some,dc=domain,dc=com
nss_base_group ou=Security Groups,ou=MyBusiness,dc=some,dc=domain,dc=com?sub
nss_initgroups_ignoreusers root,ldap,named,avahi,haldaemon,dbus,radvd,tomcat,radiusd,news,mailman,nscd,gdm
# this configuration is based on SFU 3.5 schema that must be installed on the ActiveDirectory server
nss_map_objectclass posixAccount user
nss_map_objectclass shadowAccount user
nss_map_attribute uid sAMAccountName
nss_map_attribute homeDirectory unixHomeDirectory
nss_map_attribute shadowLastChange pwdLastSet
nss_map_objectclass posixGroup group
nss_map_attribute uniqueMember member
pam_login_attribute sAMAccountName
pam_filter objectclass=User
pam_password md5
# configuration for the LDAP server connection
ssl no
uri ldap://LDAP.SERVER.NAME/
tls_cacertdir /etc/openldap/cacerts


   The pam_ldap and nss_ldap come with a default configuration file – just overwrite both of these with the content above (after adapting it to your needs – change the LDAP server name, the LDAP base DN, login user and search paths).

   This is as good a time as any to make sure that your computer can indeed access the LDAP server. I recommend installing openldap-clients and running a test query using ldapsearch. For example, the following query will list all the users eligible for log in using the configuration above:

   
ldapsearch -h LDAP.SERVER.NAME -D "CN=authuser,CN=Users,dc=some,dc=domain,dc=com" -w 123456 -b "ou=SBSUsers,ou=Users,ou=MyBusiness,dc=some,dc=domain,dc=com" dn


3. Now you need to configure the authentication stack to use your new LDAP configuration. Unfortunately, the Fedora configuration tool will not allow you to select LDAP without SSL or TLS and without Krebros, so we’d need to edit the configuration files by hand. But lets start with a clean setup – run authconfig-tui --enablemkhomedir and make sure only “Cache Information”, “Use Shadow Passwords” and “Local authorization is sufficient” are selected, and click “Next”.

   Now lets go edit the configuration files directory. There are two configuration files that need to be edited – /etc/pam.d/system-auth and /etc/pam.d/password-auth. The changes needed to both are identical so just go ahead and edit one of them with your favorite text editor and then copy it over the other one:

   • In the auth section, before the line for pam_deny add:

     
auth sufficient pam_ldap.so use_first_pass


   • In the account section, before the line for pam_permit add:

     
account [default=bad success=ok user_unknown=ignore] pam_ldap.so


   • In the password section, before the line for pam_deny add:

     
password sufficient pam_ldap.so use_authtok


   • In the session section, after the last line, add:

     
session optional pam_ldap.so


   Alternatively, you can download this patch file, and execute it using cd /etc/pam.d; patch < fix-auth.txt.

   Additionally you need to configure NSS separately by adding the ldap module to the configuration in /etc/nsswitch.conf: edit the file and add it in the lines for passwd, shadow and groups, like so:

   
passwd: files ldap
shadow: files ldap
group: files ldap


4. We also need to get SELinux to allow NSS and PAM to contact the LDAP server as part of the login process (before the user gets their own security context where such things are allowed). To do that, run this command: setsebool authlogin_nsswitch_use_ldap 1

Your system should now be ready to log in using LDAP. Have fun.

Required Ingridients:

• A computer with The GIMP installed
• Your handy smart phone with a 5MP or better camera
• A good pen and paper.

So anyway, here’s the process from top to bottom, with pictures:

1. Sit down at a proper table, and using a good black heavy-line pen on a white clean high-density paper, write what you need to write – slowly and deliberately but without pauses. Try not to smear the ink so you get clean continuous lines, otherwise the quality suffers a lot.
   
2. Now take your phone and start the camera app. Make sure that flash is on (not auto – always on), and if your camera supports it, set the “auto focus” mode to “Macro”. Position the camera close to the paper so that it sees your whole text and hold the shutter button (don’t release it yet) to let the camera focus. If you don’t get a clean focus then don’t take the shot, move the camera a bit away and try again until you get a clean focus.
3. After the picture is taken, load it into the computer. This part is usually the most complicated part of the whole process. On my phone I have “Google Docs” app installed, so I “Share” to “Docs” and I then use the browser to go to Google Docs and download the image file.
   
4. Now its time to start GIMP, load the picture and do the magic:
   
5. The first tool to use is the “Crop” tool from the toolbox – we need the image contain only the actual hand written note we want to convert, and specifically we need to get rid of the edges of the picture where the flash didn’t highlight the paper well (because the camera was so close to the paper
   
   The “Auto Shrink” feature is normally very useful for these kinds of jobs, but because of the inherently “noisy’ background of the paper, it wouldn’t work at all – just do your best manually and leave a bit of margin around the text. When you’re done setting up the box around the text, then click the center of the selection to make the crop.
6. Next we need to clear the image of most of the background noise of the paper before the real work can begin – to do this we will use the popular “Unsharp Mask” filter
   
   When the “Unsharp Mask” dialog comes up, push both the “Radius” and “Amount” sliders all the way to the end, while leaving the “Threshold” value at its default small value (I usually set it to 5, but any small number will work fine)
   
   After you apply the filter, the image would look drastically different, as you can see in the example below, but we’re not done yet
   
   If you look closely you’ll see that there are still some color artifacts present. In this example the photograph source is of rather high quality, but with less high quality input you may still see here some blobs and spots which should get taken care of by the next step.
7. To completely separate the hand written text from the background, we will use the “Threshold” command from the “Colors” menu – this will highlight in black only the ink from the photograph and will clear everything else to white. When the “Threshold” dialog opens, click the “Auto” button to automatically select the correct threshold value.
   
   At this point we are basically done with the major part of the work. We need only prepare the image for embedding and possibly due a bit more clean up if the original wasn’t of a good enough quality and we still got some black blotches where there shouldn’t be any.
8. The next step is to remove the white background from the image so it can be later embed the image into another document without having a white box around the text, that hides whatever we were supposedly “writing over”. From the “Colors” menu select the “Color to Alpha” command and apply its default setting (which should be to have the color White converted to transparency)
   
9. If we still got some inky looking blotches, left from the previous stage that we want to remove, you can clean them up manually by adding a layer mask
   
   And set it up to start completely white (opaque – which is the default)
   
   Once that is done – and you can see the layer mask as a white box to the right of the layer preview in the layers tab, take a paintbrush from the toolbox, and touch it to where you have noise that you want removed, careful not to touch actual lines
   
   Finally apply the layer mask by right clicking the layer in the layers tab and selecting “Apply Mask”
10. The last step is to save the result as a PNG file – so that we keep the transparency of the background.

The new image is now ready for import into your PDF editing software of choise, or into any other document where you need to fake ink on paper. You can also, obviously, keep the digital file and use it many times without bothering your hardware (pen, paper and camera) again.

Good luck.

The main advantage of either of these methods is security: both have easy transport security (SSH by default, Apache if you set it to server over SSL) and are easy to setup authentication for (SSH authenticate against the system’s accounts using PAM and Apache authenticate against basically anything with a simple setup).

The main disadvantage of these methods are that they are slow (SSH is apparently somewhat faster then HTTP) and when supporting multiple large projects of many developers I started running into all kinds of weird connection errors when you try to manipulate many files on many projects at the same time.

Subversion itself offers another alternative using their own network service called svnserve – this is a standard unix daemon that listens on a specific port and uses a native protocol to communicate with Subversion clients (using the svn:// schema in Subversion URLs). It offers very good performance, but no transport security (encryption) by default. Another major problem with using svnserve as a network service is that while CentOS ships the binary itself (it is required as part of the way that the svn+ssh:// protocol is implemented) it doesn’t ship any support files to run it as a standalone service nor to help with its configuration. Also by default svnserve can only authenticate users using its own Apache-style password database file – which makes it unsuitable to integrate in large organizations.

In this article I’ll document how I setup snvserve as a network service to support a large development environment. The requirements do not include transport security because the server is on a private network and can only be accessed by trusted computers (either local or through a VPN), but we do need to have Subversion users authenticate against a central authentication server that is used by all local services. In my setup the authentication services is Mirosoft ActiveDirectory, but the local server is setup to authenticate to the ActiveDirectory using PAM, so we will setup svnserve to use PAM and gloss over the ActiveDirectory specifics.

The process is as follows:

1. Set up your server: Install CentOS 6 and configure PAM to authenticate to your central authentication. Verify that users can SSH into the server using their login credentials.
2. Set up your Subversion repository: Install subversion and use svnadmin to create your repository. In the below examples I’ve created the repository under /var/svn
3. Set up svnserve to require authentication and do the authentication using the Cyrus SASL libraries: copy the file svnserve.conf from your repository’s configuration directory (for example /var/svn/svnserve.conf) to /etc/svnserve.conf. Edit it and add in the [general] section the following lines:
anon-access = none
auth-access = write
realm = The Name of Your Repository
make sure that all other settings in that section are commented out. Now add, at the bottom of the file, a new section like this:
[sasl]
use-sasl = true

4. Setup the Cyrus SASL library to work with the saslauthd authentication service: create the file /etc/sasl2/svn.conf with the following content:
pwcheck_method: saslauthd
mech_list: plain login

5. Start the saslauthd service and make sure it always run when the system start, by executing the following commands:
# service saslauthd start
# chkconfig saslauthd on

6. Set up saslauthd to allow svnserve to authenticate using the main system’s PAM configuration, by executing the following command:
# cd /etc/pam.d
# ln -s system-auth svn

7. Create the SysV initialization script for svnserve – this will allow you to start and stop svnserve using the service command and have it run when the system start. This is the major part that I expected CentOS to ship but is missing. Creating a good SysV script is not trivial – you can do it yourself but I suggest using the script presented here. I’ve used the script from this blog post which is not bad but its implementation of status didn’t report the status of a dead process, so I modified it and you can download my modified version here. The file is compressed because of WordPress, just download it, run it through gunzip and copy the resulting file to /etc/init.d/svnserve and then give it “execute permissions” using:
# chmod 755 /etc/init.d/svnserve

8. Create a configuration file for the service by creating and editing the file /etc/sysconfig/subversion.conf with this content:
OPTIONS="--config-file=/etc/svnserve.conf -r /var/svn"

   We use the -r option to limit svnserve access to only our repository, so have the value there point to your actual repository if its not /var/svn
9. Set up svnserve to run when the system start, and then start the service itself:
# chkconfig svnserve on
# service svnserve start


And that’s it – you should have svnserve listening on port 3690 and ready to serve clients. The URL you use to access the repository should include only the server name as svnserve access is already rooted to only your repository by the configuration file. So for example if my server is called svn then the URL will be svn://svn.

This setup will still allow you to access the repository using the svn+ssh:// protocol as you would under a normal setup. It can be a bit confusing as access over SSH uses different paths then over the Subversion svnserve network service, because you have to use the full path to the repository on the local file system in the svn+ssh:// URL. To circumvent this, its possible to get the SSH access to also be rooted to your repository’s path and thus be symmetric with the above setup. To do this, create a new file at /usr/local/bin/svnserve and put the following code in it:
#!/bin/bash
exec /usr/bin/svnserve "$@" -r /var/svn

Give the file “execute permissions” by running
# chmod 755 /usr/local/bin/svnserve
, so it can be executed by the Subversion client instead of the system’s svnserve binary. Now both native Subversion and SSH access use basically the same URL, except for the schema part.

Related articles

• CentOS – Subversion Configuration (waterbiscuit.wordpress.com)
• Passwords and svn (stackoverflow.com)
• Importing a subversion repository (stackoverflow.com)
• Subversion – Merging Repositories (stackoverflow.com)

ספיציפית החוקר – שי דנצינגר – מצא ששופטים הדנים בבקשות חנינה של אסירים ישראלים מחלקים את הישיבות שלהם לשלושה חלקים המופרדים ביניהם בהפסקות אוכל, ובהנתן שאנחנו מפקטרים החוצה כל שיקול אחר (בין אם הוא לגיטימי או לא – כמו אחוז מזמן המאסר המקורי שהאסיר כבר עשה, חומרת הפשע, השתייכות עדתית וכו’) אפשר לראות בצורה מובהקת ירידה דרמטית באחוז ההצלחה של בקשות חנינה בין תחילת וסוף כל חלק, כשאחרי ההפסקה אחוזי ההצלחה חוזרים לרמתם הקודמת.

יש כמה מאמרים באינטרנט שסוקרים את עבודת המחקר ומציאים מסקנות, לדוגמה הסקירה של הבלוג “Not Rocket Science” של מגזין “Discover”‮ שהיא מעניינת – ואני ממליץ עליה אם לא בא לכם לקרוא את המאמר המקורי, אבל רציתי לדבר על תשישות החלטות (“Decision Fatigue”) בהקשרים של טכנולוגית תקשורת – נושא שקרוב אלי בהרבה מאשר היעילות של המערכת השיפוטית הישראלית.

הזיהוי של ההתנהגות האנושית שבה ככל שאנשים נדרשים לבצע יותר החלטות – ו\או החלטות קשות יותר – כך הם נהיים יותר עדישים לבחירות שלהם, אינו משהו חדש או מפתיע לכל מי שצופה בהתנהגות אנושית באיזו שהיא רמה, בין אם מדובר מעצבת ממשקי משתמש חובבנית או פסיכולוג מורשה, כשבמאמר הנדון מה שבעיקר אמור להפתיע זה שההתנהגות הזאת נראית, בעוצמה, גם אצל שופטים מקצועיים שאמון עליהם שהחלטות שלהם חייבות להיות נקיות מכל שיקול חיצוני – מכיוון שהן נוגעות במישרין לחירות של אדם או לעיתים אפילו לחייו. כל שכן אפשר לזהות את ההתנהגות הזאת בכל מקום בחייו של אדם, בעיקר בעידן המודרני שבו אנחנו נאלצים לבצע החלטות אלפי או מיליוני פעמים ביום.

הכשל לזהות את הבעיה, ולתת פתרון נכון, נפוץ בקרב מי שמודעים לבעיה: אפילו באותו פודקסט (פודקסט מספר 24, באזור דקה 63), קצת לאחר שספולסקי מזכיר את הנושא של תשישות החלטות, הם מדברים על ממשק המשתמש של המנהלים שבו רשימת האפשרויות לסימון סיבת סגירת שאלה היא ארוכה מדי – מעל 20 אפשרויות וצריך שיהיה שם לא יותר מ-16 אפשרויות שונות: שזה נשמע כמו התאמה נכונה לתשישות החלטות, אבל זו עדיין אופטימיזציה גרועה: רעיון יותר טוב הוא לחלק את האפשרויות לעץ החלטות רדוד ולהוביל את המשתמש דרך “ממשק אשף” המציג כל החלטה בתורה – לדוגמה, אם צריך לבחור בין כ-30 אפשרויות, אפשר לתרגם את זה לצעד אחד הבוחר בין כל האפשרויות (עץ החלטות בעומק 1) או סדרה של שאלות כן/לא (עץ החלטות בעומק 5) עם כי האופטימום הוא איפשהו באמצע – כנראה משהו כמו שלושה צעדים עם 3~4 החלטות בכל צעד, כמו “מבחן אמריקאי”.

מעבר לממשקי המשתמש, את תשישות ההחלטות – או אולי תרגום טוב יותר יהיה “הלם החלטות” (כמו “הלם קרב” – “combat fatigue”) אפשר לראות גם בחיים האמיתיים, בעיקר אצל עובדים בחברות סטארט-אפ: כמות הפרוייקטים הפתוחים בכל רגע נתון, והצורך לעבור כל הזמן בין עבודה מרוכזת בנושא אחד לעבודה בנושא אחר, לענות על דואר, להתייעץ או ליעץ לעובדים אחרים, וכו’ היא בעצמה יוצרת עומס החלטות כבד – אפילו בלי להתחשב בעבודה עצמה.

לדעתי השיקול של הפחת הלם החלטות צריך להיות בין השיקולים הראשונים שצריך להתחשב בהם כשבאים לתכנן מערכות לשימוש בני אדם – בין אם זה ממשקי משתמש לתוכנה או נהלי והרגלי עבודה בחברות טכנולוגיה, וכל אדם הנמצא בחשיפה להלם החלטות צריך להיות מודע לסכנות הכרוכות בכך ולתכנן דרכי מניעה – רק לצערי שאין לי כרגע שום רעיון בנושא, ואשמח לשמוע כל הצעה ועצה.

The problem is that the “old archive storage” also has limited disk space and I got fed up managing the archive by hand. The solution I came up is to scan the hierarchy of  log files in the storage (logs are stored hierarchically according to origin and type) and delete old files until I have enough room to move some newer files in. That way the “old archive storage” is always kept full and keeps as much back-log as possible and does this automatically.

The piece of code that determines which files we want to delete works like this:

1. Use find to list all the files in the directory structure
2. Pipe it to perl and collect all the file names in a list
3. Use perl’s sort operator to compare the modification times of each file in the list and show them in the order (i.e. oldest first)
4. Use head to get just the first file

So it looks like this:

find /mnt/httpd_back/ -type f | perl -nle 'next unless -f; push @files, $_; END { foreach $file (sort { @a=stat($a); @b=stat($b); $a[9] <=> $b[9] } @files) { print $file; }}' | head -n1


Note: normally we use head to get some initial output and terminate the process early before it does more costly work – when head has enough data it terminates the pipe sending SIGPIPE to the upstream process and that usually terminates the process that generates the data. In this case – and in all other cases involving sort – the upstream process buffers all the data in its own memory before outputting anything, so it can sort everything, and using head here is just a filter to get what I want and does not actually save me from doing all the work. I could have easily done the same thing inside the perl script itself by replacing the block of  print $file; with print $file; last; – this has the same effect as using head, because head will send SIGPIPE to perl after getting the first print and will terminate it. Deciding which way you want to go is probably more about readability of the code and I prefer my original version because its easier to read to non-perl specialists.

I can then just remove that file, see if I have enough room to move in the newer log file and if no – repeat the process.

This would work well, I believe, but it may be inefficient if I find a bunch of small files and I want to copy in a large file. So what I did next is to take advantage of the fact that all the log files I have are named using the following simple format:

<service>-<type>_log-<year><month><day>.gz

and that allows me to easily find all the log files that record the same day and eliminate them at the same time. Subsequent moving of additional files will likely succeed because I cleared out all the log files of an entire day. If not, I can always go and clear up another day’s worth of logs.

Lately I’ve been having problems updating software on my Motorola Milestone (1, as in A853) running CyanogenMod 7.1 (thanks to Nadalbak who maintains an unofficial and unsupported port of CyanogenMod for this old device). When I start the Android Market and do an update of an existing application, I get the error “Package file is invalid” for any application. Sometimes removing an application and reinstalling it will work, but often not.

There could be several problems that cause this, apparently a problem with the file permissions on the file systems is common, and if this is your problem then it can be fixed by opening the terminal emulator, executing “su” to gain super-user permissions and then running “fix_permissions” (it will take a while to complete).

If this doesn’t solve the problem for you, then likely the problem is that you ran out of space on your “data” partition or “cache” partition. This is very common if you have a large “apps partition” on your SD card and you are in the habit of installing tons of applications – I know I am .

The problem is the “Dalvik cache” that gets full and apparently the operating system doesn’t clear old files from it so it will eventually run out of space.

I’ve tried cleaning the Dalvik cache, using Titanium backup and the OpenRecovery menu – but that doesn’t clean the cache properly for some reason, likely because it expects the cache to be on the “data” partition but in CyanogenMod 7 for Milestone the Dalvik cache is on the “cache” partition.

To solve the problem, boot into OpenRecovery then select “Wipe cache” from the main menu. Please note that you must wipe the entire cache partition and not just the Dalvik cache. Also make sure not to choose the similar option to wipe the data partition as that will remove all your personal data from the phone…

Good luck.

Update:

If your /cache partition is constantly overloaded in your Mileston A853 running CyanogenMode 7.1, you can disable the hosting of the apps dalvik cache under /cache by editing the system’s build.prop file. To do it follow these instructions.

1. Start a terminal in your phone using the terminal emulator app (or an alternative – I use ConnectBot).
2. Execute su and approve the super user mode.
3. Execute mount /system -o remount,rw to allow editing the build.prop file.
4. Execute vi /system/build.prop to edit the file.
5. Find the instruction dalvik.vm.dexopt-cache-only – you can type /dalvik<ENTER> to find it. Move the cursor to the end of the line and press on “A” to start editing. Delete the “1″ at the end of the that line and write “0″ instead.
6. Issue an “ESC” button (in ConnectBot you can do it by pressing the camera shutter button) and then type “:x” to save the changes and leave the editor.
7. Execute mount /system -o remount,ro to return the system files to read only mode.
8. Reboot to OpenRecovery and use it to clear the dalvik cache and the cache partition, and then reboot the phone.

Your device should now have enough space in the /cache partition.

Related articles

• CyanogenMod 7.1 Released (beast4romtheeast.wordpress.com)
• Netflix for Android Officially Recognizes CyanogenMod ROMs (pocketnow.com)

If you ever had to work with MS-Windows file server, you should know that you can also access SMB file shares using URLs – with the schema “smb”, like this: smb://file-server/share-name.

Using a URL like that will ask the file browser to open an SMB connection to the file server and try to list the content of the share. If your file server is not of the kind that likes anonymous users, a password dialog would come up where you have to enter a user name and a password, and a domain name. Nautilus will show an authentication dialog with a “domain” field pre-filled with the domain name “WORKGROUP” (which is unlikly to be what you want), while in KDE there is no distinct field for the domain as it expects MS-Windows like “DOMAIN\user” format, which users are likely not accustomed to. If you now type in your password and ask it to be saved, at best the file browser will open the share but not save the password and you will have to type it again the next time, while at worst – the browser will not be able to list the share and prompt you for the password again and again.

A useful way to workaround the issue is to have the “domain” part already in the “smb://” URL – that way the authentication process and the password keyring manager already knows the correct MS-Windows domain name to log in with and will either pre-fill it in the correct field.

GNOME and Nautilus

In GNOME (and using the GVFS command line tools – more about it later), the format of the URL is smb://domain;user@server/share, so for example if your domain name is “OFFICE” and your user is “oded”, and you want to access the share “Documents” on the server “files”, then the URL will be smb://OFFICE;oded@files/Documents:

The password saving feature will now work fine and you can even bookmark the location and if you save the password, then next time you can just click the bookmark to automatically connect to the share.

KDE and Dolphin

In KDE the format of the URL is smb://domain\user@server/share (similar to the user specification in MS-Windows), so using the same example above the URL will be smb://OFFICE\oded@files/Documents:

As you can see, the user name field is pre-filled with the MS-Windows user specification and you are left with only putting in the password. You can also note that Dolphin has “URL encoded” the back-slash character – don’t worry about it, it will work just fine and you can also bookmark this location and the “Remember password” will faithfully keep your password regardless if the URL is “URL encoded” or not.

The main problem with using Consolas on your Linux workstation, is that this font is provided by Microsoft, and while if you are running MS-Windows (or even Mac OS-X) it may already be installed – as it is bundled with many Microsoft products, us in the Linux world have no easy (and legal) way to get to use Consolas in our code editing. Unlike Microsoft Core Fonts for the Web Consolas is not available for download – probably for the same reason the core fonts packages were pulled. But as Consolas is bundled with many Microsoft products, some are available for free download for anyone, we can use that to get us some nifty Consolas prettiness in our day to day Linux computing.

The following steps will allow you to get Consolas on your system rather easily (assuming you don’t flinch at using a terminal) and without installing any Microsoft products. I’m pretty sure its also legal to do so, even when taking into account Microsoft’s EULA, and a discussion of this is at the end if you are interested. Well, into the fray!

Requirements

you need to have the following software packages installed. If you don’t already have them installed, they are available for all Linux operating system, probably using your built-in software management UI, such as Ubuntu’s Software Center or Fedora’s Software Management.

• Wine – the Microsoft Windows compatibility layer for Linux
• cabextract – a Microsoft cabinet file format extractor

Procedure

After you have these installed, lets start going to the Microsoft download center and downloading the latest edition of the freePowerPoint Viewer. In the page linked, click on “Download” and download the resulting file to somewhere on your computer. The default download location for Fedora is the “Downloads” directory and for Ubuntu it is the “Desktop” directory.

Next, let’s open a terminal window (“gnome-terminal” if you are running a GNOME desktop, or “konsole” if you are running a KDE desktop), and follow these steps:

• mkdir tmp – Create a temporary directory. The process involves creating a “wine prefix” and unpacking some files into it, and I wouldn’t want to mess up an existing wine setup if you have one.
• cd tmp – move to the new temporary directory.
• WINEPREFIX=$(pwd) wine ~/Downloads/PowerPointViewer.exe /extract:c:\\ – ask the PowerPoint Viewer, nicely, to extract its content to what Windows call “C:\” instead of installing it. Wine will setup a simulated “C: drive” inside your temporary directory and will then run the installer – you will have to read and agree to the PowerPoint Viewer EULA, but I don’t think you have anything to worry about (see the discussion below). For this command I’m assuming you’ve downloaded the PowerPoint Viewer executable to the “Downloads” directory. If this is not the case, you may change the command appropriately.
• cabextract drive_c/ppviewer.cab -F 'CONSOLA*' – The installer has put a “Microsoft Cabinet file” into the simulated “C: drive”, that contains the files we need, so here we extract the Consolas TTF files from the cabinet.
• rename 'y/A-Z/a-z/;s/consola/Consolas /;s/b/Bold/;s/i/Italic/;s/z/Bold Italic/;s/ \./ Regular./' *.TTF – Optional step – rename the extract files to something that a looks humanly readable. Unless you want to keep the TTF files for future use, you can skip this step.

Now you can install the new fonts – open a file browser and go to your temporary directory. Under GNOME you can install the fonts by opening the font file and the font viewer window should have an “Install Font” button at the bottom right corner. Under KDE, right click the font files and select Actions->Install… and in the dialog that opens select “Personal” to install the font only for you or “System” to install the font to all the users (this will require a system administrator password). After you complete this step for all the TTF files that were created, you can copy the files elsewhere if you want to save them as backup for when you want to reinstall your computer. Finally it is recommended to remove the temporary directory and all its content – you have no further need for this.

Legal Issues

I am not a lawyer and the following is not actually a legal argument, but lets try to look at the above procedure through the Microsoft EULA that you have to agree to in order to get the files:

It is my belief that this procedure is perfectly reasonable for personal use on any device you use – paragraph 1.a of the EULA says “You may install and use any number of copies of the software on your devices.” The rest of the paragraph immediately goes and limits the use of the software but I do no believe that its possible for a license to limit the type of use you do with a software you legally obtained (as long as that use itself is not infringing on the copyright on the software). Its like buying a car and have the manufacturer say that this car may not be used to drive on dirt roads – the manufacturer may refuse to service the car after you drive on dirt roads, but he cannot sue your for violating the “terms of use”.

Please note that after extracting the TTF files, you may not distribute the files, i.e. copy them to other people – this is strictly prohibited both under copyright law and under paragraph 1.b of the EULA, because it will not be “complete and unmodified” copies of the PowerPoint Viewer. You may, though, distribute copies of the original PowerPoint Viewer download to friends along with these instructions .

Regarding the legality of extracting files from the installer, the Microsoft EULA has this to say: “You may not work around any technical limitations in the software” – but we didn’t work around any technical limitations: the Microsoft software itself extracted the files for our use, so there is no technical limitation prevent us from copying files off the installer.

The PowerPoint cabinet also contains all the other fonts of the Microsoft ClearType font collection, of which only Calibri would be of any interest to users, the rest aren’t that interesting but then again – I hate serifs (interestingly all of the ClearType font collection fonts start with “C”).

Related articles

• Manage & Compare Fonts Easily With Font Manager [Linux] (makeuseof.com)
• Free TTF font site (xpjimt.wordpress.com)
• Get The New ICS Font Roboto On Your Android Device Right Now (androidpolice.com)

Locating the correct position in the binary log from which the server can carry on is difficult but can be made easier by the mysqlbinlog utility that can scan the binary log files and show you which position is valid using the --start-position to try random positions in the binary log file and see which position will let you read from the file.

Still, testing each and every possible byte position by hand is very time consuming, not to say very boring. The following small script will allocate the next readable position in the binary log, given a beginning position (that you can see in the MySQL slave status IO position).

start=1008443439
end=$(($start+20000))
binlog=mysql-bin.021468
for; do
  if mysqlbinlog -vv $binlog --start-position=$pos \
        --stop-position=$end > /dev/null 2>&1; then
    echo $pos
    break
  fi
done

[All numbers are made up, obviously - substitute your own]

This will echo the first position in the specified MySQL binary log, from which the log can be read correctly (assuming the corruption is smaller then 20K). You then can restart the slave after the corrupted part by issuing these commands to MySQL:

STOP SLAVE;
CHANGE MASTER TO MASTER_HOST='my-master', MASTER_USER='this-slave',
MASTER_PASSWORD='my-password', MASTER_LOG_FILE='mysql-bin.021468',
MASTER_LOG_POS=1008444916;
STOP SLAVE;

[Where 1008444916 is the position the script reported]

Important note: This is only relevant when it’s affordable to lose few transactions (you should pay attention to the distance between the last position of the IO thread and the position that this script find as usable). If you fear that there may be important data in the missing transactions – don’t use this method and do rebuild your database.

Related articles

• MySQL Replication Setup (sqldbpool.com)
• How To Set Up SSH Encrypted MySQL Replication (kozar.wordpress.com)
• R1Soft Discusses CDP Backup Software for MySQL Databases at 2011 MySQL Conference and Expo (prweb.com)
• Five Things You Need to Know About MySQL (pcworld.com)