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 / FileUtils.ycp < prev    next >
Text File  |  2006-11-29  |  9KB  |  301 lines
  1. /**
  2.  * File:        modules/FileUtils.ycp
  3.  * Package:     YaST2
  4.  * Authors:     Lukas Ocilka <lukas.ocilka@suse.cz>
  5.  * Summary:     Module for getting information about files and directories.
  6.  *        Their types and sizes and functions for checking, creating and
  7.  *        removing them.
  8.  * Flags:    Stable
  9.  *
  10.  * $Id: FileUtils.ycp 33224 2006-10-02 14:17:13Z jsrain $
  11.  */
  12. {
  13.     module "FileUtils";
  14.     
  15.     textdomain "base";
  16.  
  17.     import "SCR";
  18.     import "Popup";
  19.  
  20.     /**
  21.      * Function which determines if the requested file/directory exists.
  22.      *
  23.      * @return    true if exists
  24.      * @param    string file name
  25.      */
  26.     global define boolean Exists (string target) {
  27.     map info = (map) SCR::Read(.target.stat, target);
  28.  
  29.     if (info != $[]) {
  30.         return true;
  31.     }
  32.     return false;
  33.     }
  34.  
  35.     /**
  36.      * Function which determines if the requested file/directory is a directory
  37.      * or it is a link to a directory.
  38.      *
  39.      * @return    true if it is a directory, nil if doesn't exist
  40.      * @param    string file name
  41.      */
  42.     global define boolean IsDirectory (string target) {
  43.     map info = (map) SCR::Read(.target.stat, target);
  44.     boolean defaultv = (info != $[] ? false:nil);
  45.  
  46.     return (boolean) info["isdir"]:defaultv;
  47.     }
  48.  
  49.     /**
  50.      * Function which determines if the requested file/directory is a regular file
  51.      * or it is a link to a regular file.
  52.      *
  53.      * @return    true if it is a regular file, nil if doesn't exist
  54.      * @param    string file name
  55.      */
  56.     global define boolean IsFile (string target) {
  57.     map info = (map) SCR::Read(.target.stat, target);
  58.     boolean defaultv = (info != $[] ? false:nil);
  59.  
  60.     return (boolean) info["isreg"]:defaultv;
  61.     }
  62.  
  63.     /**
  64.      * Function which determines if the requested file/directory is a block file (device)
  65.      * or link to a block device.
  66.      *
  67.      * @return    true if it is a block file, nil if doesn't exist
  68.      * @param    string file name
  69.      */
  70.     global define boolean IsBlock (string target) {
  71.     map info = (map) SCR::Read(.target.stat, target);
  72.     boolean defaultv = (info != $[] ? false:nil);
  73.  
  74.     return (boolean) info["isblock"]:defaultv;
  75.     }
  76.  
  77.     /**
  78.      * Function which determines if the requested file/directory is a fifo
  79.      * or link to a fifo.
  80.      *
  81.      * @return    true if it is a fifo, nil if doesn't exist
  82.      * @param    string file name
  83.      */
  84.     global define boolean IsFifo (string target) {
  85.     map info = (map) SCR::Read(.target.stat, target);
  86.     boolean defaultv = (info != $[] ? false:nil);
  87.  
  88.     return (boolean) info["isfifo"]:defaultv;
  89.     }
  90.  
  91.     /**
  92.      * Function which determines if the requested file/directory is a link.
  93.      *
  94.      * @return    true if it is a link, nil if doesn't exist
  95.      * @param    string file name
  96.      */
  97.     global define boolean IsLink (string target) {
  98.     map info = (map) SCR::Read(.target.lstat, target);
  99.     boolean defaultv = (info != $[] ? false:nil);
  100.  
  101.     return (boolean) info["islink"]:defaultv;
  102.     }
  103.  
  104.     /**
  105.      * Function which determines if the requested file/directory is a socket
  106.      * or link to a socket.
  107.      *
  108.      * @return    true if it is a socket, nil if doesn't exist
  109.      * @param    string file name
  110.      */
  111.     global define boolean IsSocket (string target) {
  112.     map info = (map) SCR::Read(.target.stat, target);
  113.     boolean defaultv = (info != $[] ? false:nil);
  114.  
  115.     return (boolean) info["issock"]:defaultv;
  116.     }
  117.  
  118.     /**
  119.      * Function which determines if the requested file/directory is
  120.      * a character device or link to a character device.
  121.      *
  122.      * @return    true if it is a charcater device, nil if doesn't exist
  123.      * @param    string file name
  124.      */
  125.     global define boolean IsCharacterDevice (string target) {
  126.     map info = (map) SCR::Read(.target.stat, target);
  127.     boolean defaultv = (info != $[] ? false:nil);
  128.  
  129.     return (boolean) info["ischr"]:defaultv;
  130.     }
  131.  
  132.     /**
  133.      * Function returns the real type of requested file/directory.
  134.      * If the file is a link to any object, "link" is returned.
  135.      *
  136.      * @return    string fle type (directory|regular|block|fifo|link|socket|chr_device), nil if doesn't exist
  137.      * @param    string file name
  138.      */
  139.     global define string GetFileRealType (string target) {
  140.     map info = (map) SCR::Read(.target.lstat, target);
  141.  
  142.     if (info["islink"]:false == true) {
  143.         return "link";
  144.     } else if (info["isdir"]:false == true) {
  145.         return "directory";
  146.     } else if (info["isreg"]:false == true) {
  147.         return "regular";
  148.     } else if (info["isblock"]:false == true) {
  149.         return "block";
  150.     } else if (info["isfifo"]:false == true) {
  151.         return "fifo";
  152.     } else if (info["issock"]:false == true) {
  153.         return "socket";
  154.     } else if (info["ischr"]:false == true) {
  155.         return "chr_device";
  156.     } else {
  157.         return nil;
  158.     }
  159.     }
  160.  
  161.     /**
  162.      * Function returns the type of requested file/directory.
  163.      * If the file is a link to any object, the object's type is returned.
  164.      *
  165.      * @return    string fle type (directory|regular|block|fifo|link|socket|chr_device), nil if doesn't exist
  166.      * @param    string file name
  167.      */
  168.     global define string GetFileType (string target) {
  169.     map info = (map) SCR::Read(.target.stat, target);
  170.  
  171.     
  172.     if (info["isdir"]:false == true) {
  173.         return "directory";
  174.     } else if (info["isreg"]:false == true) {
  175.         return "regular";
  176.     } else if (info["isblock"]:false == true) {
  177.         return "block";
  178.     } else if (info["isfifo"]:false == true) {
  179.         return "fifo";
  180.     } else if (info["issock"]:false == true) {
  181.         return "socket";
  182.     } else if (info["islink"]:false == true) {
  183.         return "link";
  184.     } else if (info["ischr"]:false == true) {
  185.         return "chr_device";
  186.     } else {
  187.         return nil;
  188.     }
  189.     }
  190.  
  191.     /**
  192.      * Function which returns the size of requested file/directory.
  193.      *
  194.      * @return    integer file size, -1 if doesn't exist
  195.      * @param    string file name
  196.      */
  197.     global define integer GetSize (string target) {
  198.     return (integer) SCR::Read(.target.size, target);
  199.     }
  200.  
  201.     /**
  202.      * Function which determines the owner's user ID of requested file/directory.
  203.      *
  204.      * @return    integer UID, nil if doesn't exist
  205.      * @param    string file name
  206.      */
  207.     global define integer GetOwnerUserID (string target) {
  208.     map info = (map) SCR::Read(.target.stat, target);
  209.  
  210.     return (integer) info["uid"]:nil;
  211.     }
  212.  
  213.     /**
  214.      * Function which determines the owner's group ID of requested file/directory.
  215.      *
  216.      * @return    integer GID, nil if doesn't exist
  217.      * @param    string file name
  218.      */
  219.     global define integer GetOwnerGroupID (string target) {
  220.     map info = (map) SCR::Read(.target.stat, target);
  221.  
  222.     return (integer) info["gid"]:nil;
  223.     }
  224.  
  225.  
  226.     /**
  227.      * Checks whether the path (directory) exists and return a boolean
  228.      * value whether everything is OK or user accepted the behavior as
  229.      * despite some errors. If the directory doesn't exist, it offers
  230.      * to create it (and eventually creates it).
  231.      *
  232.      * @param string pathvalue (directory)
  233.      * @return boolean whether everything was OK or whether user decided to ignore eventual errors
  234.      *
  235.      * @unstable
  236.      */
  237.     global define boolean CheckAndCreatePath (string pathvalue) {
  238.         string check_path = pathvalue;
  239.  
  240.         // remove the final slash
  241.         if (regexpmatch(check_path, "/$")) check_path = regexpsub(check_path, "^(.*)/$", "\\1");
  242.         y2milestone("Checking existency of %1 path", check_path);
  243.  
  244.         // Directory (path) already exists
  245.         if (FileUtils::Exists(check_path)) {
  246.             y2milestone("Path %1 exists", check_path);
  247.             // Directory (path) is a type 'directory'
  248.             if (FileUtils::IsDirectory(check_path)) {
  249.                 return true;
  250.             // Directory (path) is not a valid 'directory'
  251.             } else {
  252.                 y2warning ("Path %1 is not a directory", check_path);
  253.                 // Continue despite the error?
  254.                 return Popup::ContinueCancel(sformat(
  255.                     // TRANSLATORS: popup question (with continue / cancel buttons)
  256.                     // %1 is the filesystem path
  257.                     _("Although the path %1 exists, it is not a directory.
  258. Continue or cancel the operation?
  259. "),
  260.                     pathvalue
  261.                 ));
  262.             }
  263.         // Directory (path) doesn't exist, trying to create it if wanted
  264.         } else {
  265.             y2milestone("Path %1 does not exist", check_path);
  266.             if (Popup::YesNo(sformat(
  267.             // TRANSLATORS: question popup (with yes / no buttons). A user entered non-existent path
  268.         // for a share, %1 is entered path
  269.         _("The path %1 does not exist.
  270. Create it now?
  271. "),
  272.             pathvalue
  273.         ))) {
  274.             // Directory creation successful
  275.             if ((boolean) SCR::Execute(.target.mkdir, check_path)) {
  276.             y2milestone("Directory %1 successfully created", check_path);
  277.                 return true;
  278.             // Failed to create the directory
  279.             } else {
  280.                     y2warning("Failed to create directory %1", check_path);
  281.                     // Continue despite the error?
  282.                     return Popup::ContinueCancel(sformat(
  283.                     // TRANSLATORS: popup question (with continue / cancel buttons)
  284.                     // %1 is the name (path) of the directory
  285.                     _("Failed to create the directory %1.
  286. Continue or cancel the current operation?
  287. "),
  288.                     pathvalue
  289.                 ));
  290.             }
  291.         // User doesn't want to create the directory
  292.             } else {
  293.             y2warning("User doesn't want to create the directory %1", check_path);
  294.             return true;
  295.             }
  296.     }
  297.     }
  298.  
  299. /* EOF */
  300. }
  301.