facelog (人脸验证日志系统)开发手册

// 创建 faceLog 服务同步实例
IFaceLogClient facelogClient = ClientFactory.builder()
								.setHostAndPort("127.0.0.1", DEFAULT_PORT) // 指定服务的主机地址和端口号
								.build(IFaceLogThriftClient.class, IFaceLogClient.class); // 创建实例(同步)
// 创建 faceLog 服务异步实例
IFaceLogClientAsync facelogClientAsync = ClientFactory.builder()
								.setHostAndPort("127.0.0.1", DEFAULT_PORT) // 指定服务的主机地址和端口号
								.buildAsync(IFaceLogThriftClient.class,IFaceLogClientAsync.class); // 创建实例(异步)

net.gdface.facelog.client.IFaceLogClient.isValidPassword

// 安全异常分类
public static enum SecurityExceptionType{
    /** 其他未分类异常 */UNCLASSIFIED,
    /** 无效MAC地址 */INVALID_MAC,
    /** 无效序列号 */INVALID_SN,
    /** 序列号被占用 */OCCUPIED_SN,
    /** 无效的设备令牌 */INVALID_TOKEN,
    /** 无效设备ID */INVALID_DEVICE_ID,
    /** 无效人员ID */INVALID_PERSON_ID,
    /** 无效root密码 */INVALID_PASSWORD,
    /** 拒绝令牌申请 */REJECT_APPLY
}

	IFaceLogClient facelogClient = ClientFactory.builder()
			.setHostAndPort("127.0.0.1", DEFAULT_PORT)
			.setDecorator(RefreshTokenDecorator.makeDecoratorFunction(new TokenHelperTestImpl()))
			.build(IFaceLogThriftClient.class, IFaceLogClient.class);
	// TokenHelperTestImpl为TokenHelper的子类，用于向RefreshTokenDecorator提供申请令牌的相关参数
	// setDecorator方法则将实现令牌自动刷新机制机制的代理接口类实例(Proxy instance)加载到服务接口实例上

@Test
public void test4RegisterDevice(){
	// 获取当前设备的MAC地址(假设只有一块网卡)
	byte[] address = NetworkUtil.getPhysicalNICs().iterator().next().getHardwareAddress();
	try {
		// 根据MAC地址和设备序列号构造一个DeviceBean数据对象
		DeviceBean device = DeviceBean.builder()
				.mac(NetworkUtil.formatMac(address, null)) // 设备当前设备MAC地址
				.serialNo("12322333") // 设置设备序列号
				.build();
		logger.info(device.toString(true,false));
		// 设备注册
		device = facelogClient.registerDevice(device);
		// 申请设备令牌
		Token deviceToken = facelogClient.online(device);
		// .....

		// 应用结束时通知facelog servcie设备下线，释放设备令牌
		facelogClient.offline(deviceToken);

		// 设备注销，设备从 facelog系统删除时调用
		facelogClient.unregisterDevice(device.getId(), deviceToken);
	} catch(ServiceRuntimeException e){
		e.printServiceStackTrace();
		assertTrue(e.getMessage(),false);
	}catch (ServiceSecurityException e) {
		logger.error(e.getMessage());
		assertTrue(e.getServiceStackTraceMessage(),false);
	}
}

/**
 * 从facelog获取消息系统参数，初始化消息系统的默认实例<br>
 * 该方法只能在应用启动时调用一次
 * @param token
 */
public void initMQDefaultFactory(Token token){
	Map<MQParam, String> mqParam = getMessageQueueParameters(token);
	MessageQueueFactorys.getFactory(mqParam.get(MQParam.MQ_TYPE))
		.init(mqParam.get(MQParam.MQ_CONNECT))
		.asDefaultFactory();/* 设置为IMessageQueueFactory默认实例 */
}

IMessageQueueFactory mqFactory = MessageQueueFactorys.getDefaultFactory();
/** 消息订阅实例 */
ISubscriber sub = mqFactory.getSubscriber();
/** 消息发布实例 */
IPublisher pub = mqFactory.getPublisher();

@Test
public void test() throws InterruptedException {
	IMessageQueueFactory factory = MessageQueueFactorys.getDefaultFactory();
	IPublisher publisher = factory.getPublisher();
	Channel<String> c1 = new Channel<String>("chat1"){};
	Channel<String> c2 = new Channel<String>("chat2"){};
	for(int i=0;i<100;++i){
		Date date = new Date();
		publisher.publish(c1, "MQTT " + date.toString());
		publisher.publish(c2, "MQTT " + date.toString());
		logger.info(date.getTime() +" : " +date.toString());
		Thread.sleep(2000);
	}
	factory.close();
}

@Test
public void testSubscriber(){
	IMessageQueueFactory factory = MessageQueueFactorys.getDefaultFactory();
	/** 消息订阅实例 */
	ISubscriber sub = factory.getSubscriber();
	// 频道名 'list1'
	Channel<String> list1 = new Channel<String>("list1",String.class,new IMessageAdapter<String>(){

		@Override
		public void onSubscribe(String t) throws SmqUnsubscribeException {
			logger.info("{}:{}","list1",t);
		}} );
	// 订阅消息，用IMessageAdapter实例显示消息
	consumer.register(list1);
	// 取消订阅
	consumer.unregister(list1);
}

public class PersonInsertAdapterTest implements CommonConstant {	
	@Test
	public void test() {		
		final IFaceLogClient serviceClient = ClientFactory.builder().setHostAndPort("127.0.0.1", DEFAULT_PORT).build(IFaceLogThriftClient.class, IFaceLogClient.class);
		new SubAdapters.BasePersonInsertSubAdapter(){
			@Override
			public void onSubscribe(Integer id) throws SmqUnsubscribeException {
				logger.info("insert person ID:{}",id);
				logger.info("new recored {}",serviceClient.getPerson(id).toString(true, false));
			}			
		}.register(MessageQueueFactorys.getDefaultFactory().getSubscriber());// 频道订阅
	}
}

/**
 * 心跳包测试
 * @author guyadong
 *
 */
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class HeartbeatTest implements ChannelConstant{
    public static final Logger logger = LoggerFactory.getLogger(HeartbeatTest.class);

	private static IFaceLogClient facelogClient;
	private static Token rootToken;

	@BeforeClass
	public static void setUpBeforeClass() throws Exception {

		// 创建服务实例
		facelogClient = ClientFactory.builder()
				.setHostAndPort("127.0.0.1", DEFAULT_PORT)
				.build(IFaceLogThriftClient.class, IFaceLogClient.class);
		// 申请令牌
		rootToken = facelogClient.applyRootToken("root", false);
		facelogClient.setTokenHelper(TokenHelperTestImpl.INSTANCE)
			.startServiceHeartbeatListener(rootToken, true);
		facelogClient.initMQDefaultFactory(rootToken);
	}
	@AfterClass
	public static void tearDownAfterClass() throws Exception {
		facelogClient.releaseRootToken(rootToken);
	}
	/**
	 * 设备端发送心跳包测试
	 * @throws InterruptedException 
	 */
	@Test
	public void test1SendHB() throws InterruptedException {
	
		System.out.println("Heartbeat thead start");
		try {
			facelogClient.makeHeartbeat(12345, rootToken)
				/** 间隔2秒发送心跳，重新启动定时任务 */
				.setInterval(2, TimeUnit.SECONDS)
				.start();
		} catch (Exception e) {
			e.printStackTrace();
		}

	}
	/**
	 * 管理端心跳包监控测试
	 * @throws InterruptedException 
	 */
	@Test
	public void test2HBMonitor() throws InterruptedException{
		DeviceHeartbeatListener hbAdapter = new DeviceHeartbeatListener(){
			@Override
			public void onSubscribe(DeviceHeartdbeatPackage t) throws SmqUnsubscribeException {
				// 显示收到的心跳包
				logger.info(t.toString());
			}};
		
		DynamicChannelListener<DeviceHeartdbeatPackage> monitor = new DynamicChannelListener<>(hbAdapter, 
			DeviceHeartdbeatPackage.class,
			facelogClient.getDynamicParamSupplier(MQParam.HB_MONITOR_CHANNEL,rootToken), 
			MessageQueueFactorys.getDefaultFactory());
		facelogClient.addServiceEventListener(monitor);
		monitor.start();
		/** 40秒后结束测试 */
		Thread.sleep(300*1000);
	}
}

public class CmdManagerTest implements CommonConstant{

	@Test
	public void testSendResetSync() throws ServiceSecurityException {
		// 创建 facelog 服务实例
		IFaceLogClient serviceClient = ClientFactory.builder().setHostAndPort("127.0.0.1", DEFAULT_PORT).build();
		// 使用root密码申请 root 令牌
		Token token = serviceClient.applyRootToken("12343", false);
		// 创建命令发送管理实例 
		CmdManager cmdManager = serviceClient.makeCmdManager(token);
		
		try {
			List<Ack<Void>> ackList = cmdManager.targetBuilder()
				.setAckChannel(serviceClient.getAckChannelSupplier(token)) // 设置命令响应通道
				.setDeviceTarget(125,207,122) // 指定设备命令执行接收目标为一组设备(id)
				.build()
				.runCmdSync(pathOfCmd(CMD_RESET),null,false); // 同步执行设备复位命令				
			// 输出命令执行结果
			for(Ack<Void> ack:ackList){
				logger.info("ack :{}",ack);
			}
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
	@Test
	public void testSendResetAsync() throws ServiceSecurityException {
		IFaceLogClient serviceClient = ClientFactory.builder().setHostAndPort("127.0.0.1", DEFAULT_PORT).build();
		// 申请 root 令牌
		Token token = serviceClient.applyRootToken("12343", false);
		// 创建命令发送管理实例 
		CmdManager cmdManager = serviceClient.makeCmdManager(token);
		
		cmdManager.targetBuilder()
			.setAckChannel(serviceClient.getAckChannelSupplier(token)) // 设置命令响应通道
			.setDeviceTarget(125,207,122) // 指定设备命令执行接收目标为一组设备(id)
			.build()
			.runCmd(pathOfCmd(CMD_RESET),null, new IAckAdapter.BaseAdapter<Object>(){
			@Override
			protected void doOnSubscribe(Ack<Object> t) {
				logger.info("ADMIN client : 设备命令响应 {}",t);
			}
		}); // 异步执行设备复位命令
	}  
}

@Test
public void testCommandAdapter(){
	IFaceLogClient serviceClient = ClientFactory.builder().setHostAndPort("127.0.0.1", DEFAULT_PORT).build();
	DeviceBean deviceBean = 。。。// 当前设备信息
	try {
		// 申请设备令牌
		Token token = serviceClient.online(deviceBean);
		// 创建设备命令分发器，并将实现 reset命令的RestAdapter实例加入分发器
		serviceClient.makeCmdDispatcher(token)
			.registerAdapter(Cmd.reset, new RestAdapter());	
	} catch (ServiceSecurityException e) {
		e.printStackTrace();
	}
}
/** reset 命令实现 */
public class RestAdapter extends CommandAdapter{
	@Override
	public void reset(Long schedule) throws DeviceCmdException {
		logger.info("device reset...");
	}
}

/**
 * 设备命令发送接收测试
 * @author guyadong
 *
 */
@FixMethodOrder(MethodSorters.NAME_ASCENDING)
public class DeviceCmdTest implements ChannelConstant{
	private static IFaceLogClient facelogClient;
	private static Token rootToken;
	/** redis 连接参数 */
	private static Map<PropName, Object> redisParam = 
			ImmutableMap.<PropName, Object>of(
					/** redis 主机名 */PropName.host,Protocol.DEFAULT_HOST,
					/** redis 端口号 */PropName.port,Protocol.DEFAULT_PORT,
					/** redis 连接密码 */PropName.password, "hello"
					);
	private static DeviceBean device;
	private static Token deviceToken;
	@BeforeClass
	public static void setUpBeforeClass() throws Exception {
		// 根据连接参数创建默认实例 
		JedisPoolLazy.createDefaultInstance( redisParam);
		// 创建服务实例
		facelogClient = ClientFactory.builder().setHostAndPort("127.0.0.1", DEFAULT_PORT).build();
		// 申请root令牌
		rootToken = facelogClient.applyRootToken("${root_password}", false);
		byte[] address = new byte[]{0x20,0x20,0x20,0x20,0x20,0x20};
		device = DeviceBean.builder().mac(NetworkUtil.formatMac(address, null)).serialNo("12322333").build();
		logger.info(device.toString(true,false));
		// 注册设备 
		device = facelogClient.registerDevice(device);
		logger.info("registered device {}",device.toString(true, false));
		// 申请设备令牌
		deviceToken = facelogClient.online(device);
		logger.info("device token = {}",deviceToken);
	}
	@AfterClass
	public static void tearDownAfterClass() throws Exception {
		facelogClient.unregisterDevice(device.getId(), deviceToken);
		facelogClient.releaseRootToken(rootToken);
	}
	/**
	 * reset 命令执行器
	 * @author guyadong
	 *
	 */
	public class RestAdapter extends CommandAdapter{
		@Override
		public void reset(Long schedule)  {
			logger.info("DEVICE client : do device reset...(执行设备RESET)");
		}		
	}
	/**
	 * isEnable 命令执行器
	 * @author guyadong
	 *
	 */
	public class IsEnableAdapter extends CommandAdapter{

		@Override
		public Boolean isEnable() {
			logger.info("DEVICE client : return enable status...(返回设备enable状态)");
			return false;
		}		
	}
	/**
	 * 模拟设备端响应设备命令
	 * @throws InterruptedException 
	 */
	@Test
	public void test1CommandAdapter(){		
		try {
			facelogClient.makeCmdDispatcher(deviceToken)
				/** 注册命令执行器 */
				.registerAdapter(Cmd.reset, new RestAdapter())
				.registerAdapter(Cmd.isEnable, new IsEnableAdapter())
				/** 程序退出时自动注销设备命令频道 */
				.autoUnregisterChannel();	
		} catch(ServiceRuntimeException e){
			e.printServiceStackTrace();
			assertTrue(e.getMessage(),false);
		}
	}
	/**
	 * 模拟设备端发送设备复位(异步执行)和isEnable命令(同步执行)
	 * @throws InterruptedException 
	 */
	@Test
	public void test2SendCmd() throws InterruptedException{
		// 创建命令发送管理实例 
		CmdManager cmdManager = facelogClient.makeCmdManager(rootToken)
				.setExecutor(DefaultExecutorProvider.getGlobalExceutor())
				.setTimerExecutor(DefaultExecutorProvider.getTimerExecutor());
		
		cmdManager.targetBuilder()
			// 设置命令序列号
			.setCmdSn(facelogClient.getCmdSnSupplier(rootToken))
			// 设置命令响应通道
			.setAckChannel(facelogClient.getAckChannelSupplier(rootToken))
			// 指定设备命令执行接收目标为一组设备(id)
			.setDeviceTarget(device.getId()).autoRemove(false);
		logger.info("异步接收命令响应:");
		cmdManager.reset(null, new IAckAdapter.BaseAdapter<Void>(){
				@Override
				protected void doOnSubscribe(Ack<Void> t) {
					logger.info("ADMIN client : 设备命令响应 {}",t);
				}
			}); // 异步执行设备复位命令
		 /** 5 秒后结束测试 */
		 Thread.sleep(5*1000);
		 logger.info("reset异步命令响应结束");
		 
		 // 复用CmdBuilder对象同步执行 isEnable 命令
		 cmdManager.targetBuilder().resetApply();
		 List<Ack<Boolean>> receivedAcks = cmdManager.isEnableSync(false);
		 logger.info("同步接收命令响应:");
		 for(Ack<Boolean> ack:receivedAcks){
			 logger.info("ADMIN client : 设备命令响应 {}",ack);
		 }
		 logger.info("isEnable同步命令响应结束");
	}
	/**
	 * 模拟设备端发送设备复位(同步执行)
	 * @throws InterruptedException
	 */
	@Test
	public void test3SendCmdSync() throws InterruptedException{
		// 创建命令发送管理实例 
		CmdManager cmdManager = facelogClient.makeCmdManager(rootToken)
				.setExecutor(DefaultExecutorProvider.getGlobalExceutor())
				.setTimerExecutor(DefaultExecutorProvider.getTimerExecutor());
		cmdManager.targetBuilder()
			// 设置命令序列号
			.setCmdSn(facelogClient.getCmdSnSupplier(rootToken))
			// 设置命令响应通道
			.setAckChannel(facelogClient.getAckChannelSupplier(rootToken))
			// 指定设备命令执行接收目标为一组设备(id)
			.setDeviceTarget(device.getId()) ;
		List<Ack<Void>> receivedAcks = cmdManager.resetSync(null, false);
		logger.info("同步接收命令响应:");
		for(Ack<Void> ack:receivedAcks){
			logger.info("ADMIN client : 设备命令响应 {}",ack);
		}
		logger.info("reset同步命令响应结束");
		logger.info("测试结束");
	}
}

{
	## hour,day为默认规则过滤器,根据day字段bit0的值可分为7x24小时过滤器和31x24小时过滤器，未定义时使用缺省值0xffffffff,即7x24小时过滤器		
	day:0xffffffff,     ## 缺省日期过滤器(32位整数):对应位为1为符合过滤条件，为0不符合过滤条件
						## bit0为1时,bit 1~7代表每周的天（1-星期日,2-星期一,3-星期二,4-星期三,5-星期四,6-星期五,7-星期六）,bit8~bit31未定义
						## bit0为0时,bit 1~31分别代表每月1~31日
	hour:0x00ffffff,    ## 缺省时间过滤器(32位整数):以小时为单位定义过滤时间，bit0~bit23代表一天的24小时，对应位为1为符合过滤条件，为0不符合过滤条件
	## 以下为可选的例外规则过滤器，当存在例外过滤器时优先使用例外过滤器，例外过滤器的值(32位整数)即为过滤时间，参见hour定义
	w1:0,				## 日期(周)过滤器，w1~w7（1-星期日,2-星期一,3-星期二,4-星期三,5-星期四,6-星期五,7-星期六）
	m25:0x00ff00ff,		## 日期(月)过滤器，m1~w31分别代表每月的1日到31日
	d0725:0x00ff00ff,   ## 日期(日期)过滤器，d0101~d1231,后面4位数字以(MMdd)代表日期
	## 当例外规则过滤器之间存在冲突时（比如存在w1,m1,d0601,3个过滤器，而6月1日也是星期一也是6月第一天），优先顺序为日期，月，周

	asLastdayIfOverflow:true/false  ## 溢出部分是否可作为每月最后一天
									## 比如我们定义了m31为0x0,而当前日期是6月30日(最后一天)，6月没有31日，如果该字段为true，则将m31规则应用于当前日期。
}

{	
	// bool类型，为true时 passLimit 字段为限制天数，且忽略 passLimitPerDay 的限制
	dayLimit:
	// integer类型，用户有效期内可以的通行总次数(或总天数)限制,为 null不限制
	passLimit:
	// integer类型，每天通行次总数限制,为{@code null}不限制
	passLimitPerDay:
	// bool类型，
	// 当因为网络异常或其他错误造成设备端无法统计通行次数判断是否允许该用户通行时,
	// 设置为{@code true}就允许通行,
	// 设置为{@code false}就不允许通行
	permitOnException:
}

root.password = new_root_password

mvn com.gitee.l0km:facelogservice-maven-plugin:${facelog_version}:run

java -jar facelog-service-${facelog_version}-standalone.jar

java -Xrunjdwp:transport=dt_socket,server=y,address=8000,suspend=n -jar facelog-service-${facelog_version}-standalone.jar

mvn dependency:get \ 
	-Dartifact=com.gitee.l0km:facelog-service:${facelog_version}:zip:docker-maven-distribution 
	-Ddest=/you/path