Cage დისტანციური ფაილების წვდომის სისტემა

სისტემის დანიშნულება

ქსელში არსებული კომპიუტერების ფაილებზე დისტანციური წვდომის მხარდაჭერა. სისტემა „ვირტუალურად“ მხარს უჭერს ფაილების ყველა ძირითად ოპერაციას (შექმნა, წაშლა, კითხვა, ჩაწერა და ა.შ.) ტრანზაქციების (შეტყობინებების) გაცვლის გზით TCP პროტოკოლის გამოყენებით.

პროგრამები

სისტემის ფუნქციონირება ეფექტურია შემდეგ შემთხვევებში:

• მობილური და ჩაშენებული მოწყობილობების მშობლიურ აპლიკაციებში (სმარტფონები, ბორტ კონტროლის სისტემები და ა.შ.), რომლებიც საჭიროებენ სწრაფ წვდომას დისტანციურ სერვერებზე არსებულ ფაილებზე კომუნიკაციაში შესაძლო დროებითი შეფერხებების ფონზე (ხაზგარეშე გასვლისას);
• დატვირთულ DBMS-ებში, თუ შეკითხვის დამუშავება ხორციელდება ზოგიერთ სერვერზე, ხოლო მონაცემების შენახვა ხორციელდება ზოგიერთ სერვერზე;
• განაწილებულ კორპორატიულ ქსელებში ინფორმაციის შეგროვებისა და დამუშავებისთვის, რაც მოითხოვს მონაცემთა მაღალი სიჩქარით გაცვლას, ზედმეტობას და საიმედოობას;
• მიკროსერვისის არქიტექტურის კომპლექსურ სისტემებში, სადაც მოდულებს შორის ინფორმაციის გაცვლის შეფერხება კრიტიკულია.

სტრუქტურა

Cage სისტემა (არსებობს დანერგვა - ბეტა ვერსია Python 3.7-ში Windows-ზე) მოიცავს ორ ძირითად ნაწილს:

1. კეიჯსერვერი — ფაილების სერვერის პროგრამა (ფუნქციების პაკეტი), რომელიც მუშაობს ქსელის კომპიუტერებზე, რომელთა ფაილები საჭიროებენ დისტანციურ წვდომას;
2. კლასი Cage კლიენტის პროგრამული უზრუნველყოფის მეთოდების ბიბლიოთეკით, სერვერებთან ურთიერთქმედების კოდირების გამარტივებით.

სისტემის გამოყენება კლიენტის მხარეს

Cage კლასის მეთოდები ცვლის ჩვეულებრივი, "რუტინული" ფაილური სისტემის ოპერაციებს: შექმნა, გახსნა, დახურვა, წაშლა ფაილები, ასევე მონაცემების კითხვა/ჩაწერა ბინარულ ფორმატში (მონაცემების პოზიციისა და ზომის მითითებით). კონცეპტუალურად, ეს მეთოდები ახლოსაა C ენის ფაილურ ფუნქციებთან, სადაც ფაილების გახსნა/დახურვა ხდება შეყვანის/გამოსვლის „არხებზე“.

სხვა სიტყვებით რომ ვთქვათ, პროგრამისტი არ მუშაობს "ფაილის" ობიექტების მეთოდებთან (კლას _იო პითონში), მაგრამ Cage კლასის მეთოდებით.

როდესაც იქმნება Cage ობიექტის ეგზემპლარი, ის ამყარებს თავდაპირველ კავშირს სერვერთან (ან რამდენიმე სერვერთან), ავტორიზებულია კლიენტის ID-ით და იღებს დადასტურებას გამოყოფილი პორტის ნომრით ყველა ფაილის ოპერაციისთვის. როდესაც 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-ს. პარალელურად, ფაილ სერვერის მქონე კომპიუტერს შეუძლია შეასრულოს ნებისმიერი სხვა სამუშაო.

სერვერი თავდაპირველად იწყება, როგორც ორი ძირითადი პროცესის კოლექცია:

1. "კავშირები" – კლიენტებთან კომუნიკაციის დამყარებისა და სერვერის ინიციატივით შეწყვეტის ოპერაციების შესრულების პროცესი;
2. "Ოპერაციები" – კლიენტების დავალებების (ოპერაციების) შესრულების პროცესი ფაილებთან მუშაობისთვის, ასევე კლიენტის ბრძანებების საფუძველზე საკომუნიკაციო სესიების დახურვისთვის.

ორივე პროცესი არ არის სინქრონიზებული და ორგანიზებულია როგორც შეტყობინებების მიღებისა და გაგზავნის გაუთავებელი მარყუჟები, რომლებიც დაფუძნებულია მრავალპროცესის რიგებზე, პროქსი ობიექტებზე, საკეტებსა და სოკეტებზე.
კავშირის პროცესი თითოეულ კლიენტს გამოყოფს პორტს მონაცემების მისაღებად და გადასაცემად. პორტების რაოდენობა დგინდება სერვერის გაშვებისას. პორტებსა და კლიენტებს შორის რუკების შენახვა ინახება ინტერპროცესის გაზიარებულ პროქსი მეხსიერებაში.

ოპერაციების პროცესი მხარს უჭერს ფაილური რესურსების გაზიარებას ისე, რომ რამდენიმე სხვადასხვა კლიენტმა შეძლოს გაზიარება (კვაზიპარალელური, რადგან წვდომა კონტროლდება საკეტებით) წაიკითხეთ მონაცემები ერთი ფაილიდან, თუ ეს დაშვებული იყო, როდესაც ის თავდაპირველად გახსნა "პირველმა" კლიენტმა.

სერვერზე ფაილების შექმნის/წაშლის/გახსნის/დახურვის ბრძანებების დამუშავება ხორციელდება თავად “ოპერაციების” პროცესში მკაცრად თანმიმდევრულად სერვერის OS-ის ფაილური ქვესისტემის გამოყენებით.

ზოგადად კითხვის/წერის დასაჩქარებლად, ეს ოპერაციები შესრულებულია ძაფებში, რომლებიც წარმოიქმნება "ოპერაციების" პროცესით. ძაფების რაოდენობა ჩვეულებრივ უდრის ღია ფაილების რაოდენობას. კლიენტებისგან წაკითხვა/ჩაწერა ამოცანები გადაეცემა გენერალურ რიგში და პირველი უფასო თემა ამოიღებს დავალებას მისი თავიდან. სპეციალური ლოგიკა საშუალებას გაძლევთ აღმოფხვრათ მონაცემთა გადაწერის ოპერაციები სერვერის RAM-ში.

ოპერაციების პროცესი მონიტორინგს უწევს კლიენტის აქტივობას და აჩერებს მათ მომსახურებას მათი ბრძანებების საფუძველზე ან უმოქმედობის ვადის გადაჭარბების შემთხვევაში.

სანდოობის უზრუნველსაყოფად, Cageserver ინახავს ყველა ტრანზაქციის ჟურნალს. ერთი ზოგადი ჟურნალი შეიცავს კლიენტების შეტყობინებების ასლებს ფაილების შექმნა/გახსნა/გადარქმევა/წაშლა. თითოეული სამუშაო ფაილისთვის იქმნება ცალკე ჟურნალი, რომელშიც ჩაწერილია შეტყობინებების ასლები ამ სამუშაო ფაილში მონაცემების წაკითხვისა და ჩაწერის ამოცანებით, აგრეთვე ჩაწერილი (ახალი) მონაცემების მასივები და მონაცემთა მასივები, რომლებიც განადგურდა გადაწერის დროს (ჩაწერა). ახალი მონაცემები ძველის „ზევით“). ).

ეს ჟურნალები იძლევა შესაძლებლობას აღადგინოთ ახალი ცვლილებები სარეზერვო ასლებში და დააბრუნოთ მიმდინარე შინაარსი წარსულში.

Cageserver არის დაახლოებით 3100 ხაზი კოდი.

Cageserver ფაილის სერვერის პროგრამის გაშვება

დაწყებისას, დიალოგში თქვენ უნდა განსაზღვროთ:
— მთავარი პორტი ავტორიზაციისთვის;
- ავტორიზებულ კლიენტებთან ტრანზაქციის გაცვლის პორტების რაოდენობა (1 ან მეტიდან, ნომრების კრებული იწყება მთავარი პორტის ნომრის გვერდით).

გალიის კლასის გამოყენება

კლასი გალიაში.Cage( cage_name="", pagesize=0, numpages=0, maxstrlen=0, server_ip={}, wake=0, awake=false, cache_file="" )

ამ კლასიდან იქმნება ობიექტები, რომლებიც ურთიერთქმედებენ ფაილურ სერვერებთან და შეიცავს ბუფერულ მეხსიერებას.

პარამეტრები

• გალიის_სახელი(ქ) - ობიექტის პირობითი სახელი, რომელიც გამოიყენება სერვერის მხარეს კლიენტების იდენტიფიცირებისთვის
• გვერდის ზომა(int) — ბუფერული მეხსიერების ერთი გვერდის ზომა (ბაიტებში)
• ნუმპაჟები(int) — ბუფერული მეხსიერების გვერდების რაოდენობა
• maxstrlen(int) - ბაიტის სტრიქონის მაქსიმალური სიგრძე ჩაწერისა და წაკითხვის ოპერაციებში
• server_ip(უკარნახოს) - ლექსიკონი გამოყენებული სერვერების მისამართებით, სადაც გასაღები არის სერვერის პირობითი სახელი (სერვერის ID აპლიკაციის შიგნით), ხოლო მნიშვნელობა არის სტრიქონი მისამართით: "ip address:port" ან "DNS: პორტი“ (სახელების და რეალური მისამართების შედარება დროებითია, შეიძლება შეიცვალოს)
• დაველოდოთ(int) — სერვერის პასუხის მოლოდინის დრო პორტების მიღებისას (წამებში)
• Awake(ლოგიკური) - დროშა, თუ როგორ იქმნება ობიექტი (ყალბი - თუ შეიქმნა ახალი ობიექტი, True - თუ ობიექტი იქმნება ადრე "ჩამოშლილი" ობიექტიდან - "ჰიბერნაციის" ოპერაციით, ნაგულისხმევად False)
• ქეში_ფაილი(ქ) - ფაილის სახელი ჰიბერნაციისთვის

მეთოდები

კეიჯი.ფაილის_შექმნა( სერვერი, გზა ) – შექმენით ახალი ფაილი

კეიჯი.ფაილის_გადარქმევა( სერვერი, გზა, ახალი_სახელი ) – გადარქმევა ფაილი

კეიჯი.file_remove( სერვერი, გზა) - ფაილის წაშლა

კეიჯი.გახსნა( სერვერი, გზა, მოდიფიკაცია ) - გახსენი ფაილი

ბრუნდება f არხი არხის ნომერი. Პარამეტრი თავდაცვის სამინისტრო - ეს არის ფაილის გახსნის რეჟიმი: "wm" - ექსკლუზიური (წაკითხვა/ჩაწერა), "rs" - მხოლოდ წასაკითხად და გაზიარებული მხოლოდ სხვა კლიენტებისთვის წასაკითხად, "ws" - წაკითხვა/ჩაწერა და გაზიარებული მხოლოდ წაკითხვისთვის. სხვა კლიენტებს.

კეიჯი.ახლოს (f არხი) – დახურეთ ფაილი

კეიჯი.დაწერა (fchannel, დასაწყისი, მონაცემები ) – ჩაწერეთ ბაიტის სტრიქონი ფაილში

კეიჯი.წაკითხული (fchannel, დასაწყისი, len_data ) – წაიკითხეთ ბაიტის სტრიქონი ფაილიდან

კეიჯი.put_pages ( f არხი ) – „უბიძგებს“ ბუფერიდან სერვერზე მითითებული არხის ყველა შეცვლილ გვერდს. იგი გამოიყენება ალგორითმის იმ წერტილებში, როდესაც უნდა დარწმუნდეთ, რომ არხზე ყველა ოპერაცია ფიზიკურად ინახება სერვერზე არსებულ ფაილში.

კეიჯი.push_all () – „უბიძგებს“ ბუფერიდან სერვერზე ყველა არხის ყველა გვერდს, მაგალითად, Cage კლასის, რომელიც შეცვლილია. გამოიყენება მაშინ, როდესაც უნდა დარწმუნდეთ, რომ ყველა არხზე ყველა ოპერაცია შენახულია სერვერზე.

წყარო: www.habr.com