Merge 89e8184ce7 into e1b4f9aafe

src/tools/index.ts

@@ -1,6 +1,7 @@
 import { tool as base64FileConverter } from './base64-file-converter';
 import { tool as base64StringConverter } from './base64-string-converter';
 import { tool as basicAuthGenerator } from './basic-auth-generator';
+import { tool as raidCalculator } from './raid-calculator';
 
 import { tool as asciiTextDrawer } from './ascii-text-drawer';
 
@@ -156,7 +157,7 @@ export const toolsByCategory: ToolCategory[] = [
   },
   {
     name: 'Math',
-    components: [mathEvaluator, etaCalculator, percentageCalculator],
+    components: [mathEvaluator, etaCalculator, percentageCalculator, raidCalculator],
   },
   {
     name: 'Measurement',

src/tools/raid-calculator/index.ts

@@ -0,0 +1,12 @@
+import { Database } from '@vicons/tabler';
+import { defineTool } from '../tool';
+
+export const tool = defineTool({
+  name: 'RAID Calculator',
+  path: '/raid-calculator',
+  description: 'Calculate storage capacity, fault tolerance and space efficiency of an array based on the number of disks, size, and RAID type',
+  keywords: ['raid', 'calculator'],
+  component: () => import('./raid-calculator.vue'),
+  icon: Database,
+  createdAt: new Date('2024-07-27'),
+});

src/tools/raid-calculator/raid-calculator.e2e.spec.ts

@@ -0,0 +1,15 @@
+import { expect, test } from '@playwright/test';
+
+test.describe('Tool - RAID Calculator', () => {
+  test.beforeEach(async ({ page }) => {
+    await page.goto('/raid-calculator');
+  });
+
+  test('Has correct title', async ({ page }) => {
+    await expect(page).toHaveTitle('RAID Calculator - IT Tools');
+  });
+
+  test('', async ({ page }) => {
+
+  });
+});

src/tools/raid-calculator/raid-calculator.service.ts

@@ -0,0 +1,151 @@
+export { raidCalculations };
+
+interface RaidType {
+  about: string
+  requirements: string
+  validate(num: number, size: number, stripeSize: number): boolean
+  capacity(num: number, size: number, stripeSize: number, unit: number): number
+  efficiency(num: number, stripeSize: number): number
+  fault(num: number, size: number, unit: number): string
+}
+
+const raidCalculations: { [key: string]: RaidType } = {
+  raid_0: {
+    about: 'RAID 0 splits data evenly across 2 or more disks without redunancy or fault tolerance creating one large storage space.',
+    requirements: 'RAID 0 requires at least 1 disk',
+    validate(num: number, size: number, stripeSize: number) {
+      return num > 1;
+    },
+    capacity(num: number, size: number, stripeSize: number, unit: number) {
+      // total disks * size
+      return (num * size) * unit;
+    },
+    efficiency(num: number, stripeSize: number) {
+      // uses 100% of space
+      return 100;
+    },
+    fault(num: number, size: number, unit: number) {
+      return 'None';
+    },
+  },
+  raid_1: {
+    about: 'RAID 1 consists of an exact copy of the data (mirror) across two or more disks. The array will operate as long as at least one drive is operational.',
+    requirements: 'RAID 1 requires at least 1 disk',
+    validate(num: number, size: number, stripeSize: number) {
+      return num > 1;
+    },
+    capacity(num: number, size: number, stripeSize: number, unit: number) {
+      // total size is size of a single drive
+      return size * unit;
+    },
+    efficiency(num: number, stripeSize: number) {
+      // 1/N
+      return (1 / num) * 100;
+    },
+    fault(num: number, size: number, unit: number) {
+      // FT = total - 1
+      return `${num - 1} drive failures`;
+    },
+  },
+  raid_5: {
+    about: 'RAID 5 uses block level striping with parity. This allows for fault tolerance with a storage reduction equal to one drive for the parity information.',
+    requirements: 'RAID 5 requires at least 3 disks',
+    validate(num: number, size: number, stripeSize: number) {
+      return num >= 3;
+    },
+    capacity(num: number, size: number, stripeSize: number, unit: number) {
+      // (N-1) * S (one drive for parity)
+      return ((num - 1) * size) * unit;
+    },
+    efficiency(num: number, stripeSize: number) {
+      // 1 - (1/N)
+      return (1 - (1 / num)) * 100;
+    },
+    fault(num: number, size: number, unit: number) {
+      // always 1 failure
+      return '1 drive failure';
+    },
+  },
+  raid_6: {
+    about: 'RAID 6 is similiar to RAID 5 but with an additional parity block. This allows for an additional disk failure at the cost of storage reduction equal to two drives.',
+    requirements: 'RAID 6 requires at least 4 disks',
+    validate(num: number, size: number, stripeSize: number) {
+      return num >= 4;
+    },
+    capacity(num: number, size: number, stripeSize: number, unit: number) {
+      // (N-2) * S (2 parity)
+      return ((num - 2) * size) * unit;
+    },
+    efficiency(num: number, stripeSize: number) {
+      // 1 - (2/N)
+      return (1 - (2 / num)) * 100;
+    },
+    fault(num: number, size: number, unit: number) {
+      // always 2 drive failures
+      return '2 drive failures';
+    },
+  },
+  raid_10: {
+    about: 'RAID 10 is a stripe of mirrors (RAID 1 + RAID 0). Each set of drives is mirrored and striped together so that each drive in the set is fault tolerant within the group.',
+    requirements: 'RAID 10 requires an even number of at least 4 disks',
+    validate(num: number, size: number, stripeSize: number) {
+      return num >= 4 && num % 2 === 0;
+    },
+    capacity(num: number, size: number, stripeSize: number, unit: number) {
+      // Total disks (stripe)/2 (mirror)
+      return ((num * size) / 2) * unit;
+    },
+    efficiency(num: number, stripeSize: number) {
+      // 1/2 (1/strips per stripe, 2 in this case)
+      return 50;
+    },
+    fault(num: number, size: number, unit: number) {
+      // one per mirror
+      return '1 drive failure per mirrored set';
+    },
+  },
+  raid_50: {
+    about: 'RAID 50 stripes multiple RAID 5 arrays together (RAID 5 + RAID 0). Each RAID 5 set can sustain a single drive failure.',
+    requirements: 'RAID 50 requires at least 6 disks with 3 minimum per stripe. Stripes must contain an equal number of disks.',
+    validate(num: number, size: number, stripeSize: number) {
+      return num >= 6 && stripeSize >= 3 && num % stripeSize === 0;
+    },
+    capacity(num: number, size: number, stripeSize: number, unit: number) {
+      // RAID 5 per stripe
+      const perStripe = ((stripeSize - 1) * size) * unit;
+
+      // sum each stripe
+      return perStripe * (num / stripeSize);
+    },
+    efficiency(num: number, stripeSize: number) {
+      // 1 - (1 / strips per stripe)
+      return (1 - (1 / stripeSize)) * 100;
+    },
+    fault(num: number, size: number, unit: number) {
+      // one per set
+      return '1 drive failure per RAID 5 set';
+    },
+  },
+  raid_60: {
+    about: 'RAID 60 stripes multiple RAID 6 arrays together (RAID 6 + RAID 0). Each RAID 6 set can sustain a two drive failures.',
+    requirements: 'RAID 60 requires at least 8 disks with 4 minimum per stripe. Stripes must contain an equal number of disks.',
+    validate(num: number, size: number, stripeSize: number) {
+      return num >= 8 && stripeSize >= 4 && num % stripeSize === 0;
+    },
+    capacity(num: number, size: number, stripeSize: number, unit: number) {
+      // RAID 6 per stripe
+      const perStripe = ((stripeSize - 2) * size) * unit;
+
+      // sum each stripe
+      return perStripe * (num / stripeSize);
+    },
+    efficiency(num: number, stripeSize: number) {
+      // 1 - (2 / strips per stripe)
+      return (1 - (2 / stripeSize)) * 100;
+    },
+    fault(num: number, size: number, unit: number) {
+      // 2 per set
+      return '2 drive failures per RAID 6 set';
+    },
+  },
+};

src/tools/raid-calculator/raid-calculator.vue

@@ -0,0 +1,128 @@
+<script setup lang="ts">
+import { raidCalculations } from './raid-calculator.service';
+import { UNIT_BASE, formatBytes } from '@/utils/convert';
+
+const diskTotal = ref(2);
+const diskSize = ref(100);
+const diskUnit = ref(10 ** 9);
+const diskPerStripe = ref(3);
+const raidType = ref('raid_0');
+const raidInfo = computed(() => raidCalculations[raidType.value].about);
+const raidRequirements = computed(() => raidCalculations[raidType.value].requirements);
+const inputsValid = computed(() => validateSetup());
+
+const totalStripes = computed(() => {
+  if (inputsValid.value) {
+    return `${diskTotal.value / diskPerStripe.value} stripes total`;
+  }
+  else {
+    return '';
+  }
+});
+
+const calculatedCapacity = computed(() => {
+  return formatBytes(raidCalculations[raidType.value].capacity(diskTotal.value, diskSize.value, diskPerStripe.value, diskUnit.value), 2, UNIT_BASE.BASE_10);
+});
+
+const calculatedFaultTolerance = computed(() => {
+  return raidCalculations[raidType.value].fault(diskTotal.value, diskSize.value, diskUnit.value);
+});
+
+const calculatedSpaceEfficiency = computed(() => {
+  return raidCalculations[raidType.value].efficiency(diskTotal.value, diskPerStripe.value).toFixed(1);
+});
+
+function validateSetup() {
+  // validate the selected RAID type against parameters
+  return raidCalculations[raidType.value].validate(diskTotal.value, diskSize.value, diskPerStripe.value);
+}
+</script>
+
+<template>
+  <div>
+    <c-card>
+      <n-form-item label="Number of disks" label-placement="left" label-width="150" mb-2>
+        <n-input-number v-model:value="diskTotal" max="10000" min="2" placeholder="Number of disks (ex: 2)" w-full />
+      </n-form-item>
+
+      <n-form-item label="Disk size" label-placement="left" label-width="150" mb-2>
+        <n-input-number v-model:value="diskSize" max="10000" min="1" placeholder="Disk size (ex: 100)" w-full />
+        <div flex items-baseline gap-2>
+          <c-select
+            v-model:value="diskUnit"
+            min-w-130px
+            ml-1
+            :options="[
+              { label: 'MB', value: 10 ** 6 },
+              { label: 'GB', value: 10 ** 9 },
+              { label: 'TB', value: 10 ** 12 },
+              { label: 'PB', value: 10 ** 15 },
+            ]"
+          />
+        </div>
+      </n-form-item>
+      <n-form-item v-if="['raid_50', 'raid_60'].includes(raidType)" label="Disks per stripe" label-placement="left" label-width="150" mb-2>
+        <n-input-number v-model:value="diskPerStripe" max="10000" min="2" placeholder="Number of disks per stripe (ex: 3)" w-full />
+        <n-input v-model:value="totalStripes" placeholder="" ml-1 w-full readonly />
+      </n-form-item>
+      <n-form-item label="RAID Type" label-placement="left" label-width="150" mb-2>
+        <c-select
+          v-model:value="raidType"
+          w-full
+          :options="[
+            { label: 'RAID 0 (stripe)', value: 'raid_0' },
+            { label: 'RAID 1 (mirror)', value: 'raid_1' },
+            { label: 'RAID 5 (parity)', value: 'raid_5' },
+            { label: 'RAID 6 (double parity)', value: 'raid_6' },
+            { label: 'RAID 10 (mirror + stripe)', value: 'raid_10' },
+            { label: 'RAID 50 (parity + stripe)', value: 'raid_50' },
+            { label: 'RAID 60 (double parity + stripe)', value: 'raid_60' },
+          ]"
+        />
+      </n-form-item>
+      <p v-if="!inputsValid" class="raidError">
+        {{ raidRequirements }}
+      </p>
+      <p>
+        {{ raidInfo }}<br /><br />
+        For more information on RAID types, see <a href="https://en.wikipedia.org/wiki/Standard_RAID_levels" target="_blank" rel="noopener">Wikipedia</a>.
+      </p>
+    </c-card>
+    <c-card title="Results">
+      <n-table v-if="inputsValid">
+        <tbody>
+          <tr>
+            <td font-bold width="30%">
+              Capacity
+            </td>
+            <td>
+              {{ calculatedCapacity }}
+            </td>
+          </tr>
+          <tr>
+            <td font-bold width="30%">
+              Fault Tolerance
+            </td>
+            <td>
+              {{ calculatedFaultTolerance }}
+            </td>
+          </tr>
+          <tr>
+            <td font-bold width="30%">
+              Space Efficiency
+            </td>
+            <td>
+              {{ calculatedSpaceEfficiency }}%
+            </td>
+          </tr>
+        </tbody>
+      </n-table>
+    </c-card>
+  </div>
+</template>
+
+<style lang="less" scoped>
+.raidError {
+  color: rgb(208, 48, 80)
+}
+</style>

src/utils/convert.ts

@@ -1,9 +1,14 @@
-export function formatBytes(bytes: number, decimals = 2) {
+export enum UNIT_BASE {
+  BASE_2 = 1024,
+  BASE_10 = 1000,
+}
+
+export function formatBytes(bytes: number, decimals = 2, base: UNIT_BASE = UNIT_BASE.BASE_2) {
   if (bytes === 0) {
     return '0 Bytes';
   }
 
-  const k = 1024;
+  const k = base;
   const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB'];
   const i = Math.floor(Math.log(bytes) / Math.log(k));