Examples with Pool com.twinsoft.convertigo.beans.core.Pool used on opensource projects

Example 1 with Pool

use of com.twinsoft.convertigo.beans.core.Pool in project convertigo by convertigo.

the class ConvertigoPlugin method getDefaultBeanIcon.

private Image getDefaultBeanIcon(Class<?> beanClass, int iconKind) {
    String iconBaseName, iconType;
    iconBaseName = "default";
    if (beanClass != null) {
        if (Criteria.class.isAssignableFrom(beanClass)) {
            iconBaseName = "criteria";
        } else if (ExtractionRule.class.isAssignableFrom(beanClass)) {
            iconBaseName = "extractionrule";
        } else if (Transaction.class.isAssignableFrom(beanClass)) {
            iconBaseName = "transaction";
        } else if (BlockFactory.class.isAssignableFrom(beanClass)) {
            iconBaseName = "blockfactory";
        } else if (Project.class.isAssignableFrom(beanClass)) {
            iconBaseName = "project";
        } else if (ScreenClass.class.isAssignableFrom(beanClass)) {
            iconBaseName = "screenclass";
        } else if (Sheet.class.isAssignableFrom(beanClass)) {
            iconBaseName = "sheet";
        } else if (Pool.class.isAssignableFrom(beanClass)) {
            iconBaseName = "pool";
        }
    }
    switch(iconKind) {
        case java.beans.BeanInfo.ICON_COLOR_16x16:
            iconType = "_color_16x16.png";
            break;
        default:
        case java.beans.BeanInfo.ICON_COLOR_32x32:
            iconType = "_color_32x32.png";
            break;
        case java.beans.BeanInfo.ICON_MONO_16x16:
            iconType = "_mono_16x16.png";
            break;
        case java.beans.BeanInfo.ICON_MONO_32x32:
            iconType = "_mono_32x32.png";
            break;
    }
    Image beanIcon = (Image) icons.get(iconBaseName + iconType);
    if (beanIcon == null) {
        ConvertigoPlugin.studioLog.debug("Getting default icon: " + iconBaseName + iconType);
        String iconName = "/com/twinsoft/convertigo/beans/core/images/" + iconBaseName + iconType;
        Device device = getDisplay();
        InputStream inputStream = ConvertigoPlugin.class.getResourceAsStream(iconName);
        beanIcon = new Image(device, inputStream);
        icons.put(iconBaseName + iconType, beanIcon);
    }
    return beanIcon;
}

Example 2 with Pool

use of com.twinsoft.convertigo.beans.core.Pool in project convertigo by convertigo.

the class ProjectExplorerView method loadDatabaseObject.

private void loadDatabaseObject(TreeParent parentTreeObject, DatabaseObject parentDatabaseObject, ProjectLoadingJob projectLoadingJob, final IProgressMonitor monitor) throws EngineException, IOException {
    try {
        new WalkHelper() {

            // recursion parameters
            TreeParent parentTreeObject;

            ProjectLoadingJob projectLoadingJob;

            // sibling parameters
            ObjectsFolderTreeObject currentTreeFolder = null;

            public void init(DatabaseObject databaseObject, TreeParent parentTreeObject, ProjectLoadingJob projectLoadingJob) throws Exception {
                this.parentTreeObject = parentTreeObject;
                this.projectLoadingJob = projectLoadingJob;
                walkInheritance = true;
                super.init(databaseObject);
            }

            protected ObjectsFolderTreeObject getFolder(TreeParent treeParent, int folderType) {
                ObjectsFolderTreeObject ofto = null;
                for (TreeObject to : treeParent.getChildren()) {
                    if (to instanceof ObjectsFolderTreeObject) {
                        if (((ObjectsFolderTreeObject) to).folderType == folderType) {
                            ofto = (ObjectsFolderTreeObject) to;
                            break;
                        }
                    }
                }
                if (ofto == null) {
                    ofto = new ObjectsFolderTreeObject(viewer, folderType);
                    treeParent.addChild(ofto);
                }
                return ofto;
            }

            @Override
            protected void walk(DatabaseObject databaseObject) throws Exception {
                // retrieve recursion parameters
                final TreeParent parentTreeObject = this.parentTreeObject;
                final ProjectLoadingJob projectLoadingJob = this.projectLoadingJob;
                // retrieve sibling parameters
                ObjectsFolderTreeObject currentTreeFolder = this.currentTreeFolder;
                String dboName = (databaseObject instanceof Step) ? ((Step) databaseObject).getStepNodeName() : databaseObject.getName();
                monitor.subTask("Loading databaseObject '" + dboName + "'...");
                DatabaseObjectTreeObject databaseObjectTreeObject = null;
                // first call case, the tree object already exists and its content is just refreshed
                if (parentTreeObject.getObject() == databaseObject) {
                    databaseObjectTreeObject = (DatabaseObjectTreeObject) parentTreeObject;
                } else // recursive call case, the tree object doesn't exist and must be added to the parent tree object
                {
                    int folderType = Integer.MIN_VALUE;
                    if (databaseObject instanceof Connector) {
                        folderType = ObjectsFolderTreeObject.FOLDER_TYPE_CONNECTORS;
                        databaseObjectTreeObject = new ConnectorTreeObject(viewer, (Connector) databaseObject, false);
                    } else if (databaseObject instanceof Sequence) {
                        folderType = ObjectsFolderTreeObject.FOLDER_TYPE_SEQUENCES;
                        databaseObjectTreeObject = new SequenceTreeObject(viewer, (Sequence) databaseObject, false);
                    } else if (databaseObject instanceof MobileApplication) {
                        databaseObjectTreeObject = new MobileApplicationTreeObject(viewer, (MobileApplication) databaseObject, false);
                    } else if (databaseObject instanceof MobilePlatform) {
                        folderType = ObjectsFolderTreeObject.FOLDER_TYPE_PLATFORMS;
                        databaseObjectTreeObject = new MobilePlatformTreeObject(viewer, (MobilePlatform) databaseObject, false);
                    } else /**
                     ***********************************************************************************************
                     */
                    if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.MobileComponent) {
                        if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.ApplicationComponent) {
                            databaseObjectTreeObject = new MobileApplicationComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
                        } else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.RouteComponent) {
                            folderType = ObjectsFolderTreeObject.FOLDER_TYPE_ROUTES;
                            databaseObjectTreeObject = new MobileRouteComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
                        } else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.RouteEventComponent) {
                            folderType = ObjectsFolderTreeObject.FOLDER_TYPE_EVENTS;
                            databaseObjectTreeObject = new MobileRouteEventComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
                        } else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.RouteActionComponent) {
                            folderType = ObjectsFolderTreeObject.FOLDER_TYPE_ACTIONS;
                            databaseObjectTreeObject = new MobileRouteActionComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
                        } else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.PageComponent) {
                            folderType = ObjectsFolderTreeObject.FOLDER_TYPE_PAGES;
                            databaseObjectTreeObject = new MobilePageComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
                        } else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIActionStack) {
                            folderType = ObjectsFolderTreeObject.FOLDER_TYPE_SHARED_ACTIONS;
                            databaseObjectTreeObject = new MobileUIComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
                        } else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UISharedComponent) {
                            folderType = ObjectsFolderTreeObject.FOLDER_TYPE_SHARED_COMPONENTS;
                            databaseObjectTreeObject = new MobileUIComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
                        } else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIDynamicMenu) {
                            folderType = ObjectsFolderTreeObject.FOLDER_TYPE_MENUS;
                            databaseObjectTreeObject = new MobileUIComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
                        } else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIComponent) {
                            if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIAttribute) {
                                folderType = ObjectsFolderTreeObject.FOLDER_TYPE_ATTRIBUTES;
                                if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIControlAttr) {
                                    folderType = ObjectsFolderTreeObject.FOLDER_TYPE_CONTROLS;
                                }
                            } else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIStyle) {
                                folderType = ObjectsFolderTreeObject.FOLDER_TYPE_STYLES;
                            } else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIControlVariable) {
                                folderType = ObjectsFolderTreeObject.FOLDER_TYPE_VARIABLES;
                            } else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UICompVariable) {
                                folderType = ObjectsFolderTreeObject.FOLDER_TYPE_VARIABLES;
                            } else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIStackVariable) {
                                folderType = ObjectsFolderTreeObject.FOLDER_TYPE_VARIABLES;
                            } else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIFormValidator) {
                                folderType = ObjectsFolderTreeObject.FOLDER_TYPE_VALIDATORS;
                            } else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIAppEvent) {
                                folderType = ObjectsFolderTreeObject.FOLDER_TYPE_EVENTS;
                            } else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIPageEvent) {
                                folderType = ObjectsFolderTreeObject.FOLDER_TYPE_EVENTS;
                            } else if (databaseObject instanceof com.twinsoft.convertigo.beans.mobile.components.UIEventSubscriber) {
                                folderType = ObjectsFolderTreeObject.FOLDER_TYPE_EVENTS;
                            }
                            databaseObjectTreeObject = new MobileUIComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
                        }
                    } else /**
                     ***********************************************************************************************
                     */
                    if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.MobileComponent) {
                        if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.ApplicationComponent) {
                            databaseObjectTreeObject = new NgxApplicationComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
                        } else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.PageComponent) {
                            folderType = ObjectsFolderTreeObject.FOLDER_TYPE_PAGES;
                            databaseObjectTreeObject = new NgxPageComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
                        } else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIActionStack) {
                            folderType = ObjectsFolderTreeObject.FOLDER_TYPE_SHARED_ACTIONS;
                            databaseObjectTreeObject = new NgxUIComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
                        } else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UISharedComponent) {
                            folderType = ObjectsFolderTreeObject.FOLDER_TYPE_SHARED_COMPONENTS;
                            databaseObjectTreeObject = new NgxUIComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
                        } else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIDynamicMenu) {
                            folderType = ObjectsFolderTreeObject.FOLDER_TYPE_MENUS;
                            databaseObjectTreeObject = new NgxUIComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
                        } else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIComponent) {
                            if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIAttribute) {
                                folderType = ObjectsFolderTreeObject.FOLDER_TYPE_ATTRIBUTES;
                                if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIControlAttr) {
                                    folderType = ObjectsFolderTreeObject.FOLDER_TYPE_CONTROLS;
                                }
                            } else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIDynamicAttr) {
                                folderType = ObjectsFolderTreeObject.FOLDER_TYPE_ATTRIBUTES;
                            } else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIStyle) {
                                folderType = ObjectsFolderTreeObject.FOLDER_TYPE_STYLES;
                            } else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIControlVariable) {
                                folderType = ObjectsFolderTreeObject.FOLDER_TYPE_VARIABLES;
                            } else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UICompVariable) {
                                folderType = ObjectsFolderTreeObject.FOLDER_TYPE_VARIABLES;
                            } else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIStackVariable) {
                                folderType = ObjectsFolderTreeObject.FOLDER_TYPE_VARIABLES;
                            } else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIAppEvent) {
                                folderType = ObjectsFolderTreeObject.FOLDER_TYPE_EVENTS;
                            } else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIPageEvent) {
                                folderType = ObjectsFolderTreeObject.FOLDER_TYPE_EVENTS;
                            } else if (databaseObject instanceof com.twinsoft.convertigo.beans.ngx.components.UIEventSubscriber) {
                                folderType = ObjectsFolderTreeObject.FOLDER_TYPE_EVENTS;
                            }
                            databaseObjectTreeObject = new NgxUIComponentTreeObject(viewer, GenericUtils.cast(databaseObject), false);
                        }
                    } else if (databaseObject instanceof UrlMapper) {
                        databaseObjectTreeObject = new UrlMapperTreeObject(viewer, (UrlMapper) databaseObject, false);
                    } else if (databaseObject instanceof UrlAuthentication) {
                        folderType = ObjectsFolderTreeObject.FOLDER_TYPE_AUTHENTICATIONS;
                        databaseObjectTreeObject = new UrlAuthenticationTreeObject(viewer, (UrlAuthentication) databaseObject, false);
                    } else if (databaseObject instanceof UrlMapping) {
                        folderType = ObjectsFolderTreeObject.FOLDER_TYPE_MAPPINGS;
                        databaseObjectTreeObject = new UrlMappingTreeObject(viewer, (UrlMapping) databaseObject, false);
                    } else if (databaseObject instanceof UrlMappingOperation) {
                        folderType = ObjectsFolderTreeObject.FOLDER_TYPE_OPERATIONS;
                        databaseObjectTreeObject = new UrlMappingOperationTreeObject(viewer, (UrlMappingOperation) databaseObject, false);
                    } else if (databaseObject instanceof UrlMappingParameter) {
                        folderType = ObjectsFolderTreeObject.FOLDER_TYPE_PARAMETERS;
                        databaseObjectTreeObject = new UrlMappingParameterTreeObject(viewer, (UrlMappingParameter) databaseObject, false);
                    } else if (databaseObject instanceof UrlMappingResponse) {
                        folderType = ObjectsFolderTreeObject.FOLDER_TYPE_RESPONSES;
                        databaseObjectTreeObject = new UrlMappingResponseTreeObject(viewer, (UrlMappingResponse) databaseObject, false);
                    } else if (databaseObject instanceof Reference) {
                        folderType = ObjectsFolderTreeObject.FOLDER_TYPE_REFERENCES;
                        databaseObjectTreeObject = new ReferenceTreeObject(viewer, (Reference) databaseObject, false);
                    } else if (databaseObject instanceof Pool) {
                        folderType = ObjectsFolderTreeObject.FOLDER_TYPE_POOLS;
                        databaseObjectTreeObject = new DatabaseObjectTreeObject(viewer, databaseObject, false);
                    } else if (databaseObject instanceof Transaction) {
                        folderType = ObjectsFolderTreeObject.FOLDER_TYPE_TRANSACTIONS;
                        databaseObjectTreeObject = new TransactionTreeObject(viewer, (Transaction) databaseObject, false);
                    } else if (databaseObject instanceof ScreenClass) {
                        if (databaseObject.getParent() instanceof IScreenClassContainer<?>) {
                            folderType = ObjectsFolderTreeObject.FOLDER_TYPE_SCREEN_CLASSES;
                            databaseObjectTreeObject = new ScreenClassTreeObject(viewer, (ScreenClass) databaseObject, false);
                        } else {
                            folderType = ObjectsFolderTreeObject.FOLDER_TYPE_INHERITED_SCREEN_CLASSES;
                            databaseObjectTreeObject = new ScreenClassTreeObject(viewer, (ScreenClass) databaseObject, false);
                        }
                    } else if (databaseObject instanceof Sheet) {
                        folderType = ObjectsFolderTreeObject.FOLDER_TYPE_SHEETS;
                        databaseObjectTreeObject = new SheetTreeObject(viewer, (Sheet) databaseObject, parentTreeObject.getObject() != databaseObject.getParent());
                    } else if (databaseObject instanceof TestCase) {
                        folderType = ObjectsFolderTreeObject.FOLDER_TYPE_TESTCASES;
                        databaseObjectTreeObject = new TestCaseTreeObject(viewer, (TestCase) databaseObject, false);
                    } else if (databaseObject instanceof Variable) {
                        folderType = ObjectsFolderTreeObject.FOLDER_TYPE_VARIABLES;
                        databaseObjectTreeObject = new VariableTreeObject2(viewer, (Variable) databaseObject, false);
                    } else if (databaseObject instanceof Step) {
                        if (databaseObject.getParent() instanceof Sequence) {
                            folderType = ObjectsFolderTreeObject.FOLDER_TYPE_STEPS;
                        }
                        databaseObjectTreeObject = new StepTreeObject(viewer, (Step) databaseObject, false);
                    } else if (databaseObject instanceof Statement) {
                        if (databaseObject.getParent() instanceof Transaction) {
                            folderType = ObjectsFolderTreeObject.FOLDER_TYPE_FUNCTIONS;
                        }
                        databaseObjectTreeObject = new StatementTreeObject(viewer, (Statement) databaseObject, false);
                    } else if (databaseObject instanceof Criteria) {
                        folderType = ObjectsFolderTreeObject.FOLDER_TYPE_CRITERIAS;
                        databaseObjectTreeObject = new CriteriaTreeObject(viewer, (Criteria) databaseObject, parentTreeObject.getObject() != databaseObject.getParent());
                    } else if (databaseObject instanceof ExtractionRule) {
                        folderType = ObjectsFolderTreeObject.FOLDER_TYPE_EXTRACTION_RULES;
                        databaseObjectTreeObject = new ExtractionRuleTreeObject(viewer, (ExtractionRule) databaseObject, parentTreeObject.getObject() != databaseObject.getParent());
                    } else if (databaseObject instanceof BlockFactory) {
                        databaseObjectTreeObject = new DatabaseObjectTreeObject(viewer, databaseObject, parentTreeObject.getObject() != databaseObject.getParent());
                    } else if (databaseObject instanceof com.twinsoft.convertigo.beans.core.Document) {
                        folderType = ObjectsFolderTreeObject.FOLDER_TYPE_DOCUMENTS;
                        com.twinsoft.convertigo.beans.core.Document document = (com.twinsoft.convertigo.beans.core.Document) databaseObject;
                        String documentRenderer = document.getRenderer();
                        if (documentRenderer.equals("DesignDocumentTreeObject"))
                            databaseObjectTreeObject = new DesignDocumentTreeObject(viewer, document, false);
                        else
                            databaseObjectTreeObject = new DocumentTreeObject(viewer, document, false);
                    } else if (databaseObject instanceof com.twinsoft.convertigo.beans.core.Listener) {
                        folderType = ObjectsFolderTreeObject.FOLDER_TYPE_LISTENERS;
                        com.twinsoft.convertigo.beans.core.Listener listener = (com.twinsoft.convertigo.beans.core.Listener) databaseObject;
                        String listenerRenderer = listener.getRenderer();
                        if (listenerRenderer.equals("FullSyncListenerTreeObject")) {
                            databaseObjectTreeObject = new FullSyncListenerTreeObject(viewer, listener, false);
                        } else {
                            databaseObjectTreeObject = new ListenerTreeObject(viewer, listener, false);
                        }
                    } else if (databaseObject instanceof com.twinsoft.convertigo.beans.core.Index) {
                        folderType = ObjectsFolderTreeObject.FOLDER_TYPE_INDEXES;
                        databaseObjectTreeObject = new DatabaseObjectTreeObject(viewer, databaseObject, false);
                    } else {
                        // unknow DBO case !!!
                        databaseObjectTreeObject = new DatabaseObjectTreeObject(viewer, databaseObject, false);
                    }
                    // no virtual folder
                    if (folderType == Integer.MIN_VALUE) {
                        parentTreeObject.addChild(databaseObjectTreeObject);
                    } else // virtual folder creation or reuse
                    {
                        /* fixed #5416 */
                        // if (currentTreeFolder == null || currentTreeFolder.folderType != folderType) {
                        // currentTreeFolder = new ObjectsFolderTreeObject(viewer, folderType);
                        // parentTreeObject.addChild(currentTreeFolder);
                        // }
                        currentTreeFolder = getFolder(parentTreeObject, folderType);
                        currentTreeFolder.addChild(databaseObjectTreeObject);
                    }
                    // case databaseObject has been changed through dbo::preconfigure, mark projectTreeObject as modified
                    if ((databaseObject.bNew) || (databaseObject.hasChanged && !databaseObject.bNew)) {
                        databaseObjectTreeObject.hasBeenModified(true);
                    }
                    // new value of recursion parameters
                    this.parentTreeObject = databaseObjectTreeObject;
                }
                // special databaseObject cases
                if (databaseObject instanceof Project) {
                    Project project = (Project) databaseObject;
                    // Creates directories and files
                    createDirsAndFiles(project.getName());
                    // Creates or Refresh xsd and wsdl folders
                    IFolder xsdFolder, wsdlFolder = null;
                    IFolder xsdInternalFolder = null;
                    try {
                        wsdlFolder = ((ProjectTreeObject) parentTreeObject).getFolder("wsdl");
                        if (!wsdlFolder.exists())
                            wsdlFolder.create(true, true, null);
                        else
                            wsdlFolder.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
                        xsdFolder = ((ProjectTreeObject) parentTreeObject).getFolder("xsd");
                        if (!xsdFolder.exists())
                            xsdFolder.create(true, true, null);
                        else {
                            xsdInternalFolder = xsdFolder.getFolder("internal");
                            if (!xsdInternalFolder.exists())
                                xsdInternalFolder.create(true, true, null);
                            xsdFolder.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
                        }
                    } catch (Exception e) {
                        e.printStackTrace();
                    }
                    // Connectors
                    IFolder xsdConnectorInternalFolder = null;
                    Collection<Connector> connectors = project.getConnectorsList();
                    if (connectors.size() != 0) {
                        // Set default connector if none
                        if (project.getDefaultConnector() == null) {
                            // Report from 4.5: fix #401
                            ConvertigoPlugin.logWarning(null, "Project \"" + project.getName() + "\" has no default connector. Try to set a default one.");
                            Connector defaultConnector = connectors.iterator().next();
                            try {
                                project.setDefaultConnector(defaultConnector);
                                defaultConnector.hasChanged = true;
                            } catch (Exception e) {
                                ConvertigoPlugin.logWarning(e, "Unable to set a default connector for project \"" + project.getName() + "\"");
                            }
                        }
                        // Refresh Traces folder
                        IFolder ifolder = ((ProjectTreeObject) parentTreeObject).getFolder("Traces");
                        if (ifolder.exists()) {
                            try {
                                ifolder.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
                            } catch (CoreException e) {
                            }
                        }
                        // Creates or Refresh internal xsd connector folders
                        for (Connector connector : connectors) {
                            try {
                                xsdConnectorInternalFolder = xsdInternalFolder.getFolder(connector.getName());
                                if (!xsdConnectorInternalFolder.exists())
                                    xsdConnectorInternalFolder.create(true, true, null);
                                else
                                    xsdConnectorInternalFolder.refreshLocal(IResource.DEPTH_INFINITE, new NullProgressMonitor());
                            } catch (Exception e) {
                                e.printStackTrace();
                            }
                        }
                    }
                } else if (databaseObject instanceof Connector) {
                    Connector connector = (Connector) databaseObject;
                    // Open connector editor
                    if (projectLoadingJob != null && connector.isDefault) {
                        projectLoadingJob.setDefaultConnectorTreeObject((ConnectorTreeObject) databaseObjectTreeObject);
                    }
                    // Traces
                    if (connector instanceof JavelinConnector) {
                        String projectName = databaseObject.getProject().getName();
                        if (projectLoadingJob == null) {
                            if (MigrationManager.isProjectMigrated(projectName)) {
                                UnloadedProjectTreeObject unloadedProjectTreeObject = new UnloadedProjectTreeObject(databaseObjectTreeObject.viewer, projectName);
                                this.projectLoadingJob = new ProjectLoadingJob(databaseObjectTreeObject.viewer, unloadedProjectTreeObject);
                                this.projectLoadingJob.loadTrace(databaseObjectTreeObject, new File(Engine.projectDir(projectName) + "/Traces/" + connector.getName()));
                            }
                        }
                        if (projectLoadingJob != null) {
                            projectLoadingJob.loadTrace(databaseObjectTreeObject, new File(Engine.projectDir(projectName) + "/Traces/" + connector.getName()));
                        }
                    }
                } else if (databaseObject instanceof Transaction) {
                    Transaction transaction = (Transaction) databaseObject;
                    // Functions
                    List<HandlersDeclarationTreeObject> treeObjects = new LinkedList<HandlersDeclarationTreeObject>();
                    String line, lineReaded;
                    int lineNumber = 0;
                    BufferedReader br = new BufferedReader(new StringReader(transaction.handlers));
                    line = br.readLine();
                    while (line != null) {
                        lineReaded = line.trim();
                        lineNumber++;
                        if (lineReaded.startsWith("function ")) {
                            try {
                                String functionName = lineReaded.substring(9, lineReaded.indexOf(')') + 1);
                                HandlersDeclarationTreeObject handlersDeclarationTreeObject = null;
                                if (functionName.endsWith(JavelinTransaction.EVENT_ENTRY_HANDLER + "()")) {
                                    handlersDeclarationTreeObject = new HandlersDeclarationTreeObject(viewer, functionName, HandlersDeclarationTreeObject.TYPE_FUNCTION_SCREEN_CLASS_ENTRY, lineNumber);
                                } else if (functionName.endsWith(JavelinTransaction.EVENT_EXIT_HANDLER + "()")) {
                                    handlersDeclarationTreeObject = new HandlersDeclarationTreeObject(viewer, functionName, HandlersDeclarationTreeObject.TYPE_FUNCTION_SCREEN_CLASS_EXIT, lineNumber);
                                } else {
                                    handlersDeclarationTreeObject = new HandlersDeclarationTreeObject(viewer, functionName, HandlersDeclarationTreeObject.TYPE_OTHER, lineNumber);
                                }
                                if (handlersDeclarationTreeObject != null) {
                                    treeObjects.add(handlersDeclarationTreeObject);
                                }
                            } catch (StringIndexOutOfBoundsException e) {
                                throw new EngineException("Exception in reading line of a transaction", e);
                            }
                        }
                        line = br.readLine();
                    }
                    if (treeObjects.size() != 0) {
                        ObjectsFolderTreeObject objectsFolderTreeObject = new ObjectsFolderTreeObject(viewer, ObjectsFolderTreeObject.FOLDER_TYPE_FUNCTIONS);
                        databaseObjectTreeObject.addChild(objectsFolderTreeObject);
                        for (HandlersDeclarationTreeObject handlersDeclarationTreeObject : treeObjects) {
                            objectsFolderTreeObject.addChild(handlersDeclarationTreeObject);
                        }
                    }
                } else if (databaseObject instanceof Sheet) {
                    addTemplates((Sheet) databaseObject, databaseObjectTreeObject);
                } else if (databaseObject instanceof ITablesProperty) {
                    ITablesProperty iTablesProperty = (ITablesProperty) databaseObject;
                    String[] tablePropertyNames = iTablesProperty.getTablePropertyNames();
                    for (int i = 0; i < tablePropertyNames.length; i++) {
                        String tablePropertyName = tablePropertyNames[i];
                        String tableRenderer = iTablesProperty.getTableRenderer(tablePropertyName);
                        XMLVector<XMLVector<Object>> xmlv = iTablesProperty.getTableData(tablePropertyName);
                        if (tableRenderer.equals("XMLTableDescriptionTreeObject")) {
                            XMLTableDescriptionTreeObject propertyXMLTableTreeObject = new XMLTableDescriptionTreeObject(viewer, tablePropertyName, xmlv, databaseObjectTreeObject);
                            databaseObjectTreeObject.addChild(propertyXMLTableTreeObject);
                        } else if (tableRenderer.equals("XMLRecordDescriptionTreeObject")) {
                            XMLRecordDescriptionTreeObject propertyXMLRecordTreeObject = new XMLRecordDescriptionTreeObject(viewer, tablePropertyName, xmlv, databaseObjectTreeObject);
                            databaseObjectTreeObject.addChild(propertyXMLRecordTreeObject);
                        }
                    }
                }
                monitor.worked(1);
                // children cannot be added in the current virtual folder
                this.currentTreeFolder = null;
                super.walk(databaseObject);
                // restore recursion parameters
                this.parentTreeObject = parentTreeObject;
                this.projectLoadingJob = projectLoadingJob;
                // restore sibling parameters
                this.currentTreeFolder = currentTreeFolder;
            }
        }.init(parentDatabaseObject, parentTreeObject, projectLoadingJob);
    } catch (EngineException e) {
        throw e;
    } catch (Exception e) {
        throw new EngineException("Exception in copyDatabaseObject", e);
    }
}

Example 3 with Pool

use of com.twinsoft.convertigo.beans.core.Pool in project convertigo by convertigo.

the class ContextManager method managePoolContexts.

private void managePoolContexts() {
    if (Engine.isStudioMode()) {
        return;
    }
    if (!Engine.isStarted) {
        Engine.logContextManager.debug("Engine is stopped => do not manage pools");
        return;
    }
    Engine.logContextManager.debug("Executing vulture thread for context pooling");
    try {
        long timeout = manage_poll_timeout;
        long now = System.currentTimeMillis();
        if (timeout != -1) {
            timeout += now;
        }
        pooledContextsToCreateSet.clear();
        Map<String, Integer> counters = new HashMap<String, Integer>();
        // with the auto-start transaction
        for (String projectName : Engine.theApp.databaseObjectsManager.getAllProjectNamesList()) {
            if (!isRunning)
                return;
            Engine.logContextManager.trace("Analyzing project " + projectName);
            Project project = null;
            try {
                project = Engine.theApp.databaseObjectsManager.getOriginalProjectByName(projectName);
            } catch (Exception e) {
                Engine.logContextManager.warn("Unable to load project '" + projectName + "'; avorting pool research for this project", e);
                continue;
            }
            Collection<Connector> vConnectors = project.getConnectorsList();
            Engine.logContextManager.trace("Connectors: " + vConnectors);
            for (Connector connector : vConnectors) {
                if (!isRunning)
                    return;
                Engine.logContextManager.trace("Connector: " + connector);
                Collection<Pool> vPools = connector.getPoolsList();
                Engine.logContextManager.trace("Pools: " + vPools);
                String poolName;
                for (Pool pool : vPools) {
                    if (!isRunning)
                        return;
                    poolName = pool.getName();
                    Engine.logContextManager.trace("Pool: " + poolName);
                    int pooledContexts = pool.getNumberOfContexts();
                    Engine.logContextManager.debug("Pool size: " + pooledContexts);
                    String poolNameWithPath = pool.getNameWithPath();
                    pooledContextsInUse = 0;
                    pooledContextsLocked = 0;
                    pooledContextsZombie = 0;
                    pooledContextsToCreate = 0;
                    counters.put(poolNameWithPath, 0);
                    if (pooledContexts > 0) {
                        for (int i = 1; i <= pool.getNumberOfContexts(); i++) {
                            if (!isRunning)
                                return;
                            Project localProject = Engine.theApp.databaseObjectsManager.getOriginalProjectByName(projectName);
                            Connector localConnector = localProject.getConnectorByName(connector.getName());
                            Pool localPool = localConnector.getPoolByName(pool.getName());
                            String servCode = localPool.getServiceCode();
                            if (servCode != null && !servCode.equals("")) {
                                if (localConnector instanceof JavelinConnector) {
                                    ((JavelinConnector) localConnector).setServiceCode(servCode);
                                    Engine.logContextManager.trace("Connector service code overridden to : " + servCode);
                                }
                            // TODO add code for each specific connector to use pools serviceCode property
                            }
                            managePoolContext(localProject, localConnector, localPool, i);
                        }
                        int pooledContextsInUsePercentage = 100 * pooledContextsInUse / pooledContexts;
                        int pooledContextsLockedPercentage = 100 * pooledContextsLocked / pooledContexts;
                        String poolStatistics = "Pool '" + poolNameWithPath + "' usage: pool size: " + pooledContexts + "; in use contexts: " + pooledContextsInUse + " (" + pooledContextsInUsePercentage + "%); zombie contexts: " + pooledContextsZombie;
                        ;
                        if (pooledContextsZombie > 0) {
                            Engine.logContextManager.warn("Pool '" + poolNameWithPath + "' had zombie contexts!");
                            Engine.logContextManager.warn(poolStatistics);
                        }
                        if (pooledContextsInUsePercentage > 80) {
                            Engine.logContextManager.warn("Pool '" + poolNameWithPath + "' is overloaded!");
                            Engine.logContextManager.warn(poolStatistics);
                        }
                        Engine.theApp.usageMonitor.setUsageCounter("[Pool] '" + poolNameWithPath + "' size", pooledContexts);
                        Engine.theApp.usageMonitor.setUsageCounter("[Pool] '" + poolNameWithPath + "' in use contexts", pooledContextsInUse + " (" + pooledContextsInUsePercentage + "%)");
                        Engine.theApp.usageMonitor.setUsageCounter("[Pool] '" + poolNameWithPath + "' locked contexts", pooledContextsLocked + " (" + pooledContextsLockedPercentage + "%)");
                        Engine.theApp.usageMonitor.setUsageCounter("[Pool] '" + poolNameWithPath + "' zombie contexts", pooledContextsZombie);
                        Engine.theApp.usageMonitor.setUsageCounter("[Pool] '" + poolNameWithPath + "' to be created contexts", pooledContextsToCreate);
                    }
                }
            }
        }
        for (Pair<Pool, Integer> pooledContextToCreate : pooledContextsToCreateSet) {
            if (!isRunning)
                return;
            String key = pooledContextToCreate.getKey().getNameWithPath();
            createPoolContext(pooledContextToCreate.getKey(), pooledContextToCreate.getValue());
            counters.put(key, counters.get(key) + 1);
            if (timeout != -1 && (now = System.currentTimeMillis()) > timeout)
                break;
        }
        for (Entry<String, Integer> entry : counters.entrySet()) {
            if (!isRunning)
                return;
            Engine.theApp.usageMonitor.setUsageCounter("[Pool] '" + entry.getKey() + "' (re)created contexts", entry.getValue());
        }
    } catch (EngineException e) {
        Engine.logContextManager.error("An unexpected error has occured in the ContextManager vulture while managing the pool contexts.", e);
    }
    Engine.logContextManager.debug("Pools creation successfully finished");
}

Example 4 with Pool

use of com.twinsoft.convertigo.beans.core.Pool in project convertigo by convertigo.

the class ContextManager method findPoolContext.

private Context findPoolContext(String contextName, String projectName, String connectorName, String poolName) throws EngineException {
    Engine.logContextManager.debug("Trying to find a pooled context");
    Engine.logContextManager.debug("   contextName=" + contextName);
    Engine.logContextManager.debug("   projectName=" + projectName);
    Engine.logContextManager.debug("   connectorName=" + connectorName);
    Engine.logContextManager.debug("   poolName=" + poolName);
    Project project = Engine.theApp.databaseObjectsManager.getProjectByName(projectName);
    Connector connector;
    if (connectorName == null) {
        connector = project.getDefaultConnector();
        connectorName = connector.getName();
    } else
        connector = project.getConnectorByName(connectorName);
    // If we cannot find the pool, abort the process
    Pool pool = connector.getPoolByName(poolName);
    if (pool == null) {
        Engine.logContextManager.debug("No pool named '" + poolName + "'; aborting pool management");
        return null;
    }
    Engine.logContextManager.debug("Found pool=" + pool);
    pool.checkSymbols();
    String contextIDPrefix = ContextManager.getPoolContextID(projectName, connectorName, poolName, "");
    if (contextName != null && !contextName.equals("default") && !contextName.equals("default*")) {
        Engine.logContextManager.debug("Explicit pooled context '" + contextIDPrefix + contextName + "' has been required");
        Context context = get(contextIDPrefix + contextName);
        if (context == null)
            throw new EngineException("Explicit pooled context '" + contextIDPrefix + contextName + "' does not exist!");
        Engine.logContextManager.debug("context.waitingRequests=" + context.waitingRequests);
        Engine.logContextManager.debug("context.lockPooledContext=" + context.lockPooledContext);
        if (!context.lockPooledContext)
            throw new EngineException("Explicit pooled context '" + contextIDPrefix + contextName + "' has not been locked!");
        Engine.logContextManager.debug("The context has been previously locked and has been explicitely requested");
        return context;
    } else {
        Engine.logContextManager.debug("Searching for good candidate");
        for (Map.Entry<String, Context> entry : contexts.entrySet()) {
            Engine.logContextManager.debug("Analyzing context " + entry.getKey());
            if (entry.getKey().startsWith(contextIDPrefix)) {
                Context context = entry.getValue();
                Engine.logContextManager.debug("context.waitingRequests=" + context.waitingRequests);
                Engine.logContextManager.debug("context.lockPooledContext=" + context.lockPooledContext);
                if ((context.waitingRequests == 0) && (!context.lockPooledContext) && verifyPoolContext(context)) {
                    Engine.logContextManager.debug("Good candidate for election: " + context.contextID);
                    return entry.getValue();
                }
            }
        }
        throw new EngineException("No more available context on the pool " + poolName + "; please try again later.");
    }
}

Example 5 with Pool

use of com.twinsoft.convertigo.beans.core.Pool in project convertigo by convertigo.

the class DatabaseObjectTreeObject method treeObjectRemoved.

public void treeObjectRemoved(TreeObjectEvent treeObjectEvent) {
    checkDone(treeObjectEvent);
    TreeObject treeObject = (TreeObject) treeObjectEvent.getSource();
    if (!(treeObject.equals(this))) {
        // this is a pool
        if (getObject() instanceof Pool) {
            Pool pool = (Pool) getObject();
            // case transaction deleted
            if (treeObject instanceof TransactionTreeObject) {
                if (treeObject.getConnectorTreeObject().equals(getConnectorTreeObject())) {
                    if (pool.getStartTransaction().equals(treeObject.getName())) {
                        pool.setStartTransaction("");
                        hasBeenModified(true);
                        viewer.refresh();
                    }
                }
            }
            // case screenclass deleted
            if (treeObject instanceof ScreenClassTreeObject) {
                if (treeObject.getConnectorTreeObject().equals(getConnectorTreeObject())) {
                    if (pool.getInitialScreenClass().equals(treeObject.getName())) {
                        pool.setInitialScreenClass("");
                        hasBeenModified(true);
                        viewer.refresh();
                    }
                }
            }
        }
    }
    if (!(treeObject.equals(this)) && (!getParents().contains(treeObject)))
        // refresh editors (e.g labels in combobox)
        getDescriptors();
}