ArthurCI: Accelerating Frontend Continuous Integration with Stable Infrastructure

Move fast with stable infra

Silicon Valley has long championed rapid delivery; Facebook’s original motto “move fast and break things” later evolved to “move fast with stable infra”, acknowledging the need to balance speed with reliability. At 58.com, cautious release practices and a dedicated QA team consume significant testing effort, prompting the creation of ArthurCI to let frontend teams focus on product features.

1. Continuous Integration

In collaborative software development, continuous integration (CI) is recommended. While CI often refers to automated builds, a successful build only shows that code is packaged, not how it works. Effective CI should also automatically deploy code to its target platform, enabling smooth production releases with high quality and low risk, and allowing managers to control release timing.

Comparison with TravisCI and other competitors

Popular frontend CI services like TravisCI and CircleCI integrate tightly with GitHub, offering simple configuration and build status badges. ArthurCI adopts these advantages while addressing drawbacks such as exposing proprietary code on public GitHub, cache conflict issues, and error‑prone YAML configurations.

Below is a description of how 58’s architecture team designed ArthurCI.

2. Advantages and Details of ArthurCI

Extremely Fast

Before building, source code and dependencies must be fetched. Dependency download typically consumes about 30% of total build time. By using Yarn instead of npm, packages are cached and downloaded in parallel, maximizing the utilization of 58’s cloud build platform and reducing preparation time as the cache grows.

During the build, webpack’s resolve.modules is used to accelerate file lookup by specifying the full path to node_modules, avoiding costly upward recursive searches.

function resolve (dir) {
  return path.join(__dirname, '..', dir)
}
module.exports = {
  resolve: {
    extensions: ['.js', '.vue', '.json'],
    modules: [
      resolve('node_modules')
    ]
  }
  // ...
}

The most time‑consuming step in frontend builds is final code compression. ArthurCI replaces webpack’s default UglifyJsPlugin with the multi‑threaded webpack-parallel-uglify-plugin, cutting compression time by roughly 40%.

Especially Easy to Use

Integrating a project into ArthurCI is straightforward and requires only two steps:

Install the gulp-zipmd5 plugin via Gulp.

Add an npm run arthur script to the project’s package.json to invoke the predefined task.

After logging in with a 58 domain account, the system displays all GitLab projects the user can access. Selecting a project and providing the required name and production path completes the configuration.

const gulp = require('gulp');
const zipmd5 = require('gulp-zipmd5');

gulp.task('arthur', () =>
  gulp.src('test/**/*')
    .pipe(zipmd5('output.zip'))
    .pipe(gulp.dest('arthur'))
);

ArthurCI offers a clear UI: the release process is simple, traceable, and visually organized, allowing users to see pending projects at a glance.

After production deployment, ArthurCI automatically notifies the 58 TMS system responsible for static resource versioning, updating CDN cache paths without manual intervention.

Stable and Reliable

Built on a cloud‑based build platform, ArthurCI abstracts away local environment differences, providing a uniform interface and global module caching that dramatically speeds up builds for large dependencies such as react-native or node‑sass.

Detailed build logs enable rapid error identification and remediation. Successful builds are persisted for future retrieval, and the system supports emergency rollbacks or direct deployment of specific historical versions.

3. Future Plans for ArthurCI

ArthurCI will leverage data intelligence to enhance its service:

Analyze build data to generate periodic success‑rate reports.

Perform performance analysis on deployment test data to predict post‑release impact.

4. Conclusion

58’s architecture team developed ArthurCI to engineer a more efficient frontend release workflow, focusing on speed, usability, and reliability. The system’s clean UI gives users full control over the release pipeline, quality assurance, and traceability between source code and deployed versions. Feedback and discussion on continuous integration and rapid delivery are welcomed.