How will I do that

H

hsnilsson•4/17/24, 8:47 AM

Hi, is authentication available for single paths like "/admin"? Looking at Cloudflare Access Pages Plugin it seems to be per domain. https://developers.cloudflare.com/pages/functions/plugins/cloudflare-access/

M

md•4/17/24, 1:43 PM

Are there any plans in adding rust to the available languages so that i can use cargo in the pages build step anytime soon?

M

md•4/17/24, 2:24 PM

i want to deploy leptos with axum on pages. every change needs to be recompiled anyway. so i can setup an extra ci, or i could connect pages via git, so it autobuilds/deploys my changes.

M

md•4/17/24, 2:25 PM

you are doing the same for any other framework solutions. its like like you wouldnt run npm build for your vue spa

BBrayn How will I do that

I

IEatBeans•4/17/24, 4:05 PM

Go to your pages project in the dashboard, go to the latest or active deployment details, and find the log streaming thing.

IIEatBeans Go to your pages project in the dashboard, go to the latest or active deployment...

B

BraynOP•4/17/24, 4:08 PM

How will I get there am not using a premium account

I

IEatBeans•4/17/24, 4:09 PM

You don’t need that. Do you have access to the cloud flare dashboard

IIEatBeans You don’t need that. Do you have access to the cloud flare dashboard

B

BraynOP•4/17/24, 4:12 PM

Yes

BBrayn Yes

I

IEatBeans•4/17/24, 4:31 PM

Ok, go to your pages project on there

I

IEatBeans•4/17/24, 4:32 PM

https://developers.cloudflare.com/pages/functions/debugging-and-logging/#view-logs-in-the-cloudflare-dashboard

Cloudflare Docs

Debugging and logging · Cloudflare Pages docs

Access your Functions logs by using the Cloudflare dashboard or the Wrangler CLI.

N

neoney•4/17/24, 4:36 PM

Trying to use DurableObjects to implement a kind of lock to prevent the same request from being called while the previous one is processing

N

neoney•4/17/24, 4:36 PM

and since durable objects just use fetch

N

neoney•4/17/24, 4:36 PM

what kind of URL should I pass to it?

N

neoney•4/17/24, 4:37 PM

does it matter, if I don't check any part of it, only the hostname and query params?

Nneoney does it matter, if I don't check any part of it, only the hostname and query par...

H

Hello, I’m Allie!•4/17/24, 4:38 PM

It just needs to be a valid URL. Though, with the new RPC APIs, you don't have to pass in a URL at all

H

Hello, I’m Allie!•4/17/24, 4:38 PM

You can just call a function directly on the stub

N

neoney•4/17/24, 4:38 PM

not using RPC yet

N

neoney•4/17/24, 4:38 PM

soo

N

neoney•4/17/24, 4:38 PM

I can do something like this?

N

neoney•4/17/24, 4:38 PM

const lockId = env.LOCK.idFromString(`${storeId}-${data.userEmail}`);
    const lock = env.LOCK.get(lockId);

    const lockUrl = new URL("http://0.0.0.0/lock");
    lockUrl.searchParams.set("durationSecs", "30");
    const lockResponse = await lock.fetch(lockUrl.toString());

    if (lockResponse.status !== 204)
      return new Error("Request being processed.");

const lockId = env.LOCK.idFromString(`${storeId}-${data.userEmail}`);
    const lock = env.LOCK.get(lockId);

    const lockUrl = new URL("http://0.0.0.0/lock");
    lockUrl.searchParams.set("durationSecs", "30");
    const lockResponse = await lock.fetch(lockUrl.toString());

    if (lockResponse.status !== 204)
      return new Error("Request being processed.");

const lockId = env.LOCK.idFromString(`${storeId}-${data.userEmail}`);
    const lock = env.LOCK.get(lockId);

    const lockUrl = new URL("http://0.0.0.0/lock");
    lockUrl.searchParams.set("durationSecs", "30");
    const lockResponse = await lock.fetch(lockUrl.toString());

    if (lockResponse.status !== 204)
      return new Error("Request being processed.");

const lockId = env.LOCK.idFromString(`${storeId}-${data.userEmail}`);
    const lock = env.LOCK.get(lockId);

    const lockUrl = new URL("http://0.0.0.0/lock");
    lockUrl.searchParams.set("durationSecs", "30");
    const lockResponse = await lock.fetch(lockUrl.toString());

    if (lockResponse.status !== 204)
      return new Error("Request being processed.");

N

neoney•4/17/24, 4:38 PM

where the fetch handler in the DO is

N

neoney•4/17/24, 4:38 PM

async fetch(request: Request) {
    const url = new URL(request.url);

    switch (url.pathname) {
      case "/unlock": {
        await this.state.storage.delete("lock");
        return new Response(null, {
          status: 204,
        });
      }
      case "/lock": {
        const lockedUntil = await this.state.storage.get<number>("lock");
        if (lockedUntil && lockedUntil > Date.now())
          return new Response(null, {
            status: 409,
          });

        const durationSecsString = url.searchParams.get("durationSecs");
        if (!durationSecsString)
          return new Response(null, {
            status: 400,
          });
        const durationSecsNumber = parseInt(durationSecsString);
        if (
          !Number.isSafeInteger(durationSecsNumber) ||
          durationSecsNumber <= 0
        )
          return new Response(null, {
            status: 400,
          });

        await this.state.storage.put("lock", Date.now());

        return new Response(null, {
          status: 204,
        });
      }
    }
  }

async fetch(request: Request) {
    const url = new URL(request.url);

    switch (url.pathname) {
      case "/unlock": {
        await this.state.storage.delete("lock");
        return new Response(null, {
          status: 204,
        });
      }
      case "/lock": {
        const lockedUntil = await this.state.storage.get<number>("lock");
        if (lockedUntil && lockedUntil > Date.now())
          return new Response(null, {
            status: 409,
          });

        const durationSecsString = url.searchParams.get("durationSecs");
        if (!durationSecsString)
          return new Response(null, {
            status: 400,
          });
        const durationSecsNumber = parseInt(durationSecsString);
        if (
          !Number.isSafeInteger(durationSecsNumber) ||
          durationSecsNumber <= 0
        )
          return new Response(null, {
            status: 400,
          });

        await this.state.storage.put("lock", Date.now());

        return new Response(null, {
          status: 204,
        });
      }
    }
  }

async fetch(request: Request) {
    const url = new URL(request.url);

    switch (url.pathname) {
      case "/unlock": {
        await this.state.storage.delete("lock");
        return new Response(null, {
          status: 204,
        });
      }
      case "/lock": {
        const lockedUntil = await this.state.storage.get<number>("lock");
        if (lockedUntil && lockedUntil > Date.now())
          return new Response(null, {
            status: 409,
          });

        const durationSecsString = url.searchParams.get("durationSecs");
        if (!durationSecsString)
          return new Response(null, {
            status: 400,
          });
        const durationSecsNumber = parseInt(durationSecsString);
        if (
          !Number.isSafeInteger(durationSecsNumber) ||
          durationSecsNumber <= 0
        )
          return new Response(null, {
            status: 400,
          });

        await this.state.storage.put("lock", Date.now());

        return new Response(null, {
          status: 204,
        });
      }
    }
  }

async fetch(request: Request) {
    const url = new URL(request.url);

    switch (url.pathname) {
      case "/unlock": {
        await this.state.storage.delete("lock");
        return new Response(null, {
          status: 204,
        });
      }
      case "/lock": {
        const lockedUntil = await this.state.storage.get<number>("lock");
        if (lockedUntil && lockedUntil > Date.now())
          return new Response(null, {
            status: 409,
          });

        const durationSecsString = url.searchParams.get("durationSecs");
        if (!durationSecsString)
          return new Response(null, {
            status: 400,
          });
        const durationSecsNumber = parseInt(durationSecsString);
        if (
          !Number.isSafeInteger(durationSecsNumber) ||
          durationSecsNumber <= 0
        )
          return new Response(null, {
            status: 400,
          });

        await this.state.storage.put("lock", Date.now());

        return new Response(null, {
          status: 204,
        });
      }
    }
  }

N

neoney•4/17/24, 4:39 PM

If I'm understanding right, I don't need to worry about the lock ID in the actual DO

N

neoney•4/17/24, 4:39 PM

right?

N

neoney•4/17/24, 4:39 PM

it's gonna be a separate object for a different userId

Nneoney ```ts const lockId = env.LOCK.idFromString(`${storeId}-${data.userEmail}`); ...

H

Hello, I’m Allie!•4/17/24, 4:39 PM

That looks fine?

N

neoney•4/17/24, 4:39 PM

Thanks

N

neoney•4/17/24, 4:39 PM

Just checking

N

neoney•4/17/24, 4:39 PM

hope it works in dev mode now..

N

neoney•4/17/24, 4:46 PM

[TypeError: Invalid Durable Object ID: must be 64 hex digits]

N

neoney•4/17/24, 4:46 PM

interesting

N

neoney•4/17/24, 4:46 PM

i guess idFromName is a better choice there

Nneoney [TypeError: Invalid Durable Object ID: must be 64 hex digits]

H

Hello, I’m Allie!•4/17/24, 4:46 PM

Oh yeah, missed that.

idFromString

idFromString

only accepts the result of an

id.toString()

id.toString()

N

neoney•4/17/24, 4:47 PM

Ah okay

N

neoney•4/17/24, 4:47 PM

Welp

N

neoney•4/17/24, 4:47 PM

I be getting a 503 response

N

neoney•4/17/24, 4:47 PM

Might be broken in dev

N

neoney•4/17/24, 4:47 PM

next-on-pages moment

N

neoney•4/17/24, 4:47 PM

not sure if it reads wrangler.toml properly...

N

neoney•4/17/24, 5:41 PM

why cant i add bindings

N

neoney•4/17/24, 5:41 PM

https://developers.cloudflare.com/pages/functions/bindings/#durable-objects says i should be able to

Cloudflare Docs

Bindings · Cloudflare Pages docs

A binding enables your Pages Functions to interact with resources on the Cloudflare developer platform. Use bindings to integrate your Pages Functions …

N

neoney•4/17/24, 5:43 PM

suddenly the button appeared after I redeployed project

N

neoney•4/17/24, 5:43 PM

idk

N

neoney•4/17/24, 6:01 PM

works in prod

N

neoney•4/17/24, 6:01 PM

def can recommend these locks

N

neoney•4/17/24, 6:01 PM

even wrote some nice utils for them

N

neoney•4/17/24, 6:01 PM

export enum LockResult {
  Success,
  AlreadyLocked,
}

export class Lock {
  private lockId: DurableObjectId;
  private stub: DurableObjectStub;

  constructor(name: string, cloudflareEnv: CloudflareEnv) {
    this.lockId = cloudflareEnv.LOCK.idFromName(name);
    this.stub = cloudflareEnv.LOCK.get(this.lockId);
  }

  async unlock() {
    const unlockUrl = new URL("http://0.0.0.0/unlock");
    const response = await this.stub.fetch(unlockUrl.toString());

    if (response.status !== 204) throw new Error(await response.text());
  }

  async lock(durationSecs: number) {
    const lockUrl = new URL("http://0.0.0.0/lock");
    lockUrl.searchParams.set("durationSecs", durationSecs.toFixed(0));
    const response = await this.stub.fetch(lockUrl.toString());

    if (response.status === 204) return LockResult.Success;
    if (response.status === 409) return LockResult.AlreadyLocked;

    throw new Error(await response.text());
  }
}

export class LockError extends Error {
  constructor(msg: string) {
    super(msg);

    // Set the prototype explicitly.
    Object.setPrototypeOf(this, LockError.prototype);
  }
}

export async function withLock<T>(
  name: string,
  cloudflareEnv: CloudflareEnv,
  lockExpirySecs: number,
  fn: () => T,
  unlockOnEnd = true,
): Promise<T> {
  const lock = new Lock(name, cloudflareEnv);

  const lockResult = await lock.lock(lockExpirySecs);

  if (lockResult === LockResult.AlreadyLocked)
    throw new LockError("Lock is already locked.");

  try {
    return fn();
  } finally {
    if (unlockOnEnd) await lock.unlock();
  }
}

export enum LockResult {
  Success,
  AlreadyLocked,
}

export class Lock {
  private lockId: DurableObjectId;
  private stub: DurableObjectStub;

  constructor(name: string, cloudflareEnv: CloudflareEnv) {
    this.lockId = cloudflareEnv.LOCK.idFromName(name);
    this.stub = cloudflareEnv.LOCK.get(this.lockId);
  }

  async unlock() {
    const unlockUrl = new URL("http://0.0.0.0/unlock");
    const response = await this.stub.fetch(unlockUrl.toString());

    if (response.status !== 204) throw new Error(await response.text());
  }

  async lock(durationSecs: number) {
    const lockUrl = new URL("http://0.0.0.0/lock");
    lockUrl.searchParams.set("durationSecs", durationSecs.toFixed(0));
    const response = await this.stub.fetch(lockUrl.toString());

    if (response.status === 204) return LockResult.Success;
    if (response.status === 409) return LockResult.AlreadyLocked;

    throw new Error(await response.text());
  }
}

export class LockError extends Error {
  constructor(msg: string) {
    super(msg);

    // Set the prototype explicitly.
    Object.setPrototypeOf(this, LockError.prototype);
  }
}

export async function withLock<T>(
  name: string,
  cloudflareEnv: CloudflareEnv,
  lockExpirySecs: number,
  fn: () => T,
  unlockOnEnd = true,
): Promise<T> {
  const lock = new Lock(name, cloudflareEnv);

  const lockResult = await lock.lock(lockExpirySecs);

  if (lockResult === LockResult.AlreadyLocked)
    throw new LockError("Lock is already locked.");

  try {
    return fn();
  } finally {
    if (unlockOnEnd) await lock.unlock();
  }
}

export enum LockResult {
  Success,
  AlreadyLocked,
}

export class Lock {
  private lockId: DurableObjectId;
  private stub: DurableObjectStub;

  constructor(name: string, cloudflareEnv: CloudflareEnv) {
    this.lockId = cloudflareEnv.LOCK.idFromName(name);
    this.stub = cloudflareEnv.LOCK.get(this.lockId);
  }

  async unlock() {
    const unlockUrl = new URL("http://0.0.0.0/unlock");
    const response = await this.stub.fetch(unlockUrl.toString());

    if (response.status !== 204) throw new Error(await response.text());
  }

  async lock(durationSecs: number) {
    const lockUrl = new URL("http://0.0.0.0/lock");
    lockUrl.searchParams.set("durationSecs", durationSecs.toFixed(0));
    const response = await this.stub.fetch(lockUrl.toString());

    if (response.status === 204) return LockResult.Success;
    if (response.status === 409) return LockResult.AlreadyLocked;

    throw new Error(await response.text());
  }
}

export class LockError extends Error {
  constructor(msg: string) {
    super(msg);

    // Set the prototype explicitly.
    Object.setPrototypeOf(this, LockError.prototype);
  }
}

export async function withLock<T>(
  name: string,
  cloudflareEnv: CloudflareEnv,
  lockExpirySecs: number,
  fn: () => T,
  unlockOnEnd = true,
): Promise<T> {
  const lock = new Lock(name, cloudflareEnv);

  const lockResult = await lock.lock(lockExpirySecs);

  if (lockResult === LockResult.AlreadyLocked)
    throw new LockError("Lock is already locked.");

  try {
    return fn();
  } finally {
    if (unlockOnEnd) await lock.unlock();
  }
}

export enum LockResult {
  Success,
  AlreadyLocked,
}

export class Lock {
  private lockId: DurableObjectId;
  private stub: DurableObjectStub;

  constructor(name: string, cloudflareEnv: CloudflareEnv) {
    this.lockId = cloudflareEnv.LOCK.idFromName(name);
    this.stub = cloudflareEnv.LOCK.get(this.lockId);
  }

  async unlock() {
    const unlockUrl = new URL("http://0.0.0.0/unlock");
    const response = await this.stub.fetch(unlockUrl.toString());

    if (response.status !== 204) throw new Error(await response.text());
  }

  async lock(durationSecs: number) {
    const lockUrl = new URL("http://0.0.0.0/lock");
    lockUrl.searchParams.set("durationSecs", durationSecs.toFixed(0));
    const response = await this.stub.fetch(lockUrl.toString());

    if (response.status === 204) return LockResult.Success;
    if (response.status === 409) return LockResult.AlreadyLocked;

    throw new Error(await response.text());
  }
}

export class LockError extends Error {
  constructor(msg: string) {
    super(msg);

    // Set the prototype explicitly.
    Object.setPrototypeOf(this, LockError.prototype);
  }
}

export async function withLock<T>(
  name: string,
  cloudflareEnv: CloudflareEnv,
  lockExpirySecs: number,
  fn: () => T,
  unlockOnEnd = true,
): Promise<T> {
  const lock = new Lock(name, cloudflareEnv);

  const lockResult = await lock.lock(lockExpirySecs);

  if (lockResult === LockResult.AlreadyLocked)
    throw new LockError("Lock is already locked.");

  try {
    return fn();
  } finally {
    if (unlockOnEnd) await lock.unlock();
  }
}

N

neoney•4/17/24, 6:32 PM

soooo

N

neoney•4/17/24, 6:32 PM

i was setting a lock for 15s

N

neoney•4/17/24, 6:32 PM

and somehow

Similar Threads

Similar Threads

Similar Threads