• Bsdiff,Bspatch 的差分增量升级(基于Win和Linux)

    目录

             背景

    内容

    准备工作

    在windows平台上

    在linux平台上

    正式工作

    生成差分文件思路

    作用差分文件思路

    在保持相同目录结构进行差分增量升级

    服务端(生成差分文件)

    客户端(作用差分文件)

    12月6日更新（修复bug)

    执行分析

    注意事项和关注的地方:

    背景

    像常见的Android 的linux平台，游戏，系统更新都会用到这一种方式。

    以我自己的理解,这种方式有些像git中的版本管理, 以最少的时间进行版本管理.核心在于如何去记录文件的差异.

    服务器端:

    通过

     bsdiff  old  new  patchfile_path

    生成差分文件.一般以.patch的文件命名.

    客户端: 根据patch文件 通过

    bspatch oldfile newfile patchfile_path

    一般情况下，本以为可以直接通过压缩包的形式去进行, 安卓平台的.apk文件是可以的,单片机的可执行hex等格式的文件也是可以的. 但通过压缩的压缩包则可能会有隐患. 通过开会讨论以及本人查询资料发现 会因为压缩算法,压缩文件顺序的不一样而导致差分包出现问题.

    原因有

    主要原因有:

    1. 不同的压缩算法会产生不同的压缩数据。即使原始数据相同,通过不同算法压缩结果也不完全一样。这会直接影响bsdiff的比较结果。

    2. 即使使用同一压缩算法,压缩文件内原始数据的顺序改变也可能改变压缩效果。压缩算法利用重复模式来达到压缩效果。顺序改变会打乱这种模式。

    3. bsdiff是按顺序比较数据生成差分的。所以就算压缩原理数据相同,其在压缩文件中的顺序变化也会导致bsdiff生成不同的差分补丁。

    4. 压缩算法本身就利用了字典及顺序来提高压缩率。这与bsdiff的工作原理有一定冲突。综上,为了生成一致的bsdiff补丁,同一个数据生成压缩包时需要保证使用同一算法和稳定的顺序。否则差分结果可能会有较大变化。一般需要压缩数据再差分时,需要注意控制这两个因素,或者考虑在解压后对原始数据文件差分。

    所以，考虑解压后保持相同的目录结构进行差分，即为生成的.patch文件和原工程有相同的目录.

    所以需要写一个脚本，生成一个差分文件夹(目录),这个差分文件夹与原工程有相同的目录结构.

    后面再根据这个差分文件夹进行升级，即为patch文件与原文件作用生成新文件，新目标和原目标相同.通过这种服务器上生成差分包，客户端上作用差分包的形式，差分包可以压缩，在客户端上解压缩，这样能更快更合理.

    所以，总共需要有2个bash脚本,一个放服务器上,生成差分包.一个放客户端上，在收到差分包后进行本地升级.

    内容

    bsdiff和bspatch去官网上截至2023年10月27日没有下载源码的权限,所以得去别的地方找找源码.

    准备工作

    在windows平台上

    参考

    whistle713/bsdiff-win: bsdiff Windows binaries and Visual Studio 2015/2019 project. (github.com)

    里面有提供能够在windows平台上允许的.exe可执行文件.

    在linux平台上

    参考

    红橙Darren视频笔记 bsdiff bspatch 使用（Linux下）_洌冰的博客-CSDN博客

    完成编译

    正式工作

    这里需要考虑到旧的目标和新的目标的一些特殊情况.

    1. 新目标有新增文件的情况
    2. 新目标有删除原来旧文件的情况
    3. 新目标和旧目标的目录和文件都能对上,只是有变化.
    4. 旧目标和新目标有 大小为0 bytes 文件的情况(bsdiff失效)

    相信一般的升级都会遇到 1.2.3.4所有情况,

    对于第4种情况,不清楚是不是bsdiff的版本问题还是linux系统的问题，我在本地的liunx没有这个问题.

    bsdiff在处理 大小为 0 bytes的文件时在linux上报错

    报错

    bsdiff:mmap()  xxx:Invalid argument

    思路:

    对于第一种和第二种情况.

    新目标新增: 在旧目标中生成一个相同名字的文件，不过大小为0 bytes

    新目标有删除有原来旧文件的情况: 在新目标中生成一个相同名字的文件，大小依然为0bytes

    这样的话，只要不出现 4 的这种问题都是能够通过bsdiff 生成相应的bspatch文件的.

    生成差分文件思路

    1.同步旧目标(对应新目标有文件增加时)

    2.同步新目标(对应新目标删除了旧文件时)

    3.递归遍历目标中的每一个文件，在另一个目标中进行查找, 可以直接通过bsdiiff 生成差分文件,

    即使是两个相同的文件，也会生成patch文件，只不过bspatch 作用这个patch文件时并不会起作用，这样是非常方便了，都不需要进行判断了。这样表现为每一个文件都有对应的差分文件.(这个需要再我的代码上改一改)

    而我下面并没有这么做，而是根据md5的值判断文件不同后再生成对应的patch文件.

    作用差分文件思路

    直接遍历生成的差分文件目录结构,调用bspatch.

    在保持相同目录结构进行差分增量升级

    服务端(生成差分文件)

    调用.

     ./gen.sh(脚本名) ./old(旧目录) ./new (新目录)

    最终会生成一个以日期后缀的差分文件的目录(和原目录保持相同的目录结构) 

    1. #!/bin/bash
    2.  
    3. # check if two arguments are given
    4. if [ $# -ne 2 ]; then
    5.   echo "Usage: $0 oldfolder newfolder"
    6.   exit 1
    7. fi
    8.  
    9. # check if the arguments are valid directories
    10. if [ ! -d "$1" ] || [ ! -d "$2" ]; then
    11.   echo "Invalid directories"
    12.   exit 2
    13. fi
    14.  
    15. # if it is ended by '/' delete '/'
    16. inputemp=$1
    17. if test "${inputemp: -1}" == "/";then
    18.     s1=${inputemp%/}
    19. else 
    20.     s1=$inputemp
    21. fi
    22.  
    23. inputemp=$2
    24. if test "${inputemp: -1}" == "/";then
    25.     s2=${inputemp%/}
    26. else 
    27.     s2=$inputemp
    28. fi
    29.  
    30.  
    31.  
    32.  
    33. # create a new directory for patch files
    34. patch_dir="patch_$(date +%Y%m%d%H%M%S)"
    35. mkdir -p "$patch_dir"
    36.  
    37. # sync in new target
    38. find "$s1" -type f | while read oldfile; do
    39.   # get the relative path of the file
    40.   rel_path=${oldfile#$s1/}
    41.   # get the corresponding file in the second directory
    42.   newfile="$s2/$rel_path"
    43.   # exist in old and not exist in new and create same name to instead in the new folder 
    44.   if [ ! -f "$newfile" ]; then
    45.     echo -e "\033[0;36m [disapper in new]: $newfile Generate 0 Bytes to instead in new target \033[0m"
    46.      mkdir -p "$(dirname $newfile)"
    47.      > $newfile  
    48.   fi
    49.  
    50. done
    51.  
    52.  
    53. # sync in old target
    54. find "$s2" -type f | while read newfile; do
    55.   # get the relative path of the file
    56.   rel_path=${newfile#$s2/}
    57.   # get the corresponding file in the second directory
    58.   oldfile="$s1/$rel_path"
    59.   # exist in new and not exist in old and create same name to instead in the old folder 
    60.   if [ ! -f "$oldfile" ]; then
    61.   echo -e "\033[0;36m [disapper in old]: $oldfile Generate 0 Bytes to instead in old target  \033[0m"
    62.   #  create the parent directory if needed
    63.     mkdir -p "$(dirname oldfile)"
    64.     > $oldfile  
    65.   fi
    66.  
    67. done
    68.  
    69.  
    70. # Generate patch 
    71. find "$s1" -type f | while read oldfile; do
    72.  
    73.   # get the relative path of the file
    74.   rel_path=${oldfile#$s1/}
    75.   # get the corresponding file in the second directory
    76.   newfile="$s2/$rel_path"
    77.   # Haved sync and create the patch file name
    78.   patch_file="$patch_dir/$rel_path.patch"
    79.   # create the parent directory if needed
    80.   mkdir -p "$(dirname "$patch_file")"
    81.   # use bsdiff to generate the patch file
    82.   oldmd5=$(md5sum $oldfile | awk '{print $1}')
    83.   newmd5=$(md5sum $newfile | awk '{print $1}')
    84.  
    85.   if [ "$oldmd5" = "$newmd5" ]; then
    86.       
    87.   echo -e "\033[0;32m Don't Need to Change \033[0m"
    88.  
    89.   else
    90.       bsdiff "$oldfile" "$newfile" "$patch_file"
    91.       echo -e "\033[0;33mGenerated patch for $rel_path \033[0m"
    92.   fi
    93.    
    94.  
    95. done
    96.  
    97. echo "Done. Patch files are in $patch_dir"

    客户端(作用差分文件)

     调用

    脚本名 旧目标 新目标(也可以是旧目标 ,相当与替换旧目标) 差分目录
    1. #!/bin/bash
    2.  
    3.  
    4. # check if two arguments are given
    5. if [ $# -ne 3 ]; then
    6.   echo "Usage: cmd  oldfolder newfolder patchfolders"
    7.   exit 1
    8. fi
    9.  
    10. # new generate 
    11. if [ ! -e "$2" ]; then
    12. mkdir $2
    13. fi
    14.  
    15. # check if the arguments are valid directories
    16. if [ ! -d "$1" ] || [ ! -d "$3" ] ; then
    17.   echo "Invalid directories"
    18.   exit 2
    19. fi
    20.  
    21. # if it is ended by '/' delete '/'
    22. inputemp=$1
    23. if test "${inputemp: -1}" == "/";then
    24.     s1=${inputemp%/}
    25. else 
    26.     s1=$inputemp
    27. fi
    28.  
    29. inputemp=$2
    30. if test "${inputemp: -1}" == "/";then
    31.     s2=${inputemp%/}
    32. else 
    33.     s2=$inputemp
    34. fi
    35.  
    36.  
    37. inputemp=$3
    38. if test "${inputemp: -1}" == "/";then
    39.     s3=${inputemp%/}
    40. else 
    41.     s3=$inputemp
    42. fi
    43.  
    44.  
    45.  
    46.  
    47.  
    48.  
    49. #loop item in path_item
    50. find "$s3" -type f -name "*.patch" | while read patch_item; do
    51.     temp=${patch_item#$s3/}
    52.     temp=${temp%.patch}  #equal to   temp=${temp:0:${#temp}-6}
    53.     oldfile="$s1/$temp"
    54.     newfile="$s2/$temp"
    55.     mkdir -p "$(dirname "$newfile")"
    56.     echo -e "\033[0;32m Generate $oldfile $newfile \033[0m"
    57.     
    58. # execute bspatch
    59.     bspatch "$oldfile" "$newfile" "$patch_item"
    60.   
    61.  
    62.  
    63.  
    64. done
    65.

    如何使用?

    一般调用过程

    1. diff -rq ./old ./new(此时会看到文件差异)
    2.  
    3. ./gen ./old ./new
    4.  
    5. ./upgrate ./old ./old ./patch_xxx 
    6.  
    7. diff -rq ./old ./new (没有输出表示更新升级完毕)

    12月6日更新（修复bug)

    出现bug,找不到软链接文件,差分升级无法作用在存在的软连接文件.

    于是更新.

    •  解决找不到软连接文件的问题，现在能找到所有文件了(包括软链接和隐藏文件)
    •  删除同步过程中的空目录和空文件(0字节文件)

     

    gen.sh 

    1. #!/bin/bash
    2.  
    3.  
    4. #record waiting_for_delete_index
    5. wddi="waiting_for_dindex"
    6. GetAllfile()
    7. {
    8.         local ret=()
    9.         local links=$(find "$1" -type l)
    10.         local normal_files=$(find "$1" -type f)
    11.         while read -r item
    12.         do
    13.             ret+=($item)
    14.         done <<< "$links"
    15.         while read -r item
    16.         do
    17.             ret+=($item)
    18.         done <<< "$normal_files"
    19.         echo ${ret[@]}
    20. }
    21.  
    22.  
    23. # check if two arguments are given
    24. if [ $# -ne 2 ]; then
    25.   echo "Usage: $0 oldfolder newfolder"
    26.   exit 1
    27. fi
    28.  
    29. # check if the arguments are valid directories
    30. if [ ! -d "$1" ] || [ ! -d "$2" ]; then
    31.   echo "Invalid directories"
    32.   exit 2
    33. fi
    34.  
    35. # if it is ended by '/' delete '/'
    36. inputemp=$1
    37. if test "${inputemp: -1}" == "/";then
    38.     s1=${inputemp%/}
    39. else 
    40.     s1=$inputemp
    41. fi
    42.  
    43. inputemp=$2
    44. if test "${inputemp: -1}" == "/";then
    45.     s2=${inputemp%/}
    46. else 
    47.     s2=$inputemp
    48. fi
    49.  
    50.  
    51.  
    52.  
    53. # create a new directory for patch files
    54. patch_dir="$(dirname $s1)"/patch_"$(echo  "$s1" | awk -F'/' '{print $NF}')"
    55. echo  patch_path: $patch_dir 
    56. mkdir -p "$patch_dir"
    57.  
    58. wddi="$(dirname $s1)"/"$wddi"
    59.  
    60. if [ ! -f $wddi ];then
    61.   touch "$wddi"
    62. else 
    63.   > $wddi 
    64. fi
    65.  
    66. # sync in new target
    67. all_files=`GetAllfile $s1`
    68. all_files=$(echo  -n "$all_files" | tr ' ' '\n')
    69. echo "$all_files" | while read oldfile; do
    70.   # get the relative path of the file
    71.   rel_path=${oldfile#$s1/}
    72.   # get the corresponding file in the second directory
    73.   newfile="$s2/$rel_path"
    74.   # exist in old and not exist in new and create same name to instead in the new folder 
    75.   if [ ! -f "$newfile" ]; then
    76.     echo -e "\033[0;36m [disapper in new]: $newfile Generate 0 Bytes to instead in new target \033[0m"
    77.  
    78.   #appends not exist path recorded list
    79.     if [ ! -d "$(dirname $newfile)" ];then
    80.          mkdir -p "$(dirname $newfile)"
    81.          echo "$(dirname $rel_path)" >> $wddi    
    82.     fi
    83.   #write 0 bytes
    84.      > $newfile  
    85.   fi
    86.  
    87. done
    88.  
    89.  
    90. # sync in old target
    91. all_files=`GetAllfile $s2`
    92. all_files=$(echo  -n "$all_files" | tr ' ' '\n')
    93. echo "$all_files" | while read newfile; do
    94.   # get the relative path of the file
    95.   rel_path=${newfile#$s2/}
    96.   # get the corresponding file in the second directory
    97.   oldfile="$s1/$rel_path"
    98.   # exist in new and not exist in old and create same name to instead in the old folder 
    99.   if [ ! -f "$oldfile" ]; then
    100.   echo -e "\033[0;36m [disapper in old]: $oldfile Generate 0 Bytes to instead in old target  \033[0m"
    101.   #  create the parent directory if needed
    102.     mkdir -p "$(dirname $oldfile)"
    103.     > $oldfile  
    104.   fi
    105.  
    106. done
    107.  
    108.  
    109. # Generate patch 
    110. # when running  in this poision ,old target is same as new target
    111. all_files=`GetAllfile $s1`
    112. all_files=$(echo  -n $all_files | tr ' ' '\n')
    113. echo "$all_files"  | while read oldfile; do
    114.   # get the relative path of the file
    115.   rel_path=${oldfile#$s1/}
    116.   # get the corresponding file in the second directory
    117.   newfile="$s2/$rel_path"
    118.   # Haved sync and create the patch file name
    119.   patch_file="$patch_dir/$rel_path.patch"
    120.   # create the parent directory if needed
    121.   mkdir -p "$(dirname "$patch_file")"
    122.   # use bsdiff to generate the patch file
    123.   oldmd5=$(md5sum $oldfile | awk '{print $1}')
    124.   newmd5=$(md5sum $newfile | awk '{print $1}')
    125.  
    126.   if [ "$oldmd5" = "$newmd5" ]; then
    127.       
    128.   echo -e "\033[0;36m Don't Need to Change \033[0m"
    129.  
    130.   else
    131.       bsdiff "$oldfile" "$newfile" "$patch_file"
    132.       echo -e "\033[0;36mGenerated patch for $rel_path \033[0m"
    133.   fi
    134. done
    135.  
    136.  
    137. # after generating patchs_files ,delete extra 0 bytes files by delete index
    138. if [ ! -f $wddi ];
    139. then 
    140.     exit 1
    141. fi
    142. cat $wddi | while read del_item;
    143. do
    144.     realpath=$s2/$del_item
    145.     if [  -d "$realpath" ] ;then
    146.         echo $realpath
    147.         rm -rf $realpath
    148.     fi
    149. done
    150.  
    151. echo "Done. Patch files are in $patch_dir"

    upgrate.sh

    1. #!/bin/bash
    2.  
    3. # wdfi="waiting_for_delete"
    4. wddi="waiting_for_dindex"
    5. # check if two arguments are given
    6. if [ $# -ne 2 ]; then
    7.   echo "Usage: upgrade  oldfolder  patch_path "
    8.   echo "example ./upgrade   ./test/old/ ./test/boot/"
    9.   exit 1
    10. fi
    11.  
    12.  
    13.  
    14. # check if the arguments are valid directories
    15. if [ ! -d "$1" -o  ! -d "$2" ] ; then
    16.   echo "Invalid directories"
    17.   exit 2
    18. fi
    19.  
    20. # if it is ended by '/' delete '/' => old folder 
    21. inputemp=$1
    22. if test "${inputemp: -1}" == "/";then
    23.     s1=${inputemp%/}
    24. else 
    25.     s1=$inputemp
    26. fi
    27.  
    28. # if it is ended by '/' delete '/'=> patch_path
    29. inputemp=$2
    30. if test "${inputemp: -1}" == "/";then
    31.     patch_path=${inputemp%/}
    32. else 
    33.     patch_path=$inputemp
    34. fi 
    35.  
    36. wddi="$patch_path/$wddi"
    37. echo    wddi : "$wddi"
    38.  
    39. patch_path="$patch_path"/patch_"$(echo  "$s1" | awk -F'/' '{print $NF}')"
    40. echo find patch_path:  $patch_path
    41.  
    42.  
    43.  
    44. #loop item in path_item
    45. find "$patch_path" -type f -name "*.patch" | while read patch_item; do
    46.     temp=${patch_item#$patch_path/}
    47.     temp=${temp%.patch}  #equal to   temp=${temp:0:${#temp}-6}
    48.     oldfile="$s1/$temp"
    49.     newfile="$s1/$temp"
    50.     mkdir -p "$(dirname "$newfile")"
    51.     if [ ! -f "$newfile" ];
    52.     then
    53.     > $newfile
    54.     fi
    55.     echo -e "\033[0;36m Generate $oldfile $newfile \033[0m"
    56.     
    57. # execute bspatch
    58.     bspatch "$oldfile" "$newfile" "$patch_item"
    59. done
    60.  
    61.  
    62. #delete not exist index when  processing  to delete 
    63. if [ ! -f $wddi ];
    64. then 
    65.     exit 1
    66. fi
    67. cat $wddi | while read del_item;
    68. do
    69.     realpath=$s1/$del_item
    70.     if [  -d "$realpath" ] ;then
    71.         echo $realpath
    72.         rm -rf $realpath
    73.     fi
    74. done
    75. echo "done"

    执行分析

    这样在服务端上执行

    ./gen  ./test/old  ./test/new (old是旧版本，new为新版本)，则在test下生成patch_old,和waiting_for_dindex.

    ./upgrade  旧文件位置  pathch文件父路径（不包括pathch文件名）

    注意事项和关注的地方:
    1. 在生成patch文件的时候，也就是 ./gen 脚本 ,先让旧目录和新目录进行了同步，最终根据每一个文件生成patch文件，并把这些patch文件单独放在pathch_旧目录名 这个目录下，这个目录和旧目录(新目录有相同的目录结构.
    2. 在./gen脚本中，因为做了同步，如果存在新版本中删除旧目录，则会将被删除的旧目录同步到新目录中，并把被删除的旧目录存放在一个清单列表中(如wddi),最终在打完patch后会在服务器端删除这些同步的内容.
    3. ./upgrade脚本 接受传入一个旧目录，和一个patch目录的父路径(不包括patch目录名),这样会在patch的父目录中寻找以旧目录后缀结尾的patch目录,然后遍历这个patch目录依次调用bspatch升级, 最终在客户端调用升级完成后会根据清单去删除同步过程中产生旧目录，0字节的文件.

  • 相关阅读:
    中倍健未来数智药房首获红杉基金1千万美元天使轮融资
    Github 2024-05-30开源项目日报Top10
    分析SSH登录日志
    RocketMQ如何保证消息被有序消费
    【C++】模板初阶
    单一职责原则
    OneNote 深度评测：使用资源、插件、模版
    workflow一次完成多个模型评价和比较
    用c++写一个高精度计算的乘法运算
    Python基础学习笔记1（AI Studio）
  • 原文地址：https://blog.csdn.net/PHILICS7/article/details/134077783