കേജ് റിമോട്ട് ഫയൽ ആക്സസ് സിസ്റ്റം

സിസ്റ്റം ഉദ്ദേശ്യം

നെറ്റ്‌വർക്കിലെ കമ്പ്യൂട്ടറുകളിലെ ഫയലുകളിലേക്കുള്ള റിമോട്ട് ആക്‌സസിനുള്ള പിന്തുണ. ടിസിപി പ്രോട്ടോക്കോൾ ഉപയോഗിച്ച് ഇടപാടുകൾ (സന്ദേശങ്ങൾ) കൈമാറ്റം ചെയ്യുന്നതിലൂടെ സിസ്റ്റം "വെർച്വലി" എല്ലാ അടിസ്ഥാന ഫയൽ പ്രവർത്തനങ്ങളെയും (സൃഷ്ടി, ഇല്ലാതാക്കൽ, വായന, എഴുത്ത് മുതലായവ) പിന്തുണയ്ക്കുന്നു.

അപ്ലിക്കേഷനുകൾ

ഇനിപ്പറയുന്ന സന്ദർഭങ്ങളിൽ സിസ്റ്റത്തിന്റെ പ്രവർത്തനം ഫലപ്രദമാണ്:

• ആശയവിനിമയത്തിൽ (ഓഫ്‌ലൈനിൽ പോകുമ്പോൾ) സാധ്യമായ താൽക്കാലിക തടസ്സങ്ങളുടെ പശ്ചാത്തലത്തിൽ റിമോട്ട് സെർവറുകളിലെ ഫയലുകളിലേക്ക് പെട്ടെന്ന് ആക്‌സസ് ആവശ്യമുള്ള മൊബൈൽ, എംബഡഡ് ഉപകരണങ്ങൾക്കുള്ള (സ്‌മാർട്ട്‌ഫോണുകൾ, ഓൺ-ബോർഡ് കൺട്രോൾ സിസ്റ്റങ്ങൾ മുതലായവ) നേറ്റീവ് ആപ്ലിക്കേഷനുകളിൽ;
• ലോഡ് ചെയ്ത DBMS-കളിൽ, ചില സെർവറുകളിൽ അന്വേഷണ പ്രോസസ്സിംഗ് നടത്തുകയും മറ്റുള്ളവയിൽ ഡാറ്റ സംഭരണം നടത്തുകയും ചെയ്താൽ;
• വിവരങ്ങൾ ശേഖരിക്കുന്നതിനും പ്രോസസ്സ് ചെയ്യുന്നതിനുമായി വിതരണം ചെയ്ത കോർപ്പറേറ്റ് നെറ്റ്‌വർക്കുകളിൽ, അതിവേഗ ഡാറ്റാ കൈമാറ്റം, ആവർത്തനവും വിശ്വാസ്യതയും ആവശ്യമാണ്;
• മൈക്രോസർവീസ് ആർക്കിടെക്ചറുള്ള സങ്കീർണ്ണമായ സിസ്റ്റങ്ങളിൽ, മൊഡ്യൂളുകൾ തമ്മിലുള്ള വിവരങ്ങൾ കൈമാറുന്നതിലെ കാലതാമസം നിർണായകമാണ്.

ഘടന

കേജ് സിസ്റ്റം (ഒരു ഇംപ്ലിമെന്റേഷൻ ഉണ്ട് - OS-ലെ പൈത്തൺ 3.7-ൽ ബീറ്റ പതിപ്പ് Windows) രണ്ട് പ്രധാന ഭാഗങ്ങൾ ഉൾക്കൊള്ളുന്നു:

1. കേജ്സെർവർ - നെറ്റ്‌വർക്കിലെ കമ്പ്യൂട്ടറുകളിൽ പ്രവർത്തിക്കുന്ന ഒരു ഫയൽ സെർവർ പ്രോഗ്രാം (ഫംഗ്ഷനുകളുടെ ഒരു പാക്കേജ്) ഫയലുകൾക്ക് റിമോട്ട് ആക്‌സസ്സ് ആവശ്യമാണ്;
2. класс കൂട് ക്ലയന്റ് സോഫ്‌റ്റ്‌വെയറിനായുള്ള മെത്തേഡുകളുടെ ഒരു ലൈബ്രറിയോടൊപ്പം, സെർവറുകളുമായുള്ള ആശയവിനിമയത്തിന്റെ കോഡിംഗ് ലളിതമാക്കുന്നു.

ക്ലയന്റ് ഭാഗത്ത് സിസ്റ്റം ഉപയോഗിക്കുന്നു

കേജ് ക്ലാസിന്റെ രീതികൾ സാധാരണ, "പതിവ്" ഫയൽ സിസ്റ്റം പ്രവർത്തനങ്ങളെ മാറ്റിസ്ഥാപിക്കുന്നു: സൃഷ്ടിക്കൽ, തുറക്കൽ, അടയ്ക്കൽ, ഇല്ലാതാക്കൽ ഫയലുകൾ, അതുപോലെ ബൈനറി ഫോർമാറ്റിൽ ഡാറ്റ വായിക്കുന്നു/എഴുതുന്നു (ഡാറ്റയുടെ സ്ഥാനവും വലുപ്പവും സൂചിപ്പിക്കുന്നു). ആശയപരമായി, ഈ രീതികൾ സി ഭാഷയുടെ ഫയൽ ഫംഗ്‌ഷനുകൾക്ക് സമീപമാണ്, ഇവിടെ ഫയലുകൾ തുറക്കൽ/അടയ്ക്കൽ ഇൻപുട്ട്/ഔട്ട്‌പുട്ടിന്റെ "ചാനലുകളിൽ" നടത്തപ്പെടുന്നു.

മറ്റൊരു വിധത്തിൽ പറഞ്ഞാൽ, പ്രോഗ്രാമർ "ഫയൽ" ഒബ്‌ജക്റ്റുകളുടെ രീതികളുമായി പ്രവർത്തിക്കുന്നില്ല (ക്ലാസ് _io പൈത്തണിൽ), എന്നാൽ കേജ് ക്ലാസിന്റെ രീതികൾക്കൊപ്പം.

ഒരു കേജ് ഒബ്‌ജക്റ്റിന്റെ ഒരു ഉദാഹരണം സൃഷ്‌ടിക്കുമ്പോൾ, അത് ഒരു സെർവറുമായി (അല്ലെങ്കിൽ നിരവധി സെർവറുകൾ) ഒരു പ്രാരംഭ കണക്ഷൻ സ്ഥാപിക്കുന്നു, ക്ലയന്റ് ഐഡി അധികാരപ്പെടുത്തിയിരിക്കുന്നു, കൂടാതെ എല്ലാ ഫയൽ പ്രവർത്തനങ്ങൾക്കും ഒരു സമർപ്പിത പോർട്ട് നമ്പർ ഉപയോഗിച്ച് സ്ഥിരീകരണം ലഭിക്കുന്നു. ഒരു കേജ് ഒബ്‌ജക്റ്റ് ഇല്ലാതാക്കുമ്പോൾ, ആശയവിനിമയം നിർത്താനും ഫയലുകൾ അടയ്ക്കാനും അത് സെർവറിനോട് നിർദ്ദേശിക്കുന്നു. ആശയവിനിമയം അവസാനിപ്പിക്കുന്നത് സെർവറുകൾക്ക് തന്നെ ആരംഭിക്കാവുന്നതാണ്.

റാം കാഷെയിൽ (ബഫർ) ക്ലയന്റ് പ്രോഗ്രാമുകളുടെ പതിവായി ഉപയോഗിക്കുന്ന ഫയൽ ശകലങ്ങൾ ബഫർ ചെയ്യുന്നതിലൂടെ സിസ്റ്റം വായന/എഴുത്ത് പ്രകടനം മെച്ചപ്പെടുത്തുന്നു.
വ്യത്യസ്‌ത ക്രമീകരണങ്ങളുള്ള (ബഫർ മെമ്മറി വലുപ്പം, സെർവറുമായി എക്‌സ്‌ചേഞ്ച് ചെയ്യുമ്പോൾ ബ്ലോക്ക് വലുപ്പം മുതലായവ) എത്ര കേജ് ഒബ്‌ജക്റ്റുകളും ക്ലയന്റ് സോഫ്‌റ്റ്‌വെയറിന് ഉപയോഗിക്കാൻ കഴിയും.

ഒരു കേജ് ഒബ്‌ജക്റ്റിന് ഒന്നിലധികം സെർവറുകളിലെ ഒന്നിലധികം ഫയലുകളുമായി ആശയവിനിമയം നടത്താൻ കഴിയും. ഒബ്‌ജക്‌റ്റ് സൃഷ്‌ടിക്കുമ്പോൾ ആശയവിനിമയ പാരാമീറ്ററുകൾ (IP വിലാസം അല്ലെങ്കിൽ DNS സെർവർ, അംഗീകാരത്തിനായുള്ള പ്രധാന പോർട്ട്, പാത, ഫയലിന്റെ പേര്) വ്യക്തമാക്കിയിരിക്കുന്നു.

ഓരോ കേജ് ഒബ്‌ജക്‌റ്റും ഒരേ സമയം ഒന്നിലധികം ഫയലുകളിൽ പ്രവർത്തിക്കാൻ കഴിയുന്നതിനാൽ, ബഫറിംഗിനായി പങ്കിട്ട മെമ്മറി സ്‌പെയ്‌സ് ഉപയോഗിക്കുന്നു. കാഷെ വലുപ്പം - ഒരു കേജ് ഒബ്‌ജക്റ്റ് സൃഷ്‌ടിക്കുമ്പോൾ പേജുകളുടെ എണ്ണവും അവയുടെ വലുപ്പവും ചലനാത്മകമായി സജ്ജീകരിച്ചിരിക്കുന്നു. ഉദാഹരണത്തിന്, 1 GB കാഷെ എന്നത് 1000 MB വീതമുള്ള 1 പേജുകൾ അല്ലെങ്കിൽ 10 ​​KB വീതമുള്ള 100 ആയിരം പേജുകൾ അല്ലെങ്കിൽ 1 KB വീതമുള്ള 1 ദശലക്ഷം പേജുകൾ. പേജുകളുടെ വലുപ്പവും എണ്ണവും തിരഞ്ഞെടുക്കുന്നത് ഓരോ ആപ്ലിക്കേഷൻ കേസിനും ഒരു പ്രത്യേക ചുമതലയാണ്.

വ്യത്യസ്‌ത ഫയലുകളിൽ വിവരങ്ങൾ എങ്ങനെ ആക്‌സസ് ചെയ്യപ്പെടുന്നു എന്നതിനെ ആശ്രയിച്ച് വ്യത്യസ്‌ത ബഫർ മെമ്മറി ക്രമീകരണങ്ങൾ നിർവ്വചിക്കാൻ നിങ്ങൾക്ക് ഒരേ സമയം ഒന്നിലധികം കേജ് ഒബ്‌ജക്‌റ്റുകൾ ഉപയോഗിക്കാം. അടിസ്ഥാനപരമായ ഒന്നായി, ഏറ്റവും ലളിതമായ ബഫറിംഗ് അൽഗോരിതം ഉപയോഗിക്കുന്നു: ഒരു നിശ്ചിത മെമ്മറി തീർന്നതിന് ശേഷം, റിട്ടയർമെന്റ് തത്വമനുസരിച്ച് പുതിയ പേജുകൾ പഴയവയെ മാറ്റിസ്ഥാപിക്കുന്നു, കുറഞ്ഞ ആക്‌സസുകളോടെ. അസമമായ (ഒരു സ്ഥിതിവിവരക്കണക്ക് അർത്ഥത്തിൽ) പങ്കിട്ട ആക്‌സസ്സിന്റെ കാര്യത്തിൽ ബഫറിംഗ് പ്രത്യേകിച്ചും ഫലപ്രദമാണ്, ഒന്നാമതായി, വ്യത്യസ്ത ഫയലുകളിലേക്കും, രണ്ടാമതായി, ഓരോ ഫയലിന്റെയും ശകലങ്ങളിലേക്കും.

കേജ് ക്ലാസ് I/O പിന്തുണയ്ക്കുന്നത് ഡാറ്റ വിലാസങ്ങൾ (അറേയുടെ സ്ഥാനവും ദൈർഘ്യവും സൂചിപ്പിക്കുന്നത്, ഫയൽ സിസ്റ്റം പ്രവർത്തനങ്ങൾ "മാറ്റിസ്ഥാപിക്കുന്നു") മാത്രമല്ല, ബഫർ മെമ്മറിയിലെ പേജ് നമ്പറുകൾ വഴി താഴ്ന്ന, "ഫിസിക്കൽ" തലത്തിലും.

കേജ് ഒബ്‌ജക്‌റ്റുകൾക്ക് യഥാർത്ഥ പ്രവർത്തനം പിന്തുണയ്‌ക്കുന്നു "ഹൈബർനേഷൻ" (“ഉറക്കം”) - അവ “തകരാൻ” കഴിയും (ഉദാഹരണത്തിന്, സെർവറുകളുമായുള്ള കണക്ഷൻ നഷ്‌ടപ്പെടുമ്പോൾ, അല്ലെങ്കിൽ ആപ്ലിക്കേഷൻ നിർത്തുമ്പോൾ മുതലായവ) ക്ലയന്റ് വശത്തുള്ള ഒരു ലോക്കൽ ഡംപ് ഫയലിലേക്ക് വേഗത്തിൽ പുനഃസ്ഥാപിക്കാം. ഈ ഫയൽ (കമ്മ്യൂണിക്കേഷൻ പുനരാരംഭിച്ച ശേഷം, നിങ്ങൾ ആപ്ലിക്കേഷൻ പുനരാരംഭിക്കുമ്പോൾ). ഇടയ്‌ക്കിടെ ഉപയോഗിക്കുന്ന ഫയൽ ശകലങ്ങൾ ഇതിനകം കാഷെയിലായിരിക്കുമെന്നതിനാൽ താൽക്കാലികമായി “ഓഫ്‌ലൈനിൽ” പോയതിനുശേഷം ക്ലയന്റ് പ്രോഗ്രാം സജീവമാക്കുമ്പോൾ ട്രാഫിക് ഗണ്യമായി കുറയ്ക്കുന്നത് ഇത് സാധ്യമാക്കുന്നു.

കേജ് ഏകദേശം 3600 കോഡ് ലൈനുകളാണ്.

സെർവർ നിർമ്മാണത്തിന്റെ തത്വങ്ങൾ

കേജ്‌സെർവർ ഫയൽ സെർവറുകൾ അനിയന്ത്രിതമായ എണ്ണം പോർട്ടുകൾ ഉപയോഗിച്ച് പ്രവർത്തിപ്പിക്കാൻ കഴിയും, അവയിലൊന്ന് ("പ്രധാന") എല്ലാ ക്ലയന്റുകളുടെയും അംഗീകാരത്തിനായി മാത്രം ഉപയോഗിക്കുന്നു, ബാക്കിയുള്ളവ ഡാറ്റാ കൈമാറ്റത്തിനായി ഉപയോഗിക്കുന്നു. കേജ് സെർവർ പ്രോഗ്രാമിന് പൈത്തൺ മാത്രമേ ആവശ്യമുള്ളൂ. സമാന്തരമായി, ഫയൽ സെർവറുള്ള കമ്പ്യൂട്ടറിന് മറ്റേതെങ്കിലും ജോലി ചെയ്യാൻ കഴിയും.

രണ്ട് പ്രധാന പ്രക്രിയകളുടെ ഒരു ശേഖരമായാണ് സെർവർ ആദ്യം ആരംഭിക്കുന്നത്:

1. "കണക്ഷനുകൾ" - ക്ലയന്റുകളുമായി ആശയവിനിമയം സ്ഥാപിക്കുന്നതിനും സെർവറിന്റെ മുൻകൈയിൽ അത് അവസാനിപ്പിക്കുന്നതിനുമുള്ള പ്രവർത്തനങ്ങൾ നടത്തുന്നതിനുള്ള ഒരു പ്രക്രിയ;
2. "പ്രവർത്തനങ്ങൾ" - ഫയലുകളുമായി പ്രവർത്തിക്കാൻ ക്ലയന്റുകളുടെ ചുമതലകൾ (പ്രവർത്തനങ്ങൾ) നിർവഹിക്കുന്നതിനുള്ള ഒരു പ്രക്രിയ, അതുപോലെ ക്ലയന്റ് കമാൻഡുകൾ അടിസ്ഥാനമാക്കിയുള്ള ആശയവിനിമയ സെഷനുകൾ അവസാനിപ്പിക്കുക.

രണ്ട് പ്രക്രിയകളും സമന്വയിപ്പിച്ചിട്ടില്ല, മൾട്ടിപ്രോസസ് ക്യൂകൾ, പ്രോക്സി ഒബ്‌ജക്റ്റുകൾ, ലോക്കുകൾ, സോക്കറ്റുകൾ എന്നിവയെ അടിസ്ഥാനമാക്കി സന്ദേശങ്ങൾ സ്വീകരിക്കുന്നതിനും അയയ്ക്കുന്നതിനുമുള്ള അനന്തമായ ലൂപ്പുകളായി ക്രമീകരിച്ചിരിക്കുന്നു.
കണക്ഷൻ പ്രക്രിയ ഓരോ ക്ലയന്റിനും ഡാറ്റ സ്വീകരിക്കുന്നതിനും കൈമാറുന്നതിനും ഒരു പോർട്ട് അനുവദിക്കുന്നു. സെർവർ ആരംഭിക്കുമ്പോൾ പോർട്ടുകളുടെ എണ്ണം സജ്ജീകരിച്ചിരിക്കുന്നു. പോർട്ടുകളും ക്ലയന്റുകളും തമ്മിലുള്ള മാപ്പിംഗ് ഇന്റർപ്രോസസ്-പങ്കിട്ട പ്രോക്സി മെമ്മറിയിൽ സംഭരിച്ചിരിക്കുന്നു.

ഒന്നിലധികം വ്യത്യസ്ത ക്ലയന്റുകൾക്ക് പങ്കിടാൻ കഴിയുന്ന തരത്തിൽ ഫയൽ ഉറവിടങ്ങൾ പങ്കിടുന്നതിനെ പ്രവർത്തന പ്രക്രിയ പിന്തുണയ്ക്കുന്നു (അർദ്ധ-സമാന്തരം, ആക്സസ് നിയന്ത്രിക്കുന്നത് ലോക്കുകളാൽ) "ആദ്യത്തെ" ക്ലയന്റ് ആദ്യം തുറക്കുമ്പോൾ ഒരു ഫയലിൽ നിന്ന് ഡാറ്റ വായിക്കുക.

ഫയലുകൾ സൃഷ്ടിക്കുന്നതിനും/ഇല്ലാതാക്കുന്നതിനും/തുറക്കുന്നതിനും/അടയ്ക്കുന്നതിനുമുള്ള കമാൻഡുകൾ പ്രോസസ്സ് ചെയ്യുന്നു സെർവർ സെർവർ ഒഎസിന്റെ ഫയൽ സബ്സിസ്റ്റം കർശനമായി തുടർച്ചയായി ഉപയോഗിച്ച് "ഓപ്പറേഷൻ" പ്രക്രിയയിൽ തന്നെ നടപ്പിലാക്കുന്നു.

സാധാരണയായി വായന/എഴുത്ത് വേഗത്തിലാക്കാൻ, ഈ പ്രവർത്തനങ്ങൾ "ഓപ്പറേഷൻസ്" പ്രോസസ് സൃഷ്ടിച്ച ത്രെഡുകളിലാണ് നടത്തുന്നത്. ത്രെഡുകളുടെ എണ്ണം സാധാരണയായി തുറന്ന ഫയലുകളുടെ എണ്ണത്തിന് തുല്യമാണ്. ക്ലയന്റുകളിൽ നിന്നുള്ള റീഡ്/റൈറ്റ് ടാസ്‌ക്കുകൾ പൊതു ക്യൂവിലേക്ക് സമർപ്പിക്കുകയും ആദ്യത്തെ സൗജന്യ ത്രെഡ് അതിന്റെ തലയിൽ നിന്ന് ചുമതല ഏറ്റെടുക്കുകയും ചെയ്യുന്നു. സെർവറിന്റെ റാമിലെ ഡാറ്റ റീറൈറ്റ് പ്രവർത്തനങ്ങൾ ഇല്ലാതാക്കാൻ പ്രത്യേക ലോജിക് നിങ്ങളെ അനുവദിക്കുന്നു.

ഓപ്പറേഷൻസ് പ്രോസസ് ക്ലയന്റ് ആക്റ്റിവിറ്റി നിരീക്ഷിക്കുകയും അവരുടെ കമാൻഡുകളിലോ അല്ലെങ്കിൽ നിഷ്‌ക്രിയ സമയപരിധി കവിയുമ്പോഴോ അവർക്ക് സേവനം നൽകുന്നത് നിർത്തുകയും ചെയ്യുന്നു.

വിശ്വാസ്യത ഉറപ്പാക്കാൻ, കേജ്‌സെർവർ എല്ലാ ഇടപാടുകളുടെയും ലോഗുകൾ സൂക്ഷിക്കുന്നു. ഫയലുകൾ സൃഷ്‌ടിക്കാനും/തുറക്കാനും/പേരുമാറ്റാനും/ഇല്ലാതാക്കാനുമുള്ള ടാസ്‌ക്കുകളുള്ള ക്ലയന്റുകളിൽ നിന്നുള്ള സന്ദേശങ്ങളുടെ പകർപ്പുകൾ ഒരു പൊതു ലോഗിൽ അടങ്ങിയിരിക്കുന്നു. പ്രവർത്തിക്കുന്ന ഓരോ ഫയലിനും ഒരു പ്രത്യേക ലോഗ് സൃഷ്‌ടിക്കുന്നു, അതിൽ ഈ പ്രവർത്തിക്കുന്ന ഫയലിലെ ഡാറ്റ വായിക്കുന്നതിനും എഴുതുന്നതിനുമുള്ള ടാസ്‌ക്കുകളുള്ള സന്ദേശങ്ങളുടെ പകർപ്പുകൾ റെക്കോർഡുചെയ്‌തു, കൂടാതെ എഴുതിയ (പുതിയ) ഡാറ്റയുടെയും ഓവർറൈറ്റിംഗ് (എഴുത്ത്) സമയത്ത് നശിപ്പിക്കപ്പെട്ട ഡാറ്റയുടെ നിരകളും. പഴയവയുടെ "മുകളിൽ" പുതിയ ഡാറ്റ). ).

ബാക്കപ്പുകളിലേക്ക് പുതിയ മാറ്റങ്ങൾ പുനഃസ്ഥാപിക്കുന്നതിനും നിലവിലെ ഉള്ളടക്കം പഴയ ഒരു പോയിന്റിലേക്ക് തിരികെ കൊണ്ടുവരുന്നതിനുമുള്ള കഴിവ് ഈ ലോഗുകൾ നൽകുന്നു.

കേജ്‌സെർവർ ഏകദേശം 3100 കോഡുകളാണ്.

Cageserver ഫയൽ സെർവർ പ്രോഗ്രാം സമാരംഭിക്കുന്നു

ആരംഭിക്കുമ്പോൾ, ഡയലോഗിൽ നിങ്ങൾ നിർവചിക്കേണ്ടതുണ്ട്:
- അംഗീകാരത്തിനായുള്ള പ്രധാന തുറമുഖം;
- അംഗീകൃത ക്ലയന്റുകളുമായുള്ള ഇടപാടുകൾ കൈമാറ്റം ചെയ്യുന്നതിനുള്ള പോർട്ടുകളുടെ എണ്ണം (ഒന്നോ അതിലധികമോ മുതൽ, പ്രധാന പോർട്ട് നമ്പറിന് അടുത്തുള്ള ഒന്നിൽ നിന്ന് അക്കങ്ങളുടെ പൂൾ ആരംഭിക്കുന്നു).

കേജ് ക്ലാസ് ഉപയോഗിക്കുന്നു

ക്ലാസ് കൂട്ടിൽ.കൂട്( cage_name="", pagesize=0, numpages=0, maxstrlen=0, server_ip={}, wait=0, awake=False, cache_file="" )

ഫയൽ സെർവറുകളുമായി സംവദിക്കുന്നതും ബഫർ മെമ്മറി അടങ്ങിയതുമായ ഒബ്‌ജക്റ്റുകൾ ഈ ക്ലാസിൽ നിന്ന് സൃഷ്‌ടിക്കപ്പെട്ടിരിക്കുന്നു.

പാരാമീറ്ററുകൾ

• കൂട്_പേര്(str) - ഒബ്‌ജക്റ്റിന്റെ സോപാധിക നാമം, ഇത് സെർവർ വശത്തുള്ള ക്ലയന്റുകളെ തിരിച്ചറിയാൻ ഉപയോഗിക്കുന്നു
• പേജ് വലുപ്പം(int) — ബഫർ മെമ്മറിയുടെ ഒരു പേജിന്റെ വലിപ്പം (ബൈറ്റുകളിൽ)
• സംഖ്യകൾ(int) — ബഫർ മെമ്മറി പേജുകളുടെ എണ്ണം
• maxstrlen(int) - റൈറ്റ്, റീഡ് ഓപ്പറേഷനുകളിലെ ഒരു ബൈറ്റ് സ്‌ട്രിംഗിന്റെ പരമാവധി ദൈർഘ്യം
• server_ip(നിഘണ്ഡു) - ഉപയോഗിച്ച വിലാസങ്ങളുള്ള ഒരു നിഘണ്ടു സെർവറുകൾ, ഇവിടെ കീ സെർവറിന്റെ സോപാധിക നാമമാണ് (ആപ്ലിക്കേഷനുള്ളിലെ സെർവർ ഐഡി), മൂല്യം വിലാസമുള്ള ഒരു സ്ട്രിംഗ് ആണ്: “ip address:port” അല്ലെങ്കിൽ “DNS:port” (പേരുകളുടെയും യഥാർത്ഥ വിലാസങ്ങളുടെയും മാപ്പിംഗ് താൽക്കാലികമാണ്, അത് മാറ്റാൻ കഴിയും)
• കാത്തിരിക്കുക(int) - പോർട്ടുകൾ സ്വീകരിക്കുമ്പോൾ സെർവറിൽ നിന്നുള്ള പ്രതികരണത്തിനായി കാത്തിരിക്കുന്ന സമയം (സെക്കൻഡിൽ)
• ഉണരുക(ബൂളിയൻ) — വസ്തു എങ്ങനെ സൃഷ്ടിക്കപ്പെടുന്നു എന്നതിന്റെ പതാക (തെറ്റായ - ഒരു പുതിയ വസ്തു സൃഷ്ടിച്ചാൽ, ട്രൂ - മുമ്പ് "തകർന്ന" ഒന്നിൽ നിന്ന് ഒരു ഒബ്ജക്റ്റ് സൃഷ്ടിക്കപ്പെട്ടാൽ - "ഹൈബർനേഷൻ" പ്രവർത്തനം ഉപയോഗിച്ച്, സ്ഥിരസ്ഥിതിയായി തെറ്റ്)
• കാഷെ_ഫയൽ(str) - ഹൈബർനേഷനുള്ള ഫയലിന്റെ പേര്

രീതികൾ

കൂട്ടിൽ.file_create( സെർവർ, പാത ) - ഒരു പുതിയ ഫയൽ സൃഷ്ടിക്കുക

കൂട്ടിൽ.file_rename( സെർവർ, പാത, new_name ) - ഫയലിന്റെ പേര് മാറ്റുക

കൂട്ടിൽ.ഫയൽ_നീക്കം( സെർവർ, പാത) - ഒരു ഫയൽ ഇല്ലാതാക്കുക

കൂട്ടിൽ.തുറക്കുക( സെർവർ, പാത, മോഡ് ) - ഫയൽ തുറക്കുക

റിട്ടേൺസ് fchannel ചാനൽ നമ്പർ. പരാമീറ്റർ എതിരായി - ഇതാണ് ഫയൽ ഓപ്പണിംഗ് മോഡ്: "wm" - എക്സ്ക്ലൂസീവ് (വായിക്കുക/എഴുതുക), "rs" - വായിക്കാൻ മാത്രം, മറ്റ് ക്ലയന്റുകൾക്ക് വായിക്കാൻ മാത്രം പങ്കിടുക, "ws" - വായിക്കുക/എഴുതുക, കൂടാതെ വായിക്കാൻ മാത്രം പങ്കിടുക മറ്റ് ക്ലയന്റുകൾ.

കൂട്ടിൽ.അടയ്ക്കുക (fchannel) - ഫയൽ അടയ്ക്കുക

കൂട്ടിൽ.എഴുതുക (fchannel, ആരംഭിക്കുക, ഡാറ്റ ) - ഒരു ഫയലിലേക്ക് ഒരു ബൈറ്റ് സ്ട്രിംഗ് എഴുതുക

കൂട്ടിൽ.വായിക്കുക (fchannel, ആരംഭിക്കുക, len_data ) - ഒരു ഫയലിൽ നിന്ന് ഒരു ബൈറ്റ് സ്ട്രിംഗ് വായിക്കുക

കൂട്ടിൽ.put_pages ( fchannel ) - ബഫറിൽ നിന്ന് സെർവറിലേക്ക് പരിഷ്കരിച്ച നിർദ്ദിഷ്ട ചാനലിന്റെ എല്ലാ പേജുകളും "പുഷ്" ചെയ്യുന്നു. ചാനലിലെ എല്ലാ പ്രവർത്തനങ്ങളും സെർവറിലെ ഒരു ഫയലിൽ ഭൗതികമായി സംരക്ഷിച്ചിട്ടുണ്ടെന്ന് ഉറപ്പാക്കേണ്ട സമയത്ത് അൽഗോരിതത്തിലെ ആ പോയിന്റുകളിൽ ഇത് ഉപയോഗിക്കുന്നു.

കൂട്ടിൽ.പുഷ്_എല്ലാം () - പരിഷ്കരിച്ച കേജ് ക്ലാസിന്റെ ഉദാഹരണത്തിനായി എല്ലാ ചാനലുകളുടെയും എല്ലാ പേജുകളും ബഫറിൽ നിന്ന് സെർവറിലേക്ക് "പുഷ്" ചെയ്യുന്നു. എല്ലാ ചാനലുകളിലെയും എല്ലാ പ്രവർത്തനങ്ങളും സെർവറിൽ സംരക്ഷിച്ചിട്ടുണ്ടെന്ന് ഉറപ്പ് വരുത്തേണ്ട സമയത്ത് ഉപയോഗിക്കുന്നു.

അവലംബം: www.habr.com