<!DOCTYPE html>
<html lang="en">
<!-- Global site tag (gtag.js) - Google Analytics -->
<script async src="https://www.googletagmanager.com/gtag/js?id=UA-112407000-2"></script>
<script>
    window.dataLayer = window.dataLayer || [];

    function gtag() {
        dataLayer.push(arguments);
    }
    gtag('js', new Date());

    gtag('config', 'UA-112407000-2');
</script>

<!-- Google Tag Manager -->
<script>
    (function (w, d, s, l, i) {
        w[l] = w[l] || [];
        w[l].push({
            'gtm.start': new Date().getTime(),
            event: 'gtm.js'
        });
        var f = d.getElementsByTagName(s)[0],
            j = d.createElement(s),
            dl = l != 'dataLayer' ? '&l=' + l : '';
        j.async = true;
        j.src =
            'https://www.googletagmanager.com/gtm.js?id=' + i + dl;
        f.parentNode.insertBefore(j, f);
    })(window, document, 'script', 'dataLayer', 'GTM-KS8HHSF');
</script>
<!-- End Google Tag Manager -->

<head>
    	<title>Troubleshooting | Codewind</title>
	<meta charset="utf-8">
	<meta name="viewport" content="width=device-width, initial-scale=1.0">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
	<meta name="viewport" content="width=device-width, initial-scale=1">
	<meta name="description" content="Troubleshooting Codewind">
	<meta name="keywords" content="troubleshooting, issues, workaround, logs, common problems, Mac, Windows, Linux, Theia, Docker, help, open a new issue, contact us, help, check the logs"/>
	<link rel="icon" type="image/png" sizes="16x16" href="images/favicon/favicon-16x16.png">
	<link rel="icon" type="image/png" sizes="32x32" href="images/favicon/favicon-32x32.png">
	<link href="https://fonts.googleapis.com/css?family=IBM+Plex+Sans:300,400,600&display=swap" rel="stylesheet">
	<!-- Bootstrap CSS CDN -->
	<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/css/bootstrap.min.css"
	integrity="sha384-ggOyR0iXCbMQv3Xipma34MD+dH/1fQ784/j6cY/iJTQUOhcWr7x9JvoRxT2MZw1T" crossorigin="anonymous">
	<link href="https://maxcdn.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css" rel="stylesheet" />
	<link rel="stylesheet" href="css/styles.css">
	<link rel="stylesheet" href="css/docs.css">
	<link rel="stylesheet" href="css/blog.css">
	<link rel="stylesheet" href="css/guides.css">
	<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/prism/1.17.1/themes/prism.min.css">
	

</head>

<body data-spy="scroll" data-target="#toc">
    <!-- Google Tag Manager (noscript) -->
    <noscript><iframe src="https://www.googletagmanager.com/ns.html?id=GTM-KS8HHSF"
        height="0" width="0" style="display:none;visibility:hidden"></iframe></noscript>
        <!-- End Google Tag Manager (noscript) -->
    <div class="main">
    <!-- Bootstrap NavBar -->
	<nav class="navbar navbar-expand-lg navbar-light cw-banner fixed-top" aria-label="topnav">
    		        <button class="navbar-toggler navbar-toggler-right" type="button" data-toggle="collapse"
            data-target="#navbarNavDropdown" aria-controls="navbarNavDropdown" aria-expanded="false"
            aria-label="Toggle navigation">
            <span class="navbar-toggler-icon"></span>
        </button>
        <a class="navbar-brand" href="/codewind/">
            <img alt="Codewind logo image"  title="Codewind logo image" src="images/header/header-logo.svg" class="cw-header-logo" alt="">
        </a>
        <div class="collapse navbar-collapse justify-content-end cw-navbar-padding" id="navbarNavDropdown">
            <ul class="navbar-nav cw-navbar-nav">
                
                <li class="nav-item cw-navbar-item cw-header-link-docs">
                    <a class="nav-link cw-nav-link cw-header-link-text" href="overview.html">Docs</a>
                </li>
                <li class="nav-item cw-navbar-item cw-header-link-news">
                    <a class="nav-link cw-nav-link cw-header-link-text" href="news.html">News</a>
                </li>
                
                <li class="nav-item cw-navbar-item cw-header-link-blog">
                    <a class="nav-link cw-nav-link cw-header-link-text" href="blog.html">Blog</a>
                </li>
                
                <li class="nav-item cw-navbar-item cw-header-link-guides">
                    <a class="nav-link cw-nav-link cw-header-link-text" href="guides.html">Guides</a>
                </li>

                 <li class="nav-item cw-navbar-item cw-header-link">
                    <a class="nav-link cw-nav-link" href="https://github.com/eclipse/codewind"><img alt="Codewind Github"  class="banner-image"  title="Codewind Github" data-toggle="tooltip" data-placement="top" id="cw_github_stars" title="..." src="images/header/github.svg"/></a>
                </li>
                
                <li class="nav-item cw-navbar-item cw-header-link">
                    <a class="nav-link cw-nav-link" href="https://twitter.com/EclipseCodewind"><img alt="Codewind Twitter"  class="banner-image" title="Codewind Twitter" src="images/header/twitter.png"/></a>
                </li>
                 <li class="nav-item cw-navbar-item cw-header-link">
                    <a class="nav-link cw-nav-link" href="https://mattermost.eclipse.org/eclipse/channels/eclipse-codewind"><img alt="Codewind Mattermost"  class="banner-image"  title="Codewind Mattermost" src="images/header/mattermost.png"/></a>
                </li>
                <li class="nav-item cw-navbar-item cw-header-link">
                    <a class="nav-link cw-nav-link" href="https://www.youtube.com/channel/UCnKCVK6RFDyHFqUmXlAhCHQ"><img alt="Codewind YouTube"  class="banner-image" title="Codewind YouTube" src="images/header/youtube.png"/></a>
                </li>
               
               
                <!-- li class="nav-item cw-navbar-item" id="download-li">
                    <button onClick="window.location.href='https://microclimate.dev/download/codewind';" type="button" class="btn cw-download-button">Download</button>
                    <a href="https://microclimate.dev/download/codewind" class="nav-link cw-nav-link cw-download-link" href="#">Download</a>
                </li>  -->


                
                <!-- Smaller devices menu END -->

            </ul>
        </div>

    	</nav>
    	<!-- End Bootstrap NavBar -->
<!-- Bootstrap row -->
<div class="row" id="body-row">
    <!-- Sidebar -->
    <div id="sidebar-container" class="bg-light"  role="navigation" aria-label="sidebar">
        <!-- Bootstrap List Group -->
        <ul class="list-group sticky-top bg-light cw-sticky-offset">
            
            

				
				<a href="overview.html" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-url="overview.html">
					What is Codewind?
				</a>
				

			

				


				

				<a href="#getting_started" id="#getting_started" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-toggle="collapse" aria-expanded="false">Getting started<span class="submenu-icon"></span></a>
				<div class="cw-sidebar-div cw-sidebar-submenu collapse" id="getting_started">

					
					
						
							<a href="gettingstarted.html" class="bg-light list-group-item" data-parent="#getting_started" data-url="gettingstarted.html">Overview: Getting started</a>
						
					
					
					
						

							

							<a href="#vs_code" id="#vs_code" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-toggle="collapse" data-parent="#getting_started" aria-expanded="false">VS Code<span class="submenu-icon"></span></a>

							<div class="cw-sidebar-div cw-sidebar-submenu-submenu collapse" id="vs_code">
								
									
										<a href="vsc-getting-started.html" class="bg-light list-group-item" data-parent="#vs_code" data-url="vsc-getting-started.html">Installing Codewind for VS Code</a>
									
										<a href="vsc-firstproject.html" class="bg-light list-group-item" data-parent="#vs_code" data-url="vsc-firstproject.html">Creating your first Codewind project with Codewind for VS Code</a>
									
										<a href="vsc-codechange.html" class="bg-light list-group-item" data-parent="#vs_code" data-url="vsc-codechange.html">Making a code change with VS Code</a>
									
							</div>
						
					
					
					
						

							

							<a href="#eclipse" id="#eclipse" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-toggle="collapse" data-parent="#getting_started" aria-expanded="false">Eclipse<span class="submenu-icon"></span></a>

							<div class="cw-sidebar-div cw-sidebar-submenu-submenu collapse" id="eclipse">
								
									
										<a href="eclipse-getting-started.html" class="bg-light list-group-item" data-parent="#eclipse" data-url="eclipse-getting-started.html">Installing Codewind for Eclipse</a>
									
										<a href="eclipse-firstproject.html" class="bg-light list-group-item" data-parent="#eclipse" data-url="eclipse-firstproject.html">Creating your first Codewind project with Codewind for Eclipse</a>
									
										<a href="eclipse-codechange.html" class="bg-light list-group-item" data-parent="#eclipse" data-url="eclipse-codechange.html">Making a code change with Eclipse</a>
									
							</div>
						
					
					
					
						

							

							<a href="#intellij" id="#intellij" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-toggle="collapse" data-parent="#getting_started" aria-expanded="false">IntelliJ<span class="submenu-icon"></span></a>

							<div class="cw-sidebar-div cw-sidebar-submenu-submenu collapse" id="intellij">
								
									
										<a href="intellij-getting-started.html" class="bg-light list-group-item" data-parent="#intellij" data-url="intellij-getting-started.html">Installing Codewind for IntelliJ</a>
									
										<a href="intellij-firstproject.html" class="bg-light list-group-item" data-parent="#intellij" data-url="intellij-firstproject.html">Creating your first Codewind project with Codewind for IntelliJ</a>
									
										<a href="intellij-codechange.html" class="bg-light list-group-item" data-parent="#intellij" data-url="intellij-codechange.html">Making a code change with IntelliJ</a>
									
							</div>
						
					
					
				</div>
				

			

				


				

				<a href="#using_codewind_as_a_hosted_application_on_the_cloud" id="#using_codewind_as_a_hosted_application_on_the_cloud" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-toggle="collapse" aria-expanded="false">Using Codewind as a hosted application on the cloud<span class="submenu-icon"></span></a>
				<div class="cw-sidebar-div cw-sidebar-submenu collapse" id="using_codewind_as_a_hosted_application_on_the_cloud">

					
					
						
							<a href="eclipseche-codewind-overview.html" class="bg-light list-group-item" data-parent="#using_codewind_as_a_hosted_application_on_the_cloud" data-url="eclipseche-codewind-overview.html">Overview: Using Codewind as a hosted application on the cloud</a>
						
					
					
					
						

							

							<a href="#eclipse_che" id="#eclipse_che" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-toggle="collapse" data-parent="#using_codewind_as_a_hosted_application_on_the_cloud" aria-expanded="false">Eclipse Che<span class="submenu-icon"></span></a>

							<div class="cw-sidebar-div cw-sidebar-submenu-submenu collapse" id="eclipse_che">
								
									
										<a href="che-installinfo.html" class="bg-light list-group-item" data-parent="#eclipse_che" data-url="che-installinfo.html">Installing Eclipse Che for Codewind</a>
									
										<a href="che-createcodewindworkspace.html" class="bg-light list-group-item" data-parent="#eclipse_che" data-url="che-createcodewindworkspace.html">Creating a Codewind workspace in Che</a>
									
										<a href="che-setupregistries.html" class="bg-light list-group-item" data-parent="#eclipse_che" data-url="che-setupregistries.html">Adding an image registry in Codewind in Che</a>
									
										<a href="che-codechange.html" class="bg-light list-group-item" data-parent="#eclipse_che" data-url="che-codechange.html">Making a code change with Codewind for Eclipse Che</a>
									
										<a href="che-createfirstproject.html" class="bg-light list-group-item" data-parent="#eclipse_che" data-url="che-createfirstproject.html">Creating your first Codewind project with Codewind for Eclipse Che</a>
									
										<a href="che-tektonpipelines.html" class="bg-light list-group-item" data-parent="#eclipse_che" data-url="che-tektonpipelines.html">Configuring Codewind for Tekton pipelines</a>
									
										<a href="che-odo-support.html" class="bg-light list-group-item" data-parent="#eclipse_che" data-url="che-odo-support.html">OpenShift Do (odo) support in Codewind</a>
									
										<a href="openshiftregistry.html" class="bg-light list-group-item" data-parent="#eclipse_che" data-url="openshiftregistry.html">Adding the OpenShift internal registry with Codewind</a>
									
										<a href="che-uninstall.html" class="bg-light list-group-item" data-parent="#eclipse_che" data-url="che-uninstall.html">Uninstalling Codewind for Eclipse Che</a>
									
							</div>
						
					
					
				</div>
				

			

				
				<a href="remote-deploying-codewind.html" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-url="remote-deploying-codewind.html">
					Deploying Codewind remotely
				</a>
				

			

				


				

				<a href="#using_codewind_remotely" id="#using_codewind_remotely" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-toggle="collapse" aria-expanded="false">Using Codewind remotely<span class="submenu-icon"></span></a>
				<div class="cw-sidebar-div cw-sidebar-submenu collapse" id="using_codewind_remotely">

					
					
						
							<a href="remote-codewind-overview.html" class="bg-light list-group-item" data-parent="#using_codewind_remotely" data-url="remote-codewind-overview.html">Overview: Using Codewind remotely</a>
						
					
					
					
						

							

							<a href="#connecting_your_ide_to_remote_codewind" id="#connecting_your_ide_to_remote_codewind" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-toggle="collapse" data-parent="#using_codewind_remotely" aria-expanded="false">Connecting your IDE to remote Codewind<span class="submenu-icon"></span></a>

							<div class="cw-sidebar-div cw-sidebar-submenu-submenu collapse" id="connecting_your_ide_to_remote_codewind">
								
									
										<a href="remotedeploy-vscode.html" class="bg-light list-group-item" data-parent="#connecting_your_ide_to_remote_codewind" data-url="remotedeploy-vscode.html">Connecting VS Code to remote Codewind</a>
									
										<a href="remotedeploy-eclipse.html" class="bg-light list-group-item" data-parent="#connecting_your_ide_to_remote_codewind" data-url="remotedeploy-eclipse.html">Connecting Eclipse to remote Codewind</a>
									
							</div>
						
					
					
					
						
							<a href="remote-setupregistries.html" class="bg-light list-group-item" data-parent="#using_codewind_remotely" data-url="remote-setupregistries.html">Adding an image registry in remote Codewind</a>
						
					
					
					
						
							<a href="remotedeploy-projects-vscode.html" class="bg-light list-group-item" data-parent="#using_codewind_remotely" data-url="remotedeploy-projects-vscode.html">Creating and importing projects</a>
						
					
					
				</div>
				

			

				
				<a href="workingwithtemplates.html" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-url="workingwithtemplates.html">
					Working with templates
				</a>
				

			

				


				

				<a href="#developing_projects" id="#developing_projects" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-toggle="collapse" aria-expanded="false">Developing projects<span class="submenu-icon"></span></a>
				<div class="cw-sidebar-div cw-sidebar-submenu collapse" id="developing_projects">

					
					
						
							<a href="checkingstatuses.html" class="bg-light list-group-item" data-parent="#developing_projects" data-url="checkingstatuses.html">Understanding application and build statuses</a>
						
					
					
					
						
							<a href="importing-existing-projects.html" class="bg-light list-group-item" data-parent="#developing_projects" data-url="importing-existing-projects.html">Importing existing projects</a>
						
					
					
					
						
							<a href="project-actions.html" class="bg-light list-group-item" data-parent="#developing_projects" data-url="project-actions.html">Project actions</a>
						
					
					
					
						
							<a href="project-settings.html" class="bg-light list-group-item" data-parent="#developing_projects" data-url="project-settings.html">Project settings</a>
						
					
					
					
						
							<a href="referencing-files.html" class="bg-light list-group-item" data-parent="#developing_projects" data-url="referencing-files.html">Referencing files external to a project</a>
						
					
					
					
						
							<a href="private-registries.html" class="bg-light list-group-item" data-parent="#developing_projects" data-url="private-registries.html">Developing with packages from private registries and repositories</a>
						
					
					
					
						
							<a href="offline-codewind.html" class="bg-light list-group-item" data-parent="#developing_projects" data-url="offline-codewind.html">Using Codewind offline</a>
						
					
					
					
						
							<a href="debugging.html" class="bg-light list-group-item" data-parent="#developing_projects" data-url="debugging.html">Debugging in Codewind</a>
						
					
					
				</div>
				

			

				


				

				<a href="#performance_monitoring" id="#performance_monitoring" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-toggle="collapse" aria-expanded="false">Performance monitoring<span class="submenu-icon"></span></a>
				<div class="cw-sidebar-div cw-sidebar-submenu collapse" id="performance_monitoring">

					
					
						
							<a href="metrics-dashboard.html" class="bg-light list-group-item" data-parent="#performance_monitoring" data-url="metrics-dashboard.html">Understanding the Metrics Dashboard</a>
						
					
					
					
						
							<a href="performance.html" class="bg-light list-group-item" data-parent="#performance_monitoring" data-url="performance.html">Monitoring applications with the Performance Dashboard</a>
						
					
					
				</div>
				

			

				


				

				<a href="#openapi_tools" id="#openapi_tools" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-toggle="collapse" aria-expanded="false">OpenAPI Tools<span class="submenu-icon"></span></a>
				<div class="cw-sidebar-div cw-sidebar-submenu collapse" id="openapi_tools">

					
					
						
							<a href="open-api-tools-for-vscode.html" class="bg-light list-group-item" data-parent="#openapi_tools" data-url="open-api-tools-for-vscode.html">Codewind OpenAPI Tools for VS Code</a>
						
					
					
					
						
							<a href="open-api-tools-for-eclipse.html" class="bg-light list-group-item" data-parent="#openapi_tools" data-url="open-api-tools-for-eclipse.html">Codewind OpenAPI Tools for Eclipse</a>
						
					
					
				</div>
				

			

				
				<a href="troubleshooting.html" class="bg-light list-group-item list-group-item-action flex-column align-items-start" data-url="troubleshooting.html">
					Troubleshooting
				</a>
				

			
            
        </ul>
        <!-- List Group END-->
    </div>
    <!-- sidebar-container END -->
    <!-- MAIN -->
    <div id="content-container">
    		<div class="py-5 px-5">
    		    <div class="cw-docs-spacer"></div>
        		<div role="main"><!-- NOTE: The '***' before each level one title adds a line to the final output, which helps this topic to be more readable and easier to consume. -->

<h1 id="troubleshooting">Troubleshooting</h1>

<p>The following sections contain workarounds for issues that you might encounter when using Codewind. If you don’t see your issue here, please check our <a href="https://github.com/eclipse/codewind/issues">GitHub repository</a>. If you still don’t see your issue, you can open a new issue in the repository.</p>

<ul>
  <li><a href="#installing-codewind">Installing Codewind</a></li>
  <li><a href="#upgrading-codewind">Upgrading Codewind</a></li>
  <li><a href="#creating-a-project">Creating a project</a></li>
  <li><a href="#importing-a-project">Importing a project</a></li>
  <li><a href="#understanding-application-metrics">Understanding Application Metrics</a></li>
  <li><a href="#troubleshooting-project-application-and-build-statuses">Troubleshooting project application and build statuses</a></li>
  <li><a href="#editing-your-project">Editing your project</a></li>
  <li><a href="#disabling-development-on-specific-projects">Disabling development on specific projects</a></li>
  <li><a href="#appsody-with-codewind">Appsody with Codewind</a></li>
  <li><a href="#openshift-do-(odo)-with-codewind">OpenShift Do (odo) with Codewind</a></li>
  <li><a href="#okd-and-openshift">OKD and OpenShift</a></li>
  <li><a href="#codewind-and-tekton-pipelines">Codewind and Tekton pipelines</a></li>
  <li><a href="#openapi-tools">OpenAPI tools</a></li>
  <li><a href="#setting-codewind-server-log-levels">Setting Codewind server log levels</a></li>
  <li><a href="#collecting-log-files-and-environment-data">Collecting log files and environment data</a></li>
</ul>

<h2 id="ide-troubleshooting">IDE Troubleshooting</h2>

<p>The following sections contain workarounds for issues that you might encounter when using Codewind in a particular IDE.</p>

<ul>
  <li><a href="#eclipse-troubleshooting">Eclipse troubleshooting</a></li>
  <li><a href="#vs-code-troubleshooting">VS Code troubleshooting</a></li>
</ul>

<hr />
<h1 id="installing-codewind">Installing Codewind</h1>

<!--
Action/Topic: Installing Codewind
Issue type: bug/info
Issue links: https://github.com/docker/for-win/issues/1560, https://github.com/eclipse/codewind-installer/issues/35, https://github.com/eclipse/codewind-installer/issues/40
0.2.0: Still present
-->

<h2 id="installer-fails-with-mount-issues-on-windows">Installer fails with mount issues on Windows</h2>
<p>If you try to install Codewind on Windows 10 and use Docker, you might see the following error:</p>

<div class="language-sh highlighter-rouge"><div class="highlight"><pre class="highlight"><code>ERROR: <span class="k">for </span>codewind-performance  Cannot start service codewind-performance: b<span class="s2">"error while creating mount source path '/host_mnt/c/codewind-data': mkdir /host_mnt/c: file exists"</span>

ERROR: <span class="k">for </span>codewind-performance  Cannot start service codewind-performance: b<span class="s2">"error while creating mount source path '/host_mnt/c/codewind-data': mkdir /host_mnt/c: file exists"</span>
Encountered errors <span class="k">while </span>bringing up the project.
</code></pre></div></div>

<p><strong>Workaround:</strong>
Enter the following command and install again:</p>
<ol>
  <li>Enter the <code class="highlighter-rouge">docker volume rm -f /host_mnt/c</code> command.</li>
  <li>Restart Docker and run the installer again.</li>
</ol>

<p>If the command and another installation attempt don’t succeed, complete the following steps instead:</p>
<ol>
  <li>Uninstall Codewind and remove all the images with the <code class="highlighter-rouge">docker system prune -a</code> command.</li>
  <li>From the Docker settings dialog box, reset Docker to the factory default to resolve the mount issues.</li>
</ol>

<p>For more information, see <a href="https://github.com/docker/for-win/issues/1560">this issue about Docker mounts on Windows</a>.</p>

<!--
Action/Topic: Installing Codewind
Issue type: bug/info
Issue link:
18.10:
-->
<h2 id="docker-shared-drive-not-accepting-os-credentials-for-windows">Docker Shared Drive not accepting OS credentials for Windows</h2>
<p>When using OS authentication setups (for example, AzureAD), Docker Shared Drive might not accept your OS credentials.</p>

<p><strong>Workaround:</strong> Create a new user account.</p>
<ol>
  <li>Navigate to <strong>Settings</strong> -&gt; <strong>Accounts</strong> -&gt; <strong>Family &amp; other people</strong> -&gt; <strong>Add someone else to this PC</strong> -&gt; <strong>I don’t have this person’s sign-in information</strong> -&gt; <strong>Add a user without a Microsoft account</strong>.</li>
  <li>Create the new account with the same username but without the prefix (for example, if your AzureAD account is <code class="highlighter-rouge">AzureAD/BobSmith</code>, your new local account should be <code class="highlighter-rouge">BobSmith</code>). Use the same password as your other account.</li>
  <li>Select your new local account and click <strong>Change account type</strong>. Select the dropdown menu and select <strong>Administrator</strong>. Share the drive again in Docker.</li>
</ol>

<!--
Action/Topic: Installing Codewind
Issue type: bug/info
Issue link: https://github.com/eclipse/codewind/issues/436
0.6.0: Still present
-->
<h2 id="error-appears-after-installing-or-updating-codewind">Error appears after installing or updating Codewind</h2>
<p>After you install or update Codewind, an error might appear when you try to start Codewind.</p>

<p><strong>Workaround:</strong>
Remove the Codewind Docker images with your IDE:</p>
<ol>
  <li>Stop Codewind.</li>
  <li>Remove the Codewind Docker images.
    <ul>
      <li>In VS Code, use the <code class="highlighter-rouge">Remove Codewind Images</code> command.</li>
      <li>In Eclipse, use the <code class="highlighter-rouge">Uninstall</code> action.</li>
    </ul>
  </li>
</ol>

<p>If removing the images with the IDE fails, remove them with the Docker command line instead:</p>
<ol>
  <li>Stop Codewind.</li>
  <li>Use <code class="highlighter-rouge">docker image ls</code> to identify the Codewind images.</li>
  <li>Then, enter <code class="highlighter-rouge">docker image rm</code> to remove them.</li>
</ol>

<p>If installing and starting Codewind still fails, you can use Docker system prune:<br />
<strong>Caution:</strong> Docker system prune removes more than just the Codewind Docker images. It can potentially remove all of your images.</p>
<ol>
  <li>Stop Codewind.</li>
  <li>Enter the <code class="highlighter-rouge">docker system prune -a</code> command.</li>
  <li>Carefully review the list of items that Docker system prune removes. Preserve any items that you want to keep.
    <ul>
      <li>To preserve containers, start all the containers that you want to save.</li>
      <li>To preserve images, start a container from the images that you want to save.</li>
    </ul>
  </li>
  <li>After you ensure the preservation of any necessary items that Docker system prune removes, enter <code class="highlighter-rouge">y</code> to continue.</li>
</ol>

<!--
Action/Topic: Installing Codewind
Issue type: bug/info
Issue link: https://github.com/eclipse/codewind/issues/2239
0.9.0: New
-->
<h2 id="cannot-find-codewind-in-marketplace-when-attempting-to-install-in-intellij">Cannot find Codewind in Marketplace when attempting to install in IntelliJ</h2>
<p>When attempting to install Codewind in IntelliJ, you cannot locate the Codewind plug-in in Marketplace, and if you verify the custom plug-in repository link, you get a <code class="highlighter-rouge">Connection failed</code> error message:</p>

<p><img src="images/intellij/custom-plugin-repo-connection-failed-error.png" alt="intellij install error" /></p>

<p>This error occurs because the custom plug-in repository link contains an additional space.</p>

<p><strong>Workaround:</strong>
Remove the extra space from the custom plug-in repository link.</p>

<!--
Action/Topic: Installing Codewind
Issue type: bug/info
Issue link: https://github.com/eclipse/codewind/issues/2563
0.11.0: New
-->
<h2 id="without-a-keychain-or-keyring-codewind-fails-to-run-certain-commands">Without a keychain or keyring, Codewind fails to run certain commands</h2>
<p>Local and remote Codewind need to use a keychain, also called a keyring, when certain commands are used. The following error messages appear on Linux:</p>
<ul>
  <li><code class="highlighter-rouge">dbus: invalid bus address (invalid or unsupported transport)</code></li>
  <li><code class="highlighter-rouge">The name org.freedesktop.secrets was not provided by any .service files</code></li>
</ul>

<p><strong>Workaround:</strong>
<strong>Including compatible keychains</strong>
Use any keyring compatible with <code class="highlighter-rouge">go-keyring</code>, which is what Codewind uses internally. These compatible keychains are included with macOS and Windows 10, and some Linux systems include the <code class="highlighter-rouge">gnome-keyring</code> package.</p>

<p>If your Linux computer doesn’t have the <code class="highlighter-rouge">gnome-keyring</code> package, you can install <a href="https://wiki.archlinux.org/index.php/GNOME/Keyring">GNOME/Keyring</a>.</p>

<p><strong>Enabling insecure keychain mode</strong>
If you cannot install a keychain, enable insecure keychain mode. If you enable this mode, your credentials are stored in a JSON text file in the <code class="highlighter-rouge">.codewind</code> directory in your user home directory. The credentials are base64 encoded, and anyone who has access to that file can decode the credentials.</p>

<p>If you use <code class="highlighter-rouge">cwctl</code> directly, use the <code class="highlighter-rouge">--insecure-keyring</code> command line argument or set <code class="highlighter-rouge">INSECURE_KEYRING=true</code> in the environment. To get the IDE plug-ins to use the insecure keyring, set <code class="highlighter-rouge">INSECURE_KEYRING=true</code> in the environment before launching the IDE from that same environment.</p>

<!--
Action/Topic: Failed to connect to remote Codewind instance
Issue type: bug/info
Issue link: https://github.com/eclipse/codewind/issues/2863
0.12.0: New
-->
<h2 id="operator-install-failed-to-connect-to-remote-codewind-instance">Operator install failed to connect to remote Codewind instance</h2>
<p>When installing Codewind remotely, you get a <code class="highlighter-rouge">Account is not fully set up</code> error message.</p>

<p><strong>Workaround</strong>
If you have set a temporary password by clicking the <code class="highlighter-rouge">Temporary</code> check box to <code class="highlighter-rouge">On</code>, log in to Keycloak to set a new one.</p>

<p>For more information, see <a href="remote-deploying-codewind.html#3-add-a-new-user-to-keycloak">Add a new user to Keycloak</a>.</p>

<hr />
<h1 id="upgrading-codewind">Upgrading Codewind</h1>

<!--
Action/Topic: Upgrading Codewind
Issue type: bug/info
Issue links: https://github.com/eclipse/codewind/issues/2604
0.11.0: New for this release
-->

<h2 id="error-upgrading-codewind-to-the-latest">Error upgrading Codewind to the latest</h2>
<p>When upgrading Codewind from any version older than 0.9 to the latest, you see the following error:</p>

<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>==&gt; Run cwctl --json remove -t 0.8.1
Removing Codewind docker images..
System architecture is:  amd64
Host operating system is:  darwin
Please wait whilst images are removed...
.FileNotFoundError: [Errno 2] No such file or directory: '/Users/&lt;username&gt;/.codewind/docker-compose.yaml'
{"error":"IMAGE_REMOVE_ERROR","error_description":"exit status 1"}
</code></pre></div></div>

<p><strong>Workaround:</strong></p>

<p>1. Remove the Codewind images by hand. On macOS or Linux, you can remove the images with the following command:
<code class="highlighter-rouge">$ docker rmi $(docker images | grep eclipse/codewind | awk '{ print $3 }')</code></p>

<p>2. Remove the Codewind network:
<code class="highlighter-rouge">$ docker network rm &lt;codewind_network&gt;</code></p>

<p>3. Go to your IDE and click <strong>Start Local Codewind</strong>. Codewind starts.</p>

<p>4. If Codewind fails to start, you can use Docker system prune.<br />
<strong>Caution:</strong> Docker system prune removes more than just the Codewind Docker images. It can potentially remove all of your images.</p>
<ol>
  <li>Enter the <code class="highlighter-rouge">$ docker system prune -a</code> command.</li>
  <li>Carefully review the list of items that Docker system prune removes. Preserve any items that you want to keep.
    <ul>
      <li>To preserve containers, start all the containers that you want to save.</li>
      <li>To preserve images, start a container from the images that you want to save.</li>
    </ul>
  </li>
  <li>After you ensure the preservation of any necessary items that Docker system prune removes, enter <code class="highlighter-rouge">y</code> to continue.</li>
</ol>

<hr />
<h1 id="creating-a-project">Creating a project</h1>

<!--
Action/Topic: Creating a project and/or Checking the application and build statuses
Issue type: bug/info
Issue link: https://github.com/eclipse/codewind/issues/477
0.4.0: Issue still present
-->
<h2 id="project-creation-on-macos-fails-and-codewind-reports-an-error">Project creation on macOS fails, and Codewind reports an error</h2>
<p>If creating a Codewind project on macOS fails, Codewind might report the <code class="highlighter-rouge">net/http: TLS handshake timeout</code> error. For a similar issue, see the report <a href="https://discussions.agilebits.com/discussion/99219/error-net-http-tls-handshake-timeout">Error “net/http: TLS handshake timeout”</a>.</p>

<p><strong>Workaround</strong>
As noted in the report <a href="https://discussions.agilebits.com/discussion/99219/error-net-http-tls-handshake-timeout">Error “net/http: TLS handshake timeout”</a>, go to <strong>Applications</strong>&gt;<strong>Utilities</strong>&gt;<strong>Keychain Access</strong> and delete from the keychain the certificates that you no longer need. You might notice that some certificates are redundant. Then, restart Codewind.</p>

<!--
Action/Topic: Creating a project and/or Checking the application and build statuses
Issue type: bug/info
Issue link: https://github.com/eclipse/codewind/issues/829
0.5.0: Issue still present
-->
<h2 id="project-creation-fails-if-a-persistent-volume-pv-is-unavailable">Project creation fails if a persistent volume (PV) is unavailable</h2>
<p>If you try to create a project on Codewind for Eclipse Che, errors might occur if a PV is unavailable for your cluster.</p>

<p><strong>Workaround:</strong> Run the <code class="highlighter-rouge">kubectl get pv</code> command to check that a PV is available for each project that you want to create.</p>

<!--
Action/Topic: Creating a project and/or Checking the application and build statuses
Issue type: bug/info
Issue link: https://github.com/eclipse/codewind/issues/2251
0.10.0: Issue still present
-->
<h2 id="codewind-unable-to-deploy-projects-on-ibm-cloud-kubernetes-service-iks-with-kubernetes-115-and-earlier">Codewind unable to deploy projects on IBM Cloud Kubernetes Service (IKS) with Kubernetes 1.15 and earlier</h2>
<p>Codewind cannot deploy Codewind style projects with remote Codewind on IKS and Kubernetes 1.15 and earlier. The projects fail to deploy, and you see the following error:</p>
<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>Failed to pull image "&lt;image&gt;": rpc error: code = Unknown desc = failed to pull and unpack image "&lt;image&gt;": failed to unpack image on snapshotter overlayfs: failed to extract layer sha256:&lt;hash&gt;: mount callback failed on /var/lib/containerd/tmpmounts/containerd-mount799987480: archive/tar: invalid tar header: unknown
</code></pre></div></div>

<p><strong>Workaround:</strong> Upgrade to the latest version of IKS. IKS clusters that run Kubernetes 1.16 and later run a later version of containerd and are not affected by this issue.</p>

<!--
Action/Topic: Creating a project and/or Checking the application and build statuses
Issue type: bug/info
Issue link:
0.2.0: Issue still present
-->
<h2 id="codewind-che-extension-loses-connectivity-to-the-codewind-pod">Codewind Che extension loses connectivity to the Codewind pod</h2>
<p>The Codewind Che extension might lose connectivity to the Codewind pod during a Lagom or Swift project build if you have multiple projects in the workspace for each runtime type. When this issue occurs, the project tree says <strong>Disconnected</strong>.</p>

<p><strong>Workaround:</strong> Refresh the projects list to have the tree repopulate. If the issue persists, refresh the webpage.</p>

<hr />
<h1 id="importing-a-project">Importing a project</h1>

<!--
Action/Topic: Importing a project.
Issue type: bug/info
Issue link:
18.10:
-->
<h2 id="imported-project-never-builds-or-starts">Imported project never builds or starts</h2>
<p>To view the status of the imported project, enter the following command:</p>

<div class="language-sh highlighter-rouge"><div class="highlight"><pre class="highlight"><code>docker logs codewind-pfe
</code></pre></div></div>

<p><strong>Workaround:</strong> If you see the following messages, the imported project is likely not a valid Codewind project.</p>

<div class="language-sh highlighter-rouge"><div class="highlight"><pre class="highlight"><code>build-log requested, no build log found <span class="k">for </span>project &lt;project name&gt;
build-log requested, no build log found <span class="k">for </span>project &lt;project name&gt;
build-log requested, no build log found <span class="k">for </span>project &lt;project name&gt;
build-log requested, no build log found <span class="k">for </span>project &lt;project name&gt;
No containerId <span class="k">for </span>running project &lt;project name&gt;
</code></pre></div></div>

<!--
Action/Topic: Importing a project.
Issue type: bug/info
Issue link: https://github.com/eclipse/codewind/issues/243
18.10:
-->
<h2 id="adding-an-existing-open-liberty-project-fails-to-build-because-of-missing-files">Adding an existing Open Liberty project fails to build because of missing files</h2>
<p>An Open Liberty project fails to build after it is added into Codewind with the <strong>Add Existing Project</strong> action, and the project fails to build because of missing files.</p>

<p><strong>Workaround:</strong> Bind the existing project again but this time for the project type, do not accept the detected type, but instead select <strong>Other (Codewind Basic Container)</strong>.</p>

<hr />
<h1 id="understanding-application-metrics">Understanding Application Metrics</h1>

<!--
Action/Topic: Understanding application metrics
18.10: Still an issue (Toby)
-->
<h2 id="application-monitoring-unavailable-after-project-import">Application Monitoring unavailable after Project Import</h2>
<p>After importing an application, when you click <code class="highlighter-rouge">App Monitor</code>, the dashboard is not displayed and results in a <code class="highlighter-rouge">Cannot GET /appmetrics-dash/</code> error. If this error appears, the application was not created by Codewind or previously had AppMetrics integration.</p>

<p><strong>Workaround:</strong> Enable AppMetrics for your application. You can enable AppMetrics for <a href="https://developer.ibm.com/node/monitoring-post-mortem/application-metrics-node-js/">Node.js</a>, <a href="https://developer.ibm.com/swift/monitoring-diagnostics/application-metrics-for-swift/">Swift</a>, and <a href="https://github.com/RuntimeTools/javametrics#spring-boot">SpringBoot</a> projects.</p>

<!--
Action/Topic: Understanding application metrics
Issue type: info
Issue link: https://github.ibm.com/dev-ex/landing-pages/issues/923
19.03: Info added in 19.03.
-->
<h2 id="profiling-markers-do-not-appear">Profiling markers do not appear</h2>
<p>If you have the Codewind Language Server for Node.js Profiling extension enabled and have run a load test, profiling markers still might not appear. Ensure that your project and load run conform to the following requirements to use profiling:</p>
<ul>
  <li>Your project exists in Theia or VS Code. Profiling is available only in Theia and VS Code.</li>
  <li>Your project is a Node.js project that was created through Codewind.</li>
  <li>Your project has <code class="highlighter-rouge">Run Load</code> executed on it.</li>
  <li>The load run successfully completed. Profiling data is written to the <code class="highlighter-rouge">load-test/&lt;datestamp&gt;/profiling.json</code> file in your Codewind project only on a successfully completed load run. If the load run was cancelled, it won’t be written to the workspace.</li>
  <li>The load run ran for a minimum of 45 seconds to gather enough profiling data to generate the <code class="highlighter-rouge">profiling.json</code> file.</li>
  <li>If a function runs quickly, in less than 5 milliseconds with the default configuration, then the function might not run during any of the samples, so it might not be included in the profiling data for that load run.</li>
  <li>Profiling is not disabled. To enable profiling, access the profiling in one of the following ways:
    <ul>
      <li>Right-click in the editor and select <code class="highlighter-rouge">Toggle Profiling</code>.</li>
      <li>Open the command palette with <code class="highlighter-rouge">cmd+shift+p</code> on a Mac or <code class="highlighter-rouge">ctrl+shift+p</code> on Windows. Then, select <code class="highlighter-rouge">Codewind: Profiling: Toggle Profiling</code>.</li>
      <li>Toggle the <code class="highlighter-rouge">Codewind Profiling: Show Profiling</code> setting in the extensions settings.</li>
    </ul>
  </li>
</ul>

<p><strong>Workaround:</strong> Review the preceding list and ensure that your project conforms to all of the items in the list.</p>

<hr />
<h1 id="troubleshooting-project-application-and-build-statuses">Troubleshooting project application and build statuses</h1>
<!--
Action/Topic: Checking the application and build statuses
Issue type: bug
Issue link: https://github.ibm.com/dev-ex/iterative-dev/issues/459
18.10: Still an issue
-->
<h2 id="troubleshooting-general-application-status-problems">Troubleshooting general application status problems</h2>
<p>If your application goes into the <strong>Stopped</strong> state unexpectedly or stays in the <strong>Starting</strong> state longer than expected, check the project logs to see whether something went wrong. Open the build and application logs from the project’s context menu. Problems with the build or project configuration can cause the application to fail to start. There are usually errors in the log files in this case.</p>

<p>Even without errors, the <strong>Stopped</strong> state can occur if:</p>
<ul>
  <li>The <a href="project-settings.html#health-check-endpoint">health check endpoint</a> of the application is unreachable. Ensure it is set to an endpoint that is reachable.</li>
  <li>The <a href="#internal-application-port">internal application port</a> is not correct.</li>
  <li>Your application uses HTTPS but the <a href="project-settings.html#https-application">HTTPS setting</a> is not set.</li>
  <li>The time required for your application to start is longer than the <a href="#project-status-ping-timeout">Project status ping timeout</a>. Increase the timeout to a more sufficient time.</li>
</ul>

<!--
Action/Topic: Checking the application and build statuses
Issue type: bug
Issue link: https://github.ibm.com/dev-ex/iterative-dev/issues/459
18.10: Still an issue
-->
<h2 id="troubleshooting-general-build-status-problems">Troubleshooting general build status problems</h2>
<p>If your build fails, try the following:</p>
<ul>
  <li>Inspect the build logs. Open the build logs from the project’s context menu. In the build logs, you can view error messages that describe the type and cause of failure.</li>
  <li>If the build failure is related to the image build, then view the docker build log and correct any errors in the project’s Dockerfile.</li>
</ul>

<!--
Action/Topic: Creating a project or Checking the application and build statuses
Issue type: bug/info
Codewind version: 0.5.0
OS: Windows
IDE extension version: 0.5.0
IDE version: Eclipse 2019-09
Issue link: https://github.com/eclipse/codewind/issues/715
-->
<h2 id="projects-stuck-in-starting-or-stopped-state">Projects stuck in starting or stopped state</h2>
<p>You might occasionally see projects stuck in the <code class="highlighter-rouge">Starting</code> or <code class="highlighter-rouge">Stopped</code> state even though the container logs say the projects are up and running. This behavior can occur when you create a number of projects, for example, using the default and Appsody templates with Codewind 0.5.0.</p>

<p><strong>Workaround</strong> Manually rebuild the projects that are stuck in <code class="highlighter-rouge">Starting</code> or <code class="highlighter-rouge">Stopped</code> state. To do this:</p>
<ol>
  <li>In the <strong>Codewind Explorer</strong> view, right-click your project and select <strong>Build</strong>.</li>
  <li>Wait for the project state to return to <strong>Running</strong> or <strong>Debugging</strong> in the <strong>Codewind Explorer</strong> view.</li>
</ol>

<!--
Action/Topic: Checking the application status
Issue type: bug/info
Codewind version: 0.9.0
Issue link: https://github.com/eclipse/codewind/issues/1269
-->
<h2 id="application-stuck-in-starting-state">Application stuck in Starting state</h2>
<p>Some project templates come with no server configured by default, like Appsody Node.js. The application status cannot be determined for these types of projects because Codewind relies on application endpoints for status. Codewind determines the port of the application by inspecting the project’s container information. The container may have a port exposed but since no server is available to ping on that port, the status check times out, and the state is stuck on <code class="highlighter-rouge">Starting</code>.</p>

<p><strong>Workaround</strong> The constant state is not inherently a problem; nonetheless, you can disable the status check for the project by taking the following steps:</p>
<ol>
  <li>Edit the <code class="highlighter-rouge">.cw-settings</code> file under the application, and set the key <code class="highlighter-rouge">internalPort</code> to <code class="highlighter-rouge">-1</code>.
    <ul>
      <li>This forces the project state to <code class="highlighter-rouge">Stopped</code>, stops pinging the project’s health check endpoint, and ignores the timeout error.</li>
    </ul>
  </li>
  <li>Once you implement the project’s server, revert the setting by setting <code class="highlighter-rouge">internalPort</code> to <code class="highlighter-rouge">""</code> to allow Codewind to use the default port of the container. Alternatively, choose a specific port if your container exposes multiple ports.</li>
</ol>

<!--
Action/Topic: Checking the application status
Issue type: bug/info
Codewind version: 0.9.0
Issue link: https://github.com/eclipse/codewind/issues/1269
-->
<h2 id="how-to-create-a-cw-settings-file-if-it-does-not-exist">How to create a .cw-settings file if it does not exist</h2>
<p>Prior to the 0.9.0 release, some Appsody and OpenShift Do (odo) templates did not come with a <code class="highlighter-rouge">.cw-settings</code>. The <code class="highlighter-rouge">.cw-settings</code> file is usually created automatically and tells Codewind how to interact with a project. Things like application and build status are tied to these settings. If you have a project from those stacks from a previous release, you must manually create the .cw-settings file. The file must reside under the project root directory.</p>

<p><strong>Workaround</strong> Create a template .cw-settings file with the following contents:</p>

<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>{
"contextRoot": "",
"internalPort": "",
"healthCheck": "",
"isHttps": false,
"ignoredPaths": [
""
]
}
</code></pre></div></div>

<!--
Action/Topic: Changing the max number of concurrent builds
Issue type: info
Codewind version: 0.9.0
-->
<h2 id="adjusting-the-maximum-number-of-concurrent-builds">Adjusting the maximum number of concurrent builds</h2>
<p>It is not recommended to alter this value because there can be a significant impact on performance but in some cases it may be necessary. For example, if there aren’t enough resources to run 3 builds concurrently, you can reduce the maximum number to 1 or 2. If you must adjust the maximum number of concurrent builds, you can set the <code class="highlighter-rouge">MC_MAX_BUILDS</code> environmental variable in the <code class="highlighter-rouge">codewind-pfe</code> container.</p>

<!--
Action/Topic: Creating a project and/or Checking the application and build statuses
Issue type: bug/info
Codewind version: 0.6.0
Issue link: https://github.com/eclipse/codewind/issues/1039
-->
<h2 id="projects-build-twice-upon-creation">Projects build twice upon creation</h2>
<p>If you use Codewind on Eclipse and VS Code at the same time, projects build twice during project creation, resulting in longer project creation time.</p>

<p><strong>Workaround:</strong> To reduce project creation time, do not use Codewind on Eclipse and on VS Code at the same time. Close either Eclipse or VS Code, then create your project.</p>

<!--
Action/Topic: Checking the application and build statuses
Issue type: bug
Issue link: https://github.ibm.com/dev-ex/iterative-dev/issues/459
18.10: Still an issue
-->
<h2 id="microprofile-project-gets-updated-twice-upon-file-change">MicroProfile project gets updated twice upon file change</h2>
<p>If you modify files in MicroProfile projects, sometimes the project gets double updates. You might see the application status changed from <strong>Running</strong> to <strong>Stopped</strong> twice. If you notice this status change, the default polling rate, which is 500 ms, is too short for the application monitor.</p>

<p><strong>Workaround:</strong> Increase the polling rate in the <code class="highlighter-rouge">server.xml</code> file to 1000 ms or longer.</p>

<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;applicationMonitor</span> <span class="na">pollingRate=</span><span class="s">"1000ms"</span> <span class="nt">/&gt;</span>
</code></pre></div></div>

<hr />
<h1 id="editing-your-project">Editing your project</h1>

<!--
Action/Topic: Editing your project
Issue type: bug
Issue link: https://github.ibm.com/dev-ex/theia/issues/3
18.10: Still an issue
-->
<h2 id="che-editor-might-not-work-correctly-in-microsoft-edge">Che editor might not work correctly in Microsoft Edge</h2>
<p>Theia, the open source code editor used by Che, currently has limited support for Microsoft Edge. The Theia team is aware of the issue and is working to fix it.</p>

<p><strong>Workaround:</strong> Use a different web browser.</p>

<!--
Action/Topic: Editing your project
Issue type: bug/info
Issue link:
18.10:
-->
<h2 id="new-projects-sometimes-do-not-show-in-che-hierarchy-view">New projects sometimes do not show in Che hierarchy view</h2>
<p>Sometimes when a new project is created, it doesn’t show up in the hierarchy view within Eclipse Che.</p>

<p><strong>Workaround:</strong> Refresh the page in the browser.</p>

<!--
Action/Topic: Creating a project and/or Checking the application and build statuses
Issue type: bug/info
Issue link: Updated in https://github.com/eclipse/codewind/issues/2613
0.11.0: Updated for this release.
-->
<h2 id="context-root--application-endpoint-not-correct">Context Root / Application Endpoint not correct</h2>
<p>If you create or bind a project that has a context root set in <code class="highlighter-rouge">.cw-settings</code>, such as a project using the Lagom template, the context root is not picked up initially. This also happens after restarting Codewind.</p>

<p><strong>Workaround</strong> For a permanent fix, edit and save the <code class="highlighter-rouge">.cw-settings</code> file, and the context root updates. For a temporary workaround, add the context root to the URL in your browser. For example, the browser might open with <code class="highlighter-rouge">localhost:34567</code> instead of <code class="highlighter-rouge">localhost:34567/mycontextroot</code>, so type <code class="highlighter-rouge">mycontextroot</code>.</p>

<hr />
<h1 id="disabling-development-on-specific-projects">Disabling development on specific projects</h1>

<!--
Action/Topic: Disabling development on specific projects
Issue type: bug/info
Issue link:
18.10:
-->
<h2 id="turning-off-auto-build-has-no-effect-for-nodejs-projects-when-you-run-codewind-locally">Turning off auto build has no effect for Node.js projects when you run Codewind locally</h2>
<p>If you turn off <code class="highlighter-rouge">auto build</code> for a Node.js project when you run Codewind locally, it has no effect. Changes you make to your code automatically start or restart a build even though <code class="highlighter-rouge">auto build</code> is disabled.</p>

<hr />
<h1 id="appsody-with-codewind">Appsody with Codewind</h1>

<!--
Action/Topic: Creating a project and/or Checking the application and build statuses
Issue type: bug/info
Issue link:
18.10:
-->
<h2 id="projects-created-never-start-after-installing-codewind">Projects created never start after installing Codewind</h2>
<p>Intermittently, after installing Codewind on Windows, projects can be created, but they never start and instead remain in the <strong>Starting</strong> state. A Docker issue for Windows exists where, although it shows a volume is mounted, it does not allow any writing to the volume. To check if this issue is present, verify that a <code class="highlighter-rouge">codewind-data</code> directory exists in the root of your <code class="highlighter-rouge">C:</code> drive on Windows and verify you can see your Appsody project folders created within.</p>

<p><strong>Workaround:</strong> This issue can appear for many reasons, so you have many possible workarounds. First, open the <code class="highlighter-rouge">Docker\Settings\Shared Drives</code> directory to confirm that your <code class="highlighter-rouge">C:</code> drive is selected. If it is not selected, select it, click <strong>Apply</strong>, and then try creating projects again. If you’re still noticing the problem, and you’re using an ID for the shared drive that is not your current user, check that the ID being used doesn’t have an expired password that requires a password reset. Reset the password if necessary.</p>

<!--
Action/Topic: Appsody with Codewind
Issue type: bug/info
Issue link: https://github.com/eclipse/codewind/issues/498
18.10:
-->
<h2 id="appsody-and-docker-desktop-on-windows-10">Appsody and Docker Desktop on Windows 10</h2>
<p>When you use Appsody, configure Docker Desktop to access your <code class="highlighter-rouge">C:</code> drive that contains your <code class="highlighter-rouge">codewind-data</code> directory. In most cases, you can configure Docker with the same user as the user who develops applications with Appsody. However, if you use Windows 10 Enterprise secured with Azure Active Directory (AAD), the AAD user does not reside in the localhost and might not be accepted in the <strong>Shared Drives</strong> tab of the Docker Desktop <strong>Settings</strong> page, especially if the organization configured AAD to issue only PIN codes instead of user passwords.</p>

<p><strong>Workaround</strong> Complete the instructions in <a href="https://github.com/gcharters/kabanero-dev-getting-started/blob/master/docker-windows-aad.md">Special notes about Appsody and Docker Desktop on Windows 10</a>.</p>

<!--
Action/Topic: Appsody with Codewind
Issue type: bug/info
Issue link: https://github.com/eclipse/codewind-docs/issues/64
18.10:
-->
<h2 id="nodejs-and-swift-templates-remain-in-the-starting-state">Node.js and Swift templates remain in the starting state</h2>
<p>The templates <code class="highlighter-rouge">Appsody Node.js template</code> and <code class="highlighter-rouge">Appsody Swift template</code> remain in the starting state by default because these templates do not have a server implemented, and therefore, their statuses cannot be detected. These templates do not have a server and are intended to help you implement your own server.</p>

<p><strong>Workaround</strong> To get the application into a <strong>Started</strong> state, use a server for the application. After the application has a server, Codewind monitors the server, and the status turns to <strong>Started</strong> if the server is running. Alternatively, you can also temporarily <a href="#how-to-stop-the-app-from-continuously-pinging">stop Codewind from continuously pinging the application</a>.</p>

<!--
Action/Topic: Appsody with Codewind
Issue type: bug/info
Issue link:
-->
<h2 id="kafka-templates-remain-in-the-starting-state">Kafka templates remain in the starting state</h2>

<p>The <code class="highlighter-rouge">Kafka</code> templates for the Appsody <code class="highlighter-rouge">Quarkus</code> and <code class="highlighter-rouge">Spring Boot</code> application stacks remain in the starting state when you create a project using them. These projects require users to configure a Kafka instance to connect to in order to run correctly. Additionally, these projects do not expose an endpoint at the <code class="highlighter-rouge">/</code> path that Codewind attempts to ping because these projects are not meant to be REST-style applications.</p>

<p><strong>Workaround</strong> Refer to the documentation for the respective stacks to find out how to configure a Kafka instance to work with the applications:</p>

<ul>
  <li><a href="https://github.com/appsody/stacks/tree/master/incubator/quarkus#kafka-template">Quarkus</a></li>
  <li><a href="https://github.com/appsody/stacks/tree/master/incubator/java-spring-boot2/templates/kafka">Spring Boot</a></li>
</ul>

<p>You should also <a href="project-settings.html#health-check-endpoint">configure the project’s health check endpoint</a> for Codewind to ping instead of the <code class="highlighter-rouge">/</code> path.</p>

<p>Alternatively, you can also temporarily <a href="#how-to-stop-the-app-from-continuously-pinging">stop Codewind from continuously pinging the application</a>.</p>

<!--
Action/Topic: Appsody with Codewind
Issue type: bug/info
Issue link: https://github.com/eclipse/codewind-docs/issues/64
18.10:
-->
<h2 id="an-unknown-error-appears-on-line-one-of-the-pomxml-file">An Unknown error appears on line one of the pom.xml file</h2>
<p>If you use an Eclipse IDE for Enterprise Developer EPP prior to version 2019.06, you might see an <code class="highlighter-rouge">Unknown</code> validation error in the <code class="highlighter-rouge">pom.xml</code> file.</p>

<p><strong>Workaround</strong> Switch to version 2019.06 or later, or see <a href="https://bugs.eclipse.org/bugs/show_bug.cgi?id=547340">Cannot import any project into Eclipse with maven-jar-plugin 3.1.2</a>.</p>

<!--
Action/Topic: Appsody with Codewind
Issue type: bug/info
Issue link: https://github.com/eclipse/codewind-docs/issues/64
18.10:
-->
<h2 id="classpath-warnings-appear-or-the-application-classes-are-not-on-the-classpath">Classpath warnings appear or the application classes are not on the classpath</h2>
<p>If you work with Appsody projects in Codewind for VS Code, you might encounter <code class="highlighter-rouge">Classpath is incomplete</code> warnings or notifications that application classes are not on the classpath.</p>

<p><strong>Workaround</strong> Add the project’s parent folder to the VS Code workspace.</p>
<ol>
  <li>After you create an Appsody Java MicroProfile project, right-click and <code class="highlighter-rouge">Add Project to Workspace</code> if it is not already added.</li>
  <li>Right-click on the project from the workspace view and select <strong>Add Folder to Workspace…</strong> and choose the parent folder of the project. Click <code class="highlighter-rouge">Add</code>.</li>
  <li>Choose the project folder and click <strong>Add</strong>.</li>
</ol>

<!--
Action/Topic: Appsody with Codewind
Issue type: bug/info
Issue link: https://github.com/eclipse/codewind-docs/issues/64 and https://github.com/eclipse/codewind/issues/239
18.10:
-->
<h2 id="starting-in-debug-mode-results-in-failure-to-attach-the-debugger">Starting in debug mode results in failure to attach the debugger</h2>
<p>If you work with Appsody projects in Codewind, and if you restart the project in debug mode, the first attempt to attach the debugger might fail.</p>

<p><strong>Workaround</strong> Run the <code class="highlighter-rouge">Attach Debugger</code> action manually. The following sample steps show instructions for VS Code. The steps to manually attach the debugger in other IDEs is similar:</p>
<ol>
  <li>After you create a project, wait for VS Code to display the project’s state as <strong>Running</strong>.</li>
  <li>Then, right-click the project and select <strong>Restart in Debug Mode</strong>.</li>
  <li>Allow the process to finish. It fails, and a connection exception window appears.</li>
  <li>The <code class="highlighter-rouge">Restarting &lt;my_project&gt; into debug mode</code> message is displayed. Wait for this restart notification to disappear.</li>
  <li>To manually set the debugger, click the <strong>Debug</strong> tab and then <strong>Play</strong>. The debugger is successfully attached to the project if <code class="highlighter-rouge">Debug &lt;my_project&gt;</code> is displayed in the message bar or if the project’s state shows <strong>Debugging</strong>.</li>
</ol>

<!--
Codewind version: 0.6.0
Action/Topic: Appsody with Codewind
Issue type: bug/info
Issue link: https://github.com/eclipse/codewind/issues/1061
-->
<h2 id="appsody-binds-fail">Appsody binds fail</h2>

<p>If an Appsody repository is already added in your local Appsody CLI, the Appsody bind might fail.</p>

<p>These steps create the issue:</p>
<ol>
  <li>The Appsody repository was added to your local Appsody CLI. The same Appsody repository was then added to Codewind from your IDE by right-clicking <strong>Projects (Local)</strong> and then clicking <strong>Manage Template Sources</strong>.</li>
  <li>Later, a project was bound to a stack from the added Appsody repository. The project appears in the Codewind Explorer view, and the <code class="highlighter-rouge">appsody.log</code> displays this error:
    <div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>[Error] The current directory is not a valid appsody project. Run `appsody init &lt;stack&gt;` to create one. Run `appsody list` to see the available stacks.
</code></pre></div>    </div>
    <p>Codewind displays an error. In VS Code, the error appears in the Codewind log:</p>
    <div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>2019/11/08 11:07:29 Please wait while the command runs...
2019/11/08 11:07:31 [Error] Repository 77b94c9b-0daf-5426-98b8-83eb8ee63e3c is not in configured list of repositories
</code></pre></div>    </div>
  </li>
</ol>

<p><strong>Workaround</strong></p>
<ol>
  <li>Remove the repository from the local Appsody CLI. For example, run the <code class="highlighter-rouge">appsody repo remove</code> command.</li>
  <li>Remove and add the repository back into Codewind with <strong>Manage Template Sources</strong>.</li>
  <li>Rebind the project to Codewind.</li>
</ol>

<!--
Codewind version: 0.9.0
Action/Topic: Appsody with Codewind
Issue type: bug/info
Issue link: https://github.com/eclipse/codewind/issues/938
-->
<h2 id="using-appsody-stacks-images-from-private-docker-registries">Using Appsody stacks images from private Docker registries</h2>

<p><strong>Local scenario</strong>
For Codewind to work with an Appsody stack image on a private Docker registry, the stack must fully qualify the image name in the <code class="highlighter-rouge">.appsody-config.yaml</code> configuration of its template, for example: <code class="highlighter-rouge">hostname[:port]/username/reponame[:tag]</code>. Also, before you work with the stack, on the local system, enter <code class="highlighter-rouge">docker login</code> to the private registry.</p>
<ul>
  <li><strong>Note:</strong> When you view the application log, you might see failures to pull the image during a rebuild. However, Codewind is taking the cached container image from your local machine. If you ever delete that image, you need to pull the image again. You can either create another project from the same stack or manually call a <code class="highlighter-rouge">docker pull</code> with the required image.</li>
</ul>

<p><strong>Remote scenario</strong>
Follow the instructions in <a href="che-setupregistries.html">Adding a container registry in Codewind</a>.</p>

<!--
Codewind version: 0.9.0
Action/Topic: Appsody with Codewind
Issue type: bug/info
Issue link: https://github.com/eclipse/codewind/issues/2455
-->
<h2 id="open-liberty-projects-do-not-start-within-the-default-timeout">Open Liberty projects do not start within the default timeout</h2>

<p>Occasionally, Appsody Open Liberty projects do not start, and you see the following entries in the <code class="highlighter-rouge">appsody.log</code>:</p>

<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>[Container] [INFO] CWWKM2010I: Searching for CWWKF0011I: in /opt/ol/wlp/usr/servers/defaultServer/logs/messages.log. This search will timeout after 120 seconds.
[Container] [INFO] CWWKM2013I: The file /opt/ol/wlp/usr/servers/defaultServer/logs/messages.log being validated does not exist.
...
[Container] [INFO] CWWKM2011E: Timed out searching for CWWKF0011I: in /opt/ol/wlp/usr/servers/defaultServer/logs/messages.log.
...
[Container] [ERROR] Failed to execute goal io.openliberty.tools:liberty-maven-plugin:3.2:dev (default-cli) on project starter-app: Unable to verify if the server was started after 120 seconds.  Consider increasing the serverStartTimeout value if this continues to occur. -&gt; [Help 1]
</code></pre></div></div>

<p>By default, Open Liberty projects are configured to wait 2 minutes (120 seconds) for the server to start. These messages are an indication that the server did not start within the default timeout period.</p>

<p><strong>Workaround</strong></p>

<p>Increase the timeout value in the project’s <code class="highlighter-rouge">pom.xml</code> file. Look for the following element and increase the value:</p>

<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>&lt;serverStartTimeout&gt;120&lt;/serverStartTimeout&gt;
</code></pre></div></div>

<hr />
<h1 id="openshift-do-odo-with-codewind">OpenShift Do (odo) with Codewind</h1>

<p>For more information about the OpenShift Do (odo) extension in Codewind, see the <a href="https://github.com/eclipse/codewind-odo-extension">README</a> file in the <code class="highlighter-rouge">codewind-odo-extension</code> repository.</p>

<!--
Action/Topic: OpenShift Do (odo) with Codewind
Issue type: bug/info
Issue link: https://github.com/eclipse/codewind/issues/1514
-->
<h2 id="building-an-odo-project-fails-because-of-an-existing-image-stream">Building an odo project fails because of an existing image stream</h2>
<p>If you try to create an image stream that already exists in your cluster and then build an odo project, you might receive error messages in the build log:</p>
<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>Failed to create component with name &lt;component name&gt;. Please use odo config view to view settings used to create component. Error: imagestreams.image.openshift.io "&lt;image stream name&gt;" already exists unable to create ImageStream for &lt;image stream name&gt;
</code></pre></div></div>

<p><strong>Workaround:</strong></p>
<ol>
  <li>Run <code class="highlighter-rouge">kubectl get is</code> to get the existing image stream.</li>
  <li>Run <code class="highlighter-rouge">kubectl delete is &lt;existing image stream name&gt;</code> to manually delete the existing image stream.</li>
</ol>

<hr />
<h1 id="okd-and-openshift">OKD and OpenShift</h1>
<!--
Codewind version: 0.5.0
OS: RHEL
Che version: 7.2.0
IDE extension version: 0.5.0
IDE version: 7.1.0
Kubernetes cluster: OKD/OpenShift
Action/Topic:
Issue type: bug/info
Issue link: https://github.com/eclipse/codewind/issues/733
-->
<h2 id="plugin-runtime-crashes-unexpectedly-and-all-plugins-are-not-working">Plugin runtime crashes unexpectedly and all plugins are not working</h2>
<p>With the latest Eclipse Che Version 7.2, you might see the following error when your user session expires for the Eclipse Che workspace: <code class="highlighter-rouge">Plugin runtime crashed unexpectedly, all plugins are not working, please reload ...</code></p>

<p>These steps reproduce the issue:</p>
<ol>
  <li>Install Eclipse Che on an OKD cluster.</li>
  <li>Create your Codewind workspace from this <a href="https://raw.githubusercontent.com/eclipse/codewind-che-plugin/master/devfiles/0.5.0/devfile.yaml">devfile</a>.</li>
  <li>After your session expires, you see a <code class="highlighter-rouge">Crash</code> message in the Codewind workspace.
<strong>Workaround</strong> Go to the <code class="highlighter-rouge">Che workspace</code> dashboard, log out of the Che workspace, and then log back in to the Che workspace. Access the Codewind workspace.</li>
</ol>

<!--
Codewind version: 0.8.0
OS: RHEL
Che version: 7.5.1
IDE extension version: 0.8.0
IDE version: 7.5.1
Kubernetes cluster: Red Hat OpenShift on IBM Cloud
Action/Topic:
Issue type: bug/info
Issue link: https://github.com/eclipse/codewind/issues/1806
-->
<h2 id="che-sometimes-fails-to-reinstall-successfully-on-red-hat-openshift-on-ibm-cloud">Che sometimes fails to reinstall successfully on Red Hat OpenShift on IBM Cloud</h2>
<p>Sometimes when Che is reinstalled on Red Hat OpenShift on IBM Cloud, the installation might fail with the following error:</p>
<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code> ✔ Create Che Cluster eclipse-che in namespace che...done.
  ❯ ✅  Post installation checklist
    ❯ PostgreSQL pod bootstrap
      ✔ scheduling...done.
      ✔ downloading images...done.
      ✖ starting
        → ERR_TIMEOUT: Timeout set to pod ready timeout 130000
</code></pre></div></div>

<p>This error appears because of permissions issues in the namespace.</p>

<p><strong>Workaround:</strong> To resolve the error, install Che into a namespace other than <code class="highlighter-rouge">che</code> with the <code class="highlighter-rouge">--chenamespace</code> flag when running <code class="highlighter-rouge">chectl server:start</code>.</p>

<hr />
<h1 id="codewind-and-tekton-pipelines">Codewind and Tekton Pipelines</h1>

<!--
Codewind version: 0.3
Che version: 7.0
IDE extension version: Theia plugin 0.3
IDE version: Theia 7.0-rc4
Action/Topic: Codewind and Tekton pipelines
Issue type: bug/info
Issue link: https://github.com/eclipse/codewind/issues/309
-->
<h2 id="codewind-cannot-access-the-tekton-dashboard-url">Codewind cannot access the Tekton dashboard URL</h2>

<p>If you install Codewind before you install Tekton, Codewind cannot access the Tekton dashboard URL. In the logs, you see the following error message:</p>

<div class="language-sh highlighter-rouge"><div class="highlight"><pre class="highlight"><code>Tekton dashboard does not appear to be installed on this cluster. Please <span class="nb">install </span>Tekton dashboard on your cluster, and restart your Codewind Che workspace.
</code></pre></div></div>

<p>These steps reproduce the issue:</p>
<ol>
  <li>Install Codewind on OpenShift.</li>
  <li>Install Tekton Pipelines.</li>
  <li>Click <strong>Open Tekton dashboard URL</strong>. Codewind does not access the Tekton dashboard URL.</li>
</ol>

<p><strong>Workaround:</strong></p>
<ol>
  <li>Go to the Eclipse Che workspace console.</li>
  <li>Select your workspace and stop it.</li>
  <li>After 2 minutes, start your workspace again.</li>
  <li>Now, access the Tekton dashboard URL from the Codewind palette.</li>
</ol>

<hr />
<h1 id="openapi-tools">OpenAPI tools</h1>

<!--
Action/Topic: OpenAPI tools
Issue type: bug/info
Issue link: https://github.com/eclipse/codewind/issues/275
Version: 2019-06 (4.12.0)
Build ID: 20190614-1200
-->
<h2 id="openapi-generation-fails-in-eclipse-if-the-output-path-does-not-exist">OpenAPI generation fails in Eclipse if the output path does not exist</h2>
<p>In Eclipse, OpenAPI generation fails if a path does not exist, and the wizard doesn’t automatically create the folder tree hierarchy if the hierarchy doesn’t already exist.</p>

<p>These steps reproduce the issue:</p>
<ol>
  <li>Install the latest version of Codewind.</li>
  <li>Add a sample OpenAPI <code class="highlighter-rouge">.yaml</code> file.</li>
  <li>From the Project or Package Explorer views, right-click the project and select one of the generator actions in <strong>OpenAPI Generate</strong>. A dialog window appears.</li>
  <li>In the dialog window, if necessary, select the OpenAPI definition file by clicking the <strong>Browse…</strong> button.</li>
  <li>In the <strong>Output folder</strong> field, copy and paste a path or edit the path directly.</li>
  <li>Click <strong>Finish</strong>. The OpenAPI generator fails if the folder doesn’t already exist.</li>
</ol>

<p><strong>Workaround:</strong>
For the VS Code extension, manually create the output folder before you start the OpenAPI generator wizard. In the wizard, you can also create the <strong>Output folder</strong> in the browse dialog. Ensure that the path points to a valid folder in the project.</p>

<p>For post-client or post-server stub generation, use a separate output folder for code generation. Depending on the language and the generator type, the OpenAPI generator generates both source code files and build-related files. Some refactoring might be necessary. For example, move the generated source code to the proper source folder that already exists in the project. However, if your project is empty, the target output folder can be the root of the project, and you don’t need to do as much refactoring and merging.</p>

<p>For Eclipse, for Java-based code generators, the Open API wizards provide additional support to configure the project. It is recommended that the project’s root folder is selected as the output folder of the generator so that <code class="highlighter-rouge">.java</code> files will be generated into the existing <code class="highlighter-rouge">src/main/java</code> and <code class="highlighter-rouge">src/test/java</code> folders. The wizard’s default value of the output folder is the project’s root folder. The wizard also performs some automatic configuration, including <code class="highlighter-rouge">pom.xml</code> file merging, and necessary updates to the project’s classpath.</p>

<!--
Action/Topic: Plugin execution validation error in the pom.xml file for Open API tools
Issue type: bug
Issue link: https://github.com/eclipse/codewind/issues/650
0.5.0: New issue
-->
<h2 id="plugin-execution-validation-error-in-the-pomxml-file">Plugin execution validation error in the pom.xml file</h2>
<p>When generating a Java client or server stub into an existing Appsody or Codewind Liberty Microprofile project, you might see a plugin execution validation error in the <code class="highlighter-rouge">pom.xml</code> file:</p>

<div class="language-sh highlighter-rouge"><div class="highlight"><pre class="highlight"><code>Plugin execution not covered by lifecycle configuration: org.codehaus.mojo:aspectj-maven-plugin:1.0:compile <span class="o">(</span>execution: default, phase: process-classes<span class="o">)</span>
</code></pre></div></div>

<p>The build is successful even though the validator reports this issue.</p>

<p><strong>Workaround:</strong> To resolve this in Eclipse, surround the plugins element under the <code class="highlighter-rouge">build</code> element of the <code class="highlighter-rouge">pom.xml</code> file with the <code class="highlighter-rouge">pluginManagement</code> element.</p>

<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;build&gt;</span>
    <span class="nt">&lt;pluginManagement&gt;</span>
        <span class="nt">&lt;plugins&gt;</span>
        ...
</code></pre></div></div>

<p>The following workaround applies to Eclipse. Add the configuration element to the <code class="highlighter-rouge">pom.xml</code> file:</p>

<div class="language-xml highlighter-rouge"><div class="highlight"><pre class="highlight"><code><span class="nt">&lt;build&gt;</span>
    <span class="nt">&lt;plugins&gt;</span>
        <span class="nt">&lt;plugin&gt;</span>
            <span class="nt">&lt;groupId&gt;</span>org.springframework.boot<span class="nt">&lt;/groupId&gt;</span>
                <span class="nt">&lt;artifactId&gt;</span>spring-boot-maven-plugin<span class="nt">&lt;/artifactId&gt;</span>
                <span class="nt">&lt;configuration&gt;</span>
                    <span class="nt">&lt;mainClass&gt;</span>org.openapitools.OpenAPI2SpringBoot<span class="nt">&lt;/mainClass&gt;</span>
                <span class="nt">&lt;/configuration&gt;</span>
                ....
</code></pre></div></div>

<hr />
<h1 id="setting-codewind-server-log-levels">Setting Codewind server log levels</h1>

<!--
Action/Topic: Setting Codewind server log levels
Issue type: info
Issue link: https://github.com/eclipse/codewind/issues/1251
Info added in 0.10.0.
-->
<h2 id="assisting-with-problem-determination-by-raising-the-default-codewind-server-log-level">Assisting with problem determination by raising the default Codewind server log level</h2>
<p>To assist with problem determination, raise the default Codewind server log level to <strong>Debug</strong> or <strong>Trace</strong>. Use the <code class="highlighter-rouge">cwctl loglevels</code> command or follow the instructions for an IDE:</p>
<ul>
  <li>In Eclipse, enable support features in the Codewind preferences, then right-click the connection in the Codewind Explorer view and click <strong>Codewind server log level</strong>.</li>
  <li>In IntelliJ, go to the <strong>Debug Log Settings</strong> dialog and enable the <code class="highlighter-rouge">org.eclipse.codewind</code> category so Codewind diagnostic debug and trace messages are written to the log. The <code class="highlighter-rouge">#org.eclipse.codewind</code> method turns on debug level messages, and the <code class="highlighter-rouge">#org.eclipse.codewind:trace</code> method turns on trace level messages.</li>
  <li>In VS Code, use the <strong>Codewind: Set Codewind Server Logging Level</strong> command in the Command Palette.</li>
</ul>

<hr />
<h1 id="collecting-log-files-and-environment-data">Collecting log files and environment data</h1>
<!--
Action/Topic: Collecting log files and environment data
Issue type: info
Issue link: https://github.com/eclipse/codewind/issues/2766
Info added in 0.12.0.
-->

<p>You can capture diagnostics from your installation by using the <code class="highlighter-rouge">cwctl diagnostics</code> CLI command to collect all available log files and environment information. You can find the <code class="highlighter-rouge">cwctl</code> CLI in your HOME directory under the <code class="highlighter-rouge">~/.codewind/&lt;version&gt;</code> path.</p>

<p>The format of the command is: 
<code class="highlighter-rouge">cwctl diagnostics [command options] [arguments...]</code></p>

<p>Command options are:</p>
<ul>
  <li><code class="highlighter-rouge">--conid &lt;value&gt;</code> - Triggers diagnostics collection for the remote codewind instance (<em>must</em> have currently configured Kubectl connection, default:”local”)</li>
  <li><code class="highlighter-rouge">--eclipseWorkspaceDir/-e &lt;value&gt;</code> - The location of your Eclipse workspace directory if using the Eclipse IDE, default:””)</li>
  <li><code class="highlighter-rouge">--intellijLogsDir/-i &lt;value&gt;</code> - The location of your IntelliJ logs directory if using the IntelliJ IDE (default: “”)</li>
  <li><code class="highlighter-rouge">--quiet/-q</code> - Turn off console messages</li>
  <li><code class="highlighter-rouge">--projects/-p</code> - Collect project containers information</li>
  <li><code class="highlighter-rouge">--nozip/-n</code> - Does not create collection zip and leaves individual collected files in place</li>
  <li><code class="highlighter-rouge">--clean</code> - Removes the <code class="highlighter-rouge">diagnostics</code> directory and all its contents from the Codewind home directory</li>
</ul>

<p>After you run the command, you can find the captured diagnostics files under your <code class="highlighter-rouge">HOME</code> directory in the <code class="highlighter-rouge">~/.codewind/diagnostics/&lt;timestamp&gt;</code> folder.</p>

<p>For more information about the <code class="highlighter-rouge">cwctl diagnostics</code> command, type <code class="highlighter-rouge">cwctl help diagnostics</code>, or see the <a href="https://github.com/eclipse/codewind-installer/blob/master/README.md#diagnosticsdg">diagnosticsCli documentation</a>.</p>

<!--
Action/Topic: Reinstate IDE specific troubleshooting help (Eclipse, VS Code and Che)
Issue type: info
Issue link: https://github.com/eclipse/codewind/issues/2633
Information reinstated in 0.12.0.
-->

<hr />
<h1 id="eclipse-troubleshooting">Eclipse troubleshooting</h1>

<p>For Codewind specific problem solving tips when using Eclipse, see the following information.</p>

<ul>
  <li><a href="#check-the-eclipse-logs">Check the Eclipse logs</a></li>
  <li><a href="#solving-common-eclipse-problems">Solving common Eclipse problems</a></li>
</ul>

<h2 id="check-the-eclipse-logs">Check the Eclipse logs</h2>
<p>The logs are found in your Eclipse workspace under <em>.metadata/.log</em>.</p>

<h2 id="solving-common-eclipse-problems">Solving common Eclipse problems</h2>
<p>The following list describes common problems that might affect Codewind.</p>

<ul>
  <li><a href="#open-application-fails">Open application fails</a></li>
  <li><a href="#debugger-fails-to-connect">Debugger fails to connect</a></li>
  <li><a href="#application-stuck-in-starting-state-in-eclipse">Application stuck in Starting state</a></li>
  <li><a href="#application-does-not-rebuild-after-making-a-change">Application does not rebuild after making a change</a></li>
  <li><a href="#correct-project-list-is-not-being-shown">Correct project list is not being shown</a></li>
  <li><a href="#application-is-not-showing-the-correct-status">Application is not showing the correct status</a></li>
</ul>

<h2 id="open-application-fails">Open application fails</h2>
<p>The default browser in Eclipse might not be able to handle the content of your application.  Try using a different browser by clicking on <strong>Window</strong> &gt; <strong>Web Browser</strong>.  Select a browser from the list and try to open the application again.</p>

<h2 id="debugger-fails-to-connect">Debugger fails to connect</h2>
<p>If the debugger fails to connect, you might need to increase the connection timeout:</p>
<ol>
  <li>Open the Eclipse preferences and select <strong>Codewind</strong>.</li>
  <li>Increase the debug connection timeout value and click <strong>Apply and Close</strong>.</li>
</ol>

<h2 id="application-stuck-in-starting-state-in-eclipse">Application stuck in Starting state in Eclipse</h2>
<p>The application might be waiting for the debugger to connect. You can resolve this by right-clicking on the project in the <strong>Codewind Explorer</strong> view and selecting <strong>Attach Debugger</strong>.  If the problem occurred because the debugger failed to connect when restarting in debug mode, make sure to increase the debug connection timeout in the Codewind preferences before trying to debug again. For more information see <a href="#debugger-fails-to-connect">Debugger fails to connect</a>.</p>

<p>If the debugger is connected but stopped on a ClassNotFoundException, click on the run button to get past the exception. You might need to click run several times as the exception occurs more than once. To avoid stopping on the exception in the future, open the Eclipse preferences and navigate to <strong>Java</strong> &gt; <strong>Debug</strong>. Uncheck <strong>Suspend execution on uncaught exceptions</strong> and click <strong>Apply and Close</strong>.</p>

<p>If the application is not waiting for the debugger to connect, try restarting the application again. If this does not work, use Codewind to disable the application and then re-enable it.</p>

<h2 id="application-does-not-rebuild-after-making-a-change">Application does not rebuild after making a change</h2>
<p>To start a build manually, right click on the application in the <strong>Codewind Explorer</strong> view, and selecting <strong>Build</strong>.</p>

<h2 id="correct-project-list-is-not-being-shown">Correct project list is not being shown</h2>
<p>Refresh the project list by right-clicking the connection in the <strong>Codewind Explorer</strong> view and selecting <strong>Refresh</strong>.</p>

<h2 id="application-is-not-showing-the-correct-status">Application is not showing the correct status</h2>
<p>Refresh the application by right-clicking it in the <strong>Codewind Explorer</strong> view and selecting <strong>Refresh</strong>.</p>

<hr />
<h1 id="vs-code-troubleshooting">VS Code troubleshooting</h1>

<p>For Codewind specific problem solving tips when using VS Code, see the following information.</p>

<h2 id="solving-common-vs-code-problems">Solving common VS Code problems</h2>
<p>The following list describes common problems that might affect Codewind.</p>

<ul>
  <li><a href="#codewind-output-stream">Codewind output stream</a></li>
  <li><a href="#finding-the-extension-logs">Finding the extension logs</a></li>
  <li><a href="#executable-file-not-found-on-path-in-vs-code">Executable file not found on PATH in VS Code</a></li>
  <li><a href="#no-eslint-warnings-or-errors">No ESLint warnings or errors</a></li>
  <li><a href="#debug">Debug</a></li>
</ul>

<h2 id="codewind-output-stream">Codewind output stream</h2>

<p>The Codewind output stream is available in the VS Code editor. It logs <code class="highlighter-rouge">cwctl</code> commands together with their output.</p>

<p>Check the Codewind output stream first when troubleshooting because it is particularly useful in helping you to debug unusual problems especially when starting Codewind. Some errors will also provide you with a button to open the Codewind output stream, for example:</p>

<p><img src="images/cdt-vsc/output_view.png" alt="Image of VS Code output with View button" /><br /></p>

<h2 id="finding-the-extension-logs">Finding the extension logs</h2>

<p>If you report an issue, you will be asked to upload your logs.</p>

<ol>
  <li>In VS Code, open <strong>Help</strong> &gt; <strong>Toggle Developer Tools</strong>.</li>
  <li>Go to the <strong>Console</strong> tab.</li>
  <li>Enter <em>codewind.log</em> in the <strong>Filter</strong> box:
<br /><img src="images/cdt-vsc/logs-location.png" alt="Log location" /></li>
  <li>Upload the contents of the log file with your issue report.</li>
</ol>

<h2 id="executable-file-not-found-on-path-in-vs-code">Executable file not found on PATH in VS Code</h2>
<!--
Action/Topic: Executable file not found on PATH in VS Code
Issue type: info
Issue link: https://github.com/eclipse/codewind/issues/1682
Solution: https://github.com/eclipse/codewind/issues/1682#issuecomment-572649328
Info added in 0.11.0.
-->
<p>Codewind will not work if it cannot find the <code class="highlighter-rouge">docker</code> executable in any of the paths specified in the <code class="highlighter-rouge">PATH</code> environment variable. The error message is similar to the following:</p>
<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>exec: "docker": executable file not found in $PATH
</code></pre></div></div>
<p>First, make sure <code class="highlighter-rouge">docker</code> is installed and that you can run it from the command line. The terminal used does not have to be a terminal within VS Code. Run the following command:</p>
<div class="highlighter-rouge"><div class="highlight"><pre class="highlight"><code>$ docker --version
Docker version 19.03.8, build afacb8b
</code></pre></div></div>
<p>Make sure the output is similar to this example.</p>

<p>If you can run <code class="highlighter-rouge">docker</code> from the command line, but Codewind still fails to find <code class="highlighter-rouge">docker</code>, it’s possible that VS Code is using a different <code class="highlighter-rouge">PATH</code> than the terminal you used. To make sure the terminal and VS Code are using the same <code class="highlighter-rouge">PATH</code>, perform the following steps:</p>

<ol>
  <li>Make sure you can run VS Code from the command line. The executable is <code class="highlighter-rouge">code</code>.
    <ul>
      <li>On Windows and Linux, you can run VS Code from the command line immediately after installation by running <code class="highlighter-rouge">code</code>.</li>
      <li>For macOS, follow the additional step, <a href="https://code.visualstudio.com/docs/setup/mac#_launching-from-the-command-line">Launching from the command line</a>.</li>
    </ul>
  </li>
  <li>Close all instances of VS Code.</li>
  <li>Open the terminal you ran <code class="highlighter-rouge">docker</code> from and run <code class="highlighter-rouge">code</code>.</li>
  <li>Now, the new VS Code instance shares the terminal’s <code class="highlighter-rouge">PATH</code>. Start Codewind again.</li>
</ol>

<h2 id="no-eslint-warnings-or-errors">No ESLint warnings or errors</h2>
<p>You see no ESLint warning or errors for Node.js projects. Install the <a href="https://marketplace.visualstudio.com/items?itemName=dbaeumer.vscode-eslint">ESLint extension</a> and follow the instructions to activate the extension.</p>

<h2 id="debug">Debug</h2>

<h3 id="debugger-attach-fails-with-the-message-configured-debug-type-java-is-not-supported">Debugger attach fails with the message “Configured debug type “java” is not supported”</h3>
<p>Install and enable the <a href="https://marketplace.visualstudio.com/items?itemName=vscjava.vscode-java-pack">Java Extension Pack</a>.</p>

<h3 id="debugger-fails-to-attach-after-restarting-project-into-debug-mode">Debugger fails to attach after restarting project into Debug mode</h3>
<p>Run the <code class="highlighter-rouge">attach debugger</code> command again. If the issue persists after a few attempts, restart the project in <strong>Debug</strong> mode a second time.</p>
</div>
        </div>
        
        <div class="py-5 px-5 text-right">
        Last update: May 13, 2020
        </div>
        
    </div>
    
</div>
<!-- footer row -->
<footer>

<div id="footer-div-mobile">
        
        <div class="row">
	        <div class="col-sm-12 text-center">
		        <span>Useful Links:</span>
		        <br/><br/>
		        <a class="cw-footer-links" href="http://www.eclipse.org">Eclipse Foundation</a><br/>
		        <a class="cw-footer-links" href="http://www.eclipse.org/legal/privacy.php">Privacy Policy</a><br/>
		        <a class="cw-footer-links" href="http://www.eclipse.org/legal/termsofuse.php">Website Terms of Use</a><br/>
		        <a class="cw-footer-links" href="http://www.eclipse.org/legal/copyright.php">Copyright Agent</a><br/>
		        <a class="cw-footer-links" href="http://www.eclipse.org/legal">Legal</a><br/>
		    </div>
        </div>
        <div class="cw_footer_display_flex cw-footer-same-height cw-footer-center">
        
        <div class="cw_footer_display_icons row">
    		<div class="cw-footer-col text-center col-md-3 col-sm-6 col-xs-12">
            <div>
                <div>
                    <a href="mailto:codewind-dev@eclipse.org"><img alt="Send us an email"  title="Send us an email" src="images/footer/email-icon.svg" class="cw-logo" /></a>
                </div>
            </div>
        </div>
        <div class="cw-footer-col text-center col-md-3 col-sm-6 col-xs-12">
            <div>
                <div>
                    <a href="https://twitter.com/EclipseCodewind"><img alt="Codewind Twitter"  title="Codewind Twitter" src="images/footer/twitter-logo.svg" class="cw-logo" /></a>
                </div>
            </div>
        </div>
        
        <div class="cw-footer-col text-center col-md-3 col-sm-6 col-xs-12">
            <div>
                <div>
                    <a href="https://github.com/eclipse/codewind"><img alt="Codewind Github"  title="Codewind Github" src="images/footer/github-logo.svg"
                            class="cw-logo" /></a>
                </div>
            </div>
        </div>
        

        <div class=" cw-footer-col text-center col-md-3 col-sm-6 col-xs-12">
            <div>
                <div>
                    <a href="https://mattermost.eclipse.org/eclipse/channels/eclipse-codewind"><img alt="Codewind Mattermost"  title="Codewind Mattermost" src="images/footer/mattermost-logo.png" class="cw-logo-mm" /></a>
                </div>
            </div>
        </div>
        <div class="cw-footer-col text-center col-md-3 col-sm-6 col-xs-12">
            <div>
                <div>
                    <a href="https://www.youtube.com/channel/UCnKCVK6RFDyHFqUmXlAhCHQ"><img alt="Codewind YouTube"  title="Codewind YouTube" src="images/footer/youtube-logo-dark.svg"
                            class="cw-logo" /></a>
                </div>
            </div>
        </div>
        <div class="cw-footer-col text-center col-md-3 col-sm-6 col-xs-12">
            <div>
                <div>
                    
                    <a href="http://www.eclipse.org"><img class="cw-logo-eclipse-mobile" alt="Eclipse"  title="Eclipse" src="images/footer/eclipse.svg"/></a>
                </div>
            </div>
        </div>
        </div>
        
		</div>
		
    </div>
    
    
    <div class="row cw-footer-desktop" id="footer-div">
        <div class="cw-footer-left">
        		<div class="px-5 cw-font-12>
	        <span class="cw-font-14">Useful Links:</span>
	        <br/><br/>
	        <a class="cw-footer-links" href="http://www.eclipse.org">Eclipse Foundation</a><br/>
	        <a class="cw-footer-links" href="http://www.eclipse.org/legal/privacy.php">Privacy Policy</a><br/>
	        <a class="cw-footer-links" href="http://www.eclipse.org/legal/termsofuse.php">Website Terms of Use</a><br/>
	        <a class="cw-footer-links" href="http://www.eclipse.org/legal/copyright.php">Copyright Agent</a><br/>
	        <a class="cw-footer-links" href="http://www.eclipse.org/legal">Legal</a><br/>
	        </div>
	        
        </div>
        <div class="cw-footer-border-right"></div>
        <div class="cw_footer_display_flex cw-footer-same-height cw-footer-center">
        <div class="cw_footer_display_icons">
    		<div class="cw-footer-col text-center">
            <div>
                <div>
                    <a href="mailto:codewind-dev@eclipse.org"><img alt="Send us an email"  title="Send us an email" src="images/footer/email-icon.svg" class="cw-logo" /></a>
                </div>
            </div>
        </div>
        <div class="cw-footer-col text-center">
            <div>
                <div>
                    <a href="https://twitter.com/EclipseCodewind"><img alt="Codewind Twitter"  title="Codewind Twitter" src="images/footer/twitter-logo.svg" class="cw-logo" /></a>
                </div>
            </div>
        </div>
        
        <div class="cw-footer-col text-center">
            <div>
                <div>
                    <a href="https://github.com/eclipse/codewind"><img alt="Codewind Github"  title="Codewind Github" src="images/footer/github-logo.svg"
                            class="cw-logo" /></a>
                </div>
            </div>
        </div>
        

        <div class=" cw-footer-col text-center">
            <div class="cw-logo-mm" >
                <div class="cw-logo-mm" >
                    <a href="https://mattermost.eclipse.org/eclipse/channels/eclipse-codewind"><img alt="Codewind Mattermost"  title="Codewind Mattermost" src="images/footer/mattermost-logo.png" class="cw-logo-mm" /></a>
                </div>
            </div>
        </div>
        <div class="cw-footer-col text-center">
            <div>
                <div>
                    <a href="https://www.youtube.com/channel/UCnKCVK6RFDyHFqUmXlAhCHQ"><img alt="Codewind YouTube"   title="Codewind YouTube" src="images/footer/youtube-logo-dark.svg"
                            class="cw-logo" /></a>
                </div>
            </div>
        </div>
        
        </div>
        
		</div>
		<div class="cw-footer-border-right"></div>
		<div class="cw-footer-right cw-footer-same-height cw-footer-vcenter">
		<div class="cw-footer-eclipse-img cw-footer-same-height px-5 ">
	        
		<a href="http://www.eclipse.org">
		<img alt="Eclipse"  title="Eclipse" src="images/footer/eclipse.svg"/>
		</a>
	        </div>
		</div>
    </div>
</footer>
<!-- footer row END -->
<!-- Main Col END -->
 <!-- Jquery -->
<script
  src="https://code.jquery.com/jquery-3.4.1.min.js"
  integrity="sha256-CSXorXvZcTkaix6Yvo6HppcZGetbYMGWSFlBw8HfCJo="
  crossorigin="anonymous"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/popper.js/1.14.7/umd/popper.min.js"
    integrity="sha384-UO2eT0CpHqdSJQ6hJty5KVphtPhzWj9WO1clHTMGa3JDZwrnQq4sF86dIHNDz0W1" crossorigin="anonymous">
</script>



<script src="https://stackpath.bootstrapcdn.com/bootstrap/4.3.1/js/bootstrap.min.js"
    integrity="sha384-JjSmVgyd0p3pXB1rRibZUAYoIIy6OrQ6VrjIEaFf/nJGzIxFDsf4x0xIM+B07jRM" crossorigin="anonymous">
</script>


<!-- Font Awesome JS -->
<script defer src="https://use.fontawesome.com/releases/v5.0.13/js/solid.js"
    integrity="sha384-tzzSw1/Vo+0N5UhStP3bvwWPq+uvzCMfrN1fEFe+xBmv1C/AtVX5K0uZtmcHitFZ" crossorigin="anonymous">
</script>
<script defer src="https://use.fontawesome.com/releases/v5.0.13/js/fontawesome.js"
    integrity="sha384-6OIrr52G08NpOFSZdxxz1xdNSndlD4vdcf/q2myIUVO0VsqaGHJsB0RaBE01VTOY" crossorigin="anonymous">
</script>

<script src="js/jquery.matchHeight-min.js"></script>
<script src="js/index.js"></script>
<script src="js/docs.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.17.1/prism.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.17.1/components/prism-docker.min.js"></script>
<script src="https://cdnjs.cloudflare.com/ajax/libs/prism/1.17.1/components/prism-json.min.js"></script>

</div>
</body>

</html>
 
 
 
 <script src="https://cdnjs.cloudflare.com/ajax/libs/anchor-js/4.2.0/anchor.min.js"></script>
 <script>
$(document).ready(function(){
	
    anchors.options.placement = 'left';
    anchors.add('h1');
    anchors.add('h2');
    anchors.add('h3');
    anchors.add('h4');
});
</script>
 