Event-driven վեբ հավելվածներ, որոնք աշխատում են Local-Second սկզբունքով
Դուք մեքենայով գնում եք Գերմանիայից Իտալիա՝ ընտանեկան արձակուրդի, 1500 կմ-ից ավելի ճանապարհ է, ուստի Ավստրիայում գիշերակացի կանգառ եք պլանավորում։ Ամբողջ օրը ղեկի մոտ անցկացնելուց հետո հասնում եք հյուրանոց՝ ոտքերը մարզելու, երեխաներին մի փոքր վազվզելու թողնելու և Ավստրիական քաղաքի առաջարկածը տեսնելու ցանկությամբ։
Դուք մեքենայով գնում եք Գերմանիայից Իտալիա՝ ընտանեկան արձակուրդի, 1500 կմ-ից ավելի ճանապարհ է, ուստի Ավստրիայում գիշերակացի կանգառ եք պլանավորում։ Ամբողջ օրը ղեկի մոտ անցկացնելուց հետո հասնում եք հյուրանոց՝ ոտքերը մարզելու, երեխաներին մի փոքր վազվզելու թողնելու և Ավստրիական քաղաքի առաջարկածը տեսնելու ցանկությամբ։
Ուրախ, որ օրվա վարելը ավարտվել է, մտնում եք հյուրանոց և գնում ընդունարան։ Եվ հենց այստեղ սկսվում է փորձանքը։ Ինտերնետը չի աշխատում, ուստի նրանք չեն կարող ձեզ գրանցել։ «Լսեք,– ասում եք դուք,– ամեն ինչ այստեղ է, ամրագրումը և հաստատումը, չե՞ք կարող հիմա ինձ սենյակի բանալին տալ և գրանցումն ավարտել հետո»։ «Կներեք,– պատասխանում են նրանք,– բանալի ստանալու միակ ճանապարհը Համակարգի միջոցով գրանցվելն է»։ Համակարգը, բնականաբար, սովորական վեբ հավելված է, որն աշխատում է բրաուզերում։
Խնդրում են սպասել, և դուք սպասում եք. անցնում է 10 րոպե, հետո 20, երեխաները սկսում են քանդել նախասրահը, և վերջապես 30 րոպե հետո կապը վերականգնվում է և գրանցումը կատարվում է։ Կարելի է ասել՝ ընդամենը 30 րոպե է։ Բայց մյուս կողմից, դուք կոդ եք գրում մոտ 12 տարեկանից և չեք կարողանում հարցնել ինքներդ ձեզ՝ իսկապե՞ս պետք է հանդուրժենք այսպիսի տեխնոլոգիա։ Չէ՞ր կարող ավելի լավը լինել։
Իհարկե կարող էր։ Սա պարզապես վատ (թեև հավանաբար էժան) համակարգի նախագծում է, որը ցանցի խնդիրների դեպքում տալիս է «ոչ օպտիմալ»՝ մեղմ ասած, օգտատիրական փորձ։
Local-first՞
Արդեն երկար ժամանակ է՝ ինձ դուր է գալիս local-first մոտեցումը։ Այն լի է գաղափարներով, որոնք պարզապես «ճիշտ» են զգացվում. ձեր տվյալները պատկանում են ձեզ, կենտրոնական սերվերը հարմարություն է, այլ ոչ թե պահանջ, հավելվածը շարունակում է աշխատել խափանումների ժամանակ։ Ուստի մտքովս անցավ՝ կարո՞ղ է սա լինել հյուրանոցի գրանցման խնդրի պատասխանը։
Հաջորդ օրվա երկար ճանապարհին այդ մասին մտածելիս եզրակացրի, որ լիարժեք local-first հավելվածը ամենայն հավանականությամբ չափազանց մեծ լուծում կլիներ այսպիսի խնդրի համար։ Գործիքներն ու տեխնիկաները գոյություն ունեն, օրինակ՝ CRDT-ները և automerge-ը, բայց դրանք փայլում են այնպիսի ոլորտներում, ինչպիսիք են համատեղ խմբագրումը և վատ կապ ունեցող բջջային հավելվածները։
Սակայն մենք կարող ենք այդ գաղափարներից մի քանիսը փոխառել՝ կառուցելու համար «local-second» լուծում։ Սովորաբար համակարգը կաշխատեր դասական, կենտրոնացված client-server եղանակով, այսինքն՝ որպես լիովին ստանդարտ վեբ հավելված + HTTP API։
Բայց երբ ցանցը խափանվում է, այն կանցնի offline ռեժիմի՝ սահմանափակ ֆունկցիոնալությամբ։ Հիմնական ծառայությունները մնում են հասանելի, իսկ տվյալները բուֆերավորվում են մինչև կապի վերականգնումը։
Այստեղ հիմնական ֆունկցիոնալությունը հյուրերին գրանցելն է, որպեսզի նրանք երկար ճանապարհից հետո հանգստանան. մյուս գործողությունները կարող են անհասանելի լինել։
Event-driven PoC
AI կոդավորման օգնականների օգնությամբ (Claude Code, եթե հետաքրքրում է) ես կառուցեցի PoC հավելված, որն իրականացնում է այսպիսի local-second վեբ հավելվածի կմախքը՝ իր backend-ի հետ միասին։ Սակայն մինչև կոդին անցնելը պետք է մի քանի որոշում կայացնել տեխնոլոգիաների և հենց ճարտարապետության վերաբերյալ։
Ավանդական վեբ հավելվածում ամբողջ տրամաբանությունը լիովին վերահսկվում և կենտրոնացված է սերվերի վրա։ Այստեղ, ընդհակառակը, սերվերային այդ տրամաբանությունից բացի, մենք երբեմն (offline ժամանակահատվածներում) ունենք տվյալների փոփոխություններ, որոնք ամբողջովին կատարվում են client-ի վրա և համաժամեցվում են միայն հետո։
Որպեսզի այսպիսի կառուցվածքի շուրջ դատողություններ անելն ավելի հեշտ լինի, ես որոշեցի կառուցել իրադարձությունների (events) վրա։ Backend-ը event-driven է. իրադարձությունները ճշմարտության հիմնական աղբյուրն են, և դրանք պահպանվում են, ինչը մեզ տալիս է audit trail և արագ query-ների համար projection-ներ կառուցելու հնարավորություն։
Event sourcing-ը հաճախ կապվում է NoSQL տվյալների բազաների և CQRS pattern-ի հետ, և այն հակված է բարդ լինելու eventual consistency-ի պատճառով։ Սակայն դա անհրաժեշտություն չէ. event sourcing-ը կարելի է իրականացնել ռելյացիոն տվյալների բազայի վրա՝ ստանալով ատոմական transaction-ների առավելությունները։
Ես ընտրեցի հենց այս ճանապարհը. transactional event sourcing PostgreSQL-ի վրա, projection-ներով, որոնք միշտ համակարգված են, քանի որ թարմացվում են նույն transaction-ում, որում ներմուծվում է իրադարձությունը։
Online ռեժիմում հավելվածն իրեն պահում է որպես միանգամայն սովորական, անհետաքրքիր CRUD վեբ հավելված։ Որպես backend HTTP API-ի օգտատեր՝ դուք երբեք չեք տեսնում իրադարձությունները։ Կան /checkin, /checkout, POST /bookings (ամրագրում ստեղծելու) endpoint-ներ։ Ներքուստ դրանք արձակում են իրադարձություններ և թարմացնում համապատասխան projection-ները։ Ընթացիկ ամրագրումները ստացվում են պարզ GET /bookings հարցումով, որը query է անում իրադարձությունների projection-ի տեսքով կառուցված աղյուսակին։ Ուրեմն ինչո՞ւ առհասարակ անհանգստանալ իրադարձություններով։

Որովհետև դրանք կտրուկ պարզեցնում են ճարտարապետությունը և համակարգի շուրջ դատողությունների եղանակը, երբ offline ռեժիմը ստանձնում է աշխատանքը։ Թուլացված ռեժիմում աշխատելիս մենք պետք է կարողանանք հյուրերին գրանցել տեղում՝ բուֆերավորելով փոփոխությունները (օրինակ՝ սենյակի հատկացումը)։ Երբ համակարգը կրկին online է, այն պետք է այդ փոփոխություններից յուրաքանչյուրը ուղարկի backend-ին, որը պետք է կիրառի դրանք տվյալների բազայում։ Եվ backend-ը (պայմանով, որ client-ը պատշաճ կերպով նույնականացված է) միշտ պետք է ընդունի այդպիսի հարցումներ. իրադարձությունները անփոփոխ փաստեր են, գրանցումն արդեն տեղի է ունեցել։
Այսպիսով, offline գրանցումները հավաքվում են որպես client-ի կողմի իրադարձություններ։ Երբ համակարգը կրկին online է դառնում, դրանք մեկ առ մեկ ուղարկվում են backend-ին։ Այնտեղ client-ի կողմի յուրաքանչյուր իրադարձություն թարգմանվում է սերվերի կողմի իրադարձության և մշակվում ճիշտ այնպես, ինչպես «սովորական» եղանակով արձակված ցանկացած իրադարձություն։

Տրամաբանությունը կոկիկ կերպով պարփակված է իրադարձությունների handler-ներում, որոնք աշխատում են և՛ երբ իրադարձությունը գալիս է online HTTP API կանչից, և՛ երբ գալիս է offline «հասնելու» մեխանիզմից։ Դրա վրա ավելանում է, որ client-ը և սերվերը կիսում են իրադարձությունների նույն հասկացությունը՝ որպես համակարգում տեղի ունեցած փաստեր, ինչը տալիս է հավելվածի շուրջ դատողությունների համահունչ շրջանակ։
Տեխնիկական մանրամասներ և backend-ի տվյալների համաժամեցումը frontend-ի հետ
Մենք դեռ տեխնոլոգիաներ չենք ընտրել։ PoC-ի frontend-ի համար ես ընտրեցի React+Typescript։ Backend-ի համար՝ Rust+Axum+sqlx (որովհետև ինչո՞ւ չէ)։ PostgreSQL-ի հետ խոսելու ունակ ցանկացած backend լեզու կաշխատեր, իսկ Rust-ը և՛ արագ է, և՛ ուժեղ տիպերի ստուգմամբ, ինչը շատ է համապատասխանում իմ ճաշակին։
Որպես կողմնակի առաջադրանք՝ ես ուզում էի պարզել, թե ինչպես է Claude Code-ը գլուխ հանում, երբ խնդրում են իրականացնել ոչ հիմնական հոսքի backend pattern (transactional event sourcing)՝ վերը նշված հոդվածներով առաջնորդվելով, այնպիսի լեզվով, որի վրա այն հիմնականում չի մարզվել և որը հազիվ թե CRUD backend-ների համար սովորական ընտրություն է։ Արդյունքը՞ Լիարժեք հաշվետվությունը կհայտնվի հաջորդ ամսվա This Month We AIed-ում, բայց ահա սփոյլեր. այն բավականին լավ հանդես եկավ, և backend կոդի գրեթե ամբողջը AI-ի ստեղծածն է, թեև պահանջեց խիստ հսկողություն։
Կան երկու frontend հավելվածներ. մեկը թույլ է տալիս հյուրերին ամրագրել հյուրանոցներ, մյուսը՝ ընդունարանի աշխատակիցներին գրանցել և դուրս գրել հյուրերին։ Իրականացումը չափազանց նվազագույն է, ավելի շուտ կմախք. բացակայում են հիմնական հնարավորություններ, օրինակ՝ ցանկացած տեսակի անվտանգություն։
Եվս մեկ ֆունկցիոնալություն դեռ չի դիտարկվել. frontend-ի վիճակը backend-ի վիճակի հետ համաժամեցված պահելը։ Ընդունարանի աշխատակիցը սովորաբար հավելվածը բաց կպահեր ամբողջ ժամանակ, ուստի backend-ի վիճակը պետք է անընդհատ համաժամեցվի frontend-ի հետ։
Ինչպես միշտ, դա անելու մի քանի խելամիտ եղանակ կա։ Frontend-ը, օրինակ, կարող է WebSocket կապ բացել backend-ի հետ, ստանալ իրադարձությունների հոսք (պարտադիր չէ նույնը, ինչ backend-ը պահպանում է, այլ դրանց ինչ-որ փոխակերպում) և կիրառել դրանք տեղում։ Կամ կարող է պարբերաբար հարցում անել այսօրվա ամրագրումների համար։ Կամ…
Իրականում կան մի քանի frontend լուծումներ, որոնք հատուկ ստեղծված են local-first հավելվածների համար, ուստի որոնումս սկսեցի այնտեղից։ Դրանցից մեկը RxDB-ն է՝ local-first JavaScript տվյալների բազա՝ տվյալները backend-ի հետ համաժամեցնելու ֆունկցիոնալությամբ։ Այն գայթակղիչ է, բայց ավելի մոտիկից նայելիս երևում է, որ այն ավելի շատ նախատեսված է «լիարժեք» local-first հավելվածների համար և պարտադիր չէ, որ իդեալական լինի մեր local-second մոտեցման համար։ RxDB-ում client-ը հիմնականում կառավարում է տվյալները, իսկ կոնֆլիկտները նույնպես լուծվում են client-ի վրա՝ նախքան սերվերի կողմից write-երն ընդունելը։ Հետաքրքիր տեխնոլոգիա է, պարզապես ճիշտ համապատասխանություն չէ։
Մեկ այլ տարբերակ է ElectricSQL-ը, որը թույլ է տալիս PostgreSQL query-ն անընդհատ համաժամեցնել JavaScript հավելվածի մեջ։ Այն աշխատում է որպես առանձին հավելված ձեր backend-ի կողքին, բայց client-ները չպետք է անմիջապես խոսեն դրա հետ։ Փոխարենը ձեր backend-ը պետք է գործի որպես proxy՝ հոգալով նույնականացումը և թույլտվությունը (authorization)՝ նախքան query-ն Electric instance-ին փոխանցելը։
Frontend-ում այն օգտագործում է long-polling հարցումներ՝ տվյալների թարմացումները անընդհատ ստանալու համար։ Դա հենց այն է, ինչ մեզ պետք է։
Electric-ը չունի ներկառուցված մեխանիզմ տեղային write-երը backend-ի հետ համաժամեցնելու համար, բայց այն նկարագրում է մի քանի pattern, որոնք կարող եք օգտագործել։
Մեր event-driven մոտեցումը նման է «shared persistent optimistic state»-ին, բայց առաջարկում է ավելի ընդհանուր պատասխան տեղային write-երը պահելու հարցին։ Այն հետևողականորեն արտապատկերում է client-ի կողմի իրադարձությունները սերվերի կողմի հասկացությունների վրա և պահպանում է աբստրակցիայի բարձր մակարդակ՝ ցածր մակարդակի insert/update գործողություններ հավաքելու փոխարեն։
ElectricSQL-ը գործնականում
Ինչպե՞ս է PoC-ն օգտագործում ElectricSQL-ը։ Electric-ի կենտրոնական հասկացությունը shape-ն է՝ frontend-ի հետ համաժամեցված պահվող query։ Rust backend հավելվածը բացահայտում է /hotels/{id}/bookings/shape endpoint, որը որոշակի query-ն proxy է անում տեղում աշխատող Electric instance-ին։ Արդյունքում client-ը չի կարող հոսքով ստանալ կամայական query-ներ, միայն մեկ ֆիքսված query։
Այստեղ այդ query-ն կարդում է տվյալները bookings projection-ից, որը թարմացվում է transactional եղանակով ամեն անգամ, երբ մշակվում են ամրագրման հետ կապված իրադարձություններ։ Ամեն անգամ, երբ ընթացիկ օրվա ամրագրումները փոխվում են, յուրաքանչյուր միացած client անմիջապես ստանում է տվյալները, և դրանք այնուհետև ցուցադրվում են սովորական React թարմացումներով։

Թերությունն այն է, որ Electric-ը այնպես օգտագործելը, ինչպես անում է PoC-ն, ներմուծում է eventual consistency-ի փոքր բաց։ Վերցնենք հյուրին դուրս գրելը. backend-ը նախ մշակում է հարցումը՝ արձակելով իրադարձություն և թարմացնելով ամրագրումների projection-ը։ Այդ պահին հարցումն ավարտված է, ինչպես նաև client-ի կողմի փոխազդեցությունը։
Արժե նշել, որ CQRS-ի նման ճարտարապետություններում eventual consistency-ի բացը սովորաբար գտնվում է սերվերի վրա։ Այստեղ eventual consistency-ն client-ի վրա է։ Այդ տարբերությունը կարող է կարևոր լինել կամ չլինել։ Այս հավելվածում դա խնդիր չէ, բայց այլ հավելվածներում կարող է լինել, այնպես որ հիշեք դա։
Այնուհետև Electric-ը նկատում է փոփոխությունը և փոփոխությունները ուղարկում client-ներին, ինչը թարմացնում է տեսքը։ Սովորաբար թարմացումը թվում է ակնթարթային, բայց HTTP API հարցման ավարտի և թարմացման ժամանման միջև կարող է լինել կարճ ուշացում։
Դրական կողմում՝ երբ offline իրադարձությունները համաժամեցվում են backend-ի հետ (երբ այն կրկին online է), frontend-ին ոչինչ անել պետք չէ. տեսքը պարզապես թարմացվում է, երբ bookings shape-ից նոր տվյալներ են գալիս։ Սա զգալիորեն պարզեցնում է համաժամեցման տրամաբանությունը։
Offline աջակցություն
Մեր local-second վեբ հավելվածը գրեթե պատրաստ է, բայց մեկ մանրուք դեռ պակասում է։ Ամեն ինչ լավ է աշխատում, երբ Ինտերնետը անջատվում է. վեբ հավելվածը անցնում է թուլացված ռեժիմի, որը կապի վերականգնումից առաջ թույլ է տալիս միայն offline գրանցումներ։
Բայց ի՞նչ է լինում, եթե ընդունարանի աշխատակիցը սեղմում է refresh և հավելվածը վերաբեռնվում է։ Refresh սեղմելը գործնականում ռեֆլեքս է, երբ ինչ-որ բան սխալ է ընթանում։ Մեր վեբ հավելվածի փոխարեն նա կտեսներ «This site can’t be reached» էկրանը։
Լուծումը Progressive Web App կառուցելն է, կարճ՝ PWA։ Այս ստանդարտն այժմ լայնորեն աջակցվում է և թույլ է տալիս քեշավորել ռեսուրսները և query-ների արդյունքները, որպեսզի դրանք հասանելի լինեն offline։ Հենց այն, ինչ մեզ պետք է։
Մեր հավելվածը PWA դարձնելը բավականին հեշտ է. այն հանգում է vite-pwa plugin-ի տեղադրմանը և որոշ կոնֆիգուրացիայի տրամադրմանը (օրինակ՝ հավելվածի պատկերակ, որը պարտադիր է. առանց դրա PWA հավելվածը ձախողվում է «լուռ», այսինքն՝ առանց որևէ սխալ հաղորդելու)։ Մենք պետք է թվարկենք offline օգտագործման համար քեշավորվող ռեսուրսները (այստեղ՝ բոլոր html, css, js ֆայլերը)։ Կարող եք ընտրել, արդյոք այդ ռեսուրսները network-first են, որտեղ բրաուզերը միշտ նախ որոնում է ավելի նոր տարբերակներ՝ նախքան քեշավորվածներին անցնելը, թե local-first, որտեղ բրաուզերը միշտ տրամադրում է տեղում քեշավորված ռեսուրսները՝ ավելի արագ բեռնելու համար, թարմացումների դժվարացման հաշվին։ PoC հյուրանոցային հավելվածում բոլոր ռեսուրսները network-first են։
Մենք նաև պետք է նշենք, թե backend-ի որ query-ների արդյունքները պետք է քեշավորվեն։ Այստեղ դրանք այն query-ներն են, որոնք վերադարձնում են հյուրանոցների ցանկը (ցուցադրվում է աշխատակցին, երբ նա սկսում է օգտագործել հավելվածը) և ընտրված հյուրանոցի մանրամասները (անվանում, սենյակների քանակ)։
Electric-ի bookings shape-ի արդյունքները քեշավորելը չի աշխատի։ Դրանք աստիճանական (incremental) են, իսկ մեզ հետաքրքրում է համակցված արդյունքը (սկզբնական query-ի արդյունքները գումարած թարմացումները), ոչ թե միայն վերջին ստացված տվյալները։ Այդ պատճառով մենք պետք է քեշավորենք Electric React hook-ի ելքը (որը միշտ վերջին, համակցված տվյալներն են) բրաուզերի local storage-ում։
Կենտրոնացված սերվերի բացակայություն
Այսպիսի local-second հավելված կառուցելը (որը սովորաբար աշխատում է որպես ավանդական client-server համակարգ և offline-ում անցնում է միայն տեղային ռեժիմի) նշանակում է հաշվի առնել մի քանի բան, քանի որ այլևս չկա կենտրոնական սերվեր, որը վավերացնում և համակարգում է տվյալների յուրաքանչյուր փոփոխություն։
Կարող է պատահել, օրինակ, որ երկու մարդ գրանցվեն նույն սենյակում։ Այդպիսի իրավիճակը պետք է ինչ-որ կերպ կառավարվի։ PoC-ն դա չի իրականացնում, բայց backend-ը պետք է ընդունի այդպիսի հակասող գրանցման հարցումներ։ Այնուհետև աշխատակիցները պետք է տեսնեն կոնֆլիկտի մասին տեսողական ազդանշան, այն լուծեն ձեռքով և կարողանան հյուրին նորից գրանցել այլ սենյակում։
Սա նույնպես բխում է event-driven մոտեցումից. իրադարձությունը, երբ արդեն գոյություն ունի, պետք է դիտարկվի որպես փաստ, դրա հետ վիճել չի կարելի։ Այն արդեն տեղի է ունեցել, և ձեր անելիքը միայն իրավիճակը շտկելու փորձն է (հնարավոր է՝ փոխհատուցող իրադարձություններ ստեղծելով)։
Իսկ ի՞նչ անել մի քանի գրանցման սեղանների դեպքում։ Թուլացված ռեժիմում կամ դրանցից միայն մեկը պետք է գործի, կամ աշխատակիցները ձեռքով պետք է պայմանավորվեն, թե որ սենյակները հատկացնեն իրենց հյուրերին։
Իդեալական դեպքում տեղային վեբ հավելվածները կարող էին միմյանց հետ հաղորդակցվել տեղային ցանցով։ Բայց բրաուզերի անվտանգության մոդելը դա անհնար է դարձնում։ WebRTC-ը մի բան է, որ կարելի է փորձել. այն տրամադրում է տեղային կապ, բայց դեռ պահանջում է կենտրոնական signalling սերվեր՝ սկզբնական կապերը համակարգելու համար։ Մեկ այլ հնարավորություն է բրաուզերից դուրս տեղային սերվեր աշխատեցնելը, որը խոսում է մյուս տեղային client-ների հետ և պահպանում է offline իրադարձությունների ընդհանուր պատկերը։
TL;DR
Ցանցի խափանումները պարզապես կյանքի մի մասն են, անկախ նրանից՝ առաջացել են ծառայության խափանումներից, թե Ինտերնետ մատակարարների տեղային խնդիրներից։ Հյուրանոցի գրանցումները հավանաբար բավականաչափ կրիտիկական չեն համակարգի լրացուցիչ բարդությունը արդարացնելու համար, բայց մյուս կողմից՝ չէ՞ր պետք օգտատիրական փորձը առաջ դասվի հյուրանոցի համակարգի տեխնիկական սահմանափակումներից։
Ամեն դեպքում, local-second հավելվածը նպատակ ունի միավորել երկու բան. կենտրոնացված տվյալների բազայի և սերվերի հարմարությունը, որոնք համակարգում են համակարգի տրամաբանությունը, կանխում կոնֆլիկտները և բոլորին թարմ պահում, և հիմնական ֆունկցիոնալության հասանելի պահելը offline «թուլացված ռեժիմի» միջոցով, որում միայն կրիտիկական տրամաբանությունն է աշխատում զուտ client-ի կողմում և համաժամեցվում հետո։
Սերվերի և client-ի տրամաբանությունը երկուսն էլ իրադարձությունների շուրջ կառուցելը տալիս է համակարգը հասկանալու և դրա շուրջ դատողություններ անելու համահունչ շրջանակ։ Իրադարձությունները անփոփոխ փաստեր են, որոնք համակարգը միշտ պետք է մշակի։ Transactional event sourcing-ը տալիս է event sourcing-ի առավելությունները՝ միասին SQL query-ներ միշտ համակարգված projection-ների վրա աշխատեցնելու հարմարության հետ։ Իրադարձությունների ամենուր օգտագործումը հնարավոր է դարձնում տեղային write-երը սերվերի հետ համաժամեցնել՝ պահպանելով աբստրակցիայի բարձր մակարդակ։
Վերջապես, ElectricSQL-ը առաջարկում է backend տվյալների բազայի փոփոխությունները frontend-ի հետ համաժամեցնելու մաքուր եղանակ՝ անկախ այն բանից, փոփոխություններն արվել են online, թե offline ժամանակահատվածից հետո «հասնելու» ընթացքում։
Online ռեժիմում սենյակները հատկացնում է սերվերը։ Offline ռեժիմում հայտնվում է սենյակը ձեռքով ընտրելու էկրան. կապի վերականգնումից հետո փոփոխությունները համաժամեցվում են ընդունարանի հավելվածի մյուս instance-ների հետ։
Դուք հանդիպե՞լ եք նման խնդիրների ձեր աշխատած հավելվածներում։ Ինչպե՞ս եք լուծել դրանք։