catproxy/src/ws/receiveMsg.js

a node proxy or host change tools

import * as status from './status';
import log from '../log';
import * as config from '../config/config';
import * as rule from '../config/rule';
import * as sendType from './sendType';
import url from 'url';
import http from 'http';
import https from 'https';
import Promise from 'promise';
import { Buffer } from 'buffer';
import { sendConnDetail } from './sendMsg';
import { getCacheFile } from '../monitor/cacheFile';
import { decodeData, isBinary, betuifyCode, updateExt } from '../dataHelper';
/*
 *
 *  所有接受到得消息是一个Object
 *
 * data:{
 * 	path: "数据访问路径，相同type下的不同逻辑处理可以用不同的path",
 * 	param: "相同type下相同的path，不同的参数可以通过这个处理"
 * }
 *
 *
 * 所有发出的消息是一个Object
 *
 * data:{
 * 	//当前请求的状态，如果不是100表示出现错误了
 * 	status: 100,
 * 	result: {'当前返回的数据'}
 * }
 *
 */
export let error = msg => {
	msg = msg || '出现系统异常，请稍后再试';
	let data = {
		status: status.ERROR,
		result: msg,
	};
	log.error(msg);
	return data;
};

export let success = msg => {
	msg = msg || '成功';
	let data = {
		status: status.SUCC,
		result: msg,
	};
	return data;
};

/**
 * 请求数据，返回所有的数据
 * @return {[object]} [请求到得 config数据]
 */
export let fetchConfig = () => {
	let data = {
		status: status.SUCC,
	};
	try {
		data.result = config.get();
		if (data.result.cacheFlush === 'undefined') {
			data.result.cacheFlush = false;
		}
		if (data.result.disCache === 'undefined') {
			data.result.disCache = true;
		}
		if (!data.result.hosts) {
			data.result.hosts = [];
		}
		return data;
	} catch (e) {
		return error();
	}
};

let updateRule = (rules, ws) => {
	try {
		rule.saveRules(rules);
		return success('更新规则成功');
	} catch (e) {
		log.error(e);
		return error('更新规则失败');
	}
};
let disCache = (status, ws) => {
	try {
		config.set('disCache', status);
		config.save('disCache');
		return success('更新配置成功');
	} catch (e) {
		log.error(e);
		return error('更新配置失败');
	}
};
let cacheFlush = (status, ws) => {
	try {
		config.set('cacheFlush', status);
		config.save('cacheFlush');
		return success('更新配置成功');
	} catch (e) {
		log.error(e);
		return error('更新配置失败');
	}
};
let monitor = (monitor, ws) => {
	try {
		config.setRecursive('monitor', monitor);
		config.save('monitor');
		return success('更新配置成功');
	} catch (e) {
		log.error(e);
		return error('更新配置失败');
	}
};

export let getConDetail = (msg = { param: {} }, ws = {}) => {
	let {
		param: { id, ext, contentType, charset, formatCode },
	} = msg;
	if (id) {
		getCacheFile(id)
			.then(data => {
				// 不是2进制数据就解码数据
				return isBinary(data) ? data : decodeData(data, charset);
			})
			.then(function(data) {
				if (typeof data === 'string' && data) {
					ext = updateExt(ext, contentType, data);
				}
				return data;
			})
			.then(function(data) {
				if (typeof data === 'string' && formatCode) {
					return betuifyCode(data, ext);
				}
				data = data || '';
				return data;
			})
			.then(
				function(data) {
					data = data || '';
					sendConnDetail({
						id,
						data,
						ext,
					});
				},
				function(data) {
					data = data || '';
					sendConnDetail({
						id,
						data,
						ext,
					});
				}
			);
	}
};

export let saveConfig = (msg = {}, ws = {}) => {
	let { path, param } = msg;
	if (path) {
		switch (msg.path) {
			case 'rule':
				if (param && param.rules) {
					return updateRule(param.rules, ws);
				} else {
					return error('更新规则必须有rules属性');
				}
			case 'disCache':
				return disCache(!!param.status, ws);
			case 'cacheFlush':
				return cacheFlush(!!param.status, ws);
			case 'monitor':
				return monitor(param, ws);
			default:
				return error('未知的保存数据');
		}
	} else {
		return error('未知的保存数据');
	}
};

// 通过远程地址更新文档
export let remoteUpdateRule = (msg = {}, ws = {}) => {
	let { url: visUrl } = msg.param;
	return new Promise((resolve, reject) => {
		config.set('remoteRuleUrl', visUrl);
		visUrl = url.parse(visUrl);
		let req = (visUrl.protocol === 'http:' ? http : https).request(
			{
				hostname: visUrl.hostname,
				port: visUrl.port ? visUrl.port : visUrl.protocol === 'http:' ? 80 : 443,
				path: visUrl.path,
				method: 'GET',
				headers: {},
			},
			res => {
				if (+res.statusCode !== 200) {
					return reject(error('服务器获取数据错误'));
				}
				res.setEncoding('utf8');
				let data = [];

				res.on('data', chunk => {
					data.push(chunk);
				});
				res.on('end', () => {
					let isBuffer = Buffer.isBuffer(data[0]);
					let result = isBuffer ? Buffer.concat(data) : data.join('');
					try {
						result = JSON.parse(result);
						config.set('hosts', result);
						config.save(['hosts', 'remoteRuleUrl']);
						return resolve(
							success({
								data: result,
								msg: '更新数据成功',
							})
						);
					} catch (e) {
						log.error(e.message);
						return reject(error('数据格式错误'));
					}
				});
			}
		);
		req.on('error', e => {
			log.error(e.message);
			reject(error(e.message));
		});
		req.end();
	});
};