├── .github
└── workflows
│ ├── go_build.yml
│ ├── go_static_analysis.yml
│ ├── markdownlint.yml
│ └── test.yml
├── .mdl.rb
├── .mdlrc
├── .yamllint
├── CODE_OF_CONDUCT.md
├── LICENSE
├── README.md
├── go.mod
├── main.go
├── pkg
└── btrfs-diff.go
├── test.data
└── test.sh
/.github/workflows/go_build.yml:
--------------------------------------------------------------------------------
1 | ---
2 | # This is a basic workflow to help you get started with Actions
3 |
4 | name: Go build
5 |
6 | # Controls when the action will run.
7 | on: # yamllint disable-line rule:truthy
8 | # Triggers the workflow on push or pull request events but only for the main branch
9 | push:
10 | branches: [master]
11 | pull_request:
12 | branches: [master]
13 |
14 | # Allows you to run this workflow manually from the Actions tab
15 | workflow_dispatch:
16 |
17 | # A workflow run is made up of one or more jobs that can run sequentially or in parallel
18 | jobs:
19 |
20 | # This workflow contains a single job called "build"
21 | build:
22 |
23 | # The type of runner that the job will run on
24 | runs-on: ubuntu-latest
25 |
26 | strategy:
27 | matrix:
28 | go: ['1.14', '1.15', '1.16', '1.17']
29 |
30 | name: Go ${{ matrix.go }} build
31 |
32 | steps:
33 |
34 | # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
35 | - uses: actions/checkout@v2
36 |
37 | # Install required packages dependencies
38 | - name: Install required packages dependencies
39 | run: DEBIAN_FRONTEND=noninteractive sudo apt-get -q -y install libbtrfs-dev
40 |
41 | # Setup different version of golang
42 | - name: Setup go
43 | uses: actions/setup-go@v2
44 | with:
45 | go-version: ${{ matrix.go }}
46 |
47 | # Build the binary
48 | - name: Building the binary
49 | run: go build -v
50 |
--------------------------------------------------------------------------------
/.github/workflows/go_static_analysis.yml:
--------------------------------------------------------------------------------
1 | ---
2 | # This is a basic workflow to help you get started with Actions
3 |
4 | name: Go static analysis
5 |
6 | # Controls when the action will run.
7 | on: # yamllint disable-line rule:truthy
8 | # Triggers the workflow on push or pull request events but only for the main branch
9 | push:
10 | branches: [master]
11 | pull_request:
12 | branches: [master]
13 |
14 | # Allows you to run this workflow manually from the Actions tab
15 | workflow_dispatch:
16 |
17 | # A workflow run is made up of one or more jobs that can run sequentially or in parallel
18 | jobs:
19 |
20 | # This workflow contains a single job called "build"
21 | build:
22 |
23 | # The type of runner that the job will run on
24 | runs-on: ubuntu-latest
25 |
26 | strategy:
27 | matrix:
28 | go: ['1.14', '1.15', '1.16', '1.17']
29 |
30 | name: Go ${{ matrix.go }} analysis
31 |
32 | steps:
33 |
34 | # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
35 | - uses: actions/checkout@v2
36 |
37 | # Install required packages dependencies
38 | - name: Install required packages dependencies
39 | run: DEBIAN_FRONTEND=noninteractive sudo apt-get -q -y install libbtrfs-dev
40 |
41 | # Setup different version of golang
42 | - name: Setup go
43 | uses: actions/setup-go@v2
44 | with:
45 | go-version: ${{ matrix.go }}
46 |
47 | # Install required packages dependencies
48 | - name: Install required packages dependencies
49 | run: |
50 | go get -u \
51 | github.com/kisielk/errcheck \
52 | golang.org/x/tools/cmd/goimports \
53 | golang.org/x/lint/golint \
54 | github.com/securego/gosec/cmd/gosec \
55 | golang.org/x/tools/go/analysis/passes/shadow/cmd/shadow \
56 | honnef.co/go/tools/cmd/staticcheck \
57 | github.com/gordonklaus/ineffassign
58 |
59 | # Static analysis checks
60 | - name: Linting (golint)
61 | run: golint -set_exit_status ./...
62 |
63 | - name: Formatting (gofmt)
64 | run: gofmt -l -s .
65 |
66 | - name: Error checking (errcheck)
67 | run: errcheck ./...
68 |
69 | - name: Imports checks (goimports)
70 | run: goimports -l .
71 |
72 | - name: Linting (govet)
73 | run: go vet ./...
74 |
75 | - name: Linting (shadow)
76 | run: go vet -vettool=$(command -v shadow) ./...
77 |
78 | - name: Security checks (gosec)
79 | run: gosec -out result.txt ./...
80 |
81 | - name: Static analysis (staticcheck)
82 | run: staticcheck ./...
83 |
84 | - name: Ineffectual assignments (ineffassign)
85 | run: ineffassign ./...
86 |
--------------------------------------------------------------------------------
/.github/workflows/markdownlint.yml:
--------------------------------------------------------------------------------
1 | ---
2 | # This is a basic workflow to help you get started with Actions
3 |
4 | name: MarkdownLint
5 |
6 | # Controls when the action will run.
7 | on: # yamllint disable-line rule:truthy
8 | # Triggers the workflow on push or pull request events but only for the main branch
9 | push:
10 | branches: [master]
11 | pull_request:
12 | branches: [master]
13 |
14 | # Allows you to run this workflow manually from the Actions tab
15 | workflow_dispatch:
16 |
17 | # A workflow run is made up of one or more jobs that can run sequentially or in parallel
18 | jobs:
19 | # This workflow contains a single job called "build"
20 | build:
21 | # The type of runner that the job will run on
22 | runs-on: ubuntu-latest
23 |
24 | # Steps represent a sequence of tasks that will be executed as part of the job
25 | steps:
26 | # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
27 | - uses: actions/checkout@v2
28 |
29 | # Runs the markdown linter
30 | - name: Run mdl
31 | uses: actionshub/markdownlint@main
32 |
--------------------------------------------------------------------------------
/.github/workflows/test.yml:
--------------------------------------------------------------------------------
1 | ---
2 | # This is a basic workflow to help you get started with Actions
3 |
4 | name: Test
5 |
6 | # Controls when the action will run.
7 | on: # yamllint disable-line rule:truthy
8 | # Triggers the workflow on push or pull request events but only for the main branch
9 | push:
10 | branches: [master]
11 | pull_request:
12 | branches: [master]
13 |
14 | # Allows you to run this workflow manually from the Actions tab
15 | workflow_dispatch:
16 |
17 | # A workflow run is made up of one or more jobs that can run sequentially or in parallel
18 | jobs:
19 |
20 | # This workflow contains a single job called "build"
21 | build:
22 |
23 | # The type of runner that the job will run on
24 | runs-on: ubuntu-latest
25 |
26 | strategy:
27 | matrix:
28 | go: ['1.14', '1.15', '1.16', '1.17']
29 |
30 | name: Go ${{ matrix.go }} build
31 |
32 | steps:
33 |
34 | # Checks-out your repository under $GITHUB_WORKSPACE, so your job can access it
35 | - uses: actions/checkout@v2
36 |
37 | # Install required packages dependencies
38 | - name: Install required packages dependencies
39 | run: DEBIAN_FRONTEND=noninteractive sudo apt-get -q -y install libbtrfs-dev btrfs-progs
40 |
41 | # Setup different version of golang
42 | - name: Setup go
43 | uses: actions/setup-go@v2
44 | with:
45 | go-version: ${{ matrix.go }}
46 |
47 | # Build the binary and install it
48 | - name: Building the binary and install it
49 | run: go build -v && go install -v
50 |
51 | # Create a BTRFS file
52 | - name: Creating an image file with a BTRFS filesystem
53 | run: rm -f test.img && truncate -s 150M test.img && sudo mkfs.btrfs -f test.img
54 |
55 | # Unmount (preventive)
56 | - name: Unmounting the BTRFS image file (preventive)
57 | run: if LC_ALL=C mount | grep -q ' on .*test\.mnt'; then sudo umount -v test.mnt; fi
58 |
59 | # Mount it
60 | - name: Mouting the BTRFS image file
61 | run: |
62 | sudo rm -fr test.mnt && sudo mkdir test.mnt && \
63 | sudo mount -v -t btrfs -o loop test.img test.mnt
64 |
65 | # Running the tests
66 | - name: Running the tests
67 | run: |
68 | TMPDIR="$(pwd)"/.tmp TEST_DIR="$(pwd)"/test.mnt \
69 | BTRFS_DIFF_BIN="$(command -v btrfs-diff-go)" sh test.sh
70 |
71 | # Unmount
72 | - name: Unmounting the BTRFS image file
73 | run: if LC_ALL=C mount | grep -q ' on .*test\.mnt'; then sudo umount -v test.mnt; fi
74 | if: always()
75 |
76 | # Cleanup
77 | - name: Cleaning up
78 | run: rm -fr test.img test.mnt
79 | if: always()
80 |
--------------------------------------------------------------------------------
/.mdl.rb:
--------------------------------------------------------------------------------
1 | # Enable all rules by default
2 | all
3 |
4 | # Extend line length
5 | rule 'MD013', :line_length => 100, :code_blocks => false
6 |
7 | # Allow two trailing space (for forcing line break)
8 | rule 'MD009', :br_spaces => 2
9 |
10 | # Allow multiple consecutive blank lines (specially in code blocks)
11 | exclude_rule 'MD012'
12 |
13 | # Allow heading terminaison with punctuation and emoji tag
14 | exclude_rule 'MD026'
15 |
--------------------------------------------------------------------------------
/.mdlrc:
--------------------------------------------------------------------------------
1 | style '.mdl.rb'
2 |
--------------------------------------------------------------------------------
/.yamllint:
--------------------------------------------------------------------------------
1 | ---
2 | extends: default
3 |
4 | rules:
5 | # 100 chars should be enough, but don't fail if a line is longer
6 | line-length:
7 | max: 100
8 | level: warning
9 |
--------------------------------------------------------------------------------
/CODE_OF_CONDUCT.md:
--------------------------------------------------------------------------------
1 | # Contributor Covenant Code of Conduct
2 |
3 | ## Our Pledge
4 |
5 | We as members, contributors, and leaders pledge to make participation in our
6 | community a harassment-free experience for everyone, regardless of age, body
7 | size, visible or invisible disability, ethnicity, sex characteristics, gender
8 | identity and expression, level of experience, education, socio-economic status,
9 | nationality, personal appearance, race, religion, or sexual identity
10 | and orientation.
11 |
12 | We pledge to act and interact in ways that contribute to an open, welcoming,
13 | diverse, inclusive, and healthy community.
14 |
15 | ## Our Standards
16 |
17 | Examples of behavior that contributes to a positive environment for our
18 | community include:
19 |
20 | * Demonstrating empathy and kindness toward other people
21 | * Being respectful of differing opinions, viewpoints, and experiences
22 | * Giving and gracefully accepting constructive feedback
23 | * Accepting responsibility and apologizing to those affected by our mistakes,
24 | and learning from the experience
25 | * Focusing on what is best not just for us as individuals, but for the
26 | overall community
27 |
28 | Examples of unacceptable behavior include:
29 |
30 | * The use of sexualized language or imagery, and sexual attention or
31 | advances of any kind
32 | * Trolling, insulting or derogatory comments, and personal or political attacks
33 | * Public or private harassment
34 | * Publishing others' private information, such as a physical or email
35 | address, without their explicit permission
36 | * Other conduct which could reasonably be considered inappropriate in a
37 | professional setting
38 |
39 | ## Enforcement Responsibilities
40 |
41 | Community leaders are responsible for clarifying and enforcing our standards of
42 | acceptable behavior and will take appropriate and fair corrective action in
43 | response to any behavior that they deem inappropriate, threatening, offensive,
44 | or harmful.
45 |
46 | Community leaders have the right and responsibility to remove, edit, or reject
47 | comments, commits, code, wiki edits, issues, and other contributions that are
48 | not aligned to this Code of Conduct, and will communicate reasons for moderation
49 | decisions when appropriate.
50 |
51 | ## Scope
52 |
53 | This Code of Conduct applies within all community spaces, and also applies when
54 | an individual is officially representing the community in public spaces.
55 | Examples of representing our community include using an official e-mail address,
56 | posting via an official social media account, or acting as an appointed
57 | representative at an online or offline event.
58 |
59 | ## Enforcement
60 |
61 | Instances of abusive, harassing, or otherwise unacceptable behavior may be
62 | reported to the community leaders responsible for enforcement at
63 | [the project issues page](https://github.com/mbideau/gimme-a-man/issues).
64 | All complaints will be reviewed and investigated promptly and fairly.
65 |
66 | All community leaders are obligated to respect the privacy and security of the
67 | reporter of any incident.
68 |
69 | ## Enforcement Guidelines
70 |
71 | Community leaders will follow these Community Impact Guidelines in determining
72 | the consequences for any action they deem in violation of this Code of Conduct:
73 |
74 | ### 1. Correction
75 |
76 | **Community Impact**: Use of inappropriate language or other behavior deemed
77 | unprofessional or unwelcome in the community.
78 |
79 | **Consequence**: A private, written warning from community leaders, providing
80 | clarity around the nature of the violation and an explanation of why the
81 | behavior was inappropriate. A public apology may be requested.
82 |
83 | ### 2. Warning
84 |
85 | **Community Impact**: A violation through a single incident or series
86 | of actions.
87 |
88 | **Consequence**: A warning with consequences for continued behavior. No
89 | interaction with the people involved, including unsolicited interaction with
90 | those enforcing the Code of Conduct, for a specified period of time. This
91 | includes avoiding interactions in community spaces as well as external channels
92 | like social media. Violating these terms may lead to a temporary or
93 | permanent ban.
94 |
95 | ### 3. Temporary Ban
96 |
97 | **Community Impact**: A serious violation of community standards, including
98 | sustained inappropriate behavior.
99 |
100 | **Consequence**: A temporary ban from any sort of interaction or public
101 | communication with the community for a specified period of time. No public or
102 | private interaction with the people involved, including unsolicited interaction
103 | with those enforcing the Code of Conduct, is allowed during this period.
104 | Violating these terms may lead to a permanent ban.
105 |
106 | ### 4. Permanent Ban
107 |
108 | **Community Impact**: Demonstrating a pattern of violation of community
109 | standards, including sustained inappropriate behavior, harassment of an
110 | individual, or aggression toward or disparagement of classes of individuals.
111 |
112 | **Consequence**: A permanent ban from any sort of public interaction within
113 | the community.
114 |
115 | ## Attribution
116 |
117 | This Code of Conduct is adapted from the [Contributor Covenant][homepage],
118 | version 2.0, available at
119 | [https://www.contributor-covenant.org/version/2/0/code_of_conduct.html][v2.0].
120 |
121 | Community Impact Guidelines were inspired by
122 | [Mozilla's code of conduct enforcement ladder][Mozilla CoC].
123 |
124 | For answers to common questions about this code of conduct, see the FAQ at
125 | [https://www.contributor-covenant.org/faq][FAQ]. Translations are available
126 | at [https://www.contributor-covenant.org/translations][translations].
127 |
128 | [homepage]: https://www.contributor-covenant.org
129 | [v2.0]: https://www.contributor-covenant.org/version/2/0/code_of_conduct.html
130 | [Mozilla CoC]: https://github.com/mozilla/diversity
131 | [FAQ]: https://www.contributor-covenant.org/faq
132 | [translations]: https://www.contributor-covenant.org/translations
133 |
134 |
--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | GNU GENERAL PUBLIC LICENSE
2 | Version 3, 29 June 2007
3 |
4 | Copyright (C) 2007 Free Software Foundation, Inc.
5 | Everyone is permitted to copy and distribute verbatim copies
6 | of this license document, but changing it is not allowed.
7 |
8 | Preamble
9 |
10 | The GNU General Public License is a free, copyleft license for
11 | software and other kinds of works.
12 |
13 | The licenses for most software and other practical works are designed
14 | to take away your freedom to share and change the works. By contrast,
15 | the GNU General Public License is intended to guarantee your freedom to
16 | share and change all versions of a program--to make sure it remains free
17 | software for all its users. We, the Free Software Foundation, use the
18 | GNU General Public License for most of our software; it applies also to
19 | any other work released this way by its authors. You can apply it to
20 | your programs, too.
21 |
22 | When we speak of free software, we are referring to freedom, not
23 | price. Our General Public Licenses are designed to make sure that you
24 | have the freedom to distribute copies of free software (and charge for
25 | them if you wish), that you receive source code or can get it if you
26 | want it, that you can change the software or use pieces of it in new
27 | free programs, and that you know you can do these things.
28 |
29 | To protect your rights, we need to prevent others from denying you
30 | these rights or asking you to surrender the rights. Therefore, you have
31 | certain responsibilities if you distribute copies of the software, or if
32 | you modify it: responsibilities to respect the freedom of others.
33 |
34 | For example, if you distribute copies of such a program, whether
35 | gratis or for a fee, you must pass on to the recipients the same
36 | freedoms that you received. You must make sure that they, too, receive
37 | or can get the source code. And you must show them these terms so they
38 | know their rights.
39 |
40 | Developers that use the GNU GPL protect your rights with two steps:
41 | (1) assert copyright on the software, and (2) offer you this License
42 | giving you legal permission to copy, distribute and/or modify it.
43 |
44 | For the developers' and authors' protection, the GPL clearly explains
45 | that there is no warranty for this free software. For both users' and
46 | authors' sake, the GPL requires that modified versions be marked as
47 | changed, so that their problems will not be attributed erroneously to
48 | authors of previous versions.
49 |
50 | Some devices are designed to deny users access to install or run
51 | modified versions of the software inside them, although the manufacturer
52 | can do so. This is fundamentally incompatible with the aim of
53 | protecting users' freedom to change the software. The systematic
54 | pattern of such abuse occurs in the area of products for individuals to
55 | use, which is precisely where it is most unacceptable. Therefore, we
56 | have designed this version of the GPL to prohibit the practice for those
57 | products. If such problems arise substantially in other domains, we
58 | stand ready to extend this provision to those domains in future versions
59 | of the GPL, as needed to protect the freedom of users.
60 |
61 | Finally, every program is threatened constantly by software patents.
62 | States should not allow patents to restrict development and use of
63 | software on general-purpose computers, but in those that do, we wish to
64 | avoid the special danger that patents applied to a free program could
65 | make it effectively proprietary. To prevent this, the GPL assures that
66 | patents cannot be used to render the program non-free.
67 |
68 | The precise terms and conditions for copying, distribution and
69 | modification follow.
70 |
71 | TERMS AND CONDITIONS
72 |
73 | 0. Definitions.
74 |
75 | "This License" refers to version 3 of the GNU General Public License.
76 |
77 | "Copyright" also means copyright-like laws that apply to other kinds of
78 | works, such as semiconductor masks.
79 |
80 | "The Program" refers to any copyrightable work licensed under this
81 | License. Each licensee is addressed as "you". "Licensees" and
82 | "recipients" may be individuals or organizations.
83 |
84 | To "modify" a work means to copy from or adapt all or part of the work
85 | in a fashion requiring copyright permission, other than the making of an
86 | exact copy. The resulting work is called a "modified version" of the
87 | earlier work or a work "based on" the earlier work.
88 |
89 | A "covered work" means either the unmodified Program or a work based
90 | on the Program.
91 |
92 | To "propagate" a work means to do anything with it that, without
93 | permission, would make you directly or secondarily liable for
94 | infringement under applicable copyright law, except executing it on a
95 | computer or modifying a private copy. Propagation includes copying,
96 | distribution (with or without modification), making available to the
97 | public, and in some countries other activities as well.
98 |
99 | To "convey" a work means any kind of propagation that enables other
100 | parties to make or receive copies. Mere interaction with a user through
101 | a computer network, with no transfer of a copy, is not conveying.
102 |
103 | An interactive user interface displays "Appropriate Legal Notices"
104 | to the extent that it includes a convenient and prominently visible
105 | feature that (1) displays an appropriate copyright notice, and (2)
106 | tells the user that there is no warranty for the work (except to the
107 | extent that warranties are provided), that licensees may convey the
108 | work under this License, and how to view a copy of this License. If
109 | the interface presents a list of user commands or options, such as a
110 | menu, a prominent item in the list meets this criterion.
111 |
112 | 1. Source Code.
113 |
114 | The "source code" for a work means the preferred form of the work
115 | for making modifications to it. "Object code" means any non-source
116 | form of a work.
117 |
118 | A "Standard Interface" means an interface that either is an official
119 | standard defined by a recognized standards body, or, in the case of
120 | interfaces specified for a particular programming language, one that
121 | is widely used among developers working in that language.
122 |
123 | The "System Libraries" of an executable work include anything, other
124 | than the work as a whole, that (a) is included in the normal form of
125 | packaging a Major Component, but which is not part of that Major
126 | Component, and (b) serves only to enable use of the work with that
127 | Major Component, or to implement a Standard Interface for which an
128 | implementation is available to the public in source code form. A
129 | "Major Component", in this context, means a major essential component
130 | (kernel, window system, and so on) of the specific operating system
131 | (if any) on which the executable work runs, or a compiler used to
132 | produce the work, or an object code interpreter used to run it.
133 |
134 | The "Corresponding Source" for a work in object code form means all
135 | the source code needed to generate, install, and (for an executable
136 | work) run the object code and to modify the work, including scripts to
137 | control those activities. However, it does not include the work's
138 | System Libraries, or general-purpose tools or generally available free
139 | programs which are used unmodified in performing those activities but
140 | which are not part of the work. For example, Corresponding Source
141 | includes interface definition files associated with source files for
142 | the work, and the source code for shared libraries and dynamically
143 | linked subprograms that the work is specifically designed to require,
144 | such as by intimate data communication or control flow between those
145 | subprograms and other parts of the work.
146 |
147 | The Corresponding Source need not include anything that users
148 | can regenerate automatically from other parts of the Corresponding
149 | Source.
150 |
151 | The Corresponding Source for a work in source code form is that
152 | same work.
153 |
154 | 2. Basic Permissions.
155 |
156 | All rights granted under this License are granted for the term of
157 | copyright on the Program, and are irrevocable provided the stated
158 | conditions are met. This License explicitly affirms your unlimited
159 | permission to run the unmodified Program. The output from running a
160 | covered work is covered by this License only if the output, given its
161 | content, constitutes a covered work. This License acknowledges your
162 | rights of fair use or other equivalent, as provided by copyright law.
163 |
164 | You may make, run and propagate covered works that you do not
165 | convey, without conditions so long as your license otherwise remains
166 | in force. You may convey covered works to others for the sole purpose
167 | of having them make modifications exclusively for you, or provide you
168 | with facilities for running those works, provided that you comply with
169 | the terms of this License in conveying all material for which you do
170 | not control copyright. Those thus making or running the covered works
171 | for you must do so exclusively on your behalf, under your direction
172 | and control, on terms that prohibit them from making any copies of
173 | your copyrighted material outside their relationship with you.
174 |
175 | Conveying under any other circumstances is permitted solely under
176 | the conditions stated below. Sublicensing is not allowed; section 10
177 | makes it unnecessary.
178 |
179 | 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
180 |
181 | No covered work shall be deemed part of an effective technological
182 | measure under any applicable law fulfilling obligations under article
183 | 11 of the WIPO copyright treaty adopted on 20 December 1996, or
184 | similar laws prohibiting or restricting circumvention of such
185 | measures.
186 |
187 | When you convey a covered work, you waive any legal power to forbid
188 | circumvention of technological measures to the extent such circumvention
189 | is effected by exercising rights under this License with respect to
190 | the covered work, and you disclaim any intention to limit operation or
191 | modification of the work as a means of enforcing, against the work's
192 | users, your or third parties' legal rights to forbid circumvention of
193 | technological measures.
194 |
195 | 4. Conveying Verbatim Copies.
196 |
197 | You may convey verbatim copies of the Program's source code as you
198 | receive it, in any medium, provided that you conspicuously and
199 | appropriately publish on each copy an appropriate copyright notice;
200 | keep intact all notices stating that this License and any
201 | non-permissive terms added in accord with section 7 apply to the code;
202 | keep intact all notices of the absence of any warranty; and give all
203 | recipients a copy of this License along with the Program.
204 |
205 | You may charge any price or no price for each copy that you convey,
206 | and you may offer support or warranty protection for a fee.
207 |
208 | 5. Conveying Modified Source Versions.
209 |
210 | You may convey a work based on the Program, or the modifications to
211 | produce it from the Program, in the form of source code under the
212 | terms of section 4, provided that you also meet all of these conditions:
213 |
214 | a) The work must carry prominent notices stating that you modified
215 | it, and giving a relevant date.
216 |
217 | b) The work must carry prominent notices stating that it is
218 | released under this License and any conditions added under section
219 | 7. This requirement modifies the requirement in section 4 to
220 | "keep intact all notices".
221 |
222 | c) You must license the entire work, as a whole, under this
223 | License to anyone who comes into possession of a copy. This
224 | License will therefore apply, along with any applicable section 7
225 | additional terms, to the whole of the work, and all its parts,
226 | regardless of how they are packaged. This License gives no
227 | permission to license the work in any other way, but it does not
228 | invalidate such permission if you have separately received it.
229 |
230 | d) If the work has interactive user interfaces, each must display
231 | Appropriate Legal Notices; however, if the Program has interactive
232 | interfaces that do not display Appropriate Legal Notices, your
233 | work need not make them do so.
234 |
235 | A compilation of a covered work with other separate and independent
236 | works, which are not by their nature extensions of the covered work,
237 | and which are not combined with it such as to form a larger program,
238 | in or on a volume of a storage or distribution medium, is called an
239 | "aggregate" if the compilation and its resulting copyright are not
240 | used to limit the access or legal rights of the compilation's users
241 | beyond what the individual works permit. Inclusion of a covered work
242 | in an aggregate does not cause this License to apply to the other
243 | parts of the aggregate.
244 |
245 | 6. Conveying Non-Source Forms.
246 |
247 | You may convey a covered work in object code form under the terms
248 | of sections 4 and 5, provided that you also convey the
249 | machine-readable Corresponding Source under the terms of this License,
250 | in one of these ways:
251 |
252 | a) Convey the object code in, or embodied in, a physical product
253 | (including a physical distribution medium), accompanied by the
254 | Corresponding Source fixed on a durable physical medium
255 | customarily used for software interchange.
256 |
257 | b) Convey the object code in, or embodied in, a physical product
258 | (including a physical distribution medium), accompanied by a
259 | written offer, valid for at least three years and valid for as
260 | long as you offer spare parts or customer support for that product
261 | model, to give anyone who possesses the object code either (1) a
262 | copy of the Corresponding Source for all the software in the
263 | product that is covered by this License, on a durable physical
264 | medium customarily used for software interchange, for a price no
265 | more than your reasonable cost of physically performing this
266 | conveying of source, or (2) access to copy the
267 | Corresponding Source from a network server at no charge.
268 |
269 | c) Convey individual copies of the object code with a copy of the
270 | written offer to provide the Corresponding Source. This
271 | alternative is allowed only occasionally and noncommercially, and
272 | only if you received the object code with such an offer, in accord
273 | with subsection 6b.
274 |
275 | d) Convey the object code by offering access from a designated
276 | place (gratis or for a charge), and offer equivalent access to the
277 | Corresponding Source in the same way through the same place at no
278 | further charge. You need not require recipients to copy the
279 | Corresponding Source along with the object code. If the place to
280 | copy the object code is a network server, the Corresponding Source
281 | may be on a different server (operated by you or a third party)
282 | that supports equivalent copying facilities, provided you maintain
283 | clear directions next to the object code saying where to find the
284 | Corresponding Source. Regardless of what server hosts the
285 | Corresponding Source, you remain obligated to ensure that it is
286 | available for as long as needed to satisfy these requirements.
287 |
288 | e) Convey the object code using peer-to-peer transmission, provided
289 | you inform other peers where the object code and Corresponding
290 | Source of the work are being offered to the general public at no
291 | charge under subsection 6d.
292 |
293 | A separable portion of the object code, whose source code is excluded
294 | from the Corresponding Source as a System Library, need not be
295 | included in conveying the object code work.
296 |
297 | A "User Product" is either (1) a "consumer product", which means any
298 | tangible personal property which is normally used for personal, family,
299 | or household purposes, or (2) anything designed or sold for incorporation
300 | into a dwelling. In determining whether a product is a consumer product,
301 | doubtful cases shall be resolved in favor of coverage. For a particular
302 | product received by a particular user, "normally used" refers to a
303 | typical or common use of that class of product, regardless of the status
304 | of the particular user or of the way in which the particular user
305 | actually uses, or expects or is expected to use, the product. A product
306 | is a consumer product regardless of whether the product has substantial
307 | commercial, industrial or non-consumer uses, unless such uses represent
308 | the only significant mode of use of the product.
309 |
310 | "Installation Information" for a User Product means any methods,
311 | procedures, authorization keys, or other information required to install
312 | and execute modified versions of a covered work in that User Product from
313 | a modified version of its Corresponding Source. The information must
314 | suffice to ensure that the continued functioning of the modified object
315 | code is in no case prevented or interfered with solely because
316 | modification has been made.
317 |
318 | If you convey an object code work under this section in, or with, or
319 | specifically for use in, a User Product, and the conveying occurs as
320 | part of a transaction in which the right of possession and use of the
321 | User Product is transferred to the recipient in perpetuity or for a
322 | fixed term (regardless of how the transaction is characterized), the
323 | Corresponding Source conveyed under this section must be accompanied
324 | by the Installation Information. But this requirement does not apply
325 | if neither you nor any third party retains the ability to install
326 | modified object code on the User Product (for example, the work has
327 | been installed in ROM).
328 |
329 | The requirement to provide Installation Information does not include a
330 | requirement to continue to provide support service, warranty, or updates
331 | for a work that has been modified or installed by the recipient, or for
332 | the User Product in which it has been modified or installed. Access to a
333 | network may be denied when the modification itself materially and
334 | adversely affects the operation of the network or violates the rules and
335 | protocols for communication across the network.
336 |
337 | Corresponding Source conveyed, and Installation Information provided,
338 | in accord with this section must be in a format that is publicly
339 | documented (and with an implementation available to the public in
340 | source code form), and must require no special password or key for
341 | unpacking, reading or copying.
342 |
343 | 7. Additional Terms.
344 |
345 | "Additional permissions" are terms that supplement the terms of this
346 | License by making exceptions from one or more of its conditions.
347 | Additional permissions that are applicable to the entire Program shall
348 | be treated as though they were included in this License, to the extent
349 | that they are valid under applicable law. If additional permissions
350 | apply only to part of the Program, that part may be used separately
351 | under those permissions, but the entire Program remains governed by
352 | this License without regard to the additional permissions.
353 |
354 | When you convey a copy of a covered work, you may at your option
355 | remove any additional permissions from that copy, or from any part of
356 | it. (Additional permissions may be written to require their own
357 | removal in certain cases when you modify the work.) You may place
358 | additional permissions on material, added by you to a covered work,
359 | for which you have or can give appropriate copyright permission.
360 |
361 | Notwithstanding any other provision of this License, for material you
362 | add to a covered work, you may (if authorized by the copyright holders of
363 | that material) supplement the terms of this License with terms:
364 |
365 | a) Disclaiming warranty or limiting liability differently from the
366 | terms of sections 15 and 16 of this License; or
367 |
368 | b) Requiring preservation of specified reasonable legal notices or
369 | author attributions in that material or in the Appropriate Legal
370 | Notices displayed by works containing it; or
371 |
372 | c) Prohibiting misrepresentation of the origin of that material, or
373 | requiring that modified versions of such material be marked in
374 | reasonable ways as different from the original version; or
375 |
376 | d) Limiting the use for publicity purposes of names of licensors or
377 | authors of the material; or
378 |
379 | e) Declining to grant rights under trademark law for use of some
380 | trade names, trademarks, or service marks; or
381 |
382 | f) Requiring indemnification of licensors and authors of that
383 | material by anyone who conveys the material (or modified versions of
384 | it) with contractual assumptions of liability to the recipient, for
385 | any liability that these contractual assumptions directly impose on
386 | those licensors and authors.
387 |
388 | All other non-permissive additional terms are considered "further
389 | restrictions" within the meaning of section 10. If the Program as you
390 | received it, or any part of it, contains a notice stating that it is
391 | governed by this License along with a term that is a further
392 | restriction, you may remove that term. If a license document contains
393 | a further restriction but permits relicensing or conveying under this
394 | License, you may add to a covered work material governed by the terms
395 | of that license document, provided that the further restriction does
396 | not survive such relicensing or conveying.
397 |
398 | If you add terms to a covered work in accord with this section, you
399 | must place, in the relevant source files, a statement of the
400 | additional terms that apply to those files, or a notice indicating
401 | where to find the applicable terms.
402 |
403 | Additional terms, permissive or non-permissive, may be stated in the
404 | form of a separately written license, or stated as exceptions;
405 | the above requirements apply either way.
406 |
407 | 8. Termination.
408 |
409 | You may not propagate or modify a covered work except as expressly
410 | provided under this License. Any attempt otherwise to propagate or
411 | modify it is void, and will automatically terminate your rights under
412 | this License (including any patent licenses granted under the third
413 | paragraph of section 11).
414 |
415 | However, if you cease all violation of this License, then your
416 | license from a particular copyright holder is reinstated (a)
417 | provisionally, unless and until the copyright holder explicitly and
418 | finally terminates your license, and (b) permanently, if the copyright
419 | holder fails to notify you of the violation by some reasonable means
420 | prior to 60 days after the cessation.
421 |
422 | Moreover, your license from a particular copyright holder is
423 | reinstated permanently if the copyright holder notifies you of the
424 | violation by some reasonable means, this is the first time you have
425 | received notice of violation of this License (for any work) from that
426 | copyright holder, and you cure the violation prior to 30 days after
427 | your receipt of the notice.
428 |
429 | Termination of your rights under this section does not terminate the
430 | licenses of parties who have received copies or rights from you under
431 | this License. If your rights have been terminated and not permanently
432 | reinstated, you do not qualify to receive new licenses for the same
433 | material under section 10.
434 |
435 | 9. Acceptance Not Required for Having Copies.
436 |
437 | You are not required to accept this License in order to receive or
438 | run a copy of the Program. Ancillary propagation of a covered work
439 | occurring solely as a consequence of using peer-to-peer transmission
440 | to receive a copy likewise does not require acceptance. However,
441 | nothing other than this License grants you permission to propagate or
442 | modify any covered work. These actions infringe copyright if you do
443 | not accept this License. Therefore, by modifying or propagating a
444 | covered work, you indicate your acceptance of this License to do so.
445 |
446 | 10. Automatic Licensing of Downstream Recipients.
447 |
448 | Each time you convey a covered work, the recipient automatically
449 | receives a license from the original licensors, to run, modify and
450 | propagate that work, subject to this License. You are not responsible
451 | for enforcing compliance by third parties with this License.
452 |
453 | An "entity transaction" is a transaction transferring control of an
454 | organization, or substantially all assets of one, or subdividing an
455 | organization, or merging organizations. If propagation of a covered
456 | work results from an entity transaction, each party to that
457 | transaction who receives a copy of the work also receives whatever
458 | licenses to the work the party's predecessor in interest had or could
459 | give under the previous paragraph, plus a right to possession of the
460 | Corresponding Source of the work from the predecessor in interest, if
461 | the predecessor has it or can get it with reasonable efforts.
462 |
463 | You may not impose any further restrictions on the exercise of the
464 | rights granted or affirmed under this License. For example, you may
465 | not impose a license fee, royalty, or other charge for exercise of
466 | rights granted under this License, and you may not initiate litigation
467 | (including a cross-claim or counterclaim in a lawsuit) alleging that
468 | any patent claim is infringed by making, using, selling, offering for
469 | sale, or importing the Program or any portion of it.
470 |
471 | 11. Patents.
472 |
473 | A "contributor" is a copyright holder who authorizes use under this
474 | License of the Program or a work on which the Program is based. The
475 | work thus licensed is called the contributor's "contributor version".
476 |
477 | A contributor's "essential patent claims" are all patent claims
478 | owned or controlled by the contributor, whether already acquired or
479 | hereafter acquired, that would be infringed by some manner, permitted
480 | by this License, of making, using, or selling its contributor version,
481 | but do not include claims that would be infringed only as a
482 | consequence of further modification of the contributor version. For
483 | purposes of this definition, "control" includes the right to grant
484 | patent sublicenses in a manner consistent with the requirements of
485 | this License.
486 |
487 | Each contributor grants you a non-exclusive, worldwide, royalty-free
488 | patent license under the contributor's essential patent claims, to
489 | make, use, sell, offer for sale, import and otherwise run, modify and
490 | propagate the contents of its contributor version.
491 |
492 | In the following three paragraphs, a "patent license" is any express
493 | agreement or commitment, however denominated, not to enforce a patent
494 | (such as an express permission to practice a patent or covenant not to
495 | sue for patent infringement). To "grant" such a patent license to a
496 | party means to make such an agreement or commitment not to enforce a
497 | patent against the party.
498 |
499 | If you convey a covered work, knowingly relying on a patent license,
500 | and the Corresponding Source of the work is not available for anyone
501 | to copy, free of charge and under the terms of this License, through a
502 | publicly available network server or other readily accessible means,
503 | then you must either (1) cause the Corresponding Source to be so
504 | available, or (2) arrange to deprive yourself of the benefit of the
505 | patent license for this particular work, or (3) arrange, in a manner
506 | consistent with the requirements of this License, to extend the patent
507 | license to downstream recipients. "Knowingly relying" means you have
508 | actual knowledge that, but for the patent license, your conveying the
509 | covered work in a country, or your recipient's use of the covered work
510 | in a country, would infringe one or more identifiable patents in that
511 | country that you have reason to believe are valid.
512 |
513 | If, pursuant to or in connection with a single transaction or
514 | arrangement, you convey, or propagate by procuring conveyance of, a
515 | covered work, and grant a patent license to some of the parties
516 | receiving the covered work authorizing them to use, propagate, modify
517 | or convey a specific copy of the covered work, then the patent license
518 | you grant is automatically extended to all recipients of the covered
519 | work and works based on it.
520 |
521 | A patent license is "discriminatory" if it does not include within
522 | the scope of its coverage, prohibits the exercise of, or is
523 | conditioned on the non-exercise of one or more of the rights that are
524 | specifically granted under this License. You may not convey a covered
525 | work if you are a party to an arrangement with a third party that is
526 | in the business of distributing software, under which you make payment
527 | to the third party based on the extent of your activity of conveying
528 | the work, and under which the third party grants, to any of the
529 | parties who would receive the covered work from you, a discriminatory
530 | patent license (a) in connection with copies of the covered work
531 | conveyed by you (or copies made from those copies), or (b) primarily
532 | for and in connection with specific products or compilations that
533 | contain the covered work, unless you entered into that arrangement,
534 | or that patent license was granted, prior to 28 March 2007.
535 |
536 | Nothing in this License shall be construed as excluding or limiting
537 | any implied license or other defenses to infringement that may
538 | otherwise be available to you under applicable patent law.
539 |
540 | 12. No Surrender of Others' Freedom.
541 |
542 | If conditions are imposed on you (whether by court order, agreement or
543 | otherwise) that contradict the conditions of this License, they do not
544 | excuse you from the conditions of this License. If you cannot convey a
545 | covered work so as to satisfy simultaneously your obligations under this
546 | License and any other pertinent obligations, then as a consequence you may
547 | not convey it at all. For example, if you agree to terms that obligate you
548 | to collect a royalty for further conveying from those to whom you convey
549 | the Program, the only way you could satisfy both those terms and this
550 | License would be to refrain entirely from conveying the Program.
551 |
552 | 13. Use with the GNU Affero General Public License.
553 |
554 | Notwithstanding any other provision of this License, you have
555 | permission to link or combine any covered work with a work licensed
556 | under version 3 of the GNU Affero General Public License into a single
557 | combined work, and to convey the resulting work. The terms of this
558 | License will continue to apply to the part which is the covered work,
559 | but the special requirements of the GNU Affero General Public License,
560 | section 13, concerning interaction through a network will apply to the
561 | combination as such.
562 |
563 | 14. Revised Versions of this License.
564 |
565 | The Free Software Foundation may publish revised and/or new versions of
566 | the GNU General Public License from time to time. Such new versions will
567 | be similar in spirit to the present version, but may differ in detail to
568 | address new problems or concerns.
569 |
570 | Each version is given a distinguishing version number. If the
571 | Program specifies that a certain numbered version of the GNU General
572 | Public License "or any later version" applies to it, you have the
573 | option of following the terms and conditions either of that numbered
574 | version or of any later version published by the Free Software
575 | Foundation. If the Program does not specify a version number of the
576 | GNU General Public License, you may choose any version ever published
577 | by the Free Software Foundation.
578 |
579 | If the Program specifies that a proxy can decide which future
580 | versions of the GNU General Public License can be used, that proxy's
581 | public statement of acceptance of a version permanently authorizes you
582 | to choose that version for the Program.
583 |
584 | Later license versions may give you additional or different
585 | permissions. However, no additional obligations are imposed on any
586 | author or copyright holder as a result of your choosing to follow a
587 | later version.
588 |
589 | 15. Disclaimer of Warranty.
590 |
591 | THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
592 | APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
593 | HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
594 | OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
595 | THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
596 | PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
597 | IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
598 | ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
599 |
600 | 16. Limitation of Liability.
601 |
602 | IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
603 | WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
604 | THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
605 | GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
606 | USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
607 | DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
608 | PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
609 | EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
610 | SUCH DAMAGES.
611 |
612 | 17. Interpretation of Sections 15 and 16.
613 |
614 | If the disclaimer of warranty and limitation of liability provided
615 | above cannot be given local legal effect according to their terms,
616 | reviewing courts shall apply local law that most closely approximates
617 | an absolute waiver of all civil liability in connection with the
618 | Program, unless a warranty or assumption of liability accompanies a
619 | copy of the Program in return for a fee.
620 |
621 | END OF TERMS AND CONDITIONS
622 |
623 | How to Apply These Terms to Your New Programs
624 |
625 | If you develop a new program, and you want it to be of the greatest
626 | possible use to the public, the best way to achieve this is to make it
627 | free software which everyone can redistribute and change under these terms.
628 |
629 | To do so, attach the following notices to the program. It is safest
630 | to attach them to the start of each source file to most effectively
631 | state the exclusion of warranty; and each file should have at least
632 | the "copyright" line and a pointer to where the full notice is found.
633 |
634 |
635 | Copyright (C)
636 |
637 | This program is free software: you can redistribute it and/or modify
638 | it under the terms of the GNU General Public License as published by
639 | the Free Software Foundation, either version 3 of the License, or
640 | (at your option) any later version.
641 |
642 | This program is distributed in the hope that it will be useful,
643 | but WITHOUT ANY WARRANTY; without even the implied warranty of
644 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
645 | GNU General Public License for more details.
646 |
647 | You should have received a copy of the GNU General Public License
648 | along with this program. If not, see .
649 |
650 | Also add information on how to contact you by electronic and paper mail.
651 |
652 | If the program does terminal interaction, make it output a short
653 | notice like this when it starts in an interactive mode:
654 |
655 | Copyright (C)
656 | This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
657 | This is free software, and you are welcome to redistribute it
658 | under certain conditions; type `show c' for details.
659 |
660 | The hypothetical commands `show w' and `show c' should show the appropriate
661 | parts of the General Public License. Of course, your program's commands
662 | might be different; for a GUI interface, you would use an "about box".
663 |
664 | You should also get your employer (if you work as a programmer) or school,
665 | if any, to sign a "copyright disclaimer" for the program, if necessary.
666 | For more information on this, and how to apply and follow the GNU GPL, see
667 | .
668 |
669 | The GNU General Public License does not permit incorporating your program
670 | into proprietary programs. If your program is a subroutine library, you
671 | may consider it more useful to permit linking proprietary applications with
672 | the library. If this is what you want to do, use the GNU Lesser General
673 | Public License instead of this License. But first, please read
674 | .
675 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 | # btrfs-diff-go
2 |
3 | Analyze differences between two BTRFS snapshots (like
4 | [GNU diff](https://www.gnu.org/software/diffutils/manual/) for directories).
5 |
6 | It is a single GO script (package) of ~ 1000 lines of code (without blanks and comments), plus a
7 | main script (binary) of 190 loc.
8 |
9 | 
10 | 
11 | [](https://goreportcard.com/report/github.com/mbideau/btrfs-diff-go)
12 | [
13 | ](https://github.com/mbideau/btrfs-diff-go/actions/workflows/go_build.yml)
14 | [
15 | ](https://github.com/mbideau/btrfs-diff-go/actions/workflows/go_static_analysis.yml)
16 | [
17 | ](https://github.com/mbideau/btrfs-diff-go/actions/workflows/test.yml)
18 | [](http://www.gnu.org/licenses/gpl-3.0)
19 | [
20 | ](CODE_OF_CONDUCT.md)
21 | [
22 | ](https://conventionalcommits.org)
23 |
24 | ## USAGE
25 |
26 | This is the output of `btrfs-diff --help` :
27 |
28 | ```text
29 |
30 | btrfs-diff-go - Analyse the differences between two related btrfs subvolumes.
31 |
32 | USAGE
33 |
34 | btrfs-diff-go [OPTIONS] PARENT CHILD
35 | Analyse the difference between btrfs PARENT and CHILD.
36 |
37 | btrfs-diff-go [OPTIONS] -f|--file STREAM
38 | Analyse the differences from a STREAM file (output from 'btrfs send').
39 |
40 | btrfs-diff-go [ -h | --help ]
41 | Display help.
42 |
43 | ARGUMENTS
44 |
45 | PARENT
46 | A btrfs subvolume that is the parent of the CHILD one.
47 |
48 | CHILD
49 | A btrfs subvolume that is the child of the PARENT one.
50 |
51 | OPTIONS
52 |
53 | -h | --help
54 | Display help.
55 |
56 | -i | --info
57 | Be verbose.
58 |
59 | -d | --debug
60 | Be more verbose.
61 |
62 | -f | --file STREAM
63 | Use a STREAM file to get the btrfs operations.
64 | This stream file must have been generated by the command
65 | 'btrfs send' (with or without the option --no-data).
66 |
67 | -t[changed] | --with-times[=changed]
68 | By defautl time modifications are ignored. With that option
69 | they will be taken into account. They are labelled as 'times'
70 | but if you also specify '=changed' they will be labelled
71 | 'changed'.
72 |
73 | -p[changed] | --with-perms[=changed]
74 | By defautl permission modifications are ignored. With that option
75 | they will be taken into account. They are labelled as 'perms'
76 | but if you also specify '=changed' they will be labelled
77 | 'changed'.
78 |
79 | -o[changed] | --with-own[=changed]
80 | By defautl ownership modifications are ignored. With that option
81 | they will be taken into account. They are labelled as 'own'
82 | but if you also specify '=changed' they will be labelled
83 | 'changed'.
84 |
85 | -a[changed] | --with-attr[=changed]
86 | By defautl attribute modifications are ignored. With that option
87 | they will be taken into account. They are labelled as 'attr'
88 | but if you also specify '=changed' they will be labelled
89 | 'changed'.
90 |
91 | EXAMPLES
92 |
93 | Get the differences between two snapshots.
94 | $ btrfs-diff-go /backup/btrfs-sp/rootfs/2020-12-25_22h00m00.shutdown.safe \
95 | /backup/btrfs-sp/rootfs/2019-12-25_21h00m00.shutdown.safe
96 |
97 | AUTHORS
98 |
99 | Originally written by: David Buckley
100 | Extended, fixed, and maintained by: Michael Bideau
101 |
102 | REPORTING BUGS
103 | Report bugs to:
104 |
105 | COPYRIGHT
106 |
107 | Copyright © 2020-2021 Michael Bideau.
108 | License GPLv3+: GNU GPL version 3 or later
109 | This is free software: you are free to change and redistribute it.
110 | There is NO WARRANTY, to the extent permitted by law.
111 |
112 | Info: original license chosen by David Buckley was MIT, but it allows sublicensing, so I
113 | chose to sublicense it to GPLv3+ to ensure code sharing
114 |
115 | SEE ALSO
116 |
117 | Home page:
118 |
119 | ```
120 |
121 |
122 | ## Installation
123 |
124 | First, install the required dependencies (example for *Debian* / *Ubuntu*)
125 |
126 | ```sh
127 | ~> sudo apt install golang libbtrfs-dev
128 | ```
129 |
130 | ### Using `go install` command
131 |
132 | Use the convenient `go install` :
133 |
134 | ```sh
135 | ~> go install github.com/mbideau/btrfs-diff-go
136 | ```
137 |
138 | That will create a binary named _btrfs-diff-go_ in `$GOPATH/bin`.
139 |
140 | ### Building from the sources
141 |
142 | Clone the repository, run the build then install it
143 |
144 | ```sh
145 | ~> git clone -q https://github.com/mbideau/btrfs-diff-go.git
146 | ~> cd btrfs-diff-go
147 | ~> go build -v
148 | ~> go install
149 | ```
150 |
151 | ### Copy the binary to `/usr/local/bin` to make it available system wide
152 |
153 | And rename it to `btrfs-diff`, if you don't care about the implementation language.
154 |
155 | ```sh
156 | ~> [ "$GOPATH" != '' ] || GOPATH="$HOME/go"
157 | ~> sudo cp $GOPATH/bin/btrfs-diff-go /usr/local/bin/btrfs-diff
158 | ~> sudo chmod +x /usr/local/bin/btrfs-diff
159 | ```
160 |
161 |
162 | ## Fast diff between BTRFS snapshots
163 |
164 | ### Why ? Reason to be
165 |
166 | The great advantage of having a [COW filesystem](https://en.wikipedia.org/wiki/Copy-on-write) with
167 | snapshoting like BTRFS is that producing the differences between two snapshots is almost
168 | instantaneous.
169 |
170 | For example, you can get the differences between *snap1* and *snap2* with the following command :
171 |
172 | ```sh
173 | ~> sudo btrfs send --quiet --no-data -p snap1 snap2 | LC_ALL=C btrfs receive --quiet --dump > /tmp/btrfs.dump
174 | ```
175 |
176 | Note that this dump is not really human readable. Moreover it contains operations, not differences.
177 | So it is not exactly what we are looking for. For example it might contains transient object
178 | informations, and multiple lines of unintuitive operations to reproduce a file state.
179 |
180 | I wanted a differences file format like the one you have when doing `diff -rq` or
181 | `git status --goort`, in short: a human friendly one.
182 |
183 | I looked at the prior art (see below), but nothing were satisfying enough, so I rolled my own
184 | diff utility (which produce the stream with `btrfs send` and then parse it).
185 |
186 | ### Prior art analysis
187 |
188 | As the time of writing this (i.e.: Dec. 2020), I have found 2 projects matching `btrfs diff`
189 | in *Github* and 0 in *Gitlab*.
190 |
191 | * [btrfs-send-go](https://github.com/bucko909/btrfs-send-go) [GO]
192 | The one that this project have extended, fixed and improved.
193 | The original author's version is raw, and have minor bugs, but does exactly the job.
194 | It is also not translatable (as-is).
195 |
196 | * [btrfs-snapshots-diff](https://github.com/sysnux/btrfs-snapshots-diff) [Python 2]
197 | It has a lot of issues (with link, but not only), and is Python 2, which is deprecated by now.
198 | No go.
199 |
200 | * [btrfs-snapshots-diff](https://github.com/daviessm/btrfs-snapshots-diff) [Python 3]
201 | A fork of the previous one, with a lot of issues fixed and in *Python 3*.
202 | Because it is written in *Python*, it means that if I want to run it in *initram* (I do) I
203 | will need to include the *Python* binary and the required dependencies. Too much for what I
204 | want.
205 | May be I could compile it with *Cython*, but I am not (yet) comfortable with that.
206 |
207 | There is also the [snapper](https://github.com/openSUSE/snapper) utility that compares BTRFS
208 | snapshots, but it does so by mounting both snapshots and doing a "standard" `diff` on them (if my
209 | understanding is correct).
210 |
211 | Finally I have found a lot of small Python script doing a BTRFS diff, but they were using a
212 | hacky way to do it (based on the `find-new` method), without being able to catch deletions.
213 | They were better-than-nothing prior to `btrfs send` and `btrfs receive`, but they are obsolete
214 | since. Hence, I skipped all those.
215 |
216 | So, I almost found what I wanted, after patching/fixing *btrfs-send-go* but I was not confident
217 | enough to trust it, and it still lacked the translation layer.
218 |
219 | This is why I first decided to roll my own script, in POSIX shell, that have all the features I
220 | was looking for. See [btrfs-diff-sh](https://github.com/mbideau/btrfs-diff-sh).
221 |
222 | But after being happy with it, it was a little bit too slow, so I decided to go back to the go
223 | version (pun intented) and fix its bug and improve its user experience.
224 |
225 | Here it is. Way faster than the shell version. Not measured yet (it's a feeling).
226 |
227 | #### Features list
228 |
229 | Cool features implemented :
230 |
231 | * can produce the raw diff from two snapshots or parse a raw stream file
232 | * produces an output close to the `diff -rq` utility and `git status --goort`
233 | * fast
234 |
235 | #### Limits / flaws
236 |
237 | It does the job, but have some limits.
238 |
239 | It was not tested on huge dumps, so it might not perform well or reveal majors bugs.
240 |
241 | Due to BTRFS implementation, some files appear as *changed*, when they are not (according to
242 | `diff` utility). I have absolutely no idea why BTRFS is acting like this… If someone can
243 | help me figures this out, I'll be glad.
244 |
245 |
246 | ## Feedbacks wanted, PR/MR welcome :heart:
247 |
248 | If you have any question or wants to share your uncovered case, please I be glad to answer and
249 | accept changes through *Pull Request*.
250 |
251 |
252 | ## Developing
253 |
254 | Do your changes, then, in the source directory, run :
255 |
256 | ```sh
257 | ~> go build -v
258 | ```
259 |
260 | ### Algorithm explained
261 |
262 | The program follows this process :
263 |
264 | * produce (with `btrfs send` syscall) or get a BRTFS file stream (from CLI arg)
265 | * parse this file in a binary mode
266 | * extract commands and their parameters (should match the line of `btrfs receive --dump`)
267 | * those commands are mapped with operation (i.e.: command 'delete' => operation 'delete')
268 | * commands are associated with paths, mostly only one, and two for rename operation
269 | * foreach command's path, we re-created the file tree with an object called 'node'
270 | * we maintain two trees: one for new files, one for old files
271 | * new files can have an original one, and old file can have a new version
272 | * after having prcessed all the commands, we flatten and analize the tree
273 | * foreach old file we produce the resulting change, then the same for each new file
274 |
275 | ## Testing
276 |
277 | And to be sure that the program is working in your environment, or that you have not broken
278 | anything while developing, you have to run the tests.
279 |
280 | Then you can run the following command:
281 |
282 | ```sh
283 | ~> sh test.sh
284 | ```
285 |
286 | It is very raw but it test already a lot of cases.
287 |
288 |
289 | ## TODO
290 |
291 | By order of priority :
292 |
293 | * [ ] create a screencast to show of the program
294 | * [ ] make the program translatable
295 | * [ ] create a Github action to automaticaly insert the help into the README from the exectuion of
296 | the command
297 | * [ ] create a Github action to generate a table of links to the sections at the top of the README
298 | * [ ] create an alpha release when the program would have received enough testing (and possibly
299 | real life conditions runs)
300 |
301 |
302 | ## Authors and contributors
303 |
304 | ### Authors
305 |
306 | Originally written by: [David Buckley](https://github.com/bucko909)
307 |
308 | Extended, fixed, and maintained by: [Michael Bideau](https://github.com/mbideau)
309 |
310 | ### Contributors
311 |
312 | With a lot of thanks to :
313 |
314 | * [Mek101](https://github.com/Mek101): very good crash-tester :wink:
315 |
316 |
317 | ## Copyright and License GPLv3
318 |
319 | Copyright © 2020-2021 Michael Bideau [France]
320 |
321 | All the *btrfs-diff-go* source codes (every file but README.md, CODE_OF_CONDUCT.md and LICENSE) are
322 | licensed under the _GPLv3+_ license.
323 |
324 | *btrfs-diff-go* is free software: you can redistribute it and/or modify it under the terms of the GNU
325 | General Public License as published by the Free Software Foundation, either version 3 of the
326 | License, or (at your option) any later version.
327 |
328 | *btrfs-diff-go* is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without
329 | even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
330 | General Public License for more details.
331 |
332 | You should have received a copy of the GNU General Public License along with btrfs-diff-go. If not,
333 | see [https://www.gnu.org/licenses/](https://www.gnu.org/licenses/).
334 |
335 |
336 | ## Code of conduct
337 |
338 | Please note that this project is released with a *Contributor Code of Conduct*. By participating in
339 | this project you agree to abide by its terms.
340 |
341 |
342 | ## About this document
343 |
344 | ### License: CC-BY-SA
345 |
346 | [
347 | ](https://creativecommons.org/licenses/by-sa/4.0/)
348 |
349 | Copyright © 2020-2021 Michael Bideau, France
350 | This document is licensed under a
351 | [Creative Commons Attribution 4.0 International License](http://creativecommons.org/licenses/by-sa/4.0/).
352 |
353 | ### Author: Michael Bideau
354 |
355 | Michael Bideau, France
356 |
357 | ### Made with: Formiko and Vim, plus some helpers/linters
358 |
359 | I started with [formiko](https://github.com/ondratu/formiko), then used
360 | [vim](https://www.vim.org/) with linters to help catching mistakes and badly written sentences:
361 |
362 | * [mdl](https://github.com/markdownlint/markdownlint)
363 | * [proselint](http://proselint.com)
364 | * [write-good](https://github.com/btford/write-good)
365 |
--------------------------------------------------------------------------------
/go.mod:
--------------------------------------------------------------------------------
1 | module github.com/mbideau/btrfs-diff-go
2 |
3 | go 1.15
4 |
--------------------------------------------------------------------------------
/main.go:
--------------------------------------------------------------------------------
1 | package main
2 |
3 | import (
4 | "fmt"
5 | "os"
6 | "path"
7 | "path/filepath"
8 | "sort"
9 | "strings"
10 |
11 | btrfsdiff "github.com/mbideau/btrfs-diff-go/pkg"
12 | )
13 |
14 | func usage(progname string) {
15 | fmt.Printf(`
16 | %[1]s - Analyse the differences between two related btrfs subvolumes.
17 |
18 | USAGE
19 |
20 | %[1]s [OPTIONS] PARENT CHILD
21 | Analyse the difference between btrfs PARENT and CHILD.
22 |
23 | %[1]s [OPTIONS] -f|--file STREAM
24 | Analyse the differences from a STREAM file (output from 'btrfs send').
25 |
26 | %[1]s [ -h | --help ]
27 | Display help.
28 |
29 | ARGUMENTS
30 |
31 | PARENT
32 | A btrfs subvolume that is the parent of the CHILD one.
33 |
34 | CHILD
35 | A btrfs subvolume that is the child of the PARENT one.
36 |
37 | OPTIONS
38 |
39 | -h | --help
40 | Display help.
41 |
42 | -i | --info
43 | Be verbose.
44 |
45 | -d | --debug
46 | Be more verbose.
47 |
48 | -f | --file STREAM
49 | Use a STREAM file to get the btrfs operations.
50 | This stream file must have been generated by the command
51 | 'btrfs send' (with or without the option --no-data).
52 |
53 | -t[changed] | --with-times[=changed]
54 | By defautl time modifications are ignored. With that option
55 | they will be taken into account. They are labelled as 'times'
56 | but if you also specify '=changed' they will be labelled
57 | 'changed'.
58 |
59 | -p[changed] | --with-perms[=changed]
60 | By defautl permission modifications are ignored. With that option
61 | they will be taken into account. They are labelled as 'perms'
62 | but if you also specify '=changed' they will be labelled
63 | 'changed'.
64 |
65 | -o[changed] | --with-own[=changed]
66 | By defautl ownership modifications are ignored. With that option
67 | they will be taken into account. They are labelled as 'own'
68 | but if you also specify '=changed' they will be labelled
69 | 'changed'.
70 |
71 | -a[changed] | --with-attr[=changed]
72 | By defautl attribute modifications are ignored. With that option
73 | they will be taken into account. They are labelled as 'attr'
74 | but if you also specify '=changed' they will be labelled
75 | 'changed'.
76 |
77 | EXAMPLES
78 |
79 | Get the differences between two snapshots.
80 | $ %[1]s /backup/btrfs-sp/rootfs/2020-12-25_22h00m00.shutdown.safe \
81 | /backup/btrfs-sp/rootfs/2019-12-25_21h00m00.shutdown.safe
82 |
83 | AUTHORS
84 |
85 | Originally written by: David Buckley
86 | Extended, fixed, and maintained by: Michael Bideau
87 |
88 | REPORTING BUGS
89 | Report bugs to:
90 |
91 | COPYRIGHT
92 |
93 | Copyright © 2020-2021 Michael Bideau.
94 | License GPLv3+: GNU GPL version 3 or later
95 | This is free software: you are free to change and redistribute it.
96 | There is NO WARRANTY, to the extent permitted by law.
97 |
98 | Info: original license chosen by David Buckley was MIT, but it allows sublicensing, so I
99 | chose to sublicense it to GPLv3+ to ensure code sharing
100 |
101 | SEE ALSO
102 |
103 | Home page:
104 |
105 | `, progname)
106 | }
107 |
108 | func main() {
109 |
110 | var optionHelp bool = false
111 | var optionDebug bool = false
112 | var optionInfo bool = false
113 | var optionFile string = ""
114 | var optionWithTimes bool = false
115 | var optionTimesAsChanged bool = false
116 | var optionWithPerms bool = false
117 | var optionPermsAsChanged bool = false
118 | var optionWithOwn bool = false
119 | var optionOwnAsChanged bool = false
120 | var optionWithAttr bool = false
121 | var optionAttrAsChanged bool = false
122 | var argSubvolParent string = ""
123 | var argSubvolChild string = ""
124 |
125 | skip := false
126 | for index, arg := range os.Args[1:] {
127 |
128 | // hacky way to compensate for lack of 'continue 2' instruction
129 | if skip {
130 | skip = false
131 | continue
132 | }
133 |
134 | switch(arg) {
135 | case "-h", "--help":
136 | optionHelp = true
137 | case "-i", "--info":
138 | optionInfo = true
139 | case "-d", "--debug":
140 | optionDebug = true
141 | case "-t", "--with-times":
142 | optionWithTimes = true
143 | case "-tchanged", "--with-times=changed":
144 | optionTimesAsChanged = true
145 | case "-p", "--with-perms":
146 | optionWithPerms = true
147 | case "-pchanged", "--with-perms=changed":
148 | optionPermsAsChanged = true
149 | case "-o", "--with-own":
150 | optionWithOwn = true
151 | case "-ochanged", "--with-own=changed":
152 | optionOwnAsChanged = true
153 | case "-a", "--with-attr":
154 | optionWithAttr = true
155 | case "-achanged", "--with-attr=changed":
156 | optionAttrAsChanged = true
157 | case "-f", "--file":
158 | if len(os.Args) > index+2 {
159 | optionFile = os.Args[index+2]
160 | skip = true
161 | }
162 | default:
163 | if len(argSubvolParent) == 0 {
164 | argSubvolParent = arg
165 | } else if len(argSubvolChild) == 0 {
166 | argSubvolChild = arg
167 | }
168 | }
169 | }
170 |
171 | if len(os.Args) <= 2 || optionHelp {
172 | usage(path.Base(os.Args[0]))
173 | os.Exit(0)
174 | }
175 |
176 | if optionInfo {
177 | btrfsdiff.SetInfo(true)
178 | }
179 |
180 | if optionDebug {
181 | btrfsdiff.SetInfo(true)
182 | btrfsdiff.SetDebug(true)
183 | }
184 |
185 | if optionWithTimes || optionTimesAsChanged {
186 | btrfsdiff.ConsiderUtimeOp(optionTimesAsChanged)
187 | }
188 | if optionWithPerms || optionPermsAsChanged {
189 | btrfsdiff.ConsiderChmodOp(optionPermsAsChanged)
190 | }
191 | if optionWithOwn || optionOwnAsChanged {
192 | btrfsdiff.ConsiderChownOp(optionOwnAsChanged)
193 | }
194 | if optionWithAttr || optionAttrAsChanged {
195 | btrfsdiff.ConsiderXattrOp(optionAttrAsChanged)
196 | }
197 |
198 | var changes []string
199 | var err error
200 | if len(optionFile) > 0 {
201 | var streamfile string
202 | streamfile, err = filepath.Abs(optionFile)
203 | if err == nil {
204 | changes, err = btrfsdiff.GetChangesFromStreamFile(streamfile)
205 | }
206 | } else {
207 | var parent string
208 | var child string
209 | parent, err = filepath.Abs(argSubvolParent)
210 | if err == nil {
211 | child, err = filepath.Abs(argSubvolChild)
212 | if err == nil {
213 | changes, err = btrfsdiff.GetChangesFromTwoSubvolumes(child, parent)
214 | }
215 | }
216 | }
217 |
218 | if err != nil {
219 | fmt.Fprintf(os.Stderr, "%v\n", err)
220 | os.Exit(1)
221 | }
222 |
223 | // if there are changes/differences
224 | if len(changes) > 0 {
225 |
226 | // sort the list alphabetically (default)
227 | sort.Strings(changes)
228 |
229 | // print changes
230 | fmt.Printf("%v\n", strings.Join(changes, "\n"))
231 |
232 | // exit 1 if there are differences
233 | os.Exit(1)
234 | }
235 | }
236 |
--------------------------------------------------------------------------------
/pkg/btrfs-diff.go:
--------------------------------------------------------------------------------
1 | //+build linux
2 |
3 | // to build it run :
4 | // GOOS=linux GOARCH=amd64 go build -a -v btrfs-diff.go
5 | // it requires: golang and libbtrfs-dev, so on GNU Linux/Debian do :
6 | // sudo apt install golang libbtrfs-dev
7 |
8 | package btrfsdiff
9 |
10 | // We get the constants from this header.
11 |
12 | // #include
13 | // #include
14 | // #include
15 | // #cgo LDFLAGS: -lbtrfs
16 | import "C"
17 |
18 | import (
19 | "bufio"
20 | "encoding/binary"
21 | "fmt"
22 | "io"
23 | "log"
24 | "os"
25 | "strings"
26 | "syscall"
27 | "unsafe"
28 | )
29 |
30 | var infoMode bool = false
31 | var debugMode bool = false
32 | var infoLogger *log.Logger
33 | var debugLogger *log.Logger
34 | var infoPrefix string = "[INFO] "
35 | var debugPrefix string = "[DEBUG] "
36 | var debugIndTab string = " "
37 |
38 | // operation is the result of one or more instructions/commands
39 | type operation int
40 |
41 | // list of available operations
42 | const (
43 | opUnspec operation = iota
44 | opIgnore
45 | opCreate
46 | opModify
47 | opTimes
48 | opPermissions
49 | opOwnership
50 | opAttributes
51 | opDelete
52 | opRename
53 | opEnd
54 | )
55 |
56 | // operation's names
57 | var names []string = []string{"!!!", "ignored", "added", "changed", "times", "perms", "own", "attr", "deleted", "renamed", "END"}
58 |
59 | // convert an operation to a string
60 | func (op operation) String() string {
61 | return names[op]
62 | }
63 |
64 | // commandMapOp is the mapping between a command and a resulting operation
65 | type commandMapOp struct {
66 | Name string
67 | Op operation
68 | }
69 |
70 | // commandInst is the instanciation of a command and its data
71 | type commandInst struct {
72 | Type *commandMapOp
73 | data []byte
74 | }
75 |
76 | // initCommandsDefinitions initialize the commands mapping with operations
77 | func initCommandsDefinitions() *[C.__BTRFS_SEND_C_MAX]commandMapOp {
78 |
79 | var commandsDefs [C.__BTRFS_SEND_C_MAX]commandMapOp
80 | commandsDefs[C.BTRFS_SEND_C_UNSPEC] = commandMapOp{Name: "BTRFS_SEND_C_UNSPEC", Op: opUnspec}
81 |
82 | commandsDefs[C.BTRFS_SEND_C_SUBVOL] = commandMapOp{Name: "BTRFS_SEND_C_SUBVOL", Op: opIgnore}
83 | commandsDefs[C.BTRFS_SEND_C_SNAPSHOT] = commandMapOp{Name: "BTRFS_SEND_C_SNAPSHOT", Op: opIgnore}
84 |
85 | commandsDefs[C.BTRFS_SEND_C_MKFILE] = commandMapOp{Name: "BTRFS_SEND_C_MKFILE", Op: opCreate}
86 | commandsDefs[C.BTRFS_SEND_C_MKDIR] = commandMapOp{Name: "BTRFS_SEND_C_MKDIR", Op: opCreate}
87 | commandsDefs[C.BTRFS_SEND_C_MKNOD] = commandMapOp{Name: "BTRFS_SEND_C_MKNOD", Op: opCreate}
88 | commandsDefs[C.BTRFS_SEND_C_MKFIFO] = commandMapOp{Name: "BTRFS_SEND_C_MKFIFO", Op: opCreate}
89 | commandsDefs[C.BTRFS_SEND_C_MKSOCK] = commandMapOp{Name: "BTRFS_SEND_C_MKSOCK", Op: opCreate}
90 | commandsDefs[C.BTRFS_SEND_C_SYMLINK] = commandMapOp{Name: "BTRFS_SEND_C_SYMLINK", Op: opCreate}
91 |
92 | commandsDefs[C.BTRFS_SEND_C_LINK] = commandMapOp{Name: "BTRFS_SEND_C_LINK", Op: opCreate}
93 |
94 | commandsDefs[C.BTRFS_SEND_C_RENAME] = commandMapOp{Name: "BTRFS_SEND_C_RENAME", Op: opRename}
95 |
96 | commandsDefs[C.BTRFS_SEND_C_UNLINK] = commandMapOp{Name: "BTRFS_SEND_C_UNLINK", Op: opDelete}
97 | commandsDefs[C.BTRFS_SEND_C_RMDIR] = commandMapOp{Name: "BTRFS_SEND_C_RMDIR", Op: opDelete}
98 |
99 | commandsDefs[C.BTRFS_SEND_C_WRITE] = commandMapOp{Name: "BTRFS_SEND_C_WRITE", Op: opModify}
100 | commandsDefs[C.BTRFS_SEND_C_CLONE] = commandMapOp{Name: "BTRFS_SEND_C_CLONE", Op: opModify}
101 | commandsDefs[C.BTRFS_SEND_C_TRUNCATE] = commandMapOp{Name: "BTRFS_SEND_C_TRUNCATE", Op: opModify}
102 |
103 | commandsDefs[C.BTRFS_SEND_C_CHMOD] = commandMapOp{Name: "BTRFS_SEND_C_CHMOD", Op: opIgnore}
104 | commandsDefs[C.BTRFS_SEND_C_CHOWN] = commandMapOp{Name: "BTRFS_SEND_C_CHOWN", Op: opIgnore}
105 | commandsDefs[C.BTRFS_SEND_C_UTIMES] = commandMapOp{Name: "BTRFS_SEND_C_UTIMES", Op: opIgnore}
106 | commandsDefs[C.BTRFS_SEND_C_SET_XATTR] = commandMapOp{Name: "BTRFS_SEND_C_SET_XATTR", Op: opIgnore}
107 | commandsDefs[C.BTRFS_SEND_C_REMOVE_XATTR] = commandMapOp{Name: "BTRFS_SEND_C_REMOVE_XATTR", Op: opIgnore}
108 |
109 | commandsDefs[C.BTRFS_SEND_C_END] = commandMapOp{Name: "BTRFS_SEND_C_END", Op: opEnd}
110 | commandsDefs[C.BTRFS_SEND_C_UPDATE_EXTENT] = commandMapOp{Name: "BTRFS_SEND_C_UPDATE_EXTENT", Op: opModify}
111 | // Sanity check (hopefully no holes).
112 | for i, command := range commandsDefs {
113 | if i != C.BTRFS_SEND_C_UNSPEC && command.Op == opUnspec {
114 | return nil
115 | }
116 | }
117 | return &commandsDefs
118 | }
119 |
120 | // do the initialization of the commands mapping
121 | var commandsDefs *[C.__BTRFS_SEND_C_MAX]commandMapOp = initCommandsDefinitions()
122 |
123 | // nodeInst is the representation of a file in a tree, with metadata attached
124 | // Children is the files in the directory (if the file is a directory)
125 | // Op is the name of the operation done on that node
126 | // Parent is the parent directory of the file
127 | // Original is the file in its previous version (new file may have an older version)
128 | type nodeInst struct {
129 | Children map[string]*nodeInst
130 | Name string
131 | State operation
132 | Parent *nodeInst
133 | Original *nodeInst
134 | }
135 |
136 | // diffInst is the structure that hold two trees, one new, one old
137 | type diffInst struct {
138 | Original nodeInst
139 | New nodeInst
140 | }
141 |
142 | // info print a message (to STDERR) only if info mode is enabled
143 | func info(msg string, params ...interface{}) {
144 | if infoMode {
145 | infoLogger.Printf(msg, params...)
146 | }
147 | }
148 |
149 | // debug print a message (to STDERR) only if debug mode is enabled
150 | func debug(msg string, params ...interface{}) {
151 | if debugMode {
152 | debugLogger.Printf(msg, params...)
153 | }
154 | }
155 |
156 | // debugInd is like 'debug()' but can handle indentation as well
157 | func debugInd(ind int, msg string, params ...interface{}) {
158 | if debugMode {
159 | indentation := ""
160 | for i:=0; i len {
218 | return AfterLast
219 | }
220 | return Regular
221 | }
222 |
223 | func getBoxTypeExternal(index int, len int) BoxType {
224 | if index+1 == len {
225 | return AfterLast
226 | }
227 | return Between
228 | }
229 |
230 | func getBoxPadding(root bool, boxType BoxType) string {
231 | if root {
232 | return ""
233 | }
234 |
235 | return boxType.String() + " "
236 | }
237 | /* END copied from: https://github.com/Tufin/asciitree/blob/master/print.go#L47 */
238 |
239 | // processSingleParamOp is the processing of single param commands (update the Diff double tree)
240 | // Note: that code only allow to register for one operation per file. For example, a file can't
241 | // have its time modified and its ownership at the same time, even if this is actually the
242 | // case in reality. That simplified design looses information. The last operation will
243 | // not override the previous one.
244 | func (diff *diffInst) processSingleParamOp(Op operation, path string) (error) {
245 |
246 | debug("BEFORE: processSingleParamOp\n")
247 | debug("--- Tree Original ---\n")
248 | diff.Original.PrintTree(os.Stderr, true, "", len(diff.Original.Children), 0)
249 | debug("--- END ---\n")
250 | debug("--- Tree New ---\n")
251 | diff.New.PrintTree(os.Stderr, true, "", len(diff.New.Children), 0)
252 | debug("--- END ---\n")
253 |
254 | debugInd(3, "searching for matching node")
255 | isNew := Op == opCreate
256 | debugInd(4, "is new? %t (only when '%v')", isNew, opCreate)
257 | fileNode := diff.updateBothTreesAndReturnNode(path, isNew)
258 | debugInd(3, "found: %v", fileNode)
259 |
260 | // in case of deletion
261 | if Op == opDelete {
262 | debugInd(3, "that's a deletion")
263 | parentWasRenamed := false
264 | if fileNode.Original == nil {
265 | debugInd(4, "no previous version of the node exist")
266 | // if parent wasn't renamed its a bug
267 | if fileNode.Parent == nil || fileNode.Parent.State != opCreate || fileNode.Parent.Original == nil || fileNode.Parent.Original.State != opRename {
268 | fmt.Fprintf(os.Stderr, "BUG? deleting path %v which was created in same diff?", path)
269 | os.Exit(1)
270 |
271 | // parent node was renamed
272 | } else {
273 | parentWasRenamed = true
274 | debugInd(5, "parent was renamed, that's normal")
275 | }
276 | }
277 |
278 | // parent was renamed: not deleting the node in the new files
279 | if parentWasRenamed {
280 | debugInd(5, "parent was renamed, not deleting the node (New files)")
281 |
282 | // parent not renamed
283 | } else {
284 |
285 | // // deleting the node in new files tree
286 | // debugInd(4, "deleting the node in the Parent tree (New tree)")
287 | // delete(fileNode.Parent.Children, fileNode.Name)
288 | }
289 |
290 | // flag the new one as deleted
291 | debugInd(4, "flaging the node as '%v' (New tree)", opDelete)
292 | fileNode.State = opDelete
293 | debugInd(4, "now node is: %v", fileNode)
294 |
295 | // // If we deleted /this/ node, it sure as hell needs no children.
296 | // debugInd(4, "deleting the node children")
297 | // fileNode.Children = nil
298 |
299 | // old version exist
300 | if fileNode.Original != nil {
301 | debugInd(5, "node had a previous version")
302 | debugInd(5, "setting its State to '%v'", opDelete)
303 | // Leave behind a sentinel in the Original structure.
304 | fileNode.Original.State = opDelete
305 | err := fileNode.Original.verifyDelete(path)
306 | if err != nil {
307 | return err
308 | }
309 | // debugInd(5, "deleting the old node children")
310 | // fileNode.Original.Children = nil
311 | }
312 |
313 | debugInd(5, "now node is: %v", fileNode)
314 |
315 | // not a deletion, and the current operation is different from the current node
316 | } else if Op != fileNode.State {
317 |
318 | // not a creation
319 | if (fileNode.State != opCreate) {
320 | debugInd(3, "the current node Op is not '%v'", fileNode.State)
321 |
322 | // do not allow a "subclass" of modifications (i.e.: times, perms, own, attrs) to override the top class modification (i.e.: changed)
323 | if (fileNode.State == opModify && (Op == opTimes || Op == opPermissions || Op == opOwnership || Op == opAttributes)) {
324 | debugInd(4, "current operation '%v' is a subclass modification", Op)
325 | debugInd(4, "not overriding the node Op (%v)", fileNode.State)
326 |
327 | // overriding the current node operation
328 | } else {
329 | debugInd(4, "replacing it with current operation '%v'", Op)
330 | fileNode.State = Op
331 | debugInd(4, "now node is: %v", fileNode)
332 | }
333 |
334 | // current node Op is opCreate and node was previously deleted
335 | } else if (fileNode.State == opDelete) {
336 |
337 | // overwritting its state with 'created'
338 | debugInd(3, "current node Op is '%v': overriding the node Op with '%v'", fileNode.State, opCreate)
339 | fileNode.State = opCreate
340 |
341 | // current node Op is opCreate
342 | } else {
343 | debugInd(3, "current node Op is '%v': not overriding the node Op", fileNode.State)
344 | }
345 |
346 | // current operation is the same as the current node
347 | } else {
348 | debugInd(3, "current operation (%v) is the same as the node Op (%v)", Op, fileNode.State)
349 | debugInd(3, "not overriding the node Op")
350 | }
351 |
352 | debug("AFTER: processSingleParamOp\n")
353 | debug("--- Tree Original ---\n")
354 | diff.Original.PrintTree(os.Stderr, true, "", len(diff.Original.Children), 0)
355 | debug("--- END ---\n")
356 | debug("--- Tree New ---\n")
357 | diff.New.PrintTree(os.Stderr, true, "", len(diff.New.Children), 0)
358 | debug("--- END ---\n")
359 |
360 | return nil
361 | }
362 |
363 | // verifyDelete checks that every children of the node are either deleted or renamed
364 | func (node *nodeInst) verifyDelete(path string) (error) {
365 | for _, child := range node.Children {
366 | if child.State != opDelete && child.State != opRename {
367 | return fmt.Errorf("BUG? deleting parent of node %v in %v which is not gone", node, path)
368 | }
369 | }
370 | return nil
371 | }
372 |
373 | // processTwoParamsOp is the processing of double params commands (update the Diff double tree)
374 | // It is used only by the 'rename' operation, although it could be used for 'link' op, but this
375 | // one is treated as a single param, for simplicity's sake.
376 | func (diff *diffInst) processTwoParamsOp(Op operation, from string, to string) {
377 |
378 | debug("BEFORE: processTwoParamsOp\n")
379 | debug("--- Tree Original ---\n")
380 | diff.Original.PrintTree(os.Stderr, true, "", len(diff.Original.Children), 0)
381 | debug("--- END ---\n")
382 | debug("--- Tree New ---\n")
383 | diff.New.PrintTree(os.Stderr, true, "", len(diff.New.Children), 0)
384 | debug("--- END ---\n")
385 |
386 | // from node
387 | debugInd(3, "searching for 'from' node")
388 | fromNode := diff.updateBothTreesAndReturnNode(from, false)
389 | debugInd(3, "found: %v", fromNode)
390 |
391 | // renaming specifics
392 | if Op == opRename {
393 | debugInd(3, "it's a renaming")
394 |
395 | // deleting the node from the new files tree, because it should only exist in the old tree
396 | debugInd(4, "removing it from its parent node '%v' (New tree)", fromNode.Parent.Name)
397 | delete(fromNode.Parent.Children, fromNode.Name)
398 | // Note: now the fromNode is orphan
399 |
400 | if fromNode.Original != nil {
401 |
402 | // if fromNode had an original, we must mark that path destroyed.
403 | debugInd(4, "set old node St to '%v' (Original tree)", opRename)
404 | fromNode.Original.State = opRename
405 | debugInd(4, "old node is now: %v", fromNode.Original)
406 | }
407 | }
408 |
409 | // to node
410 | debugInd(3, "searching for 'to' node")
411 | toNode := diff.updateBothTreesAndReturnNode(to, true)
412 | debugInd(3, "found: %v", toNode)
413 |
414 | // renaming specifics
415 | if Op == opRename {
416 | debugInd(3, "it's a renaming (bis)")
417 |
418 | // attaching the old node (which was orphan) to the new files tree
419 | debugInd(4, "adding the 'from' node to the 'to' node parent tree at name '%v' (New tree)", toNode.Name)
420 | toNode.Parent.Children[toNode.Name] = fromNode
421 |
422 | // updating its name
423 | debugInd(4, "'from' node Name is replaced by the 'to' node Name '%v'", toNode.Name)
424 | fromNode.Name = toNode.Name
425 |
426 | // ensuring its status is 'added'
427 | debugInd(4, "'from' node Op is set to '%v'", opCreate)
428 | fromNode.State = opCreate
429 |
430 | // updating the parent node
431 | debugInd(4, "'from' node Parent is assigned the 'to' node Parent '%v'", toNode.Parent.Name)
432 | fromNode.Parent = toNode.Parent
433 |
434 | debugInd(4, "now node is: %v", toNode.Parent.Children[toNode.Name])
435 | }
436 |
437 | debug("AFTER: processTwoParamsOp\n")
438 | debug("--- Tree Original ---\n")
439 | diff.Original.PrintTree(os.Stderr, true, "", len(diff.Original.Children), 0)
440 | debug("--- END ---\n")
441 | debug("--- Tree New ---\n")
442 | diff.New.PrintTree(os.Stderr, true, "", len(diff.New.Children), 0)
443 | debug("--- END ---\n")
444 | }
445 |
446 | // updateBothTreesAndReturnNode return the searched node, after it has updated both Diff trees (old and new)
447 | func (diff *diffInst) updateBothTreesAndReturnNode(path string, isNew bool) *nodeInst {
448 | if diff.New.Original == nil {
449 | debugInd(4, "the New tree is not referencing the Original one, fixing that")
450 | diff.New.Original = &diff.Original
451 | diff.New.Original.Name = "/"
452 | }
453 | if path == "" {
454 | diff.New.Name = "/"
455 | debugInd(4, "empty path, returning the node from the top level of the New tree '%v'", diff.New.Name)
456 | return &diff.New
457 | }
458 |
459 | // foreach part of the path (in the 'New' tree)
460 | debugInd(4, "splitted path in parts, processing each one ...")
461 | parts := strings.Split(path, "/")
462 |
463 | parent := &diff.New
464 | for i, part := range parts {
465 | nodeName := strings.Trim(part, "\x00")
466 | debugInd(5, "- %v", nodeName)
467 | debugInd(6, "parent node is %v", parent)
468 | if parent.Children == nil {
469 | debugInd(7, "no children: set a new empty children list/map")
470 | parent.Children = make(map[string]*nodeInst)
471 | }
472 |
473 | // get the node in the parent tree (New tree)
474 | debugInd(6, "getting the node in the children (New tree)")
475 | newNode := parent.Children[nodeName]
476 | debugInd(7, "found: %v", newNode)
477 |
478 | // the parent part/node doesn't exist
479 | if newNode == nil {
480 | debugInd(6, "creating the node")
481 |
482 | // creating it
483 | parent.Children[nodeName] = &nodeInst{}
484 | newNode = parent.Children[nodeName]
485 | newNode.Name = nodeName
486 | newNode.Parent = parent
487 | debugInd(7, "created: %v", newNode)
488 | debugInd(7, "added to its parent node (New tree)")
489 |
490 | // no previous version of the parent node
491 | oldParent := parent.Original
492 | if oldParent == nil {
493 | debugInd(7, "no previous version of the parent node (Original tree)")
494 | // was !(isNew && i == len(parts)-1) which is the same, but replaced for consistency reason
495 | if !isNew || i < len(parts)-1 {
496 | debugInd(7, "isNew is 'false' or the parent part isn't the last one")
497 | // Either a path has a route in the oldParent, or it's been
498 | // explicitly created. Once we traverse into a path without
499 | // an oldParent, we know the full tree, so getting here is a
500 | // sign we did it wrong.
501 | fmt.Fprintf(os.Stderr, "BUG? referenced path %v cannot exist\n", path)
502 |
503 | debug("DURING: updateBothTreesAndReturnNode\n")
504 | debug("--- Tree Original ---\n")
505 | diff.Original.PrintTree(os.Stderr, true, "", len(diff.Original.Children), 0)
506 | debug("--- END ---\n")
507 | debug("--- Tree New ---\n")
508 | diff.New.PrintTree(os.Stderr, true, "", len(diff.New.Children), 0)
509 | debug("--- END ---\n")
510 |
511 | os.Exit(1)
512 | }
513 |
514 | // the parent node have a previous version
515 | } else {
516 | debugInd(7, "the parent node have an old version (Original tree)")
517 | debugInd(8, "old parent: %v", oldParent)
518 | if oldParent.Children == nil {
519 | debugInd(9, "no children: set a new empty children list/map")
520 | oldParent.Children = make(map[string]*nodeInst)
521 | }
522 |
523 | // the parent node was renamed
524 | //if parent.State == opCreate && oldParent.State == opDelete {
525 | // if parent.State == opCreate && oldParent.State == opRename {
526 | //
527 | // // do not create the old node version
528 | // // because it is supposed to be processed by the new files tree
529 | // debugInd(8, "old parent node was renamed, not creating the old node in it")
530 | //
531 | // // no renaming of the parent node
532 | // } else {
533 |
534 | // get the node in the old tree (Original tree)
535 | debugInd(8, "getting the old node (Original tree)")
536 | oldNode := oldParent.Children[nodeName]
537 | debugInd(9, "found: %v", oldNode)
538 |
539 | // the node didn't exist before
540 | if oldNode == nil {
541 | if !isNew || i < len(parts)-1 {
542 | debugInd(8, "isNew is 'false' or the parent part isn't the last one")
543 |
544 | // Was meant to already exist, so make sure it did!
545 | debugInd(8, "creating old node")
546 | oldParent.Children[nodeName] = &nodeInst{}
547 | oldNode = oldParent.Children[nodeName]
548 | oldNode.Name = nodeName
549 | oldNode.Parent = oldParent
550 | newNode.Original = oldNode
551 | debugInd(9, "old node created: %v", oldNode)
552 | debugInd(9, "added to old parent node '%v' (Original tree)", oldParent.Name)
553 | } else {
554 | debugInd(9, "not creating the old node because it is new (%t)", isNew)
555 | }
556 |
557 | // old node exist
558 | } else {
559 | debugInd(8, "previous node version: %v", oldNode)
560 | }
561 | // }
562 | }
563 |
564 | // the parent part/node exists
565 | } else {
566 | debugInd(6, "node exists (New tree)")
567 | if isNew && i == len(parts)-1 {
568 | debugInd(7, "isNew is 'true' and the node is the last one")
569 |
570 | // As this is the target of a create, we should expect to see
571 | // nothing here... or a previously deleted node
572 | if (newNode.State != opDelete) {
573 | fmt.Fprintf(os.Stderr, "BUG? overwritten path %v already existed\n", path)
574 | os.Exit(1)
575 | }
576 | }
577 | }
578 | parent = newNode
579 | }
580 | debugInd(4, "returning node '%v'", parent)
581 | return parent
582 | }
583 |
584 | // convert a node to a string
585 | func (node *nodeInst) String() string {
586 | var oriNodeName string = ""
587 | var oriNodeSt operation
588 | var childrenCount int = len(node.Children)
589 | if node.Original != nil {
590 | oriNodeName = node.Original.Name
591 | if oriNodeName == node.Name {
592 | oriNodeName = ""
593 | }
594 | oriNodeSt = node.Original.State
595 | return fmt.Sprintf("_n('%v', St:%v, ori:%v, oriSt:%v, child:%d)", node.Name, node.State, oriNodeName, oriNodeSt, childrenCount)
596 | }
597 | return fmt.Sprintf("_n('%v', St:%v, child:%d)", node.Name, node.State, childrenCount)
598 | }
599 |
600 | // convert a tree to a string
601 | func (diff *diffInst) String() string {
602 | return "\n\t" + strings.Join((diff.Changes())[:], "\n\t") + "\n"
603 | }
604 |
605 | // getNodePath return the new path of a node
606 | func getNodePath(node *nodeInst, isNew bool) string {
607 | if node != nil {
608 | var path string = node.Name
609 | var current *nodeInst = node.Parent
610 | if current != nil {
611 | for {
612 | debugInd(3, "current node: %v", current)
613 | if current.Name != "/" {
614 | path = current.Name + "/" + path
615 | } else {
616 | path = "/" + path
617 | }
618 | debugInd(3, "path (increment): %v", path)
619 | current = current.Parent
620 | if current == nil {
621 | break
622 | }
623 | }
624 | }
625 | if len(path) > 0 {
626 | debugInd(3, "path (final): '%v'", path)
627 | return path
628 | }
629 | }
630 | return ""
631 | }
632 |
633 | // Changes return the list of changes for a diff double tree
634 | func (diff *diffInst) Changes() []string {
635 | newFiles := make(map[string]*nodeInst)
636 | oldFiles := make(map[string]*nodeInst)
637 | debug("--- new ---")
638 | resolvePathsAndFlatten(&diff.New, "", newFiles)
639 | debug("------")
640 | debug("--- old ---")
641 | resolvePathsAndFlatten(&diff.Original, "", oldFiles)
642 | debug("------")
643 | debug("processing %d old files ...", len(oldFiles))
644 | var ret []string
645 |
646 | // old files
647 | for path, node := range oldFiles {
648 | debugInd(1, "- old node: %v # %v", node, path)
649 |
650 | ancestorRenamed := node.getFirstAncestorRenamed(false /* only consider parent's state */)
651 | if ancestorRenamed != nil {
652 | debugInd(2, "a node's parent has been renamed (%v): ignoring", ancestorRenamed)
653 | continue
654 | }
655 |
656 | // getting the same path in the new files
657 | var newFileNode *nodeInst = newFiles[path]
658 |
659 | debugInd(2, "new file node: %v", newFileNode)
660 |
661 | // all the modified files (found in new files and old node Op is opUnspec)
662 | if newFileNode != nil && node.State == opUnspec {
663 | debugInd(2, "found in new files (%v) and old node St is '%v'", newFileNode, opUnspec)
664 | debugInd(2, "that's a changed file")
665 |
666 | // file hasn't changed
667 | if node.State == opUnspec && newFileNode.State == opUnspec {
668 |
669 | debugInd(2, "found in new files (%v) and old node St is '%v'", newFileNode, opUnspec)
670 | debugInd(2, "that's an unchanged file, not appending it to the list of changes")
671 |
672 | // file has changed
673 | } else {
674 | ret = append(ret, fmt.Sprintf("%7v: %v", newFileNode.State, path))
675 | debugInd(4, "appended (node.St:%v): %7v: %v (%v) (%v)", node.State, newFileNode.State, path, newFileNode, node)
676 | }
677 |
678 | // deleting the node from the new ones, to avoid being processed twice for the same info
679 | debugInd(3, "deleting node in new files")
680 | delete(newFiles, path)
681 |
682 | // a weird changed file (first deleted, then re-created with another content)
683 | } else if node.State == opDelete && newFileNode != nil && newFileNode.State == opCreate {
684 | debugInd(2, "found in new files (%v) and old node St is '%v' (not '%v')", newFileNode, opDelete, opUnspec)
685 | debugInd(2, "that's a weird changed file (deleted and created)")
686 |
687 | ret = append(ret, fmt.Sprintf("%7v: %v", opModify, path))
688 | debugInd(3, "appended (node.St:%v): %7v: %v (%v) (%v)", node.State, opModify, path, newFileNode, node)
689 |
690 | // deleting the node from the new ones, to avoid being processed twice for the same info
691 | debugInd(2, "deleting node in new files")
692 | delete(newFiles, path)
693 |
694 | // not a modified file (not in new files, or node Op is not opUnspec)
695 | } else {
696 | debugInd(2, "not found in new files (%v) or old node St is not '%v'", newFileNode, opUnspec)
697 | debugInd(2, "not a changed file (%v)", node.State)
698 |
699 | // renaming, is handled by the new files
700 | if node.State == opRename {
701 | debugInd(3, "was renamed, not append it to the list of changes (handled by new files)")
702 |
703 | // deletion of a node belonging to a parent also deleted
704 | } else if (node.State == opDelete && node.Parent.State == opDelete) {
705 | debugInd(2, "old node St is '%v' and its parent too: ignoring a node deletion in a parent deleted", node.State)
706 |
707 | // something else
708 | } else {
709 | debugInd(2, "old node St is not '%v' and not '%v', or not in new files (%v), or new file Op is not '%v'", opDelete, opRename, newFileNode, opCreate)
710 | ret = append(ret, fmt.Sprintf("%7v: %v", node.State, path))
711 | debugInd(3, "appended (rest): %7v: %v", node.State, path)
712 | }
713 | }
714 | }
715 |
716 | // new files
717 | debug("processing %d new files ...", len(newFiles))
718 | for path, node := range newFiles {
719 | debugInd(1, "- new node: %v # %v", node, path)
720 |
721 | ancestorRenamed := node.getFirstAncestorRenamed(true /* consider parent's original node state */)
722 | if ancestorRenamed != nil {
723 | debugInd(2, "a node's parent has been renamed (%v): ignoring", ancestorRenamed)
724 | continue
725 | }
726 |
727 | // renaming
728 | if node.State == opCreate && node.Original != nil && node.Original.State == opRename {
729 | debugInd(2, "was renamed")
730 | debugInd(2, "getting old node path...")
731 | oldNodePath := getNodePath(node.Original, false)
732 | debugInd(2, "old node path: '%v'", oldNodePath)
733 | if len(oldNodePath) > 0 {
734 | ret = append(ret, fmt.Sprintf("%7v: %v to %v", node.Original.State, oldNodePath, path))
735 | debugInd(2, "appended (new): %7v: %v to %v", node.Original.State, oldNodePath, path)
736 | }
737 |
738 | } else if (node.State == opDelete) {
739 | debugInd(2, "ignored (deleted): %7v: %v", node.State, path)
740 | } else {
741 | ret = append(ret, fmt.Sprintf("%7v: %v", node.State, path))
742 | debugInd(2, "appended (new): %7v: %v", node.State, path)
743 | }
744 | }
745 | return ret
746 | }
747 |
748 | // return the first node's ancestor that has been renamed
749 | // if checkOriginal is 'true' this is considering the parent's original state
750 | // instead of the parent's state
751 | func (node *nodeInst) getFirstAncestorRenamed(checkOriginal bool) *nodeInst {
752 | if node != nil {
753 | ref := node
754 | for {
755 | if ref.Parent == nil {
756 | break
757 | }
758 | if ((ref.Parent.State == opRename && ! checkOriginal) || (
759 | ref.Parent.State == opCreate && ref.Parent.Original != nil && ref.Parent.Original.State == opRename)) {
760 | return ref.Parent
761 | }
762 | ref = ref.Parent
763 | }
764 | }
765 | return nil
766 | }
767 |
768 | // resolvePathsAndFlatten generate a flat slice with full path mapped to nodes
769 | func resolvePathsAndFlatten(node *nodeInst, prefix string, ret map[string]*nodeInst) {
770 | debug("resolvePathsAndFlatten() %v%v (%v)", prefix, node.Name, node)
771 | newPrefix := prefix + node.Name
772 | debugInd(1, "newPrefix: '%v'", newPrefix)
773 | if newPrefix != "" {
774 | debugInd(1, "replacing node %v by %v", ret[newPrefix], node)
775 | ret[newPrefix] = node
776 | } else {
777 | debugInd(1, "replacing node %v by %v (empty prefix)", ret["/"], node)
778 | ret["/"] = node
779 | }
780 | if (node.State == opCreate && (node.Original == nil || node.Original.State != opRename)) {
781 | debugInd(1, "stoping because node St is '%v' (and its original one wasn't renamed)", opCreate)
782 | return
783 | }
784 | debugInd(1, "iterating over node %d children", len(node.Children))
785 | var trailingSlash string = "/"
786 | if node.Name == "/" {
787 | trailingSlash = ""
788 | }
789 | for _, child := range node.Children {
790 | resolvePathsAndFlatten(child, newPrefix+trailingSlash, ret)
791 | }
792 | }
793 |
794 | // peekAndDiscard return n bytes from the stream buffer, if required increase its size
795 | func peekAndDiscard(input *bufio.Reader, n int) ([]byte, error) {
796 | buffered := input.Buffered()
797 | if n > buffered {
798 | debug("peekAndDiscard() need to read more bytes '%v' than there are buffered '%v'", n, buffered)
799 | debug("peekAndDiscard() increasing the buffer size to match the need")
800 | input = bufio.NewReaderSize(input, n)
801 | }
802 | data, err := input.Peek(n)
803 | if err != nil {
804 | return nil, err
805 | }
806 | if _, err := input.Discard(n); err != nil {
807 | return nil, err
808 | }
809 | return data, nil
810 | }
811 |
812 | // readCommand return a command from reading and parsing the stream input
813 | func readCommand(input *bufio.Reader) (*commandInst, error) {
814 | cmdSizeB, err := peekAndDiscard(input, 4)
815 | if err != nil {
816 | return nil, fmt.Errorf("short read on command size: %v", err)
817 | }
818 | cmdSize := binary.LittleEndian.Uint32(cmdSizeB)
819 | debug("command size: '%v' (%v)", cmdSize, cmdSizeB)
820 | cmdTypeB, err := peekAndDiscard(input, 2)
821 | if err != nil {
822 | return nil, fmt.Errorf("short read on command type: %v", err)
823 | }
824 | cmdType := binary.LittleEndian.Uint16(cmdTypeB)
825 | debug("command type: '%v' (%v)", cmdType, cmdTypeB)
826 | if cmdType > C.BTRFS_SEND_C_MAX {
827 | return nil, fmt.Errorf("stream contains invalid command type %v", cmdType)
828 | }
829 | _, err = peekAndDiscard(input, 4)
830 | if err != nil {
831 | return nil, fmt.Errorf("short read on command checksum: %v", err)
832 | }
833 | cmdData, err := peekAndDiscard(input, int(cmdSize))
834 | if err != nil {
835 | return nil, fmt.Errorf("short read on command data: %v", err)
836 | }
837 | return &commandInst{
838 | Type: &commandsDefs[cmdType],
839 | data: cmdData,
840 | }, nil
841 | }
842 |
843 | // ReadParam return a parameter of a command, if it matches the one expected
844 | func (command *commandInst) ReadParam(expectedType int) (string, error) {
845 | if len(command.data) < 4 {
846 | return "", fmt.Errorf("no more parameters")
847 | }
848 | paramType := binary.LittleEndian.Uint16(command.data[0:2])
849 | debugInd(3, "param type: '%v' (expected: %v, raw: %v)", expectedType, paramType, command.data[0:2])
850 | if int(paramType) != expectedType {
851 | return "", fmt.Errorf("expect type %v; got %v", expectedType, paramType)
852 | }
853 | paramLength := binary.LittleEndian.Uint16(command.data[2:4])
854 | debugInd(3, "param length: '%v' (raw: %v)", paramLength, command.data[2:4])
855 | if int(paramLength)+4 > len(command.data) {
856 | return "", fmt.Errorf("short command param; length was %v but only %v left", paramLength, len(command.data)-4)
857 | }
858 | ret := strings.Trim(string(command.data[4 : 4+paramLength]), "\x00")
859 | debugInd(3, "param: '%v' (str:'%v', raw: %v)", ret, string(command.data[4 : 4+paramLength]), command.data[4 : 4+paramLength])
860 | command.data = command.data[4+paramLength:]
861 | return ret, nil
862 | }
863 |
864 | // readStream reads the stream and produce a diff, using the channel specified
865 | func readStream(stream *os.File, diff *diffInst, channel chan error) {
866 | channel <- doReadStream(stream, diff)
867 | }
868 |
869 | // doReadStream reads the stream and produce a diff
870 | func doReadStream(stream *os.File, diff *diffInst) error {
871 | // ensure that we catch the error from stream.Close()
872 | var err error
873 | defer func() {
874 | cerr := stream.Close()
875 | if err == nil {
876 | err = cerr
877 | }
878 | }()
879 | input := bufio.NewReader(stream)
880 | btrfsStreamHeader, err := input.ReadString('\x00')
881 | if err != nil {
882 | return err
883 | }
884 | if btrfsStreamHeader[:len(btrfsStreamHeader)-1] != C.BTRFS_SEND_STREAM_MAGIC {
885 | return fmt.Errorf("magic is %v, not %v", btrfsStreamHeader, C.BTRFS_SEND_STREAM_MAGIC)
886 | }
887 | verB, err := peekAndDiscard(input, 4)
888 | if err != nil {
889 | return err
890 | }
891 | ver := binary.LittleEndian.Uint32(verB)
892 | if ver != 1 {
893 | return fmt.Errorf("unexpected stream version %v", ver)
894 | }
895 | info("reading each command until EOF ...")
896 | debug("reading each command until EOF ...")
897 | var ret error = nil
898 | var stop bool = false
899 | for {
900 | // read input and get the command type and data
901 | var command *commandInst
902 | command, err = readCommand(input)
903 | if err != nil {
904 | ret = err
905 | break
906 | }
907 | info("%v -> %v", command.Type.Name, command.Type.Op)
908 | debug("%v -> %v", command.Type.Name, command.Type.Op)
909 |
910 | // analyze the command ...
911 | switch command.Type.Op {
912 |
913 | // unspecified: bug
914 | case opUnspec:
915 | ret = fmt.Errorf("unexpected command %v", command)
916 |
917 | // ignored operation
918 | case opIgnore:
919 | debugInd(1, "ignoring (as specified in command definitions)")
920 |
921 | // two path ops
922 | case opRename:
923 | debugInd(1, "'%v' operation", command.Type.Op)
924 | debugInd(2, "reading param (C.BTRFS_SEND_A_PATH) ...")
925 |
926 | // reading 'from' and 'to' params
927 | var fromPath string
928 | var toPath string
929 | fromPath, err = command.ReadParam(C.BTRFS_SEND_A_PATH)
930 | if err != nil {
931 | ret = err
932 | break
933 | }
934 | info("@from: '%v'", fromPath)
935 | debugInd(2, "from: '%v'", fromPath)
936 | debugInd(2, "reading param (C.BTRFS_SEND_A_PATH_TO) ...")
937 | toPath, err = command.ReadParam(C.BTRFS_SEND_A_PATH_TO)
938 | if err != nil {
939 | ret = err
940 | break
941 | }
942 | info("@to: '%v'", toPath)
943 | debugInd(2, "to: '%v'", toPath)
944 |
945 | // process to represent the renaming in the diff double tree
946 | debugInd(2, "updating the diff double tree")
947 | diff.processTwoParamsOp(command.Type.Op, fromPath, toPath)
948 | debugInd(2, "'%v' operation processed", command.Type.Op)
949 |
950 | // end operation
951 | case opEnd:
952 | debugInd(1, "END operation")
953 | stop = true
954 |
955 | // other operations
956 | default:
957 | debugInd(1, "other operation (%v)", command.Type.Op)
958 |
959 | // read the 'path' param
960 | var path string
961 | if (command.Type.Name == "BTRFS_SEND_C_CLONE" && command.Type.Op == opModify) {
962 | debugInd(2, "reading param (C.BTRFS_SEND_A_FILE_OFFSET) ...")
963 | _, err = command.ReadParam(C.BTRFS_SEND_A_FILE_OFFSET)
964 | if err != nil {
965 | ret = err
966 | break
967 | }
968 | debugInd(2, "reading param (C.BTRFS_SEND_A_CLONE_LEN) ...")
969 | _, err = command.ReadParam(C.BTRFS_SEND_A_CLONE_LEN)
970 | if err != nil {
971 | ret = err
972 | break
973 | }
974 | }
975 | debugInd(2, "reading param (C.BTRFS_SEND_A_PATH) ...")
976 | path, err = command.ReadParam(C.BTRFS_SEND_A_PATH)
977 | if err != nil {
978 | ret = err
979 | break
980 | }
981 | info("@path: '%v'", path)
982 | debugInd(2, "path: '%v'", path)
983 |
984 | // adding the operation to the list of changes
985 | debugInd(2, "processing operation '%v'", command.Type.Op)
986 | err = diff.processSingleParamOp(command.Type.Op, path)
987 | if err != nil {
988 | ret = err
989 | break
990 | }
991 | debugInd(2, "operation '%v' processed", command.Type.Op)
992 | }
993 | if stop || err != nil {
994 | debugInd(1, "breaking out of the loop")
995 | break
996 | }
997 | }
998 | return ret
999 | }
1000 |
1001 | // getSubVolUID return the subvolume UID
1002 | func getSubVolUID(path string) (C.__u64, error) {
1003 | var sus C.struct_subvol_uuid_search
1004 | var subvolInfo *C.struct_subvol_info
1005 | info("opening path '%s'", path)
1006 | debug("opening path '%s'", path)
1007 | subvolDir, err := os.OpenFile(path, os.O_RDONLY, 0777)
1008 | if err != nil {
1009 | return 0, fmt.Errorf("open returned %v", err)
1010 | }
1011 | r := C.subvol_uuid_search_init(C.int(subvolDir.Fd()), &sus)
1012 | if r < 0 {
1013 | return 0, fmt.Errorf("subvol_uuid_search_init returned %v", r)
1014 | }
1015 | subvolInfo, err = C.subvol_uuid_search(&sus, 0, nil, 0, C.CString(path), C.subvol_search_by_path)
1016 | if subvolInfo == nil {
1017 | return 0, fmt.Errorf("subvol_uuid_search returned %v", err)
1018 | }
1019 | return C.__u64(subvolInfo.root_id), nil
1020 | }
1021 |
1022 | // btrfsSendSyscall write the file stream with the system call 'btrfs send'
1023 | func btrfsSendSyscall(stream *os.File, source string, subvolume string) error {
1024 | // ensure that we catch the error from stream.Close()
1025 | var err error
1026 | defer func() {
1027 | cerr := stream.Close()
1028 | if err == nil {
1029 | err = cerr
1030 | }
1031 | }()
1032 | debug("opening subvolume '%s'", subvolume)
1033 | subvolDir, err := os.OpenFile(subvolume, os.O_RDONLY, 0777)
1034 | if err != nil {
1035 | return fmt.Errorf("open returned %v", err)
1036 | }
1037 | sourceUID, err := getSubVolUID(source)
1038 | if err != nil {
1039 | fmt.Fprintf(os.Stderr, "getSubVolUID returns %v\n", err)
1040 | os.Exit(1)
1041 | }
1042 | debug("sourceUID %v", sourceUID)
1043 | var subvolFd C.uint = C.uint(subvolDir.Fd())
1044 | var opts C.struct_btrfs_ioctl_send_args
1045 | opts.send_fd = C.__s64(stream.Fd())
1046 | opts.clone_sources = &sourceUID
1047 | opts.clone_sources_count = 1
1048 | opts.parent_root = sourceUID
1049 | opts.flags = C.BTRFS_SEND_FLAG_NO_FILE_DATA
1050 | ret, _, err := syscall.Syscall(syscall.SYS_IOCTL, uintptr(subvolFd), C.BTRFS_IOC_SEND, uintptr(unsafe.Pointer(&opts)))
1051 | if ret != 0 {
1052 | return err
1053 | }
1054 | return nil
1055 | }
1056 |
1057 | // btrfsSendDiff returns the differences between two subvolumes
1058 | func btrfsSendDiff(source, subvolume string) (*diffInst, error) {
1059 | read, write, err := os.Pipe()
1060 | if err != nil {
1061 | return nil, fmt.Errorf("pipe returned %v", err)
1062 | }
1063 |
1064 | var diff diffInst = diffInst{}
1065 | channel := make(chan error)
1066 | go readStream(read, &diff, channel)
1067 | err = btrfsSendSyscall(write, source, subvolume)
1068 | if err != nil {
1069 | return nil, fmt.Errorf("btrfsSendSyscall returns %v", err)
1070 | }
1071 | err = <-channel
1072 | if err != nil {
1073 | return nil, fmt.Errorf("readStream returns %v", err)
1074 | }
1075 | return &diff, nil
1076 | }
1077 |
1078 | // btrfsSendDiff returns the differences from a file stream
1079 | func btrfsStreamFileDiff(streamfile string) (*diffInst, error) {
1080 | debug("opening file '%v'", streamfile)
1081 | f, err := os.Open(streamfile)
1082 | if err != nil {
1083 | return nil, fmt.Errorf("open returned %v", err)
1084 | }
1085 |
1086 | // ensure that we catch the error from f.Close()
1087 | defer func() {
1088 | cerr := f.Close()
1089 | if err == nil {
1090 | err = cerr
1091 | }
1092 | }()
1093 |
1094 | var diff diffInst = diffInst{}
1095 | channel := make(chan error)
1096 | go readStream(f, &diff, channel)
1097 | if err != nil {
1098 | return nil, fmt.Errorf("btrfsGetSyscall returns %v", err)
1099 | }
1100 | err = <-channel
1101 | if err != nil && err != io.EOF {
1102 | return nil, fmt.Errorf("readStream returns %v", err)
1103 | }
1104 | return &diff, nil
1105 | }
1106 |
1107 | // GetChangesFromTwoSubvolumes return a list of changes (a diff) between two BTRFS subvolumes
1108 | func GetChangesFromTwoSubvolumes(child string, parent string) ([]string, error) {
1109 | parentStat, err := os.Stat(parent)
1110 | if err != nil {
1111 | return nil, err
1112 | }
1113 | if !parentStat.IsDir() {
1114 | return nil, fmt.Errorf("'%s' is not a directory", parent)
1115 | }
1116 | childStat, err := os.Stat(child)
1117 | if err != nil {
1118 | return nil, err
1119 | }
1120 | if !childStat.IsDir() {
1121 | return nil, fmt.Errorf("'%s' is not a directory", child)
1122 | }
1123 | diff, err := btrfsSendDiff(parent, child)
1124 | if err != nil {
1125 | return nil, err
1126 | }
1127 | return diff.Changes(), nil
1128 | }
1129 |
1130 | // GetChangesFromStreamFile return a list of changes (a diff) from a BTRFS send stream file
1131 | func GetChangesFromStreamFile(streamfile string) ([]string, error) {
1132 | fileStat, err := os.Lstat(streamfile)
1133 | if err != nil {
1134 | return nil, err
1135 | }
1136 | if !fileStat.Mode().IsRegular() {
1137 | return nil, fmt.Errorf("'%s' is not a file", streamfile)
1138 | }
1139 | diff, err := btrfsStreamFileDiff(streamfile)
1140 | if err != nil {
1141 | return nil, err
1142 | }
1143 | return diff.Changes(), nil
1144 | }
1145 |
1146 | // SetInfo set the info mode flag
1147 | func SetInfo(status bool) {
1148 | infoMode = status
1149 | if infoMode {
1150 | infoLogger = log.New(os.Stderr, infoPrefix, log.Lmicroseconds)
1151 | info("INFO mode enabled")
1152 | }
1153 | }
1154 |
1155 | // SetDebug set the debug mode flag
1156 | func SetDebug(status bool) {
1157 | debugMode = status
1158 | if debugMode {
1159 | debugLogger = log.New(os.Stderr, debugPrefix, log.Lmicroseconds)
1160 | debug("DEBUG mode enabled")
1161 | }
1162 | }
1163 |
1164 | // ConsiderUtimeOp consider the Utime instruction (eventually turned into a 'changed' operation)
1165 | func ConsiderUtimeOp(asOpModify bool) {
1166 | var opRef operation = opTimes
1167 | if asOpModify {
1168 | opRef = opModify
1169 | }
1170 | debug("Utimes will be considered as '%v'", opRef)
1171 | commandsDefs[C.BTRFS_SEND_C_UTIMES] = commandMapOp{Name: "BTRFS_SEND_C_UTIMES", Op: opRef}
1172 | }
1173 |
1174 | // ConsiderChmodOp consider the Chmod instruction (eventually turned into a 'changed' operation)
1175 | func ConsiderChmodOp(asOpModify bool) {
1176 | var opRef operation = opPermissions
1177 | if asOpModify {
1178 | opRef = opModify
1179 | }
1180 | debug("Chmod will be considered as '%v'", opRef)
1181 | commandsDefs[C.BTRFS_SEND_C_CHMOD] = commandMapOp{Name: "BTRFS_SEND_C_CHMOD", Op: opRef}
1182 | }
1183 |
1184 | // ConsiderChownOp consider the Chown instruction (eventually turned into a 'changed' operation)
1185 | func ConsiderChownOp(asOpModify bool) {
1186 | var opRef operation = opOwnership
1187 | if asOpModify {
1188 | opRef = opModify
1189 | }
1190 | debug("Chown will be considered as '%v'", opRef)
1191 | commandsDefs[C.BTRFS_SEND_C_CHOWN] = commandMapOp{Name: "BTRFS_SEND_C_CHOWN", Op: opRef}
1192 | }
1193 |
1194 | // ConsiderXattrOp consider the Xattr instruction (eventually turned into a 'changed' operation)
1195 | func ConsiderXattrOp(asOpModify bool) {
1196 | var opRef operation = opAttributes
1197 | if asOpModify {
1198 | opRef = opModify
1199 | }
1200 | debug("Xattr will be considered as '%v'", opRef)
1201 | commandsDefs[C.BTRFS_SEND_C_SET_XATTR] = commandMapOp{Name: "BTRFS_SEND_C_SET_XATTR", Op: opRef}
1202 | commandsDefs[C.BTRFS_SEND_C_REMOVE_XATTR] = commandMapOp{Name: "BTRFS_SEND_C_REMOVE_XATTR", Op: opRef}
1203 | }
1204 |
--------------------------------------------------------------------------------
/test.data:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/mbideau/btrfs-diff-go/f170ae4ff60bfa5224e956aebd1971616915d8d6/test.data
--------------------------------------------------------------------------------
/test.sh:
--------------------------------------------------------------------------------
1 | #!/bin/bash
2 |
3 | set -e
4 |
5 | THIS_DIR="$(realpath "$(dirname "$0")")"
6 |
7 | if [ "$BTRFS_DIFF_BIN" = '' ]; then
8 | BTRFS_DIFF_BIN="$THIS_DIR"/btrfs-diff-go
9 | fi
10 | if [ "$TMPDIR" = '' ]; then
11 | TMPDIR="$THIS_DIR"/.tmp
12 | fi
13 | if [ "$TEST_DIR" = '' ]; then
14 | TEST_DIR="$THIS_DIR"/testdir
15 | fi
16 | DATA_DIR="$TEST_DIR"/data
17 | SNAPS_DIR="$TEST_DIR"/snaps
18 |
19 | if [ ! -e "$BTRFS_DIFF_BIN" ]; then
20 | echo "Binary '$BTRFS_DIFF_BIN' not found" >&2
21 | exit 1
22 | fi
23 | if [ ! -x "$BTRFS_DIFF_BIN" ]; then
24 | echo "Binary '$BTRFS_DIFF_BIN' not executable" >&2
25 | exit 1
26 | fi
27 |
28 | use_sudo=
29 | if [ "$(id -u)" != '0' ]; then
30 | echo "Using sudo"
31 | use_sudo=sudo
32 | fi
33 |
34 | echo "Tmp directory: '$TMPDIR'"
35 | [ ! -d "$TMPDIR" ] && mkdir -p "$TMPDIR"
36 | $use_sudo chown "$USER" "$TMPDIR"
37 | $use_sudo chmod u=rwx "$TMPDIR"
38 |
39 | echo "Test directory: '$TEST_DIR'"
40 | remove_test_dir=false
41 | if [ ! -d "$TEST_DIR" ]; then
42 | mkdir -p "$TEST_DIR"
43 | remove_test_dir=true
44 | fi
45 | $use_sudo chown "$USER" "$TEST_DIR"
46 | $use_sudo chmod u=rwx "$TEST_DIR"
47 |
48 | echo "-- Removing existing data and snapshots"
49 | [ -d "$DATA_DIR" ] && $use_sudo btrfs subvolume delete "$DATA_DIR" > /dev/null
50 | if [ -d "$SNAPS_DIR" ]; then
51 | [ -n "$(ls "$SNAPS_DIR")" ] && for snap in "$SNAPS_DIR"/*; do
52 | $use_sudo btrfs subvolume delete "$snap" > /dev/null
53 | done
54 | fi
55 | rm -f "$TMPDIR"/a_raw "$TMPDIR"/a "$TMPDIR"/b "$TMPDIR"/b_diff "$TMPDIR"/diff "$TMPDIR"/diff.out "$TMPDIR"/diff.src
56 |
57 | echo "-- Creating a subvolume that will contains the data: '$DATA_DIR' (read-write)"
58 | btrfs subvolume create "$DATA_DIR" > /dev/null
59 |
60 | echo "-- Creating a subvolume that will contains the snapshots: '$SNAPS_DIR' (read-only)"
61 | [ ! -d "$SNAPS_DIR" ] && mkdir -p "$SNAPS_DIR"
62 |
63 | echo "-- Creating first snapshot (with no data)"
64 | btrfs subvolume snapshot -r "$DATA_DIR" "$SNAPS_DIR"/000 > /dev/null
65 |
66 | echo "-- Creating data and snapshots for each commands"
67 | I=1
68 | (
69 | cat < foo_file
71 | mkdir bar
72 | mv foo_file bar
73 | echo baz > bar/baz_file
74 | ln bar/baz_file bar/baaz_file
75 | mv bar/baz_file bar/foo_file
76 | rm bar/foo_file
77 | rm -rf bar
78 | mkdir dir
79 | touch dir/file
80 | mkfifo dir/fifo
81 | ln dir/file dir/hardlink
82 | ln -s file dir/symlink
83 | mv dir/hardlink dir/hardlink.rn
84 | mv dir/symlink dir/symlink.rn
85 | mv dir/fifo dir/fifo.rn
86 | echo todel > dir/file_to_del
87 | mkdir -p dir/subdir/leafdir
88 | echo yep > dir/subdir/yep
89 | echo leaf > dir/subdir/leafdir/leaf
90 | mv dir topdir
91 | rm -rf topdir
92 | END
93 | ) | while read -r command; do
94 | (cd "$DATA_DIR"; sh -c "$command")
95 | btrfs subvolume snapshot -r "$DATA_DIR" "$SNAPS_DIR/$(printf "%03i" $I)" > /dev/null
96 | echo "$I: $command" >&2
97 | I=$((I + 1))
98 | done
99 |
100 | echo "-- Comparing snapshots between them with '$(basename "$BTRFS_DIFF_BIN")' "`
101 | `"then with 'diff' and printing unmatching lines (between both diff)"
102 | failed=false
103 | for A in "$SNAPS_DIR"/*; do
104 | for B in "$SNAPS_DIR"/*; do
105 | if [ "$A" = "$B" ]; then continue; fi
106 | $use_sudo "$BTRFS_DIFF_BIN" "$A" "$B" > "$TMPDIR"/a_raw 2>&1 || true
107 | sed 's#^renamed: \(.*\) to \(.*\)$# added: \2\ndeleted: \1#g' "$TMPDIR"/a_raw | sort > "$TMPDIR"/a || true
108 | LC_ALL=C diff -qr "$A" "$B" | \
109 | sed "s|$A|old|; s|$B|new|g; s|: |/|; s/Only in new/ added: /; s/Only in old/deleted: /; s|Files old/.* and new/\(.*\) differ|changed: /\1|" | \
110 | sed "/File .* is a fifo while file .* is a fifo/d" | \
111 | sort > "$TMPDIR"/b || true
112 | # Filter things that were spuriously added (can happen due to utimes changes and stuff).
113 | # Then filter only changes (else we spit out headers for the stuff we filtered).
114 | if ! LC_ALL=C diff -u5 "$TMPDIR"/a "$TMPDIR"/b >"$TMPDIR"/b_diff && \
115 | [ "$(cat -s "$TMPDIR"/b_diff | grep -v '^-changed' | grep -c '^[+-][^+-]')" -ne 0 ]; then
116 | echo "FAIL: $A $B" | sed "s|$TEST_DIR/\?||g"
117 | cat -s "$TMPDIR"/b_diff | grep -v '^-changed' | grep '^[+-][^+-]' | sed "s|^|$A $B: |" | sed "s|$TEST_DIR/\?||g"
118 | failed=true
119 | break 2
120 | fi
121 | done
122 | done
123 | if [ "$failed" = 'false' ]; then
124 | echo "SUCCESS"
125 | else
126 | echo "FAIL"
127 | exit 1
128 | fi
129 |
130 | echo "-- Now testing against a tricky stream file ..."
131 | # from: https://git.kernel.org/pub/scm/linux/kernel/git/kdave/btrfs-progs.git/tree/tests/misc-tests/016-send-clone-src
132 | # 'multi-clone-src-v4.8.2.stream.xz' has been extracted and 'multi-clone-src-v4.8.2.stream' renamed to 'test.data'
133 | failed=true
134 | if ! "$BTRFS_DIFF_BIN" --file "$THIS_DIR"/test.data >"$TMPDIR"/diff.out; then
135 | cat >"$TMPDIR"/diff.src < /dev/null
154 | if [ -d "$SNAPS_DIR" ]; then
155 | [ -n "$(ls "$SNAPS_DIR")" ] && for snap in "$SNAPS_DIR"/*; do
156 | $use_sudo btrfs subvolume delete "$snap" > /dev/null
157 | done
158 | fi
159 | rm -f "$TMPDIR"/a_raw "$TMPDIR"/a "$TMPDIR"/b "$TMPDIR"/b_diff "$TMPDIR"/diff "$TMPDIR"/diff.out "$TMPDIR"/diff.src
160 | if [ -d "$TEST_DIR" ] && [ "$remove_test_dir" = 'true' ]; then
161 | rm -fr "$TEST_DIR"
162 | fi
163 |
--------------------------------------------------------------------------------