Changeset 404


Ignore:
Timestamp:
03/17/08 15:00:32 (12 years ago)
Author:
Eoin
Message:

Some threading bug with the LogListView?!

Location:
trunk/src
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/HaliteWindow.cpp

    r403 r404  
    154154        tbinfo.fsState = TBSTATE_INDETERMINATE; 
    155155        ::SendMessage(hWndToolBar, TB_SETBUTTONINFO, ID_FILE_NEW, (LPARAM)&tbinfo); 
    156          
     156 
    157157        // Register UIEvents and the timer for the monitoring interval 
    158158        SetTimer(ID_UPDATE_TIMER, 500); 
  • trunk/src/advtabs/Debug.hpp

    r395 r404  
    107107        ~LogListViewCtrl() 
    108108        { 
     109                hal::mutex_t::scoped_lock l(mutex_); 
     110 
    109111                if (conn_.connected()) conn_.disconnect(); 
    110112        } 
     
    126128        void operator()(shared_ptr<hal::EventDetail> event) 
    127129        { 
    128                 int itemPos = AddItem(0, 0, lexical_cast<wstring>(event->timeStamp()).c_str(), 0); 
     130                hal::mutex_t::scoped_lock l(mutex_); 
     131                wstring timeStamp = lexical_cast<wstring>(event->timeStamp()); 
     132 
     133                try 
     134                { 
     135 
     136                int itemPos = AddItem(0, 0, L"Hello"); 
    129137 
    130138                SetItemText(itemPos, 1, event->msg().c_str()); 
     
    135143                if (halite().logListLen() <= GetItemCount()) 
    136144                        DeleteItem(halite().logListLen()); 
     145 
     146                } 
     147                catch(...) 
     148                {} 
    137149        } 
    138150 
     
    142154private: 
    143155        void OnAttach() 
    144         {                
     156        {        
     157                hal::mutex_t::scoped_lock l(mutex_); 
     158         
    145159                SetExtendedListViewStyle(WS_EX_CLIENTEDGE|LVS_EX_FULLROWSELECT|LVS_EX_HEADERDRAGDROP); 
    146160                SetSortListViewExtendedStyle(SORTLV_USESHELLBITMAPS, SORTLV_USESHELLBITMAPS); 
     
    153167        void OnDestroy() 
    154168        { 
     169                hal::mutex_t::scoped_lock l(mutex_); 
     170 
    155171                conn_.disconnect(); 
    156172                saveSettings(); 
    157173        } 
    158174 
     175        mutable hal::mutex_t mutex_; 
    159176        boost::signals::connection conn_; 
    160177}; 
  • trunk/src/halEvent.cpp

    r392 r404  
    3434{ 
    3535        if (event->level() != hal::Event::debug || halite().logDebug()) 
    36                 event_signal_(event); 
     36                signal(event); 
    3737} 
    3838         
  • trunk/src/halEvent.hpp

    r376 r404  
    7070                return event_signal_.connect(fn); 
    7171        } 
    72          
    73 private: 
     72 
     73        void signal(boost::shared_ptr<EventDetail> e) 
     74        { 
     75                mutex_t::scoped_lock l(mutex_); 
     76 
     77                event_signal_(e); 
     78        } 
     79         
     80private: 
     81        mutable mutex_t mutex_; 
     82 
    7483        boost::signal<void (boost::shared_ptr<EventDetail>)> event_signal_; 
    7584}; 
  • trunk/src/halSignaler.hpp

    r402 r404  
    2121        void operator()()  
    2222        { 
     23                HAL_DEV_MSG(L"Once"); 
     24 
    2325                f_(); 
    2426                 
     
    3941        void connect_repeat(const typename S::slot_type& slot) 
    4042        { 
     43                HAL_DEV_MSG(L"connect_repeat"); 
    4144                repeat_.connect(slot); 
    4245        } 
     
    4447        void connect_once(const typename S::slot_type& slot) 
    4548        { 
     49                HAL_DEV_MSG(L"connect_once"); 
    4650                once_.connect(slot); 
    4751        } 
     
    4953        void operator()()  
    5054        { 
     55                HAL_DEV_MSG(L"operator()"); 
    5156                repeat_(); 
    5257 
    5358                once_(); 
    5459                once_.disconnect_all_slots(); 
     60                HAL_DEV_MSG(L"Once disconnected"); 
    5561        }        
     62 
     63        void disconnect_all_once() 
     64        { 
     65                once_.disconnect_all_slots(); 
     66                HAL_DEV_MSG(L"All disconnected"); 
     67        } 
    5668 
    5769private: 
  • trunk/src/halTorrent.cpp

    r403 r404  
    317317                                        Event::info, a.timestamp()))); 
    318318 
    319                         get(a.handle)->signals.torrent_paused(); 
     319                        get(a.handle)->signals().torrent_paused(); 
    320320                } 
    321321                 
  • trunk/src/halTorrentInternal.hpp

    r403 r404  
    399399         
    400400        bool compactStorage_; 
     401}; 
     402 
     403 
     404struct signalers 
     405{ 
     406        signaler<> torrent_finished; 
     407        signaler<> torrent_paused; 
    401408}; 
    402409 
     
    501508        void addToSession(bool paused = false) 
    502509        { 
     510                try 
     511                { 
     512 
    503513                mutex_t::scoped_lock l(mutex_);  
    504                  
    505                 if (!in_session_ && the_session_)  
     514                assert(the_session_ != 0); 
     515 
     516                HAL_DEV_MSG(wformat_t(L"addToSession() paused=%1%") % paused); 
     517                 
     518                if (!inSession())  
    506519                {                        
    507520                        string_t dir = to_utf8(save_directory_); 
     
    526539                        handle_.force_reannounce(); 
    527540                }        
     541 
     542                assert(inSession()); 
     543                HAL_DEV_MSG(L"Added to session"); 
     544 
     545                } 
     546                catch(std::exception& e) 
     547                { 
     548                        hal::event().post(boost::shared_ptr<hal::EventDetail>( 
     549                                new hal::EventStdException(Event::critical, e, L"addToSession")));  
     550                } 
    528551        } 
    529552         
    530553        void removeFromSession(bool writeData=true) 
    531554        { 
    532                 HAL_DEV_MSG(wformat_t(L"removeFromSession() %1%") % writeData); 
     555                try 
     556                { 
    533557 
    534558                mutex_t::scoped_lock l(mutex_); 
    535559                assert(inSession()); 
     560 
     561                HAL_DEV_MSG(wformat_t(L"removeFromSession() writeData=%1%") % writeData); 
    536562                 
    537563                if (writeData) 
    538564                { 
     565                        HAL_DEV_MSG(L"getting resume data"); 
    539566                        resumedata_ = handle_.write_resume_data(); // Update the fast-resume data 
     567                        HAL_DEV_MSG(L"writing resume data"); 
    540568                        writeResumeData(); 
    541569                } 
    542570                 
     571                HAL_DEV_MSG(L"removing handle from session"); 
    543572                the_session_->remove_torrent(handle_); 
    544573                in_session_ = false; 
    545                  
     574                state_ = TorrentDetail::torrent_stopped; 
     575 
    546576                assert(!inSession());    
     577                HAL_DEV_MSG(L"Removed from session!"); 
     578 
     579                } 
     580                catch(std::exception& e) 
     581                { 
     582                        hal::event().post(boost::shared_ptr<hal::EventDetail>( 
     583                                new hal::EventStdException(Event::critical, e, L"removeFromSession")));  
     584                } 
    547585        } 
    548586         
     
    550588        {  
    551589                mutex_t::scoped_lock l(mutex_); 
    552                  
    553                 if (in_session_ && (the_session_ != 0)) 
    554                 {                
    555                         if (handle_.is_valid()) 
    556                         { 
    557                                 return true; 
    558                         } 
    559                 } 
    560                  
    561                 return false; 
     590 
     591                return (in_session_ && the_session_ != 0 && handle_.is_valid()); 
    562592        } 
    563593         
     
    588618                {        
    589619                        addToSession(true); 
     620 
    590621                        assert(inSession()); 
    591                         state_ = TorrentDetail::torrent_paused;  
     622                        assert(handle_.is_paused()); 
    592623                } 
    593624                else 
    594625                { 
    595626                        assert(inSession()); 
     627 
    596628                        handle_.pause(); 
    597                         signals.torrent_paused.connect_once(bind(&TorrentInternal::completedPauseEvent, this)); 
     629                        signals().torrent_paused.disconnect_all_once(); 
     630                        signals().torrent_paused.connect_once(bind(&TorrentInternal::completed_pause, this)); 
    598631 
    599632                        state_ = TorrentDetail::torrent_pausing;         
    600                 }        
    601                  
    602                 assert(handle_.is_paused()); 
     633                }                        
    603634        } 
    604635         
     
    612643                        { 
    613644                                assert(inSession()); 
     645 
    614646                                handle_.pause(); 
    615                                 signals.torrent_paused.connect_once(bind(&TorrentInternal::completedPauseEvent, this)); 
     647                                signals().torrent_paused.disconnect_all_once(); 
     648                                signals().torrent_paused.connect_once(bind(&TorrentInternal::completed_stop, this)); 
    616649 
    617650                                state_ = TorrentDetail::torrent_stopping; 
     
    628661        void forceRecheck() 
    629662        { 
    630                 mutex_t::scoped_lock l(mutex_); 
    631                  
     663                mutex_t::scoped_lock l(mutex_);          
    632664                HAL_DEV_MSG(L"forceRecheck()"); 
    633665 
    634                 if (state_ != TorrentDetail::torrent_stopped) 
    635                 { 
    636                         assert(inSession()); 
    637  
    638                         if (state_ == TorrentDetail::torrent_active) 
    639                         { 
    640                                 handle_.pause(); 
    641                                 signals.torrent_paused.connect_once(bind(&TorrentInternal::handleRecheck, this)); 
    642  
    643                                 state_ = TorrentDetail::torrent_stopping; 
    644                         } 
    645                         else if (state_ == TorrentDetail::torrent_paused) 
    646                         {                        
    647                                 handleRecheck();                                 
    648                         } 
    649                         else 
    650                         { 
    651                                 signals.torrent_paused.connect_once(bind(&TorrentInternal::handleRecheck, this)); 
    652                         } 
    653                 } 
    654                 else 
    655                 { 
    656                         handleRecheck(); 
    657                 } 
    658         } 
    659  
    660         void handleRecheck() 
    661         { 
    662                 mutex_t::scoped_lock l(mutex_); 
    663  
    664                 HAL_DEV_MSG(L"handleRecheck()"); 
    665  
    666                 state_ = TorrentDetail::torrent_stopped; 
    667                 removeFromSession(false); 
    668                 resume(); 
     666                switch (state_) 
     667                { 
     668                case TorrentDetail::torrent_stopped: 
     669                        clearResumeData(); 
     670                        resume(); 
     671                        break; 
     672 
     673                case TorrentDetail::torrent_stopping: 
     674                case TorrentDetail::torrent_pausing: 
     675                        signals().torrent_paused.disconnect_all_once(); 
     676 
     677                case TorrentDetail::torrent_active: 
     678                        signals().torrent_paused.connect_once(bind(&TorrentInternal::handle_recheck, this)); 
     679                        handle_.pause(); 
     680                        break; 
     681 
     682                default: 
     683                        assert(false); 
     684                }; 
    669685        } 
    670686         
    671687        void writeResumeData() 
    672         {                                
     688        {                                        
     689                HAL_DEV_MSG(L"writeResumeData()"); 
    673690                wpath_t resumeDir = workingDir_/L"resume"; 
    674691                 
     
    678695                bool halencode_result = halencode(resumeDir/filename_, resumedata_); 
    679696                assert(halencode_result); 
     697                HAL_DEV_MSG(L"Written!"); 
    680698        } 
    681699         
     
    955973                return infoMemory_; 
    956974        } 
    957  
    958         struct  
    959         { 
    960                 signaler<> torrent_finished; 
    961                 signaler<> torrent_paused; 
    962         }  
    963         signals; 
     975         
     976        signalers& signals() 
     977        { 
     978                mutex_t::scoped_lock l(mutex_); 
     979                return signals_; 
     980        } 
    964981 
    965982private:         
     983        signalers signals_; 
     984 
    966985        void applySettings() 
    967986        {                
     
    977996        void applyTransferSpeed() 
    978997        { 
     998                mutex_t::scoped_lock l(mutex_); 
    979999                if (inSession()) 
    9801000                { 
     
    9911011        void applyConnectionLimit() 
    9921012        { 
     1013                mutex_t::scoped_lock l(mutex_); 
    9931014                if (inSession()) 
    9941015                { 
     
    10021023        void applyRatio() 
    10031024        {  
     1025                mutex_t::scoped_lock l(mutex_); 
    10041026                if (inSession()) 
    10051027                { 
     
    10121034        void applyTrackers() 
    10131035        { 
     1036                mutex_t::scoped_lock l(mutex_); 
    10141037                if (inSession()) 
    10151038                { 
     
    10361059        void applyTrackerLogin() 
    10371060        { 
     1061                mutex_t::scoped_lock l(mutex_); 
    10381062                if (inSession()) 
    10391063                { 
     
    10501074        void applyFilePriorities() 
    10511075        {                
     1076                mutex_t::scoped_lock l(mutex_); 
    10521077                if (inSession())  
    10531078                { 
     
    10611086        void applyResolveCountries() 
    10621087        { 
     1088                mutex_t::scoped_lock l(mutex_); 
    10631089                if (inSession()) 
    10641090                { 
     
    10691095        } 
    10701096         
    1071         void completedPauseEvent() 
    1072         { 
    1073                 mutex_t::scoped_lock l(mutex_); 
    1074                  
    1075                 event().post(shared_ptr<EventDetail>( 
    1076                         new EventInfo(L"completedPauseEvent"))); 
    1077                  
    1078                 assert(inSession());             
    1079                  
    1080                 if (TorrentDetail::torrent_pausing == state_) 
    1081                 { 
    1082                         state_ = TorrentDetail::torrent_paused;  
    1083                         assert(handle_.is_paused()); 
    1084                 } 
    1085                 else if (TorrentDetail::torrent_stopping == state_) 
    1086                 { 
    1087                         removeFromSession(); 
    1088                          
    1089                         state_ = TorrentDetail::torrent_stopped; 
    1090                 } 
    1091         } 
    1092          
     1097        void completed_pause() 
     1098        { 
     1099                mutex_t::scoped_lock l(mutex_); 
     1100                assert(inSession()); 
     1101                assert(handle_.is_paused());     
     1102                                 
     1103                state_ = TorrentDetail::torrent_paused;  
     1104 
     1105                HAL_DEV_MSG(L"completed_pause()"); 
     1106        } 
     1107 
     1108        void completed_stop() 
     1109        { 
     1110                mutex_t::scoped_lock l(mutex_); 
     1111                assert(inSession()); 
     1112                assert(handle_.is_paused());     
     1113                 
     1114                state_ = TorrentDetail::torrent_stopped; 
     1115                 
     1116                removeFromSession();                     
     1117                assert(!inSession()); 
     1118 
     1119                HAL_DEV_MSG(L"completed_stop()"); 
     1120        } 
     1121 
     1122        void handle_recheck() 
     1123        { 
     1124                mutex_t::scoped_lock l(mutex_); 
     1125 
     1126                HAL_DEV_MSG(L"handleRecheck()"); 
     1127 
     1128                state_ = TorrentDetail::torrent_stopped; 
     1129                removeFromSession(false); 
     1130                resume(); 
     1131        } 
     1132                 
    10931133        static lbt::session* the_session_; 
    10941134        static wpath_t workingDir_; 
     
    13091349void TorrentInternal::setConnectionLimit(int maxConn, int maxUpload) 
    13101350{ 
     1351        mutex_t::scoped_lock l(mutex_); 
     1352 
    13111353        connections_ = maxConn; 
    13121354        uploads_ = maxUpload; 
     
    13221364void TorrentInternal::setTransferSpeed(float download, float upload) 
    13231365{        
     1366        mutex_t::scoped_lock l(mutex_); 
     1367 
    13241368        transferLimit_ = std::make_pair(download, upload); 
    13251369         
     
    13341378TorrentDetail_ptr TorrentInternal::getTorrentDetail_ptr() 
    13351379{        
     1380        mutex_t::scoped_lock l(mutex_); 
     1381 
    13361382        try 
    13371383        { 
Note: See TracChangeset for help on using the changeset viewer.