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 / AutoinstSoftware.ycp < prev    next >
Encoding:
Text File  |  2006-11-29  |  12.8 KB  |  440 lines
  1. /**
  2.  * File:    modules/AutoinstSoftware.ycp
  3.  * Package:    Autoyast
  4.  * Summary:    Software
  5.  * Authors:    Anas Nashif <nashif@suse.de>
  6.  *
  7.  * $Id: AutoinstSoftware.ycp 34071 2006-11-06 11:37:19Z ug $
  8.  *
  9.  */
  10. {
  11.     module "AutoinstSoftware";
  12.     textdomain "autoinst";
  13.  
  14.     import "Profile";
  15.     import "Summary";
  16.     import "Stage";
  17.     import "SpaceCalculation";
  18.     import "Packages";
  19.     import "Popup";
  20.     import "Report";
  21.     import "Kernel";
  22.     import "AutoinstConfig";
  23.     import "ProductControl";
  24.     import "Storage";
  25.     import "Mode";
  26.  
  27.     import "PackageAI";
  28.  
  29.     global map Software = $[];
  30.  
  31.     global map<string, any> image = $[];
  32.  
  33.     // patterns
  34.     global list<string> patterns = [];
  35.  
  36.     // Kernel, force type of kernel to be installed
  37.     global string kernel = "";
  38.  
  39.     // Packages that should be installed in continue mode
  40.     global list<string> post_packages = [];
  41.  
  42.     global string ft_module = "";
  43.  
  44.     /* Enable Imaging */
  45.     global boolean imaging = false;
  46.  
  47.     /* default value of settings modified */
  48.     global boolean modified = false;
  49.  
  50.     /**
  51.      * Function sets internal variable, which indicates, that any
  52.      * settings were modified, to "true"
  53.      */
  54.     global define void SetModified ()
  55.     {
  56.         modified = true;
  57.     }
  58.  
  59.     /**
  60.      * Functions which returns if the settings were modified
  61.      * @return boolean  settings were modified
  62.      */
  63.     global define boolean GetModified ()
  64.     {
  65.         return modified;
  66.     }
  67.  
  68.  
  69.     /**
  70.      * Import data
  71.      * @param settings settings to be imported
  72.      * @return true on success
  73.      */
  74.     global define boolean Import(map settings)
  75.     {
  76.         Software = settings;
  77.         patterns = settings["patterns"]:[];
  78.  
  79.         string notFound = "";
  80.         Packages::Init(true);
  81.         Packages::InitializeAddOnProducts();
  82.         foreach( string pack, settings["packages"]:[], ``{
  83.             if( ! Pkg::IsAvailable(pack) && Stage::initial() ) {
  84.                 notFound = notFound + pack + "\n";
  85.             }
  86.         });
  87.         if( size(notFound) > 0 ) {
  88.             y2error("packages not found: %1",notFound);
  89.             // warning text during the installation. %1 is a list of package names
  90.             Report::Error( sformat(_("These packages could not be found on the installation source:\n%1"), notFound));
  91.         }
  92.  
  93.         PackageAI::toinstall  = settings["packages"]:[];
  94.         kernel = settings["kernel"]:"";
  95.         post_packages = settings["post-packages"]:[];
  96.         PackageAI::toremove  =  settings["remove-packages"]:[];
  97.  
  98.         /* Imaging */
  99.         /*
  100.         map<string, any> image = settings["system_images"]:$[];
  101.         imaging = image["enable_multicast_images"]:false;
  102.         ft_module = image["module_name"]:"";
  103.         if (settings == $[])
  104.             modified = false;
  105.         else
  106.             modified = true;
  107.         */
  108.         image = settings["image"]:$[];
  109.         if( size(image) > 0 )
  110.             imaging=true;
  111.  
  112.         return true;
  113.     }
  114.  
  115.     /**
  116.      * Constructer
  117.      */
  118.     global define void AutoinstSoftware()
  119.     {
  120.         if ( Stage::cont () && Mode::autoinst ())
  121.         {
  122.         Pkg::TargetInit ("/", false);
  123.             Import(Profile::current["software"]:$[]);
  124.         }
  125.         return;
  126.     }
  127.  
  128.     /**
  129.      * Export data
  130.      * @return dumped settings (later acceptable by Import())
  131.      */
  132.     global define map Export()
  133.     {
  134.         map s = $[];
  135.         if (kernel != "")
  136.             s["kernel"] = kernel ;
  137.  
  138.         if( patterns != [])
  139.             s["patterns"] = patterns;
  140.  
  141.         if (PackageAI::toinstall != [])
  142.             s["packages"] = PackageAI::toinstall;
  143.  
  144.         if (post_packages != [])
  145.             s["post-packages"] = post_packages ;
  146.  
  147.         if (PackageAI::toremove != [])
  148.             s["remove-packages"] = PackageAI::toremove;
  149.  
  150.  
  151.         return (s);
  152.     }
  153.  
  154.  
  155.     /**
  156.      * Add packages needed by modules, i.e. NIS, NFS etc.
  157.      * @param list of strings packages to add
  158.      * @return void
  159.      */
  160.     global define void AddModulePackages(list<string> module_packages)
  161.     {
  162.         PackageAI::toinstall = toset((list<string>)
  163.                 union(PackageAI::toinstall,  module_packages));
  164.         //
  165.         // Update profile
  166.         //
  167.         Profile::current["software"] = Export();
  168.         return;
  169.     }
  170.  
  171.     /**
  172.      * Remove packages not needed by modules, i.e. NIS, NFS etc.
  173.      * @param list of packages to remove
  174.      * @return void
  175.      */
  176.     global define void RemoveModulePackages (list<string> module_packages)
  177.     {
  178.         PackageAI::toinstall = filter(string p, PackageAI::toinstall, ``(!contains(module_packages,p)));
  179.         Profile::current["software"] = Export();
  180.         return;
  181.     }
  182.  
  183.  
  184.  
  185.     /**
  186.      * Summary
  187.      * @return Html formatted configuration summary
  188.      */
  189.     global define string Summary()
  190.     {
  191.         string summary = "";
  192.         
  193.         summary = Summary::AddHeader(summary, _("Selected Patterns"));
  194.         if (size( patterns ) > 0 )
  195.         {
  196.             summary = Summary::OpenList(summary);
  197.             foreach(string a, patterns, ``{
  198.                 summary = Summary::AddListItem(summary, a);
  199.             });
  200.             summary = Summary::CloseList(summary);
  201.         }
  202.         else
  203.         {
  204.             summary = Summary::AddLine(summary, Summary::NotConfigured());
  205.         }
  206.         summary = Summary::AddHeader(summary, _("Individually Selected Packages"));
  207.         summary = Summary::AddLine(summary, sformat("%1",
  208.                     size(PackageAI::toinstall)));
  209.  
  210.         summary = Summary::AddHeader(summary, _("Packages to Remove"));
  211.         summary = Summary::AddLine(summary, sformat("%1",
  212.                     size(PackageAI::toremove)));
  213.  
  214.         if (kernel != "")
  215.         {
  216.             summary = Summary::AddHeader(summary, _("Force Kernel Package"));
  217.             summary = Summary::AddLine(summary, sformat("%1", kernel));
  218.         }
  219.         return summary;
  220.     }
  221.     /**
  222.      * Compute list of packages selected by user and other packages needed for important
  223.      * configuration modules.
  224.      * @return list of strings list of packages needed for autoinstallation
  225.      */
  226.     global define list<string> autoinstPackages()
  227.     {
  228.  
  229.         list<string> allpackages = [];
  230.  
  231.         // the primary list of packages
  232.         allpackages = (list<string>) union (allpackages,  PackageAI::toinstall);
  233.  
  234.         // In autoinst mode, a kernel should not be  available
  235.         // in <packages>
  236.         if ( size(kernel) == 0)
  237.         {
  238.             list <string> kernel_pkgs = Kernel::ComputePackages ();
  239.             allpackages = (list <string>) union (allpackages, kernel_pkgs);
  240.         }
  241.         else
  242.         {
  243.             if (Pkg::IsAvailable (kernel))
  244.             {
  245.                 allpackages = add (allpackages, kernel);
  246.                 string kernel_nongpl = kernel + "-nongpl";
  247.  
  248.                 if (Pkg::IsAvailable (kernel_nongpl))
  249.                     allpackages = add (allpackages, kernel_nongpl);
  250.             }
  251.             else
  252.             {
  253.                 y2warning ("%1 not available, using kernel-default", kernel);
  254.                 list <string> kernel_pkgs = Kernel::ComputePackages ();
  255.                 allpackages = (list <string>) union (allpackages, kernel_pkgs);
  256.             }
  257.         }
  258.  
  259.         if (haskey(Profile::current, "inetd")) {
  260.                 map conf = Profile::current["inetd"]:$[];
  261.                 if (conf["netd_service"]:`none == `xinetd )
  262.                         allpackages = (list<string>) union(allpackages,
  263.                                 ["xinetd"]);
  264.                 else
  265.                         allpackages = (list<string>) union(allpackages,
  266.                                 ["inetd"]);
  267.  
  268.         }
  269.  
  270.         if (haskey(Profile::current, "nis")) {
  271.                 map conf = Profile::current["nis"]:$[];
  272.                 if (conf["start_nis"]:false)
  273.                         allpackages = (list<string>) union(allpackages, ["yast2-nis-client","ypbind"]);
  274.  
  275.                 if (conf["start_autofs"]:false)
  276.                 {
  277.                     string pkg = "autofs4";
  278.                     allpackages = add (allpackages, pkg);
  279.                 }
  280.         }
  281.  
  282.         if (haskey(Profile::current, "security")) {
  283.             allpackages = (list<string>) union(allpackages,
  284.                     ["yast2-security"]);
  285.         }
  286.  
  287.         if (haskey(Profile::current, "ldap")) {
  288.                 map ldapclient = Profile::current["ldap"]:$[];
  289.                 if (ldapclient["start_ldap"]:false)
  290.                         allpackages = (list<string>) union(allpackages, ["pam_ldap","nss_ldap"]);
  291.                 if (ldapclient["start_autofs"]:false)
  292.                 {
  293.                     string pkg = "autofs4";
  294.                     allpackages = add (allpackages, pkg);
  295.                 }
  296.         }
  297.  
  298.         if (haskey(Profile::current, "nfs_server"))
  299.         {
  300.             boolean start_nfsserver = Profile::current["nfs_server", "start_nfsserver"]:false;
  301.             if (start_nfsserver)
  302.                 allpackages = (list<string>) union(allpackages, ["yast2-nfs-server", "nfs-utils"]);
  303.         }
  304.  
  305.  
  306.         if (haskey(Profile::current, "mail")) {
  307.                 map mail = Profile::current["mail"]:$[];
  308.                 if (mail["mta"]:`other == `postfix)
  309.                 {
  310.                         allpackages = add(allpackages, "postfix");
  311.                         PackageAI::toremove = add(PackageAI::toremove, "sendmail");
  312.                         if (mail["use_amavis"]:false)
  313.                                 allpackages = add(allpackages, "amavis-postfix");
  314.                 }
  315.                 else if (mail["mta"]:`other == `sendmail)
  316.                 {
  317.                         allpackages = add(allpackages, "sendmail");
  318.                         PackageAI::toremove = add(PackageAI::toremove, "postfix");
  319.  
  320.                         if (mail["use_amavis"]:false)
  321.                                 allpackages = add(allpackages, "amavis-sendmail");
  322.                 }
  323.         }
  324.         return allpackages;
  325.     }
  326.  
  327.  
  328.  
  329.     /**
  330.      * Configure software settings
  331.      * @param void
  332.      * @return boolean
  333.      */
  334.     global define boolean Write()
  335.     {
  336.  
  337.         if (imaging)
  338.         {
  339.             if( ! image["run_kickoff"]:false )
  340.                 ProductControl::DisabledModules=add(ProductControl::DisabledModules, "kickoff");
  341.             ProductControl::DisabledModules=add(ProductControl::DisabledModules, "rpmcopy");
  342.             return true;
  343.         }
  344.  
  345.         boolean ok = true;
  346.  
  347.         Packages::Init(true);
  348.         list<string> failed = [];
  349.  
  350.         /* set SoftLock to avoid the installation of recommended patterns (#159466) */
  351.         foreach( map<string,any> p, Pkg::ResolvableProperties ("", `pattern, ""), ``{
  352.             Pkg::ResolvableSetSoftLock( p["name"]:"", `pattern );
  353.         });
  354.  
  355.         foreach(string p, toset(patterns),
  356.                 ``{
  357.             if (! Pkg::ResolvableInstall( p, `pattern ) )
  358.             {
  359.                 failed = add(failed, p);
  360.             }
  361.         });
  362.  
  363.         if (size(failed) > 0 )
  364.         {
  365.             y2error("Error while setting pattern: %1",  mergestring(failed, ","));
  366.             Report::Warning(sformat(_("Could not set patterns: %1."), mergestring(failed, ",")));
  367.         }
  368.  
  369.         list<string> autoinstPacks = autoinstPackages ();
  370.         y2milestone("Packages selected in autoinstall mode: %1", autoinstPacks);
  371.  
  372.         if (size(autoinstPacks) > 0 )
  373.         {
  374.             y2milestone("Installing individual packages: %1", Pkg::DoProvide(autoinstPacks) );
  375.         }
  376.  
  377.  
  378.         list<string> computed_packages = Packages::ComputeSystemPackageList();
  379.         y2debug("Computed list of packages: %1", computed_packages);
  380.  
  381.  
  382.         //
  383.         // Now remove all packages listed in remove-packages
  384.         //
  385.         y2milestone("Packages to be removed: %1", PackageAI::toremove);
  386.         if (size(PackageAI::toremove) > 0 )
  387.         {
  388.             foreach (string rp, PackageAI::toremove, ``{
  389.                 //Pkg::ResolvableSetSoftLock( rp, `package ); // FIXME: maybe better Pkg::PkgTaboo(rp) ?
  390.                 Pkg::PkgTaboo(rp);
  391.             });
  392.  
  393.             Pkg::DoRemove(PackageAI::toremove);
  394.         }
  395.         list<string> pack = Storage::AddPackageList();
  396.         if( size(pack)>0 )
  397.         {
  398.             y2milestone("Installing storage packages: %1", Pkg::DoProvide( pack ));
  399.         }
  400.         //
  401.         // Solve dependencies
  402.         //
  403.         Pkg::PkgSolve(false);
  404.  
  405.         SpaceCalculation::ShowPartitionWarning();
  406.  
  407.         return (ok);
  408.     }
  409.  
  410.  
  411.     /**
  412.      * Initialize temporary target
  413.      */
  414.     global define void  pmInit()
  415.     {
  416.  
  417. //        string tmproot = AutoinstConfig::tmpDir;
  418.  
  419. //        SCR::Execute(.target.mkdir, tmproot + "/root");
  420. //        Pkg::TargetInit( tmproot + "/root", true);
  421.         Pkg::TargetInit( "/", true);
  422.         y2milestone("SourceStartCache: %1", Pkg::SourceStartCache(false));
  423.         return;
  424.     }
  425.  
  426.  
  427.     /**
  428.      * Add post packages
  429.      * @param list calculated post packages
  430.      * @return void
  431.      */
  432.     global define void addPostPackages(list<string> calcpost)
  433.     {
  434.         post_packages = (list<string>)toset(union(calcpost,post_packages));
  435.         return;
  436.     }
  437.  
  438.     //EOF
  439. }
  440.