entropy.client.services.ugc.commands

1 # -*- coding: utf-8 -*- 2 """ 3 4 @author: Fabio Erculiani <lxnay@sabayonlinux.org> 5 @contact: lxnay@sabayonlinux.org 6 @copyright: Fabio Erculiani 7 @license: GPL-2 8 9 B{Entropy Client Services UGC Base Commands}. 10 11 """ 12 13 from __future__ import with_statement 14 import os 15 from entropy.exceptions import * 16 from entropy.const import etpConst 17 from entropy.output import darkblue, bold, blue, darkgreen, darkred, brown 18 from entropy.i18n import _ 19 from entropy.core.settings.base import SystemSettings 20

21 -class Base:

22

23 - def __init__(self, OutputInterface, Service):

24 25 if not hasattr(OutputInterface,'updateProgress'): 26 mytxt = _("OutputInterface does not have an updateProgress method") 27 raise IncorrectParameter("IncorrectParameter: %s, (! %s !)" % (OutputInterface,mytxt,)) 28 elif not callable(OutputInterface.updateProgress): 29 mytxt = _("OutputInterface does not have an updateProgress method") 30 raise IncorrectParameter("IncorrectParameter: %s, (! %s !)" % (OutputInterface,mytxt,)) 31 32 from entropy.services.ugc.interfaces import Client as Cl 33 if not isinstance(Service, (Cl,)): 34 mytxt = _("A valid entropy.services.ugc.interfaces.Client based instance is needed") 35 raise IncorrectParameter("IncorrectParameter: %s, (! %s !)" % (Service,mytxt,)) 36 37 import socket, zlib, struct 38 import entropy.tools as entropyTools 39 import entropy.dump as dumpTools 40 self.entropyTools, self.socket, self.zlib, self.struct, self.dumpTools = entropyTools, socket, zlib, struct, dumpTools 41 self.Output = OutputInterface 42 self.Service = Service 43 self.output_header = '' 44 self.SystemSettings = SystemSettings()

45

46 - def handle_standard_answer(self, data, repository = None, arch = None, product = None):

47 do_skip = False 48 # elaborate answer 49 if data == None: 50 mytxt = _("feature not supported remotely") 51 self.Output.updateProgress( 52 "[%s:%s|%s:%s|%s:%s] %s" % ( 53 darkblue(_("repo")), 54 bold(str(repository)), 55 darkred(_("arch")), 56 bold(str(arch)), 57 darkgreen(_("product")), 58 bold(str(product)), 59 blue(mytxt), 60 ), 61 importance = 1, 62 type = "error", 63 header = self.output_header 64 ) 65 do_skip = True 66 elif not data: 67 mytxt = _("service temporarily not available") 68 self.Output.updateProgress( 69 "[%s:%s|%s:%s|%s:%s] %s" % ( 70 darkblue(_("repo")), 71 bold(str(repository)), 72 darkred(_("arch")), 73 bold(str(arch)), 74 darkgreen(_("product")), 75 bold(str(product)), 76 blue(mytxt), 77 ), 78 importance = 1, 79 type = "error", 80 header = self.output_header 81 ) 82 do_skip = True 83 elif data == self.Service.answers['no']: 84 # command failed 85 mytxt = _("command failed") 86 self.Output.updateProgress( 87 "[%s:%s|%s:%s|%s:%s] %s" % ( 88 darkblue(_("repo")), 89 bold(str(repository)), 90 darkred(_("arch")), 91 bold(str(arch)), 92 darkgreen(_("product")), 93 bold(str(product)), 94 blue(mytxt), 95 ), 96 importance = 1, 97 type = "error", 98 header = self.output_header 99 ) 100 elif data != self.Service.answers['ok']: 101 mytxt = _("received wrong answer") 102 self.Output.updateProgress( 103 "[%s:%s|%s:%s|%s:%s] %s: %s" % ( 104 darkblue(_("repo")), 105 bold(str(repository)), 106 darkred(_("arch")), 107 bold(str(arch)), 108 darkgreen(_("product")), 109 bold(str(product)), 110 blue(mytxt), 111 repr(data), 112 ), 113 importance = 1, 114 type = "error", 115 header = self.output_header 116 ) 117 do_skip = True 118 return do_skip

119

120 - def get_result(self, session):

121 # get the information 122 cmd = "%s rc" % (session,) 123 self.Service.transmit(cmd) 124 try: 125 data = self.Service.receive() 126 return data 127 except: 128 self.entropyTools.print_traceback() 129 return None

130

131 - def convert_stream_to_object(self, data, gzipped, repository = None, arch = None, product = None):

132 133 # unstream object 134 error = False 135 try: 136 data = self.Service.stream_to_object(data, gzipped) 137 except (EOFError,IOError,self.zlib.error,self.dumpTools.pickle.UnpicklingError,): 138 mytxt = _("cannot convert stream into object") 139 self.Output.updateProgress( 140 "[%s:%s|%s:%s|%s:%s] %s" % ( 141 darkblue(_("repo")), 142 bold(unicode(repository)), 143 darkred(_("arch")), 144 bold(unicode(arch)), 145 darkgreen(_("product")), 146 bold(unicode(product)), 147 blue(mytxt), 148 ), 149 importance = 1, 150 type = "error", 151 header = self.output_header 152 ) 153 data = None 154 error = True 155 return data, error

156

157 - def retrieve_command_answer(self, cmd, session_id, repository = None, arch = None, product = None, compression = False):

158 159 tries = 3 160 lasterr = None 161 while 1: 162 163 if tries <= 0: 164 return lasterr 165 tries -= 1 166 167 try: 168 # send command 169 self.Service.transmit(cmd) 170 except (SSLError,): 171 return None 172 # receive answer 173 data = self.Service.receive() 174 175 skip = self.handle_standard_answer(data, repository, arch, product) 176 if skip: 177 continue 178 179 data = self.get_result(session_id) 180 if data == None: 181 lasterr = None 182 continue 183 elif not data: 184 lasterr = False 185 continue 186 187 objdata, error = self.convert_stream_to_object(data, compression, repository, arch, product) 188 if not error: 189 return objdata

190

191 - def do_generic_handler(self, cmd, session_id, tries = 10, compression = False):

192 193 self.Service.check_socket_connection() 194 195 while 1: 196 try: 197 result = self.retrieve_command_answer(cmd, session_id, compression = compression) 198 if result == None: 199 return False,'command not supported' # untranslated on purpose 200 return result 201 except (self.socket.error,self.struct.error,): 202 self.Service.reconnect_socket() 203 tries -= 1 204 if tries < 1: 205 raise

206

207 - def set_gzip_compression(self, session, do):

208 self.Service.check_socket_connection() 209 cmd = "%s %s %s %s zlib" % (session, 'session_config', 'compression', do,) 210 self.Service.transmit(cmd) 211 data = self.Service.receive() 212 if data == self.Service.answers['ok']: 213 return True 214 return False

215

216 - def service_login(self, username, password, session_id):

217 218 cmd = "%s %s %s %s" % ( 219 session_id, 220 'login', 221 username, 222 password, 223 ) 224 return self.do_generic_handler(cmd, session_id)

225

226 - def service_logout(self, username, session_id):

227 228 cmd = "%s %s %s" % ( 229 session_id, 230 'logout', 231 username, 232 ) 233 return self.do_generic_handler(cmd, session_id)

234

235 - def get_logged_user_data(self, session_id):

236 237 cmd = "%s %s" % ( 238 session_id, 239 'user_data', 240 ) 241 return self.do_generic_handler(cmd, session_id)

242

243 - def is_user(self, session_id):

244 245 cmd = "%s %s" % ( 246 session_id, 247 'is_user', 248 ) 249 return self.do_generic_handler(cmd, session_id)

250

251 - def is_developer(self, session_id):

252 253 cmd = "%s %s" % ( 254 session_id, 255 'is_developer', 256 ) 257 return self.do_generic_handler(cmd, session_id)

258

259 - def is_moderator(self, session_id):

260 261 cmd = "%s %s" % ( 262 session_id, 263 'is_moderator', 264 ) 265 return self.do_generic_handler(cmd, session_id)

266

267 - def is_administrator(self, session_id):

268 269 cmd = "%s %s" % ( 270 session_id, 271 'is_administrator', 272 ) 273 return self.do_generic_handler(cmd, session_id)

274

275 - def available_commands(self, session_id):

276 277 cmd = "%s %s" % ( 278 session_id, 279 'available_commands', 280 ) 281 return self.do_generic_handler(cmd, session_id)

282 283

284 -class Client(Base):

285

286 - def __init__(self, EntropyInterface, ServiceInterface):

287 Base.__init__(self, EntropyInterface, ServiceInterface)

288

289 - def differential_packages_comparison(self, session_id, idpackages, repository, arch, product):

290 291 myidlist = ' '.join([str(x) for x in idpackages]) 292 cmd = "%s %s %s %s %s %s %s" % ( 293 session_id, 294 'repository_server:dbdiff', 295 repository, 296 arch, 297 product, 298 self.SystemSettings['repositories']['branch'], 299 myidlist, 300 ) 301 302 # enable zlib compression 303 compression = self.set_gzip_compression(session_id, True) 304 305 data = self.do_generic_handler(cmd, session_id, tries = 5, compression = compression) 306 307 # disable compression 308 self.set_gzip_compression(session_id, False) 309 310 return data

311

312 - def get_repository_treeupdates(self, session_id, repository, arch, product):

313 314 cmd = "%s %s %s %s %s %s" % ( 315 session_id, 316 'repository_server:treeupdates', 317 repository, 318 arch, 319 product, 320 self.SystemSettings['repositories']['branch'], 321 ) 322 return self.do_generic_handler(cmd, session_id, tries = 5)

323

324 - def get_package_sets(self, session_id, repository, arch, product):

325 326 cmd = "%s %s %s %s %s %s" % ( 327 session_id, 328 'repository_server:get_package_sets', 329 repository, 330 arch, 331 product, 332 self.SystemSettings['repositories']['branch'], 333 ) 334 return self.do_generic_handler(cmd, session_id, tries = 5)

335

336 - def get_repository_metadata(self, session_id, repository, arch, product):

337 338 cmd = "%s %s %s %s %s %s" % ( 339 session_id, 340 'repository_server:get_repository_metadata', 341 repository, 342 arch, 343 product, 344 self.SystemSettings['repositories']['branch'], 345 ) 346 return self.do_generic_handler(cmd, session_id, tries = 5)

347

348 - def get_strict_package_information(self, session_id, idpackages, repository, arch, product):

349 350 cmd = "%s %s %s %s %s %s %s %s" % ( 351 session_id, 352 'repository_server:pkginfo_strict', 353 True, 354 repository, 355 arch, 356 product, 357 self.SystemSettings['repositories']['branch'], 358 ' '.join([str(x) for x in idpackages]), 359 ) 360 361 # enable zlib compression 362 compression = self.set_gzip_compression(session_id, True) 363 364 data = self.do_generic_handler(cmd, session_id, compression = compression) 365 366 # disable compression 367 self.set_gzip_compression(session_id, False) 368 369 return data

370

371 - def ugc_do_downloads(self, session_id, pkgkeys):

372 373 cmd = "%s %s %s" % ( 374 session_id, 375 'ugc:do_downloads', 376 ' '.join(pkgkeys), 377 ) 378 return self.do_generic_handler(cmd, session_id)

379

380 - def ugc_do_download_stats(self, session_id, package_names):

381 382 sub_lists = self.entropyTools.split_indexable_into_chunks( 383 package_names, 100) 384 385 last_srv_rc_data = None 386 for pkgkeys in sub_lists: 387 388 release_string = '--N/A--' 389 rel_file = etpConst['systemreleasefile'] 390 if os.path.isfile(rel_file) and os.access(rel_file,os.R_OK): 391 with open(rel_file,"r") as f: 392 release_string = f.read(512) 393 394 hw_hash = self.SystemSettings['hw_hash'] 395 if not hw_hash: 396 hw_hash = '' 397 398 mydict = { 399 'branch': self.SystemSettings['repositories']['branch'], 400 'release_string': release_string, 401 'hw_hash': hw_hash, 402 'pkgkeys': ' '.join(pkgkeys), 403 } 404 xml_string = self.entropyTools.xml_from_dict(mydict) 405 406 cmd = "%s %s %s" % ( 407 session_id, 408 'ugc:do_download_stats', 409 xml_string, 410 ) 411 last_srv_rc_data = self.do_generic_handler(cmd, session_id) 412 if not isinstance(last_srv_rc_data, tuple): 413 return last_srv_rc_data 414 elif last_srv_rc_data[0] != True: 415 return last_srv_rc_data 416 return last_srv_rc_data

417

418 - def ugc_get_downloads(self, session_id, pkgkey):

419 420 cmd = "%s %s %s" % ( 421 session_id, 422 'ugc:get_downloads', 423 pkgkey, 424 ) 425 return self.do_generic_handler(cmd, session_id)

426

427 - def ugc_get_alldownloads(self, session_id):

428 429 cmd = "%s %s" % ( 430 session_id, 431 'ugc:get_alldownloads', 432 ) 433 434 # enable zlib compression 435 compression = self.set_gzip_compression(session_id, True) 436 437 rc = self.do_generic_handler(cmd, session_id, compression = compression) 438 439 # disable compression 440 self.set_gzip_compression(session_id, False) 441 442 return rc

443

444 - def ugc_do_vote(self, session_id, pkgkey, vote):

445 446 cmd = "%s %s %s %s" % ( 447 session_id, 448 'ugc:do_vote', 449 pkgkey, 450 vote, 451 ) 452 return self.do_generic_handler(cmd, session_id)

453

454 - def ugc_get_vote(self, session_id, pkgkey):

455 456 cmd = "%s %s %s" % ( 457 session_id, 458 'ugc:get_vote', 459 pkgkey, 460 ) 461 return self.do_generic_handler(cmd, session_id)

462

463 - def ugc_get_allvotes(self, session_id):

464 465 cmd = "%s %s" % ( 466 session_id, 467 'ugc:get_allvotes', 468 ) 469 470 # enable zlib compression 471 compression = self.set_gzip_compression(session_id, True) 472 473 rc = self.do_generic_handler(cmd, session_id, compression = compression) 474 475 # disable compression 476 self.set_gzip_compression(session_id, False) 477 478 return rc

479

480 - def ugc_add_comment(self, session_id, pkgkey, comment, title, keywords):

481 482 mydict = { 483 'comment': comment, 484 'title': title, 485 'keywords': keywords, 486 } 487 xml_string = self.entropyTools.xml_from_dict(mydict) 488 489 cmd = "%s %s %s %s" % ( 490 session_id, 491 'ugc:add_comment', 492 pkgkey, 493 xml_string, 494 ) 495 496 return self.do_generic_handler(cmd, session_id)

497

498 - def ugc_edit_comment(self, session_id, iddoc, new_comment, new_title, new_keywords):

499 500 mydict = { 501 'comment': new_comment, 502 'title': new_title, 503 'keywords': new_keywords, 504 } 505 xml_string = self.entropyTools.xml_from_dict(mydict) 506 507 cmd = "%s %s %s %s" % ( 508 session_id, 509 'ugc:edit_comment', 510 iddoc, 511 xml_string, 512 ) 513 return self.do_generic_handler(cmd, session_id)

514

515 - def ugc_remove_comment(self, session_id, iddoc):

516 517 cmd = "%s %s %s" % ( 518 session_id, 519 'ugc:remove_comment', 520 iddoc, 521 ) 522 return self.do_generic_handler(cmd, session_id)

523

524 - def ugc_remove_image(self, session_id, iddoc):

525 526 cmd = "%s %s %s" % ( 527 session_id, 528 'ugc:remove_image', 529 iddoc, 530 ) 531 return self.do_generic_handler(cmd, session_id)

532

533 - def ugc_remove_file(self, session_id, iddoc):

534 535 cmd = "%s %s %s" % ( 536 session_id, 537 'ugc:remove_file', 538 iddoc, 539 ) 540 return self.do_generic_handler(cmd, session_id)

541

542 - def ugc_remove_youtube_video(self, session_id, iddoc):

543 544 cmd = "%s %s %s" % ( 545 session_id, 546 'ugc:remove_youtube_video', 547 iddoc, 548 ) 549 return self.do_generic_handler(cmd, session_id)

550

551 - def ugc_get_docs(self, session_id, pkgkey):

552 553 cmd = "%s %s %s" % ( 554 session_id, 555 'ugc:get_alldocs', 556 pkgkey, 557 ) 558 return self.do_generic_handler(cmd, session_id)

559

560 - def ugc_get_textdocs(self, session_id, pkgkey):

561 562 cmd = "%s %s %s" % ( 563 session_id, 564 'ugc:get_textdocs', 565 pkgkey, 566 ) 567 return self.do_generic_handler(cmd, session_id)

568

569 - def ugc_get_textdocs_by_identifiers(self, session_id, identifiers):

570 571 cmd = "%s %s %s" % ( 572 session_id, 573 'ugc:get_textdocs_by_identifiers', 574 ' '.join([str(x) for x in identifiers]), 575 ) 576 return self.do_generic_handler(cmd, session_id)

577

578 - def ugc_get_documents_by_identifiers(self, session_id, identifiers):

579 580 cmd = "%s %s %s" % ( 581 session_id, 582 'ugc:get_documents_by_identifiers', 583 ' '.join([str(x) for x in identifiers]), 584 ) 585 return self.do_generic_handler(cmd, session_id)

586

587 - def ugc_send_file_stream(self, session_id, file_path):

588 589 if not (os.path.isfile(file_path) and os.access(file_path,os.R_OK)): 590 return False,False,'cannot read file_path' 591 592 import zlib 593 # enable stream 594 cmd = "%s %s %s on" % ( 595 session_id, 596 'session_config', 597 'stream', 598 ) 599 status, msg = self.do_generic_handler(cmd, session_id) 600 if not status: 601 return False,status,msg 602 603 # enable zlib compression 604 compression = self.set_gzip_compression(session_id, True) 605 606 # start streamer 607 stream_status = True 608 stream_msg = 'ok' 609 f = open(file_path,"rb") 610 chunk = f.read(8192) 611 base_path = os.path.basename(file_path) 612 transferred = len(chunk) 613 max_size = self.entropyTools.get_file_size(file_path) 614 while chunk: 615 616 if (not self.Service.quiet) or self.Service.show_progress: 617 self.Output.updateProgress( 618 "%s, %s: %s" % ( 619 blue(_("User Generated Content")), 620 darkgreen(_("sending file")), 621 darkred(base_path), 622 ), 623 importance = 1, 624 type = "info", 625 header = brown(" @@ "), 626 back = True, 627 count = (transferred,max_size,), 628 percent = True 629 ) 630 631 chunk = zlib.compress(chunk, 7) # compression level 1-9 632 cmd = "%s %s %s" % ( 633 session_id, 634 'stream', 635 chunk, 636 ) 637 status, msg = self.do_generic_handler(cmd, session_id, compression = compression) 638 if not status: 639 stream_status = status 640 stream_msg = msg 641 break 642 chunk = f.read(8192) 643 transferred += len(chunk) 644 645 f.close() 646 647 # disable compression 648 self.set_gzip_compression(session_id, False) 649 650 # disable config 651 cmd = "%s %s %s off" % ( 652 session_id, 653 'session_config', 654 'stream', 655 ) 656 status, msg = self.do_generic_handler(cmd, session_id) 657 if not status: 658 return False,status,msg 659 660 return True,stream_status,stream_msg

661

662 - def ugc_send_file(self, session_id, pkgkey, file_path, doc_type, title, description, keywords):

663 664 status, rem_status, err_msg = self.ugc_send_file_stream(session_id, file_path) 665 if not (status and rem_status): 666 return False,err_msg 667 668 mydict = { 669 'doc_type': str(doc_type), 670 'title': title, 671 'description': description, 672 'keywords': keywords, 673 'file_name': os.path.join(pkgkey,os.path.basename(file_path)), 674 'real_filename': os.path.basename(file_path), 675 } 676 xml_string = self.entropyTools.xml_from_dict(mydict) 677 678 cmd = "%s %s %s %s" % ( 679 session_id, 680 'ugc:register_stream', 681 pkgkey, 682 xml_string, 683 ) 684 return self.do_generic_handler(cmd, session_id)

685

686 - def report_error(self, session_id, error_data):

687 688 import zlib 689 xml_string = self.entropyTools.xml_from_dict_extended(error_data) 690 xml_comp_string = zlib.compress(xml_string) 691 692 cmd = "%s %s %s" % ( 693 session_id, 694 'ugc:report_error', 695 xml_comp_string, 696 ) 697 698 return self.do_generic_handler(cmd, session_id)

699

Source Code for Module entropy.client.services.ugc.commands