@oneuptime/common 7.0.4135 → 7.0.4142

package/Server/Services/MonitorStatusTimelineService.ts

@@ -37,7 +37,7 @@ export class Service extends DatabaseService<MonitorStatusTimeline> {
     try {
       mutex = await Semaphore.lock({
         key: createBy.data.monitorId.toString(),
-        namespace: "MonitorStatusTimeline.onBeforeCreate",
+        namespace: "MonitorStatusTimeline.create",
       });
     } catch (e) {
       logger.error(e);
@@ -73,6 +73,13 @@ export class Service extends DatabaseService<MonitorStatusTimeline> {
       }
     }
 
+    const monitorStatusId: ObjectID | undefined | null =
+      createBy.data.monitorStatusId || createBy.data.monitorStatus?.id;
+
+    if (!monitorStatusId) {
+      throw new BadDataException("monitorStatusId is null");
+    }
+
     const stateBeforeThis: MonitorStatusTimeline | null = await this.findOneBy({
       query: {
         monitorId: createBy.data.monitorId,
@@ -100,6 +107,20 @@ export class Service extends DatabaseService<MonitorStatusTimeline> {
       createBy.data.isOwnerNotified = true;
     }
 
+    // check if this new state and the previous state are same.
+    // if yes, then throw bad data exception.
+
+    if (stateBeforeThis && stateBeforeThis.monitorStatusId && monitorStatusId) {
+      if (
+        stateBeforeThis.monitorStatusId.toString() ===
+        monitorStatusId.toString()
+      ) {
+        throw new BadDataException(
+          "Monitor Status cannot be same as previous status.",
+        );
+      }
+    }
+
     const stateAfterThis: MonitorStatusTimeline | null = await this.findOneBy({
       query: {
         monitorId: createBy.data.monitorId,
@@ -123,6 +144,19 @@ export class Service extends DatabaseService<MonitorStatusTimeline> {
       createBy.data.endsAt = stateAfterThis.startsAt;
     }
 
+    // check if this new state and the previous state are same.
+    // if yes, then throw bad data exception.
+
+    if (stateAfterThis && stateAfterThis.monitorStatusId && monitorStatusId) {
+      if (
+        stateAfterThis.monitorStatusId.toString() === monitorStatusId.toString()
+      ) {
+        throw new BadDataException(
+          "Monitor Status cannot be same as next status.",
+        );
+      }
+    }
+
     logger.debug("State After this");
     logger.debug(stateAfterThis);
 

package/Server/Services/ScheduledMaintenanceStateTimelineService.ts

@@ -29,6 +29,7 @@ import logger from "../Utils/Logger";
 import CaptureSpan from "../Utils/Telemetry/CaptureSpan";
 import { LIMIT_PER_PROJECT } from "../../Types/Database/LimitMax";
 import WorkspaceNotificationRuleService from "./WorkspaceNotificationRuleService";
+import Semaphore, { SemaphoreMutex } from "../Infrastructure/Semaphore";
 
 export class Service extends DatabaseService<ScheduledMaintenanceStateTimeline> {
   public constructor() {
@@ -93,96 +94,197 @@ export class Service extends DatabaseService<ScheduledMaintenanceStateTimeline>
       throw new BadDataException("scheduledMaintenanceId is null");
     }
 
-    if (!createBy.data.startsAt) {
-      createBy.data.startsAt = OneUptimeDate.getCurrentDate();
-    }
+    let mutex: SemaphoreMutex | null = null;
 
-    const stateBeforeThis: ScheduledMaintenanceStateTimeline | null =
-      await this.findOneBy({
-        query: {
-          scheduledMaintenanceId: createBy.data.scheduledMaintenanceId,
-          startsAt: QueryHelper.lessThanEqualTo(createBy.data.startsAt),
-        },
-        sort: {
-          startsAt: SortOrder.Descending,
-        },
-        props: {
-          isRoot: true,
-        },
-        select: {
-          scheduledMaintenanceStateId: true,
-          startsAt: true,
-          endsAt: true,
-        },
-      });
+    try {
+      try {
+        mutex = await Semaphore.lock({
+          key: createBy.data.scheduledMaintenanceId.toString(),
+          namespace: "ScheduledMaintenanceStateTimeline.create",
+        });
+      } catch (err) {
+        logger.error(err);
+      }
 
-    // If this is the first state, then do not notify the owner.
-    if (!stateBeforeThis) {
-      // since this is the first status, do not notify the owner.
-      createBy.data.isOwnerNotified = true;
-    }
+      if (!createBy.data.startsAt) {
+        createBy.data.startsAt = OneUptimeDate.getCurrentDate();
+      }
 
-    const stateAfterThis: ScheduledMaintenanceStateTimeline | null =
-      await this.findOneBy({
-        query: {
-          scheduledMaintenanceId: createBy.data.scheduledMaintenanceId,
-          startsAt: QueryHelper.greaterThan(createBy.data.startsAt),
-        },
-        sort: {
-          startsAt: SortOrder.Ascending,
-        },
-        props: {
-          isRoot: true,
-        },
-        select: {
-          scheduledMaintenanceStateId: true,
-          startsAt: true,
-          endsAt: true,
-        },
-      });
+      const scheduledMaintenanceStateId: ObjectID | undefined | null =
+        createBy.data.scheduledMaintenanceStateId ||
+        createBy.data.scheduledMaintenanceState?.id;
 
-    // compute ends at. It's the start of the next status.
-    if (stateAfterThis && stateAfterThis.startsAt) {
-      createBy.data.endsAt = stateAfterThis.startsAt;
-    }
+      if (!scheduledMaintenanceStateId) {
+        throw new BadDataException("scheduledMaintenanceStateId is null");
+      }
+
+      const stateBeforeThis: ScheduledMaintenanceStateTimeline | null =
+        await this.findOneBy({
+          query: {
+            scheduledMaintenanceId: createBy.data.scheduledMaintenanceId,
+            startsAt: QueryHelper.lessThanEqualTo(createBy.data.startsAt),
+          },
+          sort: {
+            startsAt: SortOrder.Descending,
+          },
+          props: {
+            isRoot: true,
+          },
+          select: {
+            scheduledMaintenanceStateId: true,
+            scheduledMaintenanceState: {
+              order: true,
+              name: true,
+            },
+            startsAt: true,
+            endsAt: true,
+          },
+        });
+
+      // If this is the first state, then do not notify the owner.
+      if (!stateBeforeThis) {
+        // since this is the first status, do not notify the owner.
+        createBy.data.isOwnerNotified = true;
+      }
 
-    const publicNote: string | undefined = (
-      createBy.miscDataProps as JSONObject | undefined
-    )?.["publicNote"] as string | undefined;
-
-    if (publicNote) {
-      const scheduledMaintenancePublicNote: ScheduledMaintenancePublicNote =
-        new ScheduledMaintenancePublicNote();
-      scheduledMaintenancePublicNote.scheduledMaintenanceId =
-        createBy.data.scheduledMaintenanceId;
-      scheduledMaintenancePublicNote.note = publicNote;
-      scheduledMaintenancePublicNote.postedAt = createBy.data.startsAt;
-      scheduledMaintenancePublicNote.createdAt = createBy.data.startsAt;
-      scheduledMaintenancePublicNote.projectId = createBy.data.projectId!;
-      scheduledMaintenancePublicNote.shouldStatusPageSubscribersBeNotifiedOnNoteCreated =
-        Boolean(createBy.data.shouldStatusPageSubscribersBeNotified);
-
-      // mark status page subscribers as notified for this state change because we dont want to send duplicate (two) emails one for public note and one for state change.
       if (
-        scheduledMaintenancePublicNote.shouldStatusPageSubscribersBeNotifiedOnNoteCreated
+        stateBeforeThis &&
+        stateBeforeThis.scheduledMaintenanceStateId &&
+        scheduledMaintenanceStateId
       ) {
-        createBy.data.isStatusPageSubscribersNotified = true;
+        if (
+          stateBeforeThis.scheduledMaintenanceStateId.toString() ===
+          scheduledMaintenanceStateId.toString()
+        ) {
+          throw new BadDataException(
+            "Scheduled Maintenance state cannot be same as previous state.",
+          );
+        }
       }
 
-      await ScheduledMaintenancePublicNoteService.create({
-        data: scheduledMaintenancePublicNote,
-        props: createBy.props,
-      });
-    }
+      if (stateBeforeThis && stateBeforeThis.scheduledMaintenanceState?.order) {
+        const newScheduledMaintenanceState: ScheduledMaintenanceState | null =
+          await ScheduledMaintenanceStateService.findOneBy({
+            query: {
+              _id: scheduledMaintenanceStateId,
+            },
+            select: {
+              order: true,
+              name: true,
+            },
+            props: {
+              isRoot: true,
+            },
+          });
 
-    return {
-      createBy,
-      carryForward: {
-        statusTimelineBeforeThisStatus: stateBeforeThis || null,
-        statusTimelineAfterThisStatus: stateAfterThis || null,
-        publicNote: publicNote,
-      },
-    };
+        if (
+          newScheduledMaintenanceState &&
+          newScheduledMaintenanceState.order
+        ) {
+          // check if the new scheduledMaintenance state is in order is greater than the previous state order
+          if (
+            stateBeforeThis &&
+            stateBeforeThis.scheduledMaintenanceState &&
+            stateBeforeThis.scheduledMaintenanceState.order &&
+            newScheduledMaintenanceState.order <=
+              stateBeforeThis.scheduledMaintenanceState.order
+          ) {
+            throw new BadDataException(
+              `ScheduledMaintenance cannot transition to ${newScheduledMaintenanceState.name} state from ${stateBeforeThis.scheduledMaintenanceState.name} state because ${newScheduledMaintenanceState.name} is before ${stateBeforeThis.scheduledMaintenanceState.name} in the order of scheduledMaintenance states.`,
+            );
+          }
+        }
+      }
+
+      const stateAfterThis: ScheduledMaintenanceStateTimeline | null =
+        await this.findOneBy({
+          query: {
+            scheduledMaintenanceId: createBy.data.scheduledMaintenanceId,
+            startsAt: QueryHelper.greaterThan(createBy.data.startsAt),
+          },
+          sort: {
+            startsAt: SortOrder.Ascending,
+          },
+          props: {
+            isRoot: true,
+          },
+          select: {
+            scheduledMaintenanceStateId: true,
+            startsAt: true,
+            endsAt: true,
+          },
+        });
+
+      // compute ends at. It's the start of the next status.
+      if (stateAfterThis && stateAfterThis.startsAt) {
+        createBy.data.endsAt = stateAfterThis.startsAt;
+      }
+
+      if (
+        stateAfterThis &&
+        stateAfterThis.scheduledMaintenanceStateId &&
+        scheduledMaintenanceStateId
+      ) {
+        if (
+          stateAfterThis.scheduledMaintenanceStateId.toString() ===
+          scheduledMaintenanceStateId.toString()
+        ) {
+          throw new BadDataException(
+            "Scheduled Maintenance state cannot be same as next state.",
+          );
+        }
+      }
+
+      const publicNote: string | undefined = (
+        createBy.miscDataProps as JSONObject | undefined
+      )?.["publicNote"] as string | undefined;
+
+      if (publicNote) {
+        const scheduledMaintenancePublicNote: ScheduledMaintenancePublicNote =
+          new ScheduledMaintenancePublicNote();
+        scheduledMaintenancePublicNote.scheduledMaintenanceId =
+          createBy.data.scheduledMaintenanceId;
+        scheduledMaintenancePublicNote.note = publicNote;
+        scheduledMaintenancePublicNote.postedAt = createBy.data.startsAt;
+        scheduledMaintenancePublicNote.createdAt = createBy.data.startsAt;
+        scheduledMaintenancePublicNote.projectId = createBy.data.projectId!;
+        scheduledMaintenancePublicNote.shouldStatusPageSubscribersBeNotifiedOnNoteCreated =
+          Boolean(createBy.data.shouldStatusPageSubscribersBeNotified);
+
+        // mark status page subscribers as notified for this state change because we dont want to send duplicate (two) emails one for public note and one for state change.
+        if (
+          scheduledMaintenancePublicNote.shouldStatusPageSubscribersBeNotifiedOnNoteCreated
+        ) {
+          createBy.data.isStatusPageSubscribersNotified = true;
+        }
+
+        await ScheduledMaintenancePublicNoteService.create({
+          data: scheduledMaintenancePublicNote,
+          props: createBy.props,
+        });
+      }
+
+      return {
+        createBy,
+        carryForward: {
+          statusTimelineBeforeThisStatus: stateBeforeThis || null,
+          statusTimelineAfterThisStatus: stateAfterThis || null,
+          publicNote: publicNote,
+          mutex: mutex,
+        },
+      };
+    } catch (error) {
+      // release the mutex if it was acquired.
+      if (mutex) {
+        try {
+          await Semaphore.release(mutex);
+        } catch (err) {
+          logger.error(err);
+        }
+      }
+
+      throw error;
+    }
   }
 
   @CaptureSpan()
@@ -190,6 +292,8 @@ export class Service extends DatabaseService<ScheduledMaintenanceStateTimeline>
     onCreate: OnCreate<ScheduledMaintenanceStateTimeline>,
     createdItem: ScheduledMaintenanceStateTimeline,
   ): Promise<ScheduledMaintenanceStateTimeline> {
+    const mutex: SemaphoreMutex | null = onCreate.carryForward.mutex;
+
     if (!createdItem.scheduledMaintenanceId) {
       throw new BadDataException("scheduledMaintenanceId is null");
     }
@@ -266,6 +370,14 @@ export class Service extends DatabaseService<ScheduledMaintenanceStateTimeline>
       });
     }
 
+    if (mutex) {
+      try {
+        await Semaphore.release(mutex);
+      } catch (err) {
+        logger.error(err);
+      }
+    }
+
     const scheduledMaintenanceState: ScheduledMaintenanceState | null =
       await ScheduledMaintenanceStateService.findOneBy({
         query: {

package/Server/Utils/Monitor/MonitorResource.ts

@@ -15,6 +15,7 @@ import Dictionary from "Common/Types/Dictionary";
 import BadDataException from "Common/Types/Exception/BadDataException";
 import BasicInfrastructureMetrics from "Common/Types/Infrastructure/BasicMetrics";
 import ReturnResult from "Common/Types/IsolatedVM/ReturnResult";
+import Semaphore, { SemaphoreMutex } from "../../Infrastructure/Semaphore";
 import { JSONObject } from "Common/Types/JSON";
 import { CheckOn, CriteriaFilter } from "Common/Types/Monitor/CriteriaFilter";
 import IncomingMonitorRequest from "Common/Types/Monitor/IncomingMonitor/IncomingMonitorRequest";
@@ -43,7 +44,6 @@ import { TelemetryQuery } from "../../../Types/Telemetry/TelemetryQuery";
 import MonitorIncident from "./MonitorIncident";
 import MonitorAlert from "./MonitorAlert";
 import MonitorStatusTimelineUtil from "./MonitorStatusTimeline";
-// import Semaphore, { SemaphoreMutex } from "../../Infrastructure/Semaphore";
 import Metric, {
   MetricPointType,
   ServiceType,
@@ -62,16 +62,16 @@ export default class MonitorResourceUtil {
   public static async monitorResource(
     dataToProcess: DataToProcess,
   ): Promise<ProbeApiIngestResponse> {
-    // let mutex: SemaphoreMutex | null = null;
+    let mutex: SemaphoreMutex | null = null;
 
-    // try {
-    //   mutex = await Semaphore.lock({
-    //     key: dataToProcess.monitorId.toString(),
-    //     namespace: "MonitorResourceUtil.monitorResource",
-    //   });
-    // } catch (err) {
-    //   logger.error(err);
-    // }
+    try {
+      mutex = await Semaphore.lock({
+        key: dataToProcess.monitorId.toString(),
+        namespace: "MonitorResourceUtil.monitorResource",
+      });
+    } catch (err) {
+      logger.error(err);
+    }
 
     let response: ProbeApiIngestResponse = {
       monitorId: dataToProcess.monitorId,
@@ -598,13 +598,13 @@ export default class MonitorResourceUtil {
       }
     }
 
-    // if (mutex) {
-    //   try {
-    //     await Semaphore.release(mutex);
-    //   } catch (err) {
-    //     logger.error(err);
-    //   }
-    // }
+    if (mutex) {
+      try {
+        await Semaphore.release(mutex);
+      } catch (err) {
+        logger.error(err);
+      }
+    }
 
     return response;
   }