home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / boot / i386 / root / usr / share / YaST2 / include / partitioning / raid_lib.ycp < prev    next >
Encoding:
Text File  |  2006-11-29  |  8.8 KB  |  376 lines
  1. /**
  2.  * File:
  3.  *   raid_lib.ycp
  4.  *
  5.  * Module:
  6.  *    configuration of raid:
  7.  *
  8.  * Summary:
  9.  *
  10.  * Authors:
  11.  *   mike <mike@suse.de>
  12.  *
  13.  * $Id: raid_lib.ycp 30804 2006-05-10 10:01:01Z fehr $
  14.  *
  15.  *
  16.  *----------------------
  17.  *  rd or Rd == raid device, a device like hda1 or /dev/system/usr
  18.  *              that belongs to a raid
  19.  */
  20.  
  21.  
  22. {
  23.   import "Storage";
  24.   import "Mode";
  25.   import "Partitions";
  26.   import "Wizard";
  27.   textdomain "storage";
  28.  
  29.  
  30. /**
  31.  * Build raid dev item list e.g.: [`item (`id ("/dev/md2"), "/dev/md2", false)]
  32.  *
  33.  **/
  34. define list<term> get_raid_devices( map tg, integer raid_nr )
  35.     ``{
  36.     list<term> all_raid_devices = [];
  37.     list<map> partitions = tg["/dev/md","partitions"]:[];
  38.  
  39.     foreach( map part, partitions, 
  40.     ``{
  41.     integer num = part["nr"]:255;
  42.     all_raid_devices = 
  43.         add( all_raid_devices, 
  44.          `item( `id(sformat("/dev/md%1", num )),
  45.             Storage::GetDeviceName( "/dev/md", num ), 
  46.             num == raid_nr ));
  47.     });
  48.     return all_raid_devices;
  49.     };
  50.  
  51.  
  52.   /**
  53.    * Checks if a RAID is currently created or if it was already
  54.    *
  55.    **/
  56. define boolean IsRaidCreated( map tg, string device, symbol what )
  57.     ``{
  58.     boolean created = false;
  59.     if( what != `wizard )
  60.     {
  61.     list<map> partitions = (list<map>)tg["/dev/md", "partitions"]:[];
  62.     y2milestone( "parts %1", partitions );
  63.  
  64.     foreach( map part, partitions, 
  65.         ``{
  66.         if( part["device"]:""==device && part["create"]:false )
  67.         {
  68.         created = true;
  69.         }
  70.         });
  71.     }
  72.     else
  73.     {
  74.     created = true;
  75.     }
  76.     y2milestone( "device %1 what %2 created %3", device, what, created );
  77.     return( created );
  78.     };
  79.  
  80.  
  81.  
  82. /**
  83.   * Update Raid ComboBox
  84.   *
  85.   */
  86. define void new_raid_list( list<term> all_raids )
  87.     ``{
  88.     y2milestone( "Update Raid ComboBox: all md devices: %1 " , all_raids );
  89.     UI::ReplaceWidget( `id(`raids_rp) , `ComboBox(`id(`raids), `opt(`notify),
  90.                // label text
  91.                        _("R&AID:"),all_raids ));
  92.     };
  93.  
  94.  
  95. /*
  96.  * Get all partitions, we can probably use as raid devices
  97.  * Add needed information: is_raid, disksize
  98.  */
  99. define list<map> get_possible_rds( map<string,map> targetMap )
  100.     ``{
  101.     list<map> ret = [];
  102.  
  103.     //////////////////////////////////////////////////////////////////////
  104.     // add the devicename i.e /dev/hda1 or /dev/system/usr to partition list
  105.     // and the device key  <subdevice>/<maindevice> i.e. 1//dev/hda
  106.  
  107.     targetMap = mapmap( string dev, map devmap, targetMap,
  108.     ``{
  109.     list<map> partitions = 
  110.         maplist( map part, devmap["partitions"]:[],
  111.         ``{
  112.         part["maindev"] = dev;
  113.         return( part );
  114.         });
  115.  
  116.     return( $[ dev: add( devmap, "partitions", partitions)] );
  117.     });
  118.  
  119.     ////////////////////////////////////////////////////////////
  120.     // Look for all partitions:
  121.     // not LVM ( here I mean /dev/<lvm_volumegroup>/<lv> entrys!
  122.     //           there are only the lv's in the targetMap under 
  123.     //           /dev/<lvm_volumegroup>/<lv> !)
  124.     // no mountpoint
  125.     // id 0x83 or 0x8e or 0xfd
  126.     // no RAID devices (this is for experts only, by hand)
  127.  
  128.     list<map> allret = [];
  129.     list types_no = [ `lvm, `sw_raid, `evms ];
  130.     list fsids = [ Partitions::fsid_lvm, Partitions::fsid_raid, 
  131.                    Partitions::fsid_native ];
  132.     list ubs = [ `UB_NONE, `UB_MD ];
  133.     foreach( string dev, map devmap, targetMap,
  134.     ``{
  135.     ret = filter( map p, devmap["partitions"]:[],
  136.               ``( size(p["mount"]:"")==0 &&
  137.               !contains( types_no, p["type"]:`primary ) &&
  138.               contains( ubs, p["used_by_type"]:`UB_NONE ) && 
  139.               (!haskey(p,"fsid")||contains( fsids, p["fsid"]:0 ))));
  140.         allret = (list<map>)merge(allret, ret );
  141.     });
  142.     return( allret );
  143.     };
  144.  
  145.  
  146.  
  147.  
  148. /*
  149.  * @param targetMap
  150.  * @param partition  the raid for which the size is calculated
  151.  * out: size of RAID as string
  152.  */
  153. define string raid_size_str( map partition )
  154.     ``{
  155.     return( ByteToHumanStringWithZero( partition["size_k"]:0*1024 ));
  156.     };
  157.  
  158.  
  159. /*
  160.  * in: targetMap: the targetMap ;-)
  161.  * in: partition: the raid for which the size is calculated
  162.  * out: size of RAID in byte
  163.  */
  164. define integer raid_size_byte( map partition )
  165.     ``{
  166.     return( partition["size_k"]:0*1024 );
  167.     };
  168.  
  169.  
  170. /*
  171.  * get the number of devices which belong to the raid
  172.  */
  173. define integer getNrOfParts( map<string,map> targetMap, string current_raid )
  174.     ``{
  175.     list<map> partition_list = get_possible_rds( targetMap );
  176.     string dev = "md" + current_raid;
  177.  
  178.     partition_list = filter( map part, partition_list, 
  179.                  ``( part["used_by"]:""==dev ) );
  180.     return( size( partition_list ) );
  181.     };
  182.  
  183.  
  184. /**
  185.  * belongs the the partition "id" already to a raid
  186.  **/
  187. define boolean isItemRd( map<string,map> tg, string id )
  188.     ``{
  189.     map partition = Storage::GetPartition( tg, id );
  190.     return( partition["used_by_type"]:`UB_NONE == `UB_MD );
  191.     };
  192.  
  193.  
  194. /**
  195.  * belongs the the partition "id" already to a raid
  196.  * if YES: popup a proper Message and return(false)
  197.  */
  198. define boolean CheckItemIsNotRaid( map<string,map> tg, string id )
  199.     ``{
  200.     y2debug("Check Item is not Raid ");
  201.     // error case:
  202.     if( id!=nil && size(id) > 0 )
  203.     {
  204.     if( !isItemRd(tg,id) )
  205.         {
  206.         return( true );
  207.         }
  208.     // Message popup
  209.     Popup::Message (sformat(_("Item %1 is already a RAID device.
  210. You cannot add it again.
  211. "), id));
  212.     }
  213.     else
  214.     {
  215.     //Message popup
  216.     Popup::Message(_("You have to select one device in the table"));
  217.     }
  218.  
  219.     return( false );
  220.     };
  221.  
  222.  
  223. /**
  224.  *  belongs the the partition "id" already to a raid?
  225.  * if NO: popup a proper Message and return(false)
  226.  **/
  227. define boolean CheckItemIsRaid( map<string,map> tg, string id )
  228.     ``{
  229.     // error case:
  230.     if( id!=nil && size(id) > 0 )
  231.     {
  232.     if( isItemRd(tg,id) )
  233.         {
  234.         return( true );
  235.         }
  236.     // Message popup
  237.     Popup::Message (sformat(_("Item %1 cannot be removed.
  238. It does not belong to a RAID.
  239. "),  id ));
  240.     }
  241.     else
  242.     {
  243.     //Message popup
  244.     Popup::Message (_("You have to select one device in the table"));
  245.     }
  246.  
  247.     return( false );
  248.     };
  249.  
  250.  
  251.   
  252. /**
  253.   *  partition list to widget table
  254.   * in:
  255.   * [  $["fsid":142,
  256.   *      "fstype":"Linux raid",
  257.   *      "nr":"var",
  258.   *      "region":[255, 16],
  259.   *      "type":`primary],
  260.   *      $[
  261.   *       "fsid":131,
  262.   *       "fstype":"Linux native",
  263.   *       "nr":4, "region":[271, 844],
  264.   *    ...
  265.   *
  266.   * out:
  267.   * [
  268.   *     `item(`id("/dev/hda1"), "/dev/hda1 ",   " 2G ",  " LVM ",   "md1"),
  269.   *     `item(`id("/dev/hda2"), "/dev/hda2 ",   " 1G ",  " Linux ", " ")
  270.   * ];
  271.   **/
  272. define list get_raid_widget_table( list<map> possRdList )
  273.     ``{
  274.     possRdList = 
  275.     sort( map x, map y, possRdList,
  276.         ``{
  277.         if( x["maindev"]:"" == y["maindev"]:"" )
  278.         {
  279.         return( x["nr"]:0 < y["nr"]:0 );
  280.         }
  281.         else
  282.         {
  283.         return( x["maindev"]:"" < y["maindev"]:"");
  284.         }
  285.         });
  286.  
  287.     return( maplist( map p, possRdList,
  288.         ``{
  289.         return(`item( `id(p["device"]:"--"), p["device"]:"--",
  290.               ByteToHumanStringWithZero(p["size_k"]:0*1024),
  291.               p["fstype"]:"--",
  292.               p["used_by"]:"--"
  293.                 ));
  294.         }));
  295.     };
  296.  
  297.     
  298. /**
  299.  * number for /dev/mdX, 0 for /dev/md0, 1 for /dev/md1
  300.  */
  301. define integer get_free_raid_nr( map<string,map> targetMap, integer min )
  302.     ``{
  303.     integer i = min;
  304.     list raid_nrs = maplist( map mdX, targetMap["/dev/md","partitions"]:[],
  305.                  ``(mdX["nr"]:256)) ;
  306.     while( contains(raid_nrs, i) && i < 255)
  307.     {
  308.     i = i+1;
  309.     }
  310.     y2milestone( "get_free_raid_nr ret:%1", i );
  311.     return( i );
  312.     };
  313.  
  314. /**
  315.  * Add the main device ( "/dev/hda") to the partition map.
  316.  * partition = $[
  317.  *                "nr"    : 1,
  318.  *              "main_dev": "/dev/hda",
  319.  *              ......
  320.  *              ];
  321.  * Use change !!!!!!!!!
  322.  * @param targetMap all targets
  323.  * @return nil
  324.  */
  325. define map add_main_dev_to_partition_map( map<string,map> targetMap )
  326.     ``{
  327.     foreach( string targetdevice, map target, targetMap, 
  328.     ``{
  329.     targetMap[targetdevice,"partitions"] = 
  330.         maplist( map p, target["partitions"]:[],
  331.         ``({
  332.         if( size(p["used_by"]:"")>0 )
  333.             {
  334.             p["main_dev"] = targetdevice;
  335.             }
  336.         return( p );
  337.         }));
  338.     });
  339.     y2debug("targets %1", targetMap );
  340.     return( targetMap );
  341.     };
  342.  
  343. /**
  344.  * @return list a list with all partition that have a key raid_name != "".
  345.  * @param targetMap all targets
  346.  */
  347. define list<map> all_raid_partitions( map<string,map> targetMap ) 
  348.     ``{
  349.     list<list> ret = 
  350.       (list<list>) maplist( string targetdevice, map target, targetMap,
  351.                 ``( filter( map part, target["partitions"]:[],
  352.                     ``(part["used_by_type"]:`UB_NONE==`UB_MD))));
  353.     return(list<map>)( flatten(ret) );
  354.     };
  355.  
  356. define boolean check_raid_possible( map<string,map> targetMap )
  357.     ``{
  358.     integer possible_parts_found = size(get_possible_rds(targetMap));
  359.  
  360.     if( possible_parts_found < 2 )
  361.         {
  362.         // Translators: the text 'do not format' must match the label in the corresponding popup!
  363.         Popup::Message(_("To use RAID, at least two partitions of type 0xFD (or 0x83)
  364. are required. Change your partition table accordingly.
  365. In most cases, this can be done in the following way:
  366. click 'Create', select 'Do not format', and set the partition ID to 0xFD.
  367. "));
  368.  
  369.         return false;
  370.         }
  371.     return true;
  372.     }
  373.  
  374. }
  375.  
  376.