src/bindings/python/elektra.py

   1 #!/usr/bin/python
   2
   3 import libpyelektra
   4
   5 class ElektraException(Exception):
   6         def __init__(self,msg):
   7                 self.msg=msg
   8         def __str__(self):
   9                 return self.msg
  10
  11 class Kdb:
  12         """General methods to acces the key database
  13 """
  14         def __init__(self):
  15                 self.__kdb__pointer__=libpyelektra.kdbOpen()
  16         def __del__(self):
  17                 libpyelektra.kdbClose(self.__kdb__pointer__)
  18
  19         #def close(self):
  20         #       """Closes the backend."""
  21         #       libpyelektra.kdbClose(self.__kdb__pointer__)
  22
  23         def getKey(self,key):
  24                 """Gets key from backend storage."""
  25                 return libpyelektra.kdbGetKey(self.__kdb__pointer__,key.__key__pointer__)
  26         def getKeyChildKeys(self, key, *args, **kargs):
  27                 options=0
  28                 if 'norecursive' in kargs and kargs['norecursive']: options+=1
  29                 if 'excldir' in kargs and kargs['excldir']: options+=2
  30                 if 'dironly' in kargs and kargs['dironly']: options+=4
  31                 if 'noempty' in kargs and kargs['noempty']: options+=8
  32                 if 'statonly' in kargs and kargs['statonly']: options+=16
  33                 if 'inactive' in kargs and kargs['inactive']: options+=32
  34                 if 'unsort' in kargs and kargs['unsort']: options+=64
  35                 if 'nfollowlink' in kargs and kargs['nfollowlink']: options+=128
  36                 #if kargs['condensed']: options+=256
  37                 #if kargs['numbers']: options+=512
  38                 #if kargs['xmlheaders']: options+=1024
  39                 #if kargs['fullname']: options+=2048
  40                 #if kargs['fullugid']: options+=4096
  41                 #if kargs['hier']: options+=8192
  42                 #if kargs['nocase']: options+=16384
  43                 #if kargs['nospanparent']: options+=32768
  44                 #if kargs['all']: options+=131072
  45                 keySet=KeySet(libpyelektra.ksNew())
  46                 libpyelektra.kdbGetKeyChildKeys(self.__kdb__pointer__,key,keySet.__keyset__pointer__,options)
  47                 return keySet
  48         def getChildKeys(self, name, *args, **kargs):
  49                 options=0
  50                 if 'norecursive' in kargs and kargs['norecursive']: options+=1
  51                 if 'excldir' in kargs and kargs['excldir']: options+=2
  52                 if 'dironly' in kargs and kargs['dironly']: options+=4
  53                 if 'noempty' in kargs and kargs['noempty']: options+=8
  54                 if 'statonly' in kargs and kargs['statonly']: options+=16
  55                 if 'inactive' in kargs and kargs['inactive']: options+=32
  56                 if 'unsort' in kargs and kargs['unsort']: options+=64
  57                 if 'nfollowlink' in kargs and kargs['nfollowlink']: options+=128
  58                 #if kargs['condensed']: options+=256
  59                 #if kargs['numbers']: options+=512
  60                 #if kargs['xmlheaders']: options+=1024
  61                 #if kargs['fullname']: options+=2048
  62                 #if kargs['fullugid']: options+=4096
  63                 #if kargs['hier']: options+=8192
  64                 #if kargs['nocase']: options+=16384
  65                 #if kargs['nospanparent']: options+=32768
  66                 #if kargs['all']: options+=131072
  67                 keySet=KeySet(libpyelektra.ksNew())
  68                 libpyelektra.kdbGetChildKeys(self.__kdb__pointer__,name,keySet.__keyset__pointer__,options)
  69                 return keySet
  70         def setKey(self,key):
  71                 """Sets key in the backend storage."""
  72                 return libpyelektra.kdbSetKey(self.__kdb__pointer__,key.__key__pointer__)
  73         def setKeys(self,keyset):
  74                 """Commits the ks KeySet to the backend storage, starting from ks's current position until its end.
  75 This is why it is suggested that you call rewind() on ks before calling this method.
  76 Each key is checked with keyNeedSync() before being actually commited. So only changed
  77 keys are updated.  If some error occurs, SetKeys() will stop. In this situation the KeySet
  78 internal cursor is left on the key that generated the error.
  79 """
  80                 return libpyelektra.setKey(self.__kdb__pointer__,keyset.__keyset__pointer__)
  81         def getRootKeys(self):
  82                 """Returns a KeySet with all root keys currently recognized and present on the system.
  83 Currently, the system and current user's user keys are returned.
  84 This is the only valid way to get to know of the root keys.
  85 """
  86                 keyset=ksNew()
  87                 libpyelektra.getRootKeys(self.__keyset_pointer__,self.__keyset__pointer__)
  88                 return keyset
  89         def error(self,no):
  90                 """Provides an error string associated with errnum"""
  91                 return libpyelektra.kdbStrError(no)
  92         def errno(self):
  93                 """return the errno of the last error"""
  94                 return libpyelektra.kdbGetErrno(self.__kdb__pointer__)
  95         def remove(self,name):
  96                 """remove the key with the name <name>"""
  97                 return libpyelektra.kdbRemove(self.__kdb__pointer__,name)
  98
  99 class Key:
 100         """Is a representation of a key, that can be modified by the following methods"""
 101         def __init__(self,*args,**kargs):
 102                 #if len(args)==1:
 103                 #       self.__key__pointer__=args[0]
 104                 if kargs.has_key('name'):
 105                         self.__key__pointer__=libpyelektra.keyNew(kargs['name'])
 106                         del kargs['name']
 107                 else:
 108                         self.__key__pointer__=libpyelektra.keyNew('')
 109                 self.set(**kargs)
 110                 if kargs.has_key('value'):
 111                         libpyelektra.keySetString(self.__key__pointer__,kargs['value'])
 112                 if kargs.has_key('lookup'):
 113                         try:
 114                                 libpyelektra.kdbGetKey(kargs['lookup'].__kdb__pointer__,self.__key__pointer__)
 115                         except AttributeError:
 116                                 raise ElektraException('lookup needs a initialised kdb object')
 117         #def new(self,name):
 118         #       """creates new key"""
 119         #       self.__key__pointer__=libpyelektra.keyNew(name)
 120         def set(self, **kargs):
 121                 if kargs.has_key('name'):
 122                         self.setName(kargs['name'])
 123                 if kargs.has_key('value'):
 124                         libpyelektra.keySetString(self.__key__pointer__,kargs['value'])
 125                 if kargs.has_key('lookup'):
 126                         try:
 127                                 libpyelektra.kdbGetKey(kargs['lookup'].__kdb__pointer__,self.__key__pointer__)
 128                         except AttributeError:
 129                                 raise ElektraException('lookup needs a initialised kdb object')
 130                 if kargs.has_key('set'):
 131                         try:
 132                                 libpyelektra.kdbSetKey(kargs['set'].__kdb__pointer__,self.__key__pointer__)
 133                         except AttributeError:
 134                                 raise ElektraException('lookup needs a initialised kdb object')
 135                 return self
 136
 137         def setName(self,name,**kargs):
 138                 """give the key a new name"""
 139                 ret= libpyelektra.keySetName(self.__key__pointer__,name)
 140                 if ret == -1:
 141                         raise ElektraException('Keyname invalid')
 142
 143                 if kargs.has_key('lookup'):
 144                         try:
 145                                 libpyelektra.kdbGetKey(kargs['lookup'].__kdb__pointer__,self.__key__pointer__)
 146                         except AttributeError:
 147                                 raise ElektraException('lookup needs a initialised kdb object')
 148         def setBinary(self):
 149                 """Set the binary value of a key"""
 150                 libpyelektra.keySetBinary(self.__key__pointer__,value)
 151         def getFullName(self):
 152                 """Set the full name of a key"""
 153                 return libpyelektra.keyGetFullName(self.__key__pointer__)
 154         def getString(self):
 155                 """Get the string value of a key"""
 156                 return libpyelektra.keyGetString(self.__key__pointer__)
 157         def setString(self,s):
 158                 """Set the full name of a key"""
 159                 return libpyelektra.keySetString(self.__key__pointer__,s)
 160         def getNameSize(self):
 161                 """returns the name size"""
 162                 return libpyelektra.keyGetNameSize(self.__key__pointer__)
 163         def getDataSize(self):
 164                 """returns the data size"""
 165                 return libpyelektra.keyGetDataSize(self.__key__pointer__)
 166         def getCommentSize(self):
 167                 """returns the comment size"""
 168                 return libpyelektra.keyGetCommentSize(self.__key__pointer__)
 169         def getComment(self):
 170                 """returns the comment"""
 171                 return libpyelektra.keyGetComment(self.__key__pointer__)
 172         def getName(self):
 173                 """returns the key name"""
 174                 return libpyelektra.keyGetName(self.__key__pointer__)
 175         def dup(self):
 176                 """returns the duplicate"""
 177                 return Key(libpyelektra.keyDup(self.__key__pointer__))
 178         def getType(self):
 179                 """return type of the key"""
 180                 return libpyelektra.keyGetType(self.__key__pointer__)
 181         def setType(self,type):
 182                 """set the key type"""
 183                 libpyelektra.keySetType(self.__key__pointer__,type)
 184         def getRecordSize(self,type):
 185                 """get the record size of the key"""
 186                 libpyelektra.keyGetRecordSize(self.__key__pointer__)
 187         def getFullNameSize(self):
 188                 """get the fullname size"""
 189                 return libpyelektra.keyGetFullNameSize(self.__key__pointer__)
 190         def name(self):
 191                 """returns the name of the key"""
 192                 return libpyelektra.keyName(self.__key__pointer__)
 193         def comment(self):
 194                 """returns the comment of the key"""
 195                 return libpyelektra.keyComment(self.__key__pointer__)
 196         def setComment(self,s):
 197                 """set the key comment"""
 198                 libpyelektra.keySetComment(self.__key__pointer__,s)
 199         def getUID(self):
 200                 """return the uid"""
 201                 return libpyelektra.keyGetUID(self.__key__pointer__)
 202         def setUID(self,uid):
 203                 """set the uid of the key"""
 204                 return libpyelektra.keySetUID(self.__key__pointer__,uid)
 205         def getGID(self):
 206                 """get the GID of the key"""
 207                 return libpyelektra.getGID(self.__key__pointer__)
 208         def setGID(self,gid):
 209                 """set the GID of the key"""
 210                 return libpyelektra.setGID(self.__key__pointer__,gid)
 211         def getMode(self):
 212                 """get the mode of the key"""
 213                 return libpyelektra.keyGetMode(self.__key__pointer__)
 214         def setMode(self,a):
 215                 """set the mode of the key"""
 216                 return libpyelektra.keySetMode(self.__key__pointer__,a)
 217         def getOwnerSize(self):
 218                 """returns the owner size"""
 219                 return libpyelektra.keyGetOwnerSize(self.__key__pointer__)
 220         def owner(self):
 221                 """returns the owner"""
 222                 return libpyelektra.keyOwner(self.__key__pointer__)
 223         def setOwner(self):
 224                 """sets a new owner"""
 225                 return libpyelektra.keySetOwner(self.__key__pointer__)
 226         def getLink(self):
 227                 """returns the link"""
 228                 return libpyelektra.keyGetLink(self.__key__pointer__)
 229         def setLink(self,value):
 230                 """sets the link"""
 231                 return libpyelektra.keySetLink(self.__key__pointer__)
 232         def getMTime(self):
 233                 """returns the MTime"""
 234                 return libpyelektra.keyGetMTime(self.__key__pointer__)
 235         def getATime(self):
 236                 """returns the ATime"""
 237                 return libpyelektra.keyGetATime(self.__key__pointer__)
 238         def getCTime(self):
 239                 """returns the CTime"""
 240                 return libpyelektra.keyGetCTime(self.__key__pointer__)
 241         def isSystem(self):
 242                 """check whether the key is under the system namespace or not"""
 243                 if libpyelektra.keyIsSystem(self.__key__pointer__)==0: return False
 244                 return True
 245         def isUser(self):
 246                 """check whether the key is under the user namespace or not"""
 247                 if libpyelektra.keyIsUser(self.__key__pointer__)==0: return False
 248                 return True
 249         def isDir(self):
 250                 """check if the key is a folder key or not"""
 251                 if libpyelektra.keyIsDir(self.__key__pointer__)==0: return False
 252                 return True
 253         def isLink(self):
 254                 """check if the key is a Link key or not"""
 255                 if libpyelektra.keyIsLink(self.__key__pointer__)==0: return False
 256                 return True
 257         def isBin(self):
 258                 """check if the key is a binary type"""
 259                 if libpyelektra.keyIsBin(self.__key__pointer__)==0: return False
 260                 return True
 261         def isString(self):
 262                 """check if the key is a string type"""
 263                 if libpyelektra.keyIsBin(self.__key__pointer__)==0: return False
 264                 return True
 265         #def close(self):
 266         #       libpyelektra.keyClose(self.__key__pointer__)
 267         def __del__(self):
 268                 libpyelektra.keyClose(self.__key__pointer__)
 269
 270 class KeySet:
 271         """Methods to manipulate KeySets. A KeySet is a linked list to group a number of Keys.
 272 KeySets have an internal cursor  to help in the Key navigation."""
 273         def __init__(self,*args):
 274                 if len(args)==1:
 275                         self.__keyset__pointer__=args[0]
 276         def new(self):
 277                 """new() creates a new keyset"""
 278                 self.__keyset__pointer__=libpyelektra.ksNew()
 279         def del_(self):
 280                 """del_() deletes the keyset"""
 281                 libpyelektra.ksDel(self.__keyset__pointer__)
 282         def rewind(self):
 283                 """resets the cursor"""
 284                 libpyelektra.ksRewind(self.__keyset__pointer__)
 285         def next(self):
 286                 """returns the next keyset in the keyset"""
 287                 libpyelektra.ksNext(self.__keyset__pointer__)
 288         def getSize(self):
 289                 """returns the number of elements in the keyset"""
 290                 libpyelektra.ksGetSize(self.__keyset__pointer__)
 291         def insert(self,key):
 292                 """inserts a new Key in the beginning of the KeySet."""
 293                 return libpyelektra.ksInsert(self.__keyset__pointer__,key.__key__pointer__)
 294         def append(self,key):
 295                 """appends a new Key at the end of the KeySet."""
 296                 return libpyelektra.ksInsert(self.__keyset__pointer__,key.__key__pointer__)
 297         def pop(self):
 298                 """Remove and return the last key of ks"""
 299                 return libpyelektra.ksPop(self.__keyset__pointer__)
 300         def insertKeys(self,toInsert):
 301                 """ks.insertKeys(toInsert) transfers all keys from toInsert to the begining of ks.
 302 After this call, toInsert will be empty and can be deleted with toInsert.del()
 303 Returns: the size of the KeySet after transfer."""
 304                 return libpyelektra.ksInsertKeys(self.__keyset__pointer__,toInsert.__keyset__pointer__)
 305         def appendKeys(self,toAppend):
 306                 """ks.insertKeys(toAppend) transfers all keys from toInsert to the begining of ks.
 307 After this call, toInsert will be empty and can be deleted with toInsert.del()
 308 Returns: the size of the KeySet after transfer."""
 309                 return libpyelektra.ksInsertKeys(self.__keyset__pointer__,toAppend.__keyset__pointer__)
 310         def sort(self):
 311                 """sort the keys in the keyset"""
 312                 libpyelektra.ksSort(self.__keyset__pointer__)
 313         def lookupByString(self,value,*args,**kargs):
 314                 """Look for a Key contained in ks that matches name, starting from ks' ksNext() position.
 315 Options: nocase\tignore case"""
 316                 options=0
 317                 if 'nocase' in kargs and kargs['nocase']: options+=32768
 318                 t=libpyelektra.ksLookupByString(self.__keyset__pointer__,value,options)
 319                 if t==0: return None
 320                 return Key(t)
 321
 322         def lookupByName(self,value,*args,**kargs):
 323                 """Look for a Key contained in ks that matches name, starting from ks' ksNext() position.
 324 Options: nocase\tignore case"""
 325                 options=0
 326                 if 'nocase' in kargs and kargs['nocase']: options+=32768
 327                 if 'all' in kargs and kargs['all']: options+=131072
 328                 t=libpyelektra.ksLookupByName(self.__keyset__pointer__,value,options)
 329                 if t==0: return None
 330                 return Key(t)
 331
 332         def lookupByBinary(self,value,options):
 333                 """Look for a Key contained in ks that matches name, starting from ks' ksNext() position.
 334 Options: nocase\tignore case"""
 335                 options=0
 336                 if 'nocase' in kargs and kargs['nocase']: options+=32768
 337                 t=libpyelektra.ksLookupByBinary(self.__keyset__pointer__,value,options)
 338                 if t==0: return None
 339                 return Key(t)
 340         def current(self):
 341                 """returns the current Key or None if you reached the end"""
 342                 t=libpyelektra.ksCurrent(self.__keyset__pointer__)
 343                 if t==0: return None
 344                 return Key(t)
 345         def head(self):
 346                 """returns the first key in the KeySet, without changing the KeySet's internal cursor."""
 347                 return Key(libpyelektra.ksHead(self.__keyset__pointer__))
 348         def tail(self):
 349                 """returns the last key in the KeySet, without changing the KeySet's internal cursor."""
 350                 return Key(libpyelektra.ksTail(self.__keyset__pointer__))