service/simulator/java/eclipse-plugin/ServiceProviderPlugin/src/oic/simulator/serviceprovider/view/dialogs/CreateResourceWizard.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.dialogs;
  18
  19 import org.eclipse.core.runtime.FileLocator;
  20 import org.eclipse.core.runtime.IPath;
  21 import org.eclipse.core.runtime.IProgressMonitor;
  22 import org.eclipse.core.runtime.Path;
  23 import org.eclipse.jface.dialogs.MessageDialog;
  24 import org.eclipse.jface.operation.IRunnableWithProgress;
  25 import org.eclipse.jface.resource.ImageDescriptor;
  26 import org.eclipse.jface.wizard.IWizardPage;
  27 import org.eclipse.jface.wizard.Wizard;
  28 import org.eclipse.jface.wizard.WizardDialog;
  29 import org.eclipse.swt.widgets.Display;
  30
  31 import java.io.FileInputStream;
  32 import java.io.FileNotFoundException;
  33 import java.io.IOException;
  34 import java.lang.reflect.InvocationTargetException;
  35 import java.net.URL;
  36 import java.util.Date;
  37 import java.util.HashMap;
  38 import java.util.Iterator;
  39 import java.util.Map;
  40 import java.util.Set;
  41
  42 import org.oic.simulator.ILogger.Level;
  43 import org.oic.simulator.SimulatorException;
  44 import org.oic.simulator.SimulatorResourceAttribute;
  45
  46 import oic.simulator.serviceprovider.Activator;
  47 import oic.simulator.serviceprovider.manager.UiListenerHandler;
  48 import oic.simulator.serviceprovider.model.AttributeHelper;
  49 import oic.simulator.serviceprovider.model.Resource;
  50 import oic.simulator.serviceprovider.model.ResourceType;
  51 import oic.simulator.serviceprovider.model.SingleResource;
  52 import oic.simulator.serviceprovider.utils.Constants;
  53 import oic.simulator.serviceprovider.utils.Utility;
  54 import oic.simulator.serviceprovider.view.dialogs.MainPage.Option;
  55
  56 /**
  57  * This class creates a UI wizard for create resource operation.
  58  */
  59 public class CreateResourceWizard extends Wizard {
  60
  61     private MainPage                       mainPage;
  62     private SimpleResourceBasicDetailsPage simpleResourceBasicDetailsPage;
  63     private SimpleResourceAddAttributePage simpleResourceAddAttributePage;
  64     private SimpleResourceOtherDetailsPage simpleResourceOtherDetailsPage;
  65     private LoadRamlPage                   loadRamlPage;
  66     private UpdatePropertiesPage           updatePropPage;
  67
  68     private String                         status;
  69
  70     private WizardDialog                   wizDialog;
  71     private boolean                        dlgForceClosed;
  72
  73     private Resource                       createdResource;
  74
  75     private IProgressMonitor               progressMonitor;
  76
  77     public CreateResourceWizard() {
  78         setWindowTitle("Create resources");
  79         IPath path = new Path("/icons/oic_logo_64x64.png");
  80         URL find = FileLocator.find(Activator.getDefault().getBundle(), path,
  81                 null);
  82         setDefaultPageImageDescriptor(ImageDescriptor.createFromURL(find));
  83
  84         setNeedsProgressMonitor(true);
  85     }
  86
  87     @Override
  88     public void addPages() {
  89         mainPage = new MainPage();
  90         simpleResourceBasicDetailsPage = new SimpleResourceBasicDetailsPage();
  91         simpleResourceAddAttributePage = new SimpleResourceAddAttributePage();
  92         simpleResourceOtherDetailsPage = new SimpleResourceOtherDetailsPage();
  93         loadRamlPage = new LoadRamlPage();
  94         updatePropPage = new UpdatePropertiesPage();
  95
  96         addPage(mainPage);
  97         addPage(simpleResourceBasicDetailsPage);
  98         addPage(simpleResourceAddAttributePage);
  99         addPage(simpleResourceOtherDetailsPage);
 100         addPage(loadRamlPage);
 101         addPage(updatePropPage);
 102     }
 103
 104     public void setWizardDialog(WizardDialog dlg) {
 105         wizDialog = dlg;
 106     }
 107
 108     public WizardDialog getWizardDialog() {
 109         return wizDialog;
 110     }
 111
 112     public boolean isDlgForceClosed() {
 113         return dlgForceClosed;
 114     }
 115
 116     public void setDlgForceClosed(boolean dlgForceClosed) {
 117         this.dlgForceClosed = dlgForceClosed;
 118     }
 119
 120     public String getConfigFilePath() {
 121         if (null == loadRamlPage) {
 122             return null;
 123         }
 124         return loadRamlPage.getConfigFilePath();
 125     }
 126
 127     public int getResourceCount() {
 128         if (null == loadRamlPage) {
 129             return 0;
 130         }
 131         return loadRamlPage.getResourceCount();
 132     }
 133
 134     public Resource getCreatedResource() {
 135         return createdResource;
 136     }
 137
 138     @Override
 139     public boolean canFinish() {
 140         IWizardPage curPage = this.getContainer().getCurrentPage();
 141         if ((curPage == updatePropPage && ((mainPage.getOption() == Option.SIMPLE_FROM_RAML) || !Activator
 142                 .getDefault().getResourceManager().isAnyResourceExist()))
 143                 || curPage == simpleResourceAddAttributePage
 144                 || (curPage == loadRamlPage && loadRamlPage.isSelectionDone() && loadRamlPage
 145                         .isMultiResourceCreation())) {
 146             return true;
 147         }
 148         return false;
 149     }
 150
 151     @Override
 152     public boolean performFinish() {
 153         final IWizardPage curPage = this.getContainer().getCurrentPage();
 154         // Handling Simple Resource Creation without RAML
 155         if (curPage == simpleResourceAddAttributePage) {
 156             try {
 157                 getContainer().run(true, false, new IRunnableWithProgress() {
 158
 159                     @Override
 160                     public void run(IProgressMonitor monitor)
 161                             throws InvocationTargetException,
 162                             InterruptedException {
 163                         try {
 164                             monitor.beginTask(
 165                                     "Single Resource Creation Without RAML", 2);
 166                             monitor.worked(1);
 167                             createSingleResourceWithoutRAML();
 168                         } finally {
 169                             monitor.done();
 170                         }
 171                     }
 172                 });
 173             } catch (InvocationTargetException e) {
 174                 Activator.getDefault().getLogManager()
 175                         .log(Level.ERROR.ordinal(), new Date(), e.getMessage());
 176                 e.printStackTrace();
 177             } catch (InterruptedException e) {
 178                 Activator.getDefault().getLogManager()
 179                         .log(Level.ERROR.ordinal(), new Date(), e.getMessage());
 180                 e.printStackTrace();
 181             }
 182         } else if (curPage == loadRamlPage) {
 183             // Validate the file path.
 184             FileInputStream fileStream = null;
 185             try {
 186                 fileStream = new FileInputStream(
 187                         loadRamlPage.getConfigFilePath());
 188             } catch (FileNotFoundException e) {
 189                 MessageDialog
 190                         .openError(getShell(), "Invalid File",
 191                                 "File doesn't exist. Either the file path or file name is invalid.");
 192                 return false;
 193             } finally {
 194                 if (null != fileStream) {
 195                     try {
 196                         fileStream.close();
 197                     } catch (IOException e) {
 198                         Activator
 199                                 .getDefault()
 200                                 .getLogManager()
 201                                 .log(Level.ERROR.ordinal(), new Date(),
 202                                         "There is an error while closing the file stream.\n");
 203                     }
 204                 }
 205             }
 206
 207             // Handling multiple instance creation of simple resource with RAML
 208             if ((loadRamlPage.getResourceCount() + Activator.getDefault()
 209                     .getResourceManager().getResourceCount()) > Constants.MAX_RESOURCE_COUNT) {
 210                 MessageDialog.openInformation(Display.getDefault()
 211                         .getActiveShell(), "Resource limit exceeded",
 212                         Constants.RESOURCE_LIMIT_EXCEEDED_MSG);
 213                 return false;
 214             }
 215
 216             final int[] resCreatedCount = new int[1];
 217             try {
 218                 getContainer().run(true, true, new IRunnableWithProgress() {
 219
 220                     @Override
 221                     public void run(final IProgressMonitor monitor)
 222                             throws InvocationTargetException,
 223                             InterruptedException {
 224                         progressMonitor = monitor;
 225                         try {
 226                             monitor.beginTask(
 227                                     "Single Resource Creation(multi-instance) With RAML",
 228                                     loadRamlPage.getResourceCount());
 229                             resCreatedCount[0] = createMultiInstanceSingleResourceWithoutRAML();
 230
 231                         } finally {
 232                             monitor.done();
 233                         }
 234                     }
 235                 });
 236             } catch (InvocationTargetException e) {
 237                 Activator.getDefault().getLogManager()
 238                         .log(Level.ERROR.ordinal(), new Date(), e.getMessage());
 239                 e.printStackTrace();
 240             } catch (InterruptedException e) {
 241                 Activator.getDefault().getLogManager()
 242                         .log(Level.ERROR.ordinal(), new Date(), e.getMessage());
 243                 e.printStackTrace();
 244             }
 245             boolean canceled = false;
 246             if (null != progressMonitor && progressMonitor.isCanceled()
 247                     && 0 == resCreatedCount[0]) {
 248                 canceled = true;
 249             }
 250             progressMonitor = null;
 251             if (canceled) {
 252                 return false;
 253             } else {
 254                 if (resCreatedCount[0] > 0) {
 255                     UiListenerHandler.getInstance()
 256                             .resourceCreatedUINotification(ResourceType.SINGLE);
 257                 }
 258             }
 259         } else if (curPage == updatePropPage) {
 260             // Handling the single instance
 261             String resName = updatePropPage.getResName();
 262             String resURI = updatePropPage.getResURI();
 263             if (null == resName || resName.trim().length() < 1) {
 264                 MessageDialog.openError(Display.getDefault().getActiveShell(),
 265                         "Invalid Resource Name.", "Resource name is invalid");
 266                 return false;
 267             }
 268             if (!Utility.isUriValid(resURI)) {
 269                 MessageDialog.openError(Display.getDefault().getActiveShell(),
 270                         "Invalid Resource URI.", Constants.INVALID_URI_MESSAGE);
 271                 return false;
 272             }
 273             // Creation of simple resource with RAML
 274             // Checking whether the URI is used by any other resource.
 275             if (Activator.getDefault().getResourceManager()
 276                     .isResourceExist(updatePropPage.getResURI())) {
 277                 MessageDialog
 278                         .openError(getShell(), "Resource URI in use",
 279                                 "Entered resource URI is in use. Please try a different one.");
 280                 return false;
 281             }
 282
 283             try {
 284                 getContainer().run(true, false, new IRunnableWithProgress() {
 285
 286                     @Override
 287                     public void run(IProgressMonitor monitor)
 288                             throws InvocationTargetException,
 289                             InterruptedException {
 290                         try {
 291                             monitor.beginTask("Completing Resource Creation", 2);
 292                             monitor.worked(1);
 293                             completeResourceCreationWithRAML();
 294                             monitor.worked(1);
 295                         } finally {
 296                             monitor.done();
 297                         }
 298                     }
 299                 });
 300             } catch (InvocationTargetException e) {
 301                 Activator.getDefault().getLogManager()
 302                         .log(Level.ERROR.ordinal(), new Date(), e.getMessage());
 303                 e.printStackTrace();
 304             } catch (InterruptedException e) {
 305                 Activator.getDefault().getLogManager()
 306                         .log(Level.ERROR.ordinal(), new Date(), e.getMessage());
 307                 e.printStackTrace();
 308             }
 309         }
 310         return true;
 311     }
 312
 313     public MainPage getMainPage() {
 314         return mainPage;
 315     }
 316
 317     public SimpleResourceBasicDetailsPage getSimpleResourceBasicDetailsPage() {
 318         return simpleResourceBasicDetailsPage;
 319     }
 320
 321     public SimpleResourceAddAttributePage getSimpleResourceAddAttributePage() {
 322         return simpleResourceAddAttributePage;
 323     }
 324
 325     public SimpleResourceOtherDetailsPage getSimpleResourceOtherDetailsPage() {
 326         return simpleResourceOtherDetailsPage;
 327     }
 328
 329     public LoadRamlPage getLoadRamlPage() {
 330         return loadRamlPage;
 331     }
 332
 333     public UpdatePropertiesPage getUpdatePropPage() {
 334         return updatePropPage;
 335     }
 336
 337     public void setStatus(String status) {
 338         this.status = status;
 339     }
 340
 341     public String getStatus() {
 342         return status;
 343     }
 344
 345     private void createSingleResourceWithoutRAML() {
 346         SingleResource resource = new SingleResource();
 347         // Basic resource details
 348         resource.setResourceURI(simpleResourceBasicDetailsPage.getResURI());
 349         resource.setResourceName(simpleResourceBasicDetailsPage.getResName());
 350         resource.setResourceType(simpleResourceBasicDetailsPage.getResType());
 351         resource.setObservable(simpleResourceBasicDetailsPage.isObservable());
 352         resource.setDiscoverable(simpleResourceBasicDetailsPage
 353                 .isDiscoverable());
 354         resource.setResourceInterfaces(simpleResourceBasicDetailsPage
 355                 .getInterfaceTypes());
 356
 357         // Resource Attributes
 358         Map<String, SimulatorResourceAttribute> attributes = new HashMap<String, SimulatorResourceAttribute>();
 359         Set<AttributeHelper> attributeSet = simpleResourceAddAttributePage
 360                 .getAttributes();
 361         if (null != attributeSet && !attributeSet.isEmpty()) {
 362             Iterator<AttributeHelper> itr = attributeSet.iterator();
 363             AttributeHelper attHelper;
 364             SimulatorResourceAttribute attribute;
 365             while (itr.hasNext()) {
 366                 attHelper = itr.next();
 367                 if (null != attHelper) {
 368                     attribute = attHelper.convertToSimulatorResourceAttribute();
 369                     attributes.put(attribute.name(), attribute);
 370                 }
 371             }
 372         }
 373
 374         // Request types
 375         resource.setGetAllowed(simpleResourceOtherDetailsPage.isGetChecked());
 376         resource.setPutAllowed(simpleResourceOtherDetailsPage.isPutChecked());
 377         resource.setPostAllowed(simpleResourceOtherDetailsPage.isPostChecked());
 378
 379         // Call method of ResourceManager and update the response in the status
 380         // string.
 381         try {
 382             boolean result = Activator.getDefault().getResourceManager()
 383                     .createSingleResource(resource, attributes);
 384             if (result) {
 385                 status = "Resource created.";
 386                 createdResource = resource;
 387             } else {
 388                 status = "Failed to create resource.";
 389                 createdResource = null;
 390             }
 391         } catch (Exception e) {
 392             status = "Failed to create resource.\n"
 393                     + Utility.getSimulatorErrorString(e, null);
 394             createdResource = null;
 395         }
 396     }
 397
 398     private void completeResourceCreationWithRAML() {
 399         try {
 400             boolean result = false;
 401             Resource res = loadRamlPage.getResource();
 402             if (res instanceof SingleResource) {
 403                 result = Activator
 404                         .getDefault()
 405                         .getResourceManager()
 406                         .completeSingleResourceCreationByRAML(res,
 407                                 updatePropPage.getResURI(),
 408                                 updatePropPage.getResName(), false);
 409             }
 410
 411             if (result) {
 412                 status = "Resource created.";
 413                 createdResource = res;
 414             } else {
 415                 status = "Failed to create resource.";
 416                 createdResource = null;
 417             }
 418         } catch (Exception e) {
 419             status = "Failed to create resource.\n"
 420                     + Utility.getSimulatorErrorString(e, null);
 421             createdResource = null;
 422         }
 423     }
 424
 425     private int createMultiInstanceSingleResourceWithoutRAML() {
 426         int toCreateCount = loadRamlPage.getResourceCount();
 427         int resCreatedCount = 0;
 428         Set<SingleResource> resources;
 429         try {
 430             resources = Activator
 431                     .getDefault()
 432                     .getResourceManager()
 433                     .createSingleResourceMultiInstances(
 434                             loadRamlPage.getConfigFilePath(), toCreateCount,
 435                             progressMonitor);
 436             if (null != progressMonitor && progressMonitor.isCanceled()) {
 437                 try {
 438                     Activator.getDefault().getResourceManager()
 439                             .removeSingleResources(resources);
 440                 } catch (SimulatorException e) {
 441                     Activator
 442                             .getDefault()
 443                             .getLogManager()
 444                             .log(Level.ERROR.ordinal(),
 445                                     new Date(),
 446                                     "There is an error while updating the resource model.\n"
 447                                             + Utility.getSimulatorErrorString(
 448                                                     e, null));
 449                 }
 450                 return 0;
 451             }
 452             if (null != resources)
 453                 resCreatedCount = resources.size();
 454             if (resCreatedCount > 0) {
 455                 status = "[" + resCreatedCount + " out of " + toCreateCount
 456                         + "]";
 457                 status += ((resCreatedCount == 1) ? "resource" : "resources")
 458                         + " created successfully.";
 459             } else {
 460                 status = "Failed to create resources.";
 461             }
 462         } catch (SimulatorException e) {
 463             status = "Failed to create resource.\n"
 464                     + Utility.getSimulatorErrorString(e, null);
 465         }
 466         return resCreatedCount;
 467     }
 468 }