Open in app

Sign in

Write

Sign in

Release Notes: Eclipse Che 5.0

Stevan Le Meur
Eclipse Che Blog
Published in
23 min readJan 12, 2017

--

Release Overview

Eclipse Che 5.0 is a generational advance of the world’s most popular open source developer workspace server and cloud IDE. Eclipse Che lets you convert any production runtime into a developer workspace. Start with Docker or Compose, “dev mode” it with our agents, and then connect with your desktop IDE or our beautiful browser IDE.

This release includes 1300 commits from 60 contributors. We have crossed 3500 GitHub stars and 600 forks. Thank you to the amazing community for supporting us!

This release includes:

  • New (fun!) CLI: Offline installation, simple configuration, and data backup.
  • CLI Assemblies: Inherit and customize the Che CLI for your custom assembly.
  • Docker Compose Runtimes: Dev workspaces with multiple containers.
  • Workspace Snapshots: Auto-image and auto-restore workspace state
  • Workspace Agents: Inject developer services into any workspaces.
  • Docker Exec Agent: Replaces `docker exec` with a Golang REST server for executing commands.
  • Stack Editor: Create stacks with your runtime, or edit and test any of our 30+ defaults.
  • Language Server Protocol: Connect open source language servers to Che.
  • New Debuggers: Added new Node.JS and Zend PHP debuggers.
  • SSH: Automatic key generation across all machines in a single workspace.
  • Desktop Sync: Synchronize workspaces with your local IDE.
  • Split & Resize: Terminals and editors can be split and sized to your exacting requirements.
  • Docker Store Certification: Security tested Che Docker image.
  • PHP: Auto-complete, definitions, debugging and more.
  • Chedir: Reproducible workspaces from your local repo with “che dir up” syntax.
  • Contributor-Friendly Docs: Easier to edit and now deployed in your Che instance.
  • More Responsive: Filesystem watchers optimize file operations and browser updates.
  • Bitnami Stacks: Certified workspace stacks for popular languages and frameworks.
  • CentOS: Che can now run on a CentOS based Docker image.

Quick Start:

Advisories:

Docker 1.11+ is now required to run Eclipse Che.

We are deprecating the eclipse/che-launcher Docker image, which was a precursor to the new CLI. The new CLI has a simpler, easier to understand syntax.

We are also deprecating the OS-specific CLI wrappers, che.sh and che.bat which would help with invoking certain Docker command lines. All commands have been packaged into the new CLI with a common syntax and a single location for configuration.

Upgrading from 4.x:

If you are using version 4.x of Eclipse Che, export your workspace from the dashboard (Workspaces > Workspace Details), and recreate the workspace into the new Eclipse Che 5.0.

Release Features Details

New (fun!) CLI

We have rewritten the CLI to make starting, stopping, configuring, and managing Eclipse Che fun. Docker is an amazing tool and we use it to create a cross-platform installer that works on any system where Docker is running. Key features of the CLI:

  • Guided help: Enter docker run eclipse/che start and the CLI will help you get configured.
  • Proxy inheritance: Proxy configuration is derived from your Docker daemon.
  • Offline installation: Install Che and your stack images disconnected from the Internet.
  • Single configuration: A single che.env file with all configuration parameters.
  • Backup: User data is stored in a single location, simplifying backup and recovery.
  • Puppetized configuration: Templates and modules are used to configure OS-specific operation.
  • Debugging mode: Run with —debug to start the Che server with a debugger port.
  • CLI logs: There is now a cli.log stored in the root of your data directory.
  • Image registry: Fetch stack and Che dependency images during a single pull cycle.
  • Future proofing: Version compatibility check and workspace upgrader for future releases.
  • Docker Compose: The CLI generates OS-specific compose syntax to run Che.

The new CLI uses internal Docker containers such as alpine, eclipse/che-ip, and puppet/puppet-agent to install a “configuration” into the folder that you volume mount into :/data. This installation will be version-controlled and will get a new che.env file that has all of the properties within it that alters how Che behaves. When you start Che, we use our embedded Puppet container to source your properties from che.env along with a set of configuration templates installed during initialization to generate an OS-specific set of runtime files that are used to start, stop and restart Che on your host.

The output of a configuration is placed into the /instance folder, which will have a docker-compose.yml and a docker-compose-container.yml for starting, stopping, and restarting Che either directly from your host or from within another Docker container. When you use the CLI to start Che, we use (yet another) Docker container to initiate a Docker Compose up or stop sequence. While Che and its various workspaces are booting, you can follow along by tailing the container output and docker logs output.

Your end users can use the same CLI to interact with their workspaces as well. We have embedded commands to connect to workspaces, SSH into workspaces, and synchronize your workspaces with your desktop IDE within the same CLI.

CLI Assemblies

We have built the new Che CLI as a Docker container that can be inherited by your custom Che assembly to create a new, customized CLI that is Che-like, but customized with your own logic and additional commands.

CLI assemblies inherit the same syntax as the Che CLI along with the ability to expose new commands that you provide. Your custom assemblies based upon Eclipse Che can begin to inherit from the new CLI today. You start by inheriting from a Docker image named eclipse/che-base and then layering in your customizations. The new Codenvy CLI is a good example as it inherits from the base image, adds in new commands, and also provides a different set of runtime templates in its init image.

Docker Compose Runtimes

Eclipse Che workspaces have their own dedicated runtimes. Eclipse Che has been extended so that workspace runtimes can be defined with Docker Compose syntax or with a multi-machine stack.

This is all fancy talk for saying that you can now have a single workspace where your database and application are in different containers, connected together into a single network!

When the workspace starts, Che will execute the workspace runtimes defined in your stack. The stack definition can be comprised of multiple machines, each with their own Docker image. Or, you can provide a single Docker Compose recipe within the stack which will delegate multi-machine activation to Che. If you launch multiple machines in a single workspace environment, we will launch them in a virtual Docker network so that the machines will have visibility and a communication path between them. You can mount directories into the workspace as well.

Example Compose Recipe:

Che requires Docker Compose recipes to contain a machine named dev-machine where the workspace projects will be mounted and the Che runtime dependencies injected. It is possible to mount extra volumes in the dev-machine so other machines can get access to these volumes using the command volumes_from:dev-machine. This allows the project data to be shared across several machines in the workspace.

The majority of the Docker Compose file syntax works with Eclipse Che. For a full list of supported syntax and workarounds for some unsupported syntax see our documentation. Or read the Workspace Administration section of our docs to get a full picture of the workspace interaction.

You can try Docker Compose workspaces with this tutorial.

Workspace Snapshots

Now you can save your workspace runtime state and your project state with a single snapshot.

With Eclipse Che your workspaces are a combination of your workspace runtimes and your project code. We marry these two together during the workspace activation cycle. When you stop a workspace, we save your project code to long term storage through a volume mount.

Previously, end users had to specifically request a snapshot for their runtime to save the state. Now, the default configuration is that any workspace stop event will automatically snapshot the workspace runtime (and all of its images). Anything in your workspace /project folder will be saved to the data folder you mounted into the Che container. We then use Docker to snapshot the remaining contents of the workspace into a Docker image. There is now a matching auto-restore configuration item which will automatically restart the workspace from the latest saved Docker image on disk. When the workspace is started, your project files will be re-mounted or re-synced into /project.

By default, Eclipse Che is configure to auto-snapshot all workspaces and auto-restore them when the workspace is started again. Those behaviours can be modified in che.env file, the single configuration file of Eclipse Che.

By default workspace snapshots are saved to local disk, but you can configure Che to save snapshots to a private registry that you have installed. This configuration is also handle in the che.env file.

Read more in our docs.

Workspace Agents

Workspace agents dynamically inject developer services to convert production runtimes into developer workspaces. Agents are used to add capabilities like Java intellisense, SSH access, debuggers, and our Web terminal into any runtime. Agents are a cross-platform way to install, start, and configure software that is essential for doing development, but usually does not exist in your production containers.

Agents can also package their dependencies as well as dependencies of project types selected by end users. For example, if you choose a Node.JS project type, then the relevant agents may include yum or npm so that when an end user opens the workspace, the utilities they need to build and run their project are ready to go.

Some agents are included and configurable by your end users. Other agents are dynamic and injected by our workspace services based upon end user activity. When creating a workspace and editing its runtime, you can enable agents for each of the machines you are using through the user dashboard.

By externalizing the developer services through agents it allows you to take a production Docker image and “dev-mode” it by enabling agents. Combining developer agents with Che’s new multi-machine workspaces, it’s simple to enable developers to code on production-grade images.

Read more in our docs.

Docker Exec Agent

If you have spent any time with Docker on the command line, an essential tool for developers is running docker exec to inject commands into a running container. Che commands (the processes that run in your workspace when you select the Play button) have always been sent to your workspace runtimes using docker exec. Docker exec is great if you are working with a single command in a synchronous fashion. However, developers want more control and interactivity with the lifecycle of the commands that they run and a single Docker container needs to be able to handle simultaneous execution of many commands without disrupting the browser client that is making those commands.

We have replaced the built-in Docker exec capability with an all-new, high performance “exec agent”. This agent is a Golang-based server for executing commands within a workspace container and then streaming process output logs and command state as events over websockets.

We have open sourced this agent and it is included in the Eclipse Che repo. There are three subsystems:

  1. JSON RPC 2.0 Web Socket interface
  2. Events
  3. REST API for starting a process, killing process, getting logs, and event subscriptions

Stack Management

Stacks define a reusable template that contains a definition for a workspace runtime, a set of commands and project configuration and metadata. Stacks, like workspaces, now support both single container and multi-container environments.

You can use Che’s built-in stacks or author your own custom stacks. There is a new “Stacks” section in the user dashboard to create, edit and manage stacks — you can edit the predefined ones or use the stack’s editor to author your own custom stacks.

The built-in stacks editor allows to author your stack and test them into a temporary workspace. When, testing the new stack, Che spins up a temporary and isolated workspace using the stack you just defined. You can use the temporary workspace to import your project, test commands and ensure all the components you need are properly configured. Once the testing session is completed, the temporary workspace will be automatically deleted.

Read more about using and customizing stacks in our docs.

Language Server Protocol

Eclipse Che now supports the language server protocol that Codenvy, Red Hat and Microsoft announced in June.

Language servers provide distributed intellisense for a language and can include syntax highlighting, code analysis, error checking and auto-completion.

In Che, language servers are packaged as agents and get injected into the workspace’s dev-machine where they are installed and activated depending the project type and the file being edited.

The language server protocol has significant momentum. There are nearly 20 planned language servers being created by the communities from different language ecosystems. Our project lead, Tyler Jewell, is particularly looking forward to the Emacs language server! With the availability and feature support for different language servers changing so frequently, we will be updating our support in each release.

Today, Che supports JSON, C#, Java, PHP and TypeScript language servers.

Plus, language servers for Go, Python and JavaScript are planned for contribution in Q1 of 2017 by Sourcegraph. We will be aggressively adding in support for additional language servers as they get released, and we will be working with other projects on a dynamic registry so that we can discover and add new language servers without having to do a new release of Che each time.

In this version of Che, we have added the following features of the language server protocol into our editor:

  • Show errors and warnings inside the editor:
  • Auto-completion:
  • Find Definitions: searches for symbol definition and jump-navigation
  • Find Reference: search project-wide references for the symbol in the given text
  • Document Symbol: view and navigate document symbols
  • Workspace Symbol: view and navigate symbols across a workspace
  • Formatting Capabilities: document formatting, document range formatting, on type formatting
  • Hover feature:

You can read about the implementation of the Language Server Protocol in the issues that were merged.

Watch the CheConf session on Language Servers:

New Debuggers

We’ve added gdb, Node.JS, and Zend PHP debuggers. You can now launch debugging servers within your workspaces for each of these services, and then configure the IDE to automatically connect to the debugger over their specialized debugging port.

Debuggers are installed and configured with the ready-to-use technology stacks provided out of the box with Eclipse Che. For example, if you select PHP stacks you can use the Zend Debugger for both PHP CLI scripts and PHP web apps.

The debugging workflow involves the following steps:

  1. Set breakpoints in the editor.
  2. Launch the debugger to start listening for a new debug session.
  3. Execute the debug command for your project.
  4. Use the debugger to analyze the behavior of your project.

Read more in our docs.

SSH

Eclipse Che now provides automatic key generation across all machines in a workspace. If your workspace is powered by Docker Compose, then the SSH agent is deployed into every container that makes up your compose services. You can optionally remove the agent from selected machines of your compose services from within the dashboard.

Each new workspace has a default key-pair generated for it. The private key for the workspace is inserted into each machine and they will all share the same public key. You can generate a new key-pair in the dashboard (under “Workspace” > “SSH”), or remove the default one to replace it with your own.

You can then use various utilities for connecting to a workspace using SSH with our Docker containers, the Che CLI, or your off-the-shelf SSH client on your desktop.

SSH with Che CLI:

Read more in our docs.

Desktop Sync

You can now use any IDE with your Eclipse Che workspaces. We have built a fast, Fuse-based mount and sync utility for your workspaces. The sync utility connects to a workspace and synchronizes the project files to a local file system. The utility works on every operating system including Linux, Mac, and Windows with the same syntax (no need to install crazy tools like Windows Putty to do SSH). Of course, Docker came to the rescue here, as the synchronizer is built into the new CLI.

Synchronizing your project files lets you have an offline / online mechanism. It also allows you to use any desktop IDE with your local project files. The synchronizer runs in the background and developers can work with their hosted Che workspaces or with their desktop IDE and the file modifications are synchronized every couple of seconds.

Our mount utility is built with a Docker container eclipse/che-mount, inside of it, we create an sshfs connection to the remote workspace using your user name, password, and workspace port number. We then use unison, a file system synchronizer, to synchronize the contents of the remote workspace with a directory in the container. Your localhost volume mounts the synchronized directory and files are shared. The unison synchronizer is run every minute, and will capture both changes made locally on your host and any changes made in the remote workspace.

To synchronize your local IDE:

This will make a secure connection to the workspace and unison sync the contents to the local host directory.

The default synchronizes everything in your workspace’s /projects folder. The size and nature (binary vs. text) of the files within your workspace affect the time it takes to complete a synchronization. If you have libraries such as with an NPM or maven repository, it may be unnecessary and taxing to synchronization all of those files.

You can improve synchronization performance by providing a unison profile. A unison profile allows you to specify path specifications of files that must be included or ignored, and there are multiple tactics for specifying the list including regex and directory pattern matching.

You provide a unison profile as a *.prf file within a folder on your local computer and then volume mount the folder containing that folder with an additional Docker option when using the CLI: -v <path-to-unison-file>:/unison .

See examples more in our docs.

Split & Resize: Terminals and Editors

Split, size, split again, and resize. You can now manipulate the terminal and editor windows to divide your workspace into your ideal layout. You can split views horizontally and vertically, and then move the split to create the view size that you want. Files that are opened within the editor can be targeted for a particular pane, and terminal command output is also pinned to the output window that you want.

You can also quickly maximize the size of a panel by using the quick option icon in the top right corner. Alternatively, you can get a fullscreen editor by just double clicking on its tab. The same behaviour applies to the processes panel, so enjoy a fullscreen terminal or console output window right now!

Read more in our docs.

Docker Store Certification

The Docker Store is a new marketplace for trusted and validated dockerized software. It provides users with greater confidence in Docker images — all Docker Store images are validated through security scanning, component inventory, open-source license usage and use of best practices in image construction. Eclipse Che is now available in the Docker Store.

PHP Love

Everyone give the great engineers at Zend, a Rogue Wave company, a big round of applause! They worked night and day to expand the PHP support within Che. There are new PHP stacks with certified PHP runtimes, PHP project types within the wizard, PHP project templates, PHP syntax highlighting, Zend debugger, and a PHP language server for eat-your-heart-out PHP intellisense.

If you activate the PHP intellisense agent, you’ll get code completion, syntax analysis and validation, formatting tools, symbols resolution as well as a set of features to navigate to definition and find references. Those features are provided by an open source language server implementation for PHP which has been integrated into Eclipse Che. This language server is implemented in pure PHP and made by the PHP community itself.

Chedir: Reproducible Developer Environments for DevOps

Chedir provides an easy to configure, reproducible and portable developer workspace controlled by a single consistent workflow to help maximize the productivity and flexibility of you and your team.

To achieve its magic, Chedir uses Eclipse Che and Docker. Workspaces are provisioned inside of a Che server that is running locally or remotely. The workspace will have its own private runtime that is also based upon Docker or Docker Compose. Your source code is then synchronized from the current directory into the hosted workspace. You can use provisioning tools such as shell scripts, Chef, or Puppet to define the software that is inside the workspace available to edit, build, run and debug your code.

Chedir is (positively) influenced by Vagrant. Where Vagrant treats a single VM as a broad abstraction as an “environment”, Chedir applies a similar abstraction to a developer workspace.

Chedir is available with the Che CLI, you can learn more about Che CLI and how to install it in our docs. With Docker, the Che CLI is the only dependency that you need in order to use Chedir.

Once installed:

This command will boot a Che server and Chedir will also create a workspace and start its runtime.

You can customize how the Che server, workspace, and project are generated by creating a Chefile and placing it into the root of your repository. The Chefile contains the configuration that will be used to setup the Che server and Che workspace.

Run Chedir down command on the host machine. Chedir will stop the workspace’s runtime, stop the Che server, and return to the host. The workspace and its project will be preserved.

To stop the Che server and remove the workspace, you can destroy it:

Read more about Chedir and Chefiles.

Contributor-Friendly Docs

Eclipse Che documentation has been repackaged into markdown templates so that documentation changes can be tracked with PRs similar to how we manage code changes. We then use Jekyll to convert markdown into static HTML that is pushed to the Che site from our CI system each night. You can see the docs on our site and within Che itself at <che-host>/docs. You can also access docs from the footer of the user dashboard.

One of the great things about a growing community is the amount of active interest there is from those that want to join the project and start to give back. The best way to begin giving back is to help us with tutorials and documentation, taking the best practices that you have learned while using the product and adding them into the documentation. GitHub-based docs allow us to broaden the community engagement and for new project contributors to learn how to collaborate with project mainters.

Performance of File Operations and Browser Updates

We made architectural changes in order to optimize file operations. File operations are at the core of an editor and the IDE must be responsive to be enjoyable.

We’ve added a new file watcher sub-system, which tracks and generates events for portions of the workspace file system, project structure, or individual files within the workspace. Our client-side extensions and plugins register new file watchers that contain the minimum sets of folders and files that need to be watched for updates, and within the system any modifications to those files are monitored in real time for broadcast to the IDE. There is dynamic registration of file watchers for important resources. For example, we register a watcher for a specific path only if it is expanded in the project tree folders.

Files opened in the browser IDE are always updated in real time to reflect any changes when:

  • Several users are using a single workspace.
  • Several clients (local IDE sync, SSH sync) are using a single workspace.
  • Several browser IDEs used in different tabs.

You can learn more in the following epic.

Bitnami Stacks

Bitnami provides certified workspace stacks for popular programming languages and frameworks. The stacks are integrated with Eclipse Che and make development frameworks simple to access and use. Each framework comes pre-installed and configured in the stack. You can go from thinking about a new app, to coding it, in just a few minutes. Pretty easy and fun!

Certified Bitnami workspace stacks for Express, Laravel, Rails, Symfony, Play, CodeIgniter and Swift are currently available in Eclipse Che. And because Bitnami engineers want to make your containers as lean as possible, they are providing these stacks using the minimalist Debian-based Docker image Minideb (learn more about minideb images in this article).

Get started with Che and Bitnami workspace stacks.

CentOS

As an alternative to the default alpine-based image users can now run Che on a CentOS based image. To achieve that you can use the new Dockerfile based on CentOS official image. The resulting che-server image will be identical to the alpine-based except that the underlying OS is the CentOS Linux distribution. To build the CentOS image just replace dockerfiles/che/Dockerfile with dockerfiles/che/Dockerfiles.centos and run the build.sh script.

Other Notable Enhancements

  • Mechanism to configure Che with configs from different sources (#2175)
  • Add possibility to install Orion Plugin (#2262)
  • Action to download all projects in workspace (#2347)
  • Ability to preview HTML files into another browser window (#2378)
  • New loading behaviors when booting workspace from the IDE (#2352)
  • New wizard to restart workspace once stopped (#2542)
  • Improved workspace-select-stack (#2432)
  • Syntax coloring for outputs in process panel (#2407)
  • System notifications mechanism (#2529)
  • Ability to rename a project (#2436)
  • Auto create files with hello world content when creating C, C++ and Python projects (#2600)
  • Replace global loader (#2589)
  • Add ability to download workspace startup logs (#2686)
  • Improved tabbed editor design (#2400)
  • Add notification when workspace agent is not reachable (#2530)
  • Better handling of workspace snapshotting operation (#2747)
  • Support for Arduino files (#2772)
  • Restore IDE UI state, opened files and panels for each sessions (#2880)
  • Contextual commands (#2730)
  • Introduce PlatformIO stacks with samples (#2887)
  • Configure workspace SSH from dashboard (#2980)
  • Soften dark theme (#2555)
  • NodeJS debugger (#2625)
  • SVN switch action (#2758)
  • Command Macro to get workspace name (#2294)
  • Command Macro to handle service protocol (#2296)
  • Easier Eclipse IDE Setup (#2705, #2610, #2696, #2733)
  • Ability to customize highlighting color in editor when creating a theme (#3254)
  • Option for linking the project explorer with the active editor (#3026)
  • Contextual editor menu with right-click action (#3066)
  • Added keyboard shortcut to expand/collapse in project explorer (#3083)
  • Added empty states in editor and project explorer (#3102)
  • Added new approach for initializing database schemas and migration (#3063)
  • Add ability to import multiple projects (#2937)
  • Workspace SSH management from Dashboard (#2059)
  • Add listeners to delete temporary workspaces on server shutdown and startup (#3245)
  • Add CPU limits for workspace containers (#3278)
  • Add ability to suspend GDB debugger session and breakpoint (#3274)
  • Display version number in dashboard (#3365)
  • Improve error message when starting nightly from a latest configuration (#3664)
  • CLI improvements for handling of nightly images (#3671)
  • Che CLI refactoring (#3646)
  • Make it possible to configure logback smtp host and port (#3670)
  • Update default_node_content (#3678)

Notable Bug Fixes

  • Fixed widget still displayed after machine destroyed (#2250)
  • Fixed wrong redirection and flickering after creating a project on dashboard (#2276)
  • Fixed duplicated terminal with dev-machine at startup (#2341)
  • Fixed RAM slider unexpected behaviors (#2340)
  • Fixed refresh issue with Find Action wizard (#2334)
  • Fixed potential loops when snapshotting workspace (#2413)
  • Fixed NPE after deleting multi-module project (#2419)
  • Fixed custom stack documentation link (#2443)
  • Fixed potential issue with opened tabs while workspace is stopped (#2372)
  • Fixed behavior to clear the list of recent actions in IDE (#2521)
  • Fixed wrong formatting when applied to a whole file (#2719)
  • Fixed applying exclude filter when indexing files (#2857)
  • Fixed displaying obvious notifications (#2875)
  • Fixed SSH widget scrolling behavior (#2059)
  • Fixed wrong placeholder message displayed while loading IDE (#2957)
  • Fixed get projects after workspace fully started (#2867)
  • Fixed close all editor when the workspace is stopped (#3175)
  • Fixed line wrapping in terminal (#3284)
  • Fixed removal of temporary workspace when server shutdown (#3245)
  • Fixed deletion of ssh keys having a “slash” character (#3000)
  • Fixed workspace start error with certain stacks on CentOS and RHEL6 (#3070)
  • Fixed text search in PRP, HTML and other files (#3087)
  • Fixed close all editors on workspace stop event (#3291)
  • Performance improvements in code completion (#3146)
  • Fixed importing maven project with relative path in modules (#3457)
  • Breakpoints disappear when nodejs debugger is resumed (#3675)
  • Don’t show notification after deleting files internally (#3652)
  • Fix upgrade CLI method (#3682)

Upgraded Dependencies

  • Upgrade Orion Editor to version 12 (#2351)

API Changes

  • Remove workspace.name from model (#2652)

Community Thank You!

We’d like to say a big thank you to everyone who helped to make Che 5.0 even better:

We hope that you are getting joy using Eclipse Che. You can engage with us through:

Docker
DevOps
Eclipse
Containers
PHP

--

--

Stevan Le Meur
Eclipse Che Blog

Written by Stevan Le Meur

200 Followers

Product Manager at Red Hat. Eclipse Che commiter. Geek, Design, Architecture and Kite surfing.

Help

Status

About

Careers

Blog

Privacy

Terms

Text to speech

Teams