You can find Kohana RPM for the current stable release 3.0.5 here, and the source RPM is available here in case you want to rebuild it yourself (and you might, details follow). New releases to correspond with new releases from Kohana will be updated there as needed.

This package is built on a CentOS 5.4 machine, with pretty much default settings.

Please note that Kohana is not tested with the PHP version 5.1.6 which is what RHEL/CentOS 5 uses by default, so there could be some problems with using it on such a default installation of the operating system. There was one place where Kohana uses a function in a way that is not supported on PHP 5.1.6, and I had to patch that with a workaround.

This package includes additional patches that I felt where necessary, some to work around Kohana issues and some to add functionality that I felt is missing or or lacking. If there is interest I can expand on the work there. I do intend to submit all patches upstream, of course – once I’m more familiar with the community process of Kohana.

In the mean time, you can try it out and let me know if it works for you or not.

Related articles by Zemanta

• Top 5 Free Linux Distributions for Servers in 2010 (taragana.com)

That being said, with a wallpaper collection, you want a software to manage it and cycle your desktop through the wallpapers. KDE has this function built it – just go to configure your wallpaper and select a directory of wallpapers, choose whether you want to cycle through the images sequentially or randomly, the delay and your done.

Not so in GNOME – simplicity for simplicity’s sake: I would have said that you get the same configurability as MS-Windows, but its not true – in GNOME’s “Background” configuration dialog, if you don’t use an image you can configure the background color to be a single color, a vertical or a horizontal color gradient (for the last two options you actually get to choose starting and ending color). MS-Windows users – eat your heart out! :-p

So what can a GNOME user do? There are a few 3rd party software that can tackle the task, at least one is even available in the repositories of most Linux distributions. Initially I tried wallpapoz which has a UI which is not really simplistic, and not really usable. Its written in Python and uses a weird client/server setup where the application UI is just a client that configures the server, and you have to run the server to actually get the functionality. Its not really comfortable to use under any circumstances and I also feel that its random selection could use some help (no reason for me to see the same wallpaper 3 times on the same day when you have more the a thousand images to choose from).

After I gave up on wallpapoz, I tried Desktop Drapes. Its has a much more modern UI and is written in GNOME’s “next-gen” programming framework: .net, and it even promises to monitor the wallpaper directory for me and automatically add new wallpapers that appear there. Unfortunately it can’t really take the load of so many wallpapers on its UI, and while it runs fine as long as I don’t open the configuration window, it doesn’t looks like it holds up on its promise to add new wallpapers without resorting to using the nice looking but very unresponsive user interface.

When Desktop Drapes stopped working for me recently, I decided to go all scripty like – GNOME is using GConf as its internal configuration system, and GConf is a MS-Windows registry like configuration directory with a few obvious advantages:

• It is rather small and simple in its layout and amount of stuff
• It is very user-centric – while there is a system GConf registry, each user loads its own registry and no registry database other then the currently logged in user is actually loaded in a session
• The backend storage for GConf is just a bunch of XML files, which is makes it easy to manage in case you need to (and you never need to)
• It has both a graphical editor which shows help for each configuration value and a command line tool which you can use to manipulate the registry
• And best of all – when you change a configuration value, it immediately takes effect!

A quick search in gconf-editor (the graphical GConf interface) brings up the following key:

/desktop/gnome/background/picture_filename

and changing it using

gconftool-2 -s /desktop/gnome/background/picture_filename string <path -to-image>

immediately applies the new desktop background.

To get our wallpapers to rotate automatically, all one needs to do is figure out a way to call gconftool-2 from cron, passing it a random wallpaper every time.

Bash to the rescue! Bash has a useful random number generator – just use $RANDOM for a 15 bit random number. For my purposes I think that 15 bit is a bit low (considering the number of wallpapers I have), so I use $RANDOM * $RANDOM for a bit more entropy. A quick hack and we end up with something like this:


WALLPAPERS_DIR=$HOME/Documents/Images/wallpapers
gconftool-2 -s /desktop/gnome/background/picture_filename -t string "$WALLPAPERS_DIR/$(ls $WALLPAPERS_DIR | head -n $(( $RANDOM * $RANDOM % $(cd $WALLPAPERS_DIR; ls | wc -l) + 1 )) | tail -1)"


Now to stick this into cron using crontab -e and you have “a poor man’s wallpaper manager”

A simple explanation of what is going on here – the heart of this one-liner is the $(( ... )) block which figures out a random number that corresponds to a file in the wallpapers directory – its basically RANDOM_VALUE modulo COUNT_WALLPAPERS + 1. the rest is just listing the wallpaper files and using head and tail to cut out just the file that I wanted.

A lot of unix configuration files use the # sign to add comments to configuration files, and a lot of software comes with very well documented files – i.e. has lots of comments. So much that if you just want a quick glimpse at the configuration that is active (not commented out) its very difficult to wade through all the documentation.

Here’s a simple grep that will filter out all the junk and leave you with just the active configuration settings:

egrep -v '^(#|\s*$)' <config file>

and on the standard output you’d get only lines that are not commented out or empty.

Do note that some configuration files can also use ; as a comment character, but modifying the grep to support this is trivial.

But if you know that you have this class on your system somewhere, and you are just not sure which jar file you need to add to your project for it to compile – this script will come in handy:

The script below generates a list of jar files, then look for the specified pattern (using grep) in each jar file’s directory and prints each jar file that contains a class to match the pattern. The script has two modes of operation – the default mode uses the operating system’s locate implementation to look for all jar files in the file system – this is very fast, but the list may not be up to date and contain files that were deleted and/or missing new files that were recently added. The second mode, triggered by the ‘-j‘ command line option uses find to get the list of all jar files under the system’s Java libraries directory (/usr/share/java) – while this works directly on the file system, it is also relatively fast because we limit the search to a rather small directory tree and doesn’t suffer from locate‘s dependency on a database which may not be up to date.

The script:

#!/bin/sh

ONLY_JAVA_DIR=

function getJars() {
    if [ -n "$ONLY_JAVA_DIR" ]; then
        find /usr/share/java/ -name '*.jar' | egrep '[^]0-9]\.jar$'
    else
        locate 'jar' | egrep '[^]0-9]\.jar$'
    fi
}

class=

while [ -n "$1" ]; do
    case "$1" in
        -j)
            ONLY_JAVA_DIR="yes"
            ;;
        *)
            class="$1"
            ;;
    esac
    shift
done

export IFS="
"

for file in $(getJars); do
    [ -f "$file" ] && (unzip -l "$file" 2>/dev/null | grep -q $class) && echo $file;
done

I often just write this script down as a one liner (it is simple as replacing getJars with a wildcard match of your choice and packing the for loop into a single line), but when using the locate mode, its common to encounter directories and files with spaces in their name and this usually causes bash to break horribly – the default record separator which is used by the for command matches spaces and breaks a single file path with spaces inside into two or more different paths. To fix this we change the value of IFS (the bash record separator definition) locally to only include new lines (hence the weird assignment) and we make sure that getJars() generates a list of files where each file path is on a line by its own.

This script is useful if you have a log for which you want to analyze load over time – transactions per second or whatnot (the version below does this for Apache httpd logs, but it can be easily modified to analyze anything). For apache (and most other HTTP servers) there are many readily available log analysis software packages that do a much better job then what one can do in a simple script, but you might not have such software pre-configured or it can’t filter what you need or you just want to analyze something else – in which case this script will come in handy.

The script receives time stamped log events – each event on a line – and collects the temporal information for each line. Then it will dump a simple vertical graph (i.e. time is on the Y axis) of load over time in the resolution that you want. Its output looks something like this:

Oct 30 14:40:00 2007 |#############                                    | 3.8 x/sec
Oct 30 14:50:00 2007 |##########################################       | 6.3 x/sec
Oct 30 15:00:00 2007 |###########################################      | 6.5 x/sec
Oct 30 15:10:00 2007 |#############################################    | 6.6 x/sec
Oct 30 15:20:00 2007 |###############################                  | 5.4 x/sec

(The output is obviously formated for terminals with monospaced fonts, so it won’t look as good here).

As you can see the script will dump summary lines for each time unit (as per the required resolution) with a bar depicting the number of requests and a value noting the number of requests per second (or whatever you want – it is easy to modify).

Running it is very simple – the script accepts log lines from standard input and you normally want to feed it the output of some filter, so for example – lets say I want to check the request load on some Apache httpd server resource accessible under /some/resource, with a 10 minute resolution – so I will run:

grep '/some/resource' /var/log/httpd/access_log | ./graphlog.pl 600

This uses grep to filter the Apache access log and will output only log events that access /some/resource into the graphing script (called graphlog.pl here). The graphing script was instructed to collect log events into batches of 10 minutes (600 seconds) for display. The result looks like what you see above.

Anyway, here’s the script: – with a lot of comments to better let you know what’s going on. Its written in perl and uses the ‘-l‘ switch to instruct perl to add a new line after each print command – this saves me a tiny bit of work as I only print the graph, with one command per line.

#!/usr/bin/perl -l

# some "safety" features for perl which I recommend to always use - it tells the perl
# compiler to fail the compiling on common errors such as typos in variable names
use strict 'refs';

# I'm using these two time formatting procedures from the POSIX support package
use POSIX qw(mktime ctime);

# we're parsing log lines like this:
# 90.149.88.157 - - [07/Nov/2007:14:00:16 +0200] "GET /some/resource HTTP/1.1" 200 4936 "-" "Mozilla/5.0 (bla bla bla)"
# I'm not filtering it - that is the job of something on the outside

# helper list of known month abbreviations so I can understand english formatted dates
my %months = ( 'Jan' => 0, 'Feb' => 1, 'Mar' => 2, 'Apr' => 3, 'May' => 4, 'Jun' => 5, 'Jul' => 6, 'Aug' => 7, 'Sep' => 8, 'Oct' => 9, 'Nov' => 10, 'Dec' => 11 );

# the method that converts formatted time stamps to useful UNIX time stamps
sub dateToTime($) {
    my ($date) = @_;

    # clean up the input to only leave the date and time in the required formatting, dropping everything
    # before the timestamp
    $date =~ s,^[^\d:/]+,,g;
    # and after the time stamp
    $date =~ s,[^\w\d:/]+.*,,g;
    # sanity check - if the date isn't parseable return an undefined value
    return undef unless $date =~ m|(\d{1,2})/(\w{3})/(\d{4}):(\d{2}):(\d{2}):(\d{2})|;
    # use mktime() to convert the time fields to a unix time stamp
    return mktime($6, $5, $4, $1, $months{$2}, ($3 - 1900));
}

# read the required resolution in seconds from the command line
my $res = shift @ARGV;
# initialize some local variables
my (%counters, $max);

# parse each line from stdin
while (<>) {
    # the above is perl magic for "read one line from standard input each iteration of the loop"
    # figure out the log event's time stamp
    m|\[(\d+[^\]]+\d+)\]| and my $time = dateToTime($1);
    # count the log event
    $cur = ++$counters{int($time / $res)};
    # check if the new counter value is the current largest counter value -
    # this is used for normalizing the graph
    $max = $cur if $max < $cur;
}

# normalize on width 80 (just because, change it to whatever is good for your terminal)
my $unit = $max / 80;

# go over each counter, in progressive temporal order and graph the value
foreach my $time (sort { $a < => $b } keys %counters) {
    chomp(my $strtime = ctime($time * $res)); # format the time for display
    my $size = ($counters{$time}/$unit); # figure out the bar size for this event
    # print the bar size with a "something per second" value
    print  "$strtime |" . ("#" x $size) . (" " x (80 - $size)) . "| " . (int($counters{$time}/$res*10)/10) . " x/sec";
}

Today we have a script that will help you pick out a nice thumbnail for a movie file – this is useful when setting up movie galleries and stuff. Of course it can be done automatically (most gallery software that support video files has automatic thumbnail extraction) but they rarely choose the best shot. The script here below would extract 100 frames from the first 30 seconds of a movie file and display them using an image browser. The script would also open a file browser window – the user will then pick the desired thumbnail image and drop it into the file browser, and then close the image browser. The script would then complete the process by naming the selected thumbnail image to be the same name as the original movie (with a different extension of course).

Requirements:

• ffmpeg – for frame extraction
• Image Magick’s convert – for thumbnail post processing
• gthumb – as the image browser
• nautilus – as the file browser

This script was written to run on my GNOME desktop, so its a bit GNOME centric, but gthumb and nautilus can be easily swapped for gwenview and dolphin, so no worries there. mencoder can possibly be used instead of ffmpeg, but I don’t know the command line for that. Image Magick is of course indispensible. The script below generates PNG thumbnails, but generating other formats – for example JPEG simply requires changing every instance of “png” to “jpg”.

Running the script is simple – supposedly its called “findthumbnail”, so I run it by providing on the command line all the video files I wish to execute it on, for example if I want to generate thumbnails for all my flv (Flash Video) files, then I’ll run

findthumbnail *.flv

The script would run on each file separately and would skip files for which there’s already an existing thumbnail. Currently the main problem is that post-processing the frames into thumbnails takes a long time (maybe 30 seconds on a fast computer) all the time the user has no feedback and is just siting there twiddling thumbs.

Anyway, here’s the code:

#!/bin/sh


while [ -n "$1" ]; do
    vid="$1"
    shift

    if ! [ -f "$vid" ]; then
        echo "File not found: $1" >&2
        continue
    fi

    vidname="$(echo $vid | sed -e 's/\.[^\.]*$//')"
    if [ -f "${vidname}.png" ]; then
        echo "File $vid already has a thumbnail"
        continue
    fi

    if [ -z "$browser" ]; then
        nautilus -n .
        browser=yes
    fi

    mkdir -p $HOME/.local/tmp/thumbs.$$
    ffmpeg -i "$vid" -r 3 -vframes 100  -y $HOME/.local/tmp/thumbs.$$/vid_frame_%03d.png
    (
        cd $HOME/.local/tmp/thumbs.$$
        for file in *.png; do
            convert "$file" -resize x300 -gravity center -crop 400x300+0+0 +repage thumb_"$file"
        done
        rm vid_frame*.png -f
    )

    gthumb $HOME/.local/tmp/thumbs.$$
    rm -rf $HOME/.local/tmp/thumbs.$$

    mv thumb_vid_frame_*.png "${vidname}.png"
done

See ? pretty simple.

Installation is simple creating a text file somewhere and putting that code into it. Its pretty white space insensitive, except for the first line – in order for the kernel to be able to run it there mustn’t be any white space before the first character. I usually put such scripts under ~/.local/bin which is in my local execution path, so this script would go into ~/.local/bin/findthumbnail. After you create the file, you just need to give it execute permissions – your favorite file browser should have this option in the file properties dialog, but from the command line you’d do something like

chmod a+x ~/.local/bin/findthumbnail


A simple explanation of the various stages is in order, I think: we loop as long as we have some value from the command line – and for each loop we get the (current) first parameter from the command line and remove it. We then check if the file exists – if not we log an error and check the next parameter. If there is a file by that name, we strip the extension from the filename and check if there is already a thumbnail for that movie – that way we can rerun the script on a directory and it will only generate thumbnails that are missing. If there isn’t an old thumbnail we can go on to create a temporary directory, extract some frames from the video file into said temp directory (using ffmpeg), create thumbnails from the frames (using convert) and remove the used frames. Lastly we launch the image browser and wait for it to be closed by the user. when the image browser is done we clean up the temporary directory and if the user has chosen a thumbnail then we make sure its named like the original file.

I skipped the part about opening the file browser because this is slightly more complicated – I want to open only one file browser, regardless how many video files I’m processing, but I don’t want to open the browser if I’m not going to process any files. So I only open the file browser after I decide that I am going to do some work, and then I use a variable to flag that I already opened the file browser so I don’t need to do it again.

Thats it. Have fun.

המצרכים:

• מחשב מודרני עם תמיכה בהאצת וירטואליזציה בחומרה. בלי מעבד עם האצת חומרה, אפשר להריץ את חלונות רק בעזרת סימולטור וזה מאוד מאוד איטי (לא טוב לבריאות הנפש). מעבדים העונים לדרישות הן מעבדי אינטל מסדרת Core 2 או מעבדים של AMD מסדרת Athlon64 FX ומעלה.
• מערכת הפעלה לינוקס עם קרנל 2.6.20 ומעלה, לדוגמה פדורה 7 או אובונטו 7.04
• חבילות התוכנה המתאימות – דרך מנהל התוכנה של מערכת ההפעלה יש לבקש להתקין את חבילת kvm.
• תקליטור של חלונות XP (רצוי גרסת Professional) ומספר רשיון חוקי ותקף. אם המחשב שעליו הולכת להיות מותקנת המערכת מכיל כבר התקנה של חלונות (או הכיל בעבר ואותו רשיון לא נצא בשימוש באף מערכת אחרת כרגע) אז אפשר להשתמש באותו קוד רשיון, אחרת יש לרכוש רשיון חדש – עותק של Microsoft Window XP Professional OEM באנגלית ניתן לרכוש החל מ-640 ש”ח

התקנה

הגדרה והתקנה של המכונה הוירטואלית נעשית כולה בפקודות טקסט בטרמינל – כיום עוד אין ממשק תצורה גרפי שתומך בצורה טובה בבנית מכונות וירטואליות של KVM. אי לכך ובהתאם לזאת, נא להפעיל תוכנת טרמינל, בהתאם למערכת ההפעלה שלכם וסביבת העבודה הגרפית. ב-GNOME כדאי להפעיל את gnome-terminal שנמצא בד”כ תחת Applications->Accessories בשם Terminal, או תחת Applications->System Tools. ב-KDE כדאי להפעיל את konsole שנמצא בד”כ תחת System->Terminal. את כל שאר הפקודות יש להקיש בטרמינל אלא אם נאמר במפורש אחרת.

לפני שנתחיל בהתקנה, יש להוריד כמה תסריטים שכתבתי, שיעזרו בהפעלת ה-KVM, ולהתקין אותם למערכת ההפעלה. מכיוון שחלקים שונים מהתהליך דורשים הרשאות מנהל מערכת, התסריט דורש הרשאות root ואוכף את זה בעזרת פקודת sudo שמופעלת באופן אוטומטי כשהתסריט מופעל שלא עם הרשאות מתאימות. כתוצאה מכך, וכדי להקל את ההפעלה של המכונות הוירטואליות על ידי משתמשים שונים, אני ממליץ להוריד את הקבצים הנ”ל ולהתקין אותם בתיקיית /usr/local/bin, אבל אפשר להתקין אותם בכל תיקייה כרצונכם. בנוסף צריך להגדיר למשתמשים המעוניינים להפעיל מכונות וירטואליות הרשאות sudo ל-kvm-start, או לאפשר להם להריץ את התוכנה כ-root בצורה אחרת.
יש להוריד את שני הקבצים kvm-start ו-kvm-network-setup ולשמור אותם על בתיקייה כפי שתואר. לאחר מכן יש להפעיל כ-root (או בעזרת sudo) את הפקודות הבאות על מנת לאפשר להריץ את התסריטים:

chmod 755 /usr/local/bin/kvm-start /usr/local/bin/kvm-network-setup

(ציינתי את התיקייה /usr/local/bin כפי שהסברתי למעלה, במקרה ולא שם נשמרו הקבצים, יש לשנות את הנתיב בהתאם)

ניגש להתקנה:

1. דבר ראשון יש לייצר את דמות הכונן הקשיח שלתוכה נתקין את מערכת ההפעלה – אין אפשרות בשלב זה להשתמש ב-KVM עם מחיצה אמיתית ולכן צריך ליצור קובץ על הכונן הקשיח הרגיל שבתוכו תתבצע סימולציה של כונן קשיח. יש לכך גם יתרונות רבים: שימוש בכונן וירטואלי מונע שגיאות שיכולות לגרום למחיקה של מערכת ההפעלה האמיתית, מאפשר לשכפל ולשמור גיבוי של מערכת ההפעלה ועוד כמה דברים יותר מורכבים (אולי אגע בהם בהמשך). הפקודה שצריך להקיש היא:
   
qemu-img create windows.img -f qcow2 6G

   על מנת ליצור כונן וירטואלי בגודל של 6GB. אפשר כמובן ליצור כונן בכל גודל שיכול להתאים לכמות המקום הפנוי בכונן הקשיח האמיתי, אבל יש לזכור שהתקנה של חלונות XP כולל עדכונים לוקחת כ-3.5GB בעצמה בלי שום דבר אחר. עם אנטי וירוס ועדכון דפדפן (ל-Firefox או Internet Explorer 7, או שניהם) אנחנו כבר ב-4GB. בכל מקרה, הקובץ שנוצר לא מייד תופס את כל המקום שציינו – הפורמט של הכונן הוירטואלי שבחרנו – qcow – לוקח שטח מהכונן האמיתי רק לפי השטח שבאמת מנוצל בכונן המדומה, ולכן הקובץ מתחיל מאוד קטן וגדל לפי מה ששומרים בתוכו. למרות זאת מומלץ מאוד לא לעשות “over booking” של הכונן המדומה ולא לבקש יותר גודל מכמות המקום הפנוי בכונן האמיתי מכיוון שזה יכול ליצור תקלות מוזרות במערכת ההפעלה הוירטואלית.
2. השלב הבא הוא להשיג תקליטור של חלונות ולדאוג שה-KVM יוכל לקרוא אותו. אם יש לנו תקליטור אמיתי אז כמובן שיש לשים אותו בכונן, אבל אם ברשותנו קובץ ISO של חלונות אז אין צורך לצרוב אותו – KVM יוכל לקרוא את קובץ ה-ISO ישירות כאילו הוא תקליטור אמיתי.
3. עכשיו אפשר לגשת להפעלה של המכונה הוירטואלית, ולהחל בהתקנה של חלונות. אם ברשותנו תקליטור אמיתי, יש להפעיל:
   
kvm-start windows.img --windows --cdrom

   לעומת זאת, אם נעדיף להתקין מקובץ ISO (לדוגמה כי אין במחשב כונן תקליטורים אמיתי), אז צריך להפעיל:
   
kvm-start windows.img --windows --cd-image ms-windows-xp.iso

   (כמובן שיש להחליף את ms-windows-xp.iso בשם הקובץ האמיתי(

   הציון של --windows מטרתו להכריח את חלונות להיות מותקן בלי תמיכה ב-ACPI, שאחרת המערכת לא תותקן כמו שצריך ותסרב לרוץ. לאחר ההתקנה אין צורך להוסיף את האפשרות הזאת במהלך הפעלה רגילה.

4. עכשיו צריך להופיע חלון ובו נטען התקליטור של חלונות. בשביל להתחיל את ההתקנה, יש ללחוץ על איזשהוא מקש תוך חמש שניות מרגע שהתקליטור נטען – תופיע על כך הודעה בחלון, ולאחר מכן ממשיכים עם התקנה רגילה של חלונות.
5. כשההתקנה מסתיימת חלונות יאתחל את המחשב הוירטואלי. יתכן והמחשב יצליח לעשות אתחול מסודר, ויתכן שהוא פשוט יכבה – במקרה שהחלון פשוט נעלם, בשורות הפקודה יש לחזור על הפקודה הקודמת ולהריץ אותה שוב כדי להשלים את השלב השני של ההתקנה.
6. בתום השלב השני, חלונות ינסה לכבות את המחשב שוב. הפעם יש לוודא שהמחשב הוירטואלי אכן נכבה והחלון נעלם – אם הוא ממשיך באתחול רגיל, פשוט יש לסגור את החלון כמו חלון של ישום רגיל. עכשיו אפשר להפעיל את המערכת הוירטואלית בלי התקליטור, בצורה הזאת:
   
kvm-start windows.img

   והמערכת תופעל מהתחלה בצורה רגילה.
7. עכשיו אפשר להגדיר את חיבור הרשת. אנחנו הולכים להשתמש בהגדרות סטאטיות בשביל הרשת הוירטואלית – ככה היה לי קל יותר לכתוב את התסריטים:
   יש לגשת לחיבורי הרשת (אני בד”כ לוחץ כפתור ימני על “Network Places” ובוחר “Properties”) ולהכנס לדיאלוג ה-TCP/IP properties של חיבור הרשת. שם יש להגדיר את כתובת ה-IP כ-192.168.100.2, את הרשת כ-255.255.255.0 ואת ה-gateway כ-192.168.100.1. בנוסף יש להגדיר את שרתי השמות לפי מה שמוגדר במחשב המארח. אני בד”כ כותב 194.90.1.5 (שרת השמות של נטוויז’ן. אני כדי משוכנע שלא אכפת להם, למרות שאני לא לקוח). לאשר ולסגור את הדיאלוג. הרשת צריכה לעבוד עכשיו ואפשר לבדוק זאת על ידי הפעלת הדפדפן (Internet Explorer בלבד, לצערי). ההגדרות הנ”ל קבועות בתסריט הגדרות הרשת (kvm-network-setup ואפשר לשנות אותן ידנית אבל עוד אין אפשרות להגדיר את זה באופן נוח.
8. מומלץ בשלב זה להפעיל את Windows Update ולהתקין את כל עדכוני האבטחה. דבר זה ידרוש אתחול המערכת מספר פעמים נוספות אבל לא יגזול יותר משעתיים שלוש על מחשב מודרני עם חיבור מהיר לאינטרנט

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

יש אפשרות לשפר את המצב על ידי שימוש ב-VNC, שהוא פרוטוקול תקשורת המאפשר העברה של תצוגה גרפית מלאה על גבי הרשת – בדומה ל-Remote Desktop של חלונות. כשמפעילים את מצב ה-VNC של KVM, לא מופיע חלון רגיל כשמפעילים את המכונה הוירטואלית, אלא במקום זאת מופעל שרת VNC מקומי, בלי תצוגה, שאפשר להתחבר אליו בעזרת תוכנת לקוח של VNC (שמגיעה עם כל מערכת הפעלה מודרנית היום), לדוגמה vncviewer או krdc (אני ממליץ על האחרון). כדי להפעיל את KVM במצב VNC יש להריץ:

kvm-start windows.img --vnc

אחרי שמערכת ההפעלה עולה אפשר להתחבר לתצוגה, לדוגמה על ידי krdc על ידי הרצה – משורת הפקודה או בעזרת דיאלוג “הפעל” הרגיל של שולחן העבודה – של הפקודה krdc :1.

תוכנת הלקוח של VNC תופסת את העכבר באופן אוטומטי כשהוא נכנס לחלון של התצוגה ומשחררת את העכבר כשמושכים אותו מחוץ לחלון. הבעיה היחידה היא שאין סנכרון טוב בין הסמן של העכבר בתוך המכונה הוירטואלית לבין הסמן הפנימי של תוכנת ה-VNC (מסיבות טכניות שאין טעם להכנס אליהן כרגע). כדי לפתור זאת צריך להכנס ל-Control Panel בחלונות, ולמצוא את הגדרות העכבר, ושם תחת Pointer Options לכבות את “Enhance pointer precision” ולכוון את “Pointer Speed” כך שיהיה בדיוק באמצע. עכשיו לאשר ולסגור.התוצאה צריכה להיות שהסמן של העכבר במערכת ההפעלה הוירטואלית וב-VNC נעים באותה מהירות אבל כנראה לא ממש אחד על השני – צריך לאפס אותם על ידי שמביאים את הסמן של העכבר במערכת ההפעלה לאחת הפינות, יוצאים מהחלון וחוזרים.

חשוב מאוד

במצב VNC, סגירת החלון של תוכנת ה-VNC לא מכבה את המחשב הוירטואלי – אפילו אם החלונות עשה shutdown והגיע למסך של “You may now turn off your computer”, ה-KVM עדיין רץ. אם הרצנו אותו משורת הפקודה אז אפשר לחזור לטרמינל ולהקיש CTRL ו-C ביחד כדי ל”שבור” את ה-KVM, אחרת צריך למצוא את ה-kvm ברשימת התהליכים ולהרוג אותו משם (ברשימת התהליכים יופיע גם kvm-start – יש להזהר לא להרוג אותו אלא רק את התהליך הראשי של ה-KVM. לאחר שהתהליך הראשי יכבה, kvm-start צריך לנקות אחריו, ולאחר מכן הוא יסגר לבד).

זהו לבינתיים. ל-kvm-start יש הרבה אפשרויות נוספות להריץ את ה-KVM, ואפשר להפעיל kvm-start --help בשביל לקבל רשימה מלאה. אם יש למישהו בעיות להפעיל את המערכת הוא מוזמן לפנות אלי, כמו כן אשמח לקבל הצעות ושיפורים לתסריטים.

בהצלחה.

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

האמת – ניסיתי לחפש משהו אחר: אתר אינטרנט על ספרים, שאינו חנות ספרים מקוונת או אתר השוואת מחירים או חיפוש ספרים לקניה (isdn.nu הוא דוגמה לשתי הקטגוריות האחרונות), והדבר היחיד שמצאתי הוא Book Crossing שבצורה מצערת מאוד אין בו דרך טובה או נוחה למצוא ספרים עם כותרת מסויימת או אפילו של מחבר מסוים (לדוגמא, החיפוש The Hobit לוקח המון זמן והתוצאה היא שתי כניסות שלכל אחת מהן איות שונה. נסו עכשיו ללחוץ על שם הסופר באחת הכניסות – התוצאה: 0 ספרים. מאוד מוזר.

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

אולי אני צריך להרים את הכפפה?