repo stringclasses 1k values | file_url stringlengths 96 373 | file_path stringlengths 11 294 | content stringlengths 0 32.8k | language stringclasses 1 value | license stringclasses 6 values | commit_sha stringclasses 1k values | retrieved_at stringdate 2026-01-04 14:45:56 2026-01-04 18:30:23 | truncated bool 2 classes |
|---|---|---|---|---|---|---|---|---|
macrozheng/mall | https://github.com/macrozheng/mall/blob/dd6569c3558f79af5b21aad601349e0f029b9a6d/mall-common/src/main/java/com/macro/mall/common/config/BaseRedisConfig.java | mall-common/src/main/java/com/macro/mall/common/config/BaseRedisConfig.java | package com.macro.mall.common.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.jsontype.impl.LaissezFaireSubTypeValidator;
import com.macro.mall.common.service.RedisService;
import com.macro.mall.common.service.impl.RedisServiceImpl;
import org.springframework.context.annotation.Bean;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.cache.RedisCacheWriter;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.data.redis.serializer.Jackson2JsonRedisSerializer;
import org.springframework.data.redis.serializer.RedisSerializationContext;
import org.springframework.data.redis.serializer.RedisSerializer;
import org.springframework.data.redis.serializer.StringRedisSerializer;
import java.time.Duration;
/**
* Redis基础配置
* Created by macro on 2020/6/19.
*/
public class BaseRedisConfig {
@Bean
public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory redisConnectionFactory,RedisSerializer<Object> redisSerializer) {
RedisTemplate<String, Object> redisTemplate = new RedisTemplate<>();
redisTemplate.setConnectionFactory(redisConnectionFactory);
redisTemplate.setKeySerializer(new StringRedisSerializer());
redisTemplate.setValueSerializer(redisSerializer);
redisTemplate.setHashKeySerializer(new StringRedisSerializer());
redisTemplate.setHashValueSerializer(redisSerializer);
redisTemplate.afterPropertiesSet();
return redisTemplate;
}
@Bean
public RedisSerializer<Object> redisSerializer() {
//创建JSON序列化器
Jackson2JsonRedisSerializer<Object> serializer = new Jackson2JsonRedisSerializer<>(Object.class);
ObjectMapper objectMapper = new ObjectMapper();
objectMapper.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
//必须设置，否则无法将JSON转化为对象，会转化成Map类型
objectMapper.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,ObjectMapper.DefaultTyping.NON_FINAL);
serializer.setObjectMapper(objectMapper);
return serializer;
}
@Bean
public RedisCacheManager redisCacheManager(RedisConnectionFactory redisConnectionFactory) {
RedisCacheWriter redisCacheWriter = RedisCacheWriter.nonLockingRedisCacheWriter(redisConnectionFactory);
//设置Redis缓存有效期为1天
RedisCacheConfiguration redisCacheConfiguration = RedisCacheConfiguration.defaultCacheConfig()
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer())).entryTtl(Duration.ofDays(1));
return new RedisCacheManager(redisCacheWriter, redisCacheConfiguration);
}
@Bean
public RedisService redisService(){
return new RedisServiceImpl();
}
}
| java | Apache-2.0 | dd6569c3558f79af5b21aad601349e0f029b9a6d | 2026-01-04T14:45:56.650249Z | false |
macrozheng/mall | https://github.com/macrozheng/mall/blob/dd6569c3558f79af5b21aad601349e0f029b9a6d/mall-common/src/main/java/com/macro/mall/common/log/WebLogAspect.java | mall-common/src/main/java/com/macro/mall/common/log/WebLogAspect.java | package com.macro.mall.common.log;
import cn.hutool.core.util.StrUtil;
import cn.hutool.core.util.URLUtil;
import cn.hutool.json.JSONUtil;
import com.macro.mall.common.domain.WebLog;
import com.macro.mall.common.util.RequestUtil;
import io.swagger.annotations.ApiOperation;
import net.logstash.logback.marker.Markers;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.Signature;
import org.aspectj.lang.annotation.*;
import org.aspectj.lang.reflect.MethodSignature;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.core.annotation.Order;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.context.request.RequestContextHolder;
import org.springframework.web.context.request.ServletRequestAttributes;
import javax.servlet.http.HttpServletRequest;
import java.lang.reflect.Method;
import java.lang.reflect.Parameter;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 统一日志处理切面
* Created by macro on 2018/4/26.
*/
@Aspect
@Component
@Order(1)
public class WebLogAspect {
private static final Logger LOGGER = LoggerFactory.getLogger(WebLogAspect.class);
@Pointcut("execution(public * com.macro.mall.controller.*.*(..))||execution(public * com.macro.mall.*.controller.*.*(..))")
public void webLog() {
}
@Before("webLog()")
public void doBefore(JoinPoint joinPoint) throws Throwable {
}
@AfterReturning(value = "webLog()", returning = "ret")
public void doAfterReturning(Object ret) throws Throwable {
}
@Around("webLog()")
public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
long startTime = System.currentTimeMillis();
//获取当前请求对象
ServletRequestAttributes attributes = (ServletRequestAttributes) RequestContextHolder.getRequestAttributes();
HttpServletRequest request = attributes.getRequest();
//记录请求信息(通过Logstash传入Elasticsearch)
WebLog webLog = new WebLog();
Object result = joinPoint.proceed();
Signature signature = joinPoint.getSignature();
MethodSignature methodSignature = (MethodSignature) signature;
Method method = methodSignature.getMethod();
if (method.isAnnotationPresent(ApiOperation.class)) {
ApiOperation log = method.getAnnotation(ApiOperation.class);
webLog.setDescription(log.value());
}
long endTime = System.currentTimeMillis();
String urlStr = request.getRequestURL().toString();
webLog.setBasePath(StrUtil.removeSuffix(urlStr, URLUtil.url(urlStr).getPath()));
webLog.setUsername(request.getRemoteUser());
webLog.setIp(RequestUtil.getRequestIp(request));
webLog.setMethod(request.getMethod());
webLog.setParameter(getParameter(method, joinPoint.getArgs()));
webLog.setResult(result);
webLog.setSpendTime((int) (endTime - startTime));
webLog.setStartTime(startTime);
webLog.setUri(request.getRequestURI());
webLog.setUrl(request.getRequestURL().toString());
Map<String,Object> logMap = new HashMap<>();
logMap.put("url",webLog.getUrl());
logMap.put("method",webLog.getMethod());
logMap.put("parameter",webLog.getParameter());
logMap.put("spendTime",webLog.getSpendTime());
logMap.put("description",webLog.getDescription());
// LOGGER.info("{}", JSONUtil.parse(webLog));
LOGGER.info(Markers.appendEntries(logMap), JSONUtil.parse(webLog).toString());
return result;
}
/**
* 根据方法和传入的参数获取请求参数
*/
private Object getParameter(Method method, Object[] args) {
List<Object> argList = new ArrayList<>();
Parameter[] parameters = method.getParameters();
for (int i = 0; i < parameters.length; i++) {
//将RequestBody注解修饰的参数作为请求参数
RequestBody requestBody = parameters[i].getAnnotation(RequestBody.class);
if (requestBody != null) {
argList.add(args[i]);
}
//将RequestParam注解修饰的参数作为请求参数
RequestParam requestParam = parameters[i].getAnnotation(RequestParam.class);
if (requestParam != null) {
Map<String, Object> map = new HashMap<>();
String key = parameters[i].getName();
if (!StrUtil.isEmpty(requestParam.value())) {
key = requestParam.value();
}
if(args[i]!=null){
map.put(key, args[i]);
argList.add(map);
}
}
}
if (argList.size() == 0) {
return null;
} else if (argList.size() == 1) {
return argList.get(0);
} else {
return argList;
}
}
}
| java | Apache-2.0 | dd6569c3558f79af5b21aad601349e0f029b9a6d | 2026-01-04T14:45:56.650249Z | false |
macrozheng/mall | https://github.com/macrozheng/mall/blob/dd6569c3558f79af5b21aad601349e0f029b9a6d/mall-search/src/test/java/com/macro/mall/search/MallSearchApplicationTests.java | mall-search/src/test/java/com/macro/mall/search/MallSearchApplicationTests.java | package com.macro.mall.search;
import com.macro.mall.search.dao.EsProductDao;
import com.macro.mall.search.domain.EsProduct;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.data.elasticsearch.core.IndexOperations;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.List;
import java.util.Map;
@SpringBootTest
public class MallSearchApplicationTests {
@Autowired
private EsProductDao productDao;
@Autowired
private ElasticsearchRestTemplate elasticsearchTemplate;
@Test
public void contextLoads() {
}
@Test
public void testGetAllEsProductList(){
List<EsProduct> esProductList = productDao.getAllEsProductList(null);
System.out.print(esProductList);
}
@Test
public void testEsProductMapping(){
IndexOperations indexOperations = elasticsearchTemplate.indexOps(EsProduct.class);
indexOperations.putMapping(indexOperations.createMapping(EsProduct.class));
Map mapping = indexOperations.getMapping();
System.out.println(mapping);
}
}
| java | Apache-2.0 | dd6569c3558f79af5b21aad601349e0f029b9a6d | 2026-01-04T14:45:56.650249Z | false |
macrozheng/mall | https://github.com/macrozheng/mall/blob/dd6569c3558f79af5b21aad601349e0f029b9a6d/mall-search/src/main/java/com/macro/mall/search/MallSearchApplication.java | mall-search/src/main/java/com/macro/mall/search/MallSearchApplication.java | package com.macro.mall.search;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
@SpringBootApplication(scanBasePackages = "com.macro.mall")
public class MallSearchApplication {
public static void main(String[] args) {
SpringApplication.run(MallSearchApplication.class, args);
}
}
| java | Apache-2.0 | dd6569c3558f79af5b21aad601349e0f029b9a6d | 2026-01-04T14:45:56.650249Z | false |
macrozheng/mall | https://github.com/macrozheng/mall/blob/dd6569c3558f79af5b21aad601349e0f029b9a6d/mall-search/src/main/java/com/macro/mall/search/controller/EsProductController.java | mall-search/src/main/java/com/macro/mall/search/controller/EsProductController.java | package com.macro.mall.search.controller;
import com.macro.mall.common.api.CommonPage;
import com.macro.mall.common.api.CommonResult;
import com.macro.mall.search.domain.EsProduct;
import com.macro.mall.search.domain.EsProductRelatedInfo;
import com.macro.mall.search.service.EsProductService;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiImplicitParam;
import io.swagger.annotations.ApiOperation;
import io.swagger.v3.oas.annotations.tags.Tag;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import java.util.List;
/**
* 搜索商品管理Controller
* Created by macro on 2018/6/19.
*/
@Controller
@Api(tags = "EsProductController")
@Tag(name = "EsProductController",description = "搜索商品管理")
@RequestMapping("/esProduct")
public class EsProductController {
@Autowired
private EsProductService esProductService;
@ApiOperation(value = "导入所有数据库中商品到ES")
@RequestMapping(value = "/importAll", method = RequestMethod.POST)
@ResponseBody
public CommonResult<Integer> importAllList() {
int count = esProductService.importAll();
return CommonResult.success(count);
}
@ApiOperation(value = "根据id删除商品")
@RequestMapping(value = "/delete/{id}", method = RequestMethod.GET)
@ResponseBody
public CommonResult<Object> delete(@PathVariable Long id) {
esProductService.delete(id);
return CommonResult.success(null);
}
@ApiOperation(value = "根据id批量删除商品")
@RequestMapping(value = "/delete/batch", method = RequestMethod.POST)
@ResponseBody
public CommonResult<Object> delete(@RequestParam("ids") List<Long> ids) {
esProductService.delete(ids);
return CommonResult.success(null);
}
@ApiOperation(value = "根据id创建商品")
@RequestMapping(value = "/create/{id}", method = RequestMethod.POST)
@ResponseBody
public CommonResult<EsProduct> create(@PathVariable Long id) {
EsProduct esProduct = esProductService.create(id);
if (esProduct != null) {
return CommonResult.success(esProduct);
} else {
return CommonResult.failed();
}
}
@ApiOperation(value = "简单搜索")
@RequestMapping(value = "/search/simple", method = RequestMethod.GET)
@ResponseBody
public CommonResult<CommonPage<EsProduct>> search(@RequestParam(required = false) String keyword,
@RequestParam(required = false, defaultValue = "0") Integer pageNum,
@RequestParam(required = false, defaultValue = "5") Integer pageSize) {
Page<EsProduct> esProductPage = esProductService.search(keyword, pageNum, pageSize);
return CommonResult.success(CommonPage.restPage(esProductPage));
}
@ApiOperation(value = "综合搜索、筛选、排序")
@ApiImplicitParam(name = "sort", value = "排序字段:0->按相关度；1->按新品；2->按销量；3->价格从低到高；4->价格从高到低",
defaultValue = "0", allowableValues = "0,1,2,3,4", paramType = "query", dataType = "integer")
@RequestMapping(value = "/search", method = RequestMethod.GET)
@ResponseBody
public CommonResult<CommonPage<EsProduct>> search(@RequestParam(required = false) String keyword,
@RequestParam(required = false) Long brandId,
@RequestParam(required = false) Long productCategoryId,
@RequestParam(required = false, defaultValue = "0") Integer pageNum,
@RequestParam(required = false, defaultValue = "5") Integer pageSize,
@RequestParam(required = false, defaultValue = "0") Integer sort) {
Page<EsProduct> esProductPage = esProductService.search(keyword, brandId, productCategoryId, pageNum, pageSize, sort);
return CommonResult.success(CommonPage.restPage(esProductPage));
}
@ApiOperation(value = "根据商品id推荐商品")
@RequestMapping(value = "/recommend/{id}", method = RequestMethod.GET)
@ResponseBody
public CommonResult<CommonPage<EsProduct>> recommend(@PathVariable Long id,
@RequestParam(required = false, defaultValue = "0") Integer pageNum,
@RequestParam(required = false, defaultValue = "5") Integer pageSize) {
Page<EsProduct> esProductPage = esProductService.recommend(id, pageNum, pageSize);
return CommonResult.success(CommonPage.restPage(esProductPage));
}
@ApiOperation(value = "获取搜索的相关品牌、分类及筛选属性")
@RequestMapping(value = "/search/relate", method = RequestMethod.GET)
@ResponseBody
public CommonResult<EsProductRelatedInfo> searchRelatedInfo(@RequestParam(required = false) String keyword) {
EsProductRelatedInfo productRelatedInfo = esProductService.searchRelatedInfo(keyword);
return CommonResult.success(productRelatedInfo);
}
}
| java | Apache-2.0 | dd6569c3558f79af5b21aad601349e0f029b9a6d | 2026-01-04T14:45:56.650249Z | false |
macrozheng/mall | https://github.com/macrozheng/mall/blob/dd6569c3558f79af5b21aad601349e0f029b9a6d/mall-search/src/main/java/com/macro/mall/search/dao/EsProductDao.java | mall-search/src/main/java/com/macro/mall/search/dao/EsProductDao.java | package com.macro.mall.search.dao;
import com.macro.mall.search.domain.EsProduct;
import org.apache.ibatis.annotations.Param;
import java.util.List;
/**
* 搜索商品管理自定义Dao
* Created by macro on 2018/6/19.
*/
public interface EsProductDao {
/**
* 获取指定ID的搜索商品
*/
List<EsProduct> getAllEsProductList(@Param("id") Long id);
}
| java | Apache-2.0 | dd6569c3558f79af5b21aad601349e0f029b9a6d | 2026-01-04T14:45:56.650249Z | false |
macrozheng/mall | https://github.com/macrozheng/mall/blob/dd6569c3558f79af5b21aad601349e0f029b9a6d/mall-search/src/main/java/com/macro/mall/search/service/EsProductService.java | mall-search/src/main/java/com/macro/mall/search/service/EsProductService.java | package com.macro.mall.search.service;
import com.macro.mall.search.domain.EsProduct;
import com.macro.mall.search.domain.EsProductRelatedInfo;
import org.springframework.data.domain.Page;
import java.util.List;
/**
* 搜索商品管理Service
* Created by macro on 2018/6/19.
*/
public interface EsProductService {
/**
* 从数据库中导入所有商品到ES
*/
int importAll();
/**
* 根据id删除商品
*/
void delete(Long id);
/**
* 根据id创建商品
*/
EsProduct create(Long id);
/**
* 批量删除商品
*/
void delete(List<Long> ids);
/**
* 根据关键字通过名称或副标题查询商品
*/
Page<EsProduct> search(String keyword, Integer pageNum, Integer pageSize);
/**
* 根据关键字通过名称或副标题复合查询商品
*/
Page<EsProduct> search(String keyword, Long brandId, Long productCategoryId, Integer pageNum, Integer pageSize,Integer sort);
/**
* 根据商品id推荐相关商品
*/
Page<EsProduct> recommend(Long id, Integer pageNum, Integer pageSize);
/**
* 搜索关键字相关品牌、分类、属性
*/
EsProductRelatedInfo searchRelatedInfo(String keyword);
}
| java | Apache-2.0 | dd6569c3558f79af5b21aad601349e0f029b9a6d | 2026-01-04T14:45:56.650249Z | false |
macrozheng/mall | https://github.com/macrozheng/mall/blob/dd6569c3558f79af5b21aad601349e0f029b9a6d/mall-search/src/main/java/com/macro/mall/search/service/impl/EsProductServiceImpl.java | mall-search/src/main/java/com/macro/mall/search/service/impl/EsProductServiceImpl.java | package com.macro.mall.search.service.impl;
import cn.hutool.core.collection.ListUtil;
import cn.hutool.core.util.StrUtil;
import com.macro.mall.search.dao.EsProductDao;
import com.macro.mall.search.domain.EsProduct;
import com.macro.mall.search.domain.EsProductRelatedInfo;
import com.macro.mall.search.repository.EsProductRepository;
import com.macro.mall.search.service.EsProductService;
import org.elasticsearch.common.lucene.search.function.FunctionScoreQuery;
import org.elasticsearch.index.query.BoolQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.query.functionscore.FunctionScoreQueryBuilder;
import org.elasticsearch.index.query.functionscore.ScoreFunctionBuilders;
import org.elasticsearch.search.aggregations.AbstractAggregationBuilder;
import org.elasticsearch.search.aggregations.Aggregation;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.bucket.filter.ParsedFilter;
import org.elasticsearch.search.aggregations.bucket.nested.ParsedNested;
import org.elasticsearch.search.aggregations.bucket.terms.ParsedLongTerms;
import org.elasticsearch.search.aggregations.bucket.terms.ParsedStringTerms;
import org.elasticsearch.search.aggregations.bucket.terms.Terms;
import org.elasticsearch.search.sort.SortBuilders;
import org.elasticsearch.search.sort.SortOrder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.elasticsearch.core.ElasticsearchRestTemplate;
import org.springframework.data.elasticsearch.core.SearchHit;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.stereotype.Service;
import org.springframework.util.CollectionUtils;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
/**
* 搜索商品管理Service实现类
* Created by macro on 2018/6/19.
*/
@Service
public class EsProductServiceImpl implements EsProductService {
private static final Logger LOGGER = LoggerFactory.getLogger(EsProductServiceImpl.class);
@Autowired
private EsProductDao productDao;
@Autowired
private EsProductRepository productRepository;
@Autowired
private ElasticsearchRestTemplate elasticsearchRestTemplate;
@Override
public int importAll() {
List<EsProduct> esProductList = productDao.getAllEsProductList(null);
Iterable<EsProduct> esProductIterable = productRepository.saveAll(esProductList);
Iterator<EsProduct> iterator = esProductIterable.iterator();
int result = 0;
while (iterator.hasNext()) {
result++;
iterator.next();
}
return result;
}
@Override
public void delete(Long id) {
productRepository.deleteById(id);
}
@Override
public EsProduct create(Long id) {
EsProduct result = null;
List<EsProduct> esProductList = productDao.getAllEsProductList(id);
if (esProductList.size() > 0) {
EsProduct esProduct = esProductList.get(0);
result = productRepository.save(esProduct);
}
return result;
}
@Override
public void delete(List<Long> ids) {
if (!CollectionUtils.isEmpty(ids)) {
List<EsProduct> esProductList = new ArrayList<>();
for (Long id : ids) {
EsProduct esProduct = new EsProduct();
esProduct.setId(id);
esProductList.add(esProduct);
}
productRepository.deleteAll(esProductList);
}
}
@Override
public Page<EsProduct> search(String keyword, Integer pageNum, Integer pageSize) {
Pageable pageable = PageRequest.of(pageNum, pageSize);
return productRepository.findByNameOrSubTitleOrKeywords(keyword, keyword, keyword, pageable);
}
@Override
public Page<EsProduct> search(String keyword, Long brandId, Long productCategoryId, Integer pageNum, Integer pageSize,Integer sort) {
Pageable pageable = PageRequest.of(pageNum, pageSize);
NativeSearchQueryBuilder nativeSearchQueryBuilder = new NativeSearchQueryBuilder();
//分页
nativeSearchQueryBuilder.withPageable(pageable);
//过滤
if (brandId != null || productCategoryId != null) {
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
if (brandId != null) {
boolQueryBuilder.must(QueryBuilders.termQuery("brandId", brandId));
}
if (productCategoryId != null) {
boolQueryBuilder.must(QueryBuilders.termQuery("productCategoryId", productCategoryId));
}
nativeSearchQueryBuilder.withFilter(boolQueryBuilder);
}
//搜索
if (StrUtil.isEmpty(keyword)) {
nativeSearchQueryBuilder.withQuery(QueryBuilders.matchAllQuery());
} else {
List<FunctionScoreQueryBuilder.FilterFunctionBuilder> filterFunctionBuilders = new ArrayList<>();
filterFunctionBuilders.add(new FunctionScoreQueryBuilder.FilterFunctionBuilder(QueryBuilders.matchQuery("name", keyword),
ScoreFunctionBuilders.weightFactorFunction(10)));
filterFunctionBuilders.add(new FunctionScoreQueryBuilder.FilterFunctionBuilder(QueryBuilders.matchQuery("subTitle", keyword),
ScoreFunctionBuilders.weightFactorFunction(5)));
filterFunctionBuilders.add(new FunctionScoreQueryBuilder.FilterFunctionBuilder(QueryBuilders.matchQuery("keywords", keyword),
ScoreFunctionBuilders.weightFactorFunction(2)));
FunctionScoreQueryBuilder.FilterFunctionBuilder[] builders = new FunctionScoreQueryBuilder.FilterFunctionBuilder[filterFunctionBuilders.size()];
filterFunctionBuilders.toArray(builders);
FunctionScoreQueryBuilder functionScoreQueryBuilder = QueryBuilders.functionScoreQuery(builders)
.scoreMode(FunctionScoreQuery.ScoreMode.SUM)
.setMinScore(2);
nativeSearchQueryBuilder.withQuery(functionScoreQueryBuilder);
}
//排序
if(sort==1){
//按新品从新到旧
nativeSearchQueryBuilder.withSorts(SortBuilders.fieldSort("id").order(SortOrder.DESC));
}else if(sort==2){
//按销量从高到低
nativeSearchQueryBuilder.withSorts(SortBuilders.fieldSort("sale").order(SortOrder.DESC));
}else if(sort==3){
//按价格从低到高
nativeSearchQueryBuilder.withSorts(SortBuilders.fieldSort("price").order(SortOrder.ASC));
}else if(sort==4){
//按价格从高到低
nativeSearchQueryBuilder.withSorts(SortBuilders.fieldSort("price").order(SortOrder.DESC));
}else{
//按相关度
nativeSearchQueryBuilder.withSorts(SortBuilders.scoreSort().order(SortOrder.DESC));
}
nativeSearchQueryBuilder.withSorts(SortBuilders.scoreSort().order(SortOrder.DESC));
NativeSearchQuery searchQuery = nativeSearchQueryBuilder.build();
LOGGER.info("DSL:{}", searchQuery.getQuery().toString());
SearchHits<EsProduct> searchHits = elasticsearchRestTemplate.search(searchQuery, EsProduct.class);
if(searchHits.getTotalHits()<=0){
return new PageImpl<>(ListUtil.empty(),pageable,0);
}
List<EsProduct> searchProductList = searchHits.stream().map(SearchHit::getContent).collect(Collectors.toList());
return new PageImpl<>(searchProductList,pageable,searchHits.getTotalHits());
}
@Override
public Page<EsProduct> recommend(Long id, Integer pageNum, Integer pageSize) {
Pageable pageable = PageRequest.of(pageNum, pageSize);
List<EsProduct> esProductList = productDao.getAllEsProductList(id);
if (esProductList.size() > 0) {
EsProduct esProduct = esProductList.get(0);
String keyword = esProduct.getName();
Long brandId = esProduct.getBrandId();
Long productCategoryId = esProduct.getProductCategoryId();
//根据商品标题、品牌、分类进行搜索
List<FunctionScoreQueryBuilder.FilterFunctionBuilder> filterFunctionBuilders = new ArrayList<>();
filterFunctionBuilders.add(new FunctionScoreQueryBuilder.FilterFunctionBuilder(QueryBuilders.matchQuery("name", keyword),
ScoreFunctionBuilders.weightFactorFunction(8)));
filterFunctionBuilders.add(new FunctionScoreQueryBuilder.FilterFunctionBuilder(QueryBuilders.matchQuery("subTitle", keyword),
ScoreFunctionBuilders.weightFactorFunction(2)));
filterFunctionBuilders.add(new FunctionScoreQueryBuilder.FilterFunctionBuilder(QueryBuilders.matchQuery("keywords", keyword),
ScoreFunctionBuilders.weightFactorFunction(2)));
filterFunctionBuilders.add(new FunctionScoreQueryBuilder.FilterFunctionBuilder(QueryBuilders.matchQuery("brandId", brandId),
ScoreFunctionBuilders.weightFactorFunction(5)));
filterFunctionBuilders.add(new FunctionScoreQueryBuilder.FilterFunctionBuilder(QueryBuilders.matchQuery("productCategoryId", productCategoryId),
ScoreFunctionBuilders.weightFactorFunction(3)));
FunctionScoreQueryBuilder.FilterFunctionBuilder[] builders = new FunctionScoreQueryBuilder.FilterFunctionBuilder[filterFunctionBuilders.size()];
filterFunctionBuilders.toArray(builders);
FunctionScoreQueryBuilder functionScoreQueryBuilder = QueryBuilders.functionScoreQuery(builders)
.scoreMode(FunctionScoreQuery.ScoreMode.SUM)
.setMinScore(2);
//用于过滤掉相同的商品
BoolQueryBuilder boolQueryBuilder = new BoolQueryBuilder();
boolQueryBuilder.mustNot(QueryBuilders.termQuery("id",id));
//构建查询条件
NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
builder.withQuery(functionScoreQueryBuilder);
builder.withFilter(boolQueryBuilder);
builder.withPageable(pageable);
NativeSearchQuery searchQuery = builder.build();
LOGGER.info("DSL:{}", searchQuery.getQuery().toString());
SearchHits<EsProduct> searchHits = elasticsearchRestTemplate.search(searchQuery, EsProduct.class);
if(searchHits.getTotalHits()<=0){
return new PageImpl<>(ListUtil.empty(),pageable,0);
}
List<EsProduct> searchProductList = searchHits.stream().map(SearchHit::getContent).collect(Collectors.toList());
return new PageImpl<>(searchProductList,pageable,searchHits.getTotalHits());
}
return new PageImpl<>(ListUtil.empty());
}
@Override
public EsProductRelatedInfo searchRelatedInfo(String keyword) {
NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
//搜索条件
if(StrUtil.isEmpty(keyword)){
builder.withQuery(QueryBuilders.matchAllQuery());
}else{
builder.withQuery(QueryBuilders.multiMatchQuery(keyword,"name","subTitle","keywords"));
}
//聚合搜索品牌名称
builder.withAggregations(AggregationBuilders.terms("brandNames").field("brandName"));
//聚合搜索分类名称
builder.withAggregations(AggregationBuilders.terms("productCategoryNames").field("productCategoryName"));
//聚合搜索商品属性，去除type=0的属性
AbstractAggregationBuilder aggregationBuilder = AggregationBuilders.nested("allAttrValues","attrValueList")
.subAggregation(AggregationBuilders.filter("productAttrs",QueryBuilders.termQuery("attrValueList.type",1))
.subAggregation(AggregationBuilders.terms("attrIds")
.field("attrValueList.productAttributeId")
.subAggregation(AggregationBuilders.terms("attrValues")
.field("attrValueList.value"))
.subAggregation(AggregationBuilders.terms("attrNames")
.field("attrValueList.name"))));
builder.withAggregations(aggregationBuilder);
NativeSearchQuery searchQuery = builder.build();
SearchHits<EsProduct> searchHits = elasticsearchRestTemplate.search(searchQuery, EsProduct.class);
return convertProductRelatedInfo(searchHits);
}
/**
* 将返回结果转换为对象
*/
private EsProductRelatedInfo convertProductRelatedInfo(SearchHits<EsProduct> response) {
EsProductRelatedInfo productRelatedInfo = new EsProductRelatedInfo();
Map<String, Aggregation> aggregationMap = ((Aggregations)response.getAggregations().aggregations()).asMap();
//设置品牌
Aggregation brandNames = aggregationMap.get("brandNames");
List<String> brandNameList = new ArrayList<>();
for(int i = 0; i<((Terms) brandNames).getBuckets().size(); i++){
brandNameList.add(((Terms) brandNames).getBuckets().get(i).getKeyAsString());
}
productRelatedInfo.setBrandNames(brandNameList);
//设置分类
Aggregation productCategoryNames = aggregationMap.get("productCategoryNames");
List<String> productCategoryNameList = new ArrayList<>();
for(int i=0;i<((Terms) productCategoryNames).getBuckets().size();i++){
productCategoryNameList.add(((Terms) productCategoryNames).getBuckets().get(i).getKeyAsString());
}
productRelatedInfo.setProductCategoryNames(productCategoryNameList);
//设置参数
Aggregation productAttrs = aggregationMap.get("allAttrValues");
List<? extends Terms.Bucket> attrIds = ((ParsedLongTerms) ((ParsedFilter) ((ParsedNested) productAttrs).getAggregations().get("productAttrs")).getAggregations().get("attrIds")).getBuckets();
List<EsProductRelatedInfo.ProductAttr> attrList = new ArrayList<>();
for (Terms.Bucket attrId : attrIds) {
EsProductRelatedInfo.ProductAttr attr = new EsProductRelatedInfo.ProductAttr();
attr.setAttrId((Long) attrId.getKey());
List<String> attrValueList = new ArrayList<>();
List<? extends Terms.Bucket> attrValues = ((ParsedStringTerms) attrId.getAggregations().get("attrValues")).getBuckets();
List<? extends Terms.Bucket> attrNames = ((ParsedStringTerms) attrId.getAggregations().get("attrNames")).getBuckets();
for (Terms.Bucket attrValue : attrValues) {
attrValueList.add(attrValue.getKeyAsString());
}
attr.setAttrValues(attrValueList);
if(!CollectionUtils.isEmpty(attrNames)){
String attrName = attrNames.get(0).getKeyAsString();
attr.setAttrName(attrName);
}
attrList.add(attr);
}
productRelatedInfo.setProductAttrs(attrList);
return productRelatedInfo;
}
}
| java | Apache-2.0 | dd6569c3558f79af5b21aad601349e0f029b9a6d | 2026-01-04T14:45:56.650249Z | false |
macrozheng/mall | https://github.com/macrozheng/mall/blob/dd6569c3558f79af5b21aad601349e0f029b9a6d/mall-search/src/main/java/com/macro/mall/search/domain/EsProductRelatedInfo.java | mall-search/src/main/java/com/macro/mall/search/domain/EsProductRelatedInfo.java | package com.macro.mall.search.domain;
import lombok.Data;
import lombok.EqualsAndHashCode;
import java.util.List;
/**
* 搜索商品的关联信息，包括品牌名称，分类名称及属性
* Created by macro on 2018/6/27.
*/
@Data
@EqualsAndHashCode
public class EsProductRelatedInfo {
private List<String> brandNames;
private List<String> productCategoryNames;
private List<ProductAttr> productAttrs;
@Data
@EqualsAndHashCode
public static class ProductAttr {
private Long attrId;
private String attrName;
private List<String> attrValues;
}
}
| java | Apache-2.0 | dd6569c3558f79af5b21aad601349e0f029b9a6d | 2026-01-04T14:45:56.650249Z | false |
macrozheng/mall | https://github.com/macrozheng/mall/blob/dd6569c3558f79af5b21aad601349e0f029b9a6d/mall-search/src/main/java/com/macro/mall/search/domain/EsProduct.java | mall-search/src/main/java/com/macro/mall/search/domain/EsProduct.java | package com.macro.mall.search.domain;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;
import org.springframework.data.elasticsearch.annotations.Setting;
import java.io.Serializable;
import java.math.BigDecimal;
import java.util.List;
/**
* 搜索商品的信息
* Created by macro on 2018/6/19.
*/
@Data
@EqualsAndHashCode
@Document(indexName = "pms")
@Setting(shards = 1,replicas = 0)
public class EsProduct implements Serializable {
private static final long serialVersionUID = -1L;
@Id
private Long id;
@Field(type = FieldType.Keyword)
private String productSn;
private Long brandId;
@Field(type = FieldType.Keyword)
private String brandName;
private Long productCategoryId;
@Field(type = FieldType.Keyword)
private String productCategoryName;
private String pic;
@Field(analyzer = "ik_max_word",type = FieldType.Text)
private String name;
@Field(analyzer = "ik_max_word",type = FieldType.Text)
private String subTitle;
@Field(analyzer = "ik_max_word",type = FieldType.Text)
private String keywords;
private BigDecimal price;
private Integer sale;
private Integer newStatus;
private Integer recommandStatus;
private Integer stock;
private Integer promotionType;
private Integer sort;
@Field(type = FieldType.Nested, fielddata = true)
private List<EsProductAttributeValue> attrValueList;
}
| java | Apache-2.0 | dd6569c3558f79af5b21aad601349e0f029b9a6d | 2026-01-04T14:45:56.650249Z | false |
macrozheng/mall | https://github.com/macrozheng/mall/blob/dd6569c3558f79af5b21aad601349e0f029b9a6d/mall-search/src/main/java/com/macro/mall/search/domain/EsProductAttributeValue.java | mall-search/src/main/java/com/macro/mall/search/domain/EsProductAttributeValue.java | package com.macro.mall.search.domain;
import lombok.Data;
import lombok.EqualsAndHashCode;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;
import java.io.Serializable;
/**
* 搜索商品的属性信息
* Created by macro on 2018/6/27.
*/
@Data
@EqualsAndHashCode
public class EsProductAttributeValue implements Serializable {
private static final long serialVersionUID = 1L;
private Long id;
private Long productAttributeId;
//属性值
@Field(type = FieldType.Keyword)
private String value;
//属性参数：0->规格；1->参数
private Integer type;
//属性名称
@Field(type=FieldType.Keyword)
private String name;
}
| java | Apache-2.0 | dd6569c3558f79af5b21aad601349e0f029b9a6d | 2026-01-04T14:45:56.650249Z | false |
macrozheng/mall | https://github.com/macrozheng/mall/blob/dd6569c3558f79af5b21aad601349e0f029b9a6d/mall-search/src/main/java/com/macro/mall/search/repository/EsProductRepository.java | mall-search/src/main/java/com/macro/mall/search/repository/EsProductRepository.java | package com.macro.mall.search.repository;
import com.macro.mall.search.domain.EsProduct;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.Pageable;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
/**
* 搜索商品ES操作类
* Created by macro on 2018/6/19.
*/
public interface EsProductRepository extends ElasticsearchRepository<EsProduct, Long> {
/**
* 搜索查询
*
* @param name 商品名称
* @param subTitle 商品标题
* @param keywords 商品关键字
* @param page 分页信息
*/
Page<EsProduct> findByNameOrSubTitleOrKeywords(String name, String subTitle, String keywords,Pageable page);
}
| java | Apache-2.0 | dd6569c3558f79af5b21aad601349e0f029b9a6d | 2026-01-04T14:45:56.650249Z | false |
macrozheng/mall | https://github.com/macrozheng/mall/blob/dd6569c3558f79af5b21aad601349e0f029b9a6d/mall-search/src/main/java/com/macro/mall/search/config/MyBatisConfig.java | mall-search/src/main/java/com/macro/mall/search/config/MyBatisConfig.java | package com.macro.mall.search.config;
import org.mybatis.spring.annotation.MapperScan;
import org.springframework.context.annotation.Configuration;
/**
* MyBatis相关配置
* Created by macro on 2019/4/8.
*/
@Configuration
@MapperScan({"com.macro.mall.mapper","com.macro.mall.search.dao"})
public class MyBatisConfig {
}
| java | Apache-2.0 | dd6569c3558f79af5b21aad601349e0f029b9a6d | 2026-01-04T14:45:56.650249Z | false |
macrozheng/mall | https://github.com/macrozheng/mall/blob/dd6569c3558f79af5b21aad601349e0f029b9a6d/mall-search/src/main/java/com/macro/mall/search/config/SwaggerConfig.java | mall-search/src/main/java/com/macro/mall/search/config/SwaggerConfig.java | package com.macro.mall.search.config;
import com.macro.mall.common.config.BaseSwaggerConfig;
import com.macro.mall.common.domain.SwaggerProperties;
import org.springframework.beans.factory.config.BeanPostProcessor;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
/**
* Swagger API文档相关配置
* Created by macro on 2018/4/26.
*/
@Configuration
@EnableSwagger2
public class SwaggerConfig extends BaseSwaggerConfig {
@Override
public SwaggerProperties swaggerProperties() {
return SwaggerProperties.builder()
.apiBasePackage("com.macro.mall.search.controller")
.title("mall搜索系统")
.description("mall搜索相关接口文档")
.contactName("macro")
.version("1.0")
.enableSecurity(false)
.build();
}
@Bean
public BeanPostProcessor springfoxHandlerProviderBeanPostProcessor() {
return generateBeanPostProcessor();
}
}
| java | Apache-2.0 | dd6569c3558f79af5b21aad601349e0f029b9a6d | 2026-01-04T14:45:56.650249Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/test/java/com/taobao/arthas/grpcweb/proxy/server/MessageUtilsTest.java | labs/arthas-grpc-web-proxy/src/test/java/com/taobao/arthas/grpcweb/proxy/server/MessageUtilsTest.java | package com.taobao.arthas.grpcweb.proxy.server;
import com.taobao.arthas.grpcweb.proxy.MessageUtils;
import org.junit.Assert;
import org.junit.Test;
public class MessageUtilsTest {
@Test
public void testValidateContentType(){
String contentType1 = "application/grpc-web";
MessageUtils.ContentType result1 = MessageUtils.validateContentType(contentType1);
String contentType2 = "application/grpc-web+proto";
MessageUtils.ContentType result2 = MessageUtils.validateContentType(contentType2);
String contentType3 = "application/grpc-web-text";
MessageUtils.ContentType result3 = MessageUtils.validateContentType(contentType3);
String contentType4 = "application/grpc-web-text+proto";
MessageUtils.ContentType result4 = MessageUtils.validateContentType(contentType4);
MessageUtils.ContentType result5 = MessageUtils.ContentType.GRPC_WEB_BINARY;
try {
String contentType5 = null;
result5 = MessageUtils.validateContentType(contentType5);
}catch (IllegalArgumentException e){
result5 = null;
}
Assert.assertEquals(result1,MessageUtils.ContentType.GRPC_WEB_BINARY);
Assert.assertEquals(result2,MessageUtils.ContentType.GRPC_WEB_BINARY);
Assert.assertEquals(result3,MessageUtils.ContentType.GRPC_WEB_TEXT);
Assert.assertEquals(result4,MessageUtils.ContentType.GRPC_WEB_TEXT);
Assert.assertNull(result5);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/test/java/com/taobao/arthas/grpcweb/proxy/server/MessageDeframerTest.java | labs/arthas-grpc-web-proxy/src/test/java/com/taobao/arthas/grpcweb/proxy/server/MessageDeframerTest.java | package com.taobao.arthas.grpcweb.proxy.server;
import com.taobao.arthas.grpcweb.proxy.MessageDeframer;
import com.taobao.arthas.grpcweb.proxy.MessageUtils;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufInputStream;
import io.netty.buffer.Unpooled;
import io.netty.util.CharsetUtil;
import org.apache.http.entity.StringEntity;
import org.apache.http.message.BasicHeader;
import org.apache.http.protocol.HTTP;
import org.junit.Assert;
import org.junit.Test;
import java.io.InputStream;
import java.util.Arrays;
public class MessageDeframerTest {
@Test
public void testProcessInput(){
String str = "AAAAAAcKBWhlbGxv";
ByteBuf content = Unpooled.copiedBuffer(str, CharsetUtil.UTF_8);
InputStream in = new ByteBufInputStream(content);
String contentTypeStr = "application/grpc-web-text";
MessageUtils.ContentType contentType = MessageUtils.validateContentType(contentTypeStr);
MessageDeframer deframer = new MessageDeframer();
boolean result = deframer.processInput(in, contentType);
Assert.assertTrue(result);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/test/java/com/taobao/arthas/grpcweb/proxy/server/StartGrpcTest.java | labs/arthas-grpc-web-proxy/src/test/java/com/taobao/arthas/grpcweb/proxy/server/StartGrpcTest.java | package com.taobao.arthas.grpcweb.proxy.server;
import com.taobao.arthas.grpcweb.proxy.server.grpcService.EchoImpl;
import com.taobao.arthas.grpcweb.proxy.server.grpcService.GreeterService;
import com.taobao.arthas.grpcweb.proxy.server.grpcService.HelloImpl;
import io.grpc.BindableService;
import io.grpc.Server;
import io.grpc.ServerBuilder;
import java.io.IOException;
public class StartGrpcTest {
private int GRPC_PORT;
public StartGrpcTest(int grpcPort){
this.GRPC_PORT = grpcPort;
}
public void startGrpcService(){
try {
Server grpcServer = ServerBuilder.forPort(GRPC_PORT).addService((BindableService) new GreeterService())
.addService((BindableService) new HelloImpl()).addService(new EchoImpl()).build();
grpcServer.start();
System.out.println("started gRPC server on port # " + GRPC_PORT);
System.in.read();
} catch (IOException e) {
System.out.println("fail to start gRPC server");
throw new RuntimeException(e);
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/test/java/com/taobao/arthas/grpcweb/proxy/server/StartGrpcWebProxyTest.java | labs/arthas-grpc-web-proxy/src/test/java/com/taobao/arthas/grpcweb/proxy/server/StartGrpcWebProxyTest.java | package com.taobao.arthas.grpcweb.proxy.server;
public class StartGrpcWebProxyTest {
private int GRPC_WEB_PROXY_PORT;
private int GRPC_PORT;
public StartGrpcWebProxyTest(int grpcWebPort, int grpcPort){
this.GRPC_WEB_PROXY_PORT = grpcWebPort;
this.GRPC_PORT = grpcPort;
}
public void startGrpcWebProxy(){
GrpcWebProxyServer grpcWebProxyServer = new GrpcWebProxyServer(GRPC_WEB_PROXY_PORT, GRPC_PORT);
grpcWebProxyServer.start();
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/test/java/com/taobao/arthas/grpcweb/proxy/server/GrpcWebProxyServerTest.java | labs/arthas-grpc-web-proxy/src/test/java/com/taobao/arthas/grpcweb/proxy/server/GrpcWebProxyServerTest.java | package com.taobao.arthas.grpcweb.proxy.server;
import grpc.gateway.testing.Echo;
import org.apache.http.HttpEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.message.BasicHeader;
import org.apache.http.protocol.HTTP;
import org.apache.http.util.EntityUtils;
import com.taobao.arthas.common.SocketUtils;
import org.junit.Before;
import org.junit.Test;
import java.io.IOException;
import java.io.InputStream;
import java.util.Arrays;
import java.util.Base64;
public class GrpcWebProxyServerTest {
private int GRPC_WEB_PROXY_PORT;
private int GRPC_PORT;
private String hostName;
private CloseableHttpClient httpClient;
@Before
public void startServer(){
GRPC_WEB_PROXY_PORT = SocketUtils.findAvailableTcpPort();
GRPC_PORT = SocketUtils.findAvailableTcpPort();
// 启动grpc服务
Thread grpcStart = new Thread(() -> {
StartGrpcTest startGrpcTest = new StartGrpcTest(GRPC_PORT);
startGrpcTest.startGrpcService();
});
grpcStart.start();
// 启动grpc-web-proxy服务
Thread grpcWebProxyStart = new Thread(() -> {
StartGrpcWebProxyTest startGrpcWebProxyTest = new StartGrpcWebProxyTest(GRPC_WEB_PROXY_PORT,GRPC_PORT);
startGrpcWebProxyTest.startGrpcWebProxy();
});
grpcWebProxyStart.start();
try {
// waiting for the server to start
Thread.sleep(1000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
hostName = "http://127.0.0.1:" + GRPC_WEB_PROXY_PORT;
httpClient = HttpClients.createDefault();
}
@Test
public void simpleReqTest() {
// 单个response
String url = hostName +"/grpc.gateway.testing.EchoService/Echo";
String requestStr = "hello world!!!";
Echo.EchoRequest request = Echo.EchoRequest.newBuilder().setMessage(requestStr).build();
System.out.println("request message--->" + requestStr);
byte[] requestData = request.toByteArray();
requestData = ByteArrayWithLengthExample(requestData);
// 编码请求载荷为gRPC-Web格式
String encodedPayload = Base64.getEncoder().encodeToString(requestData);
try {
String result = "";
String encoding = "utf-8";
HttpPost httpPost = getPost(url, encodedPayload, encoding);
//发送请求，并拿到结果（同步阻塞）
CloseableHttpResponse response = httpClient.execute(httpPost);
//获取返回结果
HttpEntity entity = response.getEntity();
if (entity != null) {
//按指定编码转换结果实体为String类型
result = EntityUtils.toString(entity, encoding);
}
EntityUtils.consume(entity);
//释放Http请求链接
response.close();
System.out.println("result-->" + result);
System.out.println("after decode...");
// gAAAAA9ncnBjLXN0YXR1czowDQo= 是结尾字符
int endStartIndex = result.indexOf("gAAAAA");
String data = result.substring(0,endStartIndex);
String end = result.substring(endStartIndex,result.length());
byte[] decodedData = Base64.getDecoder().decode(data);
byte[] decodedEnd = Base64.getDecoder().decode(end);
// 去掉前5个byte
decodedData = RemoveBytesExample(decodedData);
decodedEnd = RemoveBytesExample(decodedEnd);
Echo.EchoResponse echoResponse = Echo.EchoResponse.parseFrom(decodedData);
System.out.println("response message--->" + echoResponse.getMessage());
String endStr = new String(decodedEnd);
System.out.println(endStr);
} catch (Exception e) {
e.printStackTrace();
}
}
@Test
public void streamReqTest() {
// stream response
String url = hostName + "/grpc.gateway.testing.EchoService/ServerStreamingEcho";
String requestStr = "hello world!!!";
Echo.ServerStreamingEchoRequest request = Echo.ServerStreamingEchoRequest.newBuilder().setMessage(requestStr)
.setMessageCount(5)
.build();
byte[] requestData = request.toByteArray();
requestData = ByteArrayWithLengthExample(requestData);
// 编码请求载荷为gRPC-Web格式
String encodedPayload = Base64.getEncoder().encodeToString(requestData);
try {
String encoding = "utf-8";
HttpPost httpPost = getPost(url, encodedPayload, encoding);
//发送请求
CloseableHttpResponse response = httpClient.execute(httpPost);
//获取返回结果
HttpEntity entity = response.getEntity();
if (entity != null) {
try (InputStream inputStream = entity.getContent()) {
// 在这里使用 inputStream 流式处理响应内容
// 例如，逐行读取响应内容
byte[] buffer = new byte[1024];
int bytesRead;
while ((bytesRead = inputStream.read(buffer)) != -1) {
// 处理读取的数据
String result = new String(buffer, 0, bytesRead);
System.out.println("result-->" + result);
System.out.println("after decode...");
// gAAAAA9ncnBjLXN0YXR1czowDQo= 是结尾字符
byte[] decodedData = Base64.getDecoder().decode(result);
// 去掉前5个byte
decodedData = RemoveBytesExample(decodedData);
if(result.startsWith("gAAAAA")){
String end = new String(decodedData);
System.out.println(end);
}else {
Echo.ServerStreamingEchoResponse echoResponse = Echo.ServerStreamingEchoResponse.parseFrom(decodedData);
System.out.println("response message--->" + echoResponse.getMessage());
}
}
}
}
EntityUtils.consume(entity);
//释放Http请求链接
response.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public HttpPost getPost(String url, String param, String encoding) throws IOException {
System.out.println("request param(encode)--->" + param);
//创建post方式请求对象
HttpPost httpPost = new HttpPost (url);
//设置请求参数实体
StringEntity reqParam = new StringEntity(param,encoding);
reqParam.setContentEncoding(new BasicHeader(HTTP.CONTENT_TYPE, "application/grpc-web-text"));
// 将请求参数放到请求对象中
httpPost.setEntity(reqParam);
//设置请求报文头信息
httpPost.setHeader("Connection","keep-alive");
httpPost.setHeader("Accept", "application/grpc-web-text");
httpPost.setHeader("Content-type", "application/grpc-web-text");//设置发送表单请求
httpPost.setHeader("X-Grpc-Web","1");
httpPost.setHeader("X-User-Agent", "grpc-web-javascript/0.1");
httpPost.setHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36");
return httpPost;
}
public byte[] ByteArrayWithLengthExample(byte[] data){
// 添加长度信息,用于编码过程
int length = data.length;
byte[] newData = {0,0,0,0,(byte) length};
byte[] combineArray = new byte[newData.length + data.length];
System.arraycopy(newData, 0, combineArray, 0, newData.length);
System.arraycopy(data, 0, combineArray, newData.length, data.length);
return combineArray;
}
public byte[] RemoveBytesExample(byte[] data){
// 去掉长度信息,用于解码过程
byte[] result = Arrays.copyOfRange(data, 5, data.length);
return result;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/test/java/com/taobao/arthas/grpcweb/proxy/server/CorsUtilsTest.java | labs/arthas-grpc-web-proxy/src/test/java/com/taobao/arthas/grpcweb/proxy/server/CorsUtilsTest.java | package com.taobao.arthas.grpcweb.proxy.server;
import com.taobao.arthas.grpcweb.proxy.CorsUtils;
import io.netty.handler.codec.http.*;
import org.junit.Test;
public class CorsUtilsTest {
@Test
public void test(){
DefaultHttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
CorsUtils.updateCorsHeader(response.headers());
System.out.println(response.headers());
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/test/java/com/taobao/arthas/grpcweb/proxy/server/grpcService/EchoImpl.java | labs/arthas-grpc-web-proxy/src/test/java/com/taobao/arthas/grpcweb/proxy/server/grpcService/EchoImpl.java | package com.taobao.arthas.grpcweb.proxy.server.grpcService;
import grpc.gateway.testing.Echo.*;
import grpc.gateway.testing.EchoServiceGrpc.EchoServiceImplBase;
import io.grpc.Metadata;
import io.grpc.Metadata.Key;
import io.grpc.Status;
import io.grpc.stub.StreamObserver;
public class EchoImpl extends EchoServiceImplBase {
@Override
public void echo(EchoRequest request, StreamObserver<EchoResponse> responseObserver) {
String message = request.getMessage();
responseObserver.onNext(EchoResponse.newBuilder().setMessage(message).setMessageCount(1).build());
responseObserver.onCompleted();
}
@Override
public void echoAbort(EchoRequest request, StreamObserver<EchoResponse> responseObserver) {
// TODO Auto-generated method stub
responseObserver.onNext(EchoResponse.newBuilder().setMessage(request.getMessage()).build());
Metadata trailers = new Metadata();
Key<String> customKey = Key.of("custom-key", Metadata.ASCII_STRING_MARSHALLER);
// 添加自定义元数据
trailers.put(customKey, "custom-value");
responseObserver.onError(Status.ABORTED.withDescription("error desc").asException(trailers));
}
@Override
public void noOp(Empty request, StreamObserver<Empty> responseObserver) {
// TODO Auto-generated method stub
super.noOp(request, responseObserver);
}
@Override
public void serverStreamingEcho(ServerStreamingEchoRequest request,
StreamObserver<ServerStreamingEchoResponse> responseObserver) {
String message = request.getMessage();
int messageCount = request.getMessageCount();
System.err.println(message);
for (int i = 0; i < messageCount; ++i) {
responseObserver.onNext(ServerStreamingEchoResponse.newBuilder().setMessage(message).build());
}
responseObserver.onCompleted();
}
@Override
public void serverStreamingEchoAbort(ServerStreamingEchoRequest request,
StreamObserver<ServerStreamingEchoResponse> responseObserver) {
// TODO Auto-generated method stub
super.serverStreamingEchoAbort(request, responseObserver);
}
@Override
public StreamObserver<ClientStreamingEchoRequest> clientStreamingEcho(
StreamObserver<ClientStreamingEchoResponse> responseObserver) {
// TODO Auto-generated method stub
return super.clientStreamingEcho(responseObserver);
}
@Override
public StreamObserver<EchoRequest> fullDuplexEcho(StreamObserver<EchoResponse> responseObserver) {
// TODO Auto-generated method stub
return super.fullDuplexEcho(responseObserver);
}
@Override
public StreamObserver<EchoRequest> halfDuplexEcho(StreamObserver<EchoResponse> responseObserver) {
// TODO Auto-generated method stub
return super.halfDuplexEcho(responseObserver);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/test/java/com/taobao/arthas/grpcweb/proxy/server/grpcService/GreeterService.java | labs/arthas-grpc-web-proxy/src/test/java/com/taobao/arthas/grpcweb/proxy/server/grpcService/GreeterService.java | /*
* Copyright 2020 The gRPC Authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.taobao.arthas.grpcweb.proxy.server.grpcService;
import grpcweb.examples.greeter.GreeterGrpc;
import grpcweb.examples.greeter.GreeterOuterClass.HelloReply;
import grpcweb.examples.greeter.GreeterOuterClass.HelloRequest;
import io.grpc.stub.StreamObserver;
public class GreeterService extends GreeterGrpc.GreeterImplBase {
@Override
public void sayHello(HelloRequest req, StreamObserver<HelloReply> responseObserver) {
System.out.println("Greeter Service responding in sayhello() method");
// throw new RuntimeException("xxxxxx");
HelloReply reply = HelloReply.newBuilder().setMessage("Hello " + req.getName()).build();
responseObserver.onNext(reply);
responseObserver.onCompleted();
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/test/java/com/taobao/arthas/grpcweb/proxy/server/grpcService/HelloImpl.java | labs/arthas-grpc-web-proxy/src/test/java/com/taobao/arthas/grpcweb/proxy/server/grpcService/HelloImpl.java | package com.taobao.arthas.grpcweb.proxy.server.grpcService;
import helloworld.GreeterGrpc.GreeterImplBase;
import helloworld.Helloworld.HelloReply;
import helloworld.Helloworld.HelloRequest;
import helloworld.Helloworld.RepeatHelloRequest;
import io.grpc.stub.StreamObserver;
public class HelloImpl extends GreeterImplBase{
@Override
public void sayHello(HelloRequest request, StreamObserver<HelloReply> responseObserver) {
// TODO Auto-generated method stub
// super.sayHello(request, responseObserver);
System.err.println("sayHello");
// throw new RuntimeException("eeee");
responseObserver.onNext(HelloReply.newBuilder().setMessage("xxxx").build());
responseObserver.onCompleted();
}
@Override
public void sayRepeatHello(RepeatHelloRequest request, StreamObserver<HelloReply> responseObserver) {
// TODO Auto-generated method stub
// super.sayRepeatHello(request, responseObserver);
System.err.println("sayRepeatHello eeee ");
// throw new RuntimeException("eeee");
responseObserver.onNext(HelloReply.newBuilder().setMessage("xxxx").build());
responseObserver.onCompleted();
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/test/java/com/taobao/arthas/grpcweb/grpc/service/JavaObjectConverterTest.java | labs/arthas-grpc-web-proxy/src/test/java/com/taobao/arthas/grpcweb/grpc/service/JavaObjectConverterTest.java | package com.taobao.arthas.grpcweb.grpc.service;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import com.taobao.arthas.grpcweb.grpc.objectUtils.JavaObjectConverter;
import org.junit.Assert;
import org.junit.Test;
import io.arthas.api.ArthasServices.ArrayElement;
import io.arthas.api.ArthasServices.ArrayValue;
import io.arthas.api.ArthasServices.BasicValue;
import io.arthas.api.ArthasServices.CollectionValue;
import io.arthas.api.ArthasServices.JavaField;
import io.arthas.api.ArthasServices.JavaFields;
import io.arthas.api.ArthasServices.JavaObject;
import io.arthas.api.ArthasServices.MapEntry;
import io.arthas.api.ArthasServices.MapValue;
import io.arthas.api.ArthasServices.NullValue;
public class JavaObjectConverterTest {
@Test
public void testString() {
JavaObject javaObject = JavaObjectConverter.toJavaObject("sss");
System.err.println(javaObject);
assertNotNull(javaObject);
assertEquals("java.lang.String", javaObject.getClassName());
assertTrue(javaObject.hasBasicValue());
assertEquals("sss", javaObject.getBasicValue().getString());
}
@Test
public void testToJavaObjectWithBasicType() {
int intValue = 123;
JavaObject javaObject = JavaObjectConverter.toJavaObject(intValue);
assertNotNull(javaObject);
assertEquals("java.lang.Integer", javaObject.getClassName());
assertTrue(javaObject.hasBasicValue());
assertEquals(intValue, javaObject.getBasicValue().getInt());
}
@Test
public void testToJavaObjectWithArray() {
int[] intArray = { 1, 2, 3 };
JavaObject javaObject = JavaObjectConverter.toJavaObject(intArray);
assertNotNull(javaObject);
assertEquals("[I", javaObject.getClassName());
assertTrue(javaObject.hasArrayValue());
ArrayValue arrayValue = javaObject.getArrayValue();
assertNotNull(arrayValue);
assertEquals("int", arrayValue.getClassName());
assertEquals(3, arrayValue.getElementsCount());
ArrayElement element = arrayValue.getElements(1);
assertEquals(2, element.getBasicValue().getInt());
}
@Test
public void testToJavaObjectWithMultiDimensionalArray() {
int[][] multiDimensionalArray = { { 1, 2, 3 }, { 4, 5, 6 } };
JavaObject javaObject = JavaObjectConverter.toJavaObjectWithExpand(multiDimensionalArray,2);
assertNotNull(javaObject);
assertEquals("[[I", javaObject.getClassName());
assertTrue(javaObject.hasArrayValue());
ArrayValue arrayValue = javaObject.getArrayValue();
assertNotNull(arrayValue);
assertEquals("[I", arrayValue.getClassName());
assertEquals(2, arrayValue.getElementsCount());
ArrayElement element = arrayValue.getElements(0);
assertTrue(element.hasArrayValue());
ArrayValue arrayValue1 = element.getArrayValue();
assertEquals("int", arrayValue1.getClassName());
ArrayElement element1 = arrayValue1.getElements(0);
assertEquals(3, arrayValue1.getElementsCount());
assertTrue(element1.hasBasicValue());
BasicValue basicValue = element1.getBasicValue();
assertEquals(1, basicValue.getInt());
}
@Test
public void testToJavaObjectWithCollection() {
List<String> stringList = new ArrayList<>();
stringList.add("foo");
stringList.add("bar");
stringList.add("baz");
JavaObject javaObject = JavaObjectConverter.toJavaObject(stringList);
assertNotNull(javaObject);
assertEquals("java.util.ArrayList", javaObject.getClassName());
assertTrue(javaObject.hasCollection());
CollectionValue collectionValue = javaObject.getCollection();
assertNotNull(collectionValue);
assertEquals(3, collectionValue.getElementsCount());
JavaObject object3 = collectionValue.getElements(2);
assertEquals("baz", object3.getBasicValue().getString());
}
@Test
public void testToJavaObjectWithMap() {
Map<String, Integer> stringIntegerMap = new HashMap<>();
stringIntegerMap.put("one", 1);
stringIntegerMap.put("two", 2);
JavaObject javaObject = JavaObjectConverter.toJavaObject(stringIntegerMap);
assertNotNull(javaObject);
assertEquals("java.util.HashMap", javaObject.getClassName());
assertTrue(javaObject.hasMap());
MapValue mapValue = javaObject.getMap();
assertNotNull(mapValue);
assertEquals(2, mapValue.getEntriesCount());
MapEntry mapEntry = mapValue.getEntries(0);
JavaObject key = mapEntry.getKey();
assertEquals("one", key.getBasicValue().getString());
JavaObject value = mapEntry.getValue();
assertEquals(1, value.getBasicValue().getInt());
}
@Test
public void testToJavaObject() {
// 创建一个复杂的 Object
ComplexObject complexObject = createComplexObject();
// 转换为 JavaObject
JavaObject javaObject = JavaObjectConverter.toJavaObject(complexObject);
// 对转换后的 JavaObject 进行断言，验证各个 field 的值是否一致
Assert.assertNotNull(javaObject);
Assert.assertEquals(ComplexObject.class.getName(), javaObject.getClassName());
JavaFields fields = javaObject.getFields();
Map<String, JavaField> fieldMap = fields.getFieldsList().stream()
.collect(Collectors.toMap(JavaField::getName, field -> field));
// 验证基础类型字段
BasicValue basicValue = fieldMap.get("basicValue").getBasicValue();
Assert.assertEquals(5, basicValue.getInt());
// 验证集合字段
JavaField collection = fieldMap.get("collection");
CollectionValue collectionValue = collection.getCollection();
Assert.assertEquals(2, collectionValue.getElementsCount());
// 验证数组字段
JavaField array = fieldMap.get("arrayValue");
ArrayValue arrayValue = array.getArrayValue();
Assert.assertEquals(2, arrayValue.getElementsCount());
// 验证嵌套对象字段
JavaField nestedObject = fieldMap.get("nestedObject");
JavaObject nestedJavaObject = nestedObject.getObjectValue();
JavaFields nestedObjectFields = nestedJavaObject.getFields();
Assert.assertEquals(1, nestedObjectFields.getFieldsCount());
JavaField nestedObjectField = nestedObjectFields.getFields(0);
Assert.assertEquals("stringValue", nestedObjectField.getName());
Assert.assertEquals("nestedValue", nestedObjectField.getBasicValue().getString());
}
private ComplexObject createComplexObject() {
ComplexObject complexObject = new ComplexObject();
complexObject.setBasicValue(5);
complexObject.setCollection(Arrays.asList("element1", "element2"));
complexObject.setArrayValue(new int[] { 1, 2 });
complexObject.setNestedObject(new NestedObject("nestedValue"));
return complexObject;
}
private static class ComplexObject {
private int basicValue;
private Collection<String> collection;
private int[] arrayValue;
private NestedObject nestedObject;
public int getBasicValue() {
return basicValue;
}
public void setBasicValue(int basicValue) {
this.basicValue = basicValue;
}
public Collection<String> getCollection() {
return collection;
}
public void setCollection(Collection<String> collection) {
this.collection = collection;
}
public int[] getArrayValue() {
return arrayValue;
}
public void setArrayValue(int[] arrayValue) {
this.arrayValue = arrayValue;
}
public NestedObject getNestedObject() {
return nestedObject;
}
public void setNestedObject(NestedObject nestedObject) {
this.nestedObject = nestedObject;
}
}
private static class NestedObject {
private String stringValue;
public NestedObject(String stringValue) {
this.stringValue = stringValue;
}
public String getStringValue() {
return stringValue;
}
public void setStringValue(String stringValue) {
this.stringValue = stringValue;
}
}
private static class TestObject {
private Double[] doubleArray;
public Double[] getDoubleArray() {
return doubleArray;
}
public void setDoubleArray(Double[] doubleArray) {
this.doubleArray = doubleArray;
}
}
@Test
public void testObjectWithDubboArrayField() {
// 创建测试对象
TestObject testObject = new TestObject();
testObject.setDoubleArray(new Double[] { 1.0, 2.0, 3.0 });
// 转换为JavaObject
JavaObject javaObject = JavaObjectConverter.toJavaObject(testObject);
// 检查各个field的值是否一致
for (int i = 0; i < testObject.getDoubleArray().length; i++) {
Double expectedValue = testObject.getDoubleArray()[i];
ArrayValue arrayValue = javaObject.getFields().getFields(0).getArrayValue();
ArrayElement arrayElement = arrayValue.getElements(i);
Double actualValue = arrayElement.getBasicValue().getDouble();
Assert.assertEquals(expectedValue, actualValue);
}
}
@Test
public void testToJavaObjectWithNullValue() {
JavaObject result = JavaObjectConverter.toJavaObject(null);
assertNotNull(result);
assertTrue(result.hasNullValue());
assertEquals(NullValue.getDefaultInstance(), result.getNullValue());
}
@Test
public void testToJavaObjectWithNullKeyInMap() {
Map<String, Object> map = new HashMap<>();
map.put(null, "value");
JavaObject result = JavaObjectConverter.toJavaObject(map);
assertNotNull(result);
assertTrue(result.hasMap());
MapValue mapValue = result.getMap();
assertEquals(1, mapValue.getEntriesCount());
MapEntry entry = mapValue.getEntries(0);
assertNotNull(entry.getKey());
assertTrue(entry.getKey().hasNullValue());
assertEquals(NullValue.getDefaultInstance(), entry.getKey().getNullValue());
assertNotNull(entry.getValue());
assertTrue(entry.getValue().hasBasicValue());
assertEquals("value", entry.getValue().getBasicValue().getString());
}
@Test
public void testToJavaObjectWithNullValueInArray() {
Object[] array = new Object[3];
array[0] = "value";
array[1] = null;
array[2] = 123;
JavaObject result = JavaObjectConverter.toJavaObject(array);
assertNotNull(result);
assertTrue(result.hasArrayValue());
ArrayValue arrayValue = result.getArrayValue();
assertEquals(3, arrayValue.getElementsCount());
ArrayElement element1 = arrayValue.getElements(0);
assertTrue(element1.hasObjectValue());
JavaObject objectValue1 = element1.getObjectValue();
assertTrue(objectValue1.hasBasicValue());
assertEquals("value", objectValue1.getBasicValue().getString());
ArrayElement element2 = arrayValue.getElements(1);
assertNotNull(element2.getNullValue());
ArrayElement element3 = arrayValue.getElements(2);
assertTrue(element3.hasObjectValue());
JavaObject objectValue3 = element3.getObjectValue();
assertTrue(objectValue3.hasBasicValue());
assertEquals(123, objectValue3.getBasicValue().getInt());
}
} | java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/GrpcServiceConnectionManager.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/GrpcServiceConnectionManager.java | /*
* Copyright 2020 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.taobao.arthas.grpcweb.proxy;
import io.grpc.Channel;
import io.grpc.ClientInterceptors;
import io.grpc.ManagedChannel;
import io.grpc.ManagedChannelBuilder;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import java.lang.invoke.MethodHandles;
/**
* TODO: Manage the connection pool to talk to the grpc-service
*/
public class GrpcServiceConnectionManager {
private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass().getName());
private final ManagedChannel channel;
public GrpcServiceConnectionManager(int grpcPortNum) {
// TODO: Manage a connection pool.
channel = ManagedChannelBuilder.forAddress("localhost", grpcPortNum).usePlaintext().build();
logger.info("**** connection channel initiated");
}
Channel getChannelWithClientInterceptor(GrpcWebClientInterceptor interceptor) {
return ClientInterceptors.intercept(channel, interceptor);
}
public ManagedChannel getChannel() {
return channel;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/MessageUtils.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/MessageUtils.java | /*
* Copyright 2020 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.taobao.arthas.grpcweb.proxy;
import com.google.common.annotations.VisibleForTesting;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
public class MessageUtils {
@VisibleForTesting
public
enum ContentType {
GRPC_WEB_BINARY, GRPC_WEB_TEXT;
}
private static Map<String, ContentType> GRPC_GCP_CONTENT_TYPES = new HashMap<String, ContentType>() {
{
put("application/grpc-web", ContentType.GRPC_WEB_BINARY);
put("application/grpc-web+proto", ContentType.GRPC_WEB_BINARY);
put("application/grpc-web-text", ContentType.GRPC_WEB_TEXT);
put("application/grpc-web-text+proto", ContentType.GRPC_WEB_TEXT);
}
};
/**
* Validate the content-type
*/
public static ContentType validateContentType(String contentType) throws IllegalArgumentException {
if (contentType == null || !GRPC_GCP_CONTENT_TYPES.containsKey(contentType)) {
throw new IllegalArgumentException("This content type is not used for grpc-web: " + contentType);
}
return getContentType(contentType);
}
static ContentType getContentType(String type) {
return GRPC_GCP_CONTENT_TYPES.get(type);
}
/**
* Find the input arg protobuf class for the given rpc-method. Convert the given
* bytes to the input protobuf. return that.
*/
static Object getInputProtobufObj(Method rpcMethod, byte[] in) {
Class[] inputArgs = rpcMethod.getParameterTypes();
Class inputArgClass = inputArgs[0];
// use the inputArg classtype to create a protobuf object
Method parseFromObj;
try {
parseFromObj = inputArgClass.getMethod("parseFrom", byte[].class);
} catch (NoSuchMethodException e) {
throw new IllegalArgumentException("Couldn't find method in 'parseFrom' in " + inputArgClass.getName());
}
Object inputObj;
try {
inputObj = parseFromObj.invoke(null, in);
} catch (InvocationTargetException | IllegalAccessException e) {
throw new IllegalArgumentException(e);
}
if (inputObj == null || !inputArgClass.isInstance(inputObj)) {
throw new IllegalArgumentException("Input obj is **not** instance of the correct input class type");
}
return inputObj;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/MessageDeframer.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/MessageDeframer.java | /*
* Copyright 2020 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.taobao.arthas.grpcweb.proxy;
import com.taobao.arthas.grpcweb.proxy.MessageUtils.ContentType;
import com.taobao.arthas.common.IOUtils;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import java.io.IOException;
import java.io.InputStream;
import java.lang.invoke.MethodHandles;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Base64;
/**
* Reads frames from the input bytes and returns a single message.
*/
public class MessageDeframer {
private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass().getName());
static final byte DATA_BYTE = (byte) 0x00;
// TODO: fix this code to be able to handle upto 4GB input size.
private int mLength = 0;
private int mReadSoFar = 0;
private ArrayList<byte[]> mFrames = new ArrayList<>();
private byte[] mMsg = null;
private int mNumFrames;
byte[] getMessageBytes() {
return mMsg;
}
int getLength() {
return mLength;
}
int getNumberOfFrames() {
return mNumFrames;
}
/**
* Reads the bytes from the given InputStream and populates bytes in
* {@link #mMsg}
*/
public boolean processInput(InputStream in, MessageUtils.ContentType contentType) {
byte[] inBytes;
try {
InputStream inStream = (contentType == ContentType.GRPC_WEB_TEXT) ? Base64.getDecoder().wrap(in) : in;
inBytes = IOUtils.getBytes(inStream);
} catch (IOException e) {
e.printStackTrace();
logger.warn("invalid input");
return false;
}
if (inBytes.length < 5) {
logger.debug("invalid input. Expected minimum of 5 bytes");
return false;
}
while (getNextFrameBytes(inBytes)) {
}
mNumFrames = mFrames.size();
// common case is only one frame.
if (mNumFrames == 1) {
mMsg = mFrames.get(0);
} else {
// concatenate all frames into one byte array
// TODO: this is inefficient.
mMsg = new byte[mLength];
int offset = 0;
for (byte[] f : mFrames) {
System.arraycopy(f, 0, mMsg, offset, f.length);
offset += f.length;
}
mFrames = null;
}
return true;
}
/** returns true if the next frame is a DATA frame */
private boolean getNextFrameBytes(byte[] inBytes) {
// Firstbyte should be 0x00 (for this to be a DATA frame)
int firstByteValue = inBytes[mReadSoFar] | DATA_BYTE;
if (firstByteValue != 0) {
logger.debug("done with DATA bytes");
return false;
}
// Next 4 bytes = length of the bytes array starting after the 4 bytes.
int offset = mReadSoFar + 1;
int len = ByteBuffer.wrap(inBytes, offset, 4).getInt();
// Empty message is special case.
// TODO: Can this is special handling be removed?
if (len == 0) {
mFrames.add(new byte[0]);
return false;
}
// Make sure we have enough bytes in the inputstream
int expectedNumBytes = len + 5 + mReadSoFar;
if (inBytes.length < expectedNumBytes) {
logger.warn(String.format("input doesn't have enough bytes. expected: %d, found %d", expectedNumBytes,
inBytes.length));
return false;
}
// Read "len" bytes into message
mLength += len;
offset += 4;
byte[] inputBytes = Arrays.copyOfRange(inBytes, offset, len + offset);
mFrames.add(inputBytes);
mReadSoFar += (len + 5);
// we have more frames to process, if there are bytes unprocessed
return inBytes.length > mReadSoFar;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/SingleHttpChunkedInput.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/SingleHttpChunkedInput.java | /*
* Copyright 2014 The Netty Project
*
* The Netty Project licenses this file to you under the Apache License,
* version 2.0 (the "License"); you may not use this file except in compliance
* with the License. You may obtain a copy of the License at:
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
package com.taobao.arthas.grpcweb.proxy;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufAllocator;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.DefaultHttpContent;
import io.netty.handler.codec.http.HttpContent;
import io.netty.handler.codec.http.LastHttpContent;
import io.netty.handler.stream.ChunkedInput;
/**
* 和 LastHttpContent 对比，少了 LastHttpContent.EMPTY_LAST_CONTENT
*
* @see LastHttpContent
* @see LastHttpContent#EMPTY_LAST_CONTENT
*/
public class SingleHttpChunkedInput implements ChunkedInput<HttpContent> {
private final ChunkedInput<ByteBuf> input;
/**
* Creates a new instance using the specified input.
* @param input {@link ChunkedInput} containing data to write
*/
public SingleHttpChunkedInput(ChunkedInput<ByteBuf> input) {
this.input = input;
// lastHttpContent = LastHttpContent.EMPTY_LAST_CONTENT;
}
/**
* Creates a new instance using the specified input. {@code lastHttpContent} will be written as the terminating
* chunk.
* @param input {@link ChunkedInput} containing data to write
* @param lastHttpContent {@link LastHttpContent} that will be written as the terminating chunk. Use this for
* training headers.
*/
public SingleHttpChunkedInput(ChunkedInput<ByteBuf> input, LastHttpContent lastHttpContent) {
this.input = input;
// this.lastHttpContent = lastHttpContent;
}
@Override
public boolean isEndOfInput() throws Exception {
if (input.isEndOfInput()) {
// Only end of input after last HTTP chunk has been sent
return true;
} else {
return false;
}
}
@Override
public void close() throws Exception {
input.close();
}
@Deprecated
@Override
public HttpContent readChunk(ChannelHandlerContext ctx) throws Exception {
return readChunk(ctx.alloc());
}
@Override
public HttpContent readChunk(ByteBufAllocator allocator) throws Exception {
if (input.isEndOfInput()) {
return null;
} else {
ByteBuf buf = input.readChunk(allocator);
if (buf == null) {
return null;
}
return new DefaultHttpContent(buf);
}
}
@Override
public long length() {
return input.length();
}
@Override
public long progress() {
return input.progress();
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/GrpcWebRequestHandler.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/GrpcWebRequestHandler.java | /*
* Copyright 2020 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.taobao.arthas.grpcweb.proxy;
import com.taobao.arthas.common.Pair;
import io.grpc.Channel;
import io.grpc.ManagedChannel;
import io.grpc.Metadata;
import io.grpc.Status;
import io.grpc.stub.MetadataUtils;
import io.grpc.stub.StreamObserver;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.ByteBufInputStream;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.*;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import java.io.InputStream;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Method;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
public class GrpcWebRequestHandler {
private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass().getName());
private final GrpcServiceConnectionManager grpcServiceConnectionManager;
public GrpcWebRequestHandler(GrpcServiceConnectionManager g) {
grpcServiceConnectionManager = g;
}
public void handle(ChannelHandlerContext ctx, FullHttpRequest req) {
// 处理 CORS OPTIONS 请求
if (req.method().equals(HttpMethod.OPTIONS)) {
FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
CorsUtils.updateCorsHeader(response.headers());
ctx.writeAndFlush(response);
return;
}
String contentTypeStr = req.headers().get(HttpHeaderNames.CONTENT_TYPE);
MessageUtils.ContentType contentType = MessageUtils.validateContentType(contentTypeStr);
SendGrpcWebResponse sendResponse = new SendGrpcWebResponse(ctx, req);
try {
// From the request, get the rpc-method name and class name and then get their
// corresponding
// concrete objects.
QueryStringDecoder queryStringDecoder = new QueryStringDecoder(req.uri());
String pathInfo = queryStringDecoder.path();
Pair<String, String> classAndMethodNames = getClassAndMethod(pathInfo);
String className = classAndMethodNames.getFirst();
String methodName = classAndMethodNames.getSecond();
Class cls = getClassObject(className);
if (cls == null) {
logger.error("cannot find service impl in the request, className: " + className);
// incorrect classname specified in the request.
sendResponse.returnUnimplementedStatusCode(className);
return;
}
// Create a ClientInterceptor object
CountDownLatch latch = new CountDownLatch(1);
GrpcWebClientInterceptor interceptor = new GrpcWebClientInterceptor(latch, sendResponse);
Channel channel = grpcServiceConnectionManager.getChannelWithClientInterceptor(interceptor);
// get the stub for the rpc call and the method to be called within the stub
io.grpc.stub.AbstractStub asyncStub = getRpcStub(channel, cls, "newStub");
Metadata headers = MetadataUtil.getHtpHeaders(req.headers());
if (!headers.keys().isEmpty()) {
asyncStub = MetadataUtils.attachHeaders(asyncStub, headers);
}
Method asyncStubCall = getRpcMethod(asyncStub, methodName);
// Get the input object bytes
ByteBuf content = req.content();
InputStream in = new ByteBufInputStream(content);
MessageDeframer deframer = new MessageDeframer();
Object inObj = null;
if (deframer.processInput(in, contentType)) {
inObj = MessageUtils.getInputProtobufObj(asyncStubCall, deframer.getMessageBytes());
}
ManagedChannel managedChannel = grpcServiceConnectionManager.getChannel();
// Invoke the rpc call
asyncStubCall.invoke(asyncStub, inObj, new GrpcCallResponseReceiver(sendResponse, latch,managedChannel));
if (!latch.await( 1000, TimeUnit.MILLISECONDS)) {
logger.warn("grpc call took too long!");
}
} catch (Exception e) {
logger.error("try to invoke grpc serivce error, uri: {}", req.uri(), e);
sendResponse.writeError(Status.UNAVAILABLE.withCause(e));
}
}
private Pair<String, String> getClassAndMethod(String pathInfo) throws IllegalArgumentException {
// pathInfo starts with "/". ignore that first char.
String[] rpcClassAndMethodTokens = pathInfo.substring(1).split("/");
if (rpcClassAndMethodTokens.length != 2) {
throw new IllegalArgumentException("incorrect pathinfo: " + pathInfo);
}
String rpcClassName = rpcClassAndMethodTokens[0];
String rpcMethodNameRecvd = rpcClassAndMethodTokens[1];
String rpcMethodName = rpcMethodNameRecvd.substring(0, 1).toLowerCase() + rpcMethodNameRecvd.substring(1);
return new Pair<>(rpcClassName, rpcMethodName);
}
private Class<?> getClassObject(String className) {
Class rpcClass = null;
try {
rpcClass = Class.forName(className + "Grpc");
} catch (ClassNotFoundException e) {
logger.info("no such class " + className);
}
return rpcClass;
}
private io.grpc.stub.AbstractStub getRpcStub(Channel ch, Class cls, String stubName) {
try {
Method m = cls.getDeclaredMethod(stubName, io.grpc.Channel.class);
return (io.grpc.stub.AbstractStub) m.invoke(null, ch);
} catch (Exception e) {
logger.warn("Error when fetching " + stubName + " for: " + cls.getName());
throw new IllegalArgumentException(e);
}
}
/**
* Find the matching method in the stub class.
*/
private Method getRpcMethod(Object stub, String rpcMethodName) {
for (Method m : stub.getClass().getMethods()) {
if (m.getName().equals(rpcMethodName)) {
return m;
}
}
throw new IllegalArgumentException("Couldn't find rpcmethod: " + rpcMethodName);
}
private static class GrpcCallResponseReceiver<Object> implements StreamObserver {
private final SendGrpcWebResponse sendResponse;
private final CountDownLatch latch;
private final ManagedChannel channel;
GrpcCallResponseReceiver(SendGrpcWebResponse s, CountDownLatch c, ManagedChannel channel) {
sendResponse = s;
latch = c;
this.channel = channel;
}
@Override
public void onNext(java.lang.Object resp) {
// TODO verify that the resp object is of Class instance returnedCls.
byte[] outB = ((com.google.protobuf.GeneratedMessageV3) resp).toByteArray();
if(!sendResponse.writeResponse(outB)){
// 这里需要断开grpc
this.channel.shutdownNow();
logger.error("Grpc shutdown from grpc web proxy client");
}
}
@Override
public void onError(Throwable t) {
Status s = Status.fromThrowable(t);
sendResponse.writeError(s);
latch.countDown();
}
@Override
public void onCompleted() {
sendResponse.writeTrailer(Status.OK, null);
latch.countDown();
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/CorsUtils.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/CorsUtils.java | package com.taobao.arthas.grpcweb.proxy;
import io.netty.handler.codec.http.HttpHeaderNames;
import io.netty.handler.codec.http.HttpHeaders;
/**
* TODO 支持让用户配置更精细的 cors header
* @author hengyunabc 2023-09-07
*
*/
public class CorsUtils {
public static void updateCorsHeader(HttpHeaders headers) {
// headers.set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_HEADERS,
// StringUtils.joinWith(",", "user-agent", "cache-control", "content-type", "content-transfer-encoding",
// "grpc-timeout", "keep-alive"));
headers.set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_HEADERS, "*");
headers.set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_ORIGIN, "*");
headers.set(HttpHeaderNames.ACCESS_CONTROL_REQUEST_HEADERS, "content-type,x-grpc-web,x-user-agent");
headers.set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_METHODS, "OPTIONS,GET,POST,HEAD");
// headers.set(HttpHeaderNames.ACCESS_CONTROL_EXPOSE_HEADERS,
// StringUtils.joinWith(",", "grpc-status", "grpc-message"));
headers.set(HttpHeaderNames.ACCESS_CONTROL_EXPOSE_HEADERS, "*");
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/MetadataUtil.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/MetadataUtil.java | /*
* Copyright 2020 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.taobao.arthas.grpcweb.proxy;
import io.grpc.Metadata;
import io.netty.handler.codec.http.HttpHeaders;
import java.util.*;
class MetadataUtil {
private static final String BINARY_HEADER_SUFFIX = "-bin";
private static final String GRPC_HEADER_PREFIX = "x-grpc-";
private static final List<String> EXCLUDED = Arrays.asList("x-grpc-web", "content-type", "grpc-accept-encoding",
"grpc-encoding");
static Metadata getHtpHeaders(HttpHeaders headers) {
Metadata httpHeaders = new Metadata();
Set<String> headerNames = headers.names();
if (headerNames == null) {
return httpHeaders;
}
// copy all headers "x-grpc-*" into Metadata
// TODO: do we need to copy all "x-*" headers instead?
for (String headerName : headerNames) {
if (EXCLUDED.contains(headerName.toLowerCase())) {
continue;
}
if (headerName.toLowerCase().startsWith(GRPC_HEADER_PREFIX)) {
// Get all the values of this header.
List<String> values = headers.getAll(headerName);
if (values != null) {
// Java enumerations have klunky API. lets convert to a list.
// this will be a short list usually.
for (String s : values) {
if (headerName.toLowerCase().endsWith(BINARY_HEADER_SUFFIX)) {
// Binary header
httpHeaders.put(Metadata.Key.of(headerName, Metadata.BINARY_BYTE_MARSHALLER), s.getBytes());
} else {
// String header
httpHeaders.put(Metadata.Key.of(headerName, Metadata.ASCII_STRING_MARSHALLER), s);
}
}
}
}
}
return httpHeaders;
}
static Map<String, String> getHttpHeadersFromMetadata(Metadata trailer) {
Map<String, String> map = new HashMap<>();
for (String key : trailer.keys()) {
if (EXCLUDED.contains(key.toLowerCase())) {
continue;
}
if (key.endsWith(Metadata.BINARY_HEADER_SUFFIX)) {
// TODO allow any object type here
byte[] value = trailer.get(Metadata.Key.of(key, Metadata.BINARY_BYTE_MARSHALLER));
map.put(key, new String(value));
} else {
String value = trailer.get(Metadata.Key.of(key, Metadata.ASCII_STRING_MARSHALLER));
map.put(key, value);
}
}
return map;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/MessageFramer.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/MessageFramer.java | /*
* Copyright 2020 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.taobao.arthas.grpcweb.proxy;
/**
* Creates frames from the input bytes.
*/
public class MessageFramer {
public enum Type {
DATA ((byte) 0x00),
TRAILER ((byte) 0x80);
public final byte value;
Type(byte b) {
value = b;
}
}
// TODO: handle more than single frame; i.e., input byte array size > (2GB - 1)
public byte[] getPrefix(byte[] in, Type type) {
int len = in.length;
return new byte[] {
type.value,
(byte) ((len >> 24) & 0xff),
(byte) ((len >> 16) & 0xff),
(byte) ((len >> 8) & 0xff),
(byte) ((len >> 0) & 0xff),
};
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/GrpcWebClientInterceptor.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/GrpcWebClientInterceptor.java | /*
* Copyright 2020 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.taobao.arthas.grpcweb.proxy;
import io.grpc.*;
import io.grpc.ClientCall.Listener;
import io.grpc.ForwardingClientCall.SimpleForwardingClientCall;
import io.grpc.ForwardingClientCallListener.SimpleForwardingClientCallListener;
import java.util.concurrent.CountDownLatch;
class GrpcWebClientInterceptor implements ClientInterceptor {
private final CountDownLatch latch;
private final SendGrpcWebResponse sendResponse;
GrpcWebClientInterceptor(CountDownLatch latch, SendGrpcWebResponse send) {
this.latch = latch;
sendResponse = send;
}
@Override
public <ReqT, RespT> ClientCall<ReqT, RespT> interceptCall(MethodDescriptor<ReqT, RespT> method,
CallOptions callOptions, Channel channel) {
return new SimpleForwardingClientCall<ReqT, RespT>(channel.newCall(method, callOptions)) {
@Override
public void start(Listener<RespT> responseListener, Metadata headers) {
super.start(new MetadataResponseListener<RespT>(responseListener), headers);
}
};
}
class MetadataResponseListener<T> extends SimpleForwardingClientCallListener<T> {
private boolean headersSent = false;
MetadataResponseListener(Listener<T> responseListener) {
super(responseListener);
}
@Override
public void onHeaders(Metadata h) {
sendResponse.writeHeaders(h);
headersSent = true;
}
@Override
public void onClose(Status s, Metadata t) {
// TODO 这个函数会在 onCompleted 之前回调，这里有点奇怪
if (!headersSent) {
// seems, sometimes onHeaders() is not called before this method is called!
// so far, they are the error cases. let onError() method in ClientListener
// handle this call. Could ignore this.
// TODO is this correct? what if onError() never gets called?
} else {
sendResponse.writeTrailer(s, t);
latch.countDown();
}
super.onClose(s, t);
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/SendGrpcWebResponse.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/SendGrpcWebResponse.java | /*
* Copyright 2020 Google LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.taobao.arthas.grpcweb.proxy;
import com.taobao.arthas.grpcweb.proxy.MessageUtils.ContentType;
import io.grpc.Metadata;
import io.grpc.Status;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.*;
import io.netty.handler.stream.ChunkedStream;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.lang.invoke.MethodHandles;
import java.util.Base64;
import java.util.Map;
/**
* <pre>
* * https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-WEB.md
* * https://github.com/grpc/grpc/blob/master/doc/PROTOCOL-HTTP2.md
*
* 据协议和抓包分析，grpc-web 回应需要以 HTTP chunk数据包，包装 grpc 本身的数据。
*
* grpc-web 的 http1.1 Response 由三部分组成：
* 1. headers , 返回 status 总是 200
* 2. data chunk ，可能多个
* 3. trailer chunk , grpc的 grpc-status, grpc-message 在这里
*
* </pre>
*
* @author hengyunabc 2023-09-06
*
*/
class SendGrpcWebResponse {
private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass().getName());
private final String contentType;
/**
* 回应的 http1.1 header 是否已发送
*/
private boolean isHeaderSent = false;
/**
* 所有的 grpc message 都会转换为一个 HTTP Chunk，所有的 Chunk 发送完之后，需要发送一个空的 Chunk 结束
*/
private boolean isEndChunkSent = false;
/**
* 在 grpc 协议里，在发送完 DATA 后，最后可能发送一个 trailer，它也需要转换为 HTTP Chunk
*/
private boolean isTrailerSent = false;
/**
* 客户端主动断开连接后,需要断开相应的grpc连接, grpc服务端才能停止监听
*/
private Boolean isSuccessSendData = true;
private ChannelHandlerContext ctx;
SendGrpcWebResponse(ChannelHandlerContext ctx, FullHttpRequest req) {
HttpHeaders headers = req.headers();
contentType = headers.get(HttpHeaderNames.CONTENT_TYPE);
this.ctx = ctx;
}
synchronized void writeHeaders(Metadata headers) {
if (isHeaderSent) {
return;
}
// 发送 http1.1 开头部分的内容
DefaultHttpResponse response = new DefaultHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK);
response.headers().set(HttpHeaderNames.CONTENT_TYPE, contentType).set(HttpHeaderNames.TRANSFER_ENCODING,
"chunked");
CorsUtils.updateCorsHeader(response.headers());
if (headers != null) {
Map<String, String> ht = MetadataUtil.getHttpHeadersFromMetadata(headers);
for (String key : ht.keySet()) {
response.headers().set(key, ht.get(key));
}
}
logger.debug("write headers: {}", response);
ctx.writeAndFlush(response);
isHeaderSent = true;
}
synchronized void returnUnimplementedStatusCode(String className) {
writeHeaders(null);
writeTrailer(
Status.UNIMPLEMENTED.withDescription("Can not find service impl, check dep, service: " + className),
null);
}
// 发送最后的 http chunked 空块
private void writeEndChunk() {
if (isEndChunkSent) {
return;
}
LastHttpContent end = new DefaultLastHttpContent();
ctx.writeAndFlush(end);
isEndChunkSent = true;
}
synchronized void writeError(Status s) {
writeHeaders(null);
writeTrailer(s, null);
}
synchronized void writeTrailer(Status status, Metadata trailer) {
if (isTrailerSent) {
return;
}
StringBuffer sb = new StringBuffer();
if (trailer != null) {
Map<String, String> ht = MetadataUtil.getHttpHeadersFromMetadata(trailer);
for (String key : ht.keySet()) {
sb.append(String.format("%s:%s\r\n", key, ht.get(key)));
}
}
sb.append(String.format("grpc-status:%d\r\n", status.getCode().value()));
if (status.getDescription() != null && !status.getDescription().isEmpty()) {
sb.append(String.format("grpc-message:%s\r\n", status.getDescription()));
}
writeResponse(sb.toString().getBytes(), MessageFramer.Type.TRAILER);
isTrailerSent = true;
writeEndChunk();
}
synchronized boolean writeResponse(byte[] out) {
return writeResponse(out, MessageFramer.Type.DATA);
}
private boolean writeResponse(byte[] out, MessageFramer.Type type) {
if (isTrailerSent) {
logger.error("grpcweb trailer sented, writeResponse can not be called, framer type: {}", type);
return false;
}
try {
// PUNT multiple frames not handled
byte[] prefix = new MessageFramer().getPrefix(out, type);
ByteArrayOutputStream oStream = new ByteArrayOutputStream();
// binary encode if it is "text" content type
if (MessageUtils.getContentType(contentType) == ContentType.GRPC_WEB_TEXT) {
byte[] concated = new byte[out.length + 5];
System.arraycopy(prefix, 0, concated, 0, 5);
System.arraycopy(out, 0, concated, 5, out.length);
oStream.write(Base64.getEncoder().encode(concated));
} else {
oStream.write(prefix);
oStream.write(out);
}
byte[] byteArray = oStream.toByteArray();
InputStream dataStream = new ByteArrayInputStream(byteArray);
ChunkedStream chunkedStream = new ChunkedStream(dataStream);
SingleHttpChunkedInput httpChunkedInput = new SingleHttpChunkedInput(chunkedStream);
ChannelFuture channelFuture = ctx.writeAndFlush(httpChunkedInput);
ChannelFutureListener channelFutureListener = new ChannelFutureListener() {
@Override
public void operationComplete(ChannelFuture future) {
if (!future.isSuccess()) {
// 写入操作失败
isSuccessSendData = false;
}
}
};
channelFuture.addListener(channelFutureListener);
return isSuccessSendData;
} catch (IOException e) {
logger.error("write grpcweb response error, framer type: {}", type, e);
return false;
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/server/GrpcWebProxyHandler.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/server/GrpcWebProxyHandler.java | package com.taobao.arthas.grpcweb.proxy.server;
import com.taobao.arthas.grpcweb.proxy.GrpcServiceConnectionManager;
import com.taobao.arthas.grpcweb.proxy.GrpcWebRequestHandler;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.FullHttpResponse;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import java.lang.invoke.MethodHandles;
import static io.netty.handler.codec.http.HttpResponseStatus.CONTINUE;
import static io.netty.handler.codec.http.HttpVersion.HTTP_1_1;
public class GrpcWebProxyHandler extends SimpleChannelInboundHandler<FullHttpRequest> {
private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass().getName());
private GrpcWebRequestHandler requestHandler;
private static GrpcServiceConnectionManager manager;
public GrpcWebProxyHandler(int grpcPort) {
manager = new GrpcServiceConnectionManager(grpcPort);
requestHandler = new GrpcWebRequestHandler(manager);
}
@Override
public void channelReadComplete(ChannelHandlerContext ctx) {
ctx.flush();
}
@Override
protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) {
logger.debug("http request: {} ", request);
send100Continue(ctx);
requestHandler.handle(ctx, request);
}
private static void send100Continue(ChannelHandlerContext ctx) {
FullHttpResponse response = new DefaultFullHttpResponse(HTTP_1_1, CONTINUE, Unpooled.EMPTY_BUFFER);
ctx.write(response);
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
logger.error("grpc web proxy handler error", cause);
ctx.close();
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/server/GrpcWebProxyServer.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/server/GrpcWebProxyServer.java | package com.taobao.arthas.grpcweb.proxy.server;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.Channel;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import java.net.InetSocketAddress;
public final class GrpcWebProxyServer {
private static final Logger logger = LoggerFactory.getLogger(GrpcWebProxyServer.class);
private int port;
private int grpcPort;
private EventLoopGroup bossGroup;
private EventLoopGroup workerGroup;
private Channel channel;
public GrpcWebProxyServer(int port, int grpcPort) {
this.port = port;
this.grpcPort = grpcPort;
bossGroup = new NioEventLoopGroup(1);
workerGroup = new NioEventLoopGroup();
}
public void start() {
try {
ServerBootstrap serverBootstrap = new ServerBootstrap();
serverBootstrap.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.handler(new LoggingHandler(LogLevel.INFO))
.childHandler(new GrpcWebProxyServerInitializer(grpcPort));
channel = serverBootstrap.bind(port).sync().channel();
logger.info("grpc web proxy server started, listening on " + port);
System.out.println("grpc web proxy server started, listening on " + port);
channel.closeFuture().sync();
} catch (InterruptedException e) {
logger.info("fail to start grpc web proxy server!");
throw new RuntimeException(e);
} finally {
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
}
public void close() {
if (bossGroup != null) {
bossGroup.shutdownGracefully();
}
if(workerGroup != null){
workerGroup.shutdownGracefully();
}
logger.info("success to close grpc web proxy server!");
}
public int actualPort() {
int boundPort = ((InetSocketAddress) channel.localAddress()).getPort();
return boundPort;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/server/GrpcWebProxyServerInitializer.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/proxy/server/GrpcWebProxyServerInitializer.java | package com.taobao.arthas.grpcweb.proxy.server;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.stream.ChunkedWriteHandler;
public class GrpcWebProxyServerInitializer extends ChannelInitializer<SocketChannel> {
private int grpcPort;
public GrpcWebProxyServerInitializer(int grpcPort) {
this.grpcPort = grpcPort;
}
@Override
public void initChannel(SocketChannel ch) {
ChannelPipeline pipeline = ch.pipeline();
pipeline.addLast(new HttpServerCodec());
pipeline.addLast(new HttpObjectAggregator(65536));
pipeline.addLast(new ChunkedWriteHandler());
pipeline.addLast(new GrpcWebProxyHandler(grpcPort));
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/DemoBootstrap.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/DemoBootstrap.java | package com.taobao.arthas.grpcweb.grpc;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.common.SocketUtils;
import com.taobao.arthas.core.advisor.TransformerManager;
import com.taobao.arthas.grpcweb.grpc.objectUtils.ComplexObject;
import com.taobao.arthas.grpcweb.grpc.server.GrpcServer;
import com.taobao.arthas.grpcweb.grpc.server.httpServer.NettyHttpServer;
import com.taobao.arthas.grpcweb.proxy.server.GrpcWebProxyServer;
import demo.MathGame;
import net.bytebuddy.agent.ByteBuddyAgent;
import org.zeroturnaround.zip.ZipUtil;
import java.io.File;
import java.io.IOException;
import java.lang.instrument.Instrumentation;
import java.lang.invoke.MethodHandles;
import java.nio.file.Paths;
import java.util.*;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.jar.JarFile;
public class DemoBootstrap {
private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass().getName());
private int GRPC_WEB_PROXY_PORT = 8567;
private int GRPC_PORT = SocketUtils.findAvailableTcpPort();
private int HTTP_PORT = SocketUtils.findAvailableTcpPort();
private Instrumentation instrumentation;
private TransformerManager transformerManager;
private ScheduledExecutorService executorService;
private static DemoBootstrap demoBootstrap;
private DemoBootstrap() throws InterruptedException, IOException {
ComplexObject ccc = createComplexObject();
// 0. 启动mathDemo
Thread mathDemo = new Thread(() ->{
MathGame game = new MathGame();
while (true) {
try {
game.run();
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
});
mathDemo.start();
// 1. 初始化相关参数,获取自身Inst
instrumentation = ByteBuddyAgent.install();
appendSpyJar(instrumentation);
this.transformerManager = new TransformerManager(instrumentation);
executorService = Executors.newScheduledThreadPool(1, new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
final Thread t = new Thread(r, "grpc-service-execute");
t.setDaemon(true);
return t;
}
});
//2. 启动grpc、grpcweb proxy、 http服务器
Thread allServerStartThread = new Thread("grpc-server-start"){
@Override
public void run(){
try {
serverStart();
} catch (IOException e) {
throw new RuntimeException(e);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
}
};
allServerStartThread.start();
}
public void serverStart() throws IOException, InterruptedException {
// 0. 创建一个对象
ComplexObject complexObject = createComplexObject();
// 1. 启动grpc服务
Thread grpcStartThread = new Thread(() -> {
GrpcServer grpcServer = new GrpcServer(GRPC_PORT, instrumentation, transformerManager);
grpcServer.start();
try {
System.in.read();
} catch (IOException e) {
throw new RuntimeException(e);
}
});
grpcStartThread.start();
// 2. 启动grpc-web-proxy服务
//this.GRPC_WEB_PROXY_PORT = SocketUtils.findAvailableTcpPort();
Thread grpcWebProxyStartThread = new Thread(() -> {
GrpcWebProxyServer grpcWebProxyServer = new GrpcWebProxyServer(GRPC_WEB_PROXY_PORT,GRPC_PORT);
grpcWebProxyServer.start();
});
grpcWebProxyStartThread.start();
// 3. 启动http服务
String currentDir = new File(getClass().getProtectionDomain().getCodeSource().getLocation().getPath()).getParentFile().getPath();
String STATIC_LOCATION = Paths.get(currentDir, "static").toString();
NettyHttpServer nettyHttpServer = new NettyHttpServer(HTTP_PORT,STATIC_LOCATION);
logger.info("start grpc server on port: {}, grpc web proxy server on port: {}, " +
"http server server on port: {}", GRPC_PORT,GRPC_WEB_PROXY_PORT,HTTP_PORT);
System.out.println("Open your web browser and navigate to " + "http" + "://127.0.0.1:" + HTTP_PORT + '/' + "index.html");
nettyHttpServer.start();
}
public synchronized static DemoBootstrap getInstance() throws Throwable {
if (demoBootstrap == null) {
demoBootstrap = new DemoBootstrap();
}
return demoBootstrap;
}
public static DemoBootstrap getRunningInstance() {
if (demoBootstrap == null) {
throw new IllegalStateException("AllServerStart must be initialized before!");
}
return demoBootstrap;
}
public void execute(Runnable command) {
executorService.execute(command);
}
public static void appendSpyJar(Instrumentation instrumentation) throws IOException {
// find spy target/classes directory
String file = DemoBootstrap.class.getProtectionDomain().getCodeSource().getLocation().getFile();
File spyClassDir = new File(file, "../../../spy/target/classes").getAbsoluteFile();
File destJarFile = new File(file, "../../../spy/target/test-spy.jar").getAbsoluteFile();
ZipUtil.pack(spyClassDir, destJarFile);
instrumentation.appendToBootstrapClassLoaderSearch(new JarFile(destJarFile));
}
public static ComplexObject createComplexObject() {
// 创建一个 ComplexObject 对象
ComplexObject complexObject = new ComplexObject();
// 设置基本类型的值
complexObject.setId(1);
complexObject.setName("Complex Object");
complexObject.setValue(3.14);
// 设置基本类型的数组
int[] numbers = { 1, 2, 3, 4, 5 };
complexObject.setNumbers(numbers);
Long[] longNumbers = {10086l,10087l,10088l,10089l,10090l,10091l};
complexObject.setLongNumbers(longNumbers);
// 创建并设置嵌套对象
ComplexObject.NestedObject nestedObject = new ComplexObject.NestedObject();
nestedObject.setNestedId(10);
nestedObject.setNestedName("Nested Object");
nestedObject.setFlag(true);
complexObject.setNestedObject(nestedObject);
List<String> stringList = new ArrayList<>();
stringList.add("foo");
stringList.add("bar");
stringList.add("baz");
complexObject.setStringList(stringList);
Map<String, Integer> stringIntegerMap = new HashMap<>();
stringIntegerMap.put("one", 1);
stringIntegerMap.put("two", 2);
complexObject.setStringIntegerMap(stringIntegerMap);
complexObject.setDoubleArray(new Double[] { 1.0, 2.0, 3.0 });
complexObject.setComplexArray(null);
complexObject.setCollection(Arrays.asList("element1", "element2"));
// 创建并设置复杂对象数组
ComplexObject[] complexArray = new ComplexObject[2];
ComplexObject complexObject1 = new ComplexObject();
complexObject1.setId(2);
complexObject1.setName("Complex Object 1");
complexObject1.setValue(2.71);
ComplexObject complexObject2 = new ComplexObject();
complexObject2.setId(3);
complexObject2.setName("Complex Object 2");
complexObject2.setValue(1.618);
complexArray[0] = complexObject1;
complexArray[1] = complexObject2;
complexObject.setComplexArray(complexArray);
// 创建并设置多维数组
int[][] multiDimensionalArray = { { 1, 2, 3 }, { 4, 5, 6 } };
complexObject.setMultiDimensionalArray(multiDimensionalArray);
// 设置数组中的基本元素数组
String[] stringArray = { "Hello", "World" };
complexObject.setStringArray(stringArray);
// 输出 ComplexObject 对象的信息
System.out.println(complexObject);
return complexObject;
}
public Instrumentation getInstrumentation() {
return instrumentation;
}
public TransformerManager getTransformerManager() {
return transformerManager;
}
public ScheduledExecutorService getScheduledExecutorService() {
return this.executorService;
}
public static void main(String[] args) throws Throwable {
DemoBootstrap.getInstance();
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/service/WatchCommandService.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/service/WatchCommandService.java | package com.taobao.arthas.grpcweb.grpc.service;
import io.arthas.api.ArthasServices.ResponseBody;
import io.arthas.api.ArthasServices.WatchRequest;
import io.arthas.api.WatchGrpc;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.advisor.AdviceWeaver;
import com.taobao.arthas.core.command.model.MessageModel;
import com.taobao.arthas.core.shell.system.ExecStatus;
import com.taobao.arthas.grpcweb.grpc.DemoBootstrap;
import com.taobao.arthas.grpcweb.grpc.model.WatchRequestModel;
import com.taobao.arthas.grpcweb.grpc.observer.ArthasStreamObserver;
import com.taobao.arthas.grpcweb.grpc.observer.impl.ArthasStreamObserverImpl;
import com.taobao.arthas.grpcweb.grpc.service.advisor.WatchRpcAdviceListener;
import io.grpc.stub.StreamObserver;
public class WatchCommandService extends WatchGrpc.WatchImplBase {
private static final Logger logger = LoggerFactory.getLogger(WatchCommandService.class);
private WatchRequestModel watchRequestModel;
private ArthasStreamObserver arthasStreamObserver;
private GrpcJobController grpcJobController;
public WatchCommandService(GrpcJobController grpcJobController) {
this.grpcJobController = grpcJobController;
}
@Override
public void watch(WatchRequest watchRequest, StreamObserver<ResponseBody> responseObserver){
// 解析watchRequest 参数
watchRequestModel = new WatchRequestModel(watchRequest);
ArthasStreamObserverImpl<ResponseBody> newArthasStreamObserver = new ArthasStreamObserverImpl<>(responseObserver, watchRequestModel, grpcJobController);
// arthasStreamObserver 传入到advisor中，实现异步传输数据
if(grpcJobController.containsJob(watchRequestModel.getJobId())){
arthasStreamObserver = grpcJobController.getGrpcJob(watchRequest.getJobId());
if(arthasStreamObserver != null && arthasStreamObserver.getPorcessStatus() == ExecStatus.RUNNING){
WatchRpcAdviceListener listener = (WatchRpcAdviceListener) AdviceWeaver.listener(arthasStreamObserver.getListener().id());
watchRequestModel.setListenerId(listener.id());
arthasStreamObserver.setRequestModel(watchRequestModel);
listener.setArthasStreamObserver(arthasStreamObserver);
arthasStreamObserver.appendResult(new MessageModel("SUCCESS CHANGE!!!!!!!!!!!"));
newArthasStreamObserver.setProcessStatus(ExecStatus.RUNNING);
newArthasStreamObserver.end(0,"修改成功!!!");
return;
}else {
arthasStreamObserver = newArthasStreamObserver;
}
}else {
arthasStreamObserver = newArthasStreamObserver;
}
// 创建watch任务
WatchTask watchTask = new WatchTask();
// 执行watch任务
DemoBootstrap.getRunningInstance().execute(watchTask);
}
private class WatchTask implements Runnable{
@Override
public void run() {
try {
watchRequestModel.enhance(arthasStreamObserver);
} catch (Throwable t) {
logger.error("Error during processing the command:", t);
arthasStreamObserver.end(-1, "Error during processing the command: " + t.getClass().getName() + ", message:" + t.getMessage()
+ ", please check $HOME/logs/arthas/arthas.log for more details." );
}
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/service/SystemPropertyCommandService.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/service/SystemPropertyCommandService.java | package com.taobao.arthas.grpcweb.grpc.service;
import com.taobao.arthas.core.shell.system.ExecStatus;
import io.arthas.api.ArthasServices.ResponseBody;
import io.arthas.api.ArthasServices.StringKey;
import io.arthas.api.ArthasServices.StringStringMapValue;
import io.arthas.api.SystemPropertyGrpc;
import com.google.protobuf.Empty;
import com.taobao.arthas.core.command.model.SystemPropertyModel;
import com.taobao.arthas.grpcweb.grpc.observer.ArthasStreamObserver;
import com.taobao.arthas.grpcweb.grpc.observer.impl.ArthasStreamObserverImpl;
import io.grpc.stub.StreamObserver;
import java.util.Map;
public class SystemPropertyCommandService extends SystemPropertyGrpc.SystemPropertyImplBase{
private GrpcJobController grpcJobController;
public SystemPropertyCommandService(GrpcJobController grpcJobController) {
this.grpcJobController = grpcJobController;
}
@Override
public void get(Empty empty, StreamObserver<ResponseBody> responseObserver){
ArthasStreamObserver<ResponseBody> arthasStreamObserver = new ArthasStreamObserverImpl<>(responseObserver, null, grpcJobController);
arthasStreamObserver.setProcessStatus(ExecStatus.RUNNING);
arthasStreamObserver.appendResult(new SystemPropertyModel(System.getProperties()));
arthasStreamObserver.end();
}
@Override
public void getByKey(StringKey request, StreamObserver<ResponseBody> responseObserver){
String propertyName = request.getKey();
ArthasStreamObserver<ResponseBody> arthasStreamObserver = new ArthasStreamObserverImpl<>(responseObserver,null, grpcJobController);
arthasStreamObserver.setProcessStatus(ExecStatus.RUNNING);
// view the specified system property
String value = System.getProperty(propertyName);
if (value == null) {
arthasStreamObserver.end(-1, "There is no property with the key " + propertyName);
return;
} else {
arthasStreamObserver.appendResult(new SystemPropertyModel(propertyName, value));
arthasStreamObserver.end();
}
}
@Override
public void update(StringStringMapValue request, StreamObserver<ResponseBody> responseObserver){
// get properties from client
Map<String, String> properties = request.getStringStringMapMap();
String propertyName = "";
String propertyValue = "";
// change system property
for (Map.Entry<String, String> entry : properties.entrySet()) {
propertyName = entry.getKey();
propertyValue = entry.getValue();
}
ArthasStreamObserver<ResponseBody> arthasStreamObserver = new ArthasStreamObserverImpl<>(responseObserver,null, grpcJobController);
arthasStreamObserver.setProcessStatus(ExecStatus.RUNNING);
try {
System.setProperty(propertyName, propertyValue);
arthasStreamObserver.appendResult(new SystemPropertyModel(propertyName, System.getProperty(propertyName)));
arthasStreamObserver.onCompleted();
}catch (Throwable t) {
arthasStreamObserver.end(-1, "Error during setting system property: " + t.getMessage());
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/service/PwdCommandService.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/service/PwdCommandService.java | package com.taobao.arthas.grpcweb.grpc.service;
import com.taobao.arthas.core.shell.system.ExecStatus;
import io.arthas.api.ArthasServices.ResponseBody;
import io.arthas.api.PwdGrpc;
import com.google.protobuf.Empty;
import com.taobao.arthas.core.command.model.PwdModel;
import com.taobao.arthas.core.shell.session.SessionManager;
import com.taobao.arthas.grpcweb.grpc.observer.ArthasStreamObserver;
import com.taobao.arthas.grpcweb.grpc.observer.impl.ArthasStreamObserverImpl;
import io.grpc.stub.StreamObserver;
import java.io.File;
import java.lang.instrument.Instrumentation;
public class PwdCommandService extends PwdGrpc.PwdImplBase{
private GrpcJobController grpcJobController;
public PwdCommandService(GrpcJobController grpcJobController) {
this.grpcJobController = grpcJobController;
}
@Override
public void pwd(Empty empty, StreamObserver<ResponseBody> responseObserver){
String path = new File("").getAbsolutePath();
ArthasStreamObserver<ResponseBody> arthasStreamObserver = new ArthasStreamObserverImpl<>(responseObserver, null,grpcJobController);
arthasStreamObserver.setProcessStatus(ExecStatus.RUNNING);
arthasStreamObserver.appendResult(new PwdModel(path));
arthasStreamObserver.onCompleted();
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/service/ObjectService.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/service/ObjectService.java | package com.taobao.arthas.grpcweb.grpc.service;
import java.lang.instrument.Instrumentation;
import java.lang.invoke.MethodHandles;
import java.nio.file.Paths;
import java.util.ArrayList;
import java.util.List;
import com.taobao.arthas.core.command.express.Express;
import com.taobao.arthas.core.command.express.ExpressException;
import com.taobao.arthas.core.command.express.ExpressFactory;
import com.taobao.arthas.core.util.Constants;
import com.taobao.arthas.grpcweb.grpc.objectUtils.JavaObjectConverter;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.common.VmToolUtils;
import arthas.VmTool;
import com.taobao.arthas.grpcweb.grpc.observer.ArthasStreamObserver;
import com.taobao.arthas.grpcweb.grpc.observer.impl.ArthasStreamObserverImpl;
import io.grpc.Status;
import io.grpc.stub.StreamObserver;
import io.arthas.api.ObjectServiceGrpc.ObjectServiceImplBase;
import io.arthas.api.ArthasServices.JavaObject;
import io.arthas.api.ArthasServices.ObjectQuery;
import io.arthas.api.ArthasServices.ObjectQueryResult;
import io.arthas.api.ArthasServices.ObjectQueryResult.Builder;
public class ObjectService extends ObjectServiceImplBase {
private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass().getName());
private VmTool vmTool;
private Instrumentation inst;
private GrpcJobController grpcJobController;
public ObjectService(GrpcJobController grpcJobController, String libDir) {
this.inst = grpcJobController.getInstrumentation();
this.grpcJobController = grpcJobController;
try {
String detectLibName = VmToolUtils.detectLibName();
String vmToolLibPath = Paths.get(libDir, detectLibName).toString();
vmTool = VmTool.getInstance(vmToolLibPath);
} catch (Throwable e) {
logger.error("init vmtool error", e);
}
}
@Override
public void query(ObjectQuery query, StreamObserver<ObjectQueryResult> responseObserver) {
if (vmTool == null) {
throw Status.UNAVAILABLE.withDescription("vmtool can not work").asRuntimeException();
}
ArthasStreamObserver<ObjectQueryResult> arthasStreamObserver = new ArthasStreamObserverImpl<>(responseObserver, null,grpcJobController);
String className = query.getClassName();
String classLoaderHash = query.getClassLoaderHash();
String classLoaderClass = query.getClassLoaderClass();
int limit = query.getLimit();
int depth = query.getDepth();
String express = query.getExpress();
String resultExpress = query.getResultExpress();
// 如果只传递了 class name 参数，则jvm 里可能有多个同名的 class，需要全部查找
if (isEmpty(classLoaderHash) && isEmpty(classLoaderClass)) {
List<Class<?>> foundClassList = new ArrayList<>();
for (Class<?> clazz : inst.getAllLoadedClasses()) {
if (clazz.getName().equals(className)) {
foundClassList.add(clazz);
}
}
// 没找到
if (foundClassList.size() == 0) {
arthasStreamObserver.onNext(ObjectQueryResult.newBuilder().setSuccess(false)
.setMessage("can not find class: " + className).build());
arthasStreamObserver.onCompleted();
return;
} else if (foundClassList.size() > 1) {
String message = "found more than one class: " + className;
arthasStreamObserver.onNext(ObjectQueryResult.newBuilder().setSuccess(false).setMessage(message).build());
arthasStreamObserver.onCompleted();
return;
} else { // 找到了指定的 类
Object[] instances = vmTool.getInstances(foundClassList.get(0), limit);
Builder builder = ObjectQueryResult.newBuilder().setSuccess(true);
/**
* 这里尝试使用express
*/
Object value = null;
if (!isEmpty(express)) {
Express unpooledExpress = ExpressFactory.unpooledExpress(foundClassList.get(0).getClassLoader());
try {
value = unpooledExpress.bind(new InstancesWrapper(instances)).get(express);
} catch (ExpressException e) {
logger.warn("ognl: failed execute express: " + express, e);
}
}
if(value != null && !isEmpty(resultExpress)){
try {
value = ExpressFactory.threadLocalExpress(value).bind(Constants.COST_VARIABLE, 0.0).get(resultExpress);
} catch (ExpressException e) {
logger.warn("ognl: failed execute result express: " + express, e);
}
}
JavaObject javaObject = JavaObjectConverter.toJavaObjectWithExpand(value, depth);
builder.addObjects(javaObject);
arthasStreamObserver.onNext(builder.build());
arthasStreamObserver.onCompleted();
return;
}
}
// 有指定 classloader hash 或者 classloader className
Class<?> foundClass = null;
for (Class<?> clazz : inst.getAllLoadedClasses()) {
if (!clazz.getName().equals(className)) {
continue;
}
ClassLoader classLoader = clazz.getClassLoader();
if (classLoader == null) {
continue;
}
if (!isEmpty(classLoaderHash)) {
String hex = Integer.toHexString(classLoader.hashCode());
if (classLoaderHash.equals(hex)) {
foundClass = clazz;
break;
}
}
if (!isEmpty(classLoaderClass) && classLoaderClass.equals(classLoader.getClass().getName())) {
foundClass = clazz;
break;
}
}
// 没找到类
if (foundClass == null) {
arthasStreamObserver.onNext(ObjectQueryResult.newBuilder().setSuccess(false)
.setMessage("can not find class: " + className).build());
arthasStreamObserver.onCompleted();
return;
}
Object[] instances = vmTool.getInstances(foundClass, limit);
Builder builder = ObjectQueryResult.newBuilder().setSuccess(true);
// for (Object obj : instances) {
// JavaObject javaObject = JavaObjectConverter.toJavaObjectWithExpand(obj, depth);
// builder.addObjects(javaObject);
// }
Object value = null;
if (!isEmpty(express)) {
Express unpooledExpress = ExpressFactory.unpooledExpress(foundClass.getClassLoader());
try {
value = unpooledExpress.bind(new InstancesWrapper(instances)).get(express);
} catch (ExpressException e) {
logger.warn("ognl: failed execute express: " + express, e);
}
}
if(value != null && !isEmpty(resultExpress)){
try {
value = ExpressFactory.threadLocalExpress(value).bind(Constants.COST_VARIABLE, 0.0).get(resultExpress);
} catch (ExpressException e) {
logger.warn("ognl: failed execute result express: " + express, e);
}
}
JavaObject javaObject = JavaObjectConverter.toJavaObjectWithExpand(value, depth);
builder.addObjects(javaObject);
arthasStreamObserver.onNext(builder.build());
arthasStreamObserver.onCompleted();
}
public static boolean isEmpty(Object str) {
return str == null || "".equals(str);
}
static class InstancesWrapper {
Object instances;
public InstancesWrapper(Object instances) {
this.instances = instances;
}
public Object getInstances() {
return instances;
}
public void setInstances(Object instances) {
this.instances = instances;
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/service/GrpcJobController.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/service/GrpcJobController.java | package com.taobao.arthas.grpcweb.grpc.service;
import com.taobao.arthas.core.advisor.TransformerManager;
import com.taobao.arthas.grpcweb.grpc.observer.ArthasStreamObserver;
import com.taobao.arthas.grpcweb.grpc.view.GrpcResultViewResolver;
import java.lang.instrument.Instrumentation;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.atomic.AtomicInteger;
public class GrpcJobController{
private Map<Long/*JOB_ID*/, ArthasStreamObserver> jobs
= new ConcurrentHashMap<Long, ArthasStreamObserver>();
// private Map<Long/*JOB_ID*/, ArthasStreamObserver> jobs
// = new HashMap<>();
private final AtomicInteger idGenerator = new AtomicInteger(0);
private GrpcResultViewResolver resultViewResolver;
private Instrumentation instrumentation;
private TransformerManager transformerManager;
public GrpcJobController(Instrumentation instrumentation, TransformerManager transformerManager, GrpcResultViewResolver resultViewResolver){
this.instrumentation = instrumentation;
this.transformerManager = transformerManager;
this.resultViewResolver = resultViewResolver;
}
public Set<Long> getJobIds(){
return jobs.keySet();
}
public void registerGrpcJob(long jobId,ArthasStreamObserver arthasStreamObserver){
jobs.put(jobId, arthasStreamObserver);
}
public void unRegisterGrpcJob(long jobId){
if(jobs.containsKey(jobId)){
jobs.remove(jobId);
}
}
public boolean containsJob(long jobId){
return jobs.containsKey(jobId);
}
public ArthasStreamObserver getGrpcJob(long jobId){
if(this.containsJob(jobId)){
return jobs.get(jobId);
}else {
return null;
}
}
public int generateGrpcJobId(){
int jobId = idGenerator.incrementAndGet();
return jobId;
}
public GrpcResultViewResolver getResultViewResolver() {
return resultViewResolver;
}
public Instrumentation getInstrumentation() {
return instrumentation;
}
public void setInstrumentation(Instrumentation instrumentation) {
this.instrumentation = instrumentation;
}
public TransformerManager getTransformerManager() {
return transformerManager;
}
public void setTransformerManager(TransformerManager transformerManager) {
this.transformerManager = transformerManager;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/service/advisor/Enhancer.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/service/advisor/Enhancer.java | package com.taobao.arthas.grpcweb.grpc.service.advisor;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.alibaba.bytekit.asm.MethodProcessor;
import com.alibaba.bytekit.asm.interceptor.InterceptorProcessor;
import com.alibaba.bytekit.asm.interceptor.parser.DefaultInterceptorClassParser;
import com.alibaba.bytekit.asm.location.Location;
import com.alibaba.bytekit.asm.location.LocationType;
import com.alibaba.bytekit.asm.location.MethodInsnNodeWare;
import com.alibaba.bytekit.asm.location.filter.GroupLocationFilter;
import com.alibaba.bytekit.asm.location.filter.InvokeCheckLocationFilter;
import com.alibaba.bytekit.asm.location.filter.InvokeContainLocationFilter;
import com.alibaba.bytekit.asm.location.filter.LocationFilter;
import com.alibaba.bytekit.utils.AsmOpUtils;
import com.alibaba.bytekit.utils.AsmUtils;
import com.alibaba.deps.org.objectweb.asm.ClassReader;
import com.alibaba.deps.org.objectweb.asm.Opcodes;
import com.alibaba.deps.org.objectweb.asm.Type;
import com.alibaba.deps.org.objectweb.asm.tree.AbstractInsnNode;
import com.alibaba.deps.org.objectweb.asm.tree.ClassNode;
import com.alibaba.deps.org.objectweb.asm.tree.MethodInsnNode;
import com.alibaba.deps.org.objectweb.asm.tree.MethodNode;
import com.taobao.arthas.common.Pair;
import com.taobao.arthas.core.GlobalOptions;
import com.taobao.arthas.core.advisor.AdviceListener;
import com.taobao.arthas.core.advisor.SpyInterceptors.*;
import com.taobao.arthas.core.util.ArthasCheckUtils;
import com.taobao.arthas.core.util.ClassUtils;
import com.taobao.arthas.core.util.FileUtils;
import com.taobao.arthas.core.util.SearchUtils;
import com.taobao.arthas.core.util.affect.EnhancerAffect;
import com.taobao.arthas.core.util.matcher.Matcher;
import com.taobao.arthas.grpcweb.grpc.DemoBootstrap;
import java.arthas.SpyAPI;
import java.io.File;
import java.io.IOException;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.IllegalClassFormatException;
import java.lang.instrument.Instrumentation;
import java.lang.instrument.UnmodifiableClassException;
import java.lang.reflect.Method;
import java.security.ProtectionDomain;
import java.util.*;
import static com.taobao.arthas.core.util.ArthasCheckUtils.isEquals;
import static java.lang.System.arraycopy;
/**
* 对类进行通知增强 Created by vlinux on 15/5/17.
* @author hengyunabc
*/
public class Enhancer implements ClassFileTransformer {
private static final Logger logger = LoggerFactory.getLogger(Enhancer.class);
private final AdviceListener listener;
private final boolean isTracing;
private final boolean skipJDKTrace;
private final Matcher classNameMatcher;
private final Matcher classNameExcludeMatcher;
private final Matcher methodNameMatcher;
private final EnhancerAffect affect;
private Set<Class<?>> matchingClasses = null;
private static final ClassLoader selfClassLoader = Enhancer.class.getClassLoader();
// 被增强的类的缓存
private final static Map<Class<?>/* Class */, Object> classBytesCache = new WeakHashMap<Class<?>, Object>();
private static SpyImpl spyImpl = new SpyImpl();
static {
SpyAPI.setSpy(spyImpl);
}
/**
* @param adviceId 通知编号
* @param isTracing 可跟踪方法调用
* @param skipJDKTrace 是否忽略对JDK内部方法的跟踪
* @param matchingClasses 匹配中的类
* @param methodNameMatcher 方法名匹配
* @param affect 影响统计
*/
public Enhancer(AdviceListener listener, boolean isTracing, boolean skipJDKTrace, Matcher classNameMatcher,
Matcher classNameExcludeMatcher,
Matcher methodNameMatcher) {
this.listener = listener;
this.isTracing = isTracing;
this.skipJDKTrace = skipJDKTrace;
this.classNameMatcher = classNameMatcher;
this.classNameExcludeMatcher = classNameExcludeMatcher;
this.methodNameMatcher = methodNameMatcher;
this.affect = new EnhancerAffect();
affect.setListenerId(listener.id());
}
@Override
public byte[] transform(final ClassLoader inClassLoader, String className, Class<?> classBeingRedefined,
ProtectionDomain protectionDomain, byte[] classfileBuffer) throws IllegalClassFormatException {
try {
// 检查classloader能否加载到 SpyAPI，如果不能，则放弃增强
try {
if (inClassLoader != null) {
inClassLoader.loadClass(SpyAPI.class.getName());
}
} catch (Throwable e) {
logger.error("the classloader can not load SpyAPI, ignore it. classloader: {}, className: {}",
inClassLoader.getClass().getName(), className, e);
return null;
}
// 这里要再次过滤一次，为啥？因为在transform的过程中，有可能还会再诞生新的类
// 所以需要将之前需要转换的类集合传递下来，再次进行判断
if (matchingClasses != null && !matchingClasses.contains(classBeingRedefined)) {
return null;
}
//keep origin class reader for bytecode optimizations, avoiding JVM metaspace OOM.
ClassNode classNode = new ClassNode(Opcodes.ASM9);
ClassReader classReader = AsmUtils.toClassNode(classfileBuffer, classNode);
// remove JSR https://github.com/alibaba/arthas/issues/1304
classNode = AsmUtils.removeJSRInstructions(classNode);
// 生成增强字节码
DefaultInterceptorClassParser defaultInterceptorClassParser = new DefaultInterceptorClassParser();
final List<InterceptorProcessor> interceptorProcessors = new ArrayList<InterceptorProcessor>();
interceptorProcessors.addAll(defaultInterceptorClassParser.parse(SpyInterceptor1.class));
interceptorProcessors.addAll(defaultInterceptorClassParser.parse(SpyInterceptor2.class));
interceptorProcessors.addAll(defaultInterceptorClassParser.parse(SpyInterceptor3.class));
if (this.isTracing) {
if (!this.skipJDKTrace) {
interceptorProcessors.addAll(defaultInterceptorClassParser.parse(SpyTraceInterceptor1.class));
interceptorProcessors.addAll(defaultInterceptorClassParser.parse(SpyTraceInterceptor2.class));
interceptorProcessors.addAll(defaultInterceptorClassParser.parse(SpyTraceInterceptor3.class));
} else {
interceptorProcessors.addAll(defaultInterceptorClassParser.parse(SpyTraceExcludeJDKInterceptor1.class));
interceptorProcessors.addAll(defaultInterceptorClassParser.parse(SpyTraceExcludeJDKInterceptor2.class));
interceptorProcessors.addAll(defaultInterceptorClassParser.parse(SpyTraceExcludeJDKInterceptor3.class));
}
}
List<MethodNode> matchedMethods = new ArrayList<MethodNode>();
for (MethodNode methodNode : classNode.methods) {
if (!isIgnore(methodNode, methodNameMatcher)) {
matchedMethods.add(methodNode);
}
}
// https://github.com/alibaba/arthas/issues/1690
if (AsmUtils.isEnhancerByCGLIB(className)) {
for (MethodNode methodNode : matchedMethods) {
if (AsmUtils.isConstructor(methodNode)) {
AsmUtils.fixConstructorExceptionTable(methodNode);
}
}
}
// 用于检查是否已插入了 spy函数，如果已有则不重复处理
GroupLocationFilter groupLocationFilter = new GroupLocationFilter();
LocationFilter enterFilter = new InvokeContainLocationFilter(Type.getInternalName(SpyAPI.class), "atEnter",
LocationType.ENTER);
LocationFilter existFilter = new InvokeContainLocationFilter(Type.getInternalName(SpyAPI.class), "atExit",
LocationType.EXIT);
LocationFilter exceptionFilter = new InvokeContainLocationFilter(Type.getInternalName(SpyAPI.class),
"atExceptionExit", LocationType.EXCEPTION_EXIT);
groupLocationFilter.addFilter(enterFilter);
groupLocationFilter.addFilter(existFilter);
groupLocationFilter.addFilter(exceptionFilter);
LocationFilter invokeBeforeFilter = new InvokeCheckLocationFilter(Type.getInternalName(SpyAPI.class),
"atBeforeInvoke", LocationType.INVOKE);
LocationFilter invokeAfterFilter = new InvokeCheckLocationFilter(Type.getInternalName(SpyAPI.class),
"atInvokeException", LocationType.INVOKE_COMPLETED);
LocationFilter invokeExceptionFilter = new InvokeCheckLocationFilter(Type.getInternalName(SpyAPI.class),
"atInvokeException", LocationType.INVOKE_EXCEPTION_EXIT);
groupLocationFilter.addFilter(invokeBeforeFilter);
groupLocationFilter.addFilter(invokeAfterFilter);
groupLocationFilter.addFilter(invokeExceptionFilter);
for (MethodNode methodNode : matchedMethods) {
if (AsmUtils.isNative(methodNode)) {
logger.info("ignore native method: {}",
AsmUtils.methodDeclaration(Type.getObjectType(classNode.name), methodNode));
continue;
}
// 先查找是否有 atBeforeInvoke 函数，如果有，则说明已经有trace了，则直接不再尝试增强，直接插入 listener
if(AsmUtils.containsMethodInsnNode(methodNode, Type.getInternalName(SpyAPI.class), "atBeforeInvoke")) {
for (AbstractInsnNode insnNode = methodNode.instructions.getFirst(); insnNode != null; insnNode = insnNode
.getNext()) {
if (insnNode instanceof MethodInsnNode) {
final MethodInsnNode methodInsnNode = (MethodInsnNode) insnNode;
if(this.skipJDKTrace) {
if(methodInsnNode.owner.startsWith("java/")) {
continue;
}
}
// 原始类型的box类型相关的都跳过
if(AsmOpUtils.isBoxType(Type.getObjectType(methodInsnNode.owner))) {
continue;
}
AdviceListenerManager.registerTraceAdviceListener(inClassLoader, className,
methodInsnNode.owner, methodInsnNode.name, methodInsnNode.desc, listener);
}
}
}else {
MethodProcessor methodProcessor = new MethodProcessor(classNode, methodNode, groupLocationFilter);
for (InterceptorProcessor interceptor : interceptorProcessors) {
try {
List<Location> locations = interceptor.process(methodProcessor);
for (Location location : locations) {
if (location instanceof MethodInsnNodeWare) {
MethodInsnNodeWare methodInsnNodeWare = (MethodInsnNodeWare) location;
MethodInsnNode methodInsnNode = methodInsnNodeWare.methodInsnNode();
AdviceListenerManager.registerTraceAdviceListener(inClassLoader, className,
methodInsnNode.owner, methodInsnNode.name, methodInsnNode.desc, listener);
}
}
} catch (Throwable e) {
logger.error("enhancer error, class: {}, method: {}, interceptor: {}", classNode.name, methodNode.name, interceptor.getClass().getName(), e);
}
}
}
// enter/exist 总是要插入 listener
AdviceListenerManager.registerAdviceListener(inClassLoader, className, methodNode.name, methodNode.desc,
listener);
affect.addMethodAndCount(inClassLoader, className, methodNode.name, methodNode.desc);
}
// https://github.com/alibaba/arthas/issues/1223 , V1_5 的major version是49
if (AsmUtils.getMajorVersion(classNode.version) < 49) {
classNode.version = AsmUtils.setMajorVersion(classNode.version, 49);
}
byte[] enhanceClassByteArray = AsmUtils.toBytes(classNode, inClassLoader, classReader);
// 增强成功，记录类
classBytesCache.put(classBeingRedefined, new Object());
// dump the class
dumpClassIfNecessary(className, enhanceClassByteArray, affect);
// 成功计数
affect.cCnt(1);
return enhanceClassByteArray;
} catch (Throwable t) {
logger.warn("transform loader[{}]:class[{}] failed.", inClassLoader, className, t);
affect.setThrowable(t);
}
return null;
}
/**
* 是否抽象属性
*/
private boolean isAbstract(int access) {
return (Opcodes.ACC_ABSTRACT & access) == Opcodes.ACC_ABSTRACT;
}
/**
* 是否需要忽略
*/
private boolean isIgnore(MethodNode methodNode, Matcher methodNameMatcher) {
return null == methodNode || isAbstract(methodNode.access) || !methodNameMatcher.matching(methodNode.name)
|| ArthasCheckUtils.isEquals(methodNode.name, "<clinit>");
}
/**
* dump class to file
*/
private static void dumpClassIfNecessary(String className, byte[] data, EnhancerAffect affect) {
if (!GlobalOptions.isDump) {
return;
}
final File dumpClassFile = new File("./arthas-class-dump/" + className + ".class");
final File classPath = new File(dumpClassFile.getParent());
// 创建类所在的包路径
if (!classPath.mkdirs() && !classPath.exists()) {
logger.warn("create dump classpath:{} failed.", classPath);
return;
}
// 将类字节码写入文件
try {
FileUtils.writeByteArrayToFile(dumpClassFile, data);
affect.addClassDumpFile(dumpClassFile);
if (GlobalOptions.verbose) {
logger.info("dump enhanced class: {}, path: {}", className, dumpClassFile);
}
} catch (IOException e) {
logger.warn("dump class:{} to file {} failed.", className, dumpClassFile, e);
}
}
/**
* 是否需要过滤的类
*
* @param classes 类集合
*/
private List<Pair<Class<?>, String>> filter(Set<Class<?>> classes) {
List<Pair<Class<?>, String>> filteredClasses = new ArrayList<Pair<Class<?>, String>>();
final Iterator<Class<?>> it = classes.iterator();
while (it.hasNext()) {
final Class<?> clazz = it.next();
boolean removeFlag = false;
if (null == clazz) {
removeFlag = true;
}
// else if (isSelf(clazz)) {
// filteredClasses.add(new Pair<Class<?>, String>(clazz, "class loaded by arthas itself"));
// removeFlag = true;
// }
else if (isUnsafeClass(clazz)) {
filteredClasses.add(new Pair<Class<?>, String>(clazz, "class loaded by Bootstrap Classloader, try to execute `options unsafe true`"));
removeFlag = true;
} else if (isExclude(clazz)) {
filteredClasses.add(new Pair<Class<?>, String>(clazz, "class is excluded"));
removeFlag = true;
} else {
Pair<Boolean, String> unsupportedResult = isUnsupportedClass(clazz);
if (unsupportedResult.getFirst()) {
filteredClasses.add(new Pair<Class<?>, String>(clazz, unsupportedResult.getSecond()));
removeFlag = true;
}
}
if (removeFlag) {
it.remove();
}
}
return filteredClasses;
}
private boolean isExclude(Class<?> clazz) {
if (this.classNameExcludeMatcher != null) {
return classNameExcludeMatcher.matching(clazz.getName());
}
return false;
}
/**
* 是否过滤Arthas加载的类
*/
private static boolean isSelf(Class<?> clazz) {
return null != clazz && isEquals(clazz.getClassLoader(), selfClassLoader);
}
/**
* 是否过滤unsafe类
*/
private static boolean isUnsafeClass(Class<?> clazz) {
return !GlobalOptions.isUnsafe && clazz.getClassLoader() == null;
}
/**
* 是否过滤目前暂不支持的类
*/
private static Pair<Boolean, String> isUnsupportedClass(Class<?> clazz) {
if (ClassUtils.isLambdaClass(clazz)) {
return new Pair<Boolean, String>(Boolean.TRUE, "class is lambda");
}
if (clazz.isInterface() && !GlobalOptions.isSupportDefaultMethod) {
return new Pair<Boolean, String>(Boolean.TRUE, "class is interface");
}
if (clazz.equals(Integer.class)) {
return new Pair<Boolean, String>(Boolean.TRUE, "class is java.lang.Integer");
}
if (clazz.equals(Class.class)) {
return new Pair<Boolean, String>(Boolean.TRUE, "class is java.lang.Class");
}
if (clazz.equals(Method.class)) {
return new Pair<Boolean, String>(Boolean.TRUE, "class is java.lang.Method");
}
if (clazz.isArray()) {
return new Pair<Boolean, String>(Boolean.TRUE, "class is array");
}
return new Pair<Boolean, String>(Boolean.FALSE, "");
}
/**
* 对象增强
*
* @param inst inst
* @param maxNumOfMatchedClass 匹配的class最大数量
* @return 增强影响范围
* @throws UnmodifiableClassException 增强失败
*/
public synchronized EnhancerAffect enhance(final Instrumentation inst, int maxNumOfMatchedClass) throws UnmodifiableClassException {
// 获取需要增强的类集合
this.matchingClasses = GlobalOptions.isDisableSubClass
? SearchUtils.searchClass(inst, classNameMatcher)
: SearchUtils.searchSubClass(inst, SearchUtils.searchClass(inst, classNameMatcher));
if (matchingClasses.size() > maxNumOfMatchedClass) {
affect.setOverLimitMsg("The number of matched classes is " +matchingClasses.size()+ ", greater than the limit value " + maxNumOfMatchedClass + ". Try to change the limit with option '-m <arg>'.");
return affect;
}
// 过滤掉无法被增强的类
List<Pair<Class<?>, String>> filtedList = filter(matchingClasses);
if (!filtedList.isEmpty()) {
for (Pair<Class<?>, String> filted : filtedList) {
logger.info("ignore class: {}, reason: {}", filted.getFirst().getName(), filted.getSecond());
}
}
logger.info("enhance matched classes: {}", matchingClasses);
affect.setTransformer(this);
try {
DemoBootstrap.getRunningInstance().getTransformerManager().addTransformer(this, isTracing);
// 批量增强
if (GlobalOptions.isBatchReTransform) {
final int size = matchingClasses.size();
final Class<?>[] classArray = new Class<?>[size];
arraycopy(matchingClasses.toArray(), 0, classArray, 0, size);
if (classArray.length > 0) {
inst.retransformClasses(classArray);
logger.info("Success to batch transform classes: " + Arrays.toString(classArray));
}
} else {
// for each 增强
for (Class<?> clazz : matchingClasses) {
try {
inst.retransformClasses(clazz);
logger.info("Success to transform class: " + clazz);
} catch (Throwable t) {
logger.warn("retransform {} failed.", clazz, t);
if (t instanceof UnmodifiableClassException) {
throw (UnmodifiableClassException) t;
} else if (t instanceof RuntimeException) {
throw (RuntimeException) t;
} else {
throw new RuntimeException(t);
}
}
}
}
} catch (Throwable e) {
logger.error("Enhancer error, matchingClasses: {}", matchingClasses, e);
affect.setThrowable(e);
}
return affect;
}
/**
* 重置指定的Class
*
* @param inst inst
* @param classNameMatcher 类名匹配
* @return 增强影响范围
* @throws UnmodifiableClassException
*/
public static synchronized EnhancerAffect reset(final Instrumentation inst, final Matcher classNameMatcher)
throws UnmodifiableClassException {
final EnhancerAffect affect = new EnhancerAffect();
final Set<Class<?>> enhanceClassSet = new HashSet<Class<?>>();
for (Class<?> classInCache : classBytesCache.keySet()) {
if (classNameMatcher.matching(classInCache.getName())) {
enhanceClassSet.add(classInCache);
}
}
try {
enhance(inst, enhanceClassSet);
logger.info("Success to reset classes: " + enhanceClassSet);
} finally {
for (Class<?> resetClass : enhanceClassSet) {
classBytesCache.remove(resetClass);
affect.cCnt(1);
}
}
return affect;
}
// 批量增强
private static void enhance(Instrumentation inst, Set<Class<?>> classes)
throws UnmodifiableClassException {
int size = classes.size();
Class<?>[] classArray = new Class<?>[size];
arraycopy(classes.toArray(), 0, classArray, 0, size);
if (classArray.length > 0) {
inst.retransformClasses(classArray);
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/service/advisor/WatchRpcAdviceListener.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/service/advisor/WatchRpcAdviceListener.java | package com.taobao.arthas.grpcweb.grpc.service.advisor;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.advisor.AccessPoint;
import com.taobao.arthas.core.advisor.Advice;
import com.taobao.arthas.core.advisor.AdviceListenerAdapter;
import com.taobao.arthas.core.advisor.ArthasMethod;
import com.taobao.arthas.core.command.express.ExpressException;
import com.taobao.arthas.core.command.model.MessageModel;
import com.taobao.arthas.core.command.model.ObjectVO;
import com.taobao.arthas.core.util.LogUtil;
import com.taobao.arthas.core.util.ThreadLocalWatch;
import com.taobao.arthas.grpcweb.grpc.model.WatchRequestModel;
import com.taobao.arthas.grpcweb.grpc.model.WatchResponseModel;
import com.taobao.arthas.grpcweb.grpc.observer.ArthasStreamObserver;
import java.lang.ref.SoftReference;
import java.lang.ref.WeakReference;
import java.time.LocalDateTime;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.atomic.AtomicInteger;
public class WatchRpcAdviceListener extends AdviceListenerAdapter {
private static final Logger logger = LoggerFactory.getLogger(WatchRpcAdviceListener.class);
private final ThreadLocalWatch threadLocalWatch = new ThreadLocalWatch();
private final AtomicInteger idGenerator = new AtomicInteger(0);
private Map<Long/*RESULT_ID*/, Object> results = new HashMap<>();
private WatchRequestModel watchRequestModel;
private ArthasStreamObserver arthasStreamObserver;
public WatchRpcAdviceListener(ArthasStreamObserver arthasStreamObserver, boolean verbose) {
this.arthasStreamObserver = arthasStreamObserver;
this.watchRequestModel = (WatchRequestModel) arthasStreamObserver.getRequestModel();
super.setVerbose(verbose);
}
public void setArthasStreamObserver(ArthasStreamObserver arthasStreamObserver) {
this.arthasStreamObserver = arthasStreamObserver;
this.watchRequestModel = (WatchRequestModel) arthasStreamObserver.getRequestModel();
}
private boolean isFinish() {
return watchRequestModel.isFinish() || !watchRequestModel.isBefore() && !watchRequestModel.isException() && !watchRequestModel.isSuccess();
}
@Override
public void before(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target, Object[] args)
throws Throwable {
// 开始计算本次方法调用耗时
threadLocalWatch.start();
if (watchRequestModel.isBefore()) {
watching(Advice.newForBefore(loader, clazz, method, target, args));
}
}
@Override
public void afterReturning(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target, Object[] args,
Object returnObject) throws Throwable {
Advice advice = Advice.newForAfterReturning(loader, clazz, method, target, args, returnObject);
if (watchRequestModel.isSuccess()) {
watching(advice);
}
finishing(advice);
}
@Override
public void afterThrowing(ClassLoader loader, Class<?> clazz, ArthasMethod method, Object target, Object[] args,
Throwable throwable) {
Advice advice = Advice.newForAfterThrowing(loader, clazz, method, target, args, throwable);
if (watchRequestModel.isException()) {
watching(advice);
}
finishing(advice);
}
private void finishing(Advice advice) {
if (isFinish()) {
watching(advice);
}
}
private void watching(Advice advice) {
try {
// 本次调用的耗时
System.out.println("************job: "+ arthasStreamObserver.getJobId() + " rpc watch advice开始正式执行,执行信息如下*****************");
System.out.println("listener ID: + " + arthasStreamObserver.getListener().id());
System.out.println("参数: \n" + watchRequestModel.toString());
System.out.println("###################***************** \n\n");
double cost = threadLocalWatch.costInMillis();
boolean conditionResult = isConditionMet(watchRequestModel.getConditionExpress(), advice, cost);
if (this.isVerbose()) {
String msg = "Condition express: " + watchRequestModel.getConditionExpress() + " , result: " + conditionResult + "\n";
arthasStreamObserver.appendResult(new MessageModel(msg));
}
if (conditionResult) {
long resultId = idGenerator.incrementAndGet();
results.put(resultId, advice);
Object value = getExpressionResult(watchRequestModel.getExpress(), advice, cost);
WatchResponseModel model = new WatchResponseModel();
model.setResultId(resultId);
model.setTs(LocalDateTime.now());
model.setCost(cost);
model.setValue(new ObjectVO(value, watchRequestModel.getExpand()));
model.setSizeLimit(watchRequestModel.getSizeLimit());
model.setClassName(advice.getClazz().getName());
model.setMethodName(advice.getMethod().getName());
if (advice.isBefore()) {
model.setAccessPoint(AccessPoint.ACCESS_BEFORE.getKey());
} else if (advice.isAfterReturning()) {
model.setAccessPoint(AccessPoint.ACCESS_AFTER_RETUNING.getKey());
} else if (advice.isAfterThrowing()) {
model.setAccessPoint(AccessPoint.ACCESS_AFTER_THROWING.getKey());
}
arthasStreamObserver.appendResult(model);
arthasStreamObserver.times().incrementAndGet();
if (isLimitExceeded(watchRequestModel.getNumberOfLimit(), arthasStreamObserver.times().get())) {
String msg = "Command execution times exceed limit: " + watchRequestModel.getNumberOfLimit()
+ ", so command will exit.\n";
arthasStreamObserver.end();
}
}
} catch (Throwable e) {
logger.warn("watch failed.", e);
arthasStreamObserver.end(-1, "watch failed, condition is: " + watchRequestModel.getConditionExpress() + ", express is: "
+ watchRequestModel.getExpress() + ", " + e.getMessage() + ", visit " + LogUtil.loggingFile()
+ " for more details.");
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/service/advisor/SpyImpl.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/service/advisor/SpyImpl.java | package com.taobao.arthas.grpcweb.grpc.service.advisor;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.advisor.AdviceListener;
import com.taobao.arthas.core.advisor.InvokeTraceable;
import com.taobao.arthas.core.shell.system.ExecStatus;
import com.taobao.arthas.core.shell.system.ProcessAware;
import com.taobao.arthas.core.util.StringUtils;
import java.arthas.SpyAPI.AbstractSpy;
import java.util.List;
/**
* <pre>
* 怎么从 className|methodDesc 到 id 对应起来？？
* 当id少时，可以id自己来判断是否符合？
*
* 如果是每个 className|methodDesc 为 key ，是否
* </pre>
*
* @author hengyunabc 2020-04-24
*
*/
public class SpyImpl extends AbstractSpy {
private static final Logger logger = LoggerFactory.getLogger(SpyImpl.class);
@Override
public void atEnter(Class<?> clazz, String methodInfo, Object target, Object[] args) {
ClassLoader classLoader = clazz.getClassLoader();
String[] info = StringUtils.splitMethodInfo(methodInfo);
String methodName = info[0];
String methodDesc = info[1];
// TODO listener 只用查一次，放到 thread local里保存起来就可以了！
List<AdviceListener> listeners = com.taobao.arthas.grpcweb.grpc.service.advisor.AdviceListenerManager.queryAdviceListeners(classLoader, clazz.getName(),
methodName, methodDesc);
if (listeners != null) {
for (AdviceListener adviceListener : listeners) {
try {
if (skipAdviceListener(adviceListener)) {
continue;
}
adviceListener.before(clazz, methodName, methodDesc, target, args);
} catch (Throwable e) {
logger.error("class: {}, methodInfo: {}", clazz.getName(), methodInfo, e);
}
}
}
}
@Override
public void atExit(Class<?> clazz, String methodInfo, Object target, Object[] args, Object returnObject) {
ClassLoader classLoader = clazz.getClassLoader();
String[] info = StringUtils.splitMethodInfo(methodInfo);
String methodName = info[0];
String methodDesc = info[1];
List<AdviceListener> listeners = com.taobao.arthas.grpcweb.grpc.service.advisor.AdviceListenerManager.queryAdviceListeners(classLoader, clazz.getName(),
methodName, methodDesc);
if (listeners != null) {
for (AdviceListener adviceListener : listeners) {
try {
if (skipAdviceListener(adviceListener)) {
continue;
}
adviceListener.afterReturning(clazz, methodName, methodDesc, target, args, returnObject);
} catch (Throwable e) {
logger.error("class: {}, methodInfo: {}", clazz.getName(), methodInfo, e);
}
}
}
}
@Override
public void atExceptionExit(Class<?> clazz, String methodInfo, Object target, Object[] args, Throwable throwable) {
ClassLoader classLoader = clazz.getClassLoader();
String[] info = StringUtils.splitMethodInfo(methodInfo);
String methodName = info[0];
String methodDesc = info[1];
List<AdviceListener> listeners = com.taobao.arthas.grpcweb.grpc.service.advisor.AdviceListenerManager.queryAdviceListeners(classLoader, clazz.getName(),
methodName, methodDesc);
if (listeners != null) {
for (AdviceListener adviceListener : listeners) {
try {
if (skipAdviceListener(adviceListener)) {
continue;
}
adviceListener.afterThrowing(clazz, methodName, methodDesc, target, args, throwable);
} catch (Throwable e) {
logger.error("class: {}, methodInfo: {}", clazz.getName(), methodInfo, e);
}
}
}
}
@Override
public void atBeforeInvoke(Class<?> clazz, String invokeInfo, Object target) {
ClassLoader classLoader = clazz.getClassLoader();
String[] info = StringUtils.splitInvokeInfo(invokeInfo);
String owner = info[0];
String methodName = info[1];
String methodDesc = info[2];
List<AdviceListener> listeners = com.taobao.arthas.grpcweb.grpc.service.advisor.AdviceListenerManager.queryTraceAdviceListeners(classLoader, clazz.getName(),
owner, methodName, methodDesc);
if (listeners != null) {
for (AdviceListener adviceListener : listeners) {
try {
if (skipAdviceListener(adviceListener)) {
continue;
}
final InvokeTraceable listener = (InvokeTraceable) adviceListener;
listener.invokeBeforeTracing(classLoader, owner, methodName, methodDesc, Integer.parseInt(info[3]));
} catch (Throwable e) {
logger.error("class: {}, invokeInfo: {}", clazz.getName(), invokeInfo, e);
}
}
}
}
@Override
public void atAfterInvoke(Class<?> clazz, String invokeInfo, Object target) {
ClassLoader classLoader = clazz.getClassLoader();
String[] info = StringUtils.splitInvokeInfo(invokeInfo);
String owner = info[0];
String methodName = info[1];
String methodDesc = info[2];
List<AdviceListener> listeners = com.taobao.arthas.grpcweb.grpc.service.advisor.AdviceListenerManager.queryTraceAdviceListeners(classLoader, clazz.getName(),
owner, methodName, methodDesc);
if (listeners != null) {
for (AdviceListener adviceListener : listeners) {
try {
if (skipAdviceListener(adviceListener)) {
continue;
}
final InvokeTraceable listener = (InvokeTraceable) adviceListener;
listener.invokeAfterTracing(classLoader, owner, methodName, methodDesc, Integer.parseInt(info[3]));
} catch (Throwable e) {
logger.error("class: {}, invokeInfo: {}", clazz.getName(), invokeInfo, e);
}
}
}
}
@Override
public void atInvokeException(Class<?> clazz, String invokeInfo, Object target, Throwable throwable) {
ClassLoader classLoader = clazz.getClassLoader();
String[] info = StringUtils.splitInvokeInfo(invokeInfo);
String owner = info[0];
String methodName = info[1];
String methodDesc = info[2];
List<AdviceListener> listeners = com.taobao.arthas.grpcweb.grpc.service.advisor.AdviceListenerManager.queryTraceAdviceListeners(classLoader, clazz.getName(),
owner, methodName, methodDesc);
if (listeners != null) {
for (AdviceListener adviceListener : listeners) {
try {
if (skipAdviceListener(adviceListener)) {
continue;
}
final InvokeTraceable listener = (InvokeTraceable) adviceListener;
listener.invokeThrowTracing(classLoader, owner, methodName, methodDesc, Integer.parseInt(info[3]));
} catch (Throwable e) {
logger.error("class: {}, invokeInfo: {}", clazz.getName(), invokeInfo, e);
}
}
}
}
private static boolean skipAdviceListener(AdviceListener adviceListener) {
if (adviceListener instanceof ProcessAware) {
ProcessAware processAware = (ProcessAware) adviceListener;
ExecStatus status = processAware.getProcess().status();
if (status.equals(ExecStatus.TERMINATED) || status.equals(ExecStatus.STOPPED)) {
return true;
}
}
return false;
}
} | java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/service/advisor/AdviceListenerManager.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/service/advisor/AdviceListenerManager.java | package com.taobao.arthas.grpcweb.grpc.service.advisor;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.common.concurrent.ConcurrentWeakKeyHashMap;
import com.taobao.arthas.core.advisor.AdviceListener;
import com.taobao.arthas.core.shell.system.ExecStatus;
import com.taobao.arthas.core.shell.system.Process;
import com.taobao.arthas.core.shell.system.ProcessAware;
import com.taobao.arthas.grpcweb.grpc.DemoBootstrap;
import java.util.ArrayList;
import java.util.List;
import java.util.Map.Entry;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
/**
*
* TODO line 的记录 listener方式？ 还是有string为key，不过 classname|method|desc|num 这样子？
* 判断是否已插入了，可以在两行中间查询，有没有 SpyAPI 的invoke?
*
* TODO trace的怎么搞？ trace 只记录一次就可以了 classname|method|desc|trace ? 怎么避免 trace 到
* SPY的invoke ？直接忽略？
*
* TODO trace命令可以动态的增加 新的函数进去不？只要关联上同一个 Listener应该是可以的。
*
* TODO 在SPY里放很多的 Object数组，然后动态的设置进去？ 比如有新的 Listener来的时候。 这样子连查表都不用了。 甚至可以动态生成
* 存放这些 Listener数组的类？ 这样子的话，只要有 Binding那里，查询到一个具体分配好的类， 这样子就可以了？
* 甚至每个ClassLoader里都动态生成这样子的 存放类，那么这样子不可以避免查 ClassLoader了么？
*
* 动态为每一个增强类，生成一个新的类，新的类里，有各种的 ID 数组，保存每一个类的每一种 trace 点的信息？？
*
* 多个 watch命令 对同一个类，现在的逻辑是，每个watch都有一个自己的 TransForm，但不会重复增强，因为做了判断。
* watch命令停止时，也没有去掉增强的代码。 只有reset时 才会去掉。
*
* 其实用户想查看局部变量，并不是想查看哪一行！ 而是想看某个函数里子调用时的 局部变量的值！ 所以实际上是想要一个新的命令，比如 watchinmethod
* ， 可以 在某个子调用里，
*
* TODO 现在的trace 可以输出行号，可能不是很精确，但是可以对应上的。 这个在新的方式里怎么支持？ 增加一个 linenumber binding？
* 从mehtodNode，向上查找到最近的行号？
*
* TODO 防止重复增强，最重要的应该还是动态增加 annotation，这个才是真正可以做到某一行，某一个子 invoke 都能识别出来的！ 无论是
* transform多少次！ 字节码怎么动态加 annotation ？ annotation里签名用 url ?的key/value方式表达！
* 这样子可以有效还原信息
*
* TODO 是否考虑一个 trace /watch命令之后，得到一个具体的 Listener ID， 允许在另外的窗口里，再次
* trace/watch时指定这个ID，就会查找到，并处理。 这样子的话，真正达到了动态灵活的，一层一层增加的trace ！
*
*
* @author hengyunabc 2020-04-24
*
*/
public class AdviceListenerManager {
private static final Logger logger = LoggerFactory.getLogger(AdviceListenerManager.class);
private static final FakeBootstrapClassLoader FAKEBOOTSTRAPCLASSLOADER = new FakeBootstrapClassLoader();
static {
// 清理失效的 AdviceListener
DemoBootstrap.getRunningInstance().getScheduledExecutorService().scheduleWithFixedDelay(new Runnable() {
@Override
public void run() {
try {
for (Entry<ClassLoader, ClassLoaderAdviceListenerManager> entry : adviceListenerMap.entrySet()) {
ClassLoaderAdviceListenerManager adviceListenerManager = entry.getValue();
synchronized (adviceListenerManager) {
for (Entry<String, List<AdviceListener>> eee : adviceListenerManager.map.entrySet()) {
List<AdviceListener> listeners = eee.getValue();
List<AdviceListener> newResult = new ArrayList<AdviceListener>();
for (AdviceListener listener : listeners) {
if (listener instanceof ProcessAware) {
ProcessAware processAware = (ProcessAware) listener;
Process process = processAware.getProcess();
if (process == null) {
continue;
}
ExecStatus status = process.status();
if (!status.equals(ExecStatus.TERMINATED)) {
newResult.add(listener);
}
}
}
if (newResult.size() != listeners.size()) {
adviceListenerManager.map.put(eee.getKey(), newResult);
}
}
}
}
} catch (Throwable e) {
try {
logger.error("clean AdviceListener error", e);
} catch (Throwable t) {
// ignore
}
}
}
}, 3, 3, TimeUnit.SECONDS);
}
private static final ConcurrentWeakKeyHashMap<ClassLoader, ClassLoaderAdviceListenerManager> adviceListenerMap = new ConcurrentWeakKeyHashMap<ClassLoader, ClassLoaderAdviceListenerManager>();
static class ClassLoaderAdviceListenerManager {
private ConcurrentHashMap<String, List<AdviceListener>> map = new ConcurrentHashMap<String, List<AdviceListener>>();
private String key(String className, String methodName, String methodDesc) {
return className + methodName + methodDesc;
}
private String keyForTrace(String className, String owner, String methodName, String methodDesc) {
return className + owner + methodName + methodDesc;
}
public void registerAdviceListener(String className, String methodName, String methodDesc,
AdviceListener listener) {
synchronized (this) {
className = className.replace('/', '.');
String key = key(className, methodName, methodDesc);
List<AdviceListener> listeners = map.get(key);
if (listeners == null) {
listeners = new ArrayList<AdviceListener>();
map.put(key, listeners);
}
if (!listeners.contains(listener)) {
listeners.add(listener);
}
}
}
public List<AdviceListener> queryAdviceListeners(String className, String methodName, String methodDesc) {
className = className.replace('/', '.');
String key = key(className, methodName, methodDesc);
List<AdviceListener> listeners = map.get(key);
return listeners;
}
public void registerTraceAdviceListener(String className, String owner, String methodName, String methodDesc,
AdviceListener listener) {
className = className.replace('/', '.');
String key = keyForTrace(className, owner, methodName, methodDesc);
List<AdviceListener> listeners = map.get(key);
if (listeners == null) {
listeners = new ArrayList<AdviceListener>();
map.put(key, listeners);
}
if (!listeners.contains(listener)) {
listeners.add(listener);
}
}
public List<AdviceListener> queryTraceAdviceListeners(String className, String owner, String methodName,
String methodDesc) {
className = className.replace('/', '.');
String key = keyForTrace(className, owner, methodName, methodDesc);
List<AdviceListener> listeners = map.get(key);
return listeners;
}
}
public static void registerAdviceListener(ClassLoader classLoader, String className, String methodName,
String methodDesc, AdviceListener listener) {
classLoader = wrap(classLoader);
className = className.replace('/', '.');
ClassLoaderAdviceListenerManager manager = adviceListenerMap.get(classLoader);
if (manager == null) {
manager = new ClassLoaderAdviceListenerManager();
adviceListenerMap.put(classLoader, manager);
}
manager.registerAdviceListener(className, methodName, methodDesc, listener);
}
public static void updateAdviceListeners() {
}
public static List<AdviceListener> queryAdviceListeners(ClassLoader classLoader, String className,
String methodName, String methodDesc) {
classLoader = wrap(classLoader);
className = className.replace('/', '.');
ClassLoaderAdviceListenerManager manager = adviceListenerMap.get(classLoader);
if (manager != null) {
return manager.queryAdviceListeners(className, methodName, methodDesc);
}
return null;
}
public static void registerTraceAdviceListener(ClassLoader classLoader, String className, String owner,
String methodName, String methodDesc, AdviceListener listener) {
classLoader = wrap(classLoader);
className = className.replace('/', '.');
ClassLoaderAdviceListenerManager manager = adviceListenerMap.get(classLoader);
if (manager == null) {
manager = new ClassLoaderAdviceListenerManager();
adviceListenerMap.put(classLoader, manager);
}
manager.registerTraceAdviceListener(className, owner, methodName, methodDesc, listener);
}
public static List<AdviceListener> queryTraceAdviceListeners(ClassLoader classLoader, String className,
String owner, String methodName, String methodDesc) {
classLoader = wrap(classLoader);
className = className.replace('/', '.');
ClassLoaderAdviceListenerManager manager = adviceListenerMap.get(classLoader);
if (manager != null) {
return manager.queryTraceAdviceListeners(className, owner, methodName, methodDesc);
}
return null;
}
private static ClassLoader wrap(ClassLoader classLoader) {
if (classLoader != null) {
return classLoader;
}
return FAKEBOOTSTRAPCLASSLOADER;
}
private static class FakeBootstrapClassLoader extends ClassLoader {
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/model/WatchRequestModel.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/model/WatchRequestModel.java | package com.taobao.arthas.grpcweb.grpc.model;
import io.arthas.api.ArthasServices.WatchRequest;
import com.taobao.arthas.core.GlobalOptions;
import com.taobao.arthas.core.advisor.AdviceListener;
import com.taobao.arthas.core.advisor.AdviceWeaver;
import com.taobao.arthas.core.util.SearchUtils;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.arthas.core.util.matcher.Matcher;
import com.taobao.arthas.grpcweb.grpc.observer.ArthasStreamObserver;
import com.taobao.arthas.grpcweb.grpc.service.advisor.WatchRpcAdviceListener;
public class WatchRequestModel extends EnhancerRequestModel {
private String classPattern;
private String methodPattern;
private String express;
private String conditionExpress;
private boolean isBefore = false;
private boolean isFinish = false;
private boolean isException = false;
private boolean isSuccess = false;
private Integer expand = 1;
private Integer sizeLimit = 10 * 1024 * 1024;
private boolean isRegEx = false;
private int numberOfLimit = 100;
private static final int MAX_EXPAND = 4;
public String toString() {
return "WatchRequestModel{" +
"classPattern='" + classPattern + '\'' +
", methodPattern='" + methodPattern + '\'' +
", express='" + express + '\'' +
", conditionExpress='" + conditionExpress + '\'' +
", isBefore=" + isBefore +
", isFinish=" + isFinish +
", isException=" + isException +
", isSuccess=" + isSuccess +
", expand=" + expand +
", sizeLimit=" + sizeLimit +
", isRegEx=" + isRegEx +
", numberOfLimit=" + numberOfLimit +
", excludeClassPattern='" + excludeClassPattern + '\'' +
", jobId=" + jobId +
", listenerId=" + listenerId +
", verbose=" + verbose +
", maxNumOfMatchedClass=" + maxNumOfMatchedClass +
'}';
}
public WatchRequestModel(WatchRequest watchRequest) {
parseRequestParams(watchRequest);
}
public Matcher getClassNameMatcher() {
if (classNameMatcher == null) {
classNameMatcher = SearchUtils.classNameMatcher(getClassPattern(), isRegEx());
}
return classNameMatcher;
}
public Matcher getMethodNameMatcher() {
if (methodNameMatcher == null) {
methodNameMatcher = SearchUtils.classNameMatcher(getMethodPattern(), isRegEx());
}
return methodNameMatcher;
}
@Override
protected AdviceListener getAdviceListener(ArthasStreamObserver arthasStreamObserver) {
WatchRequestModel watchRequestModel = (WatchRequestModel) arthasStreamObserver.getRequestModel();
if (watchRequestModel.getListenerId()!= 0) {
AdviceListener listener = AdviceWeaver.listener(watchRequestModel.getListenerId());
if (listener != null) {
return listener;
}
}
return new WatchRpcAdviceListener(arthasStreamObserver, GlobalOptions.verbose || watchRequestModel.isVerbose());
}
public Matcher getClassNameExcludeMatcher() {
if (classNameExcludeMatcher == null && getExcludeClassPattern() != null) {
classNameExcludeMatcher = SearchUtils.classNameMatcher(getExcludeClassPattern(), isRegEx());
}
return classNameExcludeMatcher;
}
public void parseRequestParams(WatchRequest watchRequest){
this.classPattern = watchRequest.getClassPattern();
this.methodPattern = watchRequest.getMethodPattern();
if(StringUtils.isEmpty(watchRequest.getExpress())){
this.express = "{params, target, returnObj}";
}else {
this.express = watchRequest.getExpress();
}
this.conditionExpress = watchRequest.getConditionExpress();
this.isBefore = watchRequest.getIsBefore();
this.isFinish = watchRequest.getIsFinish();
this.isException = watchRequest.getIsException();
this.isSuccess = watchRequest.getIsSuccess();
if (!watchRequest.getIsBefore() && !watchRequest.getIsFinish() && !watchRequest.getIsException() && !watchRequest.getIsSuccess()) {
this.isFinish = true;
}
if (watchRequest.getExpand() <= 0) {
this.expand = 1;
} else if (watchRequest.getExpand() > MAX_EXPAND){
this.expand = MAX_EXPAND;
} else {
this.expand = watchRequest.getExpand();
}
if (watchRequest.getSizeLimit() == 0) {
this.sizeLimit = 10 * 1024 * 1024;
} else {
this.sizeLimit = watchRequest.getSizeLimit();
}
this.isRegEx = watchRequest.getIsRegEx();
if (watchRequest.getNumberOfLimit() == 0) {
this.numberOfLimit = 100;
} else {
this.numberOfLimit = watchRequest.getNumberOfLimit();
}
if(watchRequest.getExcludeClassPattern().equals("")){
this.excludeClassPattern = null;
}else {
this.excludeClassPattern = watchRequest.getExcludeClassPattern();
}
this.listenerId = watchRequest.getListenerId();
this.verbose = watchRequest.getVerbose();
if(watchRequest.getMaxNumOfMatchedClass() == 0){
this.maxNumOfMatchedClass = 50;
}else {
this.maxNumOfMatchedClass = watchRequest.getMaxNumOfMatchedClass();
}
this.jobId = watchRequest.getJobId();
}
public String getClassPattern() {
return classPattern;
}
public void setClassPattern(String classPattern) {
this.classPattern = classPattern;
}
public String getMethodPattern() {
return methodPattern;
}
public void setMethodPattern(String methodPattern) {
this.methodPattern = methodPattern;
}
public String getExpress() {
return express;
}
public void setExpress(String express) {
this.express = express;
}
public String getConditionExpress() {
return conditionExpress;
}
public void setConditionExpress(String conditionExpress) {
this.conditionExpress = conditionExpress;
}
public boolean isBefore() {
return isBefore;
}
public void setBefore(boolean before) {
isBefore = before;
}
public boolean isFinish() {
return isFinish;
}
public void setFinish(boolean finish) {
isFinish = finish;
}
public boolean isException() {
return isException;
}
public void setException(boolean exception) {
isException = exception;
}
public boolean isSuccess() {
return isSuccess;
}
public void setSuccess(boolean success) {
isSuccess = success;
}
public Integer getExpand() {
return expand;
}
public void setExpand(Integer expand) {
this.expand = expand;
}
public Integer getSizeLimit() {
return sizeLimit;
}
public void setSizeLimit(Integer sizeLimit) {
this.sizeLimit = sizeLimit;
}
public boolean isRegEx() {
return isRegEx;
}
public void setRegEx(boolean regEx) {
isRegEx = regEx;
}
public int getNumberOfLimit() {
return numberOfLimit;
}
public void setNumberOfLimit(int numberOfLimit) {
this.numberOfLimit = numberOfLimit;
}
public String getExcludeClassPattern() {
return excludeClassPattern;
}
public void setExcludeClassPattern(String excludeClassPattern) {
this.excludeClassPattern = excludeClassPattern;
}
public void setClassNameMatcher(Matcher classNameMatcher) {
this.classNameMatcher = classNameMatcher;
}
public void setClassNameExcludeMatcher(Matcher classNameExcludeMatcher) {
this.classNameExcludeMatcher = classNameExcludeMatcher;
}
public void setMethodNameMatcher(Matcher methodNameMatcher) {
this.methodNameMatcher = methodNameMatcher;
}
public long getListenerId() {
return listenerId;
}
public void setListenerId(long listenerId) {
this.listenerId = listenerId;
}
public boolean isVerbose() {
return verbose;
}
public void setVerbose(boolean verbose) {
this.verbose = verbose;
}
public int getMaxNumOfMatchedClass() {
return maxNumOfMatchedClass;
}
public void setMaxNumOfMatchedClass(int maxNumOfMatchedClass) {
this.maxNumOfMatchedClass = maxNumOfMatchedClass;
}
public long getJobId() {
return jobId;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/model/WatchResponseModel.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/model/WatchResponseModel.java | package com.taobao.arthas.grpcweb.grpc.model;
import com.taobao.arthas.core.command.model.WatchModel;
public class WatchResponseModel extends WatchModel {
private long resultId;
public long getResultId() {
return resultId;
}
public void setResultId(long resultId) {
this.resultId = resultId;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/model/EnhancerRequestModel.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/model/EnhancerRequestModel.java | package com.taobao.arthas.grpcweb.grpc.model;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.advisor.AdviceListener;
import com.taobao.arthas.core.advisor.InvokeTraceable;
import com.taobao.arthas.core.command.model.EnhancerModel;
import com.taobao.arthas.core.command.monitor200.AbstractTraceAdviceListener;
import com.taobao.arthas.core.util.LogUtil;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.arthas.core.util.affect.EnhancerAffect;
import com.taobao.arthas.core.util.matcher.Matcher;
import com.taobao.arthas.core.view.Ansi;
import com.taobao.arthas.grpcweb.grpc.observer.ArthasStreamObserver;
import com.taobao.arthas.grpcweb.grpc.service.advisor.Enhancer;
import java.lang.instrument.Instrumentation;
import java.util.Collections;
import java.util.List;
public abstract class EnhancerRequestModel {
private static final Logger logger = LoggerFactory.getLogger(EnhancerRequestModel.class);
protected static final List<String> EMPTY = Collections.emptyList();
public static final String[] EXPRESS_EXAMPLES = { "params", "returnObj", "throwExp", "target", "clazz", "method",
"{params,returnObj}", "params[0]" };
protected String excludeClassPattern;
protected Matcher classNameMatcher;
protected Matcher classNameExcludeMatcher;
protected Matcher methodNameMatcher;
protected long jobId;
protected long listenerId;
protected boolean verbose;
protected int maxNumOfMatchedClass;
/**
* 类名匹配
*
* @return 获取类名匹配
*/
protected abstract Matcher getClassNameMatcher();
/**
* 排除类名匹配
*/
protected abstract Matcher getClassNameExcludeMatcher();
/**
* 方法名匹配
*
* @return 获取方法名匹配
*/
protected abstract Matcher getMethodNameMatcher();
/**
* 获取监听器
*
* @return 返回监听器
*/
protected abstract AdviceListener getAdviceListener(ArthasStreamObserver arthasStreamObserver);
public void enhance(ArthasStreamObserver arthasStreamObserver) {
EnhancerAffect effect = null;
try {
Instrumentation inst = arthasStreamObserver.getInstrumentation();
AdviceListener listener = getAdviceListener(arthasStreamObserver);
if (listener == null) {
logger.error("advice listener is null");
String msg = "advice listener is null, check arthas log";
// arthasStreamObserver.appendResult(new EnhancerModel(effect, false, msg));
arthasStreamObserver.end(-1, msg);
return;
}
boolean skipJDKTrace = false;
if(listener instanceof AbstractTraceAdviceListener) {
skipJDKTrace = ((AbstractTraceAdviceListener) listener).getCommand().isSkipJDKTrace();
}
Enhancer enhancer = new Enhancer(listener, listener instanceof InvokeTraceable, skipJDKTrace, getClassNameMatcher(), getClassNameExcludeMatcher(), getMethodNameMatcher());
// 注册通知监听器
arthasStreamObserver.register(listener, enhancer);
effect = enhancer.enhance(inst, this.maxNumOfMatchedClass);
if (effect.getThrowable() != null) {
String msg = "error happens when enhancing class: "+effect.getThrowable().getMessage();
// arthasStreamObserver.appendResult(new EnhancerModel(effect, false, msg));
arthasStreamObserver.end(-1, msg + ", check arthas log: " + LogUtil.loggingFile());
return;
}
if (effect.cCnt() == 0 || effect.mCnt() == 0) {
// no class effected
if (!StringUtils.isEmpty(effect.getOverLimitMsg())) {
String msg = "no class effected";
// arthasStreamObserver.appendResult(new EnhancerModel(effect, false));
arthasStreamObserver.end(-1, msg);
return;
}
// might be method code too large
// arthasStreamObserver.appendResult(new EnhancerModel(effect, false, "No class or method is affected"));
String smCommand = Ansi.ansi().fg(Ansi.Color.GREEN).a("sm CLASS_NAME METHOD_NAME").reset().toString();
String optionsCommand = Ansi.ansi().fg(Ansi.Color.GREEN).a("options unsafe true").reset().toString();
String javaPackage = Ansi.ansi().fg(Ansi.Color.GREEN).a("java.*").reset().toString();
String resetCommand = Ansi.ansi().fg(Ansi.Color.GREEN).a("reset CLASS_NAME").reset().toString();
String logStr = Ansi.ansi().fg(Ansi.Color.GREEN).a(LogUtil.loggingFile()).reset().toString();
String issueStr = Ansi.ansi().fg(Ansi.Color.GREEN).a("https://github.com/alibaba/arthas/issues/47").reset().toString();
String msg = "No class or method is affected, try:\n"
+ "1. Execute `" + smCommand + "` to make sure the method you are tracing actually exists (it might be in your parent class).\n"
+ "2. Execute `" + optionsCommand + "`, if you want to enhance the classes under the `" + javaPackage + "` package.\n"
+ "3. Execute `" + resetCommand + "` and try again, your method body might be too large.\n"
+ "4. Match the constructor, use `<init>`, for example: `watch demo.MathGame <init>`\n"
+ "5. Check arthas log: " + logStr + "\n"
+ "6. Visit " + issueStr + " for more details.";
arthasStreamObserver.end(-1, msg);
return;
}
arthasStreamObserver.appendResult(new EnhancerModel(effect, true));
//异步执行，在RpcAdviceListener中结束
} catch (Throwable e) {
String msg = "error happens when enhancing class: "+e.getMessage();
logger.error(msg, e);
// arthasStreamObserver.appendResult(new EnhancerModel(effect, false, msg));
arthasStreamObserver.end(-1, msg);
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/observer/ArthasStreamObserver.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/observer/ArthasStreamObserver.java | package com.taobao.arthas.grpcweb.grpc.observer;
import com.taobao.arthas.core.advisor.AdviceListener;
import com.taobao.arthas.core.command.model.ResultModel;
import com.taobao.arthas.core.shell.system.ExecStatus;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.Instrumentation;
import java.util.concurrent.atomic.AtomicInteger;
public interface ArthasStreamObserver<T> {
void onNext(T value);
void onError(Throwable t);
void onCompleted();
Instrumentation getInstrumentation();
ArthasStreamObserver write(String msg);
void appendResult(ResultModel result);
AtomicInteger times();
void register(AdviceListener listener, ClassFileTransformer transformer);
void unregister();
void end();
ExecStatus getPorcessStatus();
void setProcessStatus(ExecStatus execStatus);
/**
* End the process.
*
* @param status the exit status.
*/
void end(int status);
/**
* End the process.
*
* @param status the exit status.
*/
void end(int status, String message);
int getJobId();
Object getRequestModel();
void setRequestModel(Object requestModel);
AdviceListener getListener();
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/observer/impl/ArthasStreamObserverImpl.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/observer/impl/ArthasStreamObserverImpl.java | package com.taobao.arthas.grpcweb.grpc.observer.impl;
import io.arthas.api.ArthasServices.ResponseBody;
import com.taobao.arthas.core.advisor.AdviceListener;
import com.taobao.arthas.core.advisor.AdviceWeaver;
import com.taobao.arthas.core.command.model.ResultModel;
import com.taobao.arthas.core.command.model.StatusModel;
import com.taobao.arthas.core.distribution.ResultDistributor;
import com.taobao.arthas.core.shell.system.ExecStatus;
import com.taobao.arthas.core.shell.system.ProcessAware;
import com.taobao.arthas.grpcweb.grpc.DemoBootstrap;
import com.taobao.arthas.grpcweb.grpc.distribution.GrpcResultDistributorImpl;
import com.taobao.arthas.grpcweb.grpc.observer.ArthasStreamObserver;
import com.taobao.arthas.grpcweb.grpc.service.GrpcJobController;
import io.grpc.stub.ServerCallStreamObserver;
import io.grpc.stub.StreamObserver;
import java.lang.instrument.ClassFileTransformer;
import java.lang.instrument.Instrumentation;
import java.util.concurrent.atomic.AtomicInteger;
public class ArthasStreamObserverImpl<T> implements ArthasStreamObserver<T> {
private StreamObserver<T> streamObserver;
private AtomicInteger times = new AtomicInteger();
private GrpcProcess process;
private Object requestModel;
private AdviceListener listener;
private ClassFileTransformer transformer;
private final int jobId;
private ResultDistributor resultDistributor;
private GrpcJobController grpcJobController;
private Instrumentation instrumentation;
public ArthasStreamObserverImpl(StreamObserver<T> streamObserver, Object requestModel, GrpcJobController grpcJobController){
this.streamObserver = streamObserver;
this.jobId = grpcJobController.generateGrpcJobId();
this.instrumentation = grpcJobController.getInstrumentation();
if (resultDistributor == null) {
resultDistributor = new GrpcResultDistributorImpl(this, grpcJobController.getResultViewResolver());
}
this.process = new GrpcProcess();
this.process.setProcessStatus(ExecStatus.READY);
// 请求参数
this.requestModel = requestModel;
// 配置客户端取消事件
this.setOnCancelHandler();
this.grpcJobController = grpcJobController;
this.grpcJobController.registerGrpcJob(jobId, this);
}
@Override
public void onNext(T value) {
streamObserver.onNext(value);
}
@Override
public void onError(Throwable t) {
streamObserver.onError(t);
}
@Override
public void onCompleted() {
this.process.setProcessStatus(ExecStatus.TERMINATED);
// grpcJobController.unRegisterGrpcJob(this.jobId);
streamObserver.onCompleted();
}
@Override
public AtomicInteger times() {
return times;
}
@Override
public void register(AdviceListener adviceListener, ClassFileTransformer transformer) {
if (adviceListener instanceof ProcessAware) {
ProcessAware processAware = (ProcessAware) adviceListener;
// listener 有可能是其它 command 创建的
if(processAware.getProcess() == null) {
this.process.setProcessStatus(ExecStatus.RUNNING);
processAware.setProcess(this.process);
}
}
this.listener = adviceListener;
AdviceWeaver.reg(listener);
this.transformer = transformer;
}
@Override
public void unregister() {
if (transformer != null) {
DemoBootstrap.getRunningInstance().getTransformerManager().removeTransformer(transformer);
}
this.process.setProcessStatus(ExecStatus.TERMINATED);
if (listener instanceof ProcessAware) {
// listener有可能其它 command 创建的，所以不能unRge
if (this.process.equals(((ProcessAware) listener).getProcess())) {
AdviceWeaver.unReg(listener);
}
} else {
AdviceWeaver.unReg(listener);
}
}
@Override
public void end() {
end(0);
}
@Override
public ExecStatus getPorcessStatus() {
return this.process.status();
}
@Override
public void setProcessStatus(ExecStatus execStatus){
this.process.setProcessStatus(execStatus);
}
@Override
public void end(int statusCode) {
end(statusCode, null);
}
@Override
public void end(int statusCode, String message) {
terminate(statusCode, message);
}
@Override
public ArthasStreamObserver write(String msg) {
ResponseBody result = ResponseBody.newBuilder().setStringValue(msg).build();
onNext((T) result);
return this;
}
@Override
public void appendResult(ResultModel result) {
if (process.status() != ExecStatus.RUNNING) {
throw new IllegalStateException(
"Cannot write to standard output when " + process.status().name().toLowerCase());
}
result.setJobId(jobId);
if (resultDistributor != null) {
resultDistributor.appendResult(result);
}
}
@Override
public int getJobId() {
return jobId;
}
@Override
public Object getRequestModel() {
return requestModel;
}
@Override
public void setRequestModel(Object requestModel) {
this.requestModel = requestModel;
}
public void setOnCancelHandler() {
ServerCallStreamObserver<T> observer = (ServerCallStreamObserver<T>) this.streamObserver;
observer.setOnCancelHandler(() -> {
this.end();
});
}
private synchronized boolean terminate(int exitCode, String message) {
boolean flag;
if (process.status() != ExecStatus.TERMINATED) {
//add status message
this.appendResult(new StatusModel(exitCode, message));
if (process != null) {
this.unregister();
}
flag = true;
} else {
flag = false;
}
this.onCompleted();
return flag;
}
public AdviceListener getListener() {
return listener;
}
@Override
public Instrumentation getInstrumentation() {
return instrumentation;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/observer/impl/GrpcProcess.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/observer/impl/GrpcProcess.java | package com.taobao.arthas.grpcweb.grpc.observer.impl;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.arthas.core.shell.session.Session;
import com.taobao.arthas.core.shell.system.ExecStatus;
import com.taobao.arthas.core.shell.system.Process;
import com.taobao.arthas.core.shell.term.Tty;
import java.util.Date;
public class GrpcProcess implements Process {
private ExecStatus processStatus;
public void setProcessStatus(ExecStatus processStatus) {
this.processStatus = processStatus;
}
@Override
public ExecStatus status() {
return processStatus;
}
@Override
public Integer exitCode() {
return null;
}
@Override
public Process setTty(Tty tty) {
return null;
}
@Override
public Tty getTty() {
return null;
}
@Override
public Process setSession(Session session) {
return null;
}
@Override
public Session getSession() {
return null;
}
@Override
public Process terminatedHandler(Handler<Integer> handler) {
return null;
}
@Override
public void run() {
}
@Override
public void run(boolean foreground) {
}
@Override
public boolean interrupt() {
return false;
}
@Override
public boolean interrupt(Handler<Void> completionHandler) {
return false;
}
@Override
public void resume() {
}
@Override
public void resume(boolean foreground) {
}
@Override
public void resume(Handler<Void> completionHandler) {
}
@Override
public void resume(boolean foreground, Handler<Void> completionHandler) {
}
@Override
public void suspend() {
}
@Override
public void suspend(Handler<Void> completionHandler) {
}
@Override
public void terminate() {
}
@Override
public void terminate(Handler<Void> completionHandler) {
}
@Override
public void toBackground() {
}
@Override
public void toBackground(Handler<Void> completionHandler) {
}
@Override
public void toForeground() {
}
@Override
public void toForeground(Handler<Void> completionHandler) {
}
@Override
public int times() {
return 0;
}
@Override
public Date startTime() {
return null;
}
@Override
public String cacheLocation() {
return null;
}
@Override
public void setJobId(int jobId) {
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/objectUtils/ComplexObject.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/objectUtils/ComplexObject.java | package com.taobao.arthas.grpcweb.grpc.objectUtils;
import java.util.Collection;
import java.util.List;
import java.util.Map;
// ComplexObject.java
public class ComplexObject {
private int id;
private String name;
private double value;
private int[] numbers;
private Long[] longNumbers;
private NestedObject nestedObject;
private ComplexObject[] complexArray;
private int[][] multiDimensionalArray;
private String[] stringArray;
private Collection<String> collection;
List<String> stringList;
Map<String, Integer> stringIntegerMap;
private Double[] doubleArray;
public static class NestedObject {
private int nestedId;
private String nestedName;
private boolean flag;
public int getNestedId() {
return nestedId;
}
public void setNestedId(int nestedId) {
this.nestedId = nestedId;
}
public String getNestedName() {
return nestedName;
}
public void setNestedName(String nestedName) {
this.nestedName = nestedName;
}
public boolean isFlag() {
return flag;
}
public void setFlag(boolean flag) {
this.flag = flag;
}
}
public Map<String, Integer> getStringIntegerMap() {
return stringIntegerMap;
}
public void setStringIntegerMap(Map<String, Integer> stringIntegerMap) {
this.stringIntegerMap = stringIntegerMap;
}
public Double[] getDoubleArray() {
return doubleArray;
}
public void setDoubleArray(Double[] doubleArray) {
this.doubleArray = doubleArray;
}
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public double getValue() {
return value;
}
public void setValue(double value) {
this.value = value;
}
public int[] getNumbers() {
return numbers;
}
public void setNumbers(int[] numbers) {
this.numbers = numbers;
}
public NestedObject getNestedObject() {
return nestedObject;
}
public void setNestedObject(NestedObject nestedObject) {
this.nestedObject = nestedObject;
}
public ComplexObject[] getComplexArray() {
return complexArray;
}
public void setComplexArray(ComplexObject[] complexArray) {
this.complexArray = complexArray;
}
public int[][] getMultiDimensionalArray() {
return multiDimensionalArray;
}
public void setMultiDimensionalArray(int[][] multiDimensionalArray) {
this.multiDimensionalArray = multiDimensionalArray;
}
public String[] getStringArray() {
return stringArray;
}
public void setStringArray(String[] stringArray) {
this.stringArray = stringArray;
}
public Long[] getLongNumbers() {
return longNumbers;
}
public void setLongNumbers(Long[] longNumbers) {
this.longNumbers = longNumbers;
}
public Collection<String> getCollection() {
return collection;
}
public void setCollection(Collection<String> collection) {
this.collection = collection;
}
public List<String> getStringList() {
return stringList;
}
public void setStringList(List<String> stringList) {
this.stringList = stringList;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/objectUtils/JavaObjectConverter.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/objectUtils/JavaObjectConverter.java | package com.taobao.arthas.grpcweb.grpc.objectUtils;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import io.arthas.api.ArthasServices.ArrayElement;
import io.arthas.api.ArthasServices.ArrayValue;
import io.arthas.api.ArthasServices.BasicValue;
import io.arthas.api.ArthasServices.CollectionValue;
import io.arthas.api.ArthasServices.CollectionValue.Builder;
import io.arthas.api.ArthasServices.JavaField;
import io.arthas.api.ArthasServices.JavaFields;
import io.arthas.api.ArthasServices.JavaObject;
import io.arthas.api.ArthasServices.MapEntry;
import io.arthas.api.ArthasServices.MapValue;
import io.arthas.api.ArthasServices.NullValue;
import io.arthas.api.ArthasServices.UnexpandedObject;
public class JavaObjectConverter {
private static final int MAX_DEPTH = 5;
public static JavaObject toJavaObject(Object obj) {
return toJavaObject(obj, 0);
}
public static JavaObject toJavaObjectWithExpand(Object obj, int expand){
int depth;
if(expand <= 0){
depth = MAX_DEPTH - 1;
}else if(expand >= MAX_DEPTH){
depth = 0;
}else {
depth = MAX_DEPTH - expand;
}
return toJavaObject(obj, depth);
}
public static JavaObject toJavaObject(Object obj, int depth) {
if (depth >= MAX_DEPTH) {
return null;
}
if (obj == null) {
return JavaObject.newBuilder().setNullValue(NullValue.getDefaultInstance()).build();
}
JavaObject.Builder objectBuilder = JavaObject.newBuilder();
Class<? extends Object> objClazz = obj.getClass();
objectBuilder.setClassName(objClazz.getName());
// 基础类型
if (isBasicType(objClazz)) {
return objectBuilder.setBasicValue(createBasicValue(obj)).build();
} else if (obj instanceof Collection) { // 集合
return objectBuilder.setCollection(createCollectionValue((Collection<?>) obj, depth)).build();
} else if (obj instanceof Map) { // map
return objectBuilder.setMap(createMapValue((Map<?, ?>) obj, depth)).build();
} else if (objClazz.isArray()) {
return objectBuilder.setArrayValue(toArrayValue(obj, depth)).build();
}
Field[] fields = objClazz.getDeclaredFields();
List<JavaField> javaFields = new ArrayList<>();
for (Field field : fields) {
field.setAccessible(true);
JavaField.Builder fieldBuilder = JavaField.newBuilder();
fieldBuilder.setName(field.getName());
try {
Object fieldValue = field.get(obj);
Class<?> fieldType = field.getType();
if (fieldValue == null) {
fieldBuilder.setNullValue(NullValue.newBuilder().setClassName(fieldType.getName()).build());
} else if (fieldType.isArray()) {
ArrayValue arrayValue = toArrayValue(fieldValue, depth + 1);
if (arrayValue != null) {
fieldBuilder.setArrayValue(arrayValue);
} else {
fieldBuilder.setUnexpandedObject(
UnexpandedObject.newBuilder().setClassName(fieldType.getName()).build());
}
} else if (fieldType.isPrimitive() || isBasicType(fieldType)) {
BasicValue basicValue = createBasicValue(fieldValue);
fieldBuilder.setBasicValue(basicValue);
} else if (fieldValue instanceof Collection) { // 集合
fieldBuilder.setCollection(createCollectionValue((Collection<?>) fieldValue, depth));
} else if (fieldValue instanceof Map) { // map
fieldBuilder.setMap(createMapValue((Map<?, ?>) fieldValue, depth));
} else {
JavaObject nestedObject = toJavaObject(fieldValue, depth + 1);
if (nestedObject != null) {
fieldBuilder.setObjectValue(nestedObject);
} else {
fieldBuilder.setUnexpandedObject(
UnexpandedObject.newBuilder().setClassName(fieldType.getName()).build());
}
}
} catch (IllegalAccessException e) {
// TODO ignore ?
}
javaFields.add(fieldBuilder.build());
}
objectBuilder.setFields(JavaFields.newBuilder().addAllFields(javaFields).build());
return objectBuilder.build();
}
private static ArrayValue toArrayValue(Object array, int depth) {
if (array == null || depth >= MAX_DEPTH) {
return null;
}
ArrayValue.Builder arrayBuilder = ArrayValue.newBuilder();
Class<?> componentType = array.getClass().getComponentType();
arrayBuilder.setClassName(componentType.getName());
int length = Array.getLength(array);
for (int i = 0; i < length; i++) {
Object element = Array.get(array, i);
if (element != null) {
if (componentType.isArray()) {
ArrayValue nestedArrayValue = toArrayValue(element, depth + 1);
if (nestedArrayValue != null) {
arrayBuilder.addElements(ArrayElement.newBuilder().setArrayValue(nestedArrayValue));
} else {
arrayBuilder.addElements(ArrayElement.newBuilder().setUnexpandedObject(
UnexpandedObject.newBuilder().setClassName(element.getClass().getName()).build()));
}
} else if (componentType.isPrimitive() || isBasicType(componentType)) {
BasicValue basicValue = createBasicValue(element);
arrayBuilder.addElements(ArrayElement.newBuilder().setBasicValue(basicValue));
} else {
JavaObject nestedObject = toJavaObject(element, depth + 1);
if (nestedObject != null) {
arrayBuilder.addElements(ArrayElement.newBuilder().setObjectValue(nestedObject));
} else {
arrayBuilder.addElements(ArrayElement.newBuilder().setUnexpandedObject(
UnexpandedObject.newBuilder().setClassName(element.getClass().getName()).build()));
}
}
} else {
arrayBuilder.addElements(ArrayElement.newBuilder()
.setNullValue(NullValue.newBuilder().setClassName(componentType.getName()).build()));
}
}
return arrayBuilder.build();
}
private static MapValue createMapValue(Map<?, ?> map, int depth) {
MapValue.Builder builder = MapValue.newBuilder();
for (Entry<?, ?> entry : map.entrySet()) {
MapEntry mapEntry = MapEntry.newBuilder().setKey(toJavaObject(entry.getKey(), depth))
.setValue(toJavaObject(entry.getValue(), depth)).build();
builder.addEntries(mapEntry);
}
return builder.build();
}
private static CollectionValue createCollectionValue(Collection<?> collection, int depth) {
Builder builder = CollectionValue.newBuilder();
for (Object o : collection) {
builder.addElements(toJavaObject(o, depth));
}
return builder.build();
}
private static BasicValue createBasicValue(Object value) {
BasicValue.Builder builder = BasicValue.newBuilder();
if (value instanceof Integer) {
builder.setInt((int) value);
} else if (value instanceof Long) {
builder.setLong((long) value);
} else if (value instanceof Float) {
builder.setFloat((float) value);
} else if (value instanceof Double) {
builder.setDouble((double) value);
} else if (value instanceof Boolean) {
builder.setBoolean((boolean) value);
} else if (value instanceof String) {
builder.setString((String) value);
}
return builder.build();
}
private static boolean isBasicType(Class<?> clazz) {
if (String.class.equals(clazz) || Integer.class.equals(clazz) || Long.class.equals(clazz)
|| Float.class.equals(clazz) || Double.class.equals(clazz) || Boolean.class.equals(clazz)) {
return true;
}
return false;
}
} | java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/distribution/GrpcResultDistributorImpl.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/distribution/GrpcResultDistributorImpl.java | package com.taobao.arthas.grpcweb.grpc.distribution;
import com.taobao.arthas.core.command.model.ResultModel;
import com.taobao.arthas.core.distribution.ResultDistributor;
import com.taobao.arthas.grpcweb.grpc.observer.ArthasStreamObserver;
import com.taobao.arthas.grpcweb.grpc.view.GrpcResultView;
import com.taobao.arthas.grpcweb.grpc.view.GrpcResultViewResolver;
public class GrpcResultDistributorImpl implements ResultDistributor {
private final ArthasStreamObserver arthasStreamObserver;
private final GrpcResultViewResolver grpcResultViewResolver;
public GrpcResultDistributorImpl(ArthasStreamObserver arthasStreamObserver, GrpcResultViewResolver resultViewResolver) {
this.arthasStreamObserver = arthasStreamObserver;
this.grpcResultViewResolver = resultViewResolver;
}
@Override
public void appendResult(ResultModel model) {
GrpcResultView resultView = grpcResultViewResolver.getResultView(model);
if (resultView != null) {
resultView.draw(arthasStreamObserver, model);
}
}
@Override
public void close() {
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/view/GrpcPwdView.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/view/GrpcPwdView.java | package com.taobao.arthas.grpcweb.grpc.view;
import io.arthas.api.ArthasServices.ResponseBody;
import io.arthas.api.ArthasServices.StringStringMapValue;
import com.taobao.arthas.core.command.model.PwdModel;
import com.taobao.arthas.grpcweb.grpc.observer.ArthasStreamObserver;
/**
* @author xuyang 2023/8/15
*/
public class GrpcPwdView extends GrpcResultView<PwdModel> {
@Override
public void draw(ArthasStreamObserver arthasStreamObserver, PwdModel result) {
StringStringMapValue stringStringMapValue = StringStringMapValue.newBuilder()
.putStringStringMap("workingDir", result.getWorkingDir()).build();
ResponseBody responseBody = ResponseBody.newBuilder()
.setJobId(result.getJobId())
.setType(result.getType())
.setStringStringMapValue(stringStringMapValue)
.build();
arthasStreamObserver.onNext(responseBody);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/view/GrpcStatusView.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/view/GrpcStatusView.java | package com.taobao.arthas.grpcweb.grpc.view;
import io.arthas.api.ArthasServices.ResponseBody;
import com.taobao.arthas.core.command.model.StatusModel;
import com.taobao.arthas.grpcweb.grpc.observer.ArthasStreamObserver;
/**
* @author xuyang 2023/8/15
*/
public class GrpcStatusView extends GrpcResultView<StatusModel> {
@Override
public void draw(ArthasStreamObserver arthasStreamObserver, StatusModel result) {
if (result.getMessage() != null) {
ResponseBody responseBody = ResponseBody.newBuilder()
.setJobId(result.getJobId())
.setType(result.getType())
.setStringValue(result.getMessage())
.build();
arthasStreamObserver.onNext(responseBody);
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/view/GrpcResultViewResolver.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/view/GrpcResultViewResolver.java | package com.taobao.arthas.grpcweb.grpc.view;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.command.model.ResultModel;
import com.taobao.arthas.grpcweb.grpc.observer.ArthasStreamObserver;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* Result view resolver for term
*
* @author xuyang 2023/8/15
*/
public class GrpcResultViewResolver {
private static final Logger logger = LoggerFactory.getLogger(GrpcResultViewResolver.class);
// modelClass -> view
private Map<Class, GrpcResultView> resultViewMap = new ConcurrentHashMap<Class, GrpcResultView>();
public GrpcResultViewResolver() {
initResultViews();
}
/**
* 需要调用此方法初始化注册ResultView
*/
private void initResultViews() {
try {
// registerView(RowAffectView.class);
//basic1000
registerView(GrpcStatusView.class);
// registerView(VersionView.class);
registerView(GrpcMessageView.class);
// registerView(HelpView.class);
//registerView(HistoryView.class);
// registerView(EchoView.class);
// registerView(CatView.class);
// registerView(Base64View.class);
// registerView(OptionsView.class);
registerView(GrpcSystemPropertyView.class);
// registerView(SystemEnvView.class);
registerView(GrpcPwdView.class);
// registerView(VMOptionView.class);
// registerView(SessionView.class);
// registerView(ResetView.class);
// registerView(ShutdownView.class);
//klass100
// registerView(ClassLoaderView.class);
// registerView(DumpClassView.class);
// registerView(GetStaticView.class);
// registerView(JadView.class);
// registerView(MemoryCompilerView.class);
// registerView(OgnlView.class);
// registerView(RedefineView.class);
// registerView(RetransformView.class);
// registerView(SearchClassView.class);
// registerView(SearchMethodView.class);
//logger
// registerView(LoggerView.class);
//monitor2000
// registerView(DashboardView.class);
// registerView(JvmView.class);
// registerView(MemoryView.class);
// registerView(MBeanView.class);
// registerView(PerfCounterView.class);
// registerView(ThreadView.class);
// registerView(ProfilerView.class);
registerView(GrpcEnhancerView.class);
// registerView(MonitorView.class);
// registerView(StackView.class);
// registerView(TimeTunnelView.class);
// registerView(TraceView.class);
registerView(GrpcWatchView.class);
// registerView(VmToolView.class);
// registerView(JFRView.class);
} catch (Throwable e) {
logger.error("register result view failed", e);
}
}
public GrpcResultView getResultView(ResultModel model) {
return resultViewMap.get(model.getClass());
}
public GrpcResultViewResolver registerView(Class modelClass, GrpcResultView view) {
//TODO 检查model的type是否重复，避免复制代码带来的bug
this.resultViewMap.put(modelClass, view);
return this;
}
public GrpcResultViewResolver registerView(GrpcResultView view) {
Class modelClass = getModelClass(view);
if (modelClass == null) {
throw new NullPointerException("model class is null");
}
return this.registerView(modelClass, view);
}
public void registerView(Class<? extends GrpcResultView> viewClass) {
GrpcResultView view = null;
try {
view = viewClass.newInstance();
} catch (Throwable e) {
throw new RuntimeException("create view instance failure, viewClass:" + viewClass, e);
}
this.registerView(view);
}
/**
* Get model class of result view
*
* @return
*/
public static <V extends GrpcResultView> Class getModelClass(V view) {
//类反射获取子类的draw方法第二个参数的ResultModel具体类型
Class<? extends GrpcResultView> viewClass = view.getClass();
Method[] declaredMethods = viewClass.getDeclaredMethods();
for (int i = 0; i < declaredMethods.length; i++) {
Method method = declaredMethods[i];
if (method.getName().equals("draw")) {
Class<?>[] parameterTypes = method.getParameterTypes();
if (parameterTypes.length == 2
&& parameterTypes[0] == ArthasStreamObserver.class
&& parameterTypes[1] != ResultModel.class
&& ResultModel.class.isAssignableFrom(parameterTypes[1])) {
return parameterTypes[1];
}
}
}
return null;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/view/GrpcEnhancerView.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/view/GrpcEnhancerView.java | package com.taobao.arthas.grpcweb.grpc.view;
import io.arthas.api.ArthasServices.ResponseBody;
import com.taobao.arthas.core.command.model.EnhancerModel;
import com.taobao.arthas.core.command.view.ViewRenderUtil;
import com.taobao.arthas.grpcweb.grpc.observer.ArthasStreamObserver;
/**
* Term grpc view for EnhancerModel
* @author xuyang 2023/8/15
*/
public class GrpcEnhancerView extends GrpcResultView<EnhancerModel> {
@Override
public void draw(ArthasStreamObserver arthasStreamObserver, EnhancerModel result) {
if (result.getEffect() != null) {
String msg = ViewRenderUtil.renderEnhancerAffect(result.getEffect());
ResponseBody responseBody = ResponseBody.newBuilder()
.setJobId(result.getJobId())
.setType(result.getType())
.setStringValue(msg)
.build();
arthasStreamObserver.onNext(responseBody);
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/view/GrpcMessageView.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/view/GrpcMessageView.java | package com.taobao.arthas.grpcweb.grpc.view;
import io.arthas.api.ArthasServices.ResponseBody;
import com.taobao.arthas.core.command.model.MessageModel;
import com.taobao.arthas.grpcweb.grpc.observer.ArthasStreamObserver;
public class GrpcMessageView extends GrpcResultView<MessageModel> {
@Override
public void draw(ArthasStreamObserver arthasStreamObserver, MessageModel result) {
ResponseBody responseBody = ResponseBody.newBuilder()
.setJobId(result.getJobId())
.setType(result.getType())
.setStringValue(result.getMessage())
.build();
arthasStreamObserver.onNext(responseBody);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/view/GrpcSystemPropertyView.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/view/GrpcSystemPropertyView.java | package com.taobao.arthas.grpcweb.grpc.view;
import io.arthas.api.ArthasServices.ResponseBody;
import io.arthas.api.ArthasServices.StringStringMapValue;
import com.taobao.arthas.core.command.model.SystemPropertyModel;
import com.taobao.arthas.grpcweb.grpc.observer.ArthasStreamObserver;
public class GrpcSystemPropertyView extends GrpcResultView<SystemPropertyModel>{
@Override
public void draw(ArthasStreamObserver arthasStreamObserver, SystemPropertyModel result) {
StringStringMapValue stringStringMapValue = StringStringMapValue.newBuilder()
.putAllStringStringMap(result.getProps()).build();
ResponseBody responseBody = ResponseBody.newBuilder()
.setJobId(result.getJobId())
.setType(result.getType())
.setStringStringMapValue(stringStringMapValue)
.build();
arthasStreamObserver.onNext(responseBody);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/view/GrpcWatchView.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/view/GrpcWatchView.java | package com.taobao.arthas.grpcweb.grpc.view;
import com.taobao.arthas.core.view.ObjectView;
import com.taobao.arthas.grpcweb.grpc.model.WatchRequestModel;
import io.arthas.api.ArthasServices.JavaObject;
import io.arthas.api.ArthasServices.ResponseBody;
import io.arthas.api.ArthasServices.WatchResponse;
import com.taobao.arthas.core.command.model.ObjectVO;
import com.taobao.arthas.core.util.DateUtils;
import com.taobao.arthas.grpcweb.grpc.model.WatchResponseModel;
import com.taobao.arthas.grpcweb.grpc.observer.ArthasStreamObserver;
import static com.taobao.arthas.grpcweb.grpc.objectUtils.JavaObjectConverter.toJavaObjectWithExpand;
/**
* Term view for WatchModel
*
* @author xuyang 2023/8/15
*/
public class GrpcWatchView extends GrpcResultView<WatchResponseModel> {
@Override
public void draw(ArthasStreamObserver arthasStreamObserver, WatchResponseModel model) {
ObjectVO objectVO = model.getValue();
// Object obj = objectVO.needExpand() ? new ObjectView(model.getSizeLimit(), objectVO).draw() : objectVO.getObject();
JavaObject javaObject = toJavaObjectWithExpand(objectVO.getObject(), objectVO.getExpand());
WatchResponse watchResponse = WatchResponse.newBuilder()
.setAccessPoint(model.getAccessPoint())
.setClassName(model.getClassName())
.setCost(model.getCost())
.setMethodName(model.getMethodName())
.setSizeLimit(model.getSizeLimit())
.setTs(DateUtils.formatDateTime(model.getTs()))
.setValue(javaObject)
.build();
ResponseBody responseBody = ResponseBody.newBuilder()
.setJobId(model.getJobId())
.setResultId(model.getResultId())
.setType(model.getType())
.setWatchResponse(watchResponse)
.build();
arthasStreamObserver.onNext(responseBody);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/view/GrpcResultView.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/view/GrpcResultView.java | package com.taobao.arthas.grpcweb.grpc.view;
import com.taobao.arthas.core.command.model.ResultModel;
import com.taobao.arthas.grpcweb.grpc.observer.ArthasStreamObserver;
/**
* Command result view for grpc client.
* Note: Result view is a reusable and stateless instance
*
* @author xuyang 2023/8/15
*/
public abstract class GrpcResultView<T extends ResultModel> {
/**
* formatted printing data to grpc client
*
* @param arthasStreamObserver
*/
public abstract void draw(ArthasStreamObserver arthasStreamObserver, T result);
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/server/GrpcServer.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/server/GrpcServer.java | package com.taobao.arthas.grpcweb.grpc.server;
import arthas.VmTool;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.common.SocketUtils;
import com.taobao.arthas.core.advisor.TransformerManager;
import com.taobao.arthas.grpcweb.grpc.service.*;
import com.taobao.arthas.grpcweb.grpc.view.GrpcResultViewResolver;
import io.grpc.Server;
import io.grpc.ServerBuilder;
import java.io.File;
import java.io.IOException;
import java.lang.instrument.Instrumentation;
import java.lang.invoke.MethodHandles;
public class GrpcServer {
private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass().getName());
private int port;
private Server grpcServer;
private Instrumentation instrumentation;
private TransformerManager transformerManager;
public GrpcServer(int port, Instrumentation instrumentation, TransformerManager transformerManager) {
if (port == 0) {
this.port = SocketUtils.findAvailableTcpPort();
} else {
this.port = port;
}
this.instrumentation = instrumentation;
this.transformerManager = transformerManager;
}
public void start() {
GrpcResultViewResolver grpcResultViewResolver = new GrpcResultViewResolver();
GrpcJobController grpcJobController = new GrpcJobController(this.instrumentation, this.transformerManager, grpcResultViewResolver);
File path = new File(VmTool.class.getProtectionDomain().getCodeSource().getLocation().getPath()).getParentFile();
String libPath = path.getAbsolutePath();
try {
grpcServer = ServerBuilder.forPort(port)
.addService(new ObjectService(grpcJobController,libPath))
.addService(new PwdCommandService(grpcJobController))
.addService(new SystemPropertyCommandService(grpcJobController))
.addService(new WatchCommandService(grpcJobController))
.build()
.start();
logger.info("Server started, listening on " + port);
Runtime.getRuntime().addShutdownHook(new Thread("grpc-server-shutdown") {
@Override
public void run() {
if (grpcServer != null) {
grpcServer.shutdown();
}
}
});
} catch (IOException e) {
throw new RuntimeException(e);
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/server/httpServer/NettyHttpServer.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/server/httpServer/NettyHttpServer.java | package com.taobao.arthas.grpcweb.grpc.server.httpServer;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import java.lang.invoke.MethodHandles;
public class NettyHttpServer {
private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass().getName());
private int port;
private final String STATIC_LOCATION;
public NettyHttpServer(int port, String staticLocation) {
this.port = port;
this.STATIC_LOCATION = staticLocation;
}
public void start() throws InterruptedException {
NioEventLoopGroup boss = new NioEventLoopGroup(1);
NioEventLoopGroup work = new NioEventLoopGroup();
try {
ServerBootstrap serverBootstrap = new ServerBootstrap();
serverBootstrap.group(boss, work)
.channel(NioServerSocketChannel.class)
.childHandler(new NettyHttpInitializer(this.STATIC_LOCATION))
.option(ChannelOption.SO_BACKLOG, 128)
.childOption(ChannelOption.SO_KEEPALIVE, true);
logger.info("start http server on port: {}", port);
ChannelFuture future = serverBootstrap.bind(port).sync();
future.channel().closeFuture().sync();
} finally {
work.shutdownGracefully();
boss.shutdownGracefully();
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/server/httpServer/NettyHttpInitializer.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/server/httpServer/NettyHttpInitializer.java | package com.taobao.arthas.grpcweb.grpc.server.httpServer;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.stream.ChunkedWriteHandler;
public class NettyHttpInitializer extends ChannelInitializer<SocketChannel> {
private final String STATIC_LOCATION;
public NettyHttpInitializer(String staticLocation) {
this.STATIC_LOCATION = staticLocation;
}
@Override
public void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
//将请求和应答消息编码或解码为HTTP消息
pipeline.addLast(new HttpServerCodec());
//将HTTP消息的多个部分组合成一条完整的HTTP消息
pipeline.addLast(new HttpObjectAggregator(64 * 1024));
pipeline.addLast(new ChunkedWriteHandler());
pipeline.addLast(new NettyHttpStaticFileHandler(this.STATIC_LOCATION));
}
} | java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/server/httpServer/NettyHttpStaticFileHandler.java | labs/arthas-grpc-web-proxy/src/main/java/com/taobao/arthas/grpcweb/grpc/server/httpServer/NettyHttpStaticFileHandler.java | package com.taobao.arthas.grpcweb.grpc.server.httpServer;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import io.netty.channel.*;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.DefaultHttpResponse;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.FullHttpResponse;
import io.netty.handler.codec.http.HttpChunkedInput;
import io.netty.handler.codec.http.HttpHeaderNames;
import io.netty.handler.codec.http.HttpHeaderValues;
import io.netty.handler.codec.http.HttpResponse;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.handler.codec.http.HttpUtil;
import io.netty.handler.codec.http.HttpVersion;
import io.netty.handler.codec.http.LastHttpContent;
import io.netty.handler.ssl.SslHandler;
import io.netty.handler.stream.ChunkedFile;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
import java.lang.invoke.MethodHandles;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.file.Paths;
import javax.activation.MimetypesFileTypeMap;
public class NettyHttpStaticFileHandler extends SimpleChannelInboundHandler<FullHttpRequest> {
private static final Logger logger = LoggerFactory.getLogger(MethodHandles.lookup().lookupClass().getName());
// 资源所在路径
private final String STATIC_LOCATION;
public NettyHttpStaticFileHandler(String staticLocation){
this.STATIC_LOCATION = staticLocation;
}
@Override
protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) throws URISyntaxException, IOException {
// 获取URI
String uri = new URI(request.uri()).getPath();
// 设置不支持favicon.ico文件
if ("/favicon.ico".equals(uri)) {
return;
}
if ("/".equals(uri)) {
uri = "/index.html";
}
// 根据路径地址构建文件
String path = Paths.get(this.STATIC_LOCATION, uri).toString();
File file = new File(path);
// 状态为1xx的话，继续请求
if (HttpUtil.is100ContinueExpected(request)) {
send100Continue(ctx);
}
// 当文件隐藏/不存在/是目录/非文件的时候，将资源指向NOT_FOUND
if (file.isHidden() || !file.exists() || file.isDirectory() || !file.isFile()) {
sendNotFound(ctx);
return;
}
final RandomAccessFile randomAccessFile;
try {
randomAccessFile = new RandomAccessFile(file, "r");
} catch (FileNotFoundException e) {
sendNotFound(ctx);
throw new RuntimeException(e);
}
HttpResponse response = new DefaultHttpResponse(request.protocolVersion(), HttpResponseStatus.OK);
// 设置文件格式内容
if (path.endsWith(".html")){
response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/html; charset=UTF-8");
}else if(path.endsWith(".js")){
response.headers().set(HttpHeaderNames.CONTENT_TYPE, "application/x-javascript");
}else if(path.endsWith(".css")){
response.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/css; charset=UTF-8");
}else{
MimetypesFileTypeMap mimetypesFileTypeMap = new MimetypesFileTypeMap();
response.headers().set(HttpHeaderNames.CONTENT_TYPE, mimetypesFileTypeMap.getContentType(path));
}
boolean keepAlive = HttpUtil.isKeepAlive(request);
if (keepAlive) {
response.headers().set(HttpHeaderNames.CONTENT_LENGTH, randomAccessFile.length());
response.headers().set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE);
}
ctx.write(response);
ChannelFuture sendFileFuture;
ChannelFuture lastContentFuture;
if (ctx.pipeline().get(SslHandler.class) == null) {
sendFileFuture =
ctx.write(new DefaultFileRegion(randomAccessFile.getChannel(), 0, randomAccessFile.length()), ctx.newProgressivePromise());
// Write the end marker.
lastContentFuture = ctx.writeAndFlush(LastHttpContent.EMPTY_LAST_CONTENT);
} else {
sendFileFuture =
ctx.writeAndFlush(new HttpChunkedInput(new ChunkedFile(randomAccessFile, 0, randomAccessFile.length(), 10 * 1024 * 1024)),
ctx.newProgressivePromise());
// HttpChunkedInput will write the end marker (LastHttpContent) for us.
lastContentFuture = sendFileFuture;
}
sendFileFuture.addListener(new ChannelProgressiveFutureListener() {
@Override
public void operationProgressed(ChannelProgressiveFuture future, long progress, long total) {
if (total < 0) { // total unknown
logger.info(future.channel() + " Transfer progress: " + progress);
} else {
logger.info(future.channel() + " Transfer progress: " + progress + " / " + total);
}
}
@Override
public void operationComplete(ChannelProgressiveFuture future) {
logger.info(future.channel() + " Transfer complete.");
}
});
// Decide whether to close the connection or not.
if (!HttpUtil.isKeepAlive(request)) {
// Close the connection when the whole content is written out.
lastContentFuture.addListener(ChannelFutureListener.CLOSE);
}
}
private static void send100Continue(ChannelHandlerContext ctx) {
FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.CONTINUE);
ctx.writeAndFlush(response);
}
private static void sendNotFound(ChannelHandlerContext ctx){
FullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.NOT_FOUND);
response.headers().set(HttpHeaderNames.CONTENT_LENGTH, 0);
ctx.writeAndFlush(response);
}
} | java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent-management-web/src/main/java/com/alibaba/arthas/nat/agent/management/web/discovery/NativeAgentProxyDiscovery.java | labs/cluster-management/native-agent-management-web/src/main/java/com/alibaba/arthas/nat/agent/management/web/discovery/NativeAgentProxyDiscovery.java | package com.alibaba.arthas.nat.agent.management.web.discovery;
import java.util.List;
/**
* @description: NativeAgentProyDiscovery
* @author：flzjkl
* @date: 2024-09-19 7:22
*/
public interface NativeAgentProxyDiscovery {
/**
* list native agent proxy address
* @param address register address
* @return native agent proxy address
*/
List<String> listNativeAgentProxy(String address);
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent-management-web/src/main/java/com/alibaba/arthas/nat/agent/management/web/discovery/impl/ZookeeperNativeAgentProxyDiscovery.java | labs/cluster-management/native-agent-management-web/src/main/java/com/alibaba/arthas/nat/agent/management/web/discovery/impl/ZookeeperNativeAgentProxyDiscovery.java | package com.alibaba.arthas.nat.agent.management.web.discovery.impl;
import com.alibaba.arthas.nat.agent.common.constants.NativeAgentConstants;
import com.alibaba.arthas.nat.agent.management.web.discovery.NativeAgentProxyDiscovery;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import java.util.List;
import java.util.concurrent.CountDownLatch;
/**
* @description: ZookeeperNativeAgentProxyDiscovery implements NativeAgentProxyDiscovery
* @author：flzjkl
* @date: 2024-07-24 20:33
*/
public class ZookeeperNativeAgentProxyDiscovery implements NativeAgentProxyDiscovery {
private static final int SESSION_TIMEOUT = 20000;
private static final CountDownLatch connectedSemaphore = new CountDownLatch(1);
@Override
public List<String> listNativeAgentProxy(String address) {
if (address == null || "".equals(address)) {
return null;
}
// Wait for connection to be established
try {
ZooKeeper zooKeeper = new ZooKeeper(address, SESSION_TIMEOUT, event -> {
if (event.getState() == Watcher.Event.KeeperState.SyncConnected) {
connectedSemaphore.countDown();
}
});
connectedSemaphore.await();
// Gets a list of all children of the parent node
List<String> children = zooKeeper.getChildren(NativeAgentConstants.NATIVE_AGENT_PROXY_KEY, false);
if (children == null || children.size() == 0) {
return children;
}
zooKeeper.close();
return children;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent-management-web/src/main/java/com/alibaba/arthas/nat/agent/management/web/discovery/impl/EtcdNativeAgentProxyDiscovery.java | labs/cluster-management/native-agent-management-web/src/main/java/com/alibaba/arthas/nat/agent/management/web/discovery/impl/EtcdNativeAgentProxyDiscovery.java | package com.alibaba.arthas.nat.agent.management.web.discovery.impl;
import com.alibaba.arthas.nat.agent.common.constants.NativeAgentConstants;
import com.alibaba.arthas.nat.agent.management.web.discovery.NativeAgentProxyDiscovery;
import io.etcd.jetcd.ByteSequence;
import io.etcd.jetcd.Client;
import io.etcd.jetcd.KV;
import io.etcd.jetcd.KeyValue;
import io.etcd.jetcd.kv.GetResponse;
import io.etcd.jetcd.options.GetOption;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
/**
* @description: EtcdNativeAgentDiscovery implements NativeAgentDiscovery
* @author：flzjkl
* @date: 2024-09-15 9:19
*/
public class EtcdNativeAgentProxyDiscovery implements NativeAgentProxyDiscovery {
private static final Logger logger = LoggerFactory.getLogger(EtcdNativeAgentProxyDiscovery.class);
@Override
public List<String> listNativeAgentProxy(String address) {
// Create kv client
Client client = null;
KV kvClient = null;
List<String> res = null;
try {
client = Client.builder().endpoints("http://" + address).build();
kvClient = client.getKVClient();
// Get value by prefix /native-agent-client
GetResponse getResponse = null;
try {
ByteSequence prefix = ByteSequence.from(NativeAgentConstants.NATIVE_AGENT_PROXY_KEY, StandardCharsets.UTF_8);
GetOption option = GetOption.newBuilder().isPrefix(Boolean.TRUE).build();
getResponse = kvClient.get(prefix, option).get();
} catch (Exception e) {
logger.error("get value failed with prefix" + NativeAgentConstants.NATIVE_AGENT_PROXY_KEY);
throw new RuntimeException(e);
}
// Build Map
List<KeyValue> kvs = getResponse.getKvs();
if (kvs == null || kvs.size() == 0) {
return null;
}
res = new ArrayList<>(kvs.size());
for (KeyValue kv : kvs) {
String value = kv.getValue().toString(StandardCharsets.UTF_8);
res.add(value);
}
} finally {
if (kvClient != null) {
kvClient.close();
}
if (client != null) {
client.close();
}
}
return res;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent-management-web/src/main/java/com/alibaba/arthas/nat/agent/management/web/server/NativeAgentManagementWebBootstrap.java | labs/cluster-management/native-agent-management-web/src/main/java/com/alibaba/arthas/nat/agent/management/web/server/NativeAgentManagementWebBootstrap.java | package com.alibaba.arthas.nat.agent.management.web.server;
import com.alibaba.arthas.nat.agent.common.constants.NativeAgentConstants;
import com.alibaba.arthas.nat.agent.common.utils.WelcomeUtil;
import com.alibaba.arthas.nat.agent.management.web.server.http.HttpRequestHandler;
import com.taobao.middleware.cli.CLI;
import com.taobao.middleware.cli.CommandLine;
import com.taobao.middleware.cli.annotations.*;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Arrays;
/**
* @description: native agent server
* @author：flzjkl
* @date: 2024-07-20 9:23
*/
@Name("arthas-native-agent-management-web")
@Summary("Bootstrap Arthas Native Management Web")
@Description("EXAMPLES:\n" + " java -jar native-agent-management-web.jar --registration-type etcd --registration-address 161.169.97.114:2379\n"
+ "java -jar native-agent-management-web.jar --port 3939 --registration-type etcd --registration-address 161.169.97.114:2379\n"
+ "https://arthas.aliyun.com/doc\n")
public class NativeAgentManagementWebBootstrap {
private static final Logger logger = LoggerFactory.getLogger(NativeAgentManagementWebBootstrap.class);
private static final int DEFAULT_NATIVE_AGENT_MANAGEMENT_WEB_PORT = 3939;
private Integer port;
public static String registrationType;
public static String registrationAddress;
@Option(longName = "port")
@Description("native agent management port, default 3939")
public void setPort(Integer port) {
this.port = port;
}
@Option(longName = "registration-type", required = true)
@Description("registration type")
public void setRegistrationType(String registrationType) {
this.registrationType = registrationType;
}
@Option(longName = "registration-address", required = true)
@Description("registration address")
public void setRegistrationAddress(String registrationAddress) {
this.registrationAddress = registrationAddress;
}
public static void main(String[] args) {
// Print welcome message
WelcomeUtil.printManagementWebWelcomeMsg();
// Startup parameter analysis
logger.info("read input config...");
NativeAgentManagementWebBootstrap nativeAgentManagementWebBootstrap = new NativeAgentManagementWebBootstrap();
CLI cli = CLIConfigurator.define(NativeAgentManagementWebBootstrap.class);
CommandLine commandLine = cli.parse(Arrays.asList(args));
try {
CLIConfigurator.inject(commandLine, nativeAgentManagementWebBootstrap);
} catch (Throwable e) {
e.printStackTrace();
System.exit(1);
}
logger.info("read input success!");
// Start the http server
logger.info("start the http server... httPort:{}", nativeAgentManagementWebBootstrap.getPortOrDefault());
NioEventLoopGroup bossGroup = new NioEventLoopGroup();
NioEventLoopGroup workGroup = new NioEventLoopGroup();
try {
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workGroup)
.channel(NioServerSocketChannel.class)
.handler(new LoggingHandler(LogLevel.INFO))
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) {
ch.pipeline().addLast(new HttpServerCodec());
ch.pipeline().addLast(new HttpObjectAggregator(NativeAgentConstants.MAX_HTTP_CONTENT_LENGTH));
ch.pipeline().addLast(new HttpRequestHandler());
}
});
ChannelFuture f = b.bind(nativeAgentManagementWebBootstrap.getPortOrDefault()).sync();
logger.info("start the http server success! htt port:{}", nativeAgentManagementWebBootstrap.getPortOrDefault());
f.channel().closeFuture().sync();
} catch (Exception e) {
e.printStackTrace();
logger.error("The native agent server fails to start, http port{}", nativeAgentManagementWebBootstrap.getPortOrDefault());
throw new RuntimeException(e);
} finally {
bossGroup.shutdownGracefully();
workGroup.shutdownGracefully();
logger.info("shutdown native agent server");
}
}
public int getPortOrDefault() {
if (this.port == null) {
return DEFAULT_NATIVE_AGENT_MANAGEMENT_WEB_PORT;
} else {
return this.port;
}
}
public String getRegistrationType() {
return registrationType;
}
public String getRegistrationAddress() {
return registrationAddress;
}
public Integer getPort() {
return port;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent-management-web/src/main/java/com/alibaba/arthas/nat/agent/management/web/server/http/HttpNativeAgentProxyHandler.java | labs/cluster-management/native-agent-management-web/src/main/java/com/alibaba/arthas/nat/agent/management/web/server/http/HttpNativeAgentProxyHandler.java | package com.alibaba.arthas.nat.agent.management.web.server.http;
import com.alibaba.arthas.nat.agent.management.web.discovery.NativeAgentProxyDiscovery;
import com.alibaba.arthas.nat.agent.management.web.factory.NativeAgentProxyDiscoveryFactory;
import com.alibaba.arthas.nat.agent.management.web.server.NativeAgentManagementWebBootstrap;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.TypeReference;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.FullHttpResponse;
import io.netty.handler.codec.http.HttpResponseStatus;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Map;
import java.util.Random;
/**
* @description: HttpNativeAgentProxyHandler
* @author：flzjkl
* @date: 2024-10-21 7:01
*/
public class HttpNativeAgentProxyHandler {
public FullHttpResponse handle(ChannelHandlerContext ctx, FullHttpRequest request) {
String content = request.content().toString(StandardCharsets.UTF_8);
Map<String, Object> bodyMap = JSON.parseObject(content, new TypeReference<Map<String, Object>>() {
});
String operation = (String) bodyMap.get("operation");
if ("findAvailableProxyAddress".equals(operation)) {
return responseFindAvailableProxyAddress(ctx, request);
}
return null;
}
public FullHttpResponse responseFindAvailableProxyAddress(ChannelHandlerContext ctx, FullHttpRequest request) {
String availableProxyAddress = findAvailableProxyAddress();
if (availableProxyAddress == null || "".equals(availableProxyAddress)) {
return null;
}
DefaultFullHttpResponse response = new DefaultFullHttpResponse(
request.getProtocolVersion(),
HttpResponseStatus.OK,
Unpooled.copiedBuffer(availableProxyAddress, StandardCharsets.UTF_8)
);
return response;
}
public String findAvailableProxyAddress() {
// Find in address register
NativeAgentProxyDiscoveryFactory proxyDiscoveryFactory = NativeAgentProxyDiscoveryFactory.getNativeAgentProxyDiscoveryFactory();
NativeAgentProxyDiscovery proxyDiscovery = proxyDiscoveryFactory.getNativeAgentProxyDiscovery(NativeAgentManagementWebBootstrap.registrationType);
List<String> proxyList = proxyDiscovery.listNativeAgentProxy(NativeAgentManagementWebBootstrap.registrationAddress);
if (proxyList == null || proxyList.size() == 0) {
return null;
}
// Return a random index of proxy address, like 127.0.0.1:2233
Random random = new Random();
int randomIndex = random.nextInt(proxyList.size());
return proxyList.get(randomIndex);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent-management-web/src/main/java/com/alibaba/arthas/nat/agent/management/web/server/http/HttpRequestHandler.java | labs/cluster-management/native-agent-management-web/src/main/java/com/alibaba/arthas/nat/agent/management/web/server/http/HttpRequestHandler.java | package com.alibaba.arthas.nat.agent.management.web.server.http;
import com.alibaba.arthas.nat.agent.common.handler.HttpOptionRequestHandler;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.net.URI;
/**
* @description: HttpRequestHandler
* @author：flzjkl
* @date: 2024-07-20 10:09
*/
public class HttpRequestHandler extends SimpleChannelInboundHandler<FullHttpRequest> {
private static final Logger logger = LoggerFactory.getLogger(HttpRequestHandler.class);
private HttpNativeAgentHandler httpNativeAgentHandler = new HttpNativeAgentHandler();
private HttpNativeAgentProxyHandler httpNativeAgentProxyHandler = new HttpNativeAgentProxyHandler();
private HttpOptionRequestHandler httpOptionRequestHandler = new HttpOptionRequestHandler();
private HttpResourcesHandler httpResourcesHandler = new HttpResourcesHandler();
@Override
protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception {
String path = new URI(request.uri()).getPath();
HttpMethod method = request.method();
FullHttpResponse resp = null;
if (HttpMethod.GET.equals(method)) {
if ("/".equals(path)) {
path = "/index.html";
}
resp = httpResourcesHandler.handlerResources(request, path);
}
if (HttpMethod.OPTIONS.equals(method)) {
resp = httpOptionRequestHandler.handleOptionsRequest(ctx, request);
}
if (HttpMethod.POST.equals(method)) {
if ("/api/native-agent".equals(path)) {
resp = httpNativeAgentHandler.handle(ctx, request);
}
if ("/api/native-agent-proxy".equals(path)) {
resp = httpNativeAgentProxyHandler.handle(ctx, request);
}
}
if (resp == null) {
resp = new DefaultFullHttpResponse(request.getProtocolVersion(), HttpResponseStatus.NOT_FOUND);
resp.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/html; charset=utf-8");
}
ctx.writeAndFlush(resp).addListener(ChannelFutureListener.CLOSE);
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
cause.printStackTrace();
if (ctx.channel().isActive()) {
ctx.writeAndFlush(new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.INTERNAL_SERVER_ERROR));
ctx.close();
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent-management-web/src/main/java/com/alibaba/arthas/nat/agent/management/web/server/http/HttpResourcesHandler.java | labs/cluster-management/native-agent-management-web/src/main/java/com/alibaba/arthas/nat/agent/management/web/server/http/HttpResourcesHandler.java | package com.alibaba.arthas.nat.agent.management.web.server.http;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.handler.codec.http.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.io.InputStream;
import java.net.URL;
import java.util.Collections;
import java.util.HashSet;
import java.util.Set;
/**
* @description: HttpResourcesHandler
* @author：flzjkl
* @date: 2024-09-23 7:44
*/
public class HttpResourcesHandler {
private static final Logger logger = LoggerFactory.getLogger(HttpResourcesHandler.class);
private static final String RESOURCES_BASE_PATH = "/native-agent";
private static final Set<String> ALLOWED_EXTENSIONS;
static {
Set<String> tempSet = new HashSet<>();
tempSet.add(".html");
tempSet.add(".css");
tempSet.add(".js");
tempSet.add(".ico");
tempSet.add(".png");
ALLOWED_EXTENSIONS = Collections.unmodifiableSet(tempSet);
}
public FullHttpResponse handlerResources(FullHttpRequest request, String path) {
try {
if (request == null || path == null) {
return null;
}
String normalizedPath = normalizePath(path);
if (normalizedPath == null) {
return null;
}
URL resourceUrl = getClass().getResource(RESOURCES_BASE_PATH + normalizedPath);
if (resourceUrl == null) {
return null;
}
try (InputStream is = resourceUrl.openStream()) {
if (is == null) {
return null;
}
ByteBuf content = readInputStream(is);
FullHttpResponse response = new DefaultFullHttpResponse(
request.protocolVersion(), HttpResponseStatus.OK, content);
HttpHeaders headers = response.headers();
headers.set(HttpHeaderNames.CONTENT_TYPE, getContentType(normalizedPath));
headers.setInt(HttpHeaderNames.CONTENT_LENGTH, content.readableBytes());
headers.set(HttpHeaderNames.CONNECTION, HttpHeaderValues.KEEP_ALIVE);
return response;
}
} catch (Exception e) {
logger.error("");
return null;
}
}
private String normalizePath(String path) {
if (path == null) {
return null;
}
path = path.replaceAll("\\.\\./", "").replaceAll("\\./", "");
path = path.startsWith("/") ? path : "/" + path;
path = path.endsWith("/") ? path.substring(0, path.length() - 1) : path;
String finalPath = path;
boolean hasAllowedExtension = ALLOWED_EXTENSIONS.stream()
.anyMatch(finalPath::endsWith);
if (!hasAllowedExtension) {
return null;
}
return path;
}
private String getContentType(String path) {
if (path.endsWith(".html")) return "text/html";
if (path.endsWith(".css")) return "text/css";
if (path.endsWith(".js")) return "application/javascript";
if (path.endsWith(".ico")) return "image/x-icon";
if (path.endsWith(".png")) return "image/png";
return "application/octet-stream";
}
private ByteBuf readInputStream(InputStream is) throws IOException {
ByteBuf buffer = Unpooled.buffer();
byte[] tmp = new byte[1024];
int length;
while ((length = is.read(tmp)) != -1) {
buffer.writeBytes(tmp, 0, length);
}
is.close();
return buffer;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent-management-web/src/main/java/com/alibaba/arthas/nat/agent/management/web/server/http/HttpNativeAgentHandler.java | labs/cluster-management/native-agent-management-web/src/main/java/com/alibaba/arthas/nat/agent/management/web/server/http/HttpNativeAgentHandler.java | package com.alibaba.arthas.nat.agent.management.web.server.http;
import com.alibaba.arthas.nat.agent.common.utils.OkHttpUtil;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.TypeReference;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.FullHttpResponse;
import io.netty.handler.codec.http.HttpResponseStatus;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
import java.util.Map;
/**
* @description: HttpNativeAgentHandler
* @author：flzjkl
* @date: 2024-08-01 7:32
*/
public class HttpNativeAgentHandler {
private static final Logger logger = LoggerFactory.getLogger(HttpNativeAgentHandler.class);
private static HttpNativeAgentProxyHandler httpNativeAgentProxyHandler = new HttpNativeAgentProxyHandler();
public FullHttpResponse handle(ChannelHandlerContext ctx, FullHttpRequest request) {
String content = request.content().toString(StandardCharsets.UTF_8);
Map<String, Object> bodyMap = JSON.parseObject(content, new TypeReference<Map<String, Object>>() {
});
String operation = (String) bodyMap.get("operation");
if ("listNativeAgent".equals(operation)) {
return doListNativeAgent(ctx, request);
}
return null;
}
private FullHttpResponse doListNativeAgent(ChannelHandlerContext ctx, FullHttpRequest request) {
// 1、Find native agent proxy address
String address = httpNativeAgentProxyHandler.findAvailableProxyAddress();
if (address == null || "".equals(address)) {
return null;
}
// 2、Send Http request to native agent proxy to get native agent list
String resStr = null;
try {
String url = "http://" + address + "/api/native-agent-proxy";
String jsonBody = "{\"operation\":\"listNativeAgent\"}";
resStr = OkHttpUtil.post(url, jsonBody);
} catch (IOException e) {
logger.error("Send http to native agent proxy failed");
throw new RuntimeException(e);
}
if (resStr == null) {
return null;
}
DefaultFullHttpResponse response = new DefaultFullHttpResponse(
request.getProtocolVersion(),
HttpResponseStatus.OK,
Unpooled.copiedBuffer(resStr, StandardCharsets.UTF_8)
);
return response;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent-management-web/src/main/java/com/alibaba/arthas/nat/agent/management/web/factory/NativeAgentProxyDiscoveryFactory.java | labs/cluster-management/native-agent-management-web/src/main/java/com/alibaba/arthas/nat/agent/management/web/factory/NativeAgentProxyDiscoveryFactory.java | package com.alibaba.arthas.nat.agent.management.web.factory;
import com.alibaba.arthas.nat.agent.management.web.discovery.NativeAgentProxyDiscovery;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.Constructor;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* @description: NativeAgentProxyDiscoveryFactory
* @author：flzjkl
* @date: 2024-10-20 20:37
*/
public class NativeAgentProxyDiscoveryFactory {
private static final String FILE_PATH = "META-INF/arthas/com.alibaba.arthas.native.agent.management.web.NativeAgentProxyDiscoveryFactory";
private static Map<String, NativeAgentProxyDiscovery> nativeAgentProxyDiscoveryMap = new ConcurrentHashMap<>();
private static volatile NativeAgentProxyDiscoveryFactory nativeAgentProxyDiscoveryFactory;
private NativeAgentProxyDiscoveryFactory() {
Map<String, String> registrationConfigMap = readConfigInfo(FILE_PATH);
loadNativeAgentDiscovery2Map(registrationConfigMap);
}
public static NativeAgentProxyDiscoveryFactory getNativeAgentProxyDiscoveryFactory() {
if (nativeAgentProxyDiscoveryFactory == null) {
synchronized (NativeAgentProxyDiscoveryFactory.class) {
if (nativeAgentProxyDiscoveryFactory == null) {
nativeAgentProxyDiscoveryFactory = new NativeAgentProxyDiscoveryFactory();
}
}
}
return nativeAgentProxyDiscoveryFactory;
}
private void loadNativeAgentDiscovery2Map(Map<String, String> registrationConfigMap) {
for (Map.Entry<String, String> entry : registrationConfigMap.entrySet()) {
String name = entry.getKey();
String classPath = entry.getValue();
try {
Class<?> clazz = Class.forName(classPath);
Constructor<?> constructor = clazz.getConstructor();
NativeAgentProxyDiscovery instance = (NativeAgentProxyDiscovery) constructor.newInstance();
nativeAgentProxyDiscoveryMap.put(name, instance);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
public Map<String, String> readConfigInfo (String filePath) {
Map<String, String> nativeAgentDiscoveryConfigMap = new ConcurrentHashMap<>();
ClassLoader classLoader = NativeAgentProxyDiscoveryFactory.class.getClassLoader();
try (InputStream inputStream = classLoader.getResourceAsStream(filePath);
BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream))) {
if (inputStream == null) {
throw new IllegalArgumentException("File not found: " + filePath);
}
String line;
while ((line = reader.readLine()) != null) {
if (!line.trim().isEmpty() && line.contains("=")) {
String[] parts = line.split("=", 2);
if (parts.length == 2) {
nativeAgentDiscoveryConfigMap.put(parts[0].trim(), parts[1].trim());
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
return nativeAgentDiscoveryConfigMap;
}
public NativeAgentProxyDiscovery getNativeAgentProxyDiscovery(String name) {
return nativeAgentProxyDiscoveryMap.get(name);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent-common/src/main/java/com/alibaba/arthas/nat/agent/common/dto/NativeAgentInfoDTO.java | labs/cluster-management/native-agent-common/src/main/java/com/alibaba/arthas/nat/agent/common/dto/NativeAgentInfoDTO.java | package com.alibaba.arthas.nat.agent.common.dto;
/**
* @description: NativeAgentInfoDTO
* @author：flzjkl
* @date: 2024-09-05 8:04
*/
public class NativeAgentInfoDTO {
private String ip;
private Integer httpPort;
private Integer wsPort;
public NativeAgentInfoDTO() {
}
public NativeAgentInfoDTO(String ip, Integer httpPort, Integer wsPort) {
this.ip = ip;
this.httpPort = httpPort;
this.wsPort = wsPort;
}
public String getIp() {
return ip;
}
public void setIp(String ip) {
this.ip = ip;
}
public Integer getHttpPort() {
return httpPort;
}
public void setHttpPort(Integer httpPort) {
this.httpPort = httpPort;
}
public Integer getWsPort() {
return wsPort;
}
public void setWsPort(Integer wsPort) {
this.wsPort = wsPort;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent-common/src/main/java/com/alibaba/arthas/nat/agent/common/utils/WelcomeUtil.java | labs/cluster-management/native-agent-common/src/main/java/com/alibaba/arthas/nat/agent/common/utils/WelcomeUtil.java | package com.alibaba.arthas.nat.agent.common.utils;
/**
* @description: WelcomeUtil
* @author：flzjkl
* @date: 2024-09-22 18:26
*/
public class WelcomeUtil {
public static void printNativeAgentWelcomeMsg() {
String welcomeMsg = " _ _ _ \n" +
" _ __ __ _ | |_ (_) __ __ ___ __ _ __ _ ___ _ __ | |_ \n" +
" | '_ \\ / _` | | __| | | \\ \\ / / / _ \\ / _` | / _` | / _ \\ | '_ \\ | __|\n" +
" | | | | | (_| | | |_ | | \\ V / | __/ | (_| | | (_| | | __/ | | | | | |_ \n" +
" |_| |_| \\__,_| \\__| |_| \\_/ \\___| \\__,_| \\__, | \\___| |_| |_| \\__|\n" +
" |___/ ";
System.out.println(welcomeMsg);
System.out.println("=======================================================================================================================");
}
public static void printManagementWebWelcomeMsg() {
String welcomeMsg = " _ _ _ _ _ \n" +
" _ __ __ _ | |_ (_) __ __ ___ __ _ __ _ ___ _ __ | |_ _ __ ___ __ _ _ __ __ _ __ _ ___ _ __ ___ ___ _ __ | |_ __ __ ___ | |__ \n" +
" | '_ \\ / _` | | __| | | \\ \\ / / / _ \\ / _` | / _` | / _ \\ | '_ \\ | __| | '_ ` _ \\ / _` | | '_ \\ / _` | / _` | / _ \\ | '_ ` _ \\ / _ \\ | '_ \\ | __| \\ \\ /\\ / / / _ \\ | '_ \\ \n" +
" | | | | | (_| | | |_ | | \\ V / | __/ | (_| | | (_| | | __/ | | | | | |_ | | | | | | | (_| | | | | | | (_| | | (_| | | __/ | | | | | | | __/ | | | | | |_ \\ V V / | __/ | |_) |\n" +
" |_| |_| \\__,_| \\__| |_| \\_/ \\___| \\__,_| \\__, | \\___| |_| |_| \\__| |_| |_| |_| \\__,_| |_| |_| \\__,_| \\__, | \\___| |_| |_| |_| \\___| |_| |_| \\__| \\_/\\_/ \\___| |_.__/ \n" +
" |___/ |___/ ";
System.out.println(welcomeMsg);
System.out.println("=========================================================================================================================================================================================================================");
}
public static void printProxyWelcomeMsg() {
String welcomeMsg = " _ _ _ \n" +
" _ __ __ _ | |_ (_)__ __ ___ __ _ __ _ ___ _ __ | |_ _ __ _ __ ___ __ __ _ _ \n" +
"| '_ \\ / _` || __|| |\\ \\ / / / _ \\ / _` | / _` | / _ \\| '_ \\ | __| | '_ \\ | '__| / _ \\ \\ \\/ /| | | |\n" +
"| | | || (_| || |_ | | \\ V / | __/ | (_| || (_| || __/| | | || |_ | |_) || | | (_) | > < | |_| |\n" +
"|_| |_| \\__,_| \\__||_| \\_/ \\___| \\__,_| \\__, | \\___||_| |_| \\__| | .__/ |_| \\___/ /_/\\_\\ \\__, |\n" +
" |___/ |_| |___/ ";
System.out.println(welcomeMsg);
System.out.println("==========================================================================================================================");
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent-common/src/main/java/com/alibaba/arthas/nat/agent/common/utils/OkHttpUtil.java | labs/cluster-management/native-agent-common/src/main/java/com/alibaba/arthas/nat/agent/common/utils/OkHttpUtil.java | package com.alibaba.arthas.nat.agent.common.utils;
import okhttp3.*;
import java.io.IOException;
import java.util.concurrent.TimeUnit;
/**
* @description: OkHttpUtil
* @author：flzjkl
* @date: 2024-10-20 21:35
*/
public class OkHttpUtil {
private static final OkHttpClient client = new OkHttpClient.Builder()
.connectTimeout(10, TimeUnit.SECONDS)
.writeTimeout(10, TimeUnit.SECONDS)
.readTimeout(30, TimeUnit.SECONDS)
.build();
private static final MediaType JSON = MediaType.get("application/json; charset=utf-8");
public static String get(String url) throws IOException {
Request request = new Request.Builder()
.url(url)
.build();
try (Response response = client.newCall(request).execute()) {
return response.body().string();
}
}
public static String post(String url, String json) throws IOException {
RequestBody body = RequestBody.create(json, JSON);
Request request = new Request.Builder()
.url(url)
.post(body)
.header("Content-Type", "application/json")
.build();
try (Response response = client.newCall(request).execute()) {
return response.body().string();
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent-common/src/main/java/com/alibaba/arthas/nat/agent/common/handler/HttpOptionRequestHandler.java | labs/cluster-management/native-agent-common/src/main/java/com/alibaba/arthas/nat/agent/common/handler/HttpOptionRequestHandler.java | package com.alibaba.arthas.nat.agent.common.handler;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.*;
/**
* @description: HttpOptionRequestHandler
* @author：flzjkl
* @date: 2024-09-22 7:21
*/
public class HttpOptionRequestHandler {
public FullHttpResponse handleOptionsRequest(ChannelHandlerContext ctx, FullHttpRequest request) {
FullHttpResponse response = new DefaultFullHttpResponse(
request.getProtocolVersion(),
HttpResponseStatus.OK,
Unpooled.EMPTY_BUFFER);
// Set the CORS response header
String origin = request.headers().get(HttpHeaderNames.ORIGIN);
if (origin != null) {
response.headers().set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_ORIGIN, origin);
} else {
response.headers().set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_ORIGIN, "*");
}
response.headers().set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_METHODS, "GET, POST, PUT, DELETE, OPTIONS");
response.headers().set(HttpHeaderNames.ACCESS_CONTROL_MAX_AGE, 3600L);
response.headers().set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_HEADERS, "Content-Type, Authorization, X-Requested-With, Accept, Origin");
// If the request contains an Access-Control-Request-Method, a response is required
String accessControlRequestMethod = request.headers().get(HttpHeaderNames.ACCESS_CONTROL_REQUEST_METHOD);
if (accessControlRequestMethod != null) {
response.headers().set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_METHODS, accessControlRequestMethod);
}
// If the request contains Access-Control-Request-Headers, a response is required
String accessControlRequestHeaders = request.headers().get(HttpHeaderNames.ACCESS_CONTROL_REQUEST_HEADERS);
if (accessControlRequestHeaders != null) {
response.headers().set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_HEADERS, accessControlRequestHeaders);
}
return response;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent-common/src/main/java/com/alibaba/arthas/nat/agent/common/constants/NativeAgentConstants.java | labs/cluster-management/native-agent-common/src/main/java/com/alibaba/arthas/nat/agent/common/constants/NativeAgentConstants.java | package com.alibaba.arthas.nat.agent.common.constants;
/**
* @description: hello world
* @author：flzjkl
* @date: 2024-09-22 0:47
*/
public class NativeAgentConstants {
public static final int ARTHAS_SERVER_HTTP_PORT = 8563;
public static final int MAX_HTTP_CONTENT_LENGTH = 1024 * 1024 * 10;
public static final String NATIVE_AGENT_KEY = "/native-agent";
public static final String NATIVE_AGENT_PROXY_KEY = "/native-agent-proxy";
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/core/JvmAttachmentHandler.java | labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/core/JvmAttachmentHandler.java | package com.alibaba.arthas.nat.agent.core;
import com.alibaba.arthas.nat.agent.common.constants.NativeAgentConstants;
import com.sun.tools.attach.AttachNotSupportedException;
import com.sun.tools.attach.VirtualMachine;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
import static com.alibaba.arthas.nat.agent.core.ArthasHomeHandler.ARTHAS_HOME_DIR;
/**
* @description: attach jvm via java agent
* @author：flzjkl
* @date: 2024-07-01 11:37
*/
public class JvmAttachmentHandler {
private static final Logger logger = LoggerFactory.getLogger(JvmAttachmentHandler.class);
private static final String ARTHAS_AGENT_JAR = "arthas-agent.jar";
public static String attachJvmByPid (Integer pid) throws Exception {
VirtualMachine vm = null;
try {
vm = VirtualMachine.attach(pid + "");
} catch (AttachNotSupportedException e) {
logger.error("attach pid failed");
throw new RuntimeException("attach pid: " + pid +" failed " + e.getMessage());
}
if (ARTHAS_HOME_DIR == null) {
ArthasHomeHandler.findArthasHome();
}
if (ARTHAS_HOME_DIR == null) {
throw new RuntimeException("arthas home was not found");
}
String agentPath = ARTHAS_HOME_DIR + File.separator + ARTHAS_AGENT_JAR;
try {
String args = ";httpPort=" + NativeAgentConstants.ARTHAS_SERVER_HTTP_PORT
+ ";javaPid=" + pid + ";ip=localhost";
vm.loadAgent(agentPath, args);
logger.info("attach pid " + pid + " success, http server port is: " + NativeAgentConstants.ARTHAS_SERVER_HTTP_PORT);
} catch (Exception e) {
logger.error("attach pid " + pid + " success, http server port is: " + NativeAgentConstants.ARTHAS_SERVER_HTTP_PORT);
throw new Exception("load agent failed, pid: " + pid + " " + e.getMessage());
} finally {
vm.detach();
}
return String.valueOf(NativeAgentConstants.ARTHAS_SERVER_HTTP_PORT);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/core/ListJvmProcessHandler.java | labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/core/ListJvmProcessHandler.java | package com.alibaba.arthas.nat.agent.core;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
import java.lang.reflect.Method;
import java.net.URL;
import java.net.URLClassLoader;
import java.util.Map;
import static com.alibaba.arthas.nat.agent.core.ArthasHomeHandler.ARTHAS_HOME_DIR;
/**
* @description: list java process via invoke com.taobao.arthas.boot.ProcessUtils#listProcessByJps
* @author：flzjkl
* @date: 2024-07-18 8:25
*/
public class ListJvmProcessHandler {
private static final Logger logger = LoggerFactory.getLogger(ListJvmProcessHandler.class);
private static final String PROCESS_UTILS_PATH = "com.taobao.arthas.boot.ProcessUtils";
private static final String LIST_PROCESS_BY_JPS_METHOD = "listProcessByJps";
public static Map<Long, String> listJvmProcessByInvoke() {
if (ARTHAS_HOME_DIR == null) {
ArthasHomeHandler.findArthasHome();
}
if (ARTHAS_HOME_DIR == null) {
return null;
}
String arthasBootPath = ARTHAS_HOME_DIR + File.separator + "arthas-boot.jar";
Method method = null;
Object instance = null;
Map<Long, String> result = null;
try {
URLClassLoader classLoader = new URLClassLoader(new URL[]{new File(arthasBootPath).toURI().toURL()});
Class<?> clazz = classLoader.loadClass(PROCESS_UTILS_PATH);
method = clazz.getDeclaredMethod(LIST_PROCESS_BY_JPS_METHOD, boolean.class);
method.setAccessible(true);
instance = clazz.getDeclaredConstructor().newInstance();
result = (Map<Long, String>) method.invoke(instance, false);
} catch (Exception e) {
logger.error("invoke list java process failed:" + e.getMessage());
throw new RuntimeException(e);
}
return result;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/core/ArthasHomeHandler.java | labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/core/ArthasHomeHandler.java | package com.alibaba.arthas.nat.agent.core;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.io.File;
import java.net.URISyntaxException;
import java.net.URL;
/**
* @description: find arthas home
* @author：flzjkl
* @date: 2024-07-27 9:12
*/
public class ArthasHomeHandler {
private static final Logger logger = LoggerFactory.getLogger(ArthasHomeHandler.class);
public static File ARTHAS_HOME_DIR;
public static void findArthasHome() {
// find arthas home
File arthasHomeDir = null;
try {
if (arthasHomeDir == null) {
// try to find from ~/.arthas/lib
File arthasDir = new File(System.getProperty("user.home"), ".arthas" + File.separator + "lib"
+ File.separator + "arthas");
verifyArthasHome(arthasDir.getAbsolutePath());
arthasHomeDir = arthasDir;
}
} catch (Exception e) {
// ignore
}
// Try set the directory where arthas-boot.jar is located to arhtas home
try {
if (arthasHomeDir == null) {
URL jarUrl = ArthasHomeHandler.class.getProtectionDomain().getCodeSource().getLocation();
if (jarUrl != null) {
File arthasDir = new File(jarUrl.toURI());
// If the path is a JAR file, use it directly
String jarDir = arthasDir.getParent();
verifyArthasHome(jarDir);
if (arthasDir != null) {
arthasHomeDir = new File(jarDir);
}
}
}
} catch (URISyntaxException e) {
throw new RuntimeException(e);
}
if (arthasHomeDir == null) {
logger.error("Please ensure that arthas-native agent-client is in the same directory as arthas-core.jar, arthas-agent.jar, and arthas-spy.jar");
throw new RuntimeException("arthas home not found");
}
ARTHAS_HOME_DIR = arthasHomeDir;
}
private static void verifyArthasHome(String arthasHome) {
File home = new File(arthasHome);
if (home.isDirectory()) {
String[] fileList = {"arthas-core.jar", "arthas-agent.jar", "arthas-spy.jar"};
for (String fileName : fileList) {
if (!new File(home, fileName).exists()) {
logger.error("Please ensure that arthas-native agent-client is in the same directory as arthas-core.jar, arthas-agent.jar, and arthas-spy.jar");
throw new IllegalArgumentException(
fileName + " do not exist, arthas home: " + home.getAbsolutePath());
}
}
return;
}
throw new IllegalArgumentException("illegal arthas home: " + home.getAbsolutePath());
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/core/MonitorTargetPidHandler.java | labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/core/MonitorTargetPidHandler.java | package com.alibaba.arthas.nat.agent.core;
import com.alibaba.arthas.nat.agent.common.constants.NativeAgentConstants;
import com.taobao.arthas.common.SocketUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @description: monitor target pid
* @author：flzjkl
* @date: 2024-09-22 7:12
*/
public class MonitorTargetPidHandler {
private static final Logger logger = LoggerFactory.getLogger(MonitorTargetPidHandler.class);
public static boolean monitorTargetPid (Integer pid) {
long tcpListenProcess = SocketUtils.findTcpListenProcess(NativeAgentConstants.ARTHAS_SERVER_HTTP_PORT);
if (tcpListenProcess == -1) {
try {
JvmAttachmentHandler.attachJvmByPid(pid);
return true;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
if (tcpListenProcess == pid) {
return true;
}
if (tcpListenProcess != pid) {
String errorMsg = "Target port: " + NativeAgentConstants.ARTHAS_SERVER_HTTP_PORT
+ " has been occupied by pid: " + tcpListenProcess;
logger.error(errorMsg);
return false;
}
return false;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/server/NativeAgentBootstrap.java | labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/server/NativeAgentBootstrap.java | package com.alibaba.arthas.nat.agent.server;
import com.alibaba.arthas.nat.agent.factory.NativeAgentRegistryFactory;
import com.alibaba.arthas.nat.agent.registry.NativeAgentRegistry;
import com.alibaba.arthas.nat.agent.core.ArthasHomeHandler;
import com.alibaba.arthas.nat.agent.server.forward.ForwardClientSocketClientHandler;
import com.alibaba.arthas.nat.agent.server.http.HttpRequestHandler;
import com.alibaba.arthas.nat.agent.common.utils.WelcomeUtil;
import com.taobao.arthas.common.UsageRender;
import com.taobao.middleware.cli.CLI;
import com.taobao.middleware.cli.CommandLine;
import com.taobao.middleware.cli.UsageMessageFormatter;
import com.taobao.middleware.cli.annotations.*;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpRequestDecoder;
import io.netty.handler.codec.http.HttpResponseEncoder;
import io.netty.handler.codec.http.HttpServerCodec;
import io.netty.handler.codec.http.websocketx.WebSocketServerProtocolHandler;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.Arrays;
import static com.taobao.arthas.common.ArthasConstants.MAX_HTTP_CONTENT_LENGTH;
/**
* @description: hello world
* @author：flzjkl
* @date: 2024-07-20 9:23
*/
@Name("arthas-native-agent")
@Summary("Bootstrap Arthas Native Agent")
@Description("EXAMPLES:\n" + "java -jar native-agent.jar --ip 116.196.97.114 --http-port 2671 --ws-port 2672 --registration-type etcd --registration-address 126.166.97.114:2379\n"
+ " https://arthas.aliyun.com/doc\n")
public class NativeAgentBootstrap {
private static final Logger logger = LoggerFactory.getLogger(NativeAgentBootstrap.class);
private static final int DEFAULT_HTTP_PORT = 2671;
private static final int DEFAULT_WS_PORT = 2672;
public String ip;
public Integer httpPort;
public Integer wsPort;
public String registrationType;
public String registrationAddress;
@Option(longName = "ip", required = true)
@Description("native agent ip")
public void setIp(String ip) {
this.ip = ip;
}
@Option(longName = "http-port")
@Description("native agent http port, default 2671")
public void setHttpPort(Integer httpPort) {
this.httpPort = httpPort;
}
@Option(longName = "ws-port")
@Description("native agent ws port, default 2672")
public void wsPort(Integer wsPort) {
this.wsPort = wsPort;
}
@Option(longName = "registration-type", required = true)
@Description("registration type")
public void setRegistrationType(String registrationType) {
this.registrationType = registrationType;
}
@Option(longName = "registration-address", required = true)
@Description("registration address")
public void setRegistrationAddress(String registrationAddress) {
this.registrationAddress = registrationAddress;
}
public static void main(String[] args) {
// Print welcome info
WelcomeUtil.printNativeAgentWelcomeMsg();
// Check And Find arthas path
logger.info("check arthas file path...");
ArthasHomeHandler.findArthasHome();
logger.info("check arthas file path success");
// Read bootstrap config
logger.info("read input config...");
NativeAgentBootstrap nativeAgentBootstrap = new NativeAgentBootstrap();
CLI cli = CLIConfigurator.define(NativeAgentBootstrap.class);
CommandLine commandLine = cli.parse(Arrays.asList(args));
try {
CLIConfigurator.inject(commandLine, nativeAgentBootstrap);
} catch (Throwable e) {
logger.error("Missing startup parameter");
e.printStackTrace();
System.out.println(usage(cli));
System.exit(1);
}
logger.info("read input config success");
// Register native agent
try {
logger.info("register native agent ...");
NativeAgentRegistryFactory nativeAgentRegistryFactory = NativeAgentRegistryFactory.getNativeAgentClientRegisterFactory();
NativeAgentRegistry nativeAgentRegistry = nativeAgentRegistryFactory.getServiceRegistration(nativeAgentBootstrap.getRegistrationType());
nativeAgentRegistry.registerNativeAgent(nativeAgentBootstrap.getRegistrationAddress()
, nativeAgentBootstrap.getIp()
, nativeAgentBootstrap.getHttpPortOrDefault() + ":" + nativeAgentBootstrap.getWsPortOrDefault());
logger.info("register native agent success!");
} catch (Exception e) {
logger.error("register native agent failed!");
e.printStackTrace();
System.exit(1);
}
// Start the websocket server
int wsPortOrDefault = nativeAgentBootstrap.getWsPortOrDefault();
Thread wsServerThread = new Thread(() -> {
logger.info("start the websocket server... ws port:" + wsPortOrDefault);
try {
EventLoopGroup bossGroup = new NioEventLoopGroup();
EventLoopGroup workerGroup = new NioEventLoopGroup();
try {
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workerGroup)
.channel(NioServerSocketChannel.class)
.handler(new LoggingHandler(LogLevel.INFO))
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) {
ChannelPipeline p = ch.pipeline();
p.addLast(new HttpRequestDecoder());
p.addLast(new HttpObjectAggregator(MAX_HTTP_CONTENT_LENGTH));
p.addLast(new HttpResponseEncoder());
p.addLast(new WebSocketServerProtocolHandler("/ws"));
p.addLast(new ForwardClientSocketClientHandler());
}
});
ChannelFuture f = b.bind("0.0.0.0", wsPortOrDefault).sync();
logger.info("start the websocket server success! ws port:" + wsPortOrDefault);
f.channel().closeFuture().sync();
} finally {
logger.info("shutdown websocket server, ws port:{}", wsPortOrDefault);
bossGroup.shutdownGracefully();
workerGroup.shutdownGracefully();
}
} catch (InterruptedException e) {
logger.error("failed to start websocket server, ws port: {}", wsPortOrDefault);
Thread.currentThread().interrupt();
e.printStackTrace();
}
});
wsServerThread.setName("native-agent-ws-server");
wsServerThread.start();
// Start the Http server
int httpPortOrDefault = nativeAgentBootstrap.getHttpPortOrDefault();
logger.info("start the http server... http port:" + httpPortOrDefault);
NioEventLoopGroup bossGroup = new NioEventLoopGroup();
NioEventLoopGroup workGroup = new NioEventLoopGroup();
try {
ServerBootstrap b = new ServerBootstrap();
b.group(bossGroup, workGroup)
.channel(NioServerSocketChannel.class)
.handler(new LoggingHandler(LogLevel.INFO))
.childHandler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) {
ch.pipeline().addLast(new HttpServerCodec());
ch.pipeline().addLast(new HttpObjectAggregator(MAX_HTTP_CONTENT_LENGTH));
ch.pipeline().addLast(new HttpRequestHandler());
}
});
ChannelFuture f = b.bind("0.0.0.0", httpPortOrDefault).sync();
logger.info("start the http server success, http port:" + httpPortOrDefault);
f.channel().closeFuture().sync();
} catch (Exception e) {
logger.error("failed to start http server, http port:" + httpPortOrDefault);
e.printStackTrace();
} finally {
bossGroup.shutdownGracefully();
workGroup.shutdownGracefully();
logger.info("shutdown http server");
}
}
private static String usage(CLI cli) {
StringBuilder usageStringBuilder = new StringBuilder();
UsageMessageFormatter usageMessageFormatter = new UsageMessageFormatter();
usageMessageFormatter.setOptionComparator(null);
cli.usage(usageStringBuilder, usageMessageFormatter);
return UsageRender.render(usageStringBuilder.toString());
}
public int getHttpPortOrDefault() {
if (this.httpPort == null) {
return DEFAULT_HTTP_PORT;
} else {
return this.httpPort;
}
}
public int getWsPortOrDefault() {
if (this.wsPort == null) {
return DEFAULT_WS_PORT;
} else {
return this.httpPort;
}
}
public String getIp() {
return ip;
}
public Integer getHttpPort() {
return httpPort;
}
public Integer getWsPort() {
return wsPort;
}
public String getRegistrationAddress() {
return registrationAddress;
}
public String getRegistrationType() {
return registrationType;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/server/dto/JavaProcessInfoDTO.java | labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/server/dto/JavaProcessInfoDTO.java | package com.alibaba.arthas.nat.agent.server.dto;
/**
* @description: Java Process DTO
* @author：flzjkl
* @date: 2024-09-06 21:31
*/
public class JavaProcessInfoDTO {
private String processName;
private Integer pid;
public JavaProcessInfoDTO() {
}
public JavaProcessInfoDTO(String applicationName, Integer pid) {
this.processName = applicationName;
this.pid = pid;
}
public void setProcessName(String processName) {
this.processName = processName;
}
public void setPid(Integer pid) {
this.pid = pid;
}
public Integer getPid() {
return pid;
}
public String getProcessName() {
return processName;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/server/forward/RelayHandler.java | labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/server/forward/RelayHandler.java | package com.alibaba.arthas.nat.agent.server.forward;
import com.alibaba.arthas.tunnel.client.ChannelUtils;
import io.netty.buffer.Unpooled;
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import io.netty.util.ReferenceCountUtil;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @description: RelayHandler
* @author：flzjkl
* @date: 2024-08-25 22:12
*/
public final class RelayHandler extends ChannelInboundHandlerAdapter {
private final static Logger logger = LoggerFactory.getLogger(RelayHandler.class);
private final Channel relayChannel;
public RelayHandler(Channel relayChannel) {
this.relayChannel = relayChannel;
}
@Override
public void channelActive(ChannelHandlerContext ctx) {
ctx.writeAndFlush(Unpooled.EMPTY_BUFFER);
}
@Override
public void channelRead(ChannelHandlerContext ctx, Object msg) {
if (relayChannel.isActive()) {
relayChannel.writeAndFlush(msg);
} else {
ReferenceCountUtil.release(msg);
}
}
@Override
public void channelInactive(ChannelHandlerContext ctx) {
if (relayChannel.isActive()) {
ChannelUtils.closeOnFlush(relayChannel);
}
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
logger.error("RelayHandler error", cause);
try {
if (relayChannel.isActive()) {
relayChannel.close();
}
} finally {
ctx.close();
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/server/forward/LocalFrameHandler.java | labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/server/forward/LocalFrameHandler.java | package com.alibaba.arthas.nat.agent.server.forward;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelPromise;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.websocketx.WebSocketClientProtocolHandler.ClientHandshakeStateEvent;
import io.netty.handler.codec.http.websocketx.WebSocketFrame;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @description: LocalFrameHandler
* @author：flzjkl
* @date: 2024-08-25 22:12
*/
public class LocalFrameHandler extends SimpleChannelInboundHandler<WebSocketFrame> {
private final static Logger logger = LoggerFactory.getLogger(LocalFrameHandler.class);
private ChannelPromise handshakeFuture;
public LocalFrameHandler() {
}
public ChannelPromise handshakeFuture() {
return handshakeFuture;
}
@Override
public void handlerAdded(ChannelHandlerContext ctx) {
handshakeFuture = ctx.newPromise();
}
@Override
public void userEventTriggered(ChannelHandlerContext ctx, Object evt) throws Exception {
super.userEventTriggered(ctx, evt);
if (evt instanceof ClientHandshakeStateEvent) {
if (evt.equals(ClientHandshakeStateEvent.HANDSHAKE_COMPLETE)) {
handshakeFuture.setSuccess();
}
}
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
logger.error("LocalFrameHandler error", cause);
if (!handshakeFuture.isDone()) {
handshakeFuture.setFailure(cause);
}
ctx.close();
}
@Override
protected void channelRead0(ChannelHandlerContext ctx, WebSocketFrame msg) throws Exception {
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/server/forward/ForwardClientSocketClientHandler.java | labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/server/forward/ForwardClientSocketClientHandler.java | package com.alibaba.arthas.nat.agent.server.forward;
import com.alibaba.arthas.nat.agent.common.constants.NativeAgentConstants;
import com.taobao.arthas.common.ArthasConstants;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.http.HttpClientCodec;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.websocketx.*;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.util.concurrent.GenericFutureListener;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.net.URI;
import java.net.URISyntaxException;
/**
* @description: Forward the ws request to arthas server
* @author：flzjkl
* @date: 2024-09-07 8:34
*/
public class ForwardClientSocketClientHandler extends SimpleChannelInboundHandler<WebSocketFrame> {
private static final Logger logger = LoggerFactory.getLogger(ForwardClientSocketClientHandler.class);
private ChannelPromise handshakeFuture;
@Override
public void channelActive(ChannelHandlerContext ctx) {
}
@Override
public void channelInactive(ChannelHandlerContext ctx) {
logger.info("WebSocket Client disconnected!");
}
@Override
public void userEventTriggered(final ChannelHandlerContext ctx, Object evt) {
if (evt.equals(WebSocketServerProtocolHandler.ServerHandshakeStateEvent.HANDSHAKE_COMPLETE)) {
try {
connectLocalServer(ctx);
} catch (Throwable e) {
logger.error("ForwardClientSocketClientHandler connect local arthas server error", e);
}
} else {
ctx.fireUserEventTriggered(evt);
}
}
private void connectLocalServer(final ChannelHandlerContext ctx) throws InterruptedException, URISyntaxException {
NioEventLoopGroup group = new NioEventLoopGroup();
// Create the Bootstrap
Bootstrap bootstrap = new Bootstrap();
LocalFrameHandler localFrameHandler = new LocalFrameHandler();
bootstrap.group(group)
.channel(NioSocketChannel.class)
.handler(new ChannelInitializer<SocketChannel>() {
@Override
protected void initChannel(SocketChannel ch) throws Exception {
ChannelPipeline pipeline = ch.pipeline();
pipeline.addLast(new LoggingHandler(LogLevel.INFO));
pipeline.addLast(new HttpClientCodec());
pipeline.addLast(new HttpObjectAggregator(ArthasConstants.MAX_HTTP_CONTENT_LENGTH));
pipeline.addLast(new WebSocketClientProtocolHandler(
WebSocketClientHandshakerFactory.newHandshaker(
new URI("ws://127.0.0.1:" + NativeAgentConstants.ARTHAS_SERVER_HTTP_PORT + "/ws"),
WebSocketVersion.V13, null, false, null
)
));
pipeline.addLast(localFrameHandler);
}
});
// Connect to arthas server
Channel arthasChannel = bootstrap.connect("127.0.0.1", NativeAgentConstants.ARTHAS_SERVER_HTTP_PORT).sync().channel();
this.handshakeFuture = localFrameHandler.handshakeFuture();
handshakeFuture.addListener(new GenericFutureListener<ChannelFuture>() {
@Override
public void operationComplete(ChannelFuture future) throws Exception {
ChannelPipeline pipeline = future.channel().pipeline();
pipeline.remove(localFrameHandler);
pipeline.addLast(new RelayHandler(ctx.channel()));
}
});
handshakeFuture.sync();
ctx.pipeline().remove(ForwardClientSocketClientHandler.this);
ctx.pipeline().addLast(new RelayHandler(arthasChannel));
}
@Override
protected void channelRead0(ChannelHandlerContext ctx, WebSocketFrame msg) throws Exception {
handshakeFuture = null;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/server/http/HttpRequestHandler.java | labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/server/http/HttpRequestHandler.java | package com.alibaba.arthas.nat.agent.server.http;
import com.alibaba.arthas.nat.agent.common.handler.HttpOptionRequestHandler;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.*;
import java.net.URI;
/**
* @description: HttpRequestHandler
* @author：flzjkl
* @date: 2024-07-20 10:09
*/
public class HttpRequestHandler extends SimpleChannelInboundHandler<FullHttpRequest> {
private HttpNativeAgentHandler httpNativeAgentHandler = new HttpNativeAgentHandler();
private HttpOptionRequestHandler httpOptionRequestHandler = new HttpOptionRequestHandler();
@Override
protected void channelRead0(ChannelHandlerContext ctx, FullHttpRequest request) throws Exception {
String path = new URI(request.uri()).getPath();
HttpMethod method = request.method();
FullHttpResponse resp = null;
if (HttpMethod.OPTIONS.equals(method)) {
resp = httpOptionRequestHandler.handleOptionsRequest(ctx, request);
}
if (HttpMethod.POST.equals(method)) {
if ("/api/native-agent".equals(path)) {
resp = httpNativeAgentHandler.handle(ctx, request);
}
}
if (resp == null) {
resp = new DefaultFullHttpResponse(request.getProtocolVersion(), HttpResponseStatus.NOT_FOUND);
resp.headers().set(HttpHeaderNames.CONTENT_TYPE, "text/html; charset=utf-8");
}
ctx.writeAndFlush(resp).addListener(ChannelFutureListener.CLOSE);
}
@Override
public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
cause.printStackTrace();
if (ctx.channel().isActive()) {
ctx.writeAndFlush(new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.INTERNAL_SERVER_ERROR));
ctx.close();
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/server/http/HttpNativeAgentHandler.java | labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/server/http/HttpNativeAgentHandler.java | package com.alibaba.arthas.nat.agent.server.http;
import com.alibaba.arthas.nat.agent.core.JvmAttachmentHandler;
import com.alibaba.arthas.nat.agent.core.ListJvmProcessHandler;
import com.alibaba.arthas.nat.agent.core.MonitorTargetPidHandler;
import com.alibaba.arthas.nat.agent.server.dto.JavaProcessInfoDTO;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.TypeReference;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.*;
import io.netty.util.CharsetUtil;
import java.nio.charset.StandardCharsets;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
/**
* @description: hello world
* @author：flzjkl
* @date: 2024-08-01 7:32
*/
public class HttpNativeAgentHandler {
private static final String OPERATION_KEY = "operation";
private static final String PID_KEY = "pid";
private static final String LIST_PROCESS_OPERATION = "listProcess";
private static final String ATTACH_JVM_OPERATION = "attachJvm";
private static final String MONITOR_OPERATION = "monitor";
public FullHttpResponse handle(ChannelHandlerContext ctx, FullHttpRequest request) {
String content = request.content().toString(StandardCharsets.UTF_8);
FullHttpResponse resp = null;
Map<String, Object> bodyMap = JSON.parseObject(content, new TypeReference<Map<String, Object>>() {
});
String operation = (String) bodyMap.get(OPERATION_KEY);
Integer pid = (Integer) bodyMap.get(PID_KEY);
if (LIST_PROCESS_OPERATION.equals(operation)) {
resp = doListProcess(ctx, request);
}
if (ATTACH_JVM_OPERATION.equals(operation)) {
resp = doAttachJvm(ctx, request, pid);
}
if (MONITOR_OPERATION.equals(operation)) {
resp = doMonitor(ctx, request, pid);
}
return resp;
}
private FullHttpResponse doMonitor(ChannelHandlerContext ctx, FullHttpRequest request, Integer pid) {
boolean monitorSuccess = MonitorTargetPidHandler.monitorTargetPid(pid);
String attachSuccessPid = monitorSuccess ? pid + "" : -1 + "";
DefaultFullHttpResponse response = buildHttpCorsResponse(attachSuccessPid);
return response;
}
private FullHttpResponse doAttachJvm(ChannelHandlerContext ctx, FullHttpRequest request, Integer pid) {
String httpPort = "";
try {
httpPort = JvmAttachmentHandler.attachJvmByPid(pid);
} catch (Exception e) {
throw new RuntimeException(e);
}
String attachSuccessMsg = httpPort;
DefaultFullHttpResponse response = buildHttpCorsResponse(attachSuccessMsg);
return response;
}
private FullHttpResponse doListProcess(ChannelHandlerContext ctx, FullHttpRequest request) {
Map<Long, String> processMap = null;
try {
processMap = ListJvmProcessHandler.listJvmProcessByInvoke();
} catch (Exception e) {
throw new RuntimeException(e);
}
List<JavaProcessInfoDTO> javaProcessInfoList = new ArrayList<>();
if (processMap != null) {
processMap.forEach((pid, applicationName) -> {
if (!"".equals(applicationName.replace(pid + " ", ""))) {
javaProcessInfoList.add(new JavaProcessInfoDTO(applicationName.replace(pid + " ", ""), pid.intValue()));
}
});
}
String processJson = JSON.toJSONString(javaProcessInfoList);
DefaultFullHttpResponse response = buildHttpCorsResponse(processJson);
return response;
}
public DefaultFullHttpResponse buildHttpCorsResponse (String msg) {
DefaultFullHttpResponse response = new DefaultFullHttpResponse(HttpVersion.HTTP_1_1, HttpResponseStatus.OK,
Unpooled.copiedBuffer(msg.getBytes(CharsetUtil.UTF_8)));
response.headers().set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_ORIGIN, "*");
response.headers().set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_METHODS, "GET, POST, PUT, DELETE, OPTIONS");
response.headers().set(HttpHeaderNames.ACCESS_CONTROL_MAX_AGE, 3600L);
response.headers().set(HttpHeaderNames.ACCESS_CONTROL_ALLOW_HEADERS, "Content-Type, Authorization, X-Requested-With, Accept, Origin");
response.headers().set(HttpHeaderNames.CONTENT_TYPE, "application/json; charset=UTF-8");
response.headers().set(HttpHeaderNames.CONTENT_LENGTH, response.content().readableBytes());
return response;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/registry/NativeAgentRegistry.java | labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/registry/NativeAgentRegistry.java | package com.alibaba.arthas.nat.agent.registry;
/**
* @description: Native agent client registry interface, easy to extend to other registry implementations
* @author：flzjkl
* @date: 2024-09-15 16:21
*/
public interface NativeAgentRegistry {
/**
* Register native agent address to registry
*
* @param address registry address
* @param k native agent ip
* @param v http port + ws port
*/
void registerNativeAgent(String address, String k, String v);
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/registry/impl/ZookeeperNativeAgentRegistry.java | labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/registry/impl/ZookeeperNativeAgentRegistry.java | package com.alibaba.arthas.nat.agent.registry.impl;
import com.alibaba.arthas.nat.agent.common.constants.NativeAgentConstants;
import com.alibaba.arthas.nat.agent.registry.NativeAgentRegistry;
import org.apache.zookeeper.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.atomic.AtomicBoolean;
/**
* @description: Zookeeper native agent client register implements NativeAgentRegistry
* @author：flzjkl
* @date: 2024-07-24 0:01
*/
public class ZookeeperNativeAgentRegistry implements NativeAgentRegistry {
private static final Logger logger = LoggerFactory.getLogger(ZookeeperNativeAgentRegistry.class);
private static CountDownLatch latch = new CountDownLatch(1);
private static final int SESSION_TIMEOUT = 15000;
public void registerNativeAgent(String address, String k, String v) {
// Create zookeeper client
ZooKeeper zk = null;
AtomicBoolean createResult = new AtomicBoolean(false);
try {
zk = new ZooKeeper(address, SESSION_TIMEOUT, event -> {
if (event.getState() == Watcher.Event.KeeperState.SyncConnected) {
latch.countDown();
createResult.compareAndSet(false, true);
}
});
latch.await();
} catch (Exception e) {
logger.error("Create zookeeper client failed");
throw new RuntimeException(e);
} finally {
latch.countDown();
}
if (!createResult.get()) {
throw new RuntimeException("Create zookeeper client failed");
}
try {
// Create a service node. If the parent node does not exist, create the parent node first
if (zk.exists(NativeAgentConstants.NATIVE_AGENT_KEY, false) == null) {
zk.create(NativeAgentConstants.NATIVE_AGENT_KEY, new byte[0], ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.PERSISTENT);
}
// The EPHEMERAL mode is used to create child nodes, which means that the nodes are automatically removed at the end of the session
String path = zk.create(NativeAgentConstants.NATIVE_AGENT_KEY + "/" + k, v.getBytes(), ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
logger.info("native agent client registered at: " + path);
} catch (KeeperException | InterruptedException e) {
logger.error("Register native agent client failed");
e.printStackTrace();
throw new RuntimeException(e);
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/registry/impl/EtcdNativeAgentRegistry.java | labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/registry/impl/EtcdNativeAgentRegistry.java | package com.alibaba.arthas.nat.agent.registry.impl;
import com.alibaba.arthas.nat.agent.common.constants.NativeAgentConstants;
import com.alibaba.arthas.nat.agent.registry.NativeAgentRegistry;
import io.etcd.jetcd.ByteSequence;
import io.etcd.jetcd.Client;
import io.etcd.jetcd.KV;
import io.etcd.jetcd.Lease;
import io.etcd.jetcd.kv.GetResponse;
import io.etcd.jetcd.kv.PutResponse;
import io.etcd.jetcd.lease.LeaseGrantResponse;
import io.etcd.jetcd.lease.LeaseKeepAliveResponse;
import io.etcd.jetcd.options.PutOption;
import io.grpc.stub.StreamObserver;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.nio.charset.StandardCharsets;
import java.time.Duration;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
/**
* @description: Etcd native agent register implements NativeAgentRegistry
* @author：flzjkl
* @date: 2024-09-13 7:54
*/
public class EtcdNativeAgentRegistry implements NativeAgentRegistry {
private static final Logger logger = LoggerFactory.getLogger(EtcdNativeAgentRegistry.class);
private final int TIME_OUT_SECONDS = 5;
private static final int CONNECTION_TIME_OUT_SECONDS = 5;
private final int LEASE_SECONDS = 20;
private static CountDownLatch latch = new CountDownLatch(1);
@Override
public void registerNativeAgent(String address, String k, String v) {
// Etcd client
Client client = null;
client = Client.builder().endpoints("http://" + address).connectTimeout(Duration.ofSeconds(CONNECTION_TIME_OUT_SECONDS)).build();
KV kvClient = client.getKVClient();
CompletableFuture<GetResponse> future = kvClient.get(ByteSequence.from("anything", StandardCharsets.UTF_8));
future.thenAcceptAsync(res -> latch.countDown());
try {
if (!latch.await(CONNECTION_TIME_OUT_SECONDS, TimeUnit.SECONDS)) {
logger.error("Connect time out");
throw new RuntimeException("Connect time out");
}
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
// Create lease
Lease leaseClient = null;
LeaseGrantResponse leaseGrantResponse = null;
try {
leaseClient = client.getLeaseClient();
leaseGrantResponse = leaseClient.grant(LEASE_SECONDS).get();
} catch (Exception e) {
logger.error("Create lease failed");
throw new RuntimeException(e);
}
long leaseId = leaseGrantResponse.getID();
leaseClient.keepAlive(leaseId, new StreamObserver<LeaseKeepAliveResponse>() {
@Override
public void onNext(LeaseKeepAliveResponse response) {
// logger.info("lease renewal success, lease id: " + response.getID());
}
@Override
public void onError(Throwable t) {
logger.error("keep alive error: " + t.getMessage());
t.printStackTrace();
}
@Override
public void onCompleted() {
}
});
// Register native agent client synchronously
try {
ByteSequence key = ByteSequence.from(NativeAgentConstants.NATIVE_AGENT_KEY + "/" + k, StandardCharsets.UTF_8);
ByteSequence value = ByteSequence.from(v, StandardCharsets.UTF_8);
PutResponse putResponse = kvClient.put(key, value, PutOption.newBuilder().withLeaseId(leaseId).build()).get(TIME_OUT_SECONDS, TimeUnit.SECONDS);
logger.info("put response {}",putResponse.toString());
} catch (Exception e) {
logger.error("Register native agent failed");
throw new RuntimeException(e);
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/factory/NativeAgentRegistryFactory.java | labs/cluster-management/native-agent/src/main/java/com/alibaba/arthas/nat/agent/factory/NativeAgentRegistryFactory.java | package com.alibaba.arthas.nat.agent.factory;
import com.alibaba.arthas.nat.agent.registry.NativeAgentRegistry;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.lang.reflect.Constructor;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* @description: NativeAgentRegistryFactory create all the realization of the registry
* @author：flzjkl
* @date: 2024-09-15 16:22
*/
public class NativeAgentRegistryFactory {
private static final String FILE_PATH = "META-INF/arthas/com.alibaba.arthas.native.agent.NativeAgentRegistryFactory";
private static Map<String, NativeAgentRegistry> registrationMap = new ConcurrentHashMap<>();
private static volatile NativeAgentRegistryFactory nativeAgentRegistryFactory;
private NativeAgentRegistryFactory() {
Map<String, String> registrationConfigMap = readConfigInfo(FILE_PATH);
loadRegister2Map(registrationConfigMap);
}
public static NativeAgentRegistryFactory getNativeAgentClientRegisterFactory() {
if (nativeAgentRegistryFactory == null) {
synchronized (NativeAgentRegistryFactory.class) {
if (nativeAgentRegistryFactory == null) {
nativeAgentRegistryFactory = new NativeAgentRegistryFactory();
}
}
}
return nativeAgentRegistryFactory;
}
private void loadRegister2Map(Map<String, String> registrationConfigMap) {
for (Map.Entry<String, String> entry : registrationConfigMap.entrySet()) {
String name = entry.getKey();
String classPath = entry.getValue();
try {
Class<?> clazz = Class.forName(classPath);
Constructor<?> constructor = clazz.getConstructor();
NativeAgentRegistry instance = (NativeAgentRegistry) constructor.newInstance();
registrationMap.put(name, instance);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
public Map<String, String> readConfigInfo (String filePath) {
Map<String, String> registrationConfigMap = new ConcurrentHashMap<>();
ClassLoader classLoader = NativeAgentRegistryFactory.class.getClassLoader();
try (InputStream inputStream = classLoader.getResourceAsStream(filePath); BufferedReader reader = new BufferedReader(new InputStreamReader(inputStream))) {
if (inputStream == null) {
throw new IllegalArgumentException("File not found: " + filePath);
}
String line;
while ((line = reader.readLine()) != null) {
if (!line.trim().isEmpty() && line.contains("=")) {
String[] parts = line.split("=", 2);
if (parts.length == 2) {
registrationConfigMap.put(parts[0].trim(), parts[1].trim());
}
}
}
} catch (IOException e) {
e.printStackTrace();
}
return registrationConfigMap;
}
public NativeAgentRegistry getServiceRegistration(String name) {
return registrationMap.get(name);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent-proxy/src/main/java/com/alibaba/arthas/nat/agent/proxy/discovery/NativeAgentDiscovery.java | labs/cluster-management/native-agent-proxy/src/main/java/com/alibaba/arthas/nat/agent/proxy/discovery/NativeAgentDiscovery.java | package com.alibaba.arthas.nat.agent.proxy.discovery;
import java.util.Map;
/**
* @description: NativeAgentDiscovery
* @author：flzjkl
* @date: 2024-09-19 7:22
*/
public interface NativeAgentDiscovery {
/**
*
* @param address register address
* @return Map<String, String> k: native agent client id ,v: http port + ws port
*/
Map<String, String> findNativeAgent(String address);
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent-proxy/src/main/java/com/alibaba/arthas/nat/agent/proxy/discovery/impl/ZookeeperNativeAgentDiscovery.java | labs/cluster-management/native-agent-proxy/src/main/java/com/alibaba/arthas/nat/agent/proxy/discovery/impl/ZookeeperNativeAgentDiscovery.java | package com.alibaba.arthas.nat.agent.proxy.discovery.impl;
import com.alibaba.arthas.nat.agent.common.constants.NativeAgentConstants;
import com.alibaba.arthas.nat.agent.proxy.discovery.NativeAgentDiscovery;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.apache.zookeeper.data.Stat;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CountDownLatch;
/**
* @description: ZookeeperNativeAgentDiscovery implements NativeAgentDiscovery
* @author：flzjkl
* @date: 2024-07-24 20:33
*/
public class ZookeeperNativeAgentDiscovery implements NativeAgentDiscovery {
private static final int SESSION_TIMEOUT = 20000;
private static final CountDownLatch connectedSemaphore = new CountDownLatch(1);
@Override
public Map<String, String> findNativeAgent(String address) {
if (address == null || "".equals(address)) {
return null;
}
// Wait for connection to be established
try {
ZooKeeper zooKeeper = new ZooKeeper(address, SESSION_TIMEOUT, event -> {
if (event.getState() == Watcher.Event.KeeperState.SyncConnected) {
connectedSemaphore.countDown();
}
});
connectedSemaphore.await();
// Gets a list of all children of the parent node
List<String> children = zooKeeper.getChildren(NativeAgentConstants.NATIVE_AGENT_KEY, false);
// Get the data of the child node
Map<String, String> res = new ConcurrentHashMap<>(children.size());
for (String child : children) {
String childPath = NativeAgentConstants.NATIVE_AGENT_KEY + "/" + child;
byte[] data = zooKeeper.getData(childPath, false, new Stat());
String dataStr = new String(data);
res.put(child, dataStr);
}
zooKeeper.close();
return res;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/labs/cluster-management/native-agent-proxy/src/main/java/com/alibaba/arthas/nat/agent/proxy/discovery/impl/EtcdNativeAgentDiscovery.java | labs/cluster-management/native-agent-proxy/src/main/java/com/alibaba/arthas/nat/agent/proxy/discovery/impl/EtcdNativeAgentDiscovery.java | package com.alibaba.arthas.nat.agent.proxy.discovery.impl;
import com.alibaba.arthas.nat.agent.common.constants.NativeAgentConstants;
import com.alibaba.arthas.nat.agent.proxy.discovery.NativeAgentDiscovery;
import io.etcd.jetcd.ByteSequence;
import io.etcd.jetcd.Client;
import io.etcd.jetcd.KV;
import io.etcd.jetcd.KeyValue;
import io.etcd.jetcd.kv.GetResponse;
import io.etcd.jetcd.options.GetOption;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import java.nio.charset.StandardCharsets;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* @description: EtcdNativeAgentDiscovery implements NativeAgentDiscovery
* @author：flzjkl
* @date: 2024-09-15 9:19
*/
public class EtcdNativeAgentDiscovery implements NativeAgentDiscovery {
private static final Logger logger = LoggerFactory.getLogger(EtcdNativeAgentDiscovery.class);
@Override
public Map<String, String> findNativeAgent(String address) {
// Create kv client
Client client = null;
KV kvClient = null;
Map<String, String> nativeAgentMap = null;
try {
client = Client.builder().endpoints("http://" + address).build();
kvClient = client.getKVClient();
// Get value by prefix /native-agent
GetResponse getResponse = null;
try {
ByteSequence prefix = ByteSequence.from(NativeAgentConstants.NATIVE_AGENT_KEY, StandardCharsets.UTF_8);
GetOption option = GetOption.newBuilder().isPrefix(true).build();
getResponse = kvClient.get(prefix, option).get();
} catch (Exception e) {
logger.error("get value failed with prefix" + NativeAgentConstants.NATIVE_AGENT_KEY);
throw new RuntimeException(e);
}
// Build Map
List<KeyValue> kvs = getResponse.getKvs();
nativeAgentMap = new ConcurrentHashMap<>(kvs.size());
for (KeyValue kv : kvs) {
String keyStr = kv.getKey().toString(StandardCharsets.UTF_8);
if (keyStr.startsWith(NativeAgentConstants.NATIVE_AGENT_PROXY_KEY)) {
continue;
}
String[] split = keyStr.split("/");
nativeAgentMap.put(split[2], kv.getValue().toString(StandardCharsets.UTF_8));
}
} finally {
if (kvClient != null) {
kvClient.close();
}
if (client != null) {
client.close();
}
}
return nativeAgentMap;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.