fix(TESB-28815): Fix bundle name (should include -bundle suffix at the end)

* fix(TUP-26081): Share libraries pb

https://jira.talendforge.org/browse/TUP-26081

* fix(TUP-26081): Share libraries pb

https://jira.talendforge.org/browse/TUP-26081

Co-authored-by: Chao MENG <cmeng@talend.com>

i18n/features/org.talend.babel.all.tos.feature/pom.xml

@@ -4,7 +4,7 @@
   <parent>
 	<groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   

i18n/plugins/org.talend.common.ui.runtime.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.common.ui.runtime.nl</artifactId>

i18n/plugins/org.talend.commons.runtime.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.commons.runtime.nl</artifactId>

i18n/plugins/org.talend.commons.ui.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.commons.ui.nl</artifactId>

i18n/plugins/org.talend.core.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.core.nl</artifactId>

i18n/plugins/org.talend.core.repository.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.core.repository.nl</artifactId>

i18n/plugins/org.talend.core.runtime.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.core.runtime.nl</artifactId>

i18n/plugins/org.talend.core.ui.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.core.ui.nl</artifactId>

i18n/plugins/org.talend.cwm.mip.edit.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.cwm.mip.edit.nl</artifactId>

i18n/plugins/org.talend.cwm.mip.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.cwm.mip.nl</artifactId>

i18n/plugins/org.talend.designer.maven.ui.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.designer.maven.ui.nl</artifactId>

i18n/plugins/org.talend.help.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.help.nl</artifactId>

i18n/plugins/org.talend.helpers.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.helpers.nl</artifactId>

i18n/plugins/org.talend.librariesmanager.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.librariesmanager.nl</artifactId>

i18n/plugins/org.talend.librariesmanager.ui.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.librariesmanager.ui.nl</artifactId>

i18n/plugins/org.talend.metadata.managment.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.metadata.managment.nl</artifactId>

i18n/plugins/org.talend.metadata.managment.ui.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.metadata.managment.ui.nl</artifactId>

i18n/plugins/org.talend.migrationTool.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.migrationTool.nl</artifactId>

i18n/plugins/org.talend.model.edit.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.model.edit.nl</artifactId>

i18n/plugins/org.talend.model.migration.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.model.migration.nl</artifactId>

i18n/plugins/org.talend.model.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.model.nl</artifactId>

i18n/plugins/org.talend.presentation.onboarding.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.presentation.onboarding.nl</artifactId>

i18n/plugins/org.talend.rcp.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.rcp.nl</artifactId>

i18n/plugins/org.talend.registration.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.registration.nl</artifactId>

i18n/plugins/org.talend.repository.items.importexport.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.repository.items.importexport.nl</artifactId>

i18n/plugins/org.talend.repository.items.importexport.ui.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.repository.items.importexport.ui.nl</artifactId>

i18n/plugins/org.talend.repository.localprovider.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.repository.localprovider.nl</artifactId>

i18n/plugins/org.talend.repository.mdm.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.repository.mdm.nl</artifactId>

i18n/plugins/org.talend.repository.metadata.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.repository.metadata.nl</artifactId>

i18n/plugins/org.talend.repository.view.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.repository.view.nl</artifactId>

i18n/plugins/org.talend.resources.nl/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.resources.nl</artifactId>

main/features/org.talend.commons.feature/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.commons.feature</artifactId>

main/features/org.talend.core.feature/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.core.feature</artifactId>

main/features/org.talend.fragment.jars.common.feature/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.fragment.jars.common.feature</artifactId>

main/features/org.talend.help.feature/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.help.feature</artifactId>

main/features/org.talend.jdt.feature/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.jdt.feature</artifactId>

main/features/org.talend.libraries.jdbc.feature/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.libraries.jdbc.feature</artifactId>

main/features/org.talend.m2e.feature/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.m2e.feature</artifactId>

main/features/org.talend.model.migration.feature/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.model.migration.feature</artifactId>

main/features/org.talend.platform.feature/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   

main/features/org.talend.rcp.feature/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.rcp.feature</artifactId>

main/features/org.talend.update.p2.feature/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.update.p2.feature</artifactId>

main/features/org.talend.updates.feature/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.updates.feature</artifactId>

main/features/org.talend.utils.feature/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.utils.feature</artifactId>

main/plugins/org.talend.common.ui.runtime/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.common.ui.runtime</artifactId>

main/plugins/org.talend.commons.runtime/META-INF/MANIFEST.MF

@@ -13,7 +13,8 @@ Require-Bundle: org.apache.log4j;visibility:=reexport,
  org.talend.libraries.apache,
  com.ibm.icu,
  org.apache.commons.io,
- org.talend.utils
+ org.talend.utils,
+ org.eclipse.core.net
 Export-Package: org.talend.commons,
  org.talend.commons.exception,
  org.talend.commons.i18n,

main/plugins/org.talend.commons.runtime/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.commons.runtime</artifactId>

main/plugins/org.talend.commons.runtime/pom_server.xml

@@ -12,7 +12,7 @@
     <parent>
         <groupId>org.talend</groupId>
         <artifactId>org.talend.tos</artifactId>
-        <version>7.2.1-SNAPSHOT</version>
+        <version>7.2.1</version>
         <relativePath>../pom_server.xml</relativePath>
     </parent>
 

main/plugins/org.talend.commons.runtime/src/org/talend/commons/CommonsPlugin.java

@@ -17,6 +17,7 @@ import java.io.InputStream;
 import java.net.URL;
 
 import org.apache.commons.lang.ArrayUtils;
+import org.eclipse.core.net.proxy.IProxyService;
 import org.eclipse.core.runtime.FileLocator;
 import org.eclipse.core.runtime.Platform;
 import org.eclipse.core.runtime.preferences.InstanceScope;
@@ -24,6 +25,7 @@ import org.osgi.framework.Bundle;
 import org.osgi.framework.BundleActivator;
 import org.osgi.framework.BundleContext;
 import org.osgi.framework.ServiceReference;
+import org.osgi.util.tracker.ServiceTracker;
 import org.talend.commons.exception.ExceptionService;
 import org.talend.commons.runtime.debug.TalendDebugHandler;
 import org.talend.commons.utils.system.EclipseCommandLine;
@@ -55,6 +57,8 @@ public class CommonsPlugin implements BundleActivator {
     // TESB-17856: For commandline builds ESB Micorservice bundle
     private static boolean isESBMicorservice = false;
 
+    private static ServiceTracker proxyTracker;
+
     public static boolean isWorkbenchCreated() {
         return isWorkbenchCreated;
     }
@@ -176,4 +180,13 @@ public class CommonsPlugin implements BundleActivator {
         return FileLocator.toFileURL(entry);
     }
 
+    public static IProxyService getProxyService() {
+        if (proxyTracker == null) {
+            proxyTracker = new ServiceTracker(Platform.getBundle(PLUGIN_ID).getBundleContext(), IProxyService.class.getName(),
+                    null);
+            proxyTracker.open();
+        }
+        return (IProxyService) proxyTracker.getService();
+    }
+
 }

main/plugins/org.talend.commons.runtime/src/org/talend/commons/i18n/internal/messages.properties

@@ -58,3 +58,6 @@ AS400ResultSet.unknowCloumn=Invalid argument\: unknown column name
 AS400ResultSet.parameterIndex=Invalid argument\: parameter index
 AS400ResultSet.outofRange=\ is out of range.
 ITaCoKitService.exception.multipleInstance=More than one instance found: {0}
+TalendProxySelector.exception.badUriMap=Bad uri map: {0}
+TalendProxySelector.exception.proxySelectionError=Error occurs when selecting proxy for {0}
+

main/plugins/org.talend.commons.runtime/src/org/talend/commons/utils/network/TalendProxySelector.java

@@ -13,37 +13,211 @@
 package org.talend.commons.utils.network;
 
 import java.io.IOException;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.net.InetSocketAddress;
+import java.net.PasswordAuthentication;
 import java.net.Proxy;
 import java.net.ProxySelector;
 import java.net.SocketAddress;
 import java.net.URI;
+import java.net.URISyntaxException;
 import java.security.AccessController;
 import java.security.PrivilegedAction;
 import java.util.ArrayList;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.HashMap;
 import java.util.HashSet;
+import java.util.LinkedHashSet;
+import java.util.LinkedList;
 import java.util.List;
+import java.util.Map;
 import java.util.Set;
 
+import org.apache.commons.lang.StringUtils;
+import org.apache.log4j.Priority;
+import org.eclipse.core.internal.net.ProxyManager;
+import org.eclipse.core.net.proxy.IProxyService;
+import org.talend.commons.CommonsPlugin;
 import org.talend.commons.exception.ExceptionHandler;
+import org.talend.commons.i18n.internal.Messages;
+import org.talend.daikon.sandbox.properties.ClassLoaderIsolatedSystemProperties;
+
+import sun.net.spi.DefaultProxySelector;
 
 /**
  * DOC cmeng  class global comment. Detailled comment
  */
 public class TalendProxySelector extends ProxySelector {
 
+    public static final String PROP_PRINT_LOGS = "talend.studio.proxy.printLogs";
+
     private static final String ECLIPSE_PROXY_SELECTOR = ".EclipseProxySelector"; //$NON-NLS-1$
 
-    private ProxySelector defaultSelector;
+    private static final String PROP_ALLOW_PROXY_REDIRECT = "talend.studio.proxy.allowProxyRedirect";
 
-    final private List<IProxySelectorProvider> selectorProviders;
+    private static final String PROP_ALLOW_PROXY_REDIRECT_EXCLUDE = "talend.studio.proxy.redirect.whiteList";
+
+    private static final String PROP_EXECUTE_CONNECTION_FAILED = "talend.studio.proxy.executeConnectionFailed";
+
+    private static final String PROP_UPDATE_SYSTEM_PROPERTIES_FOR_JRE = "talend.studio.proxy.jre.updateSystemProperties";
+
+    private static final String PROP_CHECK_PROXY = "talend.studio.proxy.checkProxy";
+
+    private static final String PROP_VALIDATE_URI = "talend.studio.proxy.validateUri";
+
+    private static final String PROP_PROXY_SELECTOR = "talend.studio.proxy.selector";
+
+    private static final String PROP_PROXY_SELECTOR_DEFAULT = "default";
+
+    private static final String PROP_PROXY_SELECTOR_JRE = "jre";
+
+    private static final String PROP_PROXY_HOST_MAP = "talend.studio.proxy.hostMap";
+
+    private static final String PROP_DISABLE_DEFAULT_SELECTOR_PROVIDER = "talend.studio.proxy.disableDefaultSelectorProvider";
+
+    /**
+     * Example: update.talend.com,socket:http,https:http;nexus.talend.com,socket,http;,socket:http
+     */
+    private static final String PROP_PROXY_MAP_HOST_DEFAULT = "";
+
+    /**
+     * Example: svn.company.com;nexus.company.com
+     */
+    private static final String PROP_ALLOW_PROXY_REDIRECT_EXCLUDE_DEFAULT = "";
+
+    private static final String KEY_DEFAULT = ":default:";
+
+    private static Field uriHostField;
+
+    private static Method proxyManagerUpdateSystemPropertiesFunc;
+
+    private static boolean checkProxy = Boolean.valueOf(System.getProperty(PROP_CHECK_PROXY, Boolean.TRUE.toString()));
+
+    /**
+     * Note: eclipse default selector may be different between TOS and TIS, TOS may use jre one, TIS may use egit one
+     */
+    private ProxySelector eclipseDefaultSelector;
+
+    private ProxySelector jreDefaultSelector;
+
+    private EProxySelector eProxySelector;
+
+    final private Map<Object, Collection<IProxySelectorProvider>> selectorProviders;
+
+    private Map<String, Map<String, String>> hostMap;
+
+    private Set<String> redirectWhiteList;
 
     private volatile static TalendProxySelector instance;
 
     private static Object instanceLock = new Object();
 
-    private TalendProxySelector(final ProxySelector defaultSelector) {
-        this.defaultSelector = defaultSelector;
-        selectorProviders = new ArrayList<>();
+    private boolean printProxyLog = false;
+
+    private boolean allowProxyRedirect = false;
+
+    private boolean disableDefaultSelectorProvider = false;
+
+    private boolean validateUri = true;
+
+    private boolean executeConnectionFailed = true;
+
+    private boolean updateSystemPropertiesForJre = true;
+
+    private TalendProxySelector(final ProxySelector eclipseDefaultSelector) {
+        this.eclipseDefaultSelector = eclipseDefaultSelector;
+        this.jreDefaultSelector = new DefaultProxySelector();
+
+        selectorProviders = Collections.synchronizedMap(new HashMap<>());
+        allowProxyRedirect = Boolean.valueOf(System.getProperty(PROP_ALLOW_PROXY_REDIRECT, Boolean.FALSE.toString()));
+        disableDefaultSelectorProvider = Boolean
+                .valueOf(System.getProperty(PROP_DISABLE_DEFAULT_SELECTOR_PROVIDER, Boolean.FALSE.toString()));
+        printProxyLog = Boolean.valueOf(System.getProperty(PROP_PRINT_LOGS, Boolean.FALSE.toString()));
+        validateUri = Boolean.valueOf(System.getProperty(PROP_VALIDATE_URI, Boolean.TRUE.toString()));
+        executeConnectionFailed = Boolean.valueOf(System.getProperty(PROP_EXECUTE_CONNECTION_FAILED, Boolean.TRUE.toString()));
+        updateSystemPropertiesForJre = Boolean
+                .valueOf(System.getProperty(PROP_UPDATE_SYSTEM_PROPERTIES_FOR_JRE, Boolean.TRUE.toString()));
+
+        switch (System.getProperty(PROP_PROXY_SELECTOR, PROP_PROXY_SELECTOR_DEFAULT).toLowerCase()) {
+        case PROP_PROXY_SELECTOR_JRE:
+            this.eProxySelector = EProxySelector.jre;
+            break;
+        default:
+            this.eProxySelector = EProxySelector.eclipse_default;
+            break;
+        }
+
+        initHostMap();
+        initRedirectList();
+    }
+
+    private void initHostMap() {
+        try {
+            hostMap = new HashMap<>();
+            String property = System.getProperty(PROP_PROXY_HOST_MAP, PROP_PROXY_MAP_HOST_DEFAULT);
+            if (StringUtils.isEmpty(property)) {
+                return;
+            }
+            String[] splits = property.split(";");
+            for (String split : splits) {
+                try {
+                    int index = split.indexOf(',');
+                    String uri = split.substring(0, index);
+                    String key = StringUtils.strip(uri);
+                    if (StringUtils.isBlank(key)) {
+                        key = KEY_DEFAULT;
+                    }
+                    key = key.toLowerCase();
+                    Map<String, String> protocolMap = hostMap.get(key);
+                    if (protocolMap == null) {
+                        protocolMap = new HashMap<>();
+                        hostMap.put(key, protocolMap);
+                    }
+                    int protocolMapIndex = index + 1;
+                    String protocolMapStr = split.substring(protocolMapIndex);
+                    String[] entry = protocolMapStr.split(",");
+                    for (String pMap : entry) {
+                        try {
+                            String[] mapEntry = pMap.split(":");
+                            if (mapEntry.length != 2) {
+                                ExceptionHandler.process(
+                                        new Exception(Messages.getString("TalendProxySelector.exception.badUriMap", pMap)));
+                                continue;
+                            }
+                            protocolMap.put(mapEntry[0].toLowerCase(), mapEntry[1].toLowerCase());
+                        } catch (Exception e) {
+                            ExceptionHandler.process(e);
+                        }
+                    }
+                } catch (Exception e) {
+                    ExceptionHandler.process(e);
+                }
+            }
+        } catch (Exception e) {
+            ExceptionHandler.process(e);
+        }
+    }
+
+    private void initRedirectList() {
+        try {
+            redirectWhiteList = new HashSet<>();
+            String property = System.getProperty(PROP_ALLOW_PROXY_REDIRECT_EXCLUDE, PROP_ALLOW_PROXY_REDIRECT_EXCLUDE_DEFAULT);
+            if (StringUtils.isEmpty(property)) {
+                return;
+            }
+            String[] split = property.split(";");
+            for (String host : split) {
+                host = StringUtils.strip(host);
+                if (StringUtils.isBlank(host)) {
+                    host = KEY_DEFAULT;
+                }
+                redirectWhiteList.add(host);
+            }
+        } catch (Exception e) {
+            ExceptionHandler.process(e);
+        }
     }
 
     public static TalendProxySelector getInstance() {
@@ -58,6 +232,18 @@ public class TalendProxySelector extends ProxySelector {
             synchronized (instanceLock) {
                 if (instance == null) {
                     instance = new TalendProxySelector(proxySelector);
+                    try {
+                        uriHostField = URI.class.getDeclaredField("host");
+                        uriHostField.setAccessible(true);
+                    } catch (Exception e) {
+                        ExceptionHandler.process(e);
+                    }
+                    try {
+                        proxyManagerUpdateSystemPropertiesFunc = ProxyManager.class.getDeclaredMethod("updateSystemProperties");
+                        proxyManagerUpdateSystemPropertiesFunc.setAccessible(true);
+                    } catch (Exception e) {
+                        ExceptionHandler.process(e);
+                    }
                 }
             }
         }
@@ -70,19 +256,216 @@ public class TalendProxySelector extends ProxySelector {
                     return null;
                 }
             });
-            if (instance.getDefaultProxySelector() == null
+            if (instance.getEclipseDefaultSelector() == null
                     || (proxySelector != null && proxySelector.getClass().getName().endsWith(ECLIPSE_PROXY_SELECTOR))) {
-                instance.setDefaultProxySelector(proxySelector);
+                instance.setEclipseDefaultSelector(proxySelector);
             }
         }
 
         return instance;
     }
 
+    public static void checkProxy() {
+        if (!checkProxy) {
+            return;
+        }
+        try {
+            TalendProxySelector.getInstance();
+        } catch (Exception e) {
+            ExceptionHandler.process(e);
+        }
+    }
+
     @Override
     public List<Proxy> select(final URI uri) {
-        final Set<Proxy> resultFromProviders = new HashSet<>();
-        List<IProxySelectorProvider> providers = getProxySelectorProviders();
+        if (printProxyLog) {
+            ExceptionHandler.log("TalendProxySelector.select " + uri);
+        }
+        if (uri == null) {
+            return Collections.EMPTY_LIST;
+        }
+        URI validatedUri = validateUri(uri);
+        Set<Proxy> results = new LinkedHashSet<>();
+
+        try {
+            final Set<Proxy> resultFromProviders = getProxysFromProviders(validatedUri);
+            if (resultFromProviders != null && !resultFromProviders.isEmpty()) {
+                results.addAll(resultFromProviders);
+            }
+        } catch (Exception e) {
+            ExceptionHandler.process(e);
+        }
+        if (printProxyLog) {
+            ExceptionHandler.log("TalendProxySelector.resultFromProviders " + results);
+        }
+
+        ProxySelector defaultProxySelector = getDefaultProxySelector();
+        if (printProxyLog) {
+            ExceptionHandler.log("TalendProxySelector.defaultProxySelector " + defaultProxySelector);
+        }
+        if (defaultProxySelector != null) {
+            /**
+             * don't validate uri here, so that we can know whether it is an issue uri
+             */
+            URI newUri = getNewUri(validatedUri, false);
+            List<Proxy> defaultProxys = null;
+            if (validateUri && StringUtils.isBlank(newUri.getHost())) {
+                /**
+                 * If host is blank, force to use jre proxy selector to avoid the eclipse proxy selector bug
+                 */
+                defaultProxys = getJreProxySelector().select(newUri);
+            } else {
+                defaultProxys = defaultProxySelector.select(newUri);
+            }
+            if (printProxyLog) {
+                ExceptionHandler.log("TalendProxySelector.defaultProxys " + defaultProxys);
+            }
+            try {
+                results.addAll(filterProxys(validatedUri, defaultProxys));
+            } catch (Exception e) {
+                results.addAll(defaultProxys);
+                ExceptionHandler.process(e);
+            }
+        }
+        if (printProxyLog) {
+            String proxys = results.toString();
+            ExceptionHandler.log("Selected proxys for " + uri + ", " + proxys);
+            ExceptionHandler.process(new Exception("Proxy call stacks"), Priority.INFO);
+        }
+        return new LinkedList<Proxy>(results);
+    }
+
+    private URI validateUri(URI uri) {
+        if (!validateUri) {
+            return uri;
+        }
+
+        URI validatedUri = null;
+        try {
+            /**
+             * DON'T use URI.create(), MUST use the conductor which requires authority
+             */
+            validatedUri = new URI(uri.getScheme(), uri.getAuthority(), uri.getPath(), uri.getQuery(), uri.getFragment());
+
+            /**
+             * Validate the host, if the host is empty, it will cause the eclipse selector to return dirrect
+             */
+            if (StringUtils.isBlank(validatedUri.getHost())) {
+                String authority = validatedUri.getAuthority();
+                if (StringUtils.isNotBlank(authority)) {
+                    // example: https://u:p@www.company.com:8081/path/a?param=b
+                    String host = null;
+                    int userInfoIndex = authority.indexOf('@');
+                    if (0 <= userInfoIndex) {
+                        authority = authority.substring(userInfoIndex + 1);
+                    }
+                    int portIndex = authority.lastIndexOf(':');
+                    if (0 <= portIndex) {
+                        host = authority.substring(0, portIndex);
+                    }
+                    try {
+                        uriHostField.set(validatedUri, host);
+                    } catch (Exception e) {
+                        ExceptionHandler.process(e);
+                    }
+                }
+
+            }
+        } catch (Exception e) {
+            ExceptionHandler.process(e);
+            if (validatedUri == null) {
+                validatedUri = uri;
+            }
+        }
+        if (printProxyLog) {
+            ExceptionHandler.log("After validate: " + uri + " -> " + validatedUri);
+        }
+        return validatedUri;
+    }
+
+    private List<Proxy> filterProxys(final URI uri, List<Proxy> defaultProxys) {
+        List<Proxy> result = new ArrayList<>();
+        if (defaultProxys != null && !defaultProxys.isEmpty()) {
+            for (Proxy proxy : defaultProxys) {
+                SocketAddress addr = null;
+                Proxy.Type proxyType = null;
+                if (proxy != null) {
+                    proxyType = proxy.type();
+                    addr = proxy.address();
+                }
+
+                boolean redirect = true;
+                if (!allowProxyRedirect) {
+                    String host = uri.getHost();
+                    if (host == null) {
+                        host = "";
+                    }
+                    host = StringUtils.strip(host).toLowerCase();
+                    if (this.redirectWhiteList.contains(host) || this.redirectWhiteList.contains(KEY_DEFAULT)) {
+                        redirect = true;
+                    } else if (Proxy.Type.DIRECT == proxyType
+                            || (addr != null && StringUtils.equals(uri.getHost(), ((InetSocketAddress) addr).getHostString()))) {
+                        redirect = false;
+                    }
+                }
+                if (redirect) {
+                    result.add(proxy);
+                } else {
+                    result.add(Proxy.NO_PROXY);
+                }
+            }
+        }
+        return result;
+    }
+
+    private URI getNewUri(URI uri, boolean validateUri) {
+        URI newUri = uri;
+        if (newUri != null) {
+            try {
+                // get host before new URI, because the host may be set manually due to URI issue
+                String host = newUri.getHost();
+                newUri = new URI(newUri.getScheme(), newUri.getAuthority(), newUri.getPath(), newUri.getQuery(),
+                        newUri.getFragment());
+                Map<String, String> protocolMap = null;
+                if (StringUtils.isNotBlank(host)) {
+                    protocolMap = hostMap.get(host.toLowerCase());
+                }
+                if (protocolMap == null) {
+                    protocolMap = hostMap.get(KEY_DEFAULT);
+                }
+
+                if (protocolMap != null) {
+                    String schema = newUri.getScheme();
+                    if (schema != null) {
+                        String lowercasedProtocol = schema.toLowerCase();
+                        String preferedProtocol = protocolMap.get(lowercasedProtocol);
+                        if (StringUtils.isNotBlank(preferedProtocol)) {
+                            /**
+                             * Note: MUST use the constructor which requires authority, because some uri may be illegal,
+                             * then host info will be stored in authority field instead of host filed
+                             */
+                            newUri = new URI(preferedProtocol, newUri.getAuthority(), newUri.getPath(), newUri.getQuery(),
+                                    newUri.getFragment());
+                        }
+                    }
+                }
+            } catch (URISyntaxException e) {
+                if (printProxyLog) {
+                    ExceptionHandler.process(
+                            new Exception(Messages.getString("TalendProxySelector.exception.proxySelectionError", uri), e),
+                            Priority.WARN);
+                }
+            }
+        }
+        if (validateUri) {
+            newUri = validateUri(newUri);
+        }
+        return newUri;
+    }
+
+    private Set<Proxy> getProxysFromProviders(final URI uri) {
+        final Set<Proxy> resultFromProviders = new LinkedHashSet<>();
+        Collection<IProxySelectorProvider> providers = getCustomProviders(uri);
         if (providers != null) {
             providers.stream().forEach(p -> {
                 if (instance == p) {
@@ -100,49 +483,126 @@ public class TalendProxySelector extends ProxySelector {
                 }
             });
         }
-        List<Proxy> result = new ArrayList<>();
+        return resultFromProviders;
+    }
 
-        if (resultFromProviders != null && !resultFromProviders.isEmpty()) {
-            result.addAll(resultFromProviders);
-        }
-
-        ProxySelector defaultProxySelector = getDefaultProxySelector();
-        if (defaultProxySelector != null) {
-            List<Proxy> defaultProxys = defaultProxySelector.select(uri);
-            if (defaultProxys != null && !defaultProxys.isEmpty()) {
-                result.addAll(defaultProxys);
+    private Collection<IProxySelectorProvider> getCustomProviders(final URI uri) {
+        Collection<IProxySelectorProvider> providers = Collections.EMPTY_LIST;
+        Collection<Object> possibleKeys = getPossibleKeys(uri);
+        for (Object key : possibleKeys) {
+            providers = this.selectorProviders.get(key);
+            if (providers != null) {
+                break;
             }
         }
-        return result;
+        return providers;
+    }
+
+    public PasswordAuthentication getHttpPasswordAuthentication() {
+        String[] schemas = new String[] { "http", "https" };
+        for (String schema : schemas) {
+            String proxyUser = System.getProperty(schema + ".proxyUser");
+            String proxyPassword = System.getProperty(schema + ".proxyPassword");
+
+            if (StringUtils.isNotBlank(proxyUser)) {
+                char[] pwdChars = new char[0];
+                if (proxyPassword != null && !proxyPassword.isEmpty()) {
+                    pwdChars = proxyPassword.toCharArray();
+                }
+                return new PasswordAuthentication(proxyUser, pwdChars);
+            }
+        }
+        return null;
     }
 
     public boolean addProxySelectorProvider(IProxySelectorProvider provider) {
-        List<IProxySelectorProvider> proxySelectorProviders = getProxySelectorProviders();
-        if (!proxySelectorProviders.contains(provider)) {
-            return proxySelectorProviders.add(provider);
+        try {
+            Object key = provider.getKey();
+            Collection<IProxySelectorProvider> collection = this.selectorProviders.get(key);
+            if (collection == null) {
+                synchronized (this.selectorProviders) {
+                    collection = this.selectorProviders.get(key);
+                    if (collection == null) {
+                        collection = Collections.synchronizedList(new LinkedList<>());
+                        this.selectorProviders.put(key, collection);
+                    }
+                }
+            }
+            collection.add(provider);
+            return true;
+        } catch (Exception e) {
+            ExceptionHandler.process(e);
         }
         return false;
     }
 
     public boolean removeProxySelectorProvider(IProxySelectorProvider provider) {
-        return getProxySelectorProviders().remove(provider);
-    }
-
-    private List<IProxySelectorProvider> getProxySelectorProviders() {
-        return selectorProviders;
+        try {
+            Object key = provider.getKey();
+            Collection<IProxySelectorProvider> collection = this.selectorProviders.get(key);
+            if (collection != null) {
+                synchronized (this.selectorProviders) {
+                    collection = this.selectorProviders.get(key);
+                    if (collection != null) {
+                        collection.remove(provider);
+                        if (collection.isEmpty()) {
+                            this.selectorProviders.remove(key);
+                        }
+                    }
+                }
+            }
+            return true;
+        } catch (Exception e) {
+            ExceptionHandler.process(e);
+        }
+        return false;
     }
 
     public ProxySelector getDefaultProxySelector() {
-        return defaultSelector;
+        switch (eProxySelector) {
+        case jre:
+            return getJreProxySelector();
+        default:
+            return eclipseDefaultSelector;
+        }
     }
 
-    public void setDefaultProxySelector(final ProxySelector selector) {
-        defaultSelector = selector;
+    private ProxySelector getJreProxySelector() {
+        try {
+            /**
+             * for tcompv0, daikon may create an isolated system properties for it, so proxies may be ignored in the new
+             * system properties; here we try to call the method to add proxies into the isolated system properties
+             */
+            if (updateSystemPropertiesForJre && ClassLoaderIsolatedSystemProperties.getInstance()
+                    .isIsolated(Thread.currentThread().getContextClassLoader())) {
+                if (printProxyLog) {
+                    ExceptionHandler.log("Before update jre proxy system properties for the isolated classloader, http.proxyHost="
+                            + System.getProperty("http.proxyHost"));
+                }
+                IProxyService proxyService = CommonsPlugin.getProxyService();
+                proxyManagerUpdateSystemPropertiesFunc.invoke(proxyService);
+                if (printProxyLog) {
+                    ExceptionHandler.log("After updated jre proxy system properties for the isolated classloader, http.proxyHost="
+                            + System.getProperty("http.proxyHost"));
+                }
+            }
+        } catch (Throwable e) {
+            ExceptionHandler.process(e);
+        }
+        return this.jreDefaultSelector;
+    }
+
+    public ProxySelector getEclipseDefaultSelector() {
+        return eclipseDefaultSelector;
+    }
+
+    public void setEclipseDefaultSelector(ProxySelector eclipseDefaultSelector) {
+        this.eclipseDefaultSelector = eclipseDefaultSelector;
     }
 
     @Override
     public void connectFailed(final URI uri, final SocketAddress sa, final IOException ioe) {
-        List<IProxySelectorProvider> providers = getProxySelectorProviders();
+        Collection<IProxySelectorProvider> providers = getCustomProviders(uri);
         if (providers != null) {
             providers.stream().forEach(p -> {
                 if (p.canHandle(uri)) {
@@ -151,23 +611,35 @@ public class TalendProxySelector extends ProxySelector {
             });
         }
 
-        ProxySelector defaultProxySelector = getDefaultProxySelector();
-        if (defaultProxySelector != null) {
-            defaultProxySelector.connectFailed(uri, sa, ioe);
+        if (executeConnectionFailed) {
+            /**
+             * Just try to make the behavior of jre proxy selector same like eclipse proxy selector
+             */
+            ProxySelector defaultProxySelector = getDefaultProxySelector();
+            if (defaultProxySelector != null) {
+                defaultProxySelector.connectFailed(uri, sa, ioe);
+            }
         }
     }
 
-    public static abstract class AbstractProxySelectorProvider implements IProxySelectorProvider {
-
-        @Override
-        public void connectFailed(final URI uri, final SocketAddress sa, final IOException ioe) {
-            // nothing to do
+    public IProxySelectorProvider createDefaultProxySelectorProvider() {
+        if (disableDefaultSelectorProvider) {
+            return null;
         }
+        return new DefaultProxySelectorProvider(Thread.currentThread());
+    }
 
+    public IProxySelectorProvider createDefaultProxySelectorProvider(String host) {
+        if (disableDefaultSelectorProvider) {
+            return null;
+        }
+        return new DefaultProxySelectorProvider(host);
     }
 
     public static interface IProxySelectorProvider {
 
+        Object getKey();
+
         boolean canHandle(final URI uri);
 
         List<Proxy> select(final URI uri);
@@ -176,4 +648,120 @@ public class TalendProxySelector extends ProxySelector {
 
     }
 
+    public static abstract class AbstractProxySelectorProvider implements IProxySelectorProvider {
+
+        private boolean isDebugMode = CommonsPlugin.isDebugMode();
+
+        @Override
+        public Object getKey() {
+            return this;
+        }
+
+        @Override
+        public void connectFailed(final URI uri, final SocketAddress sa, final IOException ioe) {
+            if (isDebugMode) {
+                ExceptionHandler.process(ioe);
+            }
+        }
+
+    }
+
+    public static Collection<Object> getPossibleKeys(URI uri) {
+        Collection<Object> possibleKeys = new ArrayList<>();
+        possibleKeys.add(Thread.currentThread());
+        if (uri != null) {
+            String uriHost = uri.getHost();
+            if (StringUtils.isNotBlank(uriHost)) {
+                possibleKeys.add(uriHost);
+            }
+        }
+        return possibleKeys;
+    }
+
+    private enum EProxySelector {
+        eclipse_default,
+        jre
+    }
+
+    private class DefaultProxySelectorProvider extends TalendProxySelector.AbstractProxySelectorProvider {
+
+        private Thread currentThread = null;
+
+        private String host = null;
+
+        public DefaultProxySelectorProvider(Thread thread) {
+            this.currentThread = thread;
+        }
+
+        public DefaultProxySelectorProvider(String host) {
+            this.host = host;
+            if (StringUtils.isNotBlank(this.host)) {
+                this.host = this.host.toLowerCase();
+            }
+        }
+
+        @Override
+        public Object getKey() {
+            if (this.currentThread != null) {
+                return currentThread;
+            }
+            if (this.host != null) {
+                return this.host;
+            }
+            return super.getKey();
+        }
+
+        @Override
+        public boolean canHandle(URI uri) {
+            if (disableDefaultSelectorProvider) {
+                return false;
+            }
+            if (currentThread != null && Thread.currentThread() == currentThread) {
+                return true;
+            }
+            if (host != null) {
+                if (uri == null) {
+                    return false;
+                }
+                String uriHost = uri.getHost();
+                if (StringUtils.isNotBlank(uriHost)) {
+                    return this.host.equals(uriHost.toLowerCase());
+                }
+                return false;
+            }
+            return false;
+        }
+
+        @Override
+        public List<Proxy> select(URI uri) {
+            List<Proxy> result = new ArrayList<>();
+            try {
+                ProxySelector defaultProxySelector = getDefaultProxySelector();
+                if (defaultProxySelector != null) {
+                    List<Proxy> defaultProxys = defaultProxySelector.select(uri);
+                    if (defaultProxys != null && !defaultProxys.isEmpty()) {
+                        for (Proxy proxy : defaultProxys) {
+                            SocketAddress addr = null;
+                            Proxy.Type proxyType = null;
+                            if (proxy != null) {
+                                proxyType = proxy.type();
+                                addr = proxy.address();
+                            }
+                            if (Proxy.Type.DIRECT == proxyType || (addr != null
+                                    && StringUtils.equals(uri.getHost(), ((InetSocketAddress) addr).getHostString()))) {
+                                result.add(Proxy.NO_PROXY);
+                            } else {
+                                result.add(proxy);
+                            }
+                        }
+                    }
+                }
+            } catch (Exception e) {
+                ExceptionHandler.process(e);
+            }
+            return result;
+        }
+
+    }
+
 }

main/plugins/org.talend.commons.runtime/src/org/talend/commons/utils/resource/UpdatesHelper.java

@@ -58,6 +58,8 @@ public class UpdatesHelper {
 
     public static final String COMPONENT_SUFFIX = "_java.xml";
 
+    public static final String COMPONENT_TEMPLATES = "templates";
+
     public static final String NEW_COMPONENT_PREFIX = "installer$$";
 
     public static boolean existArtifacts(File base) {
@@ -296,6 +298,9 @@ public class UpdatesHelper {
 
     public static boolean isOldComponent(File f) {
         if (f != null && f.exists() && f.isDirectory()) {
+            if (f.getName().equals(COMPONENT_TEMPLATES)) {
+                return true;
+            }
             File[] listFiles = f.listFiles();
             if (listFiles != null) {
                 for (File subFile : listFiles) {

main/plugins/org.talend.commons.ui/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.commons.ui</artifactId>

main/plugins/org.talend.commons.ui/src/main/java/org/talend/commons/ui/swt/drawing/background/BackgroundRefresher.java

@@ -339,7 +339,7 @@ public class BackgroundRefresher implements IBackgroundRefresher {
             }
             if ((WindowSystem.isGTK() || EnvironmentUtils.isMacOsSytem()) && child instanceof Tree) {
                 returnedPoint.y += ((Tree) child).getHeaderHeight();
-                returnedPoint.y += ((Table) child).getItemHeight();
+                returnedPoint.y += ((Tree) child).getItemHeight();
             }
             child = child.getParent();
             ScrollBar vScrollBar = child.getVerticalBar();

main/plugins/org.talend.commons.ui/src/main/java/org/talend/commons/ui/swt/linking/TableToTreeLinker.java

@@ -104,7 +104,6 @@ public class TableToTreeLinker<D1, D2> extends BgDrawableComposite implements IB
         this.source = sourceTable;
 
         dataToTableItemCache = new DataToTableItemCache(sourceTable);
-
     }
 
     protected IStyleLink getDefaultStyleLink() {
@@ -232,7 +231,7 @@ public class TableToTreeLinker<D1, D2> extends BgDrawableComposite implements IB
 
             int yStraight = sourceToCommonPoint.y + treeItemHeight / 2 + tableItemBounds.y;
             pointEndStraight.x = sourceToCommonPoint.x + xStartBezierLink;
-            if (Platform.OS_MACOSX.equals(Platform.getOS())) {
+            if (Platform.OS_MACOSX.equals(Platform.getOS()) || Platform.OS_LINUX.equals(Platform.getOS())) {
                 pointStartStraight.x = sourceToCommonPoint.x + tableItem.getParent().getBounds().width;
                 pointEndStraight.x = pointStartStraight.x;
             } else {
@@ -311,10 +310,10 @@ public class TableToTreeLinker<D1, D2> extends BgDrawableComposite implements IB
                 // Added by Marvin Wang on Nov. 28, 2012 for bug TDI-23378. This is not the best way to fix this issue,
                 // but till now I have not found the root cause.
                 if (Platform.OS_LINUX.equals(Platform.getOS())) {
-                    pointEndCentralCurve.y = pointEndCentralCurve.y - tableItem.getBounds().height;
+                    pointEndCentralCurve.y = pointEndCentralCurve.y - tableItem.getBounds().height - treeItemHeight / 2;
                 }
                 if (Platform.OS_MACOSX.equals(Platform.getOS())) {
-                    pointEndCentralCurve.y = pointEndCentralCurve.y + tableItem.getBounds(0).height;
+                    pointEndCentralCurve.y = pointEndCentralCurve.y - tableItem.getBounds().height;
                 }
                 drawableLink.setPoint1(pointEndStraight);
                 drawableLink.setPoint2(pointEndCentralCurve);

main/plugins/org.talend.core.repository/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.core.repository</artifactId>

main/plugins/org.talend.core.repository/src/main/java/org/talend/core/repository/model/ProxyRepositoryFactory.java

@@ -70,6 +70,7 @@ import org.talend.commons.runtime.service.ITaCoKitService;
 import org.talend.commons.ui.gmf.util.DisplayUtils;
 import org.talend.commons.ui.runtime.exception.MessageBoxExceptionHandler;
 import org.talend.commons.utils.data.container.RootContainer;
+import org.talend.commons.utils.network.TalendProxySelector;
 import org.talend.commons.utils.time.TimeMeasure;
 import org.talend.commons.utils.workbench.resources.ResourceUtils;
 import org.talend.core.AbstractDQModelService;
@@ -2020,6 +2021,11 @@ public final class ProxyRepositoryFactory implements IProxyRepositoryFactory {
 
             TimeMeasure.begin("logOnProject"); //$NON-NLS-1$
             try {
+                /**
+                 * init/check proxy selector, in case default proxy selector is not registed yet
+                 */
+                TalendProxySelector.checkProxy();
+
                 System.getProperties().put("ReadOnlyUser", Boolean.FALSE.toString()); //$NON-NLS-1$
 
                 // remove the auto-build to enhance the build speed and application's use
@@ -2405,9 +2411,14 @@ public final class ProxyRepositoryFactory implements IProxyRepositoryFactory {
     @Override
     @SuppressWarnings("unchecked")
     public void executeRepositoryWorkUnit(RepositoryWorkUnit workUnit) {
+        checkProxySettings();
         this.repositoryFactoryFromProvider.executeRepositoryWorkUnit(workUnit);
     }
 
+    private void checkProxySettings() {
+        TalendProxySelector.checkProxy();
+    }
+
     @Override
     public void unloadResources(Property property) throws PersistenceException {
         repositoryFactoryFromProvider.unloadResources(property);

main/plugins/org.talend.core.repository/src/main/java/org/talend/core/repository/utils/ProjectHelper.java

@@ -131,4 +131,22 @@ public class ProjectHelper {
         }
         return null;
     }
+
+    /**
+     * define the different value for the project types the string value in the licence files Matcht the java enum name
+     * this is a copy of org.talend.commons.model.KeyConstants.ProjectType to avoid adding the all library
+     *
+     */
+    public static enum ProjectType {
+        DI,
+        DQ,
+        MDM;
+    }
+
+    public static int getProjectTypeOrdinal(org.talend.core.model.properties.Project project) {
+        if (project != null && project.getType() != null) {
+            return ProjectType.valueOf(project.getType()).ordinal();
+        }
+        return 0;
+    }
 }

main/plugins/org.talend.core.runtime/mappings/mapping_XSD.xml

@@ -29,6 +29,8 @@
 			<dbType type="xs:time" ignoreLen="true" ignorePre="true"/>
 			<dbType type="xs:decimal" ignoreLen="true" ignorePre="true"/>
 			<dbType type="xs:QName" ignoreLen="true" ignorePre="true"/>
+			<dbType type="xs:list" ignoreLen="true" ignorePre="true"/>
+			<dbType type="xs:union" ignoreLen="true" ignorePre="true"/>
 		</dbTypes>
 
 		<language name="java">
@@ -141,6 +143,12 @@
 				<dbType type="xs:time">
 					<talendType type="id_Date" default="true" />
 				</dbType>
+				<dbType type="xs:list">
+					<talendType type="id_List" default="true" />
+				</dbType>
+				<dbType type="xs:union">
+					<talendType type="id_Object" default="true" />
+				</dbType>
 			</dbToTalendTypes>
 		</language>
 	</dbms>

main/plugins/org.talend.core.runtime/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.core.runtime</artifactId>

main/plugins/org.talend.core.runtime/src/main/java/org/talend/core/IESBService.java

@@ -12,11 +12,14 @@
 // ============================================================================
 package org.talend.core;
 
+import java.util.List;
+
 import org.eclipse.ui.IEditorPart;
 import org.eclipse.ui.IWorkbenchPart;
 import org.talend.core.model.process.INode;
 import org.talend.core.model.process.IProcess;
 import org.talend.core.model.properties.Item;
+import org.talend.core.model.properties.ProcessItem;
 import org.talend.core.model.properties.Property;
 import org.talend.core.model.repository.ERepositoryObjectType;
 import org.talend.core.utils.IXSDPopulationUtil;
@@ -47,6 +50,8 @@ public interface IESBService extends IService {
 
     public StringBuffer getAllTheJObNames(IRepositoryNode jobList);
 
+    public List<String> getSerivceRelatedJobIds(Item serviceItem);
+
     public void deleteOldRelation(String jobID);
 
     // public void setSelectedItem(Item, )
@@ -59,6 +64,8 @@ public interface IESBService extends IService {
 
     public void copyDataServiceRelateJob(Item newItem);
 
+    public boolean isRESTService(ProcessItem processItem);
+
     public IXSDPopulationUtil getXSDPopulationUtil();
 
     public boolean isWSDLEditor(IWorkbenchPart part);

main/plugins/org.talend.core.runtime/src/main/java/org/talend/core/ILibraryManagerService.java

@@ -206,8 +206,12 @@ public interface ILibraryManagerService extends IService {
      */
     public boolean isJarNeedToBeDeployed(File jarFile);
 
+    public boolean isSameFile(File f1, File f2);
+
     public void checkModuleStatus(ModuleNeeded module);
 
     public String getJarNameFromMavenuri(String mavenURI);
 
+    public void guessMavenRUIFromIndex(File jarFile, Map<String, String> sourceAndMavenUri);
+
 }

main/plugins/org.talend.core.runtime/src/main/java/org/talend/core/database/conn/ConnParameterKeys.java

@@ -302,4 +302,11 @@ public class ConnParameterKeys {
 
     public static final String CONN_PARA_KEY_DATABRICKS_DBFS_DEP_FOLDER="CONN_PARA_KEY_DATABRICKS_DBFS_DEP_FOLDER";
 
+    /**
+     * Override hadoop configuration
+     */
+    public static final String CONN_PARA_KEY_SET_HADOOP_CONF = "CONN_PARA_KEY_SET_HADOOP_CONF";
+
+    public static final String CONN_PARA_KEY_HADOOP_CONF_SPECIFIC_JAR = "CONN_PARA_KEY_HADOOP_CONF_SPECIFIC_JAR";
+
 }

main/plugins/org.talend.core.runtime/src/main/java/org/talend/core/database/conn/DatabaseConnStrUtil.java

@@ -47,6 +47,8 @@ public class DatabaseConnStrUtil {
     // for match url has :<port> exist
     private static final String PATTERN_PORT = "(:\\d{1,5})";
 
+    private static final String DATABASE_STRING = "DATABASE=";
+
     private static String getStringReplace(final String init, final String before, final String after,
             final boolean supportContext) {
         return getStringReplace(init, before, after, supportContext, false);
@@ -127,6 +129,13 @@ public class DatabaseConnStrUtil {
                 } else {
                     s = getStringReplace(s, EDatabaseConnVar.PORT.getVariable(), port, supportContext);
                 }
+                if (EDatabaseConnTemplate.TERADATA.equals(connStr)) {
+                    if (StringUtils.isNotBlank(sid)) {
+                        s = getStringReplace(s, EDatabaseConnVar.SID.getVariable(), DATABASE_STRING + sid, supportContext);
+                    } else {
+                        s = getStringReplace(s, EDatabaseConnVar.SID.getVariable() + ",", sid, supportContext); //$NON-NLS-1$
+                    }
+                }
                 s = getStringReplace(s, EDatabaseConnVar.SID.getVariable(), sid, supportContext);
                 s = getStringReplace(s, EDatabaseConnVar.SERVICE_NAME.getVariable(), sid, supportContext);
                 s = getStringReplace(s, EDatabaseConnVar.DATASOURCE.getVariable(), datasource, supportContext);
@@ -565,7 +574,7 @@ public class DatabaseConnStrUtil {
         List<ERepositoryObjectType> extraTypes = new ArrayList<>();
         IGenericDBService dbService = null;
         if (GlobalServiceRegister.getDefault().isServiceRegistered(IGenericDBService.class)) {
-            dbService = (IGenericDBService) GlobalServiceRegister.getDefault().getService(IGenericDBService.class);
+            dbService = GlobalServiceRegister.getDefault().getService(IGenericDBService.class);
         }
         if (dbService != null) {
             extraTypes.addAll(dbService.getExtraTypes());

main/plugins/org.talend.core.runtime/src/main/java/org/talend/core/database/conn/version/EDatabaseVersion4Drivers.java

@@ -166,9 +166,9 @@ public enum EDatabaseVersion4Drivers {
     REDSHIFT(new DbVersion4Drivers(EDatabaseTypeName.REDSHIFT, "redshift", "REDSHIFT", //$NON-NLS-1$ //$NON-NLS-2$
             "redshift-jdbc42-no-awssdk-1.2.20.1043.jar")), //$NON-NLS-1$
     REDSHIFT_SSO(new DbVersion4Drivers(EDatabaseTypeName.REDSHIFT_SSO, "redshift sso", "REDSHIFT_SSO", //$NON-NLS-1$ //$NON-NLS-2$
-            new String[] { "redshift-jdbc42-no-awssdk-1.2.20.1043.jar", "aws-java-sdk-1.11.406.jar", "jackson-core-2.9.5.jar", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-                    "jackson-databind-2.9.5.jar", "jackson-annotations-2.9.0.jar", "httpcore-4.4.9.jar", "httpclient-4.5.5.jar", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$//$NON-NLS-4$
-                    "joda-time-2.8.1.jar", "commons-logging-1.1.3.jar" })), //$NON-NLS-1$ //$NON-NLS-2$
+            new String[] { "redshift-jdbc42-no-awssdk-1.2.20.1043.jar", "aws-java-sdk-1.11.406.jar", "jackson-core-2.9.9.jar", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+                    "jackson-databind-2.9.9.jar", "jackson-annotations-2.9.0.jar", "httpcore-4.4.9.jar", "httpclient-4.5.5.jar", //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$//$NON-NLS-4$
+                    "joda-time-2.8.1.jar", "commons-logging-1.1.3.jar", "commons-codec-1.6.jar" })), //$NON-NLS-1$ //$NON-NLS-2$
 
     AMAZON_AURORA(new DbVersion4Drivers(EDatabaseTypeName.AMAZON_AURORA, "mysql-connector-java-5.1.30-bin.jar")); //$NON-NLS-1$
 

main/plugins/org.talend.core.runtime/src/main/java/org/talend/core/hadoop/HadoopClassLoaderFactory2.java

@@ -12,9 +12,13 @@
 // ============================================================================
 package org.talend.core.hadoop;
 
+import java.io.File;
 import java.net.MalformedURLException;
+import java.util.Optional;
 import java.util.Set;
+import java.util.function.Consumer;
 
+import org.apache.commons.lang.StringUtils;
 import org.talend.commons.exception.ExceptionHandler;
 import org.talend.core.classloader.ClassLoaderFactory;
 import org.talend.core.classloader.DynamicClassLoader;
@@ -67,9 +71,18 @@ public class HadoopClassLoaderFactory2 {
         return getClassLoader(relatedClusterId, EHadoopCategory.HBASE, distribution, version, useKrb);
     }
 
-    public static ClassLoader getHadoopCustomClassLoader(String uid, Object customJars) {
-        return HadoopClassLoaderFactory2.builder().withTypePrefix(EHadoopCategory.CUSTOM.getName()).withUid(uid)
-                .build(customJars, true);
+    public static ClassLoader getHadoopCustomClassLoader(String uid, String relatedClusterId, EHadoopCategory category,
+            Object customJars, boolean useKrb) {
+        ClassLoader classLoader = HadoopClassLoaderFactory2.builder().withTypePrefix(EHadoopCategory.CUSTOM.getName())
+                .withUid(uid).build(customJars, true);
+        if (StringUtils.isNotBlank(relatedClusterId) && classLoader instanceof DynamicClassLoader) {
+            try {
+                classLoader = addExtraJars(relatedClusterId, category, (DynamicClassLoader) classLoader, useKrb);
+            } catch (MalformedURLException e) {
+                ExceptionHandler.process(e);
+            }
+        }
+        return classLoader;
     }
 
     public static ClassLoader getHCatalogClassLoader(String relatedClusterId, String distribution, String version, boolean useKrb) {
@@ -198,16 +211,35 @@ public class HadoopClassLoaderFactory2 {
             String[] addedJars = null;
             String[] excludedJars = null;
             String[] securityJars = getSecurityJars(category);
-            String customConfsJarName = hadoopClusterService.getCustomConfsJarName(relatedClusterId);
-            if (customConfsJarName != null) {
-                addedJars = new String[] { customConfsJarName };
+
+            Optional<HadoopConfJarBean> customConfsJar = hadoopClusterService.getCustomConfsJar(relatedClusterId);
+            HadoopConfJarBean confJarBean = customConfsJar.orElse(null);
+            String customConfsJarName = customConfsJar.map(b -> b.getCustomConfJarName()).orElse(null);
+            Consumer<DynamicClassLoader> afterLoaded = null;
+            if (confJarBean != null) {
+                if (confJarBean.isOverrideCustomConf()) {
+                    String overrideCustomConfPath = confJarBean.getOriginalOverrideCustomConfPath();
+                    if (StringUtils.isBlank(overrideCustomConfPath) || !new File(overrideCustomConfPath).exists()) {
+                        ExceptionHandler.process(
+                                new Exception("Set Hadoop configuration JAR path is invalid: " + overrideCustomConfPath));
+                    } else {
+                        afterLoaded = (t) -> t.addLibrary(overrideCustomConfPath);
+                    }
+                } else {
+                    if (StringUtils.isNotBlank(customConfsJarName)) {
+                        addedJars = new String[] { customConfsJarName };
+                    }
+                }
                 excludedJars = securityJars;
             } else if (useKrb) {
                 addedJars = securityJars;
                 excludedJars = new String[] { customConfsJarName };
             }
-            if (addedJars != null || excludedJars != null) {
+            if (addedJars != null || excludedJars != null || afterLoaded != null) {
                 cll = DynamicClassLoader.createNewOneBaseLoader(loader, addedJars, excludedJars);
+                if (afterLoaded != null) {
+                    afterLoaded.accept(cll);
+                }
             }
         }
 

main/plugins/org.talend.core.runtime/src/main/java/org/talend/core/hadoop/HadoopConfJarBean.java

@@ -0,0 +1,92 @@
+// ============================================================================
+//
+// Copyright (C) 2006-2019 Talend Inc. - www.talend.com
+//
+// This source code is available under agreement available at
+// %InstallDIR%\features\org.talend.rcp.branding.%PRODUCTNAME%\%PRODUCTNAME%license.txt
+//
+// You should have received a copy of the agreement
+// along with this program; if not, write to Talend SA
+// 9 rue Pages 92150 Suresnes, France
+//
+// ============================================================================
+package org.talend.core.hadoop;
+
+/**
+ * DOC cmeng  class global comment. Detailled comment
+ */
+public class HadoopConfJarBean {
+
+    private boolean overrideCustomConf;
+
+    private boolean isContextMode;
+
+    /**
+     * value saved in connection, it may be a context
+     */
+    private String overrideCustomConfPath;
+
+    /**
+     * original value of the path, if connection is in context mode, then this value if the default value of the context
+     */
+    private String originalOverrideCustomConfPath;
+
+    private String customConfJarName;
+
+    public HadoopConfJarBean(boolean isContextMode, boolean overrideCustomConf, String overrideCustomConfPath,
+            String originalOverrideCustomConfPath, String customConfJarName) {
+        this.isContextMode = isContextMode;
+        this.overrideCustomConf = overrideCustomConf;
+        this.overrideCustomConfPath = overrideCustomConfPath;
+        this.originalOverrideCustomConfPath = originalOverrideCustomConfPath;
+        this.customConfJarName = customConfJarName;
+    }
+
+    public boolean isContextMode() {
+        return isContextMode;
+    }
+
+    public void setContextMode(boolean isContextMode) {
+        this.isContextMode = isContextMode;
+    }
+
+    public boolean isOverrideCustomConf() {
+        return overrideCustomConf;
+    }
+
+    public void setOverrideCustomConf(boolean overrideCustomConf) {
+        this.overrideCustomConf = overrideCustomConf;
+    }
+
+    public String getOriginalOverrideCustomConfPath() {
+        return originalOverrideCustomConfPath;
+    }
+
+    public void setOriginalOverrideCustomConfPath(String originalOverrideCustomConfPath) {
+        this.originalOverrideCustomConfPath = originalOverrideCustomConfPath;
+    }
+
+    public String getOverrideCustomConfPath() {
+        return overrideCustomConfPath;
+    }
+
+    public void setOverrideCustomConfPath(String overrideCustomConfPath) {
+        this.overrideCustomConfPath = overrideCustomConfPath;
+    }
+
+    public String getCustomConfJarName() {
+        return customConfJarName;
+    }
+
+    public void setCustomConfJarName(String customConfJarName) {
+        this.customConfJarName = customConfJarName;
+    }
+
+    @Override
+    public String toString() {
+        return "HadoopConfJarBean [overrideCustomConf=" + overrideCustomConf + ", isContextMode=" + isContextMode
+                + ", overrideCustomConfPath=" + overrideCustomConfPath + ", originalOverrideCustomConfPath="
+                + originalOverrideCustomConfPath + ", customConfJarName=" + customConfJarName + "]";
+    }
+
+}

main/plugins/org.talend.core.runtime/src/main/java/org/talend/core/hadoop/IHadoopClusterService.java

@@ -14,6 +14,7 @@ package org.talend.core.hadoop;
 
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 
 import org.eclipse.core.runtime.IPath;
 import org.talend.commons.exception.BusinessException;
@@ -232,11 +233,12 @@ public interface IHadoopClusterService extends IService {
      */
     public Item getHadoopClusterItemById(String id);
 
-    public String getCustomConfsJarName(String id);
+    public Optional<HadoopConfJarBean> getCustomConfsJar(String id);
 
-    public String getCustomConfsJarName(String id, boolean createJarIfNotExist, boolean addExtraIds);
+    public Optional<HadoopConfJarBean> getCustomConfsJar(String id, boolean createJarIfNotExist, boolean addExtraIds);
 
-    public String getCustomConfsJarName(ConnectionItem connectionItem, boolean createJarIfNotExist, boolean addExtraIds);
+    public Optional<HadoopConfJarBean> getCustomConfsJar(ConnectionItem connectionItem, boolean createJarIfNotExist,
+            boolean addExtraIds);
 
     public void useCustomConfsJarIfNeeded(List<ModuleNeeded> modulesNeeded, String clusterId);
 

main/plugins/org.talend.core.runtime/src/main/java/org/talend/core/model/components/IComponent.java

@@ -60,6 +60,15 @@ public interface IComponent {
 
     public String getOriginalName();
 
+    /**
+     * Only for component display (palette,search)
+     * 
+     * @return
+     */
+    default public String getDisplayName() {
+        return getName();
+    }
+
     public String getLongName();
 
     public String getOriginalFamilyName();

main/plugins/org.talend.core.runtime/src/main/java/org/talend/core/model/metadata/MetadataTable.java

@@ -153,7 +153,7 @@ public class MetadataTable implements IMetadataTable, Cloneable {
             List<IMetadataColumn> temp = new ArrayList<IMetadataColumn>();
             temp.addAll(this.listColumns);
             temp.addAll(this.unusedColumns);
-            if (originalColumns != null) {
+            if (originalColumns != null && isRepository) {
                 Collections.sort(temp, new Comparator<IMetadataColumn>() {
 
                     @Override

main/plugins/org.talend.core.runtime/src/main/java/org/talend/core/model/routines/RoutineLibraryMananger.java

@@ -13,6 +13,7 @@
 package org.talend.core.model.routines;
 
 import java.io.File;
+import java.io.IOException;
 import java.net.URI;
 import java.net.URL;
 import java.util.ArrayList;
@@ -31,9 +32,12 @@ import org.osgi.framework.Bundle;
 import org.talend.commons.utils.resource.FileExtensions;
 import org.talend.core.GlobalServiceRegister;
 import org.talend.core.ILibraryManagerService;
-import org.talend.core.ISVNProviderServiceInCoreRuntime;
-import org.talend.core.PluginChecker;
 import org.talend.core.model.general.LibraryInfo;
+import org.talend.core.nexus.ArtifactRepositoryBean;
+import org.talend.core.nexus.TalendLibsServerManager;
+import org.talend.core.runtime.maven.MavenArtifact;
+import org.talend.core.runtime.maven.MavenConstants;
+import org.talend.core.runtime.maven.MavenUrlHelper;
 
 /**
  * wchen class global comment. Detailled comment
@@ -96,9 +100,12 @@ public class RoutineLibraryMananger {
                                 try {
                                     URL fileUrl = FileLocator.toFileURL(entry);
                                     if(fileUrl != null){
-                                    	if (!"file".equals(fileUrl.getProtocol())) throw new IllegalArgumentException();
-                                    	URI fileUri = new File(fileUrl.getFile()).toURI();
-                                        libManagerService.deploy(fileUri);
+                                        if (!"file".equals(fileUrl.getProtocol())) throw new IllegalArgumentException();
+                                        File file = new File(fileUrl.getFile());
+                                        if (needDeploy(fileUrl)) {
+                                            URI fileUri = file.toURI();
+                                            libManagerService.deploy(fileUri);
+                                        }
                                     }
                                 } catch (Exception e) {
                                     log.warn("Cannot deploy: " + bundleName + path);
@@ -114,6 +121,56 @@ public class RoutineLibraryMananger {
         }
     }
 
+    private boolean needDeploy(URL fileUrl) throws IOException, Exception {
+        File file = new File(fileUrl.getFile());
+        ILibraryManagerService libManagerService = null;
+        if (GlobalServiceRegister.getDefault().isServiceRegistered(ILibraryManagerService.class)) {
+            libManagerService = (ILibraryManagerService) GlobalServiceRegister.getDefault()
+                    .getService(ILibraryManagerService.class);
+        }
+        if (libManagerService != null) {
+            Map<String, String> sourceAndMavenUri = new HashMap<>();
+            libManagerService.guessMavenRUIFromIndex(file, sourceAndMavenUri);
+            String mavUri = null;
+            boolean isSnapshot = false;
+            for (String key : sourceAndMavenUri.keySet()) {
+                if (sourceAndMavenUri.get(key).equals(file.getPath())) {
+                    mavUri = key;
+                    break;
+                }
+            }
+            if (mavUri == null) {
+                return true;
+            }
+            final MavenArtifact parseMvnUrl = MavenUrlHelper.parseMvnUrl(mavUri);
+            if (parseMvnUrl != null) {
+                if (parseMvnUrl.getVersion() != null && parseMvnUrl.getVersion().endsWith(MavenConstants.SNAPSHOT)) {
+                    isSnapshot = true;
+                }
+            }
+            TalendLibsServerManager manager = TalendLibsServerManager.getInstance();
+            ArtifactRepositoryBean customNexusServer = manager.getCustomNexusServer();
+            File jarFile = null;
+            try {
+                jarFile = libManagerService.resolveJar(customNexusServer, mavUri);
+            } catch (Exception ex) {
+                // Ignore here
+            }
+            boolean exist = (jarFile != null && jarFile.exists());
+            if (exist) {
+                if (isSnapshot) {
+                    boolean isSame = libManagerService.isSameFile(jarFile, file);
+                    if (!isSame) {
+                        return true;
+                    }
+                }
+            } else {
+                return true;
+            }
+        }
+        return false;
+    }
+
     public Map<String, List<LibraryInfo>> getRoutineAndJars() {
         if (routineAndJars == null) {
             routineAndJars = new HashMap<String, List<LibraryInfo>>();

main/plugins/org.talend.core.runtime/src/main/java/org/talend/core/model/utils/ParameterValueUtil.java

@@ -77,21 +77,24 @@ public final class ParameterValueUtil {
                 }
             }
         } else if (param.getValue() instanceof List) { // for TABLE
-            List<Map<String, Object>> tableValues = (List<Map<String, Object>>) param.getValue();
-            for (Map<String, Object> line : tableValues) {
-                for (String key : line.keySet()) {
-                    Object cellValue = line.get(key);
-                    if (cellValue instanceof String) { // cell is text so
-                        // rename data if
-                        // needed
-                        String value = (String) cellValue;
-                        if (value.contains(oldName)) {
-                            // line.put(key, value.replaceAll(oldName,
-                            // newName));
-                            // String newValue = renameValues(value, oldName, newName, flag);
-                            String newValue = splitQueryData(oldName, newName, value);
-                            if (!value.equals(newValue)) {
-                                line.put(key, newValue);
+            List tableValues = (List) param.getValue();
+            for (Object current : tableValues) {
+                if (current != null && current instanceof Map) {
+                    Map<String, Object> line = (Map<String, Object>) current;
+                    for (String key : line.keySet()) {
+                        Object cellValue = line.get(key);
+                        if (cellValue instanceof String) { // cell is text so
+                            // rename data if
+                            // needed
+                            String value = (String) cellValue;
+                            if (value.contains(oldName)) {
+                                // line.put(key, value.replaceAll(oldName,
+                                // newName));
+                                // String newValue = renameValues(value, oldName, newName, flag);
+                                String newValue = splitQueryData(oldName, newName, value);
+                                if (!value.equals(newValue)) {
+                                    line.put(key, newValue);
+                                }
                             }
                         }
                     }
@@ -721,13 +724,22 @@ public final class ParameterValueUtil {
                 return true;
             }
         } else if (param.getValue() instanceof List) { // for TABLE
-            List<Map<String, Object>> tableValues = (List<Map<String, Object>>) param.getValue();
-            for (Map<String, Object> line : tableValues) {
-                for (String key : line.keySet()) {
-                    Object cellValue = line.get(key);
-                    if (cellValue instanceof String) { // cell is text so
-                        // test data
-                        if (ParameterValueUtil.valueContains((String) cellValue, name)) {
+            List tableValues = (List) param.getValue();
+            for (Object current : tableValues) {
+                if (current != null) {
+                    if (current instanceof Map) {
+                        Map<String, Object> line = (Map<String, Object>) current;
+                        for (String key : line.keySet()) {
+                            Object cellValue = line.get(key);
+                            if (cellValue instanceof String) { // cell is text so
+                                // test data
+                                if (ParameterValueUtil.valueContains((String) cellValue, name)) {
+                                    return true;
+                                }
+                            }
+                        }
+                    } else if (current instanceof String) {
+                        if (ParameterValueUtil.valueContains((String) current, name)) {
                             return true;
                         }
                     }

main/plugins/org.talend.core.runtime/src/main/java/org/talend/core/nexus/HttpClientTransport.java

@@ -12,14 +12,12 @@
 // ============================================================================
 package org.talend.core.nexus;
 
-import java.net.Authenticator;
 import java.net.InetSocketAddress;
 import java.net.PasswordAuthentication;
 import java.net.Proxy;
 import java.net.Proxy.Type;
 import java.net.URI;
 import java.net.URISyntaxException;
-import java.util.ArrayList;
 import java.util.List;
 
 import org.apache.commons.lang.StringUtils;
@@ -37,7 +35,6 @@ import org.eclipse.core.runtime.IProgressMonitor;
 import org.eclipse.core.runtime.NullProgressMonitor;
 import org.eclipse.core.runtime.OperationCanceledException;
 import org.talend.commons.exception.BusinessException;
-import org.talend.commons.exception.ExceptionHandler;
 import org.talend.commons.utils.network.TalendProxySelector;
 import org.talend.commons.utils.network.TalendProxySelector.IProxySelectorProvider;
 import org.talend.core.runtime.CoreRuntimePlugin;
@@ -167,7 +164,7 @@ public abstract class HttpClientTransport {
         }
     }
 
-    private IProxySelectorProvider addProxy(final DefaultHttpClient httpClient, URI requestURI) {
+    public static IProxySelectorProvider addProxy(final DefaultHttpClient httpClient, URI requestURI) {
         IProxySelectorProvider proxySelectorProvider = null;
         try {
             if (Boolean.valueOf(System.getProperty(PROP_PROXY_HTTP_CLIENT_USE_DEFAULT_SETTINGS, Boolean.FALSE.toString()))) {
@@ -185,10 +182,10 @@ public abstract class HttpClientTransport {
                 }
                 final Proxy finalProxy = usedProxy;
                 InetSocketAddress address = (InetSocketAddress) finalProxy.address();
-                String proxyServer = address.getHostName();
+                String proxyServer = address.getHostString();
                 int proxyPort = address.getPort();
-                PasswordAuthentication proxyAuthentication = Authenticator.requestPasswordAuthentication(proxyServer,
-                        address.getAddress(), proxyPort, "Http Proxy", "Http proxy authentication", null);
+                TalendProxySelector proxySelector = TalendProxySelector.getInstance();
+                PasswordAuthentication proxyAuthentication = proxySelector.getHttpPasswordAuthentication();
                 if (proxyAuthentication != null) {
                     String proxyUser = proxyAuthentication.getUserName();
                     if(StringUtils.isNotBlank(proxyUser)){
@@ -203,7 +200,7 @@ public abstract class HttpClientTransport {
                 }
                 HttpHost proxyHost = new HttpHost(proxyServer, proxyPort);
                 httpClient.getParams().setParameter(ConnRoutePNames.DEFAULT_PROXY, proxyHost);
-                proxySelectorProvider = createProxySelectorProvider();
+                proxySelectorProvider = proxySelector.createDefaultProxySelectorProvider();
             }
             return proxySelectorProvider;
         } finally {
@@ -213,61 +210,12 @@ public abstract class HttpClientTransport {
         }
     }
 
-    private void removeProxy(IProxySelectorProvider proxySelectorProvider) {
+    public static void removeProxy(IProxySelectorProvider proxySelectorProvider) {
         if (proxySelectorProvider != null) {
             TalendProxySelector.getInstance().removeProxySelectorProvider(proxySelectorProvider);
         }
     }
 
-    private IProxySelectorProvider createProxySelectorProvider() {
-        IProxySelectorProvider proxySelectorProvider = new TalendProxySelector.AbstractProxySelectorProvider() {
-
-            private Thread currentThread = Thread.currentThread();
-
-            @Override
-            public List<Proxy> select(URI uri) {
-                // return Collections.EMPTY_LIST;
-
-                List<Proxy> newProxys = new ArrayList<>();
-                if (uri == null) {
-                    return newProxys;
-                }
-                String schema = uri.getScheme();
-                if (schema != null && schema.toLowerCase().startsWith("socket")) { //$NON-NLS-1$
-                    try {
-                        URI newUri = new URI("https", uri.getUserInfo(), uri.getHost(), uri.getPort(), uri.getPath(),
-                                uri.getQuery(), uri.getFragment());
-                        List<Proxy> proxys = TalendProxySelector.getInstance().getDefaultProxySelector().select(newUri);
-                        if (proxys != null && !proxys.isEmpty()) {
-                            newProxys.addAll(proxys);
-                        } else {
-                            newUri = new URI("http", uri.getUserInfo(), uri.getHost(), uri.getPort(), uri.getPath(),
-                                    uri.getQuery(), uri.getFragment());
-                            proxys = TalendProxySelector.getInstance().getDefaultProxySelector().select(newUri);
-                            if (proxys != null && !proxys.isEmpty()) {
-                                newProxys.addAll(proxys);
-                            }
-                        }
-                    } catch (URISyntaxException e) {
-                        ExceptionHandler.process(e);
-                    }
-                }
-                return newProxys;
-
-            }
-
-            @Override
-            public boolean canHandle(URI uri) {
-                if (Thread.currentThread() == currentThread) {
-                    return true;
-                }
-                return false;
-            }
-
-        };
-        return proxySelectorProvider;
-    }
-
     public void processResponseCode(HttpResponse response) throws BusinessException {
         StatusLine statusLine = response.getStatusLine();
         int responseCode = statusLine.getStatusCode();

main/plugins/org.talend.core.runtime/src/main/java/org/talend/core/nexus/TalendMavenResolver.java

@@ -24,6 +24,9 @@ import org.osgi.framework.ServiceReference;
 import org.osgi.service.cm.ManagedService;
 import org.osgi.util.tracker.ServiceTracker;
 import org.osgi.util.tracker.ServiceTrackerCustomizer;
+import org.talend.commons.exception.ExceptionHandler;
+import org.talend.commons.utils.network.TalendProxySelector;
+import org.talend.commons.utils.network.TalendProxySelector.IProxySelectorProvider;
 import org.talend.core.runtime.CoreRuntimePlugin;
 
 /**
@@ -102,7 +105,24 @@ public class TalendMavenResolver {
     }
 
     public static File resolve(String mvnUri) throws IOException, RuntimeException {
-        return getMavenResolver().resolve(mvnUri);
+        TalendProxySelector selectorInstance = null;
+        IProxySelectorProvider proxySelector = null;
+        try {
+            try {
+                selectorInstance = TalendProxySelector.getInstance();
+                proxySelector = selectorInstance.createDefaultProxySelectorProvider();
+                if (proxySelector != null) {
+                    selectorInstance.addProxySelectorProvider(proxySelector);
+                }
+            } catch (Exception e) {
+                ExceptionHandler.process(e);
+            }
+            return getMavenResolver().resolve(mvnUri);
+        } finally {
+            if (proxySelector != null && selectorInstance != null) {
+                selectorInstance.removeProxySelectorProvider(proxySelector);
+            }
+        }
     }
 
     public static void upload(String groupId, String artifactId, String classifier, String extension, String version,

main/plugins/org.talend.core.runtime/src/main/java/org/talend/core/runtime/maven/MavenArtifact.java

@@ -24,7 +24,7 @@ public class MavenArtifact implements Cloneable {
     private static final char ARTIFACT_SEPARATOR = '-';
 
     private String repositoryUrl, groupId, artifactId, version, type, classifier, description, url, license, licenseUrl,
-            distribution, username, password, lastUpdated;
+            distribution, username, password, lastUpdated, sha1, md5;
 
     public String getLastUpdated() {
         return this.lastUpdated;
@@ -138,6 +138,22 @@ public class MavenArtifact implements Cloneable {
         this.password = password;
     }
 
+    public String getSha1() {
+        return sha1;
+    }
+
+    public void setSha1(String sha1) {
+        this.sha1 = sha1;
+    }
+
+    public String getMd5() {
+        return md5;
+    }
+
+    public void setMd5(String md5) {
+        this.md5 = md5;
+    }
+
     /**
      *
      * DOC ggu Comment method "getFileName".

main/plugins/org.talend.core.runtime/src/main/java/org/talend/core/runtime/process/LastGenerationInfo.java

@@ -19,6 +19,7 @@ import java.util.Set;
 
 import org.talend.core.model.general.ModuleNeeded;
 import org.talend.core.model.process.JobInfo;
+import org.talend.core.model.process.ProcessUtils;
 
 /**
  * DOC nrousseau class global comment. Detailled comment
@@ -78,7 +79,7 @@ public class LastGenerationInfo {
      * @return the modulesNeededPerJob
      */
     public Set<ModuleNeeded> getModulesNeededWithSubjobPerJob(String jobId, String jobVersion) {
-        String key = jobId + "_" + jobVersion; //$NON-NLS-1$
+        String key = this.getProcessKey(jobId, jobVersion);
         if (!modulesNeededWithSubjobPerJob.containsKey(key)) {
             modulesNeededWithSubjobPerJob.put(key, new HashSet<ModuleNeeded>());
         }
@@ -90,7 +91,7 @@ public class LastGenerationInfo {
      * @return the modulesNeededPerJob
      */
     public Set<ModuleNeeded> getModulesNeededPerJob(String jobId, String jobVersion) {
-        String key = jobId + "_" + jobVersion; //$NON-NLS-1$
+        String key = this.getProcessKey(jobId, jobVersion);
         if (!modulesNeededPerJob.containsKey(key)) {
             modulesNeededPerJob.put(key, new HashSet<ModuleNeeded>());
         }
@@ -103,7 +104,7 @@ public class LastGenerationInfo {
      * @return the contextPerJob
      */
     public Set<String> getContextPerJob(String jobId, String jobVersion) {
-        String key = jobId + "_" + jobVersion; //$NON-NLS-1$
+        String key = this.getProcessKey(jobId, jobVersion);
         if (!contextPerJob.containsKey(key)) {
             contextPerJob.put(key, new HashSet<String>());
         }
@@ -116,7 +117,7 @@ public class LastGenerationInfo {
      * @param modulesNeededPerJob the modulesNeededPerJob to set
      */
     public void setModulesNeededPerJob(String jobId, String jobVersion, Set<ModuleNeeded> modulesNeeded) {
-        String key = jobId + "_" + jobVersion; //$NON-NLS-1$
+        String key = this.getProcessKey(jobId, jobVersion); 
         modulesNeededPerJob.put(key, new HashSet<ModuleNeeded>(modulesNeeded));
     }
 
@@ -125,8 +126,8 @@ public class LastGenerationInfo {
      *
      * @param modulesNeededWithSubjobPerJob the modulesNeededWithSubjobPerJob to set
      */
-    public void setModulesNeededWithSubjobPerJob(String jobId, String jobVersion, Set<ModuleNeeded> modulesNeeded) {
-        String key = jobId + "_" + jobVersion; //$NON-NLS-1$
+    public void setModulesNeededWithSubjobPerJob(String jobId, String jobVersion, Set<ModuleNeeded> modulesNeeded) {      
+        String key = this.getProcessKey(jobId, jobVersion);
         if (modulesNeeded == null) {
             modulesNeededWithSubjobPerJob.put(key, null);
         } else {
@@ -140,17 +141,17 @@ public class LastGenerationInfo {
      * @param contextPerJob the contextPerJob to set
      */
     public void setContextPerJob(String jobId, String jobVersion, Set<String> contexts) {
-        String key = jobId + "_" + jobVersion; //$NON-NLS-1$
+        String key = this.getProcessKey(jobId, jobVersion); 
         contextPerJob.put(key, new HashSet<String>(contexts));
     }
 
     public void setUseDynamic(String jobId, String jobVersion, boolean dynamic) {
-        String key = jobId + "_" + jobVersion; //$NON-NLS-1$
+        String key = this.getProcessKey(jobId, jobVersion); 
         useDynamic.put(key, dynamic);
     }
 
     public boolean isUseDynamic(String jobId, String jobVersion) {
-        String key = jobId + "_" + jobVersion; //$NON-NLS-1$
+        String key = this.getProcessKey(jobId, jobVersion); 
         if (!useDynamic.containsKey(key)) {
             return false;
         }
@@ -162,12 +163,12 @@ public class LastGenerationInfo {
     }
 
     public void setUseRules(String jobId, String jobVersion, boolean useRules) {
-        String key = jobId + "_" + jobVersion; //$NON-NLS-1$
+        String key = this.getProcessKey(jobId, jobVersion); 
         this.useRules.put(key, useRules);
     }
 
     public boolean isUseRules(String jobId, String jobVersion) {
-        String key = jobId + "_" + jobVersion; //$NON-NLS-1$
+        String key = this.getProcessKey(jobId, jobVersion); 
         if (!useRules.containsKey(key)) {
             return false;
         }
@@ -179,12 +180,12 @@ public class LastGenerationInfo {
     }
 
     public void setUsePigUDFs(String jobId, String jobVersion, boolean useRules) {
-        String key = jobId + "_" + jobVersion; //$NON-NLS-1$
+        String key = this.getProcessKey(jobId, jobVersion); 
         this.usedPigUDFs.put(key, useRules);
     }
 
     public boolean isUsePigUDFs(String jobId, String jobVersion) {
-        String key = jobId + "_" + jobVersion; //$NON-NLS-1$
+        String key = this.getProcessKey(jobId, jobVersion); 
         if (!usedPigUDFs.containsKey(key)) {
             return false;
         }
@@ -251,7 +252,7 @@ public class LastGenerationInfo {
      * @return the modulesNeededPerJob
      */
     public Set<String> getRoutinesNeededPerJob(String jobId, String jobVersion) {
-        String key = jobId + "_" + jobVersion; //$NON-NLS-1$
+        String key = this.getProcessKey(jobId, jobVersion);
         if (!routinesNeededPerJob.containsKey(key)) {
             routinesNeededPerJob.put(key, new HashSet<String>());
         }
@@ -279,7 +280,8 @@ public class LastGenerationInfo {
     }
 
     private String getProcessKey(String jobId, String jobVersion) {
-        return jobId + "_" + jobVersion; //$NON-NLS-1$
+        String pureJobId = ProcessUtils.getPureItemId(jobId);
+        return pureJobId + "_" + jobVersion; //$NON-NLS-1$
     }
 
     /**
@@ -288,7 +290,7 @@ public class LastGenerationInfo {
      * @return the pigudfNeededPerJob
      */
     public Set<String> getPigudfNeededPerJob(String jobId, String jobVersion) {
-        String key = jobId + "_" + jobVersion; //$NON-NLS-1$
+        String key = this.getProcessKey(jobId, jobVersion);
         if (!pigudfNeededPerJob.containsKey(key)) {
             pigudfNeededPerJob.put(key, new HashSet<String>());
         }
@@ -302,7 +304,7 @@ public class LastGenerationInfo {
      * @param modulesNeededPerJob the modulesNeededPerJob to set
      */
     public void setRoutinesNeededPerJob(String jobId, String jobVersion, Set<String> modulesNeeded) {
-        String key = jobId + "_" + jobVersion; //$NON-NLS-1$
+        String key = this.getProcessKey(jobId, jobVersion);
         routinesNeededPerJob.put(key, new HashSet<String>(modulesNeeded));
     }
 
@@ -312,7 +314,7 @@ public class LastGenerationInfo {
      * @param pigudfNeededPerJob the pigudfNeededPerJob to set
      */
     public void setPigudfNeededPerJob(String jobId, String jobVersion, Set<String> modulesNeeded) {
-        String key = jobId + "_" + jobVersion; //$NON-NLS-1$
+        String key = this.getProcessKey(jobId, jobVersion);
         pigudfNeededPerJob.put(key, new HashSet<String>(modulesNeeded));
     }
 
@@ -321,7 +323,7 @@ public class LastGenerationInfo {
      * @return the modulesNeededPerJob
      */
     public Set<String> getRoutinesNeededWithSubjobPerJob(String jobId, String jobVersion) {
-        String key = jobId + "_" + jobVersion; //$NON-NLS-1$
+        String key = this.getProcessKey(jobId, jobVersion);
         if (!routinesNeededWithSubjobPerJob.containsKey(key)) {
             routinesNeededWithSubjobPerJob.put(key, new HashSet<String>());
         }
@@ -334,7 +336,7 @@ public class LastGenerationInfo {
      * @return the pigudfNeededWithSubjobPerJob
      */
     public Set<String> getPigudfNeededWithSubjobPerJob(String jobId, String jobVersion) {
-        String key = jobId + "_" + jobVersion; //$NON-NLS-1$
+        String key = this.getProcessKey(jobId, jobVersion);
         if (!pigudfNeededWithSubjobPerJob.containsKey(key)) {
             pigudfNeededWithSubjobPerJob.put(key, new HashSet<String>());
         }
@@ -348,7 +350,7 @@ public class LastGenerationInfo {
      * @param modulesNeededPerJob the modulesNeededPerJob to set
      */
     public void setRoutinesNeededWithSubjobPerJob(String jobId, String jobVersion, Set<String> modulesNeeded) {
-        String key = jobId + "_" + jobVersion; //$NON-NLS-1$
+        String key = this.getProcessKey(jobId, jobVersion);
         routinesNeededWithSubjobPerJob.put(key, new HashSet<String>(modulesNeeded));
     }
 
@@ -358,7 +360,7 @@ public class LastGenerationInfo {
      * @param pigudfNeededWithSubjobPerJob the pigudfNeededWithSubjobPerJob to set
      */
     public void setPigudfNeededWithSubjobPerJob(String jobId, String jobVersion, Set<String> modulesNeeded) {
-        String key = jobId + "_" + jobVersion; //$NON-NLS-1$
+        String key = this.getProcessKey(jobId, jobVersion);
         pigudfNeededWithSubjobPerJob.put(key, new HashSet<String>(modulesNeeded));
     }
 

main/plugins/org.talend.core.runtime/src/main/java/org/talend/designer/codegen/AbstractRoutineSynchronizer.java

@@ -19,7 +19,9 @@ import java.util.Collection;
 import java.util.Collections;
 import java.util.Date;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Map;
+import java.util.Set;
 
 import org.eclipse.core.resources.IFile;
 import org.eclipse.core.resources.IFolder;
@@ -79,6 +81,8 @@ public abstract class AbstractRoutineSynchronizer implements ITalendSynchronizer
     }
 
     private Collection<RoutineItem> getAll(ERepositoryObjectType type, boolean syncRef) throws SystemException {
+        // init code project
+        getRunProcessService().getTalendCodeJavaProject(type);
         // remove routine with same name in reference project
         final Map<String, RoutineItem> beansList = new HashMap<String, RoutineItem>();
         for (IRepositoryViewObject obj : getRepositoryService().getProxyRepositoryFactory().getAll(type)) {
@@ -95,27 +99,37 @@ public abstract class AbstractRoutineSynchronizer implements ITalendSynchronizer
         return (IRepositoryService) GlobalServiceRegister.getDefault().getService(IRepositoryService.class);
     }
 
-    private void getReferencedProjectRoutine(final Map<String, RoutineItem> beansList, final Project project,
-            ERepositoryObjectType routineType, boolean syncRef) throws SystemException {
-        for (IRepositoryViewObject obj : getRepositoryService().getProxyRepositoryFactory().getAll(project, routineType)) {
+    private Set<IRepositoryViewObject> getReferencedProjectRoutine(final Map<String, RoutineItem> beansList,
+            final Project project, ERepositoryObjectType routineType, boolean syncRef) throws SystemException {
+        // init ref code project
+        if (syncRef) {
+            getRunProcessService().getTalendCodeJavaProject(routineType, project.getTechnicalLabel());
+        }
+        Set<IRepositoryViewObject> routines = new HashSet<>();
+        routines.addAll(getRepositoryService().getProxyRepositoryFactory().getAll(project, routineType));
+        for (IRepositoryViewObject obj : routines) {
             final String key = obj.getProperty().getLabel();
             // it does not have a routine with same name
             if (!beansList.containsKey(key)) {
                 beansList.put(key, (RoutineItem) obj.getProperty().getItem());
             }
-            if (syncRef) {
-                // sync routine
-                syncRoutine((RoutineItem) obj.getProperty().getItem(), false, true, true);
-            }
+        }
+        for (ProjectReference projectReference : project.getProjectReferenceList()) {
+            routines.addAll(getReferencedProjectRoutine(beansList, new Project(projectReference.getReferencedProject()),
+                    routineType, syncRef));
         }
         if (syncRef) {
+            routines.stream().forEach(obj -> {
+                try {
+                    syncRoutine((RoutineItem) obj.getProperty().getItem(), project.getTechnicalLabel(), true, true);
+                } catch (SystemException e) {
+                    ExceptionHandler.process(e);
+                }
+            });
             // sync system routine
             syncSystemRoutine(project);
         }
-
-        for (ProjectReference projectReference : project.getProjectReferenceList()) {
-            getReferencedProjectRoutine(beansList, new Project(projectReference.getReferencedProject()), routineType, syncRef);
-        }
+        return routines;
     }
 
     protected void syncSystemRoutine(Project project) throws SystemException {
@@ -128,24 +142,17 @@ public abstract class AbstractRoutineSynchronizer implements ITalendSynchronizer
     }
 
     protected IFile getRoutineFile(RoutineItem routineItem) throws SystemException {
-        return getRoutineFile(routineItem, true);
+        return getRoutineFile(routineItem, ProjectManager.getInstance().getCurrentProject().getTechnicalLabel());
     }
 
-    protected IFile getRoutineFile(RoutineItem routineItem, boolean currentProject) throws SystemException {
-        String projectTechName;
-        if (currentProject) {
-            projectTechName = ProjectManager.getInstance().getCurrentProject().getTechnicalLabel();
-        } else {
-            projectTechName = ProjectManager.getInstance().getProject(routineItem).getTechnicalLabel();
-        }
+    protected IFile getRoutineFile(RoutineItem routineItem, String projectTechName) throws SystemException {
         ITalendProcessJavaProject talendProcessJavaProject = getRunProcessService()
                 .getTalendCodeJavaProject(ERepositoryObjectType.getItemType(routineItem), projectTechName);
         if (talendProcessJavaProject == null) {
             return null;
         }
         IFolder routineFolder = talendProcessJavaProject.getSrcSubFolder(null, routineItem.getPackageType());
-        IFile file = routineFolder.getFile(routineItem.getProperty().getLabel() + JavaUtils.JAVA_EXTENSION);
-        return file;
+        return routineFolder.getFile(routineItem.getProperty().getLabel() + JavaUtils.JAVA_EXTENSION);
     }
 
     private IFile getProcessFile(ProcessItem item) throws SystemException {
@@ -193,30 +200,31 @@ public abstract class AbstractRoutineSynchronizer implements ITalendSynchronizer
 
     @Override
     public void syncRoutine(RoutineItem routineItem, boolean copyToTemp) throws SystemException {
-        syncRoutine(routineItem, true, copyToTemp, false);
+        syncRoutine(routineItem, ProjectManager.getInstance().getCurrentProject().getTechnicalLabel(), copyToTemp, false);
     }
 
     @Override
     public void syncRoutine(RoutineItem routineItem, boolean copyToTemp, boolean forceUpdate) throws SystemException {
-        syncRoutine(routineItem, true, copyToTemp, forceUpdate);
+        syncRoutine(routineItem, ProjectManager.getInstance().getCurrentProject().getTechnicalLabel(), copyToTemp, forceUpdate);
     }
 
     @Override
-    public void syncRoutine(RoutineItem routineItem, boolean currentProject, boolean copyToTemp, boolean forceUpdate) throws SystemException {
+    public void syncRoutine(RoutineItem routineItem, String projectTechName, boolean copyToTemp, boolean forceUpdate)
+            throws SystemException {
         boolean needSync = false;
         if (routineItem != null) {
             if (forceUpdate || !isRoutineUptodate(routineItem)) {
                 needSync = true;
             } else {
-                IFile file = getRoutineFile(routineItem, currentProject);
+                IFile file = getRoutineFile(routineItem, projectTechName);
                 if (file != null && !file.exists()) {
                     needSync = true;
                 }
             }
         }
         if (needSync) {
-            doSyncRoutine(routineItem, currentProject, copyToTemp);
-            if (currentProject) {
+            doSyncRoutine(routineItem, projectTechName, copyToTemp);
+            if (ProjectManager.getInstance().getCurrentProject().getTechnicalLabel().equals(projectTechName)) {
                 setRoutineAsUptodate(routineItem);
             }
         }
@@ -224,14 +232,14 @@ public abstract class AbstractRoutineSynchronizer implements ITalendSynchronizer
 
     public void syncRoutine(RoutineItem routineItem) throws SystemException {
         if (routineItem != null) {
-            doSyncRoutine(routineItem, true, true);
+            doSyncRoutine(routineItem, ProjectManager.getInstance().getCurrentProject().getTechnicalLabel(), true);
             setRoutineAsUptodate(routineItem);
         }
     }
 
-    private void doSyncRoutine(RoutineItem routineItem, boolean currentProject, boolean copyToTemp) throws SystemException {
+    private void doSyncRoutine(RoutineItem routineItem, String projectTechName, boolean copyToTemp) throws SystemException {
         try {
-            IFile file = getRoutineFile(routineItem, currentProject);
+            IFile file = getRoutineFile(routineItem, projectTechName);
             if (file == null) {
                 return;
             }
@@ -374,7 +382,7 @@ public abstract class AbstractRoutineSynchronizer implements ITalendSynchronizer
     @Override
     public void syncAllBeansForLogOn() throws SystemException {
         for (RoutineItem beanItem : getBeans(true)) {
-            syncRoutine(beanItem, true, true, true);
+            syncRoutine(beanItem, true, true);
         }
     }
 

main/plugins/org.talend.core.runtime/src/main/java/org/talend/designer/codegen/ITalendSynchronizer.java

@@ -45,7 +45,8 @@ public interface ITalendSynchronizer {
 
     void syncRoutine(RoutineItem routineItem, boolean copyToTemp, boolean forceUpdate) throws SystemException;
 
-    void syncRoutine(RoutineItem routineItem, boolean currentProject, boolean copyToTemp, boolean forceUpdate) throws SystemException;
+    void syncRoutine(RoutineItem routineItem, String projectTechName, boolean copyToTemp, boolean forceUpdate)
+            throws SystemException;
 
     IFile getFile(Item item) throws SystemException;
 

main/plugins/org.talend.core.runtime/src/main/java/org/talend/designer/core/IDesignerCoreService.java

@@ -195,4 +195,7 @@ public interface IDesignerCoreService extends IService {
     public void setTACReadTimeout(int timeout);
 
     boolean isDelegateNode(INode node);
+
+    boolean isNeedContextInJar(IProcess process);
+
 }

main/plugins/org.talend.core.runtime/src/main/java/org/talend/designer/runprocess/IRunProcessService.java

@@ -216,6 +216,8 @@ public interface IRunProcessService extends IService {
 
     ITalendProcessJavaProject getTalendJobJavaProject(Property property);
 
+    IFolder getCodeSrcFolder(ERepositoryObjectType type, String projectTechName);
+
     ITalendProcessJavaProject getTempJavaProject();
 
     void clearProjectRelatedSettings();

main/plugins/org.talend.core.runtime/src/main/java/org/talend/designer/runprocess/ItemCacheManager.java

@@ -71,7 +71,12 @@ public class ItemCacheManager {
             processItem = getRefProcessItem(ProjectManager.getInstance().getCurrentProject(), parsedArray[1]);
         } else {
             Project project = ProjectManager.getInstance().getProjectFromProjectTechLabel(parsedArray[0]);
-            processItem = getProcessItem(project, parsedArray[1]);
+            if (project != null) {
+                processItem = getProcessItem(project, parsedArray[1]);
+            }
+            if (processItem == null) {
+                processItem = getRefProcessItem(ProjectManager.getInstance().getCurrentProject(), parsedArray[1]);
+            }
         }
         return processItem;
     }
@@ -112,7 +117,12 @@ public class ItemCacheManager {
             refProcessItem = getRefProcessItem(ProjectManager.getInstance().getCurrentProject(), parsedArray[1], version);
         } else {
             Project project = ProjectManager.getInstance().getProjectFromProjectTechLabel(parsedArray[0]);
-            refProcessItem = getProcessItem(project, parsedArray[1], version);
+            if (project != null) {
+                refProcessItem = getProcessItem(project, parsedArray[1], version);
+            }
+            if (refProcessItem == null) {
+                refProcessItem = getRefProcessItem(ProjectManager.getInstance().getCurrentProject(), parsedArray[1], version);
+            }
         }
         return refProcessItem;
     }

main/plugins/org.talend.core.runtime/src/main/java/org/talend/repository/ProjectManager.java

@@ -200,6 +200,10 @@ public final class ProjectManager {
      * return all the referenced projects of current project.
      */
     public List<Project> getAllReferencedProjects(boolean force) {
+        return getAllReferencedProjects(getCurrentProject(), force);
+    }
+
+    public List<Project> getAllReferencedProjects(Project targetProject, boolean force) {
         List<Project> allReferencedprojects = new ArrayList<Project>();
         if (GlobalServiceRegister.getDefault().isServiceRegistered(IProxyRepositoryService.class)) {
             if (this.getCurrentProject() == null) {
@@ -212,7 +216,7 @@ public final class ProjectManager {
             IProxyRepositoryFactory factory = service.getProxyRepositoryFactory();
             if (factory != null) {
                 List<org.talend.core.model.properties.Project> rProjects = factory
-                        .getReferencedProjects(this.getCurrentProject());
+                        .getReferencedProjects(targetProject);
                 if (rProjects != null) {
                     for (org.talend.core.model.properties.Project p : rProjects) {
                         Project project = new Project(p);

main/plugins/org.talend.core.runtime/src/main/java/org/talend/repository/model/RepositoryConstants.java

@@ -98,6 +98,8 @@ public class RepositoryConstants {
 
     public static final String REPOSITORY_CLOUD_APAC_ID = "cloud_apac"; //$NON-NLS-1$
 
+    public static final String REPOSITORY_CLOUD_US_WEST_ID = "cloud_us_west"; //$NON-NLS-1$
+
     public static final String REPOSITORY_CLOUD_CUSTOM_ID = "cloud_custom"; //$NON-NLS-1$
 
     public static final String REPOSITORY_URL = "url"; //$NON-NLS-1$

main/plugins/org.talend.core.ui/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.core.ui</artifactId>

main/plugins/org.talend.core/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.core</artifactId>

main/plugins/org.talend.core/src/main/java/org/talend/core/CoreService.java

@@ -54,6 +54,7 @@ import org.talend.core.model.metadata.QueryUtil;
 import org.talend.core.model.metadata.builder.ConvertionHelper;
 import org.talend.core.model.metadata.builder.connection.MetadataTable;
 import org.talend.core.model.process.ElementParameterParser;
+import org.talend.core.model.process.ProcessUtils;
 import org.talend.core.model.properties.Item;
 import org.talend.core.model.relationship.RelationshipItemBuilder;
 import org.talend.core.model.repository.IRepositoryViewObject;
@@ -280,9 +281,10 @@ public class CoreService implements ICoreService {
             ICodeGeneratorService codeGenService = (ICodeGeneratorService) GlobalServiceRegister.getDefault().getService(
                     ICodeGeneratorService.class);
             codeGenService.createRoutineSynchronizer().syncAllRoutinesForLogOn();
-            codeGenService.createRoutineSynchronizer().syncAllPigudfForLogOn();
+            if (ProcessUtils.isRequiredPigUDFs(null)) {
+                codeGenService.createRoutineSynchronizer().syncAllPigudfForLogOn();
+            }
         }
-
     }
 
     @Override

main/plugins/org.talend.core/src/main/java/org/talend/core/model/components/conversions/RenameComponentConversion.java

@@ -43,7 +43,7 @@ public class RenameComponentConversion implements IComponentConversion {
         replaceAllInAllNodesParameterValue(item, oldNodeUniqueName, newNodeUniqueName);
     }
 
-    private static void replaceAllInAllNodesParameterValue(ProcessType item, String oldName, String newName) {
+    protected static void replaceAllInAllNodesParameterValue(ProcessType item, String oldName, String newName) {
         for (Object o : item.getNode()) {
             NodeType nt = (NodeType) o;
             ComponentUtilities.replaceInNodeParameterValue(nt, oldName, newName);

main/plugins/org.talend.core/src/main/java/org/talend/core/model/components/conversions/RenameETLJDBCComponentConversion.java

@@ -0,0 +1,40 @@
+// ============================================================================
+//
+// Copyright (C) 2006-2019 Talend Inc. - www.talend.com
+//
+// This source code is available under agreement available at
+// %InstallDIR%\features\org.talend.rcp.branding.%PRODUCTNAME%\%PRODUCTNAME%license.txt
+//
+// You should have received a copy of the agreement
+// along with this program; if not, write to Talend SA
+// 9 rue Pages 92150 Suresnes, France
+//
+// ============================================================================
+package org.talend.core.model.components.conversions;
+
+import org.talend.core.model.components.ComponentUtilities;
+import org.talend.designer.core.model.utils.emf.talendfile.NodeType;
+import org.talend.designer.core.model.utils.emf.talendfile.ProcessType;
+
+public class RenameETLJDBCComponentConversion extends RenameComponentConversion{
+
+    private String newName;
+    
+    private String oldName;
+
+    public RenameETLJDBCComponentConversion(String newName, String oldName) {
+        super(newName);
+        this.newName = newName;
+        this.oldName = oldName;
+    }
+
+    public void transform(NodeType node) {
+        node.setComponentName(newName);
+        ProcessType item = (ProcessType) node.eContainer();
+        String oldNodeUniqueName = ComponentUtilities.getNodeUniqueName(node);
+        String newNodeUniqueName = oldNodeUniqueName.replaceAll(oldName, newName);
+        ComponentUtilities.setNodeUniqueName(node, newNodeUniqueName);
+        replaceAllInAllNodesParameterValue(item, oldNodeUniqueName, newNodeUniqueName);
+    }
+
+}

main/plugins/org.talend.core/src/main/java/org/talend/core/model/utils/ProcessStreamTrashReaderUtil.java

@@ -204,7 +204,7 @@ public final class ProcessStreamTrashReaderUtil {
                         String line = null;
                         while ((line = reader.readLine()) != null) {
                             System.out.println("getErrorStream " + line); //$NON-NLS-1$
-                            if(line.startsWith("log4j:WARN")){
+                            if(line.startsWith("log4j:WARN") || line.startsWith("SLF4J:")){
                                 continue;
                             }
                             buffer.append(line);

main/plugins/org.talend.core/src/main/java/org/talend/designer/runprocess/ProcessorUtilities.java

@@ -64,6 +64,8 @@ import org.talend.core.language.LanguageManager;
 import org.talend.core.model.components.ComponentCategory;
 import org.talend.core.model.components.EComponentType;
 import org.talend.core.model.components.IComponent;
+import org.talend.core.model.components.IComponentsFactory;
+import org.talend.core.model.components.IComponentsService;
 import org.talend.core.model.general.ModuleNeeded;
 import org.talend.core.model.general.Project;
 import org.talend.core.model.metadata.IMetadataColumn;
@@ -81,6 +83,7 @@ import org.talend.core.model.process.JobInfo;
 import org.talend.core.model.process.ProcessUtils;
 import org.talend.core.model.process.ReplaceNodesInProcessProvider;
 import org.talend.core.model.properties.Item;
+import org.talend.core.model.properties.JobletProcessItem;
 import org.talend.core.model.properties.ProcessItem;
 import org.talend.core.model.properties.Property;
 import org.talend.core.model.relationship.Relation;
@@ -170,6 +173,8 @@ public class ProcessorUtilities {
 
     private static boolean isDebug = false;
 
+    private static boolean isCIMode = false;
+
     private static JobInfo mainJobInfo;
 
     public static void addOpenEditor(IEditorPart editor) {
@@ -613,28 +618,55 @@ public class ProcessorUtilities {
         return processor;
     }
 
-    private static boolean checkLoopDependencies(Relation mainJobInfo, Map<String, String> idToLastestVersionMap)
+    public static boolean checkLoopDependencies(Relation mainJobInfo, Map<String, String> idToLastestVersionMap)
             throws ProcessorException {
         List<Relation> itemsJobRelatedTo = getItemsRelation(mainJobInfo, idToLastestVersionMap);
         List<Relation> relationChecked = new ArrayList<>();
         relationChecked.add(mainJobInfo);
-        return checkLoopDependencies(mainJobInfo, itemsJobRelatedTo, relationChecked, idToLastestVersionMap);
+        return checkLoopDependencies(mainJobInfo, mainJobInfo, itemsJobRelatedTo, relationChecked, idToLastestVersionMap);
     }
 
-    private static boolean checkLoopDependencies(Relation mainRelation, List<Relation> itemsJobRelatedTo,
+    private static boolean checkLoopDependencies(Relation mainRelation, Relation currentRelation,
+            List<Relation> itemsJobRelatedTo,
             List<Relation> relationChecked, Map<String, String> idToLastestVersionMap) throws ProcessorException {
         boolean hasDependency = false;
         for (Relation relation : itemsJobRelatedTo) {
+            try {
+                // means the tRunjob deactivate, or one of the specific version tRunjon deactivate, skip
+                Map<String, Set<String>> actTrunjobHM = getActivateTRunjobMap(currentRelation.getId(),
+                        currentRelation.getVersion());
+                if (actTrunjobHM.get(relation.getId()) == null
+                        || !actTrunjobHM.get(relation.getId()).contains(relation.getVersion())) {
+                    continue;
+                }
+            } catch (Exception e) {
+                throw new ProcessorException(e);
+            }
+
             hasDependency = relation.getId().equals(mainRelation.getId())
                     && relation.getVersion().equals(mainRelation.getVersion());
             if (!hasDependency) {
                 List<Relation> itemsChildJob = getItemsRelation(relation, idToLastestVersionMap);
                 if (!relationChecked.contains(relation)) {
                     relationChecked.add(relation);
-                    hasDependency = checkLoopDependencies(mainRelation, itemsChildJob, relationChecked, idToLastestVersionMap);
+                    hasDependency = checkLoopDependencies(mainRelation, relation, itemsChildJob, relationChecked,
+                            idToLastestVersionMap);
                 }
                 if (!hasDependency) {
                     for (Relation childRelation : itemsChildJob) {
+
+                        try {
+                            // means the tRunjob deactivate, or one of the specific version tRunjon deactivate, skip
+                            Map<String, Set<String>> activateTRunjobMap = getActivateTRunjobMap(relation.getId(),
+                                    relation.getVersion());
+                            if (activateTRunjobMap.get(childRelation.getId()) == null
+                                    || !activateTRunjobMap.get(childRelation.getId()).contains(childRelation.getVersion())) {
+                                continue;
+                            }
+                        } catch (Exception e) {
+                            throw new ProcessorException(e);
+                        }
+
                         hasDependency = checkLoopDependencies(childRelation, idToLastestVersionMap);
                         if (hasDependency) {
                             break;
@@ -650,6 +682,133 @@ public class ProcessorUtilities {
         return hasDependency;
     }
 
+    private static Map<String, Set<String>> getActivateTRunjobMap(String id, String version) throws PersistenceException {
+        Map<String, Set<String>> actTrunjobHM = new HashMap<String, Set<String>>();
+        ProcessType processType = null;
+        try {
+            IRepositoryViewObject currentJobObject = ProxyRepositoryFactory.getInstance().getSpecificVersion(id, version, true);
+            if (currentJobObject != null) {
+                Item item = currentJobObject.getProperty().getItem();
+                if (item instanceof ProcessItem) {
+                    processType = ((ProcessItem) item).getProcess();
+                } else if (item instanceof JobletProcessItem) {
+                    processType = ((JobletProcessItem) item).getJobletProcess();
+                }
+            }
+        } catch (PersistenceException e) {
+            ExceptionHandler.process(e);
+        }
+        if (processType != null) {
+            List<Project> allProjects = new ArrayList<Project>();
+            allProjects.add(ProjectManager.getInstance().getCurrentProject());
+            allProjects.addAll(ProjectManager.getInstance().getAllReferencedProjects());
+
+            List<String> jobletsComponentsList = new ArrayList<String>();
+            IComponentsFactory componentsFactory = null;
+            if (GlobalServiceRegister.getDefault().isServiceRegistered(IComponentsService.class)) {
+                IComponentsService compService = (IComponentsService) GlobalServiceRegister.getDefault()
+                        .getService(IComponentsService.class);
+                if (compService != null) {
+                    componentsFactory = compService.getComponentsFactory();
+                    for (IComponent component : componentsFactory.readComponents()) {
+                        if (component.getComponentType() == EComponentType.JOBLET) {
+                            jobletsComponentsList.add(component.getName());
+                        }
+                    }
+                }
+            }
+
+            String jobletPaletteType = null;
+            String frameWork = processType.getFramework();
+            if (StringUtils.isBlank(frameWork)) {
+                jobletPaletteType = ComponentCategory.CATEGORY_4_DI.getName();
+            } else if (frameWork.equals(HadoopConstants.FRAMEWORK_SPARK)) {
+                jobletPaletteType = ComponentCategory.CATEGORY_4_SPARK.getName();
+            } else if (frameWork.equals(HadoopConstants.FRAMEWORK_SPARK_STREAMING)) {
+                jobletPaletteType = ComponentCategory.CATEGORY_4_SPARKSTREAMING.getName();
+            }
+
+            for (Object nodeObject : processType.getNode()) {
+                NodeType node = (NodeType) nodeObject;
+                // not tRunjob && not joblet then continue
+                if (!node.getComponentName().equals("tRunJob") && !jobletsComponentsList.contains(node.getComponentName())) { // $NON-NLS-1$
+                    continue;
+                }
+                boolean nodeActivate = true;
+                String processIds = null;
+                String processVersion = null;
+                for (Object elementParam : node.getElementParameter()) {
+                    ElementParameterType elemParamType = (ElementParameterType) elementParam;
+                    if ("PROCESS:PROCESS_TYPE_PROCESS".equals(elemParamType.getName())) { // $NON-NLS-1$
+                        processIds = elemParamType.getValue();
+                        if (StringUtils.isNotBlank(processIds)) {
+                            for (String jobId : processIds.split(ProcessorUtilities.COMMA)) {
+                                if (actTrunjobHM.get(jobId) == null) {
+                                    actTrunjobHM.put(jobId, new HashSet<String>());
+                                }
+                            }
+                        }
+                    } else if ("PROCESS:PROCESS_TYPE_VERSION".equals(elemParamType.getName()) // $NON-NLS-1$
+                            || "PROCESS_TYPE_VERSION".equals(elemParamType.getName())) { // $NON-NLS-1$
+                        processVersion = elemParamType.getValue();
+                    } else if ("ACTIVATE".equals(elemParamType.getName())) { // $NON-NLS-1$
+                        nodeActivate = Boolean.parseBoolean(elemParamType.getValue());
+                    }
+                }
+
+                if (nodeActivate) {
+                    if (StringUtils.isNotBlank(processIds)) {
+                        for (String jobId : processIds.split(ProcessorUtilities.COMMA)) {
+                            String actualVersion = processVersion;
+                            if (RelationshipItemBuilder.LATEST_VERSION.equals(processVersion)) {
+                                for (Project project : allProjects) {
+                                    IRepositoryViewObject lastVersion = null;
+                                    lastVersion = ProxyRepositoryFactory.getInstance().getLastVersion(project, jobId);
+                                    if (lastVersion != null) {
+                                        actualVersion = lastVersion.getVersion();
+                                        break;
+                                    }
+                                }
+                            }
+                            if (actTrunjobHM.get(jobId) != null) {
+                                actTrunjobHM.get(jobId).add(actualVersion);
+                            }
+
+                        }
+                    } else if (componentsFactory != null && jobletPaletteType != null) {
+                        // for joblet
+                        IComponent cc = componentsFactory.get(node.getComponentName(), jobletPaletteType);
+                        if (GlobalServiceRegister.getDefault().isServiceRegistered(IJobletProviderService.class)) {
+                            IJobletProviderService jobletService = (IJobletProviderService) GlobalServiceRegister.getDefault()
+                                    .getService(IJobletProviderService.class);
+                            Property property = jobletService.getJobletComponentItem(cc);
+                            if (property != null && StringUtils.isNotBlank(property.getId())) {
+                                String jobletId = property.getId();
+                                if (actTrunjobHM.get(jobletId) == null) {
+                                    actTrunjobHM.put(jobletId, new HashSet<String>());
+                                }
+                                String actualVersion = processVersion;
+                                if (RelationshipItemBuilder.LATEST_VERSION.equals(processVersion)) {
+                                    for (Project project : allProjects) {
+                                        IRepositoryViewObject lastVersion = null;
+                                        lastVersion = ProxyRepositoryFactory.getInstance().getLastVersion(project, jobletId);
+                                        if (lastVersion != null) {
+                                            actualVersion = lastVersion.getVersion();
+                                            break;
+                                        }
+                                    }
+                                }
+
+                                actTrunjobHM.get(jobletId).add(actualVersion);
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        return actTrunjobHM;
+    }
+
     private static List<Relation> getItemsRelation(Relation mainJobInfo, Map<String, String> idToLastestVersionMap) throws ProcessorException {
         List<Relation> itemsJobRelatedTo = new ArrayList<Relation>();
         try {
@@ -1116,7 +1275,7 @@ public class ProcessorUtilities {
 
             Set<ModuleNeeded> neededLibraries =
                     CorePlugin.getDefault().getDesignerCoreService().getNeededLibrariesForProcess(currentProcess,
-                            false);
+                            isCIMode && BitwiseOptionUtils.containOption(option, GENERATE_MAIN_ONLY));
             if (neededLibraries != null) {
                 LastGenerationInfo.getInstance().setModulesNeededWithSubjobPerJob(jobInfo.getJobId(),
                         jobInfo.getJobVersion(), neededLibraries);
@@ -1229,14 +1388,23 @@ public class ProcessorUtilities {
     public static void cleanSourceFolder(IProgressMonitor progressMonitor, IProcess currentProcess,
             IProcessor processor) {
         try {
+            ITalendProcessJavaProject jobProject = processor.getTalendJavaProject();
+            // clean up source code
             IPath codePath = processor.getSrcCodePath().removeLastSegments(2);
-            IFolder srcFolder = processor.getTalendJavaProject().getProject().getFolder(codePath);
+            IFolder srcFolder = jobProject.getProject().getFolder(codePath);
             String jobPackageFolder = JavaResourcesHelper.getJobClassPackageFolder(currentProcess);
             for (IResource resource : srcFolder.members()) {
-                if (resource.getProjectRelativePath().toPortableString().endsWith(jobPackageFolder)) {
-                    break;
+                if (!resource.getProjectRelativePath().toPortableString().endsWith(jobPackageFolder)) {
+                    resource.delete(true, progressMonitor);
+                }
+            }
+            // clean up resources folder if needed
+            if (ProcessorUtilities.isExportConfig() && !designerCoreService.isNeedContextInJar(currentProcess)) {
+                for (IResource resource : jobProject.getResourcesFolder().members()) {
+                    if (resource.exists()) {
+                        resource.delete(true, progressMonitor);
+                    }
                 }
-                resource.delete(true, progressMonitor);
             }
         } catch (CoreException e) {
             ExceptionHandler.process(e);
@@ -2589,7 +2757,54 @@ public class ProcessorUtilities {
     }
 
     public static boolean isEsbJob(String processId, String version) {
-        return esbJobs.contains(esbJobKey(processId, version));
+        ProcessItem processItem = ItemCacheManager.getProcessItem(processId, version);
+        if (processItem != null && processItem.getProperty() != null && processItem.getProperty().getItem() != null) {
+            Set<JobInfo> infos = ProcessorUtilities.getChildrenJobInfo(processItem.getProperty().getItem(), false);
+            for (JobInfo jobInfo : infos) {
+                ProcessType processType = jobInfo.getProcessItem().getProcess();
+                EList<NodeType> nodes = processType.getNode();
+                for (NodeType nodeType : nodes) {
+                    if (isEsbComponentName(nodeType.getComponentName())) {
+                        return true;
+                    }
+                }
+            }
+            return false;
+        }
+        return false;
+    }
+    
+    public static boolean isEsbJob(IProcess process) {
+        return isEsbJob(process, false);
+    }
+
+    public static boolean isEsbJob(IProcess process, boolean checkCurrentProcess) {
+
+        if (process instanceof IProcess2) {
+
+            if (checkCurrentProcess) {
+                for (INode n : process.getGraphicalNodes()) {
+                    if (isEsbComponentName(n.getComponent().getName())) {
+                        return true;
+                    }
+                }
+            } else {
+                Set<JobInfo> infos = ProcessorUtilities.getChildrenJobInfo(((IProcess2) process).getProperty().getItem(), false);
+
+                for (JobInfo jobInfo : infos) {
+                    ProcessType processType = jobInfo.getProcessItem().getProcess();
+                    EList<NodeType> nodes = processType.getNode();
+                    for (NodeType nodeType : nodes) {
+                        if (isEsbComponentName(nodeType.getComponentName())) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
+
+        return false;
     }
 
     private static void addEsbJob(JobInfo jobInfo) {
@@ -2629,4 +2844,8 @@ public class ProcessorUtilities {
         return "tRunJob".equalsIgnoreCase(componentName) || "cTalendJob".equalsIgnoreCase(componentName);
     }
 
+    public static void setCIMode(boolean isCIMode) {
+        ProcessorUtilities.isCIMode = isCIMode;
+    }
+
 }

main/plugins/org.talend.cwm.mip.edit/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.cwm.mip.edit</artifactId>

main/plugins/org.talend.cwm.mip.editor/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.cwm.mip.editor</artifactId>

main/plugins/org.talend.cwm.mip/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.cwm.mip</artifactId>

main/plugins/org.talend.datatools.xml/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.datatools.xml</artifactId>

main/plugins/org.talend.datatools.xml/src/main/java/org/talend/datatools/xml/utils/ATreeNode.java

@@ -277,6 +277,9 @@ public class ATreeNode {
      * @throws OdaException
      */
     public void setDataType(String type) throws OdaException {
+        if (type == null) {
+            type = "";
+        }
         originalDataType = new String(type);
         this.dataType = getDataType(type);
     }

main/plugins/org.talend.datatools.xml/src/main/java/org/talend/datatools/xml/utils/XSDPopulationUtil2.java

@@ -43,8 +43,10 @@ import org.eclipse.xsd.XSDImport;
 import org.eclipse.xsd.XSDModelGroup;
 import org.eclipse.xsd.XSDParticle;
 import org.eclipse.xsd.XSDSchema;
+import org.eclipse.xsd.XSDSimpleTypeDefinition;
 import org.eclipse.xsd.XSDTerm;
 import org.eclipse.xsd.XSDTypeDefinition;
+import org.eclipse.xsd.XSDVariety;
 import org.eclipse.xsd.impl.XSDNamedComponentImpl;
 import org.eclipse.xsd.util.XSDConstants;
 import org.eclipse.xsd.util.XSDResourceImpl;
@@ -355,12 +357,15 @@ public class XSDPopulationUtil2 implements IXSDPopulationUtil {
                 }
             }
             if (!resolvedAsComplex) {
-                String dataType = xsdElementDeclarationParticle.getTypeDefinition().getQName();
+                XSDTypeDefinition typeDefinition = xsdElementDeclarationParticle.getTypeDefinition();
+                String dataType = typeDefinition.getQName();
                 if (!XSDConstants
-                        .isSchemaForSchemaNamespace(xsdElementDeclarationParticle.getTypeDefinition().getTargetNamespace())
-                        && xsdElementDeclarationParticle.getTypeDefinition().getBaseType() != null) {
-                    if (!"xs:anySimpleType".equals(xsdElementDeclarationParticle.getTypeDefinition().getBaseType().getQName())) {
-                        dataType = xsdElementDeclarationParticle.getTypeDefinition().getBaseType().getQName();
+                        .isSchemaForSchemaNamespace(typeDefinition.getTargetNamespace())
+                        && typeDefinition.getBaseType() != null) {
+                    if (!"xs:anySimpleType".equals(typeDefinition.getBaseType().getQName())) {
+                        dataType = typeDefinition.getBaseType().getQName();
+                    } else if (typeDefinition instanceof XSDSimpleTypeDefinition) {
+                        dataType = getVarietyType(((XSDSimpleTypeDefinition) typeDefinition).getVariety());
                     }
                 }
                 partNode.setDataType(dataType);
@@ -378,6 +383,16 @@ public class XSDPopulationUtil2 implements IXSDPopulationUtil {
         }
     }
 
+    private String getVarietyType(XSDVariety variety) {
+        String dataType = "xs:anyType";
+        if (XSDVariety.LIST_LITERAL.equals(variety)) {
+            dataType = "xs:list";
+        } else if (XSDVariety.UNION_LITERAL.equals(variety)) {
+            dataType = "xs:union";
+        }
+        return dataType;
+    }
+
     private void handleOptionalAttribute(ATreeNode node, XSDParticle xsdParticle) {
         if (node == null || xsdParticle == null || xsdParticle.getElement() == null) {
             return;
@@ -485,6 +500,17 @@ public class XSDPopulationUtil2 implements IXSDPopulationUtil {
                 }
                 if (xsdTypeDefinition instanceof XSDComplexTypeDefinition) {
                     addComplexTypeDetails(xsdSchema, node, xsdTypeDefinition, prefix, namespace, "/" + elementName + "/");
+                } else if (xsdTypeDefinition instanceof XSDSimpleTypeDefinition) {
+                    String dataType = xsdTypeDefinition.getQName();
+                    if (!XSDConstants.isSchemaForSchemaNamespace(xsdTypeDefinition.getTargetNamespace())
+                            && xsdTypeDefinition.getBaseType() != null) {
+                        if (!"xs:anySimpleType".equals(xsdTypeDefinition.getBaseType().getQName())) {
+                            dataType = xsdTypeDefinition.getBaseType().getQName();
+                        } else if (xsdTypeDefinition instanceof XSDSimpleTypeDefinition) {
+                            dataType = getVarietyType(((XSDSimpleTypeDefinition) xsdTypeDefinition).getVariety());
+                        }
+                    }
+                    node.setDataType(dataType);
                 }
                 List<String> namespaceList = new ArrayList(namespaceToPrefix.keySet());
                 Collections.reverse(namespaceList);
@@ -565,7 +591,11 @@ public class XSDPopulationUtil2 implements IXSDPopulationUtil {
             particleToTreeNode.clear();
         }
 
-        return rootNodes.get(0);
+        if (rootNodes.isEmpty()) {
+            return null;
+        } else {
+            return rootNodes.get(0);
+        }
     }
 
     private void addSubstitutionDetails(XSDSchema xsdSchema, ATreeNode parentNode, XSDElementDeclaration elementDeclaration,
@@ -760,11 +790,14 @@ public class XSDPopulationUtil2 implements IXSDPopulationUtil {
             ATreeNode childNode = new ATreeNode();
             childNode.setValue(attributeDeclarationName);
             childNode.setType(ATreeNode.ATTRIBUTE_TYPE);
-            String dataType = xsdAttributeDeclaration.getTypeDefinition().getQName();
-            XSDTypeDefinition baseType = xsdAttributeDeclaration.getTypeDefinition().getBaseType();
-            if (!XSDConstants.isSchemaForSchemaNamespace(xsdAttributeDeclaration.getTypeDefinition().getTargetNamespace())) {
+            XSDSimpleTypeDefinition typeDefinition = xsdAttributeDeclaration.getTypeDefinition();
+            String dataType = typeDefinition.getQName();
+            XSDTypeDefinition baseType = typeDefinition.getBaseType();
+            if (!XSDConstants.isSchemaForSchemaNamespace(typeDefinition.getTargetNamespace())) {
                 if (baseType != null && !"xs:anySimpleType".equals(baseType.getQName())) { //$NON-NLS-1$
                     dataType = baseType.getQName();
+                } else if (typeDefinition instanceof XSDSimpleTypeDefinition) {
+                    dataType = getVarietyType(((XSDSimpleTypeDefinition) typeDefinition).getVariety());
                 }
             }
             if (dataType != null && dataType.length() > 0) {

main/plugins/org.talend.designer.maven.aether/pom.xml

@@ -4,7 +4,7 @@
   <parent>
     <groupId>org.talend.studio</groupId>
     <artifactId>tcommon-studio-se</artifactId>
-    <version>7.2.1-SNAPSHOT</version>
+    <version>7.2.1</version>
     <relativePath>../../../</relativePath>
   </parent>
   <artifactId>org.talend.designer.maven.aether</artifactId>

main/plugins/org.talend.designer.maven.aether/src/main/java/org/talend/designer/maven/aether/RepositorySystemFactory.java

@@ -35,6 +35,7 @@ import org.eclipse.aether.util.artifact.SubArtifact;
 import org.eclipse.aether.util.listener.ChainedRepositoryListener;
 import org.eclipse.aether.util.listener.ChainedTransferListener;
 import org.eclipse.aether.util.repository.AuthenticationBuilder;
+import org.talend.designer.maven.aether.util.TalendAetherProxySelector;
 
 /**
  * created by wchen on Aug 10, 2017 Detailled comment
@@ -72,6 +73,8 @@ public class RepositorySystemFactory {
                     .setLocalRepositoryManager(system.newLocalRepositoryManager(repositorySystemSession, localRepo));
             repositorySystemSession.setTransferListener(new ChainedTransferListener());
             repositorySystemSession.setRepositoryListener(new ChainedRepositoryListener());
+            repositorySystemSession.setProxySelector(new TalendAetherProxySelector());
+            sessions.put(localRepo, repositorySystemSession);
         }
 
         return repositorySystemSession;
@@ -107,6 +110,7 @@ public class RepositorySystemFactory {
         Authentication auth = new AuthenticationBuilder().addUsername(userName).addPassword(password).build();
         RemoteRepository distRepo = new RemoteRepository.Builder(repositoryId, "default", repositoryUrl).setAuthentication(auth)
                 .build();
+        distRepo = new RemoteRepository.Builder(distRepo).setProxy(new TalendAetherProxySelector().getProxy(distRepo)).build();
 
         deployRequest.setRepository(distRepo);
 

main/plugins/org.talend.designer.maven.aether/src/main/java/org/talend/designer/maven/aether/util/DynamicDistributionAetherUtils.java

@@ -152,6 +152,7 @@ public class DynamicDistributionAetherUtils {
             builder = builder.setAuthentication(auth);
         }
         RemoteRepository central = builder.build();
+        central = new RemoteRepository.Builder(central).setProxy(new TalendAetherProxySelector().getProxy(central)).build();
 
         CollectRequest collectRequest = new CollectRequest();
         collectRequest.setRoot(dependency);
@@ -307,6 +308,7 @@ public class DynamicDistributionAetherUtils {
             builder = builder.setAuthentication(auth);
         }
         RemoteRepository central = builder.build();
+        central = new RemoteRepository.Builder(central).setProxy(new TalendAetherProxySelector().getProxy(central)).build();
 
         VersionRangeRequest verRangeRequest = new VersionRangeRequest();
         verRangeRequest.addRepository(central);
@@ -353,6 +355,7 @@ public class DynamicDistributionAetherUtils {
             builder = builder.setAuthentication(auth);
         }
         RemoteRepository central = builder.build();
+        central = new RemoteRepository.Builder(central).setProxy(new TalendAetherProxySelector().getProxy(central)).build();
 
         VersionRangeRequest verRangeRequest = new VersionRangeRequest();
         verRangeRequest.addRepository(central);
@@ -426,6 +429,7 @@ public class DynamicDistributionAetherUtils {
 
         LocalRepository localRepo = new LocalRepository(repositoryPath);
         session.setLocalRepositoryManager(system.newLocalRepositoryManager(session, localRepo));
+        session.setProxySelector(new TalendAetherProxySelector());
 
         updateDependencySelector(session, monitor);
 

main/plugins/org.talend.designer.maven.aether/src/main/java/org/talend/designer/maven/aether/util/MavenLibraryResolverProvider.java

@@ -14,12 +14,10 @@ package org.talend.designer.maven.aether.util;
 
 import java.util.HashMap;
 import java.util.Map;
+import java.util.function.Consumer;
 
 import org.apache.maven.model.License;
 import org.apache.maven.model.Model;
-import org.apache.maven.model.building.DefaultModelBuilderFactory;
-import org.apache.maven.model.building.DefaultModelBuildingRequest;
-import org.apache.maven.model.building.ModelBuildingResult;
 import org.apache.maven.repository.internal.MavenRepositorySystemUtils;
 import org.eclipse.aether.DefaultRepositorySystemSession;
 import org.eclipse.aether.RepositorySystem;
@@ -39,6 +37,7 @@ import org.eclipse.aether.transport.file.FileTransporterFactory;
 import org.eclipse.aether.transport.http.HttpTransporterFactory;
 import org.eclipse.aether.util.repository.AuthenticationBuilder;
 import org.eclipse.m2e.core.MavenPlugin;
+import org.talend.commons.exception.ExceptionHandler;
 import org.talend.core.nexus.ArtifactRepositoryBean;
 import org.talend.core.nexus.TalendLibsServerManager;
 import org.talend.core.runtime.maven.MavenArtifact;
@@ -85,6 +84,8 @@ public class MavenLibraryResolverProvider {
             defaultRemoteRepository = new RemoteRepository.Builder("talend", "default", talendServer.getRepositoryURL()) //$NON-NLS-1$ //$NON-NLS-2$
                     .setAuthentication(authentication).build();
         }
+        defaultRemoteRepository = new RemoteRepository.Builder(defaultRemoteRepository)
+                .setProxy(new TalendAetherProxySelector().getProxy(defaultRemoteRepository)).build();
     }
 
     public ArtifactResult resolveArtifact(MavenArtifact aritfact) throws Exception {
@@ -99,16 +100,13 @@ public class MavenLibraryResolverProvider {
     }
 
     public Map<String, Object> resolveDescProperties(MavenArtifact aritfact) throws Exception {
+        Map<String, Object> properties = null;
         MavenArtifact clonedArtifact = aritfact.clone();
         clonedArtifact.setType("pom"); //$NON-NLS-1$
-        Map<String, Object> properties = new HashMap<String, Object>();
         ArtifactResult result = resolveArtifact(clonedArtifact);
         if (result != null && result.isResolved()) {
-            DefaultModelBuilderFactory factory = new DefaultModelBuilderFactory();
-            DefaultModelBuildingRequest request = new DefaultModelBuildingRequest();
-            request.setPomFile(result.getArtifact().getFile());
-            ModelBuildingResult modelResult = factory.newInstance().build(request);
-            Model model = modelResult.getEffectiveModel();
+            properties = new HashMap<String, Object>();
+            Model model = MavenPlugin.getMavenModelManager().readMavenModel(result.getArtifact().getFile());
             if (model != null) {
                 properties.put("type", model.getPackaging()); //$NON-NLS-1$
                 properties.put("license.count", model.getLicenses().size()); //$NON-NLS-1$
@@ -127,16 +125,28 @@ public class MavenLibraryResolverProvider {
     }
 
     public RemoteRepository getRemoteRepositroy(MavenArtifact aritfact) {
+        RemoteRepository remoteRepository = null;
+        Consumer<RemoteRepository> update = null;
         if (aritfact != null && aritfact.getRepositoryUrl() != null) {
             if (urlToRepositoryMap.containsKey(aritfact.getRepositoryUrl())) {
-                return urlToRepositoryMap.get(aritfact.getRepositoryUrl());
+                remoteRepository = urlToRepositoryMap.get(aritfact.getRepositoryUrl());
+            } else {
+                remoteRepository = buildRemoteRepository(aritfact);
+                urlToRepositoryMap.put(aritfact.getRepositoryUrl(), remoteRepository);
             }
-
-            RemoteRepository repository = buildRemoteRepository(aritfact);
-            urlToRepositoryMap.put(aritfact.getRepositoryUrl(), repository);
-            return repository;
+            update = (r) -> urlToRepositoryMap.put(aritfact.getRepositoryUrl(), r);
+        } else {
+            remoteRepository = defaultRemoteRepository;
+            update = (r) -> defaultRemoteRepository = r;
         }
-        return defaultRemoteRepository;
+        try {
+            remoteRepository = new RemoteRepository.Builder(remoteRepository)
+                    .setProxy(defaultRepoSystemSession.getProxySelector().getProxy(remoteRepository)).build();
+            update.accept(remoteRepository);
+        } catch (Exception e) {
+            ExceptionHandler.process(e);
+        }
+        return remoteRepository;
     }
 
     private RemoteRepository buildRemoteRepository(MavenArtifact aritfact) {
@@ -149,6 +159,8 @@ public class MavenLibraryResolverProvider {
             repository = new RemoteRepository.Builder("talend", "default", aritfact.getRepositoryUrl()) //$NON-NLS-1$ //$NON-NLS-2$
                     .setAuthentication(authentication).build();
         }
+        repository = new RemoteRepository.Builder(repository).setProxy(new TalendAetherProxySelector().getProxy(repository))
+                .build();
         return repository;
     }
 
@@ -166,6 +178,7 @@ public class MavenLibraryResolverProvider {
 
         LocalRepository localRepo = new LocalRepository( /* "target/local-repo" */target);
         session.setLocalRepositoryManager(system.newLocalRepositoryManager(session, localRepo));
+        session.setProxySelector(new TalendAetherProxySelector());
 
         return session;
     }