yanlongqi/jhinno-openapi-java-sdk
1
0
Fork 0
mirror of https://github.com/yanlongqi/jhinno-openapi-java-sdk.git synced 2026-03-22 06:15:10 +08:00
Code Issues Packages Releases Wiki Activity

作业相关接口集成完成

Browse Source
This commit is contained in:
lqyan
2024-02-06 17:02:28 +08:00
parent 86e3fcb7f0
commit 83a6392db6
15 changed files with 1035 additions and 14 deletions
Download Patch File Download Diff File Expand all files Collapse all files

34
src/main/java/com/jhinno/sdk/openapi/api/JHApiExecution.java
View File

@@ -204,6 +204,20 @@ public class JHApiExecution {
}
/**
* 发起一个有返回值的POST请求
*
* @param path 请求路径
* @param username 用户名
* @param type 强求提的数据类型
* @param <R> 返回的数据类型
* @return 请求后的数据
*/
public <R> R post(String path, String username, TypeReference<ResponseResult<R>> type) {
return post(path, username, null, type);
}
/**
* 发起一个没有返回值的POST请求
*
@@ -228,7 +242,8 @@ public class JHApiExecution {
* @param username 用户名
*/
public void post(String path, String username) {
post(path, username, null);
post(path, username, new TypeReference<ResponseResult<?>>() {
});
}
@@ -251,6 +266,20 @@ public class JHApiExecution {
return result.getData();
}
/**
* 发起一个有返回值的PUT请求
*
* @param path 请求路径
* @param username 用户名
* @param type 强求提的数据类型
* @param <R> 返回的数据类型
* @return 请求后的数据
*/
public <R> R put(String path, String username, TypeReference<ResponseResult<R>> type) {
return put(path, username, null, type);
}
/**
* 发一个没有返回值的PUT请求
*
@@ -275,7 +304,8 @@ public class JHApiExecution {
* @param username 用户名
*/
public void put(String path, String username) {
put(path, username, null);
put(path, username, new TypeReference<ResponseResult<?>>() {
});
}

308
src/main/java/com/jhinno/sdk/openapi/api/job/JHJobApiExecution.java
View File

@@ -4,9 +4,11 @@ import cn.hutool.core.collection.CollectionUtil;
import cn.hutool.json.JSONUtil;
import com.fasterxml.jackson.core.type.TypeReference;
import com.jhinno.sdk.openapi.ArgsException;
import com.jhinno.sdk.openapi.CommonConstant;
import com.jhinno.sdk.openapi.ServiceException;
import com.jhinno.sdk.openapi.api.JHApiExecution;
import com.jhinno.sdk.openapi.api.ResponseResult;
import com.jhinno.sdk.openapi.api.file.FileInfo;
import com.jhinno.sdk.openapi.client.JHApiClient;
import org.apache.commons.lang3.StringUtils;
@@ -48,7 +50,7 @@ public class JHJobApiExecution extends JHApiExecution {
map.put("appId", appId);
map.put("params", JSONUtil.toJsonStr(params));
String path = JHApiClient.getUrl(JobPathConstant.JOB_SUBMIT_PATH, map);
List<Map<String, String>> result = post(path, username, null, new TypeReference<ResponseResult<List<Map<String, String>>>>() {
List<Map<String, String>> result = post(path, username, new TypeReference<ResponseResult<List<Map<String, String>>>>() {
});
if (CollectionUtil.isEmpty(result)) {
throw new ServiceException(path, 500, "作业提交返回为空！");
@@ -56,5 +58,309 @@ public class JHJobApiExecution extends JHApiExecution {
return result.get(0).get("jobid");
}
/**
* 使用作业id查询作业文件列表
*
* @param username 用户名
* @param jobId 作业id
* @return 作业文件列表
*/
public List<FileInfo> getJobFilesById(String username, String jobId) {
if (StringUtils.isBlank(jobId)) {
throw new ArgsException("jobId不能为空！");
}
String path = JobPathConstant.JOB_FIND_JOB_FILES_PATH.replace("{jobId}", jobId);
return get(path, username, new TypeReference<ResponseResult<List<FileInfo>>>() {
});
}
/**
* 分页查询作业列表
* <p>作业名、作业状态等为非必填自动，如果为空则没有添加该查询条件</p
*
* @param username 用户名
* @param page 页码（非必填，默认：1）
* @param pageSize 每页大小（非必填，默认：20）
* @param name 作业名（非必填）
* @param status 作业状态（非必填）
* @param condition 自定义条件（非必填）
* @return 作业列表
*/
public PageJobInfo getJobPage(String username, Integer page, Integer pageSize, String name, String status, Map<String, Object> condition) {
Map<String, Object> params = new HashMap<>(5);
if (page != null) {
params.put("page", page);
}
if (pageSize != null) {
params.put("pageSize", pageSize);
}
if (StringUtils.isNotBlank(name)) {
params.put("jobName", name);
}
if (StringUtils.isBlank(status)) {
params.put("status", status);
}
if (CollectionUtil.isNotEmpty(condition)) {
params.put("condition", JSONUtil.toJsonStr(params));
}
String path = JHApiClient.getUrl(JobPathConstant.JOB_PAGE_PATH, params);
return get(path, username, new TypeReference<ResponseResult<PageJobInfo>>() {
});
}
/**
* 查询作业详情
*
* @param username 用户名
* @param jobId 作业id
* @return 作业详情
*/
public JobInfo getJobDetail(String username, String jobId) {
if (StringUtils.isBlank(jobId)) {
throw new ArgsException("jobId不能为空！");
}
String path = JobPathConstant.JOB_DETAIL_INFO_PATH.replace("{jobId}", jobId);
return get(path, username, new TypeReference<ResponseResult<JobInfo>>() {
});
}
/**
* 分页检索作业名称查询作业信息
*
* @param username 用户名
* @param name 作业名 （必填）
* @param page 页码 （非必填，默认：1）
* @param pageSize 页大小（非必填，默认：20）
* @return 作业列表
*/
public List<JobInfo> getJobsByName(String username, String name, Integer page, Integer pageSize) {
if (StringUtils.isBlank(name)) {
throw new ArgsException("name不能为空！");
}
Map<String, Object> params = new HashMap<>(3);
params.put("name", name);
if (page != null) {
params.put("page", page);
}
if (pageSize != null) {
params.put("pageSize", pageSize);
}
String path = JHApiClient.getUrl(JobPathConstant.JOB_LIST_BY_NAME_PATH, params);
return get(path, username, new TypeReference<ResponseResult<List<JobInfo>>>() {
});
}
/**
* 分页检索作业状态
* <p>
* status（作业状态）的取值如下：
* <ol>
* <li>RUN（运行）</li>
* <li>PEND（等待）</li>
* <li>PSUSP（等待中挂起）</li>
* <li>USUSP（用户挂起）</li>
* <li>SSUSP（系统挂起）</li>
* <li>ZOMBI（僵尸）</li>
* <li>DONE（完成）</li>
* <li>EXIT（退出）</li>
* <li>UNKNOWN#UNKWN（状态不明）</li>
* </ol>
*
* @param username 用户名
* @param status 作业状态
* @param page 页码
* @param pageSize 分页大小
* @return 作业列表
*/
public List<JobInfo> getJobsByStatus(String username, String status, Integer page, Integer pageSize) {
if (StringUtils.isBlank(status)) {
throw new ArgsException("status不能为空！");
}
Map<String, Object> params = new HashMap<>(3);
if (page != null) {
params.put("page", page);
}
if (pageSize != null) {
params.put("pageSize", pageSize);
}
String path = JHApiClient.getUrl(JobPathConstant.JOB_LIST_BY_STATUS_PATH.replace("{status}", status), params);
return get(path, username, new TypeReference<ResponseResult<List<JobInfo>>>() {
});
}
/**
* 通过作业id列表查询作业列表
*
* @param username 用户列表
* @param jobIds 作业id列表
* @return 作业列表
*/
public List<JobInfo> getJobsByIds(String username, List<String> jobIds) {
if (CollectionUtil.isEmpty(jobIds)) {
throw new ArgsException("jobIds不能为空！");
}
Map<String, Object> params = new HashMap<>(1);
params.put("jobIds", String.join(CommonConstant.NORMAL_CHARACTER_COMMA, jobIds));
String path = JHApiClient.getUrl(JobPathConstant.JOB_LIST_BY_IDS_PATH, params);
return get(path, username, new TypeReference<ResponseResult<List<JobInfo>>>() {
});
}
/**
* 操作作业
* <p>
* {@link JobActionEnum} 中的 静态方法{@link JobActionEnum#getJobAction(String)}可以将前端的字符转换为{@link JobActionEnum}对象
* <p>
* 或者使用{@link #action(String, String, String)}直接操作，但最终还是调的这个方法，我们只不过是内部做了转换而已
*
* @param username 用户名
* @param action 作业操作类型（必填）
* @param jobId 作业id
* @see JobActionEnum
*/
public void action(String username, JobActionEnum action, String jobId) {
if (action == null) {
throw new ArgsException("action不能为空！");
}
if (StringUtils.isBlank(jobId)) {
throw new ArgsException("jobId不能为空！");
}
String path = JobPathConstant.JOB_ACTION_PATH.replace("{jobId}", jobId).replace("{action}", action.getAction());
put(path, username);
}
/**
* 操作作业
*
* @param username 用户名
* @param action 作业的操作类型（必填），取值见{@link JobActionEnum}中的中值
* @param jobId 作业id
*/
public void action(String username, String action, String jobId) {
action(username, JobActionEnum.getJobAction(action), jobId);
}
/**
* 批量操作作业
* <p>
* {@link JobsActionEnum} 中的 静态方法{@link JobsActionEnum#getJobAction(String)}可以将前端的字符转换为{@link JobsActionEnum}对象
* <p>
* 或者使用{@link #actions(String, String, List)}直接操作，但最终还是调的这个方法，我们只不过是内部做了转换而已
*
* @param username 用户名
* @param action 操作类型
* @param jobIds 作业id列表
*/
public void actions(String username, JobsActionEnum action, List<String> jobIds) {
if (action == null) {
throw new ArgsException("action不能为空！");
}
if (CollectionUtil.isEmpty(jobIds)) {
throw new ArgsException("jobIds不能为空！");
}
Map<String, Object> params = new HashMap<>(1);
params.put("jobIds", String.join(CommonConstant.NORMAL_CHARACTER_COMMA, jobIds));
String path = JHApiClient.getUrl(JobPathConstant.JOB_ACTION_IDS_PATH.replace("{action}", action.getAction()), params);
put(path, username);
}
/**
* 操作作业
*
* @param username 用户名
* @param action 作业的操作类型（必填），取值见{@link JobsActionEnum}中的中值
* @param jobIds 作业id列表
*/
public void actions(String username, String action, List<String> jobIds) {
actions(username, JobsActionEnum.getJobAction(action), jobIds);
}
/**
* +
* 查询制定作业的作业历史
*
* @param username 用户名
* @param jobId 作业id
* @return 作业历史
*/
public JobHistoryInfo getJobHistory(String username, String jobId) {
if (StringUtils.isBlank(jobId)) {
throw new ArgsException("jobId不能为空！");
}
String path = JobPathConstant.JOB_HISTORY_PATH.replace("{jobId}", jobId);
List<JobHistoryInfo> list = get(path, username, new TypeReference<ResponseResult<List<JobHistoryInfo>>>() {
});
if (CollectionUtil.isEmpty(list)) {
throw new ServiceException(path, 500, "历史作业信息不存在！");
}
return list.get(0);
}
/**
* 通过多个id查询作业历史列表
*
* @param username 用户名
* @param jobIds 作业id列表
* @return 作业历史列表
*/
public List<JobHistoryInfo> getJobsHistory(String username, List<String> jobIds) {
if (CollectionUtil.isEmpty(jobIds)) {
throw new ArgsException("jobIds不能为空！");
}
Map<String, Object> params = new HashMap<>(1);
params.put("jobIds", String.join(CommonConstant.NORMAL_CHARACTER_COMMA, jobIds));
String path = JHApiClient.getUrl(JobPathConstant.JOB_HISTORY_IDS_PATH, params);
return get(path, username, new TypeReference<ResponseResult<List<JobHistoryInfo>>>() {
});
}
/**
* 获取作业的动态输出
*
* @param username 用户名
* @param jobId 作业id
* @return 作业的动态输出
*/
public String getJobPeek(String username, String jobId) {
if (StringUtils.isBlank(jobId)) {
throw new ArgsException("jobId不能为空！");
}
String path = JobPathConstant.JOB_PEEK_PATH.replace("{jobId}", jobId);
ResponseResult<String> result = jhApiClient.get(path, getHeaders(username), new TypeReference<ResponseResult<String>>() {
});
if (StringUtils.equals(result.getResult(), CommonConstant.FAILED)) {
throw new ServiceException(path, result.getCode(), result.getMessage());
}
// 产品BUG，这里作兼容性处理，保证SDK在BUG修复后能用
if (StringUtils.isNotBlank(result.getData())) {
return result.getData();
}
return result.getMessage();
}
/**
* 连接作业会话
*
* @param username 用户名
* @param jobId 作业id
* @return 未知
*/
public Object connectJobSession(String username, String jobId) {
if (StringUtils.isBlank(jobId)) {
throw new ArgsException("jobId不能为空！");
}
String path = JobPathConstant.JOB_CONNECT_SESSION_PATH.replace("{jobId}", jobId);
return post(path, username, new TypeReference<ResponseResult<Object>>() {
});
}
}

64
src/main/java/com/jhinno/sdk/openapi/api/job/JobActionEnum.java Normal file
View File

@@ -0,0 +1,64 @@
package com.jhinno.sdk.openapi.api.job;
import com.jhinno.sdk.openapi.ArgsException;
import lombok.AllArgsConstructor;
import lombok.Getter;
import org.apache.commons.lang3.StringUtils;
/**
* 作业的操作类型
*
* @author yanlongqi
* @date 2024/2/6 15:01
*/
@Getter
@AllArgsConstructor
public enum JobActionEnum {
/**
* 杀死作业
*/
KILL("kill"),
/**
* 恢复作业
*/
RESUME("resume"),
/**
* 暂停作业
*/
STOP("stop"),
/**
* 置顶作业
*/
TOP("top"),
/**
* 置低作业
*/
BOT("bot"),
;
private final String action;
/**
* 将作业的操作转换为JobActionEnum
*
* @param action 操作字符
* @return 作业操作类型
* @throws ArgsException action的类型不存在的异常
*/
public static JobActionEnum getJobAction(String action) {
for (JobActionEnum value : values()) {
if (StringUtils.equals(action, value.getAction())) {
return value;
}
}
throw new ArgsException(action + "类型不存在！");
}
}

24
src/main/java/com/jhinno/sdk/openapi/api/job/JobHistoryInfo.java Normal file
View File

@@ -0,0 +1,24 @@
package com.jhinno.sdk.openapi.api.job;
import lombok.Data;
/**
* 作业历史信息
*
* @author yanlongqi
* @date 2024/2/6 16:00
*/
@Data
public class JobHistoryInfo {
/**
* 作业id
*/
private String jobId;
/**
* 作业历史
*/
private String jobhistory;
}

273
src/main/java/com/jhinno/sdk/openapi/api/job/JobInfo.java Normal file
View File

@@ -0,0 +1,273 @@
package com.jhinno.sdk.openapi.api.job;
import lombok.Data;
import java.util.Date;
import java.util.List;
import java.util.Map;
/**
* 作业详情
*
* @author yanlongqi
* @date 2024/2/6 13:54
*/
@Data
public class JobInfo {
/**
* 作业id
*/
private String id;
/**
* 作业索引（类型待确认）
*/
private String index;
/**
* 作业id
*/
private String jobId;
/**
* 作业名称
*/
private String name;
/**
* 作业状态
* <p>
* 可能的取值：<br/>
* <ol>
* <li>RUN（运行）</li>
* <li>PEND（等待）</li>
* <li>PSUSP（等待中挂起）</li>
* <li>USUSP（用户挂起）</li>
* <li>SSUSP（系统挂起）</li>
* <li>ZOMBI（僵尸）</li>
* <li>DONE（完成）</li>
* <li>EXIT（退出）</li>
* <li>UNKNOWN#UNKWN（状态不明）</li>
* </ol>
*
* </p>
* <p>
* 数组作业（及arrayJob="true"）时status的类型是一个map<br/>
* 如：{"done":1,"run":12}
* </p>
*/
private Object status;
/**
* 主机
*/
private String host;
/**
* 队列
*/
private String queue;
/**
* 排队号
*/
private Integer queueNumber;
/**
* 属主
*/
private String owner;
/**
* 执行节列表
*/
private List<String> executionHost;
/**
* 插槽
*/
private String slots;
/**
* 作业提交时间
*/
private Date submitTime;
/**
* 作业执行时间
*/
private Date executionTime;
/**
* 作业终止时间
*/
private Date terminationTime;
/**
* 工作目录
*/
private String cwd;
/**
* 作业提交工作目录
*/
private String subCwd;
/**
* 密级
*/
private String confidential;
/**
* 密级映射
*/
private Integer confidential_map;
/**
* 作业数据删除时间
*/
private Date deleteTime;
/**
* 项目
*/
private String project;
/**
* 索引id
*/
private String indexid;
/**
* 是否数组作业，true是，false不是
*/
private String arrayJob;
/**
* 会话id
*/
private String desktopid;
private List<String> reasons;
/**
* 运行时间
*/
private String runTime;
/**
* 作业类型
*/
private Boolean jobType;
/**
*
*/
private Boolean jobDesktopExpires;
/**
*
*/
private Boolean jobDataNotExists;
/**
*
*/
private Boolean hasAlarmHost;
/**
*
*/
private String alarmInfo;
/**
*
*/
private Boolean hasJobException;
/**
*
*/
private String exceptionInfo;
/**
* 应用名称
*/
private String appName;
/**
*
*/
private Integer underRunThreshold;
/**
*
*/
private Integer overRunThreshold;
/**
*
*/
private Float idleThreshold;
/**
* 用户中文名
*/
private String userNameCn;
/**
*
*/
private String jobIndexIds;
/**
* 作业数据是否删除
*/
private Boolean jobIsDeleted;
/**
* 是否独占
*/
private Boolean exclusive;
/**
* 是否docker作业
*/
private Boolean isDocker;
/**
* 图形脚本名称
*/
private String graphicScriptName;
/**
* 绑定CPU列表
*/
private List<Map<String, Object>> cpuBinds;
/**
* 绑定GPU列表
*/
private List<Map<String, Object>> gpuBinds;
/**
*
*/
private List<StageInfo> transferProgressIn;
/**
*
*/
private List<StageInfo> transferProgressOut;
/**
* 组织树
*/
private String organizationTree;
/**
* 是否本地作业
*/
private Boolean isLocalSpoolerJob;
}

69
src/main/java/com/jhinno/sdk/openapi/api/job/JobPathConstant.java
View File

@@ -13,4 +13,73 @@ public class JobPathConstant {
* 提交作业
*/
public static final String JOB_SUBMIT_PATH = "/ws/api/jobs/jsub";
/**
* 使用作业id查询作业列表
*/
public static final String JOB_FIND_JOB_FILES_PATH = "/ws/api/jobs/{jobId}/files";
/**
* 分页查询作业列表
*/
public static final String JOB_PAGE_PATH = "/ws/api/jobs/page";
/**
* 查询作业详情
*/
public static final String JOB_DETAIL_INFO_PATH = "/ws/api/jobs/{jobId}";
/**
* 分页检索作业名
*/
public static final String JOB_LIST_BY_NAME_PATH = "/ws/api/jobs/byName";
/**
* 作业号检索作业列表
*/
public static final String JOB_LIST_BY_STATUS_PATH = "/ws/api/jobs/byStatus/{status}";
/**
* 通过作业号查询作业列表
*/
public static final String JOB_LIST_BY_IDS_PATH = "/ws/api/jobs/list";
/**
* 作业操作
*/
public static final String JOB_ACTION_PATH = "/ws/api/jobs/{jobId}/{action}";
/**
* 批量操作作业
*/
public static final String JOB_ACTION_IDS_PATH = "/ws/api/jobs/{action}";
/**
* 获取作业历史
*/
public static final String JOB_HISTORY_PATH = "/ws/api/jobs/{jobId}/hist";
/**
* 通过多个作业号查询作业历史
*/
public static final String JOB_HISTORY_IDS_PATH = "/ws/api/jobs/hist";
/**
* 获取作业动态输出
*/
public static final String JOB_PEEK_PATH = "/ws/api/jobs/{jobId}/peek";
/**
* 连接作业会话
*/
public static final String JOB_CONNECT_SESSION_PATH = "/ws/api/jobs/{jobId}/connect";
}

51
src/main/java/com/jhinno/sdk/openapi/api/job/JobsActionEnum.java Normal file
View File

@@ -0,0 +1,51 @@
package com.jhinno.sdk.openapi.api.job;
import com.jhinno.sdk.openapi.ArgsException;
import lombok.AllArgsConstructor;
import lombok.Getter;
import org.apache.commons.lang3.StringUtils;
/**
* @author yanlongqi
* @date 2024/2/6 15:42
*/
@Getter
@AllArgsConstructor
public enum JobsActionEnum {
/**
* 杀死作业
*/
KILL("kill"),
/**
* 恢复作业
*/
RESUME("resume"),
/**
* 暂停作业
*/
STOP("stop"),
;
private final String action;
/**
* 将作业的操作转换为JobsActionEnum
*
* @param action 操作字符
* @return 作业操作类型
* @exception ArgsException action的类型不存在的异常
*/
public static JobsActionEnum getJobAction(String action) {
for (JobsActionEnum value : values()) {
if (StringUtils.equals(action, value.getAction())) {
return value;
}
}
throw new ArgsException(action + "类型不存在！");
}
}

26
src/main/java/com/jhinno/sdk/openapi/api/job/PageJobInfo.java Normal file
View File

@@ -0,0 +1,26 @@
package com.jhinno.sdk.openapi.api.job;
import lombok.Data;
import java.util.List;
/**
* 查询分页作业数据
*
* @author yanlongqi
* @date 2024/2/6 11:31
*/
@Data
public class PageJobInfo {
/**
* 作业总数
*/
private Integer total;
/**
* 作业列表
*/
private List<JobInfo> jobs;
}

62
src/main/java/com/jhinno/sdk/openapi/api/job/StageInfo.java Normal file
View File

@@ -0,0 +1,62 @@
package com.jhinno.sdk.openapi.api.job;
import lombok.Data;
/**
* 阶段信息（不明白）
*
* @author yanlongqi
* @date 2024/2/6 14:11
*/
@Data
public class StageInfo {
/**
*
*/
private Long op;
/**
*
*/
private Long stageNo;
/**
*
*/
private Integer transferStatus;
/**
*
*/
private String stageType;
/**
* -f 操作符号前面的机器，默认是提交节点
*/
private String srcHost;
/**
* -f 操作符号前面的文件
*/
private String srcData;
/**
* -f 操作符号后面的机器，默认是计算头节点
*/
private String desHost;
/**
* -f 操作符号后面的文件
*/
private String desData;
/**
*
*/
private String progress;
/**
*
*/
private Long exitCode;
}

1
src/test/java/com/jhinno/sdk/openapi/test/app/AppApiTest.java
View File

@@ -2,7 +2,6 @@ package com.jhinno.sdk.openapi.test.app;
import cn.hutool.core.lang.ConsoleTable;
import com.jhinno.sdk.openapi.api.app.*;
import com.jhinno.sdk.openapi.api.file.FileInfo;
import com.jhinno.sdk.openapi.test.JHClientConfig;
import org.junit.Test;

5
src/test/java/com/jhinno/sdk/openapi/test/auth/AuthApiTest.java
View File

@@ -5,7 +5,7 @@ import com.jhinno.sdk.openapi.test.JHClientConfig;
import org.junit.Test;
/**
* 鉴权相关测试累
* 鉴权相关测试累类
*
* @author yanlongqi
* @date 2024/2/1 18:06
@@ -23,6 +23,9 @@ public class AuthApiTest {
System.out.println("token:" + token);
}
/**
* 测试退出登录
*/
@Test
public void testLogout(){
jhAppApiExecution.logout("lqyan");

18
src/test/java/com/jhinno/sdk/openapi/test/data/DataApiTest.java
View File

@@ -5,10 +5,10 @@ import com.jhinno.sdk.openapi.test.JHClientConfig;
import org.junit.Test;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
/**
* 作业数据区相关单元测试类
*
* @author yanlongqi
* @date 2024/2/4 17:10
*/
@@ -16,26 +16,38 @@ public class DataApiTest {
public static final JHDataApiExecution execution = new JHDataApiExecution(JHClientConfig.client);
/**
* 测试获取作业数据区目录列表
*/
@Test
public void testGetSpoolers() {
System.out.println(execution.getSpoolersData("jhadmin"));
}
/**
* 测试根作业id获取作业数据区列表
*/
@Test
public void testGetSpoolersDataById() {
System.out.println(execution.getSpoolersDataById("jhadmin", "5909"));
}
/**
* 测试根作业id列表获取作业数据区列表
*/
@Test
public void testGetSpoolersDataByIds() {
System.out.println(execution.getSpoolersDataByIds("jhadmin", Arrays.asList("6799", "6686")));
}
/**
* 测试通过作业数据区名称获作业数据列表
*/
@Test
public void testGetSpoolersDataByName() {
System.out.println(execution.getSpoolersByName("jhadmin", "fluent__N_2d_t1_fluent-test_20220722172408"));
System.out.println(execution.getSpoolersByName("jhadmin", "common_sub__t1_aaa.sh_20240206103137"));
}

9
src/test/java/com/jhinno/sdk/openapi/test/file/FileApiTest.java
View File

@@ -79,10 +79,7 @@ public class FileApiTest {
/**
* 测试新建文件
* <p>
* 当前接口请求执行失败
* </p>
* 测试新建文件（接口执行失败）
*/
@Test
public void testMkFile() {
@@ -102,7 +99,7 @@ public class FileApiTest {
/**
* 测试伤上传文件，不覆盖源文件
* 测试伤上传文件，（不覆盖源文件，如果isCover是true，上传后的文件有数字下标）
*/
@Test
public void testUploadFileNoCover() throws IOException {
@@ -116,7 +113,7 @@ public class FileApiTest {
*/
@Test
public void testGetFileDownloadUrl() {
System.out.println(execution.getFileDownloadUrl("jhadmin", "$HOME/temp/双色球.xls"));
System.out.println(execution.getFileDownloadUrl("jhadmin", "$HOME/aa2a.sh"));
}

99
src/test/java/com/jhinno/sdk/openapi/test/job/JobApiTest.java
View File

@@ -1,13 +1,19 @@
package com.jhinno.sdk.openapi.test.job;
import com.jhinno.sdk.openapi.api.job.JHJobApiExecution;
import com.jhinno.sdk.openapi.api.job.JobHistoryInfo;
import com.jhinno.sdk.openapi.api.job.PageJobInfo;
import com.jhinno.sdk.openapi.test.JHClientConfig;
import org.junit.Test;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
/**
* 作业相关测试类
*
* @author yanlongqi
* @date 2024/2/5 18:56
*/
@@ -25,4 +31,97 @@ public class JobApiTest {
params.put("JH_NCPU", "1");
System.out.println(execution.submit("jhadmin", "common_sub", params));
}
/**
* 测试根据作业id查询作业文件列表
*/
@Test
public void testGetJobFilesById() {
System.out.println(execution.getJobFilesById("jhadmin", "42"));
}
/**
* 测试分页查询作业列表
*/
@Test
public void testGetJobPage() {
PageJobInfo jhadmin = execution.getJobPage("jhadmin", 1, 5, null, null, null);
System.out.println(jhadmin);
}
/**
* 测试查看作业详情
*/
@Test
public void tesGetJobDetail() {
System.out.println(execution.getJobDetail("jhadmin", "42"));
}
/**
* 测试使用作业名称检索
*/
@Test
public void testGetJobsByName() {
System.out.println(execution.getJobsByName("jhadmin", "common", 1, 10));
}
/**
* 测根据作业状态检索作业（我的理解，作业列表为空应该返回一个空的列表不能报错）
*/
@Test
public void testGetJobsByStatus() {
System.out.println(execution.getJobsByStatus("jhadmin", "DONE", 1, 10));
}
/**
* 测试使用作业拆id列表查询作业
*/
@Test
public void testGetJobsByIds() {
System.out.println(execution.getJobsByIds("jhadmin", Arrays.asList("42", "41")));
}
/**
* 测试查询作业历史
*/
@Test
public void testGetJobHistory() {
JobHistoryInfo result = execution.getJobHistory("jhadmin", "42");
System.out.println(result);
}
/**
* 测试通过多个子哦也好查询作业历史
*/
@Test
public void testGetJobsHistory() {
List<JobHistoryInfo> result = execution.getJobsHistory("jhadmin", Arrays.asList("41", "42"));
System.out.println(result);
}
/**
* 测试获取作业动态输出（作业动态输出的数据写在了message，我做了处理，需要产品改进）
*/
@Test
public void testGetJobPeek() {
String peek = execution.getJobPeek("jhadmin", "45");
System.out.println("peek = " + peek);
}
/**
* 测试会话连接（目前没有测试条件）
*/
@Test
public void testConnectJobSession() {
Object o = execution.connectJobSession("jhadmin", "45");
System.out.println(o);
}
}