Meister Features for Continuous Delivery at Scale
OpenMake Meister® strengthens your Continuous Delivery foundation using build automation to manage, control and accelerate the software compile and link process. It uses commercial strength server pooling and load balancing for heavy use Continuous Build requirements called by your Continuous Integration engine such as Jenkins. Jenkins calls on Meister to automate the creation of binaries. Meister leverages compile plugins to support reproducible builds, delivering dependency management, build acceleration, distributed builds and build audits without one-off compile scripts such as Maven, Ant or Make. You can develop custom Playbooks to standardize and manage how compilers are called, manage declared inputs, and expose how binaries of all types are created. Compile Plugins use tools like Ant with source code scanning to generate a build control file and standardize the compile/link process to achieve repeatable software compiles across your application versions and life cycle. Out of the box, Meister supports over 200 compile Plugins.
Build Automation Defined
Build Automation can be a confusing term and often associated with Jenkins. However, Jenkins does not do Build Automation. It is a workflow management tool used to define a Continuous Integration process to support DevOps and Continuous Delivery. Jenkins calls other tools to perform software compiles, normally a script written in Ant or Maven. Meister automates the creation and use of these scripts.
Plugins and "VPATH" for Predictable Build
Creating predictability and repeat-ability in your software compiles requires standardization at multiple levels. The challenge is to create the predictability as the build changes for multiple streams and life cycle states. A script is static and cannot easily adjust to these changes. In addition, minimizing source code changes that comes from outside version control is critical in order for all builds to produce consistent results. Meister takes on this challenge by supporting a "Dependency Directory" which is similar to a VPATH for standardizing on declared inputs. Secondly, Meister uses Playbooks and Plugins, that creates consistent build logic. After implementing Meister, a large Financial Service went from several hundred build scripts to less than a dozen Playbooks. If an update needs to be made to one of the Playbooks, it is done in a single location and shared by all. The ultimate in reuse, and it is the reuse that delivers the predictability. Reuse cannot be achieved with one-off build scripts. We were the first to use plugin and Playbooks for standardizing compiles but not the last.
Accelerate Builds for Continuous Integration
Meister has the intelligence to drastically reduce your build times for full builds and down to a few seconds with accurate incremental builds. Meister uses Build Avoidance only re-building the source code that has been changed. Because Meister tracks the low level dependencies, your incremental builds are reliable reducing the need for executing a full 'clean' build. Meister also builds independent artifacts in parallel using low level source code scanning to determine the dependencies without the need to write a script that manages the ordering. So easy! Meister supports build acceleration for all supported languages including Java, .Net, C++, C-Unix and others including the ability to manage multiple .Net Solution files in a single parallel build stream.
See into the Readiness of your Software Build
Meister integrates with 'best of breed' version control tools for retrieving and auditing artifacts. When a build is executed in 'audit' mode, Meister grabs the version control item history, showing in the audit report the artifact version information, which can be used to trace a change in a build back to a particular developer. This link is critical when determining coding problems and resolving run-time issues not found in testing, but discovered in production. To achieve Continuous Delivery, you must be able to see into the readiness of any build, at any time.
To understand the readiness of a build does not mean simply installing and running the software. It is important to have the ability to see into how the build was executed, what source was included and what 3rd party and transitive dependencies were used. Meister's Build Audit provides you with this information. Meister's audit exposes critical information before you run a 'smoke' test. Meister's Build Insight exposes the source code and dependencies used to create your binaries giving you insight into the readiness of your software release. This level of insight can also be used to show the content of any production release, making your Auditors very happy. Meister's Build Automation performs low level code scanning and reports on every file used in your compile and link process, even when it is not stored in a version control tool. Meister's Audit supports many Version Control tools including: Git, SVN, IBM ClearCase, IBM RTC, Microsoft TFS, CVS, Perforce, AccuRev, Serena Dimensions, Serena PVCS, Integrity and others.
Jenkins Continuous Integration at Scale
Remote Agents are installed on servers allowing OpenMake Meister to distribute the workload of your Continuous Integration process across multiple machines and Server Pools. Remote Agents can be hosted on physical or cloud environments allowing the support of Server Pools with a mix of physical, virtual or cloud based servers. OpenMake Meister's Server Pool management features include the ability to automatically select the most efficient machine in the pool for the fastest processing possible. You can use Meister's in conjunction with Jenkins to scale your Continuous Integration across large build environment. And you can add Build Servers and Pools for load balancing as you need them keeping your cost low and managed.Automatic Dependency Management and Impact Analysis
Meister uses deep dependency scanning to make build decisions and to report on the impact of a potential software change. By running a Build with Impact Analysis enabled, a detailed report will be generated and can be shown 'exploded' going from source to binary or 'imploded' from binary to source. Meister's Dependency Management is used at multiple levels. It is used to accelerate builds with both Build Avoidance and building in parallel, and is used to audit the build, showing all artifacts used even when they are not stored in version control.
Monitor your Builds in Real Time
Meister includes a Build Monitor that runs in 'real time' allowing you to easily see the status of your build with errors, successes and ordering. Meister's Real Time build monitor shows you the lowest level of calls, including each time the compiler/linker/archiver is invoked as well as any external process that is called such as static code analysis. By seeing into every data point, Meister allows you to to be proactive in addressing build issues, as it exposes exactly what it is doing - no guess work.
Integrates Build Automation into IDEs such as .Net and Eclipse
To determine what object needs to be built, Meister integrates with both Eclipse (project files) and Microsoft .Net (solution files) to generate the meta data of the objects to be compiled. This allows your builds inside the IDEs to be repeated outside of the IDEs without coding a single line of Ant, Maven or Nant code. OpenMake Meister is integrated into Visual Studio .Net and TeamBuild to give you a full Microsoft development experience. When Meister is used to manage the compile and link process, it leverages MSBuild in the process. This gives you a 100% repeatable process between compiles inside the IDE and outside the IDE called by a Build Automation process. In addition, Meister can compile multiple solution files in the correct order in one build pass.
Improve Agile Development with Adaptive Build
Meister's build automation improves your agile development by matching the adaptive and iterative nature of your source code changes with the quick compilation of your binaries. Meister's Build Automation eliminates build bottlenecks caused by slow compiles, manual updates to scripts and errors common to a build process that is driven by static processes. Meister gets your builds ready for agile by:
- Providing adaptable build scripts that synchronize builds running outside the IDE with builds running within the IDE.
- Accelerated Java and C builds supporting 10 minutes builds or less.
- Accurate incremental and pre-commit builds so your agile process is never doing a "clean all" build that runs for hours.
- Continuous Integration with Distributed Builds.
- Build Acceleration using Build Avoidance and Building in Parallel (Java and .NET).
Anything less than the above takes you right back to the "waterfall" approach where your build manager needs the luxury of time to tweak broken build scripts. Meister delivers to the agile team, fast, consistent and repeatable compile and build processing.