EdgeOne Implementation of Session Persistence Based on Client IP Addresses

// Based on client IP addresses, return the clients to different origin server groups, i.e., with the same IP address, the same client returns to the same origin server.
const ORIGIN_GROUPS = ["originGroup1", "originGroup2"];

// Define the number of virtual nodes. If there are many origin server groups (ORIGIN_GROUPS), it is recommended to reduce the number of virtual nodes.
const VIRTUAL_NODES_PER_GROUP = 15;
const ORIGIN_HEADER_NAME = 'X-Forwarded-For-Origin';
let virtualNodesHashesCache = null;

// Define global variables to track the function invocation count.
addEventListener("fetch", (event) => {
  handleRequest(event.request);
});

async function handleRequest(request) {
  // Obtain the client IP address through the EO-Client-IP header.
  const ip = request.headers.get("EO-Client-IP") || "";
  
  // If there are no hash values for virtual nodes in the cache, generate the hash values.
  if (!virtualNodesHashesCache) {
    virtualNodesHashesCache = await generateVirtualNodesHashes();
  }
  
  const group = await findSourceGroupForIp(
    ip,
    virtualNodesHashesCache.hashes,
    virtualNodesHashesCache.mapping
  );
  console.log(`Group: ${group}`);
  
  request.headers.set(ORIGIN_HEADER_NAME, group)

  return;
}

// Generate virtual nodes' hash values.
async function generateVirtualNodesHashes() {
  const virtualNodesHashes = {};
  
  for (let group in ORIGIN_GROUPS) {
    for (let i = 0; i < VIRTUAL_NODES_PER_GROUP; i++) {
      const virtualNodeIdentifier = `${group}-VN${i}`;
      const hash = await md5(virtualNodeIdentifier);
      if (!virtualNodesHashes[hash]) {
        virtualNodesHashes[hash] = group;
      }
    }
  }

  const hashes = Object.keys(virtualNodesHashes).sort();
  
  return { hashes, mapping: virtualNodesHashes }; // Return the sorted array of hash values and mapping relationship.
}

// Map the client IP address to the virtual node and find the corresponding origin server group.
async function findSourceGroupForIp(ip, hashes, mapping) {
  
  // Use the MD5 function to calculate the hash value of the IP address.
  const ipHash = await md5(ip);
  let closestHash = hashes.find((hash) => hash > ipHash) || hashes[0];
  
  // Based on the found hash value of the virtual node, obtain the corresponding origin server group name from the virtual node hash table.
  const selectedGroupName = mapping[closestHash];
  const selectedGroupIPs = ORIGIN_GROUPS[selectedGroupName];
  
  // Print logs that display the client IP address, hash value, closest virtual node hash value, and selected origin server group name.
  console.log(
    `IP: ${ip}, Hash: ${ipHash}, Closest Hash: ${closestHash}, Selected Group: ${selectedGroupName}`
  );
  
  // Return the selected origin server group name.
  return selectedGroupIPs;
}

function bufferToHex(arr) {
  return Array.prototype.map
    .call(arr, (x) => (x >= 16 ? x.toString(16) : "0" + x.toString(16)))
    .join("");
}

async function md5(text) {
  const buffer = await crypto.subtle.digest("MD5", TextEncoder().encode(text));
  return bufferToHex(new Uint8Array(buffer));
}