View Javadoc

1   /*
2    *  Licensed to the Apache Software Foundation (ASF) under one
3    *  or more contributor license agreements.  See the NOTICE file
4    *  distributed with this work for additional information
5    *  regarding copyright ownership.  The ASF licenses this file
6    *  to you under the Apache License, Version 2.0 (the
7    *  "License"); you may not use this file except in compliance
8    *  with the License.  You may obtain a copy of the License at
9    *  
10   *    http://www.apache.org/licenses/LICENSE-2.0
11   *  
12   *  Unless required by applicable law or agreed to in writing,
13   *  software distributed under the License is distributed on an
14   *  "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   *  KIND, either express or implied.  See the License for the
16   *  specific language governing permissions and limitations
17   *  under the License. 
18   *  
19   */
20  package org.apache.directory.server.ldap.gui;
21  
22  
23  import java.awt.BorderLayout;
24  import java.awt.Component;
25  import java.awt.Dimension;
26  import java.awt.Point;
27  import java.awt.Toolkit;
28  import java.awt.event.WindowAdapter;
29  import java.awt.event.WindowEvent;
30  import java.io.IOException;
31  import java.util.ArrayList;
32  import java.util.List;
33  
34  import javax.swing.JOptionPane;
35  import javax.swing.JPanel;
36  import javax.swing.JFrame;
37  import javax.swing.JScrollPane;
38  import javax.swing.JTable;
39  import javax.swing.JButton;
40  import javax.swing.BoxLayout;
41  import javax.swing.JTextField;
42  import javax.swing.JMenuBar;
43  import javax.swing.JMenu;
44  import javax.swing.JMenuItem;
45  import javax.swing.event.ListSelectionEvent;
46  import javax.swing.event.ListSelectionListener;
47  
48  import org.apache.directory.server.ldap.LdapService;
49  import org.apache.directory.server.ldap.LdapSession;
50  import org.apache.directory.server.ldap.handlers.extended.GracefulShutdownHandler;
51  import org.apache.directory.shared.ldap.message.extended.GracefulDisconnect;
52  import org.apache.directory.shared.ldap.message.extended.NoticeOfDisconnect;
53  import org.apache.mina.common.CloseFuture;
54  import org.apache.mina.common.IoAcceptor;
55  import org.apache.mina.common.IoHandler;
56  import org.apache.mina.common.IoSession;
57  import org.apache.mina.common.WriteFuture;
58  
59  import org.slf4j.Logger;
60  import org.slf4j.LoggerFactory;
61  
62  
63  public class SessionsFrame extends JFrame
64  {
65      private static final Logger LOG = LoggerFactory.getLogger( SessionsFrame.class );
66      private static final long serialVersionUID = -863445561454536133L;
67      private static final String REFRESH_COMMAND = "Refresh";
68  
69      boolean isServiceBound = true;
70      private IoSession requestor;
71      private IoHandler ldapProvider;
72      private JPanel jContentPane;
73      private JPanel mainPanel;
74      private JScrollPane sessionsPane;
75      private JTable sessionsTable;
76      private JPanel filterPanel;
77      private JButton filterButton;
78      private JTextField filterText;
79      private JMenuBar menuBar;
80      private JMenu menuFile;
81      private JMenuItem exitItem;
82      private JMenu menuSession;
83      private JMenuItem closeItem;
84      private JMenu menuSendNoD;
85      private JMenuItem unavailableItem;
86      private JMenuItem protocolErrorItem;
87      private JMenuItem strongAuthRequiredItem;
88      private JPanel southPanel;
89      private JMenuItem showRequests;
90      private JButton refreshButton;
91  
92      private LdapSession selected;
93      private JMenuItem unbindItem;
94      private JMenuItem bindItem;
95      private LdapService ldapService;
96  
97  
98      /**
99       * This is the default constructor
100      * @param ldapService the session registry
101      */
102     public SessionsFrame( LdapService ldapService )
103     {
104         super();
105         this.ldapService = ldapService;
106         initialize();
107     }
108 
109 
110     /**
111      * This method initializes this
112      */
113     private void initialize()
114     {
115         this.setSize( 789, 436 );
116         this.setJMenuBar( getMainMenuBar() );
117         this.setContentPane( getJContentPane() );
118         this.setTitle( "Sessions" );
119         this.addWindowListener( new java.awt.event.WindowAdapter()
120         {
121             public void windowClosing( java.awt.event.WindowEvent e )
122             {
123                 SessionsFrame.this.setVisible( false );
124                 SessionsFrame.this.dispose();
125             }
126         } );
127     }
128 
129 
130     /**
131      * This method initializes jContentPane
132      * 
133      * @return javax.swing.JPanel
134      */
135     private JPanel getJContentPane()
136     {
137         if ( jContentPane == null )
138         {
139             jContentPane = new JPanel();
140             jContentPane.setLayout( new BorderLayout() );
141             jContentPane.add( getMainPanel(), java.awt.BorderLayout.CENTER );
142         }
143         return jContentPane;
144     }
145 
146 
147     /**
148      * This method initializes jPanel    
149      *     
150      * @return javax.swing.JPanel    
151      */
152     private JPanel getMainPanel()
153     {
154         if ( mainPanel == null )
155         {
156             mainPanel = new JPanel();
157             mainPanel.setLayout( new BorderLayout() );
158             mainPanel.add( getFilterPanel(), java.awt.BorderLayout.NORTH );
159             mainPanel.add( getSessionsPane(), java.awt.BorderLayout.CENTER );
160             mainPanel.add( getSouthPanel(), java.awt.BorderLayout.SOUTH );
161         }
162         return mainPanel;
163     }
164 
165 
166     /**
167      * This method initializes jScrollPane    
168      *     
169      * @return javax.swing.JScrollPane    
170      */
171     private JScrollPane getSessionsPane()
172     {
173         if ( sessionsPane == null )
174         {
175             sessionsPane = new JScrollPane();
176             sessionsPane.setName( "jScrollPane" );
177             sessionsPane.setViewportView( getSessionsTable() );
178         }
179         return sessionsPane;
180     }
181 
182 
183     /**
184      * This method initializes jTable    
185      *     
186      * @return javax.swing.JTable    
187      */
188     private JTable getSessionsTable()
189     {
190         if ( sessionsTable == null )
191         {
192             sessionsTable = new JTable();
193             sessionsTable.setSelectionMode( javax.swing.ListSelectionModel.SINGLE_SELECTION );
194             sessionsTable.setModel( new SessionsModel( ldapService.getLdapSessionManager().getSessions() ) );
195             sessionsTable.getSelectionModel().addListSelectionListener( new ListSelectionListener()
196             {
197                 public void valueChanged( ListSelectionEvent e )
198                 {
199                     int row = sessionsTable.getSelectedRow();
200                     if ( row == -1 )
201                     {
202                         selected = null;
203                     }
204                     else
205                     {
206                         selected = ( ( SessionsModel ) sessionsTable.getModel() ).getLdapSession( row );
207                         closeItem.setEnabled( true );
208                         menuSendNoD.setEnabled( true );
209                         showRequests.setEnabled( true );
210                     }
211                 }
212             } );
213         }
214         return sessionsTable;
215     }
216 
217 
218     /**
219      * This method initializes jPanel    
220      *     
221      * @return javax.swing.JPanel    
222      */
223     private JPanel getFilterPanel()
224     {
225         if ( filterPanel == null )
226         {
227             filterPanel = new JPanel();
228             filterPanel.setLayout( new BoxLayout( getFilterPanel(), BoxLayout.X_AXIS ) );
229             filterPanel.setBorder( javax.swing.BorderFactory
230                 .createEtchedBorder( javax.swing.border.EtchedBorder.RAISED ) );
231             filterPanel.add( getFilterButton(), null );
232             filterPanel.add( getFilterText(), null );
233         }
234         return filterPanel;
235     }
236 
237 
238     /**
239      * This method initializes jButton    
240      *     
241      * @return javax.swing.JButton    
242      */
243     private JButton getFilterButton()
244     {
245         if ( filterButton == null )
246         {
247             filterButton = new JButton();
248             filterButton.setText( "Filter" );
249         }
250         return filterButton;
251     }
252 
253 
254     /**
255      * This method initializes jTextField    
256      *     
257      * @return javax.swing.JTextField    
258      */
259     private JTextField getFilterText()
260     {
261         if ( filterText == null )
262         {
263             filterText = new JTextField();
264         }
265         return filterText;
266     }
267 
268 
269     /**
270      * This method initializes jJMenuBar    
271      *     
272      * @return javax.swing.JMenuBar    
273      */
274     private JMenuBar getMainMenuBar()
275     {
276         if ( menuBar == null )
277         {
278             menuBar = new JMenuBar();
279             menuBar.add( getMenuFile() );
280             menuBar.add( getMenuSession() );
281         }
282         return menuBar;
283     }
284 
285 
286     /**
287      * This method initializes jMenu    
288      *     
289      * @return javax.swing.JMenu    
290      */
291     private JMenu getMenuFile()
292     {
293         if ( menuFile == null )
294         {
295             menuFile = new JMenu();
296             menuFile.setText( "File" );
297             menuFile.add( getExitItem() );
298         }
299         return menuFile;
300     }
301 
302 
303     /**
304      * This method initializes jMenuItem    
305      *     
306      * @return javax.swing.JMenuItem    
307      */
308     private JMenuItem getExitItem()
309     {
310         if ( exitItem == null )
311         {
312             exitItem = new JMenuItem();
313             exitItem.setText( "exit" );
314             exitItem.addActionListener( new java.awt.event.ActionListener()
315             {
316                 public void actionPerformed( java.awt.event.ActionEvent e )
317                 {
318                     SessionsFrame.this.setVisible( false );
319                     SessionsFrame.this.dispose();
320                 }
321             } );
322         }
323         return exitItem;
324     }
325 
326 
327     /**
328      * This method initializes jMenu    
329      *     
330      * @return javax.swing.JMenu    
331      */
332     private JMenu getMenuSession()
333     {
334         if ( menuSession == null )
335         {
336             menuSession = new JMenu();
337             menuSession.setText( "Session" );
338             menuSession.add( getCloseItem() );
339             closeItem.setEnabled( false );
340             menuSession.add( getMenuSendNoD() );
341             menuSendNoD.setEnabled( false );
342             menuSession.add( getShowRequests() );
343             menuSession.add( getUnbindItem() );
344             menuSession.add( getBindItem() );
345             showRequests.setEnabled( false );
346         }
347         return menuSession;
348     }
349 
350 
351     /**
352      * This method initializes jMenuItem    
353      *     
354      * @return javax.swing.JMenuItem    
355      */
356     private JMenuItem getCloseItem()
357     {
358         if ( closeItem == null )
359         {
360             closeItem = new JMenuItem();
361             closeItem.setText( "close" );
362             closeItem.addActionListener( new java.awt.event.ActionListener()
363             {
364                 public void actionPerformed( java.awt.event.ActionEvent e )
365                 {
366                     ldapService.getLdapSessionManager().removeLdapSession( selected.getIoSession() );
367                     try
368                     {
369                         Thread.sleep( 250 );
370                     }
371                     catch ( InterruptedException e1 )
372                     {
373                         LOG.error( "", e1 );
374                     }
375                     refresh();
376                 }
377             } );
378         }
379         return closeItem;
380     }
381 
382 
383     /**
384      * This method initializes jMenu    
385      *     
386      * @return javax.swing.JMenu    
387      */
388     private JMenu getMenuSendNoD()
389     {
390         if ( menuSendNoD == null )
391         {
392             menuSendNoD = new JMenu();
393             menuSendNoD.setText( "Send NoD" );
394             menuSendNoD.add( getUnavailableItem() );
395             menuSendNoD.add( getProtocolErrorItem() );
396             menuSendNoD.add( getStrongAuthRequiredItem() );
397         }
398         return menuSendNoD;
399     }
400 
401 
402     /**
403      * This method initializes jMenuItem    
404      *     
405      * @return javax.swing.JMenuItem    
406      */
407     private JMenuItem getUnavailableItem()
408     {
409         if ( unavailableItem == null )
410         {
411             unavailableItem = new JMenuItem();
412             unavailableItem.setText( "unavailable" );
413             unavailableItem.addActionListener( new java.awt.event.ActionListener()
414             {
415                 public void actionPerformed( java.awt.event.ActionEvent e )
416                 {
417                     selected.getIoSession().write( NoticeOfDisconnect.UNAVAILABLE );
418                     try
419                     {
420                         Thread.sleep( 250 );
421                     }
422                     catch ( InterruptedException e1 )
423                     {
424                         LOG.error( "", e1 );
425                     }
426                     refresh();
427                 }
428             } );
429         }
430         return unavailableItem;
431     }
432 
433 
434     /**
435      * This method initializes jMenuItem    
436      *     
437      * @return javax.swing.JMenuItem    
438      */
439     private JMenuItem getProtocolErrorItem()
440     {
441         if ( protocolErrorItem == null )
442         {
443             protocolErrorItem = new JMenuItem();
444             protocolErrorItem.setText( "protocolError" );
445             protocolErrorItem.addActionListener( new java.awt.event.ActionListener()
446             {
447                 public void actionPerformed( java.awt.event.ActionEvent e )
448                 {
449                     selected.getIoSession().write( NoticeOfDisconnect.PROTOCOLERROR );
450                     try
451                     {
452                         Thread.sleep( 250 );
453                     }
454                     catch ( InterruptedException e1 )
455                     {
456                         LOG.error( "", e1 );
457                     }
458                     refresh();
459                 }
460             } );
461         }
462         return protocolErrorItem;
463     }
464 
465 
466     /**
467      * This method initializes jMenuItem    
468      *     
469      * @return javax.swing.JMenuItem    
470      */
471     private JMenuItem getStrongAuthRequiredItem()
472     {
473         if ( strongAuthRequiredItem == null )
474         {
475             strongAuthRequiredItem = new JMenuItem();
476             strongAuthRequiredItem.setText( "strongAuthRequired" );
477             strongAuthRequiredItem.addActionListener( new java.awt.event.ActionListener()
478             {
479                 public void actionPerformed( java.awt.event.ActionEvent e )
480                 {
481                     WriteFuture future = selected.getIoSession().write( NoticeOfDisconnect.STRONGAUTHREQUIRED );
482                     try
483                     {
484                         future.join( 1000 );
485                         CloseFuture cfuture = selected.getIoSession().close();
486                         cfuture.join( 1000 );
487                     }
488                     catch ( Exception e1 )
489                     {
490                         LOG.error( "", e1 );
491                     }
492                     refresh();
493                 }
494             } );
495         }
496         return strongAuthRequiredItem;
497     }
498 
499 
500     //    /**
501     //     * This method initializes jPopupMenu    
502     //     *     
503     //     * @return javax.swing.JPopupMenu    
504     //     */
505     //    private JPopupMenu getSessionsPopupMenu()
506     //    {
507     //        if ( popupMenu == null )
508     //        {
509     //            popupMenu = new JPopupMenu();
510     //            popupMenu.add(getJMenuItem());
511     //            popupMenu.add(getJMenu());
512     //            popupMenu.add(getJMenuItem4());
513     //        }
514     //        return popupMenu;
515     //    }
516 
517     /**
518      * This method initializes jPanel    
519      *     
520      * @return javax.swing.JPanel    
521      */
522     private JPanel getSouthPanel()
523     {
524         if ( southPanel == null )
525         {
526             southPanel = new JPanel();
527             southPanel
528                 .setBorder( javax.swing.BorderFactory.createEtchedBorder( javax.swing.border.EtchedBorder.RAISED ) );
529             southPanel.add( getRefreshButton(), null );
530         }
531         return southPanel;
532     }
533 
534 
535     /**
536      * This method initializes jMenuItem    
537      *     
538      * @return javax.swing.JMenuItem    
539      */
540     private JMenuItem getShowRequests()
541     {
542         if ( showRequests == null )
543         {
544             showRequests = new JMenuItem();
545             showRequests.setText( "show requests" );
546             showRequests.addActionListener( new java.awt.event.ActionListener()
547             {
548                 public void actionPerformed( java.awt.event.ActionEvent e )
549                 {
550                     OutstandingRequestsDialog dialog =
551                             new OutstandingRequestsDialog( SessionsFrame.this, selected, ldapService );
552                     dialog.addWindowListener( new WindowAdapter()
553                     {
554                         public void windowClosed( WindowEvent e )
555                         {
556                             e.getWindow().dispose();
557                         }
558                     } );
559                     dialog.setVisible( true );
560                 }
561             } );
562         }
563         return showRequests;
564     }
565 
566 
567     //    /**
568     //     * This method initializes jMenuItem    
569     //     *     
570     //     * @return javax.swing.JMenuItem    
571     //     */
572     //    private JMenuItem getJMenuItem()
573     //    {
574     //        if ( jMenuItem == null )
575     //        {
576     //            jMenuItem = new JMenuItem();
577     //            jMenuItem.setText("close");
578     //        }
579     //        return jMenuItem;
580     //    }
581     //
582     //
583     //    /**
584     //     * This method initializes jMenu    
585     //     *     
586     //     * @return javax.swing.JMenu    
587     //     */
588     //    private JMenu getJMenu()
589     //    {
590     //        if ( jMenu == null )
591     //        {
592     //            jMenu = new JMenu();
593     //            jMenu.setText("Send NoD");
594     //            jMenu.add(getJMenuItem1());
595     //            jMenu.add(getJMenuItem2());
596     //            jMenu.add(getJMenuItem3());
597     //        }
598     //        return jMenu;
599     //    }
600     //
601     //
602     //    /**
603     //     * This method initializes jMenuItem1    
604     //     *     
605     //     * @return javax.swing.JMenuItem    
606     //     */
607     //    private JMenuItem getJMenuItem1()
608     //    {
609     //        if ( jMenuItem1 == null )
610     //        {
611     //            jMenuItem1 = new JMenuItem();
612     //            jMenuItem1.setText("unavailable");
613     //        }
614     //        return jMenuItem1;
615     //    }
616     //
617     //
618     //    /**
619     //     * This method initializes jMenuItem2    
620     //     *     
621     //     * @return javax.swing.JMenuItem    
622     //     */
623     //    private JMenuItem getJMenuItem2()
624     //    {
625     //        if ( jMenuItem2 == null )
626     //        {
627     //            jMenuItem2 = new JMenuItem();
628     //            jMenuItem2.setText("protocolError");
629     //        }
630     //        return jMenuItem2;
631     //    }
632     //
633     //
634     //    /**
635     //     * This method initializes jMenuItem3    
636     //     *     
637     //     * @return javax.swing.JMenuItem    
638     //     */
639     //    private JMenuItem getJMenuItem3()
640     //    {
641     //        if ( jMenuItem3 == null )
642     //        {
643     //            jMenuItem3 = new JMenuItem();
644     //            jMenuItem3.setText("strongAuthRequired");
645     //        }
646     //        return jMenuItem3;
647     //    }
648     //
649     //
650     //    /**
651     //     * This method initializes jMenuItem4    
652     //     *     
653     //     * @return javax.swing.JMenuItem    
654     //     */
655     //    private JMenuItem getJMenuItem4()
656     //    {
657     //        if ( jMenuItem4 == null )
658     //        {
659     //            jMenuItem4 = new JMenuItem();
660     //            jMenuItem4.setText("show requests");
661     //        }
662     //        return jMenuItem4;
663     //    }
664 
665     /**
666      * This method initializes jButton2    
667      *     
668      * @return javax.swing.JButton    
669      */
670     private JButton getRefreshButton()
671     {
672         if ( refreshButton == null )
673         {
674             refreshButton = new JButton();
675             refreshButton.setText( REFRESH_COMMAND );
676             refreshButton.addActionListener( new java.awt.event.ActionListener()
677             {
678                 public void actionPerformed( java.awt.event.ActionEvent e )
679                 {
680                     if ( e.getActionCommand().equals( REFRESH_COMMAND ) )
681                     {
682                         refresh();
683                     }
684                 }
685             } );
686         }
687         return refreshButton;
688     }
689 
690 
691     private void refresh()
692     {
693         LOG.info( "Refreshing Sessions UI" );
694         sessionsTable.setModel( new SessionsModel( ldapService.getLdapSessionManager().getSessions() ) );
695         closeItem.setEnabled( false );
696         menuSendNoD.setEnabled( false );
697         showRequests.setEnabled( false );
698         unbindItem.setEnabled( isServiceBound );
699         bindItem.setEnabled( !isServiceBound );
700     }
701 
702     public void setRequestor( IoSession requestor )
703     {
704         this.requestor = requestor;
705     }
706 
707     /**
708      * This method initializes jMenuItem    
709      *     
710      * @return javax.swing.JMenuItem    
711      */
712     private JMenuItem getUnbindItem()
713     {
714         if ( unbindItem == null )
715         {
716             unbindItem = new JMenuItem();
717             unbindItem.setText( "Unbind Service" );
718             unbindItem.setEnabled( isServiceBound );
719             unbindItem.addActionListener( new java.awt.event.ActionListener()
720             {
721                 public void actionPerformed( java.awt.event.ActionEvent e )
722                 {
723                     int input = JOptionPane.showConfirmDialog( SessionsFrame.this,
724                         "Selecting no will send a notice of disconnect ONLY.  "
725                             + "\nSelecting yes will send both.  Cancel will abort unbind.",
726                         "Send graceful disconnect before disconnect notice?", JOptionPane.YES_NO_CANCEL_OPTION );
727                     IoAcceptor acceptor = ( IoAcceptor ) requestor.getService();
728                     List<IoSession> sessions = new ArrayList<IoSession>(
729                             acceptor.getManagedSessions( requestor.getServiceAddress() ) );
730 
731                     if ( input == JOptionPane.CANCEL_OPTION )
732                     {
733                     }
734                     else if ( input == JOptionPane.NO_OPTION )
735                     {
736                         GracefulShutdownHandler.sendNoticeOfDisconnect( sessions, requestor );
737                         acceptor.unbind( requestor.getServiceAddress() );
738                         isServiceBound = false;
739                         unbindItem.setEnabled( isServiceBound );
740                         bindItem.setEnabled( !isServiceBound );
741                         JOptionPane.showMessageDialog( SessionsFrame.this, "Ldap service for "
742                             + requestor.getLocalAddress() + " has been successfully unbound.", "Success!",
743                             JOptionPane.INFORMATION_MESSAGE );
744                         refresh();
745                     }
746                     else
747                     {
748                         ShutdownDialog dialog = new ShutdownDialog();
749                         setCenteredPosition( SessionsFrame.this, dialog );
750                         dialog.setModal( true );
751                         dialog.setVisible( true );
752 
753                         if ( dialog.isSendCanceled() )
754                         {
755                             LOG.debug( "GracefulShutdown was canceled." );
756                             JOptionPane.showMessageDialog( SessionsFrame.this, "Shutdown has been canceled.",
757                                 "Graceful Shutdown Aborted", JOptionPane.OK_OPTION );
758                             return;
759                         }
760 
761                         LOG.debug( "GracefulShutdown parameters captured." );
762                         int timeOffline = dialog.getTimeOffline();
763                         int delay = dialog.getDelay();
764                         GracefulDisconnect graceful = new GracefulDisconnect( timeOffline, delay );
765                         GracefulShutdownHandler.sendGracefulDisconnect( sessions, graceful, requestor );
766                         acceptor.unbind( requestor.getServiceAddress() );
767                         isServiceBound = false;
768                         unbindItem.setEnabled( isServiceBound );
769                         bindItem.setEnabled( !isServiceBound );
770 
771                         // do progress dialog with bypass button to wait for delay time
772                         if ( delay > 0 )
773                         {
774                             ShutdownProgress progress = new ShutdownProgress();
775                             setCenteredPosition( SessionsFrame.this, progress );
776                             progress.setModal( true );
777                             progress.setTime( delay * 1000 );
778                             Thread t = new Thread( progress );
779                             t.start();
780                             progress.setVisible( true );
781                         }
782 
783                         // now send the notice of disconnect
784                         GracefulShutdownHandler.sendNoticeOfDisconnect( sessions, requestor );
785                         JOptionPane.showMessageDialog( SessionsFrame.this, "Ldap service for "
786                             + requestor.getLocalAddress() + " has been successfully unbound.", "Success!",
787                             JOptionPane.OK_OPTION );
788                         refresh();
789                     }
790                 }
791             } );
792         }
793         return unbindItem;
794     }
795 
796 
797     private void setCenteredPosition( JFrame frame, Component comp )
798     {
799         Point pt = new Point();
800         Toolkit tk = Toolkit.getDefaultToolkit();
801         Dimension screenSize = tk.getScreenSize();
802         pt.x = ( screenSize.width - frame.getWidth() ) / 2;
803         pt.y = ( screenSize.height - frame.getHeight() ) / 2;
804 
805         pt.x += ( frame.getWidth() - comp.getWidth() ) / 2;
806         pt.y += ( frame.getHeight() - comp.getHeight() ) / 2;
807         comp.setLocation( pt );
808     }
809 
810 
811     /**
812      * This method initializes jMenuItem    
813      *     
814      * @return javax.swing.JMenuItem    
815      */
816     private JMenuItem getBindItem()
817     {
818         if ( bindItem == null )
819         {
820             bindItem = new JMenuItem();
821             bindItem.setText( "Bind Service" );
822             unbindItem.setEnabled( !isServiceBound );
823             bindItem.addActionListener( new java.awt.event.ActionListener()
824             {
825                 public void actionPerformed( java.awt.event.ActionEvent e )
826                 {
827                     try
828                     {
829                         ( ( IoAcceptor ) requestor.getService() ).bind( requestor.getServiceAddress(), getLdapProvider() );
830                         JOptionPane.showMessageDialog( SessionsFrame.this, "Ldap service " + requestor.getServiceAddress()
831                             + " has been successfully bound.\n" + " Clients may now connect to the server once again.",
832                             "Success!", JOptionPane.INFORMATION_MESSAGE );
833                         isServiceBound = true;
834                         unbindItem.setEnabled( isServiceBound );
835                         bindItem.setEnabled( !isServiceBound );
836                     }
837                     catch ( IOException e1 )
838                     {
839                         LOG.error( "failed to rebind ldap service", e1 );
840                         JOptionPane.showMessageDialog( SessionsFrame.this, e1.getMessage(), "Error encountered!",
841                             JOptionPane.ERROR_MESSAGE );
842                     }
843                 }
844             } );
845         }
846         return bindItem;
847     }
848 
849 
850     public void setLdapProvider( IoHandler ldapProvider )
851     {
852         this.ldapProvider = ldapProvider;
853     }
854 
855 
856     public IoHandler getLdapProvider()
857     {
858         return ldapProvider;
859     }
860 } //  @jve:decl-index=0:visual-constraint="10,10"