First thing you will need is a computer/server with 2+ drives (that you don’t mind loosing the data on), the Raid mirror will end up being the smallest of the two. You may use/mix advanced format 4KB drives, but I’ll get to that later.

A note before you begin, initialising a new array will take along time (6 hours for a 2TB array of 2 drives, minimum), so plan to leave your server alone while it does that.

Firstly install mdadm

sudo aptitude install mdadm

You will then be able to cat /proc/mdstat to verify its working

Next up is to find and prepare your drives. You can use ls /dev/sd* or lsblk to get the list of current drives. In my case this was /dev/sdb and /dev/sdc.

Partitioning

mdadm uses partitions of type ‘Linux RAID Autodetect’ to build array from, so we now need to create these partitions on our drives. For examples sake we’ll use fdisk here.

sudo fdisk /dev/sdb

If you have any existing partitions (use p to list) clear them with o.

Then create the new partition with n, use the defaults to create the maximum size.

Set the type with t and set it to ‘fd’ which is ‘Linux RAID Autodetect’ (formatting the new partition is not neccessary at this point).

Finally use w to write the changes to disk and q to exit.

Rinse and repeat for the other drive.

Advanced Format: You can spot advanced format drives by printing the list of partitions a checking the physical sector size, Eg. an AF drive:
Sector size (logical/physical): 512 bytes / 4096 bytes
And a non-AF drive:
Sector size (logical/physical): 512 bytes / 512 bytes
In the above case fdisk will warn you about the logical sector size not matching the physical size when you run it, but fear not, its fine.

Creating

If you are mixing AF drives and non-AF drives put the AF drives first in the list when creating the array, this will cause mdadm to use 4KB sector sizes rather than 512B, in my setup /dev/sdc is the AF drive.

Create the array with

sudo mdadm --create /dev/md0 --level=1 --raid-disks=2 /dev/sdc /dev/sdb

You may name it something other than md0, although it is good practice to use mdX where X is a number.

Doing a cat /proc/mdstat will show something like

Personalities : [linear] [multipath] [raid0] [raid1] [raid6] [raid5] [raid4] [raid10]
md0 : active raid1 sdb1[1] sdc1[0]
      1953512400 blocks super 1.2 [2/2] [UU]
      [>.............] resync = 0.1% (65245/1953512400) finish=612.2min speed=65748K/sec

unused devices: <none>

Now’s the best time to leave it overnight to finish setting it up. Since I did notice the speed drop to almost nothing when mounted. You may format the drive now (to check that it doesn’t throw any warnings, see the next section).

[...Some time later...]

Personalities : [linear] [multipath] [raid0] [raid1] [raid6] [raid5] [raid4] [raid10]
md0 : active raid1 sdb1[1] sdc1[0]
      1953512400 blocks super 1.2 [2/2] [UU]

unused devices: <none>

Done and ready to use

Formatting and using

We’ll use ext4 here, but feel free to use your favourite.

sudo mkfs.ext4 /dev/md0

That should give no warnings, however if it does complain about the offset you could try and stop the array (mdadm --stop /dev/md0) and create the partitions again but set the display to sectors (with u twice) and create the partitions with the first sector being 2048.

Now for mounting, add the following line to /etc/fstab and create the directory /mnt/data (or use any other location)

/dev/md0  /mnt/data  ext4  errors=remount-ro  0  2

And mount

mount /mnt/data

Done.

Double-check with df -h

Filesystem            Size  Used Avail Use% Mounted on
/dev/mapper/root      228G  6.7G  210G   4% /
udev                  868M  8.0K  868M   1% /dev
tmpfs                 351M  1.2M  350M   1% /run
none                  5.0M     0  5.0M   0% /run/lock
none                  877M     0  877M   0% /run/shm
/dev/sda1             228M   67M  149M  32% /boot
/dev/md0              1.8T  319G  1.4T  19% /mnt/data

I hope this helps, but let me know if you ran into any problems and if you got around it so I can update this for the next person going Raid.

Some of my favourites:

Heisenbug
It is an error, which disappears or alters when it is attempted to be identified by analogy to Heisenberg uncertainty principle in quantum physics.

Reality 101 failure
The program (or more likely feature of a program) does exactly what was asked for, but when it’s deployed it turns out that the problem was misunderstood and the program is basically useless.

Protoduction
This is a prototype that ends up in production.

Megamoth
MEGA MOnolithic meTHod. Usually, it stretches over two screens in height and often contained inside aGod Object (an object that knows or does too much). Megamoths of greater size than 2k LOC have been sighted. Beware of the megamoth!

http://www.xnet.tk/CreateRule.php

Example:
Old Url: http://www.xnet.tk/index.php?page=123&something=else
New Url: http://www.xnet.tk/htaccess/rules/

The generated rule would be:

RewriteCond %{QUERY_STRING} ^page=123&something=else$
RewriteRule .*  htaccess/rules/? [R=301,L]

It can’t handle crossing domains (yet).

One thing that normally breaks gzip compression is something printing/echoing before the ob_start (usually the result of an error, debug output, errant space somewhere etc…), this is where the ob_get_length and ob_flush come in.

The problem is that headers_sent is not a reliable way to tell if any thing has been output because it may still be in the output buffer, so if we flush it before hand problem solved.

<?php

function doPage()
{
   echo 'Hello World';
}

if (ob_get_length() > 0)
   @ob_flush();

if (!headers_sent() && @ob_start("ob_gzhandler"))
{
   doPage();
   ob_end_flush();
   //Probably a good idea to exit here as more output would break it
   exit;
}
else
{
   doPage();
}

Playing around with opacity which seems to work well

The typical way to-do this with lighttpd is to set the error-handler to your script.

$HTTP["host"] == "my.com" {
    server.document-root = "/var/www/my.com"
    server.error-handler-404 = "/index.php"
}

We use an error-handler here rather than rewriting the url as with apache because there’s no way to detect if the url is actually a file (ie. your css/js files).

Problem here is that this will break query strings for anything other than the root url (query strings are what’s after the ?). ie. when accessing /post/123/postname/?confirm=true the confirm will not appear in the $_GET or $_REQUEST arrays while /?confirm=true will.

So how do we fix this? The method I’ve used is to manually parse the query string and put its values into the get and request arrays, as below.

function fix_query_string()
{
    $url = "http://".$_SERVER['HTTP_HOST'].$_SERVER['REQUEST_URI'];
    $query = parse_url($url,PHP_URL_QUERY);
    if ($query == False || empty($query))
        return;
    $_SERVER['QUERY_STRING'] = $query;
    parse_str($query,$query);
    foreach($query as $key=>$value)
    {
        $_GET[$key] = $_REQUEST[$key] = $value;
    }
}
if (stripos($_SERVER['SERVER_SOFTWARE'], 'lighttpd') !== false)
    fix_query_string();

Hope this helps!

Looking around the ‘net I settled on rendering the control to a bitmap and then drawing the bitmap to the screen (fast operation), which is called double buffering.

For example.

//In the OnPaint function or every time you redraw the control
Bitmap offscreenBitMap = new Bitmap(this.Width, this.Height);
Graphics offscreenGraphics = Graphics.FromImage(offscreenBitMap);
g.Clear(this.BackColor);

//Drawing code with offscreenGraphics

offscreenGraphics.Dispose();

//Draw bitmap to screen
Graphics clientDC = this.CreateGraphics();
clientDC.DrawImage(offscreenBitMap , 0, 0);

The above should be sufficient for most people, but read on if you redraw the control many times a second.

While this solved the flickering problem another problem promptly appeared (don’t they always).

Because the control was being redrawn about 10-15 times a second, it was causing the application to “stutter”, as in not respond for the milliseconds when the control was being drawn (i.e. dragging the window around wouldn’t be smooth).

So putting the render code in its own thread seemed like a good idea. Problem now is how to synchronise/communicate the need to re-render the control when needed.

My solution was to use an object lock and Monitor.

Method of operation

1. Application thread locks object
2. Render thread attempts to lock object (waits for application thread to release object)
3. When redraw is needed, release object
4. Render thread acquires object lock
5. Control is drawn to bitmap
6. Render thread releases object
7. Application thread is invoked to post the redraw
8. Goto 1

One thing to note is that this threaded model shouldn’t be used in design mode, as it may cause Visual Studio to hang.

Another is that calls to redraw the control should be ignored if its already rendering from another call.

Download [Project] [Code File]

[..using..]
using System.Threading;

public partial class ThreadedRendererControl : Control
{
    Thread renderThread;
    object renderControl = new object();
    private bool currentlyDrawing = false;
    private object dataLock = new object();

    public ThreadedRendererControl()
    {
        InitializeComponent();

        Monitor.Enter(renderControl);

        if (!DesignMode) //No point threading in design mode (in IDE)
        {
            renderThread = new Thread(new ThreadStart(Renderer));
            Disposed += new EventHandler(ThreadedRendererControl_Disposed);
        }
        Resize += new EventHandler(this.ThreadedRendererControl_Resize);
    }

    void ThreadedRendererControl_Disposed(object sender, EventArgs e)
    {
        renderThread.Abort();
    }
    public void UpdateData()
    {
        lock (dataLock)
        {
            //Update any data here that is used by the renderer
        }
    }
    public void Redraw()
    {
        if (DesignMode)//Just draw component in design mode
        {
            this.Invalidate(); //this will call OnPaint
            return;
        }
        //Only start the render thread on the first redraw
        if (renderThread.ThreadState == ThreadState.Unstarted)
            renderThread.Start();
        //Prevent multiple attempts to draw before current request has finished
        lock (dataLock)
        {
            if (currentlyDrawing == false)
                currentlyDrawing = true;
            else
                return;
        }
        //Allow the render thread to aquire the lock
        Monitor.Exit(renderControl);
    }
    private void Renderer()
    {
        while (true)
        {
            Bitmap bmp;
            Monitor.Enter(renderControl);
            lock (dataLock) //prevent data from being changed during rendering
            {
                bmp = Draw();
            }
            //Release lock
            Monitor.Exit(renderControl);

            //If the form is currently loading (not yet displayed)
            //posting the redraw will crash the app, as there's nothing to draw to
            if (IsHandleCreated)
                //Synchronously invoke the PostRedraw, this will also lock the renderControl object
                this.Invoke(new Action(PostRedraw), new object[] { bmp });
            else
                Thread.Sleep(10); //Wait, and loop again
        }
    }
    private void PostRedraw(Bitmap bmp)
    {
        Monitor.Enter(renderControl);
        lock (dataLock) currentlyDrawing = false;
        //Draw the bitmap
        Graphics clientDC = this.CreateGraphics();
        clientDC.DrawImage(bmp, 0, 0);
    }
    private Bitmap Draw()
    {
        Bitmap offscreenBitMap = new Bitmap(this.Width, this.Height);
        Graphics offscreenGraphics = Graphics.FromImage(offscreenBitMap);
        offscreenGraphics.Clear(this.BackColor);

        Font labelFont = this.Font;

        offscreenGraphics.DrawString("I was drawn in another thread!", labelFont, Brushes.Black, 0, 0);

        offscreenGraphics.Dispose();
        return offscreenBitMap;
    }
    protected override void OnPaint(PaintEventArgs pe)
    {
        if (DesignMode)
        {
            Graphics clientDC = this.CreateGraphics();
            clientDC.DrawImage(Draw(), 0, 0);
        }
        else
            Redraw();
    }

    private void ThreadedRendererControl_Resize(object sender, EventArgs e)
    {
        Redraw();
    }
}

In hindsight maybe I should of just found a way to draw it faster rather than use threading. Regardless, I hope you found this useful!

This is a clock that tells you the time by highlighting text in a block of text. In this case using a C# Console App. Not exactly original, but I thought I’d give it a try.
The progress bar counts the time until the next 5 minute mark.

Download Code
Download Executable

Show code on page

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Drawing;

namespace TimeTextSquare
{
    class Program
    {
        static void Main(string[] args)
        {
            TextClock clock = new TextClock()
                {
                    Colour1 = ConsoleColor.Green,
                    Colour2 = ConsoleColor.DarkGray
                };
            Console.CursorVisible = false;
            Console.WindowWidth = 15;
            Console.WindowHeight = 8;
            clock.Time = DateTime.Now;
            while (true)
            {
                Console.Clear();
                clock.Time = DateTime.Now;
                //clock.Time = clock.Time.AddMinutes(5);
                Console.Title = clock.Time.ToLongTimeString();
                clock.WriteTimeSquare();

                System.Threading.Thread.Sleep(new TimeSpan(0, 0, 5));
            }
        }
    }
    class TextClock
    {
        readonly string[] clockText = new string[]
        {
            "ITSMATENQUARTER",
            "TWENTYHALFIVEVE",
            "PASTOMELEVENINE",
            "EIGHTWELVESEVEN",
            "TENTHREEFIVESIX",
            "FOURTWONEOCLOCK",
            ">>|>>|>>|>>|>>|"
        };

        public DateTime Time { get; set; }
        public ConsoleColor Colour1 { get; set; }
        public ConsoleColor Colour2 { get; set; }

        List minuteHighlightStrings = new List();
        List highlightStrings = new List();
        string hourHighlightString;
        bool highlightFirstA = false;

        void SetTimeStrings()
        {
            minuteHighlightStrings.Clear();
            highlightStrings.Clear();
            hourHighlightString = "";

            highlightStrings.Add("ITS");

            if (Time.Minute < 5)
                highlightStrings.Add("OCLOCK");
            else if (Time.Minute < 10)
                minuteHighlightStrings.Add("FIVE");
            else if (Time.Minute < 15)
                minuteHighlightStrings.Add("TEN");
            else if (Time.Minute < 20)
                minuteHighlightStrings.Add("QUARTER");
            else if (Time.Minute < 25)
                minuteHighlightStrings.Add("TWENTY");
            else if (Time.Minute < 30)
            {
                minuteHighlightStrings.Add("TWENTY");
                minuteHighlightStrings.Add("FIVE");
            }
            else if (Time.Minute < 35)
                highlightStrings.Add("HALF");
            else if (Time.Minute < 40)
            {
                minuteHighlightStrings.Add("TWENTY");
                minuteHighlightStrings.Add("FIVE");
            }
            else if (Time.Minute < 45)
                minuteHighlightStrings.Add("TWENTY");
            else if (Time.Minute < 50)
                minuteHighlightStrings.Add("QUARTER");
            else if (Time.Minute < 55)
                minuteHighlightStrings.Add("TEN");
            else if (Time.Minute < 60)
                minuteHighlightStrings.Add("FIVE");

            if (minuteHighlightStrings.Contains("QUARTER"))
                highlightFirstA = true;

            if (Time.Minute < 35 && Time.Minute >= 5)
                highlightStrings.Add("PAST");
            else if (Time.Minute >= 35)
                highlightStrings.Add("TO");

            int hour = Time.Hour;
            if (Time.Minute >= 35)
                hour++;
            if (hour > 12)
                hour -= 12;
            string[] hourStrings = new string[] { "TWELVE", "ONE", "TWO", "THREE", "FOUR", "FIVE", "SIX", "SEVEN", "EIGHT", "NINE", "TEN", "ELEVEN", "TWELVE" };
            hourHighlightString = hourStrings[hour];
        }

        public void WriteTimeSquare()
        {
            SetTimeStrings();
            Console.ForegroundColor = Colour2;

            for (int lineCounter = 0; lineCounter < clockText.Length - 1; lineCounter++)
            {
                string lineText = clockText[lineCounter];
                for (int charCounter = 0; charCounter < lineText.Length; charCounter++)
                {
                    string remainingText = lineText.Substring(charCounter);
                    bool found = false;
                    foreach (string highlightStr in highlightStrings)
                        if (remainingText.StartsWith(highlightStr))
                        {
                            found = true;
                            Console.ForegroundColor = Colour1;
                            Console.Write(highlightStr);
                            Console.ForegroundColor = Colour2;
                            charCounter += highlightStr.Length - 1;
                        }
                    if (lineCounter

dlg.Show();
//Make full screen
//cant use WindowState as its not a form
//dlg.DesktopBounds = Screen.FromControl(dlg).WorkingArea;
((Form)dlg).WindowState = FormWindowState.Maximized;
dlg.BringToFront();

Update

Looks like the dialog can be cast to a form allowing WindowState to be set.

PrintPreviewDialog dlg = new PrintPreviewDialog();
dlg.Document = doc;
((Form)dlg).WindowState = FormWindowState.Maximized;
dlg.ShowDialog();

However this doesn’t tell you what has been inserted/removed, you will have to poll the drives manually to find out.
If you need that you will have to register to receive events from windows which involves P/Invoking RegisterDeviceNotification (See Drive Detector at Code Project).

[...]
using System.Runtime.InteropServices;
using System.Security.Permissions;

public class MyForm : Form
{
        const int WM_DEVICECHANGE = 0x0219;
        const int DBT_DEVICEARRIVAL = 0x8000; // system detected a new device
        const int DBT_DEVICEREMOVECOMPLETE = 0x8004; //device was removed
        const int DBT_DEVNODES_CHANGED = 0x0007; //device changed
        const int DBT_DEVTYP_VOLUME = 0x00000002; // logical volume

        [SecurityPermission(SecurityAction.LinkDemand, Flags = SecurityPermissionFlag.UnmanagedCode)]
        protected override void WndProc(ref Message m)
        {
            if (m.Msg == WM_DEVICECHANGE
                && m.WParam.ToInt32() == DBT_DEVICEARRIVAL
                || m.WParam.ToInt32() == DBT_DEVICEREMOVECOMPLETE
                || m.WParam.ToInt32() == DBT_DEVNODES_CHANGED))
            {
                if (m.WParam.ToInt32() != DBT_DEVNODES_CHANGED)
                {
                    int devType = Marshal.ReadInt32(m.LParam, 4);
                    if (devType == DBT_DEVTYP_VOLUME)
                    {
                        //Poll drives
                    }
                }
                else
                {
                    //Poll drives
                }
            }

            base.WndProc(ref m);
        }
}