Цел на системата
Поддръжка за отдалечен достъп до файлове на компютри в мрежата. Системата “виртуално” поддържа всички основни файлови операции (създаване, изтриване, четене, запис и т.н.) чрез обмен на транзакции (съобщения) с помощта на TCP протокола.
приложения
Функционалността на системата е ефективна в следните случаи:
- в нативни приложения за мобилни и вградени устройства (смартфони, бордови системи за управление и др.), които изискват бърз достъп до файлове на отдалечени сървъри при възможни временни прекъсвания на комуникацията (с излизане офлайн);
- в заредени СУБД, ако обработката на заявки се извършва на някои сървъри, а съхранението на данни се извършва на други;
- в разпределени корпоративни мрежи за събиране и обработка на информация, изискващи висока скорост на обмен на данни, резервираност и надеждност;
- в сложни системи с микросервизна архитектура, където закъсненията в обмена на информация между модулите са критични.
Структура
Системата Cage (има реализация - бета версия в Python 3.7 на Windows) включва две основни части:
- Cageserver — програма за файлов сървър (пакет от функции), която работи на компютри в мрежата, чиито файлове изискват отдалечен достъп;
- клас Клетка с библиотека от методи за клиентски софтуер, опростяваща кодирането на взаимодействието със сървърите.
Използване на системата от страна на клиента
Методите на класа Cage заместват обичайните, „рутинни“ операции на файловата система: създаване, отваряне, затваряне, изтриване файлове, както и четене/запис на данни в двоичен формат (посочвайки позицията и размера на данните). Концептуално тези методи са близки до файловите функции на езика C, където отварянето/затварянето на файлове се извършва „по канали” на вход/изход.
С други думи, програмистът не работи с методи на „файлови“ обекти (клас _io в Python), но с методи от класа Cage.
Когато се създаде екземпляр на обект Cage, той установява първоначална връзка със сървър (или няколко сървъра), упълномощава се от клиентския идентификатор и получава потвърждение със специален номер на порт за всички файлови операции. Когато обект Cage бъде изтрит, той инструктира сървъра да спре комуникацията и да затвори файловете. Прекратяването на комуникацията може да бъде инициирано и от самите сървъри.
Системата подобрява производителността при четене/запис чрез буфериране на често използвани файлови фрагменти на клиентски програми в RAM кеша (буфер).
Клиентският софтуер може да използва произволен брой Cage обекти с различни настройки (размер на буферната памет, размер на блока при обмен със сървъра и т.н.).
Един обект на Cage може да комуникира с множество файлове на множество сървъри. Комуникационните параметри (IP адрес или DNS сървър, основен порт за оторизация, път и име на файл) се посочват при създаване на обекта.
Тъй като всеки обект на Cage може да работи с множество файлове едновременно, споделеното пространство в паметта се използва за буфериране. Размер на кеша – броят на страниците и техният размер се задават динамично при създаване на обект Cage. Например 1 GB кеш е 1000 страници по 1 MB всяка, или 10 хиляди страници по 100 KB всяка, или 1 милион страници по 1 KB всяка. Изборът на размер и брой страници е специфична задача за всеки случай на приложение.
Можете да използвате няколко обекта на Cage едновременно, за да дефинирате различни настройки на буферната памет в зависимост от начина на достъп до информацията в различните файлове. Като основен се използва най-простият алгоритъм за буфериране: след изчерпване на дадено количество памет новите страници изместват старите според принципа на пенсиониране с минимален брой достъпи. Буферирането е особено ефективно в случай на неравномерен (в статистически смисъл) споделен достъп, първо, до различни файлове и, второ, до фрагменти от всеки файл.
Класът Cage поддържа I/O не само чрез адреси на данни (посочващи позицията и дължината на масива, „заместващи“ операции на файловата система), но и на по-ниско, „физическо“ ниво - чрез номера на страници в буферната памет.
Оригиналната функция се поддържа за обекти Cage "хибернация" („заспиване“) - те могат да бъдат „свити“ (например в случай на загуба на връзка със сървъри или когато приложението е спряно и т.н.) в локален дъмп файл от страна на клиента и бързо възстановени от този файл (след възобновяване на комуникацията, когато рестартирате приложението). Това прави възможно значително намаляване на трафика при активиране на клиентската програма след временно излизане „офлайн“, тъй като често използваните файлови фрагменти вече ще бъдат в кеша.
Cage е около 3600 реда код.
Принципи на изграждане на сървър
Файловите сървъри на Cageserver могат да се изпълняват с произволен брой портове, един от които („главен“) се използва само за оторизация на всички клиенти, останалите се използват за обмен на данни. Сървърната програма Cage изисква само Python. Успоредно с това компютърът с файловия сървър може да изпълнява всяка друга работа.
Първоначално сървърът стартира като съвкупност от два основни процеса:
- "Връзки" – процес за извършване на операциите по установяване на комуникация с клиенти и прекратяването й по инициатива на сървъра;
- "Операции" – процес за изпълнение на задачи (операции) на клиенти за работа с файлове, както и за затваряне на комуникационни сесии въз основа на клиентски команди.
И двата процеса не са синхронизирани и са организирани като безкрайни цикли на получаване и изпращане на съобщения въз основа на многопроцесни опашки, прокси обекти, ключалки и сокети.
Процесът на свързване разпределя порт за всеки клиент за получаване и предаване на данни. Броят на портовете се задава при стартиране на сървъра. Съпоставянето между портове и клиенти се съхранява в споделена междупроцесна прокси памет.
Операционният процес поддържа споделяне на файлови ресурси, така че множество различни клиенти да могат да споделят (квазипаралелен, тъй като достъпът се контролира от ключалки) чете данни от един файл, ако това е било разрешено при първоначалното му отваряне от "първия" клиент.
Обработката на команди за създаване/изтриване/отваряне/затваряне на файлове на сървъра се извършва в самия процес „Операции” строго последователно с помощта на файловата подсистема на сървърната ОС.
За да се ускори като цяло четенето/записът, тези операции се извършват в нишки, породени от процеса „Операции“. Броят на нишките обикновено е равен на броя на отворените файлове. Задачите за четене/запис от клиенти се изпращат към общата опашка и първата свободна нишка поема задачата от главата си. Специалната логика ви позволява да елиминирате операциите по пренаписване на данни в RAM паметта на сървъра.
Операционният процес следи дейността на клиента и спира да ги обслужва или по техни команди, или когато времето за изчакване на неактивност е превишено.
За да гарантира надеждност, Cageserver поддържа регистрационни файлове на всички транзакции. Един общ дневник съдържа копия на съобщения от клиенти със задачи за създаване/отваряне/преименуване/изтриване на файлове. За всеки работен файл се създава отделен журнал, в който се записват копия на съобщения със задачи за четене и запис на данни в този работен файл, както и масиви от записани (нови) данни и масиви от данни, които са били унищожени при презаписване (запис нови данни „върху“ старите). ).
Тези регистрационни файлове предоставят възможност както за възстановяване на нови промени в архивите, така и за връщане назад на текущото съдържание до точка в миналото.
Cageserver е около 3100 реда код.
Стартиране на програмата за файлов сървър Cageserver
Когато стартирате, трябва да дефинирате в диалоговия прозорец:
— основно пристанище за разрешение;
— броя на портовете за обмен на транзакции с оторизирани клиенти (от 1 или повече, наборът от числа започва от този до основния номер на порта).
Използване на Cage Class
клас клетка.Клетка( cage_name="", pagesize=0, numpages=0, maxstrlen=0, server_ip={}, wait=0, awake=False, cache_file="" )
От този клас се създават обекти, които взаимодействат с файлови сървъри и съдържат буферна памет.
Параметри
- име_на_клетка(ул.) - условно име на обекта, което се използва за идентифициране на клиенти от страна на сървъра
- размер на страницата(Int) — размер на една страница от буферната памет (в байтове)
- числа(Int) — брой страници на буферната памет
- maxstrlen(Int) - максималната дължина на байтов низ при операции за запис и четене
- server_ip(Dict) - речник с адресите на използваните сървъри, където ключът е условното име на сървъра (id на сървъра вътре в приложението), а стойността е низ с адреса: “ip адрес:порт” или “DNS: порт” (сравняването на имена и реални адреси е временно, може да се променя)
- чакам(Int) — време за изчакване на отговор от сървъра при получаване на портове (в секунди)
- буден(булева) — флаг за това как е създаден обектът (Фалшив - ако се създаде нов обект, Вярно - ако даден обект е създаден от преди това "свит" - използвайки операцията "хибернация", False по подразбиране)
- кеш_файл(ул.) - име на файл за хибернация
методи
Клетка.file_create( сървър, път ) – създаване на нов файл
Клетка.file_rename( сървър, път, ново_име ) – преименуване на файла
Клетка.file_remove( сървър, път) - изтриване на файл
Клетка.отворен( сървър, път, мод ) - отворете файла
Се завръща fchannel номер на канал. Параметър моден — това е режимът на отваряне на файла: „wm“ — изключителен (четене/запис), „rs“ — само за четене и споделен само за четене от други клиенти, „ws“ — четене/запис и споделен само за четене- само от други клиенти.
Клетка.близо (fchannel) – затворете файла
Клетка.пиша (fchannel, начало, данни ) – запис на байтов низ във файл
Клетка.чета (fchannel, начало, len_data ) – чете байтов низ от файл
Клетка.put_pages ( fchannel ) – „избутва“ от буфера към сървъра всички страници от посочения канал, които са били променени. Използва се в онези моменти от алгоритъма, когато трябва да сте сигурни, че всички операции в канала са физически записани във файл на сървъра.
Клетка.push_all () – „избутва“ от буфера към сървъра всички страници от всички канали за екземпляр от класа Cage, които са били модифицирани. Използва се, когато трябва да сте сигурни, че всички операции на всички канали са запазени на сървъра.
Източник: www.habr.com