מחלקת "תכנות נורמלי במערכות 'ימות'..."

[MusiCode]

@MusiCode אמר ב[מחלקת "תכנות נורמלי במערכות

זה נראה ככה:
בקשה ראשונה: https://call2yemot.com/ext
התשובה: read=f-000=ivr,n,...
(המילה הראשונה read היא מסמנת קבלת הקשות. אח"כ, שם הקובץ שיושמע כתפריט. אח"כ שם המשתנה שיוחזר)

למעשה הבקשה הראשונה נראית כך:
https://call2yemot.com/ext?ApiPhone=0504100000&ApiCallId=b6t76r7v6v4754c

[nigun]

@MusiCode
ליתר דיוק
ApiCallId=0b1b92e09984f1d6f200e3190b805a6ab0625f68&ApiDID=0773137777&ApiRealDID=0773137777&ApiPhone=0504100000&ApiExtension=5/1

[yossiz]

@MusiCode מה שאתה צריך הוא מימוש של generator coroutines .

משהו כזה:

var activeCalls = {};

function router(req, res) {
    var callId = getCallId(req);
    var currentCall = activeCalls[callId];
    if (currentCall) {
        var returnedValue = extractValue(req);
    } else {
        currentCall = activeCalls[callId] = Call();
        returnedValue = null;
    }
    var reply = currentCall.next(returnedValue);
    return res.send(reply.value);
}

function* Call() {
    yield playfile("file");
    var f = yield read("file", 1, 5, ...);
    yield goToFolder("/7/" + f);
    yield hangup();
}

אני לא מצרף מימוש של playfile, read, gotofolder, hangup כי אין לי מושג איך ה-API של ימות עובד. אבל כל אחד מפונקצייות אלו אמור להחזיר את המחרוזת שצריך להשיב למערכת ימות

[yossiz]

בהמשך להנ"ל,
בינתיים השתמשתי רק בקוד סינכרוני בתוך פונקציית call. אבל בחיים האמתיים תצטרכו מן הסתם קוד איסינכרוני.
מאז נוד 10 ומעלה אפשר להשתמש ב-Asynchronous generators.
זה נראה כך,

var activeCalls = {};
 
async function router(req, res) {
    var callId = getCallId(req);
    var currentCall = activeCalls[callId];
    if (currentCall) {
        var returnedValue = extractValue(req);
    } else {
        currentCall = activeCalls[callId] = Call();
        returnedValue = null;
    }
    var reply = await currentCall.next(returnedValue);
    return res.send(reply.value);
}
 
async function* Call() {
    yield playfile("file");
    var f = yield read("file", 1, 5, ...);
    yield goToFolder("/7/" + f);
    yield hangup();
}

אני מקווה ללמוד יותר את ה-API של ימות ואז אוכל להביא משהו יותר מושלם.

[yossiz]

איזה מחרוזת שולחים כדי לסיים את השיחה בימות?
אני מנסה לעשות סוג של hello world עם yield כדי להדגים צורת הפעולה

@MusiCode האם הקוד הנ"ל עונה על דרישותיך? הפונקציה call נראה כמעט כמו הקוד שלך רק בתוספת המילה yield.

[nigun]

@yossiz
החיבור יכול להסתיים במעבר לשלוחה אחרת
ואז לא נשלח כלום
ואם הלקוח ניתק את השיחה כשהוא עדיין בשלוחת API המערכת תשלח את כל הערכים שנאספו עד עכשיו בשלוחה בתוספת hangup=yes

[yossiz]

@nigun אני שואל מה אני אמור לשלוח כדי לנתק את השיחה מהצד שלי?
(בקיצור מימוש של פונקציה בשם hangup)

[nigun]

@yossiz
שולחים את המשתמש לשלוחת ניתוק
(לא ידוע לי על דרך אחרת)

[yossiz]

@nigun אמר במחלקת "תכנות נורמלי במערכות 'ימות'...":

שולחים את המשתמש לשלוחת ניתוק

איך נראה המחרוזת שיעשה את זה? אני ממש ממש לא מכיר את מערכת ימות

[nigun]

@yossiz אמר במחלקת "תכנות נורמלי במערכות 'ימות'...":

אני ממש ממש לא מכיר את מערכת ימות

אתה לא מפסיד כלום
בכל מקרה מעבר לשלוחה אחרת בPHP יראה משהו כזה

print "go_to_folder=../";

ואם אתה רוצה שישמע הודעה לפני המעבר

print "id_list_message=f-028.n-100.f-029&go_to_folder=/4&";

שזה בעצם משמיע לו את קובץ 028 ואז את המספר 100 ואז את קובץ 029 ואז עובר לשלוחה 4

[yossiz]

@nigun אמר במחלקת "תכנות נורמלי במערכות 'ימות'...":

print "go_to_folder=../";

ואז בממשק של ימות מגדירים את השלוחה שינתק?

אגב, לא הבנתי מה בדיוק רצית לעשות בקוד ה-GO שהבאת למעלה, אבל מימוש של coroutine הוא אפילו יותר טבעי ב-GO מאשר ב-JS. לכאורה אפשר לעשות מחלקה שעושה את השימוש בימות ממש טבעי וזורם.

[nigun]

@yossiz אמר במחלקת "תכנות נורמלי במערכות 'ימות'...":

@nigun אמר במחלקת "תכנות נורמלי במערכות 'ימות'...":

print "go_to_folder=../";

ואז בממשק של ימות מגדירים את השלוחה שינתק?

כן

אגב, לא הבנתי מה בדיוק רצית לעשות בקוד ה-GO שהבאת למעלה, אבל מימוש של coroutine הוא אפילו יותר טבעי ב-GO מאשר ב-JS. לכאורה אפשר לעשות מחלקה שעושה את השימוש בימות ממש טבעי וזורם.

בקוד למעלה
ניסיתי לשאול האם אפשר להרוג תהליך שכבר רץ מקריאה קודמת
אז לצורך הדוגמה בניתי שרת HTTP שקריאה לlocalhost:8000/run מפעילה את הפונקציה run(foo)
(אין ל פונקציה כזאת כרגע זה כדי לתת הדגמה של הפעלת תהליך)
וכיון שזה קריאה א-סינכרונית אני לא צריך להישאר בדף כדי שפונקציה תמשיך לרוץ
אבל אם הפונקציה היא אינסופית או שרצה להרבה זמן
אני רוצה דרך לשלוט עליה עם קריאה נפרדת
למשל להרוג את התהליך אחרי שעה
אז רציתי שיהיה אופציה בסגנון של קריאה ל localhost:8000/kill
שמפעילה את הפונקציה kill(foo)
ובעברית "להרוג את תהליך foo"
אבל הבעיה היא שאי אפשר להשפיע על התהליך מהקריאה הקודמת ע"י קריאה בשם של התהליך (foo)
אמנם אם אני מקבל בשעת ההפעלה את הPID של התהליך אז אני יכול להרוג אותו ע"י קריאה לPID
(לכאורה אני יכול להחליט בהפעלה מה הPID כדי שאני אוכל לגשת אליו אחר כך
ואם לא אפשר לקבל אותו בהפעלה ולשמור אותו איפה שהוא
אבל כל זה נוגע להריגת התהליך אבל להמשיך הפעלה לאותו תהליך זה כבר משהו אחר

[MusiCode]

@yossiz אמר במחלקת "תכנות נורמלי במערכות 'ימות'...":

@MusiCode מה שאתה צריך הוא מימוש של coroutines.

משהו כזה:

var activeCalls = {};

function router(req, res) {
    var callId = getCallId(req);
    var currentCall = activeCalls[callId];
    if (currentCall) {
        var returnedValue = extractValue(req);
    } else {
        currentCall = activeCalls[callId] = Call();
        returnedValue = null;
    }
    var reply = currentCall.next(returnedValue);
    return res.send(reply.value);
}

function* Call() {
    yield playfile("file");
    var f = yield read("file", 1, 5, ...);
    yield goToFolder("/7/" + f);
    yield hangup();
}

אני לא מצרף מימוש של playfile, read, gotofolder, hangup כי אין לי מושג איך ה-API של ימות עובד. אבל כל אחד מפונקצייות אלו אמור להחזיר את המחרוזת שצריך להשיב למערכת ימות

אם זה אמיתי, זה מדהים!...
לא הבנתי, מה זה קורוטין?
אפשר הסבר?

אני מנסה להבין את הקוד, אבל כמו שאמרתי,
אני בנוד מלפני כמה ימים...
יש לי נוד אחרון.
צריך איזו חבילה לזה?

[yossiz]

@MusiCode אמר במחלקת "תכנות נורמלי במערכות 'ימות'...":

לא הבנתי, מה זה קורוטין?
אפשר הסבר?

generator coroutine הוא בדיוק החלום שלך, זה פונקציה שמפסיקה את עצמה באמצע ומחזירה ערך, ואח"כ אפשר להמשיך אותה בדיוק מהמקום שבו היא עצרה.
אפשר לקבל ערך מהפונקציה על כל עצירה, ולהעביר לפונקציה ערך על כל המשך הרצה.

ב-JS, עושים פונקציה כזאת עם התחביר: function*
העצירה והחזרת ערך מתבצעת על ידי מילת המפתח yield.
הרצת הפונקציה לא באמת מריצה אותה אלא מייצרת אובייקט מסוג generator. אפשר לקרוא generator.next כדי להריץ את השלב הבא של הפונקציה. generator.next מחזירה אובייקט בעלת 2 חברים {value: xxx, done: true/false}.

טוב, אידך פירושא זיל גמור...

אני מנסה להבין את הקוד, אבל כמו שאמרתי,

אני בנוד מלפני כמה ימים...

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

צריך איזו חבילה לזה?

לא
בעזה"י אעלה עוד מעט דוגמת hello world שעובד.

[nigun]

@yossiz
אני לא יודע איך זה עובד בנוד
אבל בגו כנראה שזה אותו דבר כי אפשר לעשות לולאה שתמשיך רק אם היא מקבלת את הערך לערוץ
אבל השאלה שלי איך אתה מכניס ערכים חדשים לתהליך שרץ מהקריאה הקודמת?
בא נשים לרגע בצד את הHTTP
במקרה שיש לך אפליקציה שאתה מעביר לה ארגומנטים משורת הפקודה
ואתה מפעיל coroutine שלא ממשיך עד שהוא מקבל את הערך yield
אם תפעיל שוב את האפליקציה משורת הפקודה עם הערך yield האם התהליך הראשון ימשיך או שהוא מחכה לו בערוץ שלו הוא לא יגמר לעולם

[yossiz]

@nigun הכל רץ בתוך תהליך אחד

נדבר על גו (למרות שאני לא מכיר)
על כל callid חדש אתה מריץ את הפונקציה (coroutine, שבמקרה של GO הוא גם goroutine).
בתוך הפונקציה אתה דוחף לתוך ערוץ את המחרוזת שאתה רוצה להחזיר לימות, ואז אתה מחכה לקבל חזרה את הבקשה הבאה של ימות.
בפונקציה הראשית, על כל בקשה מהשרת אתה מחלץ מתוכו את מזהה השיחה ודוחף את הפרמטרים לתוך הערוץ המתאים לפי מזהה השיחה, זה יגרום לפונקציה הנכונה להמשיך הרצתה.
פשוט מאוד, או שאני מפספס משהו?

[yossiz]

מצו"ב דגמה פשוטה, זה אמור לעבוד (פחות או יותר).
יש המון המון מה לשפר פה, אבל אפשר לקבל את הכיוון.
חילקתי את זה ל-2 קבצים:
yemot-api-handler.js (קוד המחלקה, ניתן לשימוש חוזר)

var activeCalls = {};

module.exports = class YemotAPIHandler {
    
    constructor(callHandler) {
        this.callHandler = callHandler;
    }
    
    async handle(req, res) {
        
        var callId = req.query.ApiCallId;
        //console.log(req.query);
        var currentCall = activeCalls[callId];
        if (currentCall) {
            var returnedValue = currentCall.getRetValue(req.query);
        } else {
            console.log(this);
            currentCall = activeCalls[callId] = new yemotCall(req.query, this.callHandler);
            returnedValue = null;
        }
        var reply = await currentCall.controller.next(returnedValue);
        console.log(reply);
        return res.send(reply.value);
    }
}

class yemotCall {
    constructor(query, callHandler) {
        this.ApiCallId = query.ApiCallId;
        this.ApiPhone = query.ApiPhone;
        this.controller = callHandler(this);
    };

    read(data, replyVar) {
        this.expect = replyVar;
        return `read=${data}=${replyVar}`;
    }
    
    goToFolder(folder) {
        return `go_to_folder=${folder}`;
    }
    
    getRetValue(query) {
        if (this.expect && query[this.expect])
        return query[this.expect];
        this.expect = null;
    }
}

simple-yemot-sample.js

const express = require('express');
const app = express();
const port = 3000;
const hangupExtension = "";

const YemotAPIHandler = require("./yemot-api-handler.js");

async function* callHandler(call) {
    var input = yield call.read(`t-שלום, אתה מתקשר ממספר ${call.ApiPhone}, הקש מספר כלשהו כעת ולאחריה סולמית`, "abc");
    yield `id_list_message=t-הקשתם ${input}.`;
    return call.goToFolder(hangupExtension);
}

var apiHandler = new YemotAPIHandler(callHandler);
app.get('*', apiHandler.handle.bind(apiHandler));

app.listen(port, ()=>console.log("YemotAPIHandler started!"));

נ.ב. לא נראה לי שאני הולך לעבוד על זה יותר כרגע. אשמח מאוד אם מישהו יעשה מזה משהו טוב...

[WWW]

@yossiz אמר במחלקת "תכנות נורמלי במערכות 'ימות'...":

איזה מחרוזת שולחים כדי לסיים את השיחה בימות?

@nigun אמר במחלקת "תכנות נורמלי במערכות 'ימות'...":

@yossiz
שולחים את המשתמש לשלוחת ניתוק
(לא ידוע לי על דרך אחרת)

אני חושב שאפשר ככה:

print "go_to_folder=hangup";

[dovid]

@yossiz זה ממש רעיון גאוני ההלבשה של הyield. לדעתי מתכנני התחביר לא התכוונו לזה...
למימוש הזה יש לזה חיסרון במקרה שייפול השרת (זה הערה לשמה, כלומר זה אחרי הכל נפלא אבל אני מחפש ב"דוקא" למה לא לעשות את הטריק הזה). אולי יותר נורמלי לצפות מ@MusiCode לכתוב בצורה לא פונקציונלית והכל יבוא על מקומו בשלום?
הרצון לכתוב לפעמים בצורה פשוטה ודקלרטיבית במקום קודים מסובכים גורמים לנו לסחוט מהשפה תחבירים :).

[yossiz]

@dovid אמר במחלקת "תכנות נורמלי במערכות 'ימות'...":

לדעתי מתכנני התחביר לא התכוונו לזה...

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

למימוש הזה יש לזה חיסרון במקרה שייפול השרת

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

טוב, אני צריך לחשוב...

עריכה: הבנתי איפה הבעיה...