]>
Commit | Line | Data |
---|---|---|
b792d887 MT |
1 | /*############################################################################# |
2 | # # | |
3 | # Pakfire - The IPFire package management system # | |
4 | # Copyright (C) 2011 Pakfire development team # | |
5 | # # | |
6 | # This program is free software: you can redistribute it and/or modify # | |
7 | # it under the terms of the GNU General Public License as published by # | |
8 | # the Free Software Foundation, either version 3 of the License, or # | |
9 | # (at your option) any later version. # | |
10 | # # | |
11 | # This program is distributed in the hope that it will be useful, # | |
12 | # but WITHOUT ANY WARRANTY; without even the implied warranty of # | |
13 | # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # | |
14 | # GNU General Public License for more details. # | |
15 | # # | |
16 | # You should have received a copy of the GNU General Public License # | |
17 | # along with this program. If not, see <http://www.gnu.org/licenses/>. # | |
18 | # # | |
19 | #############################################################################*/ | |
c605d735 | 20 | |
5168e648 MT |
21 | #include <Python.h> |
22 | ||
23 | #include "config.h" | |
c605d735 MT |
24 | #include "relation.h" |
25 | #include "repo.h" | |
26 | #include "solvable.h" | |
27 | ||
28 | PyTypeObject SolvableType = { | |
29 | PyObject_HEAD_INIT(NULL) | |
30 | tp_name: "_pakfire.Solvable", | |
31 | tp_basicsize: sizeof(SolvableObject), | |
32 | tp_flags: Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, | |
33 | tp_new : Solvable_new, | |
34 | tp_dealloc: (destructor) Solvable_dealloc, | |
35 | tp_doc: "Sat Solvable objects", | |
5168e648 | 36 | tp_str: (reprfunc)Solvable_string, |
c605d735 MT |
37 | }; |
38 | ||
39 | // Solvable | |
40 | PyObject* Solvable_new(PyTypeObject *type, PyObject *args, PyObject *kwds) { | |
41 | SolvableObject *self; | |
42 | ||
43 | RepoObject *repo; | |
44 | const char *name; | |
45 | const char *evr; | |
46 | const char *arch = "noarch"; | |
47 | ||
48 | if (!PyArg_ParseTuple(args, "Oss|s", &repo, &name, &evr, &arch)) { | |
49 | /* XXX raise exception */ | |
714392de | 50 | return NULL; |
c605d735 MT |
51 | } |
52 | ||
53 | self = (SolvableObject *)type->tp_alloc(type, 0); | |
54 | if (self != NULL) { | |
55 | self->_id = repo_add_solvable(repo->_repo); | |
56 | self->_pool = repo->_repo->pool; | |
57 | ||
58 | /* Fill solvable with data. */ | |
59 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
60 | ||
61 | solv->name = pool_str2id(self->_pool, name, 1); | |
62 | solv->evr = pool_str2id(self->_pool, evr, 1); | |
63 | solv->arch = pool_str2id(self->_pool, arch, 1); | |
64 | ||
65 | /* add self-provides */ | |
45f5a3d9 | 66 | Id rel = pool_rel2id(self->_pool, solv->name, solv->evr, REL_EQ, 1); |
c605d735 MT |
67 | solv->provides = repo_addid_dep(repo->_repo, solv->provides, rel, 0); |
68 | } | |
69 | ||
70 | return (PyObject *)self; | |
71 | } | |
72 | ||
73 | PyObject *Solvable_dealloc(SolvableObject *self) { | |
74 | self->ob_type->tp_free((PyObject *)self); | |
714392de MT |
75 | |
76 | Py_RETURN_NONE; | |
c605d735 MT |
77 | } |
78 | ||
5168e648 MT |
79 | PyObject *Solvable_string(SolvableObject *self) { |
80 | Solvable *solvable = pool_id2solvable(self->_pool, self->_id); | |
81 | ||
82 | const char *str = pool_solvable2str(self->_pool, solvable); | |
83 | ||
84 | return Py_BuildValue("s", str); | |
85 | } | |
86 | ||
c605d735 MT |
87 | PyObject *Solvable_get_name(SolvableObject *self) { |
88 | Solvable *solvable = pool_id2solvable(self->_pool, self->_id); | |
89 | ||
90 | const char *name = pool_id2str(solvable->repo->pool, solvable->name); | |
91 | ||
92 | return Py_BuildValue("s", name); | |
93 | } | |
94 | ||
95 | PyObject *Solvable_get_evr(SolvableObject *self) { | |
96 | Solvable *solvable = pool_id2solvable(self->_pool, self->_id); | |
97 | ||
98 | const char *evr = pool_id2str(solvable->repo->pool, solvable->evr); | |
99 | ||
100 | return Py_BuildValue("s", evr); | |
101 | } | |
102 | ||
103 | PyObject *Solvable_get_arch(SolvableObject *self) { | |
104 | Solvable *solvable = pool_id2solvable(self->_pool, self->_id); | |
105 | ||
106 | const char *arch = pool_id2str(solvable->repo->pool, solvable->arch); | |
107 | ||
108 | return Py_BuildValue("s", arch); | |
109 | } | |
110 | ||
111 | PyObject *Solvable_get_vendor(SolvableObject *self) { | |
112 | Solvable *solvable = pool_id2solvable(self->_pool, self->_id); | |
113 | ||
114 | const char *vendor = pool_id2str(solvable->repo->pool, solvable->vendor); | |
115 | ||
116 | return Py_BuildValue("s", vendor); | |
117 | } | |
118 | ||
119 | PyObject *Solvable_set_vendor(SolvableObject *self, PyObject *args) { | |
120 | Solvable *solvable = pool_id2solvable(self->_pool, self->_id); | |
121 | ||
122 | const char *vendor; | |
123 | if (!PyArg_ParseTuple(args, "s", &vendor)) { | |
124 | /* XXX raise exception */ | |
714392de | 125 | return NULL; |
c605d735 MT |
126 | } |
127 | ||
128 | solvable->vendor = pool_str2id(self->_pool, vendor, 1); | |
129 | ||
130 | Py_RETURN_NONE; | |
131 | } | |
132 | ||
133 | PyObject *Solvable_get_repo_name(SolvableObject *self) { | |
134 | Solvable *solvable = pool_id2solvable(self->_pool, self->_id); | |
135 | ||
136 | return Py_BuildValue("s", solvable->repo->name); | |
137 | } | |
138 | ||
139 | PyObject *Solvable_add_provides(SolvableObject *self, PyObject *args) { | |
140 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
141 | ||
142 | RelationObject *rel; | |
143 | if (!PyArg_ParseTuple(args, "O", &rel)) { | |
144 | /* XXX raise exception */ | |
714392de | 145 | return NULL; |
c605d735 MT |
146 | } |
147 | ||
148 | solv->provides = repo_addid_dep(solv->repo, solv->provides, rel->_id, 0); | |
149 | ||
150 | Py_RETURN_NONE; | |
151 | } | |
152 | ||
153 | PyObject *_Solvable_get_dependencies(Solvable *solv, Offset deps) { | |
154 | Repo *repo = solv->repo; | |
155 | Pool *pool = repo->pool; | |
156 | ||
c605d735 | 157 | Id id, *ids; |
31267a64 | 158 | const char *dep_str; |
c605d735 MT |
159 | |
160 | PyObject *list = PyList_New(0); | |
161 | ||
162 | ids = repo->idarraydata + deps; | |
163 | while((id = *ids++) != 0) { | |
164 | dep_str = pool_dep2str(pool, id); | |
165 | ||
166 | // Do not include the filelist. | |
167 | if (strcmp(dep_str, "solvable:filemarker") == 0) | |
168 | break; | |
169 | ||
170 | PyList_Append(list, Py_BuildValue("s", dep_str)); | |
171 | } | |
172 | ||
173 | Py_INCREF(list); | |
174 | return list; | |
175 | } | |
176 | ||
177 | PyObject *Solvable_get_provides(SolvableObject *self) { | |
178 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
179 | ||
180 | return _Solvable_get_dependencies(solv, solv->provides); | |
181 | } | |
182 | ||
183 | PyObject *Solvable_add_requires(SolvableObject *self, PyObject *args) { | |
184 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
185 | ||
186 | RelationObject *rel; | |
187 | if (!PyArg_ParseTuple(args, "O", &rel)) { | |
188 | /* XXX raise exception */ | |
714392de | 189 | return NULL; |
c605d735 MT |
190 | } |
191 | ||
192 | solv->requires = repo_addid_dep(solv->repo, solv->requires, rel->_id, 0); | |
193 | ||
194 | Py_RETURN_NONE; | |
195 | } | |
196 | ||
197 | PyObject *Solvable_get_requires(SolvableObject *self) { | |
198 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
199 | ||
200 | return _Solvable_get_dependencies(solv, solv->requires); | |
201 | } | |
202 | ||
203 | PyObject *Solvable_add_obsoletes(SolvableObject *self, PyObject *args) { | |
204 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
205 | ||
206 | RelationObject *rel; | |
207 | if (!PyArg_ParseTuple(args, "O", &rel)) { | |
208 | /* XXX raise exception */ | |
714392de | 209 | return NULL; |
c605d735 MT |
210 | } |
211 | ||
212 | solv->obsoletes = repo_addid_dep(solv->repo, solv->obsoletes, rel->_id, 0); | |
213 | ||
214 | Py_RETURN_NONE; | |
215 | } | |
216 | ||
217 | PyObject *Solvable_get_obsoletes(SolvableObject *self) { | |
218 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
219 | ||
220 | return _Solvable_get_dependencies(solv, solv->obsoletes); | |
221 | } | |
222 | ||
223 | PyObject *Solvable_add_conflicts(SolvableObject *self, PyObject *args) { | |
224 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
225 | ||
226 | RelationObject *rel; | |
227 | if (!PyArg_ParseTuple(args, "O", &rel)) { | |
228 | /* XXX raise exception */ | |
714392de | 229 | return NULL; |
c605d735 MT |
230 | } |
231 | ||
232 | solv->conflicts = repo_addid_dep(solv->repo, solv->conflicts, rel->_id, 0); | |
233 | ||
234 | Py_RETURN_NONE; | |
235 | } | |
236 | ||
237 | PyObject *Solvable_get_conflicts(SolvableObject *self) { | |
238 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
239 | ||
240 | return _Solvable_get_dependencies(solv, solv->conflicts); | |
241 | } | |
242 | ||
243 | PyObject *Solvable_set_uuid(SolvableObject *self, PyObject *args) { | |
244 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
245 | ||
246 | const char *uuid; | |
247 | ||
248 | if (!PyArg_ParseTuple(args, "s", &uuid)) { | |
249 | /* XXX raise exception */ | |
714392de | 250 | return NULL; |
c605d735 MT |
251 | } |
252 | ||
253 | repo_set_str(solv->repo, self->_id, SOLVABLE_PKGID, uuid); | |
254 | ||
255 | Py_RETURN_NONE; | |
256 | } | |
257 | ||
258 | PyObject *Solvable_get_uuid(SolvableObject *self) { | |
259 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
260 | ||
261 | const char *uuid = repo_lookup_str(solv->repo, self->_id, SOLVABLE_PKGID); | |
262 | ||
263 | return Py_BuildValue("s", uuid); | |
264 | } | |
265 | ||
266 | PyObject *Solvable_set_hash1(SolvableObject *self, PyObject *args) { | |
267 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
268 | ||
269 | const char *hash1; | |
270 | ||
271 | if (!PyArg_ParseTuple(args, "s", &hash1)) { | |
272 | /* XXX raise exception */ | |
714392de | 273 | return NULL; |
c605d735 MT |
274 | } |
275 | ||
276 | repo_set_str(solv->repo, self->_id, SOLVABLE_CHECKSUM, hash1); | |
277 | ||
278 | Py_RETURN_NONE; | |
279 | } | |
280 | ||
281 | PyObject *Solvable_get_hash1(SolvableObject *self) { | |
282 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
283 | ||
284 | const char *hash1 = repo_lookup_str(solv->repo, self->_id, SOLVABLE_CHECKSUM); | |
285 | ||
286 | return Py_BuildValue("s", hash1); | |
287 | } | |
288 | ||
289 | PyObject *Solvable_set_summary(SolvableObject *self, PyObject *args) { | |
290 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
291 | ||
292 | const char *summary; | |
293 | ||
294 | if (!PyArg_ParseTuple(args, "s", &summary)) { | |
295 | /* XXX raise exception */ | |
714392de | 296 | return NULL; |
c605d735 MT |
297 | } |
298 | ||
299 | repo_set_str(solv->repo, self->_id, SOLVABLE_SUMMARY, summary); | |
300 | ||
301 | Py_RETURN_NONE; | |
302 | } | |
303 | ||
304 | PyObject *Solvable_get_summary(SolvableObject *self) { | |
305 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
306 | ||
307 | const char *summary = repo_lookup_str(solv->repo, self->_id, SOLVABLE_SUMMARY); | |
308 | ||
309 | return Py_BuildValue("s", summary); | |
310 | } | |
311 | ||
312 | PyObject *Solvable_set_description(SolvableObject *self, PyObject *args) { | |
313 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
314 | ||
315 | const char *desc; | |
316 | ||
317 | if (!PyArg_ParseTuple(args, "s", &desc)) { | |
318 | /* XXX raise exception */ | |
714392de | 319 | return NULL; |
c605d735 MT |
320 | } |
321 | ||
322 | repo_set_str(solv->repo, self->_id, SOLVABLE_DESCRIPTION, desc); | |
323 | ||
324 | Py_RETURN_NONE; | |
325 | } | |
326 | ||
327 | PyObject *Solvable_get_description(SolvableObject *self) { | |
328 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
329 | ||
330 | const char *desc = repo_lookup_str(solv->repo, self->_id, | |
331 | SOLVABLE_DESCRIPTION); | |
332 | ||
333 | return Py_BuildValue("s", desc); | |
334 | } | |
335 | ||
336 | PyObject *Solvable_set_url(SolvableObject *self, PyObject *args) { | |
337 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
338 | ||
339 | const char *url; | |
340 | ||
341 | if (!PyArg_ParseTuple(args, "s", &url)) { | |
342 | /* XXX raise exception */ | |
714392de | 343 | return NULL; |
c605d735 MT |
344 | } |
345 | ||
346 | repo_set_str(solv->repo, self->_id, SOLVABLE_URL, url); | |
347 | ||
348 | Py_RETURN_NONE; | |
349 | } | |
350 | ||
351 | PyObject *Solvable_get_url(SolvableObject *self) { | |
352 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
353 | ||
354 | const char *url = repo_lookup_str(solv->repo, self->_id, SOLVABLE_URL); | |
355 | ||
356 | return Py_BuildValue("s", url); | |
357 | } | |
358 | ||
359 | PyObject *Solvable_set_groups(SolvableObject *self, PyObject *args) { | |
360 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
361 | ||
362 | const char *groups; | |
363 | ||
364 | if (!PyArg_ParseTuple(args, "s", &groups)) { | |
365 | /* XXX raise exception */ | |
714392de | 366 | return NULL; |
c605d735 MT |
367 | } |
368 | ||
369 | repo_set_str(solv->repo, self->_id, SOLVABLE_GROUP, groups); | |
370 | ||
371 | Py_RETURN_NONE; | |
372 | } | |
373 | ||
374 | PyObject *Solvable_get_groups(SolvableObject *self) { | |
375 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
376 | ||
377 | const char *groups = repo_lookup_str(solv->repo, self->_id, SOLVABLE_GROUP); | |
378 | ||
379 | return Py_BuildValue("s", groups); | |
380 | } | |
381 | ||
382 | PyObject *Solvable_set_filename(SolvableObject *self, PyObject *args) { | |
383 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
384 | ||
385 | const char *filename; | |
386 | ||
387 | if (!PyArg_ParseTuple(args, "s", &filename)) { | |
388 | /* XXX raise exception */ | |
714392de | 389 | return NULL; |
c605d735 MT |
390 | } |
391 | ||
392 | repo_set_str(solv->repo, self->_id, SOLVABLE_MEDIAFILE, filename); | |
393 | ||
394 | Py_RETURN_NONE; | |
395 | } | |
396 | ||
397 | PyObject *Solvable_get_filename(SolvableObject *self) { | |
398 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
399 | ||
400 | const char *filename = repo_lookup_str(solv->repo, self->_id, | |
401 | SOLVABLE_MEDIAFILE); | |
402 | ||
403 | return Py_BuildValue("s", filename); | |
404 | } | |
405 | ||
406 | PyObject *Solvable_set_license(SolvableObject *self, PyObject *args) { | |
407 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
408 | ||
409 | const char *license; | |
410 | ||
411 | if (!PyArg_ParseTuple(args, "s", &license)) { | |
412 | /* XXX raise exception */ | |
714392de | 413 | return NULL; |
c605d735 MT |
414 | } |
415 | ||
416 | repo_set_str(solv->repo, self->_id, SOLVABLE_LICENSE, license); | |
417 | ||
418 | Py_RETURN_NONE; | |
419 | } | |
420 | ||
421 | PyObject *Solvable_get_license(SolvableObject *self) { | |
422 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
423 | ||
424 | const char *license = repo_lookup_str(solv->repo, self->_id, | |
425 | SOLVABLE_LICENSE); | |
426 | ||
427 | return Py_BuildValue("s", license); | |
428 | } | |
429 | ||
430 | PyObject *Solvable_set_buildhost(SolvableObject *self, PyObject *args) { | |
431 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
432 | ||
433 | const char *buildhost; | |
434 | ||
435 | if (!PyArg_ParseTuple(args, "s", &buildhost)) { | |
436 | /* XXX raise exception */ | |
714392de | 437 | return NULL; |
c605d735 MT |
438 | } |
439 | ||
440 | repo_set_str(solv->repo, self->_id, SOLVABLE_BUILDHOST, buildhost); | |
441 | ||
442 | Py_RETURN_NONE; | |
443 | } | |
444 | ||
445 | PyObject *Solvable_get_buildhost(SolvableObject *self) { | |
446 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
447 | ||
448 | const char *buildhost = repo_lookup_str(solv->repo, self->_id, | |
449 | SOLVABLE_BUILDHOST); | |
450 | ||
451 | return Py_BuildValue("s", buildhost); | |
452 | } | |
453 | ||
454 | PyObject *Solvable_set_maintainer(SolvableObject *self, PyObject *args) { | |
455 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
456 | ||
457 | const char *maintainer; | |
458 | ||
459 | if (!PyArg_ParseTuple(args, "s", &maintainer)) { | |
460 | /* XXX raise exception */ | |
714392de | 461 | return NULL; |
c605d735 MT |
462 | } |
463 | ||
464 | repo_set_str(solv->repo, self->_id, SOLVABLE_PACKAGER, maintainer); | |
465 | ||
466 | Py_RETURN_NONE; | |
467 | } | |
468 | ||
469 | PyObject *Solvable_get_maintainer(SolvableObject *self) { | |
470 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
471 | ||
472 | const char *maintainer = repo_lookup_str(solv->repo, self->_id, | |
473 | SOLVABLE_PACKAGER); | |
474 | ||
475 | return Py_BuildValue("s", maintainer); | |
476 | } | |
477 | ||
478 | PyObject *Solvable_set_downloadsize(SolvableObject *self, PyObject *args) { | |
479 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
480 | ||
481 | unsigned int downloadsize; | |
482 | ||
483 | if (!PyArg_ParseTuple(args, "i", &downloadsize)) { | |
484 | /* XXX raise exception */ | |
714392de | 485 | return NULL; |
c605d735 MT |
486 | } |
487 | ||
488 | repo_set_num(solv->repo, self->_id, SOLVABLE_DOWNLOADSIZE, downloadsize); | |
489 | ||
490 | Py_RETURN_NONE; | |
491 | } | |
492 | ||
493 | PyObject *Solvable_get_downloadsize(SolvableObject *self) { | |
494 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
495 | ||
496 | unsigned int downloadsize = repo_lookup_num(solv->repo, self->_id, | |
497 | SOLVABLE_DOWNLOADSIZE, 0); | |
498 | ||
499 | return Py_BuildValue("i", downloadsize); | |
500 | } | |
501 | ||
502 | PyObject *Solvable_set_installsize(SolvableObject *self, PyObject *args) { | |
503 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
504 | ||
505 | unsigned int installedsize; | |
506 | ||
507 | if (!PyArg_ParseTuple(args, "i", &installedsize)) { | |
508 | /* XXX raise exception */ | |
714392de | 509 | return NULL; |
c605d735 MT |
510 | } |
511 | ||
512 | repo_set_num(solv->repo, self->_id, SOLVABLE_INSTALLSIZE, installedsize); | |
513 | ||
514 | Py_RETURN_NONE; | |
515 | } | |
516 | ||
517 | PyObject *Solvable_get_installsize(SolvableObject *self) { | |
518 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
519 | ||
520 | unsigned int installedsize = repo_lookup_num(solv->repo, self->_id, | |
521 | SOLVABLE_INSTALLSIZE, 0); | |
522 | ||
523 | return Py_BuildValue("i", installedsize); | |
524 | } | |
525 | ||
526 | PyObject *Solvable_set_buildtime(SolvableObject *self, PyObject *args) { | |
527 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
528 | ||
529 | unsigned int buildtime; | |
530 | ||
531 | if (!PyArg_ParseTuple(args, "i", &buildtime)) { | |
532 | /* XXX raise exception */ | |
714392de | 533 | return NULL; |
c605d735 MT |
534 | } |
535 | ||
536 | repo_set_num(solv->repo, self->_id, SOLVABLE_BUILDTIME, buildtime); | |
537 | ||
538 | Py_RETURN_NONE; | |
539 | } | |
540 | ||
541 | PyObject *Solvable_get_buildtime(SolvableObject *self) { | |
542 | Solvable *solv = pool_id2solvable(self->_pool, self->_id); | |
543 | ||
544 | unsigned int buildtime = repo_lookup_num(solv->repo, self->_id, | |
545 | SOLVABLE_BUILDTIME, 0); | |
546 | ||
547 | if (buildtime == 0) | |
548 | Py_RETURN_NONE; | |
549 | ||
550 | return Py_BuildValue("i", buildtime); | |
551 | } | |
552 |