सुलह - वितरित सिस्टम में डेटा अखंडता की जाँच

वितरित प्रणालियों का विकास और उपयोग करते समय, हमें सिस्टम के बीच डेटा की अखंडता और पहचान की निगरानी के कार्य का सामना करना पड़ता है - सुलह का कार्य ।

इस ऑपरेशन के लिए ग्राहक द्वारा निर्धारित की जाने वाली आवश्यकताएं न्यूनतम समय हैं, क्योंकि जितनी जल्दी विसंगति का पता चलता है, उतनी ही आसानी से इसके परिणामों को खत्म करना होगा। यह कार्य इस तथ्य से काफी जटिल है कि सिस्टम निरंतर गति (~ 100,000 प्रति घंटे लेनदेन) और 0% विसंगतियों को प्राप्त नहीं कर सकता है।

मुख्य विचार

समाधान का मुख्य विचार निम्नलिखित आरेख में वर्णित किया जा सकता है।
हम प्रत्येक तत्व को अलग से मानते हैं।

डेटा एडेप्टर

प्रत्येक प्रणाली अपने स्वयं के विषय क्षेत्र के लिए डिज़ाइन की गई है और, परिणामस्वरूप, वस्तुओं के विवरण में काफी भिन्नता हो सकती है। हमें इन वस्तुओं से केवल एक निश्चित क्षेत्र की तुलना करने की आवश्यकता है।

तुलना प्रक्रिया को सरल बनाने के लिए, हम प्रत्येक डेटा स्रोत के लिए एक एडेप्टर लिखकर वस्तुओं को एक प्रारूप में लाते हैं। वस्तुओं को एक ही प्रारूप में लाने से उपयोग की जाने वाली मेमोरी की मात्रा को काफी कम किया जा सकता है, क्योंकि हम केवल तुलना किए जाने वाले फ़ील्ड को संग्रहीत करेंगे।

हुड के तहत, एडेप्टर में कोई भी डेटा स्रोत हो सकता है: HttpClient , SqlClient , DynamoDbClient , आदि।

निम्नलिखित IAdapter इंटरफ़ेस है जिसे आप लागू करना चाहते हैं:

public interface IAdapter<T> where T : IModel { int Id { get; } Task<IEnumerable<T>> GetItemsAsync(ISearchModel searchModel); } public interface IModel { Guid Id { get; } int GetHash(); } 

कोष

सभी डेटा पढ़ने के बाद ही डेटा सामंजस्य शुरू हो सकता है, क्योंकि एडेप्टर उन्हें यादृच्छिक क्रम में वापस कर सकते हैं।

इस मामले में, रैम की मात्रा पर्याप्त नहीं हो सकती है, खासकर यदि आप एक ही समय में कई सामंजस्य चलाते हैं, तो बड़े समय अंतराल का संकेत मिलता है।

IStorage इंटरफ़ेस पर विचार करें

 public interface IStorage { int SourceAdapterId { get; } int TargetAdapterId { get; } int MaxWriteCapacity { get; } Task InitializeAsync(); Task<int> WriteItemsAsync(IEnumerable<IModel> items, int adapterId); Task<IEnumerable<IResultModel>> GetDifferenceAsync(ISearchDifferenceModel model); } public interface ISearchDifferenceModel { int Offset { get; } int Limit { get; } } 

भंडारण। एमएस SQL ​​आधारित कार्यान्वयन

हमने MS SQL का उपयोग करके IStorage को लागू किया, जिसने हमें Db सर्वर की तरफ पूरी तरह से तुलना करने की अनुमति दी।

अनुरोध किए जा रहे मूल्यों को संग्रहीत करने के लिए, बस निम्नलिखित तालिका बनाएं:

 CREATE TABLE [dbo].[Storage_1540747667] ( [id] UNIQUEIDENTIFIER NOT NULL, [adapterid] INT NOT NULL, [qty] INT NOT NULL, [price] INT NOT NULL, CONSTRAINT [PK_Storage_1540747667] PRIMARY KEY ([id], [adapterid]) ) 

प्रत्येक रिकॉर्ड में सिस्टम फ़ील्ड ( [id] , [अनुकूलकआईड]] और तुलना के लिए फ़ील्ड ( [मात्रा] , [मूल्य] ) होते हैं। सिस्टम फ़ील्ड के बारे में कुछ शब्द:

[आईडी] - प्रविष्टि की अद्वितीय पहचानकर्ता, दोनों प्रणालियों में समान
[एडॉप्टरआईड] - एडेप्टर की पहचानकर्ता जिसके माध्यम से रिकॉर्ड प्राप्त किया गया था

चूंकि सामंजस्य प्रक्रियाएं समानांतर में शुरू की जा सकती हैं और अंतराल को इंटरसेक्ट कर सकती हैं, हम उनमें से प्रत्येक के लिए एक अद्वितीय नाम के साथ एक तालिका बनाते हैं। यदि सामंजस्य सफल रहा, तो यह तालिका हटा दी गई है, अन्यथा एक रिपोर्ट रिकॉर्ड की सूची के साथ भेजी जाती है जिसमें विसंगतियां हैं।

भंडारण। मान तुलना

कल्पना कीजिए कि हमारे पास 2 सेट हैं जिनके तत्वों का बिल्कुल समान फ़ील्ड फ़ील्ड है। उनके प्रतिच्छेदन के 4 संभावित मामलों पर विचार करें:

ए तत्व केवल बाएं सेट में मौजूद हैं।
बी तत्व दोनों सेट में मौजूद हैं, लेकिन उनके अलग-अलग अर्थ हैं।
सी तत्व केवल सही सेट में मौजूद हैं।
डी तत्व दोनों सेट में मौजूद हैं और इसका एक ही अर्थ है।

एक विशिष्ट समस्या में, हमें ए, बी, सी के मामलों में वर्णित तत्वों को खोजने की आवश्यकता है । आप फुल ऑर्ट जॉइन के माध्यम से MS SQL में एक क्वेरी में वांछित परिणाम प्राप्त कर सकते हैं:

 select [s1].[id], [s1].[adapterid] from [dbo].[Storage_1540758006] as [s1] full outer join [dbo].[Storage_1540758006] as [s2] on [s2].[id] = [s1].[id] and [s2].[adapterid] != [s1].[adapterid] and [s2].[qty] = [s1].[qty] and [s2].[price] = [s1].[price] where [s2].[id] is nul 

इस अनुरोध के आउटपुट में 4 प्रकार के रिकॉर्ड हो सकते हैं जो प्रारंभिक आवश्यकताओं को पूरा करते हैं

भंडारण। हैशिंग

तुलना की गई वस्तुओं पर हैशिंग का उपयोग करने से आप लिखने की लागत को काफी कम कर सकते हैं और संचालन की तुलना कर सकते हैं। विशेषकर जब दर्जनों क्षेत्रों की तुलना करने की बात आती है।

हैशिंग की सबसे सार्वभौमिक विधि किसी वस्तु का क्रमबद्ध प्रतिनिधित्व है।

1. हैशिंग के लिए, हम मानक गेटहैशकोड () पद्धति का उपयोग करते हैं, जो इंट 32 पर लौटता है और सभी आदिम प्रकारों के लिए ओवरराइड होता है।
2. इस मामले में, टकराव की संभावना की संभावना नहीं है, क्योंकि केवल समान पहचानकर्ताओं के साथ रिकॉर्ड की तुलना की जाती है।

इस अनुकूलन में प्रयुक्त तालिका संरचना पर विचार करें:

 CREATE TABLE [dbo].[Storage_1540758006] ( [id] UNIQUEIDENTIFIER NOT NULL, [adapterid] INT NOT NULL, [hash] INT NOT NULL, CONSTRAINT [PK_Storage_1540758006] PRIMARY KEY ([id], [adapterid], [hash]) ) 

इस तरह की संरचना का लाभ एक रिकॉर्ड (24 बाइट्स) के भंडारण की निरंतर लागत है, जो कि तुलना किए गए क्षेत्रों की संख्या पर निर्भर नहीं करेगा।

स्वाभाविक रूप से, तुलना प्रक्रिया अपने परिवर्तनों से गुजरती है और बहुत सरल हो जाती है।

 select [s1].[id], [s1].[adapterid] from [dbo].[Storage_1540758006] as [s1] full outer join [dbo].[Storage_1540758006] as [s2] on [s2].[id] = [s1].[id] and [s2].[adapterid] != [s1].[adapterid] and [s2].[hash] = [s1].[hash] where [s2].[id] is null 

प्रोसेसर

इस खंड में, हम एक ऐसे वर्ग के बारे में बात करेंगे जिसमें सुलह के सभी व्यापारिक तर्क शामिल हैं:

1. एडेप्टर से डेटा की समानांतर रीडिंग
2. डेटा हैशिंग
3. डेटाबेस में मानों का बफर रिकॉर्ड
4. परिणामों का वितरण

सामंजस्य प्रक्रिया का अधिक व्यापक विवरण अनुक्रम आरेख और IProcessor इंटरफ़ेस को देखकर प्राप्त किया जा सकता है ।

 public interface IProcessor<T> where T : IModel { IAdapter<T> SourceAdapter { get; } IAdapter<T> TargetAdapter { get; } IStorage Storage { get; } Task<IProcessResult> ProcessAsync(); Task<IEnumerable<IResultModel>> GetDifferenceAsync(ISearchDifferenceModel model); } 

धन्यवाद

राय के लिए MySale Group के मेरे सहयोगियों को बहुत धन्यवाद: AntonStrakhov , Nesstory , Barlog_5 , Kostya Krivtsun और VeterManve - विचार के लेखक।