💙 🤷🏻 🛸 बड़ी संख्या में फ़ाइलों का संग्रहण 🎡 🧔🏿 📷

अच्छा स्वास्थ्य, हॉकर्स! एक डेटिंग साइट परियोजना पर काम करने की प्रक्रिया में, उपयोगकर्ता फ़ोटो के भंडारण को व्यवस्थित करना आवश्यक हो गया। संदर्भ की शर्तों के अनुसार, प्रति उपयोगकर्ता फ़ोटो की संख्या 10 फ़ाइलों तक सीमित है। लेकिन दसियों हज़ार उपयोगकर्ता हो सकते हैं। विशेष रूप से यह देखते हुए कि परियोजना अपने वर्तमान स्वरूप में "शून्य" की शुरुआत से पहले से ही मौजूद है। यही है, डेटाबेस में पहले से ही हजारों उपयोगकर्ता हैं। लगभग किसी भी फाइल सिस्टम, जहां तक मुझे पता है, एक फ़ोल्डर में बड़ी संख्या में बच्चे के नोड्स के लिए बहुत नकारात्मक रूप से प्रतिक्रिया करता है। अनुभव से, मैं कह सकता हूं कि मूल फ़ोल्डर में 1000-1500 फ़ाइलों / फ़ोल्डरों के बाद समस्याएं शुरू होती हैं।

अस्वीकरण। मैंने लेख लिखने से पहले गुगली की और चर्चा के तहत मुद्दे के कई समाधान पाए (उदाहरण के लिए, यहाँ या यहाँ )। लेकिन मुझे एक भी समाधान नहीं मिला जो वास्तव में मेरा मेल खाता हो। इसके अलावा, इस लेख में मैं केवल समस्या को हल करने में अपना खुद का अनुभव साझा करता हूं।

सिद्धांत

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

एक छोटा सा विषयांतर। ऑटो-इंक्रीमेंट की बात करते हैं। एक डेटिंग साइट में एक दर्जन या दो हजार उपयोगकर्ता हो सकते हैं। सवाल यह है कि कितने उपयोगकर्ता आम तौर पर अपने अस्तित्व के पूरे समय के लिए परियोजना से गुजरते हैं। उदाहरण के लिए, डेटिंग-आरयू के सक्रिय दर्शक कई सौ हजार हैं। हालांकि, सिर्फ कल्पना करें कि इस परियोजना के जीवनकाल के दौरान कितने उपयोगकर्ता शेष हैं; कितने उपयोगकर्ता अब तक सक्रिय नहीं हैं। अब हमारे कानून में जोड़ें, जो हमें कम से कम छह महीने के लिए उपयोगकर्ताओं के बारे में जानकारी संग्रहीत करने के लिए बाध्य करता है ... जल्द ही या बाद में, 4 के साथ UNSIGNED INT का एक पैसा समाप्त हो जाएगा। इसलिए, BIGINT को प्राथमिक कुंजी के लिए लेना सबसे अच्छा है।

अब आइए कई प्रकार के BIGINT की कल्पना करने की कोशिश करें। यह 8 बाइट्स है। प्रत्येक बाइट 0 से 255 तक है। 255 बच्चे नोड्स किसी भी फाइल सिस्टम के लिए काफी सामान्य हैं। यही है, हम फ़ाइल पहचानकर्ता को हेक्साडेसिमल प्रतिनिधित्व में लेते हैं, हम इसे दो वर्णों के विखंडन में तोड़ देते हैं। हम इन चंक्स को फ़ोल्डर के नाम के रूप में उपयोग करते हैं, बाद में भौतिक फ़ाइल के नाम के रूप में। लाभ!

0f/65/84/10/67/68/19/ff.file

सुरुचिपूर्ण और सरल। फ़ाइल एक्सटेंशन यहां महत्वपूर्ण नहीं है। वैसे भी, फ़ाइल एक स्क्रिप्ट द्वारा दी जाएगी जो ब्राउज़र को एक विशेष MIME प्रकार देगी, जिसे हम डेटाबेस में भी संग्रहीत करेंगे। इसके अलावा, डेटाबेस में फ़ाइल के बारे में जानकारी संग्रहीत करना आपको ब्राउज़र के लिए इसके लिए पथ को फिर से परिभाषित करने की अनुमति देता है। कहते हैं, हमारे पास जो फ़ाइल है वह वास्तव में पथ / /content/files/0f/65/84/10/67/68/19/ff.file साथ प्रोजेक्ट डायरेक्टरी के सापेक्ष स्थित है। और डेटाबेस में आप इसके लिए एक URL लिख सकते हैं, उदाहरण के लिए, /content/users/678/files/somefile । एसईओ शायद अभी बहुत मुस्कुराए हैं। यह सब हमें चिंता करने की अनुमति नहीं देता है कि फाइल को भौतिक रूप से कहां रखा जाए।

डेटाबेस में तालिका

पहचानकर्ता, MIME प्रकार, URL और भौतिक स्थान के अलावा, यदि आवश्यक हो तो समान फ़ाइलों को फ़िल्टर करने के लिए हम तालिका में md5 और sha1 फ़ाइलों को संग्रहीत करेंगे। बेशक, हमें इस तालिका में इकाई संबंधों को संग्रहीत करने की भी आवश्यकता है। मान लीजिए कि उपयोगकर्ता आईडी जिसमें फाइलें हैं। और अगर परियोजना बहुत बड़ी नहीं है, तो उसी प्रणाली में हम स्टोर कर सकते हैं, कह सकते हैं, माल की तस्वीरें। इसलिए, हम उस इकाई वर्ग के नाम को भी संचित करेंगे जिसका रिकॉर्ड है।

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

और एक बात। हमारे कानून के अनुसार, हमें शारीरिक रूप से कस्टम छवियों को संग्रहीत करना होगा। यही है, हमें शारीरिक रूप से हटाने के बजाय किसी तरह हटाए गए चित्रों को चिह्नित करने की आवश्यकता है। इन उद्देश्यों के लिए बिट क्षेत्र का उपयोग करना सबसे सुविधाजनक है। ऐसे मामलों में, मैं आमतौर पर INT के एक क्षेत्र का उपयोग करता हूं। आरक्षित करना है, इसलिए बोलना है। इसके अलावा, मेरे पास अंत से 5 वें बिट में DELETED ध्वज रखने की पहले से ही स्थापित परंपरा है। लेकिन यह फिर से फिर से बात नहीं करता है।

परिणामस्वरूप हमारे पास क्या है:

 create table `files` ( `id` bigint not null auto_increment, --   `entity_type` char(32) not null default '', --   `entity` bigint null, -- ID  `mime` char(32) not null default '', -- MIME- `md5` char(32) not null default '', -- MD5 `sha1` char(40) not null default '', -- SHA1 `file` char(64) not null default '', --   `url` varchar(250) not null default '', -- URL `meta` text null, -- -   JSON    `size` bigint not null default '0', --  `created` datetime not null, --   `updated` datetime null, --   `access` tinyint not null default '0', --   `flags` int not null default '0', --  primary key (`id`), index (`entity_type`), index (`entity`), index (`mime`), index (`md5`), index (`sha1`), index (`url`) ) engine = InnoDB;

डिस्पैचर क्लास

अब हमें एक वर्ग बनाने की जरूरत है जिसके साथ हम फाइलें अपलोड करेंगे। वर्ग को फ़ाइलें बनाने, फ़ाइलों को बदलने / संशोधित करने, फ़ाइलों को हटाने की क्षमता प्रदान करनी चाहिए। इसके अलावा, यह दो बिंदुओं पर विचार करने योग्य है। सबसे पहले, परियोजना को सर्वर से सर्वर में स्थानांतरित किया जा सकता है। तो कक्षा में आपको एक संपत्ति को परिभाषित करने की आवश्यकता होती है जिसमें फ़ाइलों की जड़ निर्देशिका होती है। दूसरे, यह बहुत अप्रिय होगा यदि कोई डेटाबेस में एक मेज पर धमाका करता है। इसलिए आपको डेटा रिकवरी की संभावना प्रदान करने की आवश्यकता है। पहले के साथ, सब कुछ आम तौर पर स्पष्ट है। डेटा बैकअप के लिए, हम केवल वही आरक्षित करेंगे जो पुनर्स्थापित नहीं किया जा सकता है।

आईडी - फ़ाइल के भौतिक स्थान से बहाल
Unit_type - पुनर्स्थापित नहीं किया गया
इकाई - बहाल नहीं
माइम - फिनो एक्सटेंशन का उपयोग करके बहाल किया गया
md5 - फ़ाइल से ही पुनर्स्थापित किया जाता है
sha1 - फ़ाइल से ही पुनर्स्थापित किया गया
फ़ाइल - फ़ाइल के भौतिक स्थान से बहाल
url - पुनर्स्थापित नहीं किया गया
मेटा - बहाल नहीं है
आकार - फ़ाइल से ही पुनर्स्थापित किया गया
बनाया - आप एक फ़ाइल से जानकारी ले सकते हैं
अद्यतन - आप एक फ़ाइल से जानकारी ले सकते हैं
पहुंच - बहाल नहीं
झंडे - बहाल नहीं

आप मेटा सूचना को तुरंत छोड़ सकते हैं। यह प्रणाली के कामकाज के लिए महत्वपूर्ण नहीं है। और तेजी से वसूली के लिए, आपको अभी भी MIME प्रकार को बचाने की आवश्यकता है। कुल: इकाई प्रकार, इकाई आईडी, MIME, URL, पहुंच और झंडे। सिस्टम की विश्वसनीयता बढ़ाने के लिए, हम प्रत्येक गंतव्य फ़ोल्डर के लिए बैकअप जानकारी को अलग से फ़ोल्डर में संग्रहीत करेंगे।

कक्षा कोड

 <?php class BigFiles { const FLAG_DELETED = 0x08000000; //    "" /** @var mysqli $_db */ protected $_db = null; protected $_webRoot = ''; protected $_realRoot = ''; function __construct(mysqli $db = null) { $this->_db = $db; } /** * /   URL- * @param string $v  * @return string */ public function webRoot($v = null) { if (!is_null($v)) { $this->_webRoot = $v; } return $this->_webRoot; } /** * /    * @param string $v  * @return string */ public function realRoot($v = null) { if (!is_null($v)) { $this->_realRoot = $v; } return $this->_realRoot; } /** *   * @param array $data   * @param string $url URL   * @param string $eType   * @param int $eID ID  * @param mixed $meta - * @param int $access  * @param int $flags  * @param int $fileID ID   * @return bool * @throws Exception */ public function upload(array $data, $url, $eType = '', $eID = null, $meta = null, $access = 127, $flags = 0, $fileID = 0) { $meta = is_array($meta) ? serialize($meta) : $meta; if (empty($data['tmp_name']) || empty($data['name'])) { $fid = intval($fileID); if (empty($fid)) { return false; } $meta = empty($meta) ? 'null' : "'" . $this->_db->real_escape_string($meta) . "'"; $q = "`meta`={$meta},`updated`=now()"; $this->_db->query("UPDATE `files` SET {$q} WHERE (`id` = {$fid}) AND (`entity_type` = '{$eType}')"); return $fid; } // File data $meta = empty($meta) ? 'null' : "'" . $this->_db->real_escape_string($meta) . "'"; $finfo = finfo_open(FILEINFO_MIME_TYPE); $mime = finfo_file($finfo , $data['tmp_name']); finfo_close($finfo); // FID, file name if (empty($fileID)) { $eID = empty($eID) ? 'null' : intval($eID); $q = <<<sql insert into `files` set `mime` = '{$mime}', `entity` = {$eID}, `entityType` = '{$eType}', `created` = now(), `access` = {$access}, `flags` = {$flags} sql; $this->_db->query($q); $fid = $this->_db->insert_id; list($ffs, $fhn) = self::fid($fid); $url = $this->_webRoot . $url . '/' . $fid; $fdir = $this->_realRoot . $ffs; self::validateDir($fdir); $index = self::getIndex($fdir); $index[$fhn] = array($fhn, $mime, $url, ($eID == 'null' ? 0 : $eID), $access, $flags); self::setIndex($fdir, $index); $fname = $ffs . '/' . $fhn . '.file'; } else { $fid = intval($fileID); $fname = $this->fileName($fid); } // Move file $fdir = $this->_realRoot . $fname; if (!move_uploaded_file($data['tmp_name'], $fdir)) { throw new Exception('Upload error'); } $q = '`md5`=\'' . md5_file($fdir) . '\',`sha1`=\'' . sha1_file($fdir) . '\',' . '`size`=' . filesize($fdir) . ',`meta`=' . $meta . ',' . (empty($fileID) ? "`url`='{$url}',`file`='{$fname}'" : '`updated`=now()'); $this->_db->query("UPDATE `files` SET {$q} WHERE (`id` = {$fid}) AND (`entity_type` = '{$eType}')"); return $fid; } /** *   * @param string $url URL * @param string $basicGroup    * @throws Exception */ public function read($url, $basicGroup = 'anonimous') { if (!ctype_alnum(str_replace(array('/', '.', '-', '_'), '', $url))) { header('HTTP/1.1 400 Bad Request'); exit; } $url = $this->_db->real_escape_string($url); $q = "SELECT * FROM `files` WHERE `url` = '{$url}' ORDER BY `created` ASC"; if ($result = $this->_db->query($q)) { $vars = array(); $ints = array('id', 'entity', 'size', 'access', 'flags'); while ($row = $result->fetch_assoc()) { foreach ($ints as $i) { $row[$i] = intval($row[$i]); } $fid = $row['id']; $vars[$fid] = $row; } if (empty($vars)) { header('HTTP/1.1 404 Not Found'); exit; } $deleted = false; $access = true; $found = ''; $mime = ''; foreach ($vars as $fdata) { $flags = intval($fdata['flags']); $deleted = ($flags & self::FLAG_DELETED) != 0; $access = self::granted($basicGroup, $fdata['access']); if (!$access || $deleted) { continue; } $found = $fdata['file']; $mime = $fdata['mime']; } if (empty($found)) { if ($deleted) { header('HTTP/1.1 410 Gone'); exit; } elseif (!$access) { header('HTTP/1.1 403 Forbidden'); exit; } } else { header('Content-type: ' . $mime . '; charset=utf-8'); readfile($this->_realRoot . $found); exit; } } header('HTTP/1.1 404 Not Found'); exit; } /** *   ()   * @param mixed $fid () * @return bool * @throws Exception */ public function delete($fid) { $fid = is_array($fid) ? implode(',', $fid) : $fid; $q = "delete from `table` where `id` in ({$fid})"; $this->_db->query($q); $result = true; foreach ($fid as $fid_i) { list($ffs, $fhn) = self::fid($fid_i); $fdir = $this->_realRoot . $ffs; $index = self::getIndex($fdir); unset($index[$fhn]); self::setIndex($fdir, $index); $result &= unlink($fdir . '/'. $fhn . '.file'); } return $result; } /** *  ()  "" * @param int $fid () * @param bool $value   * @return bool */ public function setDeleted($fid, $value=true) { $fid = is_array($fid) ? implode(',', $fid) : $fid; $o = $value ? ' | ' . self::FLAG_DELETED : ' & ' . (~self::FLAG_DELETED); $this->_db->query("update `files` set `flags` = `flags` {$o} where `id` in ({$fid})"); return true; } /** *   * @param int $fid  * @return string * @throws Exception */ public function fileName($fid) { list($ffs, $fhn) = self::fid($fid); self::validateDir($this->_realRoot . $ffs); return $ffs . '/' . $fhn . '.file'; } /** *   . *           . * @param int $fid   * @return array */ public static function fid($fid) { $ffs = str_split(str_pad(dechex($fid), 16, '0', STR_PAD_LEFT), 2); $fhn = array_pop($ffs); $ffs = implode('/', $ffs); return array($ffs, $fhn); } /** *    * @param string $f     * @return bool * @throws Exception */ public static function validateDir($f) { if (!is_dir($f)) { if (!mkdir($f, 0700, true)) { throw new Exception('cannot make dir: ' . $f); } } return true; } /** *    * @param string $f       * @return array */ public static function getIndex($f) { $index = array(); if (file_exists($f . '/.index')) { $_ = file($f . '/.index'); foreach ($_ as $_i) { $row = trim($_i); $row = explode('|', $row); array_walk($row, 'trim'); $rid = $row[0]; $index[$rid] = $row; } } return $index; } /** *    * @param string $f       * @param array $index    * @return bool */ public static function setIndex($f, array $index) { $_ = array(); foreach ($index as $row) { $_[] = implode('|', $row); } return file_put_contents($f . '/.index', implode("\r\n", $_)); } /** *   * @param string $group   (. ) * @param int $value   * @return bool */ public static function granted($group, $value=0) { $groups = array('anonimous', 'user', 'manager', 'admin', 'inactive', 'blocked', 'deleted'); if ($group == 'root') { return true; } foreach ($groups as $groupID => $groupName) { if ($groupName == $group) { return (((1 << $groupID) & $value) != 0); } } return false; } }

कुछ बिंदुओं पर विचार करें:

- realRoot - फाइल सिस्टम के साथ फ़ोल्डर का पूरा पथ एक स्लैश में समाप्त होता है।
- वेबरूट - एक प्रमुख स्लैश के बिना साइट की जड़ से पथ (नीचे देखें क्यों)।
- DBMS के रूप में, मैं MySQLi एक्सटेंशन का उपयोग करता हूं।
- वास्तव में, $ _FILES सरणी से जानकारी अपलोड विधि के पहले तर्क के रूप में पारित की जाती है।
- यदि आप किसी मौजूदा फ़ाइल की आईडी पास करने के लिए अपडेट विधि को कॉल करते हैं, तो इसे बदल दिया जाएगा यदि tmp_name में इनपुट सरणी खाली नहीं है।
- आप एक बार में कई बार फाइलों के झंडे हटा सकते हैं और बदल सकते हैं। ऐसा करने के लिए, फ़ाइल पहचानकर्ता को पास करने के बजाय, आपको पहचानकर्ताओं के साथ या तो एक सरणी पास करनी चाहिए, या उनके साथ एक स्ट्रिंग, अल्पविराम द्वारा अलग किया जाना चाहिए।

मार्ग

वास्तव में, यह साइट के रूट में htaccess की कुछ लाइनों के नीचे आता है (यह माना जाता है कि mod_rewrite सक्षम है):

 RewriteCond %{REQUEST_URI} ^/content/(.*)$ RewriteCond %{REQUEST_FILENAME} !-f RewriteRule ^(.+)$ content/index.php?file=$1 [L,QSA]

"सामग्री" मेरे मामले में साइट की जड़ में फ़ोल्डर है। बेशक आप फ़ोल्डर को अलग नाम दे सकते हैं। और निश्चित ही index.php, सामग्री फ़ोल्डर में मेरे मामले में संग्रहीत:

 <?php $dbHost = '127.0.0.1'; $dbUser = 'user'; $dbPass = '****'; $dbName = 'database'; try { if (empty($_REQUEST['file'])) { header('HTTP/1.1 400 Bad Request'); exit; } $userG = 'anonimous'; //      ;      $files = new BigFiles(new mysqli($dbHost,$dbUser,$dbPass,$dbName)); $files->realRoot(dirname(__FILE__).'/files/'); $files->read($_REQUEST['file'],$userG); } catch (Exception $e) { header('HTTP/1.1 500 Internal Error'); header('Content-Type: text/plain; charset=utf-8'); echo $e->getMessage(); exit; }

खैर, अपने आप ही, हम फ़ाइल सिस्टम को बाहरी एक्सेस से ही बंद कर देते हैं। केवल एक पंक्ति के साथ content/files फ़ोल्डर content/files जड़ में .htaccess फ़ाइल रखें:

 Deny from all

परिणाम

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

बड़ी संख्या में फ़ाइलों का संग्रहण

सिद्धांत

डेटाबेस में तालिका

डिस्पैचर क्लास

मार्ग

परिणाम

More articles: