@omar#4289 same as, I am getting the

Harshil Bodara · 2023-10-27T09:10:46.098Z

@omar same as, I am getting the same issue, I have explained my issue

H

Harshil BodaraOP•10/27/23, 9:13 AM

the first time, it is working correctly,
when re-call the water Schedule a second time does the calling schedule 2 times every 2 seconds, same as the next

O

omar4289•10/27/23, 9:30 AM

What is the code in the worker ?

O

omar4289•10/27/23, 9:30 AM

Do you always refer to the same do instance ?

O

omar4289•10/27/23, 9:31 AM

@Harshil Bodara

H

Harshil BodaraOP•10/27/23, 9:31 AM

But whenever I call the schedule, I want to call the alarm only once

H

Harshil BodaraOP•10/27/23, 9:32 AM

export class Water {
id: string | DurableObjectId;
storage: DurableObjectStorage;
doEverySeconds: number;
env: Env;

constructor(state: DurableObjectState, env: Env) {
this.storage = state.storage;
this.id = state.id;
this.doEverySeconds = 2;
this.env = env;
}

async fetch() {
const alarmTime = await this.storage.get("alarmTime");
console.log("alarmTime",alarmTime)
if (!alarmTime) {
await this.scheduleAlarm();
} else {
return new Response("Water alarm is already scheduled.");
}
return new Response("Water schedule Successfully!");
}

async alarm() {
console.log("Water Alarm Doing");
await this.scheduleAlarm();
}

async scheduleAlarm() {
let scheduledTime: number = Date.now() + this.doEverySeconds * 1000;
await this.storage.put("alarmTime", scheduledTime.toString());
this.storage.setAlarm(scheduledTime);
}
}

H

Harshil BodaraOP•10/27/23, 9:32 AM

O

omar4289•10/27/23, 9:33 AM

Ah Ok, I get your point, basically what you want to do is execute your alarm call once in 2 seconds, regardless of how many requests you receive within the 2 seconds range, right ?

H

Harshil BodaraOP•10/27/23, 9:34 AM

yes, exactly

O

omar4289•10/27/23, 9:35 AM

ok, let me send you the code

H

Harshil BodaraOP•10/27/23, 9:36 AM

for exmaple alaram calling
First time call = schudle call every 2 second (working fine)
second time call = 2 time schudle call every 2 second
third time call = 3 time schudle call every 2 second

but i want to do
-------------------------------------

First time call = schudle call every 2 second (working fine)
second time call = 1 time schudle call every 2 second
third time call = 1 time schudle call every 2 second

H

Harshil BodaraOP•10/27/23, 9:36 AM

O

omar4289•10/27/23, 9:37 AM

export class Water {
id: string | DurableObjectId;
storage: DurableObjectStorage;
doEverySeconds: number;
env: Env;

constructor(state: DurableObjectState, env: Env) {
this.storage = state.storage;
this.id = state.id;
this.doEverySeconds = 2;
this.env = env;
}

async fetch() {
const alarmTime = await this.storage.get("alarmTime");
console.log("alarmTime",alarmTime)
if (!alarmTime) {
await this.scheduleAlarm();
} else {
return new Response("Water alarm is already scheduled.");
}
return new Response("Water schedule Successfully!");
}

async alarm() {
console.log("Water Alarm Doing");
await this.storage.delete("alarmTime");
}

async scheduleAlarm() {
let scheduledTime: number = Date.now() + this.doEverySeconds * 1000;
await this.storage.put("alarmTime", scheduledTime.toString());
this.storage.setAlarm(scheduledTime);
}
}

O

omar4289•10/27/23, 9:37 AM

Just replaced the this.scheduleAlarm in the alarm function to await storage.delete

H

Harshil BodaraOP•10/27/23, 9:40 AM

when i call the API, so alaram calling is only one time

H

Harshil BodaraOP•10/27/23, 9:40 AM

not every 2 secondse

O

omar4289•10/27/23, 9:41 AM

This will be the outcome:
Call to DO at t + 1s: Will schedule the alarm
Call to DO at t + 1.5s: Will return alarm already scheduled (therefore would do nothing)
Call to DO at t + 2s: WIll return alarm already scheduled (therefore would do nothing)
At t + 3s: The alarm will be executed
At t + 5s: Nothing will happen, until the DO schedules the alarm again through the fetch

O

omar4289•10/27/23, 9:41 AM

Is this what you are trying to build ?

O

omar4289•10/27/23, 9:42 AM

Based on what I have provided, do you want the alarm to be executed still at t + 5s, t + 7s, .... t + 99s ?

H

Harshil BodaraOP•10/27/23, 9:45 AM

yes, like this

O

omar4289•10/27/23, 9:45 AM

Can you send the code where you call your DO from the worker ?

O

omar4289•10/27/23, 9:45 AM

When you get the id and then send the fetch request to the DO

H

Harshil BodaraOP•10/27/23, 9:46 AM

but I want to when re-calling the schedule so before, schedule is clear(restart) and then the alarm calling

Oomar4289 This will be the outcome: Call to DO at t + 1s: Will schedule the alarm Call to ...

O

omar4289•10/27/23, 9:47 AM

Ok, can you express it in a timeline like I did here

O

omar4289•10/27/23, 9:48 AM

From t + 1s, to t + 9s

H

Harshil BodaraOP•10/27/23, 9:48 AM

main.ts
--------------------------
import { ThrowableRouter } from 'itty-router-extras';
import { Env } from '../types';
import { withDurables } from 'itty-durable';
export { Water } from './crons/water';

const router = ThrowableRouter();

router.all("", withDurables());

router.get('/water', async (request: Request, env: Env) => {
const doId = env.WATER.newUniqueId();
const WaterInstance = env.WATER.get(doId);

return WaterInstance.fetch(request, env);
});

router.all("", ()=> { return new Response("Route not Found!") });

export default {
fetch: router.handle,
};

crons/water/index.ts
---------------------------------
export class Water {
id: string | DurableObjectId;
storage: DurableObjectStorage;
doEverySeconds: number;
env: Env;

constructor(state: DurableObjectState, env: Env) {
this.storage = state.storage;
this.id = state.id;
this.doEverySeconds = 2;
this.env = env;
}

async fetch() {
const alarmTime = await this.storage.get("alarmTime");
console.log("alarmTime",alarmTime)
if (!alarmTime) {
await this.scheduleAlarm();
} else {
return new Response("Water alarm is already scheduled.");
}
return new Response("Water schedule Successfully!");
}

async alarm() {
console.log("Water Alarm Doing");
await this.storage.delete("alarmTime");
}

async scheduleAlarm() {
let scheduledTime: number = Date.now() + this.doEverySeconds * 1000;
await this.storage.put("alarmTime", scheduledTime.toString());
this.storage.setAlarm(scheduledTime);
}
}

H

Harshil BodaraOP•10/27/23, 9:51 AM

for example:-
first-time call schedule: alarm calling
2s: alarm calling
4s: alarm calling
6s: alarm calling

when I recall the API, it is already scheduled already doing
8s: alarm calling
10s: alarm calling
continue

OR
first time call schudle: alarm calling
2s: alarm calling
4s: alarm calling
6s: alarm calling

O

omar4289•10/27/23, 9:52 AM

Ok, I get it

O

omar4289•10/27/23, 9:53 AM

So, here the new code
1. const doId = env.WATER.newUniqueId(); must be replaced with env.WATER.idFromName('water_instance'). The reason is that you have different DO instance per call if you use newUniqueId(). Different instances means, different storage, they are not synced together ....

O

omar4289•10/27/23, 9:54 AM

2. async alarm() {
console.log("Water Alarm Doing");
await this.scheduleAlarm();
}

H

Harshil BodaraOP•10/27/23, 10:05 AM

he said, water schdule already working so how may i stop and again run?

O

omar4289•10/27/23, 10:05 AM

Ok, if you want to manage the state of your waterfall, here is a better solution

H

Harshil BodaraOP•10/27/23, 10:09 AM

yes, let me know

O

omar4289•10/27/23, 10:19 AM

@Harshil Bodara

O

omar4289•10/27/23, 10:19 AM

router.get('/water/start', async (request: Request, env: Env) => {
    const doId = env.WATER.idFromName('water_instance');
    const WaterInstance = env.WATER.get(doId);
    return WaterInstance.fetch(request);
});

router.get('/water/stop', async (request: Request, env: Env) => {
    const doId = env.WATER.idFromName('water_instance');
    const WaterInstance = env.WATER.get(doId);
    return WaterInstance.fetch(request);
});

router.get('/water/start', async (request: Request, env: Env) => {
    const doId = env.WATER.idFromName('water_instance');
    const WaterInstance = env.WATER.get(doId);
    return WaterInstance.fetch(request);
});

router.get('/water/stop', async (request: Request, env: Env) => {
    const doId = env.WATER.idFromName('water_instance');
    const WaterInstance = env.WATER.get(doId);
    return WaterInstance.fetch(request);
});

router.get('/water/start', async (request: Request, env: Env) => {
    const doId = env.WATER.idFromName('water_instance');
    const WaterInstance = env.WATER.get(doId);
    return WaterInstance.fetch(request);
});

router.get('/water/stop', async (request: Request, env: Env) => {
    const doId = env.WATER.idFromName('water_instance');
    const WaterInstance = env.WATER.get(doId);
    return WaterInstance.fetch(request);
});

router.get('/water/start', async (request: Request, env: Env) => {
    const doId = env.WATER.idFromName('water_instance');
    const WaterInstance = env.WATER.get(doId);
    return WaterInstance.fetch(request);
});

router.get('/water/stop', async (request: Request, env: Env) => {
    const doId = env.WATER.idFromName('water_instance');
    const WaterInstance = env.WATER.get(doId);
    return WaterInstance.fetch(request);
});

O

omar4289•10/27/23, 10:19 AM

export class Water {
    id: string | DurableObjectId;
    storage: DurableObjectStorage;
    doEverySeconds: number;
    env: Env;

    constructor(state: DurableObjectState, env: Env) {
        this.storage = state.storage;
        this.id = state.id;
        this.doEverySeconds = 2;
        this.env = env;
    }

    async fetch(request: Request) {
        const url = new URL(request.url);
        const action = url.pathname.split('/')[2];

        switch (action) {
            case 'start':
                const alarmTime = await this.storage.get('alarmTime');
                if (!alarmTime) {
                    await this.scheduleAlarm();
                    return new Response('Water schedule Successfully!');
                } else {
                    return new Response('Water alarm is already scheduled.');
                }
            case 'stop':
        await this.storage.deleteAlarm();
        await this.storage.delete('alarmTime');
        return new Response("Water alarm stopped");
      default:
        return new Response('', { status: 404 });
        }
    }

    async alarm() {
        console.log('Water Alarm Doing');
        await this.scheduleAlarm();
    }

    async scheduleAlarm() {
        let scheduledTime: number = Date.now() + this.doEverySeconds * 1000;
        await this.storage.put('alarmTime', scheduledTime.toString());
        await this.storage.setAlarm(scheduledTime);
    }
}

export class Water {
    id: string | DurableObjectId;
    storage: DurableObjectStorage;
    doEverySeconds: number;
    env: Env;

    constructor(state: DurableObjectState, env: Env) {
        this.storage = state.storage;
        this.id = state.id;
        this.doEverySeconds = 2;
        this.env = env;
    }

    async fetch(request: Request) {
        const url = new URL(request.url);
        const action = url.pathname.split('/')[2];

        switch (action) {
            case 'start':
                const alarmTime = await this.storage.get('alarmTime');
                if (!alarmTime) {
                    await this.scheduleAlarm();
                    return new Response('Water schedule Successfully!');
                } else {
                    return new Response('Water alarm is already scheduled.');
                }
            case 'stop':
        await this.storage.deleteAlarm();
        await this.storage.delete('alarmTime');
        return new Response("Water alarm stopped");
      default:
        return new Response('', { status: 404 });
        }
    }

    async alarm() {
        console.log('Water Alarm Doing');
        await this.scheduleAlarm();
    }

    async scheduleAlarm() {
        let scheduledTime: number = Date.now() + this.doEverySeconds * 1000;
        await this.storage.put('alarmTime', scheduledTime.toString());
        await this.storage.setAlarm(scheduledTime);
    }
}

export class Water {
    id: string | DurableObjectId;
    storage: DurableObjectStorage;
    doEverySeconds: number;
    env: Env;

    constructor(state: DurableObjectState, env: Env) {
        this.storage = state.storage;
        this.id = state.id;
        this.doEverySeconds = 2;
        this.env = env;
    }

    async fetch(request: Request) {
        const url = new URL(request.url);
        const action = url.pathname.split('/')[2];

        switch (action) {
            case 'start':
                const alarmTime = await this.storage.get('alarmTime');
                if (!alarmTime) {
                    await this.scheduleAlarm();
                    return new Response('Water schedule Successfully!');
                } else {
                    return new Response('Water alarm is already scheduled.');
                }
            case 'stop':
        await this.storage.deleteAlarm();
        await this.storage.delete('alarmTime');
        return new Response("Water alarm stopped");
      default:
        return new Response('', { status: 404 });
        }
    }

    async alarm() {
        console.log('Water Alarm Doing');
        await this.scheduleAlarm();
    }

    async scheduleAlarm() {
        let scheduledTime: number = Date.now() + this.doEverySeconds * 1000;
        await this.storage.put('alarmTime', scheduledTime.toString());
        await this.storage.setAlarm(scheduledTime);
    }
}

export class Water {
    id: string | DurableObjectId;
    storage: DurableObjectStorage;
    doEverySeconds: number;
    env: Env;

    constructor(state: DurableObjectState, env: Env) {
        this.storage = state.storage;
        this.id = state.id;
        this.doEverySeconds = 2;
        this.env = env;
    }

    async fetch(request: Request) {
        const url = new URL(request.url);
        const action = url.pathname.split('/')[2];

        switch (action) {
            case 'start':
                const alarmTime = await this.storage.get('alarmTime');
                if (!alarmTime) {
                    await this.scheduleAlarm();
                    return new Response('Water schedule Successfully!');
                } else {
                    return new Response('Water alarm is already scheduled.');
                }
            case 'stop':
        await this.storage.deleteAlarm();
        await this.storage.delete('alarmTime');
        return new Response("Water alarm stopped");
      default:
        return new Response('', { status: 404 });
        }
    }

    async alarm() {
        console.log('Water Alarm Doing');
        await this.scheduleAlarm();
    }

    async scheduleAlarm() {
        let scheduledTime: number = Date.now() + this.doEverySeconds * 1000;
        await this.storage.put('alarmTime', scheduledTime.toString());
        await this.storage.setAlarm(scheduledTime);
    }
}

H

Harshil BodaraOP•10/27/23, 10:34 AM

Thank you, @omar , It was a very exciting good solution
now schedule is working fine

O

omar4289•10/27/23, 10:37 AM

You are welcome

O

omar4289•10/27/23, 10:38 AM

You should still add more control in case your alarm did stop - For example, on run, if the alarm did not execute since 60minutes, then just rerun it instead of returning already scheduled

H

Harshil BodaraOP•10/27/23, 10:38 AM

Thank you So much! @omar

H

Harshil BodaraOP•10/27/23, 10:39 AM

yes, i got it

@omar#4289 same as, I am getting the

Similar Threads

Similar Threads

Similar Threads