Review comments fixed.

Externalize all the visible strings.
Make writeWsLockInfo() a protected method.
Create .lock file if is does not exist.
Try HOSTNAME variable to read host name.

Author: raghucssit

bundles/org.eclipse.ui.ide.application/META-INF/MANIFEST.MF

@@ -2,7 +2,7 @@ Manifest-Version: 1.0
 Bundle-ManifestVersion: 2
 Bundle-Name: %Plugin.name
 Bundle-SymbolicName: org.eclipse.ui.ide.application;singleton:=true
-Bundle-Version: 1.5.600.qualifier
+Bundle-Version: 1.6.600.qualifier
 Bundle-Vendor: %Plugin.providerName
 Bundle-Localization: plugin
 Require-Bundle: org.eclipse.ui.ide;bundle-version="[3.21.0,4.0.0)",

bundles/org.eclipse.ui.ide.application/src/org/eclipse/ui/internal/ide/application/IDEApplication.java

@@ -20,15 +20,18 @@
 
 import static org.eclipse.jface.util.Util.isValid;
 
+import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
+import java.io.FileWriter;
 import java.io.IOException;
 import java.io.OutputStream;
 import java.net.InetAddress;
 import java.net.MalformedURLException;
 import java.net.URL;
-import java.net.UnknownHostException;
+import java.nio.file.Files;
+import java.nio.file.Paths;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Properties;
@@ -89,6 +92,8 @@ public class IDEApplication implements IApplication, IExecutableExtension {
 
 	private static final String DISPLAY_VAR = "DISPLAY"; //$NON-NLS-1$
 
+	private static final String HOSTNAME_VAR = "HOSTNAME"; //$NON-NLS-1$
+
 	private static final String PROCESS_ID = "process-id"; //$NON-NLS-1$
 
 	private static final String DISPLAY = "display"; //$NON-NLS-1$
@@ -127,6 +132,8 @@ public class IDEApplication implements IApplication, IExecutableExtension {
 	 */
 	public static final String PLUGIN_ID = "org.eclipse.ui.ide.application"; //$NON-NLS-1$
 
+	private String lockFileBackup = null;
+
 	/**
 	 * Creates a new IDE application.
 	 */
@@ -243,12 +250,21 @@ protected Object checkInstanceLocation(Shell shell, Map applicationArguments) {
 				// at this point its valid, so try to lock it and update the
 				// metadata version information if successful
 				try {
+					// Check if the workspace is locked. If not then write who is going to lock now.
+					if (!instanceLoc.isLocked()) {
+						lockFileBackup = readLockFile(instanceLoc.getURL());
+						writeWsLockInfo();
+					}
+
 					if (instanceLoc.lock()) {
 						writeWorkspaceVersion();
-						writeWsLockInfo();
 						return null;
 					}
 
+					// We wrote to lock file assuming we can will acquire lock. For some unknown
+					// reasons we could not acquire lock. Then write back what was there before.
+					writeBackLockFileBackup(instanceLoc.getURL());
+
 					// we failed to create the directory.
 					// Two possibilities:
 					// 1. directory is already in use
@@ -258,10 +274,19 @@ protected Object checkInstanceLocation(Shell shell, Map applicationArguments) {
 						if (isDevLaunchMode(applicationArguments)) {
 							return EXIT_WORKSPACE_LOCKED;
 						}
+
+						String wsLockedError = NLS.bind(IDEWorkbenchMessages.IDEApplication_workspaceCannotLockMessage,
+								workspaceDirectory.getAbsolutePath());
+						// check if there is a lock info then append it to error message.
+						String lockInfo = getWorkspaceLockInfo(instanceLoc.getURL());
+						if (lockInfo != null && !lockInfo.isBlank()) {
+							wsLockedError = wsLockedError + System.lineSeparator() + System.lineSeparator()
+									+ NLS.bind(IDEWorkbenchMessages.Workspace_Lock_Owner, lockInfo);
+						}
 						MessageDialog.openError(
 								shell,
 								IDEWorkbenchMessages.IDEApplication_workspaceCannotLockTitle,
-								NLS.bind(IDEWorkbenchMessages.IDEApplication_workspaceCannotLockMessage, workspaceDirectory.getAbsolutePath()));
+								wsLockedError);
 					} else {
 						MessageDialog.openError(
 								shell,
@@ -331,11 +356,21 @@ protected Object checkInstanceLocation(Shell shell, Map applicationArguments) {
 
 				// the operation will fail if the url is not a valid
 				// instance data area, so other checking is unneeded
-				if (instanceLoc.set(workspaceUrl, true)) {
+				if (instanceLoc.set(workspaceUrl, false)) {
 					launchData.writePersistedData();
-					writeWorkspaceVersion();
-					writeWsLockInfo();
-					return null;
+
+					if (!instanceLoc.isLocked()) {
+						lockFileBackup = readLockFile(workspaceUrl);
+						writeWsLockInfo();
+					}
+					if (instanceLoc.lock()) {
+						writeWorkspaceVersion();
+						return null;
+					}
+					// We wrote to lock file assuming we can will acquire lock. For some unknown
+					// reasons we could not acquire lock. Then write back what was there before.
+					writeBackLockFileBackup(workspaceUrl);
+
 				}
 			} catch (IllegalStateException e) {
 				MessageDialog
@@ -367,13 +402,11 @@ protected Control createCustomArea(Composite parent) {
 						return null;
 					}
 
-					String displayText = "Workspace lock is held by the following owner:\n".concat(lockInfo); //$NON-NLS-1$
-
 					Composite container = new Composite(parent, SWT.NONE);
 					container.setLayout(new FillLayout());
 
 					Label multiLineText = new Label(container, SWT.NONE);
-					multiLineText.setText(displayText);
+					multiLineText.setText(NLS.bind(IDEWorkbenchMessages.Workspace_Lock_Owner, lockInfo));
 
 					return container;
 				}
@@ -394,25 +427,28 @@ protected Control createCustomArea(Composite parent) {
 	 */
 	private String getWorkspaceLockInfo(URL workspaceUrl) {
 		File lockFile = getLockFile(workspaceUrl);
+		if (lockFile == null) {
+			return null;
+		}
 		StringBuilder sb = new StringBuilder();
 		Properties props = new Properties();
 		try (FileInputStream is = new FileInputStream(lockFile)) {
 			props.load(is);
 			String prop = props.getProperty(USER);
 			if (prop != null) {
-				sb.append("user: ").append(prop).append(System.lineSeparator()); //$NON-NLS-1$
+				sb.append(NLS.bind(IDEWorkbenchMessages.User, prop));
 			}
 			prop = props.getProperty(HOST);
 			if (prop != null) {
-				sb.append("host: ").append(prop).append(System.lineSeparator()); //$NON-NLS-1$
+				sb.append(NLS.bind(IDEWorkbenchMessages.Host, prop));
 			}
 			prop = props.getProperty(DISPLAY);
 			if (prop != null) {
-				sb.append("display: ").append(prop).append(System.lineSeparator()); //$NON-NLS-1$
+				sb.append(NLS.bind(IDEWorkbenchMessages.Display, prop));
 			}
 			prop = props.getProperty(PROCESS_ID);
 			if (prop != null) {
-				sb.append("process-id: ").append(prop).append(System.lineSeparator()); //$NON-NLS-1$
+				sb.append(NLS.bind(IDEWorkbenchMessages.Process_Id, prop));
 			}
 			return sb.toString();
 		} catch (Exception e) {
@@ -425,17 +461,7 @@ private String getWorkspaceLockInfo(URL workspaceUrl) {
 	 * Write lock owner details onto workspace lock file. Data includes user, host,
 	 * display and current java process id.
 	 */
-	private void writeWsLockInfo() {
-		Location instanceLoc = Platform.getInstanceLocation();
-		if (instanceLoc == null || instanceLoc.isReadOnly()) {
-			return;
-		}
-
-		File lockFile = getLockFile(instanceLoc.getURL());
-		if (lockFile == null) {
-			return;
-		}
-
+	protected void writeWsLockInfo() {
 		Properties props = new Properties();
 
 		String user = System.getProperty(USER_NAME);
@@ -455,13 +481,65 @@ private void writeWsLockInfo() {
 			props.setProperty(PROCESS_ID, pid);
 		}
 
+		if (props.isEmpty()) {
+			return;
+		}
+
+		Location instanceLoc = Platform.getInstanceLocation();
+		if (instanceLoc == null || instanceLoc.isReadOnly()) {
+			return;
+		}
+
+		File lockFile = getLockFile(instanceLoc.getURL());
+		if (lockFile == null) {
+			return;
+		}
+
+		if (lockFile == null || !lockFile.exists()) {
+			return;
+		}
+
 		try (OutputStream output = new FileOutputStream(lockFile)) {
 			props.store(output, null);
 		} catch (IOException e) {
 			IDEWorkbenchPlugin.log("Could not modify lock file", e); //$NON-NLS-1$
 		}
 	}
 
+	private String readLockFile(URL workspaceUrl) {
+		File lockFile = getLockFile(workspaceUrl);
+
+		if (lockFile == null) {
+			return null;
+		}
+
+		if (lockFile.exists() && lockFile.isFile()) {
+			try {
+				return new String(Files.readAllBytes(Paths.get(lockFile.getPath())));
+			} catch (IOException e) {
+				IDEWorkbenchPlugin.log("Could not read lock file", e); //$NON-NLS-1$
+			}
+		}
+		return null;
+	}
+
+	private void writeBackLockFileBackup(URL workspaceUrl) {
+		if (lockFileBackup == null || lockFileBackup.isEmpty()) {
+			return;
+		}
+		File lockFile = getLockFile(workspaceUrl);
+
+		if (lockFile == null) {
+			return;
+		}
+
+		try (BufferedWriter writer = new BufferedWriter(new FileWriter(lockFile, false))) {
+			writer.write(lockFileBackup);
+		} catch (IOException e) {
+			IDEWorkbenchPlugin.log("Could not write back backup data to lock file", e); //$NON-NLS-1$
+		}
+	}
+
 	private String getDisplay() {
 		String displayEnv = null;
 		try {
@@ -484,14 +562,32 @@ private String getProcessId() {
 
 	private String getHostName() {
 		String hostName = null;
+
+		// Try fast approach first. Some OS(Like Linux) has HOSTNAME environment
+		// variable set.
+		try {
+			hostName = System.getenv(HOSTNAME_VAR);
+			if (hostName != null && !hostName.isEmpty()) {
+				return hostName;
+			}
+		} catch (Exception e) {
+			// Ignore here because we will try another method in the next step.
+		}
+
 		try {
 			hostName = InetAddress.getLocalHost().getHostName();
-		} catch (UnknownHostException e) {
+		} catch (Exception e) {
 			IDEWorkbenchPlugin.log("Failed to read host name.", e); //$NON-NLS-1$
 		}
 		return hostName;
 	}
 
+	/**
+	 * Returns the lock file if it is present or it will create a lock file.
+	 *
+	 * @param workspaceUrl
+	 * @return Create .lock file if it does not present and return.
+	 */
 	private File getLockFile(URL workspaceUrl) {
 		if (workspaceUrl == null) {
 			return null;
@@ -500,13 +596,17 @@ private File getLockFile(URL workspaceUrl) {
 		// make sure the directory exists
 		File metaDir = new File(workspaceUrl.getPath(), METADATA_FOLDER);
 		if (!metaDir.exists()) {
-			return null;
+			metaDir.mkdirs();
 		}
 
-		// make sure the file exists
 		File lockFile = new File(metaDir, LOCK_FILENAME);
 		if (!lockFile.exists()) {
-			return null;
+			try {
+				lockFile.createNewFile();
+			} catch (IOException e) {
+				IDEWorkbenchPlugin.log("Failed to create workspace lock file.", e); //$NON-NLS-1$
+				return null;
+			}
 		}
 
 		return lockFile;

bundles/org.eclipse.ui.ide/src/org/eclipse/ui/internal/ide/IDEWorkbenchMessages.java

@@ -1147,6 +1147,12 @@ public class IDEWorkbenchMessages extends NLS {
 	public static String WorkbenchPreference_maxSimultaneousBuilds;
 	public static String WorkbenchPreference_maxSimultaneousBuildIntervalError;
 
+	public static String User;
+	public static String Host;
+	public static String Display;
+	public static String Process_Id;
+	public static String Workspace_Lock_Owner;
+
 	static {
 		// load message values from bundle file
 		NLS.initializeMessages(BUNDLE_NAME, IDEWorkbenchMessages.class);