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().syncExec(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                                         } catch (SimulatorException e1) {
 305                                             MessageDialog
 306                                                     .openInformation(Display
 307                                                             .getDefault()
 308                                                             .getActiveShell(),
 309                                                             "Deletion Failed",
 310                                                             "Failed to delete the resource.");
 311                                         }
 312                                         changeDeleteVisibility();
 313                                     }
 314                                 });
 315                     }
 316                 });
 317             }
 318         }
 319     }
 320
 321     private void addAutomationMenu(final Menu menu,
 322             final SingleResource selectedResource) {
 323         MenuItem startItem = new MenuItem(menu, SWT.NONE);
 324         startItem.setText(Constants.START_RESOURCE_AUTOMATION);
 325         startItem.addSelectionListener(new SelectionAdapter() {
 326             @Override
 327             public void widgetSelected(SelectionEvent e) {
 328                 // Block starting resource level
 329                 // automation if any attribute level
 330                 // automation is in progress for the
 331                 // selected resource
 332                 boolean started = resourceManager
 333                         .isAttributeAutomationStarted(selectedResource);
 334                 if (started) {
 335                     MessageDialog
 336                             .openInformation(
 337                                     Display.getDefault().getActiveShell(),
 338                                     "Attribute automation is in progress",
 339                                     "Attribute level automation for this resource is already in progress!!!\nPlease stop all "
 340                                             + "running attribute level automations to start resource level automation.");
 341                 } else {
 342                     // Start the automation
 343                     // Fetch the settings data
 344                     List<AutomationSettingHelper> automationSettings;
 345                     automationSettings = AutomationSettingHelper
 346                             .getAutomationSettings(null);
 347
 348                     // Open the settings dialog
 349                     AutomationSettingDialog dialog = new AutomationSettingDialog(
 350                             Activator.getDefault().getWorkbench()
 351                                     .getActiveWorkbenchWindow().getShell(),
 352                             automationSettings);
 353                     dialog.create();
 354                     if (dialog.open() == Window.OK) {
 355                         String automationType = dialog.getAutomationType();
 356                         String updateFreq = dialog.getUpdateFrequency();
 357
 358                         AutoUpdateType autoType = AutoUpdateType
 359                                 .valueOf(automationType);
 360                         int updFreq = Utility
 361                                 .getUpdateIntervalFromString(updateFreq);
 362                         boolean status = resourceManager
 363                                 .startResourceAutomationUIRequest(autoType,
 364                                         updFreq, selectedResource);
 365                         if (!status) {
 366                             String statusMsg = "Automation request failed!!!";
 367                             MessageDialog.openInformation(Display.getDefault()
 368                                     .getActiveShell(), "Automation Status",
 369                                     statusMsg);
 370                         }
 371                     }
 372                 }
 373             }
 374         });
 375
 376         MenuItem stopItem = new MenuItem(menu, SWT.NONE);
 377         stopItem.setText(Constants.STOP_RESOURCE_AUTOMATION);
 378         stopItem.addSelectionListener(new SelectionAdapter() {
 379             @Override
 380             public void widgetSelected(SelectionEvent e) {
 381                 boolean status = resourceManager
 382                         .stopResourceAutomationUIRequest(selectedResource);
 383                 if (!status) {
 384                     String statusMsg = "Automation stop failed.";
 385                     MessageDialog.openInformation(Display.getDefault()
 386                             .getActiveShell(), "Automation Status", statusMsg);
 387                 }
 388             }
 389         });
 390
 391         // Set the initial visibility of menu items
 392         boolean status = resourceManager
 393                 .isResourceAutomationStarted(selectedResource);
 394         startItem.setEnabled(!status);
 395         stopItem.setEnabled(status);
 396     }
 397
 398     private void addUIListeners() {
 399
 400         createButton.addSelectionListener(new SelectionAdapter() {
 401             @Override
 402             public void widgetSelected(SelectionEvent e) {
 403                 if (resourceManager.getResourceCount() >= Constants.MAX_RESOURCE_COUNT) {
 404                     MessageDialog
 405                             .openInformation(Display.getDefault()
 406                                     .getActiveShell(),
 407                                     "Resource limit exceeded",
 408                                     "Exceeded the limit of resources that can exist in the server.");
 409                     return;
 410                 }
 411                 PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable() {
 412
 413                     @Override
 414                     public void run() {
 415                         CreateResourceWizard createWizard = new CreateResourceWizard();
 416                         ResourceWizardDialog wizardDialog = new ResourceWizardDialog(
 417                                 Display.getDefault().getActiveShell(),
 418                                 createWizard);
 419                         createWizard.setWizardDialog(wizardDialog);
 420                         int open = wizardDialog.open();
 421                         if (open == WizardDialog.OK
 422                                 || createWizard.isDlgForceClosed()) {
 423
 424                             Option option = createWizard.getMainPage()
 425                                     .getOption();
 426                             if (option == Option.SIMPLE_FROM_RAML
 427                                     || option == Option.SIMPLE) {
 428                                 SingleResource res = (SingleResource) createWizard
 429                                         .getCreatedResource();
 430                                 if (null != res) {
 431                                     boolean canSelect = true;
 432                                     if (option == Option.SIMPLE_FROM_RAML
 433                                             && createWizard.getResourceCount() > 1) {
 434                                         canSelect = false;
 435                                     }
 436                                     if (canSelect) {
 437                                         singleResTreeViewer.setSelection(
 438                                                 new StructuredSelection(res),
 439                                                 true);
 440                                         resourceManager
 441                                                 .resourceSelectionChanged(res);
 442                                     }
 443                                 }
 444                             }
 445
 446                             MessageDialog.openInformation(Display.getDefault()
 447                                     .getActiveShell(),
 448                                     "Resource Creation Status", createWizard
 449                                             .getStatus());
 450                         }
 451                     }
 452                 });
 453             }
 454         });
 455
 456         deleteButton.addSelectionListener(new SelectionAdapter() {
 457             @Override
 458             public void widgetSelected(SelectionEvent e) {
 459                 PlatformUI.getWorkbench().getDisplay().syncExec(new Runnable() {
 460
 461                     @Override
 462                     public void run() {
 463                         boolean exist = resourceManager.isAnyResourceExist();
 464                         if (!exist) {
 465                             return;
 466                         }
 467                         DeleteResourceWizard deleteWizard = new DeleteResourceWizard();
 468                         ResourceWizardDialog wizardDialog = new ResourceWizardDialog(
 469                                 PlatformUI.getWorkbench().getDisplay()
 470                                         .getActiveShell(), deleteWizard);
 471                         int open = wizardDialog.open();
 472                         if (open == Window.OK) {
 473                             singleResTreeViewer.refresh();
 474
 475                             if (!deleteWizard.getStatus()) {
 476                                 MessageDialog
 477                                         .openInformation(Display.getDefault()
 478                                                 .getActiveShell(),
 479                                                 "Resource Deletion Failed",
 480                                                 "Failed to delete the resources. Please try again.");
 481                             }
 482                             changeDeleteVisibility();
 483                         }
 484                     }
 485                 });
 486             }
 487         });
 488     }
 489
 490     public void addManagerListeners() {
 491         UiListenerHandler.getInstance().addResourceListChangedUIListener(
 492                 resourceListChangedListener);
 493         UiListenerHandler.getInstance().addResourcePropertiesChangedUIListener(
 494                 resourcePropertiesChangedListener);
 495     }
 496
 497     @Override
 498     public void setFocus() {
 499     }
 500
 501     @Override
 502     public void dispose() {
 503         // Unregister the listener
 504         if (null != resourceListChangedListener) {
 505             UiListenerHandler.getInstance()
 506                     .removeResourceListChangedUIListener(
 507                             resourceListChangedListener);
 508             resourceManager.resourceSelectionChanged(null);
 509         }
 510         if (null != resourcePropertiesChangedListener) {
 511             UiListenerHandler.getInstance()
 512                     .removeResourcePropertiesChangedUIListener(
 513                             resourcePropertiesChangedListener);
 514         }
 515         super.dispose();
 516     }
 517 }
 518
 519 class SingleResourceContentProvider implements ITreeContentProvider {
 520
 521     @Override
 522     public void dispose() {
 523     }
 524
 525     @Override
 526     public void inputChanged(Viewer arg0, Object arg1, Object arg2) {
 527     }
 528
 529     @Override
 530     public Object[] getChildren(Object parent) {
 531         return null;
 532     }
 533
 534     @Override
 535     public Object[] getElements(Object parent) {
 536         List<SingleResource> resList;
 537         resList = Activator.getDefault().getResourceManager()
 538                 .getSingleResourceList();
 539         if (null == resList) {
 540             resList = new ArrayList<SingleResource>();
 541         }
 542         return resList.toArray();
 543     }
 544
 545     @Override
 546     public Object getParent(Object child) {
 547         return null;
 548     }
 549
 550     @Override
 551     public boolean hasChildren(Object parent) {
 552         return false;
 553     }
 554 }
 555
 556 class TreeLabelProvider extends LabelProvider {
 557     @Override
 558     public String getText(Object element) {
 559         if (element instanceof Resource) {
 560             Resource res = (Resource) element;
 561             return res.getResourceName();
 562         }
 563         return null;
 564     }
 565
 566     @Override
 567     public Image getImage(Object element) {
 568         if (element instanceof SingleResource) {
 569             return Activator.getDefault().getImageRegistry()
 570                     .get(Constants.SINGLE_RESOURCE);
 571         }
 572         return null;
 573     }
 574 }