@metaplay/metaplay-auth 1.4.2 → 1.6.0

package/src/buildCommand.ts

@@ -0,0 +1,267 @@
+import { Command } from 'commander'
+import { exit } from 'process'
+import { existsSync } from 'fs'
+import { pathJoin, executeCommand, ExecuteCommandResult } from './utils.js'
+import { logger } from './logging.js'
+import path from 'path'
+
+function resolveBuildEngine(engine?: string): string {
+  const validBuildEngines = ['buildx', 'buildkit']
+
+  // If not specified, auto-detect
+  if (!engine) {
+    // Bitbucket does not support buildx, so use buildkit, otherwise default to buildx
+    if (process.env.BITBUCKET_PIPELINE_UUID) {
+      return 'buildkit'
+    } else {
+      return 'buildx'
+    }
+  }
+
+  // If specified from outside, check validity
+  if (!validBuildEngines.includes(engine)) {
+    throw new Error(`Invalid Docker build engine '${engine}', must be one of: ${validBuildEngines.join(', ')}`)
+  }
+
+  return engine
+}
+
+export function registerBuildCommand(program: Command): void {
+  program
+    .command('build-image [extraArgs...]')
+    .description('build the game server docker image')
+    .option('-t, --image-tag <image-tag>', 'tag for the output image, eg, "myserver:d08747679d"', 'gameserver:<timestamp>')
+    .option('--sdk-root <directory>', 'relative path to the MetaplaySDK directory', 'MetaplaySDK')
+    .option(
+      '--project-root <directory>',
+      'relative path to the project root (where Backend/ directory is located)',
+      '.'
+    )
+    .option('--backend-dir <directory>', '[for legacy projects] name of the Backend/ directory', 'Backend')
+    .option(
+      '--shared-code-dir <directory>',
+      'path to the shared code directory of the project, relative to --project-root',
+      'Assets/SharedCode'
+    )
+    .option(
+      '--engine <engine>',
+      'docker build engine to use (buildx or buildkit), auto-detected if not specified',
+      'buildx'
+    )
+    .option('--architecture <architecture>', 'target platform architecture (amd64 or arm64)', 'amd64')
+    .option('--build-number <build-number>', 'number of this build (eg, 153)')
+    .option('--commit-id <commit-id>', 'commit id of this build (eg, d08747679d1e7fc9c1c685b396636da689ae476d)')
+    .action(
+      async (
+        extraArgs: string[],
+        options: {
+          imageTag: string
+          sdkRoot: string
+          projectRoot: string
+          sharedCodeDir: string
+          backendDir: string
+          engine: string
+          architecture: string
+          buildNumber?: string
+          commitId?: string
+        }
+      ) => {
+        // Resolve imageTag to use: fill in <timestamp> with current unix time
+        let imageTag = options.imageTag
+        imageTag = imageTag.replace('<timestamp>', Math.floor(+new Date() / 1000).toString())
+        console.log(`Building docker image '${imageTag}'..`)
+
+        if (imageTag.endsWith(':latest')) {
+          console.error('Building docker image with "latest" tag is not allowed as it won\'t update the cloud environments reliably. Use commit id like git sha or timestamp instead.')
+          exit(1)
+        }
+
+        if (extraArgs.length !== 0) {
+          console.log(`Extra args to docker: ${JSON.stringify(extraArgs)}`)
+        }
+
+        // Check that sdkRoot is a valid directory
+        const sdkRootPath = options.sdkRoot.replaceAll('\\', '/')
+        if (path.isAbsolute(sdkRootPath)) {
+          console.error(`The --sdk-root (${sdkRootPath}) is an absolute path, please specify a relative path instead`)
+          exit(2)
+        }
+        if (sdkRootPath.startsWith('..')) {
+          console.error(
+            `The --sdk-root (${sdkRootPath}) path cannot point outside the current directory (i.e., cannot start with '..')`
+          )
+          exit(2)
+        }
+        if (!existsSync(sdkRootPath)) {
+          console.error(
+            `The Metaplay SDK directory '${sdkRootPath}' does not exist, specify correct directory with --sdk-root!`
+          )
+          exit(2)
+        }
+
+        // Check that we can find Dockerfile.server in sdkRoot
+        const dockerFilePath = pathJoin(sdkRootPath, 'Dockerfile.server')
+        if (!existsSync(dockerFilePath)) {
+          console.error(
+            `Cannot locate Dockerfile.server at ${dockerFilePath} -- check that the --sdk-root path points to the MetaplaySDK directory!`
+          )
+          exit(2)
+        }
+
+        // Check projectRoot directory
+        const projectRootPath = options.projectRoot.replaceAll('\\', '/')
+        if (path.isAbsolute(sdkRootPath)) {
+          console.error(
+            `The --project-root (${projectRootPath}) is an absolute path, please specify a relative path instead`
+          )
+          exit(2)
+        }
+        if (projectRootPath.startsWith('..')) {
+          console.error(
+            `The --project-root (${projectRootPath}) path cannot point outside the current directory (i.e., cannot start with '..')`
+          )
+          exit(2)
+        }
+        if (!existsSync(projectRootPath)) {
+          console.error(
+            `The project root directory '${projectRootPath}' does not exist, specify correct directory with --project-root`
+          )
+          exit(2)
+        }
+        const projectBackendDir = pathJoin(projectRootPath, options.backendDir)
+        if (!existsSync(projectBackendDir)) {
+          console.error(
+            `Unable to find project backend in '${projectBackendDir}', check that --project-root is correct!`
+          )
+          exit(2)
+        }
+
+        // Resolve sharedCodePath
+        const sharedCodePath = pathJoin(projectRootPath, options.sharedCodeDir)
+        if (!existsSync(sharedCodePath)) {
+          console.error(
+            `The shared code directory (${sharedCodePath}) does not exist, make sure the --shared-code-dir points to the directory where shared source code is located!`
+          )
+          exit(2)
+        }
+
+        // Resolve target platform from architecture
+        const validArchitetures = ['amd64', 'arm64']
+        if (!validArchitetures.includes(options.architecture)) {
+          console.error(
+            `Invalid architecture '${options.architecture}' specified, must be one of ${JSON.stringify(validArchitetures)}`
+          )
+          exit(2)
+        }
+        const platform = `linux/${options.architecture}` // \note Only linux is supported
+
+        // Auto-detect git commit id from well-known environment variables, if not defined.
+        // Use well-known CI-defined environment variables to detect the commit id instead
+        // of checking git state as that gives a more reliable result.
+        let commitId = options.commitId
+        if (!commitId) {
+          commitId =
+            process.env.GIT_COMMIT ?? // Jenkins
+            process.env.GITHUB_SHA ?? // GitHub Actions
+            process.env.CI_COMMIT_SHA ?? // GitLab CI
+            process.env.CIRCLE_SHA1 ?? // Circle CI
+            process.env.TRAVIS_COMMIT ?? // Travis CI
+            process.env.BUILD_SOURCEVERSION ?? // Azure DevOps
+            process.env.BITBUCKET_COMMIT ?? // Bitbucket Pipelines
+            process.env.BUILD_VCS_NUMBER ?? // TeamCity
+            process.env.BUILDKITE_COMMIT ?? // Buildkite
+            process.env.DRONE_COMMIT_SHA ?? // Drone CI
+            process.env.SEMAPHORE_GIT_SHA // Semaphore CI
+          if (commitId) {
+            console.log(`Using auto-detected commit id: ${commitId}`)
+          } else {
+            console.warn('Failed to auto-detect commit id, please specify with "--commit-id <git-sha>"')
+          }
+        }
+
+        // Auto-detect build number from well-known environment variables, if not defined.
+        // Use well-known CI-defined environment variables to detect the build number.
+        let buildNumber = options.buildNumber
+        if (!buildNumber) {
+          buildNumber =
+            process.env.BUILD_NUMBER ?? // Jenkins
+            process.env.GITHUB_RUN_NUMBER ?? // GitHub Actions
+            process.env.CI_PIPELINE_IID ?? // GitLab CI
+            process.env.CIRCLE_BUILD_NUM ?? // Circle CI
+            process.env.TRAVIS_BUILD_NUMBER ?? // Travis CI
+            process.env.BUILD_BUILDNUMBER ?? // Azure Pipelines
+            process.env.BITBUCKET_BUILD_NUMBER ?? // Bitbucket Pipelines
+            process.env.BUILD_NUMBER ?? // TeamCity
+            process.env.BUILDKITE_BUILD_NUMBER ?? // Buildkite
+            process.env.DRONE_BUILD_NUMBER ?? // Drone CI
+            process.env.SEMAPHORE_BUILD_NUMBER // Semaphore CI
+          if (buildNumber) {
+            console.log(`Using auto-detected build number: ${buildNumber}`)
+          } else {
+            console.warn('Failed to auto-detect build number, please specify with "--build-number <build-number>"')
+          }
+        }
+
+        // Resolve build engine to use
+        let buildEngine = resolveBuildEngine(options.engine)
+        logger.debug(`Using docker build engine: ${buildEngine}`)
+
+        // Check that docker is installed and running
+        const checkDockerResult = await executeCommand('docker', ['ps'], { inheritStdio: false, env: {} })
+        if (checkDockerResult.exitCode !== 0) {
+          console.error('Failed to invoke docker, please make sure that docker is installed and running')
+          exit(1)
+        }
+
+        // If buildx engine specified, check that it works
+        if (buildEngine === 'buildx') {
+          const checkBuildxResult = await executeCommand('docker', ['buildx', 'version'], {
+            inheritStdio: false,
+            env: {},
+          })
+          if (checkBuildxResult.exitCode !== 0) {
+            console.warn('Docker buildx is not supported on this machine, falling back to --engine=buildkit')
+            buildEngine = 'buildkit'
+          }
+        }
+
+        // Resolve build engine args
+        const dockerEnv = buildEngine === 'buildkit' ? { DOCKER_BUILDKIT: '1' } : {}
+        const buildEngineArgs = buildEngine === 'buildx' ? ['buildx', 'build', '--load'] : ['build']
+
+        // Resolve final build invocation
+        const dockerArgs = buildEngineArgs
+          // .concat(['--progress=plain'])
+          .concat(['--pull']) // make sure we have latest versions of images where version isn't fully pinned
+          .concat(['-t', imageTag])
+          .concat(['-f', dockerFilePath])
+          .concat(['--platform', platform]) // target platform(s)
+          .concat(options.buildNumber ? ['--build-arg', `BUILD_NUMBER=${options.buildNumber}`] : [])
+          .concat(options.commitId ? ['--build-arg', `COMMIT_ID=${options.commitId}`] : [])
+          .concat(['--build-arg', `SDK_ROOT=${sdkRootPath}`])
+          .concat(['--build-arg', `PROJECT_ROOT=${projectRootPath}`])
+          .concat(['--build-arg', `SHARED_CODE_DIR=${options.sharedCodeDir.replaceAll('\\', '/')}`]) // pass relative-to-project-root dir
+          .concat(['--build-arg', `BACKEND_DIR=${options.backendDir.replaceAll('\\', '/')}`])
+          .concat(extraArgs) // pass extraArgs directly to docker
+          .concat(['.'])
+        console.log(`Execute: docker ${dockerArgs.join(' ')}`)
+
+        // Execute docker build
+        let buildResult: ExecuteCommandResult
+        try {
+          buildResult = await executeCommand('docker', dockerArgs, {
+            inheritStdio: true,
+            env: { ...process.env, ...dockerEnv, DOCKER_CLI_HINTS: 'false' },
+          })
+          if (buildResult.exitCode !== 0) {
+            console.error(`Docker build failed with exit code ${buildResult.exitCode}`)
+            exit(buildResult.exitCode)
+          }
+          console.log(`Successfully built docker image '${imageTag}'!`)
+        } catch (err) {
+          console.error(`Failed to invoke docker build: ${err instanceof Error ? err.message : String(err)}`)
+          exit(1)
+        }
+      }
+    )
+}

package/src/config.ts

@@ -0,0 +1,12 @@
+/**
+ * Base URL to the Metaplay developer portal. Override with global flag --portal-base-url.
+ */
+export let portalBaseUrl = 'https://portal.metaplay.dev'
+
+/**
+ * Set the base URL to the Metaplay developer portal.
+ * @param url - The base URL to the Metaplay developer portal.
+ */
+export function setPortalBaseUrl(url: string): void {
+  portalBaseUrl = url
+}