Yeah

Another use for that would be a staging namespace and a production namespace (to have different data, but sometimes the same code impl)

But then each would have potentially different data - interesting - yea that's something to think about

I think of them as servers, yeah. But nobody (including you) can access a DO without going through your workers. So your DO doesn't necessarily need to have an API key, but your worker might want to have some privileged admin endpoint, if that's what you're asking

I guess to be clear, you could put the auth wherever makes you happy. But the mental model of a single DO (to me anyway) is to think of them as a server. I'm not sure how else you'd read the total count from 100 different places around the world without sending the server a message -- right?

One more question about isolate sharing: what objects are eligible for sharing? All objects in the same script? Or only objects of the same class, same namespace?

Objects in a namespace currently, but that's an impl detail subject to change

Great - thanks! i suppose technically you could go as far up as the script level

In the example of a simple counter that I want to get the total value from to my worker. In the worker I will have to use something like fetch('/counter/total/'). Inside the DO fetch(request) { if(request === '/counter/total/') return state.storage.counter } Is this the intended way to use it?

so you would need routing in the worker and in the DO

Yep, if your DO needs to handle different kinds of requests then I'd treat it just like any other server and route how you see fit (such as by URL)

ok, just making sure! it felt a bit strange to me

Or if it's really a simple counter you could make GET return the total without incrementing, and POST incr and return the count, etc

lets say you would build some sort of website statistics tool with a DO, incrementing the counter is consistent? even if you have a lot of writes per second?

Yeah, the persistent storage API is consistent in a DO. You just have to keep in mind that any time you

await

another request might be served concurrently.

So you wouldn't want to do a read, then await some fetch to another service, then do a write that expected nobody else to do anything while you were waiting on the fetch. (We do offer transactions. None of this is really different than any other server using, say, Postgres.)

We have a blog post coming out soon about some improvements here.

so if I await the storage.put, and you have concurrent writes coming from other requests, its possible the counter total value will not be correct?

If im checking the documentation: https://developers.cloudflare.com/workers/learning/using-durable-objects#example---counter. They are storing it in a variable to make sure the returned value is correct. But im interested in knowing if the actual stored value in the storage will remain correct with a lot of concurrent writes. (same approach as in the example of the docs)

but as long as they're exported it shouldn't matter if the class has a name (

MyClass.name

)... right?

That example ensures the stored value and returned value are correct

Thanks for your help!

I'm not sure actually, probably easiest to try by adjusting our template code https://github.com/cloudflare/durable-objects-template

yea idk why i ask tbh, of course i can just try it

probably won't test it out for a while though, if i do end up actually finishing something i'll probably post an update here i guess

Can anyone at cloudflare put eyes on this, seems to be IO blocking bug for long running fetches

assuming 1.) refers to using a delete class migration, these are equivalent operations

you can use the itty-durable to call like internal class: https://github.com/kwhitley/itty-durable

https://liveblocks.io -> cool new product launched. Asked if they do not intend to use DO, and it turns out - they are actually using DO: https://news.ycombinator.com/item?id=27998674. Full HN thread here: https://news.ycombinator.com/item?id=27994480 .

Is/will there be a good way to write DOs in webassembly languages like rust?