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_strict_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_strict', 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 ugc_do_downloads(self, session_id, pkgkeys):

382 383 cmd = "%s %s %s" % ( 384 session_id, 385 'ugc:do_downloads', 386 ' '.join(pkgkeys), 387 ) 388 return self.do_generic_handler(cmd, session_id)

389

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

391 392 release_string = '--N/A--' 393 rel_file = etpConst['systemreleasefile'] 394 if os.path.isfile(rel_file) and os.access(rel_file,os.R_OK): 395 with open(rel_file,"r") as f: 396 release_string = f.read(512) 397 398 hw_hash = self.SystemSettings['hw_hash'] 399 if not hw_hash: 400 hw_hash = '' 401 402 mydict = { 403 'branch': self.SystemSettings['repositories']['branch'], 404 'release_string': release_string, 405 'hw_hash': hw_hash, 406 'pkgkeys': ' '.join(pkgkeys), 407 } 408 xml_string = self.entropyTools.xml_from_dict(mydict) 409 410 cmd = "%s %s %s" % ( 411 session_id, 412 'ugc:do_download_stats', 413 xml_string, 414 ) 415 return self.do_generic_handler(cmd, session_id)

416

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

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

425

426 - def ugc_get_alldownloads(self, session_id):

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

442

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

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

452

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

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

461

462 - def ugc_get_allvotes(self, session_id):

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

478

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

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

496

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

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

513

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

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

522

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

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

531

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

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

540

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

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

549

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

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

558

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

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

567

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

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

576

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

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

585

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

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

660

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

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

684

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

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

698

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