r23796: main COPYING file for samba4, plus some formatting varients
[samba.git] / source4 / 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 3 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 #
24 # Interface notes:
25 #
26 #   - should an empty dn be represented as None, or an empty string?
27 #
28 #   - should single-valued attributes be a string, or a list with one
29 #     element?
30 #
31
32 from ldb import *
33
34 # Global initialisation
35
36 result = ldb_global_init()
37
38 if result != 0:
39     raise LdbError, (result, 'ldb_global_init failed')
40
41 # Ldb exceptions
42
43 class LdbError(Exception):
44     """An exception raised when a ldb error occurs.
45     The exception data is a tuple consisting of the ldb number and a
46     string description of the error."""
47     pass
48
49 # Ldb classes
50
51 class LdbMessage:
52     """A class representing a ldb message as a Python dictionary."""
53     
54     def __init__(self):
55         self.mem_ctx = talloc_init(None)
56         self.msg = ldb_msg_new(self.mem_ctx)
57
58     def __del__(self):
59         if self.mem_ctx is not None:
60             talloc_free(self.mem_ctx)
61             self.mem_ctx = None
62             self.msg = None
63
64     # Make the dn attribute of the object dynamic
65
66     def __getattr__(self, attr):
67         if attr == 'dn':
68             return ldb_dn_linearize(None, self.msg.dn)
69         return self.__dict__[attr]
70
71     def __setattr__(self, attr, value):
72         if attr == 'dn':
73             self.msg.dn = ldb_dn_explode(self.msg, value)
74             if self.msg.dn == None:
75                 err = LDB_ERR_INVALID_DN_SYNTAX
76                 raise LdbError(err, ldb_strerror(err))
77             return
78         self.__dict__[attr] = value
79         
80     # Get and set individual elements
81
82     def __getitem__(self, key):
83
84         elt = ldb_msg_find_element(self.msg, key)
85
86         if elt is None:
87             raise KeyError, "No such attribute '%s'" % key
88
89         return [ldb_val_array_getitem(elt.values, i)
90                 for i in range(elt.num_values)]
91
92     def __setitem__(self, key, value):
93         ldb_msg_remove_attr(self.msg, key)
94         if type(value) in (list, tuple):
95             [ldb_msg_add_value(self.msg, key, v) for v in value]
96         else:
97             ldb_msg_add_value(self.msg, key, value)
98
99     # Dictionary interface
100     # TODO: move to iterator based interface
101
102     def len(self):
103         return self.msg.num_elements
104
105     def keys(self):
106         return [ldb_message_element_array_getitem(self.msg.elements, i).name
107                 for i in range(self.msg.num_elements)]
108
109     def values(self):
110         return [self[k] for k in self.keys()]
111
112     def items(self):
113         return [(k, self[k]) for k in self.keys()]
114
115     # Misc stuff
116
117     def sanity_check(self):
118         return ldb_msg_sanity_check(self.msg)
119
120 class Ldb:
121     """A class representing a binding to a ldb file."""
122
123     def __init__(self, url, flags = 0):
124         """Initialise underlying ldb."""
125     
126         self.mem_ctx = talloc_init('mem_ctx for ldb 0x%x' % id(self))
127         self.ldb_ctx = ldb_init(self.mem_ctx)
128
129         result = ldb_connect(self.ldb_ctx, url, flags, None)
130
131         if result != LDB_SUCCESS:
132             raise LdbError, (result, ldb_strerror(result))
133         
134     def __del__(self):
135         """Called when the object is to be garbage collected."""
136         self.close()
137
138     def close(self):
139         """Close down a ldb."""
140         if self.mem_ctx is not None:
141             talloc_free(self.mem_ctx)
142             self.mem_ctx = None
143             self.ldb_ctx = None
144
145     def _ldb_call(self, fn, *args):
146         """Call a ldb function with args.  Raise a LdbError exception
147         if the function returns a non-zero return value."""
148         
149         result = fn(*args)
150
151         if result != LDB_SUCCESS:
152             raise LdbError, (result, ldb_strerror(result))
153
154     def search(self, expression):
155         """Search a ldb for a given expression."""
156
157         self._ldb_call(ldb_search, self.ldb_ctx, None, LDB_SCOPE_DEFAULT,
158                        expression, None);
159
160         return [LdbMessage(ldb_message_ptr_array_getitem(result.msgs, ndx))
161                 for ndx in range(result.count)]
162
163     def delete(self, dn):
164         """Delete a dn."""
165
166         _dn = ldb_dn_explode(self.ldb_ctx, dn)
167
168         self._ldb_call(ldb_delete, self.ldb_ctx, _dn)
169
170     def rename(self, olddn, newdn):
171         """Rename a dn."""
172         
173         _olddn = ldb_dn_explode(self.ldb_ctx, olddn)
174         _newdn = ldb_dn_explode(self.ldb_ctx, newdn)
175         
176         self._ldb_call(ldb_rename, self.ldb_ctx, _olddn, _newdn)
177
178     def add(self, m):
179         self._ldb_call(ldb_add, self.ldb_ctx, m.msg)