spark(scala)获取fsimage,并分析出fsimage中的小文件信息

已于 2022-04-21 09:34:39 修改
阅读量688 收藏 2
点赞数 1
分类专栏： java基础 文章标签： spark
于 2020-03-24 16:14:57 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/miracle_8/article/details/105074353
版权

spark(scala)获取fsimage,并分析出fsimage中的小文件信息

项目要求:

  1. 获取fsimage并解析, 做聚合操作
  2. 采用spark并发处理
// pom.xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <parent>
        <artifactId>flink-test</artifactId>
        <groupId>com.sm</groupId>
        <version>0.0.1</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.sm</groupId>
    <artifactId>02-flink-scala</artifactId>

    <properties>
        <flink-scala.version>1.6.2</flink-scala.version>
        <flink-streaming-scala.version>1.6.2</flink-streaming-scala.version>
        <flink-client.version>1.6.2</flink-client.version>
        <scala.version>2.11</scala.version>
        <spark-streaming.version>2.4.4</spark-streaming.version>
        <logback-classic.version>1.2.3</logback-classic.version>
        <scala-logging.version>3.9.2</scala-logging.version>
        <spark-sql.version>2.4.4</spark-sql.version>
        <spark-hive.version>2.4.4</spark-hive.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-scala_${scala.version}</artifactId>
            <version>${flink-scala.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-streaming-scala_${scala.version}</artifactId>
            <version>${flink-streaming-scala.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-clients_${scala.version}</artifactId>
            <version>${flink-client.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.commons</groupId>
            <artifactId>commons-lang3</artifactId>
            <version>3.9</version>
        </dependency>

        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-streaming_${scala.version}</artifactId>
            <version>${spark-streaming.version}</version>
        </dependency>
        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-sql_2.11</artifactId>
            <version>${spark-sql.version}</version>
        </dependency>

        <dependency>
            <groupId>org.apache.spark</groupId>
            <artifactId>spark-hive_${scala.version}</artifactId>
            <version>${spark-hive.version}</version>
        </dependency>
        <!--logger-->
        <dependency>
            <groupId>com.typesafe.scala-logging</groupId>
            <artifactId>scala-logging_${scala.version}</artifactId>
            <version>${scala-logging.version}</version>
        </dependency>
    </dependencies>
</project>

代码如下:

// OfflineFSImage.scala
package com.sm

import java.io.File

import org.apache.spark.rdd.RDD
import org.apache.spark.sql.types._
import org.apache.spark.sql.{DataFrame, Row, SparkSession}

import scala.collection.mutable.ListBuffer

/**
  * 〈一句话功能简述〉<br> 
  * 〈功能详细描述〉
  *
  * @author 
  * @see [相关类/方法]（可选）
  * @since [产品/模块版本] （可选）
  * @date 2020/1/13
  */
object OfflineFSImage{
  private[this] val appName: String = "OfflineFSImage"
  private[this] val warehouseLocation: String = new File("spark-warehouse").getAbsolutePath
  private[this] val hiveTableName: String = "hive表" // 存放所有hive的元数据信息
  private[this] val hiveTableNameFinalResult: String = "final_result"


  val fileImageSchema = StructType(
    Seq(
      StructField("cluster", StringType, true)
      ,StructField("path", StringType, true)
      ,StructField("user", StringType, true)
      ,StructField("sum", LongType, true)
      ,StructField("allsum", LongType, true)

      ,StructField("minmodificationtime", StringType, true)
      ,StructField("maxmodificationtime", StringType, true)
      ,StructField("minaccesstime", StringType, true)
      ,StructField("maxaccesstime", StringType, true)
      ,StructField("smallfilecount", IntegerType, true)
      ,StructField("allfilecount", IntegerType, true)
      ,StructField("ishive", StringType, true)
    )
  )
  // 主方法入口
  def main(args: Array[String]): Unit = {
    var inputPath: String = ""
    if (args.length < 1) {
      println("输入参数为空，将采用默认的输入参数: hdfs://aaa:9000/user/cj0114/fsimage_001.csv")
      inputPath = "hdfs://aaa:9000/user/cj0114/fsimage_001.csv"
    } else {
      inputPath = args(0)
    }

    val startTime = System.currentTimeMillis()
    val sparkSession = SparkSession
      .builder()
//      .master("spark://bbb:7077")
      .appName(appName)
      .config("spark.sql.warehouse.dir", warehouseLocation)
      .enableHiveSupport()
      .getOrCreate()

    val fsImageRDD: RDD[Array[String]] = sparkSession
      .sparkContext
      .textFile(inputPath)
      .filter(!_.contains("NSQUOTA")) // 过滤fsimage中的第一行
      .map(_.split("\\^"))


    // fsimage文件存在异常数据
    val errorMsg: RDD[Array[String]] = fsImageRDD.filter(_.length < 12)
    println("errorMsg.size：" + errorMsg.count() + "个")
    val rightMsg: RDD[Array[String]] = fsImageRDD.filter(_.length >= 12)
    println("rightMsg.size：" + rightMsg.count() + "个")

    // 获取hive表中的数据
    val hiveTableFrame: DataFrame = sparkSession.sql("select * from " + hiveTableName)
    // 将hive表中数据列subpath封装为树对象 进行broadcast
    val subPathList: Array[String] = hiveTableFrame.rdd.map(row => {
      row.getString(4)
    }).collect()

    println("subPathList=" + subPathList.length)
    val node: TreeNode = DirectoryTree.addToTree(subPathList)
    // 广播树数据
    val broadcastValue = sparkSession.sparkContext.broadcast(node)

    // 文件行
    val fileRDD: RDD[(String, Row)] = rightMsg
      .filter(!_(9).startsWith("d")) // 获取目录中没有.Trash的文件
      .flatMap(splitPathByArray(_, broadcastValue.value))
      .map(line => (line.getAs[String](1), line))
      .reduceByKey((x,y) => { // x是总和
//        cluster path user sum 总大小(包含副本的)
//        min(修改时间) max(修改时间) min(创建时间) max(创建时间) 小文件(个数) 总文件(个数) hive(是否是hive)
        Row(x.getString(0),
          x.getString(1),
          (if (x.getString(2).equals(y.getString(2))) x.getString(2) else "multiUser"),
          x.getLong(3) + y.getLong(3),
          x.getLong(4) + y.getLong(4),
          (if (x.getString(5) > y.getString(5)) y.getString(5) else x.getString(5)),
          (if (x.getString(6) > y.getString(6)) x.getString(6) else y.getString(6)),
          (if (x.getString(7) > y.getString(7)) y.getString(7) else x.getString(7)),
          (if (x.getString(8) > y.getString(8)) x.getString(8) else y.getString(8)),
          x.getInt(9) + y.getInt(9),
          x.getInt(10) + y.getInt(10),
          x.getString(11))
      }, 30)
      // 数据量较大 无法执行collect操作 会降driver端内存撑爆
//      .collect() // 收集分布在各个worker的数据到driver节点
//      .map(_._2)

    val directRDD: RDD[(String, Row)] = rightMsg
      .filter(_(9).startsWith("d")) // 获取目录中没有.Trash的文件
      .map(array => {
        var pathSelf: String = array(0) // Path
        // 判断是否存在
        var isHiveTable = false;
        if (DirectoryTree.findInTree(pathSelf, node)) {
          isHiveTable = true;
        }

      (pathSelf, Row("cluster",
          array(0),
          array(10),
          0L,
          0L, // 计算文件的总大小=文件数 * 副本数
          array(2),
          array(2),
          array(3),
          array(3),
          -1, // 标记是否是小文件
          0, // 固定值, 方便计算总的个数
          (if (isHiveTable) "是" else "否"))) // 是否是hive表)
    })

    // 输出目录存在，则删除
//    val output: Path = new Path("hdfs://aaa:9000/user/2/offlineFSImageOutput")
//    val output: Path = new Path("hdfs://a/user/1/hdfs_fsimage/offlineFSImageOutput/")
    //    val hdfs: FileSystem = org.apache.hadoop.fs.FileSystem.get(new URI("hdfs://aaa:9000"), new Configuration())
//    val hdfs: FileSystem = org.apache.hadoop.fs.FileSystem.get(new URI("hdfs://a"), new Configuration())
    //
    // 删除输出目录
//    if (hdfs.exists(output)) {
//      hdfs.delete(output, true)
//    }
//    fileRDD.saveAsTextFile("hdfs://aaa:9000/user/2/offlineFSImageOutput")
//    finalResult.saveAsTextFile("hdfs://a/user/4/hdfs_fsimage/offlineFSImageOutput/")


    // fileRDD和directRDD会出现重合的地方  需要在directRDD中去除
    val distinctRDD: RDD[(String, Row)] = directRDD.subtractByKey(fileRDD)

    val finalRdd: RDD[Row] = fileRDD.union(distinctRDD).map(_._2)
    println("finalRdd=" + finalRdd.count())

    // 20200323 写入到hive表中
    val fileRDDDF1: DataFrame = sparkSession.createDataFrame(finalRdd, fileImageSchema)
    fileRDDDF1.createOrReplaceTempView("final_result_tmp")
    sparkSession.sql("truncate table " + hiveTableNameFinalResult)
    sparkSession.sqlContext.sql("insert into table " + hiveTableNameFinalResult + " select * from final_result_tmp")
    sparkSession.close()
    println("花费时间: " + (System.currentTimeMillis() - startTime) + " ms")
  }

  /**
    * 将文件路径切割 /a/b/c.txt => ['/a','/a/b'] ，并且计算包括副本的总大小和是否是小文件
    * @param fileLine
    * @return
    */
  @throws(classOf[NullPointerException])
  def splitPathByArray(fileLine: Array[String], node: TreeNode): ListBuffer[Row] = {
    if (fileLine == null || fileLine.length == 0) {
      println("当前行为空或路径为空") // TODO 日志记录
    }

    var pathSelf: String = fileLine(0) // Path
    // 判断是否存在
    var isHiveTable = false;
    if (DirectoryTree.findInTree(pathSelf, node)) {
      isHiveTable = true;
    }

    val result = new ListBuffer[Row]
    var loopControl: Boolean = true
    var index: Int = -1
    var splitResult: String = ""
    while (loopControl) {
      index = pathSelf.lastIndexOf("/")
      if (index == 0 || index == -1) {
        loopControl = false
      } else {
        splitResult = pathSelf.substring(0, index)
        pathSelf = splitResult
//        Path,Replication,ModificationTime,AccessTime,PreferredBlockSize,
//        BlocksCount,FileSize,NSQUOTA,DSQUOTA,Permission,UserName,GroupName,
//        总文件大小,是否是小文件,文件固定(1)
//
//        cluster path user sum 总大小(包含副本的)
//        min(修改时间) max(修改时间) min(创建时间) max(创建时间) 小文件(个数) 总文件(个数) hive(是否是hive)
        result += Row("cluster",
          splitResult,
          fileLine(10),
          fileLine(6).toLong,
          fileLine(1).toInt * fileLine(6).toLong, // 计算文件的总大小=文件数 * 副本数
          fileLine(2),
          fileLine(2),
          fileLine(3),
          fileLine(3),
          (if (fileLine(6).toLong <= 1 * 1024 * 1024) 1 else 0), // 标记是否是小文件
          1, // 固定值, 方便计算总的个数
          (if (isHiveTable) "是" else "否") // 是否是hive表
        )
      }
    }
    return result
  }
}

// DirectoryTree.scala
package com.sm

import scala.collection.mutable
import scala.collection.mutable.HashMap
/**
  * 〈一句话功能简述〉<br> 
  * 〈功能详细描述〉
  *
  * @author miracle
  * @see [相关类/方法]（可选）
  * @since [产品/模块版本] （可选）
  * @date 2020/3/23
  */
object DirectoryTree {

  val treeNode: TreeNode = new TreeNode("/")

      /*
       * 在树上查找节点
       */
      def findInTree(directory: String, root: TreeNode): Boolean = {
        return recursionfindInTree(directory.replaceFirst("/", ""), root.getNodeList);
      }

      def recursionfindInTree(directory: String, children: HashMap[String, TreeNode]): Boolean = {
        if (directory == null || "".compareTo(directory) == 0 || children.size == 0) {
          return true;
    }

    var currentDirect: String = ""
    var lastDirect: String = ""
    var firstSeperator: Int = directory.indexOf("/");
    if (firstSeperator == -1) {
      currentDirect = directory;
      lastDirect = null;
    } else {
      currentDirect = directory.substring(0, firstSeperator);
      lastDirect = directory.substring(firstSeperator + 1);
    }

    val exists = children.get(currentDirect)
    if (exists != None) {
      return recursionfindInTree(lastDirect, exists.get.nodeList);
    } else {
      return false;
    }
  }

  def println(): String = {
    val str: mutable.StringBuilder = new mutable.StringBuilder()
    treeNode.nodeList.foreach(str.append)
    return str.mkString
  }

  /*
   * 根据list构建树
   */
  def addToTree(list: Array[String]): TreeNode = {
    list.foreach(directory => {
      recursionAddToTree(directory.replaceFirst("/", ""), treeNode.getNodeList);
    })
    return treeNode
  }

  def recursionAddToTree(directory: String, children: HashMap[String, TreeNode]): Unit = {
    if (directory == null || "".compareTo(directory) == 0) {
      return ;
    }

    var currentDirect: String = ""
    var lastDirect: String = ""
    var firstSeperator: Int = directory.indexOf("/");
    if (firstSeperator == -1) {
      currentDirect = directory;
      lastDirect = null;
    } else {
      currentDirect = directory.substring(0, firstSeperator);
      lastDirect = directory.substring(firstSeperator + 1);
    }

    val exists = children.get(currentDirect)
    if (exists != None) {
      recursionAddToTree(lastDirect, exists.get.nodeList);
    } else {
      val newTreeNode: TreeNode = new TreeNode(currentDirect)
      children.put(currentDirect, newTreeNode);
      recursionAddToTree(lastDirect, newTreeNode.getNodeList);
    }
  }
}

// TreeNode.scala
package com.sm

import scala.collection.mutable.HashMap

/**
  * 〈一句话功能简述〉<br> 
  * 〈功能详细描述〉
  *
  * @author miracle
  * @see [相关类/方法]（可选）
  * @since [产品/模块版本] （可选）
  * @date 2020/3/23
  */
class TreeNode(urlParam: String) extends Serializable {
  var url: String = urlParam
  var nodeList: HashMap[String, TreeNode] = new HashMap[String, TreeNode]()

  def getUrl = url
  def getNodeList = nodeList

  def setUrl(value: String): Unit = url = value
  def setNodeList(value: HashMap[String, TreeNode]): Unit = nodeList = value
}
miracle_8
关注
  • 1
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
hfsa:Hadoop FSImage分析器（HFSA）
05-14
Hadoop FSImage分析器（HFSA） 介绍 Hadoop FSImage分析器（HFSA）通过提供补充 支持对HDFS数据文件以及用户和组目录的概述进行概述（回答“谁拥有多少个/大/小文件...”） 一个用于从派生的用于快速和部分多线程的fsimage处理API文件，目录和符号链接访问者的） 库的用法示例 有关示例用法，请参见 。 以下行访问所有目录，文件和符号链接索引节点： RandomAccessFile file = new RandomAccessFile ( " src/test/resources/fsi_small.img " , " r " ); // Load file into memory FsImageData fsimageData = new FsImageLoader . Builder () .parallel() . build()
2021-05-08
weixin_44280906的博客
05-08 261
版本 时间 描述 V1.0 2020-12-18 创建 V1.2 2021-01-17 新增 spark 面试题 V1.3 2021-01-18 新增 kafka 面试题 V1.4 2021-01-20 新增 hbase 面试题 V1.5 2021-01-30 新增 flink 面试题 复习大数据面试题，看这一套就够了！ 持续更新中… 文章更新首发于公众号：五分钟学大数据 获取此套面试题最新pdf版，请搜索公众号【五分钟学大数据】，对话框发送 面试宝典 此套面试题来自于各大厂的真实面试题及常问的知识点，如果
Spark 3.0.3 伪分布式
su_mingyang的博客
09-02 548
1、spark 概述 Spark是一种基于内存的快速、通用、可扩展的大数据分析计算引擎 Spark Core中提供了Spark的最基础的与最核心的功能 Spark SQL是Spark用来操作结构化数据的组件 Spark Streaming是Spark平台上针对实时数据进行流式计算的API Spark MLib 是Spark提供一个机器学习算法库 Spark GraphX 是spark面向图计算提供的框架与算法 Spark 3.0默认使用的scala编译版本为2.12 2、wordcount案例 使用
大数据HDFS集群运维之小文件统计
weixin_51100441的博客
02-25 417
随着公司集群规模越来越大，数据增长越来越快，文件Size比HDFS的Block Size（默认128MB）小的多的文件，小文件治理也迫在眉睫。目前采用离线分析Namenode元数据的方式进行统计分析。提示：以下是本篇文章正文内容，下面案例可供参考使用Fsimage文件可以获取到HDFS的文件情况，使用sql进行统计分析能获取到集群文件使用情况，具体看业务需要，运维人员也方便对现HDFS集群做出更好的判断。
oiv 查看 Fsimage 文件和oev 查看 Edits 文件
qq_43224174的博客
12-08 1255
oiv 查看 Fsimage 文件 1、进入目的路径 [lqs@bdc112 current]$ cd /home/lqs/module/hadoop-3.1.3/data/dfs/name/current 语法： hdfs oiv -p 文件类型 -i 镜像文件 -o 转换后文件输出路径 2、使用命令进行转换 [lqs@bdc112 current]$ hdfs oiv -p XML -i fsimage_0000000000000000330 -o /home/lqs/module/hadoo
hdfs元数据实时采集
qq_34295546的博客
07-18 1039
因Hdfs集群元数据量大，因此即使存储到磁盘上，存储开销依然很大，并且RocksDB为了提高写入和查询性能，会将部分数据放到内存中，因此单条数据越小，对内存和磁盘的开销越小，因此需要找一个在性能和序列化后数据量均较好的序列化方案。主要是借用的zk的节点监控来回调触发各种操作的。consumer端获取到数据后处理，这里获取的是op，op不会带节点的id，里面都是些绝对路径，所以就借用到了之前加载时库中的节点id，通过路径解析出id，然后进行目录的聚合等操作，然后再写会rocksDb，并写出到es。
大数据Hadoop、Hive、Kafka、Hbase、Spark等框架面经
m0_46689661的博客
12-05 9011
大数据Hadoop、Hive、Kafka、Hbase、Spark等框架面经
第二十讲.HDFS管理员命令(查看状态信息+保存元数据+获取最新fsimage+设置目录配额和空间配额)
美妙人生IT
08-13 674
HDFS 视频：【美妙人生】Hadoop课程系列之HDFS--手把手教你精通HDFS 【美妙人生】Hadoop课程系列之HDFS--手把手教你精通HDFS 【视频笔记】 hdfs管理员操作dfsadmin ------------------------------- 1.-report：返回集群的状态信息 $>hdfs dfsadmin -report 2.-metasave：默认存放到{HADOOP_LOG_DIR}路径下,包含datanode和块的信...
解析fsimage文件（文件与数据块）
小小码农
06-03 2142
fsimage文件与editslog文件存储的路径  查看hdfs-site.xml属性： fsimage、editslog文件存储：（可多目录） dfs.namenode.name.dir /opt/data/name blk数据块文件：（可多目录） dfs.datanode.data.dir /opt/data/dn1,/opt/data/dn2 fsimage和editslog文件存储在dfs.namenode.name.dir的值下面。 /opt/data/name/current/
hdfs小文件使用fsimage分析实例
Direction_Wind的博客
03-22 4515
这里写目录标题1 小文件来源分析1.1 数据主要来源：2 处理方案2.1 实时计算任务2.2 hive做优化，小文件做合并:2.2.1 已有数据2.2.2 新接入数据做数据合并后在load进hive新表dwd层及以后可以通过设置这些参数。2.2.3 mapreduce 定义规范3fsimage 离线分析hdfs内容3.1创建hive表 存储元数据，做分析用3.2 处理fsimage文件3.2.1获取fsimage文件：3.2.2从2进制文件解析：3.2.3加载进hive中3.2.4 统计文件整体情况3.2.
利用fsimage分析HDFS小文件
bigdata_player
08-29 635
在Hive中，所谓的小文件是指文件大小远小于HDFS块大小的文件，通常小于128 MB，甚至更少。这些小文件可能是Hive表的一部分，每个小文件都包含一个或几个表的记录，它们以文本格式存储。存储空间占用过多：在Hadoop生态系统中，每个小文件都将占用一定的存储空间，而且每个小文件也需要一个块来存储。如果存在大量的小文件，将浪费大量的存储空间。处理延迟：小文件数量过多，会引起大量IO操作，导致处理延迟。查询性能下降：小文件用于分区和表划分，可能导致查询延迟并降低查询性能。
HDFS小文件处理方案
08-30
讲解HDFS小文件处理方案方法
Scala和Spark大数据分析函数式编程、数据流和机器学习
04-23
Scala和Spark大数据分析函数式编程、数据流和机器学习
基于Java、Scala和Spark的数据处理与分析设计源码
04-05
本资源提供了一套基于Java、Scala和Spark的数据处理与分析设计源码，包含1381个文件，其中包括634个CRC文件，316个BK文件，35个Class字节码文件，20个XML配置文件，15个Java源代码文件，13个JAR打包文件，8个...
基于Scala的Apache Spark流感病毒数据分析设计与实现源码
最新发布
04-11
项目包含99个文件，其中包括40个Scala文件、24个CRC文件、20个Parquet文件、9个XML文件、2个Gitignore文件、1个Markdown文档、1个output/als_model2/1697955895383/metadata/part-00000文件和1个JSON文件。...
详解如何使用Spark和Scala分析Apache访问日志
08-25
主要介绍了详解如何使用Spark和Scala分析Apache访问日志，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
SparkTest:Intellij Idea中的Spark Scala项目样本
04-30
火花测试 测试项目。 Spark + Intellij Idea + Scala的集成。
java基础（十）捕获异常还是抛出异常
热门推荐
miracle_8的博客
10-19 1万+
1、 异常分类 a. RuntimeException 及其子类不要求捕捉，而其它的异常要求捕捉随便举几个 RuntimeException 子异常，有：数组越界异常、空指针异常、0作除数异常b. 非RuntimeException 异常有：Socket异常、IO异常等c. 对比一下我们就会发现，RuntimeException 是在程序中可以完全避免的， c1. 比如数组越界异常，只要我在程序
scala用spark读取csv文件并读取条数
04-25
关于您的问题，可以使用以下代码使用Spark和Scala读取CSV文件并计算行数： ```scala import org.apache.spark.sql.SparkSession object ReadCSVFile { def main(args: Array[String]) { val spark = ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值