Changeset 590 for trunk


Ignore:
Timestamp:
10/10/08 18:07:05 (11 years ago)
Author:
Eoin
Message:

Supporting the new libtorrent interface to fast resume data. Not yet working!

Location:
trunk
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/res/Halite.rc

    r573 r590  
    870870        HAL_TRACKER_REPLY_ALERT                 "%2%. %3% Peers. (%1%)" 
    871871        HAL_FAST_RESUME_ALERT                   "Fast resume failed: %2%. (%1%)" 
     872        HAL_WRITE_RESUME_ALERT                  "Resume data generated. (%1%)" 
    872873        HAL_PIECE_FINISHED_ALERT                "Piece %2% finished. (%1%)" 
    873874        HAL_BLOCK_FINISHED_ALERT                "Block %2% of piece %3% finished. (%1%)" 
  • trunk/src/HaliteDialogBase.hpp

    r578 r590  
    8080                        if (focusedTorrent_) 
    8181                        { 
    82                                 HAL_DEV_MSG(hal::wform(L"HaliteDialogBase::handleUiUpdate(%1%)")  
    83                                         % hal::to_wstr_shim(focusedTorrent_->name())); 
     82                        //      HAL_DEV_MSG(hal::wform(L"HaliteDialogBase::handleUiUpdate(%1%)")  
     83                        //              % hal::to_wstr_shim(focusedTorrent_->name())); 
    8484                        } 
    8585                } 
  • trunk/src/global/ini.cpp

    r558 r590  
    77#include "stdAfx.hpp" 
    88 
    9 #define WINVER 0x0500 
    10 #define _WIN32_WINNT 0x0500 
    11 #define _WIN32_IE 0x0500 
    12 #define _RICHEDIT_VER 0x0200 
    13 #define VC_EXTRALEAN 
    14  
    15 #include <boost/foreach.hpp> 
    169#include <boost/date_time/posix_time/posix_time.hpp> 
    17  
    18 #include <atlbase.h> 
    19 #include <atlapp.h> 
    20  
    21 extern WTL::CAppModule _Module; 
    2210 
    2311#include "txml.hpp" 
     
    133121                } 
    134122                 
    135                 foreach(std::string elem, location) 
     123                foreach (std::string elem, location) 
    136124                { 
    137125                        xml::node* child_node = data_node->first_child(elem); 
  • trunk/src/halSession.cpp

    r583 r590  
    499499        } 
    500500         
     501        void operator()(libt::save_resume_data_alert const& a) const 
     502        { 
     503                event_log.post(shared_ptr<EventDetail>( 
     504                        new EventMsg((hal::wform(hal::app().res_wstr(HAL_WRITE_RESUME_ALERT))  
     505                                        % get(a.handle)->name()),  
     506                                event_logger::info, a.timestamp()))); 
     507 
     508                if (a.resume_data) 
     509                        get(a.handle)->write_resume_data(*a.resume_data); 
     510                get(a.handle)->signals().resume_data(); 
     511        } 
     512         
    501513        void operator()(libt::peer_error_alert const& a) const 
    502514        { 
     
    581593                                        % a.num_peers) 
    582594                )       );                               
    583         } 
    584          
    585         void operator()(libt::save_resume_data_alert const& a) const 
    586         { 
    587                 event_log.post(shared_ptr<EventDetail>( 
    588                         new EventGeneral(lbt_category_to_event(a.category()), a.timestamp(), 
    589                                 hal::wform(hal::app().res_wstr(HAL_FAST_RESUME_ALERT)) 
    590                                         % get(a.handle)->name() 
    591                                         % hal::from_utf8_safe(a.message())) 
    592                 )       );               
    593595        } 
    594596         
     
    662664                )       );       
    663665 
    664                 bit_impl_.signals.successful_listen(); 
     666                //bit_impl_.signals.successful_listen(); 
    665667        } 
    666668         
  • trunk/src/halSignaler.hpp

    r564 r590  
    99{ 
    1010 
     11template<typename F=boost::function<bool ()> > 
    1112struct signaler_wrapper : public boost::signals::trackable 
    1213{ 
    13         signaler_wrapper(boost::function<bool ()> f) : 
     14        signaler_wrapper(F f) : 
    1415                f_(f) 
    15         { 
    16                 HAL_DEV_MSG(L"signaler_wrapper ctor"); 
    17         } 
     16        {} 
    1817 
    1918        void operator()()  
    2019        { 
    21                 HAL_DEV_MSG(L"signaler_wrapper operator()"); 
    22  
    2320                if (f_()) 
    2421                { 
    25                 //      HAL_DEV_MSG(L"Disconnecting"); 
    26                 //      delete this; 
     22                        HAL_DEV_MSG(L"signaler_wrapper Disconnecting"); 
     23                        delete this; 
    2724                } 
    2825        } 
    2926 
    3027private: 
    31         boost::function<bool ()> f_; 
     28         F f_; 
    3229}; 
    3330 
  • trunk/src/halTorrent.cpp

    r577 r590  
    565565        l_(t->mutex_) 
    566566{ 
    567         HAL_DEV_MSG(L"Ctor proxy"); 
     567//      HAL_DEV_MSG(L"Ctor proxy"); 
    568568} 
    569569 
    570570bit::torrent::exec_around_ptr::proxy::~proxy()  
    571571{ 
    572         HAL_DEV_MSG(L"Dtor proxy"); 
     572//      HAL_DEV_MSG(L"Dtor proxy"); 
    573573} 
    574574 
  • trunk/src/halTorrentDefines.hpp

    r573 r590  
    4444#define HAL_FILE_ERROR_ALERT                            HAL_TORRENT_EXT_BEGIN + 27 
    4545#define HAL_DHT_REPLY_ALERT                                     HAL_TORRENT_EXT_BEGIN + 28 
     46#define HAL_WRITE_RESUME_ALERT                          HAL_TORRENT_EXT_BEGIN + 29 
    4647 
    4748#define HAL_TORRENT_INT_BEGIN                           42000 
  • trunk/src/halTorrentInternal.hpp

    r583 r590  
    235235{ 
    236236        signaler<> torrent_finished; 
     237 
    237238        boost::signal<void ()> torrent_paused; 
     239        boost::signal<void ()> resume_data; 
    238240}; 
    239241 
     
    353355                { 
    354356 
    355                 if (true || in_session()) 
     357                if (in_session()) 
    356358                { 
    357359                        statusMemory_ = handle_.status(); 
     
    518520 
    519521                HAL_DEV_MSG(hal::wform(L"add_to_session() paused=%1%") % paused); 
    520  
    521522                 
    522523                if (!in_session())  
     
    531532                        std::vector<char> buf; 
    532533                        if (libt::load_file(resume_file.c_str(), buf) == 0) 
     534                        { 
     535                                HAL_DEV_MSG(L"Using resume data"); 
    533536                                p.resume_data = &buf; 
     537                        } 
    534538 
    535539                        p.ti = info_memory_; 
    536540                        p.save_path = path_to_utf8(save_directory_); 
    537                         p.storage_mode = libt::storage_mode_compact;//compactStorage_ ? libt::storage_mode_compact : libt::storage_mode_sparse; 
     541                        p.storage_mode = compactStorage_ ? libt::storage_mode_compact : libt::storage_mode_sparse; 
    538542                        p.paused = paused; 
    539543                        p.duplicate_is_error = false; 
     
    559563        } 
    560564         
    561         void remove_from_session(bool writeData=true) 
     565        bool remove_from_session(bool write_data=true) 
    562566        { 
    563567                try 
     
    567571                assert(in_session()); 
    568572 
    569                 HAL_DEV_MSG(hal::wform(L"remove_from_session() writeData=%1%") % writeData); 
    570                  
    571                 if (writeData) 
    572                 { 
    573                         HAL_DEV_MSG(L"getting resume data"); 
    574 //                      resumedata_ = handle_.save(); // Update the fast-resume data 
    575                         HAL_DEV_MSG(L"writing resume data"); 
    576                         write_resume_data(); 
    577  
    578 //                      torrent_standalone tsa(shared_from_this()); 
    579 //                      tsa.save_standalone(workingDir_/L"torrents"/(name_+L".xml")); 
    580                 } 
    581                  
    582                 HAL_DEV_MSG(L"removing handle from session"); 
    583                 the_session_->remove_torrent(handle_); 
    584                 in_session_ = false; 
    585  
    586                 assert(!in_session());   
    587                 HAL_DEV_MSG(L"Removed from session!"); 
     573                HAL_DEV_MSG(hal::wform(L"remove_from_session() writeData=%1%") % write_data); 
     574                 
     575                if (write_data) 
     576                { 
     577                        HAL_DEV_MSG(L"requesting resume data");                  
     578                 
     579                        signaler_wrapper<>* sig = new signaler_wrapper<>(bind(&torrent_internal::remove_from_session, this, false)); 
     580                        signals().resume_data.connect(bind(&signaler_wrapper<>::operator(), sig)); 
     581                         
     582                        handle_.save_resume_data(); 
     583 
     584                        return false; 
     585                } 
     586                else 
     587                {                
     588                        HAL_DEV_MSG(L"removing handle from session"); 
     589                        the_session_->remove_torrent(handle_); 
     590                        in_session_ = false; 
     591 
     592                        assert(!in_session());   
     593                        HAL_DEV_MSG(L"Removed from session!"); 
     594 
     595                        return true; 
     596                } 
    588597 
    589598                } 
     
    591600                { 
    592601                        hal::event_log.post(boost::shared_ptr<hal::EventDetail>( 
    593                                 new hal::EventStdException(event_logger::critical, e, L"removeFromSession")));  
     602                                new hal::EventStdException(event_logger::critical, e, L"remove_fromSession")));  
     603                        return false; 
    594604                } 
    595605        } 
     
    638648                        HAL_DEV_MSG(hal::wform(L"pause() - handle_.pause()")); 
    639649                        handle_.pause(); 
    640                         //signals().torrent_paused.disconnect_all_once(); 
    641  
    642                         signaler_wrapper* sig = new signaler_wrapper(bind(&torrent_internal::completed_pause, this)); 
    643                         signals().torrent_paused.connect(bind(&signaler_wrapper::operator(), sig)); 
     650 
     651                        signaler_wrapper<>* sig = new signaler_wrapper<>(bind(&torrent_internal::completed_pause, this)); 
     652                        signals().torrent_paused.connect(bind(&signaler_wrapper<>::operator(), sig)); 
    644653 
    645654                        state_ = torrent_details::torrent_pausing;       
     
    657666                                assert(in_session()); 
    658667 
    659                                 signaler_wrapper* sig = new signaler_wrapper(bind(&torrent_internal::completed_stop, this)); 
    660                                 signals().torrent_paused.connect(bind(&signaler_wrapper::operator(), sig)); 
     668                                signaler_wrapper<>* sig = new signaler_wrapper<>(bind(&torrent_internal::completed_stop, this)); 
     669                                signals().torrent_paused.connect(bind(&signaler_wrapper<>::operator(), sig)); 
    661670                                 
    662671                                HAL_DEV_MSG(hal::wform(L"stop() - handle_.pause()")); 
     
    706715        } 
    707716         
    708         void write_resume_data() 
     717        void write_resume_data(const libt::entry& ent) 
    709718        {                                        
    710719                HAL_DEV_MSG(L"write_resume_data()"); 
    711                 wpath resumeDir = hal::app().get_working_directory()/L"resume"; 
    712                  
    713                 if (!exists(resumeDir)) 
    714                         create_directory(resumeDir); 
    715                                  
    716 //              bool halencode_result = halencode(resumeDir/filename_, resumedata_); 
    717 //              assert(halencode_result); 
     720 
     721                wpath resume_dir = hal::app().get_working_directory()/L"resume"; 
     722                 
     723                if (!exists(resume_dir)) 
     724                        create_directory(resume_dir); 
     725 
     726                boost::filesystem::ofstream out(resume_dir/(name_ + L".fastresume"), std::ios_base::binary); 
     727                out.unsetf(std::ios_base::skipws); 
     728                bencode(std::ostream_iterator<char>(out), ent); 
     729 
    718730                HAL_DEV_MSG(L"Written!"); 
    719731        } 
     
    721733        void clear_resume_data() 
    722734        { 
    723                 wpath resumeFile = hal::app().get_working_directory()/L"resume"/filename_; 
    724                  
    725                 if (exists(resumeFile)) 
    726                         remove(resumeFile); 
     735                wpath resume_file = hal::app().get_working_directory()/L"resume"/filename_; 
     736                 
     737                if (exists(resume_file)) 
     738                        remove(resume_file); 
    727739 
    728740//              resumedata_ = libt::entry(); 
     
    12371249                mutex_t::scoped_lock l(mutex_); 
    12381250                assert(in_session()); 
    1239         //      assert(handle_.is_paused());                     
    1240                  
    1241                 remove_from_session(); 
    1242                 assert(!in_session()); 
    1243  
    1244                 HAL_DEV_MSG(L"completed_stop()"); 
     1251                assert(handle_.is_paused());                     
     1252                 
     1253                if (remove_from_session()) 
     1254                { 
     1255                        assert(!in_session()); 
     1256                        HAL_DEV_MSG(L"completed_stop()"); 
     1257                } 
    12451258 
    12461259                state_ = torrent_details::torrent_stopped; 
     
    12881301         
    12891302//      boost::intrusive_ptr<libt::torrent_info> metadata_; 
    1290         libt::lazy_entry resumedata_; 
     1303//      boost::shared_ptr<libt::entry> resumedata_; 
    12911304         
    12921305        wstring trackerUsername_;        
Note: See TracChangeset for help on using the changeset viewer.