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 / modules / AutoinstRAID.ycp < prev    next >
Encoding:
Text File  |  2006-11-29  |  7.1 KB  |  270 lines
  1. /**
  2.  * File:    modules/AutoinstRAID.ycp
  3.  * Module:    Auto-Installation
  4.  * Summary:    RAID
  5.  * Authors:    Anas Nashif <nashif@suse.de>
  6.  *
  7.  * $Id: AutoinstRAID.ycp 27288 2006-01-24 14:29:15Z ug $
  8.  */
  9. {
  10.  
  11.     module "AutoinstRAID";
  12.     textdomain "autoinst";
  13.  
  14.     import "Storage";
  15.     import "Partitions";
  16.     import "AutoinstStorage";
  17.  
  18.     include "partitioning/partition_defines.ycp";
  19.     include "partitioning/raid_lib.ycp";
  20.  
  21.  
  22.     global map<string, map> ExistingRAID = $[];
  23.  
  24.     global boolean old_available = false;
  25.  
  26.     
  27.  
  28.     map raid = $[];
  29.  
  30.     // Local variables
  31.     list region = [0,0];
  32.  
  33.     // Temporary copy of variable from Storage
  34.     map<string, map> targetMap = $[];
  35.  
  36.  
  37.     /**
  38.      * Constructor
  39.      * @return void
  40.      */
  41.     global define void AutoinstRAID () {
  42.         return;
  43.     }
  44.  
  45.     /**
  46.      * Initialize
  47.      */
  48.     global boolean Init ()
  49.     {
  50.         raid   = filter(string k, map v,
  51.                 AutoinstStorage::AutoTargetMap, ``(k  == "/dev/md"));
  52.         
  53.         if (size(raid) == 0)
  54.         {
  55.             return false;
  56.         }
  57.  
  58.         ExistingRAID    = filter(string k,map v, Storage::GetTargetMap(), ``(k == "/dev/md"));
  59.         y2milestone("Existing RAID: %1", ExistingRAID );
  60.  
  61.         if (size(ExistingRAID) > 0 )
  62.             old_available = true;
  63.  
  64.         return true;
  65.     }
  66.  
  67.     /**
  68.      * Return existing MDs
  69.      * @return list list of existing MDs
  70.      */
  71.     global define list ExistingMDs ( string md ) {
  72.         return(filter( map part, get_possible_rds( Storage::GetTargetMap() ),  
  73.                     ``( part["raid_name"]:"-1" == md )));
  74.     }
  75.  
  76.  
  77.     /**
  78.      * Return deleted MDs
  79.      * @return list list of deleted MDs
  80.      */
  81.     global define list DeletedMDs ( string md ) {
  82.         list<list<map> > ret = [];
  83.         foreach( string dev, map devmap, Storage::GetTargetMap(),
  84.                  ``{
  85.             ret = add( ret,
  86.                        filter( map part, devmap["partitions"]:[],
  87.                                ``(
  88.                                   part["raid_name"]:"" == md
  89.                                   &&
  90.                                   part["delete"]:false
  91.                                   &&
  92.                                   part["fsid"]:0 == Partitions::fsid_raid
  93.                                   )
  94.                                )
  95.                        );
  96.         });
  97.  
  98.         return( flatten(ret) );
  99.     }
  100.  
  101.  
  102.     /**
  103.      * Delete MDs
  104.      * @return list list of deleted MDs
  105.      */
  106.     global define list DeleteMDs () {
  107.         list to_bo_deleted = [];
  108.         foreach( string dev, map devmap, Storage::GetTargetMap(), ``{
  109.             foreach( map part,  devmap["partitions"]:[], ``{
  110.                 if (part["old_raid_name"]:"" != "" && part["delete"]:false)
  111.                 {
  112.                     to_bo_deleted= add(to_bo_deleted, part["old_raid_name"]:"");
  113.                 }
  114.             });
  115.         });
  116.  
  117.         y2milestone("mds to delete: %1", to_bo_deleted);
  118.  
  119.         if (old_available)
  120.         {
  121.             list<map> mds = Storage::GetTargetMap()["/dev/md","partitions"]:[];
  122.             list<map> new_mds = maplist( map md, mds ,``{
  123.                 if ( contains(to_bo_deleted, md["device"]:""))
  124.                 {
  125.                     md["delete"] = true;
  126.                 }
  127.                 return (md);
  128.             });
  129.             y2milestone("new_mds: %1", new_mds );
  130.             map allmds =  targetMap["/dev/md"]:$[];
  131.             allmds["partitions"] = new_mds;
  132.             targetMap["/dev/md"] = allmds;
  133.             Storage::SetTargetMap(targetMap);
  134.         }
  135.     }
  136.  
  137.  
  138.  
  139.     define boolean remove_possible_mds () {
  140.  
  141.         boolean prefer_remove = raid["/dev/md", "prefer_remove"]:false;
  142.         if (old_available && prefer_remove)
  143.         {
  144.             list<map> existing_mds = ExistingRAID["/dev/md","partitions"]:[];
  145.             list<map> modified_mds = maplist( map md, existing_mds ,``{
  146.                     md["delete"] = true;
  147.                     return (md);
  148.                     });
  149.             map<string, any> allmds =  (map<string, any>)ExistingRAID["/dev/md"]:$[];
  150.             allmds["partitions"]    = modified_mds;
  151.             map<string,map> tg = Storage::GetTargetMap();
  152.             tg["/dev/md"] = allmds;
  153.             Storage::SetTargetMap(tg);
  154.             // update our variable
  155.             ExistingRAID["/dev/md"] = allmds;
  156.         }
  157.         return true;
  158.     }
  159.  
  160.     /**
  161.      * Create RAID Configuration
  162.      * @return boolean
  163.      */
  164.     global define boolean Write() {
  165.  
  166.         remove_possible_mds ();
  167.         list<map> raid_partitions = raid["/dev/md", "partitions"]:[];
  168.  
  169.         list<map> RaidList =  maplist ( map md, raid_partitions,  ``{
  170.             string use    = raid["/dev/md","use"]:"none";
  171.             string dev    = sformat("/dev/md%1", md["partition_nr"]:0);
  172.             md["device"]    = dev;
  173.  
  174.  
  175.             if (md["enc_type"]:`none!=`none )
  176.             {
  177.                 Storage::SetCryptPwd( dev, md["crypt_key"]:"" );
  178.             }
  179.             y2milestone("Working on %1", md);
  180.  
  181.  
  182.             integer chunk_size = 4;
  183.             map options = md["raid_options"]:$[];
  184.             string raid_type    = options["raid_type"]:"raid1";
  185.  
  186.             if ( raid_type == "raid5" )
  187.             {
  188.                 chunk_size = 128;
  189.             }
  190.             if ( raid_type == "raid0" )
  191.             {
  192.                 chunk_size = 32;
  193.             }
  194.  
  195.  
  196.             if (!haskey(options, "raid_type"))
  197.             {
  198.                 options["raid_type"] = raid_type;
  199.             }
  200.  
  201.             integer sel_chunksize = tointeger(options["chunk_size"]:"0");
  202.  
  203.             if ( sel_chunksize != 0 )
  204.             {
  205.                 chunk_size = sel_chunksize;
  206.                 options["chunk_size"]    = chunk_size;
  207.             }
  208.  
  209.  
  210.             if(  raid_type == "raid5" && options["parity_algorithm"]:"" == "" )
  211.             {
  212.                 options["parity_algorithm"] = "left_symmetric";
  213.             }
  214.  
  215.             md["nr"] = md["partition_nr"]:0;
  216.  
  217.  
  218.             if (!haskey(md, "create"))
  219.             {
  220.                 md["create"]    = true;
  221.                 md["status"]    = "create";
  222.             }
  223.  
  224.             if (!haskey(md, "format"))
  225.             {
  226.                 md["format"]    = false;
  227.             }
  228.  
  229.             if (md["format"]:false)
  230.             {
  231.                 md["used_fs"]    = md["filesystem"]:`ext2;
  232.             }
  233.  
  234.             md["type"]        = `sw_raid;
  235.             if (haskey(md, "raid_options"))
  236.                 md=remove(md, "raid_options");
  237.         md["devices"] = AutoinstStorage::raid2device[md["device"]:""]:[];
  238.             return (union(md, options));
  239.         });
  240.  
  241.         list allraid = [];
  242.         if (size (ExistingRAID["/dev/md","partitions"]:[]) > 0 )
  243.         {
  244.             allraid = union (ExistingRAID["/dev/md", "partitions"]:[], RaidList );
  245.         }
  246.         else
  247.         {
  248.             allraid =  RaidList;
  249.         }
  250.         y2milestone("All RAID: %1", allraid);
  251.  
  252.  
  253.         map<string, any> RaidMap = 
  254.             $[
  255.             "partitions" : allraid,
  256.             "type"       : `CT_MD
  257.             ];
  258.         y2milestone("RaidMap: %1", RaidMap);
  259.  
  260.         map<string,map> tg = Storage::GetTargetMap();
  261.         tg["/dev/md"] = RaidMap;
  262.         Storage::SetTargetMap(tg);
  263.         y2milestone("Targets: %1", Storage::GetTargetMap());
  264.         return true;
  265.     }
  266.  
  267.  
  268. }
  269.  
  270.