@social-mail/social-mail-web-server 1.4.778 → 1.4.779

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@social-mail/social-mail-web-server",
-  "version": "1.4.778",
+  "version": "1.4.779",
   "description": "## Phase 1",
   "main": "index.js",
   "type": "module",

package/src/server/model/events/MailboxContactEvents.ts

@@ -47,8 +47,7 @@ export default class MailboxContactEvents extends AuthenticatedEvents<MailboxCon
 
     async afterUpdate(entity: MailboxContact, entry: ChangeEntry<MailboxContact>) {
         // if blocked was changed
-        const { mailboxID, blocked, autoClose } = entity;
-        let { openThreads , totalThreads } = entity;
+        const { mailboxID, blocked, autoClose, emailAddressID, openThreads } = entity;
 
         const db = ServiceProvider.resolve(this, SocialMailContext);
         if (entry.isUpdated("autoClose") || entry.isUpdated("blocked")) {
@@ -68,26 +67,16 @@ export default class MailboxContactEvents extends AuthenticatedEvents<MailboxCon
             } else {
                 // we need to recalculate
 
-                const t = await db.emails.where(entity, (p) => (x) =>
-                        x.threadContacts
-                            .some((tc) => tc.mailboxID === p.mailboxID
-                                && tc.emailAddressID === p.emailAddressID)
-                        && x.threadID === x.emailID
+                const all = await db.emails
+                    .where(entity , (p) => (x) => x.threadContacts.some((t) => t.mailboxID === p.mailboxID
+                        && t.emailAddressID === p.emailAddressID)
+                        && x.threadID === null
                     )
                     .sum(void 0, (p) => (x) => ({
-                        openThreads: x.closed === null ? 1 : 0,
-                        totalThreads: 1
-                    }));
-
-                if (t) {
-                    openThreads = t.openThreads;
-                    totalThreads = t.totalThreads;
-                }
-                await db.mailboxes.where({ mailboxID }, (p) => (x) => x.mailboxID === p.mailboxID)
-                    .update({ openThreads, totalThreads }, (p) => (x) => ({
-                        openThreads: Sql.math.max(0, x.openThreads + Sql.cast.asInteger(p.openThreads)),
-                        totalThreads: Sql.math.max(0, x.totalThreads + Sql.cast.asInteger(p.totalThreads))
+                        totalThreads: 1,
+                        openThreads: x.lastReplyID === null ? 1 : 0
                     }));
+                await db.mailboxContacts.statements.update(all, { mailboxID, emailAddressID});
             }
         }
 

package/src/server/storage/LockFile.ts

@@ -1,7 +1,7 @@
 /* eslint-disable no-console */
 import { Stream } from "node:stream";
 import { dirname, join } from "node:path";
-import { existsSync, mkdirSync, openSync, constants, writeSync, closeSync, unlinkSync, statSync } from "node:fs";
+import { existsSync, mkdirSync, openSync, constants, writeSync, closeSync, unlinkSync, statSync, fdatasyncSync } from "node:fs";
 import { createHash, randomUUID } from "node:crypto";
 import * as os from "node:os";
 import sleep from "../../common/sleep.js";
@@ -31,43 +31,48 @@ export default class LockFile implements Disposable {
 
         const lockFile = join(lockFolder, hash + ".lock");
 
-        const till = Date.now() + timeout;
+        let now = Date.now();
+        const till = now + timeout;
 
-        while(Date.now() < till) {
+
+        do {
 
             try {
                 // check if it exists..
                 if (!existsSync(lockFile)) {
                     // create and return..
-                    const fd = openSync(lockFile, "wx", openMode);
-                    writeSync(fd, "1");
-                    return new LockFile(lockFile, fd);
+                    return new LockFile(lockFile);
                 }
 
                 const stat = statSync(lockFile);
-                const diff = Date.now() - stat.mtimeMs;
-                if (diff > 30000) {
-                    // most likely this is dead...
+                const past = now - 15000;
+                if(stat.mtimeMs < past) {
+                    // it is dead...
                     unlinkSync(lockFile);
-                    continue;
                 }
-
             } catch (error){
                 // do nothing
-                // console.error(error);
+                console.error(error);
             }
             await sleep(3000);
-        }
+            now = Date.now();
+        }while(now < till);
 
         throw new Error("Could not acquire lock");
     }
 
     timer: any;
+    fd: any;
 
-    constructor(private readonly lockFile, private readonly fd) {
+    constructor(private readonly lockFile) {
+        const fd = this.fd = openSync(lockFile, "wx", openMode);
+        let n = 1;
+        writeSync(fd, (n++) + "" );
+        fdatasyncSync(fd);
         this.timer = setInterval(() => {
             try {
-                writeSync(fd, "1");
+                writeSync(fd, (n++) + "" );
+                fdatasyncSync(fd);
             } catch {
                 // do nothing
             }

package/src/tests/core/lock-file/lock-file-test.ts

@@ -1,6 +1,8 @@
+/* eslint-disable no-console */
 import assert from "assert";
 import sleep from "../../../common/sleep.js";
 import LockFile from "../../../server/storage/LockFile.js";
+import { closeSync } from "fs";
 
 (Symbol as any).dispose ??= Symbol("dispose");
 (Symbol as any).asyncDispose ??= Symbol("asyncDispose");
@@ -16,6 +18,13 @@ const lock1 = async () => {
     console.log("Releasing lock 1");
 };
 
+const deadLock = async () => {
+    const l = await LockFile.lock("a1");
+    closeSync(l.fd);
+    l.fd = null;
+    clearInterval(l.timer);
+};
+
 const lock2 = async () => {
     await sleep(10);
     console.log("Opening lock 2");
@@ -26,9 +35,16 @@ const lock2 = async () => {
     console.log("Releasing lock 2");
 };
 
-export default function() {
-    return Promise.all([
+export default async function() {
+    await Promise.all([
         lock1(),
         lock2()
     ]);
+
+    console.log(`Trying Dead Lock`);
+
+    await Promise.all([
+        deadLock(),
+        lock2()
+    ]);
 }