chore: add constants for file size and replace throughout app

Author: jescalada

src/config/index.ts

@@ -5,6 +5,7 @@ import { GitProxyConfig, Convert } from './generated/config';
 import { ConfigLoader, Configuration } from './ConfigLoader';
 import { serverConfig } from './env';
 import { configFile } from './file';
+import { GIGABYTE } from '../constants';
 
 // Cache for current configuration
 let _currentConfig: GitProxyConfig | null = null;
@@ -299,7 +300,7 @@ export const getRateLimit = () => {
 export const getMaxPackSizeBytes = (): number => {
   const config = loadFullConfiguration();
   const configuredValue = config.limits?.maxPackSizeBytes;
-  const fallback = 1024 * 1024 * 1024; // 1 GiB default
+  const fallback = 1 * GIGABYTE; // 1 GiB default
 
   if (
     typeof configuredValue === 'number' &&

src/constants/index.ts

@@ -0,0 +1,5 @@
+const KILOBYTE = 1024;
+const MEGABYTE = KILOBYTE * 1024;
+const GIGABYTE = MEGABYTE * 1024;
+
+export { KILOBYTE, MEGABYTE, GIGABYTE };

src/proxy/routes/index.ts

@@ -6,6 +6,7 @@ import { executeChain } from '../chain';
 import { processUrlPath, validGitRequest, getAllProxiedHosts } from './helper';
 import { ProxyOptions } from 'express-http-proxy';
 import { getMaxPackSizeBytes } from '../../config';
+import { MEGABYTE } from '../../constants';
 
 enum ActionType {
   ALLOWED = 'Allowed',
@@ -151,10 +152,10 @@ const extractRawBody = async (req: Request, res: Response, next: NextFunction) =
   }
 
   const proxyStream = new PassThrough({
-    highWaterMark: 4 * 1024 * 1024,
+    highWaterMark: 4 * MEGABYTE,
   });
   const pluginStream = new PassThrough({
-    highWaterMark: 4 * 1024 * 1024,
+    highWaterMark: 4 * MEGABYTE,
   });
 
   req.pipe(proxyStream);

src/proxy/ssh/server.ts

@@ -8,6 +8,7 @@ import * as db from '../../db';
 import { Action } from '../actions';
 import { SSHAgent } from '../../security/SSHAgent';
 import { SSHKeyManager } from '../../security/SSHKeyManager';
+import { KILOBYTE, MEGABYTE } from '../../constants';
 
 interface SSHUser {
   username: string;
@@ -795,8 +796,8 @@ export class SSHServer {
         readyTimeout: 30000,
         keepaliveInterval: 15000,
         keepaliveCountMax: 5,
-        windowSize: 1024 * 1024,
-        packetSize: 32768,
+        windowSize: 1 * MEGABYTE,
+        packetSize: 32 * KILOBYTE,
         privateKey: usingUserKey ? (userPrivateKey as Buffer) : proxyPrivateKey,
         debug: (msg: string) => {
           console.debug('[GitHub SSH Debug]', msg);
@@ -950,8 +951,8 @@ export class SSHServer {
         readyTimeout: 30000,
         keepaliveInterval: 15000, // 15 seconds between keepalives (recommended for SSH connections is 15-30 seconds)
         keepaliveCountMax: 5, // Recommended for SSH connections is 3-5 attempts
-        windowSize: 1024 * 1024, // 1MB window size
-        packetSize: 32768, // 32KB packet size
+        windowSize: 1 * MEGABYTE, // 1MB window size
+        packetSize: 32 * KILOBYTE, // 32KB packet size
         privateKey: fs.readFileSync(sshConfig.hostKey.privateKeyPath),
         debug: (msg: string) => {
           console.debug('[GitHub SSH Debug]', msg);

test/proxy/performance.test.js

@@ -1,10 +1,11 @@
 const chai = require('chai');
+const { KILOBYTE, MEGABYTE } = require('../../src/constants');
 const expect = chai.expect;
 
 describe('HTTP/HTTPS Performance Tests', () => {
   describe('Memory Usage Tests', () => {
     it('should handle small POST requests efficiently', async () => {
-      const smallData = Buffer.alloc(1024); // 1KB
+      const smallData = Buffer.alloc(1 * KILOBYTE);
       const startMemory = process.memoryUsage().heapUsed;
 
       // Simulate request processing
@@ -20,12 +21,12 @@ describe('HTTP/HTTPS Performance Tests', () => {
       const endMemory = process.memoryUsage().heapUsed;
       const memoryIncrease = endMemory - startMemory;
 
-      expect(memoryIncrease).to.be.lessThan(1024 * 5); // Should use less than 5KB
-      expect(req.body.length).to.equal(1024);
+      expect(memoryIncrease).to.be.lessThan(KILOBYTE * 5); // Should use less than 5KB
+      expect(req.body.length).to.equal(KILOBYTE);
     });
 
     it('should handle medium POST requests within reasonable limits', async () => {
-      const mediumData = Buffer.alloc(10 * 1024 * 1024); // 10MB
+      const mediumData = Buffer.alloc(10 * MEGABYTE);
       const startMemory = process.memoryUsage().heapUsed;
 
       // Simulate request processing
@@ -41,12 +42,12 @@ describe('HTTP/HTTPS Performance Tests', () => {
       const endMemory = process.memoryUsage().heapUsed;
       const memoryIncrease = endMemory - startMemory;
 
-      expect(memoryIncrease).to.be.lessThan(15 * 1024 * 1024); // Should use less than 15MB
-      expect(req.body.length).to.equal(10 * 1024 * 1024);
+      expect(memoryIncrease).to.be.lessThan(15 * MEGABYTE); // Should use less than 15MB
+      expect(req.body.length).to.equal(10 * MEGABYTE);
     });
 
     it('should handle large POST requests up to size limit', async () => {
-      const largeData = Buffer.alloc(100 * 1024 * 1024); // 100MB
+      const largeData = Buffer.alloc(100 * MEGABYTE);
       const startMemory = process.memoryUsage().heapUsed;
 
       // Simulate request processing
@@ -62,25 +63,25 @@ describe('HTTP/HTTPS Performance Tests', () => {
       const endMemory = process.memoryUsage().heapUsed;
       const memoryIncrease = endMemory - startMemory;
 
-      expect(memoryIncrease).to.be.lessThan(120 * 1024 * 1024); // Should use less than 120MB
-      expect(req.body.length).to.equal(100 * 1024 * 1024);
+      expect(memoryIncrease).to.be.lessThan(120 * MEGABYTE); // Should use less than 120MB
+      expect(req.body.length).to.equal(100 * MEGABYTE);
     });
 
     it('should reject requests exceeding size limit', async () => {
-      const oversizedData = Buffer.alloc(1200 * 1024 * 1024); // 1.2GB (exceeds 1GB limit)
+      const oversizedData = Buffer.alloc(1200 * MEGABYTE); // 1.2GB (exceeds 1GB limit)
 
       // Simulate size check
-      const maxPackSize = 1024 * 1024 * 1024;
+      const maxPackSize = 1 * GIGABYTE;
       const requestSize = oversizedData.length;
 
       expect(requestSize).to.be.greaterThan(maxPackSize);
-      expect(requestSize).to.equal(1200 * 1024 * 1024);
+      expect(requestSize).to.equal(1200 * MEGABYTE);
     });
   });
 
   describe('Processing Time Tests', () => {
     it('should process small requests quickly', async () => {
-      const smallData = Buffer.alloc(1024); // 1KB
+      const smallData = Buffer.alloc(1 * KILOBYTE);
       const startTime = Date.now();
 
       // Simulate processing
@@ -96,11 +97,11 @@ describe('HTTP/HTTPS Performance Tests', () => {
       const processingTime = Date.now() - startTime;
 
       expect(processingTime).to.be.lessThan(100); // Should complete in less than 100ms
-      expect(req.body.length).to.equal(1024);
+      expect(req.body.length).to.equal(1 * KILOBYTE);
     });
 
     it('should process medium requests within acceptable time', async () => {
-      const mediumData = Buffer.alloc(10 * 1024 * 1024); // 10MB
+      const mediumData = Buffer.alloc(10 * MEGABYTE);
       const startTime = Date.now();
 
       // Simulate processing
@@ -116,11 +117,11 @@ describe('HTTP/HTTPS Performance Tests', () => {
       const processingTime = Date.now() - startTime;
 
       expect(processingTime).to.be.lessThan(1000); // Should complete in less than 1 second
-      expect(req.body.length).to.equal(10 * 1024 * 1024);
+      expect(req.body.length).to.equal(10 * MEGABYTE);
     });
 
     it('should process large requests within reasonable time', async () => {
-      const largeData = Buffer.alloc(100 * 1024 * 1024); // 100MB
+      const largeData = Buffer.alloc(100 * MEGABYTE);
       const startTime = Date.now();
 
       // Simulate processing
@@ -136,7 +137,7 @@ describe('HTTP/HTTPS Performance Tests', () => {
       const processingTime = Date.now() - startTime;
 
       expect(processingTime).to.be.lessThan(5000); // Should complete in less than 5 seconds
-      expect(req.body.length).to.equal(100 * 1024 * 1024);
+      expect(req.body.length).to.equal(100 * MEGABYTE);
     });
   });
 
@@ -148,7 +149,7 @@ describe('HTTP/HTTPS Performance Tests', () => {
       // Simulate 10 concurrent small requests
       for (let i = 0; i < 10; i++) {
         const request = new Promise((resolve) => {
-          const smallData = Buffer.alloc(1024);
+          const smallData = Buffer.alloc(1 * KILOBYTE);
           const req = {
             method: 'POST',
             url: '/github.com/test/test-repo.git/git-receive-pack',
@@ -168,7 +169,7 @@ describe('HTTP/HTTPS Performance Tests', () => {
       expect(results).to.have.length(10);
       expect(totalTime).to.be.lessThan(1000); // Should complete all in less than 1 second
       results.forEach((result) => {
-        expect(result.body.length).to.equal(1024);
+        expect(result.body.length).to.equal(1 * KILOBYTE);
       });
     });
 
@@ -177,7 +178,7 @@ describe('HTTP/HTTPS Performance Tests', () => {
       const startTime = Date.now();
 
       // Simulate mixed operations
-      const sizes = [1024, 1024 * 1024, 10 * 1024 * 1024]; // 1KB, 1MB, 10MB
+      const sizes = [1 * KILOBYTE, 1 * MEGABYTE, 10 * MEGABYTE];
 
       for (let i = 0; i < 9; i++) {
         const request = new Promise((resolve) => {
@@ -226,7 +227,7 @@ describe('HTTP/HTTPS Performance Tests', () => {
       const processingTime = endTime - startTime;
 
       expect(processingTime).to.be.lessThan(100); // Should handle errors quickly
-      expect(memoryIncrease).to.be.lessThan(2048); // Should not leak memory (allow for GC timing)
+      expect(memoryIncrease).to.be.lessThan(2 * KILOBYTE); // Should not leak memory (allow for GC timing)
     });
 
     it('should handle malformed requests efficiently', async () => {
@@ -239,7 +240,7 @@ describe('HTTP/HTTPS Performance Tests', () => {
         headers: {
           'content-type': 'application/x-git-receive-pack-request',
         },
-        body: Buffer.alloc(1024),
+        body: Buffer.alloc(1 * KILOBYTE),
       };
 
       // Simulate validation
@@ -256,24 +257,24 @@ describe('HTTP/HTTPS Performance Tests', () => {
       const startMemory = process.memoryUsage().heapUsed;
 
       // Simulate processing with cleanup
-      const data = Buffer.alloc(10 * 1024 * 1024); // 10MB
+      const data = Buffer.alloc(10 * MEGABYTE);
       const _processedData = Buffer.concat([data]);
 
       // Simulate cleanup
       data.fill(0); // Clear buffer
       const cleanedMemory = process.memoryUsage().heapUsed;
 
-      expect(_processedData.length).to.equal(10 * 1024 * 1024);
+      expect(_processedData.length).to.equal(10 * MEGABYTE);
       // Memory should be similar to start (allowing for GC timing)
-      expect(cleanedMemory - startMemory).to.be.lessThan(5 * 1024 * 1024);
+      expect(cleanedMemory - startMemory).to.be.lessThan(5 * MEGABYTE);
     });
 
     it('should handle multiple cleanup cycles without memory growth', async () => {
       const initialMemory = process.memoryUsage().heapUsed;
 
       // Simulate multiple processing cycles
       for (let i = 0; i < 5; i++) {
-        const data = Buffer.alloc(5 * 1024 * 1024); // 5MB
+        const data = Buffer.alloc(5 * MEGABYTE);
         const _processedData = Buffer.concat([data]);
         data.fill(0); // Cleanup
 
@@ -287,7 +288,7 @@ describe('HTTP/HTTPS Performance Tests', () => {
       const memoryGrowth = finalMemory - initialMemory;
 
       // Memory growth should be minimal
-      expect(memoryGrowth).to.be.lessThan(10 * 1024 * 1024); // Less than 10MB growth
+      expect(memoryGrowth).to.be.lessThan(10 * MEGABYTE); // Less than 10MB growth
     });
   });
 
@@ -298,7 +299,7 @@ describe('HTTP/HTTPS Performance Tests', () => {
       // Simulate config loading
       const testConfig = {
         proxy: { port: 8000, host: 'localhost' },
-        limits: { maxPackSizeBytes: 1024 * 1024 * 1024 },
+        limits: { maxPackSizeBytes: 1 * GIGABYTE },
       };
 
       const endTime = Date.now();
@@ -315,7 +316,7 @@ describe('HTTP/HTTPS Performance Tests', () => {
       // Simulate config validation
       const testConfig = {
         proxy: { port: 8000 },
-        limits: { maxPackSizeBytes: 1024 * 1024 * 1024 },
+        limits: { maxPackSizeBytes: 1 * GIGABYTE },
       };
       const isValid = testConfig.proxy.port > 0 && testConfig.limits.maxPackSizeBytes > 0;
 

test/ssh/integration.test.js

@@ -6,6 +6,7 @@ const ssh2 = require('ssh2');
 const config = require('../../src/config');
 const db = require('../../src/db');
 const chain = require('../../src/proxy/chain');
+const { MEGABYTE } = require('../../src/constants');
 const SSHServer = require('../../src/proxy/ssh/server').default;
 
 describe('SSH Pack Data Capture Integration Tests', () => {
@@ -63,7 +64,7 @@ describe('SSH Pack Data Capture Integration Tests', () => {
     // Stub dependencies
     sinon.stub(config, 'getSSHConfig').callsFake(mockConfig.getSSHConfig);
     sinon.stub(config, 'getProxyUrl').callsFake(mockConfig.getProxyUrl);
-    sinon.stub(config, 'getMaxPackSizeBytes').returns(500 * 1024 * 1024);
+    sinon.stub(config, 'getMaxPackSizeBytes').returns(500 * MEGABYTE);
     sinon.stub(db, 'findUserBySSHKey').callsFake(mockDb.findUserBySSHKey);
     sinon.stub(db, 'findUser').callsFake(mockDb.findUser);
     sinon.stub(chain.default, 'executeChain').callsFake(mockChain.executeChain);
@@ -147,7 +148,7 @@ describe('SSH Pack Data Capture Integration Tests', () => {
       // Simulate large but acceptable pack data (100MB)
       const dataHandler = mockStream.on.withArgs('data').firstCall?.args[1];
       if (dataHandler) {
-        const largePack = Buffer.alloc(100 * 1024 * 1024, 'pack-data');
+        const largePack = Buffer.alloc(100 * MEGABYTE, 'pack-data');
         dataHandler(largePack);
       }
 
@@ -164,7 +165,7 @@ describe('SSH Pack Data Capture Integration Tests', () => {
       // Simulate oversized pack data (600MB)
       const dataHandler = mockStream.on.withArgs('data').firstCall?.args[1];
       if (dataHandler) {
-        const oversizedPack = Buffer.alloc(600 * 1024 * 1024, 'oversized-pack');
+        const oversizedPack = Buffer.alloc(600 * MEGABYTE, 'oversized-pack');
         dataHandler(oversizedPack);
       }