Changeset 739


Ignore:
Timestamp:
04/03/09 21:17:30 (11 years ago)
Author:
Eoin
Message:

Cleaning up torrent removal code.

Location:
trunk/src
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/HaliteListView.cpp

    r737 r739  
    225225} 
    226226 
     227void HaliteListViewCtrl::remove_to_bin(hal::fs::wpath root, boost::shared_ptr<hal::file_details_vec> files) 
     228{ 
     229        std::vector<wchar_t> file_names_buffer; 
     230 
     231        foreach(hal::file_details file, *files) 
     232        { 
     233                std::wstring file_location = (hal::wform(L"File %1%\\%2%\\%3%")  
     234                        % root.file_string() % file.branch % file.filename).str(); 
     235 
     236                wstring full_file = hal::fs::wpath(root / file.branch / file.filename).file_string(); 
     237                  
     238                HAL_DEV_MSG(hal::wform(L"File %1%") % full_file); 
     239 
     240                std::copy(full_file.begin(), full_file.end(),  
     241                        std::back_inserter(file_names_buffer)); 
     242                file_names_buffer.push_back(L'\0'); 
     243        } 
     244        file_names_buffer.push_back(L'\0'); 
     245 
     246        SHFILEOPSTRUCT shf; 
     247 
     248        shf.hwnd = *this; 
     249        shf.wFunc = FO_DELETE; 
     250        shf.pFrom = &file_names_buffer[0]; 
     251        shf.pTo = 0; 
     252        shf.fFlags = FOF_ALLOWUNDO; 
     253 
     254        SHFileOperation(&shf); 
     255} 
     256 
    227257LRESULT HaliteListViewCtrl::OnRemoveWipeFiles(WORD wNotifyCode, WORD wID, HWND hWndCtl, BOOL& bHandled) 
    228258{ 
     
    235265 
    236266        foreach(wstring name, torrent_names) 
    237                 hal::bittorrent().remove_torrent_wipe_files(name); 
     267                hal::bittorrent().remove_torrent_wipe_files(name, bind(&HaliteListViewCtrl::remove_to_bin, this, _1, _2)); 
    238268 
    239269        return 0; 
  • trunk/src/HaliteListView.hpp

    r727 r739  
    126126        void erase_torrent_name(wstring name); 
    127127        bool sort_list_comparison(std::wstring l,  std::wstring r, size_t index, bool ascending); 
     128        void remove_to_bin(hal::fs::wpath root, boost::shared_ptr<hal::file_details_vec> files); 
    128129 
    129130private: 
  • trunk/src/HaliteWindow.cpp

    r720 r739  
    363363         
    364364        wpath file(lpszPath, boost::filesystem::native);         
    365         hal::bittorrent().add_torrent(file, wpath(default_save_folder), startPaused, managed, allocation_type,  
    366                 wpath(default_move_folder), use_move_to); 
     365 
     366        if (use_move_to) 
     367                hal::bittorrent().add_torrent(file, wpath(default_save_folder), startPaused, managed, allocation_type,  
     368                        wpath(default_move_folder)); 
     369        else 
     370                hal::bittorrent().add_torrent(file, wpath(default_save_folder), startPaused, managed, allocation_type); 
    367371 
    368372        issueUiUpdate(); 
  • trunk/src/halSession.hpp

    r737 r739  
    833833 
    834834        void add_torrent(wpath file, wpath saveDirectory, bool startStopped, bool managed, bit::allocations alloc,  
    835                         boost::filesystem::wpath moveToDirectory, bool useMoveTo)  
     835                        boost::filesystem::wpath moveToDirectory)  
    836836        { 
    837837                try  
    838838                {        
    839                 torrent_internal_ptr TIp; 
     839//              torrent_internal_ptr TIp; 
    840840 
    841841                std::pair<std::string, std::string> names = extract_names(file); 
    842842                wstring xml_name = from_utf8(names.first) + L".xml"; 
    843843 
    844                 if (false && fs::exists(file.parent_path()/xml_name)) 
     844/*              if (false && fs::exists(file.parent_path()/xml_name)) 
    845845                { 
    846846                        torrent_standalone tsa; 
     
    857857                        } 
    858858                } 
    859  
    860                 if (!TIp) 
    861                 { 
    862                         if (useMoveTo) 
    863                                 TIp.reset(new torrent_internal(file, saveDirectory, alloc, moveToDirectory));            
    864                         else 
    865                                 TIp.reset(new torrent_internal(file, saveDirectory, alloc)); 
    866  
     859*/ 
     860                torrent_internal_ptr TIp = 
     861                        the_torrents_.create_torrent(file, saveDirectory, alloc, moveToDirectory); 
     862 
     863                if(TIp) 
     864                { 
    867865                        TIp->set_managed(managed); 
    868866                        TIp->set_transfer_speed(bittorrent().default_torrent_download(), bittorrent().default_torrent_upload()); 
    869867                        TIp->set_connection_limit(bittorrent().default_torrent_max_connections(), bittorrent().default_torrent_max_uploads()); 
    870868                        TIp->set_resolve_countries(resolve_countries_); 
    871                 } 
    872                  
    873                 std::pair<torrent_manager::torrent_by_name::iterator, bool> p = 
    874                         the_torrents_.insert(TIp); 
    875                  
    876                 if (p.second) 
    877                 { 
    878                         torrent_internal_ptr me = the_torrents_.get(TIp->name());                
    879                          
     869 
     870 
    880871                        if (!startStopped)  
    881                                 me->add_to_session(); 
     872                                TIp->add_to_session(); 
    882873                        else 
    883                                 me->set_state_stopped(); 
     874                                TIp->set_state_stopped(); 
    884875                } 
    885876                 
     
    890881                                new EventTorrentException(event_logger::critical, event_logger::torrentException,  
    891882                                        std::string(e.what()), to_utf8(file.string()), std::string("addTorrent")))); 
     883                } 
     884        } 
     885 
     886        void remove_to_bin(boost::shared_ptr<file_details_vec> files, wpath path) 
     887        { 
     888                foreach(file_details file, *files) 
     889                { 
     890                        std::wstring file_location = (wform(L"File %1%\\%2%\\%3%")  
     891                                % path.file_string() % file.branch % file.filename).str(); 
     892 
     893                        HAL_DEV_MSG(wform(L"File %1%\\%2%\\%3%") % path.file_string() % file.branch % file.filename); 
    892894                } 
    893895        } 
     
    953955                try { 
    954956                event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Removing Torrent."))); 
    955                  
     957 
     958                boost::shared_ptr<file_details_vec> files = boost::shared_ptr<file_details_vec>(new file_details_vec());                 
    956959                torrent_internal_ptr pTI = the_torrents_.get(filename); 
     960 
     961        //      pTI->get_file_details(*files);           
     962        //      thread_t t(bind(&bit_impl::remove_to_bin, this, files, pTI->get_save_directory())); 
     963 
    957964                libt::torrent_handle handle = pTI->handle(); 
    958965                the_torrents_.erase(filename); 
    959966                 
    960         //      thread_t t(bind(&bit_impl::removal_thread, this, pTI, false));   
     967                event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Removed, started thread."))); 
    961968                 
    962969                } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "remove_torrent") 
    963970        } 
    964971 
    965         void remove_torrent_wipe_files(const std::wstring& filename) 
     972        void remove_torrent_wipe_files(const std::wstring& filename, remove_files fn) 
    966973        { 
    967974                try { 
    968975                event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Removing Torrent and files."))); 
    969                  
     976 
     977                boost::shared_ptr<file_details_vec> files = boost::shared_ptr<file_details_vec>(new file_details_vec());                 
    970978                torrent_internal_ptr pTI = the_torrents_.get(filename); 
    971                 libt::torrent_handle handle = pTI->handle(); 
     979 
     980                pTI->get_file_details(*files); 
     981                thread_t t(bind(fn, pTI->get_save_directory(), files)); 
     982 
     983                pTI->clear_resume_data(); 
     984                pTI->delete_torrent_file(); 
     985 
    972986                the_torrents_.erase(filename); 
    973987                 
    974         //      thread_t t(bind(&bit_impl::removal_thread, this, pTI, true));    
     988                event_log.post(shared_ptr<EventDetail>(new EventMsg(L"Removed, started thread."))); 
    975989                 
    976990                } HAL_GENERIC_TORRENT_EXCEPTION_CATCH(filename, "remove_torrent_wipe_files") 
  • trunk/src/halTorrent.cpp

    r714 r739  
    559559 
    560560void bit::add_torrent(wpath file, wpath saveDirectory, bool startStopped, bool managed, allocations alloc,  
    561                 boost::filesystem::wpath moveToDirectory, bool useMoveTo)  
    562 { 
    563         pimpl()->add_torrent(file, saveDirectory, startStopped, managed, alloc, moveToDirectory, useMoveTo); 
     561                boost::filesystem::wpath moveToDirectory)  
     562{ 
     563        pimpl()->add_torrent(file, saveDirectory, startStopped, managed, alloc, moveToDirectory); 
    564564} 
    565565 
     
    754754} 
    755755 
    756 void bit::remove_torrent_wipe_files_wstr(const std::wstring& filename) 
    757 { 
    758         pimpl()->remove_torrent_wipe_files(hal::to_wstr_shim(filename)); 
     756void bit::remove_torrent_wipe_files_wstr(const std::wstring& filename, remove_files f) 
     757{ 
     758        pimpl()->remove_torrent_wipe_files(hal::to_wstr_shim(filename), f); 
    759759} 
    760760 
  • trunk/src/halTorrent.hpp

    r714 r739  
    498498typedef boost::function<bool (size_t, size_t, std::wstring)> progress_callback; 
    499499typedef boost::function<void (int)> report_num_active; 
     500typedef boost::function<void (wpath path, boost::shared_ptr<file_details_vec> files)> remove_files; 
    500501typedef std::pair<wstring, wstring> wstring_pair; 
    501502typedef std::pair<float, float> float_pair; 
     
    725726        void add_torrent(boost::filesystem::wpath file, boost::filesystem::wpath saveDirectory,  
    726727                bool startPaused=false, bool managed=false, allocations alloc=hal::bit::sparse_allocation,  
    727                 boost::filesystem::wpath moveToDirectory=L"", bool useMoveTo=false); 
     728                boost::filesystem::wpath moveToDirectory=L""); 
    728729         
    729730        void get_all_peer_details(const std::string& filename, peer_details_vec& peerContainer); 
     
    762763 
    763764        template<typename S> 
    764         void remove_torrent_wipe_files(S filename) 
     765        void remove_torrent_wipe_files(S filename, remove_files fn) 
    765766        {  
    766                 remove_torrent_wipe_files_wstr(to_wstr_shim(filename));  
     767                remove_torrent_wipe_files_wstr(to_wstr_shim(filename), fn);  
    767768        }        
    768769 
     
    788789         
    789790        void remove_torrent_wstr(const std::wstring& filename); 
    790         void remove_torrent_wipe_files_wstr(const std::wstring&  filename); 
     791        void remove_torrent_wipe_files_wstr(const std::wstring&  filename, remove_files fn); 
    791792         
    792793        torrent_details_manager torrentDetails_; 
  • trunk/src/halTorrentInternal.cpp

    r696 r739  
    222222} 
    223223 
     224file_details_vec torrent_internal::get_file_details() 
     225{ 
     226        file_details_vec files; 
     227        get_file_details(files); 
     228 
     229        return files; 
     230} 
     231 
    224232void torrent_internal::get_file_details(file_details_vec& files) 
    225233{ 
  • trunk/src/halTorrentInternal.hpp

    r723 r739  
    6161class TorrentInternalOld; 
    6262class torrent_internal; 
     63class torrent_manager; 
    6364} 
    6465 
     
    331332        { 
    332333                state(torrent_details::torrent_stopped); 
    333                 TORRENT_STATE_LOG(L"Torrent state machine initiate"); 
    334                 initiate(); 
    335         } 
    336          
     334        } 
     335 
     336private: 
    337337        torrent_internal(wpath filename, wpath saveDirectory, bit::allocations alloc, wpath move_to_directory=L"") : 
    338338                TORRENT_INTERNALS_DEFAULTS, 
     
    342342        { 
    343343                state(torrent_details::torrent_stopped); 
    344                 assert(the_session_);    
    345                  
    346                 TORRENT_STATE_LOG(L"Torrent state machine initiate"); 
    347                 initiate(); 
     344                assert(the_session_); 
    348345 
    349346                prepare(filename); 
     
    352349        #undef TORRENT_INTERNALS_DEFAULTS 
    353350 
     351public: 
    354352        void locked_process_event(const sc::event_base & e) 
    355353        { 
     
    500498        void clear_resume_data() 
    501499        { 
    502                 wpath resume_file = hal::app().get_working_directory()/L"resume"/filename_; 
     500                wpath resume_file = hal::app().get_working_directory() / L"resume" / (name_ + L".fastresume"); 
    503501                 
    504502                if (exists(resume_file)) 
    505503                        remove(resume_file); 
     504        } 
     505 
     506        void delete_torrent_file() 
     507        {                
     508                wpath torrent_file = hal::app().get_working_directory() / L"torrents" / filename_; 
     509                 
     510                if (exists(torrent_file)) 
     511                        remove(torrent_file); 
    506512        } 
    507513 
     
    754760 
    755761        void get_file_details(file_details_vec& files); 
     762        file_details_vec get_file_details(); 
    756763         
    757764        void prepare(wpath filename); 
     
    852859 
    853860        static libt::session* the_session_;      
     861 
     862        friend class torrent_manager; 
    854863 
    855864private: 
     
    864873        void state(unsigned s); 
    865874 
     875        void initialize_state_machine(torrent_internal_ptr p) 
     876        { 
     877                own_weak_ptr_ = boost::weak_ptr<torrent_internal>(p); 
     878 
     879                TORRENT_STATE_LOG(L"Torrent state machine initiate"); 
     880                initiate(); 
     881        } 
     882 
    866883        mutable mutex_t mutex_; 
    867884        signalers signals_; 
     885 
     886        boost::weak_ptr<torrent_internal> own_weak_ptr_; 
    868887         
    869888        std::pair<float, float> transfer_limit_; 
     
    915934}; 
    916935 
    917 typedef std::map<std::string, TorrentInternalOld> TorrentMap; 
    918 typedef std::pair<std::string, TorrentInternalOld> TorrentPair; 
     936//typedef std::map<std::string, TorrentInternalOld> TorrentMap; 
     937//typedef std::pair<std::string, TorrentInternalOld> TorrentPair; 
    919938 
    920939class torrent_manager :  
     
    936955                explicit torrent_holder(torrent_internal_ptr t) : 
    937956                        torrent(t), filename(torrent->filename()), name(torrent->name()) 
    938                 {} 
    939                                                  
     957                {}                               
     958 
    940959                friend class boost::serialization::access; 
    941960                template<class Archive> 
    942                 void serialize(Archive& ar, const unsigned int version) 
     961                void load(Archive& ar, const unsigned int version) 
    943962                { 
    944963                        using boost::serialization::make_nvp; 
     
    947966                        ar & make_nvp("filename", filename); 
    948967                        ar & make_nvp("name", name); 
    949                 } 
     968 
     969                        torrent->initialize_state_machine(torrent); 
     970                } 
     971 
     972                template<class Archive> 
     973                void save(Archive& ar, const unsigned int version) const 
     974                { 
     975                        using boost::serialization::make_nvp; 
     976 
     977                        ar & make_nvp("torrent", torrent); 
     978                        ar & make_nvp("filename", filename); 
     979                        ar & make_nvp("name", name); 
     980                } 
     981 
     982                BOOST_SERIALIZATION_SPLIT_MEMBER() 
    950983        }; 
    951984         
     
    9761009                iniClass("bittorrent", "torrent_manager", ini) 
    9771010        {} 
     1011         
     1012/*      std::pair<torrent_by_name::iterator, bool> insert(torrent_internal_ptr t) 
     1013        { 
     1014                return insert(torrent_holder(t)); 
     1015        } 
     1016*/ 
     1017 
     1018        torrent_internal_ptr create_torrent(wpath filename, wpath saveDirectory, bit::allocations alloc, wpath move_to_directory=L"") 
     1019        { 
     1020                torrent_internal_ptr t = torrent_internal_ptr(new torrent_internal(filename, saveDirectory, alloc, move_to_directory)); 
     1021 
     1022                std::pair<torrent_by_name::iterator, bool> p = insert(torrent_holder(t)); 
     1023 
     1024                if (!p.second) t.reset(); 
     1025 
     1026                return t;                        
     1027        } 
    9781028 
    9791029        std::pair<torrent_by_name::iterator, bool> insert(const torrent_holder& h) 
    9801030        { 
     1031        //      torrent->initialize_state_machine(torrent); 
     1032 
    9811033                return torrents_.get<by_name>().insert(h); 
    9821034        } 
    983          
    984         std::pair<torrent_by_name::iterator, bool> insert(torrent_internal_ptr t) 
    985         { 
    986                 return insert(torrent_holder(t)); 
    987         } 
    9881035 
    9891036        torrent_internal_ptr get_by_file(const wstring& filename) 
     
    10231070        size_t erase(const wstring& name) 
    10241071        { 
     1072                torrent_by_name::iterator it = torrents_.get<by_name>().find(name); 
     1073                 
     1074                if (it != torrents_.get<by_name>().end()) 
     1075                        (*it).torrent->stop(); 
     1076 
    10251077                return torrents_.get<by_name>().erase(name); 
    10261078        } 
Note: See TracChangeset for help on using the changeset viewer.