We’re pleased to present our new release Clarive 7.0.11 with two new administration features. 

Rulebook Variables

Now you can keep your rulebook variables private with secret variables. The content is not visible to the user and the data is encrypted to the database.

Variables also now have multiple scopes. Define the scope in the variable and it will only be available for rulebooks that run under the given scope.

clarive variable definition

Users can only manage variables for owned projects

Docker Admin Interface

Clarive rulebooks can download, install and run shell commands within Docker images with the image: op. Starting with this release, you can manage all Docker images and containers installed and available to rulebooks on the Clarive server.

The Clarive Docker admin panel can manage both instances and containers. A complete list is shown including the current status of each one of the containers.

Using the containers list you can do over them actions like start, stop and delete. You can delete Docker images too to keep your image registry tidy and remove old images.

Improvements and issues resolved

Other small fixes and enhancements added to the release:

  • ENH – Small Kanban improvements
  • ENH – Update js libraries
  • ENH – Variable management for rulebooks
  • FIX – Topic grid filter bugs
  • FIX – Rulebook sed op fixes
  • FIX – Push to git repositories allowed with no project related to repository (Enterprise Edition Only)

Ready to upgrade?

Just follow the standard procedure for installing the new version. Click here to get it from our install page.

Cloud images have been updated automatically in case you are a user of our cloud.


Join us in our Community for suggestions and bug reports.

Thanks to everyone who participated in making this release possible.


The next release, 7.0.12 will come out on the first week of January 2018 with mostly bug fixes and small enhancements.

And a major release, 7.1 is coming up later in January packed with some awesome additions:

  • A brand new navigation interface, with tabless project-oriented navigation
  • A revamped Git repository interface
  • A new admin interface
  • Revamp documentation
  • And much more!

Get an early start and try Clarive now. Get your custom cloud instance for free.

In this post we are going to explain how to make application deployments using Clarive EE both to the Google Play Store, and to the iOS store (Apple Store) thanks to the Clarive Plugins

This process will not require any additional programming knowledge. Thanks to the interface offered by the rules designer we’ll be able to configure these deployments.

For more information about Clarive and the components we use, see our Docs.

Deploying to Google Play Store
General features

In the case of Android applications, the Gradle plugin is used to compile the application, and the Fastlane plugin to send it to the Play Store automatically.


Beforehand, we need to ensure that there is already a first version of the application uploaded so that the deployment can be carried out automatically.

We then create a Generic Server from the Resources → Server panel. On this server we have the application installed together with Gradle and Fastlane.

Once we have configured the server, we need to go to the rules designer and create a new rule with the type Pipeline in the Admin panel.

We then use the PRE phase to compile the application. To do this, we drag the operation Gradle compile:

In the set up box that appears, we should select the server that was previously configured, and fill out the remaining fields in order for it to compile correctly.

We then need to drag the operation Fastlane task to the RUN phase in order to configure the upload of the application to the Play Store:

We then fill in the operation form with all the necessary data ready for the upload.

We are now ready for the deployment to Play Store. Next we need to add the operations to deploy to Apple Store using the same Pipeline.

Deploying to Apple Store
General features

This time we’ll use the Fastlane plugin to compile and send the application to Apple Store automatically. We need to ensure that Xcode is installed together with Fastlane.


We now need to create a Generic Server, just like we did previously. On this server we have the application installed together with Fastlane and Xcode.

We must also configure the access credentials for our Apple Store account in the Resource iOSCredentials, which we access from the Resources → iOS panel.

In the same way as we did previously with Android, we’ll compile our application in the PRE phase, with theFastlane task operation.

Within the configuration of the operation, we need to select the server, the credentials, and fill in the rest of the necessary fields.

We then configure the delivery of the application to the Apple Store, using the same Fastlane task operation in the RUN phase.

We need to select the ‘Upload App’ option, and fill in the fields.

With this Pipeline we have now set up automatic publication both in the Play Store and the Apple Store.
If you have any questions please don’t hesitate to contact us at Clarive Community.

Try Clarive now. Get your custom cloud instance for free.

The Clarive team is very excited to announce the release of Clarive 6.8. Our new release brings a whole set of features and functionalities that take Lean Application Delivery to a new level

Release Goals

The focus of the 6.8 release series is to improve the quality and intelligence of the delivery pipeline. We’re very committed to solving some of what we consider to be very important issues that impact on the quality and robustness of the DevOps toolchain, namely:

  • Error prevention, mitigation and guidance
  • Pipeline quality and completeness
  • Realtime DevOps debugging
  • Profiling and bottleneck detection

Root-cause Analysis

Eradicating errors is not just a tongue twister.

Your delivery pipeline is probably comprised of many different tools, technologies and resources. Even the most robust DevOps chains tend to encounter errors along the way, caused by compiler errors, application server issues or resource failures, like simple disk space errors downstream at endpoints in the network.

Clarive 6.8’s new root-cause analysis feature is a powerful tool to help deal with errors that can bring your pipeline to a standstill. Root-cause analysis helps identify why problems/errors happen when they happen:

  • From admin initiated remediation
  • From collaboration input
  • From Clarive’s own curated knowledge base

For example, in the screenshot below, Clarive interpreted an error, giving guidance to the user that “rebase was needed” (a dependency problem was detected in the Git repository prior to deploying the application):

Root-cause Analysis - new release

New root-cause configuration items can be configured to parse errors and give guidance on how to respond to errors. Root causes can be also recorded on-the-fly into the knowledge base for future, automatic matching.

DevOps Quality

Even the best DevOps automation has bugs. DevOps is about making it easy to deliver changes continuously with quality and speed. But how robust is your DevOps automation? What if you introduce changes to it that break build and deployment applications. DevOps has become part of the final product. You’ve just bankrupted the business!

Clarive 6.8 brings a pipeline static analysis checker that verifies how strong and resilient your automation is before you make changes. It will also make recommendations that help create more mature and safer logic:

  • Does it have a rollback procedure?
  • Did you make it a template or hard-coded variables
  • Is your pipeline modular or monolithic?
  • And many more, besides

DevOps Quality - new release

The static analysis of Clarive rules can be executed from the command-line every time a rule is saved. You can even prevent the rule from being saved if it has errors, helping making the whole system even more secure.

Pipeline Stage Profiling

Create pipeline stages and profile them by stage and operation type:

  • networking for testing and deploying
  • remote command profiling
  • DSL and local script profiling
  • Repository clone or checkout times
  • etc.

Pipeline Stage Profiling - new release

The stage visualizations can now be seen in the job monitor live. Clarive 6.8 stores historical profiling data so that you can profile the evolution, and prevent and detect bottlenecks ahead of time.

Step-by-Step Debugging

The new step-by-step debugger is one of the best new features coming out in the 6.8 series.

In this version you can watch how the deployment runs step-by-step, with live logs and standard error and output from endpoints, external integrated and orchestrated applications, databases, etc. All the scripts and rule logic executed externally, will be controlled from a single entry point – the Clarive DevOps platform.

deployment runs step-by-step - new release

Some of the key features of step-by-step debugging coming out in the 6.8 release series:

  • Breakpoints
  • Watch variables and stash
  • Change values before executing (in debug mode)
  • Repeat and rollback steps
  • Pause and connect to server from the web interface (!)
  • Dry-run and mock steps

Additional Enhancements

There many more, over one hundred, enhancements in Clarive 6.8. Here are some of them:

  • Job log streaming – logs are now streamed from the remote servers through the agents to the browser.
  • User groups are now part of security scopes
  • Project-specific pipelines
  • New scope events


There are many new plugins that will be covered in another series of posts, so stay tuned. But here are some new important additions and complete makeovers:

  • SAP
  • Salesforce
  • Siebel
  • Changeman ZMF
  • Endevor

Coming Up Soon

Clarive feature releases come out every month. The next release will bring important improvements in many areas, including:

  • New features for customizing dashboards and dashlet layout
  • Lean Delivery Boards, a new redesign of our current Kanban Boards
  • Our Docker “inception” runner, which lets you run the pipeline inside _curated_ Docker images
  • More profiling options and reports
  • User-defined rules
  • Predictive analysis of errors
  • Pipeline test cases
  • Asset tracking features

And finally, a revamp of our UI that includes an improved and more fluid user experience.

the future is now with Clarive - future release

The new UI makes navigation more intuitive and quicker (with a navigation bar search).

There are many more exciting features coming out this year, so please watch this space!




DevOps and Bimodal IT are two terms which have recently come onto the radar in the world of enterprise IT.  Confusion surrounding the definition and use of these concepts is rife so we sought to demystify these terms and understand how analysts such as Gartner see them in play over the next few years.

Eddy Pauwels, VP of Sales and Marketing at Clarive Software, were interviewed by Enterprise Management 360º a few days ago…

“This is why I often speak about lean application and service delivery when an organization is serious about DevOps. I believe they should look at the following things; first of all, they should look at application delivery from an end-to-end or a holistic perspective and try to orchestrate it like this. It should try to automate whatever can be automated so that one can deliver at a speed of business and that can be ranging from a few times a year or frequently a few times a day or even an hour if really need be.”

“I believe that DevOps is one of the key answers to support a Bimodal IT organization providing of course that it’s implemented properly and supported by the right infrastructure tooling. As we’ve seen DevOps improve the collaboration and communication between development and operations and try to increase the level of automation in order to support the delivery at the speed of business.”

“A good DevOps tool or solution supporting Bimodal IT for me should at least have one of the following characteristics. Firstly, it should allow you to define and automate any discussion topic between development and operations, whether these are called releases, projects, springs, test cases, change requests or defects, you name it. Secondly, it should be able to provide you with dynamic end-to-end insight into status and activity within the delivery process regardless of the mode being used, so that you really get a deep understanding from a customer perspective inside the delivery process.”

To listen to the full interview, please click here

The foundation of the configuration managed by Clarive for its delivery pipelines and changesets are stored in its powerful Configuration Database.

Environments and their resources are managed in the Clarive Configuration Database as graphs. Each resource is defined as a Configuration Item (CI). Configuration items belong to Classes (ie. TomcatInstance or a OracleDB classes), and each class may belong to one or more families, such as Database or Middleware families.


CIs can be connected to one another through relationships. For instance, an application may depend on a certain DB CI instance when deploying, so there exists a relationship between both.

Here are a sample list of possible relationships among CIs:

  • A release (topic) may contain require certain infrastructure to be deployed
  • A changeset contains repository changes, such as Git revisions
  • An application (itself a CI) may depend on certain microservice CIs
  • A pipeline rule may depend on Variables (which are CIs)
  • Variables may have different values depending on which target Environment (another CI) the Variable is being invoked for.

Relationships are created by associating one entity with another, ie. adding a changeset to a release. Clarive also curates the relationships and removes them if one of the CIs is deleted or deprecated.


Relationships may be visualized with any one of the CI Graph representations. These representations may be opened on the fly as properties of a CI (or Topic).

Graphical visualization of the relationship between CIs in Clarive

Application and Service Configuration

Any Clarive Project, which is used to represent applications and services in a organization, can be modeled from available configuration templates using the project configuration editor:

Application models are stored in the Clarive graph database and can then be displayed using the same CI visualizations mentioned above.



Database Release Automation

Implementing a fully automated, continuous application delivery process requires that ALL configuration items, including those that are stored in a database, be version controlled and deployed as part of the full cycle.

Unfortunately, a recent survey showed that many companies which implement continuous delivery for their application code do not do the same for their database code.

Here are some of the database configuration items that Clarive is capable of managing:

1) DDL, schema

2) DB Scripts, Stored-Procedures, Functions and Triggers, such as PL/SQL or Mongo Javascript

3) Application Configuration stored in the Database


Why is Clarive concerned about managing data? Well, the answer is rather simple: a great number of applications, be it in-house or closed ERP products, store their configuration in the database. Configuration that affects how the application logic and interface behaves. Usually this means inserting or updating a few rows of data from one environment to the next.