diff options
author | Tor Norbye <tnorbye@google.com> | 2014-09-04 13:24:04 -0700 |
---|---|---|
committer | Tor Norbye <tnorbye@google.com> | 2014-09-04 13:24:04 -0700 |
commit | c3d3a90f6b4ead083d63e28e6b9fcea93d675678 (patch) | |
tree | fc0dcd722b6d445468dbe7dad13b4c11781b1cbe /platform/platform-api/src/com/intellij/util/net/HttpProxySettingsUi.java | |
parent | 1aa2e09bdbd413eacb677e9fa4b50630530d0656 (diff) | |
download | idea-c3d3a90f6b4ead083d63e28e6b9fcea93d675678.tar.gz |
Snapshot idea/138.1980 from git://git.jetbrains.org/idea/community.git
Change-Id: Ib567c9c152d770212a7a3db20fbf591c210920bd
Diffstat (limited to 'platform/platform-api/src/com/intellij/util/net/HttpProxySettingsUi.java')
-rw-r--r-- | platform/platform-api/src/com/intellij/util/net/HttpProxySettingsUi.java | 386 |
1 files changed, 386 insertions, 0 deletions
diff --git a/platform/platform-api/src/com/intellij/util/net/HttpProxySettingsUi.java b/platform/platform-api/src/com/intellij/util/net/HttpProxySettingsUi.java new file mode 100644 index 000000000000..e71d8e5af4ec --- /dev/null +++ b/platform/platform-api/src/com/intellij/util/net/HttpProxySettingsUi.java @@ -0,0 +1,386 @@ +/* + * Copyright 2000-2014 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.intellij.util.net; + +import com.google.common.net.HostAndPort; +import com.google.common.net.InetAddresses; +import com.google.common.net.InternetDomainName; +import com.intellij.openapi.application.ApplicationManager; +import com.intellij.openapi.options.ConfigurableUi; +import com.intellij.openapi.ui.Messages; +import com.intellij.openapi.ui.MultiLineLabelUI; +import com.intellij.openapi.util.Comparing; +import com.intellij.openapi.util.text.StringUtil; +import com.intellij.openapi.wm.IdeFocusManager; +import com.intellij.openapi.wm.IdeFrame; +import com.intellij.ui.PortField; +import com.intellij.ui.components.JBLabel; +import com.intellij.ui.components.JBRadioButton; +import com.intellij.util.proxy.CommonProxy; +import com.intellij.util.proxy.JavaProxyProperty; +import com.intellij.util.ui.UIUtil; +import org.jetbrains.annotations.NotNull; +import org.jetbrains.annotations.Nullable; + +import javax.swing.*; +import java.awt.*; +import java.awt.event.ActionEvent; +import java.awt.event.ActionListener; +import java.io.IOException; +import java.net.HttpURLConnection; +import java.util.concurrent.atomic.AtomicReference; + +class HttpProxySettingsUi implements ConfigurableUi<HttpConfigurable> { + private JPanel myMainPanel; + + private JTextField myProxyLoginTextField; + private JPasswordField myProxyPasswordTextField; + private JCheckBox myProxyAuthCheckBox; + private PortField myProxyPortTextField; + private JTextField myProxyHostTextField; + private JCheckBox myRememberProxyPasswordCheckBox; + + private JLabel myProxyLoginLabel; + private JLabel myProxyPasswordLabel; + private JLabel myHostNameLabel; + private JLabel myPortNumberLabel; + private JBRadioButton myAutoDetectProxyRb; + private JBRadioButton myUseHTTPProxyRb; + private JBLabel mySystemProxyDefined; + private JBRadioButton myNoProxyRb; + private JBRadioButton myHTTP; + private JBRadioButton mySocks; + private JButton myClearPasswordsButton; + private JLabel myErrorLabel; + private JButton myCheckButton; + private JBLabel myOtherWarning; + private JLabel myProxyExceptionsLabel; + private JTextArea myProxyExceptions; + private JLabel myNoProxyForLabel; + private JCheckBox myPacUrlCheckBox; + private JTextField myPacUrlTextField; + private volatile boolean myConnectionCheckInProgress; + + @Override + public boolean isModified(@NotNull HttpConfigurable settings) { + if (!isValid()) { + return false; + } + + return !Comparing.strEqual(myProxyExceptions.getText().trim(), settings.PROXY_EXCEPTIONS) || + settings.USE_PROXY_PAC != myAutoDetectProxyRb.isSelected() || + settings.USE_PAC_URL != myPacUrlCheckBox.isSelected() || + !Comparing.strEqual(settings.PAC_URL, myPacUrlTextField.getText()) || + settings.USE_HTTP_PROXY != myUseHTTPProxyRb.isSelected() || + settings.PROXY_AUTHENTICATION != myProxyAuthCheckBox.isSelected() || + settings.KEEP_PROXY_PASSWORD != myRememberProxyPasswordCheckBox.isSelected() || + settings.PROXY_TYPE_IS_SOCKS != mySocks.isSelected() || + !Comparing.strEqual(settings.PROXY_LOGIN, myProxyLoginTextField.getText()) || + !Comparing.strEqual(settings.getPlainProxyPassword(), new String(myProxyPasswordTextField.getPassword())) || + settings.PROXY_PORT != myProxyPortTextField.getNumber() || + !Comparing.strEqual(settings.PROXY_HOST, myProxyHostTextField.getText()); + } + + public HttpProxySettingsUi(@NotNull final HttpConfigurable settings) { + ButtonGroup group = new ButtonGroup(); + group.add(myUseHTTPProxyRb); + group.add(myAutoDetectProxyRb); + group.add(myNoProxyRb); + myNoProxyRb.setSelected(true); + + ButtonGroup proxyTypeGroup = new ButtonGroup(); + proxyTypeGroup.add(myHTTP); + proxyTypeGroup.add(mySocks); + myHTTP.setSelected(true); + + myProxyExceptions.setBorder(UIUtil.getTextFieldBorder()); + + Boolean property = Boolean.getBoolean(JavaProxyProperty.USE_SYSTEM_PROXY); + mySystemProxyDefined.setVisible(Boolean.TRUE.equals(property)); + if (Boolean.TRUE.equals(property)) { + mySystemProxyDefined.setIcon(Messages.getWarningIcon()); + mySystemProxyDefined.setFont(mySystemProxyDefined.getFont().deriveFont(Font.BOLD)); + mySystemProxyDefined.setUI(new MultiLineLabelUI()); + } + + myProxyAuthCheckBox.addActionListener(new ActionListener() { + @Override + public void actionPerformed(@NotNull ActionEvent e) { + enableProxyAuthentication(myProxyAuthCheckBox.isSelected()); + } + }); + myPacUrlCheckBox.addActionListener(new ActionListener() { + @Override + public void actionPerformed(@NotNull ActionEvent e) { + myPacUrlTextField.setEnabled(myPacUrlCheckBox.isSelected()); + } + }); + + ActionListener listener = new ActionListener() { + @Override + public void actionPerformed(@NotNull ActionEvent e) { + enableProxy(myUseHTTPProxyRb.isSelected()); + } + }; + myUseHTTPProxyRb.addActionListener(listener); + myAutoDetectProxyRb.addActionListener(listener); + myNoProxyRb.addActionListener(listener); + + myClearPasswordsButton.addActionListener(new ActionListener() { + @Override + public void actionPerformed(@NotNull ActionEvent e) { + settings.clearGenericPasswords(); + //noinspection DialogTitleCapitalization + Messages.showMessageDialog(myMainPanel, "Proxy passwords were cleared.", "Auto-detected Proxy", Messages.getInformationIcon()); + } + }); + + configureCheckButton(); + } + + private void configureCheckButton() { + if (HttpConfigurable.getInstance() == null) { + myCheckButton.setVisible(false); + return; + } + + myCheckButton.addActionListener(new ActionListener() { + @Override + public void actionPerformed(@NotNull ActionEvent e) { + final String title = "Check Proxy Settings"; + final String answer = Messages.showInputDialog(myMainPanel, "Warning: your settings will be saved.\n\nEnter any URL to check connection to:", + title, Messages.getQuestionIcon(), "http://", null); + if (StringUtil.isEmptyOrSpaces(answer)) { + return; + } + + final HttpConfigurable settings = HttpConfigurable.getInstance(); + apply(settings); + final AtomicReference<IOException> exceptionReference = new AtomicReference<IOException>(); + myCheckButton.setEnabled(false); + myCheckButton.setText("Check connection (in progress...)"); + myConnectionCheckInProgress = true; + ApplicationManager.getApplication().executeOnPooledThread(new Runnable() { + @Override + public void run() { + HttpURLConnection connection = null; + try { + //already checked for null above + //noinspection ConstantConditions + connection = settings.openHttpConnection(answer); + connection.setReadTimeout(3 * 1000); + connection.setConnectTimeout(3 * 1000); + connection.connect(); + final int code = connection.getResponseCode(); + if (HttpURLConnection.HTTP_OK != code) { + exceptionReference.set(new IOException("Error code: " + code)); + } + } + catch (IOException e) { + exceptionReference.set(e); + } + finally { + if (connection != null) { + connection.disconnect(); + } + } + //noinspection SSBasedInspection + SwingUtilities.invokeLater(new Runnable() { + @Override + public void run() { + myConnectionCheckInProgress = false; + reset(settings); // since password might have been set + Component parent; + if (myMainPanel.isShowing()) { + parent = myMainPanel; + myCheckButton.setText("Check connection"); + myCheckButton.setEnabled(canEnableConnectionCheck()); + } + else { + IdeFrame frame = IdeFocusManager.findInstance().getLastFocusedFrame(); + if (frame == null) { + return; + } + parent = frame.getComponent(); + } + //noinspection ThrowableResultOfMethodCallIgnored + final IOException exception = exceptionReference.get(); + if (exception == null) { + Messages.showMessageDialog(parent, "Connection successful", title, Messages.getInformationIcon()); + } + else { + final String message = exception.getMessage(); + if (settings.USE_HTTP_PROXY) { + settings.LAST_ERROR = message; + } + Messages.showErrorDialog(parent, errorText(message)); + } + } + }); + } + }); + } + }); + } + + private boolean canEnableConnectionCheck() { + return !myNoProxyRb.isSelected() && !myConnectionCheckInProgress; + } + + @Override + public void reset(@NotNull HttpConfigurable settings) { + myNoProxyRb.setSelected(true); // default + myAutoDetectProxyRb.setSelected(settings.USE_PROXY_PAC); + myPacUrlCheckBox.setSelected(settings.USE_PAC_URL); + myPacUrlTextField.setText(settings.PAC_URL); + myUseHTTPProxyRb.setSelected(settings.USE_HTTP_PROXY); + myProxyAuthCheckBox.setSelected(settings.PROXY_AUTHENTICATION); + + enableProxy(settings.USE_HTTP_PROXY); + + myProxyLoginTextField.setText(settings.PROXY_LOGIN); + myProxyPasswordTextField.setText(settings.getPlainProxyPassword()); + + myProxyPortTextField.setNumber(settings.PROXY_PORT); + myProxyHostTextField.setText(settings.PROXY_HOST); + myProxyExceptions.setText(StringUtil.notNullize(settings.PROXY_EXCEPTIONS)); + + myRememberProxyPasswordCheckBox.setSelected(settings.KEEP_PROXY_PASSWORD); + mySocks.setSelected(settings.PROXY_TYPE_IS_SOCKS); + myHTTP.setSelected(!settings.PROXY_TYPE_IS_SOCKS); + + boolean showError = !StringUtil.isEmptyOrSpaces(settings.LAST_ERROR); + myErrorLabel.setVisible(showError); + myErrorLabel.setText(showError ? errorText(settings.LAST_ERROR) : null); + + final String oldStyleText = CommonProxy.getMessageFromProps(CommonProxy.getOldStyleProperties()); + myOtherWarning.setVisible(oldStyleText != null); + if (oldStyleText != null) { + myOtherWarning.setText(oldStyleText); + myOtherWarning.setUI(new MultiLineLabelUI()); + myOtherWarning.setIcon(Messages.getWarningIcon()); + } + } + + @NotNull + private static String errorText(@NotNull String s) { + return "Problem with connection: " + s; + } + + private boolean isValid() { + if (myUseHTTPProxyRb.isSelected()) { + String host = getText(myProxyHostTextField); + if (host == null) { + return false; + } + + try { + HostAndPort parsedHost = HostAndPort.fromString(host); + if (parsedHost.hasPort()) { + return false; + } + host = parsedHost.getHostText(); + + try { + InetAddresses.forString(host); + return true; + } + catch (IllegalArgumentException e) { + // it is not an IPv4 or IPv6 literal + } + + InternetDomainName.from(host); + } + catch (IllegalArgumentException e) { + return false; + } + + if (myProxyAuthCheckBox.isSelected()) { + return !StringUtil.isEmptyOrSpaces(myProxyLoginTextField.getText()) && myProxyPasswordTextField.getPassword().length > 0; + } + } + return true; + } + + @Override + public void apply(@NotNull HttpConfigurable settings) { + if (!isValid()) { + return; + } + + if (isModified(settings)) { + settings.AUTHENTICATION_CANCELLED = false; + } + + settings.USE_PROXY_PAC = myAutoDetectProxyRb.isSelected(); + settings.USE_PAC_URL = myPacUrlCheckBox.isSelected(); + settings.PAC_URL = getText(myPacUrlTextField); + settings.USE_HTTP_PROXY = myUseHTTPProxyRb.isSelected(); + settings.PROXY_TYPE_IS_SOCKS = mySocks.isSelected(); + settings.PROXY_AUTHENTICATION = myProxyAuthCheckBox.isSelected(); + settings.KEEP_PROXY_PASSWORD = myRememberProxyPasswordCheckBox.isSelected(); + + settings.PROXY_LOGIN = getText(myProxyLoginTextField); + settings.setPlainProxyPassword(new String(myProxyPasswordTextField.getPassword())); + settings.PROXY_EXCEPTIONS = StringUtil.nullize(myProxyExceptions.getText(), true); + + settings.PROXY_PORT = myProxyPortTextField.getNumber(); + settings.PROXY_HOST = getText(myProxyHostTextField); + } + + @Nullable + private static String getText(@NotNull JTextField field) { + return StringUtil.nullize(field.getText(), true); + } + + private void enableProxy(boolean enabled) { + myHostNameLabel.setEnabled(enabled); + myPortNumberLabel.setEnabled(enabled); + myProxyHostTextField.setEnabled(enabled); + myProxyPortTextField.setEnabled(enabled); + mySocks.setEnabled(enabled); + myHTTP.setEnabled(enabled); + myProxyExceptions.setEnabled(enabled); + myProxyExceptions.setBackground(myProxyPortTextField.getBackground()); + myProxyExceptionsLabel.setEnabled(enabled); + myNoProxyForLabel.setEnabled(enabled); + + myProxyAuthCheckBox.setEnabled(enabled); + enableProxyAuthentication(enabled && myProxyAuthCheckBox.isSelected()); + myCheckButton.setEnabled(canEnableConnectionCheck()); + + final boolean autoDetectProxy = myAutoDetectProxyRb.isSelected(); + myPacUrlCheckBox.setEnabled(autoDetectProxy); + myClearPasswordsButton.setEnabled(autoDetectProxy); + myPacUrlTextField.setEnabled(autoDetectProxy && myPacUrlCheckBox.isSelected()); + } + + private void enableProxyAuthentication(boolean enabled) { + myProxyPasswordLabel.setEnabled(enabled); + myProxyLoginLabel.setEnabled(enabled); + + myProxyLoginTextField.setEnabled(enabled); + myProxyPasswordTextField.setEnabled(enabled); + + myRememberProxyPasswordCheckBox.setEnabled(enabled); + } + + @Override + @NotNull + public JComponent getComponent() { + return myMainPanel; + } +} |