src/solvable.c

   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 #############################################################################*/
  20
  21 #include <Python.h>
  22
  23 #include "config.h"
  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",
  36         tp_str: (reprfunc)Solvable_string,
  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 */
  50                 return NULL;
  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 */
  66                 Id rel = pool_rel2id(self->_pool, solv->name, solv->evr, REL_EQ, 1);
  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);
  75
  76         Py_RETURN_NONE;
  77 }
  78
  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
  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 */
 125                 return NULL;
 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 */
 145                 return NULL;
 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
 157         Id id, *ids;
 158         const char *dep_str;
 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 */
 189                 return NULL;
 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 */
 209                 return NULL;
 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 */
 229                 return NULL;
 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 */
 250                 return NULL;
 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 */
 273                 return NULL;
 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 */
 296                 return NULL;
 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 */
 319                 return NULL;
 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 */
 343                 return NULL;
 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 */
 366                 return NULL;
 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 */
 389                 return NULL;
 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 */
 413                 return NULL;
 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 */
 437                 return NULL;
 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 */
 461                 return NULL;
 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 */
 485                 return NULL;
 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 */
 509                 return NULL;
 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 */
 533                 return NULL;
 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