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 / OSRStatus.ycp < prev    next >
Encoding:
Text File  |  2006-11-29  |  11.2 KB  |  458 lines
  1. /**
  2.  *  File:
  3.  *   OSRStatus.ycp
  4.  *
  5.  *  Module:
  6.  *   YaST2 OS Repair
  7.  *
  8.  *  Summary:
  9.  *
  10.  *
  11.  *  Authors:
  12.  *   Johannes Buchhold <jbuch@suse.de>, 2002
  13.  *
  14.  * $Id: OSRStatus.ycp 23769 2005-06-21 12:18:10Z jsuchome $
  15.  */
  16. {
  17.   module "OSRStatus";
  18.  
  19.   textdomain "repair";
  20.  
  21.   global string status                = "";
  22.   global string severity            = "";
  23.   global string next_detect_method_name        = "";
  24.  
  25.  
  26.   map status_map    = $[
  27.                 "detect_ok"     : $[
  28.                             "color"       :  "blue",
  29.                             "status_text" :  _("OK"),
  30.                             "priority"      : 3,
  31.                             "type"      : "detect"
  32.                 ],
  33.                 "detect_error"     : $[
  34.                             "color"       :    "red",
  35.                             "status_text" :  _("Error"),
  36.                             "priority"    : 6,
  37.                             "type"      : "detect",
  38.                 ],
  39.                 "detect_problem"     : $[
  40.                             "color"       : "red",
  41.                             "status_text" :  _("Problematic"),
  42.                             "type"      : "detect",
  43.                             "priority"    : 5
  44.                 ],
  45.                 "detect_omit"     : $[
  46.                             "color"       : "blue",
  47.                             "status_text" :  _("Omitted"),
  48.                             "type"      : "detect",
  49.                             "priority"    : 4
  50.                 ],
  51.                 "repair_ok"     : $[
  52.                             "color"       : "green",
  53.                             "status_text" : _("Repaired"),
  54.                             "type"      : "repair",
  55.                             "priority"    : 7
  56.                 ],
  57.                 "repair_error"     : $[
  58.                             "color"          : "red",
  59.                             "status_text"    : _("Failed"),
  60.                             "type"         : "repair",
  61.                             "priority"       : 9
  62.                 ],
  63.                 "repair_omit"     : $[
  64.                             "color"            : "red",
  65.                             "status_text"     : _("Omitted"),
  66.                             "type"          : "repair",
  67.                             "priority"        : 8
  68.                 ],
  69.                 "open"         : $[
  70.                             "color"        : "green",
  71.                             "status_text"    : _("Open"),
  72.                             "type"            : "detect",
  73.                             "priority"        : 1
  74.                 ],
  75.                 "not_found"        : $[
  76.                             "color"        : "blue",
  77.                             "status_text"    : _("Not found"),
  78.                             "type"          : "detect",
  79.                             "priority"        : 2
  80.                             ]
  81.   ];
  82.  
  83.  
  84.   global define void RestartScan(string tnext_detect_method_name)``{
  85.       next_detect_method_name =tnext_detect_method_name;
  86.   }
  87.  
  88.   global define void Reset()``{
  89.       status = "";
  90.       severity = "";
  91.       next_detect_method_name = "";
  92.   }
  93.  
  94.   global define string Color(string local_status) ``{
  95.       return status_map [ local_status, "color"]:"blue";
  96.   }
  97.  
  98.  
  99.   global define string Text(string local_status) ``{
  100.       return status_map [ local_status, "status_text"]:"";
  101.   }
  102.  
  103.   global define integer Priority(string local_status) ``{
  104.       return status_map [ local_status, "priority"]:1;
  105.   }
  106.  
  107.   global define string PriorityStr(integer priority ) ``{
  108.  
  109.       list status_list = maplist (string key, map val, (map<string,map<any,any> >) status_map,``(val));
  110.       map pr_map = (map<string,any>) find (map<string,any> v, (list<map<string,any> >)status_list,
  111.     ``( v["priority"]:1 == priority ));
  112.       if ( pr_map != nil && pr_map != $[] )
  113.       return pr_map["status_text"]:"detect_ok";
  114.       else return "detect_ok";
  115.   }
  116.  
  117.   global define string PriorityKey(integer priority ) ``{
  118.  
  119.       list status_list = maplist (string key, map val,(map<string,map<any,any> >) status_map,
  120.     ``( add (val, "key", key ) ));
  121.       map pr_map = (map<string,any>) find (map<string,any> v, (list<map<string,any> >)status_list,
  122.     ``( v["priority"]:1 == priority ));
  123.       if ( pr_map != nil && pr_map != $[] )
  124.       return pr_map["key"]:"";
  125.       else return "detect_ok";
  126.   }
  127.  
  128.   /**
  129.    *  Returns the level of severity of the detected error.
  130.    *  This severity involves the rescue system to stop the further execution if
  131.    *  the detected error is not repaired. E.g. if the rescue system does not
  132.    *  detect any harddisks it makes no sense to go on checking for any errors.
  133.    *  The rescue system will halt.
  134.    *
  135.    *  API function.
  136.    *
  137.    *  @return string The severity of the detected error.
  138.    */
  139.   global define boolean IsErrorSeverityBlocking() ``{
  140.       return ( severity == "blocking");
  141.   };
  142.  
  143.   /**
  144.    *  Returns the level of severity of the detected error. This severity means
  145.    *  that the detected error involves to jump to the next detection module
  146.    *  without executing any further method of the current module. E.g. if the
  147.    *  rescue system detects that the LILO package is not installed on the system
  148.    *  and this error could not be repaired, it makes no sense to check the LILO
  149.    *  configuration file for any errors. So the rescue system jumps to the next
  150.    *  module in the module sequence.
  151.    *
  152.    *  API function.
  153.    *
  154.    *  @return string The severity of the detected error.
  155.    */
  156.   global define boolean IsErrorSeverityModuleBlocking() ``{
  157.       return ( severity == "module_blocking");
  158.   };
  159.  
  160.   /**
  161.    *  Sets the level of severity of the detected error.
  162.    *  API function.
  163.    *  @return string The severity of the detected error.
  164.    */
  165.   global define void ErrorSeverityBlocking() ``{
  166.       severity = "blocking";
  167.   };
  168.  
  169.   /**
  170.    *  Sets the level of severity of the detected error.
  171.    *  API function.
  172.    *  @return string The severity of the detected error.
  173.    */
  174.   global define void ErrorSeverityModuleBlocking() ``{
  175.       severity = "module_blocking";
  176.   };
  177.  
  178.   /**
  179.    *  This function is a wrapper for the definition of the correct status.
  180.    */
  181.   global define void DetectOK2Name(string tnext_detect_method_name) ``{
  182.       status =  "detect_ok";
  183.       severity = "";
  184.       next_detect_method_name = tnext_detect_method_name;
  185.   };
  186.  
  187.   /**
  188.    *  This function is a wrapper for the definition of the correct status.
  189.    */
  190.   global define void DetectError2Name(string tnext_detect_method_name) ``{
  191.       status = "detect_error";
  192.       next_detect_method_name = tnext_detect_method_name;
  193.   };
  194.  
  195.   /**
  196.    *  This function is a wrapper for the definition of the correct status.
  197.    *
  198.    *  API function,
  199.    *
  200.    *  @return void
  201.    */
  202.   global define void DetectProblem2Name(string tnext_detect_method_name) ``{
  203.       status = "detect_problem";
  204.       next_detect_method_name = tnext_detect_method_name;
  205.   };
  206.  
  207.   /**
  208.    *  This function is a wrapper for the definition of the correct status.
  209.    *
  210.    *  API function,
  211.    *
  212.    *  @return void
  213.    */
  214.   global define void RepairOK2Name(string tnext_detect_method_name) ``{
  215.       status   = "repair_ok";
  216.       severity = "";
  217.       next_detect_method_name = tnext_detect_method_name;
  218.   };
  219.  
  220.   /**
  221.    *  This function is a wrapper for the definition of the correct status.
  222.    *
  223.    *  API function,
  224.    *
  225.    *  @return void
  226.    */
  227.   global define void RepairError2Name(string tnext_detect_method_name) ``{
  228.       status = "repair_error";
  229.       next_detect_method_name = tnext_detect_method_name;
  230.   };
  231.  
  232.   /**
  233.    *  This function is a wrapper for the definition of the correct status.
  234.    *
  235.    *  API function,
  236.    *
  237.    *  @return void
  238.    */
  239.   global define void RepairOmit2Name(string tnext_detect_method_name) ``{
  240.       status = "repair_omit";
  241.       next_detect_method_name = tnext_detect_method_name;
  242.   };
  243.  
  244.   /**
  245.    *  This function is a wrapper for the definition of the correct status.
  246.    *
  247.    *  API function,
  248.    *
  249.    *  @return void
  250.    */
  251.   global define void NotFound2Name(string tnext_detect_method_name) ``{
  252.       status = "not_found";
  253.       next_detect_method_name = tnext_detect_method_name;
  254.   };
  255.  
  256.   global define void NotFound()``{
  257.       status   = "not_found";
  258.       severity = "";
  259.       next_detect_method_name = "";
  260.   }
  261.  
  262.   /**
  263.    *  This function is a wrapper for the definition of the correct status.
  264.    *
  265.    *  API function,
  266.    */
  267.   global define void DetectOK() ``{
  268.       status =  "detect_ok";
  269.       severity = "";
  270.       next_detect_method_name = "";
  271.   };
  272.  
  273.   /**
  274.    *  This function is a wrapper for the definition of the correct status.
  275.    *
  276.    *  API function,
  277.    */
  278.   global define void DetectError() ``{
  279.       status = "detect_error";
  280.       next_detect_method_name = "";
  281.   };
  282.  
  283.  
  284.   /**
  285.    *  This function is a wrapper for the definition of the correct status.
  286.    *
  287.    *  API function,
  288.    */
  289.   global define void DetectOmit() ``{
  290.       status = "detect_omit";
  291.       next_detect_method_name = "";
  292.   };
  293.  
  294.   /**
  295.    *  This function is a wrapper for the definition of the correct status.
  296.    *
  297.    *  API function,
  298.    */
  299.   global define void DetectProblem() ``{
  300.       status = "detect_problem";
  301.       next_detect_method_name = "";
  302.   };
  303.  
  304.   /**
  305.    *  This function is a wrapper for the definition of the correct status.
  306.    *
  307.    *  API function,
  308.    */
  309.   global define void RepairOK() ``{
  310.       status   = "repair_ok";
  311.       severity = "";
  312.       next_detect_method_name = "";
  313.   };
  314.  
  315.   /**
  316.    *  This function is a wrapper for the definition of the correct status.
  317.    *
  318.    *  API function,
  319.    */
  320.   global define void RepairError() ``{
  321.       status = "repair_error";
  322.       next_detect_method_name = "";
  323.   };
  324.  
  325.   /**
  326.    *  This function is a wrapper for the definition of the correct status.
  327.    *
  328.    *  API function,
  329.    */
  330.   global define void RepairOmit() ``{
  331.       status = "repair_omit";
  332.       next_detect_method_name = "";
  333.   };
  334.  
  335.   global define void Open() ``{
  336.       status   = "open";
  337.       severity = "";
  338.       next_detect_method_name = "";
  339.   }
  340.  
  341.   global define void Cancel()``{
  342.       status = "cancel";
  343.       severity = "";
  344.       next_detect_method_name = "";
  345.   }
  346.  
  347.  /**
  348.    *  This function is a wrapper for the definition of the correct status.
  349.    *
  350.    *  API function,
  351.    */
  352.   global define void Exit() ``{
  353.       status = "exit";
  354.       next_detect_method_name = "";
  355.   };
  356.  
  357.   /**
  358.    *  This function is a wrapper for the definition of the correct status.
  359.    *
  360.    *  API function,
  361.    *
  362.    *  @return Is OK?
  363.    */
  364.   global define boolean IsStatusDetectOK() ``{
  365.       return ( status ==  "detect_ok");
  366.   };
  367.  
  368.   /**
  369.    *  This function is a wrapper for the definition of the correct status.
  370.    *
  371.    *  API function,
  372.    *
  373.    *  @return Is error?
  374.    */
  375.   global define boolean IsStatusDetectError() ``{
  376.       return ( status == "detect_error");
  377.   };
  378.  
  379.   /**
  380.    *  This function is a wrapper for the definition of the correct status.
  381.    *
  382.    *  API function,
  383.    *
  384.    *  @return Omitted?
  385.    */
  386.   global define boolean IsStatusDetectOmit() ``{
  387.       return ( status == "detect_omit");
  388.   };
  389.  
  390.   /**
  391.    *  This function is a wrapper for the definition of the correct status.
  392.    *
  393.    *  API function,
  394.    *
  395.    *  @return Is detect problem?
  396.    */
  397.   global define boolean IsStatusDetectProblem() ``{
  398.       return ( status == "detect_problem") ;
  399.   };
  400.  
  401.   /**
  402.    *  This function is a wrapper for the definition of the correct status.
  403.    *
  404.    *  API function,
  405.    *
  406.    *  @return Repaired?
  407.    */
  408.   global define boolean IsStatusRepairOK() ``{
  409.       return ( status == "repair_ok");
  410.   };
  411.  
  412.   /**
  413.    *  This function is a wrapper for the definition of the correct status.
  414.    *
  415.    *  API function,
  416.    *
  417.    *  @return Repair failed?
  418.    */
  419.   global define boolean IsStatusRepairError() ``{
  420.       return ( status == "repair_error");
  421.   };
  422.  
  423.   /**
  424.    *  This function is a wrapper for the definition of the correct status.
  425.    *
  426.    *  API function,
  427.    *
  428.    *  @return Repait omitted?
  429.    */
  430.   global define boolean IsStatusRepairOmit() ``{
  431.       return ( status == "repair_omit");
  432.   };
  433.  
  434.   global define boolean IsStatusNotFound()``{
  435.       return ( status == "not_found");
  436.   }
  437.  
  438.   /**
  439.    *  This function is a wrapper for the definition of the correct status.
  440.    *
  441.    *  API function,
  442.    *
  443.    *  @return void
  444.    */
  445.   global define boolean IsStatusExit() ``{
  446.       return ( status == "exit");
  447.   };
  448.  
  449.   global define boolean IsOpen()``{
  450.       return ( status == "open");
  451.   }
  452.  
  453.   global define boolean IsCancel()``{
  454.       return ( status == "cancel");
  455.   }
  456.  
  457. }
  458.