🥇 टॅरंटूलसाठी आमचे स्वतःचे कॅप्ड एक्सपायर्ड मॉड्यूल लिहिणे

काही काळापूर्वी आम्हाला जागांमधील टपल्स साफ करण्याची समस्या आली. तारांतुलटॅरंटूलची मेमरी कमी असताना साफसफाई सुरू करणे आवश्यक नव्हते, तर आगाऊ आणि एका विशिष्ट वारंवारतेने सुरू करणे आवश्यक होते. या कामासाठी टॅरंटूलमध्ये लुआ भाषेत लिहिलेले एक मॉड्यूल आहे, ज्याला म्हणतात कालबाह्यथोड्या काळासाठी हे मॉड्यूल वापरल्यानंतर, आम्हाला जाणवले की ते आमच्या गरजांसाठी योग्य नाही: मोठ्या प्रमाणात डेटाच्या सतत साफसफाई दरम्यान लुआ क्रॅश होत होता. म्हणून आम्ही आमचे स्वतःचे कॅप्ड एक्सपायरेशन मॉड्यूल विकसित करण्याचा विचार केला, अशी आशा होती की मूळ प्रोग्रामिंग भाषेत लिहिलेला कोड आमच्या गरजा सर्वोत्तम प्रकारे पूर्ण करेल.

आमच्यासाठी एक चांगले उदाहरण म्हणजे टॅरंटूल मॉड्यूल ज्याला म्हणतात memcachedतो वापरत असलेला दृष्टिकोन ट्युपलचा टाइम-टू-लाइव्ह (TTL) निर्दिष्ट करणाऱ्या जागेत एक वेगळे फील्ड तयार करण्यावर आधारित आहे. मॉड्यूल पार्श्वभूमीतील जागा स्कॅन करतो, TTL ची सध्याच्या वेळेशी तुलना करतो आणि ट्युपल हटवायचा की नाही हे ठरवतो. मेमकॅच केलेल्या मॉड्यूलचा कोड सोपा आणि सुंदर आहे, परंतु खूप सामान्य आहे. प्रथम, तो कोणत्या प्रकारचा इंडेक्स ट्रॅव्हर्स केला जात आहे आणि हटवला जात आहे हे विचारात घेत नाही. दुसरे, प्रत्येक पास सर्व ट्युपल स्कॅन करतो, जे बरेच मोठे असू शकतात. कालबाह्य झालेल्या मॉड्यूलने पहिली समस्या सोडवली (ट्री इंडेक्स वेगळ्या वर्गात वेगळे करणे), तर दुसरी समस्या अद्यापही सुटलेली नाही. या तीन मुद्द्यांनी माझा स्वतःचा कोड लिहिण्याचा पर्याय निश्चित केला.

वर्णन

टॅरंटूलसाठी खूप चांगले दस्तऐवजीकरण आहे. ट्यूटोरियल C मध्ये तुमच्या स्वतःच्या संग्रहित प्रक्रिया कशा लिहायच्या याबद्दल मी तुम्हाला सल्ला देतो की तुम्ही प्रथम त्याशी परिचित व्हा, जेणेकरून तुम्हाला खाली दिसणारे आदेश आणि कोड समजतील. याकडे देखील लक्ष देणे योग्य आहे. संदर्भ तुमचे स्वतःचे कॅप्ड मॉड्यूल लिहिताना उपलब्ध असलेल्या ऑब्जेक्ट्सना, म्हणजे बॉक्स, फायबर, निर्देशांक и टीएक्सएन.

चला बाहेरून सुरुवात करूया आणि कॅप्ड एक्सपायर्ड मॉड्यूल कसा दिसतो ते पाहूया:

fiber = require('fiber')
net_box = require('net.box')
box.cfg{listen = 3300}
box.schema.func.create('libcapped-expirationd.start', {language = 'C'})
box.schema.user.grant('guest', 'execute', 'function', 'libcapped-expirationd.start')
box.schema.func.create('libcapped-expirationd.kill', {language = 'C'})
box.schema.user.grant('guest', 'execute', 'function', 'libcapped-expirationd.kill')
box.schema.space.create('tester')
box.space.tester:create_index('primary', {unique = true, parts = {1, 'unsigned'}})
capped_connection = net_box:new(3300)

सोप्या भाषेत, आपण आपल्या libcapped-expirationd.so लायब्ररी असलेल्या डायरेक्टरीमध्ये tarantool चालवतो. लायब्ररी दोन फंक्शन्स एक्सपोर्ट करते: start आणि kill. प्रथम, आपल्याला box.schema.func.create आणि box.schema.user.grant वापरून Lua मधून ही फंक्शन्स अॅक्सेस करण्यायोग्य बनवावी लागतील. नंतर, आपण एक स्पेस तयार करतो ज्याच्या ट्युपल्समध्ये फक्त तीन फील्ड असतील: पहिले युनिक आयडेंटिफायर, दुसरे ईमेल अॅड्रेस आणि तिसरे ट्युपल्सचे लाईफटाइम. आपण पहिल्या फील्डच्या वर एक ट्री इंडेक्स तयार करतो आणि त्याला प्रायमरी म्हणतो. पुढे, आपल्याला आपल्या मूळ लायब्ररीसाठी कनेक्शन ऑब्जेक्ट मिळतो.

तयारीच्या कामानंतर, आम्ही स्टार्ट फंक्शन लाँच करतो:

capped_connection:call('libcapped-expirationd.start', {'non-indexed', box.space.tester.id, box.space.tester.index.primary, box.space.tester.index.primary, 3, 1024, 3600})

हे उदाहरण स्कॅनिंग दरम्यान अगदी त्याच प्रकारे काम करेल जसे एक्सपायर्ड मॉड्यूल, जे लुआ मध्ये लिहिलेले आहे. स्टार्ट फंक्शनला दिलेला पहिला युक्तिवाद म्हणजे युनिक टास्क नेम. दुसरा स्पेस आयडेंटिफायर. तिसरा युनिक इंडेक्स आहे ज्याद्वारे ट्युपल्स डिलीट केले जातील. चौथा इंडेक्स आहे ज्याद्वारे ट्युपल्स ट्रॅव्हर्स केले जातील. पाचवा ट्युपल्स फील्ड नंबर आहे ज्यामध्ये लाइव्ह वेळ आहे (क्रमांकन 1 पासून सुरू होते, 0 पासून नाही!). सहावा आणि सातवा स्कॅनिंग सेटिंग्ज आहेत. 1024 ही एका व्यवहारात स्कॅन केलेल्या ट्युपल्सची कमाल संख्या आहे. 3600 हा सेकंदात पूर्ण स्कॅन वेळ आहे.

लक्षात ठेवा की उदाहरणात ट्रॅव्हर्सल आणि डिलीशनसाठी समान इंडेक्स वापरला आहे. जर तो ट्री इंडेक्स असेल, तर ट्रॅव्हर्सल लहान की वरून मोठ्या की कडे जाते. जर तो हॅश इंडेक्स सारखा दुसरा इंडेक्स असेल, तर ट्रॅव्हर्सल सामान्यतः यादृच्छिक क्रमाने केले जाते. जागेतील सर्व टपल्स एकाच स्कॅनमध्ये स्कॅन केले जातात.

चला ६० सेकंदांच्या आयुष्यासह जागेत अनेक टपल्स घालूया:

box.space.tester:insert{0, 'user0@tarantool.io', math.floor(fiber.time()) + 60}
box.space.tester:insert{1, 'user1@tarantool.io', math.floor(fiber.time()) + 60}
box.space.tester:insert{2, 'user2@tarantool.io', math.floor(fiber.time()) + 60}

चला इन्सर्शन यशस्वी झाले आहे का ते तपासूया:

tarantool> box.space.tester.index.primary:select()
---
- - [0, 'user0@tarantool.io', 1576418976]
  - [1, 'user1@tarantool.io', 1576418976]
  - [2, 'user2@tarantool.io', 1576418976]
...

चला ६०+ सेकंदांनंतर (पहिल्या टपल इन्सर्शनच्या सुरुवातीपासून मोजणी करून) सिलेक्टची पुनरावृत्ती करूया आणि कॅप्ड एक्सपायर्ड मॉड्यूल आधीच काम करत आहे का ते पाहूया:

tarantool> box.space.tester.index.primary:select()
---
  - []
...

चला काम थांबवूया:

capped_connection:call('libcapped-expirationd.kill', {'non-indexed'})

चला दुसरे उदाहरण पाहू जिथे ट्रॅव्हर्सलसाठी वेगळा इंडेक्स वापरला जातो:

fiber = require('fiber')
net_box = require('net.box')
box.cfg{listen = 3300}
box.schema.func.create('libcapped-expirationd.start', {language = 'C'})
box.schema.user.grant('guest', 'execute', 'function', 'libcapped-expirationd.start')
box.schema.func.create('libcapped-expirationd.kill', {language = 'C'})
box.schema.user.grant('guest', 'execute', 'function', 'libcapped-expirationd.kill')
box.schema.space.create('tester')
box.space.tester:create_index('primary', {unique = true, parts = {1, 'unsigned'}})
box.space.tester:create_index('exp', {unique = false, parts = {3, 'unsigned'}})
capped_connection = net_box:new(3300)

येथे, काही अपवाद वगळता, सर्वकाही पहिल्या उदाहरणाप्रमाणेच आहे. आपण तिसऱ्या फील्डच्या वर एक ट्री इंडेक्स तयार करतो आणि त्याला एक्सप म्हणतो. हा इंडेक्स प्रायमरी नावाच्या इंडेक्सप्रमाणे अद्वितीय असण्याची गरज नाही. ट्रॅव्हर्सल एक्सप इंडेक्स वापरून केले जाईल आणि डिलीशन प्रायमरी इंडेक्स वापरून केले जाईल. आपल्याला आठवते की पूर्वी दोन्ही केवळ प्रायमरी इंडेक्स वापरून केले जात होते.

तयारीच्या कामानंतर, आम्ही नवीन वितर्कांसह प्रारंभ फंक्शन चालवतो:

capped_connection:call('libcapped-expirationd.start', {'indexed', box.space.tester.id, box.space.tester.index.primary, box.space.tester.index.exp, 3, 1024, 3600})

चला पुन्हा जागेत अनेक टपल्स घालूया, ज्यांचे आयुष्य 60 सेकंद आहे:

box.space.tester:insert{0, 'user0@tarantool.io', math.floor(fiber.time()) + 60}
box.space.tester:insert{1, 'user1@tarantool.io', math.floor(fiber.time()) + 60}
box.space.tester:insert{2, 'user2@tarantool.io', math.floor(fiber.time()) + 60}

३० सेकंदांनंतर, आपण त्याच प्रकारे आणखी काही टपल्स जोडू:

box.space.tester:insert{3, 'user3@tarantool.io', math.floor(fiber.time()) + 60}
box.space.tester:insert{4, 'user4@tarantool.io', math.floor(fiber.time()) + 60}
box.space.tester:insert{5, 'user5@tarantool.io', math.floor(fiber.time()) + 60}

चला इन्सर्शन यशस्वी झाले आहे का ते तपासूया:

tarantool> box.space.tester.index.primary:select()
---
- - [0, 'user0@tarantool.io', 1576421257]
  - [1, 'user1@tarantool.io', 1576421257]
  - [2, 'user2@tarantool.io', 1576421257]
  - [3, 'user3@tarantool.io', 1576421287]
  - [4, 'user4@tarantool.io', 1576421287]
  - [5, 'user5@tarantool.io', 1576421287]
...

tarantool> box.space.tester.index.primary:select()
---
- - [3, 'user3@tarantool.io', 1576421287]
  - [4, 'user4@tarantool.io', 1576421287]
  - [5, 'user5@tarantool.io', 1576421287]
...

त्या जागेत असे ट्युपल्स शिल्लक होते ज्यांचे आयुष्य अंदाजे ३० सेकंद होते. शिवाय, आयडी २ आणि १५७६४२१२५७ च्या आयुष्यमान असलेल्या ट्युपलवरून आयडी ३ आणि १५७६४२१२८७ च्या आयुष्यमान असलेल्या ट्युपलकडे जाताना स्कॅन थांबला. एक्सप इंडेक्स कीजच्या क्रमामुळे १५७६४२१२८७ किंवा त्याहून अधिक आयुष्यमान असलेल्या ट्युपल्स स्कॅन केले गेले नाहीत. सुरुवातीपासूनच आम्ही ही बचत करण्याचे लक्ष्य ठेवत होतो.

चला काम थांबवूया:

capped_connection:call('libcapped-expirationd.kill', {'indexed'})

अंमलबजावणी

प्रकल्पाच्या सर्व वैशिष्ट्यांबद्दल सांगण्याचा सर्वोत्तम मार्ग म्हणजे त्याच्या स्रोताकडून माहिती मिळवणे. कोडया प्रकाशनात, आपण फक्त सर्वात महत्त्वाच्या मुद्द्यांवर लक्ष केंद्रित करू, म्हणजे, स्पेस बायपास अल्गोरिदम.

आपण start मेथडला पास केलेले आर्ग्युमेंट्स expirationd_task नावाच्या स्ट्रक्चरमध्ये साठवले जातात:

struct expirationd_task
{
  char name[256];
  uint32_t space_id;
  uint32_t rm_index_id;
  uint32_t it_index_id;
  uint32_t it_index_type; 
  uint32_t field_no;
  uint32_t scan_size;
  uint32_t scan_time;
};

नाव गुणधर्म हे कार्याचे नाव आहे. space_id गुणधर्म हा स्पेस आयडेंटिफायर आहे. rm_index_id गुणधर्म हा टपल डिलीट करण्यासाठी वापरल्या जाणाऱ्या अद्वितीय निर्देशांकाचा आयडेंटिफायर आहे. it_index_id गुणधर्म हा टपल ट्रॅव्हर्सलसाठी वापरल्या जाणाऱ्या निर्देशांकाचा आयडेंटिफायर आहे. it_index_type गुणधर्म हा टपल ट्रॅव्हर्सलसाठी वापरला जाणारा इंडेक्स प्रकार आहे. filed_no गुणधर्म हा टपल फील्ड क्रमांक आहे ज्यामध्ये टाइम-टू-लाइव्ह मूल्य आहे. स्कॅन_साईज गुणधर्म म्हणजे एका व्यवहारात स्कॅन केलेल्या टपलची कमाल संख्या. स्कॅन_टाइम गुणधर्म म्हणजे सेकंदांमध्ये पूर्ण स्कॅन वेळ.

आम्ही युक्तिवाद विश्लेषणाचा समावेश करणार नाही. हे कष्टाचे पण सोपे काम आहे आणि लायब्ररी तुम्हाला त्यात मदत करेल. मेसेजपक्कसाध्या mp_bool, mp_double, mp_int, mp_uint आणि mp_array प्रकारांचा वापर करण्याऐवजी, केवळ लुआमधून mp_map प्रकारासह जटिल डेटा स्ट्रक्चर म्हणून पास केलेल्या निर्देशांकांमध्ये अडचणी येऊ शकतात. तथापि, संपूर्ण निर्देशांकाचे विश्लेषण करणे आवश्यक नाही. फक्त त्याची विशिष्टता तपासणे, प्रकार मोजणे आणि ओळखकर्ता काढणे पुरेसे आहे.

पार्सिंगसाठी वापरल्या जाणाऱ्या सर्व फंक्शन्सच्या प्रोटोटाइपची यादी करूया:

bool expirationd_parse_name(struct expirationd_task *task, const char **pos);
bool expirationd_parse_space_id(struct expirationd_task *task, const char **pos);
bool expirationd_parse_rm_index_id(struct expirationd_task *task, const char **pos);
bool expirationd_parse_rm_index_unique(struct expirationd_task *task, const char **pos);
bool expirationd_parse_rm_index(struct expirationd_task *task, const char **pos);
bool expirationd_parse_it_index_id(struct expirationd_task *task, const char **pos);
bool expirationd_parse_it_index_type(struct expirationd_task *task, const char **pos);
bool expirationd_parse_it_index(struct expirationd_task *task, const char **pos);
bool expirationd_parse_field_no(struct expirationd_task *task, const char **pos);
bool expirationd_parse_scan_size(struct expirationd_task *task, const char **pos);
bool expirationd_parse_scan_time(struct expirationd_task *task, const char **pos);

आता आपण सर्वात महत्वाच्या भागाकडे वळूया - स्पेस ट्रॅव्हर्सल आणि ट्युपल डिलीशनमागील लॉजिक. स्कॅन_साईजपेक्षा मोठे नसलेले ट्युपलचे प्रत्येक ब्लॉक एकाच व्यवहाराद्वारे स्कॅन आणि मॉडिफाय केले जाते. यशस्वी झाल्यास, हा व्यवहार केला जातो; जर एखादी त्रुटी आली तर ती परत आणली जाते. expirationd_iterate फंक्शनला दिलेला शेवटचा युक्तिवाद इटरेटरकडे निर्देशक असतो जिथून स्कॅन सुरू होतो किंवा सुरू राहतो. एरर येईपर्यंत, स्पेस संपेपर्यंत किंवा प्रक्रिया लवकर थांबवण्याचा कोणताही मार्ग नसेपर्यंत हे इटरेटर अंतर्गतरित्या वाढवले जाते. expirationd_expired फंक्शन ट्युपलचे आयुष्यमान तपासते, expirationd_delete ट्युपल डिलीट करते आणि expirationd_breakable आपल्याला पुढे जायचे आहे की नाही ते तपासते.

Expirationd_iterate फंक्शन कोड:

static bool
expirationd_iterate(struct expirationd_task *task, box_iterator_t **iterp)
{
  box_iterator_t *iter = *iterp;
  box_txn_begin();
  for (uint32_t i = 0; i < task->scan_size; ++i) {
    box_tuple_t *tuple = NULL;
    if (box_iterator_next(iter, &tuple) < 0) {
      box_iterator_free(iter);
      *iterp = NULL;
      box_txn_rollback();
      return false;
    }
    if (!tuple) {
      box_iterator_free(iter);
      *iterp = NULL;
      box_txn_commit();
      return true;
    }
    if (expirationd_expired(task, tuple))
      expirationd_delete(task, tuple);
    else if (expirationd_breakable(task))
      break;
  }
  box_txn_commit();
  return true;
}

फंक्शन कोड expired_expired:

static bool
expirationd_expired(struct expirationd_task *task, box_tuple_t *tuple)
{
  const char *buf = box_tuple_field(tuple, task->field_no - 1);
  if (!buf || mp_typeof(*buf) != MP_UINT)
    return false;
  uint64_t val = mp_decode_uint(&buf);
  if (val > fiber_time64() / 1000000)
    return false;
  return true;
}

एक्सपायरेशनडी_डिलीट फंक्शन कोड:

static void
expirationd_delete(struct expirationd_task *task, box_tuple_t *tuple)
{
  uint32_t len;
  const char *str = box_tuple_extract_key(tuple, task->space_id, task->rm_index_id, &len);
  box_delete(task->space_id, task->rm_index_id, str, str + len, NULL);
}

Expirationd_breakable फंक्शन कोड:

static bool
expirationd_breakable(struct expirationd_task *task)
{
  return task->it_index_id != task->rm_index_id && task->it_index_type == ITER_GT;
}