@peerbit/server 3.0.0 → 4.0.1

package/lib/ui/index.html

@@ -23,7 +23,7 @@
       Learn how to configure a non-root public URL by running `npm run build`.
     -->
 	<title>Peerbit</title>
-  <script type="module" crossorigin src="/assets/index-cac7195d.js"></script>
+  <script type="module" crossorigin src="/assets/index-5ed0229d.js"></script>
   <link rel="stylesheet" href="/assets/index-5265c558.css">
 </head>
 

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@peerbit/server",
-	"version": "3.0.0",
+	"version": "4.0.1",
 	"author": "dao.xyz",
 	"repository": {
 		"type": "git",
@@ -23,7 +23,10 @@
 		"./lib/esm/config.js": "./lib/esm/config.browser.js",
 		"./config.js": "./lib/esm/config.browser.js",
 		"./lib/esm/remotes.js": "./lib/esm/remotes.browser.js",
-		"./remotes.js": "./lib/esm/remotes.browser.js"
+		"./remotes.js": "./lib/esm/remotes.browser.js",
+		"./lib/esm/docker.js": "./lib/esm/docker.browser.js",
+		"./docker.js": "./lib/esm/docker.browser.js",
+		"./lib/esm/aws.js": "./lib/esm/aws.browser.js"
 	},
 	"files": [
 		"lib",
@@ -52,22 +55,25 @@
 	},
 	"devDependencies": {
 		"@peerbit/test-lib": "^0.0.1",
-		"@peerbit/test-utils": "1.0.17",
+		"@peerbit/test-utils": "1.0.18",
 		"@types/tmp": "^0.2.3",
 		"@types/yargs": "^17.0.24",
 		"aws-sdk": "^2.1259.0",
 		"dotenv": "^16.1.4"
 	},
 	"dependencies": {
-		"@aws-sdk/client-route-53": "^3.345.0",
-		"@dao-xyz/libp2p-noise": "^12.0.1",
+		"@dao-xyz/libp2p-noise": "^13.0.1",
 		"axios": "^1.4.0",
 		"chalk": "^5.3.0",
-		"peerbit": "1.3.1",
+		"peerbit": "2.0.0",
 		"tar-stream": "^3.1.6",
 		"tmp": "^0.2.1",
 		"yargs": "^17.7.2",
 		"zlib": "^1.0.5"
 	},
-	"gitHead": "06d341c4ea81b70c76018899b029f4419c311500"
+	"optionalDependencies": {
+		"@aws-sdk/client-ec2": "^3.390.0",
+		"@aws-sdk/client-route-53": "^3.391.0"
+	},
+	"gitHead": "bc0b13f17bf92ec4284d95153f047faf2a336b11"
 }

package/src/aws.browser.ts

@@ -0,0 +1 @@
+// Unsupported

package/src/aws.ts

@@ -1,4 +1,5 @@
-import { getMyIp } from "./domain.js";
+import { delay } from "@peerbit/time";
+import { type PeerId } from "@libp2p/interface/peer-id";
 
 export const createRecord = async (options: {
 	domain: string;
@@ -10,6 +11,7 @@ export const createRecord = async (options: {
 		"@aws-sdk/client-route-53"
 	);
 	const { isIPv4, isIPv6 } = await import("net");
+	const { getMyIp } = await import("./domain.js");
 
 	const myIp = await getMyIp();
 	const v4 = isIPv4(myIp);
@@ -46,3 +48,250 @@ export const createRecord = async (options: {
 	});
 	await client.send(cmd);
 };
+
+const setupUserData = (email: string, grantAccess: PeerId[] = []) => {
+	const peerIdStrings = grantAccess.map((x) => x.toString());
+	return `#!/bin/bash
+cd /home/ubuntu
+curl -fsSL https://deb.nodesource.com/setup_19.x | sudo -E bash - &&\
+sudo apt-get install -y nodejs
+npm install -g @peerbit/server
+sudo peerbit domain test --email ${email}
+peerbit start ${peerIdStrings.map((key) => `--ga ${key}`)} > log.txt 2>&1 &
+`;
+};
+const PURPOSE_TAG_NAME = "Purpose";
+const PURPOSE_TAG_VALUE = "Peerbit";
+
+// Ubuntu Server 20.04 LTS (HVM), SSD Volume Type (64-bit (Arm))
+export const AWS_LINUX_ARM_AMIs: Record<string, string> = {
+	/* 	"af-south-1" */
+	"ap-northeast-1": "ami-01444f83954203c6f",
+	"ap-northeast-2": "ami-0ac62099928d25fec",
+	"ap-northeast-3": "ami-0efdceaebc778c5f3",
+	"ap-south-1": "ami-0df6182e39efe7c4d",
+	"ap-southeast-1": "ami-01d87e25d3c65ec37",
+	"ap-southeast-2": "ami-0641fc20c25fdd380",
+	/* 	"ap-south-2", */
+	/* 	"ap-southeast-3",
+		"ap-southeast-4", */
+	"ca-central-1": "ami-0a3e942fe4813672b",
+	/* 	"cn-north-1",
+		"cn-northwest-1", */
+	"eu-central-1": "ami-0d85ad3aa712d96af",
+	/* 	"eu-central-2", */
+	"eu-north-1": "ami-0ff124a3d7381bfec",
+	/* 	"eu-south-1",
+		"eu-south-2", */
+	"eu-west-1": "ami-09c59b011574e4c96",
+	"eu-west-2": "ami-03e26d11b665ac7be",
+	"eu-west-3": "ami-00771c0ac817397bd",
+	/* 	"il-central-1",
+		"me-central-1",
+		"me-south-1", */
+	"sa-east-1": "ami-08dc4b989f93eafb9",
+	"us-east-1": "ami-097d5b19d4f1a7d1b",
+	"us-east-2": "ami-0071e4b30f26879e2",
+	/* 	"us-gov-east-1",
+		"us-gov-west-1", */
+	"us-west-1": "ami-0dca369228f3b2ce7",
+	"us-west-2": "ami-0c79a55dda52434da",
+};
+export const launchNodes = async (properties: {
+	region?: string;
+	email: string;
+	count?: number;
+	size?: "micro" | "small" | "medium" | "large" | "xlarge" | "2xlarge";
+	namePrefix?: string;
+	grantAccess?: PeerId[];
+}): Promise<
+	{ instanceId: string; publicIp: string; name: string; region: string }[]
+> => {
+	if (properties.count && properties.count > 10) {
+		throw new Error(
+			"Unexpected node launch count: " +
+				properties.count +
+				". To prevent unwanted behaviour you can also launch 10 nodes at once"
+		);
+	}
+	const count = properties.count || 1;
+
+	const {
+		EC2Client,
+		CreateTagsCommand,
+		RunInstancesCommand,
+		DescribeSecurityGroupsCommand,
+		CreateSecurityGroupCommand,
+		AuthorizeSecurityGroupIngressCommand,
+		DescribeInstancesCommand,
+	} = await import("@aws-sdk/client-ec2");
+	const client = new EC2Client({ region: properties.region });
+	const regionString = await client.config.region();
+
+	let securityGroupOut = (
+		await client.send(
+			new DescribeSecurityGroupsCommand({
+				Filters: [
+					{ Name: "tag:" + PURPOSE_TAG_NAME, Values: [PURPOSE_TAG_VALUE] },
+				],
+			})
+		)
+	)?.SecurityGroups?.[0];
+	if (!securityGroupOut) {
+		securityGroupOut = await client.send(
+			new CreateSecurityGroupCommand({
+				GroupName: "peerbit-node",
+				Description: "Security group for running Peerbit nodes",
+			})
+		);
+		await client.send(
+			new CreateTagsCommand({
+				Resources: [securityGroupOut.GroupId!],
+				Tags: [{ Key: PURPOSE_TAG_NAME, Value: PURPOSE_TAG_VALUE }],
+			})
+		);
+		await client.send(
+			new AuthorizeSecurityGroupIngressCommand({
+				GroupId: securityGroupOut.GroupId,
+				IpPermissions: [
+					{
+						IpRanges: [{ CidrIp: "0.0.0.0/0" }],
+						IpProtocol: "tcp",
+						FromPort: 80,
+						ToPort: 80,
+					}, // Frontend
+					{
+						IpRanges: [{ CidrIp: "0.0.0.0/0" }],
+						IpProtocol: "tcp",
+						FromPort: 443,
+						ToPort: 443,
+					}, // Frontend SSL
+					{
+						IpRanges: [{ CidrIp: "0.0.0.0/0" }],
+						IpProtocol: "tcp",
+						FromPort: 9002,
+						ToPort: 9002,
+					}, // HTTPS api
+					{
+						IpRanges: [{ CidrIp: "0.0.0.0/0" }],
+						IpProtocol: "tcp",
+						FromPort: 8082,
+						ToPort: 8082,
+					}, // HTTP api
+					{
+						IpRanges: [{ CidrIp: "0.0.0.0/0" }],
+						IpProtocol: "tcp",
+						FromPort: 4002,
+						ToPort: 4005,
+					}, // libp2p
+					{
+						IpRanges: [{ CidrIp: "0.0.0.0/0" }],
+						IpProtocol: "tcp",
+						FromPort: 22,
+						ToPort: 22,
+					}, // SSH
+				],
+			})
+		);
+	}
+	const instanceTag =
+		"Peerbit" + (properties.namePrefix ? "-" + properties.namePrefix : "");
+	let existingCounter =
+		(
+			await client.send(
+				new DescribeInstancesCommand({
+					Filters: [{ Name: "tag:Purpose", Values: [instanceTag] }],
+				})
+			)
+		).Reservations?.length || 0;
+
+	console.log(regionString, AWS_LINUX_ARM_AMIs[regionString]);
+	const instanceOut = await client.send(
+		new RunInstancesCommand({
+			ImageId: AWS_LINUX_ARM_AMIs[regionString],
+			SecurityGroupIds: [securityGroupOut.GroupId!],
+			InstanceType: "t4g." + (properties.size || "micro"),
+			UserData: Buffer.from(
+				setupUserData(properties.email, properties.grantAccess)
+			).toString("base64"),
+			MinCount: count,
+			MaxCount: count,
+			// InstanceInitiatedShutdownBehavior: 'terminate' // to enable termination when node shutting itself down
+		})
+	);
+
+	if (!instanceOut.Instances || instanceOut.Instances.length === 0) {
+		throw new Error("Failed to create instance");
+	}
+
+	const names: string[] = [];
+	for (const instance of instanceOut.Instances) {
+		existingCounter++;
+		const name =
+			(properties.namePrefix ? properties.namePrefix : "peerbit-node") +
+			"-" +
+			existingCounter;
+		names.push(name);
+		await client.send(
+			new CreateTagsCommand({
+				Resources: [instance.InstanceId!],
+				Tags: [
+					{ Key: "Name", Value: name },
+					{ Key: "Purpose", Value: instanceTag },
+				],
+			})
+		);
+	}
+
+	// wait for instance ips to become available
+	let publicIps: string[] = [];
+	for (let i = 0; i < 10; i++) {
+		const info = await client.send(
+			new DescribeInstancesCommand({
+				InstanceIds: instanceOut.Instances.map((x) => x.InstanceId!),
+			})
+		);
+		const foundInstances = info
+			.Reservations!.map((x) => x.Instances!.map((y) => y))
+			.flat()!;
+		const foundIps: string[] = [];
+		for (const out of instanceOut.Instances) {
+			const foundInstance = foundInstances.find(
+				(x) => x!.InstanceId === out.InstanceId!
+			);
+			if (!foundInstance!.PublicIpAddress) {
+				await delay(3000);
+				continue;
+			}
+			foundIps.push(foundInstance!.PublicIpAddress!);
+		}
+		publicIps = foundIps;
+		break;
+	}
+
+	if (publicIps.length === 0) {
+		throw new Error("Failed to resolve IPs for created instances");
+	}
+
+	return publicIps.map((v, ix) => {
+		return {
+			instanceId: instanceOut.Instances![ix].InstanceId!,
+			publicIp: v,
+			name: names[ix],
+			region: regionString,
+		};
+	}); // TODO types
+};
+
+export const terminateNode = async (properties: {
+	instanceId: string;
+	region?: string;
+}) => {
+	const { EC2Client, TerminateInstancesCommand } = await import(
+		"@aws-sdk/client-ec2"
+	);
+	const client = new EC2Client({ region: properties.region });
+	await client.send(
+		new TerminateInstancesCommand({ InstanceIds: [properties.instanceId] })
+	);
+};