package com.cloud.device.service.impl;
|
|
import com.alibaba.fastjson.JSONArray;
|
import com.alibaba.fastjson.JSONObject;
|
import com.cloud.common.exception.ApplicationException;
|
import com.cloud.common.utils.RestTemplateUtil;
|
import com.cloud.common.utils.StringUtil;
|
import com.cloud.device.constants.Constants;
|
import com.cloud.device.dao.*;
|
import com.cloud.device.model.*;
|
import com.cloud.device.service.ClusterService;
|
import com.cloud.device.service.TokenService;
|
import com.cloud.device.vo.*;
|
import lombok.extern.log4j.Log4j;
|
import org.apache.commons.lang3.StringUtils;
|
import org.apache.tomcat.util.bcel.Const;
|
import org.springframework.beans.factory.annotation.Autowired;
|
import org.springframework.http.MediaType;
|
import org.springframework.stereotype.Service;
|
import org.springframework.transaction.annotation.Transactional;
|
import org.springframework.web.client.ResourceAccessException;
|
|
import java.awt.*;
|
import java.io.UnsupportedEncodingException;
|
import java.util.*;
|
import java.util.List;
|
import java.util.concurrent.atomic.AtomicBoolean;
|
import java.util.stream.Collectors;
|
|
@Log4j
|
@Service
|
public class ClusterServiceImpl implements ClusterService {
|
|
/*接口定义*/
|
|
/**
|
* 获取本地库接口
|
*/
|
public static final String HTTP_FIND_LOCAL_DATABASE = "findLocalDatabase";
|
|
/**
|
* 获取同步库接口
|
*/
|
public static final String HTTP_FIND_ALL_DATABASE = "findAllDatabase";
|
|
public static final String HTTP_VERIFY_CLUSTER_PWD = "verifyClusterPwd";
|
|
/**
|
* 获取同步库接口
|
*/
|
public static final String HTTP_SEARCH_NODE="searchNode";
|
|
/**
|
* 获取摄像机接口
|
*/
|
public static final String HTTP_CAMERA_SHOW = "cam_show";
|
|
public static final String HTTP_SEARCH_PORT = "11111";
|
|
/**
|
* 是否获取设备下数据库信息
|
*/
|
public static final String IS_CONTAINER_DB = "isContainerDb";
|
public static final String IS_CONTAINER_DB_YES = "1";
|
|
|
@Autowired
|
private ClusterDao clusterDao;
|
|
@Autowired
|
private TokenService tokenService;
|
|
@Autowired
|
private NodeDao nodeDao;
|
|
@Autowired
|
private DicDao dicDao;
|
|
@Autowired
|
private DeviceDao deviceDao;
|
@Autowired
|
private OrgDao orgDao;
|
|
@Override
|
public Cluster selectById(String id){
|
return clusterDao.selectById(id);
|
}
|
|
public boolean verifyClusterPwdByCServer(String address, String pwd){
|
String url;
|
if(address.split(":").length > 1)
|
url = "http://"+address+"/"+HTTP_VERIFY_CLUSTER_PWD;
|
else
|
url = "http://"+address+":"+HTTP_SEARCH_PORT+"/"+HTTP_VERIFY_CLUSTER_PWD;
|
|
JSONObject param = new JSONObject();
|
param.put("password", pwd);
|
try {
|
String result = RestTemplateUtil.post(url, param, MediaType.APPLICATION_JSON_UTF8, false);
|
if(StringUtils.isNotEmpty(result)){
|
JSONObject jsonResult = JSONObject.parseObject(result);
|
if(jsonResult.get("result") !=null && jsonResult.get("result") == "1")//表示集群密码正确
|
return true;
|
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
return false;
|
}
|
/**
|
* 删除集群信息
|
* @param id
|
* @param cookie
|
* @return
|
*/
|
public boolean deleteById(String id, String cookie){
|
Cluster cluster = clusterDao.selectById(id);
|
if(cluster !=null){
|
if(cookie.equals(cluster.getCookie())){
|
Integer status = clusterDao.deleteById(id);
|
if(status >0){
|
deviceDao.deleteByClusterId(id);
|
return true;
|
}
|
}
|
}
|
return false;
|
}
|
|
|
/**
|
* 保存Cluster
|
*
|
* @param
|
* @return
|
*/
|
@Override
|
@Transactional
|
public int save(String address, String cookie){
|
String cluster_ip_port = address+":"+HTTP_SEARCH_PORT;
|
log.info("添加集群时任一节点ip和端口:"+cluster_ip_port);
|
|
ClusterNodeVo clusterNodeVo = searchNode(cluster_ip_port);
|
if(clusterNodeVo !=null){
|
//判断集群是否已加入
|
Cluster clusterModel = clusterDao.selectById(clusterNodeVo.getCluster_id());
|
final String clusterId = clusterNodeVo.getCluster_id();
|
if(clusterModel == null){//集群不存在
|
log.info("集群不存在，新增集群信息");
|
clusterModel = new Cluster();
|
clusterModel.setId(clusterNodeVo.getCluster_id());
|
clusterModel.setName(clusterNodeVo.getCluster_name());
|
clusterModel.setCookie(cookie);
|
clusterModel.setAddress(cluster_ip_port);
|
// clusterModel.preInsert(tokenService.currentUser());
|
clusterModel.setRevJson("{}");
|
int saveStatus = clusterDao.saveSelective(clusterModel);
|
if(saveStatus>0){
|
//保存集群节点信息和节点下的摄像机信息
|
clusterNodeVo.getList().parallelStream().forEach(n->{
|
Node node = new Node();
|
node.setId(n.getUuid());
|
node.setNodeId(n.getNode_id());
|
node.setCreateTime(n.getCreate_time());
|
node.setDevId(n.getDev_id());
|
node.setDevName(n.getDev_name());
|
node.setNodeIp(n.getNode_ip());
|
node.setClusterId(clusterId);
|
Integer insertResult = nodeDao.insertSelective(node);//保存节点
|
|
if(insertResult > 0){
|
log.info("节点ip："+node.getNodeIp());
|
List<CameraVo> cameraList = searchCamera(node.getNodeIp());
|
if(cameraList !=null && cameraList.size()>0){
|
for (CameraVo cv : cameraList){//保存节点下摄像机
|
Device model = new Device();
|
model.setId(cv.getStr_cam_dev_id());//摄像机编码
|
model.setIp(cv.getStr_ip());
|
model.setPort(cv.getN_port());
|
model.setAddress(cv.getStr_addr());
|
model.setBrand(cv.getStr_brand());//品牌
|
model.setName(cv.getStr_name());
|
model.setUsername(cv.getStr_username());
|
model.setPassword(cv.getStr_password());
|
model.setRemarks(cv.getStr_reserved());
|
model.setType(Device.DEVICE_TYPE_CAMERA);
|
model.setNodeId(n.getUuid());
|
model.setDelFlag("0");
|
model.setStatus(0);
|
model.setCameraType(cv.getType());
|
deviceDao.insertSelective(model);//保存摄像机设备
|
}
|
}
|
}
|
});
|
return saveStatus;
|
}
|
}else{//如果集群已经存在
|
log.info("更新集群信息");
|
// clusterModel.preUpdate(tokenService.currentUser());
|
clusterModel.setName(clusterNodeVo.getCluster_name());
|
clusterModel.setDelFlag("0");
|
clusterModel.setCookie(cookie);
|
int updateStatus = clusterDao.updateByIdSelective(clusterModel);//更新集群信息
|
if(updateStatus > 0){
|
clusterNodeVo.getList().parallelStream().forEach(n->{
|
Node node = nodeDao.selectById(n.getUuid());
|
if(node == null){
|
node = new Node();
|
node.setId(n.getUuid());
|
node.setNodeId(n.getNode_id());
|
node.setCreateTime(n.getCreate_time());
|
node.setDevId(n.getDev_id());
|
node.setDevName(n.getDev_name());
|
node.setNodeIp(n.getNode_ip());
|
node.setClusterId(clusterId);
|
nodeDao.insertSelective(node);//保存节点
|
}else{
|
node.setId(n.getUuid());
|
node.setNodeId(n.getNode_id());
|
node.setCreateTime(n.getCreate_time());
|
node.setDevId(n.getDev_id());
|
node.setDevName(n.getDev_name());
|
node.setNodeIp(n.getNode_ip());
|
node.setClusterId(clusterId);
|
nodeDao.updateByIdSelective(node);
|
}
|
|
log.info("节点ip："+n.getNode_ip());
|
List<CameraVo> cameraList = searchCamera(n.getNode_ip());
|
if(cameraList !=null && cameraList.size()>0){
|
for (CameraVo cv : cameraList){//保存节点下摄像机
|
Device model = deviceDao.selectById(cv.getStr_cam_dev_id());
|
boolean isEdit = false;
|
if(model == null){
|
model = new Device();
|
}else{
|
isEdit = true;
|
}
|
model.setId(cv.getStr_cam_dev_id());//摄像机编码
|
model.setIp(cv.getStr_ip());
|
model.setPort(cv.getN_port());
|
model.setAddress(cv.getStr_addr());
|
model.setBrand(cv.getStr_brand());//品牌
|
model.setName(cv.getStr_name());
|
model.setUsername(cv.getStr_username());
|
model.setPassword(cv.getStr_password());
|
model.setRemarks(cv.getStr_reserved());
|
model.setType(Device.DEVICE_TYPE_CAMERA);
|
model.setNodeId(n.getUuid());
|
model.setDelFlag("0");
|
model.setCameraType(cv.getType());//0:本地摄像机,1:GB28181
|
if(!isEdit){
|
model.setStatus(0);
|
deviceDao.insert(model);//保存摄像机设备
|
}
|
else
|
deviceDao.updateById(model);
|
}
|
}
|
|
});
|
}
|
|
return updateStatus;
|
}
|
}
|
return 0;
|
}
|
|
|
@Override
|
public MenuTreeVo refreshCluster(String clusterIp,String type,String id){
|
MenuTreeVo result = new MenuTreeVo();
|
|
Map<String, Object> param = new HashMap<>();
|
param.put("type", Constants.DEVICE_TYPE);
|
Map<String,String> deviceTypes = dicDao.getByType(param).stream().collect(Collectors.toMap(Dic::getValue, Dic::getName));
|
|
|
List<MenuTreeVo> nodeMenus = new ArrayList<>();
|
List<MenuTreeVo> deviceMenus = new ArrayList<>();
|
|
Cluster newCluster = null;
|
if(type.equals(Constants.TYPE_CLUSTER)){//点击的是集群
|
newCluster = clusterDao.selectById(id);
|
result.setId(newCluster.getId());
|
result.setName(newCluster.getName());
|
|
nodeMenus = new ArrayList<>();
|
List<Node> nodes = nodeDao.findByClusterId(id);
|
if(nodes !=null && nodes.size()>0){
|
for(Node node : nodes){
|
|
MenuTreeVo nodeMenu = new MenuTreeVo();
|
nodeMenu.setId(node.getId());
|
nodeMenu.setName(node.getDevName());
|
nodeMenu.setIp(node.getNodeIp());
|
nodeMenu.setAddress(node.getAddress());
|
nodeMenu.setType(deviceTypes.get(Device.DEVICE_TYPE_IP));
|
nodeMenu.setPublicIp(node.getPublicIp());
|
nodeMenu.setPublicPort(node.getPublicPort());
|
List<Device> devices = deviceDao.findByNodeId(node.getId());
|
if(devices!=null && devices.size()>0){
|
for(Device device : devices){
|
MenuTreeVo deviceMenu = new MenuTreeVo();
|
deviceMenu.setId(device.getId());
|
deviceMenu.setName(device.getName());
|
deviceMenu.setIp(device.getIp());
|
deviceMenu.setAddress(device.getAddress());
|
deviceMenu.setType(deviceTypes.get(device.getType()));
|
deviceMenu.setPublicIp(node.getPublicIp());
|
deviceMenu.setPublicPort(node.getPublicPort());
|
deviceMenu.setOrgId(device.getOrgId());
|
if(device.getOrgId() !=null){
|
Org org = orgDao.selectById(device.getOrgId());
|
if(org !=null)
|
deviceMenu.setOrgName(org.getName());
|
}
|
deviceMenus.add(deviceMenu);
|
}
|
}
|
nodeMenu.setChild(deviceMenus);
|
nodeMenus.add(nodeMenu);
|
}
|
}
|
result.setChild(nodeMenus);
|
}else if(type.equals(Constants.TYPE_NODE)){//点击的是节点
|
Node node = nodeDao.selectById(id);
|
newCluster = clusterDao.selectById(node.getClusterId());
|
|
MenuTreeVo nodeMenu = new MenuTreeVo();
|
nodeMenu.setId(node.getId());
|
nodeMenu.setName(node.getDevName());
|
nodeMenu.setIp(node.getNodeIp());
|
nodeMenu.setAddress(node.getAddress());
|
nodeMenu.setType(deviceTypes.get(Device.DEVICE_TYPE_IP));
|
nodeMenu.setPublicIp(node.getPublicIp());
|
nodeMenu.setPublicPort(node.getPublicPort());
|
List<Device> devices = deviceDao.findByNodeId(node.getId());
|
if(devices!=null && devices.size()>0){
|
for(Device device : devices){
|
MenuTreeVo deviceMenu = new MenuTreeVo();
|
deviceMenu.setId(device.getId());
|
deviceMenu.setName(device.getName());
|
deviceMenu.setIp(device.getIp());
|
deviceMenu.setAddress(device.getAddress());
|
deviceMenu.setType(deviceTypes.get(device.getType()));
|
deviceMenu.setPublicIp(node.getPublicIp());
|
deviceMenu.setPublicPort(node.getPublicPort());
|
deviceMenu.setOrgId(device.getOrgId());
|
if(device.getOrgId() !=null){
|
Org org = orgDao.selectById(device.getOrgId());
|
if(org !=null)
|
deviceMenu.setOrgName(org.getName());
|
}
|
deviceMenus.add(deviceMenu);
|
}
|
}
|
nodeMenu.setChild(deviceMenus);
|
nodeMenus.add(nodeMenu);
|
|
}else if(type.equals(Constants.TYPE_DEVICE)){//点击的是设备
|
Device device = deviceDao.selectById(id);
|
Node node = nodeDao.selectById(device.getNodeId());
|
newCluster = clusterDao.selectById(node.getClusterId());
|
// List<Device> devices = deviceDao.findByNodeId(device.getNodeId());
|
List<MenuTreeVo> newList = new ArrayList<>();
|
MenuTreeVo nodeMenu = new MenuTreeVo();
|
nodeMenu.setId(node.getId());
|
nodeMenu.setName(node.getDevName());
|
nodeMenu.setIp(node.getNodeIp());
|
nodeMenu.setAddress(node.getAddress());
|
nodeMenu.setType(deviceTypes.get(Device.DEVICE_TYPE_IP));
|
nodeMenu.setPublicIp(node.getPublicIp());
|
nodeMenu.setPublicPort(node.getPublicPort());
|
|
MenuTreeVo deviceMenu = new MenuTreeVo();
|
deviceMenu.setId(device.getId());
|
deviceMenu.setName(device.getName());
|
deviceMenu.setIp(device.getIp());
|
deviceMenu.setAddress(device.getAddress());
|
deviceMenu.setType(deviceTypes.get(device.getType()));
|
deviceMenu.setPublicIp(node.getPublicIp());
|
deviceMenu.setPublicPort(node.getPublicPort());
|
deviceMenu.setOrgId(device.getOrgId());
|
if(device.getOrgId() !=null){
|
Org org = orgDao.selectById(device.getOrgId());
|
if(org !=null)
|
deviceMenu.setOrgName(org.getName());
|
}
|
newList.add(deviceMenu);
|
|
//点击设备的时候 只显示这个设备
|
/*for(Device d : devices){
|
if(!d.getId().equals(id)){
|
deviceMenu = new MenuTreeVo();
|
deviceMenu.setId(d.getId());
|
deviceMenu.setName(d.getName());
|
deviceMenu.setIp(d.getIp());
|
deviceMenu.setAddress(d.getAddress());
|
deviceMenu.setType(deviceTypes.get(d.getType()));
|
deviceMenu.setPublicIp(node.getPublicIp());
|
deviceMenu.setPublicPort(node.getPublicPort());
|
newList.add(deviceMenu);
|
}
|
}*/
|
|
nodeMenu.setChild(newList);
|
nodeMenus.add(nodeMenu);
|
|
}
|
|
result.setId(newCluster.getId());
|
result.setName(newCluster.getName());
|
result.setChild(nodeMenus);
|
|
return result;
|
}
|
|
public List<MenuTreeVo> getAllClusterMenuInfo(String condition){
|
List<MenuTreeVo> list = new ArrayList<>();
|
|
/**
|
* condition是IP地址或设备名称或设备地址模糊搜索
|
*/
|
|
Map<String, Object> param = new HashMap<>();
|
param.put("type", Constants.DEVICE_TYPE);
|
Map<String,String> deviceTypes = dicDao.getByType(param).stream().collect(Collectors.toMap(Dic::getValue, Dic::getName));
|
|
// List<Cluster> clusters = clusterDao.findClusterByParam(null);
|
// if(clusters !=null && clusters.size()>0){
|
// for(Cluster cluster : clusters){
|
// MenuTreeVo clusterMenu = new MenuTreeVo();
|
// clusterMenu.setId(cluster.getId());
|
// clusterMenu.setName(cluster.getName());
|
// clusterMenu.setType("");
|
// clusterMenu.setIp(cluster.getAddress());
|
// clusterMenu.setAddress("");
|
//
|
// List<MenuTreeVo> nodeList = new ArrayList<>();
|
// List<Node> nodes = nodeDao.findByClusterId(cluster.getId());
|
// if(nodes !=null && nodes.size()>0){
|
// for(Node node:nodes){
|
// MenuTreeVo nodeMenu = new MenuTreeVo();
|
// nodeMenu.setId(node.getId());
|
// nodeMenu.setName(node.getDevName());
|
// nodeMenu.setIp(node.getNodeIp());
|
// nodeMenu.setAddress(node.getAddress());
|
// nodeMenu.setType(deviceTypes.get(Device.DEVICE_TYPE_IP));
|
// nodeMenu.setPublicIp(node.getPublicIp());
|
// nodeMenu.setPublicPort(node.getPublicPort());
|
//
|
// List<MenuTreeVo> deviceList = new ArrayList<>();
|
// List<Device> devices = deviceDao.findByNodeId(node.getId());
|
// for(Device device : devices){
|
// MenuTreeVo deviceMenu = new MenuTreeVo();
|
// deviceMenu.setId(device.getId());
|
// deviceMenu.setName(device.getName());
|
// deviceMenu.setIp(device.getIp());
|
// deviceMenu.setAddress(device.getAddress());
|
// deviceMenu.setType(deviceTypes.get(device.getType()));
|
// deviceMenu.setPublicIp(node.getPublicIp());
|
// deviceMenu.setPublicPort(node.getPublicPort());
|
// deviceMenu.setOrgId(device.getOrgId());
|
// if(device.getOrgId() !=null){
|
// Org org = orgDao.selectById(device.getOrgId());
|
// if(org !=null)
|
// deviceMenu.setOrgName(org.getName());
|
// }
|
// deviceList.add(deviceMenu);
|
// }
|
// nodeMenu.setChild(deviceList);
|
// nodeList.add(nodeMenu);
|
// }
|
// }
|
// clusterMenu.setChild(nodeList);
|
// list.add(clusterMenu);
|
// }
|
// }
|
Map devParam = new HashMap();
|
devParam.put("condition",condition);
|
List<Device> deviceList = deviceDao.findAllClusterDevice(devParam);//查找符合条件的摄像机信息
|
if(deviceList !=null && deviceList.size() >0){
|
Map<String, Node> nodeMap = new HashMap<>();
|
Map<String, Cluster> clusterMap = new HashMap<>();
|
for(Device device : deviceList){
|
String nodeId = device.getNodeId();
|
if(!nodeMap.containsKey(nodeId)){
|
Node node = nodeDao.selectById(nodeId);
|
if(node !=null){
|
nodeMap.put(nodeId, node);
|
if(!clusterMap.containsKey(node.getClusterId())){
|
clusterMap.put(node.getClusterId(), clusterDao.selectById(node.getClusterId()));
|
}
|
}
|
}
|
}
|
|
for(Map.Entry<String, Cluster> entry : clusterMap.entrySet()){
|
Cluster cluster = entry.getValue();
|
MenuTreeVo clusterMenu = new MenuTreeVo();
|
clusterMenu.setId(cluster.getId());
|
clusterMenu.setName(cluster.getName());
|
clusterMenu.setType("");
|
clusterMenu.setIp(cluster.getAddress());
|
clusterMenu.setAddress("");
|
List<MenuTreeVo> nodeMenus = new ArrayList<>();
|
for(Map.Entry<String, Node> nodeEntry : nodeMap.entrySet()){
|
Node node = nodeEntry.getValue();
|
if(node.getClusterId().equals(cluster.getId())){
|
MenuTreeVo nodeMenu = new MenuTreeVo();
|
nodeMenu.setId(node.getId());
|
nodeMenu.setName(node.getDevName());
|
nodeMenu.setIp(node.getNodeIp());
|
nodeMenu.setAddress(node.getAddress());
|
nodeMenu.setType(deviceTypes.get(Device.DEVICE_TYPE_IP));
|
nodeMenu.setPublicIp(node.getPublicIp());
|
nodeMenu.setPublicPort(node.getPublicPort());
|
List<MenuTreeVo> deviceMenus = new ArrayList<>();
|
for(Device device : deviceList){
|
if(device.getNodeId().equals(node.getId())){
|
MenuTreeVo deviceMenu = new MenuTreeVo();
|
deviceMenu.setId(device.getId());
|
deviceMenu.setName(device.getName());
|
deviceMenu.setIp(device.getIp());
|
deviceMenu.setAddress(device.getAddress());
|
deviceMenu.setType(deviceTypes.get(device.getType()));
|
deviceMenu.setPublicIp(node.getPublicIp());
|
deviceMenu.setPublicPort(node.getPublicPort());
|
deviceMenu.setOrgId(device.getOrgId());
|
if(device.getOrgId() !=null){
|
Org org = orgDao.selectById(device.getOrgId());
|
if(org !=null)
|
deviceMenu.setOrgName(org.getName());
|
}
|
deviceMenus.add(deviceMenu);
|
}
|
}
|
nodeMenu.setChild(deviceMenus);
|
nodeMenus.add(nodeMenu);
|
}
|
}
|
clusterMenu.setChild(nodeMenus);
|
|
list.add(clusterMenu);
|
}
|
}
|
|
return list;
|
}
|
|
|
public List<Cluster> findAllClusterList(){
|
List<Cluster> clusters = clusterDao.findClusterByParam(null);
|
if(clusters !=null && clusters.size()>0){
|
for(Cluster cluster : clusters){
|
List<Node> nodes = nodeDao.findByClusterId(cluster.getId());
|
if(nodes !=null && nodes.size()>0){
|
for(Node node:nodes){
|
List<Device> devices = deviceDao.findByNodeId(node.getId());
|
node.setDevices(devices);
|
}
|
}
|
cluster.setNodes(nodes);
|
}
|
}
|
|
return clusters;
|
}
|
|
/**
|
* 获取数据库中集群
|
* @param params
|
* @return
|
*/
|
@Override
|
public List<Cluster> findClusters(Map<String, Object> params){
|
return clusterDao.findClusterByParam(params);
|
}
|
|
/**
|
* 通过集群ids获取集群信息
|
* @param ids
|
* @return
|
*/
|
public List<Cluster> findClusterByIds(List<String> ids){
|
return clusterDao.findClusterByIds(ids);
|
}
|
|
/**
|
* 获取集群及节点信息，isContainerDb=1，表示需要获取节点下的数据库信息
|
* @param params
|
* @return
|
*/
|
@Override
|
public List<Cluster> findAllNode(Map<String, Object> params) {
|
/**
|
* 1. 获取集群信息
|
* 2. 获取集群中的同步库
|
* 3. 获取节点
|
*/
|
boolean isContainerDb = false;
|
if(params !=null
|
&& params.get(IS_CONTAINER_DB) !=null
|
&& IS_CONTAINER_DB_YES.equals(params.get(IS_CONTAINER_DB))){
|
isContainerDb =true;
|
}
|
List<Cluster> list= clusterDao.findClusterByParam(params);
|
|
boolean finalIsContainerDb = isContainerDb;
|
list.parallelStream().forEach(e -> {
|
//if(finalIsContainerDb) {//是否获取同步库信息
|
try {
|
e.setSyncDbs(getSyncDatabases(getSyncDataUrl(e.getAddress())));
|
} catch (ResourceAccessException ex) {
|
log.error("集群获取同步库失败");
|
ex.printStackTrace();
|
}
|
//}
|
try {
|
//获取节点信息,不获取本地库信息
|
e.setNodes(findNodes(e.getAddress(), finalIsContainerDb));
|
}catch (ResourceAccessException ex){
|
log.error("集群获取节点失败");
|
ex.printStackTrace();
|
}
|
}
|
|
);
|
return list;
|
}
|
|
/**
|
* 根据节点查询节点信息及所属集群信息(有可能一个节点属于多个集群)
|
*
|
* @param nodeIds
|
* @return
|
*/
|
@Override
|
public List<ClusterNodeVo> findNodesByIds(String nodeIds) {
|
/**
|
* 1. 遍历nodeIds，查询所属集群
|
* 2. 调用接口查询节点详细信息
|
* 3. 拼装VO
|
*/
|
if(StringUtils.isEmpty(nodeIds)){
|
throw new ApplicationException("节点Id不能为空");
|
}
|
|
return getNodeCluster(nodeIds);
|
}
|
|
|
/**
|
* 通过集群地址，获取集群信息和节点信息
|
* @param address
|
* @return
|
*/
|
@Override
|
public List<ClusterNodeVo> findByCLuster(String address) {
|
return null;
|
}
|
|
|
/**
|
* 根据多个集群ids来获取集群及节点信息
|
* @param clusterIds
|
* @return
|
*/
|
@Override
|
public List<Map> findClusterNodesByClusterIds(String clusterIds) {
|
List<Map> list = new ArrayList<>();
|
String[] arrIds = clusterIds.split(",");
|
if(arrIds !=null && arrIds.length>0){
|
List<Cluster> clusters = clusterDao.findClusterByIds(Arrays.asList(arrIds));
|
if(clusters !=null && clusters.size()>0){
|
clusters.parallelStream().forEach(e->{
|
if(StringUtils.isNotEmpty(e.getAddress())){
|
Map<String,Object> map = new HashMap();
|
ClusterNodeVo clusterNodeVo = searchNode(e.getAddress());
|
log.info("clusterNodeVo:"+clusterNodeVo);
|
if(clusterNodeVo !=null){
|
map.put("cluster_id",clusterNodeVo.getCluster_id());
|
map.put("cluster_name",clusterNodeVo.getCluster_name());
|
map.put("list",clusterNodeVo.getList());
|
}
|
|
list.add(map);
|
}
|
});
|
}
|
|
return list;
|
}
|
return null;
|
}
|
|
/**
|
* 将人员分享到 集群节点
|
*
|
* @param sharePersonParamVo
|
* @return
|
*/
|
@Override
|
public List<String> sharePersonToCluster(SharePersonParamVo sharePersonParamVo) {
|
/**
|
* 1. 循环调用节点接口
|
* 1）获得接口地址
|
* 2）传递参数 personIds 和 DB Ids
|
*
|
* 2. 记录接口的返回值，将共享失败的数据，返回前台
|
*/
|
|
return null;
|
}
|
|
@Override
|
public ClusterNodeVo findClusteInfoByNodeIp(Map<String, Object> params) {
|
String url = params.get("nodeIp").toString()+":"+ HTTP_SEARCH_PORT;
|
return searchNode(url);
|
}
|
|
@Override
|
public List<MenuTreeVo> getClusterDeviceTree() {
|
List<MenuTreeVo> list = new ArrayList<>();
|
List<Cluster> clusters = clusterDao.findClusterByParam(null);
|
if(clusters !=null && clusters.size() > 0){
|
for(Cluster cluster : clusters){
|
MenuTreeVo clusterMenu = new MenuTreeVo();
|
clusterMenu.setId(cluster.getId());
|
clusterMenu.setName(cluster.getName());
|
if(StringUtils.isNotEmpty(cluster.getAddress())){
|
String[] ipAddr = cluster.getAddress().split(":");
|
if(ipAddr !=null && ipAddr.length == 2){
|
clusterMenu.setIp(ipAddr[0]);
|
}
|
}
|
clusterMenu.setType(Constants.TYPE_CLUSTER);
|
List<MenuTreeVo> nodeList = new ArrayList<>();
|
|
List<Node> nodes = nodeDao.findByClusterId(cluster.getId());
|
if(nodes !=null && nodes.size() > 0){
|
for(Node node : nodes){
|
MenuTreeVo nodeMenu = new MenuTreeVo();
|
nodeMenu.setId(node.getId());
|
nodeMenu.setName(node.getDevName());
|
nodeMenu.setType(Constants.TYPE_NODE);
|
nodeMenu.setIp(node.getNodeIp());
|
nodeMenu.setParentId(cluster.getId());//父id
|
List<Device> devices = deviceDao.findByNodeId(node.getId());
|
List<MenuTreeVo> deviceList = new ArrayList<>();
|
if(devices !=null && devices.size() > 0){
|
for(Device device : devices){
|
MenuTreeVo deviceMenu = new MenuTreeVo();
|
deviceMenu.setId(device.getId());
|
deviceMenu.setName(device.getName());
|
deviceMenu.setType(Constants.TYPE_DEVICE);
|
deviceMenu.setStatus(Constants.DEVICE_STATUS_OK);
|
deviceMenu.setParentId(node.getId());
|
if(StringUtils.isNotEmpty(device.getLongitude()) && StringUtils.isNotEmpty(device.getLatitude())){
|
deviceMenu.setIsOnMap(1);//已定位到地图
|
deviceMenu.setLongitude(device.getLongitude());
|
deviceMenu.setLatitude(device.getLatitude());
|
}
|
else
|
deviceMenu.setIsOnMap(0);//未定位到地图
|
deviceList.add(deviceMenu);
|
}
|
}
|
nodeMenu.setChild(deviceList);
|
nodeList.add(nodeMenu);
|
}
|
}
|
clusterMenu.setChild(nodeList);
|
list.add(clusterMenu);
|
}
|
}
|
|
return list;
|
}
|
|
/**
|
* 获取节点所属的集群信息(可能节点属于多个集群)
|
* @param nodeIds 节点列表
|
* @return
|
*/
|
private List<ClusterNodeVo> getNodeCluster(String nodeIds){
|
List<ClusterNodeVo> clusterNodeVos=new ArrayList<>();
|
|
List<Cluster> clusters = findAllNode(null);
|
String[] ids = nodeIds.split(",");
|
for(String nodeId:ids){
|
for(Cluster c : clusters){
|
List<Node> nodes =c.getNodes();
|
AtomicBoolean isGet = new AtomicBoolean(false);
|
for(Node node : nodes){
|
if(nodeId.equals(node.getId())){//表示找到节点所属的集群
|
ClusterNodeVo clusterNodeVo = new ClusterNodeVo();
|
clusterNodeVo.setCluster_id(c.getId().toString());
|
clusterNodeVo.setCluster_name(c.getName());
|
|
clusterNodeVos.add(clusterNodeVo);
|
isGet.set(true);
|
break;
|
}
|
}
|
if(isGet.get()){
|
break;
|
}
|
|
}
|
}
|
return clusterNodeVos;
|
}
|
|
/**
|
* 节点本地库地址
|
* @param nodeId
|
* @param port
|
* @return
|
*/
|
private String getLocalDataUrl(String nodeId,String port){
|
return "http://"+nodeId.substring(nodeId.indexOf("@")+1,nodeId.length())+":"+port+"/"+HTTP_FIND_LOCAL_DATABASE;
|
}
|
|
/**
|
* 同步库地址
|
* @param url
|
* @return
|
*/
|
private String getSyncDataUrl(String url){
|
return "http://"+url+"/"+HTTP_FIND_ALL_DATABASE;
|
}
|
|
/**
|
* 节点接口地址
|
* @param url
|
* @return
|
*/
|
private String getNodeUrl(String url){
|
return "http://"+url+"/"+HTTP_SEARCH_NODE;
|
}
|
|
/**
|
* 获取摄像机地址
|
* @param url
|
* @return
|
*/
|
private String getCameraUrl(String url){
|
return "http://"+ url + ":" + HTTP_SEARCH_PORT + "/" + HTTP_CAMERA_SHOW;
|
}
|
|
/**
|
* 获取端口号
|
* @param url
|
* @return
|
*/
|
private String getPort(String url){
|
return url.substring(url.lastIndexOf(":")+1,url.length());
|
}
|
|
/**
|
* 获取所有集群信息和节点信息
|
* @return
|
*/
|
@Override
|
public List<Map> getAllCluListData(){
|
List<Map> list = new ArrayList<>();
|
List<Cluster> clusters = clusterDao.findClusterByParam(null);
|
clusters.parallelStream().forEach(e->{
|
Map<String,Object> map = new HashMap<>();
|
ClusterNodeVo clusterNodeVo = searchNode(e.getAddress());
|
log.info("clusterNodeVo:"+clusterNodeVo);
|
if(clusterNodeVo !=null){
|
map.put("cluster_id",clusterNodeVo.getCluster_id());
|
map.put("cluster_name",clusterNodeVo.getCluster_name());
|
map.put("list",clusterNodeVo.getList());
|
}
|
|
list.add(map);
|
});
|
|
return list;
|
}
|
|
|
public Map getClusterTreeData(){
|
Map<String,Object> selectAll = new HashMap();
|
selectAll.put("parentId","0");
|
selectAll.put("id","-1");
|
selectAll.put("label","全选");
|
|
List<Map> list = new ArrayList<>();
|
List<Cluster> clusters = clusterDao.findClusterByParam(null);
|
clusters.parallelStream().forEach(e-> {
|
Map<String, Object> map = new HashMap<>();
|
ClusterNodeVo clusterNodeVo = searchNode(e.getAddress());
|
if(clusterNodeVo !=null){
|
map.put("parentId","-1");
|
map.put("id",clusterNodeVo.getCluster_id());
|
map.put("label",clusterNodeVo.getCluster_name());
|
if(clusterNodeVo.getList() !=null && clusterNodeVo.getList().size()>0){
|
List<Map> nodeChildren = new ArrayList<>();
|
Map node;
|
for(NodeVo nodeVo : clusterNodeVo.getList()){
|
node = new HashMap();
|
node.put("parentId",clusterNodeVo.getCluster_id());
|
node.put("id",nodeVo.getNode_id());
|
node.put("label",nodeVo.getDev_name());
|
nodeChildren.add(node);
|
}
|
|
map.put("children", nodeChildren);
|
}
|
list.add(map);
|
}
|
});
|
selectAll.put("children",list);
|
return selectAll;
|
}
|
|
/**
|
* 获取集群节点及底库信息
|
* @return
|
*/
|
@Override
|
public List<Map> getAllCluDataBaseList() {
|
List<Map> list = new ArrayList<>();
|
List<Cluster> clusters = clusterDao.findClusterByParam(null);//查询所有集群
|
clusters.parallelStream().forEach(e->{
|
Map map = new HashMap();
|
ClusterNodeVo clusterNodeVo = searchNode(e.getAddress());
|
if(clusterNodeVo !=null){
|
map.put("cluster_id",clusterNodeVo.getCluster_id());//集群id
|
map.put("cluster_name",clusterNodeVo.getCluster_name());//集群名称
|
List<Map> nodeIPList = new ArrayList<>();
|
for (NodeVo nodeVo : clusterNodeVo.getList()) {
|
Map nodeMap = new HashMap();
|
nodeMap.put("uuid",nodeVo.getUuid());
|
nodeMap.put("node_ip",nodeVo.getNode_ip());
|
nodeIPList.add(nodeMap);
|
}
|
map.put("cluIPList", nodeIPList);//集群节点ip列表
|
map.put("syncDataBase", getSyncDatabases(getSyncDataUrl(e.getAddress())));//集群中的同步库
|
}
|
list.add(map);
|
});
|
return list;
|
}
|
|
/**
|
* 通过集群address获取集群信息和所有节点信息
|
* @param url
|
* @return
|
*/
|
private ClusterNodeVo searchNode(String url){
|
try {
|
log.info("searchNode url:"+url);
|
String result = RestTemplateUtil.post(getNodeUrl(url), new JSONObject(), MediaType.APPLICATION_JSON_UTF8, String.class, false);
|
if(StringUtils.isNotEmpty(result)){
|
String all = new String(result.getBytes("ISO-8859-1"),"utf-8");
|
return JSONObject.parseObject(all, ClusterNodeVo.class);
|
}
|
|
} catch (UnsupportedEncodingException e) {
|
e.printStackTrace();
|
}
|
return null;
|
}
|
|
/**
|
* 获取集群节点列表
|
* @param url
|
* @param isContainerDb 是否获取节点本地库列表
|
* @return
|
*/
|
private List<Node> findNodes(String url , boolean isContainerDb){
|
List<Node> nodeList = new ArrayList<>();
|
|
ClusterNodeVo clusterNodeVo = searchNode(url);
|
|
if(clusterNodeVo != null && clusterNodeVo.getList()!=null && clusterNodeVo.getList().size()>0){
|
List<NodeVo> list = clusterNodeVo.getList();
|
|
list.parallelStream().forEach(e -> {
|
Node node = new Node();
|
node.setId(e.getUuid());
|
node.setAddress("");
|
node.setNodeIp(e.getNode_ip());
|
node.setNodeId(e.getNode_id());
|
node.setDevId(e.getDev_id());
|
node.setDevName(e.getDev_name());
|
|
//获取节点下的设备信息
|
node.setDevices(deviceDao.findByNodeId(e.getUuid()));
|
if(isContainerDb) {
|
try {
|
node.setLocalDates(findLocalDataBases(getLocalDataUrl(e.getNode_id(), getPort(url))));
|
} catch (ResourceAccessException ex) {
|
log.error("节点获取本地库失败");
|
ex.printStackTrace();
|
}
|
}
|
nodeList.add(node);
|
});
|
}
|
|
return nodeList;
|
}
|
|
/**
|
* 获取本地库列表
|
* @param url
|
* @return
|
*/
|
private List<Database> findLocalDataBases(String url){
|
JSONObject a = new JSONObject();
|
String all= null;
|
try {
|
all = new String( RestTemplateUtil.post(url, a, MediaType.APPLICATION_JSON_UTF8, String.class, false).getBytes("ISO-8859-1"),"utf-8");
|
} catch (UnsupportedEncodingException e) {
|
e.printStackTrace();
|
}
|
List<Database> list = JSONObject.parseArray(all, Database.class);
|
|
return list;
|
}
|
|
/**
|
* 同步库列表
|
* @param url
|
* @return
|
*/
|
private List<Database> getSyncDatabases(String url){
|
String all= null;
|
try {
|
|
all = new String(RestTemplateUtil.post(url, new JSONObject(), MediaType.APPLICATION_JSON_UTF8, String.class, false).getBytes("ISO-8859-1"),"utf-8");
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
List<Database> list = JSONObject.parseArray(all, Database.class);
|
return list;
|
}
|
|
private List<CameraVo> searchCamera(String url){
|
try {
|
log.info("CameraShow url:"+url);
|
String result = RestTemplateUtil.post(getCameraUrl(url), new JSONObject(), MediaType.APPLICATION_JSON_UTF8, String.class, false);
|
if(StringUtils.isNotEmpty(result)){
|
String all = new String(result.getBytes("ISO-8859-1"),"utf-8");
|
return JSONArray.parseArray(all, CameraVo.class);
|
}
|
} catch (UnsupportedEncodingException e) {
|
e.printStackTrace();
|
}
|
|
return null;
|
}
|
|
|
|
}
|
