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 |
|---|---|---|---|---|---|---|---|---|
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/view/MBeanView.java | core/src/main/java/com/taobao/arthas/core/command/view/MBeanView.java | package com.taobao.arthas.core.command.view;
import com.taobao.arthas.core.command.model.MBeanAttributeVO;
import com.taobao.arthas.core.command.model.MBeanModel;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.text.Color;
import com.taobao.text.Decoration;
import com.taobao.text.ui.LabelElement;
import com.taobao.text.ui.TableElement;
import com.taobao.text.util.RenderUtil;
import javax.management.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import static com.taobao.text.ui.Element.label;
import static javax.management.MBeanOperationInfo.*;
/**
* View of 'mbean' command
*
* @author gongdewei 2020/4/26
*/
public class MBeanView extends ResultView<MBeanModel> {
@Override
public void draw(CommandProcess process, MBeanModel result) {
if (result.getMbeanNames() != null) {
drawMBeanNames(process, result.getMbeanNames());
} else if (result.getMbeanMetadata() != null) {
drawMBeanMetadata(process, result.getMbeanMetadata());
} else if (result.getMbeanAttribute() != null) {
drawMBeanAttributes(process, result.getMbeanAttribute());
}
}
private void drawMBeanAttributes(CommandProcess process, Map<String, List<MBeanAttributeVO>> mbeanAttributeMap) {
for (Map.Entry<String, List<MBeanAttributeVO>> entry : mbeanAttributeMap.entrySet()) {
String objectName = entry.getKey();
List<MBeanAttributeVO> attributeVOList = entry.getValue();
TableElement table = new TableElement().leftCellPadding(1).rightCellPadding(1);
table.row(true, "OBJECT_NAME", objectName);
table.row(true, label("NAME").style(Decoration.bold.bold()),
label("VALUE").style(Decoration.bold.bold()));
for (MBeanAttributeVO attributeVO : attributeVOList) {
String attributeName = attributeVO.getName();
String valueStr;
if (attributeVO.getError() != null) {
valueStr = RenderUtil.render(new LabelElement(attributeVO.getError()).style(Decoration.bold_off.fg(Color.red)));
} else {
//convert array to list
// TODO support all array type
Object value = attributeVO.getValue();
if (value instanceof String[]) {
value = Arrays.asList((String[]) value);
} else if (value instanceof Integer[]) {
value = Arrays.asList((Integer[]) value);
} else if (value instanceof Long[]) {
value = Arrays.asList((Long[]) value);
} else if (value instanceof int[]) {
value = convertArrayToList((int[]) value);
} else if (value instanceof long[]) {
value = convertArrayToList((long[]) value);
}
//to string
valueStr = String.valueOf(value);
}
table.row(attributeName, valueStr);
}
process.write(RenderUtil.render(table, process.width()));
process.write("\n");
}
}
private List<Long> convertArrayToList(long[] longs) {
List<Long> list = new ArrayList<Long>();
for (long aLong : longs) {
list.add(aLong);
}
return list;
}
private List<Integer> convertArrayToList(int[] ints) {
List<Integer> list = new ArrayList<Integer>();
for (int anInt : ints) {
list.add(anInt);
}
return list;
}
private void drawMBeanMetadata(CommandProcess process, Map<String, MBeanInfo> mbeanMetadata) {
TableElement table = createTable();
for (Map.Entry<String, MBeanInfo> entry : mbeanMetadata.entrySet()) {
String objectName = entry.getKey();
MBeanInfo mBeanInfo = entry.getValue();
drawMetaInfo(mBeanInfo, objectName, table);
drawAttributeInfo(mBeanInfo.getAttributes(), table);
drawOperationInfo(mBeanInfo.getOperations(), table);
drawNotificationInfo(mBeanInfo.getNotifications(), table);
}
process.write(RenderUtil.render(table, process.width()));
}
private void drawMBeanNames(CommandProcess process, List<String> mbeanNames) {
for (String mbeanName : mbeanNames) {
process.write(mbeanName).write("\n");
}
}
private static TableElement createTable() {
TableElement table = new TableElement().leftCellPadding(1).rightCellPadding(1);
table.row(true, label("NAME").style(Decoration.bold.bold()),
label("VALUE").style(Decoration.bold.bold()));
return table;
}
private void drawMetaInfo(MBeanInfo mBeanInfo, String objectName, TableElement table) {
table.row(new LabelElement("MBeanInfo").style(Decoration.bold.fg(Color.red)));
table.row(new LabelElement("Info:").style(Decoration.bold.fg(Color.yellow)));
table.row("ObjectName", objectName);
table.row("ClassName", mBeanInfo.getClassName());
table.row("Description", mBeanInfo.getDescription());
drawDescriptorInfo("Info Descriptor:", mBeanInfo, table);
MBeanConstructorInfo[] constructors = mBeanInfo.getConstructors();
if (constructors.length > 0) {
for (int i = 0; i < constructors.length; i++) {
table.row(new LabelElement("Constructor-" + i).style(Decoration.bold.fg(Color.yellow)));
table.row("Name", constructors[i].getName());
table.row("Description", constructors[i].getDescription());
}
}
}
private void drawAttributeInfo(MBeanAttributeInfo[] attributes, TableElement table) {
for (MBeanAttributeInfo attribute : attributes) {
table.row(new LabelElement("MBeanAttributeInfo").style(Decoration.bold.fg(Color.red)));
table.row(new LabelElement("Attribute:").style(Decoration.bold.fg(Color.yellow)));
table.row("Name", attribute.getName());
table.row("Description", attribute.getDescription());
table.row("Readable", String.valueOf(attribute.isReadable()));
table.row("Writable", String.valueOf(attribute.isWritable()));
table.row("Is", String.valueOf(attribute.isIs()));
table.row("Type", attribute.getType());
drawDescriptorInfo("Attribute Descriptor:", attribute, table);
}
}
private void drawOperationInfo(MBeanOperationInfo[] operations, TableElement table) {
for (MBeanOperationInfo operation : operations) {
table.row(new LabelElement("MBeanOperationInfo").style(Decoration.bold.fg(Color.red)));
table.row(new LabelElement("Operation:").style(Decoration.bold.fg(Color.yellow)));
table.row("Name", operation.getName());
table.row("Description", operation.getDescription());
String impact = "";
switch (operation.getImpact()) {
case ACTION:
impact = "action";
break;
case ACTION_INFO:
impact = "action/info";
break;
case INFO:
impact = "info";
break;
case UNKNOWN:
impact = "unknown";
break;
}
table.row("Impact", impact);
table.row("ReturnType", operation.getReturnType());
MBeanParameterInfo[] signature = operation.getSignature();
if (signature.length > 0) {
for (int i = 0; i < signature.length; i++) {
table.row(new LabelElement("Parameter-" + i).style(Decoration.bold.fg(Color.yellow)));
table.row("Name", signature[i].getName());
table.row("Type", signature[i].getType());
table.row("Description", signature[i].getDescription());
}
}
drawDescriptorInfo("Operation Descriptor:", operation, table);
}
}
private void drawNotificationInfo(MBeanNotificationInfo[] notificationInfos, TableElement table) {
for (MBeanNotificationInfo notificationInfo : notificationInfos) {
table.row(new LabelElement("MBeanNotificationInfo").style(Decoration.bold.fg(Color.red)));
table.row(new LabelElement("Notification:").style(Decoration.bold.fg(Color.yellow)));
table.row("Name", notificationInfo.getName());
table.row("Description", notificationInfo.getDescription());
table.row("NotifTypes", Arrays.toString(notificationInfo.getNotifTypes()));
drawDescriptorInfo("Notification Descriptor:", notificationInfo, table);
}
}
private void drawDescriptorInfo(String title, DescriptorRead descriptorRead, TableElement table) {
Descriptor descriptor = descriptorRead.getDescriptor();
String[] fieldNames = descriptor.getFieldNames();
if (fieldNames.length > 0) {
table.row(new LabelElement(title).style(Decoration.bold.fg(Color.yellow)));
for (String fieldName : fieldNames) {
Object fieldValue = descriptor.getFieldValue(fieldName);
table.row(fieldName, fieldValue == null ? "" : fieldValue.toString());
}
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/view/MonitorView.java | core/src/main/java/com/taobao/arthas/core/command/view/MonitorView.java | package com.taobao.arthas.core.command.view;
import com.taobao.arthas.core.command.model.MonitorModel;
import com.taobao.arthas.core.command.monitor200.MonitorData;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.util.DateUtils;
import com.taobao.text.Decoration;
import com.taobao.text.ui.TableElement;
import com.taobao.text.util.RenderUtil;
import java.text.DecimalFormat;
import static com.taobao.text.ui.Element.label;
/**
* Term view for MonitorModel
* @author gongdewei 2020/4/28
*/
public class MonitorView extends ResultView<MonitorModel> {
@Override
public void draw(CommandProcess process, MonitorModel result) {
TableElement table = new TableElement(2, 3, 3, 1, 1, 1, 1, 1).leftCellPadding(1).rightCellPadding(1);
table.row(true, label("timestamp").style(Decoration.bold.bold()),
label("class").style(Decoration.bold.bold()),
label("method").style(Decoration.bold.bold()),
label("total").style(Decoration.bold.bold()),
label("success").style(Decoration.bold.bold()),
label("fail").style(Decoration.bold.bold()),
label("avg-rt(ms)").style(Decoration.bold.bold()),
label("fail-rate").style(Decoration.bold.bold()));
final DecimalFormat df = new DecimalFormat("0.00");
for (MonitorData data : result.getMonitorDataList()) {
table.row(
DateUtils.formatDateTime(data.getTimestamp()),
data.getClassName(),
data.getMethodName(),
"" + data.getTotal(),
"" + data.getSuccess(),
"" + data.getFailed(),
df.format(div(data.getCost(), data.getTotal())),
df.format(100.0d * div(data.getFailed(), data.getTotal())) + "%"
);
}
process.write(RenderUtil.render(table, process.width()) + "\n");
}
private double div(double a, double b) {
if (b == 0) {
return 0;
}
return a / b;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/view/ViewRenderUtil.java | core/src/main/java/com/taobao/arthas/core/command/view/ViewRenderUtil.java | package com.taobao.arthas.core.command.view;
import com.taobao.arthas.core.command.model.ChangeResultVO;
import com.taobao.arthas.core.command.model.EnhancerAffectVO;
import com.taobao.arthas.core.command.model.ThreadVO;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.text.Color;
import com.taobao.text.Decoration;
import com.taobao.text.Style;
import com.taobao.text.ui.LabelElement;
import com.taobao.text.ui.Overflow;
import com.taobao.text.ui.RowElement;
import com.taobao.text.ui.TableElement;
import com.taobao.text.util.RenderUtil;
import java.util.EnumMap;
import java.util.List;
import java.util.Map;
import static com.taobao.text.ui.Element.label;
import static java.lang.String.format;
/**
* view render util for term/tty
* @author gongdewei 2020/6/22
*/
public class ViewRenderUtil {
/** Thread State Colors */
public static final EnumMap<Thread.State, Color> colorMapping = new EnumMap<Thread.State, Color>(Thread.State.class);
static {
colorMapping.put(Thread.State.NEW, Color.cyan);
colorMapping.put(Thread.State.RUNNABLE, Color.green);
colorMapping.put(Thread.State.BLOCKED, Color.red);
colorMapping.put(Thread.State.WAITING, Color.yellow);
colorMapping.put(Thread.State.TIMED_WAITING, Color.magenta);
colorMapping.put(Thread.State.TERMINATED, Color.blue);
}
/**
* Render key-value table
* @param map
* @param width
* @return
*/
public static String renderKeyValueTable(Map<String, String> map, int width) {
TableElement table = new TableElement(1, 4).leftCellPadding(1).rightCellPadding(1);
table.row(true, label("KEY").style(Decoration.bold.bold()), label("VALUE").style(Decoration.bold.bold()));
for (Map.Entry<String, String> entry : map.entrySet()) {
table.row(entry.getKey(), entry.getValue());
}
return RenderUtil.render(table, width);
}
/**
* Render change result vo
* @param result
* @return
*/
public static TableElement renderChangeResult(ChangeResultVO result) {
TableElement table = new TableElement().leftCellPadding(1).rightCellPadding(1);
table.row(true, label("NAME").style(Decoration.bold.bold()),
label("BEFORE-VALUE").style(Decoration.bold.bold()),
label("AFTER-VALUE").style(Decoration.bold.bold()));
table.row(result.getName(), StringUtils.objectToString(result.getBeforeValue()),
StringUtils.objectToString(result.getAfterValue()));
return table;
}
/**
* Render EnhancerAffectVO
* @param affectVO
* @return
*/
public static String renderEnhancerAffect(EnhancerAffectVO affectVO) {
final StringBuilder infoSB = new StringBuilder();
List<String> classDumpFiles = affectVO.getClassDumpFiles();
if (classDumpFiles != null) {
for (String classDumpFile : classDumpFiles) {
infoSB.append("[dump: ").append(classDumpFile).append("]\n");
}
}
List<String> methods = affectVO.getMethods();
if (methods != null) {
for (String method : methods) {
infoSB.append("[Affect method: ").append(method).append("]\n");
}
}
infoSB.append(format("Affect(class count: %d , method count: %d) cost in %s ms, listenerId: %d",
affectVO.getClassCount(),
affectVO.getMethodCount(),
affectVO.getCost(),
affectVO.getListenerId()));
if (!StringUtils.isEmpty(affectVO.getOverLimitMsg())) {
infoSB.append("\n" + affectVO.getOverLimitMsg());
}
if (affectVO.getThrowable() != null) {
infoSB.append("\nEnhance error! exception: ").append(affectVO.getThrowable());
}
infoSB.append("\n");
return infoSB.toString();
}
public static String drawThreadInfo(List<ThreadVO> threads, int width, int height) {
TableElement table = new TableElement(1, 6, 3, 2, 2, 2, 2, 2, 2, 2).overflow(Overflow.HIDDEN).rightCellPadding(1);
// Header
table.add(
new RowElement().style(Decoration.bold.fg(Color.black).bg(Color.white)).add(
"ID",
"NAME",
"GROUP",
"PRIORITY",
"STATE",
"%CPU",
"DELTA_TIME",
"TIME",
"INTERRUPTED",
"DAEMON"
)
);
int count = 0;
for (ThreadVO thread : threads) {
Color color = colorMapping.get(thread.getState());
String time = formatTimeMills(thread.getTime());
String deltaTime = formatTimeMillsToSeconds(thread.getDeltaTime());
double cpu = thread.getCpu();
LabelElement daemonLabel = new LabelElement(thread.isDaemon());
if (!thread.isDaemon()) {
daemonLabel.setStyle(Style.style(Color.magenta));
}
LabelElement stateElement;
if (thread.getState() != null) {
stateElement = new LabelElement(thread.getState()).style(color.fg());
} else {
stateElement = new LabelElement("-");
}
table.row(
new LabelElement(thread.getId()),
new LabelElement(thread.getName()),
new LabelElement(thread.getGroup() != null ? thread.getGroup() : "-"),
new LabelElement(thread.getPriority()),
stateElement,
new LabelElement(cpu),
new LabelElement(deltaTime),
new LabelElement(time),
new LabelElement(thread.isInterrupted()),
daemonLabel
);
if (++count >= height) {
break;
}
}
return RenderUtil.render(table, width, height);
}
private static String formatTimeMills(long timeMills) {
long seconds = timeMills / 1000;
long mills = timeMills % 1000;
long min = seconds / 60;
seconds = seconds % 60;
//return String.format("%d:%d.%03d", min, seconds, mills);
String str;
if (mills >= 100) {
str = min + ":" + seconds + "." + mills;
} else if (mills >= 10) {
str = min + ":" + seconds + ".0" + mills;
} else {
str = min + ":" + seconds + ".00" + mills;
}
return str;
}
private static String formatTimeMillsToSeconds(long timeMills) {
long seconds = timeMills / 1000;
long mills = timeMills % 1000;
//return String.format("%d.%03d", seconds, mills);
String str;
if (mills >= 100) {
str = seconds + "." + mills;
} else if (mills >= 10) {
str = seconds + ".0" + mills;
} else {
str = seconds + ".00" + mills;
}
return str;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/view/LoggerView.java | core/src/main/java/com/taobao/arthas/core/command/view/LoggerView.java | package com.taobao.arthas.core.command.view;
import com.taobao.arthas.core.command.logger.LoggerHelper;
import com.taobao.arthas.core.command.model.LoggerModel;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.text.Decoration;
import com.taobao.text.ui.TableElement;
import com.taobao.text.util.RenderUtil;
import java.util.List;
import java.util.Map;
import static com.taobao.text.ui.Element.label;
/**
* View of 'logger' command
*
* @author gongdewei 2020/4/22
*/
public class LoggerView extends ResultView<LoggerModel> {
@Override
public void draw(CommandProcess process, LoggerModel result) {
if (result.getMatchedClassLoaders() != null) {
process.write("Matched classloaders: \n");
ClassLoaderView.drawClassLoaders(process, result.getMatchedClassLoaders(), false);
process.write("\n");
return;
}
process.write(renderLoggerInfo(result.getLoggerInfoMap(), process.width()));
}
private String renderLoggerInfo(Map<String, Map<String, Object>> loggerInfos, int width) {
StringBuilder sb = new StringBuilder(8192);
for (Map.Entry<String, Map<String, Object>> entry : loggerInfos.entrySet()) {
Map<String, Object> info = entry.getValue();
TableElement table = new TableElement(2, 10).leftCellPadding(1).rightCellPadding(1);
TableElement appendersTable = new TableElement().rightCellPadding(1);
Class<?> clazz = (Class<?>) info.get(LoggerHelper.clazz);
table.row(label(LoggerHelper.name).style(Decoration.bold.bold()), label("" + info.get(LoggerHelper.name)))
.row(label(LoggerHelper.clazz).style(Decoration.bold.bold()), label("" + clazz.getName()))
.row(label(LoggerHelper.classLoader).style(Decoration.bold.bold()),
label("" + info.get(LoggerHelper.classLoader)))
.row(label(LoggerHelper.classLoaderHash).style(Decoration.bold.bold()),
label("" + info.get(LoggerHelper.classLoaderHash)))
.row(label(LoggerHelper.level).style(Decoration.bold.bold()),
label("" + info.get(LoggerHelper.level)));
if (info.get(LoggerHelper.effectiveLevel) != null) {
table.row(label(LoggerHelper.effectiveLevel).style(Decoration.bold.bold()),
label("" + info.get(LoggerHelper.effectiveLevel)));
}
if (info.get(LoggerHelper.config) != null) {
table.row(label(LoggerHelper.config).style(Decoration.bold.bold()),
label("" + info.get(LoggerHelper.config)));
}
table.row(label(LoggerHelper.additivity).style(Decoration.bold.bold()),
label("" + info.get(LoggerHelper.additivity)))
.row(label(LoggerHelper.codeSource).style(Decoration.bold.bold()),
label("" + info.get(LoggerHelper.codeSource)));
@SuppressWarnings("unchecked")
List<Map<String, Object>> appenders = (List<Map<String, Object>>) info.get(LoggerHelper.appenders);
if (appenders != null && !appenders.isEmpty()) {
for (Map<String, Object> appenderInfo : appenders) {
Class<?> appenderClass = (Class<?>) appenderInfo.get(LoggerHelper.clazz);
appendersTable.row(label(LoggerHelper.name).style(Decoration.bold.bold()),
label("" + appenderInfo.get(LoggerHelper.name)));
appendersTable.row(label(LoggerHelper.clazz), label("" + appenderClass.getName()));
appendersTable.row(label(LoggerHelper.classLoader), label("" + info.get(LoggerHelper.classLoader)));
appendersTable.row(label(LoggerHelper.classLoaderHash),
label("" + info.get(LoggerHelper.classLoaderHash)));
if (appenderInfo.get(LoggerHelper.file) != null) {
appendersTable.row(label(LoggerHelper.file), label("" + appenderInfo.get(LoggerHelper.file)));
}
if (appenderInfo.get(LoggerHelper.target) != null) {
appendersTable.row(label(LoggerHelper.target),
label("" + appenderInfo.get(LoggerHelper.target)));
}
if (appenderInfo.get(LoggerHelper.blocking) != null) {
appendersTable.row(label(LoggerHelper.blocking),
label("" + appenderInfo.get(LoggerHelper.blocking)));
}
if (appenderInfo.get(LoggerHelper.appenderRef) != null) {
appendersTable.row(label(LoggerHelper.appenderRef),
label("" + appenderInfo.get(LoggerHelper.appenderRef)));
}
}
table.row(label("appenders").style(Decoration.bold.bold()), appendersTable);
}
sb.append(RenderUtil.render(table, width)).append('\n');
}
return sb.toString();
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/view/VmToolView.java | core/src/main/java/com/taobao/arthas/core/command/view/VmToolView.java | package com.taobao.arthas.core.command.view;
import com.taobao.arthas.core.command.model.ObjectVO;
import com.taobao.arthas.core.command.model.VmToolModel;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.arthas.core.view.ObjectView;
/**
*
* @author hengyunabc 2022-04-24
*
*/
public class VmToolView extends ResultView<VmToolModel> {
@Override
public void draw(CommandProcess process, VmToolModel model) {
if (model.getMatchedClassLoaders() != null) {
process.write("Matched classloaders: \n");
ClassLoaderView.drawClassLoaders(process, model.getMatchedClassLoaders(), false);
process.write("\n");
return;
}
ObjectVO objectVO = model.getValue();
String resultStr = StringUtils.objectToString(objectVO.needExpand() ? new ObjectView(objectVO).draw() : objectVO.getObject());
process.write(resultStr).write("\n");
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/view/SessionView.java | core/src/main/java/com/taobao/arthas/core/command/view/SessionView.java | package com.taobao.arthas.core.command.view;
import com.taobao.arthas.core.command.model.SessionModel;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.text.Decoration;
import com.taobao.text.ui.TableElement;
import com.taobao.text.util.RenderUtil;
import static com.taobao.text.ui.Element.label;
/**
* Term / Tty view for session result
*
* @author gongdewei 2020/3/27
*/
public class SessionView extends ResultView<SessionModel> {
@Override
public void draw(CommandProcess process, SessionModel result) {
//会话详情
TableElement table = new TableElement().leftCellPadding(1).rightCellPadding(1);
table.row(true, label("Name").style(Decoration.bold.bold()), label("Value").style(Decoration.bold.bold()));
table.row("JAVA_PID", "" + result.getJavaPid()).row("SESSION_ID", "" + result.getSessionId());
if (result.getAgentId() != null) {
table.row("AGENT_ID", "" + result.getAgentId());
}
if (result.getTunnelServer() != null) {
table.row("TUNNEL_SERVER", "" + result.getTunnelServer());
table.row("TUNNEL_CONNECTED", "" + result.isTunnelConnected());
}
if (result.getStatUrl() != null) {
table.row("STAT_URL", result.getStatUrl());
}
if (result.getUserId() != null) {
table.row("USER_ID", result.getUserId());
}
process.write(RenderUtil.render(table, process.width()));
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/view/VMOptionView.java | core/src/main/java/com/taobao/arthas/core/command/view/VMOptionView.java | package com.taobao.arthas.core.command.view;
import com.sun.management.VMOption;
import com.taobao.arthas.core.command.model.VMOptionModel;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.text.Decoration;
import com.taobao.text.ui.TableElement;
import com.taobao.text.util.RenderUtil;
import java.util.List;
import static com.taobao.text.ui.Element.label;
/**
* @author gongdewei 2020/4/15
*/
public class VMOptionView extends ResultView<VMOptionModel> {
@Override
public void draw(CommandProcess process, VMOptionModel result) {
if (result.getVmOptions() != null) {
process.write(renderVMOptions(result.getVmOptions(), process.width()));
} else if (result.getChangeResult() != null) {
TableElement table = ViewRenderUtil.renderChangeResult(result.getChangeResult());
process.write(RenderUtil.render(table, process.width()));
}
}
private static String renderVMOptions(List<VMOption> diagnosticOptions, int width) {
TableElement table = new TableElement(1, 1, 1, 1).leftCellPadding(1).rightCellPadding(1);
table.row(true, label("KEY").style(Decoration.bold.bold()),
label("VALUE").style(Decoration.bold.bold()),
label("ORIGIN").style(Decoration.bold.bold()),
label("WRITEABLE").style(Decoration.bold.bold()));
for (VMOption option : diagnosticOptions) {
table.row(option.getName(), option.getValue(), "" + option.getOrigin(), "" + option.isWriteable());
}
return RenderUtil.render(table, width);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/express/ExpressFactory.java | core/src/main/java/com/taobao/arthas/core/command/express/ExpressFactory.java | package com.taobao.arthas.core.command.express;
import java.lang.ref.WeakReference;
/**
* ExpressFactory
* @author ralf0131 2017-01-04 14:40.
* @author hengyunabc 2018-10-08
*/
public class ExpressFactory {
/**
* 这里不能直接在 ThreadLocalMap 里强引用 Express（它由 ArthasClassLoader 加载），否则 stop/detach 后会被业务线程持有，
* 导致 ArthasClassLoader 无法被 GC 回收。
*
* 用 WeakReference 打断强引用链：Thread -> ThreadLocalMap -> value(WeakReference) -X-> Express。
*/
private static final ThreadLocal<WeakReference<Express>> expressRef = ThreadLocal
.withInitial(() -> new WeakReference<Express>(new OgnlExpress()));
/**
* get ThreadLocal Express Object
* @param object
* @return
*/
public static Express threadLocalExpress(Object object) {
WeakReference<Express> reference = expressRef.get();
Express express = reference == null ? null : reference.get();
if (express == null) {
express = new OgnlExpress();
expressRef.set(new WeakReference<Express>(express));
}
return express.reset().bind(object);
}
public static Express unpooledExpress(ClassLoader classloader) {
if (classloader == null) {
classloader = ClassLoader.getSystemClassLoader();
}
return new OgnlExpress(new ClassLoaderClassResolver(classloader));
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/express/OgnlExpress.java | core/src/main/java/com/taobao/arthas/core/command/express/OgnlExpress.java | package com.taobao.arthas.core.command.express;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import ognl.ClassResolver;
import ognl.MemberAccess;
import ognl.Ognl;
import ognl.OgnlContext;
import ognl.OgnlRuntime;
/**
* @author ralf0131 2017-01-04 14:41.
* @author hengyunabc 2018-10-18
*/
public class OgnlExpress implements Express {
private static final MemberAccess MEMBER_ACCESS = new DefaultMemberAccess(true);
private static final Logger logger = LoggerFactory.getLogger(OgnlExpress.class);
private static final ArthasObjectPropertyAccessor OBJECT_PROPERTY_ACCESSOR = new ArthasObjectPropertyAccessor();
private Object bindObject;
private final OgnlContext context;
public OgnlExpress() {
this(CustomClassResolver.customClassResolver);
}
public OgnlExpress(ClassResolver classResolver) {
OgnlRuntime.setPropertyAccessor(Object.class, OBJECT_PROPERTY_ACCESSOR);
context = new OgnlContext(MEMBER_ACCESS, classResolver, null, null);
}
@Override
public Object get(String express) throws ExpressException {
try {
return Ognl.getValue(express, context, bindObject);
} catch (Exception e) {
logger.error("Error during evaluating the expression:", e);
throw new ExpressException(express, e);
}
}
@Override
public boolean is(String express) throws ExpressException {
final Object ret = get(express);
return ret instanceof Boolean && (Boolean) ret;
}
@Override
public Express bind(Object object) {
this.bindObject = object;
return this;
}
@Override
public Express bind(String name, Object value) {
context.put(name, value);
return this;
}
@Override
public Express reset() {
context.clear();
return this;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/express/CustomClassResolver.java | core/src/main/java/com/taobao/arthas/core/command/express/CustomClassResolver.java | package com.taobao.arthas.core.command.express;
import ognl.ClassResolver;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
/**
* @author diecui1202 on 2017/9/29.
* @see ognl.DefaultClassResolver
*/
public class CustomClassResolver implements ClassResolver {
public static final CustomClassResolver customClassResolver = new CustomClassResolver();
private Map<String, Class<?>> classes = new ConcurrentHashMap<String, Class<?>>(101);
private CustomClassResolver() {
}
@Override
public Class classForName(String className, Map context) throws ClassNotFoundException {
Class<?> result = null;
if ((result = classes.get(className)) == null) {
try {
ClassLoader classLoader = Thread.currentThread().getContextClassLoader();
if (classLoader != null) {
result = classLoader.loadClass(className);
} else {
result = Class.forName(className);
}
} catch (ClassNotFoundException ex) {
if (className.indexOf('.') == -1) {
result = Class.forName("java.lang." + className);
classes.put("java.lang." + className, result);
}
}
classes.put(className, result);
}
return result;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/express/ExpressException.java | core/src/main/java/com/taobao/arthas/core/command/express/ExpressException.java | package com.taobao.arthas.core.command.express;
/**
* 表达式异常
* Created by vlinux on 15/5/20.
*/
public class ExpressException extends Exception {
private final String express;
/**
* 表达式异常
*
* @param express 原始表达式
* @param cause 异常原因
*/
public ExpressException(String express, Throwable cause) {
super(cause);
this.express = express;
}
/**
* 获取表达式
*
* @return 返回出问题的表达式
*/
public String getExpress() {
return express;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/express/DefaultMemberAccess.java | core/src/main/java/com/taobao/arthas/core/command/express/DefaultMemberAccess.java | package com.taobao.arthas.core.command.express;
import ognl.MemberAccess;
import java.lang.reflect.AccessibleObject;
import java.lang.reflect.Member;
import java.lang.reflect.Modifier;
import java.util.Map;
/**
* ognl.DefaultMemberAccess (ognl:ognl:3.1.19)
*
* This class provides methods for setting up and restoring
* access in a Field. Java 2 provides access utilities for setting
* and getting fields that are non-public. This object provides
* coarse-grained access controls to allow access to private, protected
* and package protected members. This will apply to all classes
* and members.
*/
public class DefaultMemberAccess implements MemberAccess {
public boolean allowPrivateAccess = false;
public boolean allowProtectedAccess = false;
public boolean allowPackageProtectedAccess = false;
public DefaultMemberAccess(boolean allowAllAccess) {
this(allowAllAccess, allowAllAccess, allowAllAccess);
}
public DefaultMemberAccess(boolean allowPrivateAccess, boolean allowProtectedAccess, boolean allowPackageProtectedAccess) {
super();
this.allowPrivateAccess = allowPrivateAccess;
this.allowProtectedAccess = allowProtectedAccess;
this.allowPackageProtectedAccess = allowPackageProtectedAccess;
}
public boolean getAllowPrivateAccess() {
return allowPrivateAccess;
}
public void setAllowPrivateAccess(boolean value) {
allowPrivateAccess = value;
}
public boolean getAllowProtectedAccess() {
return allowProtectedAccess;
}
public void setAllowProtectedAccess(boolean value) {
allowProtectedAccess = value;
}
public boolean getAllowPackageProtectedAccess() {
return allowPackageProtectedAccess;
}
public void setAllowPackageProtectedAccess(boolean value) {
allowPackageProtectedAccess = value;
}
@Override
public Object setup(Map context, Object target, Member member, String propertyName) {
Object result = null;
if (isAccessible(context, target, member, propertyName)) {
AccessibleObject accessible = (AccessibleObject) member;
if (!accessible.isAccessible()) {
result = Boolean.TRUE;
accessible.setAccessible(true);
}
}
return result;
}
@Override
public void restore(Map context, Object target, Member member, String propertyName, Object state) {
if (state != null) {
((AccessibleObject)member).setAccessible((Boolean)state);
}
}
/**
* Returns true if the given member is accessible or can be made accessible
* by this object.
*
* @param context the current execution context (not used).
* @param target the Object to test accessibility for (not used).
* @param member the Member to test accessibility for.
* @param propertyName the property to test accessibility for (not used).
* @return true if the member is accessible in the context, false otherwise.
*/
@Override
public boolean isAccessible(Map context, Object target, Member member, String propertyName) {
int modifiers = member.getModifiers();
boolean result = Modifier.isPublic(modifiers);
if (!result) {
if (Modifier.isPrivate(modifiers)) {
result = getAllowPrivateAccess();
} else {
if (Modifier.isProtected(modifiers)) {
result = getAllowProtectedAccess();
} else {
result = getAllowPackageProtectedAccess();
}
}
}
return result;
}
} | java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/express/ClassLoaderClassResolver.java | core/src/main/java/com/taobao/arthas/core/command/express/ClassLoaderClassResolver.java | package com.taobao.arthas.core.command.express;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import ognl.ClassResolver;
/**
* @author hengyunabc 2018-10-18
* @see ognl.DefaultClassResolver
*/
public class ClassLoaderClassResolver implements ClassResolver {
private ClassLoader classLoader;
private Map<String, Class<?>> classes = new ConcurrentHashMap<String, Class<?>>(101);
public ClassLoaderClassResolver(ClassLoader classLoader) {
this.classLoader = classLoader;
}
@Override
public Class classForName(String className, Map context) throws ClassNotFoundException {
Class<?> result = null;
if ((result = classes.get(className)) == null) {
try {
result = classLoader.loadClass(className);
} catch (ClassNotFoundException ex) {
if (className.indexOf('.') == -1) {
result = Class.forName("java.lang." + className);
classes.put("java.lang." + className, result);
}
}
if (result == null) {
return null;
}
classes.put(className, result);
}
return result;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/express/Express.java | core/src/main/java/com/taobao/arthas/core/command/express/Express.java | package com.taobao.arthas.core.command.express;
/**
* 表达式
* Created by vlinux on 15/5/20.
*/
public interface Express {
/**
* 根据表达式获取值
*
* @param express 表达式
* @return 表达式运算后的值
* @throws ExpressException 表达式运算出错
*/
Object get(String express) throws ExpressException;
/**
* 根据表达式判断是与否
*
* @param express 表达式
* @return 表达式运算后的布尔值
* @throws ExpressException 表达式运算出错
*/
boolean is(String express) throws ExpressException;
/**
* 绑定对象
*
* @param object 待绑定对象
* @return this
*/
Express bind(Object object);
/**
* 绑定变量
*
* @param name 变量名
* @param value 变量值
* @return this
*/
Express bind(String name, Object value);
/**
* 重置整个表达式
*
* @return this
*/
Express reset();
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/command/express/ArthasObjectPropertyAccessor.java | core/src/main/java/com/taobao/arthas/core/command/express/ArthasObjectPropertyAccessor.java | package com.taobao.arthas.core.command.express;
import java.util.Map;
import com.taobao.arthas.core.GlobalOptions;
import ognl.ObjectPropertyAccessor;
import ognl.OgnlException;
/**
* @author hengyunabc 2022-03-24
*/
public class ArthasObjectPropertyAccessor extends ObjectPropertyAccessor {
@Override
public Object setPossibleProperty(Map context, Object target, String name, Object value) throws OgnlException {
if (GlobalOptions.strict) {
throw new IllegalAccessError(GlobalOptions.STRICT_MESSAGE);
}
return super.setPossibleProperty(context, target, name, value);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/distribution/ResultConsumerHelper.java | core/src/main/java/com/taobao/arthas/core/distribution/ResultConsumerHelper.java | package com.taobao.arthas.core.distribution;
import com.alibaba.fastjson2.JSON;
import com.taobao.arthas.core.command.model.Countable;
import com.taobao.arthas.core.command.model.ResultModel;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
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.concurrent.ConcurrentHashMap;
/**
* 命令结果模型辅助类
*
* @author gongdewei 2020/5/18
*/
public class ResultConsumerHelper {
private static final Logger logger = LoggerFactory.getLogger(ResultConsumerHelper.class);
private static ConcurrentHashMap<String, List<Field>> modelFieldMap = new ConcurrentHashMap<String, List<Field>>();
/**
* 估算命令执行结果的item数量，目的是提供一个度量值，作为Consumer分发时进行切片的参考依据，避免单次发送大量数据。
* 注意：此方法调用频繁，避免产生内存碎片
*
* @param model
* @return
*/
public static int getItemCount(ResultModel model) {
//如果实现Countable接口，则认为model自己统计元素数量
if (model instanceof Countable) {
return ((Countable) model).size();
}
//对于普通的Model，通过类反射统计容器类字段统计元素数量
//缓存Field对象，避免产生内存碎片
Class modelClass = model.getClass();
List<Field> fields = modelFieldMap.get(modelClass.getName());
if (fields == null) {
fields = new ArrayList<Field>();
Field[] declaredFields = modelClass.getDeclaredFields();
for (int i = 0; i < declaredFields.length; i++) {
Field field = declaredFields[i];
Class<?> fieldClass = field.getType();
//如果是List/Map/Array/Countable类型的字段，则缓存起来后面统计数量
if (Collection.class.isAssignableFrom(fieldClass)
|| Map.class.isAssignableFrom(fieldClass)
|| Countable.class.isAssignableFrom(fieldClass)
|| fieldClass.isArray()) {
field.setAccessible(true);
fields.add(field);
}
}
List<Field> old_fields = modelFieldMap.putIfAbsent(modelClass.getName(), fields);
if (old_fields != null) {
fields = old_fields;
}
}
//统计Model对象的item数量
int count = 0;
try {
for (int i = 0; i < fields.size(); i++) {
Field field = fields.get(i);
if (!field.isAccessible()) {
field.setAccessible(true);
}
Object value = field.get(model);
if (value != null) {
if (value instanceof Collection) {
count += ((Collection) value).size();
} else if (value.getClass().isArray()) {
count += Array.getLength(value);
} else if (value instanceof Map) {
count += ((Map) value).size();
} else if (value instanceof Countable) {
count += ((Countable) value).size();
}
}
}
} catch (Exception e) {
logger.error("get item count of result model failed, model: {}", JSON.toJSONString(model), e);
}
return count > 0 ? count : 1;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/distribution/CompositeResultDistributor.java | core/src/main/java/com/taobao/arthas/core/distribution/CompositeResultDistributor.java | package com.taobao.arthas.core.distribution;
/**
* 复合结果分发器，将消息同时分发给其包含的多个真实分发器
* @author gongdewei 2020/4/30
*/
public interface CompositeResultDistributor extends ResultDistributor {
void addDistributor(ResultDistributor distributor);
void removeDistributor(ResultDistributor distributor);
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/distribution/DistributorOptions.java | core/src/main/java/com/taobao/arthas/core/distribution/DistributorOptions.java | package com.taobao.arthas.core.distribution;
/**
* 命令结果分发器选项
* @author gongdewei 2020/5/18
*/
public class DistributorOptions {
/**
* ResultConsumer的结果队列长度，用于控制内存缓存的命令结果数据量
*/
public static int resultQueueSize = 50;
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/distribution/ResultConsumer.java | core/src/main/java/com/taobao/arthas/core/distribution/ResultConsumer.java | package com.taobao.arthas.core.distribution;
import com.taobao.arthas.core.command.model.ResultModel;
import java.util.List;
/**
* Command result consumer
* @author gongdewei 2020-03-26
*/
public interface ResultConsumer {
/**
* Append the phased result to queue
* @param result a phased result of the command
* @return true means distribution success, return false means discard data
*/
boolean appendResult(ResultModel result);
/**
* Retrieves and removes a pack of results from the head
* @return a pack of results
*/
List<ResultModel> pollResults();
long getLastAccessTime();
void close();
boolean isClosed();
boolean isPolling();
String getConsumerId();
void setConsumerId(String consumerId);
/**
* Retrieves the consumer's health status
* @return
*/
boolean isHealthy();
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/distribution/PackingResultDistributor.java | core/src/main/java/com/taobao/arthas/core/distribution/PackingResultDistributor.java | package com.taobao.arthas.core.distribution;
import com.taobao.arthas.core.command.model.ResultModel;
import java.util.List;
public interface PackingResultDistributor extends ResultDistributor {
/**
* Get results of command
*/
List<ResultModel> getResults();
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/distribution/ResultDistributor.java | core/src/main/java/com/taobao/arthas/core/distribution/ResultDistributor.java | package com.taobao.arthas.core.distribution;
import com.taobao.arthas.core.command.model.ResultModel;
/**
* Command result distributor, sending results to consumers who joins in the same session.
* @author gongdewei 2020-03-26
*/
public interface ResultDistributor {
/**
* Append the phased result to queue
* @param result a phased result of the command
*/
void appendResult(ResultModel result);
/**
* Close result distribtor, release resources
*/
void close();
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/distribution/SharingResultDistributor.java | core/src/main/java/com/taobao/arthas/core/distribution/SharingResultDistributor.java | package com.taobao.arthas.core.distribution;
import java.util.List;
public interface SharingResultDistributor extends ResultDistributor {
/**
* Add consumer to sharing session
* @param consumer
*/
void addConsumer(ResultConsumer consumer);
/**
* Remove consumer from sharing session
* @param consumer
*/
void removeConsumer(ResultConsumer consumer);
/**
* Get all consumers of session
* @return
*/
List<ResultConsumer> getConsumers();
/**
* Get consumer by id
* @param consumerId
* @return
*/
ResultConsumer getConsumer(String consumerId);
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/distribution/impl/SharingResultDistributorImpl.java | core/src/main/java/com/taobao/arthas/core/distribution/impl/SharingResultDistributorImpl.java | package com.taobao.arthas.core.distribution.impl;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.command.model.InputStatusModel;
import com.taobao.arthas.core.command.model.MessageModel;
import com.taobao.arthas.core.command.model.ResultModel;
import com.taobao.arthas.core.distribution.DistributorOptions;
import com.taobao.arthas.core.distribution.ResultConsumer;
import com.taobao.arthas.core.distribution.SharingResultDistributor;
import com.taobao.arthas.core.shell.session.Session;
import com.taobao.arthas.core.shell.system.Job;
import java.util.List;
import java.util.UUID;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.locks.ReentrantLock;
public class SharingResultDistributorImpl implements SharingResultDistributor {
private static final Logger logger = LoggerFactory.getLogger(SharingResultDistributorImpl.class);
private List<ResultConsumer> consumers = new CopyOnWriteArrayList<ResultConsumer>();
private BlockingQueue<ResultModel> pendingResultQueue = new ArrayBlockingQueue<ResultModel>(10);
private final Session session;
private Thread distributorThread;
private volatile boolean running;
private AtomicInteger consumerNumGenerator = new AtomicInteger(0);
private SharingResultConsumerImpl sharingResultConsumer = new SharingResultConsumerImpl();
// 标记是否已经因为不健康而中断过，避免重复中断导致死循环
private volatile boolean interruptedForUnhealthy = false;
public SharingResultDistributorImpl(Session session) {
this.session = session;
this.running = true;
distributorThread = new Thread(new DistributorTask(), "ResultDistributor");
distributorThread.setDaemon(true); // 设置为守护线程，避免阻止 JVM 退出
distributorThread.start();
}
@Override
public void appendResult(ResultModel result) {
//要避免阻塞影响业务线程执行
try {
if (!pendingResultQueue.offer(result, 100, TimeUnit.MILLISECONDS)) {
ResultModel discardResult = pendingResultQueue.poll();
// 正常情况走不到这里，除非distribute 循环堵塞或异常终止
// 输出队列满，终止当前执行的命令
interruptJob("result queue is full: "+ pendingResultQueue.size());
}
} catch (InterruptedException e) {
//ignore
}
}
private void interruptJob(String message) {
Job job = session.getForegroundJob();
if (job != null) {
logger.warn(message+", current job was interrupted.", job.id());
job.interrupt();
pendingResultQueue.offer(new MessageModel(message+", current job was interrupted."));
}
}
private void distribute() {
while (running) {
try {
ResultModel result = pendingResultQueue.poll(100, TimeUnit.MILLISECONDS);
if (result != null) {
sharingResultConsumer.appendResult(result);
// 如果没有 consumer，跳过健康检查
if (consumers.isEmpty()) {
continue;
}
//判断是否有至少一个consumer是健康的
int healthCount = 0;
for (int i = 0; i < consumers.size(); i++) {
ResultConsumer consumer = consumers.get(i);
if(consumer.isHealthy()){
healthCount += 1;
}
consumer.appendResult(result);
}
//所有consumer都不是健康状态，终止当前执行的命令
//使用标志位避免重复中断导致死循环
if (healthCount == 0 && !interruptedForUnhealthy) {
interruptedForUnhealthy = true;
interruptJob("all consumers are unhealthy");
}
} else {
// 队列为空时，检查是否有健康的consumer，如果有则重置标志位
if (interruptedForUnhealthy) {
for (int i = 0; i < consumers.size(); i++) {
if (consumers.get(i).isHealthy()) {
interruptedForUnhealthy = false;
break;
}
}
}
}
} catch (InterruptedException e) {
// 线程被中断，正常退出
Thread.currentThread().interrupt();
break;
} catch (Throwable e) {
logger.warn("distribute result failed: " + e.getMessage(), e);
}
}
logger.debug("ResultDistributor thread exited");
}
@Override
public void close() {
this.running = false;
// 中断线程，使其尽快退出 poll 阻塞
if (distributorThread != null) {
distributorThread.interrupt();
}
// 清理 consumers
for (ResultConsumer consumer : consumers) {
try {
consumer.close();
} catch (Exception e) {
logger.warn("close consumer failed: " + e.getMessage(), e);
}
}
consumers.clear();
// 清空待处理队列
pendingResultQueue.clear();
}
@Override
public void addConsumer(ResultConsumer consumer) {
int consumerNo = consumerNumGenerator.incrementAndGet();
String consumerId = UUID.randomUUID().toString().replaceAll("-", "") + "_" + consumerNo;
consumer.setConsumerId(consumerId);
//将队列中的消息复制给新的消费者
sharingResultConsumer.copyTo(consumer);
consumers.add(consumer);
}
@Override
public void removeConsumer(ResultConsumer consumer) {
consumers.remove(consumer);
consumer.close();
}
@Override
public List<ResultConsumer> getConsumers() {
return consumers;
}
@Override
public ResultConsumer getConsumer(String consumerId) {
for (int i = 0; i < consumers.size(); i++) {
ResultConsumer consumer = consumers.get(i);
if (consumer.getConsumerId().equals(consumerId)) {
return consumer;
}
}
return null;
}
private class DistributorTask implements Runnable {
@Override
public void run() {
distribute();
}
}
private static class SharingResultConsumerImpl implements ResultConsumer {
private BlockingQueue<ResultModel> resultQueue = new ArrayBlockingQueue<ResultModel>(DistributorOptions.resultQueueSize);
private ReentrantLock queueLock = new ReentrantLock();
private InputStatusModel lastInputStatus;
@Override
public boolean appendResult(ResultModel result) {
queueLock.lock();
try {
//输入状态不入历史指令队列，复制时在最后发送
if (result instanceof InputStatusModel) {
lastInputStatus = (InputStatusModel) result;
return true;
}
while (!resultQueue.offer(result)) {
ResultModel discardResult = resultQueue.poll();
}
} finally {
if (queueLock.isHeldByCurrentThread()) {
queueLock.unlock();
}
}
return true;
}
public void copyTo(ResultConsumer consumer) {
//复制时加锁，避免消息顺序错乱，这里堵塞只影响分发线程，不会影响到业务线程
queueLock.lock();
try {
for (ResultModel result : resultQueue) {
consumer.appendResult(result);
}
//发送输入状态
if (lastInputStatus != null) {
consumer.appendResult(lastInputStatus);
}
} finally {
if (queueLock.isHeldByCurrentThread()) {
queueLock.unlock();
}
}
}
@Override
public List<ResultModel> pollResults() {
return null;
}
@Override
public long getLastAccessTime() {
return 0;
}
@Override
public void close() {
}
@Override
public boolean isClosed() {
return false;
}
@Override
public boolean isPolling() {
return false;
}
@Override
public String getConsumerId() {
return "shared-consumer";
}
@Override
public void setConsumerId(String consumerId) {
}
@Override
public boolean isHealthy() {
return true;
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/distribution/impl/PackingResultDistributorImpl.java | core/src/main/java/com/taobao/arthas/core/distribution/impl/PackingResultDistributorImpl.java | package com.taobao.arthas.core.distribution.impl;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.alibaba.fastjson2.JSON;
import com.taobao.arthas.core.command.model.ResultModel;
import com.taobao.arthas.core.distribution.PackingResultDistributor;
import com.taobao.arthas.core.shell.session.Session;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
public class PackingResultDistributorImpl implements PackingResultDistributor {
private static final Logger logger = LoggerFactory.getLogger(PackingResultDistributorImpl.class);
private BlockingQueue<ResultModel> resultQueue = new ArrayBlockingQueue<ResultModel>(500);
private final Session session;
public PackingResultDistributorImpl(Session session) {
this.session = session;
}
@Override
public void appendResult(ResultModel result) {
if (!resultQueue.offer(result)) {
logger.warn("result queue is full: {}, discard later result: {}", resultQueue.size(), JSON.toJSONString(result));
}
}
@Override
public void close() {
}
@Override
public List<ResultModel> getResults() {
ArrayList<ResultModel> results = new ArrayList<ResultModel>(resultQueue.size());
resultQueue.drainTo(results);
return results;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/distribution/impl/TermResultDistributorImpl.java | core/src/main/java/com/taobao/arthas/core/distribution/impl/TermResultDistributorImpl.java | package com.taobao.arthas.core.distribution.impl;
import com.taobao.arthas.core.command.model.ResultModel;
import com.taobao.arthas.core.command.view.ResultView;
import com.taobao.arthas.core.command.view.ResultViewResolver;
import com.taobao.arthas.core.distribution.ResultDistributor;
import com.taobao.arthas.core.shell.command.CommandProcess;
/**
* Term/Tty Result Distributor
*
* @author gongdewei 2020-03-26
*/
public class TermResultDistributorImpl implements ResultDistributor {
private final CommandProcess commandProcess;
private final ResultViewResolver resultViewResolver;
public TermResultDistributorImpl(CommandProcess commandProcess, ResultViewResolver resultViewResolver) {
this.commandProcess = commandProcess;
this.resultViewResolver = resultViewResolver;
}
@Override
public void appendResult(ResultModel model) {
ResultView resultView = resultViewResolver.getResultView(model);
if (resultView != null) {
resultView.draw(commandProcess, 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/core/src/main/java/com/taobao/arthas/core/distribution/impl/CompositeResultDistributorImpl.java | core/src/main/java/com/taobao/arthas/core/distribution/impl/CompositeResultDistributorImpl.java | package com.taobao.arthas.core.distribution.impl;
import com.taobao.arthas.core.command.model.ResultModel;
import com.taobao.arthas.core.distribution.CompositeResultDistributor;
import com.taobao.arthas.core.distribution.ResultDistributor;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
/**
* 复合结果分发器，将消息同时分发给其包含的真实分发器
*
* @author gongdewei 2020/4/30
*/
public class CompositeResultDistributorImpl implements CompositeResultDistributor {
private List<ResultDistributor> distributors = Collections.synchronizedList(new ArrayList<ResultDistributor>());
public CompositeResultDistributorImpl() {
}
public CompositeResultDistributorImpl(ResultDistributor ... distributors) {
for (ResultDistributor distributor : distributors) {
this.addDistributor(distributor);
}
}
@Override
public void addDistributor(ResultDistributor distributor) {
distributors.add(distributor);
}
@Override
public void removeDistributor(ResultDistributor distributor) {
distributors.remove(distributor);
}
@Override
public void appendResult(ResultModel result) {
for (ResultDistributor distributor : distributors) {
distributor.appendResult(result);
}
}
@Override
public void close() {
for (ResultDistributor distributor : distributors) {
distributor.close();
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/distribution/impl/ResultConsumerImpl.java | core/src/main/java/com/taobao/arthas/core/distribution/impl/ResultConsumerImpl.java | package com.taobao.arthas.core.distribution.impl;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.alibaba.fastjson2.JSON;
import com.taobao.arthas.core.command.model.ResultModel;
import com.taobao.arthas.core.distribution.DistributorOptions;
import com.taobao.arthas.core.distribution.ResultConsumer;
import com.taobao.arthas.core.distribution.ResultConsumerHelper;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.locks.ReentrantLock;
/**
* @author gongdewei 2020/3/27
*/
public class ResultConsumerImpl implements ResultConsumer {
private static final Logger logger = LoggerFactory.getLogger(ResultConsumerImpl.class);
private BlockingQueue<ResultModel> resultQueue;
private volatile long lastAccessTime;
private volatile boolean polling;
private ReentrantLock lock = new ReentrantLock();
private int resultBatchSizeLimit = 20;
private int resultQueueSize = DistributorOptions.resultQueueSize;
private long pollTimeLimit = 2 * 1000;
private String consumerId;
private boolean closed;
private long sendingItemCount;
public ResultConsumerImpl() {
lastAccessTime = System.currentTimeMillis();
resultQueue = new ArrayBlockingQueue<ResultModel>(resultQueueSize);
}
@Override
public boolean appendResult(ResultModel result) {
//可能某些Consumer已经断开，不会再读取，这里不能堵塞！
boolean discard = false;
while (!resultQueue.offer(result)) {
ResultModel discardResult = resultQueue.poll();
discard = true;
}
return !discard;
}
@Override
public List<ResultModel> pollResults() {
try {
lastAccessTime = System.currentTimeMillis();
long accessTime = lastAccessTime;
if (lock.tryLock(500, TimeUnit.MILLISECONDS)) {
polling = true;
sendingItemCount = 0;
long firstResultTime = 0;
// sending delay: time elapsed after firstResultTime
long sendingDelay = 0;
// waiting time: time elapsed after access
long waitingTime = 0;
List<ResultModel> sendingResults = new ArrayList<ResultModel>(resultBatchSizeLimit);
while (!closed
&&sendingResults.size() < resultBatchSizeLimit
&& sendingDelay < 100
&& waitingTime < pollTimeLimit) {
ResultModel aResult = resultQueue.poll(100, TimeUnit.MILLISECONDS);
if (aResult != null) {
sendingResults.add(aResult);
//是否为第一次获取到数据
if (firstResultTime == 0) {
firstResultTime = System.currentTimeMillis();
}
//判断是否需要立即发送出去
if (shouldFlush(sendingResults, aResult)) {
break;
}
} else {
if (firstResultTime > 0) {
//获取到部分数据后，队列已经取完，计算发送延时时间
sendingDelay = System.currentTimeMillis() - firstResultTime;
}
//计算总共等待时间，长轮询最大等待时间
waitingTime = System.currentTimeMillis() - accessTime;
}
}
//resultQueue.drainTo(sendingResults, resultSizeLimit-sendingResults.size());
if(logger.isDebugEnabled()) {
logger.debug("pollResults: {}, results: {}", sendingResults.size(), JSON.toJSONString(sendingResults));
}
return sendingResults;
}
} catch (InterruptedException e) {
//e.printStackTrace();
} finally {
if (lock.isHeldByCurrentThread()) {
lastAccessTime = System.currentTimeMillis();
polling = false;
lock.unlock();
}
}
return Collections.emptyList();
}
/**
* 估算对象数量及大小，判断是否需要立即发送出去
* @param sendingResults
* @param last
* @return
*/
private boolean shouldFlush(List<ResultModel> sendingResults, ResultModel last) {
//TODO 引入一个估算模型，每个model自统计对象数量
sendingItemCount += ResultConsumerHelper.getItemCount(last);
return sendingItemCount >= 100;
}
@Override
public boolean isHealthy() {
return isPolling()
|| resultQueue.size() < resultQueueSize
|| System.currentTimeMillis() - lastAccessTime < 1000;
}
@Override
public long getLastAccessTime() {
return lastAccessTime;
}
@Override
public void close(){
this.closed = true;
}
@Override
public boolean isClosed() {
return closed;
}
@Override
public boolean isPolling() {
return polling;
}
public int getResultBatchSizeLimit() {
return resultBatchSizeLimit;
}
public void setResultBatchSizeLimit(int resultBatchSizeLimit) {
this.resultBatchSizeLimit = resultBatchSizeLimit;
}
@Override
public String getConsumerId() {
return consumerId;
}
@Override
public void setConsumerId(String consumerId) {
this.consumerId = consumerId;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/view/ClassInfoView.java | core/src/main/java/com/taobao/arthas/core/view/ClassInfoView.java | package com.taobao.arthas.core.view;
import com.taobao.arthas.core.util.Constants;
import com.taobao.arthas.core.util.StringUtils;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.security.CodeSource;
/**
* Java类信息控件
* Created by vlinux on 15/5/7.
*/
public class ClassInfoView implements View {
private final Class<?> clazz;
private final boolean isPrintField;
private final int width;
public ClassInfoView(Class<?> clazz, boolean isPrintField, int width) {
this.clazz = clazz;
this.isPrintField = isPrintField;
this.width = width;
}
@Override
public String draw() {
return drawClassInfo();
}
private String getCodeSource(final CodeSource cs) {
if (null == cs
|| null == cs.getLocation()
|| null == cs.getLocation().getFile()) {
return Constants.EMPTY_STRING;
}
return cs.getLocation().getFile();
}
private String drawClassInfo() {
final CodeSource cs = clazz.getProtectionDomain().getCodeSource();
final TableView view = new TableView(new TableView.ColumnDefine[]{
new TableView.ColumnDefine("isAnonymousClass".length(), false, TableView.Align.RIGHT),
// (列数-1) * 3 + 4 = 7
new TableView.ColumnDefine(width - "isAnonymousClass".length() - 7, false, TableView.Align.LEFT)
})
.addRow("class-info", StringUtils.classname(clazz))
.addRow("code-source", getCodeSource(cs))
.addRow("name", StringUtils.classname(clazz))
.addRow("isInterface", clazz.isInterface())
.addRow("isAnnotation", clazz.isAnnotation())
.addRow("isEnum", clazz.isEnum())
.addRow("isAnonymousClass", clazz.isAnonymousClass())
.addRow("isArray", clazz.isArray())
.addRow("isLocalClass", clazz.isLocalClass())
.addRow("isMemberClass", clazz.isMemberClass())
.addRow("isPrimitive", clazz.isPrimitive())
.addRow("isSynthetic", clazz.isSynthetic())
.addRow("simple-name", clazz.getSimpleName())
.addRow("modifier", StringUtils.modifier(clazz.getModifiers(), ','))
.addRow("annotation", drawAnnotation())
.addRow("interfaces", drawInterface())
.addRow("super-class", drawSuperClass())
.addRow("class-loader", drawClassLoader());
if (isPrintField) {
view.addRow("fields", drawField());
}
return view.hasBorder(true).padding(1).draw();
}
private String drawField() {
final StringBuilder fieldSB = new StringBuilder();
final Field[] fields = clazz.getDeclaredFields();
if (fields.length > 0) {
for (Field field : fields) {
final KVView kvView = new KVView(new TableView.ColumnDefine(TableView.Align.RIGHT), new TableView.ColumnDefine(50, false, TableView.Align.LEFT))
.add("modifier", StringUtils.modifier(field.getModifiers(), ','))
.add("type", StringUtils.classname(field.getType()))
.add("name", field.getName());
final StringBuilder annotationSB = new StringBuilder();
final Annotation[] annotationArray = field.getAnnotations();
if (null != annotationArray && annotationArray.length > 0) {
for (Annotation annotation : annotationArray) {
annotationSB.append(StringUtils.classname(annotation.annotationType())).append(",");
}
if (annotationSB.length() > 0) {
annotationSB.deleteCharAt(annotationSB.length() - 1);
}
kvView.add("annotation", annotationSB);
}
if (Modifier.isStatic(field.getModifiers())) {
final boolean isAccessible = field.isAccessible();
try {
field.setAccessible(true);
kvView.add("value", StringUtils.objectToString(field.get(null)));
} catch (IllegalAccessException e) {
//
} finally {
field.setAccessible(isAccessible);
}
}//if
fieldSB.append(kvView.draw()).append("\n");
}//for
}
return fieldSB.toString();
}
private String drawAnnotation() {
final StringBuilder annotationSB = new StringBuilder();
final Annotation[] annotationArray = clazz.getDeclaredAnnotations();
if (annotationArray.length > 0) {
for (Annotation annotation : annotationArray) {
annotationSB.append(StringUtils.classname(annotation.annotationType())).append(",");
}
if (annotationSB.length() > 0) {
annotationSB.deleteCharAt(annotationSB.length() - 1);
}
} else {
annotationSB.append(Constants.EMPTY_STRING);
}
return annotationSB.toString();
}
private String drawInterface() {
final StringBuilder interfaceSB = new StringBuilder();
final Class<?>[] interfaceArray = clazz.getInterfaces();
if (interfaceArray.length == 0) {
interfaceSB.append(Constants.EMPTY_STRING);
} else {
for (Class<?> i : interfaceArray) {
interfaceSB.append(i.getName()).append(",");
}
if (interfaceSB.length() > 0) {
interfaceSB.deleteCharAt(interfaceSB.length() - 1);
}
}
return interfaceSB.toString();
}
private String drawSuperClass() {
final LadderView ladderView = new LadderView();
Class<?> superClass = clazz.getSuperclass();
if (null != superClass) {
ladderView.addItem(StringUtils.classname(superClass));
while (true) {
superClass = superClass.getSuperclass();
if (null == superClass) {
break;
}
ladderView.addItem(StringUtils.classname(superClass));
}//while
}
return ladderView.draw();
}
private String drawClassLoader() {
final LadderView ladderView = new LadderView();
ClassLoader loader = clazz.getClassLoader();
if (null != loader) {
ladderView.addItem(loader.toString());
while (true) {
loader = loader.getParent();
if (null == loader) {
break;
}
ladderView.addItem(loader.toString());
}
}
return ladderView.draw();
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/view/TableView.java | core/src/main/java/com/taobao/arthas/core/view/TableView.java | package com.taobao.arthas.core.view;
import com.taobao.arthas.core.util.Constants;
import com.taobao.arthas.core.util.StringUtils;
import java.io.StringReader;
import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import static java.lang.Math.abs;
import static java.lang.Math.max;
import static java.lang.String.format;
/**
* 表格控件
* Created by vlinux on 15/5/7.
*/
public class TableView implements View {
/**
* 上边框
*/
public static final int BORDER_TOP = 1;
/**
* 下边框
*/
public static final int BORDER_BOTTOM = 1 << 1;
// 各个列的定义
private final ColumnDefine[] columnDefineArray;
// 是否渲染边框
private boolean hasBorder;
// 边框
private int borders = BORDER_TOP | BORDER_BOTTOM;
// 内填充
private int padding;
public TableView(ColumnDefine[] columnDefineArray) {
this.columnDefineArray = null == columnDefineArray
? new ColumnDefine[0]
: columnDefineArray;
}
public TableView(int columnNum) {
this.columnDefineArray = new ColumnDefine[columnNum];
for (int index = 0; index < this.columnDefineArray.length; index++) {
columnDefineArray[index] = new ColumnDefine();
}
}
private boolean isAnyBorder(int... borders) {
if (null == borders) {
return false;
}
for (int b : borders) {
if ((this.borders & b) == b) {
return true;
}
}
return false;
}
/**
* 获取表格边框设置
*
* @return 边框位
*/
public int borders() {
return borders;
}
/**
* 设置表格边框
*
* @param border 边框位
* @return this
*/
public TableView borders(int border) {
this.borders = border;
return this;
}
@Override
public String draw() {
final StringBuilder tableSB = new StringBuilder();
// init width cache
final int[] widthCacheArray = new int[getColumnCount()];
for (int index = 0; index < widthCacheArray.length; index++) {
widthCacheArray[index] = abs(columnDefineArray[index].getWidth());
}
final int tableHigh = getTableHigh();
for (int rowIndex = 0; rowIndex < tableHigh; rowIndex++) {
final boolean isFirstRow = rowIndex == 0;
final boolean isLastRow = rowIndex == tableHigh - 1;
// 打印首分隔行
if (isFirstRow
&& hasBorder()
&& isAnyBorder(BORDER_TOP)) {
tableSB.append(drawSeparationLine(widthCacheArray)).append("\n");
}
// 打印内部分割行
if (!isFirstRow
&& hasBorder()) {
tableSB.append(drawSeparationLine(widthCacheArray)).append("\n");
}
// 绘一行
tableSB.append(drawRow(widthCacheArray, rowIndex));
// 打印结尾分隔行
if (isLastRow
&& hasBorder()
&& isAnyBorder(BORDER_BOTTOM)) {
// 打印分割行
tableSB.append(drawSeparationLine(widthCacheArray)).append("\n");
}
}
return tableSB.toString();
}
private String drawRow(int[] widthCacheArray, int rowIndex) {
final StringBuilder rowSB = new StringBuilder();
final Scanner[] scannerArray = new Scanner[getColumnCount()];
try {
boolean hasNext;
do {
hasNext = false;
final StringBuilder segmentSB = new StringBuilder();
for (int colIndex = 0; colIndex < getColumnCount(); colIndex++) {
final String borderChar = hasBorder() ? "|" : Constants.EMPTY_STRING;
final int width = widthCacheArray[colIndex];
final boolean isLastColOfRow = colIndex == widthCacheArray.length - 1;
if (null == scannerArray[colIndex]) {
scannerArray[colIndex] = new Scanner(
new StringReader(StringUtils.wrap(getData(rowIndex, columnDefineArray[colIndex]), width)));
}
final Scanner scanner = scannerArray[colIndex];
final String data;
if (scanner.hasNext()) {
data = scanner.nextLine();
hasNext = true;
} else {
data = Constants.EMPTY_STRING;
}
if (width > 0) {
final ColumnDefine columnDefine = columnDefineArray[colIndex];
final String dataFormat = getDataFormat(columnDefine, width);
final String paddingChar = StringUtils.repeat(" ", padding);
segmentSB.append(format(borderChar + paddingChar + dataFormat + paddingChar, data));
}
if (isLastColOfRow) {
segmentSB.append(borderChar).append("\n");
}
}
if (hasNext) {
rowSB.append(segmentSB);
}
} while (hasNext);
return rowSB.toString();
} finally {
for (Scanner scanner : scannerArray) {
if (null != scanner) {
scanner.close();
}
}
}
}
private String getData(int rowIndex, ColumnDefine columnDefine) {
return columnDefine.getHigh() <= rowIndex
? Constants.EMPTY_STRING
: columnDefine.dataList.get(rowIndex);
}
private String getDataFormat(ColumnDefine columnDefine, int width) {
switch (columnDefine.align) {
case RIGHT: {
return "%" + width + "s";
}
case LEFT:
default: {
return "%-" + width + "s";
}
}
}
/*
* 获取表格高度
*/
private int getTableHigh() {
int tableHigh = 0;
for (ColumnDefine columnDefine : columnDefineArray) {
tableHigh = max(tableHigh, columnDefine.getHigh());
}
return tableHigh;
}
/*
* 打印分隔行
*/
private String drawSeparationLine(int[] widthCacheArray) {
final StringBuilder separationLineSB = new StringBuilder();
for (int width : widthCacheArray) {
if (width > 0) {
separationLineSB.append("+").append(StringUtils.repeat("-", width + 2 * padding));
}
}
return separationLineSB
.append("+")
.toString();
}
/**
* 添加数据行
*
* @param columnDataArray 数据数组
*/
public TableView addRow(Object... columnDataArray) {
if (null == columnDataArray) {
return this;
}
for (int index = 0; index < columnDefineArray.length; index++) {
final ColumnDefine columnDefine = columnDefineArray[index];
if (index < columnDataArray.length
&& null != columnDataArray[index]) {
columnDefine.dataList.add(StringUtils.replace(columnDataArray[index].toString(), "\t", " "));
} else {
columnDefine.dataList.add(Constants.EMPTY_STRING);
}
}
return this;
}
/**
* 对齐方向
*/
public enum Align {
LEFT,
RIGHT
}
/**
* 列定义
*/
public static class ColumnDefine {
private final int width;
private final boolean isAutoResize;
private final Align align;
private final List<String> dataList = new ArrayList<String>();
public ColumnDefine(int width, boolean isAutoResize, Align align) {
this.width = width;
this.isAutoResize = isAutoResize;
this.align = align;
}
public ColumnDefine(Align align) {
this(0, true, align);
}
public ColumnDefine() {
this(Align.LEFT);
}
/**
* 获取当前列的宽度
*
* @return 宽度
*/
public int getWidth() {
if (!isAutoResize) {
return width;
}
int maxWidth = 0;
for (String data : dataList) {
final Scanner scanner = new Scanner(new StringReader(data));
try {
while (scanner.hasNext()) {
maxWidth = max(StringUtils.length(scanner.nextLine()), maxWidth);
}
} finally {
scanner.close();
}
}
return maxWidth;
}
/**
* 获取当前列的高度
*
* @return 高度
*/
public int getHigh() {
return dataList.size();
}
}
/**
* 设置是否画边框
*
* @param hasBorder true / false
*/
public TableView hasBorder(boolean hasBorder) {
this.hasBorder = hasBorder;
return this;
}
/**
* 是否画边框
*
* @return true / false
*/
public boolean hasBorder() {
return hasBorder;
}
/**
* 设置内边距大小
*
* @param padding 内边距
*/
public TableView padding(int padding) {
this.padding = padding;
return this;
}
/**
* 获取表格列总数
*
* @return 表格列总数
*/
public int getColumnCount() {
return columnDefineArray.length;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/view/LadderView.java | core/src/main/java/com/taobao/arthas/core/view/LadderView.java | package com.taobao.arthas.core.view;
import com.taobao.arthas.core.util.StringUtils;
import java.util.ArrayList;
import java.util.List;
/**
* 阶梯缩进控件
* Created by vlinux on 15/5/8.
*/
public class LadderView implements View {
// 分隔符
private static final String LADDER_CHAR = "`-";
// 缩进符
private static final String STEP_CHAR = " ";
// 缩进长度
private static final int INDENT_STEP = 2;
private final List<String> items = new ArrayList<String>();
@Override
public String draw() {
final StringBuilder ladderSB = new StringBuilder();
int deep = 0;
for (String item : items) {
// 第一个条目不需要分隔符
if (deep == 0) {
ladderSB
.append(item)
.append("\n");
}
// 其他的需要添加分隔符
else {
ladderSB
.append(StringUtils.repeat(STEP_CHAR, deep * INDENT_STEP))
.append(LADDER_CHAR)
.append(item)
.append("\n");
}
deep++;
}
return ladderSB.toString();
}
/**
* 添加一个项目
*
* @param item 项目
* @return this
*/
public LadderView addItem(String item) {
items.add(item);
return this;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/view/Ansi.java | core/src/main/java/com/taobao/arthas/core/view/Ansi.java | package com.taobao.arthas.core.view;
import java.util.ArrayList;
import java.util.concurrent.Callable;
/**
* Provides a fluent API for generating ANSI escape sequences.
*
* @author <a href="http://hiramchirino.com">Hiram Chirino</a>
* @since 1.0
*/
public class Ansi {
private static final char FIRST_ESC_CHAR = 27;
private static final char SECOND_ESC_CHAR = '[';
public static enum Color {
BLACK(0, "BLACK"),
RED(1, "RED"),
GREEN(2, "GREEN"),
YELLOW(3, "YELLOW"),
BLUE(4, "BLUE"),
MAGENTA(5, "MAGENTA"),
CYAN(6, "CYAN"),
WHITE(7, "WHITE"),
DEFAULT(9, "DEFAULT");
private final int value;
private final String name;
Color(int index, String name) {
this.value = index;
this.name = name;
}
@Override
public String toString() {
return name;
}
public int value() {
return value;
}
public int fg() {
return value + 30;
}
public int bg() {
return value + 40;
}
public int fgBright() {
return value + 90;
}
public int bgBright() {
return value + 100;
}
}
public static enum Attribute {
RESET(0, "RESET"),
INTENSITY_BOLD(1, "INTENSITY_BOLD"),
INTENSITY_FAINT(2, "INTENSITY_FAINT"),
ITALIC(3, "ITALIC_ON"),
UNDERLINE(4, "UNDERLINE_ON"),
BLINK_SLOW(5, "BLINK_SLOW"),
BLINK_FAST(6, "BLINK_FAST"),
NEGATIVE_ON(7, "NEGATIVE_ON"),
CONCEAL_ON(8, "CONCEAL_ON"),
STRIKETHROUGH_ON(9, "STRIKETHROUGH_ON"),
UNDERLINE_DOUBLE(21, "UNDERLINE_DOUBLE"),
INTENSITY_BOLD_OFF(22, "INTENSITY_BOLD_OFF"),
ITALIC_OFF(23, "ITALIC_OFF"),
UNDERLINE_OFF(24, "UNDERLINE_OFF"),
BLINK_OFF(25, "BLINK_OFF"),
NEGATIVE_OFF(27, "NEGATIVE_OFF"),
CONCEAL_OFF(28, "CONCEAL_OFF"),
STRIKETHROUGH_OFF(29, "STRIKETHROUGH_OFF");
private final int value;
private final String name;
Attribute(int index, String name) {
this.value = index;
this.name = name;
}
@Override
public String toString() {
return name;
}
public int value() {
return value;
}
}
public static enum Erase {
FORWARD(0, "FORWARD"),
BACKWARD(1, "BACKWARD"),
ALL(2, "ALL");
private final int value;
private final String name;
Erase(int index, String name) {
this.value = index;
this.name = name;
}
@Override
public String toString() {
return name;
}
public int value() {
return value;
}
}
public static final String DISABLE = Ansi.class.getName() + ".disable";
private static Callable<Boolean> detector = new Callable<Boolean>() {
public Boolean call() throws Exception {
return !Boolean.getBoolean(DISABLE);
}
};
public static void setDetector(final Callable<Boolean> detector) {
if (detector == null) {
throw new IllegalArgumentException();
}
Ansi.detector = detector;
}
public static boolean isDetected() {
try {
return detector.call();
} catch (Exception e) {
return true;
}
}
private static final InheritableThreadLocal<Boolean> holder = new InheritableThreadLocal<Boolean>() {
@Override
protected Boolean initialValue() {
return isDetected();
}
};
public static void setEnabled(final boolean flag) {
holder.set(flag);
}
public static boolean isEnabled() {
return holder.get();
}
public static Ansi ansi() {
if (isEnabled()) {
return new Ansi();
} else {
return new NoAnsi();
}
}
public static Ansi ansi(StringBuilder builder) {
if (isEnabled()) {
return new Ansi(builder);
} else {
return new NoAnsi(builder);
}
}
public static Ansi ansi(int size) {
if (isEnabled()) {
return new Ansi(size);
} else {
return new NoAnsi(size);
}
}
private static class NoAnsi
extends Ansi {
public NoAnsi() {
super();
}
public NoAnsi(int size) {
super(size);
}
public NoAnsi(StringBuilder builder) {
super(builder);
}
@Override
public Ansi fg(Color color) {
return this;
}
@Override
public Ansi bg(Color color) {
return this;
}
@Override
public Ansi fgBright(Color color) {
return this;
}
@Override
public Ansi bgBright(Color color) {
return this;
}
@Override
public Ansi a(Attribute attribute) {
return this;
}
@Override
public Ansi cursor(int x, int y) {
return this;
}
@Override
public Ansi cursorToColumn(int x) {
return this;
}
@Override
public Ansi cursorUp(int y) {
return this;
}
@Override
public Ansi cursorRight(int x) {
return this;
}
@Override
public Ansi cursorDown(int y) {
return this;
}
@Override
public Ansi cursorLeft(int x) {
return this;
}
@Override
public Ansi cursorDownLine() {
return this;
}
@Override
public Ansi cursorDownLine(final int n) {
return this;
}
@Override
public Ansi cursorUpLine() {
return this;
}
@Override
public Ansi cursorUpLine(final int n) {
return this;
}
@Override
public Ansi eraseScreen() {
return this;
}
@Override
public Ansi eraseScreen(Erase kind) {
return this;
}
@Override
public Ansi eraseLine() {
return this;
}
@Override
public Ansi eraseLine(Erase kind) {
return this;
}
@Override
public Ansi scrollUp(int rows) {
return this;
}
@Override
public Ansi scrollDown(int rows) {
return this;
}
@Override
public Ansi saveCursorPosition() {
return this;
}
@Override
@Deprecated
public Ansi restorCursorPosition() {
return this;
}
@Override
public Ansi restoreCursorPosition() {
return this;
}
@Override
public Ansi reset() {
return this;
}
}
private final StringBuilder builder;
private final ArrayList<Integer> attributeOptions = new ArrayList<Integer>(5);
public Ansi() {
this(new StringBuilder());
}
public Ansi(Ansi parent) {
this(new StringBuilder(parent.builder));
attributeOptions.addAll(parent.attributeOptions);
}
public Ansi(int size) {
this(new StringBuilder(size));
}
public Ansi(StringBuilder builder) {
this.builder = builder;
}
public Ansi fg(Color color) {
attributeOptions.add(color.fg());
return this;
}
public Ansi fgBlack() {
return this.fg(Color.BLACK);
}
public Ansi fgBlue() {
return this.fg(Color.BLUE);
}
public Ansi fgCyan() {
return this.fg(Color.CYAN);
}
public Ansi fgDefault() {
return this.fg(Color.DEFAULT);
}
public Ansi fgGreen() {
return this.fg(Color.GREEN);
}
public Ansi fgMagenta() {
return this.fg(Color.MAGENTA);
}
public Ansi fgRed() {
return this.fg(Color.RED);
}
public Ansi fgYellow() {
return this.fg(Color.YELLOW);
}
public Ansi bg(Color color) {
attributeOptions.add(color.bg());
return this;
}
public Ansi bgCyan() {
return this.bg(Color.CYAN);
}
public Ansi bgDefault() {
return this.bg(Color.DEFAULT);
}
public Ansi bgGreen() {
return this.bg(Color.GREEN);
}
public Ansi bgMagenta() {
return this.bg(Color.MAGENTA);
}
public Ansi bgRed() {
return this.bg(Color.RED);
}
public Ansi bgYellow() {
return this.bg(Color.YELLOW);
}
public Ansi fgBright(Color color) {
attributeOptions.add(color.fgBright());
return this;
}
public Ansi fgBrightBlack() {
return this.fgBright(Color.BLACK);
}
public Ansi fgBrightBlue() {
return this.fgBright(Color.BLUE);
}
public Ansi fgBrightCyan() {
return this.fgBright(Color.CYAN);
}
public Ansi fgBrightDefault() {
return this.fgBright(Color.DEFAULT);
}
public Ansi fgBrightGreen() {
return this.fgBright(Color.GREEN);
}
public Ansi fgBrightMagenta() {
return this.fgBright(Color.MAGENTA);
}
public Ansi fgBrightRed() {
return this.fgBright(Color.RED);
}
public Ansi fgBrightYellow() {
return this.fgBright(Color.YELLOW);
}
public Ansi bgBright(Color color) {
attributeOptions.add(color.bgBright());
return this;
}
public Ansi bgBrightCyan() {
return this.fgBright(Color.CYAN);
}
public Ansi bgBrightDefault() {
return this.bgBright(Color.DEFAULT);
}
public Ansi bgBrightGreen() {
return this.bgBright(Color.GREEN);
}
public Ansi bgBrightMagenta() {
return this.bg(Color.MAGENTA);
}
public Ansi bgBrightRed() {
return this.bgBright(Color.RED);
}
public Ansi bgBrightYellow() {
return this.bgBright(Color.YELLOW);
}
public Ansi a(Attribute attribute) {
attributeOptions.add(attribute.value());
return this;
}
public Ansi cursor(final int x, final int y) {
return appendEscapeSequence('H', x, y);
}
public Ansi cursorToColumn(final int x) {
return appendEscapeSequence('G', x);
}
public Ansi cursorUp(final int y) {
return appendEscapeSequence('A', y);
}
public Ansi cursorDown(final int y) {
return appendEscapeSequence('B', y);
}
public Ansi cursorRight(final int x) {
return appendEscapeSequence('C', x);
}
public Ansi cursorLeft(final int x) {
return appendEscapeSequence('D', x);
}
public Ansi cursorDownLine() {
return appendEscapeSequence('E');
}
public Ansi cursorDownLine(final int n) {
return appendEscapeSequence('E', n);
}
public Ansi cursorUpLine() {
return appendEscapeSequence('F');
}
public Ansi cursorUpLine(final int n) {
return appendEscapeSequence('F', n);
}
public Ansi eraseScreen() {
return appendEscapeSequence('J', Erase.ALL.value());
}
public Ansi eraseScreen(final Erase kind) {
return appendEscapeSequence('J', kind.value());
}
public Ansi eraseLine() {
return appendEscapeSequence('K');
}
public Ansi eraseLine(final Erase kind) {
return appendEscapeSequence('K', kind.value());
}
public Ansi scrollUp(final int rows) {
return appendEscapeSequence('S', rows);
}
public Ansi scrollDown(final int rows) {
return appendEscapeSequence('T', rows);
}
public Ansi saveCursorPosition() {
return appendEscapeSequence('s');
}
@Deprecated
public Ansi restorCursorPosition() {
return appendEscapeSequence('u');
}
public Ansi restoreCursorPosition() {
return appendEscapeSequence('u');
}
public Ansi reset() {
return a(Attribute.RESET);
}
public Ansi bold() {
return a(Attribute.INTENSITY_BOLD);
}
public Ansi boldOff() {
return a(Attribute.INTENSITY_BOLD_OFF);
}
public Ansi a(String value) {
flushAttributes();
builder.append(value);
return this;
}
public Ansi a(boolean value) {
flushAttributes();
builder.append(value);
return this;
}
public Ansi a(char value) {
flushAttributes();
builder.append(value);
return this;
}
public Ansi a(char[] value, int offset, int len) {
flushAttributes();
builder.append(value, offset, len);
return this;
}
public Ansi a(char[] value) {
flushAttributes();
builder.append(value);
return this;
}
public Ansi a(CharSequence value, int start, int end) {
flushAttributes();
builder.append(value, start, end);
return this;
}
public Ansi a(CharSequence value) {
flushAttributes();
builder.append(value);
return this;
}
public Ansi a(double value) {
flushAttributes();
builder.append(value);
return this;
}
public Ansi a(float value) {
flushAttributes();
builder.append(value);
return this;
}
public Ansi a(int value) {
flushAttributes();
builder.append(value);
return this;
}
public Ansi a(long value) {
flushAttributes();
builder.append(value);
return this;
}
public Ansi a(Object value) {
flushAttributes();
builder.append(value);
return this;
}
public Ansi a(StringBuffer value) {
flushAttributes();
builder.append(value);
return this;
}
public Ansi newline() {
flushAttributes();
builder.append(System.getProperty("line.separator"));
return this;
}
public Ansi format(String pattern, Object... args) {
flushAttributes();
builder.append(String.format(pattern, args));
return this;
}
@Override
public String toString() {
flushAttributes();
return builder.toString();
}
///////////////////////////////////////////////////////////////////
// Private Helper Methods
///////////////////////////////////////////////////////////////////
private Ansi appendEscapeSequence(char command) {
flushAttributes();
builder.append(FIRST_ESC_CHAR);
builder.append(SECOND_ESC_CHAR);
builder.append(command);
return this;
}
private Ansi appendEscapeSequence(char command, int option) {
flushAttributes();
builder.append(FIRST_ESC_CHAR);
builder.append(SECOND_ESC_CHAR);
builder.append(option);
builder.append(command);
return this;
}
private Ansi appendEscapeSequence(char command, Object... options) {
flushAttributes();
return _appendEscapeSequence(command, options);
}
private void flushAttributes() {
if (attributeOptions.isEmpty()) {
return;
}
if (attributeOptions.size() == 1 && attributeOptions.get(0) == 0) {
builder.append(FIRST_ESC_CHAR);
builder.append(SECOND_ESC_CHAR);
builder.append('m');
} else {
_appendEscapeSequence('m', attributeOptions.toArray());
}
attributeOptions.clear();
}
private Ansi _appendEscapeSequence(char command, Object... options) {
builder.append(FIRST_ESC_CHAR);
builder.append(SECOND_ESC_CHAR);
int size = options.length;
for (int i = 0; i < size; i++) {
if (i != 0) {
builder.append(';');
}
if (options[i] != null) {
builder.append(options[i]);
}
}
builder.append(command);
return this;
}
} | java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/view/MethodInfoView.java | core/src/main/java/com/taobao/arthas/core/view/MethodInfoView.java | package com.taobao.arthas.core.view;
import com.taobao.arthas.core.util.Constants;
import com.taobao.arthas.core.util.StringUtils;
import java.lang.annotation.Annotation;
import java.lang.reflect.Method;
/**
* Java方法信息控件
* Created by vlinux on 15/5/9.
*/
public class MethodInfoView implements View {
private final Method method;
private final int width;
public MethodInfoView(Method method, int width) {
this.method = method;
this.width = width;
}
@Override
public String draw() {
return new TableView(new TableView.ColumnDefine[]{
new TableView.ColumnDefine("declaring-class".length(), false, TableView.Align.RIGHT),
// (列数-1) * 3 + 4 = 7
new TableView.ColumnDefine(width - "declaring-class".length() - 7, false, TableView.Align.LEFT)
})
.addRow("declaring-class", method.getDeclaringClass().getName())
.addRow("method-name", method.getName())
.addRow("modifier", StringUtils.modifier(method.getModifiers(), ','))
.addRow("annotation", drawAnnotation())
.addRow("parameters", drawParameters())
.addRow("return", drawReturn())
.addRow("exceptions", drawExceptions())
.padding(1)
.hasBorder(true)
.draw();
}
private String drawAnnotation() {
final StringBuilder annotationSB = new StringBuilder();
final Annotation[] annotationArray = method.getDeclaredAnnotations();
if (annotationArray.length > 0) {
for (Annotation annotation : annotationArray) {
annotationSB.append(StringUtils.classname(annotation.annotationType())).append(",");
}
if (annotationSB.length() > 0) {
annotationSB.deleteCharAt(annotationSB.length() - 1);
}
} else {
annotationSB.append(Constants.EMPTY_STRING);
}
return annotationSB.toString();
}
private String drawParameters() {
final StringBuilder paramsSB = new StringBuilder();
final Class<?>[] paramTypes = method.getParameterTypes();
if (paramTypes.length > 0) {
for (Class<?> clazz : paramTypes) {
paramsSB.append(StringUtils.classname(clazz)).append("\n");
}
}
return paramsSB.toString();
}
private String drawReturn() {
final StringBuilder returnSB = new StringBuilder();
final Class<?> returnTypeClass = method.getReturnType();
returnSB.append(StringUtils.classname(returnTypeClass)).append("\n");
return returnSB.toString();
}
private String drawExceptions() {
final StringBuilder exceptionSB = new StringBuilder();
final Class<?>[] exceptionTypes = method.getExceptionTypes();
if (exceptionTypes.length > 0) {
for (Class<?> clazz : exceptionTypes) {
exceptionSB.append(StringUtils.classname(clazz)).append("\n");
}
}
return exceptionSB.toString();
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/view/ObjectView.java | core/src/main/java/com/taobao/arthas/core/view/ObjectView.java | package com.taobao.arthas.core.view;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONWriter;
import com.alibaba.fastjson2.writer.FieldWriter;
import com.alibaba.fastjson2.writer.ObjectWriterCreator;
import com.alibaba.fastjson2.writer.ObjectWriterProvider;
import com.taobao.arthas.common.ArthasConstants;
import com.taobao.arthas.core.GlobalOptions;
import com.taobao.arthas.core.command.model.ObjectVO;
import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.reflect.Field;
import java.text.SimpleDateFormat;
import java.util.*;
import static java.lang.String.format;
/**
* 对象控件<br/>
* 能展示出一个对象的内部结构
* Created by vlinux on 15/5/20.
*/
public class ObjectView implements View {
public static final int MAX_DEEP = 4;
private static final Logger logger = LoggerFactory.getLogger(ObjectView.class);
private final static int MAX_OBJECT_LENGTH = ArthasConstants.MAX_HTTP_CONTENT_LENGTH;
private static final ObjectWriterProvider JSON_OBJECT_WRITER_PROVIDER = new ObjectWriterProvider(
new ObjectWriterCreator() {
@Override
protected void setDefaultValue(List<FieldWriter> fieldWriters, Class objectClass) {
// fastjson2 默认会通过无参构造函数创建一个对象来提取字段默认值（用于 NotWriteDefaultValue 等能力），
// 这可能触发目标对象的构造逻辑（比如单例守卫、资源初始化等），在 Arthas 里属于不可接受的副作用。
// 这里直接禁用该行为，只基于现有对象进行序列化。
}
});
public static String toJsonString(Object object) {
JSONWriter.Context context = new JSONWriter.Context(JSON_OBJECT_WRITER_PROVIDER);
context.setMaxLevel(4097);
context.config(JSONWriter.Feature.IgnoreErrorGetter,
JSONWriter.Feature.ReferenceDetection,
JSONWriter.Feature.IgnoreNonFieldGetter,
JSONWriter.Feature.WriteNonStringKeyAsString);
return JSON.toJSONString(object, context);
}
private final Object object;
private final int deep;
private final int maxObjectLength;
public ObjectView(ObjectVO objectVO) {
this(MAX_OBJECT_LENGTH, objectVO);
}
// int参数在前面，防止构造函数二义性
public ObjectView(int maxObjectLength, ObjectVO objectVO) {
this(objectVO.getObject(), objectVO.expandOrDefault(), maxObjectLength);
}
public ObjectView(Object object, int deep) {
this(object, deep, MAX_OBJECT_LENGTH);
}
public ObjectView(Object object, int deep, int maxObjectLength) {
this.object = object;
this.deep = deep > MAX_DEEP ? MAX_DEEP : deep;
this.maxObjectLength = maxObjectLength;
}
@Override
public String draw() {
StringBuilder buf = new StringBuilder();
try {
if (GlobalOptions.isUsingJson) {
return toJsonString(object);
}
renderObject(object, 0, deep, buf);
return buf.toString();
} catch (ObjectTooLargeException e) {
buf.append(" Object size exceeds size limit: ")
.append(maxObjectLength)
.append(", try to specify -M size_limit in your command, check the help command for more.");
return buf.toString();
} catch (Throwable t) {
logger.error("ObjectView draw error, object class: {}", object.getClass(), t);
return "ERROR DATA!!! object class: " + object.getClass() + ", exception class: " + t.getClass()
+ ", exception message: " + t.getMessage();
}
}
private final static String TAB = " ";
private final static Map<Byte, String> ASCII_MAP = new HashMap<Byte, String>();
static {
ASCII_MAP.put((byte) 0, "NUL");
ASCII_MAP.put((byte) 1, "SOH");
ASCII_MAP.put((byte) 2, "STX");
ASCII_MAP.put((byte) 3, "ETX");
ASCII_MAP.put((byte) 4, "EOT");
ASCII_MAP.put((byte) 5, "ENQ");
ASCII_MAP.put((byte) 6, "ACK");
ASCII_MAP.put((byte) 7, "BEL");
ASCII_MAP.put((byte) 8, "BS");
ASCII_MAP.put((byte) 9, "HT");
ASCII_MAP.put((byte) 10, "LF");
ASCII_MAP.put((byte) 11, "VT");
ASCII_MAP.put((byte) 12, "FF");
ASCII_MAP.put((byte) 13, "CR");
ASCII_MAP.put((byte) 14, "SO");
ASCII_MAP.put((byte) 15, "SI");
ASCII_MAP.put((byte) 16, "DLE");
ASCII_MAP.put((byte) 17, "DC1");
ASCII_MAP.put((byte) 18, "DC2");
ASCII_MAP.put((byte) 19, "DC3");
ASCII_MAP.put((byte) 20, "DC4");
ASCII_MAP.put((byte) 21, "NAK");
ASCII_MAP.put((byte) 22, "SYN");
ASCII_MAP.put((byte) 23, "ETB");
ASCII_MAP.put((byte) 24, "CAN");
ASCII_MAP.put((byte) 25, "EM");
ASCII_MAP.put((byte) 26, "SUB");
ASCII_MAP.put((byte) 27, "ESC");
ASCII_MAP.put((byte) 28, "FS");
ASCII_MAP.put((byte) 29, "GS");
ASCII_MAP.put((byte) 30, "RS");
ASCII_MAP.put((byte) 31, "US");
ASCII_MAP.put((byte) 127, "DEL");
}
private void renderObject(Object obj, int deep, int expand, final StringBuilder buf) throws ObjectTooLargeException {
if (null == obj) {
appendStringBuilder(buf,"null");
} else {
final Class<?> clazz = obj.getClass();
final String className = clazz.getSimpleName();
// 7种基础类型,直接输出@类型[值]
if (Integer.class.isInstance(obj)
|| Long.class.isInstance(obj)
|| Float.class.isInstance(obj)
|| Double.class.isInstance(obj)
// || Character.class.isInstance(obj)
|| Short.class.isInstance(obj)
|| Byte.class.isInstance(obj)
|| Boolean.class.isInstance(obj)) {
appendStringBuilder(buf, format("@%s[%s]", className, obj));
}
// Char要特殊处理,因为有不可见字符的因素
else if (Character.class.isInstance(obj)) {
final Character c = (Character) obj;
// ASCII的可见字符
if (c >= 32
&& c <= 126) {
appendStringBuilder(buf, format("@%s[%s]", className, c));
}
// ASCII的控制字符
else if (ASCII_MAP.containsKey((byte) c.charValue())) {
appendStringBuilder(buf, format("@%s[%s]", className, ASCII_MAP.get((byte) c.charValue())));
}
// 超过ASCII的编码范围
else {
appendStringBuilder(buf, format("@%s[%s]", className, c));
}
}
// 字符串类型单独处理
else if (String.class.isInstance(obj)) {
appendStringBuilder(buf, "@");
appendStringBuilder(buf, className);
appendStringBuilder(buf, "[");
for (Character c : ((String) obj).toCharArray()) {
switch (c) {
case '\n':
appendStringBuilder(buf, "\\n");
break;
case '\r':
appendStringBuilder(buf, "\\r");
break;
default:
appendStringBuilder(buf, c.toString());
}//switch
}//for
appendStringBuilder(buf, "]");
}
// 集合类输出
else if (Collection.class.isInstance(obj)) {
@SuppressWarnings("unchecked") final Collection<Object> collection = (Collection<Object>) obj;
// 非根节点或空集合只展示摘要信息
if (!isExpand(deep, expand)
|| collection.isEmpty()) {
appendStringBuilder(buf, format("@%s[isEmpty=%s;size=%d]",
className,
collection.isEmpty(),
collection.size()));
}
// 展开展示
else {
appendStringBuilder(buf, format("@%s[", className));
for (Object e : collection) {
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep+1; i++) {
appendStringBuilder(buf, TAB);
}
renderObject(e, deep + 1, expand, buf);
appendStringBuilder(buf, ",");
}
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep; i++) {
appendStringBuilder(buf, TAB);
}
appendStringBuilder(buf, "]");
}
}
// Map类输出
else if (Map.class.isInstance(obj)) {
@SuppressWarnings("unchecked") final Map<Object, Object> map = (Map<Object, Object>) obj;
// 非根节点或空集合只展示摘要信息
if (!isExpand(deep, expand)
|| map.isEmpty()) {
appendStringBuilder(buf, format("@%s[isEmpty=%s;size=%d]",
className,
map.isEmpty(),
map.size()));
} else {
appendStringBuilder(buf, format("@%s[", className));
for (Map.Entry<Object, Object> entry : map.entrySet()) {
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep+1; i++) {
appendStringBuilder(buf, TAB);
}
renderObject(entry.getKey(), deep + 1, expand, buf);
appendStringBuilder(buf, ":");
renderObject(entry.getValue(), deep + 1, expand, buf);
appendStringBuilder(buf, ",");
}
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep; i++) {
appendStringBuilder(buf, TAB);
}
appendStringBuilder(buf, "]");
}
}
// 数组类输出
else if (obj.getClass().isArray()) {
final String typeName = obj.getClass().getSimpleName();
// int[]
if (typeName.equals("int[]")) {
final int[] arrays = (int[]) obj;
// 非根节点或空集合只展示摘要信息
if (!isExpand(deep, expand)
|| arrays.length == 0) {
appendStringBuilder(buf, format("@%s[isEmpty=%s;size=%d]",
typeName,
arrays.length == 0,
arrays.length));
}
// 展开展示
else {
appendStringBuilder(buf, format("@%s[", className));
for (int e : arrays) {
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep+1; i++) {
appendStringBuilder(buf, TAB);
}
renderObject(e, deep + 1, expand, buf);
appendStringBuilder(buf, ",");
}
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep; i++) {
appendStringBuilder(buf, TAB);
}
appendStringBuilder(buf, "]");
}
}
// long[]
else if (typeName.equals("long[]")) {
final long[] arrays = (long[]) obj;
// 非根节点或空集合只展示摘要信息
if (!isExpand(deep, expand)
|| arrays.length == 0) {
appendStringBuilder(buf, format("@%s[isEmpty=%s;size=%d]",
typeName,
arrays.length == 0,
arrays.length));
}
// 展开展示
else {
appendStringBuilder(buf, format("@%s[", className));
for (long e : arrays) {
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep+1; i++) {
appendStringBuilder(buf, TAB);
}
renderObject(e, deep + 1, expand, buf);
appendStringBuilder(buf, ",");
}
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep; i++) {
appendStringBuilder(buf, TAB);
}
appendStringBuilder(buf, "]");
}
}
// short[]
else if (typeName.equals("short[]")) {
final short[] arrays = (short[]) obj;
// 非根节点或空集合只展示摘要信息
if (!isExpand(deep, expand)
|| arrays.length == 0) {
appendStringBuilder(buf, format("@%s[isEmpty=%s;size=%d]",
typeName,
arrays.length == 0,
arrays.length));
}
// 展开展示
else {
appendStringBuilder(buf, format("@%s[", className));
for (short e : arrays) {
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep+1; i++) {
appendStringBuilder(buf, TAB);
}
renderObject(e, deep + 1, expand, buf);
appendStringBuilder(buf, ",");
}
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep; i++) {
appendStringBuilder(buf, TAB);
}
appendStringBuilder(buf, "]");
}
}
// float[]
else if (typeName.equals("float[]")) {
final float[] arrays = (float[]) obj;
// 非根节点或空集合只展示摘要信息
if (!isExpand(deep, expand)
|| arrays.length == 0) {
appendStringBuilder(buf, format("@%s[isEmpty=%s;size=%d]",
typeName,
arrays.length == 0,
arrays.length));
}
// 展开展示
else {
appendStringBuilder(buf, format("@%s[", className));
for (float e : arrays) {
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep+1; i++) {
appendStringBuilder(buf, TAB);
}
renderObject(e, deep + 1, expand, buf);
appendStringBuilder(buf, ",");
}
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep; i++) {
appendStringBuilder(buf, TAB);
}
appendStringBuilder(buf, "]");
}
}
// double[]
else if (typeName.equals("double[]")) {
final double[] arrays = (double[]) obj;
// 非根节点或空集合只展示摘要信息
if (!isExpand(deep, expand)
|| arrays.length == 0) {
appendStringBuilder(buf, format("@%s[isEmpty=%s;size=%d]",
typeName,
arrays.length == 0,
arrays.length));
}
// 展开展示
else {
appendStringBuilder(buf, format("@%s[", className));
for (double e : arrays) {
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep+1; i++) {
appendStringBuilder(buf, TAB);
}
renderObject(e, deep + 1, expand, buf);
appendStringBuilder(buf, ",");
}
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep; i++) {
appendStringBuilder(buf, TAB);
}
appendStringBuilder(buf, "]");
}
}
// boolean[]
else if (typeName.equals("boolean[]")) {
final boolean[] arrays = (boolean[]) obj;
// 非根节点或空集合只展示摘要信息
if (!isExpand(deep, expand)
|| arrays.length == 0) {
appendStringBuilder(buf, format("@%s[isEmpty=%s;size=%d]",
typeName,
arrays.length == 0,
arrays.length));
}
// 展开展示
else {
appendStringBuilder(buf, format("@%s[", className));
for (boolean e : arrays) {
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep+1; i++) {
appendStringBuilder(buf, TAB);
}
renderObject(e, deep + 1, expand, buf);
appendStringBuilder(buf, ",");
}
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep; i++) {
appendStringBuilder(buf, TAB);
}
appendStringBuilder(buf, "]");
}
}
// char[]
else if (typeName.equals("char[]")) {
final char[] arrays = (char[]) obj;
// 非根节点或空集合只展示摘要信息
if (!isExpand(deep, expand)
|| arrays.length == 0) {
appendStringBuilder(buf, format("@%s[isEmpty=%s;size=%d]",
typeName,
arrays.length == 0,
arrays.length));
}
// 展开展示
else {
appendStringBuilder(buf, format("@%s[", className));
for (char e : arrays) {
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep+1; i++) {
appendStringBuilder(buf, TAB);
}
renderObject(e, deep + 1, expand, buf);
appendStringBuilder(buf, ",");
}
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep; i++) {
appendStringBuilder(buf, TAB);
}
appendStringBuilder(buf, "]");
}
}
// byte[]
else if (typeName.equals("byte[]")) {
final byte[] arrays = (byte[]) obj;
// 非根节点或空集合只展示摘要信息
if (!isExpand(deep, expand)
|| arrays.length == 0) {
appendStringBuilder(buf, format("@%s[isEmpty=%s;size=%d]",
typeName,
arrays.length == 0,
arrays.length));
}
// 展开展示
else {
appendStringBuilder(buf, format("@%s[", className));
for (byte e : arrays) {
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep+1; i++) {
appendStringBuilder(buf, TAB);
}
renderObject(e, deep + 1, expand, buf);
appendStringBuilder(buf, ",");
}
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep; i++) {
appendStringBuilder(buf, TAB);
}
appendStringBuilder(buf, "]");
}
}
// Object[]
else {
final Object[] arrays = (Object[]) obj;
// 非根节点或空集合只展示摘要信息
if (!isExpand(deep, expand)
|| arrays.length == 0) {
appendStringBuilder(buf, format("@%s[isEmpty=%s;size=%d]",
typeName,
arrays.length == 0,
arrays.length));
}
// 展开展示
else {
appendStringBuilder(buf, format("@%s[", className));
for (Object e : arrays) {
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep+1; i++) {
appendStringBuilder(buf, TAB);
}
renderObject(e, deep + 1, expand, buf);
appendStringBuilder(buf, ",");
}
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep; i++) {
appendStringBuilder(buf, TAB);
}
appendStringBuilder(buf, "]");
}
}
}
// Throwable输出
else if (Throwable.class.isInstance(obj)) {
if (!isExpand(deep, expand)) {
appendStringBuilder(buf, format("@%s[%s]", className, obj));
} else {
final Throwable throwable = (Throwable) obj;
final StringWriter sw = new StringWriter();
final PrintWriter pw = new PrintWriter(sw);
throwable.printStackTrace(pw);
appendStringBuilder(buf, sw.toString());
}
}
// Date输出
else if (Date.class.isInstance(obj)) {
appendStringBuilder(buf, format("@%s[%s]", className, new SimpleDateFormat("yyyy-MM-dd HH:mm:ss,SSS").format(obj)));
}
else if (obj instanceof Enum<?>) {
appendStringBuilder(buf, format("@%s[%s]", className, obj));
}
// 普通Object输出
else {
if (!isExpand(deep, expand)) {
appendStringBuilder(buf, format("@%s[%s]", className, obj));
} else {
appendStringBuilder(buf, format("@%s[", className));
final List<Field> fields;
Class<?> objClass = obj.getClass();
if (GlobalOptions.printParentFields) {
fields = new ArrayList<Field>();
// 当父类为null的时候说明到达了最上层的父类(Object类).
while (objClass != null) {
fields.addAll(Arrays.asList(objClass.getDeclaredFields()));
objClass = objClass.getSuperclass();
}
} else {
fields = new ArrayList<Field>(Arrays.asList(objClass.getDeclaredFields()));
}
for (Field field : fields) {
field.setAccessible(true);
try {
final Object value = field.get(obj);
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep+1; i++) {
appendStringBuilder(buf, TAB);
}
appendStringBuilder(buf, field.getName());
appendStringBuilder(buf, "=");
renderObject(value, deep + 1, expand, buf);
appendStringBuilder(buf, ",");
} catch (ObjectTooLargeException t) {
buf.append("...");
break;
} catch (Throwable t) {
// ignore
}
}//for
appendStringBuilder(buf, "\n");
for (int i = 0; i < deep; i++) {
appendStringBuilder(buf, TAB);
}
appendStringBuilder(buf, "]");
}
}
}
}
/**
* 是否展开当前深度的节点
*
* @param deep 当前节点的深度
* @param expand 展开极限
* @return true:当前节点需要展开 / false:当前节点不需要展开
*/
private static boolean isExpand(int deep, int expand) {
return deep < expand;
}
/**
* append string to a string builder, with upper limit check
* @param buf the StringBuilder buffer
* @param data the data to be appended
* @throws ObjectTooLargeException if the size has exceeded the upper limit
*/
private void appendStringBuilder(StringBuilder buf, String data) throws ObjectTooLargeException {
if (buf.length() + data.length() > maxObjectLength) {
throw new ObjectTooLargeException("Object size exceeds size limit: " + maxObjectLength);
}
buf.append(data);
}
private static class ObjectTooLargeException extends Exception {
public ObjectTooLargeException(String message) {
super(message);
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/view/KVView.java | core/src/main/java/com/taobao/arthas/core/view/KVView.java | package com.taobao.arthas.core.view;
import com.taobao.arthas.core.util.StringUtils;
import java.util.Scanner;
/**
* KV排版控件
* Created by vlinux on 15/5/9.
*/
public class KVView implements View {
private final TableView tableView;
public KVView() {
this.tableView = new TableView(new TableView.ColumnDefine[]{
new TableView.ColumnDefine(TableView.Align.RIGHT),
new TableView.ColumnDefine(TableView.Align.RIGHT),
new TableView.ColumnDefine(TableView.Align.LEFT)
})
.hasBorder(false)
.padding(0);
}
public KVView(TableView.ColumnDefine keyColumnDefine, TableView.ColumnDefine valueColumnDefine) {
this.tableView = new TableView(new TableView.ColumnDefine[]{
keyColumnDefine,
new TableView.ColumnDefine(TableView.Align.RIGHT),
valueColumnDefine
})
.hasBorder(false)
.padding(0);
}
public KVView add(final Object key, final Object value) {
tableView.addRow(key, " : ", value);
return this;
}
@Override
public String draw() {
String content = tableView.draw();
StringBuilder sb = new StringBuilder();
// 清理多余的空格
Scanner scanner = new Scanner(content);
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
if (line != null) {
//清理一行后面多余的空格
line = StringUtils.stripEnd(line, " ");
}
sb.append(line).append('\n');
}
scanner.close();
return sb.toString();
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/view/TreeView.java | core/src/main/java/com/taobao/arthas/core/view/TreeView.java | package com.taobao.arthas.core.view;
import com.taobao.arthas.core.util.StringUtils;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 树形控件
* Created by vlinux on 15/5/26.
*/
public class TreeView implements View {
private static final String STEP_FIRST_CHAR = "`---";
private static final String STEP_NORMAL_CHAR = "+---";
private static final String STEP_HAS_BOARD = "| ";
private static final String STEP_EMPTY_BOARD = " ";
private static final String TIME_UNIT = "ms";
// 是否输出耗时
private final boolean isPrintCost;
// 根节点
private final Node root;
// 当前节点
private Node current;
// 最耗时的节点
private Node maxCost;
public TreeView(boolean isPrintCost, String title) {
this.root = new Node(title).markBegin().markEnd();
this.current = root;
this.isPrintCost = isPrintCost;
}
@Override
public String draw() {
findMaxCostNode(root);
final StringBuilder treeSB = new StringBuilder();
final Ansi highlighted = Ansi.ansi().fg(Ansi.Color.RED);
recursive(0, true, "", root, new Callback() {
@Override
public void callback(int deep, boolean isLast, String prefix, Node node) {
treeSB.append(prefix).append(isLast ? STEP_FIRST_CHAR : STEP_NORMAL_CHAR);
if (isPrintCost && !node.isRoot()) {
if (node == maxCost) {
// the node with max cost will be highlighted
treeSB.append(highlighted.a(node.toString()).reset().toString());
} else {
treeSB.append(node.toString());
}
}
treeSB.append(node.data);
if (!StringUtils.isBlank(node.mark)) {
treeSB.append(" [").append(node.mark).append(node.marks > 1 ? "," + node.marks : "").append("]");
}
treeSB.append("\n");
}
});
return treeSB.toString();
}
/**
* 递归遍历
*/
private void recursive(int deep, boolean isLast, String prefix, Node node, Callback callback) {
callback.callback(deep, isLast, prefix, node);
if (!node.isLeaf()) {
final int size = node.children.size();
for (int index = 0; index < size; index++) {
final boolean isLastFlag = index == size - 1;
final String currentPrefix = isLast ? prefix + STEP_EMPTY_BOARD : prefix + STEP_HAS_BOARD;
recursive(
deep + 1,
isLastFlag,
currentPrefix,
node.children.get(index),
callback
);
}
}
}
/**
* 查找耗时最大的节点，便于后续高亮展示
* @param node
*/
private void findMaxCostNode(Node node) {
if (!node.isRoot() && !node.parent.isRoot()) {
if (maxCost == null) {
maxCost = node;
} else if (maxCost.totalCost < node.totalCost) {
maxCost = node;
}
}
if (!node.isLeaf()) {
for (Node n: node.children) {
findMaxCostNode(n);
}
}
}
/**
* 创建一个分支节点
*
* @param data 节点数据
* @return this
*/
public TreeView begin(String data) {
Node n = current.find(data);
if (n != null) {
current = n;
} else {
current = new Node(current, data);
}
current.markBegin();
return this;
}
/**
* 结束一个分支节点
*
* @return this
*/
public TreeView end() {
if (current.isRoot()) {
throw new IllegalStateException("current node is root.");
}
current.markEnd();
current = current.parent;
return this;
}
/**
* 结束一个分支节点,并带上备注
*
* @return this
*/
public TreeView end(String mark) {
if (current.isRoot()) {
throw new IllegalStateException("current node is root.");
}
current.markEnd().mark(mark);
current = current.parent;
return this;
}
/**
* 树节点
*/
private static class Node {
/**
* 父节点
*/
final Node parent;
/**
* 节点数据
*/
final String data;
/**
* 子节点
*/
final List<Node> children = new ArrayList<Node>();
final Map<String, Node> map = new HashMap<String, Node>();
/**
* 开始时间戳
*/
private long beginTimestamp;
/**
* 结束时间戳
*/
private long endTimestamp;
/**
* 备注
*/
private String mark;
/**
* 构造树节点(根节点)
*/
private Node(String data) {
this.parent = null;
this.data = data;
}
/**
* 构造树节点
*
* @param parent 父节点
* @param data 节点数据
*/
private Node(Node parent, String data) {
this.parent = parent;
this.data = data;
parent.children.add(this);
parent.map.put(data, this);
}
/**
* 查找已经存在的节点
*/
Node find(String data) {
return map.get(data);
}
/**
* 是否根节点
*
* @return true / false
*/
boolean isRoot() {
return null == parent;
}
/**
* 是否叶子节点
*
* @return true / false
*/
boolean isLeaf() {
return children.isEmpty();
}
Node markBegin() {
beginTimestamp = System.nanoTime();
return this;
}
Node markEnd() {
endTimestamp = System.nanoTime();
long cost = getCost();
if (cost < minCost) {
minCost = cost;
}
if (cost > maxCost) {
maxCost = cost;
}
times++;
totalCost += cost;
return this;
}
Node mark(String mark) {
this.mark = mark;
marks++;
return this;
}
long getCost() {
return endTimestamp - beginTimestamp;
}
/**
* convert nano-seconds to milli-seconds
*/
double getCostInMillis(long nanoSeconds) {
return nanoSeconds / 1000000.0;
}
public String toString() {
StringBuilder sb = new StringBuilder();
if (times <= 1) {
sb.append("[").append(getCostInMillis(getCost())).append(TIME_UNIT).append("] ");
} else {
sb.append("[min=").append(getCostInMillis(minCost)).append(TIME_UNIT).append(",max=")
.append(getCostInMillis(maxCost)).append(TIME_UNIT).append(",total=")
.append(getCostInMillis(totalCost)).append(TIME_UNIT).append(",count=")
.append(times).append("] ");
}
return sb.toString();
}
/**
* 合并统计相同调用,并计算最小\最大\总耗时
*/
private long minCost = Long.MAX_VALUE;
private long maxCost = Long.MIN_VALUE;
private long totalCost = 0;
private long times = 0;
private long marks = 0;
}
/**
* 遍历回调接口
*/
private interface Callback {
void callback(int deep, boolean isLast, String prefix, Node node);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/view/View.java | core/src/main/java/com/taobao/arthas/core/view/View.java | package com.taobao.arthas.core.view;
/**
* 命令行控件<br/>
* Created by vlinux on 15/5/7.
*/
public interface View {
/**
* 输出外观
*/
String draw();
} | java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/security/SecurityAuthenticator.java | core/src/main/java/com/taobao/arthas/core/security/SecurityAuthenticator.java | package com.taobao.arthas.core.security;
import java.security.Principal;
import javax.security.auth.Subject;
import javax.security.auth.login.LoginException;
/**
* A {@link SecurityAuthenticator} allows to plugin custom authenticators, such
* as JAAS based or custom implementations.
*/
public interface SecurityAuthenticator {
boolean needLogin();
/**
* Sets the name of the realm to use.
*/
void setName(String name);
/**
* Gets the name of the realm.
*/
String getName();
/**
* Sets the role class names (separated by comma)
* <p/>
* By default if no explicit role class names has been configured, then this
* implementation will assume the {@link Subject}
* {@link java.security.Principal}s is a role if the classname contains the word
* <tt>role</tt> (lower cased).
*
* @param names a list of FQN class names for role
* {@link java.security.Principal} implementations.
*/
void setRoleClassNames(String names);
/**
* Attempts to login the {@link java.security.Principal} on this realm.
* <p/>
* The login is a success if no Exception is thrown, and a {@link Subject} is
* returned.
*
* @param principal the principal
* @return the subject for the logged in principal, must <b>not</b> be
* <tt>null</tt>
* @throws LoginException is thrown if error logging in the
* {@link java.security.Principal}
*/
Subject login(Principal principal) throws LoginException;
/**
* Attempt to logout the subject.
*
* @param subject subject to logout
* @throws LoginException is thrown if error logging out subject
*/
void logout(Subject subject) throws LoginException;
/**
* Gets the user roles from the given {@link Subject}
*
* @param subject the subject
* @return <tt>null</tt> if no roles, otherwise a String with roles separated by
* comma.
*/
String getUserRoles(Subject subject);
} | java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/security/SecurityAuthenticatorImpl.java | core/src/main/java/com/taobao/arthas/core/security/SecurityAuthenticatorImpl.java | package com.taobao.arthas.core.security;
import java.security.Principal;
import javax.security.auth.Subject;
import javax.security.auth.login.LoginException;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.common.ArthasConstants;
import com.taobao.arthas.core.util.StringUtils;
/**
* TODO 支持不同角色不同权限，command按角色分类？
*
* @author hengyunabc 2021-03-03
*
*/
public class SecurityAuthenticatorImpl implements SecurityAuthenticator {
private static final Logger logger = LoggerFactory.getLogger(SecurityAuthenticatorImpl.class);
private String username;
private String password;
private Subject subject;
public SecurityAuthenticatorImpl(String username, String password) {
if (username != null && password == null) {
password = StringUtils.randomString(32);
logger.info("\nUsing generated security password: {}\n", password);
}
if (username == null && password != null) {
username = ArthasConstants.DEFAULT_USERNAME;
}
this.username = username;
this.password = password;
subject = new Subject();
}
@Override
public void setName(String name) {
// TODO Auto-generated method stub
}
@Override
public String getName() {
// TODO Auto-generated method stub
return null;
}
@Override
public void setRoleClassNames(String names) {
// TODO Auto-generated method stub
}
@Override
public Subject login(Principal principal) throws LoginException {
if (principal == null) {
return null;
}
if (principal instanceof BasicPrincipal) {
BasicPrincipal basicPrincipal = (BasicPrincipal) principal;
if (basicPrincipal.getName().equals(username) && basicPrincipal.getPassword().equals(this.password)) {
return subject;
}
}
if (principal instanceof BearerPrincipal) {
BearerPrincipal bearerPrincipal = (BearerPrincipal) principal;
// Bearer Token认证：将token作为password进行验证
if (bearerPrincipal.getToken().equals(this.password)) {
return subject;
}
}
if (principal instanceof LocalConnectionPrincipal) {
return subject;
}
return null;
}
@Override
public void logout(Subject subject) throws LoginException {
// TODO Auto-generated method stub
}
@Override
public String getUserRoles(Subject subject) {
// TODO Auto-generated method stub
return null;
}
@Override
public boolean needLogin() {
return username != null && password != null;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/security/BasicPrincipal.java | core/src/main/java/com/taobao/arthas/core/security/BasicPrincipal.java | package com.taobao.arthas.core.security;
import java.security.Principal;
/**
* Basic {@link Principal}.
*
* @author hengyunabc 2021-03-04
*/
public final class BasicPrincipal implements Principal {
private final String username;
private final String password;
public BasicPrincipal(String username, String password) {
this.username = username;
this.password = password;
}
@Override
public String getName() {
return username;
}
public String getUsername() {
return username;
}
public String getPassword() {
return password;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((password == null) ? 0 : password.hashCode());
result = prime * result + ((username == null) ? 0 : username.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
BasicPrincipal other = (BasicPrincipal) obj;
if (password == null) {
if (other.password != null)
return false;
} else if (!password.equals(other.password))
return false;
if (username == null) {
if (other.username != null)
return false;
} else if (!username.equals(other.username))
return false;
return true;
}
@Override
public String toString() {
// do not display the password
return "BasicPrincipal[" + username + "]";
}
} | java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/security/AuthUtils.java | core/src/main/java/com/taobao/arthas/core/security/AuthUtils.java | package com.taobao.arthas.core.security;
import java.net.InetSocketAddress;
import java.net.SocketAddress;
import java.security.Principal;
import com.taobao.arthas.core.config.Configure;
import com.taobao.arthas.core.server.ArthasBootstrap;
import io.netty.channel.ChannelHandlerContext;
/**
*
* @author hengyunabc 2021-09-01
*
*/
public class AuthUtils {
private static Configure configure = ArthasBootstrap.getInstance().getConfigure();
public static Principal localPrincipal(ChannelHandlerContext ctx) {
if (configure.isLocalConnectionNonAuth() && isLocalConnection(ctx)) {
return new LocalConnectionPrincipal();
}
return null;
}
public static boolean isLocalConnection(ChannelHandlerContext ctx) {
SocketAddress remoteAddress = ctx.channel().remoteAddress();
if (remoteAddress instanceof InetSocketAddress) {
String hostAddress = ((InetSocketAddress) remoteAddress).getAddress().getHostAddress();
if ("127.0.0.1".equals(hostAddress)) {
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/core/src/main/java/com/taobao/arthas/core/security/LocalConnectionPrincipal.java | core/src/main/java/com/taobao/arthas/core/security/LocalConnectionPrincipal.java | package com.taobao.arthas.core.security;
import java.security.Principal;
/**
* 本地连接的特殊处理 {@link Principal}.
*
* @author hengyunabc 2021-09-01
*/
public final class LocalConnectionPrincipal implements Principal {
public LocalConnectionPrincipal() {
}
@Override
public String getName() {
return null;
}
public String getUsername() {
return null;
}
public String getPassword() {
return null;
}
} | java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/security/BearerPrincipal.java | core/src/main/java/com/taobao/arthas/core/security/BearerPrincipal.java | package com.taobao.arthas.core.security;
import java.security.Principal;
/**
* Bearer Token {@link Principal}.
*/
public final class BearerPrincipal implements Principal {
private final String token;
public BearerPrincipal(String token) {
this.token = token;
}
@Override
public String getName() {
return "bearer";
}
public String getToken() {
return token;
}
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((token == null) ? 0 : token.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
return false;
BearerPrincipal other = (BearerPrincipal) obj;
if (token == null) {
if (other.token != null)
return false;
} else if (!token.equals(other.token))
return false;
return true;
}
@Override
public String toString() {
// do not display the token for security reasons
return "BearerPrincipal[***]";
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/server/ArthasBootstrap.java | core/src/main/java/com/taobao/arthas/core/server/ArthasBootstrap.java | package com.taobao.arthas.core.server;
import java.arthas.SpyAPI;
import java.io.File;
import java.io.IOException;
import java.lang.instrument.Instrumentation;
import java.lang.instrument.UnmodifiableClassException;
import java.lang.reflect.Method;
import java.security.CodeSource;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Properties;
import java.util.Set;
import java.util.Timer;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.jar.JarFile;
import com.alibaba.arthas.deps.ch.qos.logback.classic.LoggerContext;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.alibaba.arthas.tunnel.client.TunnelClient;
import com.alibaba.bytekit.asm.instrument.InstrumentConfig;
import com.alibaba.bytekit.asm.instrument.InstrumentParseResult;
import com.alibaba.bytekit.asm.instrument.InstrumentTransformer;
import com.alibaba.bytekit.asm.matcher.SimpleClassMatcher;
import com.alibaba.bytekit.utils.AsmUtils;
import com.alibaba.bytekit.utils.IOUtils;
import com.alibaba.fastjson2.JSON;
import com.alibaba.fastjson2.JSONWriter;
import com.taobao.arthas.common.AnsiLog;
import com.taobao.arthas.common.ArthasConstants;
import com.taobao.arthas.common.PidUtils;
import com.taobao.arthas.common.SocketUtils;
import com.taobao.arthas.core.advisor.Enhancer;
import com.taobao.arthas.core.advisor.TransformerManager;
import com.taobao.arthas.core.command.BuiltinCommandPack;
import com.taobao.arthas.core.command.CommandExecutorImpl;
import com.taobao.arthas.core.command.view.ResultViewResolver;
import com.taobao.arthas.core.config.BinderUtils;
import com.taobao.arthas.core.config.Configure;
import com.taobao.arthas.core.config.FeatureCodec;
import com.taobao.arthas.core.env.ArthasEnvironment;
import com.taobao.arthas.core.env.MapPropertySource;
import com.taobao.arthas.core.env.PropertiesPropertySource;
import com.taobao.arthas.core.env.PropertySource;
import com.taobao.arthas.core.security.SecurityAuthenticator;
import com.taobao.arthas.core.security.SecurityAuthenticatorImpl;
import com.taobao.arthas.core.server.instrument.ClassLoader_Instrument;
import com.taobao.arthas.core.shell.ShellServer;
import com.taobao.arthas.core.shell.ShellServerOptions;
import com.taobao.arthas.core.shell.command.CommandResolver;
import com.taobao.arthas.core.shell.handlers.BindHandler;
import com.taobao.arthas.core.shell.history.HistoryManager;
import com.taobao.arthas.core.shell.history.impl.HistoryManagerImpl;
import com.taobao.arthas.core.shell.impl.ShellServerImpl;
import com.taobao.arthas.core.shell.session.SessionManager;
import com.taobao.arthas.core.shell.session.impl.SessionManagerImpl;
import com.taobao.arthas.core.shell.term.impl.HttpTermServer;
import com.taobao.arthas.core.shell.term.impl.http.api.HttpApiHandler;
import com.taobao.arthas.core.shell.term.impl.http.session.HttpSessionManager;
import com.taobao.arthas.core.shell.term.impl.httptelnet.HttpTelnetTermServer;
import com.taobao.arthas.core.util.ArthasBanner;
import com.taobao.arthas.core.util.FileUtils;
import com.taobao.arthas.core.util.IPUtils;
import com.taobao.arthas.core.util.InstrumentationUtils;
import com.taobao.arthas.core.util.LogUtil;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.arthas.core.util.UserStatUtil;
import com.taobao.arthas.core.util.affect.EnhancerAffect;
import com.taobao.arthas.core.util.matcher.WildcardMatcher;
import com.taobao.arthas.core.mcp.ArthasMcpBootstrap;
import com.taobao.arthas.mcp.server.CommandExecutor;
import com.taobao.arthas.mcp.server.protocol.server.handler.McpHttpRequestHandler;
import io.netty.channel.ChannelFuture;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.util.concurrent.DefaultThreadFactory;
import io.netty.util.concurrent.EventExecutorGroup;
/**
* @author vlinux on 15/5/2.
* @author hengyunabc
*/
public class ArthasBootstrap {
private static final String ARTHAS_SPY_JAR = "arthas-spy.jar";
public static final String ARTHAS_HOME_PROPERTY = "arthas.home";
private static String ARTHAS_HOME = null;
public static final String CONFIG_NAME_PROPERTY = "arthas.config.name";
public static final String CONFIG_LOCATION_PROPERTY = "arthas.config.location";
public static final String CONFIG_OVERRIDE_ALL = "arthas.config.overrideAll";
private static ArthasBootstrap arthasBootstrap;
private ArthasEnvironment arthasEnvironment;
private Configure configure;
private AtomicBoolean isBindRef = new AtomicBoolean(false);
private Instrumentation instrumentation;
private InstrumentTransformer classLoaderInstrumentTransformer;
private Thread shutdown;
private ShellServer shellServer;
private ScheduledExecutorService executorService;
private SessionManager sessionManager;
private TunnelClient tunnelClient;
private File outputPath;
private static LoggerContext loggerContext;
private EventExecutorGroup workerGroup;
private Timer timer = new Timer("arthas-timer", true);
private TransformerManager transformerManager;
private ResultViewResolver resultViewResolver;
private HistoryManager historyManager;
private HttpApiHandler httpApiHandler;
private McpHttpRequestHandler mcpRequestHandler;
private ArthasMcpBootstrap arthasMcpBootstrap;
private HttpSessionManager httpSessionManager;
private SecurityAuthenticator securityAuthenticator;
private ArthasBootstrap(Instrumentation instrumentation, Map<String, String> args) throws Throwable {
this.instrumentation = instrumentation;
initFastjson();
// 1. initSpy()
initSpy();
// 2. ArthasEnvironment
initArthasEnvironment(args);
String outputPathStr = configure.getOutputPath();
if (outputPathStr == null) {
outputPathStr = ArthasConstants.ARTHAS_OUTPUT;
}
outputPath = new File(outputPathStr);
outputPath.mkdirs();
// 3. init logger
loggerContext = LogUtil.initLogger(arthasEnvironment);
// 4. 增强ClassLoader
enhanceClassLoader();
// 5. init beans
initBeans();
// 6. start agent server
bind(configure);
executorService = Executors.newScheduledThreadPool(1, new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
final Thread t = new Thread(r, "arthas-command-execute");
t.setDaemon(true);
return t;
}
});
shutdown = new Thread("as-shutdown-hooker") {
@Override
public void run() {
ArthasBootstrap.this.destroy();
}
};
transformerManager = new TransformerManager(instrumentation);
Runtime.getRuntime().addShutdownHook(shutdown);
}
private void initFastjson() {
// ignore getter error #1661
// #2081
JSON.config(JSONWriter.Feature.IgnoreErrorGetter, JSONWriter.Feature.WriteNonStringKeyAsString);
}
private void initBeans() {
this.resultViewResolver = new ResultViewResolver();
this.historyManager = new HistoryManagerImpl();
}
private void initSpy() throws Throwable {
// TODO init SpyImpl ?
// 将Spy添加到BootstrapClassLoader
ClassLoader parent = ClassLoader.getSystemClassLoader().getParent();
Class<?> spyClass = null;
if (parent != null) {
try {
spyClass =parent.loadClass("java.arthas.SpyAPI");
} catch (Throwable e) {
// ignore
}
}
if (spyClass == null) {
CodeSource codeSource = ArthasBootstrap.class.getProtectionDomain().getCodeSource();
if (codeSource != null) {
File arthasCoreJarFile = new File(codeSource.getLocation().toURI().getSchemeSpecificPart());
File spyJarFile = new File(arthasCoreJarFile.getParentFile(), ARTHAS_SPY_JAR);
instrumentation.appendToBootstrapClassLoaderSearch(new JarFile(spyJarFile));
} else {
throw new IllegalStateException("can not find " + ARTHAS_SPY_JAR);
}
}
}
void enhanceClassLoader() throws IOException, UnmodifiableClassException {
if (configure.getEnhanceLoaders() == null) {
return;
}
Set<String> loaders = new HashSet<String>();
for (String s : configure.getEnhanceLoaders().split(",")) {
loaders.add(s.trim());
}
// 增强 ClassLoader#loadClsss ，解决一些ClassLoader加载不到 SpyAPI的问题
// https://github.com/alibaba/arthas/issues/1596
byte[] classBytes = IOUtils.getBytes(ArthasBootstrap.class.getClassLoader()
.getResourceAsStream(ClassLoader_Instrument.class.getName().replace('.', '/') + ".class"));
SimpleClassMatcher matcher = new SimpleClassMatcher(loaders);
InstrumentConfig instrumentConfig = new InstrumentConfig(AsmUtils.toClassNode(classBytes), matcher);
InstrumentParseResult instrumentParseResult = new InstrumentParseResult();
instrumentParseResult.addInstrumentConfig(instrumentConfig);
classLoaderInstrumentTransformer = new InstrumentTransformer(instrumentParseResult);
instrumentation.addTransformer(classLoaderInstrumentTransformer, true);
if (loaders.size() == 1 && loaders.contains(ClassLoader.class.getName())) {
// 如果只增强 java.lang.ClassLoader，可以减少查找过程
instrumentation.retransformClasses(ClassLoader.class);
} else {
InstrumentationUtils.trigerRetransformClasses(instrumentation, loaders);
}
}
private void initArthasEnvironment(Map<String, String> argsMap) throws IOException {
if (arthasEnvironment == null) {
arthasEnvironment = new ArthasEnvironment();
}
/**
* <pre>
* 脚本里传过来的配置项，即命令行参数 > System Env > System Properties > arthas.properties
* arthas.properties 提供一个配置项，可以反转优先级。 arthas.config.overrideAll=true
* https://github.com/alibaba/arthas/issues/986
* </pre>
*/
Map<String, Object> copyMap;
if (argsMap != null) {
copyMap = new HashMap<String, Object>(argsMap);
// 添加 arthas.home
if (!copyMap.containsKey(ARTHAS_HOME_PROPERTY)) {
copyMap.put(ARTHAS_HOME_PROPERTY, arthasHome());
}
} else {
copyMap = new HashMap<String, Object>(1);
copyMap.put(ARTHAS_HOME_PROPERTY, arthasHome());
}
MapPropertySource mapPropertySource = new MapPropertySource("args", copyMap);
arthasEnvironment.addFirst(mapPropertySource);
tryToLoadArthasProperties();
configure = new Configure();
BinderUtils.inject(arthasEnvironment, configure);
}
private static String arthasHome() {
if (ARTHAS_HOME != null) {
return ARTHAS_HOME;
}
CodeSource codeSource = ArthasBootstrap.class.getProtectionDomain().getCodeSource();
if (codeSource != null) {
try {
ARTHAS_HOME = new File(codeSource.getLocation().toURI().getSchemeSpecificPart()).getParentFile().getAbsolutePath();
} catch (Throwable e) {
AnsiLog.error("try to find arthas.home from CodeSource error", e);
}
}
if (ARTHAS_HOME == null) {
ARTHAS_HOME = new File("").getAbsolutePath();
}
return ARTHAS_HOME;
}
static String reslove(ArthasEnvironment arthasEnvironment, String key, String defaultValue) {
String value = arthasEnvironment.getProperty(key);
if (value == null) {
return defaultValue;
}
return arthasEnvironment.resolvePlaceholders(value);
}
// try to load arthas.properties
private void tryToLoadArthasProperties() throws IOException {
this.arthasEnvironment.resolvePlaceholders(CONFIG_LOCATION_PROPERTY);
String location = reslove(arthasEnvironment, CONFIG_LOCATION_PROPERTY, null);
if (location == null) {
location = arthasHome();
}
String configName = reslove(arthasEnvironment, CONFIG_NAME_PROPERTY, "arthas");
if (location != null) {
if (!location.endsWith(".properties")) {
location = new File(location, configName + ".properties").getAbsolutePath();
}
if (new File(location).exists()) {
Properties properties = FileUtils.readProperties(location);
boolean overrideAll = false;
if (arthasEnvironment.containsProperty(CONFIG_OVERRIDE_ALL)) {
overrideAll = arthasEnvironment.getRequiredProperty(CONFIG_OVERRIDE_ALL, boolean.class);
} else {
overrideAll = Boolean.parseBoolean(properties.getProperty(CONFIG_OVERRIDE_ALL, "false"));
}
PropertySource<?> propertySource = new PropertiesPropertySource(location, properties);
if (overrideAll) {
arthasEnvironment.addFirst(propertySource);
} else {
arthasEnvironment.addLast(propertySource);
}
}
}
}
/**
* Bootstrap arthas server
*
* @param configure 配置信息
* @throws IOException 服务器启动失败
*/
private void bind(Configure configure) throws Throwable {
long start = System.currentTimeMillis();
if (!isBindRef.compareAndSet(false, true)) {
throw new IllegalStateException("already bind");
}
// init random port
if (configure.getTelnetPort() != null && configure.getTelnetPort() == 0) {
int newTelnetPort = SocketUtils.findAvailableTcpPort();
configure.setTelnetPort(newTelnetPort);
logger().info("generate random telnet port: " + newTelnetPort);
}
if (configure.getHttpPort() != null && configure.getHttpPort() == 0) {
int newHttpPort = SocketUtils.findAvailableTcpPort();
configure.setHttpPort(newHttpPort);
logger().info("generate random http port: " + newHttpPort);
}
// try to find appName
if (configure.getAppName() == null) {
configure.setAppName(System.getProperty(ArthasConstants.PROJECT_NAME,
System.getProperty(ArthasConstants.SPRING_APPLICATION_NAME, null)));
}
try {
if (configure.getTunnelServer() != null) {
tunnelClient = new TunnelClient();
tunnelClient.setAppName(configure.getAppName());
tunnelClient.setId(configure.getAgentId());
tunnelClient.setTunnelServerUrl(configure.getTunnelServer());
tunnelClient.setVersion(ArthasBanner.version());
ChannelFuture channelFuture = tunnelClient.start();
channelFuture.await(10, TimeUnit.SECONDS);
}
} catch (Throwable t) {
logger().error("start tunnel client error", t);
}
try {
ShellServerOptions options = new ShellServerOptions()
.setInstrumentation(instrumentation)
.setPid(PidUtils.currentLongPid())
.setWelcomeMessage(ArthasBanner.welcome());
if (configure.getSessionTimeout() != null) {
options.setSessionTimeout(configure.getSessionTimeout() * 1000);
}
this.httpSessionManager = new HttpSessionManager();
if (IPUtils.isAllZeroIP(configure.getIp()) && StringUtils.isBlank(configure.getPassword())) {
// 当 listen 0.0.0.0 时，强制生成密码，防止被远程连接
String errorMsg = "Listening on 0.0.0.0 is very dangerous! External users can connect to your machine! "
+ "No password is currently configured. " + "Therefore, a default password is generated, "
+ "and clients need to use the password to connect!";
AnsiLog.error(errorMsg);
configure.setPassword(StringUtils.randomString(64));
AnsiLog.error("Generated arthas password: " + configure.getPassword());
logger().error(errorMsg);
logger().info("Generated arthas password: " + configure.getPassword());
}
this.securityAuthenticator = new SecurityAuthenticatorImpl(configure.getUsername(), configure.getPassword());
shellServer = new ShellServerImpl(options);
List<String> disabledCommands = new ArrayList<String>();
if (configure.getDisabledCommands() != null) {
String[] strings = StringUtils.tokenizeToStringArray(configure.getDisabledCommands(), ",");
if (strings != null) {
disabledCommands.addAll(Arrays.asList(strings));
}
}
BuiltinCommandPack builtinCommands = new BuiltinCommandPack(disabledCommands);
List<CommandResolver> resolvers = new ArrayList<CommandResolver>();
resolvers.add(builtinCommands);
//worker group
workerGroup = new NioEventLoopGroup(new DefaultThreadFactory("arthas-TermServer", true));
// TODO: discover user provided command resolver
if (configure.getTelnetPort() != null && configure.getTelnetPort() > 0) {
logger().info("try to bind telnet server, host: {}, port: {}.", configure.getIp(), configure.getTelnetPort());
shellServer.registerTermServer(new HttpTelnetTermServer(configure.getIp(), configure.getTelnetPort(),
options.getConnectionTimeout(), workerGroup, httpSessionManager));
} else {
logger().info("telnet port is {}, skip bind telnet server.", configure.getTelnetPort());
}
if (configure.getHttpPort() != null && configure.getHttpPort() > 0) {
logger().info("try to bind http server, host: {}, port: {}.", configure.getIp(), configure.getHttpPort());
shellServer.registerTermServer(new HttpTermServer(configure.getIp(), configure.getHttpPort(),
options.getConnectionTimeout(), workerGroup, httpSessionManager));
} else {
// listen local address in VM communication
if (configure.getTunnelServer() != null) {
shellServer.registerTermServer(new HttpTermServer(configure.getIp(), configure.getHttpPort(),
options.getConnectionTimeout(), workerGroup, httpSessionManager));
}
logger().info("http port is {}, skip bind http server.", configure.getHttpPort());
}
for (CommandResolver resolver : resolvers) {
shellServer.registerCommandResolver(resolver);
}
shellServer.listen(new BindHandler(isBindRef));
if (!isBind()) {
throw new IllegalStateException("Arthas failed to bind telnet or http port! Telnet port: "
+ String.valueOf(configure.getTelnetPort()) + ", http port: "
+ String.valueOf(configure.getHttpPort()));
}
//http api session manager
sessionManager = new SessionManagerImpl(options, shellServer.getCommandManager(), shellServer.getJobController());
//http api handler
httpApiHandler = new HttpApiHandler(historyManager, sessionManager);
// Mcp Server
String mcpEndpoint = configure.getMcpEndpoint();
String mcpProtocol = configure.getMcpProtocol();
if (mcpEndpoint != null && !mcpEndpoint.trim().isEmpty()) {
logger().info("try to start mcp server, endpoint: {}, protocol: {}.", mcpEndpoint, mcpProtocol);
CommandExecutor commandExecutor = new CommandExecutorImpl(sessionManager);
this.arthasMcpBootstrap = new ArthasMcpBootstrap(commandExecutor, mcpEndpoint, mcpProtocol);
this.mcpRequestHandler = this.arthasMcpBootstrap.start().getMcpRequestHandler();
}
logger().info("as-server listening on network={};telnet={};http={};timeout={};mcp={};mcpProtocol={};", configure.getIp(),
configure.getTelnetPort(), configure.getHttpPort(), options.getConnectionTimeout(), configure.getMcpEndpoint(), configure.getMcpProtocol());
// 异步回报启动次数
if (configure.getStatUrl() != null) {
logger().info("arthas stat url: {}", configure.getStatUrl());
}
UserStatUtil.setStatUrl(configure.getStatUrl());
UserStatUtil.setAgentId(configure.getAgentId());
UserStatUtil.arthasStart();
try {
SpyAPI.init();
} catch (Throwable e) {
// ignore
}
logger().info("as-server started in {} ms", System.currentTimeMillis() - start);
} catch (Throwable e) {
logger().error("Error during start as-server", e);
destroy();
throw e;
}
}
private void shutdownWorkGroup() {
if (workerGroup != null) {
workerGroup.shutdownGracefully(200, 200, TimeUnit.MILLISECONDS);
workerGroup = null;
}
}
/**
* 判断服务端是否已经启动
*
* @return true:服务端已经启动;false:服务端关闭
*/
public boolean isBind() {
return isBindRef.get();
}
public EnhancerAffect reset() throws UnmodifiableClassException {
return Enhancer.reset(this.instrumentation, new WildcardMatcher("*"));
}
/**
* call reset() before destroy()
*/
public void destroy() {
if (this.arthasMcpBootstrap != null) {
try {
// stop 时需要主动关闭 mcp keep-alive 调度线程，避免 stop 后残留线程导致 ArthasClassLoader 无法回收
this.arthasMcpBootstrap.shutdown();
} catch (Throwable e) {
logger().error("stop mcp server error", e);
} finally {
this.arthasMcpBootstrap = null;
this.mcpRequestHandler = null;
}
}
if (shellServer != null) {
shellServer.close();
shellServer = null;
}
if (sessionManager != null) {
sessionManager.close();
sessionManager = null;
}
if (this.httpSessionManager != null) {
httpSessionManager.stop();
}
if (timer != null) {
timer.cancel();
}
if (this.tunnelClient != null) {
try {
tunnelClient.stop();
} catch (Throwable e) {
logger().error("stop tunnel client error", e);
}
}
if (executorService != null) {
executorService.shutdownNow();
}
if (transformerManager != null) {
transformerManager.destroy();
}
if (classLoaderInstrumentTransformer != null) {
instrumentation.removeTransformer(classLoaderInstrumentTransformer);
}
// clear the reference in Spy class.
cleanUpSpyReference();
shutdownWorkGroup();
UserStatUtil.destroy();
if (shutdown != null) {
try {
Runtime.getRuntime().removeShutdownHook(shutdown);
} catch (Throwable t) {
// ignore
}
}
logger().info("as-server destroy completed.");
if (loggerContext != null) {
loggerContext.stop();
}
}
/**
* 单例
*
* @param instrumentation JVM增强
* @return ArthasServer单例
* @throws Throwable
*/
public synchronized static ArthasBootstrap getInstance(Instrumentation instrumentation, String args) throws Throwable {
if (arthasBootstrap != null) {
return arthasBootstrap;
}
Map<String, String> argsMap = FeatureCodec.DEFAULT_COMMANDLINE_CODEC.toMap(args);
// 给配置全加上前缀
Map<String, String> mapWithPrefix = new HashMap<String, String>(argsMap.size());
for (Entry<String, String> entry : argsMap.entrySet()) {
mapWithPrefix.put("arthas." + entry.getKey(), entry.getValue());
}
return getInstance(instrumentation, mapWithPrefix);
}
/**
* 单例
*
* @param instrumentation JVM增强
* @return ArthasServer单例
* @throws Throwable
*/
public synchronized static ArthasBootstrap getInstance(Instrumentation instrumentation, Map<String, String> args) throws Throwable {
if (arthasBootstrap == null) {
arthasBootstrap = new ArthasBootstrap(instrumentation, args);
}
return arthasBootstrap;
}
/**
* @return ArthasServer单例
*/
public static ArthasBootstrap getInstance() {
if (arthasBootstrap == null) {
throw new IllegalStateException("ArthasBootstrap must be initialized before!");
}
return arthasBootstrap;
}
public void execute(Runnable command) {
executorService.execute(command);
}
/**
* 清除SpyAPI里的引用
*/
private void cleanUpSpyReference() {
try {
SpyAPI.setNopSpy();
SpyAPI.destroy();
} catch (Throwable e) {
// ignore
}
// AgentBootstrap.resetArthasClassLoader();
try {
Class<?> clazz = ClassLoader.getSystemClassLoader().loadClass("com.taobao.arthas.agent334.AgentBootstrap");
Method method = clazz.getDeclaredMethod("resetArthasClassLoader");
method.invoke(null);
} catch (Throwable e) {
// ignore
}
}
public TunnelClient getTunnelClient() {
return tunnelClient;
}
public ShellServer getShellServer() {
return shellServer;
}
public SessionManager getSessionManager() {
return sessionManager;
}
public Timer getTimer() {
return this.timer;
}
public ScheduledExecutorService getScheduledExecutorService() {
return this.executorService;
}
public Instrumentation getInstrumentation() {
return this.instrumentation;
}
public TransformerManager getTransformerManager() {
return this.transformerManager;
}
private Logger logger() {
return LoggerFactory.getLogger(this.getClass());
}
public ResultViewResolver getResultViewResolver() {
return resultViewResolver;
}
public HistoryManager getHistoryManager() {
return historyManager;
}
public HttpApiHandler getHttpApiHandler() {
return httpApiHandler;
}
public McpHttpRequestHandler getMcpRequestHandler() {
return mcpRequestHandler;
}
public File getOutputPath() {
return outputPath;
}
public SecurityAuthenticator getSecurityAuthenticator() {
return securityAuthenticator;
}
public Configure getConfigure() {
return configure;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/server/instrument/ClassLoader_Instrument.java | core/src/main/java/com/taobao/arthas/core/server/instrument/ClassLoader_Instrument.java | package com.taobao.arthas.core.server.instrument;
import com.alibaba.bytekit.agent.inst.Instrument;
import com.alibaba.bytekit.agent.inst.InstrumentApi;
/**
* @see java.lang.ClassLoader#loadClass(String)
* @author hengyunabc 2020-11-30
*
*/
@Instrument(Class = "java.lang.ClassLoader")
public abstract class ClassLoader_Instrument {
public Class<?> loadClass(String name) throws ClassNotFoundException {
if (name.startsWith("java.arthas.")) {
ClassLoader extClassLoader = ClassLoader.getSystemClassLoader().getParent();
if (extClassLoader != null) {
return extClassLoader.loadClass(name);
}
}
Class clazz = InstrumentApi.invokeOrigin();
return clazz;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/config/Configure.java | core/src/main/java/com/taobao/arthas/core/config/Configure.java | package com.taobao.arthas.core.config;
import com.taobao.arthas.core.shell.ShellServerOptions;
import com.taobao.arthas.core.util.reflect.ArthasReflectUtils;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;
import static java.lang.reflect.Modifier.isStatic;
/**
* <pre>
* 配置类。
* 注意本类里的所有字段不能有默认值，否则会出现配置混乱。
* 在 com.taobao.arthas.core.Arthas#attach 里会调用 Configure#toStrig
* <pre>
*
* @author vlinux
* @author hengyunabc 2018-11-12
*/
@Config(prefix = "arthas")
public class Configure {
private String ip;
private Integer telnetPort;
private Integer httpPort;
private Long javaPid;
private String arthasCore;
private String arthasAgent;
private String tunnelServer;
private String agentId;
private String username;
private String password;
/**
* @see com.taobao.arthas.common.ArthasConstants#ARTHAS_OUTPUT
*/
private String outputPath;
/**
* 需要被增强的ClassLoader的全类名，多个用英文 , 分隔
*/
private String enhanceLoaders;
/**
* <pre>
* 1. 如果显式传入 arthas.agentId ，则直接使用
* 2. 如果用户没有指定，则自动尝试在查找应用的 appname，加为前缀，比如 system properties设置 project.name是 demo，则
* 生成的 agentId是 demo-xxxx
* </pre>
*/
private String appName;
/**
* report executed command
*/
private String statUrl;
/**
* session timeout seconds
* @see ShellServerOptions#DEFAULT_SESSION_TIMEOUT
*/
private Long sessionTimeout;
/**
* disabled commands
*/
private String disabledCommands;
/**
* 本地连接不需要鉴权，即使配置了password。arthas.properties 里默认为true
*/
private Boolean localConnectionNonAuth;
/**
* MCP (Model Context Protocol) endpoint path
*/
private String mcpEndpoint;
/**
* MCP Server Protocol: STREAMABLE or STATELESS
*/
private String mcpProtocol;
public String getIp() {
return ip;
}
public void setIp(String ip) {
this.ip = ip;
}
public Integer getTelnetPort() {
return telnetPort;
}
public void setTelnetPort(int telnetPort) {
this.telnetPort = telnetPort;
}
public void setHttpPort(int httpPort) {
this.httpPort = httpPort;
}
public Integer getHttpPort() {
return httpPort;
}
public long getJavaPid() {
return javaPid;
}
public void setJavaPid(long javaPid) {
this.javaPid = javaPid;
}
public String getArthasAgent() {
return arthasAgent;
}
public void setArthasAgent(String arthasAgent) {
this.arthasAgent = arthasAgent;
}
public String getArthasCore() {
return arthasCore;
}
public void setArthasCore(String arthasCore) {
this.arthasCore = arthasCore;
}
public Long getSessionTimeout() {
return sessionTimeout;
}
public void setSessionTimeout(long sessionTimeout) {
this.sessionTimeout = sessionTimeout;
}
public String getTunnelServer() {
return tunnelServer;
}
public void setTunnelServer(String tunnelServer) {
this.tunnelServer = tunnelServer;
}
public String getAgentId() {
return agentId;
}
public void setAgentId(String agentId) {
this.agentId = agentId;
}
public String getStatUrl() {
return statUrl;
}
public void setStatUrl(String statUrl) {
this.statUrl = statUrl;
}
public String getAppName() {
return appName;
}
public void setAppName(String appName) {
this.appName = appName;
}
public String getEnhanceLoaders() {
return enhanceLoaders;
}
public void setEnhanceLoaders(String enhanceLoaders) {
this.enhanceLoaders = enhanceLoaders;
}
public String getOutputPath() {
return outputPath;
}
public void setOutputPath(String outputPath) {
this.outputPath = outputPath;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public String getDisabledCommands() {
return disabledCommands;
}
public void setDisabledCommands(String disabledCommands) {
this.disabledCommands = disabledCommands;
}
public boolean isLocalConnectionNonAuth() {
return localConnectionNonAuth != null && localConnectionNonAuth;
}
public void setLocalConnectionNonAuth(boolean localConnectionNonAuth) {
this.localConnectionNonAuth = localConnectionNonAuth;
}
public String getMcpEndpoint() {
return mcpEndpoint;
}
public void setMcpEndpoint(String mcpEndpoint) {
this.mcpEndpoint = mcpEndpoint;
}
public String getMcpProtocol() {
return mcpProtocol;
}
public void setMcpProtocol(String mcpProtocol) {
this.mcpProtocol = mcpProtocol;
}
/**
* 序列化成字符串
*
* @return 序列化字符串
*/
@Override
public String toString() {
final Map<String, String> map = new HashMap<String, String>();
for (Field field : ArthasReflectUtils.getFields(Configure.class)) {
// 过滤掉静态类
if (isStatic(field.getModifiers())) {
continue;
}
// 非静态的才需要纳入非序列化过程
try {
Object fieldValue = ArthasReflectUtils.getFieldValueByField(this, field);
if (fieldValue != null) {
map.put(field.getName(), String.valueOf(fieldValue));
}
} catch (Throwable t) {
//
}
}
return FeatureCodec.DEFAULT_COMMANDLINE_CODEC.toString(map);
}
/**
* 反序列化字符串成对象
*
* @param toString 序列化字符串
* @return 反序列化的对象
*/
public static Configure toConfigure(String toString) throws IllegalAccessException {
final Configure configure = new Configure();
final Map<String, String> map = FeatureCodec.DEFAULT_COMMANDLINE_CODEC.toMap(toString);
for (Map.Entry<String, String> entry : map.entrySet()) {
final Field field = ArthasReflectUtils.getField(Configure.class, entry.getKey());
if (null != field && !isStatic(field.getModifiers())) {
ArthasReflectUtils.set(field, ArthasReflectUtils.valueOf(field.getType(), entry.getValue()), configure);
}
}
return configure;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/config/NestedConfig.java | core/src/main/java/com/taobao/arthas/core/config/NestedConfig.java | package com.taobao.arthas.core.config;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
*
* @author hengyunabc 2019-08-05
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface NestedConfig {
} | java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/config/Config.java | core/src/main/java/com/taobao/arthas/core/config/Config.java | package com.taobao.arthas.core.config;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
/**
*
* @author hengyunabc 2019-08-05
*
*/
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Config {
String prefix() default "";
} | java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/config/BinderUtils.java | core/src/main/java/com/taobao/arthas/core/config/BinderUtils.java | package com.taobao.arthas.core.config;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import com.taobao.arthas.core.env.Environment;
/**
*
* @author hengyunabc 2020-01-10
*
*/
public class BinderUtils {
public static void inject(Environment environment, Object instance) {
inject(environment, null, null, instance);
}
public static void inject(Environment environment, String prefix, Object instance) {
inject(environment, null, prefix, instance);
}
public static void inject(Environment environment, String parentPrefix, String prefix, Object instance) {
if (prefix == null) {
prefix = "";
}
Class<? extends Object> type = instance.getClass();
try {
Config annotation = type.getAnnotation(Config.class);
if (annotation == null) {
prefix = parentPrefix + '.' + prefix;
} else {
prefix = annotation.prefix();
if (prefix != null) {
if (parentPrefix != null && parentPrefix.length() > 0) {
prefix = parentPrefix + '.' + prefix;
}
}
}
Method[] declaredMethods = type.getDeclaredMethods();
// 获取到所有setter方法，再提取出field。根据前缀从 properties里取出值，再尝试用setter方法注入到对象里
for (Method method : declaredMethods) {
String methodName = method.getName();
Class<?>[] parameterTypes = method.getParameterTypes();
if (parameterTypes.length == 1 && methodName.startsWith("set") && methodName.length() > "set".length()) {
String field = getFieldNameFromSetterMethod(methodName);
String configKey = prefix + '.' + field;
if (environment.containsProperty(configKey)) {
Object reslovedValue = environment.getProperty(prefix + '.' + field, parameterTypes[0]);
if (reslovedValue != null) {
method.invoke(instance, new Object[] { reslovedValue });
}
}
}
}
} catch (Exception e) {
throw new RuntimeException("inject error. prefix: " + prefix + ", instance: " + instance, e);
}
// process @NestedConfig
Field[] fields = type.getDeclaredFields();
for (Field field : fields) {
NestedConfig nestedConfig = field.getAnnotation(NestedConfig.class);
if (nestedConfig != null) {
String prefixForField = field.getName();
if (parentPrefix != null && prefix.length() > 0) {
prefixForField = prefix + '.' + prefixForField;
}
field.setAccessible(true);
try {
Object fieldValue = field.get(instance);
if (fieldValue == null) {
fieldValue = field.getType().newInstance();
}
inject(environment, prefix, prefixForField, fieldValue);
field.set(instance, fieldValue);
} catch (Exception e) {
throw new RuntimeException("process @NestedConfig error, field: " + field + ", prefix: "
+ prefix + ", instance: " + instance, e);
}
}
}
}
/**
* 从setter方法获取到field的String。比如 setHost， 则获取到的是host。
*
* @param methodName
* @return
*/
private static String getFieldNameFromSetterMethod(String methodName) {
String field = methodName.substring("set".length());
String startPart = field.substring(0, 1).toLowerCase();
String endPart = field.substring(1);
field = startPart + endPart;
return field;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/config/FeatureCodec.java | core/src/main/java/com/taobao/arthas/core/config/FeatureCodec.java | package com.taobao.arthas.core.config;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.Stack;
import static com.taobao.arthas.core.util.ArthasCheckUtils.isEquals;
import static com.taobao.arthas.core.util.ArthasCheckUtils.isIn;
import static com.taobao.arthas.core.util.StringUtils.isBlank;
/**
* Feature编解器(线程安全)<br/>
* <p/>
* 用于封装系统内部features/attribute等扩展字段的管理
* Created by dukun on 15/3/31.
*/
public class FeatureCodec {
// 对象的编码解码器
public final static FeatureCodec DEFAULT_COMMANDLINE_CODEC = new FeatureCodec(';', '=');
/**
* KV片段分割符<br/>
* KV片段定义为一个完整的KV对，例如字符串<span>;k1=v1;k2=v2;</span>
* 其中<b>;</b>即为KV片段分隔符
*/
private final char kvSegmentSeparator;
/**
* KV分割符<br/>
* KV定义为一个KV对区分K和V的分割符号，例如字符串<span>k1=v1</span>
* 其中<b>=</b>即为KV分隔符
*/
private final char kvSeparator;
/**
* 转义前缀符
*/
private static final char ESCAPE_PREFIX_CHAR = '\\';
/**
* 使用指定的KV分割符构造FeatureParser<br/>
*
* @param kvSegmentSeparator KV对之间的分隔符
* @param kvSeparator K与V之间的分隔符
*/
public FeatureCodec(final char kvSegmentSeparator, final char kvSeparator) {
// 分隔符禁止与转义前缀符相等
if (isIn(ESCAPE_PREFIX_CHAR, kvSegmentSeparator, kvSeparator)) {
throw new IllegalArgumentException("separator can not init to '" + ESCAPE_PREFIX_CHAR + "'.");
}
this.kvSegmentSeparator = kvSegmentSeparator;
this.kvSeparator = kvSeparator;
}
/**
* map集合转换到feature字符串
*
* @param map map集合
* @return feature字符串
*/
public String toString(final Map<String, String> map) {
final StringBuilder featureSB = new StringBuilder().append(kvSegmentSeparator);
if (null == map
|| map.isEmpty()) {
return featureSB.toString();
}
for (Map.Entry<String, String> entry : map.entrySet()) {
featureSB
.append(escapeEncode(entry.getKey()))
.append(kvSeparator)
.append(escapeEncode(entry.getValue()))
.append(kvSegmentSeparator)
;
}
return featureSB.toString();
}
/**
* feature字符串转换到map集合
*
* @param featureString the feature string
* @return the map
*/
public Map<String, String> toMap(final String featureString) {
final Map<String, String> map = new HashMap<String, String>();
if (isBlank(featureString)) {
return map;
}
for (String kv : escapeSplit(featureString, kvSegmentSeparator)) {
if (isBlank(kv)) {
// 过滤掉为空的字符串片段
continue;
}
final String[] ar = escapeSplit(kv, kvSeparator);
if (ar.length != 2) {
// 过滤掉不符合K:V单目的情况
continue;
}
final String k = ar[0];
final String v = ar[1];
if (!isBlank(k)
&& !isBlank(v)) {
map.put(escapeDecode(k), escapeDecode(v));
}
}
return map;
}
/**
* 转义编码
*
* @param string 原始字符串
* @return 转义编码后的字符串
*/
private String escapeEncode(final String string) {
final StringBuilder returnSB = new StringBuilder();
for (final char c : string.toCharArray()) {
if (isIn(c, kvSegmentSeparator, kvSeparator, ESCAPE_PREFIX_CHAR)) {
returnSB.append(ESCAPE_PREFIX_CHAR);
}
returnSB.append(c);
}
return returnSB.toString();
}
/**
* 转义解码
*
* @param string 编码字符串
* @return 转义解码后的字符串
*/
private String escapeDecode(String string) {
final StringBuilder segmentSB = new StringBuilder();
final int stringLength = string.length();
for (int index = 0; index < stringLength; index++) {
final char c = string.charAt(index);
if (isEquals(c, ESCAPE_PREFIX_CHAR)
&& index < stringLength - 1) {
final char nextChar = string.charAt(++index);
// 下一个字符是转义符
if (isIn(nextChar, kvSegmentSeparator, kvSeparator, ESCAPE_PREFIX_CHAR)) {
segmentSB.append(nextChar);
}
// 如果不是转义字符，则需要两个都放入
else {
segmentSB.append(c);
segmentSB.append(nextChar);
}
} else {
segmentSB.append(c);
}
}
return segmentSB.toString();
}
/**
* 编码字符串拆分
*
* @param string 编码字符串
* @param splitEscapeChar 分割符
* @return 拆分后的字符串数组
*/
private String[] escapeSplit(String string, char splitEscapeChar) {
final ArrayList<String> segmentArrayList = new ArrayList<String>();
final Stack<Character> decodeStack = new Stack<Character>();
final int stringLength = string.length();
for (int index = 0; index < stringLength; index++) {
boolean isArchive = false;
final char c = string.charAt(index);
// 匹配到转义前缀符
if (isEquals(c, ESCAPE_PREFIX_CHAR)) {
decodeStack.push(c);
if (index < stringLength - 1) {
final char nextChar = string.charAt(++index);
decodeStack.push(nextChar);
}
}
// 匹配到分割符
else if (isEquals(c, splitEscapeChar)) {
isArchive = true;
}
// 匹配到其他字符
else {
decodeStack.push(c);
}
if (isArchive
|| index == stringLength - 1) {
final StringBuilder segmentSB = new StringBuilder(decodeStack.size());
while (!decodeStack.isEmpty()) {
segmentSB.append(decodeStack.pop());
}
segmentArrayList.add(
segmentSB
.reverse() // 因为堆栈中是逆序的,所以需要对逆序的字符串再次逆序
.toString() // toString
.trim() // 考虑到字符串片段可能会出现首尾空格的场景，这里做一个过滤
);
}
}
return segmentArrayList.toArray(new String[0]);
}
} | java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/Shell.java | core/src/main/java/com/taobao/arthas/core/shell/Shell.java | package com.taobao.arthas.core.shell;
import com.taobao.arthas.core.shell.cli.CliToken;
import com.taobao.arthas.core.shell.session.Session;
import com.taobao.arthas.core.shell.system.Job;
import com.taobao.arthas.core.shell.system.JobController;
import java.util.List;
/**
* An interactive session between a consumer and a shell.
*
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
*/
public interface Shell {
/**
* Create a job, the created job should then be executed with the {@link Job#run()} method.
*
* @param line the command line creating this job
* @return the created job
*/
Job createJob(List<CliToken> line);
/**
* See {@link #createJob(List)}
*/
Job createJob(String line);
/**
* @return the shell's job controller
*/
JobController jobController();
/**
* @return the current shell session
*/
Session session();
/**
* Close the shell.
*/
void close(String reason);
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/ShellServer.java | core/src/main/java/com/taobao/arthas/core/shell/ShellServer.java | package com.taobao.arthas.core.shell;
import com.taobao.arthas.core.shell.command.CommandResolver;
import com.taobao.arthas.core.shell.future.Future;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.arthas.core.shell.handlers.NoOpHandler;
import com.taobao.arthas.core.shell.impl.ShellServerImpl;
import com.taobao.arthas.core.shell.system.impl.InternalCommandManager;
import com.taobao.arthas.core.shell.system.impl.JobControllerImpl;
import com.taobao.arthas.core.shell.term.Term;
import com.taobao.arthas.core.shell.term.TermServer;
/**
* The shell server.<p/>
* <p>
* A shell server is associated with a collection of {@link TermServer term servers}: the {@link #registerTermServer(TermServer)}
* method registers a term server. Term servers life cycle are managed by this server.<p/>
* <p>
* When a {@link TermServer term server} receives an incoming connection, a {@link com.taobao.arthas.core.shell.system.JobController} instance is created and
* associated with this connection.<p/>
* <p>
* The {@link #createShell()} method can be used to create {@link com.taobao.arthas.core.shell.system.JobController} instance for testing purposes.
*
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
*/
public abstract class ShellServer {
/**
* Create a new shell server with default options.
*
* @param options the options
* @return the created shell server
*/
public static ShellServer create(ShellServerOptions options) {
return new ShellServerImpl(options);
}
/**
* Create a new shell server with specific options.
*
* @return the created shell server
*/
public static ShellServer create() {
return new ShellServerImpl(new ShellServerOptions());
}
/**
* Register a command resolver for this server.
*
* @param resolver the resolver
* @return a reference to this, so the API can be used fluently
*/
public abstract ShellServer registerCommandResolver(CommandResolver resolver);
/**
* Register a term server to this shell server, the term server lifecycle methods are managed by this shell server.
*
* @param termServer the term server to add
* @return a reference to this, so the API can be used fluently
*/
public abstract ShellServer registerTermServer(TermServer termServer);
/**
* Create a new shell, the returned shell should be closed explicitly.
*
* @param term the shell associated terminal
* @return the created shell
*/
public abstract Shell createShell(Term term);
/**
* Create a new shell, the returned shell should be closed explicitly.
*
* @return the created shell
*/
public abstract Shell createShell();
/**
* Start the shell service, this is an asynchronous start.
*/
public ShellServer listen() {
return listen(new NoOpHandler<Future<Void>>());
}
/**
* Start the shell service, this is an asynchronous start.
*
* @param listenHandler handler for getting notified when service is started
*/
public abstract ShellServer listen(Handler<Future<Void>> listenHandler);
/**
* Close the shell server, this is an asynchronous close.
*/
public void close() {
close(new NoOpHandler<Future<Void>>());
}
/**
* Close the shell server, this is an asynchronous close.
*
* @param completionHandler handler for getting notified when service is stopped
*/
public abstract void close(Handler<Future<Void>> completionHandler);
/**
* @return global job controller instance
*/
public abstract JobControllerImpl getJobController();
/**
* @return get command manager instance
*/
public abstract InternalCommandManager getCommandManager();
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/ShellServerOptions.java | core/src/main/java/com/taobao/arthas/core/shell/ShellServerOptions.java | package com.taobao.arthas.core.shell;
import com.taobao.arthas.core.util.ArthasBanner;
import java.lang.instrument.Instrumentation;
/**
* The configurations options for the shell server.
*
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
*/
public class ShellServerOptions {
/**
* Default of how often, in ms, to check for expired sessions
*/
public static final long DEFAULT_REAPER_INTERVAL = 60 * 1000; // 60 seconds
/**
* Default time, in ms, that a shell session lasts for without being accessed before expiring.
*/
public static final long DEFAULT_SESSION_TIMEOUT = 30 * 60 * 1000; // 30 minutes
/**
* Default time, in ms, that a server waits for a client to connect
*/
public static final long DEFAULT_CONNECTION_TIMEOUT = 6000; // 6 seconds
public static final String DEFAULT_WELCOME_MESSAGE = ArthasBanner.welcome();
public static final String DEFAULT_INPUTRC = "com/taobao/arthas/core/shell/term/readline/inputrc";
private String welcomeMessage;
private long sessionTimeout;
private long reaperInterval;
private long connectionTimeout;
private long pid;
private Instrumentation instrumentation;
public ShellServerOptions() {
welcomeMessage = DEFAULT_WELCOME_MESSAGE;
sessionTimeout = DEFAULT_SESSION_TIMEOUT;
connectionTimeout = DEFAULT_CONNECTION_TIMEOUT;
reaperInterval = DEFAULT_REAPER_INTERVAL;
}
/**
* @return the shell welcome message
*/
public String getWelcomeMessage() {
return welcomeMessage;
}
/**
* Set the shell welcome message, i.e the message displayed in the user console when he connects to the shell.
*
* @param welcomeMessage the welcome message
* @return a reference to this, so the API can be used fluently
*/
public ShellServerOptions setWelcomeMessage(String welcomeMessage) {
this.welcomeMessage = welcomeMessage;
return this;
}
/**
* @return the session timeout
*/
public long getSessionTimeout() {
return sessionTimeout;
}
/**
* Set the session timeout.
*
* @param sessionTimeout the new session timeout
* @return a reference to this, so the API can be used fluently
*/
public ShellServerOptions setSessionTimeout(long sessionTimeout) {
this.sessionTimeout = sessionTimeout;
return this;
}
/**
* @return the reaper interval
*/
public long getReaperInterval() {
return reaperInterval;
}
/**
* Set the repear interval, i.e the period at which session eviction is performed.
*
* @param reaperInterval the new repeat interval
* @return a reference to this, so the API can be used fluently
*/
public ShellServerOptions setReaperInterval(long reaperInterval) {
this.reaperInterval = reaperInterval;
return this;
}
public ShellServerOptions setPid(long pid) {
this.pid = pid;
return this;
}
public ShellServerOptions setInstrumentation(Instrumentation instrumentation) {
this.instrumentation = instrumentation;
return this;
}
public long getPid() {
return pid;
}
public Instrumentation getInstrumentation() {
return instrumentation;
}
public long getConnectionTimeout() {
return connectionTimeout;
}
public void setConnectionTimeout(long connectionTimeout) {
this.connectionTimeout = connectionTimeout;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/system/Process.java | core/src/main/java/com/taobao/arthas/core/shell/system/Process.java | package com.taobao.arthas.core.shell.system;
import java.util.Date;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.arthas.core.shell.session.Session;
import com.taobao.arthas.core.shell.term.Tty;
/**
* A process managed by the shell.
*
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
*/
public interface Process {
/**
* @return the current process status
*/
ExecStatus status();
/**
* @return the process exit code when the status is {@link ExecStatus#TERMINATED} otherwise {@code null}
*/
Integer exitCode();
/**
* Set the process tty.
*
* @param tty the process tty
* @return this object
*/
Process setTty(Tty tty);
/**
* @return the process tty
*/
Tty getTty();
/**
* Set the process session
*
* @param session the process session
* @return this object
*/
Process setSession(Session session);
/**
* @return the process session
*/
Session getSession();
/**
* Set an handler for being notified when the process terminates.
*
* @param handler the handler called when the process terminates.
* @return this object
*/
Process terminatedHandler(Handler<Integer> handler);
/**
* Run the process.
*/
void run();
/**
* Run the process.
*/
void run(boolean foreground);
/**
* Attempt to interrupt the process.
*
* @return true if the process caught the signal
*/
boolean interrupt();
/**
* Attempt to interrupt the process.
*
* @param completionHandler handler called after interrupt callback
* @return true if the process caught the signal
*/
boolean interrupt(Handler<Void> completionHandler);
/**
* Suspend the process.
*/
void resume();
/**
* Suspend the process.
*/
void resume(boolean foreground);
/**
* Suspend the process.
*
* @param completionHandler handler called after resume callback
*/
void resume(Handler<Void> completionHandler);
/**
* Suspend the process.
*
* @param completionHandler handler called after resume callback
*/
void resume(boolean foreground, Handler<Void> completionHandler);
/**
* Resume the process.
*/
void suspend();
/**
* Resume the process.
*
* @param completionHandler handler called after suspend callback
*/
void suspend(Handler<Void> completionHandler);
/**
* Terminate the process.
*/
void terminate();
/**
* Terminate the process.
*
* @param completionHandler handler called after end callback
*/
void terminate(Handler<Void> completionHandler);
/**
* Set the process in background.
*/
void toBackground();
/**
* Set the process in background.
*
* @param completionHandler handler called after background callback
*/
void toBackground(Handler<Void> completionHandler);
/**
* Set the process in foreground.
*/
void toForeground();
/**
* Set the process in foreground.
*
* @param completionHandler handler called after foreground callback
*/
void toForeground(Handler<Void> completionHandler);
/**
* Execution times
*/
int times();
/**
* Build time
*/
Date startTime();
/**
* Get cache file location
*/
String cacheLocation();
/**
* Set job id
*
* @param jobId job id
*/
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/core/src/main/java/com/taobao/arthas/core/shell/system/ProcessAware.java | core/src/main/java/com/taobao/arthas/core/shell/system/ProcessAware.java | package com.taobao.arthas.core.shell.system;
/**
*
* @author hengyunabc 2020-05-18
*
*/
public interface ProcessAware {
public Process getProcess();
public void setProcess(Process process);
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/system/ExecStatus.java | core/src/main/java/com/taobao/arthas/core/shell/system/ExecStatus.java | package com.taobao.arthas.core.shell.system;
/**
* The status of an execution.
*
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
*/
public enum ExecStatus {
/**
* The job is ready, it can be running or terminated.
*/
READY,
/**
* The job is running, it can be stopped or terminated.
*/
RUNNING,
/**
* The job is stopped, it can be running or terminated.
*/
STOPPED,
/**
* The job is terminated.
*/
TERMINATED
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/system/Job.java | core/src/main/java/com/taobao/arthas/core/shell/system/Job.java | package com.taobao.arthas.core.shell.system;
import java.util.Date;
import com.taobao.arthas.core.shell.session.Session;
import com.taobao.arthas.core.shell.term.Tty;
/**
* A job executed in a {@link JobController}, grouping one or several process.<p/>
*
* The job life cycle can be controlled with the {@link #run}, {@link #resume} and {@link #suspend} and {@link #interrupt}
* methods.
*
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
*/
public interface Job {
/**
* @return the job id
*/
int id();
/**
* @return the job exec status
*/
ExecStatus status();
/**
* @return the execution line of the job, i.e the shell command line that launched this job
*/
String line();
/**
* Run the job, before running the job a {@link Tty} must be set.
*
* @return this object
*/
Job run();
/**
* Run the job, before running the job a {@link Tty} must be set.
*
* @return this object
*/
Job run(boolean foreground);
/**
* Attempt to interrupt the job.
*
* @return true if the job is actually interrupted
*/
boolean interrupt();
/**
* Resume the job to foreground.
*/
Job resume();
/**
* @return true if the job is running in background
*/
boolean isRunInBackground();
/**
* Send the job to background.
*
* @return this object
*/
Job toBackground();
/**
* Send the job to foreground.
*
* @return this object
*/
Job toForeground();
/**
* Resume the job.
*
* @param foreground true when the job is resumed in foreground
*/
Job resume(boolean foreground);
/**
* Resume the job.
*
* @return this object
*/
Job suspend();
/**
* Terminate the job.
*/
void terminate();
/**
* @return the first process in the job
*/
Process process();
/**
* @return the date with job timeout
*/
Date timeoutDate();
/**
* Set the date with job timeout
* @param date the date with job timeout
*/
void setTimeoutDate(Date date);
/**
* @return the session this job belongs to
*/
Session getSession();
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/system/JobListener.java | core/src/main/java/com/taobao/arthas/core/shell/system/JobListener.java | package com.taobao.arthas.core.shell.system;
/**
* Job listener
* @author gongdewei 2020-03-23
*/
public interface JobListener {
void onForeground(Job job);
void onBackground(Job job);
void onTerminated(Job job);
void onSuspend(Job job);
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/system/JobController.java | core/src/main/java/com/taobao/arthas/core/shell/system/JobController.java | package com.taobao.arthas.core.shell.system;
import com.taobao.arthas.core.distribution.ResultDistributor;
import com.taobao.arthas.core.shell.cli.CliToken;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.arthas.core.shell.session.Session;
import com.taobao.arthas.core.shell.system.impl.InternalCommandManager;
import com.taobao.arthas.core.shell.term.Term;
import java.util.List;
import java.util.Set;
/**
* The job controller.<p/>
*
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
*/
public interface JobController {
/**
* @return the active jobs
*/
Set<Job> jobs();
/**
* Returns an active job in this session by its {@literal id}.
*
* @param id the job id
* @return the job of {@literal null} when not found
*/
Job getJob(int id);
/**
* Create a job wrapping a process.
*
* @param commandManager command manager
* @param tokens the command tokens
* @param session the current session
* @param jobHandler job event handler
* @param term telnet term
* @param resultDistributor
* @return the created job
*/
Job createJob(InternalCommandManager commandManager, List<CliToken> tokens, Session session, JobListener jobHandler, Term term, ResultDistributor resultDistributor);
/**
* Close the controller and terminate all the underlying jobs, a closed controller does not accept anymore jobs.
*/
void close(Handler<Void> completionHandler);
/**
* Close the shell session and terminate all the underlying jobs.
*/
void close();
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/system/impl/CommandCompletion.java | core/src/main/java/com/taobao/arthas/core/shell/system/impl/CommandCompletion.java | package com.taobao.arthas.core.shell.system.impl;
import com.taobao.arthas.core.shell.cli.CliToken;
import com.taobao.arthas.core.shell.cli.Completion;
import com.taobao.arthas.core.shell.session.Session;
import java.util.List;
/**
* @author beiwei30 on 23/11/2016.
*/
class CommandCompletion implements Completion {
private final Completion completion;
private final String line;
private final List<CliToken> newTokens;
public CommandCompletion(Completion completion, String line, List<CliToken> newTokens) {
this.completion = completion;
this.line = line;
this.newTokens = newTokens;
}
@Override
public Session session() {
return completion.session();
}
@Override
public String rawLine() {
return line;
}
@Override
public List<CliToken> lineTokens() {
return newTokens;
}
@Override
public void complete(List<String> candidates) {
completion.complete(candidates);
}
@Override
public void complete(String value, boolean terminal) {
completion.complete(value, terminal);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/system/impl/InternalCommandManager.java | core/src/main/java/com/taobao/arthas/core/shell/system/impl/InternalCommandManager.java | package com.taobao.arthas.core.shell.system.impl;
import com.taobao.arthas.core.command.BuiltinCommandPack;
import com.taobao.arthas.core.shell.cli.CliToken;
import com.taobao.arthas.core.shell.cli.Completion;
import com.taobao.arthas.core.shell.cli.CompletionUtils;
import com.taobao.arthas.core.shell.command.Command;
import com.taobao.arthas.core.shell.command.CommandResolver;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
/**
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
*/
public class InternalCommandManager {
private final List<CommandResolver> resolvers;
public InternalCommandManager(CommandResolver... resolvers) {
this.resolvers = Arrays.asList(resolvers);
}
public InternalCommandManager(List<CommandResolver> resolvers) {
this.resolvers = resolvers;
}
public List<CommandResolver> getResolvers() {
return resolvers;
}
public Command getCommand(String commandName) {
Command command = null;
for (CommandResolver resolver : resolvers) {
// 内建命令在ShellLineHandler里提前处理了，所以这里不需要再查找内建命令
if (resolver instanceof BuiltinCommandPack) {
command = getCommand(resolver, commandName);
if (command != null) {
break;
}
}
}
return command;
}
/**
* Perform completion, the completion argument will be notified of the completion progress.
*
* @param completion the completion object
*/
public void complete(final Completion completion) {
List<CliToken> lineTokens = completion.lineTokens();
int index = findLastPipe(lineTokens);
LinkedList<CliToken> tokens = new LinkedList<CliToken>(lineTokens.subList(index + 1, lineTokens.size()));
// Remove any leading white space
while (tokens.size() > 0 && tokens.getFirst().isBlank()) {
tokens.removeFirst();
}
// > 1 means it's a text token followed by something else
if (tokens.size() > 1) {
completeSingleCommand(completion, tokens);
} else {
completeCommands(completion, tokens);
}
}
private void completeCommands(Completion completion, LinkedList<CliToken> tokens) {
String prefix = tokens.size() > 0 ? tokens.getFirst().value() : "";
List<String> names = new LinkedList<String>();
for (CommandResolver resolver : resolvers) {
for (Command command : resolver.commands()) {
String name = command.name();
boolean hidden = command.cli() != null && command.cli().isHidden();
if (name.startsWith(prefix) && !names.contains(name) && !hidden) {
names.add(name);
}
}
}
if (names.size() == 1) {
completion.complete(names.get(0).substring(prefix.length()), true);
} else {
String commonPrefix = CompletionUtils.findLongestCommonPrefix(names);
if (commonPrefix.length() > prefix.length()) {
completion.complete(commonPrefix.substring(prefix.length()), false);
} else {
completion.complete(names);
}
}
}
private void completeSingleCommand(Completion completion, LinkedList<CliToken> tokens) {
ListIterator<CliToken> it = tokens.listIterator();
while (it.hasNext()) {
CliToken ct = it.next();
it.remove();
if (ct.isText()) {
final List<CliToken> newTokens = new ArrayList<CliToken>();
while (it.hasNext()) {
newTokens.add(it.next());
}
StringBuilder tmp = new StringBuilder();
for (CliToken token : newTokens) {
tmp.append(token.raw());
}
final String line = tmp.toString();
for (CommandResolver resolver : resolvers) {
Command command = getCommand(resolver, ct.value());
if (command != null) {
command.complete(new CommandCompletion(completion, line, newTokens));
return;
}
}
completion.complete(Collections.<String>emptyList());
}
}
}
private static Command getCommand(CommandResolver commandResolver, String name) {
List<Command> commands = commandResolver.commands();
if (commands == null || commands.isEmpty()) {
return null;
}
for (Command command : commands) {
if (name.equals(command.name())) {
return command;
}
}
return null;
}
private static int findLastPipe(List<CliToken> lineTokens) {
int index = -1;
for (int i = 0; i < lineTokens.size(); i++) {
if ("|".equals(lineTokens.get(i).value())) {
index = i;
}
}
return index;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/system/impl/GlobalJobControllerImpl.java | core/src/main/java/com/taobao/arthas/core/shell/system/impl/GlobalJobControllerImpl.java | package com.taobao.arthas.core.shell.system.impl;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.GlobalOptions;
import com.taobao.arthas.core.distribution.ResultDistributor;
import com.taobao.arthas.core.server.ArthasBootstrap;
import com.taobao.arthas.core.shell.cli.CliToken;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.arthas.core.shell.session.Session;
import com.taobao.arthas.core.shell.system.Job;
import com.taobao.arthas.core.shell.system.JobListener;
import com.taobao.arthas.core.shell.term.Term;
/**
* 全局的Job Controller，不应该存在启停的概念，不需要在连接的断开时关闭，
*
* @author gehui 2017年7月31日 上午11:55:41
*/
public class GlobalJobControllerImpl extends JobControllerImpl {
private Map<Integer, JobTimeoutTask> jobTimeoutTaskMap = new ConcurrentHashMap<Integer, JobTimeoutTask>();
private static final Logger logger = LoggerFactory.getLogger(GlobalJobControllerImpl.class);
@Override
public void close(final Handler<Void> completionHandler) {
if (completionHandler != null) {
completionHandler.handle(null);
}
}
@Override
public void close() {
jobTimeoutTaskMap.clear();
for (Job job : jobs()) {
job.terminate();
}
}
@Override
public boolean removeJob(int id) {
JobTimeoutTask jobTimeoutTask = jobTimeoutTaskMap.remove(id);
if (jobTimeoutTask != null) {
jobTimeoutTask.cancel();
}
return super.removeJob(id);
}
@Override
public Job createJob(InternalCommandManager commandManager, List<CliToken> tokens, Session session, JobListener jobHandler, Term term, ResultDistributor resultDistributor) {
final Job job = super.createJob(commandManager, tokens, session, jobHandler, term, resultDistributor);
/*
* 达到超时时间将会停止job
*/
JobTimeoutTask jobTimeoutTask = new JobTimeoutTask(job);
long jobTimeoutInSecond = getJobTimeoutInSecond();
Date timeoutDate = new Date(System.currentTimeMillis() + (jobTimeoutInSecond * 1000));
ArthasBootstrap.getInstance().getScheduledExecutorService().schedule(jobTimeoutTask, jobTimeoutInSecond, TimeUnit.SECONDS);
jobTimeoutTaskMap.put(job.id(), jobTimeoutTask);
job.setTimeoutDate(timeoutDate);
return job;
}
private long getJobTimeoutInSecond() {
long result = -1;
String jobTimeoutConfig = GlobalOptions.jobTimeout.trim();
try {
char unit = jobTimeoutConfig.charAt(jobTimeoutConfig.length() - 1);
String duration = jobTimeoutConfig.substring(0, jobTimeoutConfig.length() - 1);
switch (unit) {
case 'h':
result = TimeUnit.HOURS.toSeconds(Long.parseLong(duration));
break;
case 'd':
result = TimeUnit.DAYS.toSeconds(Long.parseLong(duration));
break;
case 'm':
result = TimeUnit.MINUTES.toSeconds(Long.parseLong(duration));
break;
case 's':
result = Long.parseLong(duration);
break;
default:
result = Long.parseLong(jobTimeoutConfig);
break;
}
} catch (Throwable e) {
logger.error("parse jobTimeoutConfig: {} error!", jobTimeoutConfig, e);
}
if (result < 0) {
// 如果设置的属性有错误，那么使用默认的1天
result = TimeUnit.DAYS.toSeconds(1);
logger.warn("Configuration with job timeout " + jobTimeoutConfig + " is error, use 1d in default.");
}
return result;
}
private static class JobTimeoutTask implements Runnable {
private Job job;
public JobTimeoutTask(Job job) {
this.job = job;
}
@Override
public void run() {
try {
if (job != null) {
Job temp = job;
job = null;
temp.terminate();
}
} catch (Throwable e) {
try {
logger.error("JobTimeoutTask error, job id: {}, line: {}", job.id(), job.line(), e);
} catch (Throwable t) {
// ignore
}
}
}
public void cancel() {
job = null;
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/system/impl/ProcessImpl.java | core/src/main/java/com/taobao/arthas/core/shell/system/impl/ProcessImpl.java | package com.taobao.arthas.core.shell.system.impl;
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.AdviceWeaver;
import com.taobao.arthas.core.command.basic1000.HelpCommand;
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.distribution.impl.TermResultDistributorImpl;
import com.taobao.arthas.core.server.ArthasBootstrap;
import com.taobao.arthas.core.shell.cli.CliToken;
import com.taobao.arthas.core.shell.command.Command;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.shell.command.internal.CloseFunction;
import com.taobao.arthas.core.shell.command.internal.StatisticsFunction;
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.system.ProcessAware;
import com.taobao.arthas.core.shell.term.Tty;
import com.taobao.middleware.cli.CLIException;
import com.taobao.middleware.cli.CommandLine;
import io.termd.core.function.Function;
import java.lang.instrument.ClassFileTransformer;
import java.util.Date;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author beiwei30 on 10/11/2016.
* @author gongdewei 2020-03-26
*/
public class ProcessImpl implements Process {
private static final Logger logger = LoggerFactory.getLogger(ProcessImpl.class);
private Command commandContext;
private Handler<CommandProcess> handler;
private List<CliToken> args;
private Tty tty;
private Session session;
private Handler<Void> interruptHandler;
private Handler<Void> suspendHandler;
private Handler<Void> resumeHandler;
private Handler<Void> endHandler;
private Handler<Void> backgroundHandler;
private Handler<Void> foregroundHandler;
private Handler<Integer> terminatedHandler;
private boolean foreground;
private ExecStatus processStatus;
private boolean processForeground;
private Handler<String> stdinHandler;
private Handler<Void> resizeHandler;
private Integer exitCode;
private CommandProcessImpl process;
private Date startTime;
private ProcessOutput processOutput;
private int jobId;
private ResultDistributor resultDistributor;
public ProcessImpl(Command commandContext, List<CliToken> args, Handler<CommandProcess> handler,
ProcessOutput processOutput, ResultDistributor resultDistributor) {
this.commandContext = commandContext;
this.handler = handler;
this.args = args;
this.resultDistributor = resultDistributor;
this.processStatus = ExecStatus.READY;
this.processOutput = processOutput;
}
@Override
public Integer exitCode() {
return exitCode;
}
@Override
public ExecStatus status() {
return processStatus;
}
@Override
public synchronized Process setTty(Tty tty) {
this.tty = tty;
return this;
}
@Override
public synchronized Tty getTty() {
return tty;
}
@Override
public void setJobId(int jobId) {
this.jobId = jobId;
}
@Override
public synchronized Process setSession(Session session) {
this.session = session;
return this;
}
@Override
public synchronized Session getSession() {
return session;
}
@Override
public int times() {
return process.times().get();
}
public Date startTime() {
return startTime;
}
@Override
public String cacheLocation() {
if (processOutput != null) {
return processOutput.cacheLocation;
}
return null;
}
@Override
public Process terminatedHandler(Handler<Integer> handler) {
terminatedHandler = handler;
return this;
}
@Override
public boolean interrupt() {
return interrupt(null);
}
@Override
public boolean interrupt(final Handler<Void> completionHandler) {
if (processStatus == ExecStatus.RUNNING || processStatus == ExecStatus.STOPPED || processStatus == ExecStatus.TERMINATED) {
final Handler<Void> handler = interruptHandler;
try {
if (handler != null) {
handler.handle(null);
}
} finally {
if (completionHandler != null) {
completionHandler.handle(null);
}
}
return handler != null;
} else {
throw new IllegalStateException("Cannot interrupt process in " + processStatus + " state");
}
}
@Override
public void resume() {
resume(true);
}
@Override
public void resume(boolean foreground) {
resume(foreground, null);
}
@Override
public void resume(Handler<Void> completionHandler) {
resume(true, completionHandler);
}
@Override
public synchronized void resume(boolean fg, Handler<Void> completionHandler) {
if (processStatus == ExecStatus.STOPPED) {
updateStatus(ExecStatus.RUNNING, null, fg, resumeHandler, terminatedHandler, completionHandler);
if (process != null) {
process.resume();
}
} else {
throw new IllegalStateException("Cannot resume process in " + processStatus + " state");
}
}
@Override
public void suspend() {
suspend(null);
}
@Override
public synchronized void suspend(Handler<Void> completionHandler) {
if (processStatus == ExecStatus.RUNNING) {
updateStatus(ExecStatus.STOPPED, null, false, suspendHandler, terminatedHandler, completionHandler);
if (process != null) {
process.suspend();
}
} else {
throw new IllegalStateException("Cannot suspend process in " + processStatus + " state");
}
}
@Override
public void toBackground() {
toBackground(null);
}
@Override
public void toBackground(Handler<Void> completionHandler) {
if (processStatus == ExecStatus.RUNNING) {
if (processForeground) {
updateStatus(ExecStatus.RUNNING, null, false, backgroundHandler, terminatedHandler, completionHandler);
}
} else {
throw new IllegalStateException("Cannot set to background a process in " + processStatus + " state");
}
}
@Override
public void toForeground() {
toForeground(null);
}
@Override
public void toForeground(Handler<Void> completionHandler) {
if (processStatus == ExecStatus.RUNNING) {
if (!processForeground) {
updateStatus(ExecStatus.RUNNING, null, true, foregroundHandler, terminatedHandler, completionHandler);
}
} else {
throw new IllegalStateException("Cannot set to foreground a process in " + processStatus + " state");
}
}
@Override
public void terminate() {
terminate(null);
}
@Override
public void terminate(Handler<Void> completionHandler) {
if (!terminate(-10, completionHandler, null)) {
throw new IllegalStateException("Cannot terminate terminated process");
}
}
private synchronized boolean terminate(int exitCode, Handler<Void> completionHandler, String message) {
if (processStatus != ExecStatus.TERMINATED) {
//add status message
this.appendResult(new StatusModel(exitCode, message));
if (process != null) {
processOutput.close();
}
updateStatus(ExecStatus.TERMINATED, exitCode, false, endHandler, terminatedHandler, completionHandler);
if (process != null) {
process.unregister();
}
return true;
} else {
return false;
}
}
private void appendResult(ResultModel result) {
result.setJobId(jobId);
if (resultDistributor != null) {
resultDistributor.appendResult(result);
}
}
private void updateStatus(ExecStatus statusUpdate, Integer exitCodeUpdate, boolean foregroundUpdate,
Handler<Void> handler, Handler<Integer> terminatedHandler,
Handler<Void> completionHandler) {
processStatus = statusUpdate;
exitCode = exitCodeUpdate;
if (!foregroundUpdate) {
if (processForeground) {
processForeground = false;
if (stdinHandler != null) {
tty.stdinHandler(null);
}
if (resizeHandler != null) {
tty.resizehandler(null);
}
}
} else {
if (!processForeground) {
processForeground = true;
if (stdinHandler != null) {
tty.stdinHandler(stdinHandler);
}
if (resizeHandler != null) {
tty.resizehandler(resizeHandler);
}
}
}
foreground = foregroundUpdate;
try {
if (handler != null) {
handler.handle(null);
}
} finally {
if (completionHandler != null) {
completionHandler.handle(null);
}
if (terminatedHandler != null && statusUpdate == ExecStatus.TERMINATED) {
terminatedHandler.handle(exitCodeUpdate);
}
}
}
@Override
public void run() {
run(true);
}
@Override
public synchronized void run(boolean fg) {
if (processStatus != ExecStatus.READY) {
throw new IllegalStateException("Cannot run proces in " + processStatus + " state");
}
processStatus = ExecStatus.RUNNING;
processForeground = fg;
foreground = fg;
startTime = new Date();
// Make a local copy
final Tty tty = this.tty;
if (tty == null) {
throw new IllegalStateException("Cannot execute process without a TTY set");
}
process = new CommandProcessImpl(this, tty);
if (resultDistributor == null) {
resultDistributor = new TermResultDistributorImpl(process, ArthasBootstrap.getInstance().getResultViewResolver());
}
final List<String> args2 = new LinkedList<String>();
for (CliToken arg : args) {
if (arg.isText()) {
args2.add(arg.value());
}
}
CommandLine cl = null;
try {
if (commandContext.cli() != null) {
if (commandContext.cli().parse(args2, false).isAskingForHelp()) {
appendResult(new HelpCommand().createHelpDetailModel(commandContext));
terminate();
return;
}
cl = commandContext.cli().parse(args2);
process.setArgs2(args2);
process.setCommandLine(cl);
}
} catch (CLIException e) {
terminate(-10, null, e.getMessage());
return;
}
if (cacheLocation() != null) {
process.echoTips("job id : " + this.jobId + "\n");
process.echoTips("cache location : " + cacheLocation() + "\n");
}
Runnable task = new CommandProcessTask(process);
ArthasBootstrap.getInstance().execute(task);
}
private class CommandProcessTask implements Runnable {
private CommandProcess process;
public CommandProcessTask(CommandProcess process) {
this.process = process;
}
@Override
public void run() {
try {
handler.handle(process);
} catch (Throwable t) {
logger.error("Error during processing the command:", t);
process.end(1, "Error during processing the command: " + t.getClass().getName() + ", message:" + t.getMessage()
+ ", please check $HOME/logs/arthas/arthas.log for more details." );
}
}
}
private class CommandProcessImpl implements CommandProcess {
private final Process process;
private final Tty tty;
private List<String> args2;
private CommandLine commandLine;
private AtomicInteger times = new AtomicInteger();
private AdviceListener listener = null;
private ClassFileTransformer transformer;
public CommandProcessImpl(Process process, Tty tty) {
this.process = process;
this.tty = tty;
}
@Override
public List<CliToken> argsTokens() {
return args;
}
@Override
public List<String> args() {
return args2;
}
@Override
public String type() {
return tty.type();
}
@Override
public boolean isForeground() {
return foreground;
}
@Override
public int width() {
return tty.width();
}
@Override
public int height() {
return tty.height();
}
@Override
public CommandLine commandLine() {
return commandLine;
}
@Override
public Session session() {
return session;
}
@Override
public AtomicInteger times() {
return times;
}
public void setArgs2(List<String> args2) {
this.args2 = args2;
}
public void setCommandLine(CommandLine commandLine) {
this.commandLine = commandLine;
}
@Override
public CommandProcess stdinHandler(Handler<String> handler) {
stdinHandler = handler;
if (processForeground && stdinHandler != null) {
tty.stdinHandler(stdinHandler);
}
return this;
}
@Override
public CommandProcess write(String data) {
synchronized (ProcessImpl.this) {
if (processStatus != ExecStatus.RUNNING) {
throw new IllegalStateException(
"Cannot write to standard output when " + status().name().toLowerCase());
}
}
processOutput.write(data);
return this;
}
@Override
public void echoTips(String tips) {
processOutput.term.write(tips);
}
@Override
public String cacheLocation() {
return ProcessImpl.this.cacheLocation();
}
@Override
public CommandProcess resizehandler(Handler<Void> handler) {
resizeHandler = handler;
tty.resizehandler(resizeHandler);
return this;
}
@Override
public CommandProcess interruptHandler(Handler<Void> handler) {
synchronized (ProcessImpl.this) {
interruptHandler = handler;
}
return this;
}
@Override
public CommandProcess suspendHandler(Handler<Void> handler) {
synchronized (ProcessImpl.this) {
suspendHandler = handler;
}
return this;
}
@Override
public CommandProcess resumeHandler(Handler<Void> handler) {
synchronized (ProcessImpl.this) {
resumeHandler = handler;
}
return this;
}
@Override
public CommandProcess endHandler(Handler<Void> handler) {
synchronized (ProcessImpl.this) {
endHandler = handler;
}
return this;
}
@Override
public CommandProcess backgroundHandler(Handler<Void> handler) {
synchronized (ProcessImpl.this) {
backgroundHandler = handler;
}
return this;
}
@Override
public CommandProcess foregroundHandler(Handler<Void> handler) {
synchronized (ProcessImpl.this) {
foregroundHandler = handler;
}
return this;
}
@Override
public void register(AdviceListener adviceListener, ClassFileTransformer transformer) {
if (adviceListener instanceof ProcessAware) {
ProcessAware processAware = (ProcessAware) adviceListener;
// listener 有可能是其它 command 创建的
if(processAware.getProcess() == null) {
processAware.setProcess(this.process);
}
}
this.listener = adviceListener;
AdviceWeaver.reg(listener);
this.transformer = transformer;
}
@Override
public void unregister() {
if (transformer != null) {
ArthasBootstrap.getInstance().getTransformerManager().removeTransformer(transformer);
}
if (listener instanceof ProcessAware) {
// listener有可能其它 command 创建的，所以不能unRge
if (this.process.equals(((ProcessAware) listener).getProcess())) {
AdviceWeaver.unReg(listener);
}
} else {
AdviceWeaver.unReg(listener);
}
}
@Override
public void resume() {
// if (suspendedListener != null) {
// AdviceWeaver.resume(suspendedListener);
// suspendedListener = null;
// }
}
@Override
public void suspend() {
// if (this.enhanceLock >= 0) {
// suspendedListener = AdviceWeaver.suspend(enhanceLock);
// }
}
@Override
public void end() {
end(0);
}
@Override
public void end(int statusCode) {
end(statusCode, null);
}
@Override
public void end(int statusCode, String message) {
terminate(statusCode, null, message);
}
@Override
public boolean isRunning() {
return processStatus == ExecStatus.RUNNING;
}
@Override
public void appendResult(ResultModel result) {
if (processStatus != ExecStatus.RUNNING) {
throw new IllegalStateException(
"Cannot write to standard output when " + status().name().toLowerCase());
}
ProcessImpl.this.appendResult(result);
}
}
static class ProcessOutput {
private List<Function<String, String>> stdoutHandlerChain;
private StatisticsFunction statisticsHandler = null;
private List<Function<String, String>> flushHandlerChain = null;
private String cacheLocation;
private Tty term;
public ProcessOutput(List<Function<String, String>> stdoutHandlerChain, String cacheLocation, Tty term) {
// this.stdoutHandlerChain = stdoutHandlerChain;
int i = 0;
for (; i < stdoutHandlerChain.size(); i++) {
if (stdoutHandlerChain.get(i) instanceof StatisticsFunction) {
break;
}
}
if (i < stdoutHandlerChain.size()) {
this.stdoutHandlerChain = stdoutHandlerChain.subList(0, i + 1);
this.statisticsHandler = (StatisticsFunction) stdoutHandlerChain.get(i);
if (i < stdoutHandlerChain.size() - 1) {
flushHandlerChain = stdoutHandlerChain.subList(i + 1, stdoutHandlerChain.size());
}
} else {
this.stdoutHandlerChain = stdoutHandlerChain;
}
this.cacheLocation = cacheLocation;
this.term = term;
}
private void write(String data) {
if (stdoutHandlerChain != null) {
//hotspot, reduce memory fragment (foreach/iterator)
int size = stdoutHandlerChain.size();
for (int i = 0; i < size; i++) {
Function<String, String> function = stdoutHandlerChain.get(i);
data = function.apply(data);
}
}
}
private void close() {
if (statisticsHandler != null && flushHandlerChain != null) {
String data = statisticsHandler.result();
for (Function<String, String> function : flushHandlerChain) {
data = function.apply(data);
if (function instanceof StatisticsFunction) {
data = ((StatisticsFunction) function).result();
}
}
}
if (stdoutHandlerChain != null) {
for (Function<String, String> function : stdoutHandlerChain) {
if (function instanceof CloseFunction) {
((CloseFunction) function).close();
}
}
}
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/system/impl/JobImpl.java | core/src/main/java/com/taobao/arthas/core/shell/system/impl/JobImpl.java | package com.taobao.arthas.core.shell.system.impl;
import java.util.Date;
import java.util.concurrent.atomic.AtomicBoolean;
import com.taobao.arthas.core.shell.future.Future;
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.Job;
import com.taobao.arthas.core.shell.system.JobListener;
import com.taobao.arthas.core.shell.system.Process;
/**
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
* @author hengyunabc 2019-05-14
* @author gongdewei 2020-03-23
*/
public class JobImpl implements Job {
final int id;
final JobControllerImpl controller;
final Process process;
final String line;
private volatile Session session;
private volatile ExecStatus actualStatus; // Used internally for testing only
volatile long lastStopped; // When the job was last stopped
volatile JobListener jobHandler;
volatile Handler<ExecStatus> statusUpdateHandler;
volatile Date timeoutDate;
final Future<Void> terminateFuture;
final AtomicBoolean runInBackground;
//final Handler<Job> foregroundUpdatedHandler;
JobImpl(int id, final JobControllerImpl controller, Process process, String line, boolean runInBackground,
Session session, JobListener jobHandler) {
this.id = id;
this.controller = controller;
this.process = process;
this.line = line;
this.session = session;
this.terminateFuture = Future.future();
this.runInBackground = new AtomicBoolean(runInBackground);
this.jobHandler = jobHandler;
if (jobHandler == null) {
throw new IllegalArgumentException("JobListener is required");
}
//this.foregroundUpdatedHandler = new ShellForegroundUpdateHandler(shell);
process.terminatedHandler(new TerminatedHandler(controller));
}
public ExecStatus actualStatus() {
return actualStatus;
}
@Override
public boolean interrupt() {
return process.interrupt();
}
@Override
public Job resume() {
return resume(true);
}
@Override
public Date timeoutDate() {
return timeoutDate;
}
@Override
public void setTimeoutDate(Date date) {
this.timeoutDate = date;
}
@Override
public Session getSession() {
return session;
}
@Override
public Job resume(boolean foreground) {
try {
process.resume(foreground, new ResumeHandler());
} catch (IllegalStateException ignore) {
}
runInBackground.set(!foreground);
// if (foreground) {
// if (foregroundUpdatedHandler != null) {
// foregroundUpdatedHandler.handle(this);
// }
// }
if (statusUpdateHandler != null) {
statusUpdateHandler.handle(process.status());
}
if (this.status() == ExecStatus.RUNNING) {
if (foreground) {
jobHandler.onForeground(this);
} else {
jobHandler.onBackground(this);
}
}
return this;
}
@Override
public Job suspend() {
try {
process.suspend(new SuspendHandler());
} catch (IllegalStateException ignore) {
return this;
}
// if (!runInBackground.get() && foregroundUpdatedHandler != null) {
// foregroundUpdatedHandler.handle(null);
// }
if (statusUpdateHandler != null) {
statusUpdateHandler.handle(process.status());
}
// shell.setForegroundJob(null);
jobHandler.onSuspend(this);
return this;
}
@Override
public void terminate() {
try {
process.terminate();
} catch (IllegalStateException ignore) {
// Process already terminated, likely by itself
} finally {
controller.removeJob(this.id);
}
}
@Override
public Process process() {
return process;
}
public ExecStatus status() {
return process.status();
}
public String line() {
return line;
}
@Override
public boolean isRunInBackground() {
return runInBackground.get();
}
@Override
public Job toBackground() {
if (!this.runInBackground.get()) {
// run in foreground mode
if (runInBackground.compareAndSet(false, true)) {
process.toBackground();
if (statusUpdateHandler != null) {
statusUpdateHandler.handle(process.status());
}
jobHandler.onBackground(this);
}
}
// shell.setForegroundJob(null);
// jobHandler.onBackground(this);
return this;
}
@Override
public Job toForeground() {
if (this.runInBackground.get()) {
if (runInBackground.compareAndSet(true, false)) {
// if (foregroundUpdatedHandler != null) {
// foregroundUpdatedHandler.handle(this);
// }
process.toForeground();
if (statusUpdateHandler != null) {
statusUpdateHandler.handle(process.status());
}
// shell.setForegroundJob(this);
jobHandler.onForeground(this);
}
}
return this;
}
@Override
public int id() {
return id;
}
@Override
public Job run() {
return run(!runInBackground.get());
}
@Override
public Job run(boolean foreground) {
// if (foreground && foregroundUpdatedHandler != null) {
// foregroundUpdatedHandler.handle(this);
// }
actualStatus = ExecStatus.RUNNING;
if (statusUpdateHandler != null) {
statusUpdateHandler.handle(ExecStatus.RUNNING);
}
//set process's tty in JobControllerImpl.createCommandProcess
//process.setTty(shell.term());
process.setSession(this.session);
process.run(foreground);
// if (!foreground && foregroundUpdatedHandler != null) {
// foregroundUpdatedHandler.handle(null);
// }
//
// if (foreground) {
// shell.setForegroundJob(this);
// } else {
// shell.setForegroundJob(null);
// }
if (this.status() == ExecStatus.RUNNING) {
if (foreground) {
jobHandler.onForeground(this);
} else {
jobHandler.onBackground(this);
}
}
return this;
}
private class TerminatedHandler implements Handler<Integer> {
private final JobControllerImpl controller;
public TerminatedHandler(JobControllerImpl controller) {
this.controller = controller;
}
@Override
public void handle(Integer exitCode) {
// if (!runInBackground.get() && actualStatus.equals(ExecStatus.RUNNING)) {
// 只有前台在运行的任务，才需要调用foregroundUpdateHandler
// if (foregroundUpdatedHandler != null) {
// foregroundUpdatedHandler.handle(null);
// }
// }
jobHandler.onTerminated(JobImpl.this);
controller.removeJob(JobImpl.this.id);
if (statusUpdateHandler != null) {
statusUpdateHandler.handle(ExecStatus.TERMINATED);
}
terminateFuture.complete();
// save command history (move to JobControllerImpl.ShellJobHandler.onTerminated)
// Term term = shell.term();
// if (term instanceof TermImpl) {
// List<int[]> history = ((TermImpl) term).getReadline().getHistory();
// FileUtils.saveCommandHistory(history, new File(Constants.CMD_HISTORY_FILE));
// }
}
}
private class ResumeHandler implements Handler<Void> {
@Override
public void handle(Void event) {
actualStatus = ExecStatus.RUNNING;
}
}
private class SuspendHandler implements Handler<Void> {
@Override
public void handle(Void event) {
actualStatus = ExecStatus.STOPPED;
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/system/impl/JobControllerImpl.java | core/src/main/java/com/taobao/arthas/core/shell/system/impl/JobControllerImpl.java | package com.taobao.arthas.core.shell.system.impl;
import com.taobao.arthas.common.ArthasConstants;
import com.taobao.arthas.core.GlobalOptions;
import com.taobao.arthas.core.distribution.ResultDistributor;
import com.taobao.arthas.core.server.ArthasBootstrap;
import com.taobao.arthas.core.shell.cli.CliToken;
import com.taobao.arthas.core.shell.command.Command;
import com.taobao.arthas.core.shell.command.internal.RedirectHandler;
import com.taobao.arthas.core.shell.command.internal.StdoutHandler;
import com.taobao.arthas.core.shell.command.internal.TermHandler;
import com.taobao.arthas.core.shell.future.Future;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.arthas.core.shell.session.Session;
import com.taobao.arthas.core.shell.system.Job;
import com.taobao.arthas.core.shell.system.JobController;
import com.taobao.arthas.core.shell.system.JobListener;
import com.taobao.arthas.core.shell.system.Process;
import com.taobao.arthas.core.shell.system.impl.ProcessImpl.ProcessOutput;
import com.taobao.arthas.core.shell.term.Term;
import com.taobao.arthas.core.util.Constants;
import com.taobao.arthas.core.util.LogUtil;
import com.taobao.arthas.core.util.TokenUtils;
import io.termd.core.function.Function;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.ListIterator;
import java.util.Set;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
* @author hengyunabc 2019-05-14
* @author gongdewei 2020-03-23
*/
public class JobControllerImpl implements JobController {
private final SortedMap<Integer, JobImpl> jobs = new TreeMap<Integer, JobImpl>();
private final AtomicInteger idGenerator = new AtomicInteger(0);
private boolean closed = false;
public JobControllerImpl() {
}
public synchronized Set<Job> jobs() {
return new HashSet<Job>(jobs.values());
}
public synchronized Job getJob(int id) {
return jobs.get(id);
}
synchronized boolean removeJob(int id) {
return jobs.remove(id) != null;
}
private void checkPermission(Session session, CliToken token) {
if (ArthasBootstrap.getInstance().getSecurityAuthenticator().needLogin()) {
// 检查session是否有 Subject
Object subject = session.get(ArthasConstants.SUBJECT_KEY);
if (subject == null) {
if (token != null && token.isText() && token.value().trim().equals(ArthasConstants.AUTH)) {
// 执行的是auth 命令
return;
}
throw new IllegalArgumentException("Error! command not permitted, try to use 'auth' command to authenticates.");
}
}
}
@Override
public Job createJob(InternalCommandManager commandManager, List<CliToken> tokens, Session session, JobListener jobHandler, Term term, ResultDistributor resultDistributor) {
checkPermission(session, tokens.get(0));
int jobId = idGenerator.incrementAndGet();
StringBuilder line = new StringBuilder();
for (CliToken arg : tokens) {
line.append(arg.raw());
}
boolean runInBackground = runInBackground(tokens);
Process process = createProcess(session, tokens, commandManager, jobId, term, resultDistributor);
process.setJobId(jobId);
JobImpl job = new JobImpl(jobId, this, process, line.toString(), runInBackground, session, jobHandler);
jobs.put(jobId, job);
return job;
}
private int getRedirectJobCount() {
int count = 0;
for (Job job : jobs.values()) {
if (job.process() != null && job.process().cacheLocation() != null) {
count++;
}
}
return count;
}
@Override
public void close(final Handler<Void> completionHandler) {
List<JobImpl> jobs;
synchronized (this) {
if (closed) {
jobs = Collections.emptyList();
} else {
jobs = new ArrayList<JobImpl>(this.jobs.values());
closed = true;
}
}
if (jobs.isEmpty()) {
if (completionHandler!= null) {
completionHandler.handle(null);
}
} else {
final AtomicInteger count = new AtomicInteger(jobs.size());
for (JobImpl job : jobs) {
job.terminateFuture.setHandler(new Handler<Future<Void>>() {
@Override
public void handle(Future<Void> v) {
if (count.decrementAndGet() == 0 && completionHandler != null) {
completionHandler.handle(null);
}
}
});
job.terminate();
}
}
}
/**
* Try to create a process from the command line tokens.
*
* @param line the command line tokens
* @param commandManager command manager
* @param jobId job id
* @param term term
* @param resultDistributor
* @return the created process
*/
private Process createProcess(Session session, List<CliToken> line, InternalCommandManager commandManager, int jobId, Term term, ResultDistributor resultDistributor) {
try {
ListIterator<CliToken> tokens = line.listIterator();
while (tokens.hasNext()) {
CliToken token = tokens.next();
if (token.isText()) {
// check before create process
checkPermission(session, token);
Command command = commandManager.getCommand(token.value());
if (command != null) {
return createCommandProcess(command, tokens, jobId, term, resultDistributor);
} else {
throw new IllegalArgumentException(token.value() + ": command not found");
}
}
}
throw new IllegalArgumentException();
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private boolean runInBackground(List<CliToken> tokens) {
boolean runInBackground = false;
CliToken last = TokenUtils.findLastTextToken(tokens);
if (last != null && "&".equals(last.value())) {
runInBackground = true;
tokens.remove(last);
}
return runInBackground;
}
private Process createCommandProcess(Command command, ListIterator<CliToken> tokens, int jobId, Term term, ResultDistributor resultDistributor) throws IOException {
List<CliToken> remaining = new ArrayList<CliToken>();
List<CliToken> pipelineTokens = new ArrayList<CliToken>();
boolean isPipeline = false;
RedirectHandler redirectHandler = null;
List<Function<String, String>> stdoutHandlerChain = new ArrayList<Function<String, String>>();
String cacheLocation = null;
while (tokens.hasNext()) {
CliToken remainingToken = tokens.next();
if (remainingToken.isText()) {
String tokenValue = remainingToken.value();
if ("|".equals(tokenValue)) {
isPipeline = true;
// 将管道符|之后的部分注入为输出链上的handler
injectHandler(stdoutHandlerChain, pipelineTokens);
continue;
} else if (">>".equals(tokenValue) || ">".equals(tokenValue)) {
String name = getRedirectFileName(tokens);
if (name == null) {
// 如果没有指定重定向文件名，那么重定向到以jobid命名的缓存中
name = LogUtil.cacheDir() + File.separator + Constants.PID + File.separator + jobId;
cacheLocation = name;
if (getRedirectJobCount() == 8) {
throw new IllegalStateException("The amount of async command that saving result to file can't > 8");
}
}
redirectHandler = new RedirectHandler(name, ">>".equals(tokenValue));
break;
}
}
if (isPipeline) {
pipelineTokens.add(remainingToken);
} else {
remaining.add(remainingToken);
}
}
injectHandler(stdoutHandlerChain, pipelineTokens);
if (redirectHandler != null) {
stdoutHandlerChain.add(redirectHandler);
term.write("redirect output file will be: " + redirectHandler.getFilePath()+"\n");
} else {
stdoutHandlerChain.add(new TermHandler(term));
if (GlobalOptions.isSaveResult) {
stdoutHandlerChain.add(new RedirectHandler());
}
}
ProcessOutput processOutput = new ProcessOutput(stdoutHandlerChain, cacheLocation, term);
ProcessImpl process = new ProcessImpl(command, remaining, command.processHandler(), processOutput, resultDistributor);
process.setTty(term);
return process;
}
private String getRedirectFileName(ListIterator<CliToken> tokens) {
while (tokens.hasNext()) {
CliToken token = tokens.next();
if (token.isText()) {
return token.value();
}
}
return null;
}
private void injectHandler(List<Function<String, String>> stdoutHandlerChain, List<CliToken> pipelineTokens) {
if (!pipelineTokens.isEmpty()) {
StdoutHandler handler = StdoutHandler.inject(pipelineTokens);
if (handler != null) {
stdoutHandlerChain.add(handler);
}
pipelineTokens.clear();
}
}
@Override
public void close() {
close(null);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/command/ExitStatus.java | core/src/main/java/com/taobao/arthas/core/shell/command/ExitStatus.java | package com.taobao.arthas.core.shell.command;
/**
* 命令执行的结束状态
*/
public class ExitStatus {
/**
* 命令执行成功的状态
*/
public static final ExitStatus SUCCESS_STATUS = new ExitStatus(0);
/**
* 命令执行成功的状态
* @return
*/
public static ExitStatus success() {
return SUCCESS_STATUS;
}
/**
* 命令执行失败
* @param statusCode
* @param message
* @return
*/
public static ExitStatus failure(int statusCode, String message) {
if (statusCode == 0) {
throw new IllegalArgumentException("failure status code cannot be 0");
}
return new ExitStatus(statusCode, message);
}
/**
* 判断是否为失败状态
* @param exitStatus
* @return
*/
public static boolean isFailed(ExitStatus exitStatus) {
return exitStatus != null && exitStatus.getStatusCode() != 0;
}
private int statusCode;
private String message;
private ExitStatus(int statusCode) {
this.statusCode = statusCode;
}
private ExitStatus(int statusCode, String message) {
this.statusCode = statusCode;
this.message = message;
}
public int getStatusCode() {
return statusCode;
}
public String getMessage() {
return message;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/command/AnnotatedCommand.java | core/src/main/java/com/taobao/arthas/core/shell/command/AnnotatedCommand.java | package com.taobao.arthas.core.shell.command;
import com.taobao.arthas.core.shell.cli.Completion;
import com.taobao.arthas.core.shell.cli.CompletionUtils;
import com.taobao.middleware.cli.CLI;
import java.util.List;
/**
* The base command class that Java annotated command should extend.
*
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
*/
public abstract class AnnotatedCommand {
/**
* @return the command name
*/
public String name() {
return null;
}
/**
* @return the command line interface, can be null
*/
public CLI cli() {
return null;
}
/**
* Process the command, when the command is done processing it should call the {@link CommandProcess#end()} method.
*
* @param process the command process
*/
public abstract void process(CommandProcess process);
/**
* Perform command completion, when the command is done completing it should call {@link Completion#complete(List)}
* or {@link Completion#complete(String, boolean)} )} method to signal completion is done.
*
* @param completion the completion object
*/
public void complete(Completion completion) {
CompletionUtils.complete(completion, this.getClass());
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/command/CommandResolver.java | core/src/main/java/com/taobao/arthas/core/shell/command/CommandResolver.java | package com.taobao.arthas.core.shell.command;
import java.util.List;
/**
* A resolver for commands, so the shell can discover commands.
*
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
*/
public interface CommandResolver {
/**
* @return the current commands
*/
List<Command> commands();
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/command/CommandBuilder.java | core/src/main/java/com/taobao/arthas/core/shell/command/CommandBuilder.java | package com.taobao.arthas.core.shell.command;
import com.taobao.arthas.core.shell.cli.Completion;
import com.taobao.arthas.core.shell.command.impl.CommandBuilderImpl;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.middleware.cli.CLI;
/**
* command builder
*
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
*/
public abstract class CommandBuilder {
/**
* Create a new command builder, the command is responsible for managing the options and arguments via the
* {@link CommandProcess#args() arguments}.
*
* @param name the command name
* @return the command
*/
public static CommandBuilder command(String name) {
return new CommandBuilderImpl(name, null);
}
/**
* Create a new command with its {@link CLI} descriptor. This command can then retrieve the parsed
* {@link CommandProcess#commandLine()} when it executes to know get the command arguments and options.
*
* @param cli the cli to use
* @return the command
*/
public static CommandBuilder command(CLI cli) {
return new CommandBuilderImpl(cli.getName(), cli);
}
/**
* Set the command process handler, the process handler is called when the command is executed.
*
* @param handler the process handler
* @return this command object
*/
public abstract CommandBuilder processHandler(Handler<CommandProcess> handler);
/**
* Set the command completion handler, the completion handler when the user asks for contextual command line
* completion, usually hitting the <i>tab</i> key.
*
* @param handler the completion handler
* @return this command object
*/
public abstract CommandBuilder completionHandler(Handler<Completion> handler);
/**
* Build the command
*
* @return the built command
*/
public abstract Command build();
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/command/CommandProcess.java | core/src/main/java/com/taobao/arthas/core/shell/command/CommandProcess.java | package com.taobao.arthas.core.shell.command;
import com.taobao.arthas.core.advisor.AdviceListener;
import com.taobao.arthas.core.command.model.ResultModel;
import com.taobao.arthas.core.shell.cli.CliToken;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.arthas.core.shell.session.Session;
import com.taobao.arthas.core.shell.term.Tty;
import com.taobao.middleware.cli.CommandLine;
import java.lang.instrument.ClassFileTransformer;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
/**
* The command process provides interaction with the process of the command.
*
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
*/
public interface CommandProcess extends Tty {
/**
* @return the unparsed arguments tokens
*/
List<CliToken> argsTokens();
/**
* @return the actual string arguments of the command
*/
List<String> args();
/**
* @return the command line object or null
*/
CommandLine commandLine();
/**
* @return the shell session
*/
Session session();
/**
* @return true if the command is running in foreground
*/
boolean isForeground();
CommandProcess stdinHandler(Handler<String> handler);
/**
* Set an interrupt handler, this handler is called when the command is interrupted, for instance user
* press <code>Ctrl-C</code>.
*
* @param handler the interrupt handler
* @return this command
*/
CommandProcess interruptHandler(Handler<Void> handler);
/**
* Set a suspend handler, this handler is called when the command is suspended, for instance user
* press <code>Ctrl-Z</code>.
*
* @param handler the interrupt handler
* @return this command
*/
CommandProcess suspendHandler(Handler<Void> handler);
/**
* Set a resume handler, this handler is called when the command is resumed, for instance user
* types <code>bg</code> or <code>fg</code> to resume the command.
*
* @param handler the interrupt handler
* @return this command
*/
CommandProcess resumeHandler(Handler<Void> handler);
/**
* Set an end handler, this handler is called when the command is ended, for instance the command is running
* and the shell closes.
*
* @param handler the end handler
* @return a reference to this, so the API can be used fluently
*/
CommandProcess endHandler(Handler<Void> handler);
/**
* Write some text to the standard output.
*
* @param data the text
* @return a reference to this, so the API can be used fluently
*/
CommandProcess write(String data);
/**
* Set a background handler, this handler is called when the command is running and put to background.
*
* @param handler the background handler
* @return this command
*/
CommandProcess backgroundHandler(Handler<Void> handler);
/**
* Set a foreground handler, this handler is called when the command is running and put to foreground.
*
* @param handler the foreground handler
* @return this command
*/
CommandProcess foregroundHandler(Handler<Void> handler);
@Override
CommandProcess resizehandler(Handler<Void> handler);
/**
* End the process with the exit status {@literal 0}
*/
void end();
/**
* 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);
/**
* Register listener
*
* @param listener
*/
void register(AdviceListener listener, ClassFileTransformer transformer);
/**
* Unregister listener
*/
void unregister();
/**
* Execution times
*
* @return execution times
*/
AtomicInteger times();
/**
* Resume process
*/
void resume();
/**
* Suspend process
*/
void suspend();
/**
* echo tips
*
* @param tips process tips
*/
void echoTips(String tips);
/**
* Get cache file location
*
* @return
*/
String cacheLocation();
/**
* Whether the process is running
*/
boolean isRunning();
/**
* Append the phased result to queue
* @param result a phased result of the command
*/
void appendResult(ResultModel result);
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/command/CommandRegistry.java | core/src/main/java/com/taobao/arthas/core/shell/command/CommandRegistry.java | package com.taobao.arthas.core.shell.command;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.concurrent.ConcurrentHashMap;
/**
* A registry that contains the commands known by a shell.<p/>
* <p>
* It is a mutable command resolver.
*
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
*/
public class CommandRegistry implements CommandResolver {
final ConcurrentHashMap<String, Command> commandMap = new ConcurrentHashMap<String, Command>();
/**
* Create a new registry.
*
* @return the created registry
*/
public static CommandRegistry create() {
return new CommandRegistry();
}
/**
* Register a single command.
*/
public CommandRegistry registerCommand(Class<? extends AnnotatedCommand> command) {
return registerCommand(Command.create(command));
}
/**
* Register a command
*
* @param command the command to register
* @return a reference to this, so the API can be used fluently
*/
public CommandRegistry registerCommand(Command command) {
return registerCommands(Collections.singletonList(command));
}
/**
* Register a list of commands.
*
* @param commands the commands to register
* @return a reference to this, so the API can be used fluently
*/
public CommandRegistry registerCommands(List<Command> commands) {
for (Command command : commands) {
commandMap.put(command.name(), command);
}
return this;
}
/**
* Unregister a command.
*
* @param commandName the command name
* @return a reference to this, so the API can be used fluently
*/
public CommandRegistry unregisterCommand(String commandName) {
commandMap.remove(commandName);
return this;
}
@Override
public List<Command> commands() {
return new ArrayList<Command>(commandMap.values());
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/command/Command.java | core/src/main/java/com/taobao/arthas/core/shell/command/Command.java | package com.taobao.arthas.core.shell.command;
import com.taobao.arthas.core.shell.cli.Completion;
import com.taobao.arthas.core.shell.command.impl.AnnotatedCommandImpl;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.middleware.cli.CLI;
import java.util.Collections;
import java.util.List;
public abstract class Command {
/**
* Create a command from a Java class, annotated with CLI annotations.
*
* @param clazz the class of the command
* @return the command object
*/
public static Command create(final Class<? extends AnnotatedCommand> clazz) {
return new AnnotatedCommandImpl(clazz);
}
/**
* @return the command name
*/
public String name() {
return null;
}
/**
* @return the command line interface, can be null
*/
public CLI cli() {
return null;
}
/**
* Create a new process with the passed arguments.
*
* @return the process handler
*/
public abstract Handler<CommandProcess> processHandler();
/**
* Perform command completion, when the command is done completing it should call {@link Completion#complete(List)}
* or {@link Completion#complete(String, boolean)} )} method to signal completion is done.
*
* @param completion the completion object
*/
public void complete(Completion completion) {
completion.complete(Collections.<String>emptyList());
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/command/impl/AnnotatedCommandImpl.java | core/src/main/java/com/taobao/arthas/core/shell/command/impl/AnnotatedCommandImpl.java | package com.taobao.arthas.core.shell.command.impl;
import com.taobao.arthas.core.shell.cli.Completion;
import com.taobao.arthas.core.shell.command.AnnotatedCommand;
import com.taobao.arthas.core.shell.command.Command;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.arthas.core.util.UserStatUtil;
import com.taobao.middleware.cli.CLI;
import com.taobao.middleware.cli.Option;
import com.taobao.middleware.cli.annotations.CLIConfigurator;
import java.util.Collections;
/**
* @author beiwei30 on 10/11/2016.
*/
public class AnnotatedCommandImpl extends Command {
private CLI cli;
private Class<? extends AnnotatedCommand> clazz;
private Handler<CommandProcess> processHandler = new ProcessHandler();
public AnnotatedCommandImpl(Class<? extends AnnotatedCommand> clazz) {
this.clazz = clazz;
cli = CLIConfigurator.define(clazz, true);
cli.addOption(new Option().setArgName("help").setFlag(true).setShortName("h").setLongName("help")
.setDescription("this help").setHelp(true));
}
private boolean shouldOverridesName(Class<? extends AnnotatedCommand> clazz) {
try {
clazz.getDeclaredMethod("name");
return true;
} catch (NoSuchMethodException ignore) {
return false;
}
}
private boolean shouldOverrideCli(Class<? extends AnnotatedCommand> clazz) {
try {
clazz.getDeclaredMethod("cli");
return true;
} catch (NoSuchMethodException ignore) {
return false;
}
}
@Override
public String name() {
if (shouldOverridesName(clazz)) {
try {
return clazz.newInstance().name();
} catch (Exception ignore) {
// Use cli.getName() instead
}
}
return cli.getName();
}
@Override
public CLI cli() {
if (shouldOverrideCli(clazz)) {
try {
return clazz.newInstance().cli();
} catch (Exception ignore) {
// Use cli instead
}
}
return cli;
}
private void process(CommandProcess process) {
AnnotatedCommand instance;
try {
instance = clazz.newInstance();
} catch (Exception e) {
process.end();
return;
}
CLIConfigurator.inject(process.commandLine(), instance);
instance.process(process);
// get userId from session for stat reporting
String userId = process.session() != null ? process.session().getUserId() : null;
UserStatUtil.arthasUsageSuccess(name(), process.args(), userId);
}
@Override
public Handler<CommandProcess> processHandler() {
return processHandler;
}
@Override
public void complete(final Completion completion) {
final AnnotatedCommand instance;
try {
instance = clazz.newInstance();
} catch (Exception e) {
super.complete(completion);
return;
}
try {
instance.complete(completion);
} catch (Throwable t) {
completion.complete(Collections.<String>emptyList());
}
}
private class ProcessHandler implements Handler<CommandProcess> {
@Override
public void handle(CommandProcess process) {
process(process);
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/command/impl/CommandBuilderImpl.java | core/src/main/java/com/taobao/arthas/core/shell/command/impl/CommandBuilderImpl.java | package com.taobao.arthas.core.shell.command.impl;
import com.taobao.arthas.core.shell.cli.Completion;
import com.taobao.arthas.core.shell.command.Command;
import com.taobao.arthas.core.shell.command.CommandBuilder;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.middleware.cli.CLI;
import java.util.Collections;
/**
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
*/
public class CommandBuilderImpl extends CommandBuilder {
private final String name;
private final CLI cli;
private Handler<CommandProcess> processHandler;
private Handler<Completion> completeHandler;
public CommandBuilderImpl(String name, CLI cli) {
this.name = name;
this.cli = cli;
}
@Override
public CommandBuilderImpl processHandler(Handler<CommandProcess> handler) {
processHandler = handler;
return this;
}
@Override
public CommandBuilderImpl completionHandler(Handler<Completion> handler) {
completeHandler = handler;
return this;
}
@Override
public Command build() {
return new CommandImpl();
}
private class CommandImpl extends Command {
@Override
public String name() {
return name;
}
@Override
public CLI cli() {
return cli;
}
@Override
public Handler<CommandProcess> processHandler() {
return processHandler;
}
@Override
public void complete(final Completion completion) {
if (completeHandler != null) {
try {
completeHandler.handle(completion);
} catch (Throwable t) {
completion.complete(Collections.<String>emptyList());
}
} else {
super.complete(completion);
}
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/command/internal/WordCountHandler.java | core/src/main/java/com/taobao/arthas/core/shell/command/internal/WordCountHandler.java | package com.taobao.arthas.core.shell.command.internal;
import com.taobao.arthas.core.shell.cli.CliToken;
import com.taobao.middleware.cli.CLIs;
import com.taobao.middleware.cli.CommandLine;
import com.taobao.middleware.cli.Option;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author ralf0131 2017-02-23 23:28.
*/
public class WordCountHandler extends StdoutHandler implements StatisticsFunction {
public static final String NAME = "wc";
private boolean lineMode;
private String result = null;
private final AtomicInteger total = new AtomicInteger(0);
public static StdoutHandler inject(List<CliToken> tokens) {
List<String> args = StdoutHandler.parseArgs(tokens, NAME);
CommandLine commandLine = CLIs.create(NAME)
.addOption(new Option().setShortName("l").setFlag(true))
.parse(args);
boolean lineMode = commandLine.isFlagEnabled("l");
return new WordCountHandler(lineMode);
}
private WordCountHandler(boolean lineMode) {
this.lineMode = lineMode;
}
@Override
public String apply(String input) {
if (!this.lineMode) {
// TODO the default behavior should be equivalent to `wc -l -w -c`
result = "wc currently only support wc -l!\n";
} else {
if (input != null && !"".equals(input.trim())) {
total.getAndAdd(input.split("\n").length);
}
}
return null;
}
@Override
public String result() {
if (result != null) {
return result;
}
return total.get() + "\n";
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/command/internal/TermHandler.java | core/src/main/java/com/taobao/arthas/core/shell/command/internal/TermHandler.java | package com.taobao.arthas.core.shell.command.internal;
import com.taobao.arthas.core.shell.term.Term;
/**
* 将数据写到term
*
* @author gehui 2017年7月26日 上午11:20:00
*/
public class TermHandler extends StdoutHandler {
private Term term;
public TermHandler(Term term) {
this.term = term;
}
@Override
public String apply(String data) {
term.write(data);
return data;
}
} | java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/command/internal/TeeHandler.java | core/src/main/java/com/taobao/arthas/core/shell/command/internal/TeeHandler.java | package com.taobao.arthas.core.shell.command.internal;
import com.taobao.arthas.core.command.basic1000.TeeCommand;
import com.taobao.arthas.core.shell.cli.CliToken;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.middleware.cli.CLI;
import com.taobao.middleware.cli.CommandLine;
import com.taobao.middleware.cli.annotations.CLIConfigurator;
import java.io.*;
import java.util.List;
/**
* @author min.yang
*/
public class TeeHandler extends StdoutHandler implements CloseFunction {
public static final String NAME = "tee";
private PrintWriter out;
private static CLI cli = null;
public TeeHandler(String filePath, boolean append) throws IOException {
if (StringUtils.isEmpty(filePath)) {
return;
}
File file = new File(filePath);
if (file.isDirectory()) {
throw new IOException(filePath + ": Is a directory");
}
if (!file.exists()) {
File parentFile = file.getParentFile();
if (parentFile != null) {
parentFile.mkdirs();
}
}
out = new PrintWriter(new BufferedWriter(new FileWriter(file, append)));
}
public static StdoutHandler inject(List<CliToken> tokens) {
List<String> args = StdoutHandler.parseArgs(tokens, NAME);
TeeCommand teeCommand = new TeeCommand();
if (cli == null) {
cli = CLIConfigurator.define(TeeCommand.class);
}
CommandLine commandLine = cli.parse(args, true);
try {
CLIConfigurator.inject(commandLine, teeCommand);
} catch (Throwable e) {
throw new RuntimeException(e);
}
String filePath = teeCommand.getFilePath();
boolean append = teeCommand.isAppend();
try {
return new TeeHandler(filePath, append);
} catch (IOException e) {
throw new RuntimeException(e);
}
}
@Override
public String apply(String data) {
data = super.apply(data);
if (out != null) {
out.write(data);
out.flush();
}
return data;
}
@Override
public void close() {
if (out != null) {
out.close();
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/command/internal/CloseFunction.java | core/src/main/java/com/taobao/arthas/core/shell/command/internal/CloseFunction.java | package com.taobao.arthas.core.shell.command.internal;
import io.termd.core.function.Function;
/**
* @author diecui1202 on 2017/11/2.
*/
public interface CloseFunction extends Function<String, String> {
void close();
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/command/internal/StdoutHandler.java | core/src/main/java/com/taobao/arthas/core/shell/command/internal/StdoutHandler.java | package com.taobao.arthas.core.shell.command.internal;
import com.taobao.arthas.core.shell.cli.CliToken;
import io.termd.core.function.Function;
import java.util.LinkedList;
import java.util.List;
/**
* @author beiwei30 on 20/12/2016.
*/
public abstract class StdoutHandler implements Function<String, String> {
public static StdoutHandler inject(List<CliToken> tokens) {
CliToken firstTextToken = null;
for (CliToken token : tokens) {
if (token.isText()) {
firstTextToken = token;
break;
}
}
if (firstTextToken == null) {
return null;
}
if (firstTextToken.value().equals(GrepHandler.NAME)) {
return GrepHandler.inject(tokens);
} else if (firstTextToken.value().equals(PlainTextHandler.NAME)) {
return PlainTextHandler.inject(tokens);
} else if (firstTextToken.value().equals(WordCountHandler.NAME)) {
return WordCountHandler.inject(tokens);
} else if (firstTextToken.value().equals(TeeHandler.NAME)){
return TeeHandler.inject(tokens);
} else{
return null;
}
}
public static List<String> parseArgs(List<CliToken> tokens, String command) {
List<String> args = new LinkedList<String>();
boolean found = false;
for (CliToken token : tokens) {
if (token.isText() && token.value().equals(command)) {
found = true;
} else if (token.isText() && found) {
args.add(token.value());
}
}
return args;
}
@Override
public String apply(String s) {
return s;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/command/internal/StatisticsFunction.java | core/src/main/java/com/taobao/arthas/core/shell/command/internal/StatisticsFunction.java | package com.taobao.arthas.core.shell.command.internal;
import io.termd.core.function.Function;
/**
* 统计类Function的接口
*
* @author diecui1202 on 2017/10/24.
*/
public interface StatisticsFunction extends Function<String, String> {
String result();
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/command/internal/RedirectHandler.java | core/src/main/java/com/taobao/arthas/core/shell/command/internal/RedirectHandler.java | package com.taobao.arthas.core.shell.command.internal;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.io.PrintWriter;
import com.taobao.arthas.core.util.LogUtil;
/**
* 重定向处理类
*
* @author gehui 2017年7月27日 上午11:38:40
* @author hengyunabc 2019-02-06
*/
public class RedirectHandler extends PlainTextHandler implements CloseFunction {
private PrintWriter out;
private File file;
public RedirectHandler() {
}
public RedirectHandler(String name, boolean append) throws IOException {
File file = new File(name);
if (file.isDirectory()) {
throw new IOException(name + ": Is a directory");
}
if (!file.exists()) {
File parentFile = file.getParentFile();
if (parentFile != null) {
parentFile.mkdirs();
}
}
this.file = file;
out = new PrintWriter(new BufferedWriter(new FileWriter(file, append)));
}
@Override
public String apply(String data) {
data = super.apply(data);
if (out != null) {
out.write(data);
out.flush();
} else {
LogUtil.getResultLogger().info(data);
}
return data;
}
@Override
public void close() {
if (out != null) {
out.close();
}
}
public String getFilePath() {
return file.getAbsolutePath();
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/command/internal/PlainTextHandler.java | core/src/main/java/com/taobao/arthas/core/shell/command/internal/PlainTextHandler.java | package com.taobao.arthas.core.shell.command.internal;
import com.taobao.arthas.core.shell.cli.CliToken;
import com.taobao.text.util.RenderUtil;
import java.util.List;
/**
* @author beiwei30 on 20/12/2016.
*/
public class PlainTextHandler extends StdoutHandler {
public static String NAME = "plaintext";
public static StdoutHandler inject(List<CliToken> tokens) {
return new PlainTextHandler();
}
@Override
public String apply(String s) {
return RenderUtil.ansiToPlainText(s);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/command/internal/GrepHandler.java | core/src/main/java/com/taobao/arthas/core/shell/command/internal/GrepHandler.java | package com.taobao.arthas.core.shell.command.internal;
import java.util.List;
import java.util.regex.Pattern;
import com.taobao.arthas.core.command.basic1000.GrepCommand;
import com.taobao.arthas.core.shell.cli.CliToken;
import com.taobao.arthas.core.util.StringUtils;
import com.taobao.middleware.cli.CLI;
import com.taobao.middleware.cli.CommandLine;
import com.taobao.middleware.cli.annotations.CLIConfigurator;
/**
* @author beiwei30 on 12/12/2016.
*/
public class GrepHandler extends StdoutHandler {
public static final String NAME = "grep";
private String keyword;
private boolean ignoreCase;
/**
* select non-matching lines
*/
private final boolean invertMatch;
private final Pattern pattern;
/**
* print line number with output lines
*/
private final boolean showLineNumber;
private boolean trimEnd;
/**
* print NUM lines of leading context
*/
private final Integer beforeLines;
/**
* print NUM lines of trailing context
*/
private final Integer afterLines;
/**
* stop after NUM selected lines
*/
private final Integer maxCount;
private static CLI cli = null;
public static StdoutHandler inject(List<CliToken> tokens) {
List<String> args = StdoutHandler.parseArgs(tokens, NAME);
GrepCommand grepCommand = new GrepCommand();
if (cli == null) {
cli = CLIConfigurator.define(GrepCommand.class);
}
CommandLine commandLine = cli.parse(args, true);
try {
CLIConfigurator.inject(commandLine, grepCommand);
} catch (Throwable e) {
throw new RuntimeException(e);
}
int context = grepCommand.getContext();
int beforeLines = grepCommand.getBeforeLines();
int afterLines = grepCommand.getAfterLines();
if (context > 0) {
if (beforeLines < 1) {
beforeLines = context;
}
if (afterLines < 1) {
afterLines = context;
}
}
return new GrepHandler(grepCommand.getPattern(), grepCommand.isIgnoreCase(), grepCommand.isInvertMatch(),
grepCommand.isRegEx(), grepCommand.isShowLineNumber(), grepCommand.isTrimEnd(), beforeLines,
afterLines, grepCommand.getMaxCount());
}
GrepHandler(String keyword, boolean ignoreCase, boolean invertMatch, boolean regexpMode,
boolean showLineNumber, boolean trimEnd, int beforeLines, int afterLines, int maxCount) {
this.ignoreCase = ignoreCase;
this.invertMatch = invertMatch;
this.showLineNumber = showLineNumber;
this.trimEnd = trimEnd;
this.beforeLines = beforeLines > 0 ? beforeLines : 0;
this.afterLines = afterLines > 0 ? afterLines : 0;
this.maxCount = maxCount > 0 ? maxCount : 0;
if (regexpMode) {
final int flags = ignoreCase ? Pattern.CASE_INSENSITIVE : 0;
this.pattern = Pattern.compile(keyword, flags);
} else {
this.pattern = null;
}
this.keyword = ignoreCase ? keyword.toLowerCase() : keyword;
}
@Override
public String apply(String input) {
StringBuilder output = new StringBuilder();
String[] lines = input.split("\n");
int continueCount = 0;
int lastStartPos = 0;
int lastContinueLineNum = -1;
int matchCount = 0;
for (int lineNum = 0; lineNum < lines.length;) {
String line = null;
if (this.trimEnd) {
line = StringUtils.stripEnd(lines[lineNum], null);
} else {
line = lines[lineNum];
}
lineNum++;
final boolean match;
if (pattern == null) {
match = (ignoreCase ? line.toLowerCase() : line).contains(keyword);
} else {
match = pattern.matcher(line).find();
}
if (invertMatch != match) {
matchCount++;
if (beforeLines > continueCount) {
int n = lastContinueLineNum == -1 ? (beforeLines >= lineNum ? 1 : lineNum - beforeLines)
: lineNum - beforeLines - continueCount;
if (n >= lastContinueLineNum || lastContinueLineNum == -1) {
StringBuilder beforeSb = new StringBuilder();
for (int i = n; i < lineNum; i++) {
appendLine(beforeSb, i, lines[i - 1]);
}
output.insert(lastStartPos, beforeSb);
}
} // end handle before lines
lastStartPos = output.length();
appendLine(output, lineNum, line);
if (afterLines > continueCount) {
int last = lineNum + afterLines - continueCount;
if (last > lines.length) {
last = lines.length;
}
for (int i = lineNum; i < last; i++) {
appendLine(output, i + 1, lines[i]);
lineNum++;
continueCount++;
lastStartPos = output.length();
}
} // end handle afterLines
continueCount++;
if (maxCount > 0 && matchCount >= maxCount) {
break;
}
} else { // not match
if (continueCount > 0) {
lastContinueLineNum = lineNum - 1;
continueCount = 0;
}
}
}
final String str = output.toString();
return str;
}
protected void appendLine(StringBuilder output, int lineNum, String line) {
if (showLineNumber) {
output.append(lineNum).append(':');
}
output.append(line).append('\n');
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/impl/BuiltinCommandResolver.java | core/src/main/java/com/taobao/arthas/core/shell/impl/BuiltinCommandResolver.java | package com.taobao.arthas.core.shell.impl;
import com.taobao.arthas.core.shell.command.Command;
import com.taobao.arthas.core.shell.command.CommandBuilder;
import com.taobao.arthas.core.shell.command.CommandProcess;
import com.taobao.arthas.core.shell.command.CommandResolver;
import com.taobao.arthas.core.shell.command.internal.GrepHandler;
import com.taobao.arthas.core.shell.command.internal.PlainTextHandler;
import com.taobao.arthas.core.shell.command.internal.WordCountHandler;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.arthas.core.shell.handlers.NoOpHandler;
import java.util.Arrays;
import java.util.List;
/**
* @author beiwei30 on 23/11/2016.
*/
class BuiltinCommandResolver implements CommandResolver {
private Handler<CommandProcess> handler;
public BuiltinCommandResolver() {
this.handler = new NoOpHandler<CommandProcess>();
}
@Override
public List<Command> commands() {
return Arrays.asList(CommandBuilder.command("exit").processHandler(handler).build(),
CommandBuilder.command("quit").processHandler(handler).build(),
CommandBuilder.command("jobs").processHandler(handler).build(),
CommandBuilder.command("fg").processHandler(handler).build(),
CommandBuilder.command("bg").processHandler(handler).build(),
CommandBuilder.command("kill").processHandler(handler).build(),
CommandBuilder.command(PlainTextHandler.NAME).processHandler(handler).build(),
CommandBuilder.command(GrepHandler.NAME).processHandler(handler).build(),
CommandBuilder.command(WordCountHandler.NAME).processHandler(handler).build());
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/impl/ShellImpl.java | core/src/main/java/com/taobao/arthas/core/shell/impl/ShellImpl.java | package com.taobao.arthas.core.shell.impl;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.common.ArthasConstants;
import com.taobao.arthas.core.security.AuthUtils;
import com.taobao.arthas.core.security.SecurityAuthenticator;
import com.taobao.arthas.core.server.ArthasBootstrap;
import com.taobao.arthas.core.shell.Shell;
import com.taobao.arthas.core.shell.ShellServer;
import com.taobao.arthas.core.shell.cli.CliToken;
import com.taobao.arthas.core.shell.cli.CliTokens;
import com.taobao.arthas.core.shell.future.Future;
import com.taobao.arthas.core.shell.handlers.shell.*;
import com.taobao.arthas.core.shell.session.Session;
import com.taobao.arthas.core.shell.session.impl.SessionImpl;
import com.taobao.arthas.core.shell.system.ExecStatus;
import com.taobao.arthas.core.shell.system.Job;
import com.taobao.arthas.core.shell.system.JobController;
import com.taobao.arthas.core.shell.system.JobListener;
import com.taobao.arthas.core.shell.system.impl.InternalCommandManager;
import com.taobao.arthas.core.shell.system.impl.JobControllerImpl;
import com.taobao.arthas.core.shell.term.Term;
import com.taobao.arthas.core.shell.term.impl.TermImpl;
import com.taobao.arthas.core.shell.term.impl.http.ExtHttpTtyConnection;
import com.taobao.arthas.core.util.Constants;
import com.taobao.arthas.core.util.FileUtils;
import io.netty.channel.ChannelHandlerContext;
import io.termd.core.telnet.TelnetConnection;
import io.termd.core.telnet.TelnetTtyConnection;
import io.termd.core.telnet.netty.NettyTelnetConnection;
import io.termd.core.tty.TtyConnection;
import java.io.File;
import java.lang.instrument.Instrumentation;
import java.security.Principal;
import java.util.Date;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import java.util.UUID;
import javax.security.auth.Subject;
import javax.security.auth.login.LoginException;
/**
* The shell session as seen from the shell server perspective.
*
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
*/
public class ShellImpl implements Shell {
private static final Logger logger = LoggerFactory.getLogger(ShellImpl.class);
private SecurityAuthenticator securityAuthenticator = ArthasBootstrap.getInstance().getSecurityAuthenticator();
private JobControllerImpl jobController;
final String id;
final Future<Void> closedFuture;
private InternalCommandManager commandManager;
private Session session = new SessionImpl();
private Term term;
private String welcome;
private Job currentForegroundJob;
private String prompt;
public ShellImpl(ShellServer server, Term term, InternalCommandManager commandManager,
Instrumentation instrumentation, long pid, JobControllerImpl jobController) {
if (term instanceof TermImpl) {
TermImpl termImpl = (TermImpl) term;
TtyConnection conn = termImpl.getConn();
// 处理telnet本地连接鉴权
if (conn instanceof TelnetTtyConnection) {
TelnetConnection telnetConnection = ((TelnetTtyConnection) conn).getTelnetConnection();
if (telnetConnection instanceof NettyTelnetConnection) {
ChannelHandlerContext handlerContext = ((NettyTelnetConnection) telnetConnection)
.channelHandlerContext();
Principal principal = AuthUtils.localPrincipal(handlerContext);
if (principal != null) {
try {
Subject subject = securityAuthenticator.login(principal);
if (subject != null) {
session.put(ArthasConstants.SUBJECT_KEY, subject);
}
} catch (LoginException e) {
logger.error("local connection auth error", e);
}
}
}
}
if (conn instanceof ExtHttpTtyConnection) {
// 传递http cookie 里的鉴权信息到新建立的session中
ExtHttpTtyConnection extConn = (ExtHttpTtyConnection) conn;
Map<String, Object> extSessions = extConn.extSessions();
for (Entry<String, Object> entry : extSessions.entrySet()) {
session.put(entry.getKey(), entry.getValue());
}
}
}
session.put(Session.COMMAND_MANAGER, commandManager);
session.put(Session.INSTRUMENTATION, instrumentation);
session.put(Session.PID, pid);
session.put(Session.SERVER, server);
session.put(Session.TTY, term);
this.id = UUID.randomUUID().toString();
session.put(Session.ID, id);
this.commandManager = commandManager;
this.closedFuture = Future.future();
this.term = term;
this.jobController = jobController;
if (term != null) {
term.setSession(session);
}
this.setPrompt();
}
public JobController jobController() {
return jobController;
}
public Set<Job> jobs() {
return jobController.jobs();
}
@Override
public synchronized Job createJob(List<CliToken> args) {
Job job = jobController.createJob(commandManager, args, session, new ShellJobHandler(this), term, null);
return job;
}
@Override
public Job createJob(String line) {
return createJob(CliTokens.tokenize(line));
}
@Override
public Session session() {
return session;
}
public Term term() {
return term;
}
public FutureHandler closedFutureHandler() {
return new FutureHandler(closedFuture);
}
public long lastAccessedTime() {
return term.lastAccessedTime();
}
public void setWelcome(String welcome) {
this.welcome = welcome;
}
private void setPrompt(){
this.prompt = "[arthas@" +
session.getPid() +
"]$ ";
}
public ShellImpl init() {
term.interruptHandler(new InterruptHandler(this));
term.suspendHandler(new SuspendHandler(this));
term.closeHandler(new CloseHandler(this));
if (welcome != null && welcome.length() > 0) {
term.write(welcome + "\n");
}
return this;
}
public String statusLine(Job job, ExecStatus status) {
StringBuilder sb = new StringBuilder("[").append(job.id()).append("]");
if (this.session().equals(job.getSession())) {
sb.append("*");
}
sb.append("\n");
sb.append(" ").append(Character.toUpperCase(status.name().charAt(0)))
.append(status.name().substring(1).toLowerCase());
sb.append(" ").append(job.line()).append("\n");
sb.append(" execution count : ").append(job.process().times()).append("\n");
sb.append(" start time : ").append(job.process().startTime()).append("\n");
String cacheLocation = job.process().cacheLocation();
if (cacheLocation != null) {
sb.append(" cache location : ").append(cacheLocation).append("\n");
}
Date timeoutDate = job.timeoutDate();
if (timeoutDate != null) {
sb.append(" timeout date : ").append(timeoutDate).append("\n");
}
sb.append(" session : ").append(job.getSession().getSessionId()).append(
session.equals(job.getSession()) ? " (current)" : "").append("\n");
return sb.toString();
}
public void readline() {
term.readline(prompt, new ShellLineHandler(this),
new CommandManagerCompletionHandler(commandManager));
}
public void close(String reason) {
if (term != null) {
try {
term.write("session (" + session.getSessionId() + ") is closed because " + reason + "\n");
} catch (Throwable t) {
// sometimes an NPE will be thrown during shutdown via web-socket,
// this ensures the shutdown process is finished properly
// https://github.com/alibaba/arthas/issues/320
logger.error("Error writing data:", t);
}
term.close();
} else {
jobController.close(closedFutureHandler());
}
}
public void setForegroundJob(Job job) {
currentForegroundJob = job;
}
public Job getForegroundJob() {
return currentForegroundJob;
}
private static class ShellJobHandler implements JobListener {
ShellImpl shell;
public ShellJobHandler(ShellImpl shell) {
this.shell = shell;
}
@Override
public void onForeground(Job job) {
shell.setForegroundJob(job);
//reset stdin handler to job's origin handler
//shell.term().stdinHandler(job.process().getStdinHandler());
}
@Override
public void onBackground(Job job) {
resetAndReadLine();
}
@Override
public void onTerminated(Job job) {
if (!job.isRunInBackground()){
resetAndReadLine();
}
// save command history
Term term = shell.term();
if (term instanceof TermImpl) {
List<int[]> history = ((TermImpl) term).getReadline().getHistory();
FileUtils.saveCommandHistory(history, new File(Constants.CMD_HISTORY_FILE));
}
}
@Override
public void onSuspend(Job job) {
if (!job.isRunInBackground()){
resetAndReadLine();
}
}
private void resetAndReadLine() {
//reset stdin handler to echo handler
//shell.term().stdinHandler(null);
shell.setForegroundJob(null);
shell.readline();
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/impl/ShellServerImpl.java | core/src/main/java/com/taobao/arthas/core/shell/impl/ShellServerImpl.java | package com.taobao.arthas.core.shell.impl;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.alibaba.arthas.tunnel.client.TunnelClient;
import com.taobao.arthas.core.server.ArthasBootstrap;
import com.taobao.arthas.core.shell.Shell;
import com.taobao.arthas.core.shell.ShellServer;
import com.taobao.arthas.core.shell.ShellServerOptions;
import com.taobao.arthas.core.shell.command.CommandResolver;
import com.taobao.arthas.core.shell.future.Future;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.arthas.core.shell.handlers.server.SessionClosedHandler;
import com.taobao.arthas.core.shell.handlers.server.SessionsClosedHandler;
import com.taobao.arthas.core.shell.handlers.server.TermServerListenHandler;
import com.taobao.arthas.core.shell.handlers.server.TermServerTermHandler;
import com.taobao.arthas.core.shell.system.Job;
import com.taobao.arthas.core.shell.system.impl.GlobalJobControllerImpl;
import com.taobao.arthas.core.shell.system.impl.InternalCommandManager;
import com.taobao.arthas.core.shell.system.impl.JobControllerImpl;
import com.taobao.arthas.core.shell.term.Term;
import com.taobao.arthas.core.shell.term.TermServer;
import com.taobao.arthas.core.util.ArthasBanner;
import java.lang.instrument.Instrumentation;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.ThreadFactory;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.atomic.AtomicInteger;
/**
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
*/
public class ShellServerImpl extends ShellServer {
private static final Logger logger = LoggerFactory.getLogger(ShellServerImpl.class);
private final CopyOnWriteArrayList<CommandResolver> resolvers;
private final InternalCommandManager commandManager;
private final List<TermServer> termServers;
private final long timeoutMillis;
private final long reaperInterval;
private String welcomeMessage;
private Instrumentation instrumentation;
private long pid;
private boolean closed = true;
private final Map<String, ShellImpl> sessions;
private final Future<Void> sessionsClosed = Future.future();
private ScheduledExecutorService scheduledExecutorService;
private JobControllerImpl jobController = new GlobalJobControllerImpl();
public ShellServerImpl(ShellServerOptions options) {
this.welcomeMessage = options.getWelcomeMessage();
this.termServers = new ArrayList<TermServer>();
this.timeoutMillis = options.getSessionTimeout();
this.sessions = new ConcurrentHashMap<String, ShellImpl>();
this.reaperInterval = options.getReaperInterval();
this.resolvers = new CopyOnWriteArrayList<CommandResolver>();
this.commandManager = new InternalCommandManager(resolvers);
this.instrumentation = options.getInstrumentation();
this.pid = options.getPid();
// Register builtin commands so they are listed in help
resolvers.add(new BuiltinCommandResolver());
}
@Override
public synchronized ShellServer registerCommandResolver(CommandResolver resolver) {
resolvers.add(0, resolver);
return this;
}
@Override
public synchronized ShellServer registerTermServer(TermServer termServer) {
termServers.add(termServer);
return this;
}
public void handleTerm(Term term) {
synchronized (this) {
// That might happen with multiple ser
if (closed) {
term.close();
return;
}
}
ShellImpl session = createShell(term);
tryUpdateWelcomeMessage();
session.setWelcome(welcomeMessage);
session.closedFuture.setHandler(new SessionClosedHandler(this, session));
session.init();
sessions.put(session.id, session); // Put after init so the close handler on the connection is set
session.readline(); // Now readline
}
private void tryUpdateWelcomeMessage() {
TunnelClient tunnelClient = ArthasBootstrap.getInstance().getTunnelClient();
if (tunnelClient != null) {
String id = tunnelClient.getId();
if (id != null) {
Map<String, String> welcomeInfos = new HashMap<String, String>();
welcomeInfos.put("id", id);
this.welcomeMessage = ArthasBanner.welcome(welcomeInfos);
}
}
}
@Override
public ShellServer listen(final Handler<Future<Void>> listenHandler) {
final List<TermServer> toStart;
synchronized (this) {
if (!closed) {
throw new IllegalStateException("Server listening");
}
toStart = termServers;
}
final AtomicInteger count = new AtomicInteger(toStart.size());
if (count.get() == 0) {
setClosed(false);
listenHandler.handle(Future.<Void>succeededFuture());
return this;
}
Handler<Future<TermServer>> handler = new TermServerListenHandler(this, listenHandler, toStart);
for (TermServer termServer : toStart) {
termServer.termHandler(new TermServerTermHandler(this));
termServer.listen(handler);
}
return this;
}
private void evictSessions() {
long now = System.currentTimeMillis();
Set<ShellImpl> toClose = new HashSet<ShellImpl>();
for (ShellImpl session : sessions.values()) {
// do not close if there is still job running,
// e.g. trace command might wait for a long time before condition is met
if (now - session.lastAccessedTime() > timeoutMillis && session.jobs().size() == 0) {
toClose.add(session);
}
logger.debug(session.id + ":" + session.lastAccessedTime());
}
for (ShellImpl session : toClose) {
long timeOutInMinutes = timeoutMillis / 1000 / 60;
String reason = "session is inactive for " + timeOutInMinutes + " min(s).";
session.close(reason);
}
}
public synchronized void setTimer() {
if (!closed && reaperInterval > 0) {
scheduledExecutorService = Executors.newSingleThreadScheduledExecutor(new ThreadFactory() {
@Override
public Thread newThread(Runnable r) {
final Thread t = new Thread(r, "arthas-shell-server");
t.setDaemon(true);
return t;
}
});
scheduledExecutorService.scheduleAtFixedRate(new Runnable() {
@Override
public void run() {
evictSessions();
}
}, 0, reaperInterval, TimeUnit.MILLISECONDS);
}
}
public synchronized void setClosed(boolean closed) {
this.closed = closed;
}
public void removeSession(ShellImpl shell) {
boolean completeSessionClosed;
Job job = shell.getForegroundJob();
if (job != null) {
// close shell's foreground job
job.terminate();
logger.info("Session {} closed, so terminate foreground job, id: {}, line: {}",
shell.session().getSessionId(), job.id(), job.line());
}
synchronized (ShellServerImpl.this) {
sessions.remove(shell.id);
shell.close("network error");
completeSessionClosed = sessions.isEmpty() && closed;
}
if (completeSessionClosed) {
sessionsClosed.complete();
}
}
@Override
public synchronized Shell createShell() {
return createShell(null);
}
@Override
public synchronized ShellImpl createShell(Term term) {
if (closed) {
throw new IllegalStateException("Closed");
}
return new ShellImpl(this, term, commandManager, instrumentation, pid, jobController);
}
@Override
public void close(final Handler<Future<Void>> completionHandler) {
List<TermServer> toStop;
List<ShellImpl> toClose;
synchronized (this) {
if (closed) {
toStop = Collections.emptyList();
toClose = Collections.emptyList();
} else {
setClosed(true);
if (scheduledExecutorService != null) {
scheduledExecutorService.shutdownNow();
}
toStop = termServers;
toClose = new ArrayList<ShellImpl>(sessions.values());
if (toClose.isEmpty()) {
sessionsClosed.complete();
}
}
}
if (toStop.isEmpty() && toClose.isEmpty()) {
completionHandler.handle(Future.<Void>succeededFuture());
} else {
final AtomicInteger count = new AtomicInteger(1 + toClose.size());
Handler<Future<Void>> handler = new SessionsClosedHandler(count, completionHandler);
for (ShellImpl shell : toClose) {
shell.close("server is going to shutdown.");
}
for (TermServer termServer : toStop) {
termServer.close(handler);
}
jobController.close();
sessionsClosed.setHandler(handler);
}
}
public JobControllerImpl getJobController() {
return jobController;
}
public InternalCommandManager getCommandManager() {
return commandManager;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/history/HistoryManager.java | core/src/main/java/com/taobao/arthas/core/shell/history/HistoryManager.java | package com.taobao.arthas.core.shell.history;
import java.util.List;
/**
* @author gongdewei 2020/4/8
*/
public interface HistoryManager {
void addHistory(String commandLine);
List<String> getHistory();
void setHistory(List<String> history);
void saveHistory();
void loadHistory();
void clearHistory();
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/history/impl/HistoryManagerImpl.java | core/src/main/java/com/taobao/arthas/core/shell/history/impl/HistoryManagerImpl.java | package com.taobao.arthas.core.shell.history.impl;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.shell.history.HistoryManager;
import com.taobao.arthas.core.util.Constants;
import com.taobao.arthas.core.util.FileUtils;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
/**
* @see io.termd.core.readline.Readline#history
* @author gongdewei 2020/4/8
*/
public class HistoryManagerImpl implements HistoryManager {
/**
* The max number of history item that will be saved in memory.
*/
private static final int MAX_HISTORY_SIZE = 500;
private static final Logger logger = LoggerFactory.getLogger(HistoryManagerImpl.class);
private List<String> history = new ArrayList<String>();
public HistoryManagerImpl() {
}
@Override
public synchronized void saveHistory() {
try {
FileUtils.saveCommandHistoryString(history, new File(Constants.CMD_HISTORY_FILE));
} catch (Throwable e) {
logger.error("save command history failed", e);
}
}
@Override
public synchronized void loadHistory() {
try {
history = FileUtils.loadCommandHistoryString(new File(Constants.CMD_HISTORY_FILE));
} catch (Throwable e) {
logger.error("load command history failed", e);
}
}
@Override
public synchronized void clearHistory() {
this.history.clear();
}
@Override
public synchronized void addHistory(String commandLine) {
while (history.size() >= MAX_HISTORY_SIZE) {
history.remove(0);
}
history.add(commandLine);
}
@Override
public synchronized List<String> getHistory() {
return new ArrayList<String>(history);
}
@Override
public synchronized void setHistory(List<String> history) {
this.history = history;
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/term/Term.java | core/src/main/java/com/taobao/arthas/core/shell/term/Term.java | package com.taobao.arthas.core.shell.term;
import com.taobao.arthas.core.shell.cli.Completion;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.arthas.core.shell.session.Session;
import io.termd.core.function.Function;
/**
* The terminal.
*
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
*/
public interface Term extends Tty {
@Override
Term resizehandler(Handler<Void> handler);
@Override
Term stdinHandler(Handler<String> handler);
Term stdoutHandler(Function<String, String> handler);
@Override
Term write(String data);
/**
* @return the last time this term received input
*/
long lastAccessedTime();
/**
* Echo some text in the terminal, escaped if necessary.<p/>
*
* @param text the text to echo
* @return a reference to this, so the API can be used fluently
*/
Term echo(String text);
/**
* Associate the term with a session.
*
* @param session the session to set
* @return a reference to this, so the API can be used fluently
*/
Term setSession(Session session);
/**
* Set an interrupt signal handler on the term.
*
* @param handler the interrupt handler
* @return a reference to this, so the API can be used fluently
*/
Term interruptHandler(SignalHandler handler);
/**
* Set a suspend signal handler on the term.
*
* @param handler the suspend handler
* @return a reference to this, so the API can be used fluently
*/
Term suspendHandler(SignalHandler handler);
/**
* Prompt the user a line of text.
*
* @param prompt the displayed prompt
* @param lineHandler the line handler called with the line
*/
void readline(String prompt, Handler<String> lineHandler);
/**
* Prompt the user a line of text, providing a completion handler to handle user's completion.
*
* @param prompt the displayed prompt
* @param lineHandler the line handler called with the line
* @param completionHandler the completion handler
*/
void readline(String prompt, Handler<String> lineHandler, Handler<Completion> completionHandler);
/**
* Set a handler that will be called when the terminal is closed.
*
* @param handler the handler
* @return a reference to this, so the API can be used fluently
*/
Term closeHandler(Handler<Void> handler);
/**
* Close the connection to terminal.
*/
void close();
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/term/Tty.java | core/src/main/java/com/taobao/arthas/core/shell/term/Tty.java | package com.taobao.arthas.core.shell.term;
import com.taobao.arthas.core.shell.handlers.Handler;
/**
* Provide interactions with the Shell TTY.
*
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
*/
public interface Tty {
/**
* @return the declared tty type, for instance {@literal vt100}, {@literal xterm-256}, etc... it can be null
* when the tty does not have declared its type.
*/
String type();
/**
* @return the current width, i.e the number of rows or {@literal -1} if unknown
*/
int width();
/**
* @return the current height, i.e the number of columns or {@literal -1} if unknown
*/
int height();
/**
* Set a stream handler on the standard input to read the data.
*
* @param handler the standard input
* @return this object
*/
Tty stdinHandler(Handler<String> handler);
/**
* Write data to the standard output.
*
* @param data the data to write
* @return this object
*/
Tty write(String data);
/**
* Set a resize handler, the handler is called when the tty size changes.
*
* @param handler the resize handler
* @return this object
*/
Tty resizehandler(Handler<Void> handler);
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/term/TermServer.java | core/src/main/java/com/taobao/arthas/core/shell/term/TermServer.java | package com.taobao.arthas.core.shell.term;
import com.taobao.arthas.common.ArthasConstants;
import com.taobao.arthas.core.config.Configure;
import com.taobao.arthas.core.shell.ShellServerOptions;
import com.taobao.arthas.core.shell.future.Future;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.arthas.core.shell.term.impl.TelnetTermServer;
/**
* A server for terminal based applications.
*
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
*/
public abstract class TermServer {
/**
* Create a term server for the Telnet protocol.
*
* @param configure
* @return the term server
*/
public static TermServer createTelnetTermServer(Configure configure, ShellServerOptions options) {
int port = configure.getTelnetPort() != null ? configure.getTelnetPort() : ArthasConstants.TELNET_PORT;
return new TelnetTermServer(configure.getIp(), port, options.getConnectionTimeout());
}
/**
* Create a term server for the HTTP protocol, using an existing router.
*
* @return the term server
*/
public static TermServer createHttpTermServer() {
// TODO
return null;
}
/**
* Set the term handler that will receive incoming client connections. When a remote terminal connects
* the {@code handler} will be called with the {@link Term} which can be used to interact with the remote
* terminal.
*
* @param handler the term handler
* @return this object
*/
public abstract TermServer termHandler(Handler<Term> handler);
/**
* Bind the term server, the {@link #termHandler(Handler)} must be set before.
*
* @return this object
*/
public TermServer listen() {
return listen(null);
}
/**
* Bind the term server, the {@link #termHandler(Handler)} must be set before.
*
* @param listenHandler the listen handler
* @return this object
*/
public abstract TermServer listen(Handler<Future<TermServer>> listenHandler);
/**
* The actual port the server is listening on. This is useful if you bound the server specifying 0 as port number
* signifying an ephemeral port
*
* @return the actual port the server is listening on.
*/
public abstract int actualPort();
/**
* Close the server. This will close any currently open connections. The close may not complete until after this
* method has returned.
*/
public abstract void close();
/**
* Like {@link #close} but supplying a handler that will be notified when close is complete.
*
* @param completionHandler the handler to be notified when the term server is closed
*/
public abstract void close(Handler<Future<Void>> completionHandler);
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/term/SignalHandler.java | core/src/main/java/com/taobao/arthas/core/shell/term/SignalHandler.java | package com.taobao.arthas.core.shell.term;
/**
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
*/
public interface SignalHandler {
boolean deliver(int key);
} | java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/term/impl/CompletionHandler.java | core/src/main/java/com/taobao/arthas/core/shell/term/impl/CompletionHandler.java | package com.taobao.arthas.core.shell.term.impl;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.shell.cli.CliToken;
import com.taobao.arthas.core.shell.cli.CliTokens;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.arthas.core.shell.session.Session;
import io.termd.core.function.Consumer;
import io.termd.core.readline.Completion;
import java.util.Collections;
import java.util.List;
/**
* @author beiwei30 on 23/11/2016.
*/
class CompletionHandler implements Consumer<Completion> {
private static final Logger logger = LoggerFactory.getLogger(CompletionHandler.class);
private final Handler<com.taobao.arthas.core.shell.cli.Completion> completionHandler;
private final Session session;
public CompletionHandler(Handler<com.taobao.arthas.core.shell.cli.Completion> completionHandler, Session session) {
this.completionHandler = completionHandler;
this.session = session;
}
@Override
public void accept(final Completion completion) {
try {
final String line = io.termd.core.util.Helper.fromCodePoints(completion.line());
final List<CliToken> tokens = Collections.unmodifiableList(CliTokens.tokenize(line));
com.taobao.arthas.core.shell.cli.Completion comp = new CompletionAdaptor(line, tokens, completion, session);
completionHandler.handle(comp);
} catch (Throwable t) {
// t.printStackTrace();
logger.error("completion error", t);
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/term/impl/HttpTermServer.java | core/src/main/java/com/taobao/arthas/core/shell/term/impl/HttpTermServer.java | package com.taobao.arthas.core.shell.term.impl;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.shell.future.Future;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.arthas.core.shell.term.Term;
import com.taobao.arthas.core.shell.term.TermServer;
import com.taobao.arthas.core.shell.term.impl.http.NettyWebsocketTtyBootstrap;
import com.taobao.arthas.core.shell.term.impl.http.session.HttpSessionManager;
import io.netty.util.concurrent.EventExecutorGroup;
import io.termd.core.function.Consumer;
import io.termd.core.tty.TtyConnection;
import java.util.concurrent.TimeUnit;
/**
* @author beiwei30 on 18/11/2016.
*/
public class HttpTermServer extends TermServer {
private static final Logger logger = LoggerFactory.getLogger(HttpTermServer.class);
private Handler<Term> termHandler;
private NettyWebsocketTtyBootstrap bootstrap;
private String hostIp;
private int port;
private long connectionTimeout;
private EventExecutorGroup workerGroup;
private HttpSessionManager httpSessionManager;
public HttpTermServer(String hostIp, int port, long connectionTimeout, EventExecutorGroup workerGroup, HttpSessionManager httpSessionManager) {
this.hostIp = hostIp;
this.port = port;
this.connectionTimeout = connectionTimeout;
this.workerGroup = workerGroup;
this.httpSessionManager = httpSessionManager;
}
@Override
public TermServer termHandler(Handler<Term> handler) {
this.termHandler = handler;
return this;
}
@Override
public TermServer listen(Handler<Future<TermServer>> listenHandler) {
// TODO: charset and inputrc from options
bootstrap = new NettyWebsocketTtyBootstrap(workerGroup, httpSessionManager).setHost(hostIp).setPort(port);
try {
bootstrap.start(new Consumer<TtyConnection>() {
@Override
public void accept(final TtyConnection conn) {
termHandler.handle(new TermImpl(Helper.loadKeymap(), conn));
}
}).get(connectionTimeout, TimeUnit.MILLISECONDS);
listenHandler.handle(Future.<TermServer>succeededFuture());
} catch (Throwable t) {
logger.error("Error listening to port " + port, t);
listenHandler.handle(Future.<TermServer>failedFuture(t));
}
return this;
}
@Override
public int actualPort() {
return bootstrap.getPort();
}
@Override
public void close() {
close(null);
}
@Override
public void close(Handler<Future<Void>> completionHandler) {
if (bootstrap != null) {
bootstrap.stop();
if (completionHandler != null) {
completionHandler.handle(Future.<Void>succeededFuture());
}
} else {
if (completionHandler != null) {
completionHandler.handle(Future.<Void>failedFuture("telnet term server not started"));
}
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/term/impl/TermImpl.java | core/src/main/java/com/taobao/arthas/core/shell/term/impl/TermImpl.java | package com.taobao.arthas.core.shell.term.impl;
import java.io.File;
import java.lang.reflect.Proxy;
import java.util.ArrayList;
import java.util.List;
import com.taobao.arthas.core.shell.cli.Completion;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.arthas.core.shell.handlers.term.CloseHandlerWrapper;
import com.taobao.arthas.core.shell.handlers.term.DefaultTermStdinHandler;
import com.taobao.arthas.core.shell.handlers.term.EventHandler;
import com.taobao.arthas.core.shell.handlers.term.RequestHandler;
import com.taobao.arthas.core.shell.handlers.term.SizeHandlerWrapper;
import com.taobao.arthas.core.shell.handlers.term.StdinHandlerWrapper;
import com.taobao.arthas.core.shell.session.Session;
import com.taobao.arthas.core.shell.term.SignalHandler;
import com.taobao.arthas.core.shell.term.Term;
import com.taobao.arthas.core.util.Constants;
import com.taobao.arthas.core.util.FileUtils;
import io.termd.core.function.Consumer;
import io.termd.core.readline.Function;
import io.termd.core.readline.Keymap;
import io.termd.core.readline.Readline;
import io.termd.core.readline.functions.HistorySearchForward;
import io.termd.core.tty.TtyConnection;
import io.termd.core.util.Helper;
/**
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
*/
public class TermImpl implements Term {
private static final List<Function> readlineFunctions = Helper.loadServices(Function.class.getClassLoader(), Function.class);
private Readline readline;
private Consumer<int[]> echoHandler;
private TtyConnection conn;
private volatile Handler<String> stdinHandler;
private List<io.termd.core.function.Function<String, String>> stdoutHandlerChain;
private SignalHandler interruptHandler;
private SignalHandler suspendHandler;
private Session session;
private boolean inReadline;
public TermImpl(TtyConnection conn) {
this(com.taobao.arthas.core.shell.term.impl.Helper.loadKeymap(), conn);
}
public TermImpl(Keymap keymap, TtyConnection conn) {
this.conn = conn;
readline = new Readline(keymap);
readline.setHistory(FileUtils.loadCommandHistory(new File(Constants.CMD_HISTORY_FILE)));
for (Function function : readlineFunctions) {
/**
* 防止没有鉴权时，查看历史命令
*
* @see io.termd.core.readline.functions.HistorySearchForward
*/
if (function.name().contains("history")) {
FunctionInvocationHandler funcHandler = new FunctionInvocationHandler(this, function);
function = (Function) Proxy.newProxyInstance(this.getClass().getClassLoader(),
HistorySearchForward.class.getInterfaces(), funcHandler);
}
readline.addFunction(function);
}
echoHandler = new DefaultTermStdinHandler(this);
conn.setStdinHandler(echoHandler);
conn.setEventHandler(new EventHandler(this));
}
@Override
public Term setSession(Session session) {
this.session = session;
return this;
}
public Session getSession() {
return session;
}
@Override
public void readline(String prompt, Handler<String> lineHandler) {
if (conn.getStdinHandler() != echoHandler) {
throw new IllegalStateException();
}
if (inReadline) {
throw new IllegalStateException();
}
inReadline = true;
readline.readline(conn, prompt, new RequestHandler(this, lineHandler));
}
public void readline(String prompt, Handler<String> lineHandler, Handler<Completion> completionHandler) {
if (conn.getStdinHandler() != echoHandler) {
throw new IllegalStateException();
}
if (inReadline) {
throw new IllegalStateException();
}
inReadline = true;
readline.readline(conn, prompt, new RequestHandler(this, lineHandler), new CompletionHandler(completionHandler, session));
}
@Override
public Term closeHandler(final Handler<Void> handler) {
if (handler != null) {
conn.setCloseHandler(new CloseHandlerWrapper(handler));
} else {
conn.setCloseHandler(null);
}
return this;
}
public long lastAccessedTime() {
return conn.lastAccessedTime();
}
@Override
public String type() {
return conn.terminalType();
}
@Override
public int width() {
return conn.size() != null ? conn.size().x() : -1;
}
@Override
public int height() {
return conn.size() != null ? conn.size().y() : -1;
}
void checkPending() {
if (stdinHandler != null && readline.hasEvent()) {
stdinHandler.handle(Helper.fromCodePoints(readline.nextEvent().buffer().array()));
checkPending();
}
}
@Override
public TermImpl resizehandler(Handler<Void> handler) {
if (inReadline) {
throw new IllegalStateException();
}
if (handler != null) {
conn.setSizeHandler(new SizeHandlerWrapper(handler));
} else {
conn.setSizeHandler(null);
}
return this;
}
@Override
public Term stdinHandler(final Handler<String> handler) {
if (inReadline) {
throw new IllegalStateException();
}
stdinHandler = handler;
if (handler != null) {
conn.setStdinHandler(new StdinHandlerWrapper(handler));
checkPending();
} else {
conn.setStdinHandler(echoHandler);
}
return this;
}
@Override
public Term stdoutHandler(io.termd.core.function.Function<String, String> handler) {
if (stdoutHandlerChain == null) {
stdoutHandlerChain = new ArrayList<io.termd.core.function.Function<String, String>>();
}
stdoutHandlerChain.add(handler);
return this;
}
@Override
public Term write(String data) {
if (stdoutHandlerChain != null) {
for (io.termd.core.function.Function<String, String> function : stdoutHandlerChain) {
data = function.apply(data);
}
}
conn.write(data);
return this;
}
public TermImpl interruptHandler(SignalHandler handler) {
interruptHandler = handler;
return this;
}
public TermImpl suspendHandler(SignalHandler handler) {
suspendHandler = handler;
return this;
}
public void close() {
conn.close();
FileUtils.saveCommandHistory(readline.getHistory(), new File(Constants.CMD_HISTORY_FILE));
}
public TermImpl echo(String text) {
echo(Helper.toCodePoints(text));
return this;
}
public void setInReadline(boolean inReadline) {
this.inReadline = inReadline;
}
public Readline getReadline() {
return readline;
}
public void handleIntr(Integer key) {
if (interruptHandler == null || !interruptHandler.deliver(key)) {
echo(key, '\n');
}
}
public void handleEof(Integer key) {
// Pseudo signal
if (stdinHandler != null) {
stdinHandler.handle(Helper.fromCodePoints(new int[]{key}));
} else {
echo(key);
readline.queueEvent(new int[]{key});
}
}
public void handleSusp(Integer key) {
if (suspendHandler == null || !suspendHandler.deliver(key)) {
echo(key, 'Z' - 64);
}
}
public TtyConnection getConn() {
return conn;
}
public void echo(int... codePoints) {
Consumer<int[]> out = conn.stdoutHandler();
for (int codePoint : codePoints) {
if (codePoint < 32) {
if (codePoint == '\t') {
out.accept(new int[]{'\t'});
} else if (codePoint == '\b') {
out.accept(new int[]{'\b', ' ', '\b'});
} else if (codePoint == '\r' || codePoint == '\n') {
out.accept(new int[]{'\n'});
} else {
out.accept(new int[]{'^', codePoint + 64});
}
} else {
if (codePoint == 127) {
out.accept(new int[]{'\b', ' ', '\b'});
} else {
out.accept(new int[]{codePoint});
}
}
}
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/term/impl/FunctionInvocationHandler.java | core/src/main/java/com/taobao/arthas/core/shell/term/impl/FunctionInvocationHandler.java | package com.taobao.arthas.core.shell.term.impl;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import com.taobao.arthas.common.ArthasConstants;
import com.taobao.arthas.core.shell.session.Session;
import io.termd.core.readline.Function;
import io.termd.core.readline.Readline;
import io.termd.core.readline.Readline.Interaction;
/**
* 拦截指定的 Function 的 apply 函数
*
* @author hengyunabc 2023-08-24
*
*/
public class FunctionInvocationHandler implements InvocationHandler {
private TermImpl termImpl;
private Function target;
public FunctionInvocationHandler(TermImpl termImpl, Function target) {
this.termImpl = termImpl;
this.target = target;
}
@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
String name = method.getName();
if (name.equals("apply")) {
Session session = termImpl.getSession();
if (session != null) {
boolean authenticated = session.get(ArthasConstants.SUBJECT_KEY) != null;
if (authenticated) {
return method.invoke(target, args);
} else {
Readline.Interaction interaction = (Interaction) args[0];
// 必要
interaction.resume();
return null;
}
}
}
return method.invoke(target, args);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/term/impl/CompletionAdaptor.java | core/src/main/java/com/taobao/arthas/core/shell/term/impl/CompletionAdaptor.java | package com.taobao.arthas.core.shell.term.impl;
import com.taobao.arthas.core.shell.cli.CliToken;
import com.taobao.arthas.core.shell.cli.Completion;
import com.taobao.arthas.core.shell.cli.CompletionUtils;
import com.taobao.arthas.core.shell.session.Session;
import com.taobao.arthas.core.util.StringUtils;
import java.util.LinkedList;
import java.util.List;
/**
* @author beiwei30 on 23/11/2016.
*/
class CompletionAdaptor implements Completion {
private final Session session;
private final String line;
private final List<CliToken> tokens;
private final io.termd.core.readline.Completion completion;
public CompletionAdaptor(String line, List<CliToken> tokens, io.termd.core.readline.Completion completion,
Session session) {
this.line = line;
this.tokens = tokens;
this.completion = completion;
this.session = session;
}
@Override
public Session session() {
return session;
}
@Override
public String rawLine() {
return line;
}
@Override
public List<CliToken> lineTokens() {
return tokens;
}
@Override
public void complete(List<String> candidates) {
String lastToken = tokens.isEmpty() ? null : tokens.get(tokens.size() - 1).value();
if(StringUtils.isBlank(lastToken)) {
lastToken = "";
}
if (candidates.size() > 1) {
// complete common prefix
String commonPrefix = CompletionUtils.findLongestCommonPrefix(candidates);
if (commonPrefix.length() > 0) {
if (!commonPrefix.equals(lastToken)) {
// only complete if the common prefix is longer than the last token
if (commonPrefix.length() > lastToken.length()) {
String strToComplete = commonPrefix.substring(lastToken.length());
completion.complete(io.termd.core.util.Helper.toCodePoints(strToComplete), false);
return;
}
}
}
}
if (candidates.size() > 0) {
List<int[]> suggestions = new LinkedList<int[]>();
for (String candidate : candidates) {
suggestions.add(io.termd.core.util.Helper.toCodePoints(candidate));
}
completion.suggest(suggestions);
} else {
completion.end();
}
}
@Override
public void complete(String value, boolean terminal) {
completion.complete(io.termd.core.util.Helper.toCodePoints(value), terminal);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/term/impl/TelnetTermServer.java | core/src/main/java/com/taobao/arthas/core/shell/term/impl/TelnetTermServer.java | package com.taobao.arthas.core.shell.term.impl;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.shell.future.Future;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.arthas.core.shell.term.Term;
import com.taobao.arthas.core.shell.term.TermServer;
import io.termd.core.function.Consumer;
import io.termd.core.telnet.netty.NettyTelnetTtyBootstrap;
import io.termd.core.tty.TtyConnection;
import java.util.concurrent.TimeUnit;
/**
* Encapsulate the Telnet server setup.
*
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
*/
public class TelnetTermServer extends TermServer {
private static final Logger logger = LoggerFactory.getLogger(TelnetTermServer.class);
private NettyTelnetTtyBootstrap bootstrap;
private String hostIp;
private int port;
private long connectionTimeout;
private Handler<Term> termHandler;
public TelnetTermServer(String hostIp, int port, long connectionTimeout) {
this.hostIp = hostIp;
this.port = port;
this.connectionTimeout = connectionTimeout;
}
@Override
public TermServer termHandler(Handler<Term> handler) {
termHandler = handler;
return this;
}
@Override
public TermServer listen(Handler<Future<TermServer>> listenHandler) {
// TODO: charset and inputrc from options
bootstrap = new NettyTelnetTtyBootstrap().setHost(hostIp).setPort(port);
try {
bootstrap.start(new Consumer<TtyConnection>() {
@Override
public void accept(final TtyConnection conn) {
termHandler.handle(new TermImpl(Helper.loadKeymap(), conn));
}
}).get(connectionTimeout, TimeUnit.MILLISECONDS);
listenHandler.handle(Future.<TermServer>succeededFuture());
} catch (Throwable t) {
logger.error("Error listening to port " + port, t);
listenHandler.handle(Future.<TermServer>failedFuture(t));
}
return this;
}
@Override
public void close() {
close(null);
}
@Override
public void close(Handler<Future<Void>> completionHandler) {
if (bootstrap != null) {
bootstrap.stop();
if (completionHandler != null) {
completionHandler.handle(Future.<Void>succeededFuture());
}
} else {
if (completionHandler != null) {
completionHandler.handle(Future.<Void>failedFuture("telnet term server not started"));
}
}
}
public int actualPort() {
return bootstrap.getPort();
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/term/impl/Helper.java | core/src/main/java/com/taobao/arthas/core/shell/term/impl/Helper.java | package com.taobao.arthas.core.shell.term.impl;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.shell.ShellServerOptions;
import com.taobao.arthas.core.shell.term.TermServer;
import io.termd.core.readline.Keymap;
import java.io.FileInputStream;
import java.io.InputStream;
/**
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
*/
public class Helper {
private static final Logger logger = LoggerFactory.getLogger(Helper.class);
public static Keymap loadKeymap() {
return new Keymap(loadInputRcFile());
}
public static InputStream loadInputRcFile() {
InputStream inputrc;
// step 1: load custom keymap file
try {
String customInputrc = System.getProperty("user.home") + "/.arthas/conf/inputrc";
inputrc = new FileInputStream(customInputrc);
logger.info("Loaded custom keymap file from " + customInputrc);
return inputrc;
} catch (Throwable e) {
// ignore
}
// step 2: load arthas default keymap file
inputrc = TermServer.class.getClassLoader().getResourceAsStream(ShellServerOptions.DEFAULT_INPUTRC);
if (inputrc != null) {
logger.info("Loaded arthas keymap file from " + ShellServerOptions.DEFAULT_INPUTRC);
return inputrc;
}
// step 3: fall back to termd default keymap file
inputrc = Keymap.class.getResourceAsStream("inputrc");
if (inputrc != null) {
return inputrc;
}
throw new IllegalStateException("Could not load inputrc file.");
}
// public static Buffer loadResource(FileSystem fs, String path) {
// try {
// return fs.readFileBlocking(path);
// } catch (Exception e) {
// return loadResource(path);
// }
// }
// public static Buffer loadResource(String path) {
// URL resource = HttpTermServer.class.getResource(path);
// if (resource != null) {
// try {
// byte[] tmp = new byte[512];
// InputStream in = resource.openStream();
// Buffer buffer = Buffer.buffer();
// while (true) {
// int l = in.read(tmp);
// if (l == -1) {
// break;
// }
// buffer.appendBytes(tmp, 0, l);
// }
// return buffer;
// } catch (IOException ignore) {
// }
// }
// return null;
// }
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/term/impl/httptelnet/NettyHttpTelnetTtyBootstrap.java | core/src/main/java/com/taobao/arthas/core/shell/term/impl/httptelnet/NettyHttpTelnetTtyBootstrap.java | package com.taobao.arthas.core.shell.term.impl.httptelnet;
import java.nio.charset.Charset;
import com.taobao.arthas.core.shell.term.impl.http.session.HttpSessionManager;
import io.netty.util.concurrent.EventExecutorGroup;
import io.termd.core.function.Consumer;
import io.termd.core.function.Supplier;
import io.termd.core.telnet.TelnetHandler;
import io.termd.core.telnet.TelnetTtyConnection;
import io.termd.core.tty.TtyConnection;
import io.termd.core.util.CompletableFuture;
import io.termd.core.util.Helper;
/**
* @author <a href="mailto:julien@julienviet.com">Julien Viet</a>
* @author hengyunabc 2019-11-05
*/
public class NettyHttpTelnetTtyBootstrap {
private final NettyHttpTelnetBootstrap httpTelnetTtyBootstrap;
private boolean outBinary;
private boolean inBinary;
private Charset charset = Charset.forName("UTF-8");
public NettyHttpTelnetTtyBootstrap(EventExecutorGroup workerGroup, HttpSessionManager httpSessionManager) {
this.httpTelnetTtyBootstrap = new NettyHttpTelnetBootstrap(workerGroup, httpSessionManager);
}
public String getHost() {
return httpTelnetTtyBootstrap.getHost();
}
public NettyHttpTelnetTtyBootstrap setHost(String host) {
httpTelnetTtyBootstrap.setHost(host);
return this;
}
public int getPort() {
return httpTelnetTtyBootstrap.getPort();
}
public NettyHttpTelnetTtyBootstrap setPort(int port) {
httpTelnetTtyBootstrap.setPort(port);
return this;
}
public boolean isOutBinary() {
return outBinary;
}
/**
* Enable or disable the TELNET BINARY option on output.
*
* @param outBinary
* true to require the client to receive binary
* @return this object
*/
public NettyHttpTelnetTtyBootstrap setOutBinary(boolean outBinary) {
this.outBinary = outBinary;
return this;
}
public boolean isInBinary() {
return inBinary;
}
/**
* Enable or disable the TELNET BINARY option on input.
*
* @param inBinary
* true to require the client to emit binary
* @return this object
*/
public NettyHttpTelnetTtyBootstrap setInBinary(boolean inBinary) {
this.inBinary = inBinary;
return this;
}
public Charset getCharset() {
return charset;
}
public void setCharset(Charset charset) {
this.charset = charset;
}
public CompletableFuture<?> start(Consumer<TtyConnection> factory) {
CompletableFuture<?> fut = new CompletableFuture();
start(factory, Helper.startedHandler(fut));
return fut;
}
public CompletableFuture<?> stop() {
CompletableFuture<?> fut = new CompletableFuture();
stop(Helper.stoppedHandler(fut));
return fut;
}
public void start(final Consumer<TtyConnection> factory, Consumer<Throwable> doneHandler) {
httpTelnetTtyBootstrap.start(new Supplier<TelnetHandler>() {
@Override
public TelnetHandler get() {
return new TelnetTtyConnection(inBinary, outBinary, charset, factory);
}
}, factory, doneHandler);
}
public void stop(Consumer<Throwable> doneHandler) {
httpTelnetTtyBootstrap.stop(doneHandler);
}
}
| java | Apache-2.0 | 17eb3c17e764728e6bf2cf3a37d56620e8835fd0 | 2026-01-04T14:45:57.082411Z | false |
alibaba/arthas | https://github.com/alibaba/arthas/blob/17eb3c17e764728e6bf2cf3a37d56620e8835fd0/core/src/main/java/com/taobao/arthas/core/shell/term/impl/httptelnet/HttpTelnetTermServer.java | core/src/main/java/com/taobao/arthas/core/shell/term/impl/httptelnet/HttpTelnetTermServer.java | package com.taobao.arthas.core.shell.term.impl.httptelnet;
import java.util.concurrent.TimeUnit;
import com.alibaba.arthas.deps.org.slf4j.Logger;
import com.alibaba.arthas.deps.org.slf4j.LoggerFactory;
import com.taobao.arthas.core.shell.future.Future;
import com.taobao.arthas.core.shell.handlers.Handler;
import com.taobao.arthas.core.shell.term.Term;
import com.taobao.arthas.core.shell.term.TermServer;
import com.taobao.arthas.core.shell.term.impl.Helper;
import com.taobao.arthas.core.shell.term.impl.TermImpl;
import com.taobao.arthas.core.shell.term.impl.http.session.HttpSessionManager;
import io.netty.util.concurrent.EventExecutorGroup;
import io.termd.core.function.Consumer;
import io.termd.core.tty.TtyConnection;
/**
* both suport http/telnet
*
* @author hengyunabc 2019-11-04
*
*/
public class HttpTelnetTermServer extends TermServer {
private static final Logger logger = LoggerFactory.getLogger(HttpTelnetTermServer.class);
private Handler<Term> termHandler;
private NettyHttpTelnetTtyBootstrap bootstrap;
private String hostIp;
private int port;
private long connectionTimeout;
private EventExecutorGroup workerGroup;
private HttpSessionManager httpSessionManager;
public HttpTelnetTermServer(String hostIp, int port, long connectionTimeout, EventExecutorGroup workerGroup, HttpSessionManager httpSessionManager) {
this.hostIp = hostIp;
this.port = port;
this.connectionTimeout = connectionTimeout;
this.workerGroup = workerGroup;
this.httpSessionManager = httpSessionManager;
}
@Override
public TermServer termHandler(Handler<Term> handler) {
this.termHandler = handler;
return this;
}
@Override
public TermServer listen(Handler<Future<TermServer>> listenHandler) {
// TODO: charset and inputrc from options
bootstrap = new NettyHttpTelnetTtyBootstrap(workerGroup, httpSessionManager).setHost(hostIp).setPort(port);
try {
bootstrap.start(new Consumer<TtyConnection>() {
@Override
public void accept(final TtyConnection conn) {
termHandler.handle(new TermImpl(Helper.loadKeymap(), conn));
}
}).get(connectionTimeout, TimeUnit.MILLISECONDS);
listenHandler.handle(Future.<TermServer>succeededFuture());
} catch (Throwable t) {
logger.error("Error listening to port " + port, t);
listenHandler.handle(Future.<TermServer>failedFuture(t));
}
return this;
}
@Override
public int actualPort() {
return bootstrap.getPort();
}
@Override
public void close() {
close(null);
}
@Override
public void close(Handler<Future<Void>> completionHandler) {
if (bootstrap != null) {
bootstrap.stop();
if (completionHandler != null) {
completionHandler.handle(Future.<Void>succeededFuture());
}
} else {
if (completionHandler != null) {
completionHandler.handle(Future.<Void>failedFuture("telnet term server not started"));
}
}
}
}
| 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.