Introduction

Octopi is the command center for all of your SCM processes. Focusing on these key concepts: Planning, Coordination, Execution, and Monitoring, Octopi provides a place where you can manage SCM processes seamlessly. From managing server configurations, synchronizing database and source code deployment, mapping bugs to promotes, monitoring applications, to managing product versioning. More importantly, by using Octopi, you have a single place where all your SCM activities are regulated, recorded and monitored. Most big companies who can afford it, have a home-grown solution that is similar to Octopi, others simply live without it.

Do I need Octopi?

One of the unfortunate reality in IT industry is that typically, a software development projects/organizations do not realize how important it is to invest time and other resources to put in place a repeatable process to manage product deployment. On the other hand, the analysis, design, and construction part of the software lifecycle has been covered a lot. However, since product deployment is where "rubber meets the road", often time an excellent piece of software falls apart when it's time to be delivered to the target consumer.

One of Octopi's main intention is to provide a working SCM "backbone" to those who need it. Therefore, the less your project/organization have in terms of SCM processes, the more you will get out of Octopi. Usually, a software development project/organization falls into one of these categories (from worst to best):

  • Everything is done manually (there isn't a single SCM tool or process in place)
  • Has several SCM tools that are used independently (they are not being used collaboratively)
  • Has manual SCM processes in place
  • Has an automated way to perform and keep track of SCM processes

Goals

  • To manage the often complex but essential process of managing digital assets (also commonly known as "artifacts") and their lifecycles
  • To manage Product versioning (a different concept than digital assets versioning)
  • To map the features with product version (what features goes with this version?)
  • To keep track of all aspects of server configuration under one interface
  • To minimize the human error risk that is associated with manual application deployment

Requirements

  1. Minimal Configuration: Need to come up with sensible defaults, which when coupled with centralized configuration system, makes deployment easy to manage
  2. Usability: Need to make complicated process manageable
  3. Repeatability: Need to be able to go back to a specific digital asset version and redo the process
  4. Expadability: Need to be expandable (feature-wise) process
  5. Scalability: Need to accommodate more applications and/or more servers
  6. Reliability: Need to have minimum downtime
  7. Predictability: Need to have enough testing coverage to provide predictable results all the time
  8. Traceability: Need to track what goes into a promote, what problems occur and how did we resolve it, also what happened during the promote
  9. Flexibility/Adaptable: Need to accommodate different types of application servers, environments, etc.
  10. Alerts and Notifications: Need to be able to recover from errors gracefully (email notifications, beeper, etc.)
  11. Portability: Need to be able to re-use the process to the other environments without too much effort.

Features

Octopi provides higher-level functions than other tools because it also facilitate workflow-like collaboration among different teams within the organization which are involved in a process.

For example, within a typical application deployment to production, the development team is not the only one involved, the deployment also depends on the DBA team for making synchronized database changes, a QA team for testing the features that are being deployed, and a team of SME's who will certify the deployment from customer's perspective. These coordinations are often neglected or handled in an ad-hoc fashion, thus lacking any kind of traceability and repeatability.

Octopi is able to accomplish this by interacting with a careful selection of existing tools which has been used widely in the industry.

For instance, rather than providing a smogasboard of "compatibility" with a wide-range of Version Control systems, Octopi focuses on the most manageable of the bunch, in this case: Subversion. This way, we can provide a branching and tagging mechanism that allows for a flexible yet controlled development environments.

IMPORTANT NOTE: We intend to support other Version Control systems in the future, but we started with Subversion with the realization that most Software Development organizations out there does not have a working SCM process. Thus by coming up with a working versioning mechanism, Octopi can help said organizations to build up (or strenghten) their SCM department.

Features:

  1. From the UI, you can: coordinate, kick-off, schedule, repeat, monitor status, query, categorize, generate reports on builds and promotes
  2. Built-in workflow engine to allow approval for promotes (and rollbacks if necessary)
  3. Flexible (property-based) configuration with built-in logics (ordered steps, alternative command, and conditional step execution)
  4. Tool-agnostic deployment engine (works with anything from Makefiles to Maven)
  5. Can handle anything from java applets to full-blown application servers (e.g. Weblogic, Tomcat, Zope, CMS, even .NET projects if scripting facilities are provided)
  6. Utilizes built-in application server scripting languages (e.g. WLST for Weblogic)

Documentation

The official documentation for Octopi will be available online in the near future, for now, a development blog is setup here