1 |
commit: eb3545e879aa0e58faec627167e5ec507423ba27 |
2 |
Author: Magnus Granberg <zorry <AT> gentoo <DOT> org> |
3 |
AuthorDate: Fri Apr 1 15:23:35 2011 +0000 |
4 |
Commit: Magnus Granberg <zorry <AT> gentoo <DOT> org> |
5 |
CommitDate: Fri Apr 1 15:23:35 2011 +0000 |
6 |
URL: http://git.overlays.gentoo.org/gitweb/?p=dev/zorry.git;a=commit;h=eb3545e8 |
7 |
|
8 |
added the guest code |
9 |
|
10 |
--- |
11 |
buildhost/buildhost/core.py | 323 ++++++++++++++----- |
12 |
buildhost/buildhost/sqlbackend.py | 636 +++++++++++++++++++++++++++++++++---- |
13 |
2 files changed, 813 insertions(+), 146 deletions(-) |
14 |
|
15 |
diff --git a/buildhost/buildhost/__init__.py b/buildhost/buildhost/__init__.py |
16 |
new file mode 100644 |
17 |
index 0000000..e69de29 |
18 |
|
19 |
diff --git a/buildhost/buildhost/core.py b/buildhost/buildhost/core.py |
20 |
index 6740e86..bbe23b6 100644 |
21 |
--- a/buildhost/buildhost/core.py |
22 |
+++ b/buildhost/buildhost/core.py |
23 |
@@ -4,11 +4,18 @@ |
24 |
|
25 |
"""core module""" |
26 |
import sys |
27 |
+from StringIO import StringIO |
28 |
import os |
29 |
import re |
30 |
import portage |
31 |
+from _emerge.actions import load_emerge_config |
32 |
+from _emerge.main import parse_opts, emerge_main |
33 |
+from _emerge.depgraph import backtrack_depgraph, depgraph, resume_depgraph |
34 |
+from _emerge.create_depgraph_params import create_depgraph_params |
35 |
+import _emerge |
36 |
import hashlib |
37 |
import errno |
38 |
+import time |
39 |
from xml.etree.ElementTree import ElementTree |
40 |
|
41 |
class get_conf_settings(object): |
42 |
@@ -49,9 +56,9 @@ def init_sql_backend(): |
43 |
database = None |
44 |
|
45 |
# Setup the database backent to use mysql |
46 |
- if DatabaseConfig.mode == 'mysql': |
47 |
- from sqlbackend import MySQLPackageDB |
48 |
- database = MySQLPackageDB(DatabaseConfig.settings['sql_mysql']) |
49 |
+ if DatabaseConfig.mode == 'pgsql': |
50 |
+ from sqlbackend import PgSQLPackageDB |
51 |
+ database = PgSQLPackageDB(DatabaseConfig.settings['sql_pgsql']) |
52 |
return database |
53 |
|
54 |
def get_file_text(filename): |
55 |
@@ -69,17 +76,17 @@ def get_file_text(filename): |
56 |
textfile.close() |
57 |
return text |
58 |
|
59 |
-def check_make_conf(database): |
60 |
- if database.get_config_active(get_conf_settings.SetBuildConfig) is None: |
61 |
- return False |
62 |
+def check_make_conf(database, config_profile): |
63 |
+ make_conf_checksum_db = database.get_default_config(config_profile)[0] |
64 |
+ if make_conf_checksum_db is None: |
65 |
+ return "1" |
66 |
make_conf_file = "/etc/make.conf" |
67 |
# Check if we can open the file and close it |
68 |
# Check if we have some error in the file (portage.util.getconfig) |
69 |
# Check if we envorment error with the config (settings.validate) |
70 |
- make_conf_checksum_db = database.get_make_conf_checksum_db(get_conf_settings.SetBuildConfig) |
71 |
- make_conf_checksum_tree = portage.checksum.sha256hash(make_conf_file) |
72 |
- if make_conf_checksum_db is None or make_conf_checksum_tree[0] != make_conf_checksum_db[0]: |
73 |
- return True |
74 |
+ make_conf_checksum_tree = portage.checksum.sha256hash(make_conf_file)[0] |
75 |
+ if make_conf_checksum_tree != make_conf_checksum_db: |
76 |
+ return "2" |
77 |
# Check if we can open the file and close it |
78 |
# Check if we have some error in the file (portage.util.getconfig) |
79 |
# Check if we envorment error with the config (settings.validate) |
80 |
@@ -91,8 +98,8 @@ def check_make_conf(database): |
81 |
portage.settings.validate() |
82 |
# With errors we return false |
83 |
except Exception as e: |
84 |
- return False |
85 |
- return True |
86 |
+ return "3" |
87 |
+ return "4" |
88 |
|
89 |
def get_iuse(portdb, cpv): |
90 |
"""Gets the current IUSE flags from the tree |
91 |
@@ -209,86 +216,228 @@ def get_flags(settings, portdb, cpv): |
92 |
#flags = filter_flags(use_flags, use_expand_hidden, usemasked, useforced) |
93 |
final_flags = filter_flags(settings, final_use, use_expand_hidden, usemasked, useforced) |
94 |
return iuse_flags, final_flags |
95 |
-def build_package(database): |
96 |
- build_list = get_package_to_build(database, get_conf_settings.SetBuildConfig) |
97 |
|
98 |
+def check_configure(database, config_profile): |
99 |
+ pass_make_conf = check_make_conf(database, config_profile) |
100 |
+ print pass_make_conf |
101 |
+ if pass_make_conf == "1": |
102 |
+ # profile not active or updatedb is runing |
103 |
+ return False |
104 |
+ elif pass_make_conf == "2": |
105 |
+ # update make.conf |
106 |
+ return False |
107 |
+ elif pass_make_conf == "3": |
108 |
+ # set the config as no working |
109 |
+ database.make_conf_error(config_profile) |
110 |
+ return False |
111 |
+ elif pass_make_conf == "4": |
112 |
+ # make.conf check OK |
113 |
+ return True |
114 |
+ |
115 |
+def check_file_in_manifest(pkgdir, settings, portdb, cpv, build_dict, build_use_flags_list): |
116 |
+ myfetchlistdict = portage.FetchlistDict(pkgdir, settings, portdb) |
117 |
+ my_manifest = portage.Manifest(pkgdir, settings['DISTDIR'], fetchlist_dict=myfetchlistdict, manifest1_compat=False, from_scratch=False) |
118 |
+ if my_manifest.findFile(build_dict['package'] + "-" + build_dict['ebuild_version'] + ".ebuild") is None: |
119 |
+ return False |
120 |
+ cpv_fetchmap = portdb.getFetchMap(cpv, useflags=build_use_flags_list, mytree=None) |
121 |
+ settings.unlock() |
122 |
+ try: |
123 |
+ portage.fetch(cpv_fetchmap, settings, listonly=0, fetchonly=0, locks_in_subdir='.locks', use_locks=1, try_mirrors=1) |
124 |
+ except: |
125 |
+ settings.lock() |
126 |
+ return False |
127 |
+ settings.lock() |
128 |
+ if my_manifest.checkCpvHashes(cpv, checkDistfiles=True, onlyDistfiles=False, checkMiscfiles=True) is not None: |
129 |
+ return False |
130 |
+ if portdb.fetch_check(cpv, useflags=build_use_flags_list, mysettings=settings, all=False) is not True: |
131 |
+ return False |
132 |
+ return True |
133 |
+ |
134 |
+def get_needed_dep_useflags(cpv, build_use_flags_list): |
135 |
+ tmpcmdline = [] |
136 |
+ tmpcmdline.append("-p") |
137 |
+ tmpcmdline.append("--autounmask") |
138 |
+ tmpcmdline.append("=" + cpv) |
139 |
+ print tmpcmdline |
140 |
+ myaction, myopts, myfiles = parse_opts(tmpcmdline, silent=False) |
141 |
+ print myaction, myopts, myfiles |
142 |
+ myparams = create_depgraph_params(myopts, myaction) |
143 |
+ print myparams |
144 |
+ settings, trees, mtimedb = load_emerge_config() |
145 |
+ try: |
146 |
+ success, mydepgraph, favorites = backtrack_depgraph( |
147 |
+ settings, trees, myopts, myparams, myaction, myfiles, spinner=None) |
148 |
+ print success, mydepgraph, favorites |
149 |
+ except portage.exception.PackageSetNotFound as e: |
150 |
+ root_config = trees[settings["ROOT"]]["root_config"] |
151 |
+ display_missing_pkg_set(root_config, e.value) |
152 |
+ return 1 |
153 |
+ use_changes = None |
154 |
+ mydepgraph._show_merge_list() |
155 |
+ mydepgraph.display_problems() |
156 |
+ if mydepgraph._dynamic_config._needed_use_config_changes: |
157 |
+ use_changes = {} |
158 |
+ for pkg, needed_use_config_changes in mydepgraph._dynamic_config._needed_use_config_changes.items(): |
159 |
+ new_use, changes = needed_use_config_changes |
160 |
+ use_changes[pkg.cpv] = changes |
161 |
+ print use_changes |
162 |
+ if use_changes is None: |
163 |
+ return None |
164 |
+ iteritems_packages = {} |
165 |
+ for k, v in use_changes.iteritems(): |
166 |
+ k_package = portage.versions.cpv_getkey(k) |
167 |
+ iteritems_packages[ k_package ] = v |
168 |
+ print iteritems_packages |
169 |
+ return iteritems_packages |
170 |
+ |
171 |
+def comper_useflags(settings, portdb, cpv, build_dict): |
172 |
+ iuse_flags, use_enable = get_flags(settings, portdb, cpv) |
173 |
+ iuse = [] |
174 |
+ print "use_enable", use_enable |
175 |
+ build_use_flags_dict = build_dict['build_useflags'] |
176 |
+ print "build_use_flags_dict", build_use_flags_dict |
177 |
+ build_use_flags_list = [] |
178 |
+ if use_enable == []: |
179 |
+ if build_use_flags_dict is None: |
180 |
+ return None |
181 |
+ for iuse_line in iuse_flags: |
182 |
+ iuse.append(reduce_flag(iuse_line)) |
183 |
+ iuse_flags_list = list(set(iuse)) |
184 |
+ use_disable = list(set(iuse_flags_list).difference(set(use_enable))) |
185 |
+ use_flagsDict = {} |
186 |
+ for x in use_enable: |
187 |
+ use_flagsDict[x] = True |
188 |
+ for x in use_disable: |
189 |
+ use_flagsDict[x] = False |
190 |
+ print "use_flagsDict", use_flagsDict |
191 |
+ for k, v in use_flagsDict.iteritems(): |
192 |
+ print "tree use flags", k, v |
193 |
+ print "db use flags", k, build_use_flags_dict[k] |
194 |
+ if build_use_flags_dict[k] != v: |
195 |
+ if build_use_flags_dict[k] is True: |
196 |
+ build_use_flags_list.append(k) |
197 |
+ if build_use_flags_dict[k] is False: |
198 |
+ build_use_flags_list.append("-" + k) |
199 |
+ if build_use_flags_list == []: |
200 |
+ build_use_flags_list = None |
201 |
+ print build_use_flags_list |
202 |
+ return build_use_flags_list |
203 |
+ |
204 |
+def get_cpv_build_list(database, build_dict, config_profile): |
205 |
+ build_cpv_dict = {} |
206 |
+ cpv_dict = {} |
207 |
+ cpv_list = "1" |
208 |
+ settings = portage.config(clone=portage.settings) |
209 |
+ portdb = portage.portdbapi(mysettings=settings) |
210 |
+ porttree = portage.portagetree(settings=settings) |
211 |
+ trees = {"/" : {"porttree":porttree}} |
212 |
+ dep_keys = ("DEPEND", "RDEPEND", "PDEPEND") |
213 |
+ pkgdir = os.path.join(settings['PORTDIR'], build_dict['categories'] + "/" + build_dict['package']) |
214 |
+ ebuild_version_checksum_tree = portage.checksum.sha256hash(pkgdir+ "/" + build_dict['package'] + "-" + build_dict['ebuild_version'] + ".ebuild")[0] |
215 |
+ print ebuild_version_checksum_tree |
216 |
+ if ebuild_version_checksum_tree != build_dict['ebuild_checksum']: |
217 |
+ new_queue_id = database.check_revision(build_dict, config_profile, ebuild_version_checksum_tree) |
218 |
+ if new_queue_id is None: |
219 |
+ return None |
220 |
+ if check_fail_times(build_dict['queue_id'], "cpv_checksum") is False: |
221 |
+ update_fail_times(build_dict['queue_id'], "cpv_checksum") |
222 |
+ else: |
223 |
+ add_cpv_fail(build_dict['queue_id'], "cpv_checksum") |
224 |
+ return None |
225 |
+ build_dict = database.get_package_to_build(config_profile, new_queue_id) |
226 |
+ categories = build_dict['categories'] |
227 |
+ package = build_dict['package'] |
228 |
+ ebuild_version = build_dict['ebuild_version'] |
229 |
+ ebuild_version_useflags = build_dict['build_useflags'] |
230 |
+ build_massage = build_dict['post_message'] |
231 |
+ cpv = unicode(categories + "/" + package + "-" + ebuild_version) |
232 |
+ cp = unicode(categories + "/" + package) |
233 |
+ pkgdir = os.path.join(settings['PORTDIR'], build_dict['categories'] + "/" + build_dict['package']) |
234 |
+ settings['O'] = pkgdir |
235 |
+ print portage.getmaskingstatus(cpv, settings=settings, portdb=portdb) |
236 |
+ if portage.getmaskingstatus(cpv, settings=settings, portdb=portdb) != []: |
237 |
+ if check_fail_times(build_dict['queue_id'], "cpv_mask") is False: |
238 |
+ update_fail_times(build_dict['queue_id'], "cpv_mask") |
239 |
+ else: |
240 |
+ add_cpv_fail(build_dict['queue_id'], "cpv_mask") |
241 |
+ return None |
242 |
+ build_use_flags_list = comper_useflags(settings, portdb, cpv, build_dict) |
243 |
+ if check_file_in_manifest(pkgdir, settings, portdb, cpv, build_dict, build_use_flags_list) is False: |
244 |
+ if check_fail_times(build_dict['queue_id'], "cpv_file_manifest") is False: |
245 |
+ update_fail_times(build_dict['queue_id'], "cpv_file_manifest") |
246 |
+ else: |
247 |
+ add_cpv_fail(build_dict['queue_id'], "cpv_file_manifest") |
248 |
+ return None |
249 |
+ build_cpv_dict = get_needed_dep_useflags(cpv, build_use_flags_list) |
250 |
+ print build_cpv_dict, build_use_flags_list, cpv |
251 |
+ build_use_flags_dict = {} |
252 |
+ if build_use_flags_list is None: |
253 |
+ build_use_flags_dict['None'] = None |
254 |
+ if build_cpv_dict is None: |
255 |
+ build_cpv_dict = {} |
256 |
+ build_cpv_dict[cpv] = build_use_flags_dict |
257 |
+ else: |
258 |
+ build_cpv_dict[cpv] = build_use_flags_dict |
259 |
+ print build_cpv_dict |
260 |
+ return build_cpv_dict |
261 |
+ |
262 |
+def main_loop(database, config_profile): |
263 |
+ repeat = True |
264 |
+ queue_id_list = 4 |
265 |
+ while repeat: |
266 |
+ build_cpv_dict = {} |
267 |
+ build_dict = {} |
268 |
+ if check_configure(database, config_profile) is not True: |
269 |
+ # time.sleep(60) |
270 |
+ continue # retunr to the start of the function |
271 |
+ else: |
272 |
+ build_dict = database.get_package_to_build(config_profile, queue_id_list) |
273 |
+ print build_dict['ebuild_id'], build_dict['post_message'] |
274 |
+ if build_dict['ebuild_id'] is None: |
275 |
+ if build_dict['post_message'] is None: |
276 |
+ # time.sleep(60) |
277 |
+ print "build_dict none" |
278 |
+ queue_id_list = queue_id_list + 1 |
279 |
+ print queue_id_list |
280 |
+ continue # return to the start of the function |
281 |
+ build_cpv_dict = get_cpv_build_list(database, build_dict, config_profile) |
282 |
+ if build_cpv_dict is None: |
283 |
+ queue_id_list = queue_id_list + 1 |
284 |
+ continue # return to the start of the function |
285 |
+ build_cpv_list = [] |
286 |
+ for k, v in build_cpv_dict.iteritems(): |
287 |
+ build_use_flags_list = [] |
288 |
+ for x, y in v.iteritems(): |
289 |
+ if y is True: |
290 |
+ build_use_flags_list.append(x) |
291 |
+ if y is False: |
292 |
+ build_use_flags_list.append("-" + x) |
293 |
+ print k, build_use_flags_list |
294 |
+ if build_use_flags_list == []: |
295 |
+ build_cpv_list.append("=" + k) |
296 |
+ else: |
297 |
+ build_use_flags = "" |
298 |
+ for flags in build_use_flags_list: |
299 |
+ build_use_flags = build_use_flags + flags + "," |
300 |
+ build_cpv_list.append("=" + k + "[" + build_use_flags + "]") |
301 |
+ print build_cpv_list |
302 |
+ argscmd = [] |
303 |
+ argscmd.append("--buildpkg") |
304 |
+ argscmd.append("--usepkg") |
305 |
+ argscmd.append("--oneshot") |
306 |
+ for build_cpv in build_cpv_list: |
307 |
+ argscmd.append(build_cpv) |
308 |
+ print argscmd |
309 |
+ emerge_main(args=argscmd) |
310 |
+ sys.exit() |
311 |
+ queue_id_list = queue_id_list + 1 |
312 |
+ |
313 |
def main(): |
314 |
# Main |
315 |
get_conf_settings.__init__ # Init settings from the configfile |
316 |
database = init_sql_backend() # Init the Database |
317 |
- input_atom = "" |
318 |
- if check_make_conf(database) is True: |
319 |
- build_list = database.get_package_to_build(get_conf_settings.SetBuildConfig) |
320 |
- print build_list |
321 |
- categories = build_list[0] |
322 |
- package = build_list[1] |
323 |
- ebuild_version = build_list[2] |
324 |
- ebuild_version_useflags = build_list[3] |
325 |
- ebuild_version_checksum_db = build_list[4] |
326 |
- use_final_checksum_db = build_list[5] |
327 |
- cpv = categories + "/" + package + "-" + ebuild_version |
328 |
- cp = categories + "/" + package |
329 |
- settings = portage.config(clone=portage.settings) |
330 |
- portdb = portage.portdbapi(mysettings=settings) |
331 |
- porttree = portage.portagetree(settings=settings) |
332 |
- trees = {"/" : {"porttree":porttree}} |
333 |
- dep_keys = ("DEPEND", "RDEPEND", "PDEPEND") |
334 |
- pkgdir = os.path.join(settings['PORTDIR'], categories + "/" + package) |
335 |
- print pkgdir |
336 |
- print settings['DISTDIR'] |
337 |
- settings['O'] = pkgdir |
338 |
- if portage.portdb.cpv_exists(cpv) is 1: |
339 |
- print cpv |
340 |
- ebuild_fetchmap = portdb.getFetchMap(cpv, useflags=None, mytree=None) |
341 |
- print ebuild_fetchmap |
342 |
- myfetchlistdict = portage.FetchlistDict(pkgdir, settings, portdb) |
343 |
- my_manifest = portage.Manifest(pkgdir, settings['DISTDIR'], fetchlist_dict=myfetchlistdict, manifest1_compat=False, from_scratch=False) |
344 |
- check_file_in_manifest = my_manifest.findFile(package + "-" + ebuild_version + ".ebuild") |
345 |
- if not check_file_in_manifest is None: |
346 |
- print "works" |
347 |
- ebuild_version_checksum_tree = portage.checksum.sha256hash(pkgdir+ "/" + package + "-" + ebuild_version + ".ebuild") |
348 |
- print ebuild_version_checksum_tree[0] |
349 |
- print ebuild_version_checksum_db |
350 |
- if ebuild_version_checksum_tree[0] == ebuild_version_checksum_db[0]: |
351 |
- print "checksum ok" |
352 |
- try: |
353 |
- ebuild_auxdb_list = portdb.aux_get(cpv, portage.auxdbkeys) |
354 |
- except: |
355 |
- ebuild_auxdb_list = [] |
356 |
- if not ebuild_auxdb_list is []: |
357 |
- print ebuild_auxdb_list |
358 |
- iuse_flags, final_use = get_flags(settings, portage.portdb, cpv) |
359 |
- use_list = "" |
360 |
- # Fix the use flags so we can hash it |
361 |
- for i in final_use: |
362 |
- use_list = use_list + i + " " |
363 |
- use_final_checksum_tree = hashlib.md5(use_list).hexdigest() |
364 |
- print use_final_checksum_db |
365 |
- if use_final_checksum_tree == use_final_checksum_db: |
366 |
- print ebuild_version_useflags |
367 |
- ebuild_fetchmap = portdb.getFetchMap(cpv, useflags=use_list, mytree=None) |
368 |
- print ebuild_fetchmap |
369 |
- settings.unlock() |
370 |
- portage.fetch(ebuild_fetchmap, settings, listonly=0, fetchonly=0, locks_in_subdir='.locks', use_locks=1, try_mirrors=1) |
371 |
- settings.lock() |
372 |
- print my_manifest.checkCpvHashes(cpv, checkDistfiles=True, onlyDistfiles=False, checkMiscfiles=True) |
373 |
- print portdb.fetch_check(cpv, useflags=use_list, mysettings=settings, all=False) |
374 |
- if portage.getmaskingstatus(cpv, settings=settings, portdb=portdb) == []: |
375 |
- print "works no mask" |
376 |
- metadata = dict(zip(dep_keys, portdb.aux_get(cpv, dep_keys))) |
377 |
- dep_str = " ".join(metadata[k] for k in dep_keys) |
378 |
- success, atoms = portage.dep_check(dep_str, None, settings, use="yes", trees=trees, myroot=settings["ROOT"]) |
379 |
- if not success: |
380 |
- sys.stderr.write("%s %s\n" % (cpv, atoms)) |
381 |
- else: |
382 |
- bad_atoms = [] |
383 |
- for atom in atoms: |
384 |
- if not atom.blocker and atom.cp == input_atom.cp: |
385 |
- matches = portdb.xmatch("match-all", atom) |
386 |
- if not portage.dep.match_from_list(input_atom, matches): |
387 |
- bad_atoms.append(atom) |
388 |
- if bad_atoms: |
389 |
- sys.stdout.write("%s\t%s\n" % (cpv, " ".join(bad_atoms))) |
390 |
+ config_profile = get_conf_settings.SetBuildConfig |
391 |
+ main_loop(database, config_profile) |
392 |
|
393 |
if __name__ == "__main__": |
394 |
main() |
395 |
|
396 |
diff --git a/buildhost/buildhost/sqlbackend.py b/buildhost/buildhost/sqlbackend.py |
397 |
index bb4166f..a609be1 100644 |
398 |
--- a/buildhost/buildhost/sqlbackend.py |
399 |
+++ b/buildhost/buildhost/sqlbackend.py |
400 |
@@ -21,12 +21,12 @@ class DatabaseConfig(object): |
401 |
# The user needs: |
402 |
# DELETE, INSERT, UPDATE, SELECT |
403 |
# Do NOT change these, set the values in the config file /etc/buildhost/buildhost.conf |
404 |
- settings['sql_mysql'] = {} |
405 |
- settings['sql_mysql']['charset'] = 'utf8' |
406 |
- settings['sql_mysql']['host'] = get_conf_settings.SetSqlHost |
407 |
- settings['sql_mysql']['db'] = get_conf_settings.SetSqlDB |
408 |
- settings['sql_mysql']['user'] = get_conf_settings.SetSqlUser |
409 |
- settings['sql_mysql']['passwd'] = get_conf_settings.SetSqlPasswd |
410 |
+ settings['sql_pgsql'] = {} |
411 |
+ # settings['sql_pgsql']['charset'] = 'utf8' |
412 |
+ settings['sql_pgsql']['host'] = get_conf_settings.SetSqlHost |
413 |
+ settings['sql_pgsql']['database'] = get_conf_settings.SetSqlDB |
414 |
+ settings['sql_pgsql']['user'] = get_conf_settings.SetSqlUser |
415 |
+ settings['sql_pgsql']['password'] = get_conf_settings.SetSqlPasswd |
416 |
|
417 |
class SQLPackageDatabase(object): |
418 |
"""we have to store our stuff somewhere |
419 |
@@ -42,87 +42,605 @@ class SQLPackageDatabase(object): |
420 |
|
421 |
sql = {} |
422 |
|
423 |
- sql['SELECT_make_conf_checksum_db'] = """ |
424 |
- SELECT make_conf_checksum |
425 |
- FROM configs |
426 |
- WHERE config = %s |
427 |
- """ |
428 |
- def get_make_conf_checksum_db(self, config_line): |
429 |
- sql = self.sql['SELECT_make_conf_checksum_db'] |
430 |
- self.cursor.execute(sql, (config_line)) |
431 |
- entries = self.cursor.fetchone() |
432 |
+ def get_default_config(self, config_profile): |
433 |
+ cursor = self.conn.cursor() |
434 |
+ sqlQ = "SELECT make_conf_checksum FROM configs WHERE active = 'True' AND id = %s AND updateing = 'False'" |
435 |
+ cursor.execute(sqlQ, (config_profile,)) |
436 |
+ return cursor.fetchone() |
437 |
+ |
438 |
+ def get_package_to_build(self, config_profile, queue_id): |
439 |
+ cursor = self.conn.cursor() |
440 |
+ print queue_id, config_profile |
441 |
+ # get what to build |
442 |
+ sqlQ1 = "SELECT ebuild_id, post_message FROM buildqueue WHERE config = %s AND extract(epoch from (NOW()) - timestamp) > 7200 AND queue_id = %s" |
443 |
+ # get use flags to use |
444 |
+ sqlQ2 = "SELECT useflag, enabled FROM ebuildqueuedwithuses WHERE queue_id = %s" |
445 |
+ # get ebuild version (v) and package id |
446 |
+ sqlQ3 = 'SELECT ebuild_version, package_id, ebuild_checksum FROM ebuilds WHERE id = %s' |
447 |
+ # get categoriy and package (c, p) |
448 |
+ sqlQ4 ='SELECT category, package_name FROM packages WHERE package_id = %s' |
449 |
+ build_dict = {} |
450 |
+ build_useflags_dict = {} |
451 |
+ cursor.execute(sqlQ1, (config_profile, queue_id)) |
452 |
+ entries = cursor.fetchone() |
453 |
+ print entries |
454 |
if entries is None: |
455 |
- return None |
456 |
+ build_dict['ebuild_id'] = None |
457 |
+ build_dict['post_message'] = None |
458 |
+ return build_dict |
459 |
+ build_dict['queue_id'] = queue_id |
460 |
+ ebuild_id = entries[0] |
461 |
+ build_dict['ebuild_id'] = ebuild_id |
462 |
+ build_dict['post_message'] = entries[1] |
463 |
+ cursor.execute(sqlQ2, (queue_id,)) |
464 |
+ entries = cursor.fetchall() |
465 |
+ if entries == []: |
466 |
+ build_useflags = None |
467 |
+ else: |
468 |
+ build_useflags = entries |
469 |
+ cursor.execute(sqlQ3, (ebuild_id,)) |
470 |
+ entries = cursor.fetchall()[0] |
471 |
+ build_dict['ebuild_version'] = entries[0] |
472 |
+ build_dict['package_id'] = entries[1] |
473 |
+ build_dict['ebuild_checksum'] = entries[2] |
474 |
+ cursor.execute(sqlQ4, (entries[1],)) |
475 |
+ entries = cursor.fetchall()[0] |
476 |
+ build_dict['categories'] = entries[0] |
477 |
+ build_dict['package'] = entries[1] |
478 |
+ if build_useflags is None: |
479 |
+ build_dict['build_useflags'] = None |
480 |
else: |
481 |
- return entries |
482 |
+ for x in build_useflags: |
483 |
+ build_useflags_dict[x[0]] = x[1] |
484 |
+ build_dict['build_useflags'] = build_useflags_dict |
485 |
+ print "build_dict", build_dict |
486 |
+ return build_dict |
487 |
+ |
488 |
+ def check_revision(self, build_dict, config_profile, ebuild_version_checksum_tree): |
489 |
+ cursor = self.conn.cursor() |
490 |
+ sqlQ1 = 'SELECT id FROM ebuilds WHERE ebuild_version = %s AND ebuild_checksum = %s AND package_id = %s' |
491 |
+ sqlQ2 = 'SELECT queue_id FROM buildqueue WHERE ebuild_id = %s AND config = %s' |
492 |
+ sqlQ3 = "SELECT useflag FROM ebuildqueuedwithuses WHERE queue_id = %s AND enabled = 'True'" |
493 |
+ cursor.execute(sqlQ1, (build_dict['ebuild_version'], ebuild_version_checksum_tree, build_dict['package_id'])) |
494 |
+ ebuild_id = cursor.fetchone()[0] |
495 |
+ print ebuild_id |
496 |
+ if ebuild_id is None: |
497 |
+ return None |
498 |
+ cursor.execute(sqlQ2, (ebuild_id, config_profile)) |
499 |
+ queue_id_list = cursor.fetchall() |
500 |
+ if queue_id_list is None: |
501 |
+ return None |
502 |
+ for queue_id in queue_id_list: |
503 |
+ cursor.execute(sqlQ3, (queue_id,)) |
504 |
+ entries = cursor.fetchall() |
505 |
+ if entries == []: |
506 |
+ build_useflags = None |
507 |
+ else: |
508 |
+ build_useflags = entries |
509 |
+ print build_useflags, build_dict['build_useflags'] |
510 |
+ if build_useflags is build_dict['build_useflags']: |
511 |
+ print queue_id[0] |
512 |
+ return queue_id[0] |
513 |
+ return None |
514 |
+ |
515 |
+ def get_config_list_all(self): |
516 |
+ cursor = self.conn.cursor() |
517 |
+ sqlQ = 'SELECT id FROM configs' |
518 |
+ cursor.execute(sqlQ) |
519 |
+ return cursor.fetchall() |
520 |
+ |
521 |
+ def update__make_conf(self, configsDict): |
522 |
+ cursor = self.conn.cursor() |
523 |
+ |
524 |
+ sqlQ = 'UPDATE configs SET make_conf_checksum = %s, make_conf_text = %s, active = %s, config_error = %s WHERE id = %s' |
525 |
+ for k, v in configsDict.iteritems(): |
526 |
+ params = [v['make_conf_checksum_tree'], v['make_conf_text'], v['active'], v['config_error'], k] |
527 |
+ cursor.execute(sqlQ, params) |
528 |
+ self.conn.commit() |
529 |
+ |
530 |
+ def have_package_db(self, categories, package): |
531 |
+ cursor = self.conn.cursor() |
532 |
+ sqlQ ='SELECT package_id FROM packages WHERE category = %s AND package_name = %s' |
533 |
+ params = categories, package |
534 |
+ cursor.execute(sqlQ, params) |
535 |
+ return cursor.fetchone() |
536 |
+ |
537 |
+ def get_categories_db(self): |
538 |
+ cursor = self.conn.cursor() |
539 |
+ sqlQ =' SELECT category FROM categories' |
540 |
+ cursor.execute(sqlQ) |
541 |
+ return cursor.fetchall() |
542 |
+ |
543 |
+ def get_categories_checksum_db(self, categories): |
544 |
+ cursor = self.conn.cursor() |
545 |
+ sqlQ =' SELECT metadata_xml_checksum FROM categories_meta WHERE category = %s' |
546 |
+ cursor.execute(sqlQ, (categories,)) |
547 |
+ return cursor.fetchone() |
548 |
+ |
549 |
+ def add_new_categories_meta_sql(self, categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree): |
550 |
+ cursor = self.conn.cursor() |
551 |
+ sqlQ = 'INSERT INTO categories_meta (category, metadata_xml_checksum, metadata_xml_text) VALUES ( %s, %s, %s )' |
552 |
+ params = categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree |
553 |
+ cursor.execute(sqlQ, params) |
554 |
+ self.conn.commit() |
555 |
+ |
556 |
+ def update_categories_meta_sql(self, categories, categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree): |
557 |
+ cursor = self.conn.cursor() |
558 |
+ sqlQ ='UPDATE categories_meta SET metadata_xml_checksum = %s, metadata_xml_text = %s WHERE category = %s' |
559 |
+ params = (categories_metadata_xml_checksum_tree, categories_metadata_xml_text_tree, categories) |
560 |
+ cursor.execute(sqlQ, params) |
561 |
+ self.conn.commit() |
562 |
+ |
563 |
+ def add_new_manifest_sql(self, package_id, get_manifest_text, manifest_checksum_tree): |
564 |
+ cursor = self.conn.cursor() |
565 |
+ sqlQ = 'INSERT INTO manifest (package_id, manifest, checksum) VALUES ( %s, %s, %s )' |
566 |
+ params = package_id, get_manifest_text, manifest_checksum_tree |
567 |
+ cursor.execute(sqlQ, params) |
568 |
+ self.conn.commit() |
569 |
+ |
570 |
+ def add_new_package_metadata(self, package_id, package_metadataDict): |
571 |
+ cursor = self.conn.cursor() |
572 |
+ sqlQ = 'SELECT changelog_checksum FROM packages_meta WHERE package_id = %s' |
573 |
+ cursor.execute(sqlQ, (package_id,)) |
574 |
+ if cursor.fetchone() is None: |
575 |
+ sqlQ = 'INSERT INTO packages_meta (package_id, changelog_text, changelog_checksum, metadata_text, metadata_checksum) VALUES ( %s, %s, %s, %s, %s )' |
576 |
+ for k, v in package_metadataDict.iteritems(): |
577 |
+ params = package_id, v['changelog_text'], v['changelog_checksum'], v[' metadata_xml_text'], v['metadata_xml_checksum'] |
578 |
+ cursor.execute(sqlQ, params) |
579 |
+ self.conn.commit() |
580 |
+ |
581 |
+ def update_new_package_metadata(self, package_id, package_metadataDict): |
582 |
+ cursor = self.conn.cursor() |
583 |
+ sqlQ = 'SELECT changelog_checksum, metadata_checksum FROM packages_meta WHERE package_id = %s' |
584 |
+ cursor.execute(sqlQ, package_id) |
585 |
+ entries = cursor.fetchone() |
586 |
+ changelog_checksum_db = entries[0] |
587 |
+ metadata_checksum_db = entries[1] |
588 |
+ for k, v in package_metadataDict.iteritems(): |
589 |
+ if changelog_checksum_db != v['changelog_checksum']: |
590 |
+ sqlQ = 'UPDATE packages_meta SET changelog_text = %s, changelog_checksum = %s WHERE package_id = %s' |
591 |
+ params = v['changelog_text'], v['changelog_checksum'], package_id |
592 |
+ cursor.execute(sqlQ, params) |
593 |
+ if metadata_checksum_db != v['metadata_xml_checksum']: |
594 |
+ sqlQ = 'UPDATE packages_meta SET metadata_text = %s, metadata_checksum = %s WHERE package_id = %s' |
595 |
+ params = v[' metadata_xml_text'], v['metadata_xml_checksum'], package_id |
596 |
+ cursor.execute(sqlQ, params) |
597 |
+ self.conn.commit() |
598 |
+ |
599 |
+ def get_manifest_db(self, package_id): |
600 |
+ cursor = self.conn.cursor() |
601 |
+ sqlQ = 'SELECT checksum FROM manifest WHERE package_id = %s' |
602 |
+ cursor.execute(sqlQ, package_id) |
603 |
+ return cursor.fetchone() |
604 |
+ |
605 |
+ def update_manifest_sql(self, package_id, get_manifest_text, manifest_checksum_tree): |
606 |
+ cursor = self.conn.cursor() |
607 |
+ sqlQ = 'UPDATE manifest SET checksum = %s, manifest = %s WHERE package_id = %s' |
608 |
+ params = (manifest_checksum_tree, get_manifest_text, package_id) |
609 |
+ cursor.execute(sqlQ, params) |
610 |
+ self.conn.commit() |
611 |
|
612 |
- sql['SELECT_config_active'] = """ |
613 |
- SELECT make_conf_checksum |
614 |
- FROM configs |
615 |
- WHERE config = %s AND active = 'y' AND updateing = 'n' |
616 |
+ def add_new_metadata(self, metadataDict): |
617 |
+ for k, v in metadataDict.iteritems(): |
618 |
+ cursor = self.conn.cursor() |
619 |
+ sqlQ = 'SELECT updaterestrictions( %s, %s )' |
620 |
+ params = k, v['restrictions'] |
621 |
+ cursor.execute(sqlQ, params) |
622 |
+ sqlQ = 'SELECT updatekeywords( %s, %s )' |
623 |
+ params = k, v['keyword'] |
624 |
+ cursor.execute(sqlQ, params) |
625 |
+ sqlQ = 'SELECT updateiuse( %s, %s )' |
626 |
+ params = k, v['iuse'] |
627 |
+ cursor.execute(sqlQ, params) |
628 |
+ self.conn.commit() |
629 |
+ |
630 |
+ def add_new_package_sql(self, packageDict): |
631 |
+ #lets have a new cursor for each metod as per best practice |
632 |
+ cursor = self.conn.cursor() |
633 |
+ sqlQ="SELECT insert_ebuild( %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'True')" |
634 |
+ ebuild_id_list = [] |
635 |
+ package_id_list = [] |
636 |
+ for k, v in packageDict.iteritems(): |
637 |
+ params = [v['categories'], v['package'], v['ebuild_version_tree'], v['ebuild_version_revision'], v['ebuild_version_checksum_tree'], |
638 |
+ v['ebuild_version_text'], v['ebuild_version_metadata_tree'][0], v['ebuild_version_metadata_tree'][1], |
639 |
+ v['ebuild_version_metadata_tree'][12], v['ebuild_version_metadata_tree'][2], v['ebuild_version_metadata_tree'][3], |
640 |
+ v['ebuild_version_metadata_tree'][5],v['ebuild_version_metadata_tree'][6], v['ebuild_version_metadata_tree'][7], |
641 |
+ v['ebuild_version_metadata_tree'][9], v['ebuild_version_metadata_tree'][11], |
642 |
+ v['ebuild_version_metadata_tree'][13],v['ebuild_version_metadata_tree'][14], v['ebuild_version_metadata_tree'][15], |
643 |
+ v['ebuild_version_metadata_tree'][16]] |
644 |
+ cursor.execute(sqlQ, params) |
645 |
+ mid = cursor.fetchone() |
646 |
+ mid=mid[0] |
647 |
+ ebuild_id_list.append(mid[1]) |
648 |
+ package_id_list.append(mid[0]) |
649 |
+ self.conn.commit() |
650 |
+ # add_new_metadata(metadataDict) |
651 |
+ return ebuild_id_list, package_id_list |
652 |
+ |
653 |
+ def add_new_ebuild_sql(packageDict, new_ebuild_list): |
654 |
+ #lets have a new cursor for each metod as per best practice |
655 |
+ cursor = self.conn.cursor() |
656 |
+ sqlQ="SELECT insert_ebuild( %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, 'True')" |
657 |
+ ebuild_id_list = [] |
658 |
+ package_id_list = [] |
659 |
+ for k, v in packageDict.iteritems(): |
660 |
+ for x in new_ebuild_list: |
661 |
+ if x == v['ebuild_version_tree']: |
662 |
+ params = [v['categories'], v['package'], v['ebuild_version_tree'], v['ebuild_version_revision'], v['ebuild_version_checksum_tree'], |
663 |
+ v['ebuild_version_text'], v['ebuild_version_metadata_tree'][0], v['ebuild_version_metadata_tree'][1], |
664 |
+ v['ebuild_version_metadata_tree'][12], v['ebuild_version_metadata_tree'][2], v['ebuild_version_metadata_tree'][3], |
665 |
+ v['ebuild_version_metadata_tree'][5],v['ebuild_version_metadata_tree'][6], v['ebuild_version_metadata_tree'][7], |
666 |
+ v['ebuild_version_metadata_tree'][9], v['ebuild_version_metadata_tree'][11], |
667 |
+ v['ebuild_version_metadata_tree'][13],v['ebuild_version_metadata_tree'][14], v['ebuild_version_metadata_tree'][15], |
668 |
+ v['ebuild_version_metadata_tree'][16]] |
669 |
+ cursor.execute(sqlQ, params) |
670 |
+ mid = cursor.fetchone() |
671 |
+ mid=mid[0] |
672 |
+ ebuild_id_list.append(mid[1]) |
673 |
+ package_id_list.append(mid[0]) |
674 |
+ self.conn.commit() |
675 |
+ # add_new_metadata(metadataDict) |
676 |
+ return ebuild_id_list, package_id_list |
677 |
+ |
678 |
+ def update_active_ebuild(self, package_id, ebuild_version_tree): |
679 |
+ cursor = self.conn.cursor() |
680 |
+ sqlQ ="UPDATE ebuilds SET active = 'False', timestamp = now() WHERE package_id = %s AND ebuild_version = %s AND active = 'True'" |
681 |
+ cursor.execute(sqlQ, (package_id, ebuild_version_tree)) |
682 |
+ self.conn.commit() |
683 |
+ |
684 |
+ sql['SELECT_get_ebuild_id_db'] = """ |
685 |
+ SELECT id |
686 |
+ FROM packages |
687 |
+ WHERE category = %s AND ebuild_name = %s AND ebuild_version = %s |
688 |
""" |
689 |
- def get_config_active(self, config_line): |
690 |
- sql = self.sql['SELECT_config_active'] |
691 |
- self.cursor.execute(sql, (config_line)) |
692 |
+ def get_ebuild_id_db(self, categories, package, ebuild_version_tree): |
693 |
+ sql = self.sql['SELECT_get_ebuild_id_db'] |
694 |
+ self.cursor.execute(sql, (categories, package, ebuild_version_tree)) |
695 |
entries = self.cursor.fetchone() |
696 |
- if entries is None: |
697 |
- return None |
698 |
- else: |
699 |
- return True |
700 |
- sql['SELECT_package_build'] = """ |
701 |
- SELECT categories, package, ebuild_version, use_flags, ebuild_version_checksum, use_checksum |
702 |
- FROM buildqueru |
703 |
- WHERE config = %s |
704 |
- ORDER BY index2 |
705 |
- LIMIT 1 |
706 |
- """ |
707 |
- def get_package_to_build(self, config_line): |
708 |
- sql = self.sql['SELECT_package_build'] |
709 |
- self.cursor.execute(sql, config_line) |
710 |
+ return entries |
711 |
+ |
712 |
+ sql['SELECT_get_cpv_from_ebuild_id'] = """ |
713 |
+ SELECT category, ebuild_name, ebuild_version |
714 |
+ FROM packages |
715 |
+ WHERE id = %s |
716 |
+ """ |
717 |
+ def get_cpv_from_ebuild_id(self, ebuild_id): |
718 |
+ cursor = self.conn.cursor() |
719 |
+ sqlQ = 'SELECT package_id FROM ebuild WHERE id = %s' |
720 |
+ self.cursor.execute(sql, ebuild_id) |
721 |
entries = self.cursor.fetchone() |
722 |
- if entries is None: |
723 |
- return False |
724 |
- else: |
725 |
- return entries |
726 |
+ return entries |
727 |
+ |
728 |
+ def get_cp_from_package_id(self, package_id): |
729 |
+ cursor = self.conn.cursor() |
730 |
+ sqlQ = "SELECT ARRAY_TO_STRING(ARRAY[category, package_name] , '/') AS cp FROM packages WHERE package_id = %s" |
731 |
+ cursor.execute(sqlQ, (package_id,)) |
732 |
+ return cursor.fetchone() |
733 |
+ |
734 |
+ sql['SELECT_get_keyword_id_db'] = """ |
735 |
+ SELECT id_keyword |
736 |
+ FROM keywords |
737 |
+ WHERE ARCH = %s AND stable = %s |
738 |
+ """ |
739 |
+ def get_keyword_id_db(self, arch, stable): |
740 |
+ sql = self.sql['SELECT_get_keyword_id_db'] |
741 |
+ self.cursor.execute(sql, (arch, stable)) |
742 |
+ entries = self.cursor.fetchone() |
743 |
+ return entries |
744 |
+ |
745 |
+ sql['INSERT_add_new_keywords'] = """ |
746 |
+ INSERT INTO keywordsToEbuild |
747 |
+ (ebuild_id, id_keyword) |
748 |
+ VALUES ( %s, %s ) |
749 |
+ """ |
750 |
+ def add_new_keywords(self, ebuild_id, keyword_id): |
751 |
+ sql = self.sql['INSERT_add_new_keywords'] |
752 |
+ self.cursor.execute(sql, (ebuild_id, keyword_id)) |
753 |
+ self.db.commit() |
754 |
|
755 |
+ sql['SELECT_have_package_buildqueue'] = """ |
756 |
+ SELECT useflags |
757 |
+ FROM buildqueue |
758 |
+ WHERE ebuild_id = %s AND config_id = %s |
759 |
+ """ |
760 |
+ def have_package_buildqueue(self, ebuild_id, config_id): |
761 |
+ sql = self.sql['SELECT_have_package_buildqueue'] |
762 |
+ params = (ebuild_id[0], config_id) |
763 |
+ self.cursor.execute(sql, params) |
764 |
+ entries = self.cursor.fetchone() |
765 |
+ return entries |
766 |
+ |
767 |
+ def add_new_package_buildqueue(self, ebuild_id, config_id, iuse_flags_list, use_enable, message): |
768 |
+ cursor = self.conn.cursor() |
769 |
+ sqlQ="SELECT insert_buildqueue( %s, %s, %s, %s, %s )" |
770 |
+ if not iuse_flags_list: |
771 |
+ iuse_flags_list=None |
772 |
+ use_enable=None |
773 |
+ params = ebuild_id, unicode(config_id), iuse_flags_list, use_enable, message |
774 |
+ cursor.execute(sqlQ, params) |
775 |
+ self.conn.commit() |
776 |
+ |
777 |
+ sql['SELECT_get_package_id'] = """ |
778 |
+ SELECT package_id |
779 |
+ FROM packages |
780 |
+ WHERE category = %s AND package_name = %s |
781 |
+ """ |
782 |
sql['SELECT_get_ebuild_checksum'] = """ |
783 |
SELECT ebuild_checksum |
784 |
FROM ebuild |
785 |
- WHERE categories = %s AND package = %s AND ebuild_version = %s |
786 |
+ WHERE package_id = %s AND ebuild_version = %s |
787 |
""" |
788 |
- def get_ebuild_checksum(self, categories, package, ebuild_version_tree): |
789 |
- sql = self.sql['SELECT_get_ebuild_checksum'] |
790 |
- self.cursor.execute(sql, (categories, package, ebuild_version_tree)) |
791 |
- entries = self.cursor.fetchone() |
792 |
+ def get_ebuild_checksum(self, package_id, ebuild_version_tree): |
793 |
+ cursor = self.conn.cursor() |
794 |
+ sqlQ = 'SELECT ebuild_checksum FROM ebuilds WHERE package_id = %s AND ebuild_version = %s AND active = TRUE' |
795 |
+ cursor.execute(sqlQ, (package_id, ebuild_version_tree)) |
796 |
+ entries = cursor.fetchone() |
797 |
if entries is None: |
798 |
return None |
799 |
- else: |
800 |
- return entries |
801 |
+ return entries[0] |
802 |
+ |
803 |
+ sql['UPDATE_update_ebuild_db'] = """ |
804 |
+ UPDATE packages |
805 |
+ SET ebuild_checksum = %s, ebuild_text = %s, |
806 |
+ depend = %s, rdepend = %s, pdepend = %s, slot = %s, src_url = %s, homepage = %s, license = %s, |
807 |
+ description = %s, keywords = %s, inherited = %s, iuse = %s, required_use = %s, provide = %s, |
808 |
+ eapi = %s, properties = %s, defined_phases = %s |
809 |
+ WHERE ebuild_id = %s |
810 |
+ """ |
811 |
+ def update_ebuild_sql(self, ebuild_id, ebuild_version_checksum_tree, |
812 |
+ ebuild_version_metadata_tree, ebuild_version_text): |
813 |
+ sql = self.sql['UPDATE_update_ebuild_db'] |
814 |
+ params = (ebuild_version_checksum_tree[0], |
815 |
+ ebuild_version_text, ebuild_version_metadata_tree[0], ebuild_version_metadata_tree[1], |
816 |
+ ebuild_version_metadata_tree[12], ebuild_version_metadata_tree[2], ebuild_version_metadata_tree[3], |
817 |
+ ebuild_version_metadata_tree[5], ebuild_version_metadata_tree[6], ebuild_version_metadata_tree[7], |
818 |
+ ebuild_version_metadata_tree[9], ebuild_version_metadata_tree[10], ebuild_version_metadata_tree[11], |
819 |
+ ebuild_version_metadata_tree[13], ebuild_version_metadata_tree[14], ebuild_version_metadata_tree[15], |
820 |
+ ebuild_version_metadata_tree[16], ebuild_id) |
821 |
+ self.cursor.execute(sql, params) |
822 |
+ self.db.commit() |
823 |
+ |
824 |
+ sql['SELECT_cp_all_db'] = """ |
825 |
+ SELECT CONCAT_WS('/',categories, package) |
826 |
+ FROM package |
827 |
+ WHERE active = '1' |
828 |
+ """ |
829 |
+ def cp_all_db(self): |
830 |
+ cursor = self.conn.cursor() |
831 |
+ sqlQ = "SELECT package_id FROM packages" |
832 |
+ cursor.execute(sqlQ) |
833 |
+ return cursor.fetchall() |
834 |
+ |
835 |
+ def add_old_package(self, old_package_list): |
836 |
+ cursor = self.conn.cursor() |
837 |
+ mark_old_list = [] |
838 |
+ sqlQ = "UPDATE ebuilds SET active = 'FALSE', timestamp = NOW() WHERE package_id = %s AND active = 'TRUE' RETURNING package_id" |
839 |
+ for old_package in old_package_list: |
840 |
+ cursor.execute(sqlQ, (old_package[0],)) |
841 |
+ entries = cursor.fetchone() |
842 |
+ if entries is not None: |
843 |
+ mark_old_list.append(entries[0]) |
844 |
+ self.conn.commit() |
845 |
+ return mark_old_list |
846 |
+ |
847 |
+ sql['UPDATE_add_old_categories'] = """ |
848 |
+ UPDATE categories |
849 |
+ SET active = '0' |
850 |
+ WHERE categories = %s |
851 |
+ """ |
852 |
+ def get_old_categories(self, categories_line): |
853 |
+ cursor = self.conn.cursor() |
854 |
+ sqlQ = "SELECT package_name FROM packages WHERE category = %s" |
855 |
+ cursor.execute(sqlQ (categories_line)) |
856 |
+ return cursor.fetchone() |
857 |
+ |
858 |
+ def del_old_categories(self, real_old_categoriess): |
859 |
+ cursor = self.conn.cursor() |
860 |
+ sqlQ = 'DELETE FROM categories categories_meta WHERE category = %s' |
861 |
+ cursor.execute(sqlQ (real_old_categories)) |
862 |
+ self.conn.commit() |
863 |
+ |
864 |
+ def add_old_ebuild(self, package_id, old_ebuild_list): |
865 |
+ cursor = self.conn.cursor() |
866 |
+ sqlQ1 = "UPDATE ebuilds SET active = 'FALSE' WHERE package_id = %s AND ebuild_version = %s" |
867 |
+ sqlQ2 = "SELECT id FROM ebuilds WHERE package_id = %s AND ebuild_version = %s AND active = 'TRUE'" |
868 |
+ sqlQ3 = "SELECT queue_id FROM buildqueue WHERE ebuild_id = %s" |
869 |
+ sqlQ4 = 'DELETE FROM ebuildqueuedwithuses buildqueue WHERE queue_id = %s' |
870 |
+ for old_ebuild in old_ebuild_list: |
871 |
+ cursor.execute(sqlQ2, (package_id, old_ebuild[0])) |
872 |
+ ebuild_id_list = cursor.fetchall() |
873 |
+ if ebuild_id_list is not None: |
874 |
+ for ebuild_id in ebuild_id_list: |
875 |
+ cursor.execute(sqlQ3, (ebuild_id)) |
876 |
+ queue_id_list = cursor.fetchall() |
877 |
+ if queue_id_list is not None: |
878 |
+ for queue_id in queue_id_list: |
879 |
+ cursor.execute(sqlQ4, (queue_id)) |
880 |
+ cursor.execute(sqlQ1, (package_id, old_ebuild[0])) |
881 |
+ self.conn.commit() |
882 |
+ |
883 |
+ sql['SELECT_cp_all_old_db'] = """ |
884 |
+ SELECT CONCAT_WS('/',categories, package) |
885 |
+ FROM package |
886 |
+ WHERE active = '0' AND DATEDIFF(NOW(), timestamp) > 60 |
887 |
+ """ |
888 |
+ def cp_all_old_db(self, old_package_id_list): |
889 |
+ cursor = self.conn.cursor() |
890 |
+ old_package_list = [] |
891 |
+ for old_package in old_package_id_list: |
892 |
+ sqlQ = "SELECT package_id FROM ebuilds WHERE package_id = %s AND active = 'FALSE' AND date_part('days', NOW() - timestamp) < 60" |
893 |
+ cursor.execute(sqlQ, old_package) |
894 |
+ entries = cursor.fetchone() |
895 |
+ if entries is None: |
896 |
+ old_package_list.append(old_package) |
897 |
+ return old_package_list |
898 |
+ |
899 |
+ sql['DELETE_del_old_ebuild'] = """ |
900 |
+ DELETE FROM ebuild |
901 |
+ WHERE categories = %s AND package = %s AND active = '0' AND DATEDIFF(NOW(), timestamp) > 60 |
902 |
+ """ |
903 |
+ def del_old_ebuild(self, ebuild_old_list_db): |
904 |
+ cursor = self.conn.cursor() |
905 |
+ sqlQ1 ='SELECT id FROM ebuilds WHERE ebuild_version = %s' |
906 |
+ sqlQ2 = 'SELECT build_id FROM buildlog WHERE ebuild_id = %s' |
907 |
+ sqlQ3 = 'DELETE FROM qa_problems repoman_problems ebuildbuildwithuses WHERE build_id = %s' |
908 |
+ sqlQ4 = 'DELETE FROM ebuildhaveskeywords ebuildhavesiuses ebuildhavesrestrictions buildlog WHERE ebuild_id = %s' |
909 |
+ for ebuild_version in ebuild_old_list_db: |
910 |
+ cursor.execute(sqlQ1, (ebuild_version)) |
911 |
+ ebuild_id_list = cursor.fetchall() |
912 |
+ for ebuild_id in ebuild_id_list: |
913 |
+ cursor.execute(sqlQ2, ebuild_id) |
914 |
+ build_id_list = cursor.fetchall() |
915 |
+ for build_id in build_id_list: |
916 |
+ cursor.execute(sqlQ3, build_id) |
917 |
+ cursor.execute(sqlQ4, ebuild_id) |
918 |
+ self.conn.commit() |
919 |
+ |
920 |
+ sql['DELETE_del_old_package'] = """ |
921 |
+ DELETE FROM package |
922 |
+ WHERE categories = %s AND package = %s AND active = '0' AND DATEDIFF(NOW(), timestamp) > 60 |
923 |
+ """ |
924 |
+ def del_old_package(self, package_id_list): |
925 |
+ cursor = self.conn.cursor() |
926 |
+ sqlQ1 = 'SELECT id FROM ebuilds WHERE package_id = %s' |
927 |
+ sqlQ2 = 'SELECT build_id FROM buildlog WHERE ebuild_id = %s' |
928 |
+ sqlQ3 = 'DELETE FROM qa_problems, repoman_problems, ebuildbuildwithuses WHERE build_id = %s' |
929 |
+ sqlQ4 = 'DELETE FROM ebuildhaveskeywords, ebuildhavesiuses, ebuildhavesrestrictions, buildlog WHERE ebuild_id = %s' |
930 |
+ sqlQ5 = 'DELETE FROM ebuilds, manifest, package_meta, packages WHERE package_id = %s' |
931 |
+ for package_id in package_id_list: |
932 |
+ cursor.execute(sqlQ1, package_id) |
933 |
+ ebuild_id_list = cursor.fetchall() |
934 |
+ for ebuild_id in ebuild_id_list: |
935 |
+ cursor.execute(sqlQ2, ebuild_id) |
936 |
+ build_id_list = cursor.fetchall() |
937 |
+ for build_id in build_id_list: |
938 |
+ cursor.execute(sqlQ3, build_id) |
939 |
+ cursor.execute(sqlQ4, ebuild_id) |
940 |
+ cursor.execute(sqlQ5, package_id) |
941 |
+ self.conn.commit() |
942 |
+ |
943 |
+ sql['DELETE_del_old_categories'] = """ |
944 |
+ DELETE FROM categories |
945 |
+ WHERE categories = %s AND active = '0' AND DATEDIFF(NOW(), timestamp) > 60 |
946 |
+ """ |
947 |
+ def del_old_package(self, categories): |
948 |
+ sql = self.sql['DELETE_del_old_categories'] |
949 |
+ self.cursor.execute(sql, (categories)) |
950 |
+ self.db.commit() |
951 |
+ |
952 |
+ def cp_list_db(self, package_id): |
953 |
+ cursor = self.conn.cursor() |
954 |
+ sqlQ = "SELECT ebuild_version FROM ebuilds WHERE active = 'TRUE' AND package_id = %s" |
955 |
+ cursor.execute(sqlQ, (package_id)) |
956 |
+ return cursor.fetchall() |
957 |
+ |
958 |
+ def cp_list_old_db(self, package_id): |
959 |
+ cursor = self.conn.cursor() |
960 |
+ sqlQ ="SELECT id, ebuild_version FROM ebuilds WHERE active = 'FALSE' AND package_id = %s AND date_part('days', NOW() - timestamp) > 60" |
961 |
+ cursor.execute(sqlQ, package_id) |
962 |
+ return cursor.fetchall() |
963 |
+ |
964 |
+ def add_qa_repoman(self, ebuild_id_list, qa_error, packageDict, config_id): |
965 |
+ ebuild_i = 0 |
966 |
+ cursor = self.conn.cursor() |
967 |
+ for k, v in packageDict.iteritems(): |
968 |
+ ebuild_id = ebuild_id_list[ebuild_i] |
969 |
+ sqlQ = 'INSERT INTO buildlog (ebuild_id, config, error_summary, timestamp ) VALUES ( %s, %s, %s, now() ) RETURNING build_id' |
970 |
+ if v['ebuild_error'] != [] or qa_error != []: |
971 |
+ if v['ebuild_error'] != [] or qa_error == []: |
972 |
+ summary = "Repoman" |
973 |
+ elif v['ebuild_error'] == [] or qa_error != []: |
974 |
+ summary = "QA" |
975 |
+ else: |
976 |
+ summary = "QA:Repoman" |
977 |
+ params = (ebuild_id, config_id, summary) |
978 |
+ cursor.execute(sqlQ, params) |
979 |
+ build_id = cursor.fetchone() |
980 |
+ if v['ebuild_error'] != []: |
981 |
+ sqlQ = 'INSERT INTO repoman_problems (problem, build_id ) VALUES ( %s, %s )' |
982 |
+ for x in v['ebuild_error']: |
983 |
+ params = (x, build_id) |
984 |
+ cursor.execute(sqlQ, params) |
985 |
+ if qa_error != []: |
986 |
+ sqlQ = 'INSERT INTO qa_problems (problem, build_id ) VALUES ( %s, %s )' |
987 |
+ for x in qa_error: |
988 |
+ params = (x, build_id) |
989 |
+ cursor.execute(sqlQ, params) |
990 |
+ ebuild_i = ebuild_i +1 |
991 |
+ self.conn.commit() |
992 |
+ |
993 |
+ sql['SELECT_qa_repoman'] = """ |
994 |
+ SELECT categories, package, ebuild_version, qa, repoman, config, hosts |
995 |
+ FROM buildlog |
996 |
+ WHERE ebuild = %sAND build = '' AND config_id = %s |
997 |
+ """ |
998 |
+ def get_qa_repoman(self, ebuild_id, config_id): |
999 |
+ sql = self.sql['SELECT_qa_repoman'] |
1000 |
+ params = (ebuild_id, config_id) |
1001 |
+ self.cursor.execute(sql, params) |
1002 |
+ entries = self.cursor.fetchall() |
1003 |
+ return entries |
1004 |
|
1005 |
- def commit(self): |
1006 |
- """Run the commit function for the database store""" |
1007 |
+ sql['DELETE_del_qa_repoman'] = """ |
1008 |
+ DELETE FROM buildlog |
1009 |
+ WHERE ebuild_id AND build = '' AND config_id = %s |
1010 |
+ """ |
1011 |
+ def del_qa_repoman(self, ebuild_id, config_id): |
1012 |
+ sql = self.sql['DELETE_del_qa_repoman'] |
1013 |
+ self.cursor.execute(sql, (ebuild_id, config_id)) |
1014 |
self.db.commit() |
1015 |
|
1016 |
-class MySQLPackageDB(SQLPackageDatabase): |
1017 |
+ sql['UPDATE_update_qa_repoman'] = """ |
1018 |
+ UPDATE buildlog |
1019 |
+ SET qa = %s, repoman = %s |
1020 |
+ WHERE ebuild_id = %s AND build = '' AND config_id = %s |
1021 |
+ """ |
1022 |
+ def update_qa_repoman(self, ebuild_id, qa_error, repoman_error, config_id): |
1023 |
+ sql = self.sql['UPDATE_update_qa_repoman'] |
1024 |
+ self.cursor.execute(sql, (qa_error, repoman_error, ebuild_id, config_id)) |
1025 |
+ self.db.commit() |
1026 |
+ |
1027 |
+ def get_arch_db(self): |
1028 |
+ cursor = self.conn.cursor() |
1029 |
+ sqlQ = 'SELECT keyword FROM keywords WHERE keyword = %s' |
1030 |
+ cursor.execute(sqlQ, ('ppc',)) |
1031 |
+ return cursor.fetchone() |
1032 |
+ |
1033 |
+ def add_new_arch_db(self, arch_list): |
1034 |
+ cursor = self.conn.cursor() |
1035 |
+ sqlQ = 'INSERT INTO keywords (keyword) VALUES ( %s )' |
1036 |
+ for arch in arch_list: |
1037 |
+ cursor.execute(sqlQ, (arch,)) |
1038 |
+ self.conn.commit() |
1039 |
+ |
1040 |
+ sql['INSERT_add_new_restriction_db'] = """ |
1041 |
+ INSERT INTO ebuildHavesRestrictions |
1042 |
+ (ebuild_id, restriction) |
1043 |
+ VALUES ( %s, %s ) |
1044 |
+ """ |
1045 |
+ |
1046 |
+ def closeconnection(self): |
1047 |
+ self.conn.close() |
1048 |
+ |
1049 |
+class PgSQLPackageDB(SQLPackageDatabase): |
1050 |
"""override for MySQL backend""" |
1051 |
|
1052 |
syntax_placeholder = "%s" |
1053 |
- syntax_autoincrement = 'AUTO_INCREMENT' |
1054 |
- |
1055 |
+ |
1056 |
def __init__(self, config=None): |
1057 |
# Do not complain about correct usage of ** magic |
1058 |
# pylint: disable-msg=W0142 |
1059 |
SQLPackageDatabase.__init__(self) |
1060 |
|
1061 |
- if config is None or 'db' not in config: |
1062 |
+ if config is None or 'database' not in config: |
1063 |
print "No configuration available!" |
1064 |
sys.exit(1) |
1065 |
|
1066 |
try: |
1067 |
- import MySQLdb |
1068 |
+ import psycopg2 |
1069 |
except ImportError: |
1070 |
- print "Please install a recent version of MySQLdb for Python" |
1071 |
+ print "Please install a recent version of dev-python/psycopg for Python" |
1072 |
sys.exit(1) |
1073 |
|
1074 |
- self.db = MySQLdb.connect(**config) |
1075 |
- self.cursor = self.db.cursor() |
1076 |
+ self.conn = psycopg2.connect(**config) |
1077 |
+ |