Java 개발 블로그

Jenkins 빌드 후 조치 call url

lovineff — Fri, 14 Jul 2023 13:42:33 +0900

Jekins 빌드 결과에 따른 api 호출 방법을 작성했습니다.

실행시 자동 설정되는 환경변수 값을 이용했습니다.

# 잡 실행 결과 조회
BUILD_STATUS=$(curl -k --user 유저명:키 --silent http://jenkinsserver:port/job/$JOB_NAME/$BUILD_NUMBER/api/json | jq -r '.result')

# 잡 실행 결과 실패시 api호출
if [ $BUILD_STATUS != 'SUCCESS' ]
then
curl -X POST http://apiserver:8080/api/send/agit \
-H 'Content-Type: application/json' \
-d '{"type":"", "channel":"develop", "text":"#JenkinsJobFailMessage\r\n'$JOB_NAME'('$BUILD_NUMBER') '$BUILD_STATUS'\r\nhttp://jenkinsserver:port/job/'$JOB_NAME'/'$BUILD_NUMBER'/console"}'
fi

jenkins algorithm negotiation fail SSH

lovineff — Fri, 14 Jul 2023 13:34:17 +0900

Jenkins 의 publish over ssh 플러그인 사용시 algorithm negotiation fail 에러 발생에 대해 대응 방법을 설명합니다.

최신 버전의 Jenkins 사용시 Publish over SSH 사용중 에러가 발생하는데요.

이에 여러 방안을 찾았으나, 젠킨슨 깃허브에 23년 6월 말 일자로 이슈업되었고 아직 댓글로 안달린것으로 확인했습니다.

결국 답은 플러그인 버전을 낮추는 것이었네요..

결론 : 두개의 라이브러리를 다운그레이드

버전 낮추기

Publish over SSH

1.25 -> 1.24

JSch dependency

0.2.8-65.v052c39de79b_2 -> 0.1.55.61.va_e9ee26616e7

버전 낮추는 방법

아래 사이트에서 라이브러리 검색 후 설치

https://plugins.jenkins.io/

서버가 폐쇄망인 경우 위 사이트에서 라이브러리를 로컬로 다운 받아 라이브러리를 업로드하면 됩니다.

Jenkins 관리 > Plugins > Advanced settings

화면의 Deploy Plugin > 파일 선택 > Deploy

젠킨스 제거 (yum)

lovineff — Mon, 10 Jul 2023 11:36:27 +0900

# yum 패키지 제거

sudo yum -y remove jenkins

# 실행 실패해도 문제없음
sudo apt-get remove --purge jenkins

# 젠킨스 설치된 모든 파일 제거
rm -rf /var/lib/jenkins
rm -rf /root/.jenkins/

QueryDsl between

lovineff — Tue, 30 May 2023 20:02:34 +0900

QueryDsl Between 사용 방법

// 값 설정
String yyyyMMdd = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyyMMdd"));


// 다른부분 생략
jpaQueryFactory
.where(Expressions.asString(yyyyMMdd).between(entity.startDate, entity.endDate))


// 실행 결과
and ('20230530' between p010.START_DATE and p010.END_DATE)

파일 거꾸로 읽기

lovineff — Fri, 26 May 2023 10:26:00 +0900

파일을 마지막 라인부터 읽어와서 문자가 있는 라인을 추출합니다.

import org.apache.commons.io.input.ReversedLinesFileReader;
import org.junit.jupiter.api.Test;
import org.springframework.util.StringUtils;
import java.io.File;
import java.io.IOException;



String filePath = "test.log";
String lastLine = "";

// 파일을 거꾸로 읽습니다.
try (ReversedLinesFileReader reader
	= new ReversedLinesFileReader(new File(filePath))){

	// 공백, 엔터를 제외한 문자가 조회될때까지 라인을 읽습니다.
    while(!StringUtils.hasText(lastLine)){
    	lastLine = reader.readLine();
	    System.out.println("lastLine = " + lastLine);
    }
} catch (IOException e) {
	e.printStackTrace();
}

System.out.println("real lastLine = " + lastLine);

파일 압축

lovineff — Thu, 25 May 2023 10:19:58 +0900

기본 압축 방법 (압축파일내 폴더 미생성)

public void pack(List<String> zipFileList, String zipFilePath, String zipFileName) throws IOException {
        log.info("------ zip pack start ------");
        log.info("zipFileList.size() = {}", zipFileList.size());
        log.info("zipFilePath = {}", zipFilePath);
        log.info("zipFileName = {}", zipFileName);

        // 압축 파일 디렉토리 생성
        Path zipDir = Paths.get(zipFilePath);
        Files.createDirectories(zipDir);

        // 압축파일 생성
        Path p = Files.createFile(Paths.get(zipFilePath + "/" + zipFileName));
        // 압축파일내 파일 추가 작업
        try (ZipOutputStream zs = new ZipOutputStream(Files.newOutputStream(p));){
             zipFileList.forEach(filePath ->{
                 Path path = Paths.get(filePath);
                 if(!Files.isDirectory(path)){
                     log.info("to Zip file = {}", filePath);

                     // 압축파일내 파일 생성
                     // ZipEntity 내에 경로 입력시 압축해제시 경로가 그대로 생성된다.
                     ZipEntry zipEntry = new ZipEntry(path.getFileName().toString());
                     try {
                         zs.putNextEntry(zipEntry);
                         Files.copy(path, zs);
                         zs.closeEntry();
                     } catch (IOException e) {
                         System.err.println(e);
                     }
                 }
             });
        }

        log.info("------ zip file end ------");
    }

압축파일내 폴더 추가 방법

파일별 폴더 경로를 생성하기 위한 객체

@Getter
@Builder
public class ZipVO {
    private String originFileFullPath;
    private String zipInnerFolderPath;
}

압축 작업

public void packByZipVOList(List<ZipVO> zipVOList, String zipFilePath, String zipFileName) throws IOException {
        log.info("------ zip pack start ------");
        log.info("zipVOList.size() = {}", zipVOList.size());
        log.info("zipFilePath = {}", zipFilePath);
        log.info("zipFileName = {}", zipFileName);

        Path zipDir = Paths.get(zipFilePath);
        Files.createDirectories(zipDir);

        Path p = Files.createFile(Paths.get(zipFilePath + "/" + zipFileName));
        try (ZipOutputStream zs = new ZipOutputStream(Files.newOutputStream(p))){
            zipVOList.forEach(zipVO ->{
                Path path = Paths.get(zipVO.getOriginFileFullPath());
                if(!Files.isDirectory(path)){
                    log.info("to Zip file = {}", zipVO.getOriginFileFullPath());
                    ZipEntry zipEntry = new ZipEntry((StringUtils.hasText(zipVO.getZipInnerFolderPath()) ? "/" + zipVO.getZipInnerFolderPath() : "") + "/" + path.getFileName());
                    try {
                        zs.putNextEntry(zipEntry);
                        Files.copy(path, zs);
                        zs.closeEntry();
                    } catch (IOException e) {
                        System.err.println(e);
                    }
                }
            });
        }

        log.info("------ zip file end ------");
    }

테스트 코드로 실제 압축파일 생성 테스트

@Test
    void packByZipVO() throws IOException {
        String zipFilePath = "/Users/a/Downloads";
        String zipFileName = "test.zip";

        List<ZipVO> zipFileList = new ArrayList<>();
        zipFileList.add(ZipVO.builder()
                .originFileFullPath("/Users/a/Downloads/202305/202304/a.xlsx")
                .zipInnerFolderPath("202304/1")
                .build());

        zipFileList.add(ZipVO.builder()
                .originFileFullPath("/Users/a/Downloads/202305/202304/b.xlsx")
                .zipInnerFolderPath(null)
                .build());

        zipFileList.add(ZipVO.builder()
                .originFileFullPath("/Users/a/Downloads/202305/202304/c.xlsx")
                .zipInnerFolderPath("202304")
                .build());

        zipFileList.add(ZipVO.builder()
                .originFileFullPath("/Users/a/Downloads/202305/20230521/d.xlsx")
                .zipInnerFolderPath("20230521/1")
                .build());

        zipFileList.add(ZipVO.builder()
                .originFileFullPath("/Users/a/Downloads/202305/20230521/e.xlsx")
                .zipInnerFolderPath(null)
                .build());

        packByZipVOList(zipFileList, zipFilePath, zipFileName);
    }

생성 결과 (압축 해제)

동적 빈 생성

lovineff — Wed, 7 Jul 2021 17:40:44 +0900

Spring에서 제공하는 ConfigurableListableBeanFactory 클래스를 이용하여 동적으로 빈 등록이 가능하다.

동적 생성할 클래스 선언

public class DynamicClass {
	// 빈 등록시 생성자 호출여부 확인용
    public DynamicClass() {
        System.out.println("생성자 호출!");
    }

    public void func(){
        System.out.println("Test");
    }
}

테스트 코드를 통한 동적 빈 생성 및 조회

@SpringBootTest
public class DynamicClassTest {
    @Test
    void test(){
        StaticApplicationContext staticApplicationContext = new StaticApplicationContext();

        // 등록 전 빈 조회
        String[] beforeBeans = staticApplicationContext.getBeanNamesForType(DynamicClass.class);
        assertTrue(beforeBeans.length == 0);

        // 빈 등록
        ConfigurableListableBeanFactory beanFactory = staticApplicationContext.getBeanFactory();
        beanFactory.registerSingleton("dynamicClass", new DynamicClass());

        // 등록한 빈 조회 (by type)
        String[] afterBeans = staticApplicationContext.getBeanNamesForType(DynamicClass.class);
        assertTrue(afterBeans.length > 0);
        for (String beanName : afterBeans) {
            System.out.println(beanName);
        }

        // 등록한 빈 조회 (by bean name)
        Object dynamicClass = staticApplicationContext.getBean("dynamicClass");
        assertNotNull(dynamicClass);
        assertTrue(dynamicClass instanceof DynamicClass);
    }
}

실행 결과

Default Method(인터페이스 디폴트 메소드)

lovineff — Wed, 7 Jul 2021 16:25:57 +0900

추상 클래스내 함수 구현 처럼 Interface 클래스 내에 함수를 선언 및 구현할 수 있도록 한다.

Interface 구현 클래스에서 Override 할 수 있다.

왜? 나왔을까?

"하위 호환성" 때문에 등장

인터페이스에 신규 함수 선언시 기존에 상속받아 구현하던 클래스에 모두 빨간불이 들어와 직접 구현을해야하는 상황을 방지하기 위해 등장함.

간단 코드로 보기

public class DefaultClass{
    public interface TestInterface {
    	// 선언 후 구현까지 해야한다.
        default void defaultFunction(){
            System.out.println("this is default function");
        }
    }

    private static class SubClass11 implements TestInterface{
    	// 기존 Interface 함수처럼 Override 가능
        @Override
        public void defaultFunction() {
            System.out.println("this is SubClass Function");
        }
    }

    private static class SubClass22 implements TestInterface{	
    	// default Function은 구현하지 않아도 된다.
    }

    public static void main(String[] args) {
        SubClass11 subClass11 = new SubClass11();
        SubClass22 subClass22 = new SubClass22();

        subClass11.defaultFunction();
        subClass22.defaultFunction();
    }
}

실행 결과

추상클래스를 사용한 통합 배치 관리 프로그램

lovineff — Tue, 6 Jul 2021 16:21:38 +0900

배치 병렬 처리를 위한 쓰레드 빈 생성 클래스

@Configuration
@EnableAsync
public class ThreadConfig {
    @Bean(name="jobExecutor")
    public Executor jobExecutor(){
        ThreadPoolTaskExecutor taskExecutor = new ThreadPoolTaskExecutor();
        taskExecutor.setCorePoolSize(5);
        taskExecutor.setMaxPoolSize(10);
        taskExecutor.setQueueCapacity(30);
        taskExecutor.setThreadNamePrefix("jobThead-");
        taskExecutor.initialize();
        return taskExecutor;
    }
}

메인 추상 클래스

@Setter
@Slf4j
public abstract class AbstractJob extends AbstractJobSub{
    private Long id;
    private String code;                // 코드
    private boolean isActive = false;   // 활성/비활성화
    private String cronRegExp;          // 크론 표현식
    private JobStatusEnum status;       // 잡 상태값
    private Long startWorkTime;         // 잡 시작 시간
    private Long endWorkTime;           // 잡 종료 시간

    /**
     * Job 실행전 수행
     */
    private void start(boolean isActive){
        jobIsWorking = true;
        startWorkTime = System.currentTimeMillis();

        changeJobStatus(id, JobStatusEnum.ING);
        makeJogLogs(id);

        if(isActive){
            logs("{} 수동 시작되었습니다.", code);
        }else{
            logs("{} 시작되었습니다.", code);
        }
    }

    /**
     * Job 종료 후 수행
     */
    private void end(){
        jobIsWorking = false;
        endWorkTime = System.currentTimeMillis();

        changeJobStatus(id, JobStatusEnum.WAIT);
        logs("{} 종료되었습니다.\t{}ms 소요되었습니다.", code, (endWorkTime - startWorkTime));
        jobIsSuccess();
    }

    /**
     * Job 종료 후 수행
     */
    private void interruptedExceptionEnd(){
        jobIsWorking = false;
        endWorkTime = System.currentTimeMillis();

        changeJobStatus(id, JobStatusEnum.WAIT);
        logs("{} 강제 종료되었습니다.\t{}ms 소요되었습니다.", code, (endWorkTime - startWorkTime));
        jobIsSuccess();
    }

    /**
     * Job 수행중 에러 발생시 처리
     * @param e: Exception
     */
    private void error(Exception e){
        jobIsWorking = false;
        changeJobStatus(id, JobStatusEnum.FAIL);
        logs("{} 오류가 발생하였습니다.", code);
        logs("{} / " + e.toString(), code);
        jobIsFail();
    }

    /**
     * Job 활성화 상태 여부 검사
     * @return : 잡 활성화 상태 여부
     */
    private boolean checkActive(){
        if(jobIsWorking || status.equals(JobStatusEnum.ING)){
            log.info("{} 실행중 상태로 중복실행을 방지합니다.", code);
            return false;
        }

        // JOB 상태 검사
        if(!isActive){
            log.info("{} 실행 가능한 상태가 아닙니다", code);
            return false;
        }

        // 크론식 검사
        boolean validExpression = CronSequenceGenerator.isValidExpression(cronRegExp);
        if(!validExpression){
            log.info("{} cron 표현식이 잘못되었습니다. > {}", code, cronRegExp);
            return false;
        }

        return true;
    }

    /**
     * Job 실행 시간 검사, true인 경우 잡 수행
     * @return : 잡 수행 가능 여부
     */
    private boolean checkIsWorkTime(){
        // 1초전 날짜로 다음 실행시간을 구하고, 현재 시간과 비교하여 실행여부를 판단한다.
        cronSequenceGenerator = new CronSequenceGenerator(cronRegExp);
        Date nextJobDate = cronSequenceGenerator.next(nowDateMinusOneMinute.getTime());

        Calendar nextJobCalendar = Calendar.getInstance();
        nextJobCalendar.setTime(nextJobDate);
        nextJobCalendar.set(Calendar.MILLISECOND, 0);

        // 같은 시간이라면 실행한다.
        if(nowDate.compareTo(nextJobCalendar) == 0){
            return true;
//        }else{
//            log.info("{} 실행 가능한 시간이 아닙니다. {} : {}", code, simpleDateFormat.format(nowDate.getTime()), simpleDateFormat.format(nextJobCalendar.getTime()));
        }

        return false;
    }

    /**
     * 초단위 설정은 0으로 하드코딩
     * @param exp
     */
    public void setCronRegExp(String exp){
        cronRegExp = "0 " + exp;
    }

    /**
     * 실제 Job 수행 전체 로직
     * 활성화 여부 검사, 잡 실행시간 검사 후 통과된 경우 Job 실행
     */
    @Async("jobExecutor")
    public void run(){
        try {
            if (checkActive() && checkIsWorkTime()) {
                start(false);
                job();
                end();
            }
        }catch (InterruptedException interruptedException){
            // 강제 종료시 일반 종료 처리
            interruptedExceptionEnd();
        }catch(Exception e){
            error(e);
            e.printStackTrace();
        }
    }

    /**
     * 즉시 실행 처리
     */
    @Async("jobExecutor")
    public void doRun(){
        try {
            if (checkActive()){
                start(true);
                job();
                end();
            }
        }catch (InterruptedException interruptedException){
            // 강제 종료시 일반 종료 처리
            interruptedExceptionEnd();
        }catch(Exception e){
            error(e);
            e.printStackTrace();
        }
    }

    /**
     * 실제 수행되는 Job 구현부
     * @throws Exception
     */
    public abstract void job() throws Exception;
}

추상클래스 상속용 클래스(로그 적재 등 작업)

@Setter
@Slf4j
public class AbstractJobSub {
    // Job 실행 상태 컨트롤용 변수
    public CronSequenceGenerator cronSequenceGenerator;
    public boolean jobIsWorking = false;
    public Calendar nowDateMinusOneMinute = Calendar.getInstance();
    public Calendar nowDate = Calendar.getInstance();

    // JobLogs 테이블 데이터 입력용 변수
    public Long jobLogsId;
    private StringBuilder logText = new StringBuilder();

    @Autowired
    private JobService jobService;

    /**
     * 현재 시간 설정 및 -1분 시간 설정
     * @param date
     */
    public void setNowDate(Calendar date){
        date.set(Calendar.MILLISECOND, 0);  // ms 제거

        nowDate.setTime(date.getTime());
        nowDateMinusOneMinute.setTime(date.getTime());
        nowDateMinusOneMinute.add(Calendar.SECOND, -1); // -1분 처리
    }

    /**
     * Job 실행 상태 수정
     * @param id : Job Id
     * @param jobStatusEnum : Job Status
     */
    public void changeJobStatus(Long id, JobStatusEnum jobStatusEnum){
        jobService.updateStatus(id, jobStatusEnum);
    }

    /**
     * 현재 실행중인 Job 즉시 중지(thread.interrupt 에러 발생)
     */
    public void emergencyStop(){
        Thread thread = Thread.currentThread();
        thread.interrupt();
    }

    /**
     * JobLogs 1로우 생성
     * @param id
     */
    public void makeJogLogs(Long id){
        this.jobLogsId = jobService.makeJobLogs(id);
        resetLogText();
    }

    /**
     * Job 성공시 JobLogs 상태값, Text 수정
     */
    public void jobIsSuccess(){
        jobService.jobIsSuccess(jobLogsId);
        updateLogText();
    }

    /**
     * Job 실패시 JobLogs 상태값, Text 수정
     */
    public void jobIsFail(){
        jobService.jobIsFail(jobLogsId);
        updateLogText();
    }

    /**
     * 빈 로그 텍스트 초기화
     */
    private void resetLogText(){
        this.logText.setLength(0);
    }

    /**
     * 잡 실행 로그를 DB에 적재
     * @param text
     */
    public void logs(String text, Object... arguments){
        LocalDateTime now = LocalDateTime.now();

        logText.append(now.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss.SSS")))
                .append("\t")
                .append(Thread.currentThread().getName())
                .append("\t")
                .append(makeLogText(text, arguments))
                .append("\n");

        log.info(text, arguments);

        // 2000자 이상의 텍스트가 적재 대기중인 경우 적재 후 초기화
        if(logText.length() > 2000){
            updateLogText();
            resetLogText();
        }
    }

    /**
     * log_text 컬럼 update
     */
    private void updateLogText(){
        if(logText.length() > 0){
            jobService.updateLogText(jobLogsId, logText.toString());
        }
    }

    private String makeLogText(String text, Object ...args){
        if(StringUtils.isEmpty(text)){
            return "";
        }

        if(!text.contains("{}")){
            return text;
        }

        StringBuilder sb = new StringBuilder();
        String[] split = text.split("\\{}");

        for (int i = 0; i < split.length; i++) {
            if(StringUtils.isEmpty(split[i].replace("{}", "").trim())){
                sb.append(args.length < i + 1 ? "" : args[i]);
            }else{
                sb.append(split[i].replace("{}", "")).append(args.length < i + 1 ? "" : args[i]);
            }
        }

        return sb.toString();
    }
}

JOB 배치 구현 클래스

@Slf4j
@Component
public class TestJob1 extends AbstractJob {
    @Override
    public void job() throws Exception {
        for (int i = 0; i < 10; i++) {
            logs("testjob1 is working");
            Thread.sleep(500);

            if(i == 5){
                emergencyStop();
            }
        }
    }
}

등록된 JOB을 실행시키는 클래스

@Slf4j
@Component
@RequiredArgsConstructor
public class MainJob {
    private final ApplicationContext applicationContext;
    private final JobService jobService;
    private final String hostName = SystemUtils.getLocalHostname();

    /**
     * 1분마다 실행되어 조건에 맞는 잡을 실행한다.
     * @throws Exception
     */
    @Scheduled(cron = "0 * * * * *")
    public void mainJob() throws Exception {
        // 실행 전 활성화 상태 대상 중 기간이 벗어난 목록 수정
        jobService.findExpiredAndActiveJobAndSetNotActive(hostName);

        // 실행 대상 job 목록 조회
        List<JobsModel> allJobsHostEquals = jobService.findWorkJobs(hostName);

        log.info("{} job size > {}", hostName, allJobsHostEquals.size());

        Calendar nowDate = Calendar.getInstance();

		// 아래 for문은 병렬 처리가 된다.
        for (JobsModel jobsModel : allJobsHostEquals) {
            // 실행 중 상태이면 수행하지 않음.
            if(jobsModel.getStatus().equals(JobStatusEnum.ING)){
                continue;
            }

            try{
                AbstractJob jobBean = (AbstractJob) applicationContext.getBean(jobsModel.getClassName());
                jobBean.setId(jobsModel.getId());
                jobBean.setNowDate(nowDate);
                jobBean.setCode(jobsModel.getCode());
                jobBean.setActive(jobsModel.getIsActive());
                jobBean.setCronRegExp(jobsModel.getCronRegExp());
                jobBean.setStatus(jobsModel.getStatus());

				// 잡 실행
                jobBean.run();
            }catch(NoSuchBeanDefinitionException noSuchBeanDefinitionException){
                log.error("존재하지 않는 Bean 이름 입니다. > {}", jobsModel.getClassName());
            }
        }
    }
}

Cron 정규식 검사

lovineff — Tue, 6 Jul 2021 16:08:06 +0900

import org.springframework.scheduling.support.CronSequenceGenerator;

boolean validExpression = CronSequenceGenerator.isValidExpression(cronRegExp);
if(!validExpression){
	log.info("{} cron 표현식이 잘못되었습니다. > {}", code, cronRegExp);
	return false;
}