נגיד ויש לי חדר ענק עם המון אנשים
האם אני יכול לגרום לאנשים לספור את עצמם (להסכים על מספר האנשים בחדר)?
נניח ואני נותן לכול אחד חוזה עם הוראות
1. מצא אדם רנדומלי.
2. האם הוא כבר ספור?
3. הצטרף לקבוצה או פיתרון אחר [אין לי מוסג איך לעשות את ז;ה]....
...
סוף משחק - כאשר כולם מסכימים שיש נגיד 700 אנשים בחדר

ואם אני מכניס אדם נוסף לחדר אז החדר יוצא משיווי משקל לרגע ואז כולם מסכימים שיש 701 אנשים

נניח ואין אפשרות ״ליצעוק״ בחדר (כמו udp) אבל אפשר לפנות לאדם רנדומלי (כמו tcp לאדם ספציפי רנדומלי)

ועדיף גם שאם הם בוחרים להתחלק לקבוצות אז יש מגבלת כמות אנשים בקבוצה (נגיד עד 10 משתתפים) גי אחרת זה יהיה לא יעיל כמו ליצעוק בכל החדר

מקווה שזאת לא שאלה ממש מפגרת או טרוויאלית..

השאלה שלך פשוטה מדי. ואני יפרט. אם אתה רוצה לדוגמה לספור מחשבים ברשת, הסיכויים שלך להצליח יהיו גדולים יותר, מפני שמחשבים (לפחות באופן תאורטי) הרבה יותר צפויים מבני אדם. הם יריצו את אותה תוכנה, אותה מערכת הפעלה וידווחו לאותו שרת master.
עם מספיק testing ואמצעי אבטחה (למנוע ממחשב לספור את עצמו פעמיים, או לזייף ספירה) אתה יכול להשיג תוצאות דיי טובות.

כאשר מדוברים באנשים זאת בעיה יותר מורכבת. אם אתה רוצה לדבר באופן תאורטי, אז זה אפשרי. בקבוצה קטנה זה יעבוד, אבל לפי דעתי מעל
50 אנשים כבר יהיה לך תהו ובהו.
כי בעולם האמיתי, אנשים הם שונים ומורכבים, הם יכולים לשקר, לשכח שהם ספרו את עצמם, לזייף ספירה, לחפות עם מישהו שלא נוכח ורשימת ה - edge cases לא תגמר. בכל מקרה לפי דעתי, אתה עדיין תצטרך אמצעי בקרה טכנולוגי או אנושי על מנת להבטיח שהספירה תקינה, ספירה עצמית תביא לך תוצאות
בעייתיות מאוד, שלא בטוח שתוכל לסמוך עליהן. זאת הסיבה שמערכת בחירות (בחירות לממשלה) עם מחשבים היא בעיה די קשה, (לא מבחינה טכנולוגית, אלא מבחינת המשתמשים, אך אתה יכול להגן על המערכת מפני בני אנוש).

יכול להיות שהשאלה שלך הרבה יותר פשוטה, ואתה מתכוון למשהו קצת פחות מורכב או רגיש (שמצריך מערכת אמינה) בכל מקרה זה ה - 2 cent
שלי.

בהצלחה.

אני חושב שדי הצלחתי בשלב הראשוני של לבנות את הכוורת
ה nodes קיבלו מספר מזהה רץ אבל זה יכול באותו אופן גם להיות uuid.
1. לבנות את הכוורת השתמשתי ב

קוד:

class Item {   readonly id: number   readonly maxConnections: number   readonly connections: Item[] = []   byDefaultTryConnectToItemId: number   getRemoteItemById: (id: number)=>Item   suggestConnectTo=0   isStable = false;   constructor(id: number,             maxConnections: number,             byDefaultTryConnectToItemId: number,             getRemoteItemById: (id: number)=>Item){     this.id = id     this.maxConnections = maxConnections;     this.byDefaultTryConnectToItemId = byDefaultTryConnectToItemId;     this.getRemoteItemById = getRemoteItemById;   }   get haveAvailableConnections(){     return this.connections.length < this.maxConnections;   }   itemIdNotInConnections(id: number): boolean{     return this.connections.filter((row)=>{return row.id === id;}).length ==0   }   canConnectItemToSelf(id: number){     const notTryToConnectSelf = this.id !== id;        if (notTryToConnectSelf && this.haveAvailableConnections &&       this.itemIdNotInConnections(id)){            return true     }     return false;   }   tryConnect(remoteItem:Item): boolean{     if (this.canConnectItemToSelf(this.byDefaultTryConnectToItemId) &&         remoteItem.canConnectItemToSelf(this.id)){         this.connections.push(remoteItem)         remoteItem.connections.push(this)         console.log("connected " + this.id + " " + this.byDefaultTryConnectToItemId)         return true     }     return false;   }   get isCompletellyStable():boolean {     return this.isStable &&     this.connections.filter( (row)=>{return row.isStable===true}).length ===this.connections.length   }   doTick(){     const r = this.getRemoteItemById( this.byDefaultTryConnectToItemId )     this.byDefaultTryConnectToItemId = r.suggestConnectTo     const remoteItem = this.getRemoteItemById( this.byDefaultTryConnectToItemId )     if (this.tryConnect(remoteItem)){       return;     } else if (this.canConnectItemToSelf(this.byDefaultTryConnectToItemId) &&       !remoteItem.canConnectItemToSelf(this.id) ){         this.byDefaultTryConnectToItemId = remoteItem.suggestConnectTo;         remoteItem.suggestConnectTo = this.id          const suggestedItem = this.getRemoteItemById( this.byDefaultTryConnectToItemId )         this.tryConnect(suggestedItem)     } else {       this.isStable =true;       console.log("Finished")           }   } } class ItemsCreator {   items: Item[]=[];   readonly itemsCountToInit: number;   readonly itemMaxConnections: number;   readonly byDefaultTryConnectToItemId: number;   constructor(itemsCountToInit: number, itemMaxConnections: number, byDefaultTryConnectToItemId: number){     this.itemsCountToInit = itemsCountToInit;     this.itemMaxConnections = itemMaxConnections;     this.byDefaultTryConnectToItemId = byDefaultTryConnectToItemId;   }   doInit(){     for(let i=0;i<this.itemsCountToInit;i++){       this.items.push(new Item(i, this.itemMaxConnections, this.byDefaultTryConnectToItemId,         (id: number)=>{           return this.items[id]         }))     }   }   clockTriggerAllItems(): void{        this.items.forEach(element => {       element.doTick()          });     console.log(this.items)   } } export const itemsCreator = new ItemsCreator(100, 3, 0) itemsCreator.doInit()

2. לקדם את השעון שהוא הקוצב לב שמניע את הריכוד הזה
הרצתי מספר פעמים
LOG of the second parameter in the constructor
בדוגמא שלי זה 100
גודל קבוצה 3
וה node הראשוני אליו להתחבר - הסימן הייחודי שלו זה 0
זה רק ניסיון חיבור אם הוא נכשל אז node[0] ימליץ למי כן להתחבר



3. ביגלל שהחיבור הוא לא מרכזי, כל node מכיר אישית למי הוא מתחבר ולכן החיבור יכול להיות בכרח חתום ומוצפן.

לבצע ספירה צריך למצוא דרך להעביר job באופן מבוזר
ה job לא חייב להיות ספירה הוא יכול להיות סוג של קריאת DNS


4. כשחושבים על זה זה יותר חזק מאיך ש dns מרכזי עובד היום כי זה מבוזר ולא ניתן לצנזורה...

אם אתה ברשת סגורה (למשל vlan), אתה יכול לספור mac address בבקשות ARP
כאשר מדובר ברטיסי רשת.

בקשות DHCP עבור IPv4.
במידה וזה IPv6 יש לך את הפרוטוקול של neighbor discovery.

אני רוצה להמנע מ Arp כי אני לא יודיע את גודל הרשת, (מה שקראתי לו ״גודל החדר)
כי udp הוא בעייתי (לכן משתמשים ב vlan, ואני אין יכולת לדעת מה יש מחוץ ל vlan או ה nat)

לכן שימוש ב ARP שזה udp בעייתי.
ipv6 זה נכון, יכול לתת מענה - אבל הרוב לא מיישמים אותו.
לי אישית אין ipv6

נקודה נוספת, גם אם יש לי peer discovery פתרתי את בעיית התשתית
אבל ברמתת האפליקציה עדיין אצטרך פיתרון (רשת mesh) כדי לשאול למי (ואם לספור אז לכמה מהם) מהחברים ב- mesh יש את הסרט שאני רוצה להוריד

יותר מיזה
נניח רשת היררכית עם up link לאנטרפרייז,
אם כדי לשאול ״למי יש את הסרט x״ תשתמש ב udp אל כל העץ
אחרי כמות לא גדולה של בקשות כאלה תגרום להפצצה של udp וקריסה של הראאוטרים בכל הרשת
(כמו ווירוס ה nimda בזמנו)
שלא לדבר על איך תחזיר את התשובה ותסכום אותה.....

בקיצור: לא ממש מסכימים כאן על דרכי העבודה. מי יכול מדבר עם מי? יש שעון משותף? יש מזהים יחודיים לכולם? איך מעבירים את התוצאה? יש שטח אחסון משותף? העברת הודעות?

מי יכול מדבר עם מי?
- ההנחה היא mesh, כאשר חייב להיות אחד (או כמה) שמקים את הראשת
אם כל אחד יבחר לו עם מי לעשות חיבור ראשוני, ייתכן ונקבל עצים נפרדים שלא מחוברים בניהם.
- בהמשך צריך להניח ש 70% מאחרי nat כל שהוא ipv4, אני מניח שבשלב הזה צריק לחשוב על פרוטוקול כמו קאדמילה - אבל אני ממש לא שם [ניסיתי להבין איך זה עובד ולא ממש הצלחתי]

יש שעון משותף?
ילכול אחד שעון משל עצמו, לא ניתן ליסמוך על ntp לסנכרון,או סדר טרנזקציות
אבל כדי לבדוק ייעילות המודל, ניתן טריגר כמו שעון לכל ה nodes
- המטרה שבפעימה הזאת יעשו את המקסימום האפשרי.

יש מזהים יחודיים לכולם?
כן, אבל כדי שאפשר יהיה לדבג נכניס אותם כמיספר רץ.
ל Job שרץ יש uuid

איך מעבירים את התוצאה?
חשבתי על זה, שאת התוצאה אפשר להעביר ישירות למי שיזם, אפילו לא צריך לשמור את הנתיב ממי שיזם.
ניתן לבדוק מי מה nodes אין לו את ה job הזה ולהפיץ אליו

יש שטח אחסון משותף?
לא, המטרה לאתר את הסרט [או מחרוזת מזהה] הספציפי אצל משהוא ספציפי ולהביא ישירות ממנו

העברת הודעות?
http post

תודה
שאלות שעזרו לי להבין

חשבתי על משהוא כזה

קוד:

class Job {   uuid=uuidv4();   jobRunStatus=JobRunStatus.Running   sttToFind: string   stopAfterFound: number //-i is infinet   maxChainLen: number //-i is infinet   finishedResultsItemIds:number[]=[]   currentChainItemIds: number[] = []   constructor(sttToFind: string, stopAfterFound: number, maxChainLen: number){     this.sttToFind = sttToFind;     this.stopAfterFound = stopAfterFound     this.maxChainLen = maxChainLen   }   get copyOperator(): Job{     const copy = new Job(this.sttToFind, this.stopAfterFound, this.maxChainLen);     copy.currentChainItemIds = [...this.currentChainItemIds];        return copy;   }   doRun(item: Item){     debugger;     if (this.jobRunStatus === JobRunStatus.Running) {       console.log(`running job ${this.sttToFind} for item ${item.id}`)       if (item.itemDataStorage.indexOf(this.sttToFind) > -1){         this.finishedResultsItemIds.push(item.id)         if (this.finishedResultsItemIds.length >= this.stopAfterFound){           this.jobRunStatus = JobRunStatus.Finished         } else {           //do subitems already has this job uuid, or un stable           //propegate to those who are not with           //currentChainItemIds.push(subItemId)           console.log("Propegate_to_child_Items(this_item_to_report_back)")         }               }     }         if (this.jobRunStatus === JobRunStatus.Finished) {       console.log(`# Finish job ${this.sttToFind} result in items`)       console.log(this.finishedResultsItemIds)       console.log("#")     }   } }