16GB खाली स्थान वाले टैबलेट के माध्यम से 4GB का टोरेंट डाउनलोड करना

उद्देश्य:

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

समाधान का मार्ग:

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

इस तथ्य के कारण कि टोरेंट क्लाइंट उस फ़ाइल में विरल ध्वज सेट करता है जिसमें वह प्राप्त डेटा लिखता है, सिस्टम एक बार में 16GB आरक्षित करने का प्रयास नहीं करता है और 4GB से अधिक फ़ाइल में लिखने का प्रयास करते समय कोई त्रुटि नहीं होगी।

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

मुझे ऐसा लगा कि इतना सरल कार्यक्रम इंटरनेट पर होना चाहिए। क्या कभी किसी को ऐसी समस्या का सामना नहीं करना पड़ा? लेकिन मुझे एहसास हुआ कि मुझे यह भी नहीं पता कि इसके लिए कौन से कीवर्ड खोजें। इसलिए, मैंने तुरंत इस कार्य के लिए एक लुआ स्क्रिप्ट बनाई और अब मैंने इसे अनुकूलित कर लिया है। यही मैं साझा करना चाहता हूं.

टोरेंट को भागों में डाउनलोड करना

1. पहले डिवाइस पर टोरेंट डाउनलोड करना प्रारंभ करें
2. ROM भर जाने तक प्रतीक्षा करें
3. डाउनलोड रोकें
4. फ़ाइल को दूसरे डिवाइस पर स्थानांतरित करें और फ़ाइल नाम में एक नंबर जोड़ें
5. फ़ाइल पूरी तरह से डाउनलोड होने तक हम पहले बिंदु पर लौटते हैं

भागों को एक फ़ाइल में विलय करना

अंतिम भाग प्राप्त होने के बाद, उन्हें एक संपूर्ण फ़ाइल में एकत्रित करना आवश्यक है।

कार्य सरल है:

1. सभी भागों को एक साथ पढ़ना
2. यदि किसी भाग में स्थिति शून्य बाइट नहीं है, तो हम इसे आउटपुट में लिखते हैं, अन्यथा हम शून्य लिखते हैं

समारोह merge_part धागों की एक श्रृंखला स्वीकार करता है streams_in जिसमें से आकार का एक भाग पढ़ता है buffer_length और विभिन्न धागों से भागों के विलय का परिणाम लौटाता है।

function merge_part(streams_in, buffer_length)
    local out_part
    for _, stream in ipairs(streams_in) do
        local in_part = stream:read(buffer_length)

        if not out_part then
            out_part = in_part -- просто копируем часть из первого файла
        elseif in_part and #in_part > 0 then

            if #out_part < #in_part then
                out_part, in_part = in_part, out_part
            end

            if out_part ~= in_part  -- данные различаются
                and in_part:find("[^ ]")   -- есть данные в in_part
                and out_part:find(" ", 1, true) -- есть пустые места в out_part
            then 
                local find_index = 1
--[[

समारोह string.gsub कार्य के लिए उपयुक्त है क्योंकि यह शून्य से भरे टुकड़ों को ढूंढेगा और जो दिया जाएगा उसे वितरित करेगा।

--]]
                out_part = out_part:gsub(" +", function(zero_string)

                    if #in_part < find_index then
                        return -- не на что менять
                    end
--[[

string.gsub यह उस स्थिति को नहीं बताता जिस पर मिलान पाया गया था। इसलिए, हम स्थिति के लिए समानांतर खोज करते हैं zero_string समारोह का उपयोग करना string.find. यह पहला शून्य बाइट खोजने के लिए पर्याप्त है।

--]]
                    local start_index = out_part:find(" ", find_index, true)
                    find_index = start_index + #zero_string

--[[

अब अगर अंदर in_part के लिए डेटा है out_part उन्हें कॉपी करें.

--]]
                    if #in_part >= start_index then
                        local end_index = start_index + #zero_string - 1
--[[

से काटें in_part शून्य के अनुक्रम के अनुरूप भाग.

--]]
                        local part = in_part:sub(start_index, end_index)

                        if (part:byte(1) ~= 0) or part:find("[^ ]") then
--[[

В part डेटा है.

--]]
                            if #part == #zero_string then
                                return part
                            else
--[[

part शून्य के अनुक्रम से कम निकला। आइए इसे उनके साथ पूरक करें।

--]]
                                return part..zero_string:sub(1, end_index - #in_part)
                            end
                        end
                    end
                end)
            end
        end
    end
    return out_part
end

निष्कर्ष

इस प्रकार, हम इस फ़ाइल को एक पीसी पर डाउनलोड और असेंबल करने में सक्षम थे। विलय के बाद, मैंने टैबलेट से टोरेंट फ़ाइल निकाली। मैंने अपने पीसी पर एक टोरेंट क्लाइंट स्थापित किया और उससे फ़ाइल की जाँच की।

टेबलेट पर अंतिम डाउनलोड किया गया भाग वितरण पर छोड़ा जा सकता है, लेकिन आपको इससे पहले भागों की पुनः जांच सक्षम करने और फ़ाइल को अनचेक करने की आवश्यकता है ताकि यह दोबारा डाउनलोड न हो।

इस्तेमाल किया गया:

1. एक टेबलेट पर फ़्लूड टोरेंट क्लाइंट।
2. पीसी पर टोरेंट क्लाइंट qBittorent।
3. लुआ स्क्रिप्ट

स्रोत: www.habr.com