add a version number to the cost parameters for licenses

- this is just the first step in util; to really use this, we need
to also make it so the version number is encoded in PurchaseInfo
when the purchase is made.
- need to write some unit tests -- this is exactly the sort of thing
where they are easy and useful

Author: williamstein

src/packages/frontend/site-licenses/purchase/quota-editor.tsx

@@ -47,7 +47,6 @@ import { KUCALC_ON_PREMISES } from "@cocalc/util/db-schema/site-defaults";
 import {
   COSTS,
   CostMap,
-  GCE_COSTS,
 } from "@cocalc/util/licenses/purchase/consts";
 import { User } from "@cocalc/util/licenses/purchase/types";
 import { money } from "@cocalc/util/licenses/purchase/utils";
@@ -112,7 +111,7 @@ export const QuotaEditor: React.FC<Props> = (props: Props) => {
     return (
       (quota.member ? COSTS.custom_cost.member : 1) *
       (quota.always_running ? COSTS.custom_cost.always_running : 1) *
-      (quota.member && quota.always_running ? GCE_COSTS.non_pre_factor : 1)
+      (quota.member && quota.always_running ? COSTS.gce.non_pre_factor : 1)
     );
   }, [quota]);
 
@@ -724,7 +723,7 @@ export const QuotaEditor: React.FC<Props> = (props: Props) => {
           <>
             <b>
               longer idle time increases price by up to{" "}
-              {COSTS.custom_cost.always_running * GCE_COSTS.non_pre_factor}{" "}
+              {COSTS.custom_cost.always_running * COSTS.gce.non_pre_factor}{" "}
               times
             </b>{" "}
             {render_explanation(`If you leave your project alone, it will be shut down the latest

src/packages/util/licenses/purchase/compute-cost.ts

@@ -8,7 +8,7 @@ import {
   LicenseIdleTimeouts,
   requiresMemberhosting,
 } from "@cocalc/util/consts/site-license";
-import { BASIC, COSTS, GCE_COSTS, MAX, STANDARD } from "./consts";
+import { BASIC, getCosts, MAX, STANDARD } from "./consts";
 import { dedicatedPrice } from "./dedicated-price";
 import { Cost, PurchaseInfo } from "./types";
 
@@ -22,6 +22,7 @@ export function compute_cost(info: PurchaseInfo): Cost {
   }
 
   let {
+    version,
     quantity,
     user,
     upgrade,
@@ -35,8 +36,6 @@ export function compute_cost(info: PurchaseInfo): Cost {
     custom_uptime,
   } = info;
 
-  // at this point, we assume the start/end dates are already
-  // set to the start/end time of a day in the user's timezone.
   const start = info.start ? new Date(info.start) : undefined;
   const end = info.end ? new Date(info.end) : undefined;
 
@@ -45,7 +44,7 @@ export function compute_cost(info: PurchaseInfo): Cost {
     throw new Error(`unknown user ${user}`);
   }
 
-  // this is set in the next if/else block
+  // custom_always_running is set in the next if/else block
   let custom_always_running = false;
   if (upgrade == "standard") {
     // set custom_* to what they would be:
@@ -77,6 +76,8 @@ export function compute_cost(info: PurchaseInfo): Cost {
     custom_member = true;
   }
 
+  const COSTS = getCosts(version);
+
   // We compute the cost for one project for one month.
   // First we add the cost for RAM and CPU.
   let cost_per_project_per_month =
@@ -93,7 +94,7 @@ export function compute_cost(info: PurchaseInfo): Cost {
       // always on non-member means it gets restarted whenever the
       // pre-empt gets killed, which is still potentially very useful
       // for long-running computations that can be checkpointed and started.
-      cost_per_project_per_month *= GCE_COSTS.non_pre_factor;
+      cost_per_project_per_month *= COSTS.gce.non_pre_factor;
     }
   } else {
     // multiply by the idle_timeout factor

src/packages/util/licenses/purchase/consts.ts

@@ -5,49 +5,13 @@
 
 import { CustomUpgrades, Subscription, User } from "./types";
 
-// discount is the number we multiply the price by:
-
-// TODO: move the actual **data** that defines this cost map to the database
-// and admin site settings.  It must be something that we can change at any time,
-// and that somebody else selling cocalc would set differently.
-
-// See https://cloud.google.com/compute/vm-instance-pricing#e2_custommachinetypepricing
-// for the monthly GCE prices
-export const GCE_COSTS = {
-  ram: 0.67, // for pre-emptibles
-  cpu: 5, // for pre-emptibles
-  disk: 0.04, // per GB/month
-  non_pre_factor: 3.5, // Roughly Google's factor for non-preemptible's
-} as const;
+import costVersions from "./cost-versions";
+
+// version for licenses before we were using versioning; this is what
+// is used when the version is not defined.
+const FALLBACK_VERSION = "1";
 
-// Our price = GCE price times this.  We charge LESS than Google VM's, due to our gamble
-// on having multiple users on a node at once.
-// 2022-06: price increase "version 2", from 0.75 → 0.8 to compensate for 15% higher GCE prices
-//          and there is also a minimum of 3gb storage (the free base quota) now.
-const COST_MULTIPLIER = 0.8;
-// We gamble that projects are packed at least twice as densely on non-member
-// nodes (it's often worse).
-const NONMEMBER_DENSITY = 2;
-// Changing this doesn't change the actual academic prices --
-// it just changes the *business* prices.
-const ACADEMIC_DISCOUNT = 0.6;
-// Disk factor is based on how many copies of user data we have, plus guesses about
-// bandwidth to transfer data around (to/from cloud storage, backblaze, etc.).
-// 10 since we have about that many copies of user data, plus snapshots, and
-// we store their data long after they stop paying...
-const DISK_FACTOR = 10;
-
-// These are based on what we observe in practice, what works well,
-// and what is configured in our backend autoscalers.  This only
-// impacts the cost of dedicated cpu and RAM.
-const RAM_OVERCOMMIT = 5;
-const CPU_OVERCOMMIT = 10;
-
-// Extra charge if project will always be on. Really we are gambling that
-// projects that are not always on, are off much of the time (at least 50%).
-// We use this factor since a 50-simultaneous active projects license could
-// easily be used about half of the time during a week in a large class.
-const ALWAYS_RUNNING_FACTOR = 2;
+const CURRENT_VERSION = "1";
 
 // Another gamble implicit in this is that pre's are available.  When they
 // aren't, cocalc.com switches to uses MUCH more expensive non-preemptibles.
@@ -62,23 +26,8 @@ export interface CostMap {
   member: number;
 }
 
-export const CUSTOM_COST: CostMap = {
-  ram:
-    (COST_MULTIPLIER * GCE_COSTS.ram) / ACADEMIC_DISCOUNT / NONMEMBER_DENSITY,
-  dedicated_ram:
-    (RAM_OVERCOMMIT * (COST_MULTIPLIER * GCE_COSTS.ram)) /
-    ACADEMIC_DISCOUNT /
-    NONMEMBER_DENSITY,
-  cpu:
-    (COST_MULTIPLIER * GCE_COSTS.cpu) / ACADEMIC_DISCOUNT / NONMEMBER_DENSITY,
-  dedicated_cpu:
-    (CPU_OVERCOMMIT * (COST_MULTIPLIER * GCE_COSTS.cpu)) /
-    ACADEMIC_DISCOUNT /
-    NONMEMBER_DENSITY,
-  disk: (DISK_FACTOR * COST_MULTIPLIER * GCE_COSTS.disk) / ACADEMIC_DISCOUNT,
-  always_running: ALWAYS_RUNNING_FACTOR,
-  member: NONMEMBER_DENSITY,
-} as const;
+// BASIC, STANDARD and MAX have nothing to do with defining pricing.  They
+// are just some presets that might have been used at some point (?).
 
 export const BASIC: CostMap = {
   ram: 1,
@@ -112,36 +61,88 @@ export const MAX: CostMap = {
 
 export const MIN_QUOTE = 100;
 
+interface GoogleComputeEngine {
+  ram: number;
+  cpu: number;
+  disk: number;
+  non_pre_factor: number;
+}
+
 interface CostsStructure {
+  version: string;
+
+  // these are critical to defining and computing the cost of a license
   user_discount: { [user in User]: number };
   sub_discount: { [sub in Subscription]: number };
-  min_quote: number;
   custom_cost: { [key in CustomUpgrades]: number };
   custom_max: { [key in CustomUpgrades]: number };
+  gce: GoogleComputeEngine;
+
+  // not even sure if any of this is ever used anymore -- it's generic.
+  min_quote: number;
   basic: { [key in CustomUpgrades]: number };
   standard: { [key in CustomUpgrades]: number };
   max: { [key in CustomUpgrades]: number };
 }
 
-export const COSTS: CostsStructure = {
-  user_discount: { academic: ACADEMIC_DISCOUNT, business: 1 },
-  sub_discount: { no: 1, monthly: 0.9, yearly: 0.85 },
-  min_quote: MIN_QUOTE,
-  custom_cost: CUSTOM_COST,
-  custom_max: MAX,
-  basic: BASIC,
-  standard: STANDARD,
-  max: MAX,
-} as const;
+export function getCosts(version = FALLBACK_VERSION): CostsStructure {
+  const {
+    SUB_DISCOUNT,
+    GCE_COSTS,
+    COST_MULTIPLIER,
+    NONMEMBER_DENSITY,
+    ACADEMIC_DISCOUNT,
+    DISK_FACTOR,
+    RAM_OVERCOMMIT,
+    CPU_OVERCOMMIT,
+    ALWAYS_RUNNING_FACTOR,
+  } = costVersions[version];
+
+  const CUSTOM_COST: CostMap = {
+    ram:
+      (COST_MULTIPLIER * GCE_COSTS.ram) / ACADEMIC_DISCOUNT / NONMEMBER_DENSITY,
+    dedicated_ram:
+      (RAM_OVERCOMMIT * (COST_MULTIPLIER * GCE_COSTS.ram)) /
+      ACADEMIC_DISCOUNT /
+      NONMEMBER_DENSITY,
+    cpu:
+      (COST_MULTIPLIER * GCE_COSTS.cpu) / ACADEMIC_DISCOUNT / NONMEMBER_DENSITY,
+    dedicated_cpu:
+      (CPU_OVERCOMMIT * (COST_MULTIPLIER * GCE_COSTS.cpu)) /
+      ACADEMIC_DISCOUNT /
+      NONMEMBER_DENSITY,
+    disk: (DISK_FACTOR * COST_MULTIPLIER * GCE_COSTS.disk) / ACADEMIC_DISCOUNT,
+    always_running: ALWAYS_RUNNING_FACTOR,
+    member: NONMEMBER_DENSITY,
+  } as const;
+
+  return {
+    version,
+
+    user_discount: { academic: ACADEMIC_DISCOUNT, business: 1 },
+    sub_discount: SUB_DISCOUNT,
+    custom_cost: CUSTOM_COST,
+    custom_max: MAX,
+    gce: GCE_COSTS,
+
+    min_quote: MIN_QUOTE,
+    basic: BASIC,
+    standard: STANDARD,
+    max: MAX,
+  } as const;
+}
+
+const COSTS = getCosts(CURRENT_VERSION);
+export { COSTS };
 
 export const discount_pct = Math.round(
-  (1 - COSTS.user_discount["academic"]) * 100
+  (1 - COSTS.user_discount["academic"]) * 100,
 );
 
 export const discount_monthly_pct = Math.round(
-  (1 - COSTS.sub_discount["monthly"]) * 100
+  (1 - COSTS.sub_discount["monthly"]) * 100,
 );
 
 export const discount_yearly_pct = Math.round(
-  (1 - COSTS.sub_discount["yearly"]) * 100
+  (1 - COSTS.sub_discount["yearly"]) * 100,
 );

src/packages/util/licenses/purchase/cost-versions.ts

@@ -0,0 +1,50 @@
+// We hard code the prices for licenses (and all versions of them) because they must
+// remain with the system forever, since we always want to be able to easily compute
+// the value of any existing licenses.  For pay-as-you-go, on the other hand, the charges
+// are always short live and ephemeral, and the parameters for them are in the database.
+
+const COST = {
+  1: {
+    // Subscription discount
+    SUB_DISCOUNT: { no: 1, monthly: 0.9, yearly: 0.85 },
+    // See https://cloud.google.com/compute/vm-instance-pricing#e2_custommachinetypepricing
+    // for the monthly GCE prices
+    GCE_COSTS: {
+      ram: 0.67, // for pre-emptibles
+      cpu: 5, // for pre-emptibles
+      disk: 0.04, // per GB/month
+      non_pre_factor: 3.5, // Roughly Google's factor for non-preemptible's
+    },
+
+    // Our price = GCE price times this.  We charge LESS than Google VM's, due to our gamble
+    // on having multiple users on a node at once.
+    // 2022-06: price increase "version 2", from 0.75 → 0.8 to compensate for 15% higher GCE prices
+    //          and there is also a minimum of 3gb storage (the free base quota) now.
+    COST_MULTIPLIER: 0.8,
+    // We gamble that projects are packed at least twice as densely on non-member
+    // nodes (it's often worse).
+    NONMEMBER_DENSITY: 2,
+    // Changing this doesn't change the actual academic prices --
+    // it just changes the *business* prices.
+    ACADEMIC_DISCOUNT: 0.6,
+    // Disk factor is based on how many copies of user data we have, plus guesses about
+    // bandwidth to transfer data around (to/from cloud storage, backblaze, etc.).
+    // 10 since we have about that many copies of user data, plus snapshots, and
+    // we store their data long after they stop paying...
+    DISK_FACTOR: 10,
+
+    // These are based on what we observe in practice, what works well,
+    // and what is configured in our backend autoscalers.  This only
+    // impacts the cost of dedicated cpu and RAM.
+    RAM_OVERCOMMIT: 5,
+    CPU_OVERCOMMIT: 10,
+
+    // Extra charge if project will always be on. Really we are gambling that
+    // projects that are not always on, are off much of the time (at least 50%).
+    // We use this factor since a 50-simultaneous active projects license could
+    // easily be used about half of the time during a week in a large class.
+    ALWAYS_RUNNING_FACTOR: 2,
+  },
+} as const;
+
+export default COST;

src/packages/util/licenses/purchase/types.ts

@@ -54,6 +54,10 @@ import type { Uptime } from "@cocalc/util/consts/site-license";
 import type { DedicatedDisk, DedicatedVM } from "@cocalc/util/types/dedicated";
 import type { CustomDescription, Period } from "../../upgrades/shopping";
 
+interface Version {
+  version?: string; // it's just a string with no special interpretation.
+}
+
 interface PurchaseInfoQuota0 {
   type: "quota";
   user: User;
@@ -77,7 +81,8 @@ interface PurchaseInfoQuota0 {
   run_limit?: number;
 }
 
-export type PurchaseInfoQuota = PurchaseInfoQuota0 &
+export type PurchaseInfoQuota = Version &
+  PurchaseInfoQuota0 &
   CustomDescription &
   StartEndDates;