@arc-fusion/cli/templates/2.0/docker-compose.yml.js

CLI for running Arc Fusion on your local machine

'use strict'
/* eslint-disable no-template-curly-in-string */
const os = require('os')
const path = require('path')

const engineDockerfile = require('./engine.Dockerfile')
const getLinkedModules = require('./links')

const { mkdirp, writeFile } = require('../../bin/utils/promises')

const isWindows = /^win/i.test(os.platform())

module.exports = async ({ ADMIN_RELEASE, FUSION_ROOT, PROJECT_ROOT, REPO_NAME, noAdmin }) => {
  const environment = {
    DB_NAME: `\${DB_NAME:-${REPO_NAME}}`,
    MONGO_URL: `mongodb://data:27017/\${DB_NAME:-${REPO_NAME}}`,
    PB_MONGODB_URI: `mongodb://data:27017/\${DB_NAME:-${REPO_NAME}}`,
    NODE_ENV: 'development',
    ENVIRONMENT: 'localhost',
    CONTEXT_PATH: '${CONTEXT_PATH:-pf}',
    DEBUG: '${DEBUG:-\'fusion:*\'}',
    HTTP_ENGINE: 'http://engine:8080',
    HTTP_RESOLVER: 'http://resolver:8080'
  }

  const networks = [
    'fusion'
  ]

  const volumes = (isWindows)
    ? {
        volumes: {
          [REPO_NAME]: {
            external: false
          }
        }
      }
    : {}

  const linkedModules = await getLinkedModules(PROJECT_ROOT) || {}
  const moduleLinks = Object.keys(linkedModules)
    .map((linkedModule) => `${linkedModules[linkedModule]}:/workdir/engine/bundle/linked_modules/${linkedModule}:ro`)

  // the node_modules volume trick to hide host files from the container causes an error if the directory does not exist
  await mkdirp(path.join(PROJECT_ROOT, 'node_modules'))

  await writeFile(
    path.join(PROJECT_ROOT, '.fusion', 'engine.Dockerfile'),
    await engineDockerfile({ PROJECT_ROOT })
  )

  return {
    version: '3',

    networks: {
      fusion: {
        driver: 'bridge',
        external: false,
        internal: false
      }
    },

    ...volumes,

    services: {
      data: {
        image: 'washpost/mongo-vandelay',
        container_name: 'fusion-data',
        environment: {
          ...environment,
          RESTORE: 'true',
          SYNC: (isWindows) ? 'true' : ''
        },
        networks: {
          fusion: {
            aliases: [
              'db',
              'database'
            ]
          }
        },
        ports: [
          '27017:27017'
        ],
        volumes: [
          '../data/db:/data/db:rw',
          '../data/dumps:/data/dumps:rw',
          '../data/restore:/data/restore:rw'
        ]
      },

      'content-cache': {
        // memcached service runs from an image, so there is no Dockerfile
        image: 'memcached',
        // max size is 10MB
        command: 'memcached -I 10m',
        container_name: 'fusion-content-cache',
        networks
      },

      'cache-proxy': {
        image: 'washpost/fusion-cache-proxy:${FUSION_RELEASE:-latest}',
        container_name: 'fusion-cache-proxy',
        depends_on: [
          'content-cache'
        ],
        networks,
        ports: [
          '9030:8080'
        ],
        environment: {
          CACHE_PROXY_CREDENTIALS: 'localhost:password',
          CACHE_NODES: 'content-cache:11211'
        }
      },

      engine: {
        build: {
          context: '..',
          dockerfile: './.fusion/engine.Dockerfile',
          args: {
            FUSION_RELEASE: '${FUSION_RELEASE:-latest}'
          }
        },
        container_name: 'fusion-engine',
        depends_on: [
          'cache-proxy',
          'data'
        ],
        env_file: [
          '../.env'
        ],
        environment: {
          ...environment,
          AWS_XRAY_ENABLED: 'false',
          CACHE_PROXY_URL: 'http://localhost:password@cache-proxy:8080/cache',
          CACHE_PREFIX: '0803',
          // because we import ALL variables from .env, ignore PORT
          PORT: '8080'
        },
        networks,
        ports: [
          '9010:8080'
        ],
        volumes: [
          '..:/workdir/engine/bundle/src:rw',
          '/workdir/engine/bundle/src/node_modules',
          '../.fusion/dist:/workdir/engine/bundle/dist:rw',
          ...moduleLinks
        ]
      },

      resolver: {
        image: 'washpost/fusion-resolver:${FUSION_RELEASE:-latest}',
        container_name: 'fusion-resolver',
        depends_on: [
          'data',
          'engine'
        ],
        environment: {
          ...environment,
          RESOLVE_FROM_DB: 'true', // should only be 'true' for local dev environments
          TRAILING_SLASH_RULE: null // Options are FORCE, DROP, or NOOP
        },
        networks,
        ports: [
          '9020:8080'
        ]
      },

      ...(
        (noAdmin)
          ? {}
          : {
              'admin-cache': {
              // memcached service runs from an image, so there is no Dockerfile
                image: 'memcached',
                // max size is 10MB
                command: 'memcached -I 10m',
                container_name: 'fusion-admin-cache',
                networks
              },

              admin: {
                image: `washpost/pagebuilder-admin:\${PB_RELEASE:-${ADMIN_RELEASE}}`,
                container_name: 'fusion-admin',
                depends_on: [
                  'admin-cache',
                  'data'
                ],
                environment: {
                  ...environment,
                  NGINX_PORT: '',
                  TOMCAT_PORT: '8888',
                  PB_AUTH_DISABLED: 'true',
                  PB_ASSETS_IMPORT_PATH: '/pb/classic/multisite',
                  PB_ASSETS_IMPORT_METHOD: 'symlink',
                  PB_MEMCACHED_HOST: 'admin-cache:11211',
                  PB_MONGODB_GARBAGE_COLLECTION: 'false',
                  PB_PERMISSIONS_ENABLED: 'false',
                  PB_RENDERING_DEBUG: 'true',
                  PB_SYSTEM_LOG_CONFIG: 'logback-info.xml',
                  PB_REPORTING_FUSION: 'http://origin:8080/${CONTEXT_PATH:-pf}',
                  PB_CONTEXT: '${CONTEXT_PATH:-pf}'
                },
                networks
              }
            }
      ),

      origin: {
        image: 'washpost/fusion-origin:${FUSION_RELEASE:-latest}',
        container_name: 'fusion-origin',
        depends_on: [
          'engine',
          'resolver'
        ],
        environment: {
          ...environment,
          ...(
            (noAdmin)
              ? {}
              : {
                  PB_ADMIN: 'http://admin:8888'
                }
          ),
          IS_ADMIN: 'true'
        },
        networks,
        ports: [
          '${PORT:-80}:8080',
          '8081:8081'
        ],
        volumes: [
          '../mocks:/etc/nginx/mocks:ro',
          '../resources:/etc/nginx/resources:ro',
          '../.fusion/dist:/etc/nginx/dist:ro'
        ]
      }
    }
  }
}