flume SpoolDirectorySource二次开发新增文件监控

于 2022-12-18 10:20:56 发布
阅读量384 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/csdn_wr/article/details/128359997
版权

flume apache java

背景

目前部分数据来源于ftp服务，为了提升数据入库的操作，打算结合flume的实时采集。发现SpoolDirectorySource这个自带的source可以监控新增的文件。但是有个问题就是它的输出是文件的内容，但是我这边只需要知道文件的绝对路径就行。所以打算剥开它的源码，来瞅一瞅。

源码分析

源码如下

/*
 * Licensed to the Apache Software Foundation (ASF) under one or more
 * contributor license agreements. See the NOTICE file distributed with this
 * work for additional information regarding copyright ownership. The ASF
 * licenses this file to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 * License for the specific language governing permissions and limitations under
 * the License.
 */

package unicom.cn.source.spooldir;

import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Preconditions;
import com.google.common.base.Throwables;
import org.apache.flume.*;
import org.apache.flume.client.avro.ReliableSpoolingFileEventReader;
import org.apache.flume.conf.BatchSizeSupported;
import org.apache.flume.conf.Configurable;
import org.apache.flume.instrumentation.SourceCounter;
import org.apache.flume.serialization.DecodeErrorPolicy;
import org.apache.flume.serialization.LineDeserializer;
import org.apache.flume.source.AbstractSource;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.File;
import java.io.IOException;
import java.util.List;
import java.util.Locale;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

import static org.apache.flume.source.SpoolDirectorySourceConfigurationConstants.*;

public class SpoolDirectorySource extends AbstractSource
    implements Configurable, EventDrivenSource, BatchSizeSupported {

  private static final Logger logger = LoggerFactory.getLogger(SpoolDirectorySource.class);

  /* Config options */
  private String completedSuffix;
  private String spoolDirectory;
  private boolean fileHeader;
  private String fileHeaderKey;
  private boolean basenameHeader;
  private String basenameHeaderKey;
  private int batchSize;
  private String includePattern;
  private String ignorePattern;
  private String trackerDirPath;
  private String deserializerType;
  private Context deserializerContext;
  private String deletePolicy;
  private String inputCharset;
  private DecodeErrorPolicy decodeErrorPolicy;
  private volatile boolean hasFatalError = false;

  private SourceCounter sourceCounter;
  ReliableSpoolingFileEventReader reader;
  private ScheduledExecutorService executor;
  private boolean backoff = true;
  private boolean hitChannelException = false;
  private boolean hitChannelFullException = false;
  private int maxBackoff;
  private ConsumeOrder consumeOrder;
  private int pollDelay;
  private boolean recursiveDirectorySearch;
  private String trackingPolicy;

  @Override
  public synchronized void start() {
    logger.info("SpoolDirectorySource source starting with directory: {}",
        spoolDirectory);

    executor = Executors.newSingleThreadScheduledExecutor();

    File directory = new File(spoolDirectory);
    try {
      reader = new ReliableSpoolingFileEventReader.Builder()
          .spoolDirectory(directory)
          .completedSuffix(completedSuffix)
          .includePattern(includePattern)
          .ignorePattern(ignorePattern)
          .trackerDirPath(trackerDirPath)
          .annotateFileName(fileHeader)
          .fileNameHeader(fileHeaderKey)
          .annotateBaseName(basenameHeader)
          .baseNameHeader(basenameHeaderKey)
          .deserializerType(deserializerType)
          .deserializerContext(deserializerContext)
          .deletePolicy(deletePolicy)
          .inputCharset(inputCharset)
          .decodeErrorPolicy(decodeErrorPolicy)
          .consumeOrder(consumeOrder)
          .recursiveDirectorySearch(recursiveDirectorySearch)
          .trackingPolicy(trackingPolicy)
          .sourceCounter(sourceCounter)
          .build();
    } catch (IOException ioe) {
      throw new FlumeException("Error instantiating spooling event parser",
          ioe);
    }

    Runnable runner = new SpoolDirectoryRunnable(reader, sourceCounter);
    executor.scheduleWithFixedDelay(
        runner, 0, pollDelay, TimeUnit.MILLISECONDS);

    super.start();
    logger.debug("SpoolDirectorySource source started");
    sourceCounter.start();
  }

  @Override
  public synchronized void stop() {
    executor.shutdown();
    try {
      executor.awaitTermination(10L, TimeUnit.SECONDS);
    } catch (InterruptedException ex) {
      logger.info("Interrupted while awaiting termination", ex);
    }
    executor.shutdownNow();

    super.stop();
    sourceCounter.stop();
    logger.info("SpoolDir source {} stopped. Metrics: {}", getName(), sourceCounter);
  }

  @Override
  public String toString() {
    return "Spool Directory source " + getName() +
        ": { spoolDir: " + spoolDirectory + " }";
  }

  @Override
  public synchronized void configure(Context context) {
    spoolDirectory = context.getString(SPOOL_DIRECTORY);
    Preconditions.checkState(spoolDirectory != null,
        "Configuration must specify a spooling directory");

    completedSuffix = context.getString(SPOOLED_FILE_SUFFIX,
        DEFAULT_SPOOLED_FILE_SUFFIX);
    deletePolicy = context.getString(DELETE_POLICY, DEFAULT_DELETE_POLICY);
    fileHeader = context.getBoolean(FILENAME_HEADER,
        DEFAULT_FILE_HEADER);
    fileHeaderKey = context.getString(FILENAME_HEADER_KEY,
        DEFAULT_FILENAME_HEADER_KEY);
    basenameHeader = context.getBoolean(BASENAME_HEADER,
        DEFAULT_BASENAME_HEADER);
    basenameHeaderKey = context.getString(BASENAME_HEADER_KEY,
        DEFAULT_BASENAME_HEADER_KEY);
    batchSize = context.getInteger(BATCH_SIZE,
        DEFAULT_BATCH_SIZE);
    inputCharset = context.getString(INPUT_CHARSET, DEFAULT_INPUT_CHARSET);
    decodeErrorPolicy = DecodeErrorPolicy.valueOf(
        context.getString(DECODE_ERROR_POLICY, DEFAULT_DECODE_ERROR_POLICY)
            .toUpperCase(Locale.ENGLISH));

    includePattern = context.getString(INCLUDE_PAT, DEFAULT_INCLUDE_PAT);
    ignorePattern = context.getString(IGNORE_PAT, DEFAULT_IGNORE_PAT);
    trackerDirPath = context.getString(TRACKER_DIR, DEFAULT_TRACKER_DIR);

    deserializerType = context.getString(DESERIALIZER, DEFAULT_DESERIALIZER);
    deserializerContext = new Context(context.getSubProperties(DESERIALIZER +
        "."));

    consumeOrder = ConsumeOrder.valueOf(context.getString(CONSUME_ORDER,
        DEFAULT_CONSUME_ORDER.toString()).toUpperCase(Locale.ENGLISH));

    pollDelay = context.getInteger(POLL_DELAY, DEFAULT_POLL_DELAY);

    recursiveDirectorySearch = context.getBoolean(RECURSIVE_DIRECTORY_SEARCH,
        DEFAULT_RECURSIVE_DIRECTORY_SEARCH);

    // "Hack" to support backwards compatibility with previous generation of
    // spooling directory source, which did not support deserializers
    Integer bufferMaxLineLength = context.getInteger(BUFFER_MAX_LINE_LENGTH);
    if (bufferMaxLineLength != null && deserializerType != null &&
        deserializerType.equalsIgnoreCase(DEFAULT_DESERIALIZER)) {
      deserializerContext.put(LineDeserializer.MAXLINE_KEY,
          bufferMaxLineLength.toString());
    }

    maxBackoff = context.getInteger(MAX_BACKOFF, DEFAULT_MAX_BACKOFF);
    if (sourceCounter == null) {
      sourceCounter = new SourceCounter(getName());
    }
    trackingPolicy = context.getString(TRACKING_POLICY, DEFAULT_TRACKING_POLICY);
  }

  @VisibleForTesting
  protected boolean hasFatalError() {
    return hasFatalError;
  }


  /**
   * The class always backs off, this exists only so that we can test without
   * taking a really long time.
   *
   * @param backoff - whether the source should backoff if the channel is full
   */
  @VisibleForTesting
  protected void setBackOff(boolean backoff) {
    this.backoff = backoff;
  }

  @VisibleForTesting
  protected boolean didHitChannelException() {
    return hitChannelException;
  }

  @VisibleForTesting
  protected boolean didHitChannelFullException() {
    return hitChannelFullException;
  }

  @VisibleForTesting
  protected SourceCounter getSourceCounter() {
    return sourceCounter;
  }

  @VisibleForTesting
  protected boolean getRecursiveDirectorySearch() {
    return recursiveDirectorySearch;
  }

  @Override
  public long getBatchSize() {
    return batchSize;
  }

  @VisibleForTesting
  protected class SpoolDirectoryRunnable implements Runnable {
    private ReliableSpoolingFileEventReader reader;
    private SourceCounter sourceCounter;

    public SpoolDirectoryRunnable(ReliableSpoolingFileEventReader reader,
                                  SourceCounter sourceCounter) {
      this.reader = reader;
      this.sourceCounter = sourceCounter;
    }

    @Override
    public void run() {
      int backoffInterval = 250;
      boolean readingEvents = false;
      try {
        while (!Thread.interrupted()) {
          readingEvents = true;
          List<Event> events = reader.readEvents(batchSize);
          readingEvents = false;
          if (events.isEmpty()) {
            break;
          }
          sourceCounter.addToEventReceivedCount(events.size());
          sourceCounter.incrementAppendBatchReceivedCount();

          try {
            getChannelProcessor().processEventBatch(events);
            reader.commit();
          } catch (ChannelFullException ex) {
            logger.warn("The channel is full, and cannot write data now. The " +
                "source will try again after " + backoffInterval +
                " milliseconds");
            sourceCounter.incrementChannelWriteFail();
            hitChannelFullException = true;
            backoffInterval = waitAndGetNewBackoffInterval(backoffInterval);
            continue;
          } catch (ChannelException ex) {
            logger.warn("The channel threw an exception, and cannot write data now. The " +
                "source will try again after " + backoffInterval +
                " milliseconds");
            sourceCounter.incrementChannelWriteFail();
            hitChannelException = true;
            backoffInterval = waitAndGetNewBackoffInterval(backoffInterval);
            continue;
          }
          backoffInterval = 250;
          sourceCounter.addToEventAcceptedCount(events.size());
          sourceCounter.incrementAppendBatchAcceptedCount();
        }
      } catch (Throwable t) {
        logger.error("FATAL: " + SpoolDirectorySource.this.toString() + ": " +
            "Uncaught exception in SpoolDirectorySource thread. " +
            "Restart or reconfigure Flume to continue processing.", t);
        if (readingEvents) {
          sourceCounter.incrementEventReadFail();
        } else {
          sourceCounter.incrementGenericProcessingFail();
        }
        hasFatalError = true;
        Throwables.propagate(t);
      }
    }

    private int waitAndGetNewBackoffInterval(int backoffInterval) throws InterruptedException {
      if (backoff) {
        TimeUnit.MILLISECONDS.sleep(backoffInterval);
        backoffInterval = backoffInterval << 1;
        backoffInterval = backoffInterval >= maxBackoff ? maxBackoff :
            backoffInterval;
      }
      return backoffInterval;
    }
  }
}

几个关键的方法

  1. public synchronized void configure(Context context)读取配置信息
  2. public synchronized void start() 监控任务开始

基于官方例子

a1.channels = ch-1
a1.sources = src-1

a1.sources.src-1.type = spooldir
a1.sources.src-1.channels = ch-1
a1.sources.src-1.spoolDir = /var/log/apache/flumeSpool
a1.sources.src-1.fileHeader = true

我们构造一下配置信息

        spoolDirectory ="D:\\tmp\\test";
        Preconditions.checkState(spoolDirectory != null,
                "Configuration must specify a spooling directory");

        completedSuffix =DEFAULT_SPOOLED_FILE_SUFFIX ;
        deletePolicy =DEFAULT_DELETE_POLICY;
        fileHeader =
                DEFAULT_FILE_HEADER;
        fileHeaderKey =
                DEFAULT_FILENAME_HEADER_KEY;
        basenameHeader =
                DEFAULT_BASENAME_HEADER;
        basenameHeaderKey =
                DEFAULT_BASENAME_HEADER_KEY;
        batchSize =
                DEFAULT_BATCH_SIZE;
        inputCharset = DEFAULT_INPUT_CHARSET;
        decodeErrorPolicy = DecodeErrorPolicy.valueOf(
               DEFAULT_DECODE_ERROR_POLICY
                        .toUpperCase(Locale.ENGLISH));

        includePattern =  DEFAULT_INCLUDE_PAT;
        ignorePattern = DEFAULT_IGNORE_PAT;
        trackerDirPath =  DEFAULT_TRACKER_DIR;

        deserializerType = DEFAULT_DESERIALIZER;
        Map<String, String> paramters=new HashMap<>();
        deserializerContext = new Context(paramters);

        consumeOrder = ConsumeOrder.valueOf(
                DEFAULT_CONSUME_ORDER.toString().toUpperCase(Locale.ENGLISH));

        pollDelay =DEFAULT_POLL_DELAY;

        recursiveDirectorySearch =
                DEFAULT_RECURSIVE_DIRECTORY_SEARCH;

        // "Hack" to support backwards compatibility with previous generation of
        // spooling directory source, which did not support deserializers
//        if (bufferMaxLineLength != null && deserializerType != null &&
//                deserializerType.equalsIgnoreCase(DEFAULT_DESERIALIZER)) {
            deserializerContext.put(LineDeserializer.MAXLINE_KEY,
                   "100");
//        }

        maxBackoff =DEFAULT_MAX_BACKOFF;
        if (sourceCounter == null) {
            sourceCounter = new SourceCounter("test");
        }
        trackingPolicy =DEFAULT_TRACKING_POLICY;


        executor = Executors.newSingleThreadScheduledExecutor();

        File directory = new File(spoolDirectory);

现在进入最关键的时候，监控任务了，核心代码

public List<Event> readEvents(int numEvents) throws IOException {
    if (!committed) {
      if (!currentFile.isPresent()) {
        throw new IllegalStateException("File should not roll when " +
            "commit is outstanding.");
      }
      logger.info("Last read was never committed - resetting mark position.");
      currentFile.get().getDeserializer().reset();
    } else {
      // Check if new files have arrived since last call
      if (!currentFile.isPresent()) {
        currentFile = getNextFile();
      }
      // Return empty list if no new files
      if (!currentFile.isPresent()) {
        return Collections.emptyList();
      }
    }

    List<Event> events = readDeserializerEvents(numEvents);

    /* It's possible that the last read took us just up to a file boundary.
     * If so, try to roll to the next file, if there is one.
     * Loop until events is not empty or there is no next file in case of 0 byte files */
    while (events.isEmpty()) {
      logger.info("Last read took us just up to a file boundary. " +
                  "Rolling to the next file, if there is one.");
      retireCurrentFile();
      currentFile = getNextFile();
      if (!currentFile.isPresent()) {
        return Collections.emptyList();
      }
      events = readDeserializerEvents(numEvents);
    }

    fillHeader(events);

    committed = false;
    lastFileRead = currentFile;
    return events;
  }

  private List<Event> readDeserializerEvents(int numEvents) throws IOException {
    EventDeserializer des = currentFile.get().getDeserializer();
    List<Event> events = des.readEvents(numEvents);
    if (events.isEmpty() && firstTimeRead) {
      events.add(EventBuilder.withBody(new byte[0]));
    }
    firstTimeRead = false;
    return events;
  }

我们需要做的事是，把返回结果event里面的文件内容替换成文件名。替换后的代码

  public List<Event> readEvents(int numEvents) throws IOException {
      if (!currentFile.isPresent()) {
        currentFile = getNextFile();
      }
      // Return empty list if no new files
      if (!currentFile.isPresent()) {
        return Collections.emptyList();
      }
      

    String filename = currentFile.get().getFile().getAbsolutePath();
    List<Event> events =new ArrayList<>();
    events.add(EventBuilder.withBody(filename.getBytes(StandardCharsets.UTF_8)));
    retireCurrentFile();
    currentFile = getNextFile();
    committed = false;
    lastFileRead = currentFile;
    return events;
  }

大功告成
源码包见附件

csdn_wr
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Flume之Taildir Source二次开发实现迭代读取目录下文件
11号车厢
08-22 749
文章目录1、下载源码包2、导入IDEA3、修改源码4、上传到服务器，编译5、新建conf文件，测试TaildirSource 1、下载源码包 注意这是源码文件 flume-ng-1.6.0-cdh5.7.0-src.tar.gz 解压到Windows目录下 2、导入IDEA 就这里注意下倒入哪个目录，后面都是next就行了。 3、修改源码 找到 getMatchFiles 方法 注释完后在...
windows搭建flume：基于源码的二次开发
大壮的博客
07-19 1590
windows搭建flume：基于源码的二次开发 ​  移除点击此处添加图片说明文字 ​先说一下flume的架构，这部分快速阅读，flume架构倒是不难，容易理解。 flume是分布式的，可靠的，高可用的，用于对不同来源的大量的日志数据进行有效收集、聚集和移动，并以集中式的数据存储的系统。 flume目前是apache的一个顶级项目。 flume中的重要模型 1.fl
Apache Flume 日志采集的系统的原理实现以及二次开发
GitChat
07-02 557
Flume 是 Cloudera 提供的一个高可用的，高可靠的，分布式的海量日志采集、聚合和传输的系统，Flume 支持在日志系统中定制各类数据发送方，用于收集数据；同时，Flume 提供对数据进行简单处理，并写到各种数据接受方（可定制）的能力。 本场 Chat 首先会带领大家入门 Flume 的原理与使用，然后针对常用的配置进行详细地阐述，帮助大家对 Flume 做到知其然，并知其所以然，并且还...
Flume经典案例之实时监控多个新文件（保姆级教程）
wanjialin的博客
12-26 820
准备工作： 1、准备多个大文件，以备后面使用 2、提前创建好目录和文件上传至linux中 操作步骤： 1、首先先将我们要操作的文件拷贝到指定的文件夹下，方便一会使用命令和写配置文件 命令cp events.csv flumelogfile/events/events_2021-12-26.csv 2、创建events-flume-logger.conf 内容如下： events.sources=eventsSource events.channels=eventsChannel events.sinks=e
flume taildir二次开发实现递归多层目录
qq_32667911的博客
05-25 416
以apache-flume-1.7.0为例， 在TaildirSourceConfigurationConstants常数类中添加配置 public static final String SOURCE_RECURSIVE = "sourceRecursive"; public static final boolean DEFAULT_SOURCE_RECURSIVE = false; TaildirSource类中 private boolean sourceRecurisive; confi
Flume监控之Ganglia
01-07
主要是用来监控系统性能，如：cpu 、mem、硬盘利用率， I/O负载、网络流量情况等，通过曲线很容易见到每个节点的工作状态，对合理调整、分配系统资源，提高系统整体性能起到重要作用。 其详细介绍和工作原理请参考...
flume 文件备份
12-05
在 Flume 自定义 Sink 开发中，`pom.xml` 会包含 Flume 相关的依赖库，例如 Flume API，以及其他必要的开发库，以便编译和测试自定义组件。 4. **使用 Safe Roll File Sink** 要在 Flume 配置中使用这个自定义 ...
Flume+Kafka整合环境（监控目录+监控文件）实验作业参考
10-31
Flume+Kafka整合环境（监控目录+监控文件） 实验作业，仅供参考
flume配置文件案例
09-27
flume配置文件，文件配了说明，可以拿下来改一改就用。 可以获取端口数据监听或者文件、文件夹内容监听，实时写入hdfs、mysql或者你需要的路径。
配置flume的conf文件
最新发布
02-09
配置flume的netcat.conf文件，其中端口号为44444
SpoolDirectorySource使用及源码分析
iteye_14970的博客
11-07 550
Spooling Directory Source简介 Spooling Directory Source可以获取硬盘上“spooling”目录的数据，这个Source将监视指定目录是否有新文件，如果有新文件的话，就解析这个新文件。事件的解析逻辑是可插拔的。在文件的内容所有的都读取到Channel之后，Spooling Directory Source会重名或者是删除该文件以表示文件已经读取完成...
Flume源码之SpoolDirectorySource
jobinzhang的博客
03-21 1741
SpoolDirectorySource是flume中的一个source，也是我们使用flume中经常接触到的一个source，最近正在使用flume的这个源，就把相关的源码学习了下。 1. 首先我们进入SpoolDirectorySource这个类，先看configure这个方法 这个方法做的事情比较简单。从代码上来看。主要是从配置文件读取一下配置信息，类似需要监控的目录，一些文件的
flume学习05---Spooling Directory Source
chbxw
03-20 1636
Spooling Directory Source此source允许您通过将要提取的文件放入磁盘上的“spooling”目录来提取数据。此源将监视指定目录的新文件，并在新文件显示时解析新文件中的event。event解析逻辑是可插入的。在给定文件被完全读入channel之后，它被重命名以指示完成（或可选地被删除）。与Exec源 Source不同，此source是可靠的，并且不会丢失数据，即使Flum
flume spoolDirectory Source原生代码流程及其拓展
lilyjoke的专栏
09-08 2187
最近小组要在flume的基础上做定制开发，以满足公司内部的业务使用。我这块主要的开发是对zip包中的文件做一定的处理后，以avro方式序列化，写入kafka。整个流程参考了flume的spoolDirectorySource的实现，因为主要是对spooldirectorySource中文件解析的部分进行了参考，所以下面的文章将会着重分析文件的解析部分。 1、  spoolDirector
flume介绍
abcdefghwelcome的博客
11-29 115
1.1.1概述 Flume是一个分布式、可靠、和高可用的海量日志采集、聚合和传输的系统。 Flume可以采集文件，socket数据包等各种形式源数据，又可以将采集到的数据输出到HDFS、hbase、hive、kafka等众多外部存储系统中。 一般的采集需求，通过对flume的简单配置即可实现。 Flume针对特殊场景也具有良好的自定义扩展能力，因此，flume可以适当于大部分的日常数据采集...
Flume概述
weixin_42644102的博客
12-18 238
学习flume需要掌握flume的完整工作流程、各组件的作用以及二次开发，并且掌握flume的事物机制。 接下来我将讲述flume的 架构图 用法 事物机制 结合实际开发讲解flume的二次开发 flume的架构图 fluflume是分布式的日志收集系统，它将各个服务器中的数据收集起来并发送到指定的地方去，比如说发送到途中的HDFS中，简单来说flume就是收集日志的。 注：日志收集系统还有一...
Flume快速入门
zp的博客
04-20 875
前言 在一个完整的离线大数据处理系统中，除了HDFS+MapReduce+Hive组成分析系统的核心之外，还需要数据采集、结果数据导出、任务调度等不可或缺的辅助系统，而这些辅助工具在Hadoop生态体系中都有便捷的开源框架，如图所示： 图：典型大规模离线数据处理平台 一、Flume日志采集框架 1.1 概述 Flume是一个分布式、可靠、和高可用的海量日志采集、聚合和传输...
flume-ng学习之spooling directory类型source配置深入及解析
Jiny_li的博客
06-27 3633
flume概述 Flume是一个分布式、可靠、高可用的海量日志聚合系统，支持在系统中定制各类数据发送方，用于收集数据；同时，Flume提供对数据的简单处理，并写到各种数据接收方的能力。 Flume主要由3个重要的组件构成：Source、Sink、Channel。 flume的核心是把数据从数据源收集过来，再送到目的地。为了保证输送一定成功，在送到目的地之前，会先缓存数据，待数据真正到
FATAL: Spool Directory source source: { spoolDir: /home/work/local/log }: Uncaught exception in
B11050101的博客
04-29 3398
flume报错如下： 28 Apr 2019 15:08:59,663 ERROR [pool-5-thread-1] (org.apache.flume.source.SpoolDirectoryExtSource2$SpoolDirectoryRunnable.run:277) - FATAL: Spool Directory source source1: { spoolDir: /h...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值