Module manage
[hide private]
[frames] | no frames]

Source Code for Module manage

  1  #!/usr/bin/python 
  2   
  3  import argparse 
  4  import os 
  5  import subprocess 
  6  import datetime 
  7  import sqlalchemy 
  8  import time 
  9   
 10  import flask 
 11  from flask_script import Manager, Command, Option, Group 
 12   
 13  from coprs import app 
 14  from coprs import db 
 15  from coprs import exceptions 
 16  from coprs import models 
 17  from coprs.logic import coprs_logic, packages_logic, actions_logic, builds_logic 
 18  from coprs.views.misc import create_user_wrapper 
 19  from coprs.whoosheers import CoprWhoosheer 
 20  from run import generate_repo_packages 
 21  from sqlalchemy import or_ 
 22   
 23   
24 -class TestCommand(Command):
25
26 - def run(self, test_args):
27 os.environ["COPRS_ENVIRON_UNITTEST"] = "1" 28 if not (("COPR_CONFIG" in os.environ) and os.environ["COPR_CONFIG"]): 29 os.environ["COPR_CONFIG"] = "/etc/copr/copr_unit_test.conf" 30 os.environ["PYTHONPATH"] = "." 31 return subprocess.call(["/usr/bin/python", "-m", "pytest"] + (test_args or []))
32 33 option_list = ( 34 Option("-a", 35 dest="test_args", 36 nargs=argparse.REMAINDER), 37 )
38 39
40 -class CreateSqliteFileCommand(Command):
41 42 """ 43 Create the sqlite DB file (not the tables). 44 Used for alembic, "create_db" does this automatically. 45 """ 46
47 - def run(self):
48 if flask.current_app.config["SQLALCHEMY_DATABASE_URI"].startswith("sqlite"): 49 # strip sqlite:/// 50 datadir_name = os.path.dirname( 51 flask.current_app.config["SQLALCHEMY_DATABASE_URI"][10:]) 52 if not os.path.exists(datadir_name): 53 os.makedirs(datadir_name)
54 55
56 -class CreateDBCommand(Command):
57 58 """ 59 Create the DB schema 60 """ 61
62 - def run(self, alembic_ini=None):
63 CreateSqliteFileCommand().run() 64 db.create_all() 65 66 # load the Alembic configuration and generate the 67 # version table, "stamping" it with the most recent rev: 68 from alembic.config import Config 69 from alembic import command 70 alembic_cfg = Config(alembic_ini) 71 command.stamp(alembic_cfg, "head")
72 73 option_list = ( 74 Option("--alembic", 75 "-f", 76 dest="alembic_ini", 77 help="Path to the alembic configuration file (alembic.ini)", 78 required=True), 79 )
80 81
82 -class DropDBCommand(Command):
83 84 """ 85 Delete DB 86 """ 87
88 - def run(self):
89 db.drop_all()
90 91
92 -class ChrootCommand(Command):
93
94 - def print_invalid_format(self, chroot_name):
95 print( 96 "{0} - invalid chroot format, must be '{release}-{version}-{arch}'." 97 .format(chroot_name))
98
99 - def print_already_exists(self, chroot_name):
100 print("{0} - already exists.".format(chroot_name))
101
102 - def print_doesnt_exist(self, chroot_name):
103 print("{0} - chroot doesn\"t exist.".format(chroot_name))
104 105 option_list = ( 106 Option("chroot_names", 107 help="Chroot name, e.g. fedora-18-x86_64.", 108 nargs="+"), 109 )
110 111
112 -class CreateChrootCommand(ChrootCommand):
113 114 "Creates a mock chroot in DB" 115
116 - def run(self, chroot_names):
125 126
127 -class RawhideToReleaseCommand(Command):
128 129 option_list = ( 130 Option("rawhide_chroot", help="Rawhide chroot name, e.g. fedora-rawhide-x86_64."), 131 Option("dest_chroot", help="Destination chroot, e.g. fedora-24-x86_64."), 132 ) 133
134 - def run(self, rawhide_chroot, dest_chroot):
135 mock_chroot = coprs_logic.MockChrootsLogic.get_from_name(dest_chroot).first() 136 if not mock_chroot: 137 print("Given chroot does not exist. Please run:") 138 print(" sudo python manage.py create_chroot {}".format(dest_chroot)) 139 return 140 141 mock_rawhide_chroot = coprs_logic.MockChrootsLogic.get_from_name(rawhide_chroot).first() 142 if not mock_rawhide_chroot: 143 print("Given rawhide chroot does not exist. Didnt you mistyped?:") 144 print(" {}".format(rawhide_chroot)) 145 return 146 147 for copr in coprs_logic.CoprsLogic.get_all(): 148 if not self.has_rawhide(copr): 149 continue 150 151 data = {"copr": copr.name, 152 "user": copr.user.name, 153 "rawhide_chroot": rawhide_chroot, 154 "dest_chroot": dest_chroot, 155 "builds": []} 156 157 for package in packages_logic.PackagesLogic.get_all(copr.id): 158 last_build = package.last_build(successful=True) 159 if last_build: 160 data["builds"].append(last_build.result_dir_name) 161 162 # rbc means rawhide_build_chroot (we needed short variable) 163 rbc = builds_logic.BuildChrootsLogic.get_by_build_id_and_name(last_build.id, rawhide_chroot).first() 164 dbc = builds_logic.BuildChrootsLogic.get_by_build_id_and_name(last_build.id, dest_chroot).first() 165 if rbc and not dbc: 166 dest_build_chroot = models.BuildChroot(**rbc.to_dict()) 167 dest_build_chroot.mock_chroot_id = mock_chroot.id 168 dest_build_chroot.mock_chroot = mock_chroot 169 db.session.add(dest_build_chroot) 170 171 if len(data["builds"]): 172 actions_logic.ActionsLogic.send_rawhide_to_release(data) 173 self.turn_on_the_chroot_for_copr(copr, rawhide_chroot, mock_chroot) 174 175 db.session.commit()
176
177 - def turn_on_the_chroot_for_copr(self, copr, rawhide_name, mock_chroot):
178 rawhide_chroot = coprs_logic.CoprChrootsLogic.get_by_name_safe(copr, rawhide_name) 179 dest_chroot = coprs_logic.CoprChrootsLogic.get_by_name_safe(copr, mock_chroot.name) 180 181 if not rawhide_chroot or dest_chroot: 182 return 183 184 create_kwargs = { 185 "buildroot_pkgs": rawhide_chroot.buildroot_pkgs, 186 "comps": rawhide_chroot.comps, 187 "comps_name": rawhide_chroot.comps_name, 188 } 189 coprs_logic.CoprChrootsLogic.create_chroot(copr.user, copr, mock_chroot, **create_kwargs)
190
191 - def has_rawhide(self, copr):
192 return any(filter(lambda ch: ch.os_version == "rawhide", copr.mock_chroots))
193 194
195 -class AlterChrootCommand(ChrootCommand):
196 197 "Activates or deactivates a chroot" 198
199 - def run(self, chroot_names, action):
200 activate = (action == "activate") 201 for chroot_name in chroot_names: 202 try: 203 coprs_logic.MockChrootsLogic.edit_by_name( 204 chroot_name, activate) 205 db.session.commit() 206 except exceptions.MalformedArgumentException: 207 self.print_invalid_format(chroot_name) 208 except exceptions.NotFoundException: 209 self.print_doesnt_exist(chroot_name)
210 211 option_list = ChrootCommand.option_list + ( 212 Option("--action", 213 "-a", 214 dest="action", 215 help="Action to take - currently activate or deactivate", 216 choices=["activate", "deactivate"], 217 required=True), 218 )
219 220
221 -class DropChrootCommand(ChrootCommand):
222 223 "Activates or deactivates a chroot" 224
225 - def run(self, chroot_names):
234 235
236 -class DisplayChrootsCommand(Command):
237 238 "Displays current mock chroots" 239
240 - def run(self, active_only):
241 for ch in coprs_logic.MockChrootsLogic.get_multiple( 242 active_only=active_only).all(): 243 244 print(ch.name)
245 246 option_list = ( 247 Option("--active-only", 248 "-a", 249 dest="active_only", 250 help="Display only active chroots", 251 required=False, 252 action="store_true", 253 default=False), 254 )
255 256
257 -class AddDebugUserCommand(Command):
258 259 """ 260 Adds user for debug/testing purpose. 261 You shouldn't use this on production instance 262 """ 263
264 - def run(self, name, mail, **kwargs):
265 user = User(username=name, mail=mail) 266 267 if kwargs["admin"]: 268 user.admin = True 269 if kwargs["no_admin"]: 270 user.admin = False 271 if kwargs["proven"]: 272 user.proven = True 273 if kwargs["no_proven"]: 274 user.proven = False 275 # 276 # if kwargs["api_token"]: 277 # user.api_token = kwargs["api_token"] 278 # user.api_token_expiration = datetime.date(2030, 1, 1) 279 # if kwargs["api_login"]: 280 # user.api_token = kwargs["api_login"] 281 # 282 283 db.session.add(create_user_wrapper(user, mail)) 284 db.session.commit()
285 286 option_list = ( 287 Option("name"), 288 Option("mail"), 289 Option("--api_token", default=None, required=False), 290 Option("--api_login", default=None, required=False), 291 Group( 292 Option("--admin", 293 action="store_true"), 294 Option("--no-admin", 295 action="store_true"), 296 exclusive=True 297 ), 298 Group( 299 Option("--proven", 300 action="store_true"), 301 Option("--no-proven", 302 action="store_true"), 303 exclusive=True 304 ), 305 )
306 307
308 -class AlterUserCommand(Command):
309
310 - def run(self, name, **kwargs):
311 user = models.User.query.filter( 312 models.User.username == name).first() 313 if not user: 314 print("No user named {0}.".format(name)) 315 return 316 317 if kwargs["admin"]: 318 user.admin = True 319 if kwargs["no_admin"]: 320 user.admin = False 321 if kwargs["proven"]: 322 user.proven = True 323 if kwargs["no_proven"]: 324 user.proven = False 325 326 db.session.add(user) 327 db.session.commit()
328 329 option_list = ( 330 Option("name"), 331 Group( 332 Option("--admin", 333 action="store_true"), 334 Option("--no-admin", 335 action="store_true"), 336 exclusive=True 337 ), 338 Group( 339 Option("--proven", 340 action="store_true"), 341 Option("--no-proven", 342 action="store_true"), 343 exclusive=True 344 ) 345 )
346 347
348 -class FailBuildCommand(Command):
349 350 """ 351 Marks build as failed on all its non-finished chroots 352 """ 353 354 option_list = [Option("build_id")] 355
356 - def run(self, build_id, **kwargs):
357 try: 358 builds_logic.BuildsLogic.mark_as_failed(build_id) 359 print("Marking non-finished chroots of build {} as failed".format(build_id)) 360 db.session.commit() 361 362 except (sqlalchemy.exc.DataError, sqlalchemy.orm.exc.NoResultFound) as e: 363 print("Error: No such build {}".format(build_id)) 364 return 1
365 366
367 -class UpdateIndexesCommand(Command):
368 """ 369 recreates whoosh indexes for all projects 370 """ 371
372 - def run(self):
373 writer = CoprWhoosheer.index.writer() 374 for copr in coprs_logic.CoprsLogic.get_all(): 375 CoprWhoosheer.delete_copr(writer, copr) 376 writer.commit(optimize=True) 377 378 writer = CoprWhoosheer.index.writer() 379 writer.schema = CoprWhoosheer.schema 380 writer.commit(optimize=True) 381 382 writer = CoprWhoosheer.index.writer() 383 for copr in coprs_logic.CoprsLogic.get_all(): 384 CoprWhoosheer.insert_copr(writer, copr) 385 writer.commit(optimize=True)
386 387
388 -class UpdateIndexesQuickCommand(Command):
389 """ 390 Recreates whoosh indexes for projects for which 391 indexed data were updated in last n minutes. 392 Doesn't update schema. 393 """ 394 395 option_list = [Option("minutes_passed")] 396
397 - def run(self, minutes_passed):
398 writer = CoprWhoosheer.index.writer() 399 query = db.session.query(models.Copr).filter( 400 models.Copr.latest_indexed_data_update >= time.time()-int(minutes_passed)*60 401 ) 402 for copr in query.all(): 403 CoprWhoosheer.update_copr(writer, copr) 404 writer.commit()
405 406
407 -class GenerateRepoPackagesCommand(Command):
408 """ 409 go through all coprs and create configuration rpm packages 410 for them, if they don't already have it 411 """ 412
413 - def run(self):
415 416 417 manager = Manager(app) 418 manager.add_command("test", TestCommand()) 419 manager.add_command("create_sqlite_file", CreateSqliteFileCommand()) 420 manager.add_command("create_db", CreateDBCommand()) 421 manager.add_command("drop_db", DropDBCommand()) 422 manager.add_command("create_chroot", CreateChrootCommand()) 423 manager.add_command("alter_chroot", AlterChrootCommand()) 424 manager.add_command("display_chroots", DisplayChrootsCommand()) 425 manager.add_command("drop_chroot", DropChrootCommand()) 426 manager.add_command("alter_user", AlterUserCommand()) 427 manager.add_command("add_debug_user", AddDebugUserCommand()) 428 manager.add_command("fail_build", FailBuildCommand()) 429 manager.add_command("update_indexes", UpdateIndexesCommand()) 430 manager.add_command("update_indexes_quick", UpdateIndexesQuickCommand()) 431 manager.add_command("generate_repo_packages", GenerateRepoPackagesCommand()) 432 manager.add_command("rawhide_to_release", RawhideToReleaseCommand()) 433 434 if __name__ == "__main__": 435 manager.run() 436