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