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 / SLP.ycp < prev    next >
Encoding:
Text File  |  2006-11-29  |  7.1 KB  |  223 lines
  1. /**
  2.  * File:    modules/SLP.ycp
  3.  * Package:    SLP Browser / Agent
  4.  * Summary:    Access to SLP Agent functions
  5.  * Authors:    Anas Nashif <nashif@suse.de>
  6.  *
  7.  * $Id: SLP.ycp 32847 2006-09-13 08:54:30Z jsuchome $
  8.  *
  9.  */
  10. {
  11.  
  12.     module "SLP";
  13.     textdomain "slp";
  14.     import "Summary";
  15.     import "HTML";
  16.  
  17.  
  18.     string Regd = "/etc/slp.reg.d";
  19.  
  20.     /**
  21.       * Issue the query for services
  22.       * @param pcServiceType The Service Type String, including authority string if
  23.       * any, for the request, such as can be discovered using  SLPSrvTypes(). 
  24.       * This could be, for example "service:printer:lpr" or "service:nfs".
  25.       * @param pcScopeList comma separated  list of scope names to search for
  26.       * service types.
  27.       * @return list<map> List of Services
  28.       */
  29.     global define list<map> FindSrvs( string pcServiceType, string pcScopeList)
  30.     {
  31.         list<map> Srvs = (list<map>) SCR::Read(.slp.findsrvs,
  32.                 $["pcServiceType":pcServiceType, "pcScopeList": pcScopeList] );
  33.         y2debug("FindSrvs: %1",  Srvs);
  34.         return Srvs;
  35.     }
  36.  
  37.     /**
  38.       * Issues an SLP service type request for service types in the scopes
  39.       * indicated by the pcScopeList.
  40.       *
  41.       * If the naming authority is "*", then
  42.       * results are returned for all naming authorities.  If the naming
  43.       * authority is the empty string, i.e.  "", then the default naming
  44.       * authority, "IANA", is used.
  45.       *
  46.       * @param pcNamingAuthority The naming authority to search.
  47.       * @param pcScopeList  comma separated  list of scope names to search for
  48.       * service types.
  49.       * @return list<string> Service Types
  50.       */
  51.     global define list<string> FindSrvTypes ( string pcNamingAuthority , string pcScopeList)
  52.     {
  53.         list<string> Types = (list<string>) SCR::Read(.slp.findsrvtypes,
  54.                                 $["pcNamingAuthority":pcNamingAuthority ,
  55.                                   "pcScopeList": pcScopeList] );
  56.         return Types;
  57.     }
  58.  
  59.  
  60.  
  61.     /**
  62.       * Find attributes of a service
  63.       * @param pcURLOrServiceType service url or type
  64.       * @return list<string> attributes
  65.       */
  66.     global define list<string> FindAttrs ( string pcURLOrServiceType )
  67.     {
  68.         list<string> Attrs = (list<string>) SCR::Read(.slp.findattrs,
  69.                                 $["pcURLOrServiceType":pcURLOrServiceType] );
  70.         return Attrs;
  71.     }
  72.  
  73.     /**
  74.       * Find attributes of a service using a unicast query
  75.       * @param pcURLOrServiceType service url or type
  76.       * @param ip IP address of the server
  77.       * @return list<string> attributes
  78.       */
  79.     global define list<string> UnicastFindAttrs (
  80.     string pcURLOrServiceType, string ip)
  81.     {
  82.     if (ip == "") return FindAttrs (pcURLOrServiceType);
  83.  
  84.         list<string> Attrs = (list<string>) SCR::Read(.slp.unicastfindattrs,
  85.             $[
  86.         "pcURLOrServiceType"    : pcURLOrServiceType,
  87.         "ip-address"        : ip
  88.         ]
  89.     );
  90.         return Attrs;
  91.     }
  92.  
  93.     /**
  94.       * Find attributes (using unicast query) of a service and return a map
  95.       * @param pcURLOrServiceType service url or type
  96.       * @param ip IP address of the server
  97.       * @return map<string,string> attributes
  98.       */
  99.     global define map<string,string> GetUnicastAttrMap (
  100.     string pcURLOrServiceType, string ip)
  101.     {
  102.         list<string> Attrs = UnicastFindAttrs (pcURLOrServiceType, ip);
  103.         return (map<string, string>) listmap(string a, Attrs, {
  104.             string s = substring(a, 1, size(a) - 2 );
  105.             list aa = splitstring(s, "=");
  106.             return $[    aa[0]:"empty" : aa[1]:"empty"    ];
  107.         });
  108.     }
  109.  
  110.     /**
  111.       * Find attributes of a service and return a map
  112.       * @param pcURLOrServiceType service url or type
  113.       * @return map<string,string> attributes
  114.       */
  115.     global define map<string,string> GetAttrMap(string pcURLOrServiceType)
  116.     {
  117.  
  118.             list<string> Attrs = FindAttrs (pcURLOrServiceType);
  119.             map<string, string> att = (map<string, string>)listmap(string a, Attrs, ``{
  120.                     string s = substring(a, 1, size(a) - 2 );
  121.                     list aa = splitstring(s, "=");
  122.                     return($[aa[0]:"empty":aa[1]:"empty"]);
  123.                     });
  124.             return att;
  125.         }
  126.  
  127.     /**
  128.       * Attribute summary
  129.       * @param Attrs attribute list
  130.       * @return string summary
  131.       */
  132.     global define string AttrSummary (list<string> Attrs)
  133.     {
  134.        string summary = "";
  135.        summary = Summary::AddHeader(summary, _("Attributes"));
  136.        summary = Summary::OpenList      ( summary );
  137.        foreach(string a, Attrs, ``{
  138.                string s = substring(a, 1, size(a) - 2 );
  139.                list aa = splitstring(s, "=");
  140.                summary = Summary::AddListItem   ( summary, sformat("%1: %2",
  141.                    HTML::Bold(aa[0]:""), aa[1]:"") );
  142.                });
  143.  
  144.        summary = Summary::CloseList     ( summary );
  145.        return summary;
  146.     }
  147.  
  148.     /**
  149.       * Register service with SLP
  150.       * @param service Service to be registered
  151.       * @return boolean True on success
  152.       */
  153.     global define boolean Reg(string service)
  154.     {
  155.         boolean ret = (boolean)SCR::Execute(.slp.reg, service);
  156.         return ret;
  157.     }
  158.  
  159.     /**
  160.       * Deregister service with SLP
  161.       * @param service Service to be deregistered
  162.       * @return boolean True on success
  163.       */
  164.     global define boolean DeReg(string service)
  165.     {
  166.  
  167.         boolean ret = (boolean)SCR::Execute(.slp.dereg, service);
  168.         return ret;
  169.     }
  170.  
  171.     /**
  172.       * Register service with SLP using a reg file
  173.       * @param service The service to be registered
  174.       * @param attr Attributes
  175.       * @param regfile Reg File
  176.       * @return boolean True on Success
  177.       */
  178.     global define boolean RegFile(string service, map<string,string> attr, string regfile)
  179.     {
  180.         list<string> slp = [];
  181.         slp=add(slp, service);
  182.         foreach(string k, string v , attr, ``{
  183.                 slp=add(slp, sformat("%1=%2", tolower(k), v ));
  184.                 });
  185.  
  186.         string all = mergestring(slp, "\n");
  187.         SCR::Execute(.target.mkdir, Regd );
  188.         boolean ret =(boolean) SCR::Write(.target.string,    sformat("%1/%2", Regd, regfile), all);
  189.         return ret;
  190.     }
  191.  
  192.     /**
  193.       * De-Register service with SLP by removing the reg file
  194.       * @param regfile The service to be deregistered
  195.       * @return boolean True on success
  196.       */
  197.     global define boolean DeRegFile(string regfile)
  198.     {
  199.         boolean ret = (boolean)SCR::Execute(.target.remove, regfile);
  200.         return ret;
  201.     }
  202.     /**
  203.      * Match Srv Type and return all data
  204.      * @param match match string
  205.      * @return list<map> list of services matching with all relevant data
  206.      */
  207.     global define list<map> MatchType (string match )
  208.     {
  209.         list<string> t = FindSrvTypes("*", "");
  210.         list<map> ret = [];
  211.         foreach(string type , t, {
  212.                 if (regexpmatch(type, match)) {
  213.                     list<map> matched = FindSrvs(type, "");
  214.                     ret = (list<map>) union(ret , maplist(map m, matched, ``{
  215.                             m["attr"] = GetAttrMap(m["srvurl"]:"");
  216.                             return(m);
  217.                             }));
  218.                 }
  219.                 });
  220.        return ret;
  221.     }
  222. }
  223.