private void newVLVIndexClicked() { if (newVLVIndexPanel == null) { newVLVIndexPanel = new NewVLVIndexPanel( (String) backends.getSelectedItem(), Utilities.getParentDialog(this)); newVLVIndexPanel.setInfo(getInfo()); newVLVIndexDialog = new GenericDialog(null, newVLVIndexPanel); Utilities.centerGoldenMean(newVLVIndexDialog, Utilities.getParentDialog(this)); newVLVIndexPanel.addConfigurationElementCreatedListener( new ConfigurationElementCreatedListener() { /** {@inheritDoc} */ public void elementCreated(ConfigurationElementCreatedEvent ev) { Object o = ev.getConfigurationObject(); if (o instanceof AbstractIndexDescriptor) { lastCreatedIndex = (AbstractIndexDescriptor) o; } } }); } else if (!newVLVIndexDialog.isVisible()) { String backendID = (String) backends.getSelectedItem(); for (BackendDescriptor backend : getInfo().getServerDescriptor().getBackends()) { if (backend.getBackendID().equalsIgnoreCase(backendID)) { newVLVIndexPanel.update(backend); break; } } } newVLVIndexDialog.setVisible(true); }
/** * Constructor of the task. * * @param info the control panel information. * @param dlg the progress dialog where the task progress will be displayed. * @param tasks the tasks to be canceled. */ public CancelTaskTask(ControlPanelInfo info, ProgressDialog dlg, List<TaskEntry> tasks) { super(info, dlg); backendSet = new HashSet<String>(); for (BackendDescriptor backend : info.getServerDescriptor().getBackends()) { backendSet.add(backend.getBackendID()); } this.tasks = new ArrayList<TaskEntry>(tasks); }
/** * Refresh the contents of the panel with the provided server descriptor. * * @param desc the server descriptor. */ private void refreshContents(final ServerDescriptor desc) { super.updateIndexMap(desc, hmIndexes); filterIndexes(hmIndexes); updateBaseDNComboBoxModel((DefaultComboBoxModel) baseDNs.getModel(), desc); // Check that all backends boolean allDisabled = false; for (BackendDescriptor backend : desc.getBackends()) { if (displayBackend(backend)) { if (backend.isEnabled()) { allDisabled = false; break; } } } if (!allDisabled) { updateErrorPaneAndOKButtonIfAuthRequired( desc, isLocal() ? INFO_CTRL_PANEL_AUTHENTICATION_REQUIRED_FOR_DISABLE_BACKEND.get() : INFO_CTRL_PANEL_CANNOT_CONNECT_TO_REMOTE_DETAILS.get(desc.getHostname())); } SwingUtilities.invokeLater( new Runnable() { /** {@inheritDoc} */ public void run() { ViewPositions pos; JScrollPane scroll = Utilities.getContainingScroll(RebuildIndexPanel.this); if (scroll != null) { pos = Utilities.getViewPositions(scroll); } else { pos = Utilities.getViewPositions(RebuildIndexPanel.this); } boolean comboVisible = baseDNs.getModel().getSize() > 0; baseDNs.setVisible(comboVisible); lNoBaseDNsFound.setVisible(!comboVisible); addRemove.getAvailableList().repaint(); addRemove.getSelectedList().repaint(); Utilities.updateViewPositions(pos); if (!desc.isLocal()) { displayErrorMessage( INFO_CTRL_PANEL_SERVER_REMOTE_SUMMARY.get(), INFO_CTRL_PANEL_SERVER_MUST_BE_LOCAL_REBUILD_INDEX_SUMMARY.get()); setEnabledOK(false); } else { displayMainPanel(); setEnabledOK(true); } } }); }
/** Reads configuration information from the configuration files. */ public void readConfiguration() { List<OpenDsException> ex = new ArrayList<OpenDsException>(); Set<ConnectionHandlerDescriptor> ls = new HashSet<ConnectionHandlerDescriptor>(); Set<BackendDescriptor> bs = new HashSet<BackendDescriptor>(); Set<DN> as = new HashSet<DN>(); try { DirectoryServer.getInstance().initializeConfiguration(); if (mustReadSchema()) { try { readSchema(); if (getSchema() != null) { // Update the schema: so that when we call the server code the // latest schema read on the server we are managing is used. DirectoryServer.setSchema(getSchema()); } } catch (OpenDsException oe) { ex.add(oe); } } // Get the Directory Server configuration handler and use it. RootCfg root = ServerManagementContext.getInstance().getRootConfiguration(); try { AdministrationConnectorCfg adminConnector = root.getAdministrationConnector(); this.adminConnector = getConnectionHandler(adminConnector); } catch (ConfigException ce) { ex.add(ce); } for (String connHandler : root.listConnectionHandlers()) { try { ConnectionHandlerCfg connectionHandler = root.getConnectionHandler(connHandler); ls.add(getConnectionHandler(connectionHandler, connHandler)); } catch (OpenDsException oe) { ex.add(oe); } } isSchemaEnabled = root.getGlobalConfiguration().isCheckSchema(); for (String backendName : root.listBackends()) { try { BackendCfg backend = root.getBackend(backendName); Set<BaseDNDescriptor> baseDNs = new HashSet<BaseDNDescriptor>(); for (DN dn : backend.getBaseDN()) { BaseDNDescriptor baseDN = new BaseDNDescriptor(BaseDNDescriptor.Type.NOT_REPLICATED, dn, null, -1, -1, -1); baseDNs.add(baseDN); } Set<IndexDescriptor> indexes = new HashSet<IndexDescriptor>(); Set<VLVIndexDescriptor> vlvIndexes = new HashSet<VLVIndexDescriptor>(); BackendDescriptor.Type type; if (backend instanceof LocalDBBackendCfg) { type = BackendDescriptor.Type.LOCAL_DB; LocalDBBackendCfg db = (LocalDBBackendCfg) backend; try { for (String indexName : db.listLocalDBIndexes()) { LocalDBIndexCfg index = db.getLocalDBIndex(indexName); indexes.add( new IndexDescriptor( index.getAttribute().getNameOrOID(), index.getAttribute(), null, index.getIndexType(), index.getIndexEntryLimit())); } } catch (OpenDsException oe) { ex.add(oe); } indexes.add(new IndexDescriptor("dn2id", null, null, new TreeSet<IndexType>(), -1)); indexes.add( new IndexDescriptor("id2children", null, null, new TreeSet<IndexType>(), -1)); indexes.add( new IndexDescriptor("id2subtree", null, null, new TreeSet<IndexType>(), -1)); try { for (String vlvIndexName : db.listLocalDBVLVIndexes()) { LocalDBVLVIndexCfg index = db.getLocalDBVLVIndex(vlvIndexName); String s = index.getSortOrder(); List<VLVSortOrder> sortOrder = getVLVSortOrder(s); vlvIndexes.add( new VLVIndexDescriptor( index.getName(), null, index.getBaseDN(), index.getScope(), index.getFilter(), sortOrder, index.getMaxBlockSize())); } } catch (OpenDsException oe) { ex.add(oe); } } else if (backend instanceof LDIFBackendCfg) { type = BackendDescriptor.Type.LDIF; } else if (backend instanceof MemoryBackendCfg) { type = BackendDescriptor.Type.MEMORY; } else if (backend instanceof BackupBackendCfg) { type = BackendDescriptor.Type.BACKUP; } else if (backend instanceof MonitorBackendCfg) { type = BackendDescriptor.Type.MONITOR; } else if (backend instanceof TaskBackendCfg) { type = BackendDescriptor.Type.TASK; } else { type = BackendDescriptor.Type.OTHER; } BackendDescriptor desc = new BackendDescriptor( backend.getBackendId(), baseDNs, indexes, vlvIndexes, -1, backend.isEnabled(), type); for (AbstractIndexDescriptor index : indexes) { index.setBackend(desc); } for (AbstractIndexDescriptor index : vlvIndexes) { index.setBackend(desc); } bs.add(desc); } catch (OpenDsException oe) { ex.add(oe); } } boolean isReplicationSecure = false; try { CryptoManagerCfg cryptoManager = root.getCryptoManager(); isReplicationSecure = cryptoManager.isSSLEncryption(); } catch (OpenDsException oe) { ex.add(oe); } replicationPort = -1; ReplicationSynchronizationProviderCfg sync = null; try { sync = (ReplicationSynchronizationProviderCfg) root.getSynchronizationProvider("Multimaster Synchronization"); } catch (OpenDsException oe) { // Ignore this one } if (sync != null) { try { if (sync.isEnabled() && sync.hasReplicationServer()) { ReplicationServerCfg replicationServer = sync.getReplicationServer(); if (replicationServer != null) { replicationPort = replicationServer.getReplicationPort(); ConnectionHandlerDescriptor.Protocol protocol = isReplicationSecure ? ConnectionHandlerDescriptor.Protocol.REPLICATION_SECURE : ConnectionHandlerDescriptor.Protocol.REPLICATION; Set<CustomSearchResult> emptySet = Collections.emptySet(); ConnectionHandlerDescriptor connHandler = new ConnectionHandlerDescriptor( new HashSet<InetAddress>(), replicationPort, protocol, ConnectionHandlerDescriptor.State.ENABLED, "Multimaster Synchronization", emptySet); ls.add(connHandler); } } String[] domains = sync.listReplicationDomains(); if (domains != null) { for (String domain2 : domains) { ReplicationDomainCfg domain = sync.getReplicationDomain(domain2); DN dn = domain.getBaseDN(); for (BackendDescriptor backend : bs) { for (BaseDNDescriptor baseDN : backend.getBaseDns()) { if (baseDN.getDn().equals(dn)) { baseDN.setType( sync.isEnabled() ? BaseDNDescriptor.Type.REPLICATED : BaseDNDescriptor.Type.DISABLED); baseDN.setReplicaID(domain.getServerId()); } } } } } } catch (OpenDsException oe) { ex.add(oe); } } try { RootDNCfg rootDN = root.getRootDN(); String[] rootUsers = rootDN.listRootDNUsers(); as.clear(); if (rootUsers != null) { for (String rootUser2 : rootUsers) { RootDNUserCfg rootUser = rootDN.getRootDNUser(rootUser2); as.addAll(rootUser.getAlternateBindDN()); } } } catch (OpenDsException oe) { ex.add(oe); } } catch (OpenDsException oe) { ex.add(oe); } catch (final Throwable t) { LOG.log(Level.WARNING, "Error reading configuration: " + t, t); OfflineUpdateException oue = new OfflineUpdateException(ERR_READING_CONFIG_LDAP.get(t.getMessage().toString()), t); ex.add(oue); } if (ex.size() > 0) { if (environmentSettingException != null) { ex.add(0, environmentSettingException); } } for (OpenDsException oe : ex) { LOG.log(Level.WARNING, "Error reading configuration: " + oe, oe); } exceptions = Collections.unmodifiableList(ex); administrativeUsers = Collections.unmodifiableSet(as); listeners = Collections.unmodifiableSet(ls); backends = Collections.unmodifiableSet(bs); }
/** * Repopulates the contents of the tree. * * @param tree the tree to be repopulated. */ private void repopulateTree(JTree tree) { ignoreSelectionEvents = true; final Point currentPosition = treeScroll.getViewport().getViewPosition(); DefaultMutableTreeNode root = getRoot(tree); TreePath path = tree.getSelectionPath(); DefaultMutableTreeNode lastSelectedNode = null; if (path != null) { lastSelectedNode = (DefaultMutableTreeNode) path.getLastPathComponent(); } TreePath newSelectionPath = null; BackendDescriptor backend = null; String backendName = (String) backends.getSelectedItem(); if (backendName != null) { for (BackendDescriptor b : getInfo().getServerDescriptor().getBackends()) { if (b.getBackendID().equalsIgnoreCase(backendName)) { backend = b; break; } } } ArrayList<ArrayList<? extends AbstractIndexTreeNode>> nodes = new ArrayList<ArrayList<? extends AbstractIndexTreeNode>>(); ArrayList<IndexTreeNode> standardIndexNodes = new ArrayList<IndexTreeNode>(); ArrayList<VLVIndexTreeNode> vlvIndexNodes = new ArrayList<VLVIndexTreeNode>(); nodes.add(standardIndexNodes); nodes.add(vlvIndexNodes); if (backend != null) { for (IndexDescriptor index : backend.getIndexes()) { standardIndexNodes.add(new IndexTreeNode(index.getName(), index)); } for (VLVIndexDescriptor index : backend.getVLVIndexes()) { vlvIndexNodes.add(new VLVIndexTreeNode(index.getName(), index)); } } DefaultTreeModel model = (DefaultTreeModel) tree.getModel(); int i = 0; int positionUnderRoot = 0; for (DefaultMutableTreeNode parent : categoryNodes) { if (nodes.get(i).size() == 0) { if (root.getIndex(parent) != -1) { model.removeNodeFromParent(parent); parent.removeAllChildren(); } } else { boolean expand = true; if (root.getIndex(parent) == -1) { model.insertNodeInto(parent, root, positionUnderRoot); } else { expand = tree.isExpanded(new TreePath(parent)) || (parent.getChildCount() == 0); parent.removeAllChildren(); } for (AbstractIndexTreeNode node : nodes.get(i)) { parent.add(node); if ((newSelectionPath == null) && ((lastSelectedNode != null) || (lastCreatedIndex != null))) { if (lastCreatedIndex != null) { if ((node instanceof IndexTreeNode) && (lastCreatedIndex instanceof IndexDescriptor)) { if (node.getName().equals(lastCreatedIndex.getName())) { newSelectionPath = new TreePath(node.getPath()); lastCreatedIndex = null; } } else if ((node instanceof VLVIndexTreeNode) && (lastCreatedIndex instanceof VLVIndexDescriptor)) { if (node.getName().equals(lastCreatedIndex.getName())) { newSelectionPath = new TreePath(node.getPath()); lastCreatedIndex = null; } } } else if (node.getName().equals(lastSelectedNode.getUserObject())) { newSelectionPath = new TreePath(node.getPath()); } } } model.nodeStructureChanged(parent); if (expand) { tree.expandPath(new TreePath(parent.getPath())); } positionUnderRoot++; } i++; } if (newSelectionPath == null) { if (firstTreeRepopulate) { newSelectionPath = new TreePath(standardIndexes.getPath()); } } if (newSelectionPath != null) { tree.setSelectionPath(newSelectionPath); tree.scrollPathToVisible(newSelectionPath); } updateEntryPane(); SwingUtilities.invokeLater( new Runnable() { public void run() { if (firstTreeRepopulate) { treeScroll.getViewport().setViewPosition(new Point(0, 0)); } else { treeScroll.getViewport().setViewPosition(currentPosition); } } }); firstTreeRepopulate = false; ignoreSelectionEvents = false; }
/** {@inheritDoc} */ protected boolean displayBackend(BackendDescriptor backend) { return !backend.isConfigBackend() && (backend.getType() == BackendDescriptor.Type.LOCAL_DB); }
/** * The event will contain all the indexes in a given backend. * * @param backend the backend whose indexes have been modified. */ public IndexModifiedEvent(BackendDescriptor backend) { this.modifiedIndexes.addAll(backend.getIndexes()); this.modifiedIndexes.addAll(backend.getVLVIndexes()); }
/** {@inheritDoc} */ protected void updateTableModel(BackendDescriptor backend) { tableModel.setData(new HashSet<AbstractIndexDescriptor>(backend.getVLVIndexes()), getInfo()); }