Examples with CommonUpdateTask com.cubrid.cubridmanager.core.common.task.CommonUpdateTask used on opensource projects

Example 31 with CommonUpdateTask

use of com.cubrid.cubridmanager.core.common.task.CommonUpdateTask in project cubrid-manager by CUBRID.

the class CompactDbTaskTest method testActiveDb.

public void testActiveDb() {
    if (StringUtil.isEqual(SystemParameter.getParameterValue("useMockTest"), "n"))
        return;
    System.out.println("<database.compactdb.001.req.txt>");
    CommonUpdateTask task = new CommonUpdateTask(CommonTaskName.COMPACT_DATABASE_TASK_NANE, ServerManager.getInstance().getServer(host, monport, userName), CommonSendMsg.getCompactDbSendMsg());
    task.setDbName("activedb");
    task.setVerbose(YesNoType.Y);
    task.execute();
    assertFalse(task.isSuccess());
    assertNotNull(task.getErrorMsg());
}

Example 32 with CommonUpdateTask

use of com.cubrid.cubridmanager.core.common.task.CommonUpdateTask in project cubrid-manager by CUBRID.

the class DeleteDatabaseDialog method deleteDatabase.

/**
	 * 
	 * Delete the database
	 * 
	 * @return <code>true</code> if successful;<code>false</code> otherwise
	 */
private boolean deleteDatabase() {
    TaskExecutor taskExcutor = new TaskExecutor() {

        public boolean exec(final IProgressMonitor monitor) {
            if (monitor.isCanceled()) {
                return false;
            }
            String taskName = Messages.bind(Messages.delDbTaskName, database.getName());
            monitor.beginTask(taskName, IProgressMonitor.UNKNOWN);
            boolean isActiveReplServer = false;
            boolean isActiveReplAgent = false;
            List<String> cubridConfContentList = null;
            for (ITask task : taskList) {
                if (task instanceof GetReplServerStatusTask) {
                    GetReplServerStatusTask getReplServerStatusTask = (GetReplServerStatusTask) task;
                    getReplServerStatusTask.execute();
                    isActiveReplServer = getReplServerStatusTask.isActive();
                } else if (task instanceof StopReplServerTask) {
                    if (isActiveReplServer) {
                        task.execute();
                    }
                } else if (task instanceof GetReplAgentStatusTask) {
                    GetReplAgentStatusTask getReplAgentStatusTask = (GetReplAgentStatusTask) task;
                    getReplAgentStatusTask.execute();
                    isActiveReplAgent = getReplAgentStatusTask.isActive();
                } else if (task instanceof StopReplicationAgentTask) {
                    if (isActiveReplAgent) {
                        task.execute();
                    }
                } else if (task instanceof SetCubridConfParameterTask) {
                    if (cubridConfContentList == null) {
                        continue;
                    } else {
                        SetCubridConfParameterTask setParaTask = (SetCubridConfParameterTask) task;
                        setParaTask.setConfContents(cubridConfContentList);
                        setParaTask.execute();
                    }
                } else {
                    task.execute();
                }
                final String msg = task.getErrorMsg();
                if (openErrorBox(getShell(), msg, monitor)) {
                    return false;
                }
                if (monitor.isCanceled()) {
                    return false;
                }
                if (task instanceof GetCubridConfParameterTask) {
                    GetCubridConfParameterTask getCubridConfParameterTask = (GetCubridConfParameterTask) task;
                    cubridConfContentList = CoreUtils.deleteDatabaseFromServiceServer(getCubridConfParameterTask, cubridConfContentList, database.getName());
                }
            }
            return true;
        }
    };
    ServerInfo serverInfo = database.getServer().getServerInfo();
    //check the replication server and agent
    if (serverInfo.isSupportReplication() == 0) {
        if (database.isDistributorDb()) {
            GetReplAgentStatusTask getReplAgentStatusTask = new GetReplAgentStatusTask(serverInfo);
            getReplAgentStatusTask.setDbName(database.getLabel());
            taskExcutor.addTask(getReplAgentStatusTask);
            StopReplicationAgentTask stopReplAgentTask = new StopReplicationAgentTask(serverInfo);
            stopReplAgentTask.setDbName(database.getLabel());
            taskExcutor.addTask(stopReplAgentTask);
        } else {
            GetReplServerStatusTask getReplServerStatusTask = new GetReplServerStatusTask(serverInfo);
            getReplServerStatusTask.setDbName(database.getLabel());
            taskExcutor.addTask(getReplServerStatusTask);
            StopReplServerTask stopReplServerTask = new StopReplServerTask(serverInfo);
            stopReplServerTask.setDbName(database.getLabel());
            taskExcutor.addTask(stopReplServerTask);
        }
    }
    CommonUpdateTask deleteDbtask = new CommonUpdateTask(CommonTaskName.DELETE_DATABASE_TASK_NAME, serverInfo, CommonSendMsg.getDeletedbSendMsg());
    deleteDbtask.setDbName(database.getName());
    if (deleteBackupVolumesButton.getSelection()) {
        deleteDbtask.setDelbackup(YesNoType.Y);
    } else {
        deleteDbtask.setDelbackup(YesNoType.N);
    }
    taskExcutor.addTask(deleteDbtask);
    GetCubridConfParameterTask getCubridConfParameterTask = new GetCubridConfParameterTask(serverInfo);
    taskExcutor.addTask(getCubridConfParameterTask);
    SetCubridConfParameterTask setCubridConfParameterTask = new SetCubridConfParameterTask(serverInfo);
    taskExcutor.addTask(setCubridConfParameterTask);
    new ExecTaskWithProgress(taskExcutor).exec(true, false);
    if (taskExcutor.isSuccess()) {
        setReturnCode(DELETE_ID);
        close();
        return true;
    } else {
        return false;
    }
}

Example 33 with CommonUpdateTask

use of com.cubrid.cubridmanager.core.common.task.CommonUpdateTask in project cubrid-manager by CUBRID.

the class StopDatabaseAction method run.

public void run() {
    Object[] objArr = this.getSelectedObj();
    if (objArr == null || objArr.length <= 0) {
        setEnabled(false);
        return;
    }
    Set<CubridDatabase> databaseSet = new HashSet<CubridDatabase>();
    for (int i = 0; objArr != null && i < objArr.length; i++) {
        if (!isSupported(objArr[i])) {
            setEnabled(false);
            return;
        }
        ISchemaNode schemaNode = (ISchemaNode) objArr[i];
        CubridDatabase database = schemaNode.getDatabase();
        databaseSet.add(database);
    }
    StringBuffer dbNames = new StringBuffer();
    Iterator<CubridDatabase> it = databaseSet.iterator();
    while (it.hasNext()) {
        CubridDatabase database = it.next();
        dbNames.append(database.getLabel()).append(",");
    }
    dbNames = new StringBuffer(dbNames.substring(0, dbNames.length() - 1));
    boolean isStop = CommonUITool.openConfirmBox(getShell(), Messages.bind(Messages.msgConfirmStopDatabase, dbNames.toString()));
    if (!isStop) {
        return;
    }
    Iterator<CubridDatabase> iter = databaseSet.iterator();
    while (iter.hasNext()) {
        CubridDatabase database = iter.next();
        final JobFamily jobFamily = new JobFamily();
        String serverName = database.getServer().getName();
        String dbName = database.getName();
        jobFamily.setServerName(serverName);
        jobFamily.setDbName(dbName);
        Job[] jobs = Job.getJobManager().find(jobFamily);
        if (jobs.length > 0) {
            CommonUITool.openWarningBox(Messages.bind(Messages.msgStopDbWithJob, dbName));
            databaseSet.remove(database);
            continue;
        }
    }
    final Object[] dbObjectArr = new Object[databaseSet.size()];
    databaseSet.toArray(dbObjectArr);
    ISelectionProvider provider = getSelectionProvider();
    final Shell shell = getShell();
    if (provider instanceof TreeViewer && dbObjectArr.length > 0) {
        final TreeViewer viewer = (TreeViewer) provider;
        TaskExecutor taskExcutor = new TaskExecutor() {

            public boolean exec(final IProgressMonitor monitor) {
                Display display = Display.getDefault();
                if (monitor.isCanceled()) {
                    return false;
                }
                for (int i = 0; i < taskList.size(); i++) {
                    ISchemaNode node = (ISchemaNode) dbObjectArr[i];
                    final CubridDatabase database = node.getDatabase();
                    if (!isSupported(database)) {
                        continue;
                    }
                    monitor.subTask(Messages.bind(Messages.stopDbTaskName, database.getName()));
                    ITask task = taskList.get(i);
                    task.execute();
                    final String msg = task.getErrorMsg();
                    if (openErrorBox(shell, msg, monitor)) {
                        return false;
                    }
                    if (monitor.isCanceled()) {
                        return false;
                    }
                    database.removeAllChild();
                    if (database.getLoader() != null) {
                        database.getLoader().setLoaded(false);
                    }
                    database.setRunningType(DbRunningType.STANDALONE);
                    display.syncExec(new Runnable() {

                        public void run() {
                            viewer.refresh(database, true);
                        }
                    });
                    if (monitor.isCanceled()) {
                        return false;
                    }
                }
                return true;
            }
        };
        boolean isContinue = true;
        for (int i = 0; i < dbObjectArr.length; i++) {
            ISchemaNode node = (ISchemaNode) dbObjectArr[i];
            CubridDatabase database = node.getDatabase();
            if (!isSupported(database)) {
                setEnabled(false);
                return;
            }
            if (!LayoutUtil.checkAllQueryEditor(database)) {
                isContinue = false;
                break;
            }
            CommonUpdateTask task = new CommonUpdateTask(CommonTaskName.STOP_DB_TASK_NAME, database.getServer().getServerInfo(), CommonSendMsg.getCommonDatabaseSendMsg());
            task.setDbName(database.getLabel());
            taskExcutor.addTask(task);
        }
        if (!isContinue) {
            return;
        }
        new ExecTaskWithProgress(taskExcutor).busyCursorWhile();
        ActionManager.getInstance().fireSelectionChanged(getSelection());
        for (int i = 0; i < dbObjectArr.length; i++) {
            CubridDatabase database = (CubridDatabase) dbObjectArr[i];
            CubridNodeManager.getInstance().fireCubridNodeChanged(new CubridNodeChangedEvent(database, CubridNodeChangedEventType.DATABASE_STOP));
        }
    }
}

Example 34 with CommonUpdateTask

use of com.cubrid.cubridmanager.core.common.task.CommonUpdateTask in project cubrid-manager by CUBRID.

the class CreateDatabaseWizard method performFinish.

/**
	 * Called when user clicks Finish
	 * 
	 * @return boolean
	 */
public boolean performFinish() {
    isCanFinished = true;
    isOverride = true;
    final String databaseName = generalInfoPage.getDatabaseName();
    String pageSize = generalInfoPage.getPageSize();
    String logPageSize = generalInfoPage.getLogPageSize();
    String generalPageNum = generalInfoPage.getGenericPageNum();
    String generalVolumePath = generalInfoPage.getGenericVolumePath();
    String charset = generalInfoPage.getCharset();
    final boolean isAutoStart = generalInfoPage.isAutoStart();
    TaskJobExecutor taskExcutor = new TaskJobExecutor() {

        public IStatus exec(final IProgressMonitor monitor) {
            Display.getDefault().syncExec(new Runnable() {

                public void run() {
                    getShell().setVisible(false);
                }
            });
            if (monitor.isCanceled()) {
                isCanFinished = true;
                Display.getDefault().syncExec(new Runnable() {

                    public void run() {
                        cancel();
                        close();
                    }
                });
                return Status.CANCEL_STATUS;
            }
            List<String> cubridConfContentList = null;
            for (ITask task : taskList) {
                if (task instanceof CreateDbTask) {
                    CreateDbTask createDbTask = (CreateDbTask) task;
                    createDbTask.setOverwriteConfigFile(isOverride);
                } else if (task instanceof SetCubridConfParameterTask) {
                    if (cubridConfContentList == null) {
                        continue;
                    } else {
                        SetCubridConfParameterTask setParaTask = (SetCubridConfParameterTask) task;
                        setParaTask.setConfContents(cubridConfContentList);
                    }
                }
                task.execute();
                final String msg = task.getErrorMsg();
                if (monitor.isCanceled()) {
                    Display.getDefault().syncExec(new Runnable() {

                        public void run() {
                            cancel();
                            close();
                        }
                    });
                    isCanFinished = true;
                    return Status.CANCEL_STATUS;
                }
                if (msg != null && msg.length() > 0 && !monitor.isCanceled() && !isCanceled()) {
                    //start database failed
                    if (task instanceof CommonUpdateTask && task.getTaskname().equals(CommonTaskName.START_DB_TASK_NAME)) {
                        Display.getDefault().syncExec(new Runnable() {

                            public void run() {
                                CommonUITool.openErrorBox(getShell(), msg + StringUtil.NEWLINE + Messages.createDBFailedMsg);
                            }
                        });
                        return Status.OK_STATUS;
                    }
                    Display.getDefault().syncExec(new Runnable() {

                        public void run() {
                            CommonUITool.openErrorBox(getShell(), msg);
                            isCanFinished = false;
                            getShell().setVisible(true);
                        }
                    });
                    return Status.CANCEL_STATUS;
                }
                if (isCanceled()) {
                    return Status.CANCEL_STATUS;
                }
                if (task instanceof CheckDirTask) {
                    CheckDirTask checkDirTask = (CheckDirTask) task;
                    final String[] dirs = checkDirTask.getNoExistDirectory();
                    if (dirs != null && dirs.length > 0) {
                        Display.getDefault().syncExec(new Runnable() {

                            public void run() {
                                CreateDirDialog dialog = new CreateDirDialog(getShell());
                                dialog.setDirs(dirs);
                                if (dialog.open() != IDialogConstants.OK_ID) {
                                    isCanFinished = false;
                                    getShell().setVisible(true);
                                }
                            }
                        });
                    }
                } else if (task instanceof CheckFileTask) {
                    CheckFileTask checkFileTask = (CheckFileTask) task;
                    final String[] files = checkFileTask.getExistFiles();
                    if (files != null && files.length > 0) {
                        Display.getDefault().syncExec(new Runnable() {

                            public void run() {
                                OverrideFileDialog dialog = new OverrideFileDialog(getShell());
                                dialog.setFiles(files);
                                isOverride = dialog.open() == IDialogConstants.OK_ID;
                                getShell().setVisible(!isOverride);
                            }
                        });
                    }
                } else if (task instanceof GetCubridConfParameterTask) {
                    GetCubridConfParameterTask getCubridConfParameterTask = (GetCubridConfParameterTask) task;
                    List<String> cubridConfContentListCandidate1 = null;
                    if (isAutoStart) {
                        cubridConfContentListCandidate1 = CoreUtils.addDatabaseToServiceServer(getCubridConfParameterTask, null, databaseName);
                    }
                    List<String> cubridConfContentListCandidate2 = null;
                    if (CompatibleUtil.isNeedCheckHAModeOnNewDb(server.getServerInfo())) {
                        cubridConfContentListCandidate2 = CoreUtils.changeHAModeFromCubridConf(getCubridConfParameterTask, cubridConfContentListCandidate1, databaseName);
                    }
                    if (cubridConfContentListCandidate2 == null) {
                        cubridConfContentList = cubridConfContentListCandidate1;
                    } else {
                        cubridConfContentList = cubridConfContentListCandidate2;
                    }
                }
                if (!isCanFinished) {
                    return Status.CANCEL_STATUS;
                }
                if (monitor.isCanceled()) {
                    Display.getDefault().syncExec(new Runnable() {

                        public void run() {
                            completeAll();
                            close();
                            cancel();
                        }
                    });
                    return Status.CANCEL_STATUS;
                }
            }
            return Status.OK_STATUS;
        }

        public void cancel() {
            super.cancel();
            GetDatabaseListTask getDatabaseListTask = new GetDatabaseListTask(server.getServerInfo());
            getDatabaseListTask.execute();
            boolean isExist = false;
            List<DatabaseInfo> databaseInfoList = getDatabaseListTask.loadDatabaseInfo();
            if (databaseInfoList != null) {
                for (int i = 0; i < databaseInfoList.size(); i++) {
                    DatabaseInfo dbInfo = databaseInfoList.get(i);
                    String dbName = dbInfo.getDbName();
                    if (dbName.equals(databaseName)) {
                        isExist = true;
                    }
                }
            }
            if (isExist) {
                CommonUpdateTask deleteTask = new CommonUpdateTask(CommonTaskName.DELETE_DATABASE_TASK_NAME, server.getServerInfo(), CommonSendMsg.getDeletedbSendMsg());
                deleteTask.setDbName(databaseName);
                deleteTask.setDelbackup(YesNoType.Y);
                deleteTask.execute();
            }
        }

        public void done(IJobChangeEvent event) {
            if (event.getResult() == Status.OK_STATUS) {
                Display.getDefault().syncExec(new Runnable() {

                    public void run() {
                        completeAll();
                        close();
                    }
                });
            }
        }
    };
    CheckDirTask checkDirTask = new CheckDirTask(server.getServerInfo());
    CheckFileTask checkFileTask = new CheckFileTask(server.getServerInfo());
    CreateDbTask createDbTask = new CreateDbTask(server.getServerInfo());
    List<String> checkedDirsList = new ArrayList<String>();
    List<String> checkedFilesList = new ArrayList<String>();
    // add checked directory(general volume path)
    addVolumePath(checkedDirsList, generalVolumePath);
    String logPageNum = generalInfoPage.getLogPageNum();
    String logVolumePath = generalInfoPage.getLogVolumePath();
    // add checked directory(log volume path)
    addVolumePath(checkedDirsList, logVolumePath);
    List<Map<String, String>> volumeList = volumeInfoPage.getVolumeList();
    for (int i = 0; i < volumeList.size(); i++) {
        Map<String, String> map = volumeList.get(i);
        String volumeName = map.get("0");
        String volumePath = map.get("4");
        // add checked directory(additional volume path)
        addVolumePath(checkedDirsList, volumePath);
        // add checked file(additional volume)
        addVolumePath(checkedFilesList, volumePath + server.getServerInfo().getPathSeparator() + volumeName);
    }
    String[] dirs = new String[checkedDirsList.size()];
    checkDirTask.setDirectory(checkedDirsList.toArray(dirs));
    String[] files = new String[checkedFilesList.size()];
    checkFileTask.setFile(checkedFilesList.toArray(files));
    createDbTask.setDbName(databaseName);
    createDbTask.setPageSize(pageSize);
    if (logPageSize != null) {
        createDbTask.setLogPageSize(logPageSize);
    }
    if (charset != null) {
        createDbTask.setCharset(charset);
    }
    createDbTask.setNumPage(generalPageNum);
    createDbTask.setGeneralVolumePath(generalVolumePath);
    createDbTask.setLogSize(logPageNum);
    createDbTask.setLogVolumePath(logVolumePath);
    createDbTask.setExVolumes(volumeList);
    if (!checkedDirsList.isEmpty()) {
        taskExcutor.addTask(checkDirTask);
    }
    if (!checkedFilesList.isEmpty()) {
        taskExcutor.addTask(checkFileTask);
    }
    taskExcutor.addTask(createDbTask);
    //add set auto added volume
    GetAutoAddVolumeInfo returnInfo = setAutoAddVolumeInfoPage.getAutoAddVolumeInfo();
    if (returnInfo != null) {
        SetAutoAddVolumeTask setTask = new SetAutoAddVolumeTask(server.getServerInfo());
        setTask.setDbname(databaseName);
        setTask.setData(returnInfo.getData());
        setTask.setDataWarnOutofspace(returnInfo.getData_warn_outofspace());
        setTask.setDataExtPage(returnInfo.getData_ext_page());
        setTask.setIndex(returnInfo.getIndex());
        setTask.setIndexWarnOutofspace(returnInfo.getIndex_warn_outofspace());
        setTask.setIndexExtPage(returnInfo.getIndex_ext_page());
        taskExcutor.addTask(setTask);
    }
    GetCubridConfParameterTask getCubridConfParameterTask = new GetCubridConfParameterTask(server.getServerInfo());
    taskExcutor.addTask(getCubridConfParameterTask);
    SetCubridConfParameterTask setCubridConfParameterTask = new SetCubridConfParameterTask(server.getServerInfo());
    taskExcutor.addTask(setCubridConfParameterTask);
    //start database
    CommonUpdateTask startDbTask = new CommonUpdateTask(CommonTaskName.START_DB_TASK_NAME, server.getServerInfo(), CommonSendMsg.getCommonDatabaseSendMsg());
    startDbTask.setDbName(databaseName);
    taskExcutor.addTask(startDbTask);
    //set dba password
    UpdateAddUserTask updateUserTask = new UpdateAddUserTask(server.getServerInfo(), false);
    UserSendObj userSendObj = new UserSendObj();
    userSendObj.setDbname(databaseName);
    userSendObj.setUsername("dba");
    String password = setDbaPasswordPage.getPassword();
    userSendObj.setUserpass(password);
    updateUserTask.setUserSendObj(userSendObj);
    taskExcutor.addTask(updateUserTask);
    JobFamily jobFamily = new JobFamily();
    String serverName = server.getName();
    jobFamily.setServerName(serverName);
    String jobName = Messages.msgCreateDbrearJobName + " - " + serverName;
    taskExcutor.schedule(jobName, jobFamily, true, Job.SHORT);
    //the close is in the job
    return false;
}

Example 35 with CommonUpdateTask

use of com.cubrid.cubridmanager.core.common.task.CommonUpdateTask in project cubrid-manager by CUBRID.

the class CreateReplicationJobExecutor method createMaster.

/**
	 * create master database
	 * 
	 * @param dbName String
	 * @param monitor IProgressMonitor
	 * @param taskList List<ITask>
	 * @return status
	 */
private IStatus createMaster(final String dbName, final IProgressMonitor monitor, List<ITask> taskList) {
    monitor.subTask(Messages.bind(Messages.createMasterJobName, dbName));
    Display display = Display.getDefault();
    MonitoringTask monitoringTask = null;
    boolean isExecuteSetParaTask = true;
    boolean isExecuteStopDbTask = true;
    boolean isExecuteStartDbTask = false;
    Map<String, Map<String, String>> confParaMaps = null;
    MonitorDashboardPreference monPref = new MonitorDashboardPreference();
    for (ITask task : taskList) {
        if (task instanceof MonitoringTask) {
            monitoringTask = (MonitoringTask) task;
            ServerInfo serverInfo = monitoringTask.getServerInfo();
            CMHostNodePersistManager.getInstance().addServer(serverInfo.getHostAddress(), serverInfo.getHostMonPort(), serverInfo.getUserName(), serverInfo);
            monitoringTask.connectServer(Version.releaseVersion, monPref.getHAHeartBeatTimeout());
        } else if (task instanceof StopReplServerTask) {
            if (isExecuteStopReplServerTask) {
                task.execute();
            } else {
                continue;
            }
        } else if (task instanceof SetCubridConfParameterTask) {
            if (isExecuteSetParaTask) {
                SetCubridConfParameterTask setCubridConfParameterTask = (SetCubridConfParameterTask) task;
                setCubridConfParameterTask.setConfParameters(confParaMaps);
                task.execute();
            } else {
                continue;
            }
        } else if (task instanceof CommonUpdateTask && task.getTaskname().equals(CommonTaskName.STOP_DB_TASK_NAME)) {
            if (isExecuteStopDbTask) {
                task.execute();
            } else {
                continue;
            }
        } else if (task instanceof CommonUpdateTask && task.getTaskname().equals(CommonTaskName.START_DB_TASK_NAME)) {
            if (isExecuteStartDbTask) {
                task.execute();
            } else {
                continue;
            }
        } else if (task instanceof GetTransferProgressTask) {
            GetTransferProgressTask getTransferProgressTask = (GetTransferProgressTask) task;
            monitor.subTask(Messages.transFileJobName);
            if (pid != null) {
                while (!isCanceled()) {
                    getTransferProgressTask.setPid(pid);
                    getTransferProgressTask.execute();
                    TransFileProgressInfo progressInfo = getTransferProgressTask.getProgressInfo();
                    if (getTransferProgressTask.isSuccess() && progressInfo != null) {
                        String transferStatus = progressInfo.getTransferStatus();
                        String transferNote = progressInfo.getTransferNote();
                        if (transferStatus != null && transferStatus.equals("success")) {
                            pid = null;
                            cancelTransFileTask = null;
                            break;
                        } else if (transferStatus != null && transferStatus.equals("failure")) {
                            pid = null;
                            cancelTransFileTask = null;
                            getTransferProgressTask.setErrorMsg(transferNote);
                            break;
                        } else {
                            try {
                                Thread.sleep(1000);
                            } catch (InterruptedException e) {
                                e.printStackTrace();
                            }
                        }
                    } else {
                        break;
                    }
                }
            }
        } else if (task instanceof CancelTransFileTask) {
            cancelTransFileTask = (CancelTransFileTask) task;
        } else {
            task.execute();
        }
        if (monitor.isCanceled()) {
            disConnect(monitoringTask);
            return Status.CANCEL_STATUS;
        }
        final String msg = task.getErrorMsg();
        if (msg != null && msg.length() > 0 && !monitor.isCanceled()) {
            disConnect(monitoringTask);
            return new Status(IStatus.ERROR, CubridManagerUIPlugin.PLUGIN_ID, msg);
        }
        if (task instanceof GetReplServerStatusTask) {
            GetReplServerStatusTask getReplServerStatusTask = (GetReplServerStatusTask) task;
            boolean isActive = getReplServerStatusTask.isActive();
            if (isActive) {
                display.syncExec(new Runnable() {

                    public void run() {
                        isExecuteStopReplServerTask = CommonUITool.openConfirmBox(Messages.bind(Messages.msgConfirmStopReplServer, dbName));
                    }
                });
                if (!isExecuteStopReplServerTask) {
                    disConnect(monitoringTask);
                    return Status.CANCEL_STATUS;
                }
            }
        } else if (task instanceof GetCubridConfParameterTask) {
            GetCubridConfParameterTask getCubridConfParameterTask = (GetCubridConfParameterTask) task;
            confParaMaps = getCubridConfParameterTask.getConfParameters();
            String mdbName = (String) getCubridConfParameterTask.getData("dbName");
            Map<String, String> dbMap = confParaMaps.get("[@" + mdbName + "]");
            if (dbMap == null) {
                Map<String, String> commonMap = confParaMaps.get(ConfConstants.COMMON_SECTION_NAME);
                if (commonMap != null && commonMap.get(ConfConstants.REPLICATION) != null && commonMap.get(ConfConstants.REPLICATION).equalsIgnoreCase("yes")) {
                    isExecuteSetParaTask = false;
                } else if (commonMap != null) {
                    isExecuteSetParaTask = true;
                    commonMap.put(ConfConstants.REPLICATION, "yes");
                }
            } else {
                String replStr = dbMap.get(ConfConstants.REPLICATION);
                if (replStr == null || replStr.equalsIgnoreCase("no")) {
                    isExecuteSetParaTask = true;
                    dbMap.put(ConfConstants.REPLICATION, "yes");
                } else {
                    isExecuteSetParaTask = false;
                }
            }
        } else if (task instanceof GetDatabaseListTask) {
            GetDatabaseListTask getDatabaseListTask = (GetDatabaseListTask) task;
            String mdbName = (String) getDatabaseListTask.getData("dbName");
            List<DatabaseInfo> dbInfoList = getDatabaseListTask.loadDatabaseInfo();
            for (int i = 0; i < dbInfoList.size(); i++) {
                DatabaseInfo dbInfo = dbInfoList.get(i);
                if (mdbName.equalsIgnoreCase(dbInfo.getDbName())) {
                    if (dbInfo.getRunningType() == DbRunningType.CS) {
                        isExecuteStopDbTask = isExecuteSetParaTask;
                    }
                    isExecuteStartDbTask = dbInfo.getRunningType() == DbRunningType.STANDALONE || isExecuteStopDbTask;
                    break;
                }
            }
        } else if (task instanceof TransFileTask) {
            TransFileTask transFileTask = (TransFileTask) task;
            pid = transFileTask.getTransFilePid();
        }
    }
    disConnect(monitoringTask);
    return Status.OK_STATUS;
}