src/solver.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 "pool.h"
  22 #include "problem.h"
  23 #include "request.h"
  24 #include "solver.h"
  25
  26 #include <solv/solverdebug.h>
  27
  28 PyTypeObject SolverType = {
  29         PyObject_HEAD_INIT(NULL)
  30         tp_name: "_pakfire.Solver",
  31         tp_basicsize: sizeof(SolverObject),
  32         tp_flags: Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE,
  33         tp_new : Solver_new,
  34         tp_dealloc: (destructor) Solver_dealloc,
  35         tp_doc: "Sat Solver objects",
  36 };
  37
  38 PyObject* Solver_new(PyTypeObject *type, PyObject *args, PyObject *kwds) {
  39         SolverObject *self;
  40
  41         PoolObject *pool;
  42
  43         if (!PyArg_ParseTuple(args, "O", &pool)) {
  44                 /* XXX raise exception */
  45         }
  46
  47         self = (SolverObject *)type->tp_alloc(type, 0);
  48         if (self != NULL) {
  49                 self->_solver = solver_create(pool->_pool);
  50                 if (self->_solver == NULL) {
  51                         Py_DECREF(self);
  52                         return NULL;
  53                 }
  54         }
  55
  56         return (PyObject *)self;
  57 }
  58
  59 PyObject *Solver_dealloc(SolverObject *self) {
  60         solver_free(self->_solver);
  61         self->ob_type->tp_free((PyObject *)self);
  62
  63         Py_RETURN_NONE;
  64 }
  65
  66 PyObject *Solver_get_fix_system(SolverObject *self, PyObject *args) {
  67         return Py_BuildValue("i", self->_solver->fixsystem);
  68 }
  69
  70 PyObject *Solver_set_fix_system(SolverObject *self, PyObject *args) {
  71         int val;
  72
  73         if (!PyArg_ParseTuple(args, "i", &val)) {
  74                 /* XXX raise exception */
  75         }
  76
  77         self->_solver->fixsystem = val;
  78
  79         Py_RETURN_NONE;
  80 }
  81
  82 PyObject *Solver_get_allow_downgrade(SolverObject *self, PyObject *args) {
  83         return Py_BuildValue("i", self->_solver->allowdowngrade);
  84 }
  85
  86 PyObject *Solver_set_allow_downgrade(SolverObject *self, PyObject *args) {
  87         int val;
  88
  89         if (!PyArg_ParseTuple(args, "i", &val)) {
  90                 /* XXX raise exception */
  91         }
  92
  93         self->_solver->allowdowngrade = val;
  94
  95         Py_RETURN_NONE;
  96 }
  97
  98 PyObject *Solver_get_allow_archchange(SolverObject *self, PyObject *args) {
  99         return Py_BuildValue("i", self->_solver->allowarchchange);
 100 }
 101
 102 PyObject *Solver_set_allow_archchange(SolverObject *self, PyObject *args) {
 103         int val;
 104
 105         if (!PyArg_ParseTuple(args, "i", &val)) {
 106                 /* XXX raise exception */
 107         }
 108
 109         self->_solver->allowarchchange = val;
 110
 111         Py_RETURN_NONE;
 112 }
 113
 114 PyObject *Solver_get_allow_vendorchange(SolverObject *self, PyObject *args) {
 115         return Py_BuildValue("i", self->_solver->allowvendorchange);
 116 }
 117
 118 PyObject *Solver_set_allow_vendorchange(SolverObject *self, PyObject *args) {
 119         int val;
 120
 121         if (!PyArg_ParseTuple(args, "i", &val)) {
 122                 /* XXX raise exception */
 123         }
 124
 125         self->_solver->allowvendorchange = val;
 126
 127         Py_RETURN_NONE;
 128 }
 129
 130 PyObject *Solver_get_allow_uninstall(SolverObject *self, PyObject *args) {
 131         return Py_BuildValue("i", self->_solver->allowuninstall);
 132 }
 133
 134 PyObject *Solver_set_allow_uninstall(SolverObject *self, PyObject *args) {
 135         int val;
 136
 137         if (!PyArg_ParseTuple(args, "i", &val)) {
 138                 /* XXX raise exception */
 139         }
 140
 141         self->_solver->allowuninstall = val;
 142
 143         Py_RETURN_NONE;
 144 }
 145
 146 PyObject *Solver_get_updatesystem(SolverObject *self, PyObject *args) {
 147         return Py_BuildValue("i", self->_solver->updatesystem);
 148 }
 149
 150 PyObject *Solver_set_updatesystem(SolverObject *self, PyObject *args) {
 151         int val;
 152
 153         if (!PyArg_ParseTuple(args, "i", &val)) {
 154                 /* XXX raise exception */
 155         }
 156
 157         self->_solver->updatesystem = val;
 158
 159         Py_RETURN_NONE;
 160 }
 161
 162 PyObject *Solver_get_do_split_provides(SolverObject *self, PyObject *args) {
 163         return Py_BuildValue("i", self->_solver->dosplitprovides);
 164 }
 165
 166 PyObject *Solver_set_do_split_provides(SolverObject *self, PyObject *args) {
 167         int val;
 168
 169         if (!PyArg_ParseTuple(args, "i", &val)) {
 170                 /* XXX raise exception */
 171         }
 172
 173         self->_solver->dosplitprovides = val;
 174
 175         Py_RETURN_NONE;
 176 }
 177
 178 PyObject *Solver_solve(SolverObject *self, PyObject *args) {
 179         RequestObject *request;
 180
 181         if (!PyArg_ParseTuple(args, "O", &request)) {
 182                 /* XXX raise exception */
 183         }
 184
 185         // Make sure, the pool is prepared.
 186         _Pool_prepare(self->_solver->pool);
 187
 188         solver_solve(self->_solver, &request->_queue);
 189
 190 #ifdef DEBUG
 191         solver_printallsolutions(self->_solver);
 192 #endif
 193
 194         if (self->_solver->problems.count == 0) {
 195                 Py_RETURN_TRUE;
 196         }
 197
 198         Py_RETURN_FALSE;
 199 }
 200
 201 PyObject *Solver_get_problems(SolverObject *self, PyObject *args) {
 202         RequestObject *request;
 203
 204         if (!PyArg_ParseTuple(args, "O", &request)) {
 205                 /* XXX raise exception */
 206                 return NULL;
 207         }
 208
 209         PyObject *list = PyList_New(0);
 210
 211         ProblemObject *problem;
 212         Id p = 0;
 213         while ((p = solver_next_problem(self->_solver, p)) != 0) {
 214                 problem = PyObject_New(ProblemObject, &ProblemType);
 215
 216                 problem->_pool = self->_solver->pool;
 217                 problem->_solver = self->_solver;
 218                 problem->_id = p;
 219                 Problem_init(problem);
 220
 221                 PyList_Append(list, (PyObject *)problem);
 222         }
 223
 224         return list;
 225 }