instrumentation/next-share/BaseLib/Core/APIImplementation/SessionRuntimeConfig.py

   1 # Written by Arno Bakker
   2 # see LICENSE.txt for license information
   3
   4 from __future__ import with_statement
   5 import sys
   6 from traceback import print_exc
   7
   8 from BaseLib.Core.exceptions import *
   9 from BaseLib.Core.SessionConfig import SessionConfigInterface
  10 from BaseLib.Core.Subtitles.SubtitlesHandler import SubtitlesHandler
  11
  12 # 10/02/10 Boudewijn: pylint points out that member variables used in
  13 # SessionRuntimeConfig do not exist.  This is because they are set in
  14 # BaseLib.Core.Session which is a subclass of SessionRuntimeConfig.
  15 #
  16 # We disable this error
  17 # pylint: disable-msg=E1101
  18
  19 class SessionRuntimeConfig(SessionConfigInterface):
  20     """
  21     Implements the BaseLib.Core.API.SessionConfigInterface
  22
  23     Use these to change the session config at runtime.
  24     """
  25     def set_state_dir(self,statedir):
  26         raise OperationNotPossibleAtRuntimeException()
  27
  28     def get_state_dir(self):
  29         self.sesslock.acquire()
  30         try:
  31             return SessionConfigInterface.get_state_dir(self)
  32         finally:
  33             self.sesslock.release()
  34
  35     def set_install_dir(self,statedir):
  36         raise OperationNotPossibleAtRuntimeException()
  37
  38     def get_install_dir(self):
  39         self.sesslock.acquire()
  40         try:
  41             return SessionConfigInterface.get_install_dir(self)
  42         finally:
  43             self.sesslock.release()
  44
  45     def set_permid_keypair_filename(self,keypair):
  46         raise OperationNotPossibleAtRuntimeException()
  47
  48     def get_permid_keypair_filename(self):
  49         self.sesslock.acquire()
  50         try:
  51             return SessionConfigInterface.get_permid_keypair_filename(self)
  52         finally:
  53             self.sesslock.release()
  54
  55     def set_listen_port(self,port):
  56         raise OperationNotPossibleAtRuntimeException()
  57
  58     def get_listen_port(self):
  59         # To protect self.sessconfig
  60         self.sesslock.acquire()
  61         try:
  62             return SessionConfigInterface.get_listen_port(self)
  63         finally:
  64             self.sesslock.release()
  65
  66     def get_video_analyser_path(self):
  67         # To protect self.sessconfig
  68         self.sesslock.acquire()
  69         try:
  70             return SessionConfigInterface.get_video_analyser_path(self)
  71         finally:
  72             self.sesslock.release()
  73
  74     def set_tracker_ip(self,value):
  75         raise OperationNotPossibleAtRuntimeException()
  76
  77     def get_tracker_ip(self):
  78         self.sesslock.acquire()
  79         try:
  80             return SessionConfigInterface.get_tracker_ip(self)
  81         finally:
  82             self.sesslock.release()
  83
  84     def set_bind_to_addresses(self,value):
  85         raise OperationNotPossibleAtRuntimeException()
  86
  87     def get_bind_to_addresses(self):
  88         self.sesslock.acquire()
  89         try:
  90             return SessionConfigInterface.get_bind_to_addresses(self)
  91         finally:
  92             self.sesslock.release()
  93
  94     def set_upnp_mode(self,value):
  95         raise OperationNotPossibleAtRuntimeException()
  96
  97     def get_upnp_mode(self):
  98         self.sesslock.acquire()
  99         try:
 100             return SessionConfigInterface.get_upnp_mode(self)
 101         finally:
 102             self.sesslock.release()
 103
 104     def set_autoclose_timeout(self,value):
 105         raise OperationNotPossibleAtRuntimeException()
 106
 107     def get_autoclose_timeout(self):
 108         self.sesslock.acquire()
 109         try:
 110             return SessionConfigInterface.get_autoclose_timeout(self)
 111         finally:
 112             self.sesslock.release()
 113
 114     def set_autoclose_check_interval(self,value):
 115         raise OperationNotPossibleAtRuntimeException()
 116
 117     def get_autoclose_check_interval(self):
 118         self.sesslock.acquire()
 119         try:
 120             return SessionConfigInterface.get_autoclose_check_interval(self)
 121         finally:
 122             self.sesslock.release()
 123
 124     def set_megacache(self,value):
 125         raise OperationNotPossibleAtRuntimeException()
 126
 127     def get_megacache(self):
 128         self.sesslock.acquire()
 129         try:
 130             return SessionConfigInterface.get_megacache(self)
 131         finally:
 132             self.sesslock.release()
 133
 134     def set_overlay(self,value):
 135         raise OperationNotPossibleAtRuntimeException()
 136
 137     def get_overlay(self):
 138         self.sesslock.acquire()
 139         try:
 140             return SessionConfigInterface.get_overlay(self)
 141         finally:
 142             self.sesslock.release()
 143
 144     def set_buddycast(self,value):
 145         raise OperationNotPossibleAtRuntimeException()
 146
 147     def get_buddycast(self):
 148         self.sesslock.acquire()
 149         try:
 150             return SessionConfigInterface.get_buddycast(self)
 151         finally:
 152             self.sesslock.release()
 153
 154     def set_start_recommender(self,value):
 155         self.sesslock.acquire()
 156         try:
 157             from BaseLib.Core.Overlay.OverlayThreadingBridge import OverlayThreadingBridge
 158
 159             SessionConfigInterface.set_start_recommender(self,value)
 160             olbridge = OverlayThreadingBridge.getInstance()
 161             task = lambda:self.olthread_set_start_recommender(value)
 162             olbridge.add_task(task,0)
 163         finally:
 164             self.sesslock.release()
 165
 166     def olthread_set_start_recommender(self,value):
 167         from BaseLib.Core.BuddyCast.buddycast import BuddyCastFactory
 168         bcfac = BuddyCastFactory.getInstance()
 169         if value:
 170             bcfac.restartBuddyCast()
 171         else:
 172             bcfac.pauseBuddyCast()
 173
 174     def get_start_recommender(self):
 175         self.sesslock.acquire()
 176         try:
 177             return SessionConfigInterface.get_start_recommender(self)
 178         finally:
 179             self.sesslock.release()
 180
 181     #
 182     # ProxyService_
 183     #
 184     def set_download_help(self,value):
 185         raise OperationNotPossibleAtRuntimeException()
 186
 187     def get_download_help(self):
 188         self.sesslock.acquire()
 189         try:
 190             return SessionConfigInterface.get_download_help(self)
 191         finally:
 192             self.sesslock.release()
 193
 194     def set_proxyservice_status(self,value):
 195         """ Set the status of the proxyservice (on or off).
 196
 197         ProxyService off means the current node could not be used as a proxy. ProxyService on means other nodes will be able to use it as a proxy.
 198
 199         @param value: one of the possible two values: PROXYSERVICE_OFF, PROXYSERVICE_ON
 200         """
 201         self.sesslock.acquire()
 202         try:
 203             SessionConfigInterface.set_proxyservice_status(self, value)
 204         finally:
 205             self.sesslock.release()
 206
 207     def get_proxyservice_status(self):
 208         """ Returns the status of the proxyservice (on or off).
 209         @return: one of the possible two values: PROXYSERVICE_OFF, PROXYSERVICE_ON
 210         """
 211         self.sesslock.acquire()
 212         try:
 213             return SessionConfigInterface.get_proxyservice_status(self)
 214         finally:
 215             self.sesslock.release()
 216     #
 217     # _ProxyService
 218     #
 219
 220
 221
 222     def set_torrent_collecting(self,value):
 223         raise OperationNotPossibleAtRuntimeException()
 224
 225     def get_torrent_collecting(self):
 226         self.sesslock.acquire()
 227         try:
 228             return SessionConfigInterface.get_torrent_collecting(self)
 229         finally:
 230             self.sesslock.release()
 231
 232
 233     def set_torrent_collecting_dir(self,value):
 234         raise OperationNotPossibleAtRuntimeException()
 235
 236     def get_torrent_collecting_dir(self):
 237         self.sesslock.acquire()
 238         try:
 239             return SessionConfigInterface.get_torrent_collecting_dir(self)
 240         finally:
 241             self.sesslock.release()
 242
 243     def get_subtitles_collecting_dir(self):
 244         with self.sesslock:
 245             return SessionConfigInterface.get_subtitles_collecting_dir(self)
 246
 247     def set_subtitles_upload_rate(self, value):
 248         with self.sesslock:
 249             SubtitlesHandler.getInstance().setUploadRate(value)
 250             SessionConfigInterface.set_subtitles_uploade_rate(self, value)
 251
 252     def get_subtitles_upload_rate(self):
 253         with self.sesslock:
 254             return SessionConfigInterface.get_subtitles_upload_rate(self)
 255
 256
 257
 258     def set_superpeer(self,value):
 259         raise OperationNotPossibleAtRuntimeException()
 260
 261     def get_superpeer(self):
 262         self.sesslock.acquire()
 263         try:
 264             return SessionConfigInterface.get_superpeer(self)
 265         finally:
 266             self.sesslock.release()
 267
 268     def set_overlay_log(self,value):
 269         raise OperationNotPossibleAtRuntimeException()
 270
 271     def get_overlay_log(self):
 272         self.sesslock.acquire()
 273         try:
 274             return SessionConfigInterface.get_overlay_log(self)
 275         finally:
 276             self.sesslock.release()
 277
 278     def set_buddycast_interval(self,value):
 279         raise OperationNotPossibleAtRuntimeException()
 280
 281     def get_buddycast_interval(self):
 282         self.sesslock.acquire()
 283         try:
 284             return SessionConfigInterface.get_buddycast_interval(self)
 285         finally:
 286             self.sesslock.release()
 287
 288     def set_torrent_collecting_max_torrents(self,value):
 289         self.sesslock.acquire()
 290         try:
 291             from BaseLib.Core.Overlay.OverlayThreadingBridge import OverlayThreadingBridge
 292
 293             SessionConfigInterface.set_torrent_collecting_max_torrents(self,value)
 294             olbridge = OverlayThreadingBridge.getInstance()
 295             task = lambda:self.olthread_set_torrent_collecting_max_torrents(value)
 296             olbridge.add_task(task,0)
 297         finally:
 298             self.sesslock.release()
 299
 300     def olthread_set_torrent_collecting_max_torrents(self,value):
 301         from BaseLib.Core.Overlay.MetadataHandler import MetadataHandler
 302         mh = MetadataHandler.getInstance()
 303         mh.set_overflow(value)
 304         mh.delayed_check_overflow(2)
 305
 306
 307     def get_torrent_collecting_max_torrents(self):
 308         self.sesslock.acquire()
 309         try:
 310             return SessionConfigInterface.get_torrent_collecting_max_torrents(self)
 311         finally:
 312             self.sesslock.release()
 313
 314     def set_buddycast_max_peers(self,value):
 315         raise OperationNotPossibleAtRuntimeException()
 316
 317     def get_buddycast_max_peers(self):
 318         self.sesslock.acquire()
 319         try:
 320             return SessionConfigInterface.get_buddycast_max_peers(self)
 321         finally:
 322             self.sesslock.release()
 323
 324     def set_torrent_collecting_rate(self,value):
 325         self.sesslock.acquire()
 326         try:
 327             from BaseLib.Core.Overlay.OverlayThreadingBridge import OverlayThreadingBridge
 328
 329             SessionConfigInterface.set_torrent_collecting_rate(self,value)
 330             olbridge = OverlayThreadingBridge.getInstance()
 331             task = lambda:self.olthread_set_torrent_collecting_rate(value)
 332             olbridge.add_task(task,0)
 333         finally:
 334             self.sesslock.release()
 335
 336     def olthread_set_torrent_collecting_rate(self,value):
 337         from BaseLib.Core.Overlay.MetadataHandler import MetadataHandler
 338         mh = MetadataHandler.getInstance()
 339         mh.set_rate(value)
 340
 341     def get_torrent_collecting_rate(self):
 342         self.sesslock.acquire()
 343         try:
 344             return SessionConfigInterface.get_torrent_collecting_rate(self)
 345         finally:
 346             self.sesslock.release()
 347
 348     def set_torrent_checking(self,value):
 349         raise OperationNotPossibleAtRuntimeException()
 350
 351     def get_torrent_checking(self):
 352         self.sesslock.acquire()
 353         try:
 354             return SessionConfigInterface.get_torrent_checking(self)
 355         finally:
 356             self.sesslock.release()
 357
 358     def set_torrent_checking_period(self,value):
 359         raise OperationNotPossibleAtRuntimeException()
 360
 361     def get_torrent_checking_period(self):
 362         self.sesslock.acquire()
 363         try:
 364             return SessionConfigInterface.get_torrent_checking_period(self)
 365         finally:
 366             self.sesslock.release()
 367
 368     def set_dialback(self,value):
 369         raise OperationNotPossibleAtRuntimeException()
 370
 371     def get_dialback(self):
 372         self.sesslock.acquire()
 373         try:
 374             return SessionConfigInterface.get_dialback(self)
 375         finally:
 376             self.sesslock.release()
 377
 378     def set_social_networking(self,value):
 379         raise OperationNotPossibleAtRuntimeException()
 380
 381     def get_social_networking(self):
 382         self.sesslock.acquire()
 383         try:
 384             return SessionConfigInterface.get_social_networking(self)
 385         finally:
 386             self.sesslock.release()
 387
 388     def set_remote_query(self,value):
 389         raise OperationNotPossibleAtRuntimeException()
 390
 391     def get_remote_query(self):
 392         self.sesslock.acquire()
 393         try:
 394             return SessionConfigInterface.get_remote_query(self)
 395         finally:
 396             self.sesslock.release()
 397
 398     def set_stop_collecting_threshold(self,value):
 399         self.sesslock.acquire()
 400         try:
 401             from BaseLib.Core.Overlay.OverlayThreadingBridge import OverlayThreadingBridge
 402
 403             SessionConfigInterface.set_stop_collecting_threshold(self,value)
 404             olbridge = OverlayThreadingBridge.getInstance()
 405             task = lambda:self.olthread_set_stop_collecting_threshold(value)
 406             olbridge.add_task(task,0)
 407         finally:
 408             self.sesslock.release()
 409
 410     def olthread_set_stop_collecting_threshold(self,value):
 411         from BaseLib.Core.Overlay.MetadataHandler import MetadataHandler
 412         mh = MetadataHandler.getInstance()
 413         mh.set_min_free_space(value)
 414         mh.delayed_check_free_space(2)
 415
 416     def get_stop_collecting_threshold(self):
 417         self.sesslock.acquire()
 418         try:
 419             return SessionConfigInterface.get_stop_collecting_threshold(self)
 420         finally:
 421             self.sesslock.release()
 422
 423     def set_internal_tracker(self,value):
 424         raise OperationNotPossibleAtRuntimeException()
 425
 426     def get_internal_tracker(self):
 427         self.sesslock.acquire()
 428         try:
 429             return SessionConfigInterface.get_internal_tracker(self)
 430         finally:
 431             self.sesslock.release()
 432
 433     def set_internal_tracker_url(self,value):
 434         raise OperationNotPossibleAtRuntimeException()
 435
 436     #def get_internal_tracker_url(self):
 437         """ Implemented in Session.py """
 438
 439     def set_mainline_dht(self,value):
 440         raise OperationNotPossibleAtRuntimeException()
 441
 442     def get_mainline_dht(self):
 443         self.sesslock.acquire()
 444         try:
 445             return SessionConfigInterface.get_mainline_dht(self)
 446         finally:
 447             self.sesslock.release()
 448
 449     def set_nickname(self,value):
 450         self.sesslock.acquire()
 451         try:
 452             return SessionConfigInterface.set_nickname(self, value)
 453         finally:
 454             self.sesslock.release()
 455
 456     def get_nickname(self):
 457         self.sesslock.acquire()
 458         try:
 459             return SessionConfigInterface.get_nickname(self)
 460         finally:
 461             self.sesslock.release()
 462
 463     def set_mugshot(self,value, mime='image/jpeg'):
 464         self.sesslock.acquire()
 465         try:
 466             return SessionConfigInterface.set_mugshot(self, value, mime)
 467         finally:
 468             self.sesslock.release()
 469
 470     def get_mugshot(self):
 471         self.sesslock.acquire()
 472         try:
 473             return SessionConfigInterface.get_mugshot(self)
 474         finally:
 475             self.sesslock.release()
 476
 477
 478     def set_tracker_dfile(self,value):
 479         raise OperationNotPossibleAtRuntimeException()
 480
 481     def get_tracker_dfile(self):
 482         self.sesslock.acquire()
 483         try:
 484             return SessionConfigInterface.get_tracker_dfile(self)
 485         finally:
 486             self.sesslock.release()
 487
 488     def set_tracker_dfile_format(self,value):
 489         raise OperationNotPossibleAtRuntimeException()
 490
 491     def get_tracker_dfile_format(self):
 492         self.sesslock.acquire()
 493         try:
 494             return SessionConfigInterface.get_tracker_dfile_format(self)
 495         finally:
 496             self.sesslock.release()
 497
 498     def set_tracker_socket_timeout(self,value):
 499         raise OperationNotPossibleAtRuntimeException()
 500
 501     def get_tracker_socket_timeout(self):
 502         self.sesslock.acquire()
 503         try:
 504             return SessionConfigInterface.get_tracker_socket_timeout(self)
 505         finally:
 506             self.sesslock.release()
 507
 508     def set_tracker_save_dfile_interval(self,value):
 509         raise OperationNotPossibleAtRuntimeException()
 510
 511     def get_tracker_save_dfile_interval(self):
 512         self.sesslock.acquire()
 513         try:
 514             return SessionConfigInterface.get_tracker_save_dfile_interval(self)
 515         finally:
 516             self.sesslock.release()
 517
 518     def set_tracker_timeout_downloaders_interval(self,value):
 519         raise OperationNotPossibleAtRuntimeException()
 520
 521     def get_tracker_timeout_downloaders_interval(self):
 522         self.sesslock.acquire()
 523         try:
 524             return SessionConfigInterface.get_tracker_timeout_downloaders_interval(self)
 525         finally:
 526             self.sesslock.release()
 527
 528     def set_tracker_reannounce_interval(self,value):
 529         raise OperationNotPossibleAtRuntimeException()
 530
 531     def get_tracker_reannounce_interval(self):
 532         self.sesslock.acquire()
 533         try:
 534             return SessionConfigInterface.get_tracker_reannounce_interval(self)
 535         finally:
 536             self.sesslock.release()
 537
 538     def set_tracker_response_size(self,value):
 539         raise OperationNotPossibleAtRuntimeException()
 540
 541     def get_tracker_response_size(self):
 542         self.sesslock.acquire()
 543         try:
 544             return SessionConfigInterface.get_tracker_response_size(self)
 545         finally:
 546             self.sesslock.release()
 547
 548     def set_tracker_timeout_check_interval(self,value):
 549         raise OperationNotPossibleAtRuntimeException()
 550
 551     def get_tracker_timeout_check_interval(self):
 552         self.sesslock.acquire()
 553         try:
 554             return SessionConfigInterface.get_tracker_timeout_check_interval(self)
 555         finally:
 556             self.sesslock.release()
 557
 558     def set_tracker_nat_check(self,value):
 559         raise OperationNotPossibleAtRuntimeException()
 560
 561     def get_tracker_nat_check(self):
 562         self.sesslock.acquire()
 563         try:
 564             return SessionConfigInterface.get_tracker_nat_check(self)
 565         finally:
 566             self.sesslock.release()
 567
 568     def set_tracker_log_nat_checks(self,value):
 569         raise OperationNotPossibleAtRuntimeException()
 570
 571     def get_tracker_log_nat_checks(self):
 572         self.sesslock.acquire()
 573         try:
 574             return SessionConfigInterface.get_tracker_log_nat_checks(self)
 575         finally:
 576             self.sesslock.release()
 577
 578     def set_tracker_min_time_between_log_flushes(self,value):
 579         raise OperationNotPossibleAtRuntimeException()
 580
 581     def get_tracker_min_time_between_log_flushes(self):
 582         self.sesslock.acquire()
 583         try:
 584             return SessionConfigInterface.get_tracker_min_time_between_log_flushes(self)
 585         finally:
 586             self.sesslock.release()
 587
 588     def set_tracker_min_time_between_cache_refreshes(self,value):
 589         raise OperationNotPossibleAtRuntimeException()
 590
 591     def get_tracker_min_time_between_cache_refreshes(self):
 592         self.sesslock.acquire()
 593         try:
 594             return SessionConfigInterface.get_tracker_min_time_between_cache_refreshes(self)
 595         finally:
 596             self.sesslock.release()
 597
 598     def set_tracker_allowed_dir(self,value):
 599         raise OperationNotPossibleAtRuntimeException()
 600
 601     def get_tracker_allowed_dir(self):
 602         self.sesslock.acquire()
 603         try:
 604             return SessionConfigInterface.get_tracker_allowed_dir(self)
 605         finally:
 606             self.sesslock.release()
 607
 608     def set_tracker_allowed_list(self,value):
 609         raise OperationNotPossibleAtRuntimeException()
 610
 611     def get_tracker_allowed_list(self):
 612         self.sesslock.acquire()
 613         try:
 614             return SessionConfigInterface.get_tracker_allowed_list(self)
 615         finally:
 616             self.sesslock.release()
 617
 618     def set_tracker_allowed_controls(self,value):
 619         raise OperationNotPossibleAtRuntimeException()
 620
 621     def get_tracker_allowed_controls(self):
 622         self.sesslock.acquire()
 623         try:
 624             return SessionConfigInterface.get_tracker_allowed_controls(self)
 625         finally:
 626             self.sesslock.release()
 627
 628     def set_tracker_multitracker_enabled(self,value):
 629         raise OperationNotPossibleAtRuntimeException()
 630
 631     def get_tracker_multitracker_enabled(self):
 632         self.sesslock.acquire()
 633         try:
 634             return SessionConfigInterface.get_tracker_multitracker_enabled(self)
 635         finally:
 636             self.sesslock.release()
 637
 638     def set_tracker_multitracker_allowed(self,value):
 639         raise OperationNotPossibleAtRuntimeException()
 640
 641     def get_tracker_multitracker_allowed(self):
 642         self.sesslock.acquire()
 643         try:
 644             return SessionConfigInterface.get_tracker_multitracker_allowed(self)
 645         finally:
 646             self.sesslock.release()
 647
 648     def set_tracker_multitracker_reannounce_interval(self,value):
 649         raise OperationNotPossibleAtRuntimeException()
 650
 651     def get_tracker_multitracker_reannounce_interval(self):
 652         self.sesslock.acquire()
 653         try:
 654             return SessionConfigInterface.get_tracker_multitracker_reannounce_interval(self)
 655         finally:
 656             self.sesslock.release()
 657
 658     def set_tracker_multitracker_maxpeers(self,value):
 659         raise OperationNotPossibleAtRuntimeException()
 660
 661     def get_tracker_multitracker_maxpeers(self):
 662         self.sesslock.acquire()
 663         try:
 664             return SessionConfigInterface.get_tracker_multitracker_maxpeers(self)
 665         finally:
 666             self.sesslock.release()
 667
 668     def set_tracker_aggregate_forward(self,value):
 669         raise OperationNotPossibleAtRuntimeException()
 670
 671     def get_tracker_aggregate_forward(self):
 672         self.sesslock.acquire()
 673         try:
 674             return SessionConfigInterface.get_tracker_aggregate_forward(self)
 675         finally:
 676             self.sesslock.release()
 677
 678     def set_tracker_aggregator(self,value):
 679         raise OperationNotPossibleAtRuntimeException()
 680
 681     def get_tracker_aggregator(self):
 682         self.sesslock.acquire()
 683         try:
 684             return SessionConfigInterface.get_tracker_aggregator(self)
 685         finally:
 686             self.sesslock.release()
 687
 688     def set_tracker_hupmonitor(self,value):
 689         raise OperationNotPossibleAtRuntimeException()
 690
 691     def get_tracker_hupmonitor(self):
 692         self.sesslock.acquire()
 693         try:
 694             return SessionConfigInterface.get_tracker_hupmonitor(self)
 695         finally:
 696             self.sesslock.release()
 697
 698     def set_tracker_multitracker_http_timeout(self,value):
 699         raise OperationNotPossibleAtRuntimeException()
 700
 701     def get_tracker_multitracker_http_timeout(self):
 702         self.sesslock.acquire()
 703         try:
 704             return SessionConfigInterface.get_tracker_multitracker_http_timeout(self)
 705         finally:
 706             self.sesslock.release()
 707
 708     def set_tracker_parse_dir_interval(self,value):
 709         raise OperationNotPossibleAtRuntimeException()
 710
 711     def get_tracker_parse_dir_interval(self):
 712         self.sesslock.acquire()
 713         try:
 714             return SessionConfigInterface.get_tracker_parse_dir_interval(self)
 715         finally:
 716             self.sesslock.release()
 717
 718     def set_tracker_show_infopage(self,value):
 719         raise OperationNotPossibleAtRuntimeException()
 720
 721     def get_tracker_show_infopage(self):
 722         self.sesslock.acquire()
 723         try:
 724             return SessionConfigInterface.get_tracker_show_infopage(self)
 725         finally:
 726             self.sesslock.release()
 727
 728     def set_tracker_infopage_redirect(self,value):
 729         raise OperationNotPossibleAtRuntimeException()
 730
 731     def get_tracker_infopage_redirect(self):
 732         self.sesslock.acquire()
 733         try:
 734             return SessionConfigInterface.get_tracker_infopage_redirect(self)
 735         finally:
 736             self.sesslock.release()
 737
 738     def set_tracker_show_names(self,value):
 739         raise OperationNotPossibleAtRuntimeException()
 740
 741     def get_tracker_show_names(self):
 742         self.sesslock.acquire()
 743         try:
 744             return SessionConfigInterface.get_tracker_show_names(self)
 745         finally:
 746             self.sesslock.release()
 747
 748     def set_tracker_favicon(self,value):
 749         raise OperationNotPossibleAtRuntimeException()
 750
 751     def get_tracker_favicon(self):
 752         self.sesslock.acquire()
 753         try:
 754             return SessionConfigInterface.get_tracker_favicon(self)
 755         finally:
 756             self.sesslock.release()
 757
 758     def set_tracker_allowed_ips(self,value):
 759         raise OperationNotPossibleAtRuntimeException()
 760
 761     def get_tracker_allowed_ips(self):
 762         self.sesslock.acquire()
 763         try:
 764             return SessionConfigInterface.get_tracker_allowed_ips(self)
 765         finally:
 766             self.sesslock.release()
 767
 768     def set_tracker_banned_ips(self,value):
 769         raise OperationNotPossibleAtRuntimeException()
 770
 771     def get_tracker_banned_ips(self):
 772         self.sesslock.acquire()
 773         try:
 774             return SessionConfigInterface.get_tracker_banned_ips(self)
 775         finally:
 776             self.sesslock.release()
 777
 778     def set_tracker_only_local_override_ip(self,value):
 779         raise OperationNotPossibleAtRuntimeException()
 780
 781     def get_tracker_only_local_override_ip(self):
 782         self.sesslock.acquire()
 783         try:
 784             return SessionConfigInterface.get_tracker_only_local_override_ip(self)
 785         finally:
 786             self.sesslock.release()
 787
 788     def set_tracker_logfile(self,value):
 789         raise OperationNotPossibleAtRuntimeException()
 790
 791     def get_tracker_logfile(self):
 792         self.sesslock.acquire()
 793         try:
 794             return SessionConfigInterface.get_tracker_logfile(self)
 795         finally:
 796             self.sesslock.release()
 797
 798     def set_tracker_allow_get(self,value):
 799         raise OperationNotPossibleAtRuntimeException()
 800
 801     def get_tracker_allow_get(self):
 802         self.sesslock.acquire()
 803         try:
 804             return SessionConfigInterface.get_tracker_allow_get(self)
 805         finally:
 806             self.sesslock.release()
 807
 808     def set_tracker_keep_dead(self,value):
 809         raise OperationNotPossibleAtRuntimeException()
 810
 811     def get_tracker_keep_dead(self):
 812         self.sesslock.acquire()
 813         try:
 814             return SessionConfigInterface.get_tracker_keep_dead(self)
 815         finally:
 816             self.sesslock.release()
 817
 818     def set_tracker_scrape_allowed(self,value):
 819         raise OperationNotPossibleAtRuntimeException()
 820
 821     def get_tracker_scrape_allowed(self):
 822         self.sesslock.acquire()
 823         try:
 824             return SessionConfigInterface.get_tracker_scrape_allowed(self)
 825         finally:
 826             self.sesslock.release()
 827
 828     def set_overlay_max_message_length(self,value):
 829         raise OperationNotPossibleAtRuntimeException()
 830
 831     def get_overlay_max_message_length(self):
 832         self.sesslock.acquire()
 833         try:
 834             return SessionConfigInterface.get_overlay_max_message_length(self)
 835         finally:
 836             self.sesslock.release()
 837
 838     def set_download_help_dir(self,value):
 839         raise OperationNotPossibleAtRuntimeException()
 840
 841     def get_download_help_dir(self):
 842         self.sesslock.acquire()
 843         try:
 844             return SessionConfigInterface.get_download_help_dir(self)
 845         finally:
 846             self.sesslock.release()
 847
 848     def set_bartercast(self,value):
 849         raise OperationNotPossibleAtRuntimeException()
 850
 851     def get_bartercast(self):
 852         self.sesslock.acquire()
 853         try:
 854             return SessionConfigInterface.get_bartercast(self)
 855         finally:
 856             self.sesslock.release()
 857
 858     def set_superpeer_file(self,value):
 859         raise OperationNotPossibleAtRuntimeException()
 860
 861     def get_superpeer_file(self):
 862         self.sesslock.acquire()
 863         try:
 864             return SessionConfigInterface.get_superpeer_file(self)
 865         finally:
 866             self.sesslock.release()
 867
 868     def set_buddycast_collecting_solution(self,value):
 869         raise OperationNotPossibleAtRuntimeException()
 870
 871     def get_buddycast_collecting_solution(self):
 872         self.sesslock.acquire()
 873         try:
 874             return SessionConfigInterface.get_buddycast_collecting_solution(self)
 875         finally:
 876             self.sesslock.release()
 877
 878     def set_peer_icon_path(self,value):
 879         raise OperationNotPossibleAtRuntimeException()
 880
 881     def get_peer_icon_path(self):
 882         self.sesslock.acquire()
 883         try:
 884             return SessionConfigInterface.get_peer_icon_path(self)
 885         finally:
 886             self.sesslock.release()
 887
 888     #
 889     # NAT Puncturing servers information setting/retrieval
 890     #
 891     def set_nat_detect(self,value):
 892         raise OperationNotPossibleAtRuntimeException()
 893
 894     def set_puncturing_private_port(self, puncturing_private_port):
 895         raise OperationNotPossibleAtRuntimeException()
 896
 897     def set_stun_servers(self, stun_servers):
 898         raise OperationNotPossibleAtRuntimeException()
 899
 900     def set_pingback_servers(self, pingback_servers):
 901         raise OperationNotPossibleAtRuntimeException()
 902
 903     def set_puncturing_coordinators(self, puncturing_coordinators):
 904         raise OperationNotPossibleAtRuntimeException()
 905
 906     def get_nat_detect(self):
 907         self.sesslock.acquire()
 908         try:
 909             return SessionConfigInterface.get_nat_detect(self)
 910         finally:
 911             self.sesslock.release()
 912
 913     def get_puncturing_internal_port(self):
 914         self.sesslock.acquire()
 915         try:
 916             return SessionConfigInterface.get_puncturing_internal_port(self)
 917         finally:
 918             self.sesslock.release()
 919
 920     def get_stun_servers(self):
 921         self.sesslock.acquire()
 922         try:
 923             return SessionConfigInterface.get_stun_servers(self)
 924         finally:
 925             self.sesslock.release()
 926
 927     def get_pingback_servers(self):
 928         self.sesslock.acquire()
 929         try:
 930             return SessionConfigInterface.get_pingback_servers(self)
 931         finally:
 932             self.sesslock.release()
 933
 934     #
 935     # Crawler
 936     #
 937     def set_crawler(self, value):
 938         raise OperationNotPossibleAtRuntimeException()
 939
 940     def get_crawler(self):
 941         self.sesslock.acquire()
 942         try:
 943             return SessionConfigInterface.get_crawler(self)
 944         finally:
 945             self.sesslock.release()
 946
 947     #
 948     # Local Peer Discovery using IP Multicast
 949     #
 950     def set_multicast_local_peer_discovery(self,value):
 951         raise OperationNotPossibleAtRuntimeException()
 952
 953     def get_multicast_local_peer_discovery(self):
 954         self.sesslock.acquire()
 955         try:
 956             return SessionConfigInterface.get_multicast_local_peer_discovery(self)
 957         finally:
 958             self.sesslock.release()
 959