हम वितरण पर लौटते हैं या असंभव कैसे करते हैं

प्रागितिहास

बहुत समय पहले नहीं, अर्थात् 5 जून को, alan008 नामक एक हैबरमैन ने एक प्रश्न पूछा। मुझे विवरण के लिए जाने के लिए मजबूर नहीं करने के लिए, मैं उसे यहां लाऊंगा:

मदद चाहिए!

कई वर्षों के लिए, अलग-अलग ग्राहकों (मुख्य रूप से uTorrent) द्वारा अलग-अलग उपयोगी ट्रैकर्स (मुख्य रूप से रट्रैकर के साथ) से कई उपयोगी सामग्री डाउनलोड की गई है। डाउनलोड की गई फ़ाइलों को बाद में मैन्युअल रूप से एक ड्राइव से दूसरे में ले जाया गया, uTorrent उन्हें तदनुसार नहीं देखता है। कई .torrent फाइलें अपने आप पुरानी हो जाती हैं (उदाहरण के लिए, .torrent फ़ाइल को बदलकर नई श्रृंखला जोड़कर श्रृंखला वितरित की गई थी)।

अब सवाल खुद: क्या कंप्यूटर पर स्वचालित रूप से (मैन्युअल रूप से नहीं) .torrent फ़ाइलों और कंप्यूटर के विभिन्न तार्किक ड्राइव पर बिखरी हुई सामग्री के बीच पत्राचार स्थापित करने का एक तरीका है? उद्देश्य: अनावश्यक (अप्रासंगिक) .टोरेंट फ़ाइलों को हटा दें, और वास्तविक लोगों के लिए - वितरण पर सब कुछ डाल दें। किसके पास कोई आइडिया है? :)

यदि आवश्यक हो (यदि आवश्यक हो), आप फिर से एक ही लॉजिकल ड्राइव पर सभी डेटा फ़ाइलों को एक निर्देशिका में रख सकते हैं।

चर्चा इस बात पर सहमत थी कि यदि यह किया जा सकता है, तो केवल कलम के साथ। यह सवाल मुझे दिलचस्प लगा और छुट्टी से लौटने के बाद मैंने इसे हल करने के लिए समय लिया।

एक सप्ताह के कुल खर्च करने के बाद .टोरेंट फ़ाइल प्रारूप को पार्स करने के लिए एक कार्यशील पुस्तकालय की तलाश में, मैंने एक प्रोग्राम लिखना शुरू कर दिया है जो उपरोक्त प्रश्न में उठाई गई समस्या को हल करेगा।

शुरू करने से पहले, यह कुछ बिंदुओं पर ध्यान देने योग्य है:

1. यह बहुत निकला, लेकिन सभी नहीं।
2. .Torrent फ़ाइल स्वरूप केवल आवश्यक स्पष्टीकरण देगा।
3. कृपया मुझे ऐसे लोगों के लिए क्षमा करें जो कई बार कम-गुणवत्ता वाले कोड के प्रति संवेदनशील हैं - मुझे पता है कि बहुत कुछ बेहतर, अधिक आशावादी और बिना त्रुटियों के लिखा जा सकता है।

उन लोगों के लिए जो इसके बारे में आए, तकनीकी विवरण और नुकसान - कृपया, बिल्ली के नीचे।


इस मामले में, इसे हल करने का एक शानदार तरीका है - फिर से पंप करना। लेकिन हम आसान तरीकों की तलाश नहीं कर रहे हैं, और इस तरह का एक विकल्प प्रस्तावित किया गया था! तो, हम कठिन कार्य को हल करेंगे - डाउनलोड न करें ।

किसी भी कार्यक्रम को लिखना शुरू करते समय, आपको पहले इसके संचालन के लिए कम से कम बुनियादी एल्गोरिदम के बारे में सोचना चाहिए। हमारे मामले में, एल्गोरिथ्म अनिवार्य रूप से दो चरणों के होते हैं:

1. सभी .torrent फ़ाइलों को ढूंढें और पढ़ें;
2. फ़ाइल के ढेर पर खोजें जो कि .torrent में वर्णित एक से मेल खाता है, और इसे .torrent में पथ के अनुरूप फ़ोल्डर में ले जाएँ।

अपने विचार को कार्यान्वित करने के लिए, मैंने C # का उपयोग किया, लेकिन किसी भी भाषा में, जिसके पास bencode प्रारूप में फाइलें पढ़ने के लिए पुस्तकालय हैं, इसके लिए उपयुक्त है, और SHA-1 हैश को पढ़ना संभव है।

ठीक है, चलो कार्य के समाधान के लिए आगे बढ़ें।

हम टॉरेंट की तलाश करते हैं और उन्हें पढ़ते हैं

जब मैंने उपकरण का पता लगाया तो .torrent-files, मुझे इस सभी चमत्कार को पार्स करने के सवाल का सामना करना पड़ा। इस विषय पर इंटरनेट को बिखेरने के बाद, मैंने इस व्यवसाय के लिए कई .NET पुस्तकालयों की खोज की। मैंने अपनी पसंद को BencodeLibrary पुस्तकालय में चुना, अधिक या कम स्पष्ट और बॉक्स से बाहर काम करना, लेकिन बाद में मुझे इसे अपनी आवश्यकताओं में थोड़ा जोड़ना पड़ा, लेकिन बाद में इस पर अधिक।

आइए सबसे सरल क्षण के साथ शुरू करें - पढ़ना।

.Torrent फ़ाइल की संरचना काफी सरल है - यह बेनकोड प्रारूप में एक शब्दकोश है। इस शब्दकोश में, हम केवल जानकारी कुंजी के साथ एक जोड़ी में रुचि रखते हैं - फ़ाइल विवरण ब्लॉक। यह भी एक शब्दकोश है और इसमें फ़ाइलों के नाम, उनके आकार के बारे में जानकारी शामिल है। इसके अलावा, जैसा कि बहुत से लोग जानते हैं, एक टोरेंट हैश फाइल पूरी तरह से नहीं, बल्कि एक निश्चित लंबाई के टुकड़ों में है, जो इन फाइलों के आकार पर निर्भर करता है। इस टुकड़े के आकार की जानकारी भी जानकारी शब्दकोश में निहित है।

पठन फ़ाइल से जानकारी संग्रहीत करने के लिए, हम निम्नलिखित Torrent वर्ग का उपयोग करेंगे:

यहाँ फ़ील्ड निम्न जानकारी संग्रहीत करते हैं:

* Name - धार नाम (आम तौर पर बोल - फ़ोल्डर नाम या फ़ाइल नाम)
* Files - फ़ाइलों की एक सूची जिसे हमें भविष्य में देखने की आवश्यकता होगी
* PieceLength -आकार - उन टुकड़ों का आकार, जिन पर हमें विचार करना है
* Hash - सभी फाइलों का हैश स्ट्रिंग
* FileName - डिस्क पर .torrent फ़ाइल का नाम

अब यह हैश लाइन पर ध्यान देने योग्य है। यह बहुत ही सरलता से बनाया गया है। सभी फ़ाइलों को एक के बाद एक (लगभग) में चिपकाया जाता है, इस प्रकार एक BIGOOOOOOOY काल्पनिक फ़ाइल का निर्माण होता है। इस काल्पनिक फ़ाइल में हम लंबाई का एक टुकड़ा ले PieceLength , SHA1 हैश पर विचार करते हैं, हैश को लाइन पर रखते हैं, अगले टुकड़े को लेते हैं, हैश पर विचार करते हैं, पिछले टुकड़े के हैश के साथ लाइन के अंत में जाते हैं। यही है, यह सभी टुकड़ों के हैश का सामान्य संयोजन है।



जैसा कि एक चौकस पाठक ध्यान दे सकता है, एक वर्ग के अंदर एक फ़ाइल सिर्फ एक फ़ाइल नहीं है, बल्कि एक विशेष डेटा प्रकार है जिसमें फ़ाइल LostFile प्रकार के एक निश्चित निर्माण द्वारा वर्णित है। यहाँ यह है:

यहां सब कुछ सरल है: फ़ाइल का नाम और उसका आकार। इसके अलावा, इस वर्ग में एक और क्षेत्र है - BeginFrom । यह उस फ़ाइल की शुरुआत का वर्णन उस बड़ी काल्पनिक फ़ाइल में करता है। हैश की गणना करने के लिए फ़ाइल का सही हिस्सा लेने की आवश्यकता होती है - क्योंकि फ़ाइल की लंबाई बहुत कम ही होती है, जो टुकड़े की लंबाई से कई गुना अधिक होती है।



आवश्यक जानकारी संग्रहीत करने के लिए संरचनाएं तैयार करने के बाद, आप उन्हें भरना शुरू कर सकते हैं।

इंटरनेट पर पाई जाने वाली BodeodeLibrary लाइब्रेरी का उपयोग करते हुए, हम हमारी .torrent फ़ाइल को पढ़ते हैं और उसमें से सूचना ब्लॉक निकालते हैं:

 List<LostFile> files = new List<LostFile>(); //  ,   BDict torrent = (BDict)BencodingUtils.DecodeFile(filename, Encoding.UTF8); BDict fileInfo = (BDict)torrent["info"]; 

अगला, इस ब्लॉक से, आपको टोरेंट के नाम, टुकड़े के आकार के बारे में डेटा एकत्र करना होगा।

 string name = ((BString)fileInfo["name"]).Value; int pieceLength = (int)((BInt)fileInfo["piece length"]).Value; 

हैश पढ़ने में एक समस्या थी, जिसका समाधान मुझे वास्तव में पसंद नहीं है, लेकिन यह काम करता है। तथ्य यह है कि, विनिर्देश के अनुसार, .torrent फ़ाइल में सभी लाइनें UFT8 में होनी चाहिए। यदि आप हैश को पढ़ते हैं, जो विनिर्देश के अनुसार, एक यूएनएफ 8 स्ट्रिंग के रूप में एक बेनकोड स्ट्रिंग के प्रारूप में लिखा गया है, तो एक तुलनात्मक समस्या होगी - समान टुकड़ों का हैश मेल नहीं खाएगा। प्रस्तावित एन्कोडिंग कोडपेज -437 में धार पढ़ने से हमें रास्तों में रूसी अक्षरों के साथ समस्याएं आती हैं। मुझे ऐसी स्थिति से बाहर निकलने का रास्ता मिला जिसने मुझे दो दिनों के लिए धीमा कर दिया, सबसे अच्छा नहीं, लेकिन काम करना - अलग-अलग एन्कोडिंग में दो बार पढ़ना।

 torrent = (BDict)BencodingUtils.DecodeFile(filename, Encoding.GetEncoding(437)); char[] pieces = ((BString)((BDict)torrent["info"])["pieces"]).Value.ToCharArray(); 

इस बिंदु पर हम दूसरे पैरामीटर के रूप में एन्कोडिंग सूचना को 'BencodingUtils.DecodeFile` विधि से पास करते हैं। यह ठीक उसी क्षण है जब आपको लाइब्रेरी में एक विधि जोड़ना था - शुरू में कोडपेज -437 को कोड में सीवन किया गया था।

हमें इस हिस्से में सबसे दिलचस्प बात मिली - फाइल जानकारी पढ़ना। टोरेंट फाइलें दो तरह की होती हैं। ये प्रकार अलग-अलग हैं कि उनमें कितनी फाइलें वर्णित हैं। केवल .torrent में केवल एक फ़ाइल का वर्णन करते समय, उसका नाम और आकार लिखा जाता है।

सबसे पहले, हम एक फ़ाइल के विवरण के साथ .torrent का विश्लेषण करेंगे।

 long Length = ((BInt)fileInfo["length"]).Value; files.Add(new LostFile(name, Length, 0)); // files -   

यहां सब कुछ सरल है - धार का नाम फ़ाइल नाम के समान है। मामले में जब वितरण में बहुत सारी फाइलें होती हैं, तो जिस फ़ोल्डर में उन्हें रखा जाना चाहिए उसका नाम नाम फ़ील्ड में लिखा जाता है (वास्तव में, कुछ भी हो सकता है, लेकिन किसी कारण से हर कोई उस फ़ोल्डर का नाम लिखता है जिसमें ये फाइलें निर्माण के दौरान स्थित थीं)। इसके अलावा, फ़ाइलों की एक सूची दिखाई देती है जिसमें प्रत्येक फ़ाइल के बारे में जानकारी होती है: इसका पथ और आकार। यदि आकार सिर्फ एक पूर्णांक है, तो फ़ाइल पथ स्ट्रिंग्स (निर्देशिका नामों) की एक सूची है, जिसके माध्यम से हम इस फ़ाइल को देखेंगे।

यह सबसे अच्छा उदाहरण द्वारा समझाया गया है। फ़ाइलों के लिए level_1\level_2_1\file_1.txt और level_1\level_2_2\file_2.txt , यदि हम उन्हें वितरित करना चाहते हैं, तो नाम फ़ील्ड में शीर्ष-स्तरीय फ़ोल्डर ( "level_1" ) का नाम होगा, और फ़ाइलों में से एक के लिए पथ सूची निम्नानुसार होगी: {"level_2_1", "file_1.txt"} और {"level_2_2", "file_2.txt"} दूसरे के लिए।

कई फ़ाइलों के साथ .torrent के लिए, हमें एक लाइन में प्रत्येक फ़ाइल का पथ एकत्र करना होगा। इसके अलावा, आपको उस BOLSHOOOOM में प्रत्येक फ़ाइल की शुरुआत को संग्रहीत करने की आवश्यकता है (वास्तव में मत भूलना!)।)

 BList filesData = (BList)fileInfo["files"]; long begin = 0; foreach (BDict file in filesData) { BList filePaths = (BList)file["path"]; long length = ((BInt)file["length"]).Value; string fullPath = name; foreach (BString partOfPath in filePaths) { fullPath += @"\" + partOfPath.Value; } files.Add(new LostFile(fullPath, length, begin)); // files -   begin += length; } 

यह नोट करना बहुत महत्वपूर्ण है कि बोल्शूओम फाइल में फाइलों का क्रम कोई भी हो सकता है, जरूरी नहीं कि वर्णानुक्रम में या आकार में। लेकिन फाइलों की सूची में फाइलों का क्रम बिल्कुल समान होगा। यह हैशिंग के सिद्धांत को समझने की कुंजी है। उदाहरण के लिए, पहले आंकड़े में दिखाई गई स्थिति में, फाइलों की सूची इस प्रकार होगी: {"file_3","file_1", ..., "file_2"} । इस प्रकार, एक फ़ाइल के हैश को देखते हुए, हम जानते हैं कि कौन सी फ़ाइल को आगे ले जाना होगा।

जब हम इस पूरी चीज़ को पढ़ते हैं और गिनते हैं, तो आइए Torrent की एक प्रति बनाएँ और Torrent :

 new Torrent(name, files, pieceLength, pieces, filename); 

.Torrent फ़ाइल के सभी रीडिंग और विश्लेषण को एक साथ एकत्रित करते हुए, हम प्राप्त करते हैं:

अब जब हमारे पास सभी आवश्यक डेटा हैं, तो हम सबसे दिलचस्प बात के लिए तैयार हैं - हमारी फ़ाइलों की खोज।

हम फाइलें ढूंढ रहे हैं

हम अपने एल्गोरिथ्म के दूसरे चरण के कार्यान्वयन के करीब आए हैं। ऐसा करने के लिए, हम इस फॉर्म के FindFiles विधि का उपयोग करेंगे:

 void FindFiles(Torrent torrent, List<FileInfo> files, string destinationPath) {} 

यहां files उन files की एक सूची है जिनके बीच हम खोज करेंगे, destinationPath गंतव्य फ़ोल्डर का पथ है जिसमें पाया गया फाइलें रखी जाएंगी।

प्रत्येक फ़ाइल में .torrent के लिए हम ढेर से सभी फाइलों पर पुनरावृति करेंगे और उनकी तुलना करेंगे। चूंकि हैश की जाँच करना काफी महंगा है, इसलिए आपको पहले बाईं फ़ाइलों को स्पष्ट रूप से साफ़ करना होगा। खैर, खुद के लिए जज: अगर मैंने .mp3 को डाउनलोड किया और इसे स्थानांतरित किया, तो मैंने स्पष्ट रूप से फ़ाइल एक्सटेंशन को नहीं बदला। नाम बदल सकता है, लेकिन विस्तार की संभावना नहीं है।

 FileInfo fileOnDisk = files[j]; if (fileOnDisk.Extension != Path.GetExtension(fileInTorrent.Name)) continue; 

यह फ़ाइल की लंबाई की जांच करने के लायक भी है, लेकिन यह पहले से ही संदिग्ध है और कभी-कभी झूठी सकारात्मकता दे सकता है। एक्सटेंशन द्वारा स्पष्ट रूप से छोड़ी गई फ़ाइलों को बाहर निकालने के बाद ही हम हैश की जाँच शुरू कर सकते हैं।

 if (!torrent.CheckHash(i, fileOnDisk)) continue; 

सत्यापन पूरा होने के बाद, और हमने यह सुनिश्चित कर लिया कि जिस फ़ाइल को हम ढूंढ रहे हैं, उससे मेल खाता है, हम इसे सही पथ के साथ गंतव्य फ़ोल्डर में ले जाते हैं। आगे बढ़ने से पहले, हम स्वाभाविक रूप से निर्देशिका की उपस्थिति की जांच करेंगे, और यह भी जांचेंगे कि क्या पहले से ही ऐसी कोई फ़ाइल है या नहीं। copyFile - उपयोगकर्ता द्वारा फॉर्म से पारित चर, इसका उद्देश्य, मुझे लगता है, सभी के लिए स्पष्ट है।

 FileInfo fileToMove = new FileInfo(destinationPath + @"\" + fileInTorrent.Name); if (!Directory.Exists(fileToMove.DirectoryName)) Directory.CreateDirectory(fileToMove.DirectoryName); if (!fileToMove.Exists) { // -  if (copyFile) File.Copy(fileOnDisk.FullName, fileToMove.FullName); else File.Move(fileOnDisk.FullName, fileToMove.FullName); //     files.Remove(fileOnDisk); //     torrent.Files.RemoveAt(i--); break; //      ,      torrent } 

ऊपर दिए गए कोड में समझाने के लिए तीन बिंदु महत्वपूर्ण हैं। मैं अंतिम दो से शुरू करूँगा - ये पंक्तियाँ:

 files.Remove(fileOnDisk); torrent.Files.RemoveAt(i--); 

मुझे पहले से छंटाई गई फ़ाइलों को विचार से हटाने के लिए यह काफी तर्कसंगत लगा, जो खोज निष्पादन के समय को थोड़ा कम कर देगा। दूसरी पंक्ति में निर्माण शामिल है। .RemoveAt(i--); चूंकि वर्तमान तत्व को संग्रह से हटा दिया जाता है, इसलिए पॉइंटर को वापस ले जाना चाहिए ताकि अगला तत्व लूप के अगले पुनरावृत्ति पर लिया जाए, न कि एक के माध्यम से।

अब पहले क्षण के बारे में। मुझे सूची के लिए foreach की उपस्थिति के बारे में पता है, लेकिन इसका उपयोग करते समय, आप इस स्पीकर को संशोधित नहीं कर सकते हैं, अर्थात, हम पहले से ही अनावश्यक अधिक तत्वों को हटाने में सक्षम नहीं होंगे। इसलिए, ऊपर वर्णित सभी चीजों को एक विधि से एकत्रित करना, हमारे पास है:

खैर यहाँ! सबसे स्वादिष्ट।

हैश चेक

जैसा कि आप ऊपर दिए गए कोड से देख सकते हैं, हैश की जांच करने के लिए, हम डिस्क पर फ़ाइल नाम और टोरेंट फ़ाइलों की सूची में फ़ाइल नंबर को स्थानांतरित करते हैं। यह फाइलों की सूची में खोज शुरू नहीं करने के लिए आवश्यक है, लेकिन तुरंत इसे संख्या से लेना है, क्योंकि यह ज्ञात है (लूप के for एक और "+1")।

 public class Torrent { public string Name; public int PieceLength; public char[] Hash; public List<LostFile> Files; public string FileName; public bool CheckHash(int index, FileInfo fileOnDisk) {} } 

अब हम अपने हैश सत्यापन विधि के कार्यान्वयन के लिए आते हैं। इस स्तर पर, हम टोरेंट फ़ाइलों की सूची में संख्या और डिस्क पर फ़ाइल का पथ जानते हैं

 LostFile checkingFile = this.Files[index]; if (checkingFile.Length < this.PieceLength * 2 - 1) return false; 

सिद्धांत रूप में, हम किसी भी फ़ाइल के हैश पर विचार कर सकते हैं, लेकिन आइए अपने कार्य को थोड़ा सरल करें। हम केवल उन फाइलों को लेंगे जिनकी लम्बाई PieceLength * 2 - 1 से अधिक या बराबर है। इस तरह का प्रतिबंध हमें सत्यापन के लिए कम से कम एक टुकड़े को अलग करने में सक्षम करेगा, जो पूरी तरह से फ़ाइल में है। इस दृष्टिकोण के कई महत्वपूर्ण लाभ हैं:

1. डिस्क पर पड़ोसी फ़ाइलों की अतिरिक्त खोज करने की आवश्यकता नहीं है;
2. हैश चंक की लंबाई शायद ही कभी 2-4 एमबी से अधिक होती है, जो हमें एक और प्लस देता है - प्रदर्शन और समय के मामले में, ऐसी फ़ाइलों को डाउनलोड करना डिस्क पर उन्हें देखने की तुलना में बहुत आसान है।

इस स्तर पर, हम सभी के लिए सबसे मुश्किल थे जो हमें करना था - सत्यापन के लिए सही टुकड़ा खोजना। आइए थोड़ा सा प्रोग्रामिंग करने से दूर हटें और एक सहायक समस्या तैयार करते हुए गणित की ओर मुड़ें।

जब कोई टोरेंट क्लाइंट के पास फाइलें रखता है, तो वह हैश को क्रम में मानता है, लेकिन ऐसा होता है कि कोई एक या अधिक फाइलें नहीं हैं। फिर टोरेंट क्लाइंट को यह जानना होगा कि अगले उपलब्ध फ़ाइल में कौन सा टुकड़ा लेना है और कहाँ से शुरू होगा। इन दो अंकों की गणना करने के लिए, हम निम्नलिखित कोड का उपयोग करेंगे, जिसमें firstChunkNumber चर में पहले टुकड़े की संख्या है जो पूरी तरह से इस फ़ाइल में समाहित है, और बाइट्स bytesOverhead - फ़ाइल के आरंभ से लेकर इस टुकड़े की शुरुआत तक बाइट्स की संख्या। इस बिंदु की बेहतर समझ के लिए, कोड के बाद व्याख्यात्मक आकृति पर एक नज़र डालें।

 long start = 0; long firstChunkNumber = 0; long bytesOveload = checkingFile.BeginFrom % this.PieceLength; if (bytesOveload == 0) //        { start = checkingFile.BeginFrom; firstChunkNumber = checkingFile.BeginFrom / this.PieceLength; } else { firstChunkNumber = checkingFile.BeginFrom / this.PieceLength + 1; start = firstChunkNumber * this.PieceLength - checkingFile.BeginFrom; } 

प्रश्न का उत्तर "मामले की स्थिति के लिए टुकड़ा संख्या अलग क्यों है जब इसकी शुरुआत फ़ाइल की शुरुआत के साथ मेल खाती है, और इस मामले के लिए जब टुकड़ा अंदर होता है?" स्वतंत्र रूप से प्रस्तावित है।

अब, टुकड़े की संख्या को जानकर, हमें निम्नलिखित निर्माण का उपयोग करते हुए धार से इसका हैश लेना चाहिए:

 char[] hashInTorrent = new char[20]; // 20 -   SHA1   Array.Copy(this.Hash, firstChunkNumber * 20, hashInTorrent, 0, 20); 

उसके बाद, आपको फ़ाइल से एक टुकड़ा पढ़ने और उसके हैश की गणना करने की आवश्यकता है:

 char[] fileHash = new char[this.PieceLength]; using (BinaryReader fs = new BinaryReader(new FileStream(fileOnDisk.FullName, FileMode.Open))) { using (SHA1CryptoServiceProvider sha1 = new SHA1CryptoServiceProvider()) { byte[] piece = new byte[this.PieceLength]; fs.BaseStream.Position = start; fs.Read(piece, 0, this.PieceLength); fileHash = Encoding.GetEncoding(437).GetString(sha1.ComputeHash(piece)).ToCharArray(); } } 

वैसे, इसकी जांच करना सबसे महत्वपूर्ण है। किसी कारण से, मेरे लिए, Equals() तरीकों में से कोई भी नहीं है जो मुझे पता चल सके, इसलिए हम इस तरह से जांचते हैं:

 for (int i = 0; i < fileHash.Length; i++) { if (fileHash[i] != hashInTorrent[i]) return false; } 

उत्साहित मस्तिष्क के निर्माण को एक साथ रखकर, हम निम्नलिखित सामग्री की एक विधि प्राप्त करते हैं:

इस अद्भुत नोट पर, तरीकों और एल्गोरिदम की कहानी समाप्त होती है, और हम इस रचना के वास्तविक जीवन में प्राप्ति की कहानी पर आगे बढ़ते हैं। यह स्पष्ट है कि इस समस्या को हल करने के लिए मेरे द्वारा हल नहीं किया गया था, लेकिन एहसास करने के लिए। इसलिए, मैं अपनी रचना को जनता की अदालत में लाता हूं, जो ऊपर लिखी गई हर चीज को लागू करता है।

कार्यक्रम

कार्यक्रम लिखा है, जैसा कि पहले ही C # में बताया गया है। काम करते समय, यह बहुत सनकी नहीं होता है, इसके लिए केवल .NET 2.0 की आवश्यकता होती है। हालांकि, इसके उपयोग पर एक प्रतिबंध है: धार ड्राइव और तार्किक ड्राइव की जड़ से संग्रह को हटाने के लिए बेहतर है। इस सीमा का कारण `SearchOption.AllDirectories` पैरामीटर का उपयोग है जब निर्देशिकाओं को स्कैन करते हैं, जो एक रीसायकल बिन या` सिस्टम वॉल्यूम सूचना` (यदि जानकार बताते हैं कि कैसे यह चारों ओर पाने के लिए है, तो मैं इसे बहुत सराहना करूँगा) जैसे बंद निर्देशिकाओं को पढ़ने की कोशिश करते समय एक दुर्घटना की ओर जाता है। बेशक, गंतव्य फ़ोल्डर के लिए कोई विशेष प्रतिबंध नहीं हैं, मुख्य बात यह है कि इसमें फिट होना है, और आप इसे लिख सकते हैं, अन्यथा यह एक त्रुटि के साथ दुर्घटनाग्रस्त हो जाएगा (मॉडल नहीं, लेकिन तार्किक)।

अगली फ़ाइल के प्रसंस्करण के बाद, इस प्रक्रिया में, परिणाम प्रदर्शित होता है - डिस्क पर .torrent फ़ाइल का नाम और संसाधित फ़ाइलों की संख्या।



स्कैनिंग शुरू करने के लिए, आपको तीन निर्देशिकाओं (छँटाई के लिए फ़ाइलें और सॉर्ट किए गए लोगों के लिए एक फ़ोल्डर के साथ) का चयन करने की आवश्यकता है, वैकल्पिक रूप से दो विकल्प निर्दिष्ट करें और स्कैनिंग शुरू करें।

प्रदर्शन के संबंध में। यह अभी भी कम है: 10 बड़ी टोरेंट फाइलों के प्रसंस्करण में लगभग 5 मिनट लगते हैं।

चूंकि एप्लिकेशन एक थ्रेड में काम करता है, इंटरफ़ेस रनटाइम पर जमा देता है, लेकिन मैं इस पर काम कर रहा हूं। मैं आपको यह भी याद दिलाना चाहता हूं कि हैश को सत्यापित करने में असमर्थता के कारण छोटी फाइलें (2 मेगाबाइट से कम) को स्थानांतरित नहीं किया जाएगा। इस तथ्य के कारण झूठी सकारात्मकता काफी संभावना है कि पहले नंबर के तहत केवल एक टुकड़ा firstChunkNumber । अब तक, सभी टुकड़ों की जांच करना बहुत महंगा है, लेकिन योजनाएं भी हैं।

यदि वे डिस्क की जड़ में एकत्र किए गए हैं, तो पुनरावृत्ति की खोज न करें।
नकल में बहुत समय लग सकता है, इसलिए इंटरफ़ेस फ्रीज कर सकता है - चिंता न करें।

चूँकि यह 4fun प्रोग्राम लिखा गया था, वहाँ कोड की गुणवत्ता थोड़ी नहीं है जो मुझे पसंद है, लेकिन यह मेरे लिए काम करता है। इस कार्यक्रम का परीक्षण नहीं किया गया था, केवल स्पष्ट त्रुटियां तय की गई थीं, इसलिए हो सकता है, लेकिन क्या छिपाना है, छिपे हुए कीड़े हैं। इस कार्यक्रम का उपयोग करते हुए, आप अपने एकमात्र जोखिम पर इसका उपयोग करते हैं।

आप जीथूब पर स्रोत प्राप्त कर सकते हैं । GPLv2 द्वारा वितरित किया गया। एक निष्पादन योग्य फ़ाइल के साथ एक संग्रह है। काम के लिए बेनकोड लाइब्रेरी की आवश्यकता है, लेकिन मूल एक नहीं, बल्कि मेरे द्वारा संशोधित (मेरे पास रिपॉजिटरी में है , यह एक सबमॉडल द्वारा जुड़ा हुआ है)।

उन सभी को धन्यवाद जिन्होंने धैर्य दिखाया और इस लेख को अंत तक पढ़ा। अपने प्रश्नों को सुनने के लिए खुशी है, एल्गोरिथ्म को बेहतर बनाने में सभी प्रकार की सहायता और, विशेष रूप से, कोड का स्वागत है।

स्रोत: BitTorrentSpecification

UPD1। चर्चा के परिणामों के आधार पर, यह मेरे लिए स्पष्ट हो गया कि वितरण के लिए फ़ाइलों को खींचकर मौजूदा संग्रहों को न तोड़ना अधिक सही होगा, बल्कि ऑर्डर किए गए संग्रह (फिल्मों और डिस्कोग्राफी, उदाहरण के लिए) के अंदर फाइलों के वितरण के लिए सही जगह पर हार्डलिंक बनाएं। भविष्य में, कार्यक्रम उस तरह से काम करेगा।

UPD2। यदि इस उपयोगिता का उपयोग करने वालों के पास कार्यक्षमता या बग रिपोर्ट के बारे में कोई अन्य इच्छाएं हैं, तो कृपया उन्हें मुद्दे ट्रैकर में गीथब पर छोड़ दें।