Warning message

Committer Maxim Musienko must create an Eclipse Foundation Account.

Status message

A creation review has been created for this proposal.

Che

Basics
This proposal is in the Project Proposal Phase (as defined in the Eclipse Development Process) and is written to declare its intent and scope. We solicit additional participation and input from the community. Please add your feedback in the comments section.
Parent Project: 
Background: 

Che is a project to create a platform for SAAS developer environments.  A SAAS developer environment is one that contains all of the tools, infrastructure, and processes necessary for a developer to edit, build, test, and debug an application.  Since a SAAS developer environment is fully hosted, whether it is running on your desktop, in your datacenter, or in the cloud, that environment can be cloned, embedded, and shared in ways that desktop-installed environments cannot be.  SAAS developer environments also contain the tools to orchestrate developer workflows, exposed in a variety of interfaces either through REST APIs, a browser-based client providing IDE functions, or a CLI.  The Che project contains a structured way to create server- and client-side extensions that are authored in Java, but generated as JavaScript, a set of standard developer-related REST APIs for interacting with development workflows, a large set of language & tooling extensions (Java, git, etc.), a default cloud IDE, and a developer environment cloud for scaling environments with large populations.

The success of the platform depends on how well it enables a wide range of tool builders to build best of breed integrated tools that run on a distributed system and accessed by a variety of clients. But the real vision of an industry platform is only realized if these tools from different tool builders can be combined together by users to suit their unique requirements, in ways that the tool builders never imagined.

Scope: 

The Che project provides a commercial grade platform for building and managing SAAS developer environments following the Eclipse RCP model of modularity.

This project includes:

  1. A structured format for an extension, authored in Java and using dependency injection for defining both the client-side and server-side logic of the resulting Web application that is generated.
  2. The Che Web Client Platform (WCP), a kernel for loading, managing, and running extensions authored in Java that get translated into client-side JavaScript and server-side Java.
  3. Tools to simplify and automate the packaging of Java extensions for deployment into the Che WCP. This is called the SDK. Also included in the Che SDK is a large set of helper APIs for creating developer-oriented application, similar to the APIs provided by the Eclipse RCP project.
  4. A large set of language and tooling extensions covering the range of developer needs and expectations, such as tools for Java, git, deployment, and subversion.  We also envision many external extensions to be created, some of which may become sub-projects or projects of their own.
  5. A default cloud IDE authored as a Che WCP application including a large set of pre-packaged extensions, with an emphasis on Java, database, SCM, and deployment tooling.
  6. A set of synchronous REST APIs for representing the key workflow of development activity, such as Project, Builder, Debugger, and Instance management. Additionally, these APIs will ship with implementations that provide behavior for running on a desktop, and can offer different provider implementations when deployed in an enterprise cloud development platform. This will also include any desktop IDE plug-ins designed to interact with the SAAS developer environment over these APIs. The initial contribution will include an Eclipse plug-in.
  7. A developer environment cloud (PAAS) for the management of large populations of concurrent developers and developer environments.  For the sake of simplification, we call this Che Enterprise.  Che Enterprise provides an multi-server architecture for scaling developer workflows in a virtualized way.   Che Enterprise is a PAAS system that will run on any public or private IAAS implementation, which will provide hardware node elasticity.  Provided in Che Enterprise is cloud administration, administrator dashboards, logic to separate editing, code assistant, builder, and debugger logic onto decoupled clusters, structured access to external resources such as secure access to GitHub or an internal data warehouse required for use during development, a repository for managing users, accounts, and subscription configurations, a system for applying behavior and access policies to development workflows, and an embedded analytics system for measuring development activity and engagement.
  8. The development of a compiler and translator that takes certain EMF / GMF models and creates Che WCP editors authored in Java and GWT that are ready for deployment. This tooling can be used to create extensions that have editors that can be used in a drag-and-drop, drawing, modeling context.

This project is a sibling to the Orion project, and the two teams have discussed many areas of alignment and collaboration moving forward. We see Orion as complementary and necessary relative to Che, as each solution is optimized for different scenarios. Che and Orion will initially collaborate on APIs for communication between browser clients and server systems; finding ways to standardize plug-in formats to work within both systems; making editors interoperable (Che will use Orion editor); and standardizing on a workspace description format so that temporary environments with fully provisioned code, project, builder, runner, and plug-ins can be automatically generated in a decoupled, command-line or URL format.

Description: 

Many development tools that are deployed on the desktop create two challenges for large organizations: configuration and compliance. When a developer or system administrator needs to install a tool individually on each machine, or each tool needs a reconfiguration for each branch / project / issue, there is a lot of manual step-by-step configuration tasks that a developer or admin must perform (repeatedly) to achieve a proper configuration.

Centralized cloud development systems, which orchestrate all of a developer’s activity such as project creation, builders, debuggers, editors, and code assistants, offer a way for environment configuration to be automated by the centralized system or offloaded to third parties such as system administrators. The second class of issues are compliance, audit, and visibility related. With development taking place on desktops, those computers become threat vectors with all of the software that gets installed, managers are unable to track usage to improve productivity, and there are limited ways to audit development activity.

Again, centralized development systems offer a way to organize this activity with a higher level of efficiency for an organization. Additionally, a cloud development system that targeted the enterprise needs to exist. Enterprises depend upon an open infrastructure combined with a set of tools (plug-ins) that represent their workflows, processes, and tool integrations that they require. The existing Eclipse project has developed a broad and diverse ecosystem of tooling plug-ins that are bound to the desktop.

Che is a project to create a platform for SAAS developer environments.  A SAAS developer environment is one that contains all of the tools, infrastructure, and processes necessary for a developer to edit, build, test, and debug an application.  Since a SAAS developer environment is fully hosted, whether it is running on your desktop, in your datacenter, or in the cloud, that environment can be cloned, embedded, and shared in ways that desktop-installed environments cannot be.  SAAS developer environments also contain the tools to orchestrate developer workflows, exposed in a variety of interfaces either through REST APIs, a browser-based client providing IDE functions, or a CLI.

Architecturally, Che is an SDK, IDE, set of APIs, a set of plug-ins, and an enterprise cloud system for running many environments at scale with security, high availability, and structured identity management. Che is a system not only for providing a SAAS developer environment that runs locally for a single individual, but also creates solutions for running many developers environments accessed by large developer populations concurrently. Essentially, Che is both a Web application that contains client- and server-side systems while also providing a specialized PAAS infrastructure optimized for developer-specific workflows.

The Che kernel applies the concepts, principles and best practices of the Eclipse RCP architecture to a Web-based architecture, running in a servlet runtime.  The Che kernel provides a Web Client Platform for building Web applications written in Java.  These Web applications are simultaneously three parts: a browser-based Web client, a hosted server-side logic repository, and a structured REST API for allowing clients and servers to communicate with each other. Applications deployed into the Che kernel (running in the SDK) have their clients translated to optimized and cross-browser portable JavaScript, and their server-logic packaged into a servlet-style deployment. The architecture of applications are modular, with extensions being structured similarly to how Eclipse extensions are built, packaged, and managed. Che Extensions, authored in Java & GWT, married with the Che Web Client Platform create a JavaScript optimized Web application. Extensions are both server- and client-side, where a single Java authored extension is transparently generated into both a client- and server-side logic that operates seamlessly within the Che kernel.

Also provided with this project are a wide set of extensions for various programming languages, tools (such as git & subversion), deployment (such as Google App Engine, Heroku, IBM, and Cloud Foundry), and enterprise needs (like datasource / SQL editing). Additionally, a default cloud IDE is provided, designed as a workbench for the enterprise developer, similar to the Eclipse project, with a default packaging of extensions and developer workflow optimized around a cloud IDE environment.

The Che system is intended to run on any servlet container, and can be deployed either as a stand alone packaging (run as a desktop application with a browser interface) or as part of an enterprise cloud platform, which turns the packaged application into a multi-tenant, secure, and scalable distributed development system. When deployed within an enterprise cloud development platform, the Che packaging (kernel + SDK + IDE + extensions) operate in a central, orchestrated fashion on a system designed to ensure HA and scalability of large developer populations,  including providing the potential for large organizations to apply sophisticated behavioral / access permissions, derive intelligence from analytics of activity, and meet compliance obligations with audit / access logs.

The Che kernel generates JavaScript that is optimized for all major browsers and also certain mobile devices. The benefit of such a system is a lightweight approach that can be used to build any type of Eclipse-style extension, accessible via a browser, but authored entirely in Java.  With the architectural approach, the migration of existing Eclipse plug-ins to a browser IDE format will be reduced as they can stay in Java and use many of the same API / SDK practices.

Additionally, this system provides a way to quickly create new distributions of IDEs that can be run on the desktop and then graduate to a full enterprise cloud platform that is centrally provisioned and managed.

Why Here?: 

With our target being both individual developers and large enterprises, Che needs an organization and set of processes that allow it to achieve maturity and exposure to a global community of developers and contributors who can build the extensions necessary to drive adoption within enterprises.

Che started in 2009 at Exo Platform, and eventually spun out to Codenvy at the beginning of the year 2013. Che has attracted developers steadily, with up to 38 people having contributed to the project so far. Che has been deployed for usage at Codenvy.com for a while and there are 125,000 user developers who have used the system, and 1000s of those have encouraged openness and provided input into its future direction.

Eclipse provides a well defined governance structure and development process. Eclipse also provides a very rich ecosystem of development that Che wants to attract and retain. Becoming an Eclipse project is the next logical step onto maturity, increase its visibility and attract other contributors and companies to an open source environment.

Che could especially contribute to the Orion and Flux projects, which are solving problems in the same related space.  Che is strongly based on the Eclipse platform using several of its technologies (e.g., JDT libraries).  Furthermore existing projects like Orion and Flux can benefit from the collaboration as Che provides infrastructure components both could use or which could be developed in collaboration reducing the effort for all.

 
Project Scheduling: 

Che plans to finish the initial contribution by the end of Q3 2014 using the 1.1 release.  The contributions could take many quarters to complete.  The Che SDK + WCP + IDE + plug-ins will be the first contribution done throughout 2014.  The Che Enterprise system will be done throughout 2015.

 
Future Work: 

Che plans to finish the initial contribution by the end of Q3 2014 using the 1.1 release.  The contributions could take many quarters to complete.  The Che SDK + WCP + IDE + plug-ins will be the first contribution done throughout 2014.  The Che Enterprise system will be done throughout 2015.

 
People
Committers: 
Alexander Reshetnyak
Alexander Garagatyi
Andrey Parfonov
Andrey Plotnikov
Anna Shumilova
Dmytro Nochevnov
Max Shaposhnik
Maxim Musienko
Oleksii Orel
Roman Iuvshin
Roman Nikitenko
Sergey Leschenko
Vitalii Parfonov
Interested Parties: 

The following individuals, organisations, companies and projects have expressed interest in this project:  SERLI, WSO2, Nuxeo, Eclipse Orion, Eclipse Flux, Jeremy Whitlock (Apigee), TaskTop, RedHat, SAP Dirigible Team

 
Source Code
Initial Contribution: 

The initial contribution for Che will consist of all current open source code available at the Codenvy SDK repositories. This includes the Codenvy SDK (runtime for managing plug-ins and tools to create packaged Web client applications), Codenvy IDE (a default application with extensions for developers and many predefined developer workflows), Codenvy Plug-Ins (a wide gamut of extensions supporting programming languages, tools, and developer workflow extensions), and Codenvy Platform API (the REST interfaces and implementation of those interfaces within server-side components for stand alone implementations). The components of Codenvy Enterprise will be open sourced and contributed starting in 2015 after a number of proprietary IP restrictions are resolved.

 
Source Repository Type: