手动备份项目流程

1 web项目：

backup/manual
BackupController
web 项目controller
/**
     * @Title: create
     * @Description: 手动创建备份
     * @author zhangjiankang
     * @param req
     * @param request
     * @param response
     * @return
     * @return Object
     * @throws
     * @date 2017年4月7日 下午1:19:43
     */
    @RequestMapping(value = "manual", method = RequestMethod.POST)
    public @ResponseBody Object create(@RequestBody BackupCreateReq req, HttpServletRequest request, HttpServletResponse response) {
        CustomerInfoVo customer = getLogonUserInfo();
        GenericDataResponse<List<BackupBean>> resultData = new GenericDataResponse<List<BackupBean>>();
        resultData.success();
        List<BackupBean> backupList = new ArrayList<BackupBean>();
        if (null == customer)
            return IWebResponses.NO_AUTH;
        if (UString.isEmpty(req.getSysName()) && UString.isEmpty(req.getDataName()))
            return IWebResponses.BACKUP_NAME_NOT_NULL;
        if (UString.isEmpty(req.getArrow_id()))
            return IWebResponses.PARAMETER_ERROR;
        if (UString.isEmpty(req.getOnline()))
            return IWebResponses.REQ_IS_NULL;
        if (req.getSysDiskId() == null && req.getDataDiskId() == null)
            return IWebResponses.REQ_IS_NULL;
        try {
            req.setCustomerId(customer.getId());
            req.setSubAccountId(getSubAccountId());
            //为备份设置时间戳
            req.setBackupStamp(System.currentTimeMillis());
            ArrowBean arrowBean = arrowCustomDao.selectOne(new ArrowBean(req.getCustomerId(), Integer.valueOf(req.getArrow_id())));
            if (arrowBean == null) {
                return IWebResponses.ARROW_NOT_EXISTS;
            }
            String backupContent = "手动为:" + req.getArrow_id() + "云主机创建备份";
            logService.saveWebArrowLogNew(customer, LogTypeEnum.WEB_BACKUP_IMAGE.getDes(), IPAddress.getIpAddr(request), backupContent, LogType.write.getId(),
                    (req.getArrow_id() != null ? req.getArrow_id() : ""));
            //远程调用controller查询备份文件大小
            // String BACKUP_QUERYBACKUP_SIZE = "backup/querySize";
            String visitUrl = ZoneCache.getZoneByUuid(arrowBean.getZoneUuid()).getUrl() + ControllerApiDeclarations.BACKUP_QUERYBACKUP_SIZE;
            Map<String, Object> map = new HashMap<String, Object>();
            map.put("instanceId", arrowBean.getUuid());
            Double sysSize = 0.00;//系统盘大小
            Double dataSize = 0.00;//数据盘大小
            if (req.getSysDiskId() != null) {
                //查询系统盘备份文件大小
                map.put("diskId", req.getSysDiskId());
                map.put("diskType", 0);
                //查询备份文件大小
                HttpProxyResponse respose = HttpConnectProxy.post(visitUrl, map);
                if (respose.notSuccess()) {
                    return IWebResponses.QUERY_IMAGE_SIZE_FAIL;//@IResponse(message = "查询备份文件大小失败")
                }
                GenericDataResponse<Double> rest = UJson.toObject(respose.getResult(), GenericDataResponse.class);
                if (rest.notSuccess()) {
                    return rest.getData();
                }
                sysSize = rest.getData();
                //1.验证资源和状态
                GenericResponse validResult = createBackupService.validateResource(arrowBean, req, sysSize, 0);
                if (validResult.notSuccess()) {
                    return validResult;
                }
                //2.web处理,系统盘备份创建
                GenericDataResponse<BackupBean> result = createBackupService.create(arrowBean, req, sysSize, 0);
                if (result.notSuccess()) {
                    return result;
                }
                BackupBean backupBean = result.getData();
                //准备backupDto参数
                BackupCreateT2C_DTO backupDto = new BackupCreateT2C_DTO(backupBean.getUuid(), backupBean.getName(), backupBean.getArrowUuid(), backupBean.getSize(), backupBean.getManualType(),
                        backupBean.getOnline(), backupBean.getContentType(), req.getSysDiskId());
                //BackupCreateDTO backupDto = new BackupCreateDTO(backupBean.getUuid(), backupBean.getName(), backupBean.getArrowUuid(), backupBean.getSize(), backupBean.getManualType(), backupBean.getOnline(),backupBean.getContentType());
                String url = ZoneCache.getZoneByUuid(arrowBean.getZoneUuid()).getUrl() + ControllerApiDeclarations.BACKUP_MANUAL_CREATE;
                //远程调用controller创建备份
                HttpProxyResponse hr = HttpConnectProxy.post(url, UMethod.getMap(backupDto));
                cacheService.updateActionState(ArrowActionEnum.BACKUP, backupBean.getArrowUuid());
                /* if (hr.isSuccess()) {// 访问成功
                    GenericResponse res = UJson.toObject(hr.getResult(), GenericResponse.class);
                    if (res.isSuccess()) {
                        cacheService.updateActionState(ArrowActionEnum.BACKUP, backupBean.getArrowUuid());
                    } else {
                        createBackupService.saveSYSException("创建备份失败controller环节错误" + hr.getResult());
                        createBackupService.createFailed(backupBean);
                    }
                } else {
                    createBackupService.saveSYSException("创建备份连接controller失败");
                    createBackupService.createFailed(backupBean);
                    return hr;
                }*/
                backupList.add(backupBean);
                resultData.setData(backupList);
            }
            if (req.getDataDiskId() != null) {
                //查询数据盘备份文件大小
                map.put("diskId", req.getDataDiskId());
                map.put("diskType", 1);
                HttpProxyResponse respose = HttpConnectProxy.post(visitUrl, map);
                if (respose.notSuccess()) {
                    createBackupService.saveOperateLog(req.getCustomerId(),3,"数据盘备份异常",IWebResponses.QUERY_IMAGE_SIZE_FAIL.toString());
                    resultData.setMsgInfo("数据盘备份失败，"+IWebResponses.QUERY_IMAGE_SIZE_FAIL);
                    resultData.setSuccess(false);
                    return resultData;
                }
                GenericDataResponse<Double> rest = UJson.toObject(respose.getResult(), GenericDataResponse.class);
                if (rest.notSuccess()) {
                    Map<String,String> restMap = JSONObject.fromObject(UJson.toObject(respose.getResult(), GenericDataResponse.class).getData());
                    createBackupService.saveOperateLog(req.getCustomerId(),3,"数据盘备份异常",restMap.get("message"));
                    resultData.setMsgInfo("数据盘备份失败，"+restMap.get("message"));
                    resultData.setSuccess(false);
                    return resultData;
                }
                dataSize = rest.getData();
                //1.验证资源和状态
                GenericResponse validResult = createBackupService.validateResource(arrowBean, req, dataSize, 1);
                if (validResult.notSuccess()) {
                    createBackupService.saveOperateLog(req.getCustomerId(),3,"数据盘备份异常",validResult.toString());
                    resultData.setMsgInfo("数据盘备份失败，"+validResult.getMsgInfo());
                    resultData.setSuccess(false);
                    return resultData;
                }
                //2.web处理,数据盘备份创建
                GenericDataResponse<BackupBean> result = createBackupService.create(arrowBean, req, dataSize, 1);
                if (result.notSuccess()) {
                    createBackupService.saveOperateLog(req.getCustomerId(),3,"数据盘备份异常",result.toString());
                    resultData.setMsgInfo("数据盘备份失败，"+result.getMsgInfo());
                    resultData.setSuccess(false);
                    return resultData;
                }
                BackupBean backupBean = result.getData();
                //准备backupDto参数
                BackupCreateT2C_DTO backupDto = new BackupCreateT2C_DTO(backupBean.getUuid(), backupBean.getName(), backupBean.getArrowUuid(), backupBean.getSize(), backupBean.getManualType(),
                        backupBean.getOnline(), backupBean.getContentType(), req.getDataDiskId());
                String url = ZoneCache.getZoneByUuid(arrowBean.getZoneUuid()).getUrl() + ControllerApiDeclarations.BACKUP_MANUAL_CREATE;
                //远程调用controller创建备份
                HttpProxyResponse hr = HttpConnectProxy.post(url, UMethod.getMap(backupDto));
                if (hr.isSuccess()) {// 访问成功
                    GenericResponse res = UJson.toObject(hr.getResult(), GenericResponse.class);
                    if (res.isSuccess()) {
                        cacheService.updateActionState(ArrowActionEnum.BACKUP, backupBean.getArrowUuid());
                    } else {
                        if (!res.getMsgCode().equals("backup_queue_full")) {
                            logger.info("创建数据盘手动备份失败，backup.uuid=" + backupBean.getUuid() + hr.getResult());
                            createBackupService.saveSYSException(ExceptionSystemTypeEnum.CONTROLLER,
                                    "创建数据盘手动备份失败，backup.uuid=" + backupBean.getUuid() + hr.getResult());
                            createBackupService.createFailed(backupBean);
                        } else {
                            logger.info("创建备份时，备份服务器连接数已满，请耐心等待!备份uuid:" + backupBean.getUuid());
                            resultData.setMsgInfo("数据盘备份繁忙，请耐心等待，" + hr.getMsgInfo());
                            resultData.setSuccess(false);
                            return resultData;
                        }
                    }
                } else {
                    createBackupService.saveSYSException(ExceptionSystemTypeEnum.CONTROLLER,
                            "创建数据盘手动备份连接controller失败，backup.uuid=" + backupBean.getUuid() + hr.getResult());
                    createBackupService.createFailed(backupBean);
                    createBackupService.saveOperateLog(req.getCustomerId(),3,"数据盘备份异常",hr.toString());
                    resultData.setMsgInfo("数据盘备份失败，"+hr.getMsgInfo());
                    resultData.setSuccess(false);
                    return resultData;
                }
                backupList.add(backupBean);
            }
            resultData.setData(backupList);
            return resultData;
        } catch (Exception e) {
            logger.error(UTrace.trace(e));
            return IWebResponses.UNKNOWN_ERROR;
        }
    }

======================================================

contraller 项目

contraller 项目

@Controller
@RequestMapping("/api/backup")
public class CreateBackupController {

/**
     * 查询备份文件实际大小
     */
    /**
     * @Title: querySize
     * @Description: 查询备份文件实际大小
     * @author zhangjiankang
     * @param instanceId
     * @param diskId
     * @param diskType:系统盘：0，数据盘：1
     * @return Object
     * @date 2017年4月10日 下午1:20:57
     */
    @RequestMapping(value = "/querySize")
    @ResponseBody
    public Object querySize(Long instanceId,Long diskId,Integer diskType, HttpServletRequest request, HttpServletResponse response) {
        GenericDataResponse<Object> returnResult = new GenericDataResponse<Object>();
        //检查arrow和diskId是否一致，判断数据一致性
        GenericResponse resMsg = createBackupService.checkArrowAndDisk(instanceId,diskId);
        if(resMsg.notSuccess()){
            returnResult.init(ISmartResponses.FAIL);
            returnResult.setData(resMsg);
            return returnResult;
        }
        HttpProxyResponse queryResult = createBackupService.querySize(instanceId,diskId,diskType);
        if (queryResult.isSuccess()) {
            GenericDataResponse<String> result = UJson.tryParametricTypeObject(queryResult.getResult(), GenericDataResponse.class, String.class);
            if (result.isSuccess()) {
                String message = result.getData();
                Map<String, Long> map = UJson.tryParametricTypeObject(message, Map.class, String.class, Long.class);
                Long size = Long.valueOf(map.get("size"));
                Double sizeG = DoubleTools.div(size, 1024 * 1024, 5);
                returnResult.init(ISmartResponses.SUCCESS);
                returnResult.setData(sizeG);
            }
        } else {
            returnResult.init(ISmartResponses.FAIL);
            returnResult.setData(ISmartResponses.CONNECT_ERROR);
        }
        return returnResult;
    }
----------------------------------------------------------------------------------
/**
     * @Title: querySize
     * @Description: 查询备份主机文件大小
     * @author zhangjiankang
     * @param instanceId
     * @param dataDiskId
     * @param sysDiskId
     * @return HttpProxyResponse
     * @date 2017年4月10日 下午1:22:01
     */
    public HttpProxyResponse querySize(Long instanceId, Long diskId, Integer diskType) {
        HttpProxyResponse response = new HttpProxyResponse();
        String storagePath = diskType.intValue() == 0 ? configService.get("volume", "volumePoolMountPath") : configService.get("volume", "dataDiskMountPath"); // 镜像本地缓存目录
        TInstanceDisk diskw = new TInstanceDisk();
        diskw.setInstanceId(instanceId);
        diskw.setId(diskId);
        TInstanceDisk disk = diskDao.selectOne(diskw);
        //查询备份将要做增量还是
        TBackup backupWhere = new TBackup();
        backupWhere.setInstanceId(instanceId);
        backupWhere.setState(1);
        backupWhere.setCurrentNode(1);
        backupWhere.setDelete(false);
        backupWhere.setManualType(1);
        //diskType:系统盘：0，数据盘：1
        backupWhere.setContentType(diskType);
        TBackup backup = backupDao.selectOne(backupWhere);
        StringBuffer imagePath = new StringBuffer();
        imagePath.append(storagePath);
        imagePath.append("/");
        if (backup == null) {//要做全量大小：bs3pycnb4cn5_bs3pycrwk4jl.img*
            String[] split = disk.getName().split("-");
            imagePath.append(split[0]);
            imagePath.append("*");
        } else {
            //要做增量大小查询：bs3pycnb4cn5_bs3pycrwk4jl.img-1478832661
            imagePath.append(disk.getName());
        }
        Map<String, Object> hmap = new HashMap<String, Object>();
        hmap.put("vmName", imagePath.toString());
        THost host = hostService.selectByInstanceId(instanceId);
        //10.12.30.101   String BACKUP_QUERYBACKUP_SIZE = "backup/querySize";
        response = HttpConnectProxy.post(PropertiesZone.getServicePath(host.getIpAdmin()) + "/" + AgentApiDeclarations.BACKUP_QUERYBACKUP_SIZE, hmap);
        if (response.notSuccess()) {
            onHostResult(host);
        }
        return response;
    }

======================================================

host 项目：

package com.xinnet.agent.backup.app;

import java.util.HashMap;
import java.util.Map;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.RequestMapping;
import com.xinnet.agent.PropertiesUtils;
import com.xinnet.agent.backup.service.BackupService;
import com.xinnet.smart.base.PropertiesBase;
import com.xinnet.smart.base.enums.ContentTypeEnum;
import com.xinnet.smart.base.util.HttpConnectProxy;
import com.xinnet.smart.base.util.UJson;
import com.xinnet.smart.base.util.UTrace;
import com.xinnet.smart.dto.backup.BackupCreateB2C_DTO;
import com.xinnet.smart.dto.backup.BackupCreateC2B_DTO;
import com.xinnet.smart.vo.GenericDataResponse;
import com.xinnet.smart.vo.ISmartResponses;
import com.xinnet.smart.vo.URequest;
import com.xinnet.smart.vo.UResponse;

@RequestMapping("backup")
@Controller
public class BackUpController {
    static final Logger logger = LoggerFactory.getLogger(BackUpController.class);
    @Autowired
    private BackupService backupServiceImpl;

    /**
     * 创建备份,controller调用Agent
     * @param json
     */
    @RequestMapping("/create")
    public void create(HttpServletRequest request, HttpServletResponse response) {
        BackupCreateC2B_DTO dto = URequest.getObject(request, BackupCreateC2B_DTO.class);
        new Thread(new Runnable() {
            public void run() {
                GenericDataResponse<BackupCreateB2C_DTO> gd = backupServiceImpl.createBackup(dto);
                HttpConnectProxy.post(ContentTypeEnum.JSON, PropertiesUtils.controllerUrl + "api/backup/createAgentResult", UJson.toString(gd));
            }
        }).start();
        UResponse.json(PropertiesBase.SUCCESS, response);
    }

    @RequestMapping(value = "/querySize")
    public void querySize(String vmName, HttpServletResponse response) {
        GenericDataResponse gr = new GenericDataResponse();
        try {
            String size = backupServiceImpl.querySystemVolume(vmName);
            if (size != null) {
                Map<String, Long> map = new HashMap<String, Long>();
                map.put("size", Long.valueOf(size));
                gr.init(ISmartResponses.SUCCESS);
                gr.setData(UJson.toString(map));
                UResponse.json(gr, response);
            } else {
                gr.init(ISmartResponses.FAIL);
                gr.setData("查询镜像大小失败");
                UResponse.json(gr, response);
            }
        } catch (Throwable e) {
            logger.error(UTrace.trace(e));
            gr.setData(e.getMessage());
            UResponse.json(gr, response);
        }
    }
}

------------------------------------

/**
     * 查询大小
     * @author duanxia
     * @date 2017年3月10日 下午5:03:53
     */
    public String querySystemVolume(String imagePath) {
        String size = null;
        List<String> cmds = new ArrayList<String>();
        cmds.add("sh");
        cmds.add("-c");
        String str = "du -sk " + imagePath + " |awk '{sum+=$1}END{print sum}'";
        cmds.add(str);
        GenericShellResponse gsr = PropertiesAgent.AGENT_SHELL.runs(cmds);
        String result = gsr.getResult();
        size = result.substring(0, result.indexOf("\n")).trim();
        return size;
    }

------------------------------------------------

// 创建ProcessBuilder   开启进程   查看计算机底层数据

public final GenericShellResponse runs(final List<String> commands) {
        GenericShellResponse ret = new GenericShellResponse();
        Process process = null;
        try {
            ProcessBuilder pb = new ProcessBuilder(commands);
            if (direcotry != null) {
                pb.directory(direcotry);
                if (logger.isDebugEnabled() || logger.isInfoEnabled()) {
                    logger.info("shell direcotry---------->{}", direcotry);
                }
            }
            process = pb.start();
            ret.setCode(process.waitFor());
            ret.setResult(UStream.read(process.getInputStream(), Charsets.UTF_8));
            return ret;
        } catch (Throwable e) {
            ret.setErrorMessage(UTrace.trace(e));
            return ret;
        } finally {
            if (process != null) {
                try {
                    if (process.getInputStream() != null) {
                        process.getInputStream().close();
                    }
                    if (process.getOutputStream() != null) {
                        process.getOutputStream().close();
                    }
                    if (process.getErrorStream() != null) {
                        process.getErrorStream().close();
                    }
                } catch (IOException e) {
                    logger.error(UTrace.trace(e));
                }
                //process.destroy();
                process.destroyForcibly();
            }
            info(ret, commands);
        }
    }