I built Eclipse Che 4.8.0, but I get "LOADING: Error while Booting developer machine" when I try to run a Workspace

I’m trying to run Eclipse Che as a tomcat server, to develop extensions.

I built the 4.8.0 version using maven with no problems. Also, I’m able to run the superdevmode. Even, I’m able to start the che server

$ cd ~/Documents/workspaces/my-eclipse-che-developer/che/assembly/assembly-main/target/eclipse-che-4.8.0-SNAPSHOT/eclipse-che-4.8.0-SNAPSHOT
$ bin/che.sh 

And I can open http://localhost:8080/dashboard and everything seems fine.

However, after I create a Workspace, when I open it, I see the message “LOADING: Error while Booting developer machine”.

Is there something that I’m doing wrong?

This is my configuration:

• Mac OS X El Capitan
• Eclipse Che Developer with Eclipse Mars, configured with yatta
• I configured Eclipse to use Maven 3.3.9 as external runtime
• I did checkout from the branch master (4.8.0-SNAPSHOT)
• I configured the project following this Eclipse Che guide
• Docker 1.12.0-a (build: 11213)
• Java 1.8.0_92
• I installed bower 1.7.9 and gulp 3.9.1
• Env variables

    export CHE_HOST_IP=127.0.0.1
    export CHE_HOSTNAME=localhost
    export CHE_CONF_FOLDER=/usr/local/opt/che

• che.properties at /usr/local/opt/che

#
# Copyright (c) 2012-2016 Codenvy, S.A.
# All rights reserved. This program and the accompanying materials
# are made available under the terms of the Eclipse Public License v1.0
# which accompanies this distribution, and is available at
# http://www.eclipse.org/legal/epl-v10.html
#
# Contributors:
#   Codenvy, S.A. - initial API and implementation
#

# workspace proxy configuration
http.proxy=
https.proxy=
no_proxy=

### Storage and user configuration
# The location where your workspaces (and their projects) are stored.
# This property works for Docker for Windows, Mac, and Linux.
# On virtualbox for windows, this property is ignored. Instead, they are stored at:
# c:\%userprofile%\AppData\Local\Eclipse Che\
che.workspace.storage=${che.home}/workspaces

# Your projects are synchronized from the Che server into the machine running each
# workspace. This is the directory in the machine where your projects are placed.
che.machine.projects.internal.storage=/projects

# Che stores various internal data objects as JSON on the file system.
che.conf.storage=${che.home}/storage

### Configuration of embedded templates and samples
# Folder that contains JSON files with code templates and samples
project.template_description.location_dir=${che.home}/templates

### Configuration of embedded stacks
#Path to predefined stacks json
che.stacks.default=${che.home}/stacks/stacks.json
#Path to folder with predefined stack icons
che.stacks.images.storage=${che.home}/stacks/images

### oAuth configuration. You can setup GitHub oAuth to automate authentication to remote
### repositories. You need to first register this application with GitHub oAuth.
# GitHub application client ID
oauth.github.clientid=NULL
oauth.github.clientsecret=NULL
oauth.github.authuri= https://github.com/login/oauth/authorize
oauth.github.tokenuri= https://github.com/login/oauth/access_token
oauth.github.redirecturis= http://localhost:${SERVER_PORT}/wsmaster/api/oauth/callback
auth.oauth.access_denied_error_page=/error-oauth

# Activates user self-service at the API level.
# Che has a single identity implementation, so this does not change the user experience.
# If true, enables user creation at API level
user.self.creation.allowed=false

# Remove locations where internal message bus events should be propagated to.
# For debugging - set to retrieve internal events from external clients.
notification.server.propagate_events=

# Che extensions can be scheduled executions on a time basis. 
# This configures the size of the thread pool allocated to extensions that are launched on
# a recurring schedule.
schedule.core_pool_size=10

### Docker is the default machine implementation within Che. Workspaces are powered by machines
### that are constructed when the workspace is started. The images used to generate containers
### for the machines can come from DockerHub or a private Docker registry.
machine.docker.registry=${CHE_REGISTRY_HOST}:5000
machine.docker.snapshot.registry_namespace=NULL
machine.docker.unused_containers_cleanup_period_min=60

### Docker registry auth config example. Note that you can configure many registries with different names.
#docker.registry.auth.your_registry_name.url=https://index.docker.io/v1/
#docker.registry.auth.your_registry_name.username=user-name
#docker.registry.auth.your_registry_name.password=user-password

docker.api.version=1.20
docker.connection.tcp.connection_timeout_ms=600000
docker.connection.tcp.read_timeout_ms=600000

### Machine configuration.  Machines power workspaces. This configures the Che behaviors that
### occur within the machine.

# This archive contains the server to run the workspace agent and any custom extensions.
# Che injects this archive into machines when they are booted or started.
machine.server.ext.archive=${che.home}/lib/ws-agent.zip

# The machine's log files are stored here
machine.logs.location=${che.logs.dir}/machine/logs

# Size of the machine by default.  What is used if RAM parameter not provided by user or API.
machine.default_mem_size_mb=1024

# When the workspace master launches a new workspace, Che performs checks of the internal Web 
# services. When Che gets a valid response, we know that the workspace agent is ready for use.
machine.ws_agent.max_start_time_ms=60000
machine.ws_agent.ping_delay_ms=2000
machine.ws_agent.ping_conn_timeout_ms=2000
machine.ws_agent.ping_timed_out_error_msg=Timeout reached. The Che server has been unable to verify that your workspace's agent has successfully booted. Either the workspace is unreachable, the agent had an error during startup, or your workspace is starting slowly. You can configure machine.ws_agent.max_start_time_ms in Che properties to increase the timeout.

# Hosts listed here will be added to /etc/hosts of each workspace machine.
# Add an entry here if you write a ws-agent extension that needs to communicate outside the machine
machine.docker.machine_extra_hosts=NULL

# This is the API endpoint of the workspace master running within the core Che server.
# This tells the workspace agent how to connect back to the Che server.
# che-host is a fake DNS hostname that Che creates for itself.
machine.docker.che_api.endpoint=http://che-host:${SERVER_PORT}/wsmaster/api

# If this is true, then we always pull an image from a registry even if we have an image cached
# locally. If false, Docker only pulls image if it does not exist locally.
machine.docker.pull_image=true

# If true, then all docker machines will start in privilege mode.
machine.docker.privilege_mode=false

# If the browser clients that are accessing Che are remote AND the configuration of Docker is an
# internal IP address or using Unix sockets, then remote browser clients will not be able to connect
# to the workspace. Set the Docker configuration so that Docker containers have an external IP 
# address and provide this host or IP address here.
machine.docker.local_node_host=NULL

# Allows to use registry for machine snapshots, you should set this property to {true},
# otherwise workspace snapshots would be saved locally.
machine.docker.snapshot_use_registry=false

# Allows to adjust machine swap memory by multiplication current machnine memory on provided value.
# default is -1 which means unlimited swap, if set multiplier value equal to 0.5 machine swap will be
# configured with size that equal to half of current machine memory, to disable swap set it to 0.
machine.docker.memory_swap_multiplier=-1

# URL path to api service.  
# Browser clients use this to initiate REST communications with workspace master
api.endpoint=http://localhost:${SERVER_PORT}/wsmaster/api

#### Everrest is a Java Web Services toolkit that manages JAX-RS & web socket communications
#### Users should rarely need to configure this.
# Disable asynchronous mechanism that is embedded in everrest.
org.everrest.asynchronous=false
# Quantity of asynchronous requests which may be processed at the same time
org.everrest.asynchronous.pool.size=20
# Size of queue. If asynchronous request can't be processed after consuming it will be added in queue.
org.everrest.asynchronous.queue.size=500
# Timeout in minutes for request. If after timeout request is not done or client did not come yet to get result of request it may be discarded.
org.everrest.asynchronous.job.timeout=10
# Size of cache for waiting, running and ended request.
org.everrest.asynchronous.cache.size=1024
# Path to asynchronous service
org.everrest.asynchronous.service.path=/async/

machine.ssh.connection_timeout_ms=3000
# The location of the Web Socket terminal used within the browser.
# This is copied into the machine and run from within it.
# Suffix helps differentiate archive for different architectures/OSes
machine.server.terminal.path_to_archive.linux_amd64=${che.home}/lib/linux_amd64/terminal
machine.server.terminal.path_to_archive.linux_arm7=${che.home}/lib/linux_arm7/terminal

# During the stop of the workspace automatically creates a snapshot if the value is {true},
# otherwise just stops the workspace.
workspace.runtime.auto_snapshot=true
# During the start of the workspace automatically restored it from a snapshot if the value is {true},
# otherwise just creates the new workspace.
workspace.runtime.auto_restore=true

# Reserved user names
user.reserved_names=

# java opts for dev machine
che.machine.java_opts=-Xms256m -Xmx2048m -Djava.security.egd=file:/dev/./urandom

EDIT: I shut down my laptop and fire it up again before to get these screenshots.

If I started che with this command

$ bin/che.sh -d

or

$ bin/che.sh -d -r:127.0.0.1

The IDE ends here

[TylerJewell]

We just rewrote our getting started docs - and now we try to channel everyone into this page to start with.

https://eclipse-che.readme.io/v4.7/docs/che-getting-started

[mariosotil]

@ddementieva @TylerJewell I hadn’t seen that page. Thank you so much. It worked.

Just for documentation purposes, it was only necessary the steps from the ‘Networking’ section. The ‘Running Che as a Docker Container’ and ‘Running Che as a Server’ sections are not necessary.