Jassif Team Institution

// user-service.js
const express = require('express');
const app = express();

app.use(express.json());

// In-memory user database for demonstration
const users = [
  { id: 1, name: 'John Doe', email: 'john@example.com' },
  { id: 2, name: 'Jane Smith', email: 'jane@example.com' }
];

// Get all users
app.get('/users', (req, res) => {
  res.json(users);
});

// Get user by ID
app.get('/users/:id', (req, res) => {
  const user = users.find(u => u.id === parseInt(req.params.id));
  if (!user) return res.status(404).json({ message: 'User not found' });
  res.json(user);
});

// Create a new user
app.post('/users', (req, res) => {
  const newUser = {
    id: users.length + 1,
    name: req.body.name,
    email: req.body.email
  };
  users.push(newUser);
  res.status(201).json(newUser);
});

const PORT = process.env.PORT || 8080;
app.listen(PORT, () => {
  console.log(`User service running on port ${PORT}`);
});

// order-service.js calling the user-service
const axios = require('axios');

async function getUserDetails(userId) {
  try {
    const response = await axios.get(`http://user-service:3001/users/${userId}`);
    return response.data;
  } catch (error) {
    console.error(`Error fetching user ${userId}:`, error.message);
    throw new Error('User service unavailable');
  }
}

// Route handler in order service
app.post('/orders', async (req, res) => {
  const { userId, products } = req.body;
  
  try {
    // Get user data from user service
    const user = await getUserDetails(userId);
    
    // Check product availability from product service
    const productStatus = await checkProductAvailability(products);
    
    if (!productStatus.allAvailable) {
      return res.status(400).json({ error: 'Some products are unavailable' });
    }
    
    // Create the order
    const order = await createOrder(userId, products, user.shippingAddress);
    
    res.status(201).json(order);
  } catch (error) {
    console.error('Order creation failed:', error);
    res.status(500).json({ error: 'Failed to create order' });
  }
});

// order-service.js publishing an event
const axios = require('axios');

async function publishEvent(eventType, data) {
  try {
    await axios.post('http://event-bus:3100/events', {
      type: eventType,
      data: data,
      source: 'order-service',
      timestamp: new Date().toISOString()
    });
    console.log(`Published event: ${eventType}`);
  } catch (error) {
    console.error(`Failed to publish event ${eventType}:`, error.message);
    // Store failed events for retry
    storeFailedEvent(eventType, data, error);
  }
}

// Create an order and publish event
app.post('/orders', async (req, res) => {
  try {
    const order = await createOrder(req.body);
    
    // Publish event for other services
    await publishEvent('order.created', order);
    
    res.status(201).json(order);
  } catch (error) {
    res.status(500).json({ error: 'Order creation failed' });
  }
});

const CircuitBreaker = require('opossum');

// Configure the circuit breaker
const options = {
  failureThreshold: 50,        // Open after 50% of requests fail
  resetTimeout: 10000,         // Try again after 10 seconds
  timeout: 8080,               // Time before request is considered failed
  errorThresholdPercentage: 50 // Error percentage to open circuit
};

// Create a circuit breaker for the user service
const getUserDetailsBreaker = new CircuitBreaker(getUserDetails, options);

// Add listeners for circuit state changes
getUserDetailsBreaker.on('open', () => {
  console.log('Circuit OPEN - User service appears to be down');
});

getUserDetailsBreaker.on('halfOpen', () => {
  console.log('Circuit HALF-OPEN - Testing user service');
});

getUserDetailsBreaker.on('close', () => {
  console.log('Circuit CLOSED - User service restored');
});

// Use the circuit breaker in the route handler
app.get('/orders/:orderId', async (req, res) => {
  const orderId = req.params.orderId;
  const order = await getOrderById(orderId);
  
  try {
    // Call the user service through the circuit breaker
    const user = await getUserDetailsBreaker.fire(order.userId);
    res.json({ order, user });
  } catch (error) {
    // If the circuit is open or the call fails, return fallback data
    console.error('Could not fetch user details:', error.message);
    res.json({
      order,
      user: { id: order.userId, name: 'User details unavailable' }
    });
  }
});

const express = require('express');
const { createProxyMiddleware } = require('http-proxy-middleware');
const rateLimit = require('express-rate-limit');
const helmet = require('helmet');

const app = express();
const PORT = 8080;

// Add security headers
app.use(helmet());

// Apply rate limiting
const apiLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100,                // limit each IP to 100 requests per windowMs
  message: 'Too many requests from this IP, please try again later'
});
app.use('/api/', apiLimiter);

// Authentication middleware
function authenticate(req, res, next) {
  const token = req.headers.authorization;
  if (!token) {
    return res.status(401).json({ error: 'Unauthorized' });
  }
  // Verify token logic would go here
  next();
}

// Service registry (hardcoded for simplicity)
const serviceRegistry = {
  userService: 'http://localhost:3001',
  productService: 'http://localhost:3002',
  orderService: 'http://localhost:3003'
};

// Define proxy middleware for each service
const userServiceProxy = createProxyMiddleware({
  target: serviceRegistry.userService,
  changeOrigin: true,
  pathRewrite: { '^/api/users': '/users' }
});

const productServiceProxy = createProxyMiddleware({
  target: serviceRegistry.productService,
  changeOrigin: true,
  pathRewrite: { '^/api/products': '/products' }
});

const orderServiceProxy = createProxyMiddleware({
  target: serviceRegistry.orderService,
  changeOrigin: true,
  pathRewrite: { '^/api/orders': '/orders' }
});

// Route requests to appropriate services
app.use('/api/users', authenticate, userServiceProxy);
app.use('/api/products', productServiceProxy);
app.use('/api/orders', authenticate, orderServiceProxy);

app.listen(PORT, () => console.log(`API Gateway running on port ${PORT}`));

const axios = require('axios');

// Simple service registry client
class ServiceRegistry {
  constructor(registryUrl) {
    this.registryUrl = registryUrl;
    this.servicesCache = {};
    this.cacheTimeout = 60000; // 1 minute
  }

  async getService(name) {
    // Check cache first
    const cachedService = this.servicesCache[name];
    if (cachedService && cachedService.expiresAt > Date.now()) {
      return this._selectInstance(cachedService.instances);
    }

    // Fetch from registry if not in cache or expired
    try {
      const response = await axios.get(`${this.registryUrl}/services/${name}`);
      const instances = response.data.instances;

      if (!instances || instances.length === 0) {
        throw new Error(`No instances found for service: ${name}`);
      }

      // Update cache
      this.servicesCache[name] = {
        instances,
        expiresAt: Date.now() + this.cacheTimeout
      };

      return this._selectInstance(instances);
    } catch (error) {
      console.error(`Error fetching service ${name}:`, error.message);
      throw new Error(`Service discovery failed for ${name}`);
    }
  }

  // Simple round-robin load balancing
  _selectInstance(instances) {
    if (!instances._lastIndex) {
      instances._lastIndex = 0;
    } else {
      instances._lastIndex = (instances._lastIndex + 1) % instances.length;
    }

    return instances[instances._lastIndex];
  }
}

// Usage example
const serviceRegistry = new ServiceRegistry('http://registry:8500/v1');

async function callUserService(userId) {
  try {
    const serviceInstance = await serviceRegistry.getService('user-service');
    const response = await axios.get(`${serviceInstance.url}/users/${userId}`);
    return response.data;
  } catch (error) {
    console.error('Error calling user service:', error.message);
    throw error;
  }
}

// In order-service.js

async function createOrder(orderData) {
  try {
    // Start the saga - create order
    const order = await orderRepository.create(orderData);

    // Publish event to trigger the next step in the saga
    await eventBus.publish('order.created', { orderId: order.id, ...orderData });

    return order;
  } catch (error) {
    console.error('Failed to create order:', error);
    throw error;
  }
}

// In payment-service.js
async function processPayment(event) {
  const { orderId, userId, amount } = event.data;

  try {
    // Process payment
    const payment = await paymentProcessor.charge(userId, amount, `Order ${orderId}`);

    // Publish success event
    await eventBus.publish('payment.succeeded', {
      orderId,
      paymentId: payment.id
    });
  } catch (error) {
    // Publish failure event to trigger compensation
    await eventBus.publish('payment.failed', {
      orderId,
      reason: error.message
    });
  }
}

// Compensating transaction in order-service.js
async function handlePaymentFailure(event) {
  const { orderId, reason } = event.data;

  // Update order status to 'payment-failed'
  await orderRepository.updateStatus(orderId, 'payment-failed', reason);

  // Notify customer about payment failure
  const order = await orderRepository.findById(orderId);
  await notificationService.notifyCustomer(order.userId, `Payment failed for order ${orderId}: ${reason}`);
}

// Event store
class EventStore {
  constructor() {
    this.events = [];
  }

  append(aggregateId, eventType, eventData) {
    const event = {
      id: this.events.length + 1,
      timestamp: new Date().toISOString(),
      aggregateId,
      type: eventType,
      data: eventData
    };

    this.events.push(event);
    this.publishEvent(event);
    return event;
  }

  getEventsForAggregate(aggregateId) {
    return this.events.filter(event => event.aggregateId === aggregateId);
  }

  publishEvent(event) {
    // Publish to subscribers/event bus
    console.log(`Event published: ${event.type}`);
  }
}

// Order aggregate
class Order {
  constructor(eventStore) {
    this.eventStore = eventStore;
  }

  createOrder(orderId, userId, items) {
    this.eventStore.append(orderId, 'OrderCreated', {
      userId,
      items,
      status: 'created'
    });
  }

  addItem(orderId, item) {
    this.eventStore.append(orderId, 'ItemAdded', { item });
  }

  removeItem(orderId, itemId) {
    this.eventStore.append(orderId, 'ItemRemoved', { itemId });
  }

  submitOrder(orderId) {
    this.eventStore.append(orderId, 'OrderSubmitted', {
      status: 'submitted',
      submittedAt: new Date().toISOString()
    });
  }

  // Rebuild the current state from events
  getOrder(orderId) {
    const events = this.eventStore.getEventsForAggregate(orderId);
    if (events.length === 0) return null;

    let order = { id: orderId, items: [] };

    for (const event of events) {
      switch (event.type) {
        case 'OrderCreated':
          order = { ...order, ...event.data };
          break;
        case 'ItemAdded':
          order.items.push(event.data.item);
          break;
        case 'ItemRemoved':
          order.items = order.items.filter(item => item.id !== event.data.itemId);
          break;
        case 'OrderSubmitted':
          order.status = event.data.status;
          order.submittedAt = event.data.submittedAt;
          break;
      }
    }

    return order;
  }
}

// Basic API Gateway with Express
const express = require('express');
const { createProxyMiddleware } = require('http-proxy-middleware');

const app = express();

// Authentication middleware
app.use('/api', (req, res, next) => {
  const authHeader = req.headers.authorization;
  if (!authHeader) {
    return res.status(401).json({ message: 'Authentication required' });
  }
  // Validate token (simplified)
  next();
});

// Route to services
app.use('/api/users', createProxyMiddleware({
  target: 'http://user-service:8080',
  pathRewrite: { '^/api/users': '/users' }
}));

app.use('/api/orders', createProxyMiddleware({
  target: 'http://order-service:3001',
  pathRewrite: { '^/api/orders': '/orders' }
}));

app.listen(8000, () => {
  console.log('API Gateway running on port 8000');
});

// circuit-breaker.js
class CircuitBreaker {
  constructor(request, options = {}) {
    this.request = request;
    this.state = 'CLOSED';
    this.failureCount = 0;
    this.successCount = 0;
    this.nextAttempt = Date.now();

    // Configurable thresholds
    this.failureThreshold = options.failureThreshold || 5;
    this.successThreshold = options.successThreshold || 2;
    this.timeout = options.timeout || 10000; // 10 seconds
  }

  async fire() {
    if (this.state === 'OPEN') {
      if (this.nextAttempt <= Date.now()) {
        this.state = 'HALF';
      } else {
        throw new Error('Circuit is OPEN');
      }
    }

    try {
      const response = await this.request();
      return this.success(response);
    } catch (err) {
      return this.fail(err);
    }
  }

  success(response) {
    if (this.state === 'HALF') {
      this.successCount++;
      if (this.successCount > this.successThreshold) {
        this.close();
      }
    }
    this.failureCount = 0;
    return response;
  }

  fail(err) {
    this.failureCount++;
    if (this.failureCount >= this.failureThreshold) {
      this.open();
    }
    return err;
  }

  open() {
    this.state = 'OPEN';
    this.nextAttempt = Date.now() + this.timeout;
  }

  close() {
    this.state = 'CLOSED';
    this.failureCount = 0;
    this.successCount = 0;
    this.nextAttempt = 0;
  }
}

module.exports = CircuitBreaker;

// order-saga.js
class OrderSaga {
  constructor(orderId) {
    this.orderId = orderId;
    this.steps = [];
    this.compensations = [];
  }

  addStep(execute, compensate) {
    this.steps.push(execute);
    this.compensations.unshift(compensate);
    return this;
  }

  async execute() {
    const executedSteps = [];

    try {
      for (const [index, step] of this.steps.entries()) {
        await step();
        executedSteps.push(index);
      }
      return { success: true };
    } catch (error) {
      console.error('Saga execution failed, compensating...', error);
      await this.compensate(executedSteps);
      return { success: false, error };
    }
  }

  async compensate(executedSteps) {
    for (const stepIndex of executedSteps) {
      try {
        await this.compensations[stepIndex]();
      } catch (compError) {
        console.error('Compensation failed:', compError);
      }
    }
  }
}

// Example usage
const orderSaga = new OrderSaga('order-123')
  .addStep(
    () => orderService.createOrder({ id: 'order-123', items: ['item1', 'item2'] }),
    () => orderService.cancelOrder('order-123')
  )
  .addStep(
    () => paymentService.processPayment('order-123', 100.00),
    () => paymentService.refundPayment('order-123')
  );

orderSaga.execute();

FROM node:16-alpine

WORKDIR /app

COPY package*.json ./
RUN npm ci --only=production

COPY . .

EXPOSE 8080

CMD ["node", "user-service.js"]

apiVersion: apps/v1
kind: Deployment
metadata:
  name: user-service
spec:
  replicas: 3
  selector:
    matchLabels:
      app: user-service
  template:
    metadata:
      labels:
        app: user-service
    spec:
      containers:
      - name: user-service
        image: my-registry/user-service:latest
        ports:
        - containerPort: 8080
        env:
        - name: DB_HOST
          value: mongodb-service
        resources:
          limits:
            cpu: "0.5"
            memory: "512Mi"
          requests:
            cpu: "0.2"
            memory: "256Mi"

// auth-middleware.js
const jwt = require('jsonwebtoken');
const authenticateService = (req, res, next) => {
  const authHeader = req.headers.authorization;
  if (!authHeader) {
    return res.status(401).json({ message: 'No token provided' });
  }

  const token = authHeader.split(' ')[1];

  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    if (decoded.iss !== 'auth-service') {
      return res.status(403).json({ message: 'Invalid token issuer' });
    }

    // Attach service info to request
    req.service = {
      id: decoded.sub,
      name: decoded.serviceName,
      permissions: decoded.permissions || []
    };

    next();
  } catch (error) {
    return res.status(401).json({ message: 'Invalid or expired token' });
  }
};

module.exports = authenticateService;

// rate-limiter.js
const rateLimit = require('express-rate-limit');
const RedisStore = require('rate-limit-redis');
const { createClient } = require('redis');
// Create Redis client

const redisClient = createClient({
  url: process.env.REDIS_URL
});

// Initialize rate limiter
const apiLimiter = rateLimit({
  windowMs: 15 * 60 * 1000, // 15 minutes
  max: 100, // Limit each IP to 100 requests per window
  standardHeaders: true, // Return rate limit info in the `RateLimit-*` headers
  store: new RedisStore({
    sendCommand: (...args) => redisClient.sendCommand(args)
  }),
  handler: (req, res) => {
    res.status(429).json({
      message: 'Too many requests, please try again later.'
    });
  }
});

module.exports = apiLimiter;

// tracing.js
const { NodeTracerProvider } = require('@opentelemetry/sdk-trace-node');
const { Resource } = require('@opentelemetry/resources');
const { SemanticResourceAttributes } = require('@opentelemetry/semantic-conventions');
const { BatchSpanProcessor } = require('@opentelemetry/sdk-trace-base');
const { JaegerExporter } = require('@opentelemetry/exporter-jaeger');
const { registerInstrumentations } = require('@opentelemetry/instrumentation');
const { HttpInstrumentation } = require('@opentelemetry/instrumentation-http');
const { ExpressInstrumentation } = require('@opentelemetry/instrumentation-express');


// Configure the tracer provider
const provider = new NodeTracerProvider({
  resource: new Resource({
    [SemanticResourceAttributes.SERVICE_NAME]: 'user-service',
    'service.version': '1.0.0',
  }),
});

// Configure Jaeger exporter
const exporter = new JaegerExporter({
  endpoint: process.env.JAEGER_ENDPOINT || 'http://localhost:14268/api/traces',
});

// Add the exporter to the provider
provider.addSpanProcessor(new BatchSpanProcessor(exporter));

// Initialize the OpenTelemetry APIs to use the NodeTracerProvider
provider.register();

// Register instrumentations
registerInstrumentations({
  instrumentations: [
    new HttpInstrumentation(),
    new ExpressInstrumentation(),
  ],
  tracerProvider: provider,
});

console.log('Tracing initialized');

// logger.js
const winston = require('winston');
const { combine, timestamp, json } = winston.format;

const logger = winston.createLogger({
  level: process.env.LOG_LEVEL || 'info',
  format: combine(
    timestamp(),
    json()
  ),
  defaultMeta: {
    service: 'user-service',
    environment: process.env.NODE_ENV || 'development',
  },
  transports: [
    new winston.transports.Console(),
    // Add other transports like file, ELK, etc.
  ],
});

// Add request ID to logs
logger.child = function(opts) {
  return new Proxy(logger, {
    get(target, property, receiver) {
      if (property === 'write') {
        return (...args) => {
          const originalMeta = args[args.length - 1] || {};
          args[args.length - 1] = { ...opts, ...originalMeta };
          return logger[property](...args);
        };
      }
      return Reflect.get(target, property, receiver);
    },
  });
};

module.exports = logger;