entropy.client.services.ugc.commands

1 # -*- coding: utf-8 -*- 2 ''' 3 # DESCRIPTION: 4 # Entropy Object Oriented Interface 5 6 Copyright (C) 2007-2009 Fabio Erculiani 7 8 This program is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 2 of the License, or 11 (at your option) any later version. 12 13 This program is distributed in the hope that it will be useful, 14 but WITHOUT ANY WARRANTY; without even the implied warranty of 15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 16 GNU General Public License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software 20 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA 21 ''' 22 23 from __future__ import with_statement 24 import os 25 from entropy.exceptions import * 26 from entropy.const import etpConst 27 from entropy.output import darkblue, bold, blue, darkgreen, darkred, brown 28 from entropy.i18n import _ 29 from entropy.core import SystemSettings 30

31 -class Base:

32

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

34 35 if not hasattr(OutputInterface,'updateProgress'): 36 mytxt = _("OutputInterface does not have an updateProgress method") 37 raise IncorrectParameter("IncorrectParameter: %s, (! %s !)" % (OutputInterface,mytxt,)) 38 elif not callable(OutputInterface.updateProgress): 39 mytxt = _("OutputInterface does not have an updateProgress method") 40 raise IncorrectParameter("IncorrectParameter: %s, (! %s !)" % (OutputInterface,mytxt,)) 41 42 from entropy.services.ugc.interfaces import Client as Cl 43 if not isinstance(Service, (Cl,)): 44 mytxt = _("A valid entropy.services.ugc.interfaces.Client based instance is needed") 45 raise IncorrectParameter("IncorrectParameter: %s, (! %s !)" % (Service,mytxt,)) 46 47 import socket, zlib, struct 48 import entropy.tools as entropyTools 49 import entropy.dump as dumpTools 50 self.entropyTools, self.socket, self.zlib, self.struct, self.dumpTools = entropyTools, socket, zlib, struct, dumpTools 51 self.Output = OutputInterface 52 self.Service = Service 53 self.output_header = '' 54 self.SystemSettings = SystemSettings()

55

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

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

129

130 - def get_result(self, session):

131 # get the information 132 cmd = "%s rc" % (session,) 133 self.Service.transmit(cmd) 134 try: 135 data = self.Service.receive() 136 return data 137 except: 138 self.entropyTools.print_traceback() 139 return None

140

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

142 143 # unstream object 144 error = False 145 try: 146 data = self.Service.stream_to_object(data, gzipped) 147 except (EOFError,IOError,self.zlib.error,self.dumpTools.pickle.UnpicklingError,): 148 mytxt = _("cannot convert stream into object") 149 self.Output.updateProgress( 150 "[%s:%s|%s:%s|%s:%s] %s" % ( 151 darkblue(_("repo")), 152 bold(unicode(repository)), 153 darkred(_("arch")), 154 bold(unicode(arch)), 155 darkgreen(_("product")), 156 bold(unicode(product)), 157 blue(mytxt), 158 ), 159 importance = 1, 160 type = "error", 161 header = self.output_header 162 ) 163 data = None 164 error = True 165 return data, error

166

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

168 169 tries = 3 170 lasterr = None 171 while 1: 172 173 if tries <= 0: 174 return lasterr 175 tries -= 1 176 177 try: 178 # send command 179 self.Service.transmit(cmd) 180 except (SSLError,): 181 return None 182 # receive answer 183 data = self.Service.receive() 184 185 skip = self.handle_standard_answer(data, repository, arch, product) 186 if skip: 187 continue 188 189 data = self.get_result(session_id) 190 if data == None: 191 lasterr = None 192 continue 193 elif not data: 194 lasterr = False 195 continue 196 197 objdata, error = self.convert_stream_to_object(data, compression, repository, arch, product) 198 if not error: 199 return objdata

200

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

202 203 self.Service.check_socket_connection() 204 205 while 1: 206 try: 207 result = self.retrieve_command_answer(cmd, session_id, compression = compression) 208 if result == None: 209 return False,'command not supported' # untranslated on purpose 210 return result 211 except (self.socket.error,self.struct.error,): 212 self.Service.reconnect_socket() 213 tries -= 1 214 if tries < 1: 215 raise

216

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

218 self.Service.check_socket_connection() 219 cmd = "%s %s %s %s zlib" % (session, 'session_config', 'compression', do,) 220 self.Service.transmit(cmd) 221 data = self.Service.receive() 222 if data == self.Service.answers['ok']: 223 return True 224 return False

225

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

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

235

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

237 238 cmd = "%s %s %s" % ( 239 session_id, 240 'logout', 241 username, 242 ) 243 return self.do_generic_handler(cmd, session_id)

244

245 - def get_logged_user_data(self, session_id):

246 247 cmd = "%s %s" % ( 248 session_id, 249 'user_data', 250 ) 251 return self.do_generic_handler(cmd, session_id)

252

253 - def is_user(self, session_id):

254 255 cmd = "%s %s" % ( 256 session_id, 257 'is_user', 258 ) 259 return self.do_generic_handler(cmd, session_id)

260

261 - def is_developer(self, session_id):

262 263 cmd = "%s %s" % ( 264 session_id, 265 'is_developer', 266 ) 267 return self.do_generic_handler(cmd, session_id)

268

269 - def is_moderator(self, session_id):

270 271 cmd = "%s %s" % ( 272 session_id, 273 'is_moderator', 274 ) 275 return self.do_generic_handler(cmd, session_id)

276

277 - def is_administrator(self, session_id):

278 279 cmd = "%s %s" % ( 280 session_id, 281 'is_administrator', 282 ) 283 return self.do_generic_handler(cmd, session_id)

284

285 - def available_commands(self, session_id):

286 287 cmd = "%s %s" % ( 288 session_id, 289 'available_commands', 290 ) 291 return self.do_generic_handler(cmd, session_id)

292 293

294 -class Client(Base):

295

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

297 Base.__init__(self, EntropyInterface, ServiceInterface)

298

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

300 301 myidlist = ' '.join([str(x) for x in idpackages]) 302 cmd = "%s %s %s %s %s %s %s" % ( 303 session_id, 304 'repository_server:dbdiff', 305 repository, 306 arch, 307 product, 308 self.SystemSettings['repositories']['branch'], 309 myidlist, 310 ) 311 312 # enable zlib compression 313 compression = self.set_gzip_compression(session_id, True) 314 315 data = self.do_generic_handler(cmd, session_id, tries = 5, compression = compression) 316 317 # disable compression 318 self.set_gzip_compression(session_id, False) 319 320 return data

321

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

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

333

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

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

345

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

347 348 cmd = "%s %s %s %s %s %s" % ( 349 session_id, 350 'repository_server:get_repository_metadata', 351 repository, 352 arch, 353 product, 354 self.SystemSettings['repositories']['branch'], 355 ) 356 return self.do_generic_handler(cmd, session_id, tries = 5)

357

358 - def get_package_information(self, session_id, idpackages, repository, arch, product):

359 360 cmd = "%s %s %s %s %s %s %s %s" % ( 361 session_id, 362 'repository_server:pkginfo', 363 True, 364 repository, 365 arch, 366 product, 367 self.SystemSettings['repositories']['branch'], 368 ' '.join([str(x) for x in idpackages]), 369 ) 370 371 # enable zlib compression 372 compression = self.set_gzip_compression(session_id, True) 373 374 data = self.do_generic_handler(cmd, session_id, compression = compression) 375 376 # disable compression 377 self.set_gzip_compression(session_id, False) 378 379 return data

380

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

382 383 cmd = "%s %s %s %s %s %s %s %s" % ( 384 session_id, 385 'repository_server:pkginfo_strict', 386 True, 387 repository, 388 arch, 389 product, 390 self.SystemSettings['repositories']['branch'], 391 ' '.join([str(x) for x in idpackages]), 392 ) 393 394 # enable zlib compression 395 compression = self.set_gzip_compression(session_id, True) 396 397 data = self.do_generic_handler(cmd, session_id, compression = compression) 398 399 # disable compression 400 self.set_gzip_compression(session_id, False) 401 402 return data

403

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

405 406 cmd = "%s %s %s" % ( 407 session_id, 408 'ugc:do_downloads', 409 ' '.join(pkgkeys), 410 ) 411 return self.do_generic_handler(cmd, session_id)

412

413 - def ugc_do_download_stats(self, session_id, pkgkeys):

414 415 release_string = '--N/A--' 416 rel_file = etpConst['systemreleasefile'] 417 if os.path.isfile(rel_file) and os.access(rel_file,os.R_OK): 418 with open(rel_file,"r") as f: 419 release_string = f.read(512) 420 421 hw_hash = self.SystemSettings['hw_hash'] 422 if not hw_hash: 423 hw_hash = '' 424 425 mydict = { 426 'branch': self.SystemSettings['repositories']['branch'], 427 'release_string': release_string, 428 'hw_hash': hw_hash, 429 'pkgkeys': ' '.join(pkgkeys), 430 } 431 xml_string = self.entropyTools.xml_from_dict(mydict) 432 433 cmd = "%s %s %s" % ( 434 session_id, 435 'ugc:do_download_stats', 436 xml_string, 437 ) 438 return self.do_generic_handler(cmd, session_id)

439

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

441 442 cmd = "%s %s %s" % ( 443 session_id, 444 'ugc:get_downloads', 445 pkgkey, 446 ) 447 return self.do_generic_handler(cmd, session_id)

448

449 - def ugc_get_alldownloads(self, session_id):

450 451 cmd = "%s %s" % ( 452 session_id, 453 'ugc:get_alldownloads', 454 ) 455 456 # enable zlib compression 457 compression = self.set_gzip_compression(session_id, True) 458 459 rc = self.do_generic_handler(cmd, session_id, compression = compression) 460 461 # disable compression 462 self.set_gzip_compression(session_id, False) 463 464 return rc

465

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

467 468 cmd = "%s %s %s %s" % ( 469 session_id, 470 'ugc:do_vote', 471 pkgkey, 472 vote, 473 ) 474 return self.do_generic_handler(cmd, session_id)

475

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

477 478 cmd = "%s %s %s" % ( 479 session_id, 480 'ugc:get_vote', 481 pkgkey, 482 ) 483 return self.do_generic_handler(cmd, session_id)

484

485 - def ugc_get_allvotes(self, session_id):

486 487 cmd = "%s %s" % ( 488 session_id, 489 'ugc:get_allvotes', 490 ) 491 492 # enable zlib compression 493 compression = self.set_gzip_compression(session_id, True) 494 495 rc = self.do_generic_handler(cmd, session_id, compression = compression) 496 497 # disable compression 498 self.set_gzip_compression(session_id, False) 499 500 return rc

501

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

503 504 mydict = { 505 'comment': comment, 506 'title': title, 507 'keywords': keywords, 508 } 509 xml_string = self.entropyTools.xml_from_dict(mydict) 510 511 cmd = "%s %s %s %s" % ( 512 session_id, 513 'ugc:add_comment', 514 pkgkey, 515 xml_string, 516 ) 517 518 return self.do_generic_handler(cmd, session_id)

519

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

521 522 mydict = { 523 'comment': new_comment, 524 'title': new_title, 525 'keywords': new_keywords, 526 } 527 xml_string = self.entropyTools.xml_from_dict(mydict) 528 529 cmd = "%s %s %s %s" % ( 530 session_id, 531 'ugc:edit_comment', 532 iddoc, 533 xml_string, 534 ) 535 return self.do_generic_handler(cmd, session_id)

536

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

538 539 cmd = "%s %s %s" % ( 540 session_id, 541 'ugc:remove_comment', 542 iddoc, 543 ) 544 return self.do_generic_handler(cmd, session_id)

545

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

547 548 cmd = "%s %s %s" % ( 549 session_id, 550 'ugc:remove_image', 551 iddoc, 552 ) 553 return self.do_generic_handler(cmd, session_id)

554

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

556 557 cmd = "%s %s %s" % ( 558 session_id, 559 'ugc:remove_file', 560 iddoc, 561 ) 562 return self.do_generic_handler(cmd, session_id)

563

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

565 566 cmd = "%s %s %s" % ( 567 session_id, 568 'ugc:remove_youtube_video', 569 iddoc, 570 ) 571 return self.do_generic_handler(cmd, session_id)

572

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

574 575 cmd = "%s %s %s" % ( 576 session_id, 577 'ugc:get_alldocs', 578 pkgkey, 579 ) 580 return self.do_generic_handler(cmd, session_id)

581

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

583 584 cmd = "%s %s %s" % ( 585 session_id, 586 'ugc:get_textdocs', 587 pkgkey, 588 ) 589 return self.do_generic_handler(cmd, session_id)

590

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

592 593 cmd = "%s %s %s" % ( 594 session_id, 595 'ugc:get_textdocs_by_identifiers', 596 ' '.join([str(x) for x in identifiers]), 597 ) 598 return self.do_generic_handler(cmd, session_id)

599

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

601 602 cmd = "%s %s %s" % ( 603 session_id, 604 'ugc:get_documents_by_identifiers', 605 ' '.join([str(x) for x in identifiers]), 606 ) 607 return self.do_generic_handler(cmd, session_id)

608

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

610 611 if not (os.path.isfile(file_path) and os.access(file_path,os.R_OK)): 612 return False,False,'cannot read file_path' 613 614 import zlib 615 # enable stream 616 cmd = "%s %s %s on" % ( 617 session_id, 618 'session_config', 619 'stream', 620 ) 621 status, msg = self.do_generic_handler(cmd, session_id) 622 if not status: 623 return False,status,msg 624 625 # enable zlib compression 626 compression = self.set_gzip_compression(session_id, True) 627 628 # start streamer 629 stream_status = True 630 stream_msg = 'ok' 631 f = open(file_path,"rb") 632 chunk = f.read(8192) 633 base_path = os.path.basename(file_path) 634 transferred = len(chunk) 635 max_size = self.entropyTools.get_file_size(file_path) 636 while chunk: 637 638 if (not self.Service.quiet) or self.Service.show_progress: 639 self.Output.updateProgress( 640 "%s, %s: %s" % ( 641 blue(_("User Generated Content")), 642 darkgreen(_("sending file")), 643 darkred(base_path), 644 ), 645 importance = 1, 646 type = "info", 647 header = brown(" @@ "), 648 back = True, 649 count = (transferred,max_size,), 650 percent = True 651 ) 652 653 chunk = zlib.compress(chunk, 7) # compression level 1-9 654 cmd = "%s %s %s" % ( 655 session_id, 656 'stream', 657 chunk, 658 ) 659 status, msg = self.do_generic_handler(cmd, session_id, compression = compression) 660 if not status: 661 stream_status = status 662 stream_msg = msg 663 break 664 chunk = f.read(8192) 665 transferred += len(chunk) 666 667 f.close() 668 669 # disable compression 670 self.set_gzip_compression(session_id, False) 671 672 # disable config 673 cmd = "%s %s %s off" % ( 674 session_id, 675 'session_config', 676 'stream', 677 ) 678 status, msg = self.do_generic_handler(cmd, session_id) 679 if not status: 680 return False,status,msg 681 682 return True,stream_status,stream_msg

683

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

685 686 status, rem_status, err_msg = self.ugc_send_file_stream(session_id, file_path) 687 if not (status and rem_status): 688 return False,err_msg 689 690 mydict = { 691 'doc_type': str(doc_type), 692 'title': title, 693 'description': description, 694 'keywords': keywords, 695 'file_name': os.path.join(pkgkey,os.path.basename(file_path)), 696 'real_filename': os.path.basename(file_path), 697 } 698 xml_string = self.entropyTools.xml_from_dict(mydict) 699 700 cmd = "%s %s %s %s" % ( 701 session_id, 702 'ugc:register_stream', 703 pkgkey, 704 xml_string, 705 ) 706 return self.do_generic_handler(cmd, session_id)

707

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

709 710 import zlib 711 xml_string = self.entropyTools.xml_from_dict_extended(error_data) 712 xml_comp_string = zlib.compress(xml_string) 713 714 cmd = "%s %s %s" % ( 715 session_id, 716 'ugc:report_error', 717 xml_comp_string, 718 ) 719 720 return self.do_generic_handler(cmd, session_id)

721

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