કેજ રિમોટ ફાઇલ એક્સેસ સિસ્ટમ

સિસ્ટમ હેતુ

નેટવર્ક પરના કમ્પ્યુટર્સ પર ફાઇલોની રિમોટ ઍક્સેસ માટે સપોર્ટ. સિસ્ટમ "વર્ચ્યુઅલી" TCP પ્રોટોકોલનો ઉપયોગ કરીને વ્યવહારો (સંદેશાઓ) ની આપલે કરીને તમામ મૂળભૂત ફાઇલ કામગીરી (બનાવવી, કાઢી નાખવી, વાંચન, લેખન વગેરે) ને સપોર્ટ કરે છે.

એપ્લિકેશન્સ

સિસ્ટમની કાર્યક્ષમતા નીચેના કેસોમાં અસરકારક છે:

• મોબાઇલ અને એમ્બેડેડ ઉપકરણો (સ્માર્ટફોન, ઓન-બોર્ડ કંટ્રોલ સિસ્ટમ્સ, વગેરે) માટેની મૂળ એપ્લિકેશનોમાં કે જેને સંચારમાં સંભવિત અસ્થાયી વિક્ષેપોના ચહેરામાં (ઓફલાઇન જવા સાથે) દૂરસ્થ સર્વર પર ફાઇલોની ઝડપી ઍક્સેસની જરૂર હોય છે;
• લોડ થયેલ DBMSs માં, જો ક્વેરી પ્રોસેસિંગ કેટલાક સર્વર પર હાથ ધરવામાં આવે છે, અને ડેટા સ્ટોરેજ અન્ય પર હાથ ધરવામાં આવે છે;
• માહિતી એકત્રિત કરવા અને પ્રક્રિયા કરવા માટે વિતરિત કોર્પોરેટ નેટવર્ક્સમાં, હાઇ સ્પીડ ડેટા એક્સચેન્જ, રિડન્ડન્સી અને વિશ્વસનીયતાની જરૂર છે;
• માઇક્રોસર્વિસ આર્કિટેક્ચર સાથે જટિલ સિસ્ટમોમાં, જ્યાં મોડ્યુલો વચ્ચે માહિતીના વિનિમયમાં વિલંબ મહત્વપૂર્ણ છે.

માળખું

કેજ સિસ્ટમ (ત્યાં અમલીકરણ છે - વિન્ડોઝ પર પાયથોન 3.7 માં બીટા સંસ્કરણ) બે મુખ્ય ભાગો સમાવે છે:

1. કેજસર્વર — ફાઇલ સર્વર પ્રોગ્રામ (ફંક્શન્સનું પેકેજ) જે નેટવર્ક પરના કમ્પ્યુટર્સ પર ચાલે છે જેની ફાઇલોને રિમોટ એક્સેસની જરૂર હોય છે;
2. વર્ગ કેજ ક્લાયન્ટ સૉફ્ટવેર માટેની પદ્ધતિઓની લાઇબ્રેરી સાથે, સર્વર્સ સાથે ક્રિયાપ્રતિક્રિયાના કોડિંગને સરળ બનાવે છે.

ક્લાયન્ટ બાજુ પર સિસ્ટમનો ઉપયોગ

કેજ વર્ગની પદ્ધતિઓ સામાન્ય, "નિયમિત" ફાઇલ સિસ્ટમ કામગીરીને બદલે છે: બનાવટ, ઉદઘાટન, બંધ, કાઢી નાખવું ફાઇલો, તેમજ બાઈનરી ફોર્મેટમાં ડેટા વાંચવા/લેખવા (ડેટાની સ્થિતિ અને કદ દર્શાવે છે). વૈચારિક રીતે, આ પદ્ધતિઓ C ભાષાના ફાઇલ કાર્યોની નજીક છે, જ્યાં ઇનપુટ/આઉટપુટની "ચેનલો પર" ફાઇલો ખોલવા/બંધ કરવાની કામગીરી કરવામાં આવે છે.

બીજા શબ્દોમાં કહીએ તો, પ્રોગ્રામર "ફાઇલ" ઑબ્જેક્ટ્સની પદ્ધતિઓ સાથે કામ કરતું નથી (વર્ગ _io પાયથોનમાં), પરંતુ કેજ વર્ગની પદ્ધતિઓ સાથે.

જ્યારે કેજ ઑબ્જેક્ટનો દાખલો બનાવવામાં આવે છે, ત્યારે તે સર્વર (અથવા ઘણા સર્વર્સ) સાથે પ્રારંભિક જોડાણ સ્થાપિત કરે છે, ક્લાયન્ટ આઈડી દ્વારા અધિકૃત છે અને તમામ ફાઇલ કામગીરી માટે સમર્પિત પોર્ટ નંબર સાથે પુષ્ટિ પ્રાપ્ત કરે છે. જ્યારે કેજ ઑબ્જેક્ટ કાઢી નાખવામાં આવે છે, ત્યારે તે સર્વરને સંદેશાવ્યવહાર બંધ કરવા અને ફાઇલોને બંધ કરવા સૂચના આપે છે. સંદેશાવ્યવહારની સમાપ્તિ સર્વર દ્વારા પણ શરૂ કરી શકાય છે.

સિસ્ટમ RAM કેશ (બફર) માં ક્લાયંટ પ્રોગ્રામ્સના વારંવાર ઉપયોગમાં લેવાતા ફાઈલ ટુકડાઓને બફર કરીને વાંચવા/લેખવાની કામગીરીમાં વધારો કરે છે.
ક્લાયન્ટ સોફ્ટવેર વિવિધ સેટિંગ્સ (બફર મેમરી સાઈઝ, સર્વર સાથે એક્સચેન્જ કરતી વખતે બ્લોક સાઈઝ વગેરે) સાથે કોઈપણ સંખ્યામાં કેજ ઑબ્જેક્ટનો ઉપયોગ કરી શકે છે.

સિંગલ કેજ ઑબ્જેક્ટ બહુવિધ સર્વર પર બહુવિધ ફાઇલો સાથે વાતચીત કરી શકે છે. ઑબ્જેક્ટ બનાવતી વખતે કોમ્યુનિકેશન પેરામીટર્સ (IP એડ્રેસ અથવા DNS સર્વર, અધિકૃતતા માટેનું મુખ્ય પોર્ટ, પાથ અને ફાઇલનું નામ) ઉલ્લેખિત છે.

દરેક કેજ ઑબ્જેક્ટ એક જ સમયે બહુવિધ ફાઇલો સાથે કામ કરી શકે છે, તેથી વહેંચાયેલ મેમરી સ્પેસ બફરિંગ માટે વપરાય છે. કેશનું કદ - કેજ ઑબ્જેક્ટ બનાવતી વખતે પૃષ્ઠોની સંખ્યા અને તેમનું કદ ગતિશીલ રીતે સેટ કરવામાં આવે છે. ઉદાહરણ તરીકે, 1 GB કેશ દરેક 1000 MB ના 1 પૃષ્ઠો અથવા 10 KB ના 100 હજાર પૃષ્ઠો અથવા 1 KB દરેકના 1 મિલિયન પૃષ્ઠો છે. દરેક એપ્લિકેશન કેસ માટે પૃષ્ઠોની સંખ્યા અને કદ પસંદ કરવાનું એક વિશિષ્ટ કાર્ય છે.

વિવિધ ફાઇલોમાં માહિતી કેવી રીતે એક્સેસ કરવામાં આવે છે તેના આધારે વિવિધ બફર મેમરી સેટિંગ્સને વ્યાખ્યાયિત કરવા માટે તમે એક જ સમયે બહુવિધ કેજ ઑબ્જેક્ટનો ઉપયોગ કરી શકો છો. મૂળભૂત તરીકે, સૌથી સરળ બફરિંગ અલ્ગોરિધમનો ઉપયોગ કરવામાં આવે છે: આપેલ મેમરીની માત્રા ખતમ થઈ જાય પછી, નવા પૃષ્ઠો ન્યૂનતમ સંખ્યામાં ઍક્સેસ સાથે નિવૃત્તિના સિદ્ધાંત અનુસાર જૂના પૃષ્ઠોને વિસ્થાપિત કરે છે. બફરિંગ ખાસ કરીને અસમાન (આંકડાકીય અર્થમાં) વહેંચાયેલ ઍક્સેસના કિસ્સામાં અસરકારક છે, પ્રથમ, વિવિધ ફાઇલો માટે, અને બીજું, દરેક ફાઇલના ટુકડાઓ માટે.

કેજ ક્લાસ I/O ને માત્ર ડેટા એડ્રેસ દ્વારા જ નહીં (એરેની સ્થિતિ અને લંબાઈ દર્શાવે છે, ફાઈલ સિસ્ટમ ઓપરેશન્સ “બદલી”), પણ બફર મેમરીમાં પેજ નંબર્સ દ્વારા - નીચલા, “ભૌતિક” સ્તરે પણ.

મૂળ કાર્ય કેજ ઑબ્જેક્ટ્સ માટે સપોર્ટેડ છે "હાઇબરનેશન" ("સ્લીપ") - તેઓ ક્લાયંટ બાજુ પરની સ્થાનિક ડમ્પ ફાઇલમાં "સંકુચિત" થઈ શકે છે (ઉદાહરણ તરીકે, સર્વર્સ સાથે કનેક્શન ખોવાઈ જવાની સ્થિતિમાં, અથવા જ્યારે એપ્લિકેશન બંધ થઈ જાય, વગેરે.) અને ઝડપથી પુનઃસ્થાપિત થઈ શકે છે. આ ફાઇલ (સંચાર ફરી શરૂ થયા પછી, જ્યારે તમે એપ્લિકેશનને ફરીથી પ્રારંભ કરો છો). આનાથી અસ્થાયી રૂપે "ઑફલાઇન" ગયા પછી ક્લાયંટ પ્રોગ્રામને સક્રિય કરતી વખતે ટ્રાફિકને નોંધપાત્ર રીતે ઘટાડવાનું શક્ય બને છે, કારણ કે વારંવાર ઉપયોગમાં લેવાતી ફાઇલના ટુકડાઓ પહેલેથી જ કેશમાં હશે.

કેજ કોડની લગભગ 3600 રેખાઓ છે.

સર્વર બાંધકામના સિદ્ધાંતો

કેજસર્વર ફાઇલ સર્વર્સને પોર્ટ્સની મનસ્વી સંખ્યા સાથે ચલાવી શકાય છે, જેમાંથી એક ("મુખ્ય") નો ઉપયોગ ફક્ત તમામ ક્લાયંટની અધિકૃતતા માટે થાય છે, બાકીનો ઉપયોગ ડેટા વિનિમય માટે થાય છે. કેજ સર્વર પ્રોગ્રામને માત્ર પાયથોનની જરૂર છે. સમાંતર, ફાઇલ સર્વર સાથેનું કમ્પ્યુટર અન્ય કોઈપણ કાર્ય કરી શકે છે.

સર્વર શરૂઆતમાં બે મુખ્ય પ્રક્રિયાઓના સંગ્રહ તરીકે શરૂ થાય છે:

1. "જોડાણો" - ક્લાઈન્ટો સાથે સંચાર સ્થાપિત કરવા અને સર્વરની પહેલ પર તેને સમાપ્ત કરવાની કામગીરી કરવા માટેની પ્રક્રિયા;
2. "ઓપરેશન્સ" - ફાઇલો સાથે કામ કરવા માટે ક્લાયંટના કાર્યો (ઓપરેશન્સ) કરવા માટેની પ્રક્રિયા, તેમજ ક્લાયંટ આદેશોના આધારે સંચાર સત્રો બંધ કરવા માટેની પ્રક્રિયા.

બંને પ્રક્રિયાઓ સમન્વયિત નથી અને મલ્ટિપ્રોસેસ કતાર, પ્રોક્સી ઑબ્જેક્ટ્સ, લૉક્સ અને સોકેટ્સ પર આધારિત સંદેશા પ્રાપ્ત કરવા અને મોકલવાના અનંત લૂપ્સ તરીકે ગોઠવવામાં આવે છે.
કનેક્શન પ્રક્રિયા દરેક ક્લાયંટને ડેટા પ્રાપ્ત કરવા અને ટ્રાન્સમિટ કરવા માટે એક પોર્ટ ફાળવે છે. જ્યારે સર્વર શરૂ થાય ત્યારે પોર્ટની સંખ્યા સેટ કરવામાં આવે છે. પોર્ટ્સ અને ક્લાયન્ટ્સ વચ્ચેનું મેપિંગ ઇન્ટરપ્રોસેસ-શેર્ડ પ્રોક્સી મેમરીમાં સંગ્રહિત થાય છે.

ઓપરેશન્સ પ્રક્રિયા ફાઇલ સંસાધનોના શેરિંગને સપોર્ટ કરે છે જેથી બહુવિધ અલગ-અલગ ક્લાયંટ શેર કરી શકે (અર્ધ-સમાંતર, કારણ કે ઍક્સેસ લૉક દ્વારા નિયંત્રિત થાય છે) એક ફાઇલમાંથી ડેટા વાંચો જો આને જ્યારે "પ્રથમ" ક્લાયન્ટ દ્વારા શરૂઆતમાં ખોલવામાં આવી હતી ત્યારે આને મંજૂરી આપવામાં આવી હતી.

સર્વર પર ફાઈલો બનાવવા/ડીલીટ/ખોલી/બંધ કરવા માટેના આદેશોની પ્રક્રિયા સર્વર OS ના ફાઈલ સબસિસ્ટમનો ઉપયોગ કરીને "ઓપરેશન્સ" પ્રક્રિયામાં જ સખત રીતે કરવામાં આવે છે.

સામાન્ય રીતે વાંચન/લેખનને ઝડપી બનાવવા માટે, આ કામગીરીઓ "ઓપરેશન્સ" પ્રક્રિયા દ્વારા ઉત્પન્ન થ્રેડોમાં કરવામાં આવે છે. થ્રેડોની સંખ્યા સામાન્ય રીતે ખુલ્લી ફાઇલોની સંખ્યા જેટલી હોય છે. ક્લાયન્ટના વાંચવા/લખવાનાં કાર્યો સામાન્ય કતારમાં સબમિટ કરવામાં આવે છે અને પ્રથમ ફ્રી થ્રેડ તેના માથામાંથી કાર્ય લે છે. વિશેષ તર્ક તમને સર્વરની રેમમાં ડેટા રીરાઇટ ઓપરેશન્સને દૂર કરવાની મંજૂરી આપે છે.

ઓપરેશન્સ પ્રક્રિયા ક્લાયંટની પ્રવૃત્તિ પર નજર રાખે છે અને તેમના આદેશો પર અથવા જ્યારે નિષ્ક્રિયતાનો સમયગાળો ઓળંગી જાય ત્યારે તેમને સેવા આપવાનું બંધ કરે છે.

વિશ્વસનીયતા સુનિશ્ચિત કરવા માટે, કેજસર્વર તમામ વ્યવહારોના લોગ રાખે છે. એક સામાન્ય લોગમાં ફાઈલો બનાવવા/ઓપન/નામ બદલવા/ડીલીટ કરવાના કાર્યો સાથે ક્લાઈન્ટોના સંદેશાની નકલો હોય છે. દરેક કાર્યકારી ફાઇલ માટે એક અલગ લોગ બનાવવામાં આવે છે, જેમાં આ કાર્યકારી ફાઇલમાં ડેટા વાંચવા અને લખવા માટેના કાર્યો સાથેના સંદેશાઓની નકલો રેકોર્ડ કરવામાં આવે છે, તેમજ લેખિત (નવા) ડેટાના એરે અને ઓવરરાઇટિંગ (લેખન) દરમિયાન નાશ પામેલા ડેટાના એરે. જૂના ડેટાની "ટોચ પર" નવો ડેટા)).

આ લોગ બેકઅપમાં નવા ફેરફારોને પુનઃસ્થાપિત કરવાની અને વર્તમાન સામગ્રીને ભૂતકાળના બિંદુ પર પાછા લાવવાની ક્ષમતા પ્રદાન કરે છે.

કેજસર્વર કોડની લગભગ 3100 રેખાઓ છે.

કેજસર્વર ફાઇલ સર્વર પ્રોગ્રામ શરૂ કરી રહ્યા છીએ

શરૂ કરતી વખતે, સંવાદમાં તમારે વ્યાખ્યાયિત કરવાની જરૂર છે:
- અધિકૃતતા માટે મુખ્ય બંદર;
— અધિકૃત ક્લાયન્ટ્સ સાથે વ્યવહારોની આપ-લે કરવા માટેના પોર્ટની સંખ્યા (1 અથવા વધુથી, સંખ્યાઓનો પૂલ મુખ્ય પોર્ટ નંબરની બાજુના એકથી શરૂ થાય છે).

કેજ ક્લાસનો ઉપયોગ કરવો

વર્ગ પાંજરાકેજ( cage_name="", pagesize=0, numpages=0, maxstrlen=0, server_ip={}, wait=0, awake=False, cache_file="" )

આ વર્ગમાંથી ઓબ્જેક્ટ બનાવવામાં આવે છે જે ફાઇલ સર્વર્સ સાથે ક્રિયાપ્રતિક્રિયા કરે છે અને બફર મેમરી ધરાવે છે.

પરિમાણો

• કેજ_નામ(str) - ઑબ્જેક્ટનું શરતી નામ, જેનો ઉપયોગ સર્વર બાજુ પરના ગ્રાહકોને ઓળખવા માટે થાય છે
• પૃષ્ઠનું કદ(પૂર્ણાંક) — બફર મેમરીના એક પૃષ્ઠનું કદ (બાઇટ્સમાં)
• સંખ્યાબંધ(પૂર્ણાંક) — બફર મેમરી પૃષ્ઠોની સંખ્યા
• maxstrlen(પૂર્ણાંક) - લખવા અને વાંચવાની ક્રિયાઓમાં બાઈટ સ્ટ્રિંગની મહત્તમ લંબાઈ
• સર્વર_આઈપી(ડિક) - ઉપયોગમાં લેવાતા સર્વરના સરનામાં સાથેનો શબ્દકોશ, જ્યાં કી એ સર્વરનું શરતી નામ છે (એપ્લિકેશનની અંદર સર્વર આઈડી), અને મૂલ્ય એ સરનામાં સાથેની સ્ટ્રિંગ છે: “ip address:port” અથવા “DNS: પોર્ટ" (નામો અને વાસ્તવિક સરનામાંની સરખામણી અસ્થાયી છે, તે બદલાઈ શકે છે)
• રાહ જુઓ(પૂર્ણાંક) — પોર્ટ્સ પ્રાપ્ત કરતી વખતે સર્વર તરફથી પ્રતિસાદ માટે રાહ જોવાનો સમય (સેકંડમાં)
• ખબરદાર(બુલિયન) — ઑબ્જેક્ટ કેવી રીતે બનાવવામાં આવે છે તેનો ધ્વજ (ખોટું - જો કોઈ નવી વસ્તુ બનાવવામાં આવી હોય, સાચું - જો કોઈ ઑબ્જેક્ટ અગાઉના "સંકુચિત" એકમાંથી બનાવવામાં આવે છે - "હાઇબરનેશન" ઑપરેશનનો ઉપયોગ કરીને, ડિફૉલ્ટ રૂપે ખોટું)
• cache_file(str) - હાઇબરનેશન માટે ફાઇલનું નામ

પદ્ધતિઓ

કેજ.file_create( સર્વર, પાથ ) - નવી ફાઇલ બનાવો

કેજ.ફાઇલ_નામ બદલો( સર્વર, પાથ, નવું_નામ ) - ફાઇલનું નામ બદલો

કેજ.ફાઇલ_દૂર કરો( સર્વર, પાથ) - ફાઇલ કાઢી નાખો

કેજ.ઓપન( સર્વર, પાથ, મોડ ) - ફાઇલ ખોલો

વળતર આપે છે fchannel ચેનલ નંબર. પરિમાણ ફેરફારની - આ ફાઇલ ઓપનિંગ મોડ છે: "wm" - વિશિષ્ટ (વાંચવા/લખવા), "rs" - ફક્ત વાંચવા માટે, અને અન્ય ક્લાયંટ દ્વારા ફક્ત વાંચવા માટે શેર કરવામાં આવે છે, "ws" - વાંચવા/લખવા માટે, અને ફક્ત દ્વારા વાંચવા માટે શેર કરવામાં આવે છે. અન્ય ગ્રાહકો.

કેજ.બંધ (fchannel) - ફાઇલ બંધ કરો

કેજ.લખી (fchannel, start, data ) - ફાઇલમાં બાઇટ સ્ટ્રિંગ લખો

કેજ.વાંચવું (fchannel, start, len_data ) - ફાઇલમાંથી બાઇટ સ્ટ્રિંગ વાંચો

કેજ.put_pages ( fchannel ) - બફરથી સર્વર પર "પુશ" કરે છે જે સુધારેલ છે તે ઉલ્લેખિત ચેનલના તમામ પૃષ્ઠો. તેનો ઉપયોગ અલ્ગોરિધમના તે બિંદુઓ પર થાય છે જ્યારે તમારે ખાતરી કરવાની જરૂર હોય કે ચેનલ પરના તમામ ઓપરેશન્સ સર્વર પરની ફાઇલમાં ભૌતિક રીતે સાચવેલ છે.

કેજ.push_all () – બફરથી સર્વર પર "પુશ" કરે છે કેજ ક્લાસના દાખલા માટે તમામ ચેનલોના તમામ પૃષ્ઠો કે જેમાં ફેરફાર કરવામાં આવ્યો છે. જ્યારે તમારે ખાતરી કરવાની જરૂર હોય કે બધી ચેનલો પરની તમામ કામગીરી સર્વર પર સાચવવામાં આવે ત્યારે વપરાય છે.

સોર્સ: www.habr.com