1 files changed, 291 insertions, 0 deletions

diff --git a/plugins/org.yocto.sdk.ide/src/org/yocto/sdk/ide/YoctoSDKChecker.java b/plugins/org.yocto.sdk.ide/src/org/yocto/sdk/ide/YoctoSDKChecker.java
new file mode 100644
index 0000000..714470b
--- /dev/null
+++ b/plugins/org.yocto.sdk.ide/src/org/yocto/sdk/ide/YoctoSDKChecker.java
@@ -0,0 +1,291 @@
+/*******************************************************************************
+ * Copyright (c) 2010 Intel Corporation.
+ * Copyright (c) 2013 BMW Car IT GmbH.
+ * 
+ * All rights reserved. This program and the accompanying materials
+ * are made available under the terms of the Eclipse Public License v1.0
+ * which accompanies this distribution, and is available at
+ * http://www.eclipse.org/legal/epl-v10.html
+ *
+ * Contributors:
+ * Intel - initial API and implementation
+ * BMW Car IT - include error and advice messages with check results
+ *******************************************************************************/
+package org.yocto.sdk.ide;
+
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileReader;
+import java.io.FilenameFilter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+
+import org.eclipse.jface.preference.IPreferenceStore;
+import org.yocto.sdk.ide.natures.YoctoSDKProjectNature;
+import org.yocto.sdk.ide.utils.YoctoSDKUtils;
+import org.yocto.sdk.ide.utils.YoctoSDKUtilsConstants;
+
+public class YoctoSDKChecker {
+        private static final String[] saInvalidVer = {"1.0", "0.9", "0.9+"};
+        private static final String SYSROOTS_DIR = "sysroots";
+        private static final String SDK_VERSION = "OECORE_SDK_VERSION";
+
+        public static enum SDKCheckResults {
+                SDK_PASS("", false),
+                TOOLCHAIN_LOCATION_EMPTY(
+                                "Poky.SDK.Location.Empty", true),
+                TOOLCHAIN_LOCATION_NONEXIST(
+                                "Poky.SDK.Location.Nonexist", true),
+                SDK_TARGET_EMPTY(
+                                "Poky.SDK.Target.Empty", true),
+                SDK_NO_TARGET_SELECTED(
+                                "Poky.SDK.No.Target.Selected", false),
+                SYSROOT_EMPTY(
+                                "Poky.Sysroot.Empty", true),
+                SYSROOT_NONEXIST(
+                                "Poky.Sysroot.Nonexist", true),
+                QEMU_KERNEL_EMPTY(
+                                "Poky.Qemu.Kernel.Empty", true),
+                QEMU_KERNEL_NONEXIST(
+                                "Poky.Qemu.Kernel.Nonexist", true),
+                WRONG_ADT_VERSION(
+                                "Poky.ADT.Sysroot.Wrongversion", false),
+                ENV_SETUP_SCRIPT_NONEXIST(
+                                "Poky.Env.Script.Nonexist", false),
+                TOOLCHAIN_NO_SYSROOT(
+                                "Poky.Toolchain.No.Sysroot", false),
+                TOOLCHAIN_HOST_MISMATCH(
+                                "Poky.Toolchain.Host.Mismatch", false);
+
+                private static final String DEFAULT_ADVICE = "Default.Advice";
+                private static final String ADVICE_SUFFIX = ".Advice";
+
+                private final String messageID;
+                private final boolean addDefaultAdvice;
+
+                private SDKCheckResults(final String messageID, final boolean addDefaultAdvice) {
+                        this.messageID = messageID;
+                        this.addDefaultAdvice = addDefaultAdvice;
+                }
+
+                public String getMessage() {
+                        return YoctoSDKMessages.getString(messageID);
+                }
+
+                public String getAdvice() {
+                        String advice = YoctoSDKMessages.getString(messageID + ADVICE_SUFFIX);
+
+                        if (addDefaultAdvice) {
+                                advice += YoctoSDKMessages.getString(DEFAULT_ADVICE);
+                        }
+
+                        return advice;
+                }
+        };
+
+        public static enum SDKCheckRequestFrom {
+                Wizard("Poky.SDK.Error.Origin.Wizard"),
+                Menu("Poky.SDK.Error.Origin.Menu"),
+                Preferences("Poky.SDK.Error.Origin.Preferences"),
+                Other("Poky.SDK.Error.Origin.Other");
+
+                private final String errorMessageID;
+
+                private SDKCheckRequestFrom(final String errorMessageID) {
+                        this.errorMessageID = errorMessageID;
+                }
+
+                public String getErrorMessage() {
+                        return YoctoSDKMessages.getString(errorMessageID);
+                }
+        };
+
+        public static void checkIfGloballySelectedYoctoProfileIsValid() throws YoctoGeneralException {
+                YoctoProfileElement profileElement = YoctoSDKUtils.getProfilesFromDefaultStore();
+                IPreferenceStore selectedProfileStore = YoctoSDKPlugin.getProfilePreferenceStore(profileElement.getSelectedProfile());
+                YoctoUIElement elem = YoctoSDKUtils.getElemFromStore(selectedProfileStore);
+
+                SDKCheckResults result = checkYoctoSDK(elem);
+                if (result != SDKCheckResults.SDK_PASS){
+                        String strErrorMsg =  getErrorMessage(result, SDKCheckRequestFrom.Wizard);
+                        throw new YoctoGeneralException(strErrorMsg);
+                }
+        }
+
+        public static SDKCheckResults checkYoctoSDK(YoctoUIElement elem) {
+                if (elem.getStrToolChainRoot().isEmpty())
+                        return SDKCheckResults.TOOLCHAIN_LOCATION_EMPTY;
+                else {
+                        File fToolChain = new File(elem.getStrToolChainRoot());
+                        if (!fToolChain.exists())
+                                return SDKCheckResults.TOOLCHAIN_LOCATION_NONEXIST;
+                }
+
+                if (elem.getStrSysrootLoc().isEmpty()) {
+                        return SDKCheckResults.SYSROOT_EMPTY;
+                } else {
+                        File fSysroot = new File(elem.getStrSysrootLoc());
+                        if (!fSysroot.exists())
+                                return SDKCheckResults.SYSROOT_NONEXIST;
+                }
+
+                if (elem.getEnumPokyMode() == YoctoUIElement.PokyMode.POKY_SDK_MODE) {
+                        //Check for SDK compatible with the host arch
+                        String platform = getPlatformArch();
+                        String sysroot_dir_str = elem.getStrToolChainRoot() + "/" + SYSROOTS_DIR;
+                        File sysroot_dir = new File(sysroot_dir_str);
+                        if (!sysroot_dir.exists())
+                                return SDKCheckResults.TOOLCHAIN_NO_SYSROOT;
+
+                        String toolchain_host_arch = null;
+
+                        try {
+                                toolchain_host_arch = findHostArch(sysroot_dir);
+                        } catch(NullPointerException e) {
+                                return SDKCheckResults.TOOLCHAIN_NO_SYSROOT;
+                        }
+
+                        if (!toolchain_host_arch.equalsIgnoreCase(platform)) {
+                                if (!platform.matches("i\\d86") || !toolchain_host_arch.matches("i\\d86"))
+                                        return SDKCheckResults.TOOLCHAIN_HOST_MISMATCH;
+                        }
+                }
+
+                if (elem.getStrTarget().isEmpty() && elem.getStrTargetsArray().length > 0) {
+                        return SDKCheckResults.SDK_NO_TARGET_SELECTED;
+                }
+
+                if (elem.getIntTargetIndex() < 0 || elem.getStrTarget().isEmpty()) {
+                        //if this is poky tree mode, prompt user whether bitbake meta-ide-support is executed?
+                        if (elem.getEnumPokyMode() == YoctoUIElement.PokyMode.POKY_TREE_MODE)
+                                return SDKCheckResults.ENV_SETUP_SCRIPT_NONEXIST;
+                        else
+                                return SDKCheckResults.SDK_TARGET_EMPTY;
+                } else {
+                        String sFileName;
+
+                        if (elem.getEnumPokyMode() == YoctoUIElement.PokyMode.POKY_SDK_MODE) {
+                                sFileName = elem.getStrToolChainRoot()+"/" + YoctoSDKUtilsConstants.DEFAULT_ENV_FILE_PREFIX + elem.getStrTarget();
+                        } else {
+                                //POKY TREE Mode
+                                sFileName = elem.getStrToolChainRoot() + YoctoSDKUtilsConstants.DEFAULT_TMP_PREFIX +
+                                                YoctoSDKUtilsConstants.DEFAULT_ENV_FILE_PREFIX + elem.getStrTarget();
+                        }
+
+                        try {
+                                File file = new File(sFileName);
+                                boolean bVersion = false;
+
+                                if (file.exists()) {
+                                        BufferedReader input = new BufferedReader(new FileReader(file));
+
+                                        try {
+                                                String line = null;
+
+                                                while ((line = input.readLine()) != null) {
+                                                        if (line.startsWith("export "+ SDK_VERSION)) {
+                                                                int beginIndex = 2;
+                                                                String sVersion = "";
+                                                                for (;;) {
+                                                                        char cValue = line.charAt(line.indexOf('=') + beginIndex++);
+
+                                                                        if ((cValue != '.') && (!Character.isDigit(cValue)) && (cValue != '+'))
+                                                                                break;
+                                                                        else
+                                                                                sVersion += String.valueOf(cValue);
+                                                                }
+
+                                                                for (int i = 0; i < saInvalidVer.length; i++) {
+                                                                        if (!sVersion.equals(saInvalidVer[i])) {
+                                                                                bVersion = true;
+                                                                                break;
+                                                                        }
+                                                                }
+
+                                                                break;
+                                                        }
+                                                }
+                                        } finally {
+                                                input.close();
+                                        }
+
+                                        if (!bVersion)
+                                                return SDKCheckResults.WRONG_ADT_VERSION;
+                                }
+                        } catch (IOException e) {
+                                e.printStackTrace();
+                        }
+                }
+
+                if (elem.getEnumDeviceMode() == YoctoUIElement.DeviceMode.QEMU_MODE) {
+                        if (elem.getStrQemuKernelLoc().isEmpty()) {
+                                return SDKCheckResults.QEMU_KERNEL_EMPTY;
+                        } else {
+                                File fQemuKernel = new File(elem.getStrQemuKernelLoc());
+                                if (!fQemuKernel.exists())
+                                        return SDKCheckResults.QEMU_KERNEL_NONEXIST;
+                        }
+                }
+
+                return SDKCheckResults.SDK_PASS;
+        }
+
+        public static String getErrorMessage(SDKCheckResults result, SDKCheckRequestFrom from) {
+                String strErrorMsg;
+                strErrorMsg = from.getErrorMessage();
+                strErrorMsg += "\n" + result.getMessage();
+                strErrorMsg += "\n" + result.getAdvice();
+
+                return strErrorMsg;
+        }
+
+        private static String getPlatformArch() {
+                String value = null;
+                try
+                {
+                        Runtime rt = Runtime.getRuntime();
+                        Process proc = rt.exec("uname -m");
+                        InputStream stdin = proc.getInputStream();
+                        InputStreamReader isr = new InputStreamReader(stdin);
+                        BufferedReader br = new BufferedReader(isr);
+                        String line = null;
+
+                        while ( (line = br.readLine()) != null) {
+                                value = line;
+                        }
+                        proc.waitFor();
+
+                } catch (Throwable t) {
+                        t.printStackTrace();
+                }
+                return value;
+        }
+
+        private static String findHostArch(File sysroot_dir) {
+                FilenameFilter nativeFilter = new FilenameFilter() {
+                        public boolean accept(File dir, String name) {
+                                if (name.endsWith("sdk-linux")) {
+                                        return true;
+                                } else {
+                                        return false;
+                                }
+                        }
+                };
+
+                File[] files = sysroot_dir.listFiles(nativeFilter);
+                String arch = null;
+
+                for (File file : files) {
+                        if (file.isDirectory()) {
+                                String path = file.getName();
+                                String[] subPath = path.split("-");
+                                arch = subPath[0];
+                        } else {
+                                continue;
+                        }
+                }
+
+                return arch;
+        }
+}