| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You 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 org.apache.sling.ide.eclipse.ui.wizards; |
| |
| import static org.apache.sling.ide.eclipse.ui.internal.SlingLaunchpadCombo.ValidationFlag.SKIP_SERVER_STARTED; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| |
| import org.apache.commons.io.IOUtils; |
| import org.apache.sling.ide.artifacts.EmbeddedArtifactLocator; |
| import org.apache.sling.ide.artifacts.EmbeddedArtifact; |
| import org.apache.sling.ide.eclipse.core.ISlingLaunchpadServer; |
| import org.apache.sling.ide.eclipse.ui.internal.Activator; |
| import org.apache.sling.ide.eclipse.ui.internal.SlingLaunchpadCombo; |
| import org.apache.sling.ide.osgi.OsgiClient; |
| import org.apache.sling.ide.osgi.OsgiClientException; |
| import org.apache.sling.ide.osgi.OsgiClientFactory; |
| import org.apache.sling.ide.transport.RepositoryInfo; |
| import org.eclipse.core.runtime.CoreException; |
| import org.eclipse.core.runtime.IProgressMonitor; |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.NullProgressMonitor; |
| import org.eclipse.core.runtime.Status; |
| import org.eclipse.jface.layout.GridDataFactory; |
| import org.eclipse.jface.wizard.WizardPage; |
| import org.eclipse.swt.SWT; |
| import org.eclipse.swt.events.KeyEvent; |
| import org.eclipse.swt.events.KeyListener; |
| import org.eclipse.swt.events.ModifyEvent; |
| import org.eclipse.swt.events.ModifyListener; |
| import org.eclipse.swt.events.SelectionAdapter; |
| import org.eclipse.swt.events.SelectionEvent; |
| import org.eclipse.swt.layout.GridData; |
| import org.eclipse.swt.layout.GridLayout; |
| import org.eclipse.swt.widgets.Button; |
| import org.eclipse.swt.widgets.Composite; |
| import org.eclipse.swt.widgets.Label; |
| import org.eclipse.swt.widgets.Text; |
| import org.eclipse.wst.server.core.IRuntime; |
| import org.eclipse.wst.server.core.IRuntimeType; |
| import org.eclipse.wst.server.core.IServer; |
| import org.eclipse.wst.server.core.IServerType; |
| import org.eclipse.wst.server.core.IServerWorkingCopy; |
| import org.eclipse.wst.server.core.ServerCore; |
| import org.osgi.framework.Version; |
| |
| public class SetupServerWizardPage extends WizardPage { |
| |
| private static final int HORIZONTAL_INDENT = 10; |
| |
| private Button useExistingServer; |
| private SlingLaunchpadCombo existingServerCombo; |
| private Button setupNewServer; |
| private Text newServerName; |
| private Text newServerHostnameName; |
| private Text newServerPort; |
| private Text newServerUsername; |
| private Text newServerPassword; |
| private Text newServerDebugPort; |
| private Button installToolingSupportBundle; |
| |
| private IServer server; |
| |
| private Button startExistingServerButton; |
| |
| private Button skipServerConfiguration; |
| |
| public SetupServerWizardPage(AbstractNewSlingApplicationWizard parent) { |
| super("chooseArchetypePage"); |
| setTitle("Select or Create Server"); |
| setDescription("This step defines which server to use with the new project."); |
| setImageDescriptor(parent.getLogo()); |
| } |
| |
| @Override |
| public AbstractNewSlingApplicationWizard getWizard() { |
| return (AbstractNewSlingApplicationWizard) super.getWizard(); |
| } |
| |
| public void createControl(Composite parent) { |
| Composite container = new Composite(parent, SWT.NONE); |
| GridLayout layout = new GridLayout(); |
| container.setLayout(layout); |
| layout.numColumns = 3; |
| layout.verticalSpacing = 9; |
| layout.marginBottom = 10; |
| |
| GridDataFactory singleRowGridDataFactory = GridDataFactory.swtDefaults().align(SWT.LEFT, SWT.CENTER) |
| .span(layout.numColumns, 1); |
| |
| useExistingServer = new Button(container, SWT.RADIO); |
| useExistingServer.setText("Add to existing server"); |
| singleRowGridDataFactory.applyTo(useExistingServer); |
| |
| Label existingServerLabel = new Label(container, SWT.NONE); |
| GridData locationLabelData = new GridData(); |
| locationLabelData.horizontalIndent = HORIZONTAL_INDENT; |
| existingServerLabel.setLayoutData(locationLabelData); |
| existingServerLabel.setText("Location:"); |
| existingServerLabel.setEnabled(true); |
| |
| existingServerCombo = new SlingLaunchpadCombo(container, null); |
| existingServerCombo.getWidget().addModifyListener(new ModifyListener() { |
| public void modifyText(ModifyEvent e) { |
| dialogChanged(); |
| } |
| }); |
| existingServerCombo.refreshRepositoryList(new NullProgressMonitor()); |
| existingServerCombo.getWidget().setEnabled(true); |
| |
| { |
| startExistingServerButton = new Button(container, SWT.CHECK); |
| GridData gd = new GridData(SWT.FILL, SWT.FILL, true, false, 2, 1); |
| gd.horizontalIndent = HORIZONTAL_INDENT; |
| startExistingServerButton.setLayoutData(gd); |
| startExistingServerButton.setText("Start server after project creation (if server not yet started)."); |
| startExistingServerButton.setSelection(true); |
| } |
| |
| skipServerConfiguration = new Button(container, SWT.RADIO); |
| skipServerConfiguration.setText("Don't deploy on a server"); |
| singleRowGridDataFactory.applyTo(skipServerConfiguration); |
| |
| setupNewServer = new Button(container, SWT.RADIO); |
| setupNewServer.setText("Setup new server"); |
| singleRowGridDataFactory.applyTo(setupNewServer); |
| |
| newLabel(container, "Server name:"); |
| newServerName = newText(container); |
| |
| newLabel(container, "Host name:"); |
| newServerHostnameName = newText(container); |
| |
| newLabel(container, "Port:"); |
| newServerPort = newText(container); |
| |
| newLabel(container, "Username:"); |
| newServerUsername = newText(container); |
| |
| newLabel(container, "Password:"); |
| newServerPassword = newText(container); |
| |
| newLabel(container, "Debug Port:"); |
| newServerDebugPort = newText(container); |
| |
| { |
| installToolingSupportBundle = new Button(container, SWT.CHECK); |
| GridData installToolingSupportBundleData = new GridData(SWT.FILL, SWT.FILL, true, false, 2, 1); |
| installToolingSupportBundleData.horizontalIndent = HORIZONTAL_INDENT; |
| installToolingSupportBundle.setLayoutData(installToolingSupportBundleData); |
| installToolingSupportBundle.setText("Check/Install org.apache.sling.tooling.support.install bundle"); |
| installToolingSupportBundle.setSelection(true); |
| } |
| |
| |
| SelectionAdapter radioListener = new SelectionAdapter() { |
| public void widgetSelected(SelectionEvent e) { |
| updateEnablements(); |
| dialogChanged(); |
| } |
| }; |
| useExistingServer.addSelectionListener(radioListener); |
| setupNewServer.addSelectionListener(radioListener); |
| |
| ModifyListener ml = new ModifyListener() { |
| |
| @Override |
| public void modifyText(ModifyEvent e) { |
| dialogChanged(); |
| } |
| }; |
| KeyListener kl = new KeyListener() { |
| |
| @Override |
| public void keyReleased(KeyEvent e) { |
| dialogChanged(); |
| } |
| |
| @Override |
| public void keyPressed(KeyEvent e) { |
| dialogChanged(); |
| } |
| }; |
| newServerName.addModifyListener(ml); |
| newServerName.addKeyListener(kl); |
| newServerHostnameName.addModifyListener(ml); |
| newServerHostnameName.addKeyListener(kl); |
| newServerPort.addModifyListener(ml); |
| newServerPort.addKeyListener(kl); |
| newServerDebugPort.addModifyListener(ml); |
| newServerDebugPort.addKeyListener(kl); |
| |
| useExistingServer.setSelection(existingServerCombo.hasServers()); |
| existingServerCombo.getWidget().setEnabled(existingServerCombo.hasServers()); |
| startExistingServerButton.setEnabled(existingServerCombo.hasServers()); |
| setupNewServer.setSelection(!existingServerCombo.hasServers()); |
| installToolingSupportBundle.setSelection(true); |
| |
| updateEnablements(); |
| |
| setPageComplete(false); |
| |
| setControl(container); |
| } |
| |
| private Label newLabel(Composite container, String text) { |
| |
| Label label = new Label(container, SWT.NONE); |
| GridData newServerPortLabelData = new GridData(); |
| newServerPortLabelData.horizontalIndent = HORIZONTAL_INDENT; |
| label.setLayoutData(newServerPortLabelData); |
| label.setEnabled(true); |
| label.setText(text); |
| |
| return label; |
| } |
| |
| private Text newText(Composite container) { |
| |
| Text text = new Text(container, SWT.BORDER); |
| text.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, false, 2, 1)); |
| |
| return text; |
| } |
| |
| private void dialogChanged() { |
| |
| // called too early |
| if (getControl() == null) { |
| return; |
| } |
| |
| if (useExistingServer.getSelection()) { |
| if (existingServerCombo.getErrorMessage(SKIP_SERVER_STARTED) != null) { |
| updateStatus(existingServerCombo.getErrorMessage()); |
| return; |
| } |
| } else if (setupNewServer.getSelection()) { |
| if (newServerName.getText().length()==0 || |
| getHostname().length()==0 || |
| newServerPort.getText().length()==0 || |
| newServerDebugPort.getText().length()==0 || |
| newServerUsername.getText().length() == 0 || |
| newServerPassword.getText().length() == 0) { |
| updateStatus("Enter values for new server"); |
| return; |
| } |
| } |
| updateStatus(null); |
| } |
| |
| private void updateEnablements() { |
| |
| existingServerCombo.getWidget().setEnabled(useExistingServer.getSelection()); |
| startExistingServerButton.setEnabled(useExistingServer.getSelection()); |
| newServerName.setEnabled(setupNewServer.getSelection()); |
| newServerHostnameName.setEnabled(setupNewServer.getSelection()); |
| newServerPort.setEnabled(setupNewServer.getSelection()); |
| newServerDebugPort.setEnabled(setupNewServer.getSelection()); |
| newServerUsername.setEnabled(setupNewServer.getSelection()); |
| newServerPassword.setEnabled(setupNewServer.getSelection()); |
| installToolingSupportBundle.setEnabled(setupNewServer.getSelection()); |
| } |
| |
| private void updateStatus(String message) { |
| setErrorMessage(message); |
| setPageComplete(message == null); |
| } |
| |
| |
| private Version getToolingSupportBundleVersion() throws OsgiClientException { |
| |
| return newOsgiClient().getBundleVersion(EmbeddedArtifactLocator.SUPPORT_BUNDLE_SYMBOLIC_NAME); |
| } |
| |
| private OsgiClient newOsgiClient() { |
| |
| String hostname = getHostname(); |
| int launchpadPort = getPort(); |
| |
| OsgiClientFactory factory = Activator.getDefault().getOsgiClientFactory(); |
| |
| // TODO remove credential hardcoding |
| return factory.createOsgiClient(new RepositoryInfo("admin", "admin", "http://" + hostname + ":" + launchpadPort |
| + "/")); |
| } |
| |
| public boolean getStartServer() { |
| if (!useExistingServer.getSelection()) { |
| return true; // new servers are automatically started |
| } |
| return startExistingServerButton.getSelection(); |
| } |
| |
| /** |
| * Gets or creates a <tt>IServer</tt> instance to deploy projects on |
| * |
| * @param monitor |
| * @return the server instance, possibly null if the user requested to skip deployment |
| * @throws CoreException |
| */ |
| public IServer getOrCreateServer(IProgressMonitor monitor) throws CoreException { |
| |
| if (skipServerConfiguration.getSelection()) { |
| return null; |
| } |
| |
| if (server != null) { |
| return server; |
| } |
| |
| if (useExistingServer.getSelection()) { |
| return existingServerCombo.getServer(); |
| } else { |
| IServerType serverType = ServerCore.findServerType("org.apache.sling.ide.launchpadServer"); |
| @SuppressWarnings("unused") |
| IRuntime existingRuntime = null;//ServerCore.findRuntime("org.apache.sling.ide.launchpadRuntimeType"); |
| IRuntime[] existingRuntimes = ServerCore.getRuntimes(); |
| for (int i = 0; i < existingRuntimes.length; i++) { |
| IRuntime aRuntime = existingRuntimes[i]; |
| if (aRuntime.getRuntimeType().getId().equals("org.apache.sling.ide.launchpadRuntimeType")) { |
| existingRuntime = aRuntime; |
| } |
| } |
| |
| Version finalVersion = null; |
| |
| if (installToolingSupportBundle.getSelection()) { |
| Version installedVersion; |
| try { |
| installedVersion = getToolingSupportBundleVersion(); |
| } catch (OsgiClientException e) { |
| throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, |
| "Failed reading the tooling support bundle version", e)); |
| } |
| finalVersion = installedVersion; |
| EmbeddedArtifactLocator artifactsLocator = Activator.getDefault().getArtifactLocator(); |
| EmbeddedArtifact toolingSupportBundle = artifactsLocator.loadToolingSupportBundle(); |
| Version ourVersion = new Version(toolingSupportBundle.getVersion()); |
| |
| if (installedVersion == null || ourVersion.compareTo(installedVersion) > 0) { |
| // then auto-install it if possible |
| try { |
| |
| InputStream contents = null; |
| try { |
| contents = toolingSupportBundle.openInputStream(); |
| newOsgiClient().installBundle(contents, toolingSupportBundle.getName()); |
| } finally { |
| IOUtils.closeQuietly(contents); |
| } |
| finalVersion = ourVersion; |
| } catch (IOException e) { |
| throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, |
| "Failed installing the tooling support bundle version", e)); |
| } catch (OsgiClientException e) { |
| throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, |
| "Failed installing the tooling support bundle version", e)); |
| } |
| } |
| } |
| |
| IRuntimeType serverRuntime = ServerCore.findRuntimeType("org.apache.sling.ide.launchpadRuntimeType"); |
| try { |
| // TODO there should be a nicer API for creating this, and also a central place for defaults |
| // TODO - we should not be creating runtimes, but maybe matching against existing ones |
| IRuntime runtime = serverRuntime.createRuntime(null, monitor); |
| runtime = runtime.createWorkingCopy().save(true, monitor); |
| IServerWorkingCopy wc = serverType.createServer(null, null, runtime, monitor); |
| wc.setHost(getHostname()); |
| wc.setName(newServerName.getText()); |
| wc.setAttribute(ISlingLaunchpadServer.PROP_PORT, getPort()); |
| wc.setAttribute(ISlingLaunchpadServer.PROP_DEBUG_PORT, Integer.parseInt(newServerDebugPort.getText())); |
| wc.setAttribute(ISlingLaunchpadServer.PROP_INSTALL_LOCALLY, installToolingSupportBundle.getSelection()); |
| wc.setAttribute(ISlingLaunchpadServer.PROP_USERNAME, newServerUsername.getText()); |
| wc.setAttribute(ISlingLaunchpadServer.PROP_PASSWORD, newServerPassword.getText()); |
| wc.setAttribute("auto-publish-time", 0); |
| if (finalVersion != null) { |
| wc.setAttribute(String.format(ISlingLaunchpadServer.PROP_BUNDLE_VERSION_FORMAT, |
| EmbeddedArtifactLocator.SUPPORT_BUNDLE_SYMBOLIC_NAME), finalVersion.toString()); |
| } |
| wc.setRuntime(runtime); |
| server = wc.save(true, monitor); |
| return server; |
| } catch (CoreException e) { |
| throw new CoreException(new Status(IStatus.ERROR, Activator.PLUGIN_ID, |
| "Failed creating the new server instance", e)); |
| |
| } |
| } |
| } |
| |
| private int getPort() { |
| return Integer.parseInt(newServerPort.getText()); |
| } |
| |
| private String getHostname() { |
| return newServerHostnameName.getText(); |
| } |
| |
| } |