26 Commits

Author SHA1 Message Date
curry772 a86d1ba30f chore: elink-online-common 서브모듈 업데이트 (JSON 파싱 횟수 최적화)
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-05-14 14:53:55 +09:00
curry772 17a343c4ac chore: elink-online-common 서브모듈 업데이트 (decryptField mergeAtRoot 수정)
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-05-14 13:35:10 +09:00
curry772 dd352fef42 chore: elink-online-common 서브모듈 업데이트 (BaseCryptoFilter 잔여 참조 수정)
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-05-14 11:28:08 +09:00
curry772 656cd39d30 refactor: CryptoFilter → InCryptoFilter 참조 교체 및 서브모듈 업데이트
- DJBErpCryptoFilter: CryptoFilter → InCryptoFilter 상속 변경
- EncFieldCryptoFilter: BaseCryptoFilter → InCryptoFilter 사용으로 변경
- DJErpApiAdapterService: CryptoFilter.PROP_MODULE_NAME → AbstractCryptoFilter.PROP_MODULE_NAME
- elink-online-common 서브모듈 feature/cryptofilter 브랜치 반영

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-05-14 11:26:50 +09:00
curry772 7be74095c5 refactor: HttpAdapterFilterFactoryKjb 제거 - elink-online-common 서브모듈 업데이트
- DJErpApiAdapterController 임포트를 HttpAdapterFilterFactory로 교체
- elink-online-common 서브모듈 포인터 업데이트 (c4a250d)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-05-13 16:18:22 +09:00
curry772 28b233aeff refactor: HttpClient5 어댑터 필터 패키지를 elink-online-common으로 이동
- custom/kjb/adapter/http/client/filter/ 패키지 삭제 (elink-online-common으로 이동)
- custom/kjb/adapter/http/client/impl/HttpClient5AdapterServiceRestAddFilter.java 삭제
- elink-online-common 서브모듈 업데이트

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-05-13 15:58:32 +09:00
curry772 7a5958481f chore: elink-online-common 서브모듈 업데이트 (테스트 로그 추가)
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-05-13 13:54:00 +09:00
curry772 ac15633b21 Merge branch 'feature/crypto-module'
CryptoFilter 암복호화 필터, HSM 연동, EncFieldCryptoFilter 실거래 검증 완료
2026-05-13 13:30:21 +09:00
curry772 158987b367 feat: EncFieldCryptoFilter 추가 및 DJErp 어댑터 암호화 모듈 연동
- EncFieldCryptoFilter 추가: /encryptedData 경로 고정 CryptoFilter 구현체
  (CryptoAdapterFilter 대체, custom 패키지로 분리)
- DJErpApiAdapterService: CRYPTO_MODULE_NAME 프로퍼티 transactionProp에 전달
- elink-online-common 서브모듈 업데이트
  (CryptoFilter UPPER_UNDERSCORE 키, HSM 통합 테스트 포함)
- elink-online-transformer 서브모듈 업데이트

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-05-13 13:30:09 +09:00
curry772 bf9f865508 feat: elink-online-transformer 서브모듈 업데이트 (ConcatN 함수 추가)
- ConcatN: 파라미터 수 제한 없는 가변 문자열 연결 함수 (numberOfParameters=-1)
- ConcatNFunctionTest, ConcatNParserTest 단위테스트 추가
- .gitignore에 작업내역 문서 패턴 추가

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-05-12 20:07:47 +09:00
curry772 9c9ad8c19c Merge branch 'feature/crypto-module'
- HSM 키 파생 전략 elink-online-common으로 이동
- HsmContextSha256KeyDerivationStrategyTest elink-online-common으로 이동
- elink-online-common 서브모듈 업데이트 (CryptoFilter AAD 지원 + 단위테스트)
2026-05-12 20:07:10 +09:00
curry772 8ace28675b feat: elink-online-common 서브모듈 업데이트 (CryptoFilter AAD 지원 + 단위테스트)
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-05-12 18:15:54 +09:00
curry772 1ab36c077b feat: HsmContextSha256KeyDerivationStrategyTest elink-online-common으로 이동
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-05-12 16:37:30 +09:00
curry772 547232bb26 feat: HSM 키 파생 전략 elink-online-common으로 이동 및 서브모듈 업데이트
- HsmContextSha256KeyDerivationStrategy: custom 패키지에서 elink-online-common으로 이동
- elink-online-common: feature/crypto-module 브랜치 (HSM 전략 클래스 + master 머지)
- elink-online-core-jpa: CryptoModuleConfig JPA Entity 및 Loader 추가

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-05-12 16:34:20 +09:00
curry772 ebd89afa0d Merge branch 'feature/template-adapter-error-msg-handler' 2026-05-12 13:06:21 +09:00
curry772 407eccc827 feat: elink-online-common 서브모듈 업데이트 (기본값 문법 + JSON 파싱)
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-05-12 13:05:43 +09:00
curry772 cebdfd6a19 fix: elink-online-common 서브모듈 업데이트 (PropManager 목 객체 수정)
Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-05-12 10:47:54 +09:00
curry772 1fd8712de0 Merge branch 'feature/template-adapter-error-msg-handler' into master 2026-05-12 09:44:19 +09:00
curry772 be204abb5e feat: elink-online-common 서브모듈 업데이트 (TemplateAdapterErrorMsgHandler)
서브모듈 elink-online-common 을 feature/template-adapter-error-msg-handler
브랜치의 신규 커밋으로 업데이트

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-05-12 09:43:00 +09:00
curry772 c2ad6d2423 Merge branch 'feature/inflow-control-improvement' into master 2026-05-08 10:51:48 +09:00
curry772 b6954139fe fix: custom.inflow 컴포넌트 스캔 추가 및 /manage/* FrontFilter 등록
- authserver-servlet.xml: com.eactive.eai.custom.inflow 패키지 component-scan 추가
  (ClientInflowTargetBucketController/MetricController 빈 등록)
- web.xml: FrontFilter url-pattern에 /manage/* 추가

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-05-08 10:50:14 +09:00
curry772 d46fa8bd1a refactor: 클라이언트 버킷 상태 모니터링 custom.inflow 패키지로 분리
- InflowTargetBucketService/Controller에서 클라이언트 관련 메서드/엔드포인트 제거
- ClientInflowTargetBucketService/Controller를 custom.inflow 패키지에 신규 생성
  (ClientInflowTargetMetricService/Controller 패턴과 일치)
- 관련 단위 테스트 추가 및 기존 테스트에서 클라이언트 케이스 제거

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-05-08 10:22:15 +09:00
curry772 31171d0187 feat: 클라이언트 유량제어/RequestProcessor custom 패키지로 분리
- DJBRequestProcessor: inbound.processor → custom.inbound.processor 이동
- ClientInflowTargetMetricService/Controller: custom.inflow 패키지 신규 생성
  클라이언트 메트릭 API(/manage/inflow/client/**)를 InflowTargetMetric*에서 분리
- InflowTargetMetricService/Controller: 클라이언트 관련 메서드/엔드포인트 제거
- InflowTargetBucketService: getClientDualManager() 분리 반영
- standard-message-config.properties: requestProcessor.class 경로 업데이트
- 단위 테스트: ClientInflowTargetMetric{Service,Controller}Test 추가,
  기존 테스트에서 클라이언트 케이스 분리

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-05-07 18:02:51 +09:00
curry772 45ad9d8b6f Merge branch 'feature/crypto-module' into master 2026-05-07 15:39:00 +09:00
curry772 dd02c5902e feat: DJB ERP 연동 암복호화 필터 추가 및 단위테스트 작성
- DJBErpCryptoFilter: CryptoFilter 상속, httpHeaderGroup 헤더 JSON에서
  x-emp-nm(groupSeq|empNo) 파싱 → groupSeq를 runtimeContext로 전달
- DJBErpCryptoFilterTest: 17개 단위테스트 (buildRuntimeContext/doPreFilter/doPostFilter)
- elink-online-common 서브모듈 업데이트 (CryptoFilter 기반 클래스 포함)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-05-07 15:04:01 +09:00
curry772 c225104711 feat: 암호화모듈 프레임워크 적용 및 사이트 특화 전략 추가
- 서브모듈 포인터 업데이트 (elink-online-common, elink-online-core-jpa)
- HsmContextSha256KeyDerivationStrategy: SHA-256(masterKey || contextValue) 키 도출 전략
  elink-online-common에서 eapim-online custom 패키지로 분리 (사이트 의존성)
  FQCN: com.eactive.eai.custom.security.keyderiv.strategy.HsmContextSha256KeyDerivationStrategy
- HsmContextSha256KeyDerivationStrategyTest 추가

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
2026-05-06 16:50:17 +09:00
48 changed files with 1730 additions and 2235 deletions
@@ -25,6 +25,9 @@
base-package="com.eactive.eai.adapter" />
<context:component-scan
base-package="com.eactive.eai.manage" />
<context:component-scan
base-package="com.eactive.eai.custom.inflow" />
<context:annotation-config />
<mvc:annotation-driven />
<mvc:default-servlet-handler />
+1
View File
@@ -19,6 +19,7 @@
<url-pattern>/agent/*</url-pattern>
<url-pattern>/common/*</url-pattern>
<url-pattern>/management/*</url-pattern>
<url-pattern>/manage/*</url-pattern>
<url-pattern>/mgr/*</url-pattern>
</filter-mapping>
@@ -29,7 +29,7 @@ import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
import com.eactive.eai.adapter.http.dynamic.HttpDynamicInAdapterManager;
import com.eactive.eai.adapter.http.dynamic.HttpDynamicInAdapterUri;
import com.eactive.eai.adapter.http.dynamic.filter.HttpAdapterFilter;
import com.eactive.eai.adapter.http.dynamic.filter.HttpAdapterFilterFactoryKjb;
import com.eactive.eai.adapter.http.dynamic.filter.HttpAdapterFilterFactory;
import com.eactive.eai.adapter.http.dynamic.filter.JwtAuthException;
import com.eactive.eai.adapter.service.DJErpApiAdapterService;
import com.eactive.eai.common.TransactionContextKeys;
@@ -220,7 +220,7 @@ public class DJErpApiAdapterController implements HttpAdapterServiceKey {
String postFilterNames = httpProp.getProperty("POST_FILTERS","");
if( postFilterNames.contains("HMAC_SHA256") ) {
HttpAdapterFilter filter = HttpAdapterFilterFactoryKjb.createFilter("HMAC_SHA256");
HttpAdapterFilter filter = HttpAdapterFilterFactory.createFilter("HMAC_SHA256");
filter.doPostFilter(adapterGroupName, postFilterNames, errorMsg, transactionProp, servletRequest, servletResponse);
}
@@ -7,6 +7,7 @@ import com.eactive.eai.adapter.Keys;
import com.eactive.eai.adapter.http.HttpMemoryLogger;
import com.eactive.eai.adapter.http.HttpMethodType;
import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceSupport;
import com.eactive.eai.adapter.http.filter.AbstractCryptoFilter;
import com.eactive.eai.adapter.http.dynamic.filter.JwtAuthFilter;
import com.eactive.eai.common.exception.ExceptionUtil;
import com.eactive.eai.common.message.MessageType;
@@ -142,7 +143,8 @@ public class DJErpApiAdapterService extends HttpAdapterServiceSupport {
transactionProp.put(INBOUND_TOKEN, inboundToken);
transactionProp.put(ENCRYPT_AES256_IV, httpProp.getProperty(ENCRYPT_AES256_IV, "")); //jwhong
transactionProp.put(ENCRYPT_AES256_KEY, httpProp.getProperty(ENCRYPT_AES256_KEY, "")); //jwhong
transactionProp.put(AbstractCryptoFilter.PROP_MODULE_NAME, httpProp.getProperty(AbstractCryptoFilter.PROP_MODULE_NAME, ""));
// SEED 컬럼암호하 시 Key로 사용함
String seedkey = getHeaders(request).getOrDefault("x-obp-partnercode", "").toString();
@@ -0,0 +1,82 @@
package com.eactive.eai.custom.adapter.http.dynamic.filter;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.lang3.StringUtils;
import com.eactive.eai.adapter.http.dynamic.filter.InCryptoFilter;
import com.eactive.eai.util.JsonPathUtil;
/**
* DJB ERP 연동용 암복호화 필터.
*
* DYNAMIC 키 컨텍스트 추출 규칙:
* HTTP 헤더 {@code httpHeaderGroup}의 값은 JSON 객체이며,
* 그 중 {@code x-emp-nm} 필드 값을 {@code groupSeq}로
* runtimeContext에 담아 키 도출 전략에 전달한다.
*
* 어댑터 프로퍼티 (부모 클래스 공통 설정 외 추가 키):
* crypto.context.key runtimeContext에 넣을 키 이름 (기본: groupSeq)
* crypto.context.header 컨텍스트 JSON이 담긴 HTTP 헤더명 (기본: httpHeaderGroup)
* crypto.context.header.field 헤더 JSON에서 추출할 필드명 (기본: x-emp-nm)
*
* 어댑터 프로퍼티 설정 예:
* crypto.module.name = AES_GCM_NoPadding_DYNAMIC_sample
* crypto.scope = FIELD
* crypto.dec.enabled = Y
* crypto.enc.enabled = N
* crypto.dec.from.path = /encryptedData
* crypto.dec.to.path = /
* crypto.context.key = groupSeq
* crypto.context.header = httpHeaderGroup
* crypto.context.header.field = x-emp-nm
*
* 필터 타입 등록 (FQCN):
* com.eactive.eai.custom.adapter.http.dynamic.filter.DJBErpCryptoFilter
*/
public class DJBErpCryptoFilter extends InCryptoFilter {
public static final String PROP_CONTEXT_KEY = "crypto.context.key";
public static final String PROP_CONTEXT_HEADER = "crypto.context.header";
public static final String PROP_CONTEXT_HEADER_FIELD = "crypto.context.header.field";
private static final String DEFAULT_CONTEXT_KEY = "groupSeq";
private static final String DEFAULT_CONTEXT_HEADER = "httpHeaderGroup";
private static final String DEFAULT_CONTEXT_HEADER_FIELD = "x-emp-nm";
/**
* httpHeaderGroup 헤더(JSON)에서 x-emp-nm 값을 추출하여 groupSeq로 매핑한다.
* 헤더가 없거나 필드를 찾을 수 없으면 빈 Map을 반환한다.
*/
@Override
protected Map<String, String> buildRuntimeContext(Properties prop, HttpServletRequest request) {
Map<String, String> ctx = new HashMap<>();
String contextKey = prop.getProperty(PROP_CONTEXT_KEY, DEFAULT_CONTEXT_KEY);
String contextHeaderName = prop.getProperty(PROP_CONTEXT_HEADER, DEFAULT_CONTEXT_HEADER);
String contextHeaderField = prop.getProperty(PROP_CONTEXT_HEADER_FIELD, DEFAULT_CONTEXT_HEADER_FIELD);
String headerJson = request.getHeader(contextHeaderName);
if (StringUtils.isBlank(headerJson)) {
logger.warn("DJBErpCryptoFilter] 컨텍스트 헤더 없음: " + contextHeaderName);
return ctx;
}
String value = JsonPathUtil.getValueAtPath(headerJson, "/" + contextHeaderField);
if (value == null) {
logger.warn("DJBErpCryptoFilter] 헤더 JSON에서 필드 추출 실패: header="
+ contextHeaderName + ", field=" + contextHeaderField);
return ctx;
}
// x-emp-nm 값은 "groupSeq|empNo" 형태 — '|' 앞부분만 groupSeq로 사용
String groupSeq = value.contains("|") ? value.substring(0, value.indexOf('|')) : value;
ctx.put(contextKey, groupSeq);
return ctx;
}
}
@@ -0,0 +1,40 @@
package com.eactive.eai.custom.adapter.http.dynamic.filter;
import java.util.Properties;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import com.eactive.eai.adapter.http.dynamic.filter.InCryptoFilter;
import com.eactive.eai.adapter.http.dynamic.filter.HttpAdapterFilter;
/**
* CryptoFilter 프로퍼티를 멤버변수로 관리하는 HttpAdapterFilter 구현체.
*
* 멤버변수에 세팅된 값을 Properties로 변환하여 {@link InCryptoFilter}에 위임한다.
* 값이 blank인 멤버변수는 Properties에 포함하지 않으며, CryptoFilter의 기본값이 적용된다.
*/
public class EncFieldCryptoFilter implements HttpAdapterFilter {
private final InCryptoFilter filter = new InCryptoFilter();
@Override
public Object doPreFilter(String adptGrpName, String adptName, Object message, Properties prop,
HttpServletRequest request, HttpServletResponse response) throws Exception {
return filter.doPreFilter(adptGrpName, adptName, message, setProp(prop), request, response);
}
@Override
public Object doPostFilter(String adptGrpName, String adptName, Object resultMessage, Properties prop,
HttpServletRequest request, HttpServletResponse response) throws Exception {
return filter.doPostFilter(adptGrpName, adptName, resultMessage, setProp(prop), request, response);
}
private Properties setProp(Properties p) {
p.setProperty(InCryptoFilter.PROP_DEC_FROM_PATH, "/encryptedData");
p.setProperty(InCryptoFilter.PROP_ENC_TO_PATH, "/encryptedData");
return p;
}
}
@@ -0,0 +1,81 @@
package com.eactive.eai.custom.inbound.processor;
import org.apache.commons.lang3.StringUtils;
import com.eactive.eai.common.inflow.Bucket;
import com.eactive.eai.common.inflow.InflowTargetVO;
import com.eactive.eai.common.inflow.dual.ClientDualBucket;
import com.eactive.eai.common.inflow.dual.DualBucket;
import com.eactive.eai.common.inflow.dual.DualCustomBucket;
import com.eactive.eai.inbound.processor.RequestProcessor;
/**
* 어댑터/인터페이스/클라이언트 유량제어 차단 시 어느 버킷(PER_SECOND/THRESHOLD)에서
* 차단됐는지 에러 메시지에 포함하는 RequestProcessor 확장.
*
* <p>ClientDualInflowControlManager와 함께 사용:
* <pre>
* inflow.control.bucket.className=com.eactive.eai.common.inflow.dual.ClientDualInflowControlManager
* </pre>
*
* <p>Spring Bean 등록 후 기존 RequestProcessor 대신 이 클래스를 어댑터에 설정한다.
*/
public class DJBRequestProcessor extends RequestProcessor {
@Override
protected String checkClientInflow(Bucket bucket, String clientId) {
if (StringUtils.isBlank(clientId)) return null;
if (bucket instanceof ClientDualBucket) {
return ((ClientDualBucket) bucket).isClientPassDetail(clientId);
}
return null;
}
@Override
protected InflowTargetVO resolveClientInflowThreshold(Bucket bucket, String clientId) {
if (bucket instanceof ClientDualBucket) {
return ((ClientDualBucket) bucket).getClientInflowThreshold(clientId);
}
return null;
}
@Override
protected String checkAdapterInflow(Bucket bucket, String adapterGroupName) {
if (bucket instanceof DualBucket) {
return ((DualBucket) bucket).isAdapterPassDetail(adapterGroupName);
}
return super.checkAdapterInflow(bucket, adapterGroupName);
}
@Override
protected String checkInterfaceInflow(Bucket bucket, String eaiSvcCd) {
if (bucket instanceof DualBucket) {
return ((DualBucket) bucket).isInterfacePassDetail(eaiSvcCd);
}
return super.checkInterfaceInflow(bucket, eaiSvcCd);
}
/**
* 차단 원인에 따라 에러 메시지에 한도 정보를 포함.
* <ul>
* <li>PER_SECOND: "API 호출 한도 초과 [name: Nreq/sec]"</li>
* <li>THRESHOLD: "API 호출 한도 초과 [name: Nreq/UNIT]"</li>
* <li>그 외: "API 호출 한도 초과 [name]" (기존 동작)</li>
* </ul>
*/
@Override
protected String buildInflowTargetErrorMsg(InflowTargetVO inflowTargetVO, String blockedType) {
if (DualCustomBucket.RESULT_BLOCKED_PER_SECOND.equals(blockedType)) {
return String.format("API 호출 한도 초과 [%s: %dreq/sec]",
inflowTargetVO.getName(),
inflowTargetVO.getThresholdPerSecond());
}
if (DualCustomBucket.RESULT_BLOCKED_THRESHOLD.equals(blockedType)) {
return String.format("API 호출 한도 초과 [%s: %dreq/%s]",
inflowTargetVO.getName(),
inflowTargetVO.getThreshold(),
inflowTargetVO.getThresholdTimeUnit());
}
return super.buildInflowTargetErrorMsg(inflowTargetVO, blockedType);
}
}
@@ -0,0 +1,63 @@
package com.eactive.eai.custom.inflow;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.eactive.eai.manage.inflow.TargetBucketStatusDTO;
/**
* 클라이언트 버킷 상태 모니터링 API.
*
* ClientDualInflowControlManager 가 활성화된 환경에서만 정상 응답한다.
*
* GET /manage/inflow/client/bucket-status → 전체 클라이언트 버킷 상태
* GET /manage/inflow/client/{clientId}/bucket-status → 특정 클라이언트 버킷 상태
*/
@RestController
@RequestMapping("/manage/inflow")
public class ClientInflowTargetBucketController {
@Autowired
private ClientInflowTargetBucketService bucketService;
@GetMapping("/client/bucket-status")
public ResponseEntity<?> getAllClientBucketStatus() {
List<TargetBucketStatusDTO> list = bucketService.getAllClientBucketStatus();
return ok(list);
}
@GetMapping("/client/{clientId}/bucket-status")
public ResponseEntity<?> getClientBucketStatus(@PathVariable String clientId) {
TargetBucketStatusDTO dto = bucketService.getClientBucketStatus(clientId);
return single(dto, "클라이언트를 찾을 수 없습니다: " + clientId);
}
private ResponseEntity<?> ok(List<TargetBucketStatusDTO> list) {
Map<String, Object> result = new HashMap<>();
result.put("success", true);
result.put("data", list);
result.put("count", list.size());
return ResponseEntity.ok(result);
}
private ResponseEntity<?> single(TargetBucketStatusDTO dto, String notFoundMsg) {
if (dto == null) {
Map<String, Object> error = new HashMap<>();
error.put("success", false);
error.put("message", notFoundMsg);
return ResponseEntity.ok(error);
}
Map<String, Object> result = new HashMap<>();
result.put("success", true);
result.put("data", dto);
return ResponseEntity.ok(result);
}
}
@@ -0,0 +1,79 @@
package com.eactive.eai.custom.inflow;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import org.springframework.stereotype.Service;
import com.eactive.eai.common.inflow.AbstractInflowControlManager;
import com.eactive.eai.common.inflow.InflowControlUtil;
import com.eactive.eai.common.inflow.InflowTargetVO;
import com.eactive.eai.common.inflow.dual.ClientDualInflowControlManager;
import com.eactive.eai.common.inflow.dual.DualCustomBucket;
import com.eactive.eai.manage.inflow.GroupBucketStatusDTO;
import com.eactive.eai.manage.inflow.TargetBucketStatusDTO;
/**
* 클라이언트 버킷 상태 조회 서비스.
*
* ClientDualInflowControlManager 가 활성화된 경우에만 동작한다.
*/
@Service
public class ClientInflowTargetBucketService {
public TargetBucketStatusDTO getClientBucketStatus(String clientId) {
ClientDualInflowControlManager manager = getClientDualManager();
if (manager == null) return null;
DualCustomBucket bucket = manager.getClientBucket(clientId);
if (bucket == null) return null;
return toDto(clientId, "CLIENT", bucket);
}
public List<TargetBucketStatusDTO> getAllClientBucketStatus() {
ClientDualInflowControlManager manager = getClientDualManager();
if (manager == null) return new ArrayList<>();
return toDtoList("CLIENT", manager.getClientBucketMap());
}
protected ClientDualInflowControlManager getClientDualManager() {
AbstractInflowControlManager base = InflowControlUtil.getInflowControlManager();
return (base instanceof ClientDualInflowControlManager) ? (ClientDualInflowControlManager) base : null;
}
private TargetBucketStatusDTO toDto(String targetId, String targetType, DualCustomBucket bucket) {
InflowTargetVO vo = bucket.getInflowTargetVo();
List<GroupBucketStatusDTO.BucketInfo> buckets = new ArrayList<>();
if (vo.getThresholdPerSecond() > 0) {
long capacity = vo.getThresholdPerSecond();
long available = bucket.getPerSecondAvailableTokens();
if (available < 0) available = capacity;
buckets.add(new GroupBucketStatusDTO.BucketInfo(
"perSecond", capacity, Math.min(available, capacity), "SEC"));
}
if (vo.getThreshold() > 0) {
long capacity = vo.getThreshold();
long available = bucket.getThresholdAvailableTokens();
if (available < 0) available = capacity;
buckets.add(new GroupBucketStatusDTO.BucketInfo(
"threshold", capacity, Math.min(available, capacity), vo.getThresholdTimeUnit()));
}
TargetBucketStatusDTO dto = new TargetBucketStatusDTO();
dto.setTargetId(targetId);
dto.setTargetType(targetType);
dto.setActivate(vo.isActivate());
dto.setBuckets(buckets);
return dto;
}
private List<TargetBucketStatusDTO> toDtoList(String targetType, Map<String, DualCustomBucket> bucketMap) {
List<TargetBucketStatusDTO> result = new ArrayList<>();
for (Map.Entry<String, DualCustomBucket> entry : bucketMap.entrySet()) {
result.add(toDto(entry.getKey(), targetType, entry.getValue()));
}
return result;
}
}
@@ -0,0 +1,94 @@
package com.eactive.eai.custom.inflow;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import com.eactive.eai.manage.inflow.TargetMetricDTO;
/**
* 클라이언트 유량제어 메트릭 API.
*
* ClientDualInflowControlManager 가 활성화된 환경에서만 정상 응답한다.
*
* GET /manage/inflow/client/metric → 전체 클라이언트 메트릭
* GET /manage/inflow/client/{clientId}/metric → 특정 클라이언트 메트릭
* POST /manage/inflow/client/metric/reset → 전체 클라이언트 메트릭 초기화
* POST /manage/inflow/client/{clientId}/metric/reset → 특정 클라이언트 메트릭 초기화
*/
@RestController
@RequestMapping("/manage/inflow")
public class ClientInflowTargetMetricController {
@Autowired
private ClientInflowTargetMetricService metricService;
@GetMapping("/client/metric")
public ResponseEntity<?> getAllClientMetrics() {
List<TargetMetricDTO> list = metricService.getAllClientMetrics();
return okList(list);
}
@GetMapping("/client/{clientId}/metric")
public ResponseEntity<?> getClientMetric(@PathVariable String clientId) {
TargetMetricDTO dto = metricService.getClientMetric(clientId);
return okSingle(dto, "클라이언트를 찾을 수 없습니다: " + clientId);
}
@PostMapping("/client/metric/reset")
public ResponseEntity<?> resetAllClientMetrics() {
metricService.resetAllClientMetrics();
return okReset("전체 클라이언트 메트릭 초기화 완료");
}
@PostMapping("/client/{clientId}/metric/reset")
public ResponseEntity<?> resetClientMetric(@PathVariable String clientId) {
boolean ok = metricService.resetClientMetric(clientId);
return okResetSingle(ok, clientId, "클라이언트");
}
private ResponseEntity<?> okList(List<TargetMetricDTO> list) {
Map<String, Object> result = new HashMap<>();
result.put("success", true);
result.put("data", list);
result.put("count", list.size());
return ResponseEntity.ok(result);
}
private ResponseEntity<?> okSingle(TargetMetricDTO dto, String notFoundMsg) {
if (dto == null) {
Map<String, Object> error = new HashMap<>();
error.put("success", false);
error.put("message", notFoundMsg);
return ResponseEntity.ok(error);
}
Map<String, Object> result = new HashMap<>();
result.put("success", true);
result.put("data", dto);
return ResponseEntity.ok(result);
}
private ResponseEntity<?> okReset(String message) {
Map<String, Object> result = new HashMap<>();
result.put("success", true);
result.put("message", message);
return ResponseEntity.ok(result);
}
private ResponseEntity<?> okResetSingle(boolean ok, String targetId, String targetLabel) {
Map<String, Object> result = new HashMap<>();
result.put("success", ok);
result.put("message", ok
? "초기화 완료: " + targetId
: targetLabel + "를 찾을 수 없습니다: " + targetId);
return ResponseEntity.ok(result);
}
}
@@ -0,0 +1,79 @@
package com.eactive.eai.custom.inflow;
import java.util.ArrayList;
import java.util.List;
import org.springframework.stereotype.Service;
import com.eactive.eai.common.inflow.AbstractInflowControlManager;
import com.eactive.eai.common.inflow.InflowControlUtil;
import com.eactive.eai.common.inflow.InflowTargetVO;
import com.eactive.eai.common.inflow.dual.ClientDualInflowControlManager;
import com.eactive.eai.common.inflow.dual.DualInflowControlManager;
import com.eactive.eai.manage.inflow.TargetMetricDTO;
@Service
public class ClientInflowTargetMetricService {
public TargetMetricDTO getClientMetric(String clientId) {
ClientDualInflowControlManager manager = getClientDualManager();
if (manager == null) return null;
InflowTargetVO vo = manager.getClientInflowThreshold(clientId);
if (vo == null) return null;
return buildDTO(clientId, "CLIENT", vo, manager.getClientMetrics(clientId));
}
public List<TargetMetricDTO> getAllClientMetrics() {
ClientDualInflowControlManager manager = getClientDualManager();
if (manager == null) return new ArrayList<>();
List<TargetMetricDTO> result = new ArrayList<>();
for (String id : manager.getClientBucketMap().keySet()) {
TargetMetricDTO dto = getClientMetric(id);
if (dto != null) result.add(dto);
}
return result;
}
public boolean resetClientMetric(String clientId) {
ClientDualInflowControlManager manager = getClientDualManager();
if (manager == null) return false;
if (manager.getClientInflowThreshold(clientId) == null) return false;
manager.resetClientMetrics(clientId);
return true;
}
public void resetAllClientMetrics() {
ClientDualInflowControlManager manager = getClientDualManager();
if (manager != null) manager.resetAllClientMetrics();
}
protected ClientDualInflowControlManager getClientDualManager() {
AbstractInflowControlManager base = InflowControlUtil.getInflowControlManager();
return (base instanceof ClientDualInflowControlManager) ? (ClientDualInflowControlManager) base : null;
}
private TargetMetricDTO buildDTO(String targetId, String targetType,
InflowTargetVO vo,
DualInflowControlManager.TargetMetrics m) {
TargetMetricDTO dto = new TargetMetricDTO();
dto.setTargetId(targetId);
dto.setTargetType(targetType);
dto.setActivate(vo.isActivate());
if (m != null) {
long allowed = m.allowed.get();
long rejPs = m.rejectedPerSecond.get();
long rejTh = m.rejectedThreshold.get();
long total = allowed + rejPs + rejTh;
dto.setAllowed(allowed);
dto.setRejectedPerSecond(rejPs);
dto.setRejectedThreshold(rejTh);
dto.setTotalRequests(total);
dto.setRejectRatio(total > 0
? Math.round((double)(rejPs + rejTh) / total * 10000) / 100.0
: 0.0);
dto.setLastResetTime(m.lastResetTime);
}
return dto;
}
}
@@ -1,123 +0,0 @@
package com.eactive.eai.custom.kjb.adapter.http.client.filter;
import java.util.Arrays;
import java.util.Map;
import java.util.Properties;
import java.util.TreeMap;
import java.util.stream.Stream;
import org.apache.commons.lang3.StringUtils;
import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceSupport;
import com.eactive.eai.common.TransactionContextKeys;
import com.eactive.eai.common.property.PropManager;
import com.eactive.eai.common.util.Logger;
public class AllHeaderFilter implements HttpClientAdapterFilter, HttpAdapterServiceKey {
protected static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
public static final String PROPERTIES_GROUP_NAME = "HttpHeaderFilter";
public static final String HEADER_KEY_NAMES = "AllHeaderFilter.blackList";
String[] HttpHeaderRelayBlackList = {
"Content-Length",
"Transfer-Encoding",
"Host",
"Authorization",
"Accept",
"Host",
"Cookie",
"Connection",
"Keep-Alive",
"Proxy-Authenticate",
"Proxy-Authorization",
"TE",
"Trailer",
"Transfer-Encoding",
"Upgrade",
"Content-Type",
"Content-Encoding",
"Content-Language",
"Content-Location",
"Content-MD5",
"Expect",
};
@Override
public Object doPreFilter(String adptGrpName, String adptName, Properties prop, Object message, Properties tempProp)
throws Exception {
logger.debug("doPreFilter Processing Start.");
Properties filterHeaders = (Properties) tempProp.get("FILTERHEADER");
if (filterHeaders == null) {
filterHeaders = new Properties();
tempProp.put("FILTERHEADER", filterHeaders);
}
Map<String, String> inboundHeaderMap = getInboundHeaderProp(tempProp);
String propValue = PropManager.getInstance().getProperty(PROPERTIES_GROUP_NAME, HEADER_KEY_NAMES, "").trim();
String[] userSettingBlackList = propValue.split(",");
if( userSettingBlackList.length > 0 ) {
HttpHeaderRelayBlackList = Stream
.concat(Arrays.stream(HttpHeaderRelayBlackList), Arrays.stream(userSettingBlackList))
.toArray(String[]::new);
}
for(String keyName : inboundHeaderMap.keySet() ) {
if( StringUtils.equalsAnyIgnoreCase( keyName, HttpHeaderRelayBlackList ) ) {
logger.debug("Skip Processing Key ["+keyName+"], value ["+inboundHeaderMap.get(keyName)+"] in HttpHeaderRelayBlackList");
continue;
}
filterHeaders.put(keyName, inboundHeaderMap.get(keyName));
logger.debug("Processing Key ["+keyName+"], value ["+inboundHeaderMap.get(keyName)+"]");
}
logger.debug("doPreFilter Processing End.");
return message;
}
public Map<String, String> getInboundHeaderProp(Properties prop) {
Properties header = new Properties();
Map<String, String> inboundHeaderMap = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
try {
Object headerObj = prop.get(HttpAdapterServiceKey.INBOUND_HEADER);
if (headerObj instanceof Properties) { //tomcat
header = (Properties) headerObj;
for (String name : header.stringPropertyNames()) {
inboundHeaderMap.put(name, header.getProperty(name));
}
} else if (headerObj instanceof String) { //weblogic
String str = (String) headerObj;
str = str.substring(1, str.length() - 1);
// key=value 쌍 분리
String[] entries = str.split(",");
for (String entry : entries) {
String[] kv = entry.split("=", 2);
if (kv.length == 2) {
inboundHeaderMap.put(kv[0].trim(), kv[1].trim());
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
return inboundHeaderMap;
}
@Override
public Object doPostFilter(String adptGrpName, String adptName, Properties prop, Object message,
Properties tempProp) throws Exception {
return message;
}
}
@@ -1,118 +0,0 @@
package com.eactive.eai.custom.kjb.adapter.http.client.filter;
import java.util.Arrays;
import java.util.Map;
import java.util.Properties;
import java.util.TreeMap;
import org.apache.commons.lang3.StringUtils;
import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
import com.eactive.eai.common.TransactionContextKeys;
import com.eactive.eai.common.property.PropManager;
import com.eactive.eai.common.util.Logger;
public class AsyncReponseFilter implements HttpClientAdapterFilter, HttpAdapterServiceKey {
protected static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
public static final String X_TRACE_ID = "partnerTraceId";
public static final String TRACE_ID = "traceId";
public static final String PROPERTIES_GROUP_NAME = "HttpHeaderFilter";
public static final String HEADER_KEY_NAMES = "AsyncReponseFilter";
@Override
public Object doPreFilter(String adptGrpName, String adptName, Properties prop, Object message, Properties tempProp)
throws Exception {
logger.debug("AsyncReponseFilter] PreFilter Processing Start!!");
String traceId = tempProp.getProperty(TransactionContextKeys.TRANSACTION_UUID, "");
Properties filterHeaders = (Properties) tempProp.get("FILTERHEADER");
if (filterHeaders == null) {
filterHeaders = new Properties();
tempProp.put("FILTERHEADER", filterHeaders);
}
String propValue = PropManager.getInstance().getProperty(PROPERTIES_GROUP_NAME, HEADER_KEY_NAMES, "").trim();
String[] headerKeyNames = propValue.split(",");
headerKeyNames = Arrays.stream(headerKeyNames)
.map(String::trim)
.toArray(String[]::new);
try {
Map<String, String> inboundHeaderMap = getInboundHeaderProp(tempProp);
if (!inboundHeaderMap.isEmpty()) {
if (inboundHeaderMap.containsKey(X_TRACE_ID)) {
filterHeaders.put(X_TRACE_ID, inboundHeaderMap.get(X_TRACE_ID));
logger.debug("AsyncReponseFilter] Processing Key ["+X_TRACE_ID+"], value ["+inboundHeaderMap.get(X_TRACE_ID)+"]");
}
if (inboundHeaderMap.containsKey(TransactionContextKeys.X_LOAN_TOKEN)) {
filterHeaders.put(TransactionContextKeys.X_LOAN_TOKEN, inboundHeaderMap.get(TransactionContextKeys.X_LOAN_TOKEN));
logger.debug("AsyncReponseFilter] Processing Key ["+TransactionContextKeys.X_LOAN_TOKEN+"], value ["+inboundHeaderMap.get(TransactionContextKeys.X_LOAN_TOKEN)+"]");
}
}
filterHeaders.setProperty(TRACE_ID, traceId);
logger.debug("AsyncReponseFilter] Processing Key ["+TRACE_ID+"], value ["+traceId+"]");
for (String keyName : inboundHeaderMap.keySet()) {
if (StringUtils.equalsAnyIgnoreCase(keyName, headerKeyNames)) {
String value = inboundHeaderMap.get(keyName);
filterHeaders.put(keyName, value);
logger.debug("AsyncReponseFilter] Processing Key [" + keyName + "], value [" + value + "]");
}
}
} catch (Exception e) {
logger.error(e.getMessage());
}
return message;
}
public Map<String, String> getInboundHeaderProp(Properties prop) {
Properties header = new Properties();
Map<String, String> inboundHeaderMap = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
try {
Object headerObj = prop.get(HttpAdapterServiceKey.INBOUND_HEADER);
if (headerObj instanceof Properties) { //tomcat
header = (Properties) headerObj;
for (String name : header.stringPropertyNames()) {
inboundHeaderMap.put(name, header.getProperty(name));
}
} else if (headerObj instanceof String) { //weblogic
String str = (String) headerObj;
str = str.substring(1, str.length() - 1);
// key=value 쌍 분리
String[] entries = str.split(",");
for (String entry : entries) {
String[] kv = entry.split("=", 2);
if (kv.length == 2) {
inboundHeaderMap.put(kv[0].trim(), kv[1].trim());
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
return inboundHeaderMap;
}
@Override
public Object doPostFilter(String adptGrpName, String adptName, Properties prop, Object message,
Properties tempProp) throws Exception {
return message;
}
}
@@ -1,115 +0,0 @@
package com.eactive.eai.custom.kjb.adapter.http.client.filter;
import java.util.concurrent.ConcurrentHashMap;
import com.eactive.eai.common.util.Logger;
public class HttpClient5AdapterFilterFactory {
static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
static String basePackage = "com.eactive.eai.custom.kjb.adapter.http.client.filter";
private static ConcurrentHashMap<String, HttpClientAdapterFilter> h = new ConcurrentHashMap<>();
private static ConcurrentHashMap<String, HttpClientAdapterExceptionFilter> eh = new ConcurrentHashMap<>();
private HttpClient5AdapterFilterFactory() {
throw new IllegalStateException("Utility class");
}
public static HttpClientAdapterFilter createFilter(String type) {
if (h.containsKey(type)) {
return h.get(type);
}
HttpClientAdapterFilter filter = null;
switch (HttpClient5AdapterFilterType.getValue(type)) {
case SIMPLEFRAMEWORK:
filter = new SimpleFrameworkFilter();
break;
case SIMPLEFRAMEWORKBODY:
filter = new SimpleframeworkBodyFilter();
break;
case JBOBP:
filter = new JBOBPFilter();
break;
case KFTCFACE:
filter = new KFTCFaceFilter();
break;
case KFTCP2P:
filter = new KFTCP2PFilter();
break;
case KAKAOBANK:
filter = new KAKAOBankFilter();
break;
case NAVERFIN:
filter = new NAVERFinFilter();
break;
case NICECREDIT:
filter = new NICECreditFilter();
break;
case TRACEBODY:
filter = new TraceBodyFilter();
break;
case TOSSBANK:
filter = new TOSSBankFilter();
break;
case ASYNCRESPONSE:
filter = new AsyncReponseFilter();
break;
case ALLHEADER:
filter = new AllHeaderFilter();
break;
default:
filter = classForName(type);
if (filter == null) {
filter = classForName(basePackage + "." + type);
}
break;
}
if (filter != null) {
h.put(type, filter);
return filter;
} else {
return null;
}
}
private static HttpClientAdapterFilter classForName(String type) {
try {
Class<?> cl = Class.forName(type);
return (HttpClientAdapterFilter) cl.newInstance();
} catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
logger.error("Cannot create a HttpClientAdapterFilter. - {}", type);
return null;
}
}
public static HttpClientAdapterExceptionFilter createExceptionFilter(String type) {
if (eh.containsKey(type)) {
return eh.get(type);
}
HttpClientAdapterExceptionFilter filter = classForExceptionFilterName(type);
if (filter == null) {
filter = classForExceptionFilterName(basePackage + "." + type);
}
if (filter != null) {
eh.put(type, filter);
return filter;
} else {
return null;
}
}
private static HttpClientAdapterExceptionFilter classForExceptionFilterName(String type) {
try {
Class<?> cl = Class.forName(type);
return (HttpClientAdapterExceptionFilter) cl.newInstance();
} catch (ClassNotFoundException | IllegalAccessException | InstantiationException e) {
logger.error("Cannot create a HttpClientAdapterExceptionFilter. - {}", type);
return null;
}
}
}
@@ -1,27 +0,0 @@
package com.eactive.eai.custom.kjb.adapter.http.client.filter;
public enum HttpClient5AdapterFilterType {
SIMPLEFRAMEWORK,
SIMPLEFRAMEWORKBODY,
JBOBP,
KFTCFACE,
KFTCP2P,
KAKAOBANK,
NAVERFIN,
NICECREDIT,
TOSSBANK,
TRACEBODY,
ASYNCRESPONSE,
ALLHEADER,
UNKNOWN;
public static HttpClient5AdapterFilterType getValue(String type) {
try {
return valueOf(type.toUpperCase());
} catch (NullPointerException e) {
return UNKNOWN;
} catch (Exception e) {
return UNKNOWN;
}
}
}
@@ -1,62 +0,0 @@
package com.eactive.eai.custom.kjb.adapter.http.client.filter;
import java.util.ArrayList;
import java.util.List;
import java.util.Properties;
import com.eactive.eai.common.util.Logger;
public abstract class HttpClientAdapterBaseFilter implements HttpClientAdapterFilter {
protected static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
protected String filterName = "";
protected List<HttpClientAdapterFilter> filters;
protected HttpClientAdapterBaseFilter(String filterName) {
this.filterName = filterName;
filters = new ArrayList<>();
logger.info("{}] filter created.", filterName);
}
protected void addFilter(HttpClientAdapterFilter filter) {
filters.add(filter);
logger.info("{}] sub filter({}) added. filters= {}", filterName, filter, filters);
}
@Override
public Object doPreFilter(String adptGrpName, String adptName, Properties prop, Object message, Properties tempProp)
throws Exception {
try {
Object filteredMessage = message;
for(HttpClientAdapterFilter subFilter : filters) {
logger.debug("{}] sub filter({}) doPreFilter start.", filterName, subFilter);
filteredMessage = subFilter.doPreFilter(adptGrpName, adptName, prop, filteredMessage, tempProp);
logger.debug("{}] sub filter({}) doPreFilter end.", filterName, subFilter);
}
return filteredMessage;
} catch (Exception e) {
logger.error(this.filterName + "] doPreFilter error.", e);
throw e;
}
}
@Override
public Object doPostFilter(String adptGrpName, String adptName, Properties prop, Object message,
Properties tempProp) throws Exception {
try {
Object filteredMessage = message;
for(HttpClientAdapterFilter subFilter : filters) {
logger.debug("{}] sub filter({}) doPostFilter start.", filterName, subFilter);
filteredMessage = subFilter.doPostFilter(adptGrpName, adptName, prop, filteredMessage, tempProp);
logger.debug("{}] sub filter({}) doPostFilter end.", filterName, subFilter);
}
return filteredMessage;
} catch (Exception e) {
logger.error(this.filterName + "] doPostFilter error.", e);
throw e;
}
}
}
@@ -1,10 +0,0 @@
package com.eactive.eai.custom.kjb.adapter.http.client.filter;
import java.util.Properties;
public interface HttpClientAdapterExceptionFilter {
public Object doExceptionFilter(String adptGrpName, String adptName, Properties prop, Object message,
Properties tempProp, Exception e) throws Exception;
}
@@ -1,12 +0,0 @@
package com.eactive.eai.custom.kjb.adapter.http.client.filter;
import java.util.Properties;
public interface HttpClientAdapterFilter {
public Object doPreFilter(String adptGrpName, String adptName, Properties prop, Object message, Properties tempProp)
throws Exception;
public Object doPostFilter(String adptGrpName, String adptName, Properties prop, Object message,
Properties tempProp) throws Exception;
}
@@ -1,35 +0,0 @@
package com.eactive.eai.custom.kjb.adapter.http.client.filter;
import java.util.Properties;
import lombok.Getter;
public class HttpClientAdapterFilterException extends RuntimeException {
private static final long serialVersionUID = -1208983360831093751L;
@Getter
private final String code;
@Getter
private final Properties prop;
@Getter
private final Properties tempProp;
public HttpClientAdapterFilterException(String code, String msg, Properties prop, Properties tmepProp) {
super(msg);
this.code = code;
this.prop = prop;
this.tempProp = tmepProp;
}
public HttpClientAdapterFilterException(String code, String msg, Properties prop, Properties tempProp, Throwable cause) {
super(msg, cause);
this.code = code;
this.prop = prop;
this.tempProp = tempProp;
}
@Override
public String toString() {
return "HttpClientAdapterFilterException [code=" + code + ", prop=" + prop + ", tempProp=" + tempProp + ", parent=" + super.toString() + "]";
}
}
@@ -1,106 +0,0 @@
package com.eactive.eai.custom.kjb.adapter.http.client.filter;
import java.util.Map;
import java.util.Properties;
import java.util.TreeMap;
import org.apache.commons.lang3.StringUtils;
import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
import com.eactive.eai.common.TransactionContextKeys;
import com.eactive.eai.common.property.PropGroupVO;
import com.eactive.eai.common.property.PropManager;
import com.eactive.eai.common.util.Logger;
public class JBOBPFilter implements HttpClientAdapterFilter, HttpAdapterServiceKey {
protected static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
public static final String KJB_HEADER = "KJB_Header";
public static final String X_OBP_PARTNERCODE = "x-obp-partnercode";
public static final String X_OBP_TXID = "x-obp-txid";
public static final String X_OBP_TRUST_SYSTEM = "x-obp-trust-system";
String systemTrustKey = "APIMGW-0001-QVBJTUdXLTAwMDE=";
@Override
public Object doPreFilter(String adptGrpName, String adptName, Properties prop, Object message, Properties tempProp)
throws Exception {
logger.debug("JBOBPFilter] PreFilter Processing Start!!");
PropGroupVO propGroupVo = PropManager.getInstance().getPropGroupVO(KJB_HEADER);
if (propGroupVo != null) systemTrustKey = propGroupVo.getProperty(X_OBP_TRUST_SYSTEM, systemTrustKey);
Properties filterHeaders = (Properties) tempProp.get("FILTERHEADER");
if (filterHeaders == null) {
filterHeaders = new Properties();
tempProp.put("FILTERHEADER", filterHeaders);
}
try {
String obpPartnerCode = "000000-00";
Map<String, String> inboundHeaderMap = getInboundHeaderProp(tempProp);
if (!inboundHeaderMap.isEmpty()) {
if (inboundHeaderMap.containsKey(X_OBP_PARTNERCODE)) {
filterHeaders.put(X_OBP_PARTNERCODE, inboundHeaderMap.get(X_OBP_PARTNERCODE));
logger.debug("JBOBPFilter] Processing Key ["+X_OBP_PARTNERCODE+"], value ["+inboundHeaderMap.get(X_OBP_PARTNERCODE)+"]");
} else {
filterHeaders.put(X_OBP_PARTNERCODE, obpPartnerCode);
logger.debug("JBOBPFilter] Processing Key ["+X_OBP_PARTNERCODE+"], value ["+obpPartnerCode+"]");
}
} else {
filterHeaders.put(X_OBP_PARTNERCODE, obpPartnerCode);
logger.debug("JBOBPFilter] Processing Key ["+X_OBP_PARTNERCODE+"], value ["+obpPartnerCode+"]");
}
String uuid = tempProp.getProperty(TransactionContextKeys.TRANSACTION_UUID, "");
if (StringUtils.isNotBlank(uuid)) {
filterHeaders.setProperty(X_OBP_TXID, uuid); // JB OBP Framework용
logger.debug("JBOBPFilter] Processing Key ["+X_OBP_TXID+"], value ["+uuid+"]");
}
if (StringUtils.isNotBlank(systemTrustKey)) {
filterHeaders.setProperty(X_OBP_TRUST_SYSTEM, systemTrustKey); // JB OBP Framework용
logger.debug("JBOBPFilter] Processing Key ["+X_OBP_TRUST_SYSTEM+"], value ["+systemTrustKey+"]");
}
} catch (Exception e) {
logger.error(e.getMessage());
}
return message;
}
public Map<String, String> getInboundHeaderProp(Properties prop) {
Properties header = new Properties();
Map<String, String> inboundHeaderMap = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
try {
Object headerObj = prop.get(HttpAdapterServiceKey.INBOUND_HEADER);
if (headerObj instanceof Properties) { //tomcat
header = (Properties) headerObj;
for (String name : header.stringPropertyNames()) {
inboundHeaderMap.put(name, header.getProperty(name));
}
} else if (headerObj instanceof String) { //weblogic
String str = (String) headerObj;
str = str.substring(1, str.length() - 1);
// key=value 분리
String[] entries = str.split(",");
for (String entry : entries) {
String[] kv = entry.split("=", 2);
if (kv.length == 2) {
inboundHeaderMap.put(kv[0].trim(), kv[1].trim());
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
return inboundHeaderMap;
}
@Override
public Object doPostFilter(String adptGrpName, String adptName, Properties prop, Object message,
Properties tempProp) throws Exception {
return message;
}
}
@@ -1,135 +0,0 @@
package com.eactive.eai.custom.kjb.adapter.http.client.filter;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Map;
import java.util.Properties;
import java.util.TreeMap;
import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
import com.eactive.eai.common.property.PropGroupVO;
import com.eactive.eai.common.property.PropManager;
import com.eactive.eai.common.util.Logger;
public class KAKAOBankFilter implements HttpClientAdapterFilter, HttpAdapterServiceKey {
protected static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
public static final String KJB_HEADER = "KJB_Header";
public static final String PROP_PREFIX = "kakaobank";
public static final String X_KKB_PARTNER_CODE = "X-KKB-PARTNER-CODE";
public static final String X_KKB_API_NAME = "X-KKB-API-NAME";
public static final String X_KKB_API_TX_ID = "X-KKB-API-TX-ID";
public static final String X_KKB_TX_TIME = "X-KKB-TX-TIME";
public static final String X_KKB_CMPR_MGMT_NO = "X-KKB-CMPR-MGMT-NO";
@Override
public Object doPreFilter(String adptGrpName, String adptName, Properties prop, Object message, Properties tempProp)
throws Exception {
logger.debug("KAKAOBankFilter] PreFilter Processing Start!!");
Object returnMessage = message;
String partnerCode = "KJB";
String apiName = "status_change";
String apiTxId = "0";
String txTime = new SimpleDateFormat("yyyyMMddHHmmss").format(new Date());
String cmprMgmtNo = "0";
PropGroupVO propGroupVo = PropManager.getInstance().getPropGroupVO(KJB_HEADER);
if (propGroupVo != null) {
partnerCode = propGroupVo.getProperty(PROP_PREFIX + "." + X_KKB_PARTNER_CODE);
apiName = propGroupVo.getProperty(PROP_PREFIX + "." + X_KKB_API_NAME);
apiTxId = propGroupVo.getProperty(PROP_PREFIX + "." + X_KKB_API_TX_ID);
cmprMgmtNo = propGroupVo.getProperty(PROP_PREFIX + "." + X_KKB_CMPR_MGMT_NO);
}
Properties filterHeaders = (Properties) tempProp.get("FILTERHEADER");
if (filterHeaders == null) {
filterHeaders = new Properties();
tempProp.put("FILTERHEADER", filterHeaders);
}
try {
Map<String, String> inboundHeaderMap = getInboundHeaderProp(tempProp);
if (!inboundHeaderMap.isEmpty()) {
if (inboundHeaderMap.containsKey(X_KKB_PARTNER_CODE)) {
filterHeaders.put(X_KKB_PARTNER_CODE, inboundHeaderMap.get(X_KKB_PARTNER_CODE));
} else {
filterHeaders.put(X_KKB_PARTNER_CODE, partnerCode);
}
if (inboundHeaderMap.containsKey(X_KKB_API_NAME)) {
filterHeaders.put(X_KKB_API_NAME, inboundHeaderMap.get(X_KKB_API_NAME));
} else {
filterHeaders.put(X_KKB_API_NAME, apiName);
}
if (inboundHeaderMap.containsKey(X_KKB_API_TX_ID)) {
filterHeaders.put(X_KKB_API_TX_ID, inboundHeaderMap.get(X_KKB_API_TX_ID));
} else {
filterHeaders.put(X_KKB_API_TX_ID, apiTxId);
}
if (inboundHeaderMap.containsKey(X_KKB_TX_TIME)) {
filterHeaders.put(X_KKB_TX_TIME, inboundHeaderMap.get(X_KKB_TX_TIME));
} else {
filterHeaders.put(X_KKB_TX_TIME, txTime);
}
if (inboundHeaderMap.containsKey(X_KKB_CMPR_MGMT_NO)) {
filterHeaders.put(X_KKB_CMPR_MGMT_NO, inboundHeaderMap.get(X_KKB_CMPR_MGMT_NO));
} else {
filterHeaders.put(X_KKB_CMPR_MGMT_NO, cmprMgmtNo);
}
} else {
filterHeaders.put(X_KKB_PARTNER_CODE, partnerCode);
filterHeaders.put(X_KKB_API_NAME, apiName);
filterHeaders.put(X_KKB_API_TX_ID, apiTxId);
filterHeaders.put(X_KKB_TX_TIME, txTime);
filterHeaders.put(X_KKB_CMPR_MGMT_NO, cmprMgmtNo);
}
logger.debug("KAKAOBankFilter] Processing Key ["+X_KKB_PARTNER_CODE+"], value ["+filterHeaders.getProperty(X_KKB_PARTNER_CODE)+"]");
logger.debug("KAKAOBankFilter] Processing Key ["+X_KKB_API_NAME+"], value ["+filterHeaders.getProperty(X_KKB_API_NAME)+"]");
logger.debug("KAKAOBankFilter] Processing Key ["+X_KKB_API_TX_ID+"], value ["+filterHeaders.getProperty(X_KKB_API_TX_ID)+"]");
logger.debug("KAKAOBankFilter] Processing Key ["+X_KKB_TX_TIME+"], value ["+filterHeaders.getProperty(X_KKB_TX_TIME)+"]");
logger.debug("KAKAOBankFilter] Processing Key ["+X_KKB_CMPR_MGMT_NO+"], value ["+filterHeaders.getProperty(X_KKB_CMPR_MGMT_NO)+"]");
} catch (Exception e) {
logger.error(e.getMessage());
}
return returnMessage;
}
public Map<String, String> getInboundHeaderProp(Properties prop) {
Properties header = new Properties();
Map<String, String> inboundHeaderMap = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
try {
Object headerObj = prop.get(HttpAdapterServiceKey.INBOUND_HEADER);
if (headerObj instanceof Properties) { //tomcat
header = (Properties) headerObj;
for (String name : header.stringPropertyNames()) {
inboundHeaderMap.put(name, header.getProperty(name));
}
} else if (headerObj instanceof String) { //weblogic
String str = (String) headerObj;
str = str.substring(1, str.length() - 1);
// key=value 분리
String[] entries = str.split(",");
for (String entry : entries) {
String[] kv = entry.split("=", 2);
if (kv.length == 2) {
inboundHeaderMap.put(kv[0].trim(), kv[1].trim());
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
return inboundHeaderMap;
}
@Override
public Object doPostFilter(String adptGrpName, String adptName, Properties prop, Object message,
Properties tempProp) throws Exception {
return message;
}
}
@@ -1,154 +0,0 @@
package com.eactive.eai.custom.kjb.adapter.http.client.filter;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Map;
import java.util.Properties;
import java.util.TreeMap;
import org.apache.commons.lang3.RandomStringUtils;
import org.apache.commons.lang3.StringUtils;
import org.json.simple.JSONObject;
import org.json.simple.JSONValue;
import com.eactive.eai.adapter.AdapterGroupVO;
import com.eactive.eai.adapter.AdapterManager;
import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
import com.eactive.eai.common.property.PropGroupVO;
import com.eactive.eai.common.property.PropManager;
import com.eactive.eai.common.server.EAIServerManager;
import com.eactive.eai.common.util.Logger;
public class KFTCFaceFilter implements HttpClientAdapterFilter, HttpAdapterServiceKey {
protected static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
public static final String KJB_HEADER = "KJB_Header";
public static final String PROP_PREFIX = "kftcface";
public static final String H_CLIENT_ID = "Client-Id";
public static final String B_ORG_CODE = "org_code";
public static final String B_TRANSACTION_ID = "transaction_id";
public static final String B_REQUEST_DATETIME = "request_datetime";
public static String instId = null;
static {
EAIServerManager eaiServerManager = EAIServerManager.getInstance();
instId = eaiServerManager.getInstId();
}
@SuppressWarnings({ "unchecked" })
@Override
public Object doPreFilter(String adptGrpName, String adptName, Properties prop, Object message, Properties tempProp)
throws Exception {
logger.debug("KFTCFaceFilter] PreFilter Processing Start!!");
JSONObject returnMessage = null;
String clientId = "";
String orgCode = "034"; // 광주은행 행코드
PropGroupVO propGroupVo = PropManager.getInstance().getPropGroupVO(KJB_HEADER);
if (propGroupVo != null) {
if (StringUtils.isEmpty(clientId))
clientId = propGroupVo.getProperty(PROP_PREFIX + "." + H_CLIENT_ID);
orgCode = propGroupVo.getProperty(PROP_PREFIX + "." + B_ORG_CODE);
}
String request_datetime = new SimpleDateFormat("yyyyMMddHHmmss").format(new Date());
String reqDate = new SimpleDateFormat("yyMMdd").format(new Date());
String reqTime = new SimpleDateFormat("HHmmss").format(new Date());
// 기관코드(3) + 요청일자(6) -- 금결원 표준화 항목, 고정 9자리.
// 요청시간(6) + 인스턴스ID(2) + RandomString(3) -- 기관별 생성 거래고유번호(11자리)
// 기관코드(3) + 요청일자(6) + 요청시간(6) + 인스턴스ID(2) + RandomString(3) -- 20자리.
String transaction_id = orgCode + reqDate + reqTime + instId + RandomStringUtils.random(3, true, true).toUpperCase();
Properties filterHeaders = (Properties) tempProp.get("FILTERHEADER");
if (filterHeaders == null) {
filterHeaders = new Properties();
tempProp.put("FILTERHEADER", filterHeaders);
}
try {
Map<String, String> inboundHeaderMap = getInboundHeaderProp(tempProp);
if (!inboundHeaderMap.isEmpty()) {
if (inboundHeaderMap.containsKey(H_CLIENT_ID)) {
filterHeaders.put(H_CLIENT_ID, inboundHeaderMap.get(H_CLIENT_ID));
logger.debug("KFTCFaceFilter] Processing Key ["+H_CLIENT_ID+"], value ["+inboundHeaderMap.get(H_CLIENT_ID)+"]");
} else {
filterHeaders.put(H_CLIENT_ID, clientId);
logger.debug("KFTCFaceFilter] Processing Key ["+H_CLIENT_ID+"], value ["+clientId+"]");
}
} else {
filterHeaders.setProperty(H_CLIENT_ID, clientId);
logger.debug("KFTCFaceFilter] Processing Key ["+H_CLIENT_ID+"], value ["+clientId+"]");
}
} catch (Exception e) {
logger.error(e.getMessage());
}
AdapterManager adapterManager = AdapterManager.getInstance();
AdapterGroupVO adptGrpVO = adapterManager.getAdapterGroupVO(adptGrpName);
String encode = adptGrpVO.getMessageEncode();
if (message == null) {
returnMessage = new JSONObject();
} else {
if (message instanceof JSONObject) {
returnMessage = (JSONObject) message;
} else if (message instanceof String) {
returnMessage = parseJson((String) message);
} else if (message instanceof byte[]) {
returnMessage = parseJson(new String((byte[]) message, encode));
}
}
returnMessage.put(B_ORG_CODE, orgCode);
returnMessage.put(B_TRANSACTION_ID, transaction_id);
returnMessage.put(B_REQUEST_DATETIME, request_datetime);
return returnMessage.toJSONString();
}
private JSONObject parseJson(String message) throws Exception {
if (message == null) {
return null;
}
return (JSONObject) JSONValue.parse(message);
}
public Map<String, String> getInboundHeaderProp(Properties prop) {
Properties header = new Properties();
Map<String, String> inboundHeaderMap = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
try {
Object headerObj = prop.get(HttpAdapterServiceKey.INBOUND_HEADER);
if (headerObj instanceof Properties) { //tomcat
header = (Properties) headerObj;
for (String name : header.stringPropertyNames()) {
inboundHeaderMap.put(name, header.getProperty(name));
}
} else if (headerObj instanceof String) { //weblogic
String str = (String) headerObj;
str = str.substring(1, str.length() - 1);
// key=value 분리
String[] entries = str.split(",");
for (String entry : entries) {
String[] kv = entry.split("=", 2);
if (kv.length == 2) {
inboundHeaderMap.put(kv[0].trim(), kv[1].trim());
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
return inboundHeaderMap;
}
@Override
public Object doPostFilter(String adptGrpName, String adptName, Properties prop, Object message,
Properties tempProp) throws Exception {
return message;
}
}
@@ -1,122 +0,0 @@
package com.eactive.eai.custom.kjb.adapter.http.client.filter;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Map;
import java.util.Properties;
import java.util.TreeMap;
import org.apache.commons.lang3.RandomStringUtils;
import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
import com.eactive.eai.common.property.PropGroupVO;
import com.eactive.eai.common.property.PropManager;
import com.eactive.eai.common.server.EAIServerManager;
import com.eactive.eai.common.util.Logger;
public class KFTCP2PFilter implements HttpClientAdapterFilter, HttpAdapterServiceKey {
protected static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
public static final String KJB_HEADER = "KJB_Header";
public static final String PROP_PREFIX = "kftcp2p";
public static final String H_ORG_CODE = "org_code";
public static final String H_TRX_NO = "api_trx_no";
public static final String H_TRX_DTM = "api_trx_dtm";
public static String instId = null;
static {
EAIServerManager eaiServerManager = EAIServerManager.getInstance();
instId = eaiServerManager.getInstId();
}
@Override
public Object doPreFilter(String adptGrpName, String adptName, Properties prop, Object message, Properties tempProp)
throws Exception {
logger.debug("KFTCP2PFilter] PreFilter Processing Start!!");
String orgCode = "D210400012"; // 광주은행 개발 기관코드(운영: K210800020)
PropGroupVO propGroupVo = PropManager.getInstance().getPropGroupVO(KJB_HEADER);
if (propGroupVo != null) {
orgCode = propGroupVo.getProperty(PROP_PREFIX + "." + H_ORG_CODE);
}
String apiTrxDtm = new SimpleDateFormat("yyyyMMddHHmmssSSS").format(new Date());
String apiTrxTm = new SimpleDateFormat("HHmmss").format(new Date());
// 기관코드(10) + 인스턴스ID(2) + 일시(6) + RandomString(2) -- 20자리
String apiTrxNo = orgCode + instId + apiTrxTm + RandomStringUtils.random(2, true, true).toUpperCase();
Properties filterHeaders = (Properties) tempProp.get("FILTERHEADER");
if (filterHeaders == null) {
filterHeaders = new Properties();
tempProp.put("FILTERHEADER", filterHeaders);
}
try {
Map<String, String> inboundHeaderMap = getInboundHeaderProp(tempProp);
if (!inboundHeaderMap.isEmpty()) {
if (inboundHeaderMap.containsKey(H_TRX_NO)) {
filterHeaders.put(H_TRX_NO, inboundHeaderMap.get(H_TRX_NO));
logger.debug("KFTCP2PFilter] Processing Key ["+H_TRX_NO+"], value ["+inboundHeaderMap.get(H_TRX_NO)+"]");
} else {
filterHeaders.put(H_TRX_NO, apiTrxNo);
logger.debug("KFTCP2PFilter] Processing Key ["+H_TRX_NO+"], value ["+apiTrxNo+"]");
}
if (inboundHeaderMap.containsKey(H_TRX_DTM)) {
filterHeaders.put(H_TRX_DTM, inboundHeaderMap.get(H_TRX_DTM));
logger.debug("KFTCP2PFilter] Processing Key ["+H_TRX_DTM+"], value ["+inboundHeaderMap.get(H_TRX_DTM)+"]");
} else {
filterHeaders.put(H_TRX_DTM, apiTrxDtm);
logger.debug("KFTCP2PFilter] Processing Key ["+H_TRX_DTM+"], value ["+apiTrxDtm+"]");
}
} else {
filterHeaders.put(H_TRX_NO, apiTrxNo);
filterHeaders.put(H_TRX_DTM, apiTrxDtm);
}
logger.debug("KFTCP2PFilter] Processing Key ["+H_TRX_NO+"], value ["+filterHeaders.getProperty(H_TRX_NO)+"]");
logger.debug("KFTCP2PFilter] Processing Key ["+H_TRX_DTM+"], value ["+filterHeaders.getProperty(H_TRX_DTM)+"]");
} catch (Exception e) {
logger.error(e.getMessage());
}
return message;
}
public Map<String, String> getInboundHeaderProp(Properties prop) {
Properties header = new Properties();
Map<String, String> inboundHeaderMap = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
try {
Object headerObj = prop.get(HttpAdapterServiceKey.INBOUND_HEADER);
if (headerObj instanceof Properties) { //tomcat
header = (Properties) headerObj;
for (String name : header.stringPropertyNames()) {
inboundHeaderMap.put(name, header.getProperty(name));
}
} else if (headerObj instanceof String) { //weblogic
String str = (String) headerObj;
str = str.substring(1, str.length() - 1);
// key=value 분리
String[] entries = str.split(",");
for (String entry : entries) {
String[] kv = entry.split("=", 2);
if (kv.length == 2) {
inboundHeaderMap.put(kv[0].trim(), kv[1].trim());
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
return inboundHeaderMap;
}
@Override
public Object doPostFilter(String adptGrpName, String adptName, Properties prop, Object message,
Properties tempProp) throws Exception {
return message;
}
}
@@ -1,107 +0,0 @@
package com.eactive.eai.custom.kjb.adapter.http.client.filter;
import java.util.Map;
import java.util.Properties;
import java.util.TreeMap;
import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
import com.eactive.eai.common.property.PropGroupVO;
import com.eactive.eai.common.property.PropManager;
import com.eactive.eai.common.util.Logger;
public class NAVERFinFilter implements HttpClientAdapterFilter, HttpAdapterServiceKey {
protected static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
public static final String KJB_HEADER = "KJB_Header";
public static final String PROP_PREFIX = "naverfin";
public static final String X_PARTNER_ID = "X-Partner-Id";
public static final String X_FINTECH_ID = "X-Fintech-Id";
@Override
public Object doPreFilter(String adptGrpName, String adptName, Properties prop, Object message, Properties tempProp)
throws Exception {
logger.debug("NAVERFinFilter] PreFilter Processing Start!!");
String partnerID = "r0jtqwC9gAW5";
String fintechId = "NF";
PropGroupVO propGroupVo = PropManager.getInstance().getPropGroupVO(KJB_HEADER);
if (propGroupVo != null) {
partnerID = propGroupVo.getProperty(PROP_PREFIX + "." + X_PARTNER_ID);
fintechId = propGroupVo.getProperty(PROP_PREFIX + "." + X_FINTECH_ID);
}
Properties filterHeaders = (Properties) tempProp.get("FILTERHEADER");
if (filterHeaders == null) {
filterHeaders = new Properties();
tempProp.put("FILTERHEADER", filterHeaders);
}
try {
Map<String, String> inboundHeaderMap = getInboundHeaderProp(tempProp);
if (!inboundHeaderMap.isEmpty()) {
if (inboundHeaderMap.containsKey(X_PARTNER_ID)) {
filterHeaders.put(X_PARTNER_ID, inboundHeaderMap.get(X_PARTNER_ID));
logger.debug("NAVERFinFilter] Processing Key ["+X_PARTNER_ID+"], value ["+inboundHeaderMap.get(X_PARTNER_ID)+"]");
} else {
filterHeaders.put(X_PARTNER_ID, partnerID);
logger.debug("NAVERFinFilter] Processing Key ["+X_PARTNER_ID+"], value ["+partnerID+"]");
}
if (inboundHeaderMap.containsKey(X_FINTECH_ID)) {
filterHeaders.put(X_FINTECH_ID, inboundHeaderMap.get(X_FINTECH_ID));
logger.debug("NAVERFinFilter] Processing Key ["+X_FINTECH_ID+"], value ["+inboundHeaderMap.get(X_FINTECH_ID)+"]");
} else {
filterHeaders.put(X_FINTECH_ID, fintechId);
logger.debug("NAVERFinFilter] Processing Key ["+X_FINTECH_ID+"], value ["+fintechId+"]");
}
} else {
filterHeaders.put(X_PARTNER_ID, partnerID);
filterHeaders.put(X_FINTECH_ID, fintechId);
}
logger.debug("NAVERFinFilter] Processing Key ["+X_PARTNER_ID+"], value ["+filterHeaders.getProperty(X_PARTNER_ID)+"]");
logger.debug("NAVERFinFilter] Processing Key ["+X_FINTECH_ID+"], value ["+filterHeaders.getProperty(X_FINTECH_ID)+"]");
} catch (Exception e) {
logger.error(e.getMessage());
}
return message;
}
public Map<String, String> getInboundHeaderProp(Properties prop) {
Properties header = new Properties();
Map<String, String> inboundHeaderMap = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
try {
Object headerObj = prop.get(HttpAdapterServiceKey.INBOUND_HEADER);
if (headerObj instanceof Properties) { //tomcat
header = (Properties) headerObj;
for (String name : header.stringPropertyNames()) {
inboundHeaderMap.put(name, header.getProperty(name));
}
} else if (headerObj instanceof String) { //weblogic
String str = (String) headerObj;
str = str.substring(1, str.length() - 1);
// key=value 분리
String[] entries = str.split(",");
for (String entry : entries) {
String[] kv = entry.split("=", 2);
if (kv.length == 2) {
inboundHeaderMap.put(kv[0].trim(), kv[1].trim());
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
return inboundHeaderMap;
}
@Override
public Object doPostFilter(String adptGrpName, String adptName, Properties prop, Object message,
Properties tempProp) throws Exception {
return message;
}
}
@@ -1,138 +0,0 @@
package com.eactive.eai.custom.kjb.adapter.http.client.filter;
import java.util.Map.Entry;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Map;
import java.util.Properties;
import java.util.TreeMap;
import org.apache.commons.lang3.StringUtils;
import org.json.simple.JSONObject;
import org.json.simple.JSONValue;
import com.eactive.eai.adapter.AdapterGroupVO;
import com.eactive.eai.adapter.AdapterManager;
import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
import com.eactive.eai.common.property.PropGroupVO;
import com.eactive.eai.common.property.PropManager;
import com.eactive.eai.common.util.Logger;
public class NICECreditFilter implements HttpClientAdapterFilter, HttpAdapterServiceKey {
protected static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
public static final String KJB_HEADER = "KJB_Header";
public static final String PROP_PREFIX = "nicecredit";
public static final String H_PRODUCTID = "ProductID";
public static final String B_REQ_DTM = "req_dtm";
public static final String B_GOODS_CLS = "goods_cls";
@SuppressWarnings({ "unchecked" })
@Override
public Object doPreFilter(String adptGrpName, String adptName, Properties prop, Object message, Properties tempProp)
throws Exception {
JSONObject returnMessage = null;
String productId = "2303102120";
String reqDtm = new SimpleDateFormat("yyyyMMddHHmmss").format(new Date());
String goodsCls = "KJBAPI0001";
PropGroupVO propGroupVo = PropManager.getInstance().getPropGroupVO(KJB_HEADER);
if (propGroupVo != null) {
productId = propGroupVo.getProperty(PROP_PREFIX + "." + H_PRODUCTID);
goodsCls = propGroupVo.getProperty(PROP_PREFIX + "." + B_GOODS_CLS);
}
Properties filterHeaders = (Properties) tempProp.get("FILTERHEADER");
if (filterHeaders == null) {
filterHeaders = new Properties();
tempProp.put("FILTERHEADER", filterHeaders);
}
try {
Map<String, String> inboundHeaderMap = getInboundHeaderProp(tempProp);
if (inboundHeaderMap != null && inboundHeaderMap.containsKey(H_PRODUCTID)) {
for (Entry<String, String> e : inboundHeaderMap.entrySet()) {
String key = (String) e.getKey();
String value = (String) e.getValue();
if (StringUtils.equalsIgnoreCase(key, H_PRODUCTID)) {
filterHeaders.setProperty(key, value);
}
if (logger.isDebugEnabled()) {
logger.debug("Request Header :" + key + "=[" + value + "]");
}
}
} else {
filterHeaders.setProperty(H_PRODUCTID, productId);
}
} catch (Exception e) {
logger.error(e.getMessage());
}
AdapterManager adapterManager = AdapterManager.getInstance();
AdapterGroupVO adptGrpVO = adapterManager.getAdapterGroupVO(adptGrpName);
String encode = adptGrpVO.getMessageEncode();
if (message == null) {
returnMessage = new JSONObject();
} else {
if (message instanceof JSONObject) {
returnMessage = (JSONObject) message;
} else if (message instanceof String) {
returnMessage = parseJson((String) message);
} else if (message instanceof byte[]) {
returnMessage = parseJson(new String((byte[]) message, encode));
}
}
returnMessage.put(B_REQ_DTM, reqDtm);
returnMessage.put(B_GOODS_CLS, goodsCls);
return returnMessage.toJSONString();
}
private JSONObject parseJson(String message) throws Exception {
if (message == null) {
return null;
}
return (JSONObject) JSONValue.parse(message);
}
public Map<String, String> getInboundHeaderProp(Properties prop) {
Properties header = new Properties();
Map<String, String> inboundHeaderMap = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
try {
Object headerObj = prop.get(HttpAdapterServiceKey.INBOUND_HEADER);
if (headerObj instanceof Properties) { //tomcat
header = (Properties) headerObj;
for (String name : header.stringPropertyNames()) {
inboundHeaderMap.put(name, header.getProperty(name));
}
} else if (headerObj instanceof String) { //weblogic
String str = (String) headerObj;
str = str.substring(1, str.length() - 1);
// key=value 분리
String[] entries = str.split(",");
for (String entry : entries) {
String[] kv = entry.split("=", 2);
if (kv.length == 2) {
inboundHeaderMap.put(kv[0].trim(), kv[1].trim());
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
return inboundHeaderMap;
}
@Override
public Object doPostFilter(String adptGrpName, String adptName, Properties prop, Object message,
Properties tempProp) throws Exception {
return message;
}
}
@@ -1,109 +0,0 @@
package com.eactive.eai.custom.kjb.adapter.http.client.filter;
import java.util.Map;
import java.util.Properties;
import java.util.TreeMap;
import org.apache.commons.lang3.StringUtils;
import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceSupport;
import com.eactive.eai.common.TransactionContextKeys;
import com.eactive.eai.common.util.Logger;
public class SimpleFrameworkFilter implements HttpClientAdapterFilter, HttpAdapterServiceKey {
protected static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
public static final String CLIENTID = "clientId";
public static final String TRACEID = "traceId";
public static final String GUID = "guid";
public static final String RECEIVEDTIMESTAMP = "receivedTimestamp";
public static final String PARTNER_TRACE_ID = "partnerTraceId";
@Override
public Object doPreFilter(String adptGrpName, String adptName, Properties prop, Object message, Properties tempProp)
throws Exception {
logger.debug("SimpleFrameworkFilter] PreFilter Processing Start!!");
Properties filterHeaders = (Properties) tempProp.get("FILTERHEADER");
if (filterHeaders == null) {
filterHeaders = new Properties();
tempProp.put("FILTERHEADER", filterHeaders);
}
Map<String, String> inboundHeaderMap = getInboundHeaderProp(tempProp);
try {
/* 업체정보 */
String clientId = tempProp.getProperty(HttpAdapterServiceSupport.PROPERTIES_NAME_CLIENT_ID);
if (StringUtils.isEmpty(clientId)) clientId = "";
filterHeaders.put(CLIENTID, clientId);
logger.debug("SimpleFrameworkFilter] Processing Key ["+CLIENTID+"], value ["+clientId+"]");
/* APIM 거래추적자 */
String uuid = tempProp.getProperty(TransactionContextKeys.TRANSACTION_UUID, "");
filterHeaders.put(TRACEID, uuid);
logger.debug("SimpleFrameworkFilter] Processing Key ["+TRACEID+"], value ["+uuid+"]");
/* GUID */
String guid = tempProp.getProperty(TransactionContextKeys.GUID, "");
filterHeaders.put(GUID, guid);
logger.debug("SimpleFrameworkFilter] Processing Key ["+GUID+"], value ["+guid+"]");
/* 최초요청시간 */
String receivedTimestamp = tempProp.getProperty(HttpAdapterServiceKey.INBOUND_REQUESTED_TIME, "");
filterHeaders.put(RECEIVEDTIMESTAMP, receivedTimestamp);
logger.debug("SimpleFrameworkFilter] Processing Key ["+RECEIVEDTIMESTAMP+"], value ["+receivedTimestamp+"]");
String partnerTraceId = inboundHeaderMap.getOrDefault(PARTNER_TRACE_ID, "");
filterHeaders.put(PARTNER_TRACE_ID, partnerTraceId);
logger.debug("SimpleFrameworkFilter] Processing Key ["+PARTNER_TRACE_ID+"], value ["+partnerTraceId+"]");
String x_loan_token = inboundHeaderMap.getOrDefault(TransactionContextKeys.X_LOAN_TOKEN, "");
filterHeaders.put(TransactionContextKeys.X_LOAN_TOKEN, x_loan_token);
logger.debug("SimpleFrameworkFilter] Processing Key ["+TransactionContextKeys.X_LOAN_TOKEN+"], value ["+x_loan_token+"]");
} catch (Exception e) {
logger.error(e.getMessage());
}
return message;
}
public Map<String, String> getInboundHeaderProp(Properties prop) {
Properties header = new Properties();
Map<String, String> inboundHeaderMap = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
try {
Object headerObj = prop.get(HttpAdapterServiceKey.INBOUND_HEADER);
if (headerObj instanceof Properties) { //tomcat
header = (Properties) headerObj;
for (String name : header.stringPropertyNames()) {
inboundHeaderMap.put(name, header.getProperty(name));
}
} else if (headerObj instanceof String) { //weblogic
String str = (String) headerObj;
str = str.substring(1, str.length() - 1);
// key=value 분리
String[] entries = str.split(",");
for (String entry : entries) {
String[] kv = entry.split("=", 2);
if (kv.length == 2) {
inboundHeaderMap.put(kv[0].trim(), kv[1].trim());
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
return inboundHeaderMap;
}
@Override
public Object doPostFilter(String adptGrpName, String adptName, Properties prop, Object message,
Properties tempProp) throws Exception {
return message;
}
}
@@ -1,28 +0,0 @@
package com.eactive.eai.custom.kjb.adapter.http.client.filter;
import java.util.Properties;
import org.json.simple.JSONObject;
import org.json.simple.JSONValue;
import com.eactive.eai.common.TransactionContextKeys;
public class SimpleframeworkBodyFilter extends SimpleFrameworkFilter {
@Override
public Object doPreFilter(String adptGrpName, String adptName, Properties prop, Object message, Properties tempProp)
throws Exception {
Object returnMessage = super.doPreFilter(adptGrpName, adptName, prop, message, tempProp);
JSONObject bizJsonStr = null;
if ( returnMessage instanceof String ) {
bizJsonStr = (JSONObject) JSONValue.parse( (String)returnMessage);
if( bizJsonStr != null ) {
bizJsonStr.put("GUID", tempProp.getOrDefault(TransactionContextKeys.GUID, "") );
}
}
return bizJsonStr != null ? bizJsonStr.toJSONString() : returnMessage;
}
}
@@ -1,97 +0,0 @@
package com.eactive.eai.custom.kjb.adapter.http.client.filter;
import java.util.Map;
import java.util.Properties;
import java.util.TreeMap;
import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
import com.eactive.eai.common.TransactionContextKeys;
import com.eactive.eai.common.property.PropGroupVO;
import com.eactive.eai.common.property.PropManager;
import com.eactive.eai.common.util.Logger;
public class TOSSBankFilter implements HttpClientAdapterFilter, HttpAdapterServiceKey {
protected static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
public static final String KJB_HEADER = "KJB_Header";
public static final String PROP_PREFIX = "tossbank";
public static final String X_TOSSBANK_LOAN_TRACE_ID = "X-TOSSBANK-LOAN-TRACE-ID";
@Override
public Object doPreFilter(String adptGrpName, String adptName, Properties prop, Object message, Properties tempProp)
throws Exception {
logger.debug("TOSSBankFilter] PreFilter Processing Start!!");
String traceId = tempProp.getProperty(TransactionContextKeys.TRANSACTION_UUID, "");
PropGroupVO propGroupVo = PropManager.getInstance().getPropGroupVO(KJB_HEADER);
if (propGroupVo != null) {
}
Properties filterHeaders = (Properties) tempProp.get("FILTERHEADER");
if (filterHeaders == null) {
filterHeaders = new Properties();
tempProp.put("FILTERHEADER", filterHeaders);
}
try {
Map<String, String> inboundHeaderMap = getInboundHeaderProp(tempProp);
if (!inboundHeaderMap.isEmpty()) {
if (inboundHeaderMap.containsKey(X_TOSSBANK_LOAN_TRACE_ID)) {
filterHeaders.put(X_TOSSBANK_LOAN_TRACE_ID, inboundHeaderMap.get(X_TOSSBANK_LOAN_TRACE_ID));
logger.debug("TOSSBankFilter] Processing Key ["+X_TOSSBANK_LOAN_TRACE_ID+"], value ["+inboundHeaderMap.get(X_TOSSBANK_LOAN_TRACE_ID)+"]");
} else {
filterHeaders.put(X_TOSSBANK_LOAN_TRACE_ID, traceId);
logger.debug("TOSSBankFilter] Processing Key ["+X_TOSSBANK_LOAN_TRACE_ID+"], value ["+traceId+"]");
}
} else {
/* APIM 거래추적자 */
filterHeaders.setProperty(X_TOSSBANK_LOAN_TRACE_ID, traceId);
logger.debug("TOSSBankFilter] Processing Key ["+X_TOSSBANK_LOAN_TRACE_ID+"], value ["+traceId+"]");
}
logger.debug("TOSSBankFilter] Processing Key ["+X_TOSSBANK_LOAN_TRACE_ID+"], value ["+filterHeaders.getProperty(X_TOSSBANK_LOAN_TRACE_ID)+"]");
} catch (Exception e) {
logger.error(e.getMessage());
}
return message;
}
public Map<String, String> getInboundHeaderProp(Properties prop) {
Properties header = new Properties();
Map<String, String> inboundHeaderMap = new TreeMap<>(String.CASE_INSENSITIVE_ORDER);
try {
Object headerObj = prop.get(HttpAdapterServiceKey.INBOUND_HEADER);
if (headerObj instanceof Properties) { //tomcat
header = (Properties) headerObj;
for (String name : header.stringPropertyNames()) {
inboundHeaderMap.put(name, header.getProperty(name));
}
} else if (headerObj instanceof String) { //weblogic
String str = (String) headerObj;
str = str.substring(1, str.length() - 1);
// key=value 분리
String[] entries = str.split(",");
for (String entry : entries) {
String[] kv = entry.split("=", 2);
if (kv.length == 2) {
inboundHeaderMap.put(kv[0].trim(), kv[1].trim());
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
return inboundHeaderMap;
}
@Override
public Object doPostFilter(String adptGrpName, String adptName, Properties prop, Object message,
Properties tempProp) throws Exception {
return message;
}
}
@@ -1,71 +0,0 @@
package com.eactive.eai.custom.kjb.adapter.http.client.filter;
import java.util.Properties;
import org.json.simple.JSONObject;
import org.json.simple.JSONValue;
import com.eactive.eai.adapter.http.dynamic.HttpAdapterServiceKey;
import com.eactive.eai.common.TransactionContextKeys;
import com.eactive.eai.common.util.Logger;
import com.nimbusds.jose.shaded.gson.JsonObject;
public class TraceBodyFilter implements HttpClientAdapterFilter, HttpAdapterServiceKey {
protected static Logger logger = Logger.getLogger(Logger.LOGGER_ADAPTER);
public static final String BIZ_HEADER = "header";
public static final String GUID = "guid";
public static final String TRACEID = "traceId";
@Override
public Object doPreFilter(String adptGrpName, String adptName, Properties prop, Object message, Properties tempProp)
throws Exception {
JSONObject bizJsonStr = null;
if (message instanceof String) {
bizJsonStr = (JSONObject) JSONValue.parse((String) message);
if ( bizJsonStr == null ) return message; //json string이 아님.
if (bizJsonStr.containsKey(BIZ_HEADER)) {
JSONObject bizHeader = (JSONObject) bizJsonStr.get(BIZ_HEADER);
putBizHeaderData(bizHeader, tempProp);
}else {
JSONObject bizHeader = new JSONObject();
bizJsonStr.put(BIZ_HEADER, bizHeader);
putBizHeaderData(bizHeader, tempProp);
}
}
return bizJsonStr != null ? bizJsonStr.toJSONString() : message;
}
static private void putBizHeaderData(JSONObject bizHeader, Properties tempProp) {
String traceId = tempProp.getProperty(TransactionContextKeys.TRANSACTION_UUID, "");
String guid = tempProp.getProperty(TransactionContextKeys.GUID, "");
bizHeader.put(GUID, guid);
logger.debug("Processing Key [" + GUID + "], value [" + guid + "]");
bizHeader.put(TRACEID, traceId);
logger.debug("Processing Key [" + TRACEID + "], value [" + traceId + "]");
}
@Override
public Object doPostFilter(String adptGrpName, String adptName, Properties prop, Object message,
Properties tempProp) throws Exception {
// TODO Auto-generated method stub
return message;
}
}
@@ -1,222 +0,0 @@
package com.eactive.eai.custom.kjb.adapter.http.client.impl;
import java.util.Properties;
//import java.util.concurrent.Callable;
import org.apache.commons.lang3.StringUtils;
import org.dom4j.Node;
import org.json.simple.JSONObject;
import com.eactive.eai.adapter.http.client.HttpClientAdapterServiceKey;
import com.eactive.eai.adapter.http.client.impl.HttpClient5AdapterServiceRest;
import com.eactive.eai.custom.kjb.adapter.http.client.filter.HttpClient5AdapterFilterFactory;
//import com.eactive.eai.custom.kjb.adapter.http.client.filter.HttpClientAdapterExceptionFilter;
import com.eactive.eai.custom.kjb.adapter.http.client.filter.HttpClientAdapterFilter;
//import com.eactive.eai.custom.kjb.adapter.http.client.filter.IBKOutCommonFilter;
//import com.eactive.eai.custom.kjb.adapter.http.client.filter.IBKOutExceptionFilter;
//import com.fasterxml.jackson.databind.ObjectMapper;
//import com.fasterxml.jackson.databind.node.ObjectNode;
//import com.ibk.eai.common.circuitbreaker.url.UrlCircuitBreakerManager;
//import io.github.resilience4j.circuitbreaker.CircuitBreaker;
/**
* 1. 기능 : HttpClient5AdapterServiceRest 호출 전후 Filter 적용할 있는 기능을 제공한다.<br>
* 2. 처리 개요 : <br>
* 3. 주의사항 <br>
*
* @author :
* @version : v 1.0.0
* @see : HttpClientAdapterServiceFactory.java,
* HttpClientAdapterServiceSupport.java, HttpClient5AdapterServiceRest.java
* @since :
*
*/
public class HttpClient5AdapterServiceRestAddFilter extends HttpClient5AdapterServiceRest
implements HttpClientAdapterServiceKey {
// 요청전 수행할 필터(쉼표(,) 구분)
static final String PRE_FILTERS = "PRE_FILTERS";
// 요청후 수행할 필터(쉼표(,) 구분)
static final String POST_FILTERS = "POST_FILTERS";
// // Adapter에서 Exception이 발생한 경우, 처리할 필터
// static final String EXCEPTION_FILTER = "EXCEPTION_FILTER";
/**
* 1. 기능 : HttpClient 호출 전후 Filter 적용용 2. 처리 개요 : <br>
* 3. 주의사항 <br>
*
* @param prop Http Adapter 속성 정보
* @return 반환 Object
* @exception Exception 수동 시스템 통신 발생
*/
public Object execute(Properties prop, Object data, Properties tempProp) throws Exception {
String adptGrpName = tempProp.getProperty(ADAPTER_GROUP_NAME);
String adptName = tempProp.getProperty(ADAPTER_NAME);
data = doPreFilters(adptGrpName, adptName, prop, data, tempProp);
Object adapterResponse = super.execute(prop, data, tempProp);
// //원본 url를 찾아서 있으면, 그것을 사용한다.
// String url = tempProp.getProperty("URL_ORG");
// if(StringUtils.isEmpty(url))
// url = tempProp.getProperty(HttpClientAdapterServiceKey.URL);
//
// UrlCircuitBreakerManager cManager = UrlCircuitBreakerManager.getInstance();
// CircuitBreaker circuitBreaker = cManager.getCircuitBreaker(url);
// try {
// if (circuitBreaker != null) {
// if (logger.isDebugEnabled()) {
// // ObjectMapper 인스턴스 생성
// ObjectMapper objectMapper = new ObjectMapper();
// // 서킷 브레이커의 메트릭 정보와 상태 정보를 직접 Node로 변환
// ObjectNode combinedNode = objectMapper.createObjectNode();
// combinedNode.put("state", circuitBreaker.getState().toString());
// combinedNode.set("metrics", objectMapper.valueToTree(circuitBreaker.getMetrics()));
// logger.debug("CircuitBreaker state [" + circuitBreaker.getName() + "] - " + combinedNode.toString());
// }
// adapterResponse = circuitBreaker.executeCallable(new HttpClientAdapterCallable(prop, data, tempProp, this));
// } else {
// adapterResponse = super.execute(prop, data, tempProp);
// }
// } catch (Exception e) {
// adapterResponse = doExceptionFilters(adptGrpName, adptName, prop, adapterResponse, tempProp, e);
//
// if (adapterResponse instanceof JSONObject)
// adapterResponse = ((JSONObject) adapterResponse).toJSONString();
//
// if (adapterResponse instanceof Node)
// adapterResponse = ((Node) adapterResponse).asXML();
//
// return adapterResponse;
// }
adapterResponse = doPostFilters(adptGrpName, adptName, prop, adapterResponse, tempProp);
if (adapterResponse instanceof JSONObject)
adapterResponse = ((JSONObject) adapterResponse).toJSONString();
if (adapterResponse instanceof Node)
adapterResponse = ((Node) adapterResponse).asXML();
return adapterResponse;
}
// protected Object callSuper(Properties prop, Object data, Properties tempProp) throws Exception {
// return super.execute(prop, data, tempProp);
// }
// private class HttpClientAdapterCallable implements Callable<Object> {
// Properties prop;
// Object data;
// Properties tempProp;
// HttpClient5AdapterServiceRestAddFilter clientService;
//
// public HttpClientAdapterCallable(Properties prop, Object data, Properties tempProp,
// HttpClient5AdapterServiceRestAddFilter clientService) {
// this.prop = prop;
// this.data = data;
// this.tempProp = tempProp;
// this.clientService = clientService;
// }
//
// @Override
// public Object call() throws Exception {
// return clientService.callSuper(prop, data, tempProp);
// }
//
// }
protected Object doPreFilters(String adptGrpName, String adptName, Properties prop, Object message,
Properties tempProp) throws Exception {
// boolean isSetCommonFilterInAdapterProp = false;
// 1. adapter에 설정된 필터 수행
String preFiltersStr = prop.getProperty(PRE_FILTERS);
if (StringUtils.isNotEmpty(preFiltersStr)) {
String[] preFilters = StringUtils.split(preFiltersStr, ",");
for (String filterName : preFilters) {
if (StringUtils.isBlank(filterName)) {
continue;
}
logger.debug("HttpClient5AdapterServiceRestAddFilter] Processing Start [" + filterName + "]");
HttpClientAdapterFilter adapterFilter = HttpClient5AdapterFilterFactory.createFilter(filterName.trim());
if (adapterFilter != null) {
// if (adapterFilter instanceof IBKOutCommonFilter)
// isSetCommonFilterInAdapterProp = true;
message = adapterFilter.doPreFilter(adptGrpName, adptName, prop, message, tempProp);
} else {
throw new Exception("Failed get Filter Class: " + filterName);
}
}
}
// // 2. IBKOutCommonFilter 필터 수행(adapter 필터에서 수행하지 않을 때만)
// if (!isSetCommonFilterInAdapterProp) {
// HttpClientAdapterFilter ibkFilter = HttpClient5AdapterFilterFactory
// .createFilter(IBKOutCommonFilter.class.getName());
// if (ibkFilter != null) {
// message = ibkFilter.doPreFilter(adptGrpName, adptName, prop, message, tempProp);
// }
// } else {
// logger.debug("IBKOutCommonFilter isSetCommonFilterInAdapterProp 'POST_FILTERS'. already in adapter filters");
// }
return message;
}
protected Object doPostFilters(String adptGrpName, String adptName, Properties prop, Object message,
Properties tempProp) throws Exception {
// boolean isSetCommonFilterInAdapterProp = false;
// 1. adapter에 설정된 필터 수행
String postFiltersStr = prop.getProperty(POST_FILTERS);
if (StringUtils.isNotEmpty(postFiltersStr)) {
String[] postFilters = StringUtils.split(postFiltersStr, ",");
for (String filterName : postFilters) {
if (StringUtils.isBlank(filterName)) {
continue;
}
HttpClientAdapterFilter adapterFilter = HttpClient5AdapterFilterFactory.createFilter(filterName.trim());
if (adapterFilter != null) {
// if (adapterFilter instanceof IBKOutCommonFilter)
// isSetCommonFilterInAdapterProp = true;
message = adapterFilter.doPostFilter(adptGrpName, adptName, prop, message, tempProp);
} else {
throw new Exception("Failed get Filter Class: " + filterName);
}
}
}
// // 2. IBKOutCommonFilter 필터 수행
// if (!isSetCommonFilterInAdapterProp) {
// HttpClientAdapterFilter ibkFilter = HttpClient5AdapterFilterFactory
// .createFilter(IBKOutCommonFilter.class.getName());
// if (ibkFilter != null) {
// message = ibkFilter.doPostFilter(adptGrpName, adptName, prop, message, tempProp);
// }
// } else {
// logger.debug("IBKOutCommonFilter isSetCommonFilterInAdapterProp 'PRE_FILTERS'. already in adapter filters");
// }
return message;
}
// protected Object doExceptionFilters(String adptGrpName, String adptName, Properties prop, Object message,
// Properties tempProp, Exception e) throws Exception {
// String exceptionFilterName = prop.getProperty(EXCEPTION_FILTER);
// if (StringUtils.isEmpty(exceptionFilterName))
// exceptionFilterName = IBKOutExceptionFilter.class.getSimpleName();
//
// HttpClientAdapterExceptionFilter exceptionFilter = HttpClient5AdapterFilterFactory.createExceptionFilter(exceptionFilterName.trim());
// return exceptionFilter.doExceptionFilter(adptGrpName, adptName, prop, message, tempProp, e);
//
// }
}
@@ -21,8 +21,6 @@ import org.springframework.web.bind.annotation.RestController;
* GET /manage/inflow/adapter/{adapterId}/bucket-status 특정 어댑터 버킷 상태
* GET /manage/inflow/interface/bucket-status 전체 인터페이스 버킷 상태
* GET /manage/inflow/interface/{interfaceId}/bucket-status 특정 인터페이스 버킷 상태
* GET /manage/inflow/client/bucket-status 전체 클라이언트 버킷 상태
* GET /manage/inflow/client/{clientId}/bucket-status 특정 클라이언트 버킷 상태
*/
@RestController
@RequestMapping("/manage/inflow")
@@ -63,22 +61,6 @@ public class InflowTargetBucketController {
return single(dto, "인터페이스를 찾을 수 없습니다: " + interfaceId);
}
// =========================================================================
// 클라이언트
// =========================================================================
@GetMapping("/client/bucket-status")
public ResponseEntity<?> getAllClientBucketStatus() {
List<TargetBucketStatusDTO> list = bucketService.getAllClientBucketStatus();
return ok(list);
}
@GetMapping("/client/{clientId}/bucket-status")
public ResponseEntity<?> getClientBucketStatus(@PathVariable String clientId) {
TargetBucketStatusDTO dto = bucketService.getClientBucketStatus(clientId);
return single(dto, "클라이언트를 찾을 수 없습니다: " + clientId);
}
// =========================================================================
// Helpers
// =========================================================================
@@ -57,24 +57,6 @@ public class InflowTargetBucketService {
return toDtoList("INTERFACE", manager.getInterfaceBucketMap());
}
// -------------------------------------------------------------------------
// 클라이언트
// -------------------------------------------------------------------------
public TargetBucketStatusDTO getClientBucketStatus(String clientId) {
DualInflowControlManager manager = getDualManager();
if (manager == null) return null;
DualCustomBucket bucket = manager.getClientBucket(clientId);
if (bucket == null) return null;
return toDto(clientId, "CLIENT", bucket);
}
public List<TargetBucketStatusDTO> getAllClientBucketStatus() {
DualInflowControlManager manager = getDualManager();
if (manager == null) return new ArrayList<>();
return toDtoList("CLIENT", manager.getClientBucketMap());
}
// -------------------------------------------------------------------------
// Private helpers
// -------------------------------------------------------------------------
@@ -13,7 +13,7 @@ import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
/**
* 어댑터/인터페이스/클라이언트 유량제어 메트릭 API.
* 어댑터/인터페이스 유량제어 메트릭 API.
*
* DualInflowControlManager 활성화된 환경에서만 정상 응답한다.
*
@@ -26,11 +26,6 @@ import org.springframework.web.bind.annotation.RestController;
* GET /manage/inflow/interface/{interfaceId}/metric 특정 인터페이스 메트릭
* POST /manage/inflow/interface/metric/reset 전체 인터페이스 메트릭 초기화
* POST /manage/inflow/interface/{interfaceId}/metric/reset 특정 인터페이스 메트릭 초기화
*
* GET /manage/inflow/client/metric 전체 클라이언트 메트릭
* GET /manage/inflow/client/{clientId}/metric 특정 클라이언트 메트릭
* POST /manage/inflow/client/metric/reset 전체 클라이언트 메트릭 초기화
* POST /manage/inflow/client/{clientId}/metric/reset 특정 클라이언트 메트릭 초기화
*/
@RestController
@RequestMapping("/manage/inflow")
@@ -95,34 +90,6 @@ public class InflowTargetMetricController {
return okResetSingle(ok, interfaceId, "인터페이스");
}
// =========================================================================
// 클라이언트
// =========================================================================
@GetMapping("/client/metric")
public ResponseEntity<?> getAllClientMetrics() {
List<TargetMetricDTO> list = metricService.getAllClientMetrics();
return okList(list);
}
@GetMapping("/client/{clientId}/metric")
public ResponseEntity<?> getClientMetric(@PathVariable String clientId) {
TargetMetricDTO dto = metricService.getClientMetric(clientId);
return okSingle(dto, "클라이언트를 찾을 수 없습니다: " + clientId);
}
@PostMapping("/client/metric/reset")
public ResponseEntity<?> resetAllClientMetrics() {
metricService.resetAllClientMetrics();
return okReset("전체 클라이언트 메트릭 초기화 완료");
}
@PostMapping("/client/{clientId}/metric/reset")
public ResponseEntity<?> resetClientMetric(@PathVariable String clientId) {
boolean ok = metricService.resetClientMetric(clientId);
return okResetSingle(ok, clientId, "클라이언트");
}
// =========================================================================
// Helpers
// =========================================================================
@@ -85,42 +85,6 @@ public class InflowTargetMetricService {
if (manager != null) manager.resetAllInterfaceMetrics();
}
// -------------------------------------------------------------------------
// 클라이언트
// -------------------------------------------------------------------------
public TargetMetricDTO getClientMetric(String clientId) {
DualInflowControlManager manager = getDualManager();
if (manager == null) return null;
InflowTargetVO vo = manager.getClientInflowThreshold(clientId);
if (vo == null) return null;
return buildDTO(clientId, "CLIENT", vo, manager.getClientMetrics(clientId));
}
public List<TargetMetricDTO> getAllClientMetrics() {
DualInflowControlManager manager = getDualManager();
if (manager == null) return new ArrayList<>();
List<TargetMetricDTO> result = new ArrayList<>();
for (String id : manager.getClientBucketMap().keySet()) {
TargetMetricDTO dto = getClientMetric(id);
if (dto != null) result.add(dto);
}
return result;
}
public boolean resetClientMetric(String clientId) {
DualInflowControlManager manager = getDualManager();
if (manager == null) return false;
if (manager.getClientInflowThreshold(clientId) == null) return false;
manager.resetClientMetrics(clientId);
return true;
}
public void resetAllClientMetrics() {
DualInflowControlManager manager = getDualManager();
if (manager != null) manager.resetAllClientMetrics();
}
// -------------------------------------------------------------------------
// Private helpers
// -------------------------------------------------------------------------
@@ -8,7 +8,7 @@ mapper.definition=standard-message-mapping-config-djb.properties
# StandardMessage Coordinator implementation
message.coordinator.class=com.eactive.eai.custom.message.StandardMessageCoordinatorDJB
# RequestProcessor implementation
requestProcessor.class=com.eactive.eai.inbound.processor.DualRequestProcessor
requestProcessor.class=com.eactive.eai.custom.inbound.processor.DJBRequestProcessor
# reader : parsing input data to StandardMessage
reader.JSON=com.eactive.eai.message.parser.JsonReader
reader.JSN=com.eactive.eai.message.parser.JsonReader
@@ -0,0 +1,317 @@
package com.eactive.eai.custom.adapter.http.dynamic.filter;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.ArgumentMatchers.*;
import static org.mockito.Mockito.*;
import java.nio.charset.StandardCharsets;
import java.util.Base64;
import java.util.Map;
import java.util.Properties;
import org.mockito.ArgumentCaptor;
import javax.servlet.http.HttpServletRequest;
import org.json.simple.JSONObject;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.MethodOrderer;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestMethodOrder;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.context.support.GenericApplicationContext;
import com.eactive.eai.common.security.CryptoModuleService;
import com.eactive.eai.common.util.ApplicationContextProvider;
@TestMethodOrder(MethodOrderer.DisplayName.class)
class DJBErpCryptoFilterTest {
private static final String MODULE_NAME = "TEST_MODULE";
// 복호화 평문 (JSON 문자열)
private static final String PLAIN_TEXT = "{\"userId\":\"U001\",\"name\":\"test\"}";
private static final byte[] PLAIN_BYTES = PLAIN_TEXT.getBytes(StandardCharsets.UTF_8);
// 더미 암호문 bytes + Base64 표현
private static final byte[] CIPHER_BYTES = new byte[]{0x10, 0x20, 0x30, 0x40};
private static final String ENC_BASE64 = Base64.getEncoder().encodeToString(CIPHER_BYTES);
// 기본 httpHeaderGroup 헤더 JSON (groupSeq|empNo 형태)
private static final String HEADER_JSON_WITH_PIPE = "{\"x-emp-nm\":\"G001|E001\"}";
private static final String HEADER_JSON_WITHOUT_PIPE = "{\"x-emp-nm\":\"G001\"}";
private static GenericApplicationContext ctx;
private static CryptoModuleService mockCryptoService;
private DJBErpCryptoFilter filter;
private HttpServletRequest mockRequest;
private Properties prop;
// =========================================================================
// 클래스 초기화 Spring ApplicationContext + Mock CryptoModuleService
// =========================================================================
@BeforeAll
static void setUpClass() throws Exception {
mockCryptoService = mock(CryptoModuleService.class);
ctx = new GenericApplicationContext();
ctx.getBeanFactory().registerSingleton("cryptoModuleService", mockCryptoService);
ctx.registerBeanDefinition("applicationContextProvider",
BeanDefinitionBuilder.genericBeanDefinition(ApplicationContextProvider.class)
.getBeanDefinition());
ctx.refresh();
when(mockCryptoService.decrypt(anyString(), anyMap(), any(byte[].class)))
.thenReturn(PLAIN_BYTES);
when(mockCryptoService.encrypt(anyString(), anyMap(), any(byte[].class)))
.thenReturn(CIPHER_BYTES);
}
@AfterAll
static void tearDownClass() {
if (ctx != null) ctx.close();
}
@BeforeEach
void setUp() {
clearInvocations(mockCryptoService); // 이전 테스트의 호출 이력 초기화 (stubbing은 유지)
filter = new DJBErpCryptoFilter();
mockRequest = mock(HttpServletRequest.class);
prop = new Properties();
prop.setProperty(DJBErpCryptoFilter.PROP_MODULE_NAME, MODULE_NAME);
}
// =========================================================================
// 1. buildRuntimeContext
// =========================================================================
@Test
@DisplayName("1-1. x-emp-nm이 'groupSeq|empNo' 형태이면 '|' 앞부분만 groupSeq로 추출")
void buildRuntimeContext_pipeFormat_extractsGroupSeqOnly() {
when(mockRequest.getHeader("httpHeaderGroup")).thenReturn(HEADER_JSON_WITH_PIPE);
Map<String, String> runtimeCtx = filter.buildRuntimeContext(prop, mockRequest);
assertEquals("G001", runtimeCtx.get("groupSeq"));
assertEquals(1, runtimeCtx.size());
}
@Test
@DisplayName("1-2. x-emp-nm에 '|'가 없으면 전체 값을 groupSeq로 사용")
void buildRuntimeContext_noPipe_usesFullValue() {
when(mockRequest.getHeader("httpHeaderGroup")).thenReturn(HEADER_JSON_WITHOUT_PIPE);
Map<String, String> runtimeCtx = filter.buildRuntimeContext(prop, mockRequest);
assertEquals("G001", runtimeCtx.get("groupSeq"));
}
@Test
@DisplayName("1-3. httpHeaderGroup 헤더가 없으면 빈 Map 반환")
void buildRuntimeContext_headerMissing_returnsEmptyMap() {
when(mockRequest.getHeader("httpHeaderGroup")).thenReturn(null);
Map<String, String> runtimeCtx = filter.buildRuntimeContext(prop, mockRequest);
assertTrue(runtimeCtx.isEmpty());
}
@Test
@DisplayName("1-4. 헤더 JSON에 x-emp-nm 필드가 없으면 빈 Map 반환")
void buildRuntimeContext_fieldMissingInJson_returnsEmptyMap() {
when(mockRequest.getHeader("httpHeaderGroup")).thenReturn("{\"other-field\":\"value\"}");
Map<String, String> runtimeCtx = filter.buildRuntimeContext(prop, mockRequest);
assertTrue(runtimeCtx.isEmpty());
}
@Test
@DisplayName("1-5. 프로퍼티로 헤더명/필드명/컨텍스트키를 커스터마이징할 수 있다")
void buildRuntimeContext_customProps_overrideDefaults() {
prop.setProperty(DJBErpCryptoFilter.PROP_CONTEXT_HEADER, "X-Custom-Header");
prop.setProperty(DJBErpCryptoFilter.PROP_CONTEXT_HEADER_FIELD, "emp-id");
prop.setProperty(DJBErpCryptoFilter.PROP_CONTEXT_KEY, "empGroup");
when(mockRequest.getHeader("X-Custom-Header")).thenReturn("{\"emp-id\":\"GRP99|EMP99\"}");
Map<String, String> runtimeCtx = filter.buildRuntimeContext(prop, mockRequest);
assertEquals("GRP99", runtimeCtx.get("empGroup"));
}
// =========================================================================
// 2. doPreFilter 복호화
// =========================================================================
@Test
@DisplayName("2-1. crypto.dec.enabled=N 이면 message를 그대로 반환하고 복호화하지 않는다")
void doPreFilter_decDisabled_returnsOriginalWithoutDecrypt() throws Exception {
prop.setProperty("crypto.dec.enabled", "N");
String original = "{\"encryptedData\":\"" + ENC_BASE64 + "\"}";
Object result = filter.doPreFilter(null, null, original, prop, mockRequest, null);
assertSame(original, result);
verifyNoInteractions(mockCryptoService);
}
@Test
@DisplayName("2-2. FIELD scope: /encryptedData 복호화 후 dec.to.path=/ 이면 body 전체를 평문으로 교체")
void doPreFilter_fieldScope_toRoot_replacesEntireBody() throws Exception {
setFieldDecryptProps("/encryptedData", "/");
when(mockRequest.getHeader("httpHeaderGroup")).thenReturn(HEADER_JSON_WITH_PIPE);
String body = "{\"encryptedData\":\"" + ENC_BASE64 + "\"}";
Object result = filter.doPreFilter(null, null, body, prop, mockRequest, null);
assertEquals(PLAIN_TEXT, result);
}
@Test
@DisplayName("2-3. FIELD scope: dec.to.path가 특정 경로이면 해당 필드에 복호화 결과를 설정")
void doPreFilter_fieldScope_toSpecificPath_setsFieldInBody() throws Exception {
setFieldDecryptProps("/encryptedData", "/plainData");
when(mockRequest.getHeader("httpHeaderGroup")).thenReturn(HEADER_JSON_WITH_PIPE);
String body = "{\"encryptedData\":\"" + ENC_BASE64 + "\"}";
String result = (String) filter.doPreFilter(null, null, body, prop, mockRequest, null);
assertTrue(result.contains("\"encryptedData\""), "원본 필드가 유지되어야 한다");
assertTrue(result.contains("\"plainData\""), "복호화 결과 필드가 추가되어야 한다");
}
@Test
@DisplayName("2-4. FIELD scope: 복호화 대상 필드가 JSON에 없으면 원본 body를 그대로 반환")
void doPreFilter_fieldScope_missingEncryptedField_returnsOriginalBody() throws Exception {
setFieldDecryptProps("/encryptedData", "/");
when(mockRequest.getHeader("httpHeaderGroup")).thenReturn(HEADER_JSON_WITH_PIPE);
String body = "{\"otherField\":\"value\"}";
Object result = filter.doPreFilter(null, null, body, prop, mockRequest, null);
assertEquals(body, result);
}
@Test
@DisplayName("2-5. BODY scope: message가 Base64 String이면 전체 복호화")
void doPreFilter_bodyScope_stringMessage_decryptsWholeBody() throws Exception {
prop.setProperty("crypto.scope", "BODY");
Object result = filter.doPreFilter(null, null, ENC_BASE64, prop, mockRequest, null);
assertEquals(PLAIN_TEXT, result);
}
@Test
@DisplayName("2-6. message가 byte[]이면 UTF-8 변환 후 FIELD 복호화 처리")
void doPreFilter_fieldScope_byteArrayMessage_convertsAndDecrypts() throws Exception {
setFieldDecryptProps("/encryptedData", "/");
when(mockRequest.getHeader("httpHeaderGroup")).thenReturn(HEADER_JSON_WITH_PIPE);
byte[] bodyBytes = ("{\"encryptedData\":\"" + ENC_BASE64 + "\"}").getBytes(StandardCharsets.UTF_8);
Object result = filter.doPreFilter(null, null, bodyBytes, prop, mockRequest, null);
assertEquals(PLAIN_TEXT, result);
}
@SuppressWarnings("unchecked")
@Test
@DisplayName("2-7. message가 JSONObject이면 toString() 변환 후 FIELD 복호화 처리")
void doPreFilter_fieldScope_jsonObjectMessage_convertsAndDecrypts() throws Exception {
setFieldDecryptProps("/encryptedData", "/");
when(mockRequest.getHeader("httpHeaderGroup")).thenReturn(HEADER_JSON_WITH_PIPE);
JSONObject jsonMsg = new JSONObject();
jsonMsg.put("encryptedData", ENC_BASE64);
Object result = filter.doPreFilter(null, null, jsonMsg, prop, mockRequest, null);
assertEquals(PLAIN_TEXT, result);
}
@SuppressWarnings("unchecked")
@Test
@DisplayName("2-8. FIELD scope: runtimeContext에 groupSeq가 올바르게 전달된다")
void doPreFilter_fieldScope_runtimeContextPassedToDecrypt() throws Exception {
setFieldDecryptProps("/encryptedData", "/");
when(mockRequest.getHeader("httpHeaderGroup")).thenReturn(HEADER_JSON_WITH_PIPE);
String body = "{\"encryptedData\":\"" + ENC_BASE64 + "\"}";
filter.doPreFilter(null, null, body, prop, mockRequest, null);
ArgumentCaptor<Map> ctxCaptor = ArgumentCaptor.forClass(Map.class);
verify(mockCryptoService).decrypt(eq(MODULE_NAME), ctxCaptor.capture(), any(byte[].class));
assertEquals("G001", ctxCaptor.getValue().get("groupSeq"));
}
// =========================================================================
// 3. doPostFilter 암호화
// =========================================================================
@Test
@DisplayName("3-1. crypto.enc.enabled 기본값(N) — resultMessage를 그대로 반환하고 암호화하지 않는다")
void doPostFilter_encDisabledByDefault_returnsOriginalWithoutEncrypt() throws Exception {
String original = "{\"result\":\"ok\"}";
Object result = filter.doPostFilter(null, null, original, prop, mockRequest, null);
assertSame(original, result);
verifyNoInteractions(mockCryptoService);
}
@Test
@DisplayName("3-2. BODY scope, enc.enabled=Y — body 전체를 암호화하여 Base64 반환")
void doPostFilter_bodyScope_encEnabled_returnsBase64() throws Exception {
prop.setProperty("crypto.scope", "BODY");
prop.setProperty("crypto.enc.enabled", "Y");
Object result = filter.doPostFilter(null, null, PLAIN_TEXT, prop, mockRequest, null);
assertEquals(ENC_BASE64, result);
}
@Test
@DisplayName("3-3. FIELD scope, enc.from.path=/ — body 전체 암호화 후 enc.to.path 필드로 래핑")
void doPostFilter_fieldScope_fromRoot_wrapsEncryptedInJson() throws Exception {
prop.setProperty("crypto.scope", "FIELD");
prop.setProperty("crypto.enc.enabled", "Y");
prop.setProperty("crypto.enc.from.path", "/");
prop.setProperty("crypto.enc.to.path", "/encryptedData");
Object result = filter.doPostFilter(null, null, PLAIN_TEXT, prop, mockRequest, null);
assertEquals("{\"encryptedData\":\"" + ENC_BASE64 + "\"}", result);
}
@SuppressWarnings("unchecked")
@Test
@DisplayName("3-4. FIELD scope: runtimeContext에 groupSeq가 올바르게 전달된다")
void doPostFilter_fieldScope_runtimeContextPassedToEncrypt() throws Exception {
prop.setProperty("crypto.scope", "FIELD");
prop.setProperty("crypto.enc.enabled", "Y");
prop.setProperty("crypto.enc.from.path", "/");
prop.setProperty("crypto.enc.to.path", "/encryptedData");
when(mockRequest.getHeader("httpHeaderGroup")).thenReturn(HEADER_JSON_WITH_PIPE);
filter.doPostFilter(null, null, PLAIN_TEXT, prop, mockRequest, null);
ArgumentCaptor<Map> ctxCaptor = ArgumentCaptor.forClass(Map.class);
verify(mockCryptoService).encrypt(eq(MODULE_NAME), ctxCaptor.capture(), any(byte[].class));
assertEquals("G001", ctxCaptor.getValue().get("groupSeq"));
}
// =========================================================================
// 헬퍼
// =========================================================================
private void setFieldDecryptProps(String fromPath, String toPath) {
prop.setProperty("crypto.scope", "FIELD");
prop.setProperty("crypto.dec.from.path", fromPath);
prop.setProperty("crypto.dec.to.path", toPath);
}
}
@@ -0,0 +1,239 @@
package com.eactive.eai.custom.inbound.processor;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.test.util.ReflectionTestUtils;
import com.eactive.eai.common.inflow.Bucket;
import com.eactive.eai.common.inflow.InflowTargetVO;
import com.eactive.eai.common.inflow.dual.ClientDualBucket;
import com.eactive.eai.common.inflow.dual.DualBucket;
import com.eactive.eai.common.inflow.dual.DualCustomBucket;
import com.eactive.eai.common.server.EAIServerManager;
import com.eactive.eai.common.util.ApplicationContextProvider;
/**
* DJBRequestProcessor 단위 테스트.
*
* <p>RequestProcessor 클래스는 static 초기화 블록에서 EAIServerManager.getInstance() 호출한다.
* @BeforeAll에서 mock ApplicationContext를 주입한 DJBRequestProcessor를 최초 로딩시킨다.
*
* <p>주의: DJBRequestProcessor를 필드 타입으로 선언하면 테스트 클래스 로딩 함께 로딩되어
* @BeforeAll 실행 전에 NPE가 발생한다. 반드시 메서드 본문 내에서만 참조해야 한다.
*/
class DJBRequestProcessorTest {
@BeforeAll
static void setupMockApplicationContext() {
ApplicationContext mockContext = mock(ApplicationContext.class);
EAIServerManager mockServerManager = mock(EAIServerManager.class);
when(mockContext.getBean(EAIServerManager.class)).thenReturn(mockServerManager);
when(mockServerManager.getLocalServerName()).thenReturn("TEST-SERVER");
when(mockServerManager.getGroupInstId()).thenReturn("TEST-INST");
ReflectionTestUtils.setField(ApplicationContextProvider.class, "context", mockContext);
}
private InflowTargetVO makeVO(String name, long perSec, long threshold, String unit) {
InflowTargetVO vo = new InflowTargetVO();
vo.setName(name);
vo.setThresholdPerSecond(perSec);
vo.setThreshold(threshold);
vo.setThresholdTimeUnit(unit);
vo.setActivate(true);
return vo;
}
// -------------------------------------------------------------------------
// checkAdapterInflow
// -------------------------------------------------------------------------
@Test
void checkAdapterInflow_dualBucket_pass_returnsNull() {
DJBRequestProcessor processor = new DJBRequestProcessor();
DualBucket mockBucket = mock(DualBucket.class);
when(mockBucket.isAdapterPassDetail("ADAPTER_A")).thenReturn(null);
assertNull(processor.checkAdapterInflow(mockBucket, "ADAPTER_A"));
verify(mockBucket).isAdapterPassDetail("ADAPTER_A");
}
@Test
void checkAdapterInflow_dualBucket_blockedPerSecond() {
DJBRequestProcessor processor = new DJBRequestProcessor();
DualBucket mockBucket = mock(DualBucket.class);
when(mockBucket.isAdapterPassDetail("ADAPTER_A")).thenReturn(DualCustomBucket.RESULT_BLOCKED_PER_SECOND);
assertEquals(DualCustomBucket.RESULT_BLOCKED_PER_SECOND,
processor.checkAdapterInflow(mockBucket, "ADAPTER_A"));
}
@Test
void checkAdapterInflow_dualBucket_blockedThreshold() {
DJBRequestProcessor processor = new DJBRequestProcessor();
DualBucket mockBucket = mock(DualBucket.class);
when(mockBucket.isAdapterPassDetail("ADAPTER_A")).thenReturn(DualCustomBucket.RESULT_BLOCKED_THRESHOLD);
assertEquals(DualCustomBucket.RESULT_BLOCKED_THRESHOLD,
processor.checkAdapterInflow(mockBucket, "ADAPTER_A"));
}
@Test
void checkAdapterInflow_nonDualBucket_pass_returnsNull() {
DJBRequestProcessor processor = new DJBRequestProcessor();
Bucket mockBucket = mock(Bucket.class);
when(mockBucket.isAdapterPass("ADAPTER_A")).thenReturn(true);
assertNull(processor.checkAdapterInflow(mockBucket, "ADAPTER_A"));
}
@Test
void checkAdapterInflow_nonDualBucket_blocked_returnsBlocked() {
DJBRequestProcessor processor = new DJBRequestProcessor();
Bucket mockBucket = mock(Bucket.class);
when(mockBucket.isAdapterPass("ADAPTER_A")).thenReturn(false);
assertEquals("BLOCKED", processor.checkAdapterInflow(mockBucket, "ADAPTER_A"));
}
// -------------------------------------------------------------------------
// checkInterfaceInflow
// -------------------------------------------------------------------------
@Test
void checkInterfaceInflow_dualBucket_pass_returnsNull() {
DJBRequestProcessor processor = new DJBRequestProcessor();
DualBucket mockBucket = mock(DualBucket.class);
when(mockBucket.isInterfacePassDetail("IF_001")).thenReturn(null);
assertNull(processor.checkInterfaceInflow(mockBucket, "IF_001"));
verify(mockBucket).isInterfacePassDetail("IF_001");
}
@Test
void checkInterfaceInflow_dualBucket_blockedPerSecond() {
DJBRequestProcessor processor = new DJBRequestProcessor();
DualBucket mockBucket = mock(DualBucket.class);
when(mockBucket.isInterfacePassDetail("IF_001")).thenReturn(DualCustomBucket.RESULT_BLOCKED_PER_SECOND);
assertEquals(DualCustomBucket.RESULT_BLOCKED_PER_SECOND,
processor.checkInterfaceInflow(mockBucket, "IF_001"));
}
@Test
void checkInterfaceInflow_nonDualBucket_pass_returnsNull() {
DJBRequestProcessor processor = new DJBRequestProcessor();
Bucket mockBucket = mock(Bucket.class);
when(mockBucket.isInterfacePass("IF_001")).thenReturn(true);
assertNull(processor.checkInterfaceInflow(mockBucket, "IF_001"));
}
@Test
void checkInterfaceInflow_nonDualBucket_blocked_returnsBlocked() {
DJBRequestProcessor processor = new DJBRequestProcessor();
Bucket mockBucket = mock(Bucket.class);
when(mockBucket.isInterfacePass("IF_001")).thenReturn(false);
assertEquals("BLOCKED", processor.checkInterfaceInflow(mockBucket, "IF_001"));
}
// -------------------------------------------------------------------------
// checkClientInflow ClientDualBucket 기반
// -------------------------------------------------------------------------
@Test
void checkClientInflow_clientDualBucket_pass_returnsNull() {
DJBRequestProcessor processor = new DJBRequestProcessor();
ClientDualBucket mockBucket = mock(ClientDualBucket.class);
when(mockBucket.isClientPassDetail("CLIENT_A")).thenReturn(null);
assertNull(processor.checkClientInflow(mockBucket, "CLIENT_A"));
verify(mockBucket).isClientPassDetail("CLIENT_A");
}
@Test
void checkClientInflow_clientDualBucket_blocked() {
DJBRequestProcessor processor = new DJBRequestProcessor();
ClientDualBucket mockBucket = mock(ClientDualBucket.class);
when(mockBucket.isClientPassDetail("CLIENT_A")).thenReturn(DualCustomBucket.RESULT_BLOCKED_THRESHOLD);
assertEquals(DualCustomBucket.RESULT_BLOCKED_THRESHOLD,
processor.checkClientInflow(mockBucket, "CLIENT_A"));
}
@Test
void checkClientInflow_nonClientDualBucket_returnsNull() {
DJBRequestProcessor processor = new DJBRequestProcessor();
Bucket mockBucket = mock(Bucket.class);
assertNull(processor.checkClientInflow(mockBucket, "CLIENT_A"));
}
@Test
void checkClientInflow_blankClientId_returnsNull() {
DJBRequestProcessor processor = new DJBRequestProcessor();
ClientDualBucket mockBucket = mock(ClientDualBucket.class);
assertNull(processor.checkClientInflow(mockBucket, ""));
verify(mockBucket, never()).isClientPassDetail(any());
}
// -------------------------------------------------------------------------
// buildInflowTargetErrorMsg
// -------------------------------------------------------------------------
@Test
void buildInflowTargetErrorMsg_perSecond_includesReqPerSec() {
DJBRequestProcessor processor = new DJBRequestProcessor();
InflowTargetVO vo = makeVO("결제API", 30, 1000, "MIN");
String msg = processor.buildInflowTargetErrorMsg(vo, DualCustomBucket.RESULT_BLOCKED_PER_SECOND);
assertEquals("API 호출 한도 초과 [결제API: 30req/sec]", msg);
}
@Test
void buildInflowTargetErrorMsg_threshold_includesReqPerUnit() {
DJBRequestProcessor processor = new DJBRequestProcessor();
InflowTargetVO vo = makeVO("결제API", 30, 1000, "MIN");
String msg = processor.buildInflowTargetErrorMsg(vo, DualCustomBucket.RESULT_BLOCKED_THRESHOLD);
assertEquals("API 호출 한도 초과 [결제API: 1000req/MIN]", msg);
}
@Test
void buildInflowTargetErrorMsg_blockedFallback_simpleFormat() {
DJBRequestProcessor processor = new DJBRequestProcessor();
InflowTargetVO vo = makeVO("결제API", 30, 1000, "MIN");
String msg = processor.buildInflowTargetErrorMsg(vo, "BLOCKED");
assertEquals("API 호출 한도 초과 [결제API]", msg);
}
@Test
void buildInflowTargetErrorMsg_nullBlockedType_simpleFormat() {
DJBRequestProcessor processor = new DJBRequestProcessor();
InflowTargetVO vo = makeVO("결제API", 30, 1000, "MIN");
String msg = processor.buildInflowTargetErrorMsg(vo, null);
assertEquals("API 호출 한도 초과 [결제API]", msg);
}
@Test
void buildInflowTargetErrorMsg_hourUnit() {
DJBRequestProcessor processor = new DJBRequestProcessor();
InflowTargetVO vo = makeVO("조회API", 10, 500, "HOUR");
String msg = processor.buildInflowTargetErrorMsg(vo, DualCustomBucket.RESULT_BLOCKED_THRESHOLD);
assertEquals("API 호출 한도 초과 [조회API: 500req/HOUR]", msg);
}
}
@@ -0,0 +1,106 @@
package com.eactive.eai.custom.inflow;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.http.ResponseEntity;
import org.springframework.test.util.ReflectionTestUtils;
import com.eactive.eai.manage.inflow.TargetBucketStatusDTO;
/**
* ClientInflowTargetBucketController 단위 테스트.
*/
class ClientInflowTargetBucketControllerTest {
private ClientInflowTargetBucketController controller;
private ClientInflowTargetBucketService mockService;
@BeforeEach
void setUp() {
controller = new ClientInflowTargetBucketController();
mockService = mock(ClientInflowTargetBucketService.class);
ReflectionTestUtils.setField(controller, "bucketService", mockService);
}
private TargetBucketStatusDTO makeDTO(String id, String type) {
TargetBucketStatusDTO dto = new TargetBucketStatusDTO();
dto.setTargetId(id);
dto.setTargetType(type);
dto.setActivate(true);
dto.setBuckets(Collections.emptyList());
return dto;
}
@SuppressWarnings("unchecked")
private Map<String, Object> body(ResponseEntity<?> response) {
return (Map<String, Object>) response.getBody();
}
// =========================================================================
// 단일 조회
// =========================================================================
@Test
void getClientBucketStatus_found_successTrueAndDataPresent() {
TargetBucketStatusDTO dto = makeDTO("CLIENT_A", "CLIENT");
when(mockService.getClientBucketStatus("CLIENT_A")).thenReturn(dto);
ResponseEntity<?> response = controller.getClientBucketStatus("CLIENT_A");
Map<String, Object> body = body(response);
assertEquals(200, response.getStatusCodeValue());
assertEquals(Boolean.TRUE, body.get("success"));
assertSame(dto, body.get("data"));
assertFalse(body.containsKey("message"));
}
@Test
void getClientBucketStatus_notFound_successFalseWithClientId() {
when(mockService.getClientBucketStatus("CLIENT_X")).thenReturn(null);
ResponseEntity<?> response = controller.getClientBucketStatus("CLIENT_X");
Map<String, Object> body = body(response);
assertEquals(Boolean.FALSE, body.get("success"));
assertTrue(body.get("message").toString().contains("CLIENT_X"));
}
// =========================================================================
// 전체 조회
// =========================================================================
@Test
void getAllClientBucketStatus_returnsListAndCount() {
List<TargetBucketStatusDTO> list = Arrays.asList(
makeDTO("CLIENT_A", "CLIENT"),
makeDTO("CLIENT_B", "CLIENT"),
makeDTO("CLIENT_C", "CLIENT")
);
when(mockService.getAllClientBucketStatus()).thenReturn(list);
ResponseEntity<?> response = controller.getAllClientBucketStatus();
Map<String, Object> body = body(response);
assertEquals(Boolean.TRUE, body.get("success"));
assertSame(list, body.get("data"));
assertEquals(3, body.get("count"));
}
@Test
void getAllClientBucketStatus_emptyList_countZero() {
when(mockService.getAllClientBucketStatus()).thenReturn(Collections.emptyList());
Map<String, Object> body = body(controller.getAllClientBucketStatus());
assertEquals(Boolean.TRUE, body.get("success"));
assertEquals(0, body.get("count"));
}
}
@@ -0,0 +1,208 @@
package com.eactive.eai.custom.inflow;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
import java.time.Duration;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.junit.jupiter.api.Test;
import com.eactive.eai.common.inflow.InflowTargetVO;
import com.eactive.eai.common.inflow.dual.ClientDualInflowControlManager;
import com.eactive.eai.common.inflow.dual.DualCustomBucket;
import com.eactive.eai.manage.inflow.GroupBucketStatusDTO;
import com.eactive.eai.manage.inflow.TargetBucketStatusDTO;
import io.github.bucket4j.Bandwidth;
import io.github.bucket4j.Bucket4j;
import io.github.bucket4j.local.LocalBucket;
/**
* ClientInflowTargetBucketService 단위 테스트.
*/
class ClientInflowTargetBucketServiceTest {
// -------------------------------------------------------------------------
// 테스트용 서브클래스
// -------------------------------------------------------------------------
private static ClientInflowTargetBucketService serviceWith(ClientDualInflowControlManager manager) {
return new ClientInflowTargetBucketService() {
@Override
protected ClientDualInflowControlManager getClientDualManager() { return manager; }
};
}
// -------------------------------------------------------------------------
// Helpers
// -------------------------------------------------------------------------
private InflowTargetVO makeVO(String name, long perSec, long threshold, String unit, boolean activate) {
InflowTargetVO vo = new InflowTargetVO();
vo.setName(name);
vo.setThresholdPerSecond(perSec);
vo.setThreshold(threshold);
vo.setThresholdTimeUnit(unit);
vo.setActivate(activate);
return vo;
}
private LocalBucket freshBucket(long capacity) {
return Bucket4j.builder()
.addLimit(Bandwidth.simple(capacity, Duration.ofSeconds(1)))
.build();
}
private LocalBucket exhaustedBucket(long capacity) {
LocalBucket b = freshBucket(capacity);
b.tryConsume(capacity);
return b;
}
private DualCustomBucket makeDualBucket(String name, long perSec, long threshold) {
return new DualCustomBucket(freshBucket(perSec), freshBucket(threshold),
makeVO(name, perSec, threshold, "DAY", true));
}
// =========================================================================
// ClientDualManager null (비활성 환경)
// =========================================================================
@Test
void getClientBucketStatus_managerIsNull_returnsNull() {
assertNull(serviceWith(null).getClientBucketStatus("CLIENT_A"));
}
@Test
void getAllClientBucketStatus_managerIsNull_returnsEmptyList() {
assertTrue(serviceWith(null).getAllClientBucketStatus().isEmpty());
}
// =========================================================================
// 버킷 미존재
// =========================================================================
@Test
void getClientBucketStatus_notFound_returnsNull() {
ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
when(manager.getClientBucket("CLIENT_A")).thenReturn(null);
assertNull(serviceWith(manager).getClientBucketStatus("CLIENT_A"));
}
// =========================================================================
// 단일 조회 targetType, targetId 매핑
// =========================================================================
@Test
void getClientBucketStatus_found_mapsClientType() {
ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
when(manager.getClientBucket("CLIENT_A")).thenReturn(makeDualBucket("CLIENT_A", 50, 5000));
TargetBucketStatusDTO dto = serviceWith(manager).getClientBucketStatus("CLIENT_A");
assertNotNull(dto);
assertEquals("CLIENT_A", dto.getTargetId());
assertEquals("CLIENT", dto.getTargetType());
assertTrue(dto.isActivate());
assertEquals(2, dto.getBuckets().size());
}
// =========================================================================
// BucketInfo 타입별 포함 여부
// =========================================================================
@Test
void toDto_onlyThreshold_bucketInfoHasOneThresholdEntry() {
InflowTargetVO vo = makeVO("C1", 0, 1000, "DAY", true);
DualCustomBucket bucket = new DualCustomBucket(null, freshBucket(1000), vo);
ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
when(manager.getClientBucket("C1")).thenReturn(bucket);
TargetBucketStatusDTO dto = serviceWith(manager).getClientBucketStatus("C1");
assertEquals(1, dto.getBuckets().size());
assertEquals("threshold", dto.getBuckets().get(0).getType());
}
@Test
void toDto_onlyPerSecond_bucketInfoHasOnePerSecondEntry() {
InflowTargetVO vo = makeVO("C2", 100, 0, null, true);
DualCustomBucket bucket = new DualCustomBucket(freshBucket(100), null, vo);
ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
when(manager.getClientBucket("C2")).thenReturn(bucket);
TargetBucketStatusDTO dto = serviceWith(manager).getClientBucketStatus("C2");
assertEquals(1, dto.getBuckets().size());
assertEquals("perSecond", dto.getBuckets().get(0).getType());
}
@Test
void toDto_bothBuckets_bucketInfoHasTwoEntries() {
ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
when(manager.getClientBucket("C3")).thenReturn(makeDualBucket("C3", 100, 5000));
TargetBucketStatusDTO dto = serviceWith(manager).getClientBucketStatus("C3");
assertEquals(2, dto.getBuckets().size());
assertEquals("perSecond", dto.getBuckets().get(0).getType());
assertEquals("threshold", dto.getBuckets().get(1).getType());
}
// =========================================================================
// 사용률 계산
// =========================================================================
@Test
void toDto_exhaustedThreshold_usagePercentIs100() {
InflowTargetVO vo = makeVO("C4", 0, 100, "DAY", true);
DualCustomBucket bucket = new DualCustomBucket(null, exhaustedBucket(100), vo);
ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
when(manager.getClientBucket("C4")).thenReturn(bucket);
TargetBucketStatusDTO dto = serviceWith(manager).getClientBucketStatus("C4");
GroupBucketStatusDTO.BucketInfo info = dto.getBuckets().get(0);
assertEquals(0, info.getAvailableTokens());
assertEquals(100.0, info.getUsagePercent(), 0.01);
}
@Test
void toDto_freshBucket_usagePercentIsZero() {
InflowTargetVO vo = makeVO("C5", 0, 100, "DAY", true);
DualCustomBucket bucket = new DualCustomBucket(null, freshBucket(100), vo);
ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
when(manager.getClientBucket("C5")).thenReturn(bucket);
TargetBucketStatusDTO dto = serviceWith(manager).getClientBucketStatus("C5");
GroupBucketStatusDTO.BucketInfo info = dto.getBuckets().get(0);
assertEquals(100, info.getAvailableTokens());
assertEquals(0.0, info.getUsagePercent(), 0.01);
}
// =========================================================================
// 전체 목록 조회
// =========================================================================
@Test
void getAllClientBucketStatus_twoEntries_returnsBoth() {
ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
Map<String, DualCustomBucket> map = new ConcurrentHashMap<>();
map.put("CLIENT_A", makeDualBucket("CLIENT_A", 10, 1000));
map.put("CLIENT_B", makeDualBucket("CLIENT_B", 20, 2000));
when(manager.getClientBucketMap()).thenReturn(map);
List<TargetBucketStatusDTO> result = serviceWith(manager).getAllClientBucketStatus();
assertEquals(2, result.size());
}
}
@@ -0,0 +1,144 @@
package com.eactive.eai.custom.inflow;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.http.ResponseEntity;
import org.springframework.test.util.ReflectionTestUtils;
import com.eactive.eai.manage.inflow.TargetMetricDTO;
/**
* ClientInflowTargetMetricController 단위 테스트.
*
* <p>Spring MVC를 기동하지 않고 컨트롤러를 직접 인스턴스화하여
* 응답 구조(success, data, count, message) 검증한다.
*/
class ClientInflowTargetMetricControllerTest {
private ClientInflowTargetMetricController controller;
private ClientInflowTargetMetricService mockService;
@BeforeEach
void setUp() {
controller = new ClientInflowTargetMetricController();
mockService = mock(ClientInflowTargetMetricService.class);
ReflectionTestUtils.setField(controller, "metricService", mockService);
}
private TargetMetricDTO makeDTO(String targetId, String targetType,
long allowed, long rejPs, long rejTh) {
TargetMetricDTO dto = new TargetMetricDTO();
dto.setTargetId(targetId);
dto.setTargetType(targetType);
dto.setActivate(true);
dto.setAllowed(allowed);
dto.setRejectedPerSecond(rejPs);
dto.setRejectedThreshold(rejTh);
long total = allowed + rejPs + rejTh;
dto.setTotalRequests(total);
dto.setRejectRatio(total > 0 ? (double)(rejPs + rejTh) / total * 100 : 0.0);
return dto;
}
@SuppressWarnings("unchecked")
private Map<String, Object> body(ResponseEntity<?> response) {
return (Map<String, Object>) response.getBody();
}
// =========================================================================
// 단일 조회
// =========================================================================
@Test
void getClientMetric_found_successTrueAndDataPresent() {
TargetMetricDTO dto = makeDTO("C1", "CLIENT", 300, 50, 20);
when(mockService.getClientMetric("C1")).thenReturn(dto);
Map<String, Object> body = body(controller.getClientMetric("C1"));
assertEquals(Boolean.TRUE, body.get("success"));
assertSame(dto, body.get("data"));
assertFalse(body.containsKey("message"));
}
@Test
void getClientMetric_notFound_successFalseWithMessage() {
when(mockService.getClientMetric("GHOST")).thenReturn(null);
Map<String, Object> body = body(controller.getClientMetric("GHOST"));
assertEquals(Boolean.FALSE, body.get("success"));
assertTrue(body.get("message").toString().contains("GHOST"));
}
// =========================================================================
// 전체 조회
// =========================================================================
@Test
void getAllClientMetrics_returnsListAndCount() {
List<TargetMetricDTO> list = Arrays.asList(
makeDTO("C1", "CLIENT", 100, 5, 5),
makeDTO("C2", "CLIENT", 200, 0, 0),
makeDTO("C3", "CLIENT", 50, 10, 0)
);
when(mockService.getAllClientMetrics()).thenReturn(list);
Map<String, Object> body = body(controller.getAllClientMetrics());
assertEquals(Boolean.TRUE, body.get("success"));
assertSame(list, body.get("data"));
assertEquals(3, body.get("count"));
}
@Test
void getAllClientMetrics_emptyList_countZero() {
when(mockService.getAllClientMetrics()).thenReturn(Collections.emptyList());
Map<String, Object> body = body(controller.getAllClientMetrics());
assertEquals(Boolean.TRUE, body.get("success"));
assertEquals(0, body.get("count"));
}
// =========================================================================
// reset
// =========================================================================
@Test
void resetClientMetric_success_successTrueWithTargetId() {
when(mockService.resetClientMetric("C1")).thenReturn(true);
Map<String, Object> body = body(controller.resetClientMetric("C1"));
assertEquals(Boolean.TRUE, body.get("success"));
assertTrue(body.get("message").toString().contains("C1"));
}
@Test
void resetClientMetric_notFound_successFalseWithTargetId() {
when(mockService.resetClientMetric("GHOST")).thenReturn(false);
Map<String, Object> body = body(controller.resetClientMetric("GHOST"));
assertEquals(Boolean.FALSE, body.get("success"));
assertTrue(body.get("message").toString().contains("GHOST"));
}
@Test
void resetAllClientMetrics_callsDelegateOnce() {
doNothing().when(mockService).resetAllClientMetrics();
controller.resetAllClientMetrics();
verify(mockService, times(1)).resetAllClientMetrics();
}
}
@@ -0,0 +1,177 @@
package com.eactive.eai.custom.inflow;
import static org.junit.jupiter.api.Assertions.*;
import static org.mockito.Mockito.*;
import java.util.List;
import org.junit.jupiter.api.Test;
import com.eactive.eai.common.inflow.InflowTargetVO;
import com.eactive.eai.common.inflow.dual.ClientDualInflowControlManager;
import com.eactive.eai.common.inflow.dual.DualInflowControlManager;
import com.eactive.eai.manage.inflow.TargetMetricDTO;
class ClientInflowTargetMetricServiceTest {
private static ClientInflowTargetMetricService serviceWith(ClientDualInflowControlManager manager) {
return new ClientInflowTargetMetricService() {
@Override
protected ClientDualInflowControlManager getClientDualManager() { return manager; }
};
}
private InflowTargetVO makeVO(String name) {
InflowTargetVO vo = new InflowTargetVO();
vo.setName(name);
vo.setActivate(true);
return vo;
}
private DualInflowControlManager.TargetMetrics makeMetrics(long allowed, long rejPs, long rejTh) {
DualInflowControlManager.TargetMetrics m = new DualInflowControlManager.TargetMetrics();
m.allowed.set(allowed);
m.rejectedPerSecond.set(rejPs);
m.rejectedThreshold.set(rejTh);
return m;
}
// =========================================================================
// null 관리자 (비활성 환경)
// =========================================================================
@Test
void getClientMetric_managerIsNull_returnsNull() {
assertNull(serviceWith(null).getClientMetric("C1"));
}
@Test
void getAllClientMetrics_managerIsNull_returnsEmptyList() {
assertTrue(serviceWith(null).getAllClientMetrics().isEmpty());
}
@Test
void resetClientMetric_managerIsNull_returnsFalse() {
assertFalse(serviceWith(null).resetClientMetric("C1"));
}
@Test
void resetAllClientMetrics_managerIsNull_noException() {
assertDoesNotThrow(() -> serviceWith(null).resetAllClientMetrics());
}
// =========================================================================
// 단일 조회
// =========================================================================
@Test
void getClientMetric_found_mapsFields() {
ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
when(manager.getClientInflowThreshold("C1")).thenReturn(makeVO("C1"));
when(manager.getClientMetrics("C1")).thenReturn(makeMetrics(200, 30, 20));
TargetMetricDTO dto = serviceWith(manager).getClientMetric("C1");
assertNotNull(dto);
assertEquals("C1", dto.getTargetId());
assertEquals("CLIENT", dto.getTargetType());
assertTrue(dto.isActivate());
assertEquals(200, dto.getAllowed());
assertEquals(30, dto.getRejectedPerSecond());
assertEquals(20, dto.getRejectedThreshold());
assertEquals(250, dto.getTotalRequests());
}
@Test
void getClientMetric_notRegistered_returnsNull() {
ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
when(manager.getClientInflowThreshold("C1")).thenReturn(null);
assertNull(serviceWith(manager).getClientMetric("C1"));
}
@Test
void getClientMetric_noMetricsYet_returnsZeroCounters() {
ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
when(manager.getClientInflowThreshold("C1")).thenReturn(makeVO("C1"));
when(manager.getClientMetrics("C1")).thenReturn(null);
TargetMetricDTO dto = serviceWith(manager).getClientMetric("C1");
assertNotNull(dto);
assertEquals(0, dto.getAllowed());
assertEquals(0, dto.getTotalRequests());
assertEquals(0.0, dto.getRejectRatio(), 0.001);
}
@Test
void getClientMetric_rejectRatioCalculation() {
ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
when(manager.getClientInflowThreshold("C1")).thenReturn(makeVO("C1"));
// allowed=90, rejPs=5, rejTh=5 reject=10/100 = 10.00%
when(manager.getClientMetrics("C1")).thenReturn(makeMetrics(90, 5, 5));
TargetMetricDTO dto = serviceWith(manager).getClientMetric("C1");
assertEquals(10.0, dto.getRejectRatio(), 0.01);
}
// =========================================================================
// 전체 조회
// =========================================================================
@Test
void getAllClientMetrics_twoEntries_returnsBoth() {
ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
java.util.Map<String, com.eactive.eai.common.inflow.dual.DualCustomBucket> bucketMap =
new java.util.LinkedHashMap<>();
bucketMap.put("C1", null);
bucketMap.put("C2", null);
when(manager.getClientBucketMap()).thenReturn(bucketMap);
when(manager.getClientInflowThreshold("C1")).thenReturn(makeVO("C1"));
when(manager.getClientInflowThreshold("C2")).thenReturn(makeVO("C2"));
when(manager.getClientMetrics("C1")).thenReturn(makeMetrics(10, 0, 0));
when(manager.getClientMetrics("C2")).thenReturn(makeMetrics(20, 5, 0));
List<TargetMetricDTO> result = serviceWith(manager).getAllClientMetrics();
assertEquals(2, result.size());
}
@Test
void getAllClientMetrics_noKeys_returnsEmptyList() {
ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
when(manager.getClientBucketMap()).thenReturn(new java.util.HashMap<>());
assertTrue(serviceWith(manager).getAllClientMetrics().isEmpty());
}
// =========================================================================
// reset
// =========================================================================
@Test
void resetClientMetric_success_returnsTrueAndCallsManager() {
ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
when(manager.getClientInflowThreshold("C1")).thenReturn(makeVO("C1"));
assertTrue(serviceWith(manager).resetClientMetric("C1"));
verify(manager).resetClientMetrics("C1");
}
@Test
void resetClientMetric_notRegistered_returnsFalseAndNoReset() {
ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
when(manager.getClientInflowThreshold("C1")).thenReturn(null);
assertFalse(serviceWith(manager).resetClientMetric("C1"));
verify(manager, never()).resetClientMetrics(any());
}
@Test
void resetAllClientMetrics_callsManager() {
ClientDualInflowControlManager manager = mock(ClientDualInflowControlManager.class);
serviceWith(manager).resetAllClientMetrics();
verify(manager).resetAllClientMetrics();
}
}
@@ -18,6 +18,7 @@ import org.springframework.test.util.ReflectionTestUtils;
*
* <p>Spring MVC를 기동하지 않고 컨트롤러를 직접 인스턴스화하여
* 응답 구조(success, data, count, message) 검증한다.
* 클라이언트 관련 테스트는 ClientInflowTargetBucketControllerTest 에서 검증한다.
*/
class InflowTargetBucketControllerTest {
@@ -148,64 +149,4 @@ class InflowTargetBucketControllerTest {
assertEquals(Boolean.TRUE, body.get("success"));
assertEquals(1, body.get("count"));
}
// =========================================================================
// 클라이언트 단일 조회
// =========================================================================
@Test
void getClientBucketStatus_found_successTrueAndDataPresent() {
TargetBucketStatusDTO dto = makeDTO("CLIENT_A", "CLIENT");
when(mockService.getClientBucketStatus("CLIENT_A")).thenReturn(dto);
ResponseEntity<?> response = controller.getClientBucketStatus("CLIENT_A");
Map<String, Object> body = body(response);
assertEquals(200, response.getStatusCodeValue());
assertEquals(Boolean.TRUE, body.get("success"));
assertSame(dto, body.get("data"));
assertFalse(body.containsKey("message"));
}
@Test
void getClientBucketStatus_notFound_successFalseWithClientId() {
when(mockService.getClientBucketStatus("CLIENT_X")).thenReturn(null);
ResponseEntity<?> response = controller.getClientBucketStatus("CLIENT_X");
Map<String, Object> body = body(response);
assertEquals(Boolean.FALSE, body.get("success"));
assertTrue(body.get("message").toString().contains("CLIENT_X"));
}
// =========================================================================
// 클라이언트 전체 조회
// =========================================================================
@Test
void getAllClientBucketStatus_returnsListAndCount() {
List<TargetBucketStatusDTO> list = Arrays.asList(
makeDTO("CLIENT_A", "CLIENT"),
makeDTO("CLIENT_B", "CLIENT"),
makeDTO("CLIENT_C", "CLIENT")
);
when(mockService.getAllClientBucketStatus()).thenReturn(list);
ResponseEntity<?> response = controller.getAllClientBucketStatus();
Map<String, Object> body = body(response);
assertEquals(Boolean.TRUE, body.get("success"));
assertSame(list, body.get("data"));
assertEquals(3, body.get("count"));
}
@Test
void getAllClientBucketStatus_emptyList_countZero() {
when(mockService.getAllClientBucketStatus()).thenReturn(Collections.emptyList());
Map<String, Object> body = body(controller.getAllClientBucketStatus());
assertEquals(Boolean.TRUE, body.get("success"));
assertEquals(0, body.get("count"));
}
}
@@ -21,8 +21,8 @@ import io.github.bucket4j.local.LocalBucket;
/**
* InflowTargetBucketService 단위 테스트.
*
* <p>getDualManager() protected로 오버라이드하는 내부 테스트 서브클래스 사용하여
* DualInflowControlManager 의존성을 주입한다.
* <p>어댑터/인터페이스: getDualManager() 오버라이드하는 서브클래스 사용.
* 클라이언트 관련 테스트는 ClientInflowTargetBucketServiceTest 에서 검증한다.
*/
class InflowTargetBucketServiceTest {
@@ -33,9 +33,7 @@ class InflowTargetBucketServiceTest {
private static InflowTargetBucketService serviceWith(DualInflowControlManager manager) {
return new InflowTargetBucketService() {
@Override
protected DualInflowControlManager getDualManager() {
return manager;
}
protected DualInflowControlManager getDualManager() { return manager; }
};
}
@@ -96,16 +94,6 @@ class InflowTargetBucketServiceTest {
assertTrue(serviceWith(null).getAllInterfaceBucketStatus().isEmpty());
}
@Test
void getClientBucketStatus_managerIsNull_returnsNull() {
assertNull(serviceWith(null).getClientBucketStatus("CLIENT_A"));
}
@Test
void getAllClientBucketStatus_managerIsNull_returnsEmptyList() {
assertTrue(serviceWith(null).getAllClientBucketStatus().isEmpty());
}
// =========================================================================
// 버킷 미존재
// =========================================================================
@@ -126,14 +114,6 @@ class InflowTargetBucketServiceTest {
assertNull(serviceWith(manager).getInterfaceBucketStatus("IF_001"));
}
@Test
void getClientBucketStatus_notFound_returnsNull() {
DualInflowControlManager manager = mock(DualInflowControlManager.class);
when(manager.getClientBucket("CLIENT_A")).thenReturn(null);
assertNull(serviceWith(manager).getClientBucketStatus("CLIENT_A"));
}
// =========================================================================
// 단일 조회 targetType, targetId 매핑
// =========================================================================
@@ -166,98 +146,10 @@ class InflowTargetBucketServiceTest {
assertEquals(2, dto.getBuckets().size());
}
@Test
void getClientBucketStatus_found_mapsClientType() {
DualInflowControlManager manager = mock(DualInflowControlManager.class);
when(manager.getClientBucket("CLIENT_A")).thenReturn(makeDualBucket("CLIENT_A", 50, 5000));
TargetBucketStatusDTO dto = serviceWith(manager).getClientBucketStatus("CLIENT_A");
assertNotNull(dto);
assertEquals("CLIENT_A", dto.getTargetId());
assertEquals("CLIENT", dto.getTargetType());
assertTrue(dto.isActivate());
assertEquals(2, dto.getBuckets().size());
}
// =========================================================================
// BucketInfo 타입별 포함 여부
// BucketInfo 용량/시간단위 매핑
// =========================================================================
@Test
void toDto_onlyThreshold_bucketInfoHasOneThresholdEntry() {
InflowTargetVO vo = makeVO("C1", 0, 1000, "DAY", true);
DualCustomBucket bucket = new DualCustomBucket(null, freshBucket(1000), vo);
DualInflowControlManager manager = mock(DualInflowControlManager.class);
when(manager.getClientBucket("C1")).thenReturn(bucket);
TargetBucketStatusDTO dto = serviceWith(manager).getClientBucketStatus("C1");
assertEquals(1, dto.getBuckets().size());
assertEquals("threshold", dto.getBuckets().get(0).getType());
}
@Test
void toDto_onlyPerSecond_bucketInfoHasOnePerSecondEntry() {
InflowTargetVO vo = makeVO("C2", 100, 0, "SEC", true);
DualCustomBucket bucket = new DualCustomBucket(freshBucket(100), null, vo);
DualInflowControlManager manager = mock(DualInflowControlManager.class);
when(manager.getClientBucket("C2")).thenReturn(bucket);
TargetBucketStatusDTO dto = serviceWith(manager).getClientBucketStatus("C2");
assertEquals(1, dto.getBuckets().size());
assertEquals("perSecond", dto.getBuckets().get(0).getType());
}
@Test
void toDto_bothBuckets_bucketInfoHasTwoEntries() {
DualInflowControlManager manager = mock(DualInflowControlManager.class);
when(manager.getClientBucket("C3")).thenReturn(makeDualBucket("C3", 100, 5000));
TargetBucketStatusDTO dto = serviceWith(manager).getClientBucketStatus("C3");
assertEquals(2, dto.getBuckets().size());
assertEquals("perSecond", dto.getBuckets().get(0).getType());
assertEquals("threshold", dto.getBuckets().get(1).getType());
}
// =========================================================================
// 사용률 계산
// =========================================================================
@Test
void toDto_exhaustedThreshold_usagePercentIs100() {
InflowTargetVO vo = makeVO("C4", 0, 100, "DAY", true);
DualCustomBucket bucket = new DualCustomBucket(null, exhaustedBucket(100), vo);
DualInflowControlManager manager = mock(DualInflowControlManager.class);
when(manager.getClientBucket("C4")).thenReturn(bucket);
TargetBucketStatusDTO dto = serviceWith(manager).getClientBucketStatus("C4");
GroupBucketStatusDTO.BucketInfo info = dto.getBuckets().get(0);
assertEquals(0, info.getAvailableTokens());
assertEquals(100.0, info.getUsagePercent(), 0.01);
}
@Test
void toDto_freshBucket_usagePercentIsZero() {
InflowTargetVO vo = makeVO("C5", 0, 100, "DAY", true);
DualCustomBucket bucket = new DualCustomBucket(null, freshBucket(100), vo);
DualInflowControlManager manager = mock(DualInflowControlManager.class);
when(manager.getClientBucket("C5")).thenReturn(bucket);
TargetBucketStatusDTO dto = serviceWith(manager).getClientBucketStatus("C5");
GroupBucketStatusDTO.BucketInfo info = dto.getBuckets().get(0);
assertEquals(100, info.getAvailableTokens());
assertEquals(0.0, info.getUsagePercent(), 0.01);
}
@Test
void toDto_capacity_perSecondBucketInfoCapacityMatchesVO() {
DualInflowControlManager manager = mock(DualInflowControlManager.class);
@@ -278,19 +170,6 @@ class InflowTargetBucketServiceTest {
// 전체 목록 조회
// =========================================================================
@Test
void getAllClientBucketStatus_twoEntries_returnsBoth() {
DualInflowControlManager manager = mock(DualInflowControlManager.class);
Map<String, DualCustomBucket> map = new ConcurrentHashMap<>();
map.put("CLIENT_A", makeDualBucket("CLIENT_A", 10, 1000));
map.put("CLIENT_B", makeDualBucket("CLIENT_B", 20, 2000));
when(manager.getClientBucketMap()).thenReturn(map);
List<TargetBucketStatusDTO> result = serviceWith(manager).getAllClientBucketStatus();
assertEquals(2, result.size());
}
@Test
void getAllAdapterBucketStatus_emptyMap_returnsEmptyList() {
DualInflowControlManager manager = mock(DualInflowControlManager.class);
@@ -210,92 +210,4 @@ class InflowTargetMetricControllerTest {
verify(mockService, times(1)).resetAllInterfaceMetrics();
}
// =========================================================================
// 클라이언트 단일 조회
// =========================================================================
@Test
void getClientMetric_found_successTrueAndDataPresent() {
TargetMetricDTO dto = makeDTO("C1", "CLIENT", 300, 50, 20);
when(mockService.getClientMetric("C1")).thenReturn(dto);
Map<String, Object> body = body(controller.getClientMetric("C1"));
assertEquals(Boolean.TRUE, body.get("success"));
assertSame(dto, body.get("data"));
}
@Test
void getClientMetric_notFound_successFalseWithMessage() {
when(mockService.getClientMetric("GHOST")).thenReturn(null);
Map<String, Object> body = body(controller.getClientMetric("GHOST"));
assertEquals(Boolean.FALSE, body.get("success"));
assertTrue(body.get("message").toString().contains("GHOST"));
}
// =========================================================================
// 클라이언트 전체 조회
// =========================================================================
@Test
void getAllClientMetrics_returnsListAndCount() {
List<TargetMetricDTO> list = Arrays.asList(
makeDTO("C1", "CLIENT", 100, 5, 5),
makeDTO("C2", "CLIENT", 200, 0, 0),
makeDTO("C3", "CLIENT", 50, 10, 0)
);
when(mockService.getAllClientMetrics()).thenReturn(list);
Map<String, Object> body = body(controller.getAllClientMetrics());
assertEquals(Boolean.TRUE, body.get("success"));
assertSame(list, body.get("data"));
assertEquals(3, body.get("count"));
}
@Test
void getAllClientMetrics_emptyList_countZero() {
when(mockService.getAllClientMetrics()).thenReturn(Collections.emptyList());
Map<String, Object> body = body(controller.getAllClientMetrics());
assertEquals(Boolean.TRUE, body.get("success"));
assertEquals(0, body.get("count"));
}
// =========================================================================
// 클라이언트 reset
// =========================================================================
@Test
void resetClientMetric_success_successTrue() {
when(mockService.resetClientMetric("C1")).thenReturn(true);
Map<String, Object> body = body(controller.resetClientMetric("C1"));
assertEquals(Boolean.TRUE, body.get("success"));
assertTrue(body.get("message").toString().contains("C1"));
}
@Test
void resetClientMetric_notFound_successFalse() {
when(mockService.resetClientMetric("GHOST")).thenReturn(false);
Map<String, Object> body = body(controller.resetClientMetric("GHOST"));
assertEquals(Boolean.FALSE, body.get("success"));
assertTrue(body.get("message").toString().contains("GHOST"));
}
@Test
void resetAllClientMetrics_callsDelegateOnce() {
doNothing().when(mockService).resetAllClientMetrics();
controller.resetAllClientMetrics();
verify(mockService, times(1)).resetAllClientMetrics();
}
}
@@ -13,12 +13,12 @@ import com.eactive.eai.common.inflow.dual.DualInflowControlManager;
/**
* InflowTargetMetricService 단위 테스트.
*
* <p>getDualManager() 오버라이드하여 DualInflowControlManager 의존성을 주입한다.
* <p>어댑터/인터페이스 테스트는 getDualManager() 오버라이드하여 DualInflowControlManager 주입.
*/
class InflowTargetMetricServiceTest {
// -------------------------------------------------------------------------
// 테스트용 서브클래스
// 테스트용 서브클래스 어댑터/인터페이스용
// -------------------------------------------------------------------------
private static InflowTargetMetricService serviceWith(DualInflowControlManager manager) {
@@ -76,11 +76,6 @@ class InflowTargetMetricServiceTest {
assertNull(serviceWith(null).getInterfaceMetric("IF1"));
}
@Test
void getClientMetric_managerIsNull_returnsNull() {
assertNull(serviceWith(null).getClientMetric("C1"));
}
// =========================================================================
// 어댑터 단일 조회
// =========================================================================
@@ -271,55 +266,4 @@ class InflowTargetMetricServiceTest {
serviceWith(manager).resetAllInterfaceMetrics();
verify(manager).resetAllInterfaceMetrics();
}
// =========================================================================
// 클라이언트 단일 조회
// =========================================================================
@Test
void getClientMetric_found_mapsFields() {
DualInflowControlManager manager = mock(DualInflowControlManager.class);
when(manager.getClientInflowThreshold("C1")).thenReturn(makeVO("C1"));
when(manager.getClientMetrics("C1")).thenReturn(makeMetrics(200, 30, 20));
TargetMetricDTO dto = serviceWith(manager).getClientMetric("C1");
assertNotNull(dto);
assertEquals("C1", dto.getTargetId());
assertEquals("CLIENT", dto.getTargetType());
assertEquals(200, dto.getAllowed());
assertEquals(250, dto.getTotalRequests());
}
@Test
void getClientMetric_notRegistered_returnsNull() {
DualInflowControlManager manager = mock(DualInflowControlManager.class);
when(manager.getClientInflowThreshold("C1")).thenReturn(null);
assertNull(serviceWith(manager).getClientMetric("C1"));
}
@Test
void resetClientMetric_success_returnsTrueAndCallsManager() {
DualInflowControlManager manager = mock(DualInflowControlManager.class);
when(manager.getClientInflowThreshold("C1")).thenReturn(makeVO("C1"));
assertTrue(serviceWith(manager).resetClientMetric("C1"));
verify(manager).resetClientMetrics("C1");
}
@Test
void resetClientMetric_notRegistered_returnsFalse() {
DualInflowControlManager manager = mock(DualInflowControlManager.class);
when(manager.getClientInflowThreshold("C1")).thenReturn(null);
assertFalse(serviceWith(manager).resetClientMetric("C1"));
}
@Test
void resetAllClientMetrics_callsManager() {
DualInflowControlManager manager = mock(DualInflowControlManager.class);
serviceWith(manager).resetAllClientMetrics();
verify(manager).resetAllClientMetrics();
}
}