service/simulator/java/eclipse-plugin/ServiceProviderPlugin/src/oic/simulator/serviceprovider/view/ResourceManagerView.java

   1 /*
   2  * Copyright 2015 Samsung Electronics All Rights Reserved.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package oic.simulator.serviceprovider.view;
  18
  19 import java.util.ArrayList;
  20 import java.util.List;
  21
  22 import oic.simulator.serviceprovider.Activator;
  23 import oic.simulator.serviceprovider.listener.IPropertiesChangedListener;
  24 import oic.simulator.serviceprovider.listener.IResourceListChangedListener;
  25 import oic.simulator.serviceprovider.manager.ResourceManager;
  26 import oic.simulator.serviceprovider.manager.UiListenerHandler;
  27 import oic.simulator.serviceprovider.model.AutomationSettingHelper;
  28 import oic.simulator.serviceprovider.model.Resource;
  29 import oic.simulator.serviceprovider.model.ResourceType;
  30 import oic.simulator.serviceprovider.model.SingleResource;
  31 import oic.simulator.serviceprovider.utils.Constants;
  32 import oic.simulator.serviceprovider.utils.Utility;
  33 import oic.simulator.serviceprovider.view.dialogs.AutomationSettingDialog;
  34 import oic.simulator.serviceprovider.view.dialogs.CreateResourceWizard;
  35 import oic.simulator.serviceprovider.view.dialogs.DeleteResourceWizard;
  36 import oic.simulator.serviceprovider.view.dialogs.MainPage.Option;
  37 import oic.simulator.serviceprovider.view.dialogs.ResourceWizardDialog;
  38
  39 import org.eclipse.jface.dialogs.MessageDialog;
  40 import org.eclipse.jface.viewers.ISelectionChangedListener;
  41 import org.eclipse.jface.viewers.IStructuredSelection;
  42 import org.eclipse.jface.viewers.ITreeContentProvider;
  43 import org.eclipse.jface.viewers.LabelProvider;
  44 import org.eclipse.jface.viewers.SelectionChangedEvent;
  45 import org.eclipse.jface.viewers.StructuredSelection;
  46 import org.eclipse.jface.viewers.TreeViewer;
  47 import org.eclipse.jface.viewers.Viewer;
  48 import org.eclipse.jface.window.Window;
  49 import org.eclipse.jface.wizard.WizardDialog;
  50 import org.eclipse.swt.SWT;
  51 import org.eclipse.swt.events.MenuAdapter;
  52 import org.eclipse.swt.events.MenuEvent;
  53 import org.eclipse.swt.events.SelectionAdapter;
  54 import org.eclipse.swt.events.SelectionEvent;
  55 import org.eclipse.swt.graphics.Color;
  56 import org.eclipse.swt.graphics.Image;
  57 import org.eclipse.swt.layout.GridData;
  58 import org.eclipse.swt.layout.GridLayout;
  59 import org.eclipse.swt.widgets.Button;
  60 import org.eclipse.swt.widgets.Composite;
  61 import org.eclipse.swt.widgets.Display;
  62 import org.eclipse.swt.widgets.Group;
  63 import org.eclipse.swt.widgets.Menu;
  64 import org.eclipse.swt.widgets.MenuItem;
  65 import org.eclipse.swt.widgets.Tree;
  66 import org.eclipse.ui.PlatformUI;
  67 import org.eclipse.ui.dialogs.FilteredTree;
  68 import org.eclipse.ui.dialogs.PatternFilter;
  69 import org.eclipse.ui.part.ViewPart;
  70 import org.oic.simulator.SimulatorException;
  71 import org.oic.simulator.server.SimulatorResource.AutoUpdateType;
  72
  73 /**
  74  * This class manages and shows the resource manager view in the perspective.
  75  */
  76 public class ResourceManagerView extends ViewPart {
  77
  78     public static final String           VIEW_ID = "oic.simulator.serviceprovider.view.resourcemanager";
  79
  80     private Button                       createButton;
  81     private Button                       deleteButton;
  82
  83     private TreeViewer                   singleResTreeViewer;
  84
  85     private IResourceListChangedListener resourceListChangedListener;
  86
  87     private IPropertiesChangedListener   resourcePropertiesChangedListener;
  88
  89     private ResourceManager              resourceManager;
  90
  91     public ResourceManagerView() {
  92
  93         resourceManager = Activator.getDefault().getResourceManager();
  94
  95         resourceListChangedListener = new IResourceListChangedListener() {
  96
  97             @Override
  98             public void onResourceCreation(final ResourceType type) {
  99                 Display.getDefault().asyncExec(new Runnable() {
 100
 101                     @Override
 102                     public void run() {
 103                         if (type == ResourceType.SINGLE) {
 104                             if (null != singleResTreeViewer) {
 105                                 singleResTreeViewer.refresh();
 106                             }
 107                         }
 108
 109                         // Trigger the visibility of delete button
 110                         changeDeleteVisibility();
 111                     }
 112                 });
 113             }
 114
 115             @Override
 116             public void onResourceDeletion(final ResourceType type) {
 117                 Display.getDefault().asyncExec(new Runnable() {
 118
 119                     @Override
 120                     public void run() {
 121                         switch (type) {
 122                             case SINGLE:
 123                                 if (null != singleResTreeViewer)
 124                                     singleResTreeViewer.refresh();
 125                                 break;
 126                         }
 127
 128                         // Trigger the visibility of delete button
 129                         changeDeleteVisibility();
 130                     }
 131                 });
 132             }
 133
 134             @Override
 135             public void onResourceListUpdate(final ResourceType type) {
 136                 Display.getDefault().asyncExec(new Runnable() {
 137
 138                     @Override
 139                     public void run() {
 140                         switch (type) {
 141                             case SINGLE:
 142                                 if (null != singleResTreeViewer)
 143                                     singleResTreeViewer.refresh();
 144                                 break;
 145                         }
 146                     }
 147                 });
 148             }
 149         };
 150
 151         resourcePropertiesChangedListener = new IPropertiesChangedListener() {
 152
 153             @Override
 154             public void onResourcePropertyChange() {
 155                 Display.getDefault().asyncExec(new Runnable() {
 156                     @Override
 157                     public void run() {
 158                         if (null != singleResTreeViewer)
 159                             singleResTreeViewer.refresh();
 160                     }
 161                 });
 162             }
 163         };
 164     }
 165
 166     public void changeDeleteVisibility() {
 167         boolean visibility = resourceManager.isAnyResourceExist();
 168         if (null != deleteButton && !deleteButton.isDisposed()) {
 169             deleteButton.setEnabled(visibility);
 170         }
 171     }
 172
 173     @Override
 174     public void createPartControl(Composite parent) {
 175         Composite compContent = new Composite(parent, SWT.NONE);
 176         GridLayout baseLayout = new GridLayout(1, false);
 177         compContent.setLayout(baseLayout);
 178
 179         GridData gd = new GridData(SWT.FILL, SWT.FILL, true, true);
 180         compContent.setLayoutData(gd);
 181
 182         Composite buttonComp = new Composite(compContent, SWT.NONE);
 183         buttonComp.setLayout(new GridLayout(2, false));
 184
 185         gd = new GridData();
 186         gd.horizontalAlignment = SWT.FILL;
 187         gd.grabExcessHorizontalSpace = true;
 188
 189         buttonComp.setLayoutData(gd);
 190
 191         createButton = new Button(buttonComp, SWT.PUSH);
 192         createButton.setText("Create");
 193         createButton.setToolTipText("Create Simulator Resource(s)");
 194
 195         gd = new GridData();
 196         gd.widthHint = 90;
 197         createButton.setLayoutData(gd);
 198
 199         deleteButton = new Button(buttonComp, SWT.PUSH);
 200         deleteButton.setText("Delete");
 201         deleteButton.setToolTipText("Delete Simulator Resource(s)");
 202
 203         gd = new GridData();
 204         gd.widthHint = 90;
 205         deleteButton.setLayoutData(gd);
 206
 207         createSimpleResourcesArea(compContent);
 208
 209         addUIListeners();
 210
 211         addManagerListeners();
 212
 213         // If there is at least one resource exist, then enable the delete
 214         // resource button
 215         changeDeleteVisibility();
 216     }
 217
 218     private void createSimpleResourcesArea(Composite compContent) {
 219         // Create a group to show all the discovered resources.
 220         // Adding the group to the folder.
 221         Group resourceGroup = new Group(compContent, SWT.NONE);
 222
 223         Color color = Display.getDefault().getSystemColor(SWT.COLOR_WHITE);
 224         resourceGroup.setBackground(color);
 225
 226         resourceGroup.setLayout(new GridLayout(1, false));
 227         GridData gd = new GridData(SWT.FILL, SWT.FILL, true, true);
 228         resourceGroup.setLayoutData(gd);
 229
 230         PatternFilter filter = new PatternFilter();
 231         FilteredTree filteredTree = new FilteredTree(resourceGroup,
 232                 SWT.H_SCROLL | SWT.V_SCROLL | SWT.SINGLE, filter, true);
 233         singleResTreeViewer = filteredTree.getViewer();
 234         singleResTreeViewer.getTree().setLayoutData(
 235                 new GridData(SWT.FILL, SWT.FILL, true, true));
 236         singleResTreeViewer
 237                 .setContentProvider(new SingleResourceContentProvider());
 238         singleResTreeViewer.setLabelProvider(new TreeLabelProvider());
 239         singleResTreeViewer.setInput(new Object());
 240
 241         singleResTreeViewer
 242                 .addSelectionChangedListener(new ISelectionChangedListener() {
 243                     @Override
 244                     public void selectionChanged(SelectionChangedEvent e) {
 245                         IStructuredSelection selection = (IStructuredSelection) e
 246                                 .getSelection();
 247                         if (null == selection) {
 248                             return;
 249                         }
 250
 251                         Resource res = null;
 252                         int size = selection.size();
 253                         if (size == 1) {
 254                             res = (Resource) selection.getFirstElement();
 255                         }
 256                         resourceManager.resourceSelectionChanged(res);
 257                     }
 258                 });
 259
 260         addMenuToSimpleResources();
 261     }
 262
 263     private void addMenuToSimpleResources() {
 264         if (null != singleResTreeViewer) {
 265             final Tree resourceTreeHead = singleResTreeViewer.getTree();
 266             if (null != resourceTreeHead) {
 267                 // Below code creates menu entries and shows them on right
 268                 // clicking a resource
 269                 final Menu menu = new Menu(resourceTreeHead);
 270                 resourceTreeHead.setMenu(menu);
 271                 menu.addMenuListener(new MenuAdapter() {
 272                     @Override
 273                     public void menuShown(MenuEvent e) {
 274                         // Clear existing menu items
 275                         MenuItem[] items = menu.getItems();
 276                         for (int index = 0; index < items.length; index++) {
 277                             items[index].dispose();
 278                         }
 279
 280                         IStructuredSelection selection = ((IStructuredSelection) singleResTreeViewer
 281                                 .getSelection());
 282                         final SingleResource resource = (SingleResource) selection
 283                                 .getFirstElement();
 284                         if (null == resource) {
 285                             return;
 286                         }
 287
 288                         addAutomationMenu(menu, resource);
 289
 290                         // Menu to remove the resource.
 291                         MenuItem deleteResource = new MenuItem(menu, SWT.NONE);
 292                         deleteResource.setText("Delete");
 293                         deleteResource
 294                                 .addSelectionListener(new SelectionAdapter() {
 295                                     @Override
 296                                     public void widgetSelected(SelectionEvent e) {
 297                                         try {
 298                                             resourceManager
 299                                                     .removeResource(resource);
 300                                             singleResTreeViewer.refresh();
 301
 302                                             resourceManager
 303                                                     .resourceSelectionChanged(null);
 304
 305                                             MessageDialog.openInformation(
 306                                                     Display.getDefault()
 307                                                             .getActiveShell(),
 308                                                     "Deleted",
 309                                                     "Resource deleted.");
 310                                         } catch (SimulatorException e1) {
 311                                             MessageDialog
 312                                                     .openInformation(Display
 313                                                             .getDefault()
 314                                                             .getActiveShell(),
 315                                                             "Deletion Failed",
 316                                                             "Failed to delete the resource.");
 317                                         }
 318                                         changeDeleteVisibility();
 319                                     }
 320                                 });
 321                     }
 322                 });
 323             }
 324         }
 325     }
 326
 327     private void addAutomationMenu(final Menu menu,
 328             final SingleResource selectedResource) {
 329         MenuItem startItem = new MenuItem(menu, SWT.NONE);
 330         startItem.setText(Constants.START_RESOURCE_AUTOMATION);
 331         startItem.addSelectionListener(new SelectionAdapter() {
 332             @Override
 333             public void widgetSelected(SelectionEvent e) {
 334                 // Block starting resource level
 335                 // automation if any attribute level
 336                 // automation is in progress for the
 337                 // selected resource
 338                 boolean started = resourceManager
 339                         .isAttributeAutomationStarted(selectedResource);
 340                 if (started) {
 341                     MessageDialog
 342                             .openInformation(
 343                                     Display.getDefault().getActiveShell(),
 344                                     "Attribute automation is in progress",
 345                                     "Attribute level automation for this resource is already in progress!!!\nPlease stop all "
 346                                             + "running attribute level automations to start resource level automation.");
 347                 } else {
 348
 349                     // Start the automation
 350                     // Fetch the settings data
 351                     List<AutomationSettingHelper> automationSettings;
 352                     automationSettings = AutomationSettingHelper
 353                             .getAutomationSettings(null);
 354
 355                     // Open the settings dialog
 356                     AutomationSettingDialog dialog = new AutomationSettingDialog(
 357                             Activator.getDefault().getWorkbench()
 358                                     .getActiveWorkbenchWindow().getShell(),
 359                             automationSettings);
 360                     dialog.create();
 361                     if (dialog.open() == Window.OK) {
 362                         String automationType = dialog.getAutomationType();
 363                         String updateFreq = dialog.getUpdateFrequency();
 364
 365                         AutoUpdateType autoType = AutoUpdateType
 366                                 .valueOf(automationType);
 367                         int updFreq = Utility
 368                                 .getUpdateIntervalFromString(updateFreq);
 369                         boolean status = resourceManager
 370                                 .startResourceAutomationUIRequest(autoType,
 371                                         updFreq, selectedResource);
 372                         String statusMsg = status ? "Automation started successfully!!!"
 373                                 : "Automation request failed!!!";
 374                         MessageDialog.openInformation(Display.getDefault()
 375                                 .getActiveShell(), "Automation Status",
 376                                 statusMsg);
 377                     }
 378                 }
 379             }
 380         });
 381
 382         MenuItem stopItem = new MenuItem(menu, SWT.NONE);
 383         stopItem.setText(Constants.STOP_RESOURCE_AUTOMATION);
 384         stopItem.addSelectionListener(new SelectionAdapter() {
 385             @Override
 386             public void widgetSelected(SelectionEvent e) {
 387                 boolean status = resourceManager
 388                         .stopResourceAutomationUIRequest(selectedResource);
 389                 String statusMsg = status ? "Automation stopped!!!"
 390                         : "Automation stop failed.";
 391                 MessageDialog.openInformation(Display.getDefault()
 392                         .getActiveShell(), "Automation Status", statusMsg);
 393             }
 394         });
 395
 396         // Set the initial visibility of menu items
 397         boolean status = resourceManager
 398                 .isResourceAutomationStarted(selectedResource);
 399         startItem.setEnabled(!status);
 400         stopItem.setEnabled(status);
 401     }
 402
 403     private void addUIListeners() {
 404
 405         createButton.addSelectionListener(new SelectionAdapter() {
 406             @Override
 407             public void widgetSelected(SelectionEvent e) {
 408                 if (resourceManager.getResourceCount() >= Constants.MAX_RESOURCE_COUNT) {
 409                     MessageDialog
 410                             .openInformation(Display.getDefault()
 411                                     .getActiveShell(),
 412                                     "Resource limit exceeded",
 413                                     "Exceeded the limit of resources that can exist in the server.");
 414                     return;
 415                 }
 416                 PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable() {
 417
 418                     @Override
 419                     public void run() {
 420                         CreateResourceWizard createWizard = new CreateResourceWizard();
 421                         ResourceWizardDialog wizardDialog = new ResourceWizardDialog(
 422                                 Display.getDefault().getActiveShell(),
 423                                 createWizard);
 424                         createWizard.setWizardDialog(wizardDialog);
 425                         int open = wizardDialog.open();
 426                         if (open == WizardDialog.OK
 427                                 || createWizard.isDlgForceClosed()) {
 428
 429                             Option option = createWizard.getMainPage()
 430                                     .getOption();
 431                             if (option == Option.SIMPLE_FROM_RAML
 432                                     || option == Option.SIMPLE) {
 433                                 SingleResource res = (SingleResource) createWizard
 434                                         .getCreatedResource();
 435                                 if (null != res) {
 436                                     boolean canSelect = true;
 437                                     if (option == Option.SIMPLE_FROM_RAML
 438                                             && createWizard.getResourceCount() > 1) {
 439                                         canSelect = false;
 440                                     }
 441                                     if (canSelect) {
 442                                         singleResTreeViewer.setSelection(
 443                                                 new StructuredSelection(res),
 444                                                 true);
 445                                         resourceManager
 446                                                 .resourceSelectionChanged(res);
 447                                     }
 448                                 }
 449                             }
 450
 451                             MessageDialog.openInformation(Display.getDefault()
 452                                     .getActiveShell(),
 453                                     "Resource Creation Status", createWizard
 454                                             .getStatus());
 455                         }
 456                     }
 457                 });
 458             }
 459         });
 460
 461         deleteButton.addSelectionListener(new SelectionAdapter() {
 462             @Override
 463             public void widgetSelected(SelectionEvent e) {
 464                 PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable() {
 465
 466                     @Override
 467                     public void run() {
 468                         boolean exist = resourceManager.isAnyResourceExist();
 469                         if (!exist) {
 470                             return;
 471                         }
 472                         DeleteResourceWizard deleteWizard = new DeleteResourceWizard();
 473                         ResourceWizardDialog wizardDialog = new ResourceWizardDialog(
 474                                 PlatformUI.getWorkbench().getDisplay()
 475                                         .getActiveShell(), deleteWizard);
 476                         int open = wizardDialog.open();
 477                         if (open == Window.OK) {
 478                             singleResTreeViewer.refresh();
 479                             MessageDialog.openInformation(Display.getDefault()
 480                                     .getActiveShell(),
 481                                     "Resource Deletion Status", deleteWizard
 482                                             .getStatus());
 483
 484                             changeDeleteVisibility();
 485                         }
 486                     }
 487                 });
 488             }
 489         });
 490     }
 491
 492     public void addManagerListeners() {
 493         UiListenerHandler.getInstance().addResourceListChangedUIListener(
 494                 resourceListChangedListener);
 495         UiListenerHandler.getInstance().addResourcePropertiesChangedUIListener(
 496                 resourcePropertiesChangedListener);
 497     }
 498
 499     @Override
 500     public void setFocus() {
 501     }
 502
 503     @Override
 504     public void dispose() {
 505         // Unregister the listener
 506         if (null != resourceListChangedListener) {
 507             UiListenerHandler.getInstance()
 508                     .removeResourceListChangedUIListener(
 509                             resourceListChangedListener);
 510             resourceManager.resourceSelectionChanged(null);
 511         }
 512         if (null != resourcePropertiesChangedListener) {
 513             UiListenerHandler.getInstance()
 514                     .removeResourcePropertiesChangedUIListener(
 515                             resourcePropertiesChangedListener);
 516         }
 517         super.dispose();
 518     }
 519 }
 520
 521 class SingleResourceContentProvider implements ITreeContentProvider {
 522
 523     @Override
 524     public void dispose() {
 525     }
 526
 527     @Override
 528     public void inputChanged(Viewer arg0, Object arg1, Object arg2) {
 529     }
 530
 531     @Override
 532     public Object[] getChildren(Object parent) {
 533         return null;
 534     }
 535
 536     @Override
 537     public Object[] getElements(Object parent) {
 538         List<SingleResource> resList;
 539         resList = Activator.getDefault().getResourceManager()
 540                 .getSingleResourceList();
 541         if (null == resList) {
 542             resList = new ArrayList<SingleResource>();
 543         }
 544         return resList.toArray();
 545     }
 546
 547     @Override
 548     public Object getParent(Object child) {
 549         return null;
 550     }
 551
 552     @Override
 553     public boolean hasChildren(Object parent) {
 554         return false;
 555     }
 556 }
 557
 558 class TreeLabelProvider extends LabelProvider {
 559     @Override
 560     public String getText(Object element) {
 561         if (element instanceof Resource) {
 562             Resource res = (Resource) element;
 563             return res.getResourceName();
 564         }
 565         return null;
 566     }
 567
 568     @Override
 569     public Image getImage(Object element) {
 570         if (element instanceof SingleResource) {
 571             return Activator.getDefault().getImageRegistry()
 572                     .get(Constants.SINGLE_RESOURCE);
 573         }
 574         return null;
 575     }
 576 }