Standarize and simplify plugin names.

- The file names are the ones the the user will be using to reference
  each plugin.  Having a long name will not help the user.
- Also, to signify that they are plugins we will use the "p_" at the
  beginning of each name.
- plugin_examples is left like that because it is not a plugin in
  itself, but a directory that contains plugins.

Please follow these naming standards when you name you plugins.

4 files changed, 0 insertions, 807 deletions

diff --git a/plugins/plugin_undelete_partitions/Makefile b/plugins/plugin_undelete_partitions/Makefile
deleted file mode 100644
index a9ef6cc..0000000
--- a/plugins/plugin_undelete_partitions/Makefile
+++ /dev/null
@@ -1,38 +0,0 @@
-# Makefile
-#
-# First Aid Kit - diagnostic and repair tool for Linux
-# Copyright (C) 2008 Joel Andres Granados <jgranado@redhat.com>
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-#
-#
-
-PYVER  := $(shell python -c 'import sys; print sys.version[0:3]')
-PYTHON = python$(PYVER)
-PYTHONINCLUDE = /usr/include/$(PYTHON)
-
-
-CFLAGS =  -I$(PYTHONINCLUDE)
-
-PYMODULE = _undelpart.so
-
-#Build with libparted (parted-1.8.3 and higher have a pkg-config file)
-LDFLAGS = $(shell pkg-config --libs libparted)
-
-build:
-	$(CC) $(CFLAGS) -shared -fPIC -o _undelpart.so _undelpart.c $(LDFLAGS)
-
-clean:
-	rm -f _undelpart.so *.pyc
diff --git a/plugins/plugin_undelete_partitions/__init__.py b/plugins/plugin_undelete_partitions/__init__.py
deleted file mode 100644
index b3402ea..0000000
--- a/plugins/plugin_undelete_partitions/__init__.py
+++ /dev/null
@@ -1,20 +0,0 @@
-# First Aid Kit - diagnostic and repair tool for Linux
-# Copyright (C) 2008 Joel Andres Granados <jgranado@redhat.com>
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-import undeletePartition
-def get_plugin():
-    return undeletePartition.UndeletePartition
diff --git a/plugins/plugin_undelete_partitions/_undelpart.c b/plugins/plugin_undelete_partitions/_undelpart.c
deleted file mode 100644
index aab4f07..0000000
--- a/plugins/plugin_undelete_partitions/_undelpart.c
+++ /dev/null
@@ -1,578 +0,0 @@
-/*
-* First Aid Kit - diagnostic and repair tool for Linux
-* Copyright (C) 2008 Joel Andres Granados <jgranado@redhat.com>
-*
-* This program is free software; you can redistribute it and/or modify
-* it under the terms of the GNU General Public License as published by
-* the Free Software Foundation; either version 2 of the License, or
-* (at your option) any later version.
-*
-* This program is distributed in the hope that it will be useful,
-* but WITHOUT ANY WARRANTY; without even the implied warranty of
-* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-* GNU General Public License for more details.
-*
-* You should have received a copy of the GNU General Public License
-* along with this program; if not, write to the Free Software
-* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-*
-*/
-
-
-#include <Python.h>
-#include <assert.h>
-#include <string.h>
-#include "parted/parted.h"
-
-/*
- * Simple representation of the partition.
- */
-typedef struct{
-    int partnum;
-    PedSector partstart;
-    PedSector partend;
-} partElem;
-
-
-/*
- * Helper function
- */
-
-/*
- * Returns a disk with the path of the device.
- */
-static PedDisk *
-_getDiskFromPath(char * path){
-    PedDevice * dev;
-    PedDisk * disk;
-    /* Try to create the device with the path */
-    dev = ped_device_get(path);
-    if(dev == NULL)
-        return NULL;
-
-    /* Read the partition table off of the device */
-    disk = ped_disk_new(dev);
-    if(disk == NULL)
-        return NULL;
-
-    return disk;
-}
-
-/*
- * Return the partition type.
- */
-static PedPartitionType
-_disk_get_part_type_for_sector (PedDisk* disk, PedSector sector)
-{
-        PedPartition*   extended;
-
-        extended = ped_disk_extended_partition (disk);
-        if (!extended
-            || !ped_geometry_test_sector_inside (&extended->geom, sector))
-                return 0;
-
-        return PED_PARTITION_LOGICAL;
-}
-
-/*
- * Create a python list from one partElement struct
- */
-static PyObject *
-_getPPartList( int partnum, int partstart, int partend ){
-    PyObject * num, * start, * end;
-    PyObject * list;
-    /*
-    * Create a new temporary list.  and add all the related values 
-    */
-    num = PyString_FromFormat("%d",partnum);
-    start = PyLong_FromLong(partstart);
-    end = PyLong_FromLong(partend);
-    list = PyList_New(3);
-    if(num == NULL || start == NULL || end == NULL ||
-            list == NULL ||
-            PyList_SetItem(list, 0, num) == -1 ||
-            PyList_SetItem(list, 1, start) == -1 ||
-            PyList_SetItem(list, 2, end) == -1){
-        goto handle_error;
-    }
-    return list;
-
-    handle_error:
-
-    Py_XDECREF(num);
-    Py_XDECREF(start);
-    Py_XDECREF(end);
-    Py_XDECREF(list);
-    return NULL;
-}
-
-/*
- * Create a array of partElem with the python list
- */
-static partElem
-_getCPartList( PyObject * list ){
-    partElem _list = {0};
-
-    // check that its a list.
-    if(!PyList_Check(list)){
-        PyErr_SetString(PyExc_StandardError, 
-                "Error malformed argument, list does not contian lisit.");
-        return _list;
-    }
-
-    // check that it has three elements.
-    if(PyList_Size(list) < 3){
-        PyErr_SetString(PyExc_StandardError, 
-                "Error Malformed argument, contained list is to small.");
-        return _list;
-    }
-
-    // Populate the _partList array.
-    _list.partnum = PyLong_AsLong( PyNumber_Long(PyList_GetItem(list, 0)) );
-    _list.partstart = PyLong_AsLong( PyList_GetItem(list, 1) );
-    _list.partend = PyLong_AsLong( PyList_GetItem(list, 2) );
-    if( PyErr_Occurred())
-        _list.partnum = '\0';
-    return _list;
-}
-
-static int
-MEGABYTE_SECTORS (PedDevice* dev)
-{
-        return PED_MEGABYTE_SIZE / dev->sector_size;
-}
-
-/*
- * Tries to recover the partition part in the disk disk.  Reutrns null if it
- * was not possible, or the partition if it was.
- */
-static PedPartition * 
-add_partition(PedDisk * disk, partElem part){
-
-    //PedDisk * clone;
-    PedSector s;
-    PedGeometry * probed;
-    PedGeometry sect_geom;
-    PedGeometry entire_dev;
-    PedPartition  * parttemp = NULL;
-    PedConstraint disk_constraint, * part_constraint;
-    PedPartitionType part_type;
-    PedFileSystemType * fs_type;
-
-    /* Initialize the entire_dev geom for the constraint calculation */
-    ped_geometry_init(&entire_dev, disk->dev, 0, disk->dev->length);
-    part_type = _disk_get_part_type_for_sector (disk, (part.partstart + part.partend) / 2);
-
-
-    /* The end is a temporary hack until we get the method of search done */
-    for (s = part.partstart; s < part.partstart+(part.partend-part.partstart)/10; s++) {
-
-        /* Get a part from the specific s sector with the device constraint */
-        ped_geometry_init (&sect_geom, disk->dev, s, 1);
-        ped_constraint_init (&disk_constraint, ped_alignment_any, ped_alignment_any,
-                &sect_geom, &entire_dev, 1, disk->dev->length);
-
-        parttemp = ped_partition_new (disk, part_type, NULL, s, part.partend);
-        if(!parttemp){
-            ped_disk_remove_partition(disk, parttemp);
-            ped_constraint_done(&disk_constraint);
-            parttemp = NULL;
-            continue;
-        }
-
-
-        /* add the partition to the disk */
-        ped_exception_fetch_all(); //dont show errors
-        if(!ped_disk_add_partition(disk, parttemp, &disk_constraint)){
-            ped_disk_remove_partition(disk, parttemp);
-            ped_constraint_done(&disk_constraint);
-            parttemp = NULL;
-            continue;
-        }
-        ped_exception_leave_all();// show errors.
-
-        /* try to detect filesystem in the partition region */
-        fs_type = ped_file_system_probe(&parttemp->geom);
-        if(!fs_type){
-            ped_disk_remove_partition(disk, parttemp);
-            ped_constraint_done(&disk_constraint);
-            parttemp = NULL;
-            continue;
-        }
-
-        /* try to find the exact region the filesystem ocupies */
-        probed = ped_file_system_probe_specific(fs_type, &parttemp->geom);
-        if(!probed){
-            ped_disk_remove_partition(disk, parttemp);
-            ped_constraint_done(&disk_constraint);
-            ped_geometry_destroy(probed);
-            parttemp = NULL;
-            continue;
-        }
-
-        /* see if probed is inside the partition region */
-        if(!ped_geometry_test_inside(&parttemp->geom, probed)) {
-            ped_disk_remove_partition(disk, parttemp);
-            ped_constraint_done(&disk_constraint);
-            ped_geometry_destroy(probed);
-            parttemp = NULL;
-            continue;
-        }
-
-        /* create a constraint for the probed region */
-        part_constraint = ped_constraint_exact (probed);
-
-        /* set the region for the partition */
-        if (!ped_disk_set_partition_geom (parttemp->disk, parttemp, part_constraint,
-                                          probed->start, probed->end)) {
-            ped_disk_remove_partition(disk, parttemp);
-            ped_constraint_done(part_constraint);
-            ped_constraint_done(&disk_constraint);
-            ped_geometry_destroy(probed);
-            parttemp = NULL;
-            continue;
-        }
-        ped_partition_set_system(parttemp, fs_type);
-        ped_disk_commit(disk);
-        ped_disk_commit_to_dev(disk);
-        ped_disk_commit_to_os(disk);
-        break;
-    }
-    return parttemp;
-}
-
-/* Pythong facing functions.
- *
- * Returns a dictionary of the form { DISK : [None, None, None, None] ...}
- */
-static PyObject *
-undelpart_getDiskList(PyObject * self, PyObject * args){
-
-    PedDevice * dev;
-
-    PyObject * dict;
-    PyObject * list;
-    PyObject * diskName;
-
-    int i;
-
-    dict = PyDict_New();
-    if(dict == NULL){
-        PyErr_SetString(PyExc_StandardError, "Error creating a new dictionary.");
-        goto handle_error;
-    }
-
-    /* Search for the disks on the system */
-    ped_device_probe_all();
-
-    for(dev=ped_device_get_next(dev); dev ; dev=ped_device_get_next(dev)){
-        /*
-         * Build the list for this particular disk and fill it with Python
-         * None Objects. 
-         */
-        list = PyList_New(4);
-        if(list == NULL){
-            PyErr_SetString(PyExc_StandardError, "Error creating a new list.");
-            goto handle_error;
-        }
-        for(i=0 ; i < 4 ; i++){ //We set all items to None.
-            if(PyList_SetItem(list, i, Py_None) == -1){
-                PyErr_SetString(PyExc_StandardError,
-                        "Error setting up the None valued list.");
-                goto handle_error;
-            }
-        }
-
-        /*
-         * Take the name out of the PedDevice structure and place it as a
-         * dictionary key.  Use the device path.
-         */
-        diskName = Py_BuildValue("s", dev->path);
-        if(diskName == NULL){
-            PyErr_SetString(PyExc_StandardError,
-                    "Error creating key for dictionary.");
-            goto handle_error;
-        }
-
-        if(PyDict_SetItem(dict, diskName, list) == -1){
-            PyErr_SetString(PyExc_StandardError,
-                    "Error while creating the dictionary entry");
-            goto handle_error;
-        }
-    }
-
-    /* If the dictionary's length is 0, something is wrong. */
-    if(PyDict_Size(dict) == 0){
-        PyErr_SetString(PyExc_StandardError,
-                "libparted was unable to get a disk list. Are you root?");
-        goto handle_error;
-    }
-
-    ped_device_free_all();
-    return dict;
-
-    handle_error:
-    assert(PyErr_Occurred());
-
-    Py_XDECREF(diskName);
-    Py_XDECREF(list);
-    Py_XDECREF(dict);
-    ped_device_free_all();
-
-    return NULL;
-}
-
-/*
- * Returns a list of partitions that are present in the disk but not in its
- * partition table. If the disk does not exist it errors. If the disk
- * has no rescueable partitions it returns a void list.  It is a list of 
- * possible partitions,  it will NOT check for rescuability.
- */
-static PyObject *
-undelpart_getRescuable(PyObject * self, PyObject * args){
-
-    PedDisk  * disk;
-    PedPartition * part;
-
-    PyObject * tempList;
-    PyObject * partitions;
-
-    char * path;
-
-    if(!PyArg_ParseTuple(args, "s", &path)){
-        PyErr_SetString(PyExc_TypeError, "Argument is not a String");
-        goto handle_error;
-    }
-
-    /* Build the empty list*/
-    partitions = PyList_New(0);
-    if(partitions == NULL){
-        PyErr_SetString(PyExc_StandardError, "Error creating a new list.");
-        goto handle_error_destroy_disk;
-    }
-
-    /* create the disk */
-    disk = _getDiskFromPath(path);
-    if(disk == NULL){
-        PyErr_SetString(PyExc_StandardError, "Error reading disk information.");
-        goto handle_error_destroy_disk;
-    }
-
-    /*
-     * We start looking for the partitions.  The partitions will be detected if
-     * the numpart is less than 1.  The basic idea is to traverse all the partitions
-     * and look for holes in between.
-     */
-    for(part = ped_disk_next_partition(disk, NULL); part ;
-            part = ped_disk_next_partition(disk, part) ){
-        // All partitions with partnum less than 1 is a possibility.
-        if(part->num < 1 && part->geom.start < part->geom.end){
-            /* create the python object */
-            tempList = _getPPartList(part->num, part->geom.start, part->geom.end);
-            /* Append the list to the return value */
-            if(tempList == NULL || PyList_Append(partitions, tempList) == -1){
-                PyErr_SetString(PyExc_StandardError,
-                        "Error creating the partition information.");
-                goto handle_error_destroy_disk;
-            }
-        }
-    }
-    ped_disk_destroy(disk);
-    ped_device_free_all();
-
-    return partitions;
-
-    handle_error_destroy_disk:
-        ped_disk_destroy(disk);
-
-    handle_error:
-        assert(PyErr_Occurred());
-
-        Py_XDECREF(partitions);
-        Py_XDECREF(tempList);
-
-        ped_device_free_all();
-        return NULL;
-}
-
-/*
- * Returns a list of valid partitions at time of scan.
- */
-static PyObject *
-undelpart_getPartitionList(PyObject * self, PyObject * args){
-
-    PedDisk * disk;
-    PedDevice * dev;
-    PedPartition * part; //libparted object
-
-    PyObject * partList; //python list of partitions
-    PyObject * tempList; //python temporary object to hold the temprorary list.
-
-    char * path;
-
-    if(!PyArg_ParseTuple(args, "s", &path)){
-        PyErr_SetString(PyExc_TypeError, "Argument is not a String");
-        goto handle_error;
-    }
-
-    /* create the disk an dev */
-    disk = _getDiskFromPath(path);
-    if(disk == NULL){
-        PyErr_SetString(PyExc_StandardError, "Error reading disk information.");
-        goto handle_error;
-    }
-    dev = disk->dev;
-
-    /* Create the python list that we are to fill */
-    partList = PyList_New(0);
-    if(partList == NULL){
-        PyErr_SetString(PyExc_StandardError, "Error creating a new list.");
-        goto handle_error;
-    }
-
-    /* Get all the active partitions from disk */
-    for(part = ped_disk_next_partition(disk, NULL) ;
-            part ; part = ped_disk_next_partition(disk, part)){
-        if(part->num < 0)
-            continue;
-
-        tempList = _getPPartList(part->num,
-                part->geom.start,
-                part->geom.end);
-        /* Append the list to the return value */
-        if(tempList == NULL || PyList_Append(partList, tempList) == -1){
-            PyErr_SetString(PyExc_StandardError,
-                    "Error appending the partition to the list.");
-            goto handle_error;
-        }
-    }
-    ped_device_free_all();
-
-    return partList;
-
-    handle_error:
-    assert(PyErr_Occurred());
-
-    Py_XDECREF(partList);
-    Py_XDECREF(tempList);
-
-    ped_device_free_all();
-
-    return NULL;
-}
-
-/*
- * On a specific disk try to rescue a list of partitions.  Return the list of partitions
- * that was recovered.  The partitions should be in the [[partNum, start, end]...]
- * format.
- */
-static PyObject *
-undelpart_rescue(PyObject * self, PyObject * args){
-
-    PedDisk * disk;
-    PedPartition * part;
-
-    PyObject * partList;
-    PyObject * rescuedParts;
-    PyObject * tempList;
-
-    partElem * _partList = NULL;
-    char * path;
-    int partListSize = 0;
-    int i;
-
-    /* Check the arguments */
-    if(!PyArg_ParseTuple(args, "sO", &path, &partList)){
-        PyErr_SetString(PyExc_TypeError, "Arguments are not valid (String, List)");
-        goto handle_error;
-    }
-    if(! PyList_Check(partList)){
-        PyErr_SetString(PyExc_TypeError,
-                "The object that was passed is not a list.");
-        goto handle_error;
-    }
-
-    /* Build the empty list, this is the return value. */
-    rescuedParts = PyList_New(0);
-    if(rescuedParts == NULL){
-        PyErr_SetString(PyExc_StandardError, "Error creating a new list.");
-        goto handle_error;
-    }
-
-    /* Put the values of the list into a array of partElem */
-    partListSize = PyList_Size(partList);
-    _partList = malloc(sizeof(partElem)*partListSize+1);
-    if(!_partList){
-        PyErr_SetString(PyExc_StandardError, "Error allocating memory.");
-        goto handle_error;
-    }
-    for(i=0; i < partListSize ; i++){
-        _partList[i] = _getCPartList(PyList_GetItem(partList, i));
-        if( PyErr_Occurred() || _partList[i].partnum == '\0'){
-            goto handle_error;
-        }
-    }
-    _partList[partListSize].partnum = '\0';
-
-    /* create the disk an dev */
-    disk = _getDiskFromPath(path);
-    if(disk == NULL){
-        PyErr_SetString(PyExc_StandardError, "Error reading disk information.");
-        goto handle_error;
-    }
-
-    /* Try to add each partition. */
-    for(i=0 ; _partList[i].partnum ; i++){
-        part = add_partition(disk, _partList[i]);
-        if(!part){
-            // could not rescue this partition. sorry
-            continue;
-        }else{
-            tempList = _getPPartList(part->num, part->geom.start, part->geom.end);
-            /* Append the list to the return value */
-            if(tempList == NULL || PyList_Append(rescuedParts, tempList) == -1){
-                PyErr_SetString(PyExc_StandardError,
-                        "Error creating the partition information.");
-                goto handle_error;
-            }
-        }
-    }
-    ped_disk_destroy(disk);
-    free(_partList);
-    ped_device_free_all();
-
-    return rescuedParts;
-
-    handle_error:
-    assert(PyErr_Occurred());
-
-    free(_partList);
-    ped_device_free_all();
-
-    return NULL;
-}
-
-static struct PyMethodDef undelpart_methods [] = {
-    { "getDiskList",
-        (PyCFunction)undelpart_getDiskList,
-        METH_VARARGS, "Generaly returns the system disk list.  Receives nothing." },
-    { "getRescuable",
-        (PyCFunction)undelpart_getRescuable,
-        METH_VARARGS, "Get a list of partitions from a specific disk that might "
-            "be rescuable.  It returns the partitions that are not in the partition "
-            "table but where present after a disk scan.  It expects the disk name."},
-    { "getPartitionList",
-        (PyCFunction)undelpart_getPartitionList,
-        METH_VARARGS, "Get the partition list off of a certain disk.  This is intended "
-            "to be used as a backup.  It returns the number of the partition, start "
-            "sector and the end sector."},
-    {"rescue",
-        (PyCFunction)undelpart_rescue,
-        METH_VARARGS, "Try to put the list of rescuable partitions into the partition "
-            "table.  If the partitions are already there, nothing will be done.  A list "
-            "of rescued partitions is returned.  This does NOT delete any partitions."}
-};
-
-void init_undelpart(void){
-    (void) Py_InitModule("_undelpart", undelpart_methods);
-}
diff --git a/plugins/plugin_undelete_partitions/undeletePartition.py b/plugins/plugin_undelete_partitions/undeletePartition.py
deleted file mode 100644
index 47566d2..0000000
--- a/plugins/plugin_undelete_partitions/undeletePartition.py
+++ /dev/null
@@ -1,171 +0,0 @@
-# First Aid Kit - diagnostic and repair tool for Linux
-# Copyright (C) 2008 Joel Andres Granados <jgranado@redhat.com>
-#
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-# GNU General Public License for more details.
-#
-# You should have received a copy of the GNU General Public License
-# along with this program; if not, write to the Free Software
-# Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-from pyfirstaidkit.plugins import Plugin,Flow
-from pyfirstaidkit.returns import *
-from pyfirstaidkit.reporting import PLUGIN
-import signal
-import _undelpart
-
-class UndeletePartition(Plugin):
-    """Plugin to detect and correct deleted partitions from system disks.
-
-    Uses parted libriary to search for partitions that are not included in
-    the partition table of a disk.  If it is possible, this plugin will put
-    the partition back into the parition table so it is visible to the
-    system again.
-    """
-
-    flows = Flow.init(Plugin)
-    # We have not restore in the noBackup flow because we have no information to restore with.
-    flows["noBackup"] = Flow({
-                    Plugin.initial: {Return: "prepare"},
-                    "prepare"     : {ReturnSuccess: "diagnose"},
-                    "diagnose"    : {ReturnSuccess: "clean", ReturnFailure: "fix"},
-                    "fix"         : {ReturnSuccess: "clean", ReturnFailure: "clean"},
-                    "clean"       : {ReturnSuccess: Plugin.final}
-                    }, description="This flow skips the backup test.  Use with care.")
-
-    name = "Undelete Partitions"
-    version = "0.1.0"
-    author = "Joel Andres Granados"
-    def __init__(self, *args, **kwargs):
-        Plugin.__init__(self, *args, **kwargs)
-
-        # Dictionary that will hold the partitions that are not included in the
-        # partition table of a certain disk and can be recovered. It will also
-        # house the initial partition table and the partition table that is a
-        # result of running the fix.  The structure is:
-        # slef.disks={diskname: [ [recoverables], initialPT, finalPT ], .... }
-        self.disks = {}
-
-    def prepare(self):
-        # For now there is no real action in the prepare task.
-        self._result=ReturnSuccess
-
-    #
-    # The diagnose will not be a real diagnose but more of an informative task.
-    # It will report all the possible paritions that could house a rescuable
-    # partition.
-    #
-    def diagnose(self):
-        self._reporting.info("Beginning Diagnose...", origin = self, level = PLUGIN)
-        self.disks = _undelpart.getDiskList()
-        self._reporting.info("Disks present in the system %s"%self.disks.keys(),
-                origin = self, level = PLUGIN)
-        # When we find a rescuable partition we change this to true.
-        rescuablePresent = False
-        for disk, elements in self.disks.iteritems():
-            self.disks[disk] = [ _undelpart.getRescuable(disk), _undelpart.getPartitionList(disk), [] ]
-            if len(self.disks[disk][0]) > 0:
-                self._reporting.info("Possible partitions to recover in disk %s: %s"%(disk, self.disks[disk][0]),
-                        origin = self, level = PLUGIN)
-                rescuablePresent = True
-        if not rescuablePresent:
-            self._result = ReturnSuccess
-            self._reporting.info("Did not find any partitions that need rescueing.",
-                    origin = self, level = PLUGIN)
-        else:
-            self._result = ReturnFailure
-
-    def backup(self):
-        self._reporting.info("Backing up partition table." , origin = self, level = PLUGIN)
-        # We actually already have the backup of the partition table in the self.disks dict.
-        # Lets check anyway.
-        backupSane = True
-        for disk, members in self.disks.iteritems():
-            if members[1] == None or len(members[1]) <= 0:
-                # We don't really have the partition table backup.
-                self._reporting.info("Couldn't backup the partition table for %s."%disk,
-                        origin = self, level = PLUGIN)
-                self._reporting.info("To force the recovery of this disk without the backup " \
-                    "please run the flow named noBackup from this plugin.",
-                    origin = self, level = PLUGIN)
-                backupSane = False
-                self._result = ReturnFailure
-
-        if backupSane:
-            self._result = ReturnSuccess
-
-    #
-    # Every partition that we suspect is rescuable, (given that it has a partition table from
-    # wich we can recover if we mess up) we try to rescue.  This will take a long time.
-    #
-    def fix(self):
-        self._reporting.info("Lets see if I can fix this... Starting fix task.",
-                origin = self, level = PLUGIN)
-        self._reporting.info("Might want to go and get a cup of coffee,"
-                "this could take a looooooong time...", origin = self, level = PLUGIN)
-        self._result = ReturnSuccess
-        rescued = []
-        try:
-            for disk, members in self.disks.iteritems():
-                if len(members[0]) > 0:#there are partitions to rescue :)
-                    self._reporting.info("Trying to rescue %s from disk %s"%(members[0], disk),
-                            origin = self, level = PLUGIN)
-                    rescued = _undelpart.rescue(disk,members[0])
-                    self._reporting.info("Partitions rescued: %s"%rescued,
-                            origin = self, level = PLUGIN)
-                elif len(members[0]) ==  0:
-                    self._reporting.info("Nothing to rescue on disk %s."%disk,
-                            origin = self, level = PLUGIN)
-                else:
-                    self_result = ReturnFailure
-                    break
-        except KeyboardInterrupt, e:
-            self._reporting.error("Received a user interruption... Moving to Restore task.",
-                    origin = self, level = PLUGIN, action = None)
-            # The user might want to keep on pushing ctrl-c, lets lock the SIGINT signal.
-            signal.signal(signal.SIGINT, keyboaordInterruptHandler)
-            self._reporting.info("Please wait until the original partition table is recovered.",
-                    origin = self, level = PLUGIN)
-            self._result = ReturnFailure
-
-    #
-    # We are not really erasing anything, so recovering is kinda out of the point.  That said
-    # anything can happen with partitioning. :)  Lets get the current partitionList and try
-    # to add all the partitions that are not in the current part list but are in the backedup
-    # one.
-    #
-    def restore(self):
-        self._reporting.info("Starting Restoring task." , origin = self, level = PLUGIN)
-        tempPartList = []
-        backupPartList = []
-        for disk, members in self.disk.iteritems():
-            tempPartList = _undelpart.getPartitionList(disk)
-            backupPartList = members[1]
-            for part in backupPartList:
-                if part not in tempPartList:# we need to restore
-                    self._reporting.info("Trying to restore partition %s on disk %s"%(part, disk),
-                            origin = self, level = PLUGIN)
-                    restore = _undelpart.rescue(disk, [part])
-                    if len(restore) > 0:
-                        self._reporting.info("Restored partition %s on disk %s"%(part, disk),
-                                origin = self, level = PLUGIN)
-                    else:
-                        self._reporting.error("Could not restore partititon %s on disk %s"%(part, disk),
-                                origin = self, level = PLUGIN, action = None)
-        # Return the signal to its previous state.
-        signal.signal(signal.SIGINT, signal.SIG_DFL)
-        self._result = ReturnSuccess
-
-    def clean(self):
-        self._reporting.info("Cleanning...",origin = self, level = PLUGIN)
-        self._result = ReturnSuccess
-
-def keyboardInterruptHandler(signum, frame):
-    pass