अक्का क्लस्टर-शेरिंग: क्या एंट्री कलाकारों के पास गतिशील प्रोप

Question

अक्का क्लस्टर-शेर्डिंग दिखता है जैसे यह एक उपयोग मामले के साथ अच्छी तरह से मेल खाता है, मुझे अक्का नोड्स में राज्यव्यापी लगातार कलाकारों के एकल उदाहरण बनाना है।

मुझे यह स्पष्ट नहीं है कि यह संभव है कि एंटर्री अभिनेता के प्रकार के लिए इसे बनाने के लिए तर्क की आवश्यकता हो। या शायद मुझे इस बात पर पुनर्विचार करने की जरूरत है कि प्रवेश अभिनेता को यह जानकारी कैसे प्राप्त होती है।

Object Account { 
    def apply(region: String, accountId: String): Props = Props(new Account(region, accountId)) 
} 

class Account(val region: String, val accountId: String) extends Actor with PersistentActor { ... } 

ClusterSharding.start जबकि सभी एंट्री अभिनेताओं बनाने के लिए एक एकल प्रॉप्स उदाहरण में ले जाता है।

akka cluster-sharding से

:

val counterRegion: ActorRef = ClusterSharding(system).start(
    typeName = "Counter", 
    entryProps = Some(Props[Counter]), 
    idExtractor = idExtractor, 
    shardResolver = shardResolver) 

और फिर यह एंट्री अभिनेता है कि आप idExtractor कैसे परिभाषित के आधार पर संदेश प्राप्त करता है हल करता है।

def getEntry(id: EntryId): ActorRef = { 
val name = URLEncoder.encode(id, "utf-8") 
context.child(name).getOrElse { 
    log.debug("Starting entry [{}] in shard [{}]", id, shardId) 

    val a = context.watch(context.actorOf(entryProps, name)) 
    idByRef = idByRef.updated(a, id) 
    refById = refById.updated(id, a) 
    state = state.copy(state.entries + id) 
    a 
} 

}

यह मैं बजाय अपने क्षेत्र से बाहर मेरी एंट्री अभिनेता आंकड़ा है और चाहिए लगता है: ठीकरा यह यह देखा जा सकता के लिए स्रोत कोड से किसी दिए गए प्रवेश अभिनेता उदाहरण के लिए नाम के रूप में आईडी का उपयोग करता है खाते द्वारा नाम दिया गया है, हालांकि यह अब थोड़ा हैकी महसूस करता है कि मैं इसे सीधे मूल्य प्राप्त करने के बजाय स्ट्रिंग से बाहर निकाल रहा हूं। क्या यह मेरा सबसे अच्छा विकल्प है?

Answer 1

मैं आपके जैसी ही स्थिति में हूं। मेरे पास सही जवाब नहीं है लेकिन मैं आपके साथ और पाठकों के साथ साझा कर सकता हूं जो मैंने किया/कोशिश की/सोचा।

विकल्प 1) जैसा कि आपने बताया है, आप आईडी, शार्ड और क्षेत्र की जानकारी निकाल सकते हैं कि आप अपनी सामग्री का नाम कैसे देते हैं और पथ को पार्स करते हैं। उछाल ए) है कि यह करना आसान है। डाउनसाइड्स ए) अक्का यूटीएफ -8 के रूप में अभिनेता पथ को एन्कोड करता है, इसलिए यदि आप एक विभाजक के रूप में कुछ भी उपयोग कर रहे हैं जो एक मानक यूआरएल चरित्र (जैसे || या डब्ल्यू/ई) नहीं है तो आपको इसे पहले डीकोड करना होगा utf8 से। ध्यान दें कि अक्का utf8 के अंदर एन्कोडिंग विधि के रूप में हार्ड-कोड किया गया है, फ़ंक्शन में एन्कोडिंग प्रारूप निकालने का कोई तरीका नहीं है, इसलिए यदि कल अक्का परिवर्तन में आपको अपना कोड भी अनुकूलित करना होगा। बी) आपका सिस्टम अब होमोमोर्फिज्म को संरक्षित नहीं कर रहा है (आपका मतलब है "यह थोड़ी हैकी लगता है")। जिसका अर्थ यह है कि आप जोखिम जोड़ रहे हैं कि आपका डेटा, एक दिन में, आपकी जानकारी विभाजक स्ट्रिंग को सार्थक डेटा के रूप में शामिल किया जा सकता है और आपका सिस्टम गड़बड़ हो सकता है।

विकल्प 2) यदि आपके अस्तित्व में नहीं है तो शेर्डिंग आपके अभिनेता को उकसाएगी। इसलिए आप अपने कोड को गैर प्रारंभिक कलाकारों को हमेशा एक इनिट संदेश भेजने के लिए मजबूर कर सकते हैं, जिसमें आपके कन्स्ट्रक्टर पैरामीटर शामिल हैं। आपका sharded अभिनेताओं तरह का उनमें से अंदर कुछ करना होगा:

val par1: Option[param1Type] = None 

def receive = { 
    case init(par1value) => par1 = Some(par1value) 
    case query(par1) => sender ! par1 
} 

और अपने क्षेत्र का उपयोग कर सकते अभिनेता से आप हमेशा पहले क्वेरी संदेश और उसके बाद init संदेश भेज सकते हैं, तो वापसी नहीं है। यह मानता है कि आपके क्षेत्र का एक्सेस अभिनेता प्रारंभिक अभिनेताओं की एक सूची नहीं रखता है, इस मामले में आप केवल init के साथ पैदा हो सकते हैं और फिर उन्हें सामान्य रूप से उपयोग कर सकते हैं। उल्टा क) यह सुंदर ख है) यह "लगता है" सही

गिरावट: एक) यह 2x संदेशों लेता है (यदि आप) initialized अभिनेताओं की एक सूची

विकल्प 3) नहीं बनाए रखते हैं इस विकल्प का परीक्षण किया गया है और काम नहीं करता है। मैं इसे यहां कोशिश करने के लिए समय बर्बाद करने से बचने के लिए यहां छोड़ दूंगा। मुझे नहीं पता कि यह काम करता है, मैंने परीक्षण नहीं किया है क्योंकि मैं विशेष परिस्थितियों और फैंसी सामान के साथ उत्पादन में इस परिदृश्य का उपयोग कर रहा हूं^_^लेकिन कोशिश करने के लिए स्वतंत्र महसूस करें और कृपया मुझे एक बजे के साथ बताएं या टिप्पणी! मूल रूप से, आप

val counterRegion: ActorRef = ClusterSharding(system).start(
    typeName = "Counter", 
    entryProps = Some(Props[Counter]), 
    idExtractor = idExtractor, 
    shardResolver = shardResolver) 

के साथ अपने क्षेत्र शुरू क्या होगा यदि आप अपने क्षेत्र निर्माण अभिनेता में, की तरह कुछ कार्य करें:

var providedPar1 = v1 
def providePar1 = providedPar1 

val counterRegion: ActorRef = ClusterSharding(system).start(
    typeName = "Counter", 
    entryProps = Some(Props(classOf[Counter], providePar1), 
    idExtractor = idExtractor, 
    shardResolver = shardResolver) 

और फिर आप प्रत्येक निर्माण के लिए providedPar1 का मूल्य बदल? इसका नकारात्मक पक्ष यह है कि, जिस विकल्प में यह काम करता है, आपको प्रदान किए गए पैरा 1 के मूल्य को बदलने से बचने की आवश्यकता होगी जब तक कि आप 100% सुनिश्चित न हों कि अभिनेता बनाया गया है, या आप इसे नए, गलत मूल्य तक पहुंचने का जोखिम उठा सकते हैं (याय , दौड़ की स्थिति!)

सामान्य रूप से आप विकल्प 2 इम्हो के साथ बेहतर होते हैं, लेकिन ज्यादातर परिदृश्यों में 1 से शुरू होने वाले जोखिम छोटे होते हैं और आप सादगी (और प्रदर्शन) फायदे के साथ उन्हें ठीक से कम कर सकते हैं।

आशा है कि यह रान मदद करता है, अगर आप 3 कोशिश करते हैं कि यह कैसे काम करता है तो मुझे बताएं!