Համակարգի նպատակը
Աջակցություն ցանցում գտնվող համակարգիչների վրա ֆայլերի հեռակա մուտքի համար: Համակարգը «վիրտուալ» աջակցում է ֆայլի բոլոր հիմնական գործողություններին (ստեղծում, ջնջում, ընթերցում, գրում և այլն)՝ փոխանակելով գործարքներ (հաղորդագրություններ) TCP արձանագրության միջոցով:
Դիմումները
Համակարգի ֆունկցիոնալությունը արդյունավետ է հետևյալ դեպքերում.
- շարժական և ներկառուցված սարքերի (սմարթֆոններ, ներկառուցված կառավարման համակարգեր և այլն) բնիկ հավելվածներում, որոնք պահանջում են արագ մուտք դեպի հեռավոր սերվերների ֆայլեր՝ հաղորդակցության հնարավոր ժամանակավոր ընդհատումների դեպքում (անցանց ռեժիմում);
- բեռնված DBMS-ներում, եթե հարցումների մշակումն իրականացվում է որոշ սերվերների վրա, իսկ տվյալների պահպանումն իրականացվում է մյուսների վրա.
- բաշխված կորպորատիվ ցանցերում տեղեկատվության հավաքման և մշակման համար, որոնք պահանջում են տվյալների բարձր արագության փոխանակում, ավելորդություն և հուսալիություն.
- միկրոսերվիսային ճարտարապետությամբ բարդ համակարգերում, որտեղ մոդուլների միջև տեղեկատվության փոխանակման հետաձգումները կարևոր են:
Կառուցվածք
Cage համակարգ (կա իրականացում՝ բետա տարբերակ Python 3.7-ում օպերացիոն համակարգում) Windows) ներառում է երկու հիմնական մաս՝
- Cageserver — ֆայլերի սերվերի ծրագիր (գործառույթների փաթեթ), որն աշխատում է ցանցի համակարգիչների վրա, որոնց ֆայլերը պահանջում են հեռավոր մուտք.
- դաս Վանդակ հաճախորդի ծրագրային ապահովման մեթոդների գրադարանով, պարզեցնելով սերվերների հետ փոխգործակցության կոդավորումը:
Օգտագործելով համակարգը հաճախորդի կողմից
Cage դասի մեթոդները փոխարինում են սովորական, «սովորական» ֆայլային համակարգի գործողությունները. ստեղծում, բացում, փակում, ջնջում ֆայլեր, ինչպես նաև տվյալների ընթերցում/գրում երկուական ձևաչափով (նշելով տվյալների դիրքը և չափը): Հայեցակարգային առումով այս մեթոդները մոտ են C լեզվի ֆայլային ֆունկցիաներին, որտեղ ֆայլերի բացումը/փակումը կատարվում է մուտքի/ելքի «ալիքների վրա»:
Այլ կերպ ասած, ծրագրավորողը չի աշխատում «ֆայլի» օբյեկտների մեթոդներով (դաս _io Python-ում), բայց Cage դասի մեթոդներով։
Երբ ստեղծվում է Cage օբյեկտի օրինակ, այն սկզբնական կապ է հաստատում սերվերի (կամ մի քանի սերվերների) հետ, լիազորված է Client Id-ի կողմից և ստանում է հաստատում հատուկ պորտի համարով բոլոր ֆայլերի գործողությունների համար: Երբ Cage օբյեկտը ջնջվում է, այն հրահանգում է սերվերին դադարեցնել հաղորդակցությունը և փակել ֆայլերը: Կապի դադարեցումը կարող է նախաձեռնվել նաև հենց սերվերների կողմից:
Համակարգը բարելավում է կարդալու/գրելու աշխատանքը՝ հաճախորդի ծրագրերի հաճախ օգտագործվող ֆայլերի բեկորները բուֆերավորելով RAM-ի քեշում (բուֆեր):
Հաճախորդի ծրագրակազմը կարող է օգտագործել ցանկացած քանակությամբ Cage օբյեկտներ տարբեր կարգավորումներով (բուֆերային հիշողության չափ, բլոկի չափ սերվերի հետ փոխանակելիս և այլն):
Մեկ Cage օբյեկտը կարող է շփվել մի քանի ֆայլերի հետ մի քանի սերվերների վրա: Օբյեկտը ստեղծելիս նշվում են հաղորդակցման պարամետրերը (IP հասցե կամ DNS սերվեր, թույլտվության հիմնական պորտ, ուղի և ֆայլի անվանումը):
Քանի որ Cage-ի յուրաքանչյուր օբյեկտ կարող է միաժամանակ աշխատել մի քանի ֆայլերի հետ, ընդհանուր հիշողության տարածությունն օգտագործվում է բուֆերացման համար: Քեշի չափը – էջերի քանակը և դրանց չափը, դինամիկ կերպով սահմանվում է Cage օբյեկտ ստեղծելիս: Օրինակ, 1 ԳԲ քեշը կազմում է 1000 էջ՝ յուրաքանչյուրը 1 ՄԲ, կամ 10 հազար էջ՝ յուրաքանչյուրը 100 ԿԲ, կամ 1 միլիոն էջ՝ յուրաքանչյուրը 1 ԿԲ: Էջերի չափի և քանակի ընտրությունը հատուկ խնդիր է յուրաքանչյուր դիմումի դեպքի համար:
Դուք կարող եք օգտագործել մի քանի Cage օբյեկտներ միաժամանակ՝ տարբեր բուֆերային հիշողության կարգավորումներ սահմանելու համար՝ կախված այն բանից, թե ինչպես է տեղեկատվության հասանելիությունը տարբեր ֆայլերում: Որպես հիմնական, օգտագործվում է ամենապարզ բուֆերային ալգորիթմը. հիշողության որոշակի քանակի սպառվելուց հետո նոր էջերը տեղահանում են հինները՝ ըստ կենսաթոշակի սկզբունքի՝ նվազագույն մուտքերի քանակով: Բուֆերավորումը հատկապես արդյունավետ է անհավասար (վիճակագրական իմաստով) ընդհանուր հասանելիության դեպքում, նախ՝ տարբեր ֆայլեր, և երկրորդ՝ յուրաքանչյուր ֆայլի հատվածներ։
Cage դասը աջակցում է I/O ոչ միայն տվյալների հասցեներով (նշելով զանգվածի դիրքը և երկարությունը, ֆայլային համակարգի «փոխարինող» գործառնությունները), այլև ավելի ցածր, «ֆիզիկական» մակարդակում՝ բուֆերային հիշողության մեջ էջերի համարներով:
Բնօրինակ գործառույթը աջակցվում է Cage օբյեկտների համար «ձմեռում» («քուն») - դրանք կարող են «փլուզվել» (օրինակ՝ սերվերների հետ կապի կորստի դեպքում, կամ երբ հավելվածը դադարեցվում է և այլն) հաճախորդի կողմում գտնվող տեղական աղբանոց ֆայլի մեջ և արագ վերականգնվել այնտեղից։ այս ֆայլը (հաղորդակցությունը վերսկսելուց հետո, երբ վերագործարկեք հավելվածը): Սա հնարավորություն է տալիս զգալիորեն նվազեցնել երթևեկությունը հաճախորդի ծրագիրը ժամանակավորապես «օֆլայն» անցնելուց հետո ակտիվացնելիս, քանի որ հաճախ օգտագործվող ֆայլի բեկորներն արդեն կլինեն քեշում:
Cage-ը մոտավորապես 3600 տող կոդ է:
Սերվերի կառուցման սկզբունքները
Cageserver ֆայլերի սերվերները կարող են գործարկվել կամայական թվով նավահանգիստներով, որոնցից մեկը («հիմնականը») օգտագործվում է միայն բոլոր հաճախորդների թույլտվության համար, մնացածը օգտագործվում են տվյալների փոխանակման համար: Cage սերվերի ծրագիրը պահանջում է միայն Python: Զուգահեռաբար ֆայլերի սերվերով համակարգիչը կարող է կատարել ցանկացած այլ աշխատանք։
Սերվերը սկզբում սկսվում է որպես երկու հիմնական գործընթացների հավաքածու.
- «Միացումներ» – հաճախորդների հետ կապ հաստատելու և սերվերի նախաձեռնությամբ այն դադարեցնելու գործողությունների կատարման գործընթաց.
- «Գործողություններ» – ֆայլերի հետ աշխատելու հաճախորդների առաջադրանքների (գործառնությունների) կատարման գործընթաց, ինչպես նաև հաճախորդի հրամանների հիման վրա հաղորդակցման նիստերը փակելու համար:
Երկու գործընթացներն էլ համաժամանակացված չեն և կազմակերպվում են որպես հաղորդագրություններ ստանալու և ուղարկելու անվերջ օղակներ՝ հիմնված բազմապրոցեսային հերթերի, պրոքսի օբյեկտների, կողպեքների և վարդակների վրա:
Միացման գործընթացը յուրաքանչյուր հաճախորդի համար հատկացնում է մի նավահանգիստ՝ տվյալներ ստանալու և փոխանցելու համար: Նավահանգիստների թիվը սահմանվում է սերվերի գործարկման ժամանակ: Նավահանգիստների և սպասառուների միջև քարտեզագրումը պահվում է միջգործընթացային համօգտագործվող պրոքսի հիշողության մեջ:
Գործառնությունների գործընթացն աջակցում է ֆայլերի ռեսուրսների փոխանակմանը, որպեսզի մի քանի տարբեր հաճախորդներ կարողանան կիսվել (քվազի զուգահեռ, քանի որ մուտքը վերահսկվում է կողպեքներով) կարդալ տվյալները մեկ ֆայլից, եթե դա թույլատրված էր, երբ այն սկզբում բացվեց «առաջին» հաճախորդի կողմից:
Ֆայլեր ստեղծելու/ջնջելու/բացելու/փակելու հրամանների մշակում սերվեր իրականացվում է «Գործողություն» գործընթացում, խստորեն հաջորդաբար օգտագործելով սերվերի ՕՀ-ի ֆայլային ենթահամակարգը:
Ընդհանուր առմամբ կարդալը/գրելը արագացնելու համար այս գործողությունները կատարվում են «Գործողություններ» գործընթացի արդյունքում առաջացած թելերով: Թելերի քանակը սովորաբար հավասար է բաց ֆայլերի թվին: Հաճախորդներից կարդալ/գրել առաջադրանքները ներկայացվում են ընդհանուր հերթին և առաջին անվճար շարանը վերցնում է առաջադրանքը գլխից: Հատուկ տրամաբանությունը թույլ է տալիս վերացնել տվյալների վերագրանցման գործողությունները սերվերի RAM-ում:
Գործառնությունների գործընթացը վերահսկում է հաճախորդի գործունեությունը և դադարեցնում է նրանց սպասարկումը կամ նրանց հրամանների հիման վրա, կամ երբ անգործության ժամկետը գերազանցում է:
Հուսալիությունն ապահովելու համար Cageserver-ը պահում է բոլոր գործարքների մատյանները: Մեկ ընդհանուր մատյան պարունակում է հաճախորդների հաղորդագրությունների պատճեններ՝ ֆայլեր ստեղծելու/բացելու/վերանվանելու/ջնջելու առաջադրանքներով: Յուրաքանչյուր աշխատանքային ֆայլի համար ստեղծվում է առանձին տեղեկամատյան, որում գրանցվում են հաղորդագրությունների պատճենները՝ այս աշխատանքային ֆայլում տվյալների կարդալու և գրելու առաջադրանքներով, ինչպես նաև գրված (նոր) տվյալների զանգվածներ և տվյալների զանգվածներ, որոնք ոչնչացվել են վերագրանցման (գրելու) ժամանակ։ նոր տվյալներ «վերևում» հինների վրա):
Այս տեղեկամատյանները հնարավորություն են տալիս ինչպես վերականգնելու նոր փոփոխությունները կրկնօրինակումներում, այնպես էլ ընթացիկ բովանդակությունը հետ բերելու անցյալի մի կետ:
Cageserver-ը մոտավորապես 3100 տող կոդ է:
Cageserver ֆայլերի սերվերի ծրագրի գործարկումը
Սկսելիս երկխոսության մեջ դուք պետք է սահմանեք.
- հիմնական նավահանգիստը թույլտվության համար.
— լիազորված հաճախորդների հետ գործարքների փոխանակման նավահանգիստների քանակը (1-ից և ավելի թվերի ֆոնդը սկսվում է հիմնական պորտի համարի կողքին գտնվողից):
Օգտագործելով վանդակի դասը
դաս վանդակՎանդակ( cage_name="", pagesize=0, numpages=0, maxstrlen=0, server_ip={}, wait=0, awake=False, cache_file="" )
Այս դասից ստեղծվում են օբյեկտներ, որոնք փոխազդում են ֆայլային սերվերների հետ և պարունակում են բուֆերային հիշողություն:
Պարամետրեր
- վանդակի_անուն(փող) - օբյեկտի պայմանական անվանումը, որն օգտագործվում է սերվերի կողմից հաճախորդները նույնականացնելու համար
- էջի չափը(int) - բուֆերային հիշողության մեկ էջի չափը (բայթերով)
- numpages(int) - բուֆերային հիշողության էջերի քանակը
- maxstrlen(int) - բայթ տողի առավելագույն երկարությունը գրելու և կարդալու գործողություններում
- server_ip(թելադրել) - օգտագործված հասցեներով բառարան սերվերներ, որտեղ բանալին սերվերի պայմանական անունն է (ծրագրի ներսում գտնվող սերվերի ID-ն), իսկ արժեքը տող է՝ «ip address:port» կամ «DNS:port» հասցեով (անունների և իրական հասցեների համապատասխանեցումը ժամանակավոր է և կարող է փոխվել):
- սպասել(int) — սերվերից պատասխանի սպասման ժամանակ նավահանգիստներ ստանալիս (վայրկյաններով)
- արթուն(բուլյան) - դրոշակ, թե ինչպես է ստեղծվում օբյեկտը (Կեղծ - եթե ստեղծվում է նոր օբյեկտ, Ճիշտ - եթե օբյեկտը ստեղծվել է նախկինում «փլուզված» օբյեկտից, օգտագործելով «ձմեռում» գործողությունը, ըստ լռելյայն կեղծ)
- cache_file(փող) - ֆայլի անունը ձմեռման համար
Մեթոդներ
Վանդակ.file_create( սերվեր, ուղի ) – ստեղծել նոր ֆայլ
Վանդակ.file_rename( սերվեր, ուղի, նոր_անուն ) – վերանվանել ֆայլը
Վանդակ.file_remove( սերվեր, ուղի) - ջնջել ֆայլը
Վանդակ.բացել( սերվեր, ուղի, ռեժիմ ) - բացել ֆայլը
Վերադառնում է fchannel ալիքի համարը. Պարամետր ՊՆ - սա ֆայլի բացման ռեժիմն է. «wm» - բացառիկ (կարդալ/գրել), «rs» - միայն կարդալու համար և համօգտագործվել միայն այլ հաճախորդների կողմից կարդալու համար, «ws» - կարդալ/գրել և կիսվել միայն կարդալու համար: այլ հաճախորդներ:
Վանդակ.սերտ (fchannel) – փակել ֆայլը
Վանդակ.գրել (fchannel, սկիզբ, տվյալներ ) – գրել բայթ տող ֆայլում
Վանդակ.կարդալ (fchannel, start, len_data ) – կարդալ բայթ տող ֆայլից
Վանդակ.put_pages ( fchannel ) – «մղում» է բուֆերից դեպի սերվեր նշված ալիքի բոլոր էջերը, որոնք փոփոխվել են: Այն օգտագործվում է ալգորիթմի այն կետերում, երբ դուք պետք է համոզվեք, որ ալիքի բոլոր գործողությունները ֆիզիկապես պահվում են սերվերի ֆայլում:
Վանդակ.push_all () – «մղում» է բուֆերից դեպի սերվեր բոլոր ալիքների բոլոր էջերը՝ փոփոխված Cage դասի օրինակի համար: Օգտագործվում է այն դեպքում, երբ դուք պետք է համոզվեք, որ բոլոր ալիքների բոլոր գործողությունները պահվում են սերվերում:
Source: www.habr.com
