devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

开源堡垒机Guacamole二次开发记录之二_基于guacamole堡垒机 开源

作者：2023面试高手 | 2024-05-07 19:09:32

赞

踩

基于guacamole堡垒机 开源

这篇主要记录录屏和SFTP的实现。

录屏及视频播放

对于录屏及录屏的播放，因为我们的项目中需要把guacd和java后端分开两台服务器部署，而guacamole的录屏是通过guacd程序录制的。我的要求是在Java后端直接把录好的视频文件通过http前端播放，因此需要把录屏放在Java端的服务器上。 

首先稍微修改一下guacamole-common的源码，添加几个可重载的函数，分别是向前端下发ws消息，向guacd上传前端消息以及ws连接关闭的地方。

GuacamoleWebSocketTunnelEndpoint类的onMessage函数中，添加receiveData(message);

  1. try {
  2.             // Write received message
  3.             writer.write(message.toCharArray());
  4.             receiveData(message);
  5.         }
  6.         catch (GuacamoleConnectionClosedException e) {
  7.             logger.debug("Connection to guacd closed.", e);
  8.         }
  9.         catch (GuacamoleException e) {
  10.             logger.debug("WebSocket tunnel write failed.", e);
  11.         }
  12.  
  13.         tunnel.releaseWriter();

onClose函数中添加closeConnect函数调用。

  1. public void onClose(Session session, CloseReason closeReason) {
  2.         try {
  3.             if (tunnel != null)
  4.                 tunnel.close();
  5.             closeConnect();
  6.         }
  7.         catch (GuacamoleException e) {
  8.             logger.debug("Unable to close WebSocket tunnel.", e);
  9.         }
  10.     }

定义两个可重载的函数

  1. protected void receiveData(String message) {
  2.         //logger.info("GuacamoleWebSocketTunnelEndpoint-receiveData");
  3.     }
  4.  
  5.     protected void closeConnect() {
  6.         //logger.info("GuacamoleWebSocketTunnelEndpoint-receiveData");
  7.     }

在Java工程的WebSocketTunnel类中重载函数

receiveData函数用于记录鼠标键盘事件

  1. @Override
  2.     protected void receiveData(String message)  {
  3.         //logger.info("WebSocketTunnel-receiveData : " + message);
  4. //        try {
  5. //            userConnectLogEntity.getBufferedWriter2().write(message);
  6. //            userConnectLogEntity.getBufferedWriter2().newLine();
  7. //            userConnectLogEntity.getBufferedWriter2().flush();
  8. //        } catch (IOException e) {
  9. //            throw new RuntimeException(e);
  10. //        }
  11.     }

sendInstruction函数，对将要发送给前端的报文进行拦截处理，重点是最后的几行，把报文记录在一个文件中。

  1. Override
  2.     protected void sendInstruction(String instruction) throws IOException {
  3.         if(instruction.startsWith("0.,36.")) {
  4.             uuid = instruction.substring(6, instruction.length()-1);
  5.             System.out.println("uuid: "+uuid);
  6.  
  7.             TunnelStream tunnelStream = new TunnelStream();
  8.             tunnelStream.setWebSocketTunnel(this);
  9.             tunnelStream.setEnd(false);
  10.             tunnelStream.setBuffer(null);
  11.             streamMap.tunnelStreamMap.put(uuid, tunnelStream);
  12.             streamMap.tunnelStreamMap.get(uuid).setOk(false);
  13.         }
  14.         else if(instruction.contains("application/octet-stream")) {
  15.             fileTranfer = true;
  16.  
  17.             GuacamoleParser parser = new GuacamoleParser();
  18.  
  19.             int parsed;
  20.             int offset = 0;
  21.             int length = instruction.toCharArray().length;
  22.             while (true) {
  23.                 try {
  24.                     if (!((parsed = parser.append(instruction.toCharArray(), offset, length)) != 0))
  25.                         break;
  26.                 }
  27.                 catch (GuacamoleException e) {
  28.                     throw new RuntimeException(e);
  29.                 }
  30.  
  31.                 offset += parsed;
  32.                 length -= parsed;
  33.             }
  34.  
  35.             GuacamoleInstruction ins = parser.next();
  36.             synchronized (bufferInstructions) {
  37.                 bufferInstructions.put(ins.getArgs().get(0), ins);
  38.             }
  39.         }
  40.         else if(instruction.contains("17.SFTP: File opened")) {
  41.             streamMap.tunnelStreamMap.get(uuid).setOk(true);
  42.         }
  43.         else if(instruction.contains("8.SFTP: OK")) {
  44.             streamMap.tunnelStreamMap.get(uuid).setOk(true);
  45.         }
  46.         else {
  47.             if(fileTranfer) {
  48.                 if(instruction.startsWith("4.blob")) {
  49.                     int num1 = instruction.indexOf(",");
  50.                     int num2 = instruction.indexOf(",", num1+1);
  51.                     int num3 = instruction.indexOf(".", num1+1);
  52.  
  53.                     int id = Integer.parseInt(instruction.substring(num3+1, num2));
  54.  
  55.                     int num4 = instruction.indexOf(".", num2+1);
  56.                     String str = instruction.substring(num4+1, instruction.length()-1);
  57.  
  58.                     TunnelStream tunnelStream = streamMap.tunnelStreamMap.get(uuid);
  59.  
  60.                     if(tunnelStream != null) {
  61.                         synchronized(streamMap) {
  62.                             streamMap.tunnelStreamMap.get(uuid).setBuffer(str);
  63.                         }
  64.  
  65.                         instruction = instruction.substring(0, num2+1) + "0.;";
  66.                     }
  67.  
  68.                 }
  69.                 else if(instruction.startsWith("3.end")) {
  70.                     System.out.println("3.end");
  71.                     fileTranfer = false;
  72.  
  73.                     TunnelStream tunnelStream = streamMap.tunnelStreamMap.get(uuid);
  74.  
  75.                     synchronized(streamMap) {
  76.                         streamMap.tunnelStreamMap.get(uuid).setEnd(true);
  77.                     }
  78.                 }
  79.             }
  80.         }
  81.  
  82.         super.sendInstruction(instruction);
  83.         if(!instruction.startsWith("0.")) {
  84.             userConnectLogEntity.getBufferedWriter().write(instruction);
  85.         }
  86.     }

closeConnect函数，用于ws连接断开时，记录日志，启动线程进行录屏文件的转换。sendInstruction函数中记录了下发的报文，通过调用guacenc程序把日志转换成m4v格式的视频文件。

  1. @Override
  2.     protected void closeConnect() {
  3.         try {
  4.             streamMap.tunnelStreamMap.remove(uuid);
  5.  
  6.             userConnectLogEntity.getBufferedWriter().flush();
  7.             userConnectLogEntity.getBufferedWriter().close();
  8.  
  9.             userConnectLogEntity.setEtime(new Date(System.currentTimeMillis()));
  10.             userConnectLogEntity.setPeriod((int)(userConnectLogEntity.getEtime().getTime()-userConnectLogEntity.getStime().getTime()) / 1000);
  11.  
  12.             Thread thread = new MyThread(userConnectLogEntity, userConnectLogService);
  13.             thread.start();
  14.         } catch (IOException e) {
  15.             throw new RuntimeException(e);
  16.         }
  17.     }

 视频转换线程

  1. public class MyThread extends Thread {
  2.         private UserConnectLogEntity userConnectLogEntity;
  3.         private IUserConnectLogService userConnectLogService;
  4.  
  5.         public MyThread(UserConnectLogEntity userConnectLogEntity, IUserConnectLogService userConnectLogService) {
  6.             this.userConnectLogEntity = userConnectLogEntity;
  7.             this.userConnectLogService = userConnectLogService;
  8.         }
  9.  
  10.         public void run() {
  11.             try {
  12.                 String fileName = userConnectLogEntity.getVideo().substring(0, userConnectLogEntity.getVideo().length()-4);
  13.                 String str = "guacenc -s 1024x768 -r 300000 -f " + fileName;
  14.                 Process process = Runtime.getRuntime().exec(str);
  15.                 process.waitFor();
  16.  
  17.                 logger.info("转换视频完成: " + fileName);
  18.             }
  19.             catch (Exception e) {
  20.                 logger.error(e.getMessage(), e);
  21.             }
  22.  
  23.             String str = userConnectLogEntity.getVideo();
  24.             int num1 = str.lastIndexOf(File.separator);
  25.             int num2 = str.lastIndexOf(File.separator, num1-1);
  26.             userConnectLogEntity.setVideo("/video"+str.substring(num2));
  27.             userConnectLogService.updateById(userConnectLogEntity);
  28.         }
  29.     }

 把视频文件暴露给web端

  1. @Configuration
  2. public class WebAppConfig extends WebMvcConfigurerAdapter {
  3.  
  4.     @Value("${fileserver.videofolder}")
  5.     private String videoFolder;
  6.  
  7.     @Override
  8.     public void addResourceHandlers(ResourceHandlerRegistry registry) {
  9.         registry.addResourceHandler("/video/**").addResourceLocations("file:"+videoFolder);
  10.         super.addResourceHandlers(registry);
  11.     }
  12. }

这样视频文件直接通过web链接就可以在浏览器中播放。

另外要说明一点的是，默认的guacenc程序转换出来的视频文件在浏览器中是无法播放的，视频的内部格式不对，需要修改一下guacamole-server的源码重新编译一下。

guacamole-server-1.5.1\src\guacenc\guacenc.c文件，121行左右，修改一下视频格式重新编译。

  1. //if (guacenc_encode(path, out_path, "mpeg4", width, height, bitrate, force))
  2. // 修改为
  3. if (guacenc_encode(path, out_path, "libx264", width, height, bitrate, force))

SFTP实现

SFTP的实现较为复杂，需要对SFTP上传下载的流程及guacamole封装的协议有较好的了解，才能实现。

文件列表

文件列表相对简单些，通过查看guacamole的前端代码，基本可以了解其流程，自己再按照流程重新写一下前端就行。

实现Guacamole.Client的onfilesystem的响应

  1. guac.onfilesystem = function(object, name) {
  2.         filesystemObject = object;
  3.         currentPath = name;
  4.         listDirectory(currentPath);
  5.     };

获取文件列表的函数 ，主要是调用filesystemObject.requestInputStream、sendAck

  1. listDirectory(path) {
  2. 	filesystemObject.requestInputStream(path, function handleStream(stream, mimetype) {
  3. 		// Ignore stream if mimetype is wrong
  4. 		if (mimetype !== Guacamole.Object.STREAM_INDEX_MIMETYPE) {
  5. 			stream.sendAck('Unexpected mimetype', Guacamole.Status.Code.UNSUPPORTED);
  6. 			return;
  7. 		}
  8.  
  9. 		currentPath = path;
  10. 		let exchangePath = path.replace(/^\//,'')
  11. 		folders = exchangePath.length ? exchangePath.split('/') : []
  12. 		paths = []
  13. 		folders.reduce((tmp, item, index) => {
  14. 			let path = tmp+"/"+item
  15. 			let obj = {
  16. 				path: path,
  17. 				folder: item
  18. 			}
  19. 			paths.push(obj)
  20. 			return path }, "")
  21. 		// Signal server that data is ready to be received
  22. 		stream.sendAck('Ready', Guacamole.Status.Code.SUCCESS);
  23.  
  24. 		// Read stream as JSON
  25. 		let reader = new Guacamole.JSONReader(stream);
  26.  
  27. 		// Acknowledge received JSON blobs
  28. 		reader.onprogress = function onprogress() {
  29. 			stream.sendAck("Received", Guacamole.Status.Code.SUCCESS);
  30. 		};
  31.  
  32. 		// Reset contents of directory
  33. 		reader.onend = function jsonReady() {
  34. 			fileList = []
  35. 			// For each received stream name
  36. 			var mimetypes = reader.getJSON();
  37.  
  38. 			for (var name in mimetypes) {
  39. 				if (name.substring(0, path.length) !== path){
  40. 					continue;
  41. 				}
  42.  
  43. 				var filename = name.substring(path.length);
  44. 				if(path.substring(path.length-1) != '/'){
  45. 					filename = name.substring(path.length+1);
  46. 				}
  47.  
  48. 				let one = {}
  49. 				one.path = filename
  50. 				if (mimetypes[name] === Guacamole.Object.STREAM_INDEX_MIMETYPE) {
  51. 					one.type="folder"
  52. 				}
  53. 				else {
  54. 					one.type="file"
  55. 				}
  56. 				one.fullpath = name
  57. 				fileList.push(one)
  58. 			}
  59. 		};
  60. 	});
  61. },

上传下载

上传下载，首先得搞清楚整体得流程，

通过wireshark抓包，可以查看guacd与java后端的通信报文，

通过浏览器自带的调试工具，可以查看前端和Java后端之间的websocket通信报文，

通过上面两个工具的抓包分析，分析出上传下载的流程。

文件下载流程：

  1. 首先前端通过websocket发送3.get报文，java后端接受到后，直接发往guacd服务端；然后前端再通过http接口发送文件请求到Java端；
  2. guacd回复application/octet-stream报文给Java后端，Java后端直接向guacd端回复ack消息，不向前端转发；
  3. guacd端开始发送4.blob文件段，Java端接收到后，将4.blob报文的实际blob字段截取下来，通过WebSocket向前端回复截取后的报文，同时通过HTTP接口向前端发送实际的文件段；
  4. 前端websocket接受到blob消息后，回复ack，Java端转发给guacd，guacd再发下一段文件，循环这个过程直到文件发送完毕。
  5. 最后guacd端发送end报文，java端通过websocket转发给前端，整个下载过程结束。

文件上传流程：

  1. 前端发送put指令，Java端接收到后，直接转给guacd端
  2. guacd端回复File Opened消息通知文件已准备好，可以写入
  3. 前端通过Http post 发送MultipartFile给java端，java端接收到后转发给guacd端
  4. guacd端回复SFTP OK消息
  5. 前端发送下一段，循环发送直到文件发送完成，最后Java端发送end命令给guacd端
  6. guacd端回复OK消息，整个文件上传流程结束

下面是代码实现的大致流程：

前端下载代码，先通过filesystemObject.requestInputStream发送下载请求，再通过iframe挂一个http get请求开始下载文件，中间通过stream.onblob事件回复Ack消息，通过stream.onend事件结束下载流程

  1. downloadfile(path){
  2. 	filesystemObject.requestInputStream(path, function downloadStreamReceived(stream, mimetype) {
  3. 		// Parse filename from string
  4. 		var filename = path.match(/(.*[\\/])?(.*)/)[2];
  5. 		var url = '/tunnels/' + uuid + '/sessions/' + stream.index + '/files/' + filename;
  6.  
  7. 		// Create temporary hidden iframe to facilitate download
  8. 		var iframe = document.createElement('iframe');
  9. 		iframe.style.display = 'none';
  10.  
  11. 		// The iframe MUST be part of the DOM for the download to occur
  12. 		document.body.appendChild(iframe);
  13.  
  14. 		iframe.onload = function downloadComplete() {
  15. 			document.body.removeChild(iframe);
  16. 		};
  17.  
  18. 		// Acknowledge (and ignore) any received blobs
  19. 		stream.onblob = function acknowledgeData() {
  20. 			stream.sendAck('OK', Guacamole.Status.Code.SUCCESS);
  21. 		};
  22.  
  23. 		// Automatically remove iframe from DOM a few seconds after the stream
  24. 		// ends, in the browser does NOT fire the "load" event for downloads
  25. 		stream.onend = function downloadComplete() {
  26. 			window.setTimeout(function cleanupIframe() {
  27. 				if (iframe.parentElement) {
  28. 					document.body.removeChild(iframe);
  29. 				}
  30. 			}, 5000);
  31. 		};
  32.  
  33. 		// Begin download
  34. 		iframe.src = url;
  35. 	});
  36. }

前端上传文件代码，file类型input的change事件响应函数。通过filesystemObject.createOutputStream发送文件上传请求，通过XMLHttpRequest post 发送文件给Java端，

  1. changFile(event){
  2. 	let file1 = event.target.files[0];
  3. 	var stream = filesystemObject.createOutputStream(file1.type, currentPath+'/'+file1.name);
  4.  
  5. 	stream.onack = function beginUpload(status) {
  6. 		if (status.isError()) {
  7. 			return;
  8. 		}
  9. 	}
  10.  
  11. 	var fd = new FormData();
  12. 	fd.append('file', file1);
  13.  
  14. 	var url = '/tunnels/' + uuid + '/sessions/' + stream.index;
  15. 	const xhr = new XMLHttpRequest();
  16. 	xhr.open('POST', url);
  17. 	xhr.send(fd);
  18.  
  19. 	xhr.onreadystatechange = function () {
  20. 		if (xhr.readyState === 4 && xhr.status === 200) {
  21. 			console.log('上传成功');
  22. 			updateDirectory(currentPath);
  23. 		}
  24. 	}
  25. },

接下来是java端的http接口，

下载文件接口，主要是通过ServletOutputStream向前端写文件流。文件流实际是在websocket处理函数中接收的，这儿guacamole通过消息过滤等方式实现了，比较复杂。我这儿简单粗暴的用了全局的公共变量实现，每个websocket实例接受到文件段后，保存到一个公共缓冲区中，再置一个标志位，http controller这儿，循环判断标准位，取出文件段，向前端写文件流。

  1. @GetMapping("/tunnels/{tnid}/sessions/{snid}/files/{filename}")
  2. public void download(@PathVariable("tnid")String tnid, @PathVariable("snid")String snid, @PathVariable("filename")String filename, HttpServletResponse response) {
  3. 	try {
  4. 		System.out.println("download controller: "+tnid);
  5. 		response.setCharacterEncoding("UTF-8");
  6. 		response.addHeader("Content-Disposition", "attachment;filename=" + URLEncoder.encode(filename, "UTF-8"));
  7. 		ServletOutputStream os = response.getOutputStream();
  8.  
  9. 		if(streamMap.tunnelStreamMap.get(tnid) != null) {
  10. 			streamMap.tunnelStreamMap.get(tnid).getWebSocketTunnel().startSendFile(snid);
  11. 			streamMap.tunnelStreamMap.get(tnid).setEnd(false);
  12. 			streamMap.tunnelStreamMap.get(tnid).setBuffer(null);
  13.  
  14. 			long start = System.currentTimeMillis();
  15. 			while(!streamMap.tunnelStreamMap.get(tnid).isEnd()){
  16. 				synchronized(streamMap) {
  17. 					String str = streamMap.tunnelStreamMap.get(tnid).getBuffer();
  18. 					if (str != null) {
  19. 						streamMap.tunnelStreamMap.get(tnid).setBuffer(null);
  20.  
  21. 						os.write(decoder.decode(str.getBytes()));
  22. 					}
  23. 				}
  24. 			}
  25. 		}
  26.  
  27. 		os.close();
  28. 	}
  29. 	catch (Exception e) {
  30. 		throw new RuntimeException(e);
  31. 	}
  32. }

上传文件接口。同样通过公共的Bean和websocket线程同步消息

  1. @PostMapping("/tunnels/{tnid}/sessions/{snid}")
  2. public void upload(@RequestParam("file") MultipartFile uploadFile, @PathVariable("tnid")String tnid, @PathVariable("snid")String snid) {
  3. 	try {
  4. 		InputStream inputStream = uploadFile.getInputStream();
  5. 		byte[] buffer = new byte[8192];
  6. 		int bytesRead = 0;
  7. 		while ((bytesRead = inputStream.read(buffer, 0, buffer.length)) != -1) {
  8.  
  9. 			long start = System.currentTimeMillis();
  10. 			while(!streamMap.tunnelStreamMap.get(tnid).isOk()) {
  11. 				// 等待上传完成消息
  12. 			}
  13.  
  14. 			streamMap.tunnelStreamMap.get(tnid).setOk(false);
  15.  
  16. 			System.out.println(bytesRead);
  17. 			byte[] bb = null;
  18. 			if(bytesRead < 8192) {
  19. 				bb = new byte[bytesRead];
  20. 				System.arraycopy(buffer, 0, bb, 0, bytesRead);
  21. 			}
  22. 			else {
  23. 				bb = buffer;
  24. 			}
  25.  
  26. 			if(streamMap.tunnelStreamMap.get(tnid) != null) {
  27. 				streamMap.tunnelStreamMap.get(tnid).getWebSocketTunnel().sendBlob(snid, bb);
  28. 			}
  29. 		}
  30.  
  31. 		if(streamMap.tunnelStreamMap.get(tnid) != null) {
  32. 			streamMap.tunnelStreamMap.get(tnid).getWebSocketTunnel().sendEnd(snid);
  33. 		}
  34.  
  35. 		inputStream.close();
  36. 	}
  37. 	catch (Exception e) {
  38. 		throw new RuntimeException(e);
  39. 	}
  40. }

 websocket处理部分，注意和http controller的同步

  1. @Override
  2. protected void sendInstruction(String instruction) throws IOException {
  3. 	if(instruction.startsWith("0.,36.")) {
  4. 		uuid = instruction.substring(6, instruction.length()-1);
  5. 		System.out.println("uuid: "+uuid);
  6.  
  7. 		TunnelStream tunnelStream = new TunnelStream();
  8. 		tunnelStream.setWebSocketTunnel(this);
  9. 		tunnelStream.setEnd(false);
  10. 		tunnelStream.setBuffer(null);
  11. 		streamMap.tunnelStreamMap.put(uuid, tunnelStream);
  12. 		streamMap.tunnelStreamMap.get(uuid).setOk(false);
  13. 	}
  14. 	else if(instruction.contains("application/octet-stream")) {
  15. 		fileTranfer = true;
  16.  
  17. 		GuacamoleParser parser = new GuacamoleParser();
  18.  
  19. 		int parsed;
  20. 		int offset = 0;
  21. 		int length = instruction.toCharArray().length;
  22. 		while (true) {
  23. 			try {
  24. 				if (!((parsed = parser.append(instruction.toCharArray(), offset, length)) != 0))
  25. 					break;
  26. 			}
  27. 			catch (GuacamoleException e) {
  28. 				throw new RuntimeException(e);
  29. 			}
  30.  
  31. 			offset += parsed;
  32. 			length -= parsed;
  33. 		}
  34.  
  35. 		GuacamoleInstruction ins = parser.next();
  36. 		synchronized (bufferInstructions) {
  37. 			bufferInstructions.put(ins.getArgs().get(0), ins);
  38. 		}
  39. 	}
  40. 	else if(instruction.contains("17.SFTP: File opened")) {
  41. 		streamMap.tunnelStreamMap.get(uuid).setOk(true);
  42. 	}
  43. 	else if(instruction.contains("8.SFTP: OK")) {
  44. 		streamMap.tunnelStreamMap.get(uuid).setOk(true);
  45. 	}
  46. 	else {
  47. 		if(fileTranfer) {
  48. 			if(instruction.startsWith("4.blob")) {
  49. 				int num1 = instruction.indexOf(",");
  50. 				int num2 = instruction.indexOf(",", num1+1);
  51. 				int num3 = instruction.indexOf(".", num1+1);
  52.  
  53. 				int id = Integer.parseInt(instruction.substring(num3+1, num2));
  54.  
  55. 				int num4 = instruction.indexOf(".", num2+1);
  56. 				String str = instruction.substring(num4+1, instruction.length()-1);
  57.  
  58. 				TunnelStream tunnelStream = streamMap.tunnelStreamMap.get(uuid);
  59.  
  60. 				if(tunnelStream != null) {
  61. 					synchronized(streamMap) {
  62. 						streamMap.tunnelStreamMap.get(uuid).setBuffer(str);
  63. 					}
  64.  
  65. 					instruction = instruction.substring(0, num2+1) + "0.;";
  66. 				}
  67. 			}
  68. 			else if(instruction.startsWith("3.end")) {
  69. 				System.out.println("3.end");
  70. 				fileTranfer = false;
  71. 				//int num1 = instruction.indexOf(".", 3);
  72. 				//int id = Integer.parseInt(instruction.substring(num1+1, instruction.length()-1));
  73.  
  74. 				TunnelStream tunnelStream = streamMap.tunnelStreamMap.get(uuid);
  75. 				synchronized(streamMap) {
  76. 					streamMap.tunnelStreamMap.get(uuid).setEnd(true);
  77. 				}
  78. 			}
  79. 		}
  80. 	}
  81.  
  82. 	super.sendInstruction(instruction);
  83. 	if(!instruction.startsWith("0.")) {
  84. 		userConnectLogEntity.getBufferedWriter().write(instruction);
  85. 	}
  86. }
  87.  
  88. public void startSendFile(String sid) {
  89. 	acknowledgeStream(sid);
  90. }
  91.  
  92. @Override
  93. protected void receiveData(String message)  {
  94. }
  95.  
  96. public void sendBlob(String sid, byte[] bytes) {
  97. 	GuacamoleWriter writer = guacamoleTunnel.acquireWriter();
  98.  
  99. 	GuacamoleInstruction ins = new GuacamoleInstruction("blob", sid, BaseEncoding.base64().encode(bytes));
  100. 	try {
  101. 		writer.writeInstruction(ins);
  102. 	}
  103. 	catch (GuacamoleException e) {
  104. 		logger.debug("Unable to send \"{}\" for intercepted stream.", ins.getOpcode(), e);
  105. 	}
  106.  
  107. 	guacamoleTunnel.releaseWriter();
  108. }
  109.  
  110. public void sendEnd(String sid) {
  111. 	GuacamoleWriter writer = guacamoleTunnel.acquireWriter();
  112. 	GuacamoleInstruction ins = new GuacamoleInstruction("end", sid);
  113. 	try {
  114. 		writer.writeInstruction(ins);
  115. 	}
  116. 	catch (GuacamoleException e) {
  117. 		logger.debug("Unable to send \"{}\" for intercepted stream.", ins.getOpcode(), e);
  118. 	}
  119.  
  120. 	guacamoleTunnel.releaseWriter();
  121. }
  122.  
  123. protected void acknowledgeStream(String sid) {
  124. 	GuacamoleInstruction ins = null;
  125. 	synchronized (bufferInstructions) {
  126. 		ins = bufferInstructions.remove(sid);
  127. 	}
  128.  
  129. 	if(ins != null) {
  130. 		GuacamoleWriter writer = guacamoleTunnel.acquireWriter();
  131. 		try {
  132. 			writer.writeInstruction(
  133. 					new GuacamoleInstruction("ack", ins.getArgs().get(0), "OK",
  134. 							Integer.toString(GuacamoleStatus.SUCCESS.getGuacamoleStatusCode())));
  135. 		}
  136. 		catch (GuacamoleException e) {
  137. 			throw new RuntimeException(e);
  138. 		}
  139.  
  140. 		guacamoleTunnel.releaseWriter();
  141. 	}
  142. }
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/550738
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号