r15348: Start adding a dict interface and tests to LdbMessage class.
[samba.git] / source / lib / ldb / swig / Ldb.py
1 """Provide a more Pythonic and object-oriented interface to ldb."""
2
3 #
4 # Swig interface to Samba
5 #
6 # Copyright (C) Tim Potter 2006
7 #
8 # This program is free software; you can redistribute it and/or modify
9 # it under the terms of the GNU General Public License as published by
10 # the Free Software Foundation; either version 2 of the License, or
11 # (at your option) any later version.
12 #   
13 # This program is distributed in the hope that it will be useful,
14 # but WITHOUT ANY WARRANTY; without even the implied warranty of
15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 # GNU General Public License for more details.
17 #   
18 # You should have received a copy of the GNU General Public License
19 # along with this program; if not, write to the Free Software
20 # Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 #
22
23 from ldb import *
24
25 # Global initialisation
26
27 result = ldb_global_init()
28
29 if result != 0:
30     raise LdbError, (result, 'ldb_global_init failed')
31
32 # Ldb exceptions
33
34 class LdbError(Exception):
35     """An exception raised when a ldb error occurs.
36     The exception data is a tuple consisting of the ldb number and a
37     string description of the error."""
38     pass
39
40 # Ldb classes
41
42 class LdbMessage:
43     """A class representing a ldb message as a Python dictionary."""
44     
45     def __init__(self):
46         self.mem_ctx = talloc_init(None)
47         self.msg = ldb_msg_new(self.mem_ctx)
48
49     def __del__(self):
50         if self.mem_ctx is not None:
51             talloc_free(self.mem_ctx)
52             self.mem_ctx = None
53             self.msg = None
54
55     # Make the dn attribute of the object dynamic
56
57     def __getattr__(self, attr):
58         if attr == 'dn':
59             return ldb_dn_linearize(None, self.msg.dn)
60         return self.__dict__[attr]
61
62     def __setattr__(self, attr, value):
63         if attr == 'dn':
64             self.msg.dn = ldb_dn_explode(self.msg, value)
65             return
66         self.__dict__[attr] = value
67         
68     # Get and set individual elements
69
70     def __getitem__(self, key):
71
72         elt = ldb_msg_find_element(self.msg, key)
73
74         if elt is None:
75             raise KeyError, "No such attribute '%s'" % key
76
77         return [ldb_val_array_getitem(elt.values, i)
78                 for i in range(elt.num_values)]
79
80     def __setitem__(self, key, value):
81         if type(value) in (list, tuple):
82             [ldb_msg_add_value(self.msg, key, v) for v in value]
83         else:
84             ldb_msg_add_value(self.msg, key, value)
85
86     # Dictionary interface
87     # TODO: move to iterator based interface
88
89     def len(self):
90         return self.msg.num_elements
91
92     def keys(self):
93         return [ldb_message_element_array_getitem(self.msg.elements, i).name
94                 for i in range(self.msg.num_elements)]
95
96     def values(self):
97         return [self[k] for k in self.keys()]
98
99     def items(self):
100         return [(k, self[k]) for k in self.keys()]
101
102 class Ldb:
103     """A class representing a binding to a ldb file."""
104
105     def __init__(self, url, flags = 0):
106         """Initialise underlying ldb."""
107     
108         self.mem_ctx = talloc_init('mem_ctx for ldb 0x%x' % id(self))
109         self.ldb_ctx = ldb_init(self.mem_ctx)
110
111         result = ldb_connect(self.ldb_ctx, url, flags, None)
112
113         if result != LDB_SUCCESS:
114             raise LdbError, (result, ldb_strerror(result))
115         
116     def __del__(self):
117         """Called when the object is to be garbage collected."""
118         self.close()
119
120     def close(self):
121         """Close down a ldb."""
122         if self.mem_ctx is not None:
123             talloc_free(self.mem_ctx)
124             self.mem_ctx = None
125             self.ldb_ctx = None
126
127     def _ldb_call(self, fn, *args):
128         """Call a ldb function with args.  Raise a LdbError exception
129         if the function returns a non-zero return value."""
130         
131         result = fn(*args)
132
133         if result != LDB_SUCCESS:
134             raise LdbError, (result, ldb_strerror(result))
135
136     def search(self, expression):
137         """Search a ldb for a given expression."""
138
139         self._ldb_call(ldb_search, self.ldb_ctx, None, LDB_SCOPE_DEFAULT,
140                        expression, None);
141
142         return [LdbMessage(ldb_message_ptr_array_getitem(result.msgs, ndx))
143                 for ndx in range(result.count)]
144
145     def delete(self, dn):
146         """Delete a dn."""
147
148         _dn = ldb_dn_explode(self.ldb_ctx, dn)
149
150         self._ldb_call(ldb_delete, self.ldb_ctx, _dn)
151
152     def rename(self, olddn, newdn):
153         """Rename a dn."""
154         
155         _olddn = ldb_dn_explode(self.ldb_ctx, olddn)
156         _newdn = ldb_dn_explode(self.ldb_ctx, newdn)
157         
158         self._ldb_call(ldb_rename, self.ldb_ctx, _olddn, _newdn)
159
160     def add(self, m):
161         self._ldb_call(ldb_add, self.ldb_ctx, m.msg)