src/_pakfire/pool.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 #include <fnmatch.h>
  23 #include <solv/poolarch.h>
  24 #include <solv/solver.h>
  25
  26 #include "constants.h"
  27 #include "pool.h"
  28 #include "relation.h"
  29 #include "repo.h"
  30 #include "solvable.h"
  31
  32 PyTypeObject PoolType = {
  33         PyObject_HEAD_INIT(NULL)
  34         tp_name: "_pakfire.Pool",
  35         tp_basicsize: sizeof(PoolObject),
  36         tp_flags: Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
  37         tp_new : Pool_new,
  38         tp_dealloc: (destructor) Pool_dealloc,
  39         tp_doc: "Sat Pool objects",
  40 };
  41
  42 // Pool
  43 PyObject* Pool_new(PyTypeObject *type, PyObject *args, PyObject *kwds) {
  44         PoolObject *self;
  45         const char *arch;
  46
  47         if (!PyArg_ParseTuple(args, "s", &arch)) {
  48                 /* XXX raise exception */
  49                 return NULL;
  50         }
  51
  52         self = (PoolObject *)type->tp_alloc(type, 0);
  53         if (self != NULL) {
  54                 self->_pool = pool_create();
  55
  56 #ifdef DEBUG
  57                 // Enable debug messages when DEBUG is defined.
  58                 pool_setdebuglevel(self->_pool, 1);
  59 #endif
  60
  61                 pool_setdisttype(self->_pool, DISTTYPE_RPM);
  62                 pool_setarch(self->_pool, arch);
  63                 if (self->_pool == NULL) {
  64                         Py_DECREF(self);
  65                         return NULL;
  66                 }
  67         }
  68
  69         return (PyObject *)self;
  70 }
  71
  72 PyObject *Pool_dealloc(PoolObject *self) {
  73         pool_free(self->_pool);
  74         self->ob_type->tp_free((PyObject *)self);
  75
  76         Py_RETURN_NONE;
  77 }
  78
  79 PyObject *Pool_add_repo(PoolObject *self, PyObject *args) {
  80         const char *name;
  81         if (!PyArg_ParseTuple(args, "s", &name)) {
  82                 /* XXX raise exception */
  83         }
  84
  85         RepoObject *repo;
  86
  87         repo = PyObject_New(RepoObject, &RepoType);
  88         if (repo == NULL)
  89                 return NULL;
  90
  91         return (PyObject *)repo;
  92 }
  93
  94 PyObject *Pool_prepare(PoolObject *self) {
  95         _Pool_prepare(self->_pool);
  96
  97         Py_RETURN_NONE;
  98 }
  99
 100 void _Pool_prepare(Pool *pool) {
 101         pool_addfileprovides(pool);
 102         pool_createwhatprovides(pool);
 103
 104         Repo *r;
 105         int idx;
 106         FOR_REPOS(idx, r) {
 107                 repo_internalize(r);
 108         }
 109 }
 110
 111 PyObject *Pool_size(PoolObject *self) {
 112         Pool *pool = self->_pool;
 113
 114         return Py_BuildValue("i", pool->nsolvables);
 115 }
 116
 117 PyObject *_Pool_search(Pool *pool, Repo *repo, const char *match, int option, const char *keyname) {
 118         // Prepare the pool, so we can search in it.
 119         _Pool_prepare(pool);
 120
 121         Dataiterator d;
 122         dataiterator_init(&d, pool, repo, 0,
 123                 keyname && pool ? pool_str2id(pool, keyname, 0) : 0, match, option);
 124
 125         PyObject *list = PyList_New(0);
 126
 127         SolvableObject *solvable;
 128         while (dataiterator_step(&d)) {
 129                 solvable = PyObject_New(SolvableObject, &SolvableType);
 130                 solvable->_pool = pool;
 131                 solvable->_id = d.solvid;
 132
 133                 PyList_Append(list, (PyObject *)solvable);
 134         }
 135
 136         dataiterator_free(&d);
 137         return list;
 138 }
 139
 140 PyObject *Pool_search(PoolObject *self, PyObject *args) {
 141         const char *match = NULL;
 142         int option = SEARCH_SUBSTRING;
 143         const char *keyname = NULL;
 144
 145         if (!PyArg_ParseTuple(args, "s|is", &match, &option, &keyname)) {
 146                 /* XXX raise exception */
 147                 return NULL;
 148         }
 149
 150         return _Pool_search(self->_pool, NULL, match, option, keyname);
 151 }
 152
 153 PyObject *Pool_set_installed(PoolObject *self, PyObject *args) {
 154         RepoObject *repo;
 155
 156         if (!PyArg_ParseTuple(args, "O", &repo)) {
 157                 /* XXX raise exception */
 158         }
 159
 160         pool_set_installed(self->_pool, repo->_repo);
 161
 162         Py_RETURN_NONE;
 163 }
 164
 165 PyObject *Pool_providers(PoolObject *self, PyObject *args) {
 166         char *name = NULL;
 167         Queue job;
 168         Solvable *solvable;
 169         Pool *pool = self->_pool;
 170         Id p, pp;
 171         int i;
 172
 173         if (!PyArg_ParseTuple(args, "s", &name)) {
 174                 return NULL;
 175         }
 176
 177         _Pool_prepare(pool);
 178         queue_init(&job);
 179
 180         Id id = pool_str2id(pool, name, 0);
 181
 182         if (id) {
 183                 FOR_PROVIDES(p, pp, id) {
 184                         solvable = pool->solvables + p;
 185
 186                         if (solvable->name == id)
 187                                 queue_push2(&job, SOLVER_SOLVABLE, p);
 188                 }
 189         }
 190
 191         for (p = 1; p < pool->nsolvables; p++) {
 192                 solvable = pool->solvables + p;
 193                 if (!solvable->repo || !pool_installable(pool, solvable))
 194                         continue;
 195
 196                 id = solvable->name;
 197                 if (fnmatch(name, pool_id2str(pool, id), 0) == 0) {
 198                         for (i = 0; i < job.count; i += 2) {
 199                                 if (job.elements[i] == SOLVER_SOLVABLE && job.elements[i + 1] == id)
 200                                         break;
 201                         }
 202
 203                         if (i == job.count)
 204                                 queue_push2(&job, SOLVER_SOLVABLE, p);
 205                 }
 206         }
 207
 208         for (id = 1; id < pool->ss.nstrings; id++) {
 209                 if (!pool->whatprovides[id])
 210                         continue;
 211
 212                 if (fnmatch(name, pool_id2str(pool, id), 0) == 0) {
 213                         Id *provides = pool->whatprovidesdata + pool->whatprovides[id];
 214
 215                         while (*provides) {
 216                                 for (i = 0; i < job.count; i += 2) {
 217                                         if (job.elements[i] == SOLVER_SOLVABLE && job.elements[i + 1] == *provides)
 218                                                 break;
 219                                 }
 220
 221                                 if (i == job.count)
 222                                         queue_push2(&job, SOLVER_SOLVABLE, *provides);
 223
 224                                 provides++;
 225                         }
 226                 }
 227         }
 228
 229         SolvableObject *s;
 230         PyObject *list = PyList_New(0);
 231
 232         for (i = 0; i < job.count; i += 2) {
 233                 switch (job.elements[i]) {
 234                         case SOLVER_SOLVABLE:
 235                                 s = PyObject_New(SolvableObject, &SolvableType);
 236                                 s->_pool = pool;
 237                                 s->_id = job.elements[i + 1];
 238
 239                                 PyList_Append(list, (PyObject *)s);
 240                 }
 241         }
 242
 243         return list;
 244 }