WereSync-1.1.5/ 0000755 0001750 0001751 00000000000 13503555360 013775 5 ustar daniel daniel 0000000 0000000 WereSync-1.1.5/LICENSE.txt 0000644 0001750 0001751 00000021707 13501054034 015615 0 ustar daniel daniel 0000000 0000000 Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction, and
distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by the
copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all other
entities that control, are controlled by, or are under common control with
that entity. For the purposes of this definition, "control" means (i) the
power, direct or indirect, to cause the direction or management of such
entity, whether by contract or otherwise, or (ii) ownership of fifty percent
(50%) or more of the outstanding shares, or (iii) beneficial ownership of such
entity.
"You" (or "Your") shall mean an individual or Legal Entity exercising
permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation source, and
configuration files.
"Object" form shall mean any form resulting from mechanical transformation or
translation of a Source form, including but not limited to compiled object
code, generated documentation, and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or Object form,
made available under the License, as indicated by a copyright notice that is
included in or attached to the work (an example is provided in the Appendix
below).
"Derivative Works" shall mean any work, whether in Source or Object form, that
is based on (or derived from) the Work and for which the editorial revisions,
annotations, elaborations, or other modifications represent, as a whole, an
original work of authorship. For the purposes of this License, Derivative
Works shall not include works that remain separable from, or merely link (or
bind by name) to the interfaces of, the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including the original
version of the Work and any modifications or additions to that Work or
Derivative Works thereof, that is intentionally submitted to Licensor for
inclusion in the Work by the copyright owner or by an individual or Legal
Entity authorized to submit on behalf of the copyright owner. For the purposes
of this definition, "submitted" means any form of electronic, verbal, or
written communication sent to the Licensor or its representatives, including
but not limited to communication on electronic mailing lists, source code
control systems, and issue tracking systems that are managed by, or on behalf
of, the Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise designated
in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity on behalf
of whom a Contribution has been received by Licensor and subsequently
incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of this
License, each Contributor hereby grants to You a perpetual, worldwide,
non-exclusive, no-charge, royalty-free, irrevocable copyright license to
reproduce, prepare Derivative Works of, publicly display, publicly perform,
sublicense, and distribute the Work and such Derivative Works in Source or
Object form.
3. Grant of Patent License. Subject to the terms and conditions of this
License, each Contributor hereby grants to You a perpetual, worldwide,
non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this
section) patent license to make, have made, use, offer to sell, sell, import,
and otherwise transfer the Work, where such license applies only to those
patent claims licensable by such Contributor that are necessarily infringed by
their Contribution(s) alone or by combination of their Contribution(s) with
the Work to which such Contribution(s) was submitted. If You institute patent
litigation against any entity (including a cross-claim or counterclaim in a
lawsuit) alleging that the Work or a Contribution incorporated within the Work
constitutes direct or contributory patent infringement, then any patent
licenses granted to You under this License for that Work shall terminate as of
the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the Work or
Derivative Works thereof in any medium, with or without modifications, and in
Source or Object form, provided that You meet the following conditions:
You must give any other recipients of the Work or Derivative Works a copy
of this License; and
You must cause any modified files to carry prominent notices stating that
You changed the files; and
You must retain, in the Source form of any Derivative Works that You
distribute, all copyright, patent, trademark, and attribution notices from the
Source form of the Work, excluding those notices that do not pertain to any
part of the Derivative Works; and
If the Work includes a "NOTICE" text file as part of its distribution,
then any Derivative Works that You distribute must include a readable copy of
the attribution notices contained within such NOTICE file, excluding those
notices that do not pertain to any part of the Derivative Works, in at least
one of the following places: within a NOTICE text file distributed as part of
the Derivative Works; within the Source form or documentation, if provided
along with the Derivative Works; or, within a display generated by the
Derivative Works, if and wherever such third-party notices normally appear.
The contents of the NOTICE file are for informational purposes only and do not
modify the License. You may add Your own attribution notices within Derivative
Works that You distribute, alongside or as an addendum to the NOTICE text from
the Work, provided that such additional attribution notices cannot be
construed as modifying the License.
You may add Your own copyright statement to Your modifications and may
provide additional or different license terms and conditions for use,
reproduction, or distribution of Your modifications, or for any such
Derivative Works as a whole, provided Your use, reproduction, and distribution
of the Work otherwise complies with the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise, any
Contribution intentionally submitted for inclusion in the Work by You to the
Licensor shall be under the terms and conditions of this License, without any
additional terms or conditions. Notwithstanding the above, nothing herein
shall supersede or modify the terms of any separate license agreement you may
have executed with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade names,
trademarks, service marks, or product names of the Licensor, except as
required for reasonable and customary use in describing the origin of the Work
and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or agreed to in
writing, Licensor provides the Work (and each Contributor provides its
Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, either express or implied, including, without limitation, any warranties
or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any risks
associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory, whether in
tort (including negligence), contract, or otherwise, unless required by
applicable law (such as deliberate and grossly negligent acts) or agreed to in
writing, shall any Contributor be liable to You for damages, including any
direct, indirect, special, incidental, or consequential damages of any
character arising as a result of this License or out of the use or inability
to use the Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all other
commercial damages or losses), even if such Contributor has been advised of
the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing the Work
or Derivative Works thereof, You may choose to offer, and charge a fee for,
acceptance of support, warranty, indemnity, or other liability obligations
and/or rights consistent with this License. However, in accepting such
obligations, You may act only on Your own behalf and on Your sole
responsibility, not on behalf of any other Contributor, and only if You agree
to indemnify, defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason of your
accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
WereSync-1.1.5/MANIFEST.in 0000644 0001750 0001751 00000001117 13501276103 015524 0 ustar daniel daniel 0000000 0000000 include README.rst
include LICENSE.txt
include COPYING
include AUTHORS
include docs/Makefile
recursive-include src *.py
recursive-include tests *.py
recursive-include docs *.rst
recursive-include docs *.py
recursive-include docs *.inc
recursive-include docs/source *.html
recursive-include docs/source *.png
recursive-include src *.svg
recursive-include src *.png
recursive-include src *.po
include src/weresync/resources/weresync.service
include src/weresync/resources/weresync-dbus.conf
include src/weresync/resources/weresync-gui.desktop
include src/weresync/resources/locale/weresync.pot WereSync-1.1.5/PKG-INFO 0000644 0001750 0001751 00000016352 13503555360 015101 0 ustar daniel daniel 0000000 0000000 Metadata-Version: 1.0
Name: WereSync
Version: 1.1.5
Summary: Incrementally clones Linux drives
Home-page: https://github.com/DonyorM/weresync
Author: Daniel Manila
Author-email: dmv@springwater7.org
License: Apache 2.0
Description: ########
WereSync
########
`Installation <#installation>`__ | `Basic Usage <#basic-usage>`__ | `Documentation `__ | `Contributing <#contributing-and-bug-reports>`__
.. image:: https://github.com/DonyorM/weresync/raw/master/docs/source/img/weresync-logo.png
:align: center
:alt: WereSync Logo
A lone hard drive stands atop a data heap, staring at the full moon. Suddenly, it
transforms...into a bootable clone of your drive, whirring hungrily at the digital
moon.
WereSync takes a Linux hard drive and effectively clones it, but works incrementally
so you don't have to spend so long backing up each time. Additionally, WereSync
can clone to a smaller drive, if your data will fit on the smaller drive. Because WereSync
uses rsync to copy, it can copy a running drive, though certain parts of state may not be
preserved.
Why Use WereSync?
=================
Hopefully, you think this project looks amazing and you want to try it right away.
However, you may be skeptical about the usefulness of WereSync. You may be
thinking, I can do this exact same thing using gparted or ddrescue. Hear me out!
There are a few reasons to use WereSync over the other tools.
- **WereSync is accessible to less-technical users.** It comes with a simple
interface and clone a drive with a single command while your computer is
running. No booting to a live disk or pushing through a long initiation
process. Unlike `dd` or CloneZilla, WereSync requires a low level of
technical skill and has an easy learning curve
- WereSync can run while the your main drive is being used, instead of blocking your computer up for hours at a time
- WereSync will incrementally update clones, making subsequent clones much faster.
- WereSync works quickly, a single command copies your entire drive, no booting to live CDs or managing MBRs.
- WereSync can copy to a smaller drive, provided your drive's data will fit.
- WereSync creates new UUIDs for the new partitions, allowing you to use the old and new drives alongside each other.
Full documentation may be found `here `__.
Installation
============
WereSync can be installed using the `setup.py` file.
.. code-block:: bash
$ ./setup.py install
If you have `pip `__ installed, you can easily install WereSync with the following command::
$ pip install weresync
For more in-depth instructions, see the `installation documentation `__.
Basic Usage
===========
**Note:** The WereSync daemon requires root capabilities to run because it has
to access block devices. The client GUI and CLI programs do not need root permissions.
Copy the policy file in `src/wersync/resources/weresync-dbus.conf` to
`/etc/dbus-1/system.d`. Then start the daemon::
$ sudo weresync-daemon & >/dev/null 2>&1
Then gui can be launched with the command::
$ weresync-gui
Which generates the following GUI, though generally the advanced options are unneeded:
.. image:: https://github.com/DonyorM/weresync/raw/master/docs/source/img/gui-example.png
:align: left
:alt: Picture of WereSync GUI
To see the options for the terminal command use::
$ weresync -h
To copy from /dev/sda to /dev/sdb (the two drives must have the same partition scheme) use::
$ weresync /dev/sda /dev/sdb
After the copy is completely finished, you can kill the daemon process.
For more information, including how to copy the partition table from drive to
another, see the `Basic Usage `__
documentation page.
Documentation
=============
Documentation can be found on the `Read the Docs `__.
Contributing and Bug Reports
============================
First, take a look at our `contribution guidelines `__.
To contribute simply fork this repository, make your changes, and submit a pull
request. Bugs can be reported on the `issue tracker `__
WereSync currently has huge need of people testing the program on complex drive setups. In order to do this please:
1. Install WereSync from pip::
pip install weresync
#. Run it on your system::
sudo weresync -C source_drive target_drive
#. Report any errors to the `issue tracker `__. Please be sure to post the contents of ``/var/log/weresync/weresync.log`` and ``fdisk -l``.
All contributions will be greatly appreciated!
Distributions Capability for Drive Copying
------------------------------------------
|ubuntu| |debian| |arch| |centos| |fedora| |opensuse|
.. |ubuntu| image:: https://img.shields.io/badge/ubuntu-stable-brightgreen.svg
.. |arch| image:: https://img.shields.io/badge/Arch%20Linux-stable-brightgreen.svg
.. |centos| image:: https://img.shields.io/badge/CentOS-not%20tested-red.svg
.. |fedora| image:: https://img.shields.io/badge/Fedora-not%20tested-red.svg
.. |opensuse| image:: https://img.shields.io/badge/openSUSE-not%20tested-red.svg
.. |debian| image:: https://img.shields.io/badge/Debian-stable-brightgreen.svg
If you are able to test any of these systems, please report your exprience at the `issue tracker `__. Any help will be much appreciated.
Licensing
=========
This project is licensed under the `Apache 2.0 License `__. Licensing is in the **LICENSE.txt** file in this directory.
Acknowledgments
===============
Huge thanks to the creators of:
* `rsync `__, whose software allowed this project to be possible.
* `GNU Parted `__
* And `GPT fdisk `__
Keywords: clone,linux,backup,smaller drive
Platform: UNKNOWN
WereSync-1.1.5/README.rst 0000644 0001750 0001751 00000013444 13501054034 015460 0 ustar daniel daniel 0000000 0000000 ########
WereSync
########
`Installation <#installation>`__ | `Basic Usage <#basic-usage>`__ | `Documentation `__ | `Contributing <#contributing-and-bug-reports>`__
.. image:: https://github.com/DonyorM/weresync/raw/master/docs/source/img/weresync-logo.png
:align: center
:alt: WereSync Logo
A lone hard drive stands atop a data heap, staring at the full moon. Suddenly, it
transforms...into a bootable clone of your drive, whirring hungrily at the digital
moon.
WereSync takes a Linux hard drive and effectively clones it, but works incrementally
so you don't have to spend so long backing up each time. Additionally, WereSync
can clone to a smaller drive, if your data will fit on the smaller drive. Because WereSync
uses rsync to copy, it can copy a running drive, though certain parts of state may not be
preserved.
Why Use WereSync?
=================
Hopefully, you think this project looks amazing and you want to try it right away.
However, you may be skeptical about the usefulness of WereSync. You may be
thinking, I can do this exact same thing using gparted or ddrescue. Hear me out!
There are a few reasons to use WereSync over the other tools.
- **WereSync is accessible to less-technical users.** It comes with a simple
interface and clone a drive with a single command while your computer is
running. No booting to a live disk or pushing through a long initiation
process. Unlike `dd` or CloneZilla, WereSync requires a low level of
technical skill and has an easy learning curve
- WereSync can run while the your main drive is being used, instead of blocking your computer up for hours at a time
- WereSync will incrementally update clones, making subsequent clones much faster.
- WereSync works quickly, a single command copies your entire drive, no booting to live CDs or managing MBRs.
- WereSync can copy to a smaller drive, provided your drive's data will fit.
- WereSync creates new UUIDs for the new partitions, allowing you to use the old and new drives alongside each other.
Full documentation may be found `here `__.
Installation
============
WereSync can be installed using the `setup.py` file.
.. code-block:: bash
$ ./setup.py install
If you have `pip `__ installed, you can easily install WereSync with the following command::
$ pip install weresync
For more in-depth instructions, see the `installation documentation `__.
Basic Usage
===========
**Note:** The WereSync daemon requires root capabilities to run because it has
to access block devices. The client GUI and CLI programs do not need root permissions.
Copy the policy file in `src/wersync/resources/weresync-dbus.conf` to
`/etc/dbus-1/system.d`. Then start the daemon::
$ sudo weresync-daemon & >/dev/null 2>&1
Then gui can be launched with the command::
$ weresync-gui
Which generates the following GUI, though generally the advanced options are unneeded:
.. image:: https://github.com/DonyorM/weresync/raw/master/docs/source/img/gui-example.png
:align: left
:alt: Picture of WereSync GUI
To see the options for the terminal command use::
$ weresync -h
To copy from /dev/sda to /dev/sdb (the two drives must have the same partition scheme) use::
$ weresync /dev/sda /dev/sdb
After the copy is completely finished, you can kill the daemon process.
For more information, including how to copy the partition table from drive to
another, see the `Basic Usage `__
documentation page.
Documentation
=============
Documentation can be found on the `Read the Docs `__.
Contributing and Bug Reports
============================
First, take a look at our `contribution guidelines `__.
To contribute simply fork this repository, make your changes, and submit a pull
request. Bugs can be reported on the `issue tracker `__
WereSync currently has huge need of people testing the program on complex drive setups. In order to do this please:
1. Install WereSync from pip::
pip install weresync
#. Run it on your system::
sudo weresync -C source_drive target_drive
#. Report any errors to the `issue tracker `__. Please be sure to post the contents of ``/var/log/weresync/weresync.log`` and ``fdisk -l``.
All contributions will be greatly appreciated!
Distributions Capability for Drive Copying
------------------------------------------
|ubuntu| |debian| |arch| |centos| |fedora| |opensuse|
.. |ubuntu| image:: https://img.shields.io/badge/ubuntu-stable-brightgreen.svg
.. |arch| image:: https://img.shields.io/badge/Arch%20Linux-stable-brightgreen.svg
.. |centos| image:: https://img.shields.io/badge/CentOS-not%20tested-red.svg
.. |fedora| image:: https://img.shields.io/badge/Fedora-not%20tested-red.svg
.. |opensuse| image:: https://img.shields.io/badge/openSUSE-not%20tested-red.svg
.. |debian| image:: https://img.shields.io/badge/Debian-stable-brightgreen.svg
If you are able to test any of these systems, please report your exprience at the `issue tracker `__. Any help will be much appreciated.
Licensing
=========
This project is licensed under the `Apache 2.0 License `__. Licensing is in the **LICENSE.txt** file in this directory.
Acknowledgments
===============
Huge thanks to the creators of:
* `rsync `__, whose software allowed this project to be possible.
* `GNU Parted `__
* And `GPT fdisk `__
WereSync-1.1.5/docs/ 0000755 0001750 0001751 00000000000 13503555360 014725 5 ustar daniel daniel 0000000 0000000 WereSync-1.1.5/docs/Makefile 0000644 0001750 0001751 00000016707 13501054034 016366 0 ustar daniel daniel 0000000 0000000 # Makefile for Sphinx documentation
#
# You can set these variables from the command line.
SPHINXOPTS =
SPHINXBUILD = sphinx-build
PAPER =
BUILDDIR = build
# Internal variables.
PAPEROPT_a4 = -D latex_paper_size=a4
PAPEROPT_letter = -D latex_paper_size=letter
ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source
# the i18n builder cannot share the environment and doctrees with the others
I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) source
.PHONY: help
help:
@echo "Please use \`make ' where is one of"
@echo " html to make standalone HTML files"
@echo " dirhtml to make HTML files named index.html in directories"
@echo " singlehtml to make a single large HTML file"
@echo " pickle to make pickle files"
@echo " json to make JSON files"
@echo " htmlhelp to make HTML files and a HTML help project"
@echo " qthelp to make HTML files and a qthelp project"
@echo " applehelp to make an Apple Help Book"
@echo " devhelp to make HTML files and a Devhelp project"
@echo " epub to make an epub"
@echo " epub3 to make an epub3"
@echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter"
@echo " latexpdf to make LaTeX files and run them through pdflatex"
@echo " latexpdfja to make LaTeX files and run them through platex/dvipdfmx"
@echo " text to make text files"
@echo " man to make manual pages"
@echo " texinfo to make Texinfo files"
@echo " info to make Texinfo files and run them through makeinfo"
@echo " gettext to make PO message catalogs"
@echo " changes to make an overview of all changed/added/deprecated items"
@echo " xml to make Docutils-native XML files"
@echo " pseudoxml to make pseudoxml-XML files for display purposes"
@echo " linkcheck to check all external links for integrity"
@echo " doctest to run all doctests embedded in the documentation (if enabled)"
@echo " coverage to run coverage check of the documentation (if enabled)"
@echo " dummy to check syntax errors of document sources"
.PHONY: clean
clean:
rm -rf $(BUILDDIR)/*
.PHONY: html
html:
$(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/html."
.PHONY: dirhtml
dirhtml:
$(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml
@echo
@echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml."
.PHONY: singlehtml
singlehtml:
$(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml
@echo
@echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml."
.PHONY: pickle
pickle:
$(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle
@echo
@echo "Build finished; now you can process the pickle files."
.PHONY: json
json:
$(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json
@echo
@echo "Build finished; now you can process the JSON files."
.PHONY: htmlhelp
htmlhelp:
$(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp
@echo
@echo "Build finished; now you can run HTML Help Workshop with the" \
".hhp project file in $(BUILDDIR)/htmlhelp."
.PHONY: qthelp
qthelp:
$(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp
@echo
@echo "Build finished; now you can run "qcollectiongenerator" with the" \
".qhcp project file in $(BUILDDIR)/qthelp, like this:"
@echo "# qcollectiongenerator $(BUILDDIR)/qthelp/WereSync.qhcp"
@echo "To view the help file:"
@echo "# assistant -collectionFile $(BUILDDIR)/qthelp/WereSync.qhc"
.PHONY: applehelp
applehelp:
$(SPHINXBUILD) -b applehelp $(ALLSPHINXOPTS) $(BUILDDIR)/applehelp
@echo
@echo "Build finished. The help book is in $(BUILDDIR)/applehelp."
@echo "N.B. You won't be able to view it unless you put it in" \
"~/Library/Documentation/Help or install it in your application" \
"bundle."
.PHONY: devhelp
devhelp:
$(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp
@echo
@echo "Build finished."
@echo "To view the help file:"
@echo "# mkdir -p $$HOME/.local/share/devhelp/WereSync"
@echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/WereSync"
@echo "# devhelp"
.PHONY: epub
epub:
$(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub
@echo
@echo "Build finished. The epub file is in $(BUILDDIR)/epub."
.PHONY: epub3
epub3:
$(SPHINXBUILD) -b epub3 $(ALLSPHINXOPTS) $(BUILDDIR)/epub3
@echo
@echo "Build finished. The epub3 file is in $(BUILDDIR)/epub3."
.PHONY: latex
latex:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo
@echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex."
@echo "Run \`make' in that directory to run these through (pdf)latex" \
"(use \`make latexpdf' here to do that automatically)."
.PHONY: latexpdf
latexpdf:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo "Running LaTeX files through pdflatex..."
$(MAKE) -C $(BUILDDIR)/latex all-pdf
@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
.PHONY: latexpdfja
latexpdfja:
$(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex
@echo "Running LaTeX files through platex and dvipdfmx..."
$(MAKE) -C $(BUILDDIR)/latex all-pdf-ja
@echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex."
.PHONY: text
text:
$(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text
@echo
@echo "Build finished. The text files are in $(BUILDDIR)/text."
.PHONY: man
man:
$(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man
@echo
@echo "Build finished. The manual pages are in $(BUILDDIR)/man."
.PHONY: texinfo
texinfo:
$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
@echo
@echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo."
@echo "Run \`make' in that directory to run these through makeinfo" \
"(use \`make info' here to do that automatically)."
.PHONY: info
info:
$(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo
@echo "Running Texinfo files through makeinfo..."
make -C $(BUILDDIR)/texinfo info
@echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo."
.PHONY: gettext
gettext:
$(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale
@echo
@echo "Build finished. The message catalogs are in $(BUILDDIR)/locale."
.PHONY: changes
changes:
$(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes
@echo
@echo "The overview file is in $(BUILDDIR)/changes."
.PHONY: linkcheck
linkcheck:
$(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck
@echo
@echo "Link check complete; look for any errors in the above output " \
"or in $(BUILDDIR)/linkcheck/output.txt."
.PHONY: doctest
doctest:
$(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest
@echo "Testing of doctests in the sources finished, look at the " \
"results in $(BUILDDIR)/doctest/output.txt."
.PHONY: coverage
coverage:
$(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage
@echo "Testing of coverage in the sources finished, look at the " \
"results in $(BUILDDIR)/coverage/python.txt."
.PHONY: xml
xml:
$(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml
@echo
@echo "Build finished. The XML files are in $(BUILDDIR)/xml."
.PHONY: pseudoxml
pseudoxml:
$(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml
@echo
@echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml."
.PHONY: dummy
dummy:
$(SPHINXBUILD) -b dummy $(ALLSPHINXOPTS) $(BUILDDIR)/dummy
@echo
@echo "Build finished. Dummy builder generates no files."
WereSync-1.1.5/docs/source/ 0000755 0001750 0001751 00000000000 13503555360 016225 5 ustar daniel daniel 0000000 0000000 WereSync-1.1.5/docs/source/_templates/ 0000755 0001750 0001751 00000000000 13503555360 020362 5 ustar daniel daniel 0000000 0000000 WereSync-1.1.5/docs/source/_templates/homepage.html 0000644 0001750 0001751 00000000170 13501054034 023021 0 ustar daniel daniel 0000000 0000000
XT+ia"tڞfNy˖ɆVPVСCy L&f/q,
U 0PH̓IӆNG\skR"
LԣͪM[:.s2ݝNy.N4 "𫫫u(nB E%L7#"VY'EU
j|&,*" j(QRl4Q*$?Б-ۆ.E6 { v}H"eGkZ4~8 `0h4ht`?E[}.<ڎITG&@WM:0Sc7;S
x7WM
qr\# CHzY7Qo{"FFr 0 ǎdm}^}ш?TT2!2Agw_nE^c/h!"Tu"fSa金
OĎ D' cF0`< t:M6RDDUέ,#xeĨz V]Fݕ[蛇eD:!8i*Dck(x$z 7y=Na2>DөV L}6o1b+sD zTtnZaMEkq"vo_*y˦'Oh{7d20 g 80FyF[# 7onHГhee䤤QB?cx艓f)$iÀm\>!!XᎊebĩgIUEg6bCUJŤE۲DM&A7n( ftk$UQdZ>Iռ :m6!ɂ"˃Rt
fSs߇W-m3NC2Yx "IfG\rEjlNGt: %E!kY&R aZ?'IZ'b Og5L$
ټ}J%(J| S>TDi!a$ISѭ]! NF~FuE2a]/Ej\.;]Pms:BdTc 7iw- rObX%Aߏ\ON@R݁ҲټQH.y!
TRt]}.!f#cR>=NUv]ζqTUmQO,0oEYټ=brYm ;;;r# >gI-tNjl'm|O 3mՉЍ `0P R: ;v ߦ)͆>ټ=-CRV49v]KߴD}z Clmm]ו FNz3XA ΤmtO͌ o~gӋh"m?jj&9v^Su]s$QiFi䣉<6 J- C8wrOCD >nnT @irpʕY^q泸 U$6YOy&VnPdfkM}p }Apoo':=d~ܺuk{4߈g CO
]jH i _.h"~mOcg",kt}ʋx #b"=űagg{= 4OU->hl!nnݺ=m鰴$"D H
>ungCOۚ4.m4]ZZYկ`8 ~ v:
0Oe.
E.z }ɓ'Z*%eoo\fpb 4\sk lF-I3.&<=>uh+&a5 ֭[}_;w7! xK / |QO}G;^8(x"|gjR@Z/LzA&1-i # L#*6)5yF٥k-wE" `wwΞ= .\d ~4MA,Բ(]'#jj^tonnvlmm fa'YHttQ JIDAT]z I`ɋxF yFmv]= #i
CbnyL N0 assΟ?Ν݈=|UHGȥQh "> ʲ8-;rH_.J ҧ =zj,//áCfSj*i CfXtoiGE&3> OWHT'[g?&li4U,{@&e]vV42 g?b#fy6ދ/xj}}y6c> , > ̋h?F}ժvs2 ܼ˭V=[̛UA$0 ?MRG
1 ?Vzg6t]~c=vlEAayҥu۠.qD;R *:yᖊ9ڵkWVWWj~GAl }џ^tpe\tyQ:NwY些7o(JСC/4b{AIx7Op`g :Xu>ݻ{ƍ ]z3x$Q9/R7.UA'&[Gԕ>jtԩ frZ}! LNݳgMxKtYQ+666WVVPTV+ʡRZ*V
Ðw ƆF%tA(<Ѷa
w] zvݻOA|絡&L"#dV j(eo`
6 E(Y&& eDu#te:Ɣ"P &G #yMg
xjQ@-LQAĊ3"AgU{< ȎiAZZyߢt"s gE A$]ltwQ"EIo
pB zr:A"%"}Qt[%2OCuym
:( PJ]=͜o2] Rd)oe<*x[UcDA*8U*@;;7 \쓂 R XA*3y"N+nIٗ,JWPe sAhN~lj2!hz'Q*xoYz\A/i#t:Q:ʝ g.#
ёs N"Q =Y :_jШD;NEU쬍j;J;p*'Ajd*sȫVw*xEUs-,?8e"i<(!䉉IAg{
88i
Izi[Yt.yh-SX HNQ)'E :*"d3ZGUb-S A$[LGUދdqKVR|DY A$YLe~FmS'kᡫExTN;M"xz2vl#tAh[%䷉*82cQ@wY`FУ#DwW2 Agmr˪oVU L ǡ# ?=~:-kOJ n;FqGY AH>lG-Stt±UtV·lM
)A$8E: 5* FAGq_]iD[-Z&C
: H4*+2Й
x l rG!+'D4
Agq"t*=AaFv\ AD;^VEo;KDtjytA>!C7! 4]dOEt2Ӕ<
: D]7& &=vzYśGG `8Ah┓UУ0q#DaP/TA$S'v:`"D ik IENDB` WereSync-1.1.5/docs/source/index.rst 0000644 0001750 0001751 00000003544 13501221042 020055 0 ustar daniel daniel 0000000 0000000 .. WereSync documentation master file, created by
sphinx-quickstart on Thu Nov 3 19:08:36 2016.
.. include:: global.rst.inc
========
WereSync
========
.. image:: img/weresync-logo.png
:align: center
Making your backup drives into were-drives, transforming them into clones at will.
WereSync incrementally backups up hard drives using rsync. Backups can be run while
you use your computer. As icing on the cake, you can boot your clone just like your
normal computer.
Installation
------------
WereSync can easily be installed with pip. Simply use::
$ pip install weresync
For more in depth information see the `installation guide `_.
Basic Usage
-----------
.. IMPORTANT::
WereSync requires root permissions to run, because it has to access block devices. Standard linux permissions restrict access to block devices to ordinary users.
First start the daemon with::
$ sudo weresync-daemon > /dev/null 2>&1 &
To start the gui use::
$ weresync-gui
For help on how the terminal command works, run::
$ weresync -h
For a basic setup, you could use a version of the following command::
$ weresync -C --efi-partition /dev/sda /dev/sdb
=========
Contents:
=========
.. toctree::
:maxdepth: 2
installation
gui
weresync
api
bootloader
translation
issues
============
Contributing
============
First, take a look at our `contribution guidelines `_.
Then, if you would like to submit a new feature or fix a bug, please submit a Pull Request at the `project repository `_.
You can submit a bug report on the `issue tracker `_.
==================
Indices and tables
==================
* :ref:`genindex`
* :ref:`modindex`
* :ref:`search`
WereSync-1.1.5/docs/source/installation.rst 0000644 0001750 0001751 00000003311 13501054034 021444 0 ustar daniel daniel 0000000 0000000 .. Installation Instructions
############
Installation
############
Dependencies
============
WereSync requires different programs for different systems. Generally these programs will be installed by default on many standard distributions (such as Ubuntu) and do not need to be manually installed.
- `rsync `_; required for all systems
- `parted `_; required for all systems
- fdisk; required for working with msdos/MBR partitioned drives
- `GPT fdisk `_; required for working with GPT partitioned drives
- `gettext `_; required for all systems
Bootloaders
-----------
WereSync will attempt to update the /boot directory of the target drive in
order to make it bootable.
However, some bootloaders, particularly MBR based ones, require a more
bootloader-specific process.
GRUB
++++
As of now, WereSync only supports installing
`Grub `_ in this way.
As of now, WereSync only needs to have the grub package installed if you
have an MBR drive. If you have an efi system, you do not need to install
any packages.
You can tell whether or not you have efi by following the instructions on
`this post `_.
If you do not have efi, you need the grub-pc package, which can be installed with the following command::
$ sudo apt-get install grub-pc
WereSync Installation
=====================
PIP
---
WereSync can easily be installed with pip::
$ pip install weresync
Code Repository
---------------
.. code::
$ git clone https://github.com/DonyorM/weresync.git
$ cd weresync
$ python3 setup.py install
WereSync-1.1.5/docs/source/issues.rst 0000644 0001750 0001751 00000000665 13501054034 020267 0 ustar daniel daniel 0000000 0000000 .. Known Issues Page
Known Issues
============
* Due to the complexity of boot loader installations, bootloading may not always install correctly depending on the nature of your setup
* Occasionally, installing the boot loader can change the order of boot on the parent drive, especially for a dual-boot drive
If you have found anymore issues, please report them to the `issue tracker `_.
WereSync-1.1.5/docs/source/translation.rst 0000644 0001750 0001751 00000003032 13501054034 021301 0 ustar daniel daniel 0000000 0000000 .. Documentation on translating WereSync
.. include:: global.rst.inc
====================
Translating WereSync
====================
WereSync supports translation via Pythons
`gettext `_
module. For end users, if your language is supported, it will simply change
based on your system locale and requires no further configuration.
More languages are always welcome. If know another language besides English
your contribution would be most welcome. You can follow these steps in order
to translate WereSync.
1. Clone WereSync to your computer::
$ git clone https://github.com/DonyorM/weresync.git
2. Enter the WereSync source directory::
$ cd weresync/src
3. Generate the `weresync.pot` file with the `pygettext` command from within
the "src" directory::
$ pygettext -d weresync weresync/*.py weresync/plugins/*.py
4. Translate the file. I recommend using a tool, such as
`poedit `_ to edit the translation. Be sure to choose
the UTF-8 encoding.
5. Place your translation files in the proper folder. `gettext` expects
specific path for language files::
$ mkdir -p resources/locale//LC_MESSAGES/weresync.po
You can find your language code `here `_.
6. Add your language code to the `LANGUAGES` list of the `interface` module.
7. Stage and commit your new language folder and the `interface.py` file.
Then create and submit a pull request.
WereSync-1.1.5/docs/source/weresync.rst 0000644 0001750 0001751 00000020035 13501220757 020613 0 ustar daniel daniel 0000000 0000000 .. WereSync command documentation.
######################
Command Line Interface
######################
For help using the weresync command when you are on the command line, use the
help flag on the weresync command::
$ weresync -h
Basic Usage
===========
Requirements
------------
.. IMPORTANT::
The WereSync daemon requires root permissions to run, because it has to access block devices. Standard linux permissions restrict access to block devices to ordinary users.
WereSync will copy GPT, MBR, and LVM drives. The source drive
must have a valid disk label (such a disk label can be created with the gdisk or
fdisk command). All `dependencies `_ must be installed.
Commands
--------
First start the weresync-daemon as root. Usually you want it to run in the
background::
$ sudo weresync-daemon > /dev/null 2>&1 &
WereSync always requires a source drive and a target drive. The source drive comes
first. So to copy from /dev/sda to /dev/sdb, use this command::
$ weresync /dev/sda /dev/sdb
This will simply copy data from one partition to the another, and if the partitions
are different, you will encounter an error. To have WereSync fix your target drives
partitions, use the ``-C`` flag::
$ weresync -C /dev/sda /dev/sdb
On subsequent backups, you may not want to include the -C flag, since this can
sometimes trigger unnecessary repartitioning.
LVM
+++
WereSync supports the copying of LVM drives with the `-l` flag::
$ weresync -C -l -B 1 volume-group /dev/sda /dev/sdb
It is highly recommended to pass which partition of the drive your boot
partition is stored on, if you have a boot partition seperate from the VG.
If you have your /boot folder inside the VG, your bootloader installation
mileage may vary.
Bootloader Installation
-----------------------
WereSync will attempt to update the target drive's system to it will boot up
properly. By default this simply changes the UUIDs in the files of the /boot
folder and EFI system partition, but specific bootloader installation plugins
can also be specified.
For this to work, it is highly recommended that you pass the root partition
with the ``-g`` flag::
$ weresync -g 1 /dev/sda /dev/sdb
If this is not passed, WereSync will attempt to discover the root filesystem on
its own, but this is unreliable.
In order for a drive on an EFI system to be made bootable, the partition number
of the EFI system partition
to be passed to WereSync with the ``-E`` flag. In this case, the root
filesystem should be installed on (``-g`` flag) should also be passed,
especially if the efi partition comes before the grub partition on the
partition list, as the efi partition can trigger the mechanisms used to find
the grub partition.
.. code-block:: bash
$ weresync -E 2 -g 3 /dev/sda /dev/sdb
If you have your boot folder on a seperate partition, be sure to let WereSync know which partition that folder is on with the ``-B`` flag::
$ weresync -E 1 -g 2 -B 3 /dev/sda /dev/sdb
Obviously replace the numbers with the proper values for your system.
Bootloader Plugins
++++++++++++++++++
Some bootloaders, especially those for MBR booting, require a more specific
process. Bootloader plugins allow such a process to occur. All plugins
available will be displayed at the end of the help message displayed with the
``-h`` flag. The specific plugin to use may be passed with the ``-L`` flag::
$ weresync -L grub2 -E 1 -g 2 /dev/sda /dev/sdb
For more information on installing and creating bootloader plugins see the
`bootloader plugin page `_
Image Files
-----------
WereSync supports image files normally. If either the target or the source ends in
".img" WereSync will automatically consider it an image file and mount it as such.
Currently there is no way to mark files not ending in .img as image files.
To create an image file on linux, use::
$ dd if=/dev/zero of=my_image.img bs=1M count=
$ sgdisk my_image.img -o
The second command creates a partition table on the command, which is currently
needed by WereSync to start analyzing a drive.
In-Depth Parameter Definitions
==============================
Usage::
weresync [-h] [-C] [-s SOURCE_MASK] [-t TARGET_MASK]
[-e EXCLUDED_PARTITIONS] [-b] [-g ROOT_PARTITION]
[-B BOOT_PARTITION] [-E EFI_PARTITION] [-m SOURCE_MOUNT]
[-M TARGET_MOUNT] [-r RSYNC_ARGS] [-l] [-L BOOTLOADER]
[-v] [-d] source target
.. list-table:: Parameters
:widths: 15 10 30 10
:header-rows: 1
* - Long Option
- Short Option
- Description
- Default
* - --help
- -h
- Displays the help message
- N/A
* - --check-and-partition
- -C
- Checks if all partitions are large enough and formatted correctly to allow
drive to be copied. If the partitions are not valid, the target drive will
be re-partitioned and reformatted.
- If unset, no checking occurs.
* - --source-mask MASK
- -s MASK
- A string to be passed to :py:func:`format` that will produce a partition
identifier (/dev/sda1 or such) of the source drive when passed two
arguments: the identifier ("/dev/sda") and a partition number in that order.
- "{0}{1}"
* - --target-mask MASK
- -t MASK
- Same as --source-mask, but applied to the target drive.
- "{0}{1}"
* - --excluded-partitions LIST
- -e LIST
- A list of comma separated partition numbers that should not be searched or
copied at any time. These partitions will still be formatted if `-C` is
passed.
- []
* - --break-on-error
- -b
- If passed the program will halt if there are any errors copying. This
flag is not recommended because it will halt even if encountering a normal
issue, like a swap partition.
- False
* - --root-partition PART_NUM
- -g PART_NUM
- The partition mounted on /. It is recommended to
pass this always, but WereSync will attempt to find the main partition
even if it is not passed.
- None, WereSync searches for the partition.
* - --boot-partition PART_NUM
- -B PART_NUM
- The partition that should be mounted on /boot of the grub_partition. If you
have a separate boot partition, you must use this flag.
- None, no partition mounted.
* - --efi-partition PART_NUM
- -E PART_NUM
- The partition that should be mounted on /boot/efi of the grub_partition. If passed this will create the /boot/efi folder if it does not exist and pass
it to grub. Required if you have an EFI partition.
- None
* - --source-mount DIR
- -m DIR
- The directory to mount partitions from the source drive on. Cannot be the
same as --target-mount.
- None, randomly generated directory in the /tmp folder.
* - --target-mount DIR
- -M DIR
- The directory to mount partitions from the target drive on. Cannot be the
same as --source-mount.
- None, randomly generated directory in the /tmp folder.
* - --rsync-args RSYNC_ARGS
- -r RSYNC_ARGS
- The arguments to be passed to the rsync instance used to copy files.
- -aAXxvH --delete
* - --lvm SOURCE [TARGET]
- -l
- This argument expects either one or two arguments specifying the
logical volume groups to copy from and to, respectively. If no target
VG is passed, WereSync will use the VG SOURCE-copy. If the target does
not exist, WereSync will create it.
- No Volume Groups are copied
* - --bootloader BOOTLOADER
- -L BOOTLOADER
- The plugin to use to install the bootloader. Such plugins can be found
at the bottom of the help message.
- The "uuid_copy" plugin.
* - --verbose
- -v
- Makes WereSync increase output and include more minor details.
- Only Warnings, more serious issues, and basic info are printed.
* - --debug
- -d
- Causes a huge amount of output, useful for debugging the program. Usually
not needed for casual use.
- Only Warnings, more serious issues, and basic info are printed.
WereSync-1.1.5/docs/weresync.1.rst 0000644 0001750 0001751 00000013554 13501327070 017456 0 ustar daniel daniel 0000000 0000000 .. Manpage documentation for WereSync. This should be converted to the groff format using rst2man.py
========
weresync
========
--------------------------------
clone linux drives incrementally
--------------------------------
:Author: Daniel Manila
:Date: June 30th, 2017
:Version: 1.0
:Manual Section: 1
:Manual group: admin
weresync-gui - GUI interface for the weresync program.
SYNOPSIS
--------
weresync [ options ] [**-g** *ROOT_PARTITION*] [**-B** *BOOT_PARTITION*]
[**-E** *EFI_PARTITION*] [**-L** *BOOTLOADER*]
[**-l** *LVM_SOURCE* [*LVM_TARGET*]]
source target
**weresync-gui**
**weresync-daemon**
DESCRIPTION
-----------
WereSync clones linux drives incrementally producing a bootable clone. Clones
produced by WereSync will have different UUIDs than the original drive, but
WereSync will update the fstab and bootloader to allow the clone to properly
boot. Clones can be created with one command or one button click, using
*weresync* or *weresync-gui* respectively, after the daemon in *weresync-daemon*
has been started as root.
OPTIONS*
-------
The *weresync-gui* command takes no arguments. These arguments apply to the *weresync* command.
--h, --help
Displays help message.
-C, --check-and-partition
Checks if all partitions are large enough and formatted correctly to allow drive to be copied. If the partitions are not valid, the target drive will be re-partitioned and reformatted. If unset, no checking occurs.
-s, --source-mask *MASK*
A string to be passed to format() that will produce a partition identifier (/dev/sda1 or such) of the source drive when passed two arguments: the identifier ("/dev/sda") and a partition number in that order. Defaults to "{0}{1}"
-t, --target-mask *MASK*
A string to be passed to format() that will produce a partition identifier (/dev/sda1 or such) of the source drive when passed two arguments: the identifier ("/dev/sda") and a partition number in that order. Defaults to "{0}{1}".
-e, --excluded-partitions *LIST*
A list of comma separated partition numbers that should not be searched or copied at any time. These partitions will still be formatted if -C is passed. Defaults to empty.
-b, --break-on-error
If passed the program will halt if there are any errors copying. This flag is not recommended because it will halt even if encountering a normal issue, like a swap partition.
-g, --root-partition *PART_NUM*
The partition mounted on /. It is recommended to pass this always, but WereSync will attempt to find the main partition even if it is not passed.
-B, --boot-partition *PART_NUM*
The partition that should be mounted on /boot of the grub_partition. If you have a separate boot partition, you must use this flag.
-E, --efi-partition *PART_NUM*
The partition that should be mounted on /boot/efi of the grub_partition. If passed this will create the /boot/efi folder if it does not exist and pass it to grub. Required if you have an EFI partition.
-m, --source-mount *DIR*
The directory to mount partitions from the source drive on. Cannot be the same as --target-mount. If unset, WereSync generates a randomly named directory in the /tmp dir.
-M, --target-mount *DIR*
The directory to mount partitions from the target drive on. Cannot be the same as --source-mount. If unset, WereSync generates a randomly named directory in the /tmp dir.
-r, --rsync-args *RSYNC_ARGS*
The arguments to be passed to the rsync instance used to copy files. Defaults to "-aAXxH --delete"
-l, --lvm *SOURCE* [*TARGET*]
This argument expects either one or two arguments specifying the logical volume groups to copy from and to, respectively. If no target VG is passed, WereSync will use the VG SOURCE-copy. If the target does not exist, WereSync will create it.
-L, --bootloader *BOOTLOADER*
The plugin to use to install the bootloader. Such plugins can be found
at the bottom of the help message. Defaults to using the "uuid_copy"
plugin.
-v, --verbose
Makes WereSync increase output and include more minor details.
-d, --debug
Causes a huge amount of output, useful for debugging the program. Usually not needed for casual use.
COPYRIGHT
---------
Copyright 2016 Daniel Manila
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
|
| ``_
|
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
EXAMPLES
--------
To copy /dev/sda to /dev/sdb on a UEFI system use::
sudo weresync -C -L grub2 -E 1 -g 2 /dev/sda /dev/sdb
This example uses grub2 as the bootloader (for most other UEFI bootloaders use
``-L uuid_copy`` or omit the ``-L`` option all together)
with the efi partition on /dev/sda1, and the root partition on /dev/sda2.
Subsequent copies should omit the ``-C`` option, since it could cause weresync
to repartition /dev/sdb again, thus deleting existing data and making weresync's
incremental abilities useless.
To copy /dev/sda to /dev/sdb on a BIOS/Legacy system use::
sudo weresync -C -L grub2 -g 1 /dev/sda /dev/sdb
This example uses grub2 as the bootloader (other bootloaders, such as syslinux,
may be passed to the ``-L`` option) and has the root partition on /dev/sda1.
The omittance of the ``-E`` option signals to WereSync that this is not a
a UEFI drive.
As above, subsequent copies should be initiated without the ``-C`` option.
The gui can simply be run with::
sudo weresync-gui
SEE ALSO
--------
Full documentation can be found at WereSync's documentation on Read The Docs:
``_
WereSync-1.1.5/setup.cfg 0000644 0001750 0001751 00000000422 13503555360 015614 0 ustar daniel daniel 0000000 0000000 [tool:pytest]
testpaths = tests
[metadata]
license_file = LICENSE.txt
[build_sphinx]
source-dir = docs/source
build-dir = docs/build
all_files = 1
[upload_sphinx]
upload-dir = docs/build/html
[flake8]
ignore =
W503,
builtins = _
[egg_info]
tag_build =
tag_date = 0
WereSync-1.1.5/setup.py 0000755 0001750 0001751 00000004777 13503554775 015542 0 ustar daniel daniel 0000000 0000000 #! /usr/bin/env python3
import os
from setuptools import setup, find_packages
import subprocess
import shutil
class InvalidSetupError(Exception):
pass
def create_mo_files():
"""Converts .po templates to readble .mo files using msgfmt."""
# Avoids this code running on read the docs, since gettext is not installed
# there
if os.environ.get("READTHEDOCS") == "True":
return []
if shutil.which("msgfmt") is None:
# If gettext isn't installed, skip this
raise InvalidSetupError("gettext not installed but is required.")
localedir = 'src/weresync/resources/locale'
po_dirs = []
langs = next(os.walk(localedir))[1]
po_dirs = [localedir + '/' + l + '/LC_MESSAGES/' for l in langs]
for d in po_dirs:
po_files = [
f for f in next(os.walk(d))[2] if os.path.splitext(f)[1] == '.po'
]
for po_file in po_files:
filename, extension = os.path.splitext(po_file)
mo_file = filename + '.mo'
msgfmt_cmd = 'msgfmt {} -o {}'.format(d + po_file, d + mo_file)
subprocess.call(msgfmt_cmd, shell=True)
return ["locale/" + l + "/LC_MESSAGES/*.mo" for l in langs]
def read(fname):
with open(os.path.join(os.path.dirname(__file__), fname)) as file:
return file.read()
target_icon_loc = "share/icons/hicolor/scalable/apps"
if os.getuid() == 0: # Install is running as root
target_icon_loc = "/usr/" + target_icon_loc
if __name__ == "__main__":
setup(
name="WereSync",
version="1.1.5",
package_dir={"": "src"},
packages=find_packages("src"),
install_requires=["parse==1.6.6", "yapsy==1.11.223", "pydbus==0.6.0"],
entry_points={
'console_scripts': [
"weresync = weresync.interface.cli:main",
"weresync-daemon = weresync.daemon.daemon:run"
],
'gui_scripts': ["weresync-gui = weresync.interface.gui:start_gui"]
},
package_data={
"weresync.resources": ["*.svg", "*.png", "weresync*.*"] + create_mo_files()
},
data_files=[(target_icon_loc,
["src/weresync/resources/weresync.svg"])],
# Metadata
author="Daniel Manila",
author_email="dmv@springwater7.org",
description="Incrementally clones Linux drives",
long_description=read("README.rst"),
license="Apache 2.0",
keywords="clone, linux, backup, smaller drive",
url="https://github.com/DonyorM/weresync",
)
WereSync-1.1.5/src/ 0000755 0001750 0001751 00000000000 13503555360 014564 5 ustar daniel daniel 0000000 0000000 WereSync-1.1.5/src/WereSync.egg-info/ 0000755 0001750 0001751 00000000000 13503555360 020015 5 ustar daniel daniel 0000000 0000000 WereSync-1.1.5/src/WereSync.egg-info/PKG-INFO 0000644 0001750 0001751 00000016352 13503555357 021127 0 ustar daniel daniel 0000000 0000000 Metadata-Version: 1.0
Name: WereSync
Version: 1.1.5
Summary: Incrementally clones Linux drives
Home-page: https://github.com/DonyorM/weresync
Author: Daniel Manila
Author-email: dmv@springwater7.org
License: Apache 2.0
Description: ########
WereSync
########
`Installation <#installation>`__ | `Basic Usage <#basic-usage>`__ | `Documentation `__ | `Contributing <#contributing-and-bug-reports>`__
.. image:: https://github.com/DonyorM/weresync/raw/master/docs/source/img/weresync-logo.png
:align: center
:alt: WereSync Logo
A lone hard drive stands atop a data heap, staring at the full moon. Suddenly, it
transforms...into a bootable clone of your drive, whirring hungrily at the digital
moon.
WereSync takes a Linux hard drive and effectively clones it, but works incrementally
so you don't have to spend so long backing up each time. Additionally, WereSync
can clone to a smaller drive, if your data will fit on the smaller drive. Because WereSync
uses rsync to copy, it can copy a running drive, though certain parts of state may not be
preserved.
Why Use WereSync?
=================
Hopefully, you think this project looks amazing and you want to try it right away.
However, you may be skeptical about the usefulness of WereSync. You may be
thinking, I can do this exact same thing using gparted or ddrescue. Hear me out!
There are a few reasons to use WereSync over the other tools.
- **WereSync is accessible to less-technical users.** It comes with a simple
interface and clone a drive with a single command while your computer is
running. No booting to a live disk or pushing through a long initiation
process. Unlike `dd` or CloneZilla, WereSync requires a low level of
technical skill and has an easy learning curve
- WereSync can run while the your main drive is being used, instead of blocking your computer up for hours at a time
- WereSync will incrementally update clones, making subsequent clones much faster.
- WereSync works quickly, a single command copies your entire drive, no booting to live CDs or managing MBRs.
- WereSync can copy to a smaller drive, provided your drive's data will fit.
- WereSync creates new UUIDs for the new partitions, allowing you to use the old and new drives alongside each other.
Full documentation may be found `here `__.
Installation
============
WereSync can be installed using the `setup.py` file.
.. code-block:: bash
$ ./setup.py install
If you have `pip `__ installed, you can easily install WereSync with the following command::
$ pip install weresync
For more in-depth instructions, see the `installation documentation `__.
Basic Usage
===========
**Note:** The WereSync daemon requires root capabilities to run because it has
to access block devices. The client GUI and CLI programs do not need root permissions.
Copy the policy file in `src/wersync/resources/weresync-dbus.conf` to
`/etc/dbus-1/system.d`. Then start the daemon::
$ sudo weresync-daemon & >/dev/null 2>&1
Then gui can be launched with the command::
$ weresync-gui
Which generates the following GUI, though generally the advanced options are unneeded:
.. image:: https://github.com/DonyorM/weresync/raw/master/docs/source/img/gui-example.png
:align: left
:alt: Picture of WereSync GUI
To see the options for the terminal command use::
$ weresync -h
To copy from /dev/sda to /dev/sdb (the two drives must have the same partition scheme) use::
$ weresync /dev/sda /dev/sdb
After the copy is completely finished, you can kill the daemon process.
For more information, including how to copy the partition table from drive to
another, see the `Basic Usage `__
documentation page.
Documentation
=============
Documentation can be found on the `Read the Docs `__.
Contributing and Bug Reports
============================
First, take a look at our `contribution guidelines `__.
To contribute simply fork this repository, make your changes, and submit a pull
request. Bugs can be reported on the `issue tracker `__
WereSync currently has huge need of people testing the program on complex drive setups. In order to do this please:
1. Install WereSync from pip::
pip install weresync
#. Run it on your system::
sudo weresync -C source_drive target_drive
#. Report any errors to the `issue tracker `__. Please be sure to post the contents of ``/var/log/weresync/weresync.log`` and ``fdisk -l``.
All contributions will be greatly appreciated!
Distributions Capability for Drive Copying
------------------------------------------
|ubuntu| |debian| |arch| |centos| |fedora| |opensuse|
.. |ubuntu| image:: https://img.shields.io/badge/ubuntu-stable-brightgreen.svg
.. |arch| image:: https://img.shields.io/badge/Arch%20Linux-stable-brightgreen.svg
.. |centos| image:: https://img.shields.io/badge/CentOS-not%20tested-red.svg
.. |fedora| image:: https://img.shields.io/badge/Fedora-not%20tested-red.svg
.. |opensuse| image:: https://img.shields.io/badge/openSUSE-not%20tested-red.svg
.. |debian| image:: https://img.shields.io/badge/Debian-stable-brightgreen.svg
If you are able to test any of these systems, please report your exprience at the `issue tracker `__. Any help will be much appreciated.
Licensing
=========
This project is licensed under the `Apache 2.0 License `__. Licensing is in the **LICENSE.txt** file in this directory.
Acknowledgments
===============
Huge thanks to the creators of:
* `rsync `__, whose software allowed this project to be possible.
* `GNU Parted `__
* And `GPT fdisk `__
Keywords: clone,linux,backup,smaller drive
Platform: UNKNOWN
WereSync-1.1.5/src/WereSync.egg-info/SOURCES.txt 0000644 0001750 0001751 00000002672 13503555357 021716 0 ustar daniel daniel 0000000 0000000 LICENSE.txt
MANIFEST.in
README.rst
setup.cfg
setup.py
docs/Makefile
docs/weresync.1.rst
docs/source/api.rst
docs/source/bootloader.rst
docs/source/conf.py
docs/source/global.rst.inc
docs/source/gui.rst
docs/source/index.rst
docs/source/installation.rst
docs/source/issues.rst
docs/source/translation.rst
docs/source/weresync.rst
docs/source/_templates/homepage.html
docs/source/img/gui-example.png
docs/source/img/weresync-logo.png
src/WereSync.egg-info/PKG-INFO
src/WereSync.egg-info/SOURCES.txt
src/WereSync.egg-info/dependency_links.txt
src/WereSync.egg-info/entry_points.txt
src/WereSync.egg-info/requires.txt
src/WereSync.egg-info/top_level.txt
src/weresync/__init__.py
src/weresync/exception.py
src/weresync/utils.py
src/weresync/daemon/__init__.py
src/weresync/daemon/copier.py
src/weresync/daemon/daemon.py
src/weresync/daemon/device.py
src/weresync/interface/__init__.py
src/weresync/interface/cli.py
src/weresync/interface/dbus_client.py
src/weresync/interface/gui.py
src/weresync/plugins/__init__.py
src/weresync/plugins/weresync_grub2.py
src/weresync/plugins/weresync_syslinux.py
src/weresync/plugins/weresync_uuid_copy.py
src/weresync/resources/__init__.py
src/weresync/resources/weresync-dbus.conf
src/weresync/resources/weresync-gui.desktop
src/weresync/resources/weresync.service
src/weresync/resources/weresync.svg
src/weresync/resources/locale/en/LC_MESSAGES/weresync.mo
src/weresync/resources/locale/en/LC_MESSAGES/weresync.po
tests/test_device.py WereSync-1.1.5/src/WereSync.egg-info/dependency_links.txt 0000644 0001750 0001751 00000000001 13503555357 024071 0 ustar daniel daniel 0000000 0000000
WereSync-1.1.5/src/WereSync.egg-info/entry_points.txt 0000644 0001750 0001751 00000000246 13503555357 023323 0 ustar daniel daniel 0000000 0000000 [console_scripts]
weresync = weresync.interface.cli:main
weresync-daemon = weresync.daemon.daemon:run
[gui_scripts]
weresync-gui = weresync.interface.gui:start_gui
WereSync-1.1.5/src/WereSync.egg-info/requires.txt 0000644 0001750 0001751 00000000053 13503555357 022421 0 ustar daniel daniel 0000000 0000000 parse==1.6.6
yapsy==1.11.223
pydbus==0.6.0
WereSync-1.1.5/src/WereSync.egg-info/top_level.txt 0000644 0001750 0001751 00000000011 13503555357 022545 0 ustar daniel daniel 0000000 0000000 weresync
WereSync-1.1.5/src/weresync/ 0000755 0001750 0001751 00000000000 13503555360 016423 5 ustar daniel daniel 0000000 0000000 WereSync-1.1.5/src/weresync/__init__.py 0000644 0001750 0001751 00000000000 13501054034 020510 0 ustar daniel daniel 0000000 0000000 WereSync-1.1.5/src/weresync/daemon/ 0000755 0001750 0001751 00000000000 13503555360 017666 5 ustar daniel daniel 0000000 0000000 WereSync-1.1.5/src/weresync/daemon/__init__.py 0000644 0001750 0001751 00000000000 13501054034 021753 0 ustar daniel daniel 0000000 0000000 WereSync-1.1.5/src/weresync/daemon/copier.py 0000644 0001750 0001751 00000036116 13501227101 021513 0 ustar daniel daniel 0000000 0000000 import weresync.daemon.device as device
import weresync.utils as utils
from weresync.exception import (CopyError, DeviceError, UnsupportedDeviceError)
import random
import os
import logging
import subprocess
from pydbus.generic import signal
LOGGER = logging.getLogger(__name__)
def mount_loop_device(image_file):
"""Mounts an image file as a loop device and returns the device name of
the mounted loop. This mounts on first free loop device. This accepts
relative paths.
:params image_file: Path pointing to the image file to mount.
:returns: A string containing device identifier (/dev/sda or such)"""
image_file = os.path.abspath(os.path.expanduser(image_file))
free_proc = subprocess.Popen(
["losetup", "-f"], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
free_output, free_error = free_proc.communicate()
if free_proc.returncode != 0:
raise DeviceError(image_file, "Error finding free loop device.",
str(free_output, "utf-8"))
device_name = str(free_output, "utf-8").strip()
mount_proc = subprocess.Popen(
["losetup", device_name, image_file],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
mount_output, mount_error = mount_proc.communicate()
if mount_proc.returncode != 0:
raise DeviceError(image_file,
"Error mounting image on {0}".format(device_name),
str(mount_output, "utf-8"))
subprocess.call(["partprobe", device_name])
return device_name
def create_new_vg_if_not_exists(lvm, name, target):
"""Creates a new Logical Volume Group with the name ``lvm`` + "copy"
and all of the partitions of the target with type "lvm" added to it.
This is not a conclusive function and misses several uses of LVM drives,
if your situation is not covered, please feel free to open a pull request
fixing it.
:param lvm: a string representing the name of the source lvm
:param target: a :py:class:`~weresync.device.DeviceManager` representing
the device whose partitions to add to the LVM."""
lvm_partitions = []
for i in target.get_partitions():
code = target.get_partition_code(i).lower()
if code == "8e00" or code == "8e":
# the two versions appear in gdisk and fdisk, respectively
lvm_partitions.append(i)
lvm_part_block = [
target.part_mask.format(target.device, x) for x in lvm_partitions
]
lvm_test = subprocess.Popen(
["vgs", name], stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
output, _ = lvm_test.communicate()
if lvm_test.returncode == 5:
# If the VG does not exist, the return code is 5
utils.run_proc(["vgcreate", name] + lvm_part_block, target.device,
"Error creating logical volume group.")
else:
if name.startswith("/dev/"):
name = name[5:]
result = utils.run_proc(
["pvs", "-S", "vg_name=" + name, "--noheadings", "-o", "pv_name"],
name, "Error finding physical volumes for LVM.")
LOGGER.debug("PVs in LVM: " + result)
results = [x.strip() for x in result.split("\n")]
lvm_part_block = [x for x in lvm_part_block if x not in results]
if len(lvm_part_block) > 0:
utils.run_proc(["vgextend", name] + lvm_part_block, name,
"Error adding PVs to LVM")
def copy_partitions(copier, part_callback=None, lvm=False):
"""Checks if partitions are valid and copies if they aren't.
:param copier: the :py:class:`~weresync.device.DeviceCopier` object to do
the copying with.
:param part_callback: see the documentation for :py:func:`~.copy_drive`"""
try:
print(_("Checking partition validity."))
copier.partitions_valid(lvm)
if part_callback is not None:
part_callback(1.0)
LOGGER.info("Drives are compatible")
except CopyError as ex:
LOGGER.warning(ex.message)
print(_("Partitions invalid!\nCopying drive partition table."))
LOGGER.warning("Drives are incompatible.")
if lvm:
copier.transfer_lvm_partition(callback=part_callback)
else:
copier.transfer_partition_table(callback=part_callback)
else:
if part_callback is not None:
part_callback(1.0)
class DriveCopier(object):
"""Object which is shared over dbus to allow interfaces to access the
daemon."""
def __init__(self):
LOGGER.debug("making object")
self._interface_name = "net.manilas.weresync.DriveCopier"
dbus = """"""
PartitionStatus = signal()
CopyStatus = signal()
BootStatus = signal()
def GetPartitions(self, device_name, part_mask, lvm):
"""Gets the partitions of the specified device. Note that this
will always return a list of strings, however if this is not an LVM
device, all of the strings will be valid numbers."""
if lvm:
source_manager = device.LVMDeviceManager(device_name)
else:
source_manager = device.DeviceManager(device_name, part_mask)
parts = source_manager.get_partitions()
for idx, val in enumerate(parts):
if type(val) != str:
parts[idx] = str(val)
return parts
def CopyDrive(self,
source,
target,
check_if_valid_and_copy=False,
source_part_mask="{0}{1}",
target_part_mask="{0}{1}",
excluded_partitions=[],
ignore_copy_failures=True,
root_partition=-1,
boot_partition=-1,
efi_partition=-1,
mount_points=("", ""),
rsync_args=device.DEFAULT_RSYNC_ARGS,
lvm_source="",
lvm_target="",
bootloader="uuid_copy"):
"""Uses a DeviceCopier to clone the source drive to the target drive.
**Note:** if using LVM, any uses of "partition" in the documentation
actually refer to logical volumes.
It is recommended to set ``check_if_valid_and_copy`` to True if the the
two drives are not the same size with the same partitions.
If either source or target ends in ".img" copy_drives will assume it is an
image file, and mount if accordingly.
:param source: The drive identifier ("/dev/sda" or the like) of the source
drive.
:param target: The drive identifier ("/dev/sda" or the like) of the target
drive.
:param check_if_valid=False: If true, the function checks if the target
drive is compatible to receive the source
drive's data. If it is not, erase the target
drive and make a proper partition table.
Defaults to False.
:param source_part_mask: A string to be passed to the "format" method that
expects to arguments, the drive name and the
partition number. Applied to the source drive.
Defaults to "{0}{1}".
:param target_part_mask: Same as source_part_mask, but applied to target
drive. Defaults to "{0}{1}"
:param excluded_partitions: Partitions to not copy or test for boot
capability.
:param ignore_copy_failures: If True, errors during copying will be
ignored and copying will continue. It is
recommended that this be left to true,
because errors frequently occur with swap
partitions or other strange partitions.
:param root_partition: If not None, this is an int that determines which
partition grub should be installed to. Defaults to
None.
:param boot_partition: If not None, this is an int that represents the
partition to mount at /boot when installing grub.
:param efi_partition: If not None, this is an int that represents the
partition to mount at /boot/efi when installing grub.
:param mount_points: Expects a tuple containing two strings pointing to
the directories where partitions should be mounted in
case of testing. If None, the function will generate
two random directories in the /tmp folder. Defaults
to None.
:param lvm: the Logical Volume Group to copy to the new drive.
:raises DeviceError: If there is an error reading data from one device or
another.
:raises CopyError: If there is an error copying the data between the two
devices.
:returns: True on success and an error message or exception on failure.
"""
LOGGER.debug("Daemon starting clone.")
def part_callback(status):
self.PartitionStatus(status)
def copy_callback(current, status):
self.CopyStatus(current, status)
def boot_callback(status):
self.BootStatus(status)
root_partition = root_partition if root_partition >= 0 else None
boot_partition = boot_partition if boot_partition >= 0 else None
efi_partition = efi_partition if efi_partition >= 0 else None
try:
source_loop = None
target_loop = None
if source.endswith(".img"):
source_loop = mount_loop_device(source)
source = source_loop
source_part_mask = "{0}p{1}"
if target.endswith(".img"):
target_loop = mount_loop_device(target)
target = target_loop
target_part_mask = "{0}p{1}"
LOGGER.warning(
"Right now, WereSync does not properly install bootloaders on "
"image files. You will have to handle that yourself if you "
"want your image to be bootable.")
source_manager = device.DeviceManager(source, source_part_mask)
target_manager = device.DeviceManager(target, target_part_mask)
try:
target_manager.get_partition_table_type()
except (DeviceError, UnsupportedDeviceError) as ex:
# Since we're erasing the target drive anyway, we can just create
# a new disk label
proc = subprocess.Popen(
["sgdisk", "-o", target_manager.device])
proc.communicate()
copier = device.DeviceCopier(source_manager, target_manager)
partitions_remade = False
if check_if_valid_and_copy:
copy_partitions(copier, part_callback)
partitions_remade = True
if lvm_source is not "":
create_new_vg_if_not_exists(lvm_source, lvm_source + "-copy",
target_manager)
lvm_source = device.LVMDeviceManager(lvm_source)
lvm_target = device.LVMDeviceManager(lvm_source.device +
"-copy")
copier.lvm_source = lvm_source
copier.lvm_target = lvm_target
if partitions_remade and check_if_valid_and_copy:
copy_partitions(copier, part_callback, lvm=True)
if mount_points is ("", "") or len(
mount_points) < 2 or mount_points[0] == mount_points[1]:
source_dir = "/tmp/" + str(random.randint(0, 100000))
target_dir = "/tmp/" + str(random.randint(-100000, -1))
os.makedirs(source_dir, exist_ok=True)
os.makedirs(target_dir, exist_ok=True)
mount_points = (source_dir, target_dir)
print(_("Beginning to copy files."))
copier.copy_files(
mount_points[0],
mount_points[1],
excluded_partitions,
ignore_copy_failures,
rsync_args,
callback=copy_callback)
print(_("Finished copying files."))
print(_("Making bootable"))
try:
copier.make_bootable(bootloader, mount_points[0],
mount_points[1], excluded_partitions,
root_partition, boot_partition,
efi_partition, boot_callback)
except DeviceError as ex:
print(
_("Error making drive bootable. All files should be fine.")
)
return ex
print(_("All done, enjoy your drive!"))
return "True"
finally:
def delete_loop(loop_name):
subprocess.call(["losetup", "-d", loop_name])
if source_loop is not None:
delete_loop(source_loop)
if target_loop is not None:
delete_loop(target_loop)
WereSync-1.1.5/src/weresync/daemon/daemon.py 0000644 0001750 0001751 00000002722 13501226371 021501 0 ustar daniel daniel 0000000 0000000 #! /usr/bin/env python3
# Copyright 2016 Daniel Manila
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Runs the daemon and exposes the necessary methods to the interface
functions.
See also :mod:`weresync.interface.dbus_client`:"""
from weresync.daemon.copier import DriveCopier
from gi.repository import GLib
from pydbus import SystemBus
import weresync.utils as utils
import logging
DEFAULT_DAEMON_LOG_LOCATION = "/var/log/weresync/weresync.log"
LOGGER = logging.getLogger(__name__)
def run():
"""Function which starts the daemon and publishes the
:class:`~weresync.daemon.copier.DriveCopier` over dbus."""
utils.start_logging_handler(DEFAULT_DAEMON_LOG_LOCATION)
utils.enable_localization()
with SystemBus() as bus:
with bus.publish("net.manilas.weresync.DriveCopier", DriveCopier()):
GLib.idle_add(lambda: LOGGER.debug("Starting GLib loop"))
loop = GLib.MainLoop()
loop.run()
if __name__ == "__main__":
run()
WereSync-1.1.5/src/weresync/daemon/device.py 0000644 0001750 0001751 00000227421 13501054034 021475 0 ustar daniel daniel 0000000 0000000 # Copyright 2016 Daniel Manila
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""This module contains the classes used to modify block devices and copy
data."""
import shlex
import os
import subprocess
import weresync.exception
from weresync.exception import DeviceError, PluginNotFoundError
import math
import logging
import sys
import glob
import parse
import re
import tempfile
MOUNT_POINT = "/mnt"
LOGGER = logging.getLogger(__name__)
SUPPORTED_FILESYSTEM_TYPES = ["swap", "ef"]
for word in glob.glob("/*/mkfs.*"):
val = word.split(".")
SUPPORTED_FILESYSTEM_TYPES += val
SUPPORTED_PARTITION_TABLE_TYPES = ["gpt", "msdos"]
"""The names, as reported by `parted` of the partition table types supported
by this program."""
DEFAULT_RSYNC_ARGS = "-aAXxH --delete"
"""Default arguments passed to rsync. See rsync documentation for what they
do."""
def multireplace(string, replacements):
"""
Given a string and a replacement map, it returns the replaced string.
`Credit goes to bgusach
`_
:param str string: string to execute replacements on
:param dict replacements: replacement dictionary
{value to find: value to replace}
:returns: a string with the replaced text."""
# Place longer ones first to keep shorter substrings from matching where
# the longer ones should take place
# For instance given the replacements {'ab': 'AB', 'abc': 'ABC'} against
# the string 'hey abc', it should produce
# 'hey ABC' and not 'hey ABc'
substrs = sorted(replacements, key=len, reverse=True)
# Create a big OR regex that matches any of the substrings to replace
regexp = re.compile('|'.join(map(re.escape, substrs)))
# For each match, look up the new string in the replacements
return regexp.sub(lambda match: replacements[match.group(0)], string)
class DeviceManager:
"""A class that allows various operations on a device.
Most methods in this class raise
:py:class:`~weresync.exception.DeviceError`
if the subprocess they initiate has an error.
:param device: a string containing the device identifier (/dev/sda or the
like)
:param partition_mask: a string as the first parameter of a the expression:
"partion_mask.format(device, partition)" resolving
to a string. Defaults to "{0}{1}"."""
def __init__(self, device, partition_mask="{0}{1}"):
"""Defines a device manager for the passed device.
:param device: a string containing the device identifier (/dev/sda or
the like)
:param partition_mask: a string as the first parameter of a the
expression: "partion_mask.format(device,
partition)" resolving to a string. Defaults to
"{0}{1}"."""
self.device = device
self.part_mask = partition_mask
def get_partitions(self):
"""Returns a list with all the partitions in the drive. The partitions
will be listed in **the order they appear on the disk**. So if
partition 4 has a start sector of 500, it will appear before partition
1 that has a start sectro of 2000
:returns: A list of integers representing the partition numbers"""
partition_table_proc = subprocess.Popen(
["parted", "-s", self.device, "print"],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, error = partition_table_proc.communicate()
exit_code = partition_table_proc.returncode
if exit_code != 0:
raise weresync.exception.DeviceError(self.device,
"Non-zero exit code",
str(output, "utf-8"))
partition_result = str(output, "utf-8").split("\n")
partitions = []
for i in partition_result:
line = i.strip().split()
if len(line) == 0:
continue # It was an empty line
num = None
try:
num = int(line[0])
except ValueError:
continue
partitions.append(num)
return partitions
def mount_point(self, partition_num):
"""Returnds an absolute path to the mountpoint of the specific partition.
Returns None if no mountpoint found (probably because partion not
mounted). The return will not have a trailing slash.
:param partition_num: The partition of whose mount to find."""
findprocess = subprocess.Popen(
[
"findmnt", "-o", "TARGET", self.part_mask.format(self.device,
partition_num)
],
stdout=subprocess.PIPE)
output, error = findprocess.communicate()
result = str(output, "utf-8").split("\n")
exit_code = findprocess.returncode
if exit_code != 0 and exit_code != 1:
# if nothing is found, findmnt returns 1; this is valid code
raise weresync.exception.DeviceError(self.device,
"Non-zero exit code",
str(output, "utf-8"))
if len(result) >= 2:
return result[1].strip().split()[0]
else:
return None
def mount_partition(self, partition_num, mount_loc):
"""Mounts the specified partition at the specified location.
:param partition_num: the number of the partition to mount
:param mount_loc: the location at which to mount the drive
:raises: :py:class:`~weresync.exception.DeviceError` if there is an
error mounting the device.
"""
mount_proc = subprocess.Popen(
[
"mount", self.part_mask.format(self.device, partition_num),
mount_loc
],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, error = mount_proc.communicate()
exit_code = mount_proc.returncode
if exit_code != 0:
raise weresync.exception.DeviceError(
self.device,
"Non-zero exit code. Partition Number: {0}".format(
partition_num), str(output, "utf-8"))
# if no error, mount succeeded
def unmount_partition(self, partition_num):
"""Unmounts a device.
:param partition_num: the number of the partition to unmount.
:raises: :py:class:`~weresync.exception.DeviceError` if the partition
is busy or the partition is not mounted.
"""
unmount_proc = subprocess.Popen(
["umount", self.part_mask.format(self.device, partition_num)],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, err = unmount_proc.communicate()
exit_code = unmount_proc.returncode
if exit_code != 0:
raise weresync.exception.DeviceError(self.device,
str(output, "utf-8"))
# If there are no errors, nothing needs be returned
def _get_blkid_info(self, partition_num, info_name):
proc = subprocess.Popen(
[
"blkid", self.part_mask.format(self.device, partition_num),
"-o", "value", "-s", info_name
],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, error = proc.communicate()
if proc.returncode != 0:
raise DeviceError(self.device,
"Error getting information for partition " +
str(partition_num), str(output, "utf-8"))
return str(output, "utf-8").strip()
def get_partition_uuid(self, partition_num):
"""Gets the UUID for a given partition. This is *not* the filesystem
UUID.
:param partition_num: the number of the partition whose UUID to get.
:returns: a string containing the partition's UUID"""
return self._get_blkid_info(partition_num, "UUID")
def get_part_uuid(self, partition_num):
"""Gets the PARTUUID for a given partition, if it exists. This is
*not* the filesystem UUID and is different from
`py:func:~.DeviceManager.get_partition_uuid`.
:param partition_num: the number of the partition whose PARTUUID to
get.
:returns: a string containing the partition's PARTUUID."""
return self._get_blkid_info(partition_num, "PARTUUID")
def get_partition_table_type(self):
"""Gets the type of partition table on the device. Usually "gpt" for
GPT disks or "msdos" for MBR disks.
:returns: A string containing the name of the partition table.
:raises DeviceError: If the parted command has a non-zero return code.
:raises UnsupportedDeviceError: If the device does not have a
supported partition type."""
process = subprocess.Popen(
["partprobe", "-s", "-d", self.device], stdout=subprocess.PIPE)
output, error = process.communicate()
exit_code = process.returncode
if exit_code != 0:
raise weresync.exception.DeviceError(self.device,
"Non-zero exit code",
str(output, "utf-8"))
result = str(output, "utf-8")
for table_type in SUPPORTED_PARTITION_TABLE_TYPES:
if table_type in result:
return table_type
else:
raise weresync.exception.UnsupportedDeviceError(
"Partition table "
"type of {0} not supported by WereSync.".format(self.device))
def get_drive_size(self):
"""Returns the maximum size of the drive, in sectors."""
query_proc = subprocess.Popen(
["blockdev", "--getsz", self.device], stdout=subprocess.PIPE)
output, error = query_proc.communicate()
exit_code = query_proc.returncode
if exit_code != 0:
raise weresync.exception.DeviceError(self.device,
"Non-zero exit code",
str(output, "utf-8"))
return int(output) # should always be valid
def get_drive_size_bytes(self):
"""Returns the maximum size of the drive, in bytes."""
query_proc = subprocess.Popen(
["blockdev", "--getsize64", self.device], stdout=subprocess.PIPE)
output, error = query_proc.communicate()
exit_code = query_proc.returncode
if exit_code != 0:
raise weresync.exception.DeviceError(self.device,
"Non-zero exit code",
str(output, "utf-8"))
return int(output)
def _get_general_info(self, partition_num):
"""Gets general information for the passed partition number, to be
investigated by other methods. It returns a list with the following
information in order:
Filesystem (/dev/sda or such), Size in 512B-blocks, Used, Available,
Use%, and Mounted Location.
Gleaned from Linux df command.
:param partition_num: the partition for which to get the information"""
mounted_here = False
try:
if self.mount_point(partition_num) is None:
self.mount_partition(partition_num, MOUNT_POINT)
mounted_here = True
proc_formal = subprocess.Popen(
["df", "--block-size=512"], stdout=subprocess.PIPE)
proc = subprocess.Popen(
["grep", self.part_mask.format(self.device, partition_num)],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
stdin=proc_formal.stdout)
output, error = proc.communicate()
exit_code = proc.returncode
if exit_code >= 2: # grep returns 2 if an error occurs
raise weresync.exception.DeviceError(
self.device, "Error running grep.",
str(output, "utf-8") + str(exit_code))
elif exit_code == 1:
raise weresync.exception.DeviceError(self.device,
"No grep line read", None)
return [x for x in str(output, "utf-8").split() if x != ""]
# Output has the following columns:
# Filesystem, Total-size, Used, Available, Use%, Mount Point
finally:
if mounted_here:
self.unmount_partition(partition_num)
def get_partition_used(self, partition_num):
"""Returns the space available in a drive in 512B blocks
:param partition_num: the number of the partition to check"""
return int(self._get_general_info(partition_num)[2])
def get_partition_size(self, partition_num):
"""Gets the size of a partition in 512B sectors.
:param partition_num: An int representing the partition whose size to
get.
:returns: An int representing the number of 512B blocks in the
partition
:raises DeviceError: if the commands getting the size of the partition
fail.
:raises ValueError: if the drive has an unsupported partition table
type."""
table_type = self.get_partition_table_type()
if table_type == "gpt":
proc = subprocess.Popen(
["sgdisk", self.device, "-p"],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, error = proc.communicate()
if proc.returncode != 0:
raise weresync.exception.DeviceError(
self.device, "Error getting device information",
str(output, "utf-8"))
for line in str(output, "utf-8").split("\n"):
if line.strip().startswith(str(partition_num)):
words = [x for x in line.split(" ") if x != ""]
return int(words[2]) - int(words[1])
# start sector is the second element in this list, last sector
# is third element
elif table_type == "msdos":
proc = subprocess.Popen(
[
"sfdisk", "-s", self.part_mask.format(self.device,
partition_num)
],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, error = proc.communicate()
if proc.returncode != 0:
raise weresync.exception.DeviceError(
self.device,
"Error getting partition size for partition {0}".format(
partition_num), str(output, "utf-8"))
return int(output)
else:
raise ValueError("Unsupported table type")
def get_partition_code(self, partition_num):
"""For GPT disks: gets the partition code (as defined by sgdisk) for
the passed partition number.
For MBR disks: gets the partition code (as defined by sfdisk) for the
passed partition number.
:param partition_num: the number of the partition whose code to find.
:raises DeviceError: If the command returns a non-zero return code.
:raises ValueError: If an invalid partition number (one that doesn't
exist) is passed.
:returns: a string containing the partition code for the appropriate
disk type."""
table_type = self.get_partition_table_type()
if table_type == "gpt":
proc = subprocess.Popen(
["sgdisk", self.device, "-p"],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, error = proc.communicate()
if proc.returncode != 0:
raise weresync.exception.DeviceError(
self.device,
"Error getting device information from sgdisk",
str(output, "utf-8"))
for line in str(output, "utf-8").split("\n"):
if line.strip().startswith(str(partition_num)):
words = line.strip().split()
return words[
5] # The code appears in the fifth column, but the
# size takes up two columns (one for value and one for unit),
# so the code appears in the sixth column.
elif table_type == "msdos":
proc = subprocess.Popen(
["fdisk", self.device, "-l"],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, error = proc.communicate()
if proc.returncode != 0:
raise weresync.exception.DeviceError(
self.device, "Error getting device partition information.",
str(output, "utf-8"))
lines = str(output, "utf-8").split("\n")
result = list(
filter(lambda x: x.strip().startswith("Device"), lines))
header_line = result[0].strip().split()
for idx, val in enumerate(header_line):
if val == "Id":
code_index = idx
break
else:
raise ValueError("Unsupported fdisk format.")
part_name = self.part_mask.format(self.device, partition_num)
for line in lines:
if line.strip().startswith(part_name):
words = line.strip().split()
loc = code_index # the code is in the 5th column
if "*" not in line:
loc -= 1
# if the partition is not bootable the column for the
# boot header is not seperated.
return words[loc]
# No partition found
raise ValueError("Invalid partition number, no partition found.")
def get_partition_alignment(self):
"""Returns the number of sectors the drive must be aligned to. For GPT
disk this is found using sgdisk's output.
This function is only supported by GPT disks.
:returns: An integer that represents the partition alignment of the
device.
:raises DeviceError: If the command returns a non-zero return code"""
table_type = self.get_partition_table_type()
if table_type == "gpt":
process = subprocess.Popen(
["sgdisk", self.device, "-p"],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, error = process.communicate()
if process.returncode != 0:
raise weresync.exception.DeviceError(
self.device, "Error finding partition alignment.",
str(output, "utf-8"))
words = [x for x in str(output, "utf-8").split("\n") if x != ""]
for word in words:
if word.startswith("Partitions will be aligned on"):
result = word.split("Partitions will be aligned on ")
# the first value of result will be "", the second value
# will be "{alignmentNum}-sector boundaries"
value = result[1].split("-")
return int(value[0])
raise weresync.exception.DeviceError(
self.device, "sgdisk returned abnormal output.")
elif table_type == "msdos":
process = subprocess.Popen(
["fdisk", self.device, "-l"],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, error = process.communicate()
if process.returncode != 0:
raise weresync.exception.DeviceError(
self.device, "Error getting partition alignment",
str(output, "utf-8"))
for line in str(output, "utf-8").split("\n"):
if line.startswith("Sector size"):
parts = line.split("Sector size (logical/physical): ")[
1].split(" / ")
# After the label there is minimum and optimal size
# seperated by a slash. Optimal is second
logical = int(parts[0].strip().split()[0])
physical = int(parts[1].strip().split()[0])
return int(physical / logical)
def get_empty_space(self):
"""Returns the amount of empty space *after* the last partition. This
does not include space hidden between partitions.
:returns: An integer representing the number of sectors free after the
last partition.
:raises DeviceError: If the command has a non-zero return code"""
table_type = self.get_partition_table_type()
if table_type == "gpt":
proc = subprocess.Popen(
["sgdisk", self.device, "-p"],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, error = proc.communicate()
if proc.returncode != 0:
raise weresync.exception.DeviceError(
self.device, "Error getting device information.",
str(output, "utf-8"))
result = str(output, "utf-8").split("\n")
total_sectors = 0
for line in result:
if line.startswith("Disk " + self.device):
words = line.split(" ")
for word in words:
try:
total_sectors = int(word)
break
except ValueError:
continue
last_part_info = [
x for x in result[-2].split(" ") if x != ""
] # the information for the last partition is always the last
# line in the output. The very last line, however is empty. The
# last real line is 2 back
last_sector = int(last_part_info[
2]) # the third column is the "end" sector column
return total_sectors - last_sector
elif table_type == "msdos":
# other possible table types with throw an UnsupportedDeviceError
# in the get_partition_table_type() method
proc = subprocess.Popen(
["fdisk", self.device, "-l"],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
output, error = proc.communicate()
lines = str(output, "utf-8").split("\n")
for line in lines:
if "sectors" in line:
words = line.split()
for word in reversed(words):
try:
total_sectors = int(word)
break
except ValueError:
continue
break
last_sector = 0
for val in reversed(lines):
if val.strip() == "":
continue
vals = val.split()
loc = 2
if "*" in val:
loc += 1
try:
value = int(vals[loc])
except ValueError:
break # When this trips, we should be past all the
# partition descriptions
if value >= last_sector:
last_sector = value
return total_sectors - value
def get_partition_file_system(self, part_num):
"""Returns the file system (ext4, ntfs, etc.) of the partition. If a
partition system that can't be created by this system is found, None
is return.
:param part_num: the partition number whose filesystem to get.
:returns: A string containing the file system type if a type found,
otherwise None. If this is a swap partition this returns
'swap'"""
proc = subprocess.Popen(
[
"blkid", "-o", "value", "-s", "TYPE",
self.part_mask.format(self.device, part_num)
],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, error = proc.communicate()
if proc.returncode != 0 and proc.returncode != 2:
raise weresync.exception.DeviceError(
self.part_mask.format(self.device, part_num),
"Error getting partition file system type.", output)
result = str(output, "utf-8").strip()
return result if result in SUPPORTED_FILESYSTEM_TYPES else None
def set_partition_file_system(self, part_num, system_type):
"""Creates a new file system on the passed partition number. This is
essentially the same as formatting the partition.
If the passed partition is currently mounted, this will unmount the
system, and remount it when finished.
:param part_num: the partition number to format
:param system_type: a file system (ex. ntfs) supported by mkfs on the
current system."""
mnt_point = self.mount_point(part_num)
try:
if mnt_point is not None:
self.unmount_partition(part_num)
if system_type == "swap":
proc = subprocess.Popen(
["mkswap", self.part_mask.format(self.device, part_num)],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
else:
proc = subprocess.Popen(
[
"mkfs", "-t", system_type,
self.part_mask.format(self.device, part_num)
],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, error = proc.communicate()
if proc.returncode != 0:
raise weresync.exception.DeviceError(
self.part_mask.format(self.device, part_num),
"Error creating new file system on partition.",
str(output, "utf-8"))
finally:
if mnt_point is not None:
self.mount_partition(part_num, mnt_point)
class LVMDeviceManager(DeviceManager):
"""This is an extension of the DeviceManager class which handles Logical
Volume groups. All method names referring to \"partition\" in fact refer
to logical volumes, but the names remain the same for compatibility
reasons.
:param source: The name of the logical volume group."""
def __init__(self, device, partition_mask="{0}/{1}"):
self.name = device.split("/")[-1]
self.device = device if not device.endswith("/") else device[0:-1]
self.device = self.device if self.device.startswith(
"/dev") else "/dev/" + self.device
self.part_mask = partition_mask
def get_partitions(self):
"""Returns the names of the logical volumes in the group, as a list of
strings."""
proc = subprocess.Popen(
["lvs", "--separator", ":"],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, error = proc.communicate()
if proc.returncode != 0:
raise weresync.exception.DeviceError(
self.device, "Error finding logical volumes.",
str(output, "utf-8"))
lines = [
x.strip().split(":") for x in str(output, "utf-8").split("\n")
if x.strip() != ""
]
return [x[0] for x in lines[1:] if x[1] == self.name]
def get_partition_table_type(self):
return "lvm"
def _get_drive_size_generic(self, units):
"""Gets the size of a logical volume group in generic units.
:param units: An indicator for units as defined by the *vgs* command.
Generally "b" or "s"."""
proc = subprocess.Popen(
[
"vgs", "--units", units, "-o", "size", "--noheadings",
self.device
],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, error = proc.communicate()
if proc.returncode != 0:
raise weresync.exception.DeviceError(
self.device, "Error finding logical volume size.",
str(output, "utf-8"))
return int(
str(output, "utf-8").strip()[0:-1]
) # The last character of the output is a "B" or an "S" and should be
# removed
def get_drive_size_bytes(self):
"""Returns the of a logical volume group in bytes."""
return self._get_drive_size_generic("b")
def get_drive_size(self):
"""Normally this function returns the drive size in sectors.
:returns: an integer representing the size of the drive in sectors
:raises DeviceError: if the command returns a non-zero return code"""
return self._get_drive_size_generic("s")
def get_partition_size(self, partition_name):
"""Gets the size, in sectors, of a logical volume.
:param partition_name: the name of the logical volume whose size to
get.
:returns: an int representing the number of bytes on the logical
volume.
:raise DeviceError: if the commands for getting the size of the
partition fail to return a 0 return code."""
proc = subprocess.Popen(
[
"lvdisplay", "-c", self.part_mask.format(self.device,
partition_name)
],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, error = proc.communicate()
if proc.returncode != 0:
raise weresync.exception.DeviceError(
self.device, "Error getting logical volume size.",
str(output, "utf-8"))
return int(str(output, "utf-8").split(":")[6])
def get_partition_code(self, partition_num):
"""Not valid for LVM drives.
:raises UnsupportedDeviceError:"""
raise weresync.exception.UnsupportedDeviceError(
"Partition codes not applicable to lvm drives.")
def _get_general_info(self, partition_num):
"""Same method as the _get_general_info method for the main
DeviceManager class."""
# This switching masks around is necessary because df sees block
# devices in mapper (ex. /dev/mapper/example--vg) rather than normal
# (ex. /dev/example-vg),
old_name = self.device
self.device = self.device[self.device.rindex("/") + 1:len(self.device)]
self.device = self.device.replace("-", "--")
old_mask = self.part_mask
self.part_mask = "/dev/mapper/{0}-{1}"
try:
result = super()._get_general_info(partition_num)
finally:
self.device = old_name
self.part_mask = old_mask
return result
# TODO make this work if needed with LVM drives
def get_partition_alignment(self):
"""Not valid for LVM drives.
:raises UnsupportedDeviceError:"""
raise weresync.exception.UnsupportedDeviceError(
"Partition codes not applicable to lvm drives.")
def get_empty_space(self):
"""Gets the amount of empty space left in the logical volume group. Due to
a lack of strict ordering in lvm, this is considered to be the total
space, not simply the space after the last partition.
:returns: An integer representing the number of sectors free in the
volume group.
:raises DeviceError: If the command has a non-zero return value."""
proc = subprocess.Popen(
[
"vgs", "--units", "s", "-o", "free", "--noheadings",
self.device
],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, error = proc.communicate()
if proc.returncode != 0:
raise weresync.exception.DeviceError(
self.device, "Error reading free space in volume group.",
str(output, "utf-8"))
result = str(output, "utf-8").strip()[0:-1]
# The final character in the results is a unit, in this case "S"
return int(result)
class DeviceCopier:
"""DeviceCopiers transfer data from a source drive to a target drive.
:param source: the drive identifier (/dev/sda or such) of the source drive.
:param target: the drive identifier (/dev/sdb or such) of the target drive.
:param lvm_source: the name or :py:class:`~.LVMDeviceManager` object
representing the source LVM. If None no LVM is copied.
:param lvm_target: the name or :py:class:`~.LVMDeviceManager` object
representing the target LVM. If None no LVM is copied.
"""
def __init__(self, source, target, lvm_source=None, lvm_target=None):
self.source = source if isinstance(
source, DeviceManager) else DeviceManager(source)
self.target = target if isinstance(
target, DeviceManager) else DeviceManager(target)
if lvm_source is not None and lvm_target is not None:
self.lvm_source = lvm_source if isinstance(
lvm_source, LVMDeviceManager) else LVMDeviceManager(lvm_source)
self.lvm_target = lvm_target if isinstance(
lvm_target, LVMDeviceManager) else LVMDeviceManager(lvm_target)
else:
self.lvm_source = None
self.lvm_target = None
self.uuid_dict = None
def get_uuid_dict(self):
"""Generates a dictionary that relates the partitions of the source
drive to the partitions of the target drive.
This function requires that both drives have the same number of
partitions with the same numbers.
This function caches its result in self.uuid_dict. After changing drive
uuids, self.uuid_dict should be set to None.
:returns: A dictionary where the keys are the source drive partition
UUIDs, and the values are the corresponding target drive
UUIDs."""
if self.uuid_dict is None:
uuids = {}
for i in self.source.get_partitions():
try:
source_uuid = self.source.get_partition_uuid(i)
except DeviceError as ex:
if ex.errors == "": # blkid returns an empty string if no
# UUID found
# This can occur for some partition types, like a
# microsoft reserved partition
continue
else:
raise ex
if source_uuid.strip() == "":
# If the uuid is empty/nothing, we don't want it
continue
uuids[source_uuid] = self.target.get_partition_uuid(i)
# This next segment gets the PARTUUID values
try:
source_part_uuid = self.source.get_part_uuid(i)
except DeviceError as ex:
if ex.errors == "":
continue
if source_part_uuid == "":
continue
uuids[source_part_uuid] = self.target.get_part_uuid(i)
if self.lvm_source is not None:
print("LVM Source is: " + self.lvm_source.device)
print("meaningless space")
source_vg = parse.parse("/dev/{0}", self.lvm_source.device)[0]
target_vg = parse.parse("/dev/{0}", self.lvm_target.device)[0]
source_name = source_vg.replace("-", "--")
target_name = target_vg.replace("-", "--")
lvm_mask = "{0}-{1}"
for i in self.lvm_source.get_partitions():
uuids[lvm_mask.format(source_name, i)] = lvm_mask.format(
target_name, i)
self.uuid_dict = uuids
LOGGER.debug("UUID Dict: " + str(uuids))
return uuids
else:
return self.uuid_dict
def _transfer_gpt(self, difference):
"""Transfers the gpt partition table from the larger source drive to
the smaller target drive.
This method is not intended to be called from any method but the
transfer partition table method below.
:param difference: the difference between the sizes of the two drives
:param margin: the amount of margin to give shrunk partitions."""
partitions = self.source.get_partitions()
part_alignment = self.target.get_partition_alignment()
add_args = []
type_args = []
difference -= (
self.source.get_empty_space() - 34
) # the empty space in the source does not count against the
# difference, but we leave the margin just in case
# It also seems that gpt disks at least have 34 unusable sectors at
# the end of the empty space, so we remove those from the count
for i in reversed(partitions):
drive_size = self.source.get_partition_size(i)
try:
part_used = self.source.get_partition_used(i)
except weresync.exception.DeviceError:
part_used = drive_size
space = int(part_alignment * math.floor(
(drive_size - part_used) / part_alignment))
part_size = None
if space > 0 and difference > 0:
# if the amount of space on the drive is bigger than the
# difference between the drives
if space > difference:
part_size = int(part_alignment * math.ceil(
(drive_size - difference) / part_alignment))
difference = 0
else:
part_size = int(part_alignment * math.ceil(part_used /
part_alignment))
difference -= space
else:
part_size = int(part_alignment * math.ceil(drive_size /
part_alignment))
difference += part_size - drive_size # this adds or subtracts
# to the difference based on whether or the aligning changed
# the size of the partition
if (i != partitions[-1]):
# delete_args += ["-d", str(i)]
add_args = [
"-n", "{0}:0:+{1}".format(i, part_size)
] + add_args # part_size is in 512 byte chunks, but gdisk
# expects a 1 kB based unit if should_break: break
# this also rounds down, in order to leave more space rather
# than less
else:
# if this is the last partition to be looped, let it occupy
# maximum space.
add_args = ["-n", "{0}:0:0".format(i)] + add_args
type_args += [
"-t", "{0}:{1}".format(i, self.source.get_partition_code(i))
]
LOGGER.debug(["sgdisk", self.target.device, "-o"] + add_args +
type_args)
clear_process = subprocess.Popen(
["sgdisk", self.target.device, "-Z"],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
clear_output, _ = clear_process.communicate()
if clear_process.returncode != 0:
LOGGER.debug("Clear Process error code: {0}".format(
clear_process.returncode))
raise weresync.exception.DeviceError(
self.target.device, "Error clearing target drive.",
str(clear_output, "utf-8"))
copy_process = subprocess.Popen(
["sgdisk", self.target.device, "-o"] + add_args + type_args,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
copy_out, copy_err = copy_process.communicate()
if copy_process.returncode != 0:
raise weresync.exception.DeviceError(
self.target.device, "Error copying partition table to target.",
str(copy_err, "utf-8"))
final_proc = subprocess.Popen(
["sgdisk", self.target.device, "-G"], stderr=subprocess.STDOUT)
final_out, final_err = final_proc.communicate()
if final_proc.returncode != 0:
raise weresync.exception.DeviceError(
self.target.device, "Error randomizing GUIDs on target device",
str(final_out, "utf-8"))
def _transfer_msdos(self, difference, margin=5):
"""Copies the partition table from a msdos source drive to a target drive.
:param margin: The percent of original size to leave as a margin in
the size of each partition. Is ignored if partition
size is 0."""
for i in self.target.get_partitions():
if self.target.mount_point(i) is not None:
self.target.unmount_partition(i)
current_proc = subprocess.Popen(
["sfdisk", "-d", self.source.device],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
partition_table, current_proc_error = current_proc.communicate()
if current_proc.returncode != 0:
raise weresync.exception.DeviceError(
self.source.device, "Error getting partition table backup.",
str(partition_table, "utf-8"))
partition_table = str(partition_table, "utf-8")
partition_listings = [
x.replace(" ", "") for x in partition_table.split("\n")
if x.startswith(
self.source.part_mask.format(self.source.device, ""))
]
for idx, val in enumerate(partition_listings):
# Standard line of sfdisk -d output:
# mbr.img1:start=2050,size=1893,Id=83, bootable
# a new version would have "type" instead of "Id"
listing = val.split(":")
pairs = {
"part": int(
parse.parse(
self.source.part_mask.format(self.source.device,
"{0}"), listing[0])[0])
}
for i in listing[1].split(","):
pair = i.split("=")
if len(pair) != 2:
pairs["bootable"] = True
else:
pairs["bootable"] = False
if (pair[0] == "Id" or pair[0] == "type"):
# Newer versions of sfdisk use type instead of Id
# This test allows both versions to be supported
pairs["type"] = pair[1]
id_key = pair[0]
# needed to create the right lines in the
# final product
else:
pairs[pair[0]] = int(pair[1])
partition_listings[idx] = pairs
partition_listings.sort(key=lambda x: x["start"])
move_start_back_by = 0
final_str = "unit: sectors\n\n"
current_extended_partition = None
for i in partition_listings:
i["start"] -= move_start_back_by
if current_extended_partition is not None and i[
"part"] <= 4: # Not a logical partition
current_extended_partition = None
if i["type"] == "5": # The partition is an extended partition
current_extended_partition = i
continue
shrink = 0
try:
part_num = i["part"]
drive_used = self.source.get_partition_used(part_num)
space = math.floor(
(i["size"] - drive_used) * (1 - margin / 100))
if space > 0 and difference > 0:
if space >= difference:
shrink = difference
else:
shrink = space
difference -= shrink
move_start_back_by += shrink
i["size"] -= shrink
except weresync.exception.DeviceError as ex:
LOGGER.warning("Error reading device.")
LOGGER.debug("Execption info:", exc_info=sys.exc_info())
if current_extended_partition is not None:
current_extended_partition["size"] -= shrink
partition_listings.sort(key=lambda x: x["part"])
# We don't know what the name of the id key is, so we have to
# concaterate it in.
final_str = "unit: sectors\n\n" + "".join([
"{val} : start= {start}, size= {size}, {type_key}= {type}{boot}\n".
format(
val=self.target.part_mask.format(self.target.device,
part_line["part"]),
boot=", bootable" if part_line["bootable"] else "",
type_key=id_key,
**part_line) for part_line in partition_listings
])
LOGGER.debug("Proposed partition table:\n" + final_str)
table_proc = subprocess.Popen(
["fdisk", self.target.device],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
stdin=subprocess.PIPE,
universal_newlines=True)
output, error = table_proc.communicate(input="o\nw\nq")
if table_proc.returncode != 0:
raise weresync.exception.CopyError(
"Could not create new partition table on target device",
output)
transfer_proc = subprocess.Popen(
["sfdisk", "--force", self.target.device],
stderr=subprocess.STDOUT,
stdin=subprocess.PIPE,
universal_newlines=True)
output, error = transfer_proc.communicate(input=final_str)
if transfer_proc.returncode != 0:
raise weresync.exception.CopyError(
"Could not copy partition table to target device.", output)
def _transfer_lvm(self, difference):
# In general, partitions and logical volumes (lvs) are synonymous in
# this method
for j in self.lvm_target.get_partitions():
if self.lvm_target.mount_point(j) is not None:
self.lvm_target.unmount(j)
LOGGER.debug("Deleting " + j)
remove_proc = subprocess.Popen(
["lvremove", "-f", self.lvm_target.device + "/" + j],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, error = remove_proc.communicate()
if remove_proc.returncode != 0:
raise weresync.exception.DeviceError(
self.lvm_target.device,
"Error removing logical volume from target.",
str(output, "utf-8"))
lvs = self.lvm_source.get_partitions()
difference -= self.lvm_source.get_empty_space()
for i in lvs:
drive_size = self.lvm_source.get_partition_size(i)
try:
part_used = self.lvm_source.get_partition_used(i)
except weresync.exception.DeviceError:
part_used = drive_size
space = drive_size - part_used
if space > 0 and difference > 0:
part_size = None
if space > difference:
part_size = drive_size - difference
else:
part_size = part_used
difference -= space
else:
part_size = drive_size
command = [
"lvcreate", "--size", str(part_size) + "S", "-n", i,
self.lvm_target.device
]
LOGGER.debug("lvcreate command: " + str(command))
with tempfile.TemporaryFile() as tmp:
copy_proc = subprocess.Popen(
command, stdout=tmp, stderr=subprocess.STDOUT)
proc_output, error = copy_proc.communicate()
tmp.seek(0)
output = tmp.read()
LOGGER.debug("Output for " + i + ": " + str(output, "utf-8"))
if copy_proc.returncode != 0:
raise weresync.exception.DeviceError(
self.lvm_target.device,
"Error creating new logical volume.",
str(output, "utf-8"))
def format_partitions(self, ignore_errors=True, callback=None, lvm=False):
"""Goes through each partition in the source drive and formats the
corresponding partition in the target drive to the same thing.
:param ignore_errrors: whether or not errors (such as a file-system
not recongized by mkfs) should be ignored. If
True such errors will be logged. If false the
exceptions will be propogated. Defaults to True.
:param callback: If not None, this function should be a function that
accepts a float between 0 and 1 to update the
progress.
:param lvm: Whether or not to use the lvm managers."""
if lvm:
source_manager = self.lvm_source
target_manager = self.lvm_target
else:
source_manager = self.source
target_manager = self.target
partitions = source_manager.get_partitions()
for i in partitions:
try:
part_type = source_manager.get_partition_file_system(i)
if callback is not None:
drive_size = target_manager.get_drive_size()
complete = 0.0
if part_type is not None:
target_manager.set_partition_file_system(i, part_type)
if callback is not None:
part_size = target_manager.get_partition_size(i)
complete += part_size / drive_size
LOGGER.debug("Callback:\nDrive Size: {0}\n"
"Part Size: {1}\n"
"Complete: {2}".format(
drive_size, part_size, complete))
callback(complete)
else:
LOGGER.warning(
"Invalid filesystem type found. Partition {0} not "
"formatted.".format(i))
except weresync.exception.DeviceError as exe:
if ignore_errors:
logging.getLogger("weresync.device").warning(
"Creating filesystem for {0} encountered errors. "
"Partition type: {1}. Skipped.".format(
target_manager.part_mask.format(
target_manager.device, i), part_type),
exc_info=sys.exc_info())
logging.getLogger("weresync.device").debug(
"Error making file system.", exc_info=sys.exc_info())
else:
raise exe
def transfer_partition_table(self, resize=True, callback=None):
"""Transfers the partition table from one drive to another. Afterwards,
it formats the partitions on the target drive to be the same as those
on the source drive.
:param resize: if true (default) then the program will attempt to
resize the partition tables to fit on a smaller drive.
This will not expand partition tables at any time.
:param callback: If not none, a function to update progress completed.
See py:func:`~.format_partitions()`"""
source_size = self.source.get_drive_size()
target_size = self.target.get_drive_size()
source_type = self.source.get_partition_table_type()
if target_size < source_size and not resize:
raise weresync.exception.CopyError(
"Target device smaller than source device and resize set to "
"false.")
elif source_type == "gpt":
self._transfer_gpt(source_size - target_size)
elif source_type == "msdos":
self._transfer_msdos(source_size - target_size)
for i in self.target.get_partitions():
if self.target.mount_point(i) is not None:
self.target.unmount_partition(i)
if callback is not None:
callback(0.3)
# the block devices still won't be updated unless the following
# command is called.
proc = subprocess.Popen(
["partprobe", self.target.device],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, error = proc.communicate()
if proc.returncode != 0:
raise weresync.exception.DeviceError(
self.target.device, "Error reloading partition mappings.",
str(output, "utf-8"))
# This weights the progress so 30% comes from creating partition and
# 70% from formatting.
progress = lambda prog: (callback(0.3 + prog * 0.7) if callback # noqa
is not None else None)
self.format_partitions(callback=progress)
# If it's done, it's done
if callback is not None:
callback(1.0)
self.uuid_dict = None # uuids will have been changed.
def transfer_lvm_partition(self, resize=True, callback=False):
if self.lvm_source is not None:
lvm_source_size = self.lvm_source.get_drive_size()
lvm_target_size = self.lvm_target.get_drive_size()
self._transfer_lvm(lvm_source_size - lvm_target_size)
self.format_partitions(callback=callback, lvm=True)
def partitions_valid(self, lvm=False):
"""Tests if the partitions on the target drive can support copying
files from the source drive.
:returns: True if no errors found.
:raises: a :py:class:`~weresync.exception.CopyError` if any part
invalid."""
if lvm:
source_manager = self.lvm_source
target_manager = self.lvm_target
else:
source_manager = self.source
target_manager = self.target
source_parts = source_manager. get_partitions()
try:
target_parts = target_manager.get_partitions()
except DeviceError as ex:
raise weresync.exception.CopyError(
"Target partitions cannot be found. Invalid.")
if source_parts != target_parts:
raise weresync.exception.CopyError(
"Partition count on two drives different. Invalid.")
for i in source_parts:
if source_manager.get_partition_file_system(
i) != target_manager.get_partition_file_system(i):
raise weresync.exception.CopyError(
"File system type for partition {0} does not match. "
"Invalid.".format(i))
try:
if source_manager.get_partition_used(
i) > target_manager.get_partition_size(i):
raise weresync.exception.CopyError(
"Information on partition {0} cannot fit on "
"corresponding partition on target drive.".format(i))
except weresync.exception.DeviceError as ex:
if "mount" in str(ex) or "swapspace" in str(
ex
): # the partition couldn't be mounted because it isn't a
# mountable partition (maybe boot sector or swap)
LOGGER.debug(
"Partition {0} couldn't be mounted. Bad FS type".
format(i),
exc_info=sys.exc_info)
else:
raise ex
return True
def _copy_fstab(self, mnt_source, mnt_target, excluded_partitions=[],
lvm=False):
"""Updates files in /etc/fstab to be bootable on the target drive.
:param mnt_source: the directory where source partitions should be
mounted.
:param mnt_target: the directory where target partitions should be
mounted.
:param excluded_partitions: partitions not to search. Defaults to
empty"""
if lvm:
source_manager = self.lvm_source
target_manager = self.lvm_target
else:
source_manager = self.source
target_manager = self.target
for i in source_manager.get_partitions():
source_mounted = False
target_mounted = False
try:
if i not in excluded_partitions:
source_loc = source_manager.mount_point(i)
if source_loc is None:
try:
source_manager.mount_partition(i, mnt_source)
source_mounted = True
source_loc = mnt_source
except weresync.exception.DeviceError as ex:
if "mount" in str(ex):
LOGGER.debug(
"Failed to mount partition. Info:\n",
exc_info=sys.exc_info())
continue
else:
raise ex
source_fstab_path = source_loc + (
"/"
if not source_loc.endswith("/") else "") + "etc/fstab"
if os.path.exists(source_fstab_path):
target_loc = target_manager.mount_point(i)
if target_loc is None:
target_manager.mount_partition(i, mnt_target)
target_mounted = True
target_loc = mnt_target
with open(source_fstab_path) as source_fstab, open(
target_loc + ("/"
if not target_loc.endswith("/")
else "") + "etc/fstab",
"w") as target_fstab:
target_fstab.write(
"# This file is generated by WereSync. All"
" comments have been copied, but they have not"
" been parsed.\n# Any reference to"
" identifiers during installation may be"
" inaccurate.\n\n")
for line in source_fstab.readlines():
stripLine = line.strip()
if stripLine == "" or stripLine.startswith(
"#"):
target_fstab.write(line)
continue
words = stripLine.split()
if words[0].startswith("UUID") or words[
0].startswith("LABEL"):
if words[0].startswith("UUID"):
blkid_arg = "-U"
elif words[0].startswith("LABEL"):
blkid_arg = "-L"
identifier = words[0].split("=")[
1] # First argument of the space
# separated list is the identifier,
# which is split by a equals sign, and the
# second value is the identifier
proc = subprocess.Popen(
["blkid", blkid_arg, identifier],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, error = proc.communicate()
if proc.returncode == 2:
raise weresync.exception.DeviceError(
self.source.device,
"Could not find block name of "
"device with id: {0}".format(
identifier),
str(output, "utf-8"))
elif proc.returncode != 0:
raise weresync.exception.DeviceError(
source_manager.device,
"Error finding device error for "
"device with id: {0}".format(
identifier),
str(output, "utf-8"))
# It figures out the value of a
# placeholder based on context. However,
# the part_masks rarely have enough context
# So we format the part_mask so that the
# first placeholder is the partition
# number, and the device name is inserted
# (comes out to something like
# "/dev/nbd0p{0}").
# Then it can figure it out.
out = str(output, "utf-8").strip()
if (self.lvm_source is not None
and self.lvm_source.device in out):
source = self.lvm_source
target = self.lvm_target
else:
source = self.source
target = self.target
result = parse.parse(source.part_mask.
format(source.device,
"{0}"), out)[0]
# the first element contains the
# number
uuid_proc = subprocess.Popen(
[
"blkid",
source.part_mask.format(
target.device, result)
],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
uuid_output, uuid_error = (
uuid_proc.communicate())
if uuid_proc.returncode == 2:
raise weresync.exception.DeviceError(
target.device,
"Could not find device {0}".format(
target.part_mask.
format(
target.device,
result)),
str(uuid_output, "utf-8"))
elif uuid_proc.returncode != 0:
raise weresync.exception.DeviceError(
target.device,
"Error finding uuid for device "
"{0}".format(
target.part_mask.
format(
target.device,
result)),
str(uuid_output, "utf-8"))
ids = str(uuid_output, "utf-8").split()
for val in ids:
if val.startswith("UUID"):
words[0] = val.replace('"', '')
# Have to remove the double
# quotes from blkid's output.
break
elif self.lvm_source is not None:
words[0] = multireplace(
words[0], self.get_uuid_dict())
target_fstab.write(" ".join(words) + "\n")
finally:
if source_mounted:
source_manager.unmount_partition(i)
if target_mounted:
source_manager.unmount_partition(i)
def _copy_files(self,
mnt_source,
mnt_target,
excluded_partitions,
ignore_failures,
rsync_args,
callback,
lvm=False):
"""This is an internal method used for copying files. See the
main `copy_files` method for documentation."""
if lvm:
source_manager = self.lvm_source
target_manager = self.lvm_target
else:
source_manager = self.source
target_manager = self.target
for i in source_manager.get_partitions():
source_mounted = False
target_mounted = False
try:
if i in excluded_partitions:
continue
source_loc = source_manager.mount_point(i)
if source_loc is None:
source_manager.mount_partition(i, mnt_source)
source_mounted = True
source_loc = mnt_source
target_loc = target_manager.mount_point(i)
if target_loc is None:
target_manager.mount_partition(i, mnt_target)
target_mounted = True
target_loc = mnt_target
LOGGER.info("Starting rsync process for partition {0}.".format(
source_manager.device))
command_args = ["rsync"] + shlex.split(rsync_args) + [
'--exclude=' + x + ''
for x in [
"/dev/*", "/proc/*", "/sys/*", "/tmp/*", "/run/*",
"/mnt/*", "/media/*", "/lost+found", "/home/*/.gvfs"
]
] + [
source_loc +
("/" if not source_loc.endswith("/") else ""), target_loc
]
if callback is not None:
command_args += ["--info=progress2"]
print("Copying partition " + str(i))
LOGGER.debug("Arguments = " + " ".join(command_args))
def run_proc():
with subprocess.Popen(
command_args,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE) as proc:
buf = bytearray()
while True:
byt = proc.stdout.read(1)
if byt == b"":
break
elif byt == b"\r":
yield buf.decode()
buf = bytearray()
else:
buf += byt
LOGGER.debug("Errors for partition {0}:\n".format(i) +
proc.stderr.read().decode())
if callback is not None:
for val in run_proc():
vals = val.split()
if len(vals) >= 2 and vals[1].endswith("%"):
try:
float_val = float(vals[1].strip("%")) / 100
except ValueError:
continue
callback(i, float_val)
LOGGER.debug("Setting to finished")
callback(i, 1.0)
else:
for val in run_proc():
# If you don't loop through the generator values, the
# rsync process doesn't run properly.
pass
except weresync.exception.DeviceError as exe:
if ignore_failures:
LOGGER.warning(
"Error copying data for partition {0} from device {1} "
"to {2}.".format(i, source_manager.device,
target_manager.device))
LOGGER.debug("Error info.", exc_info=sys.exc_info())
if callback is not None:
callback(i, -1.0)
else:
raise exe
finally:
if source_mounted:
source_manager.unmount_partition(i)
if target_mounted:
target_manager.unmount_partition(i)
print(_("Finished copying files."))
def copy_files(self,
mnt_source,
mnt_target,
excluded_partitions=[],
ignore_failures=True,
rsync_args=DEFAULT_RSYNC_ARGS,
callback=None):
"""Copies all files from source to target drive, doing one partition
at a time. This assumes that the two drives have equivalent partition
mappings, i.e. that the data on partition 1 of the source drive should
be on partition 1 of the target drive.
:param mnt_source: The directory to mount partitions from the source
drive on.
:param mnt_target: The directory to mount partitions from the target
drive on.
:param excluded_partitions: A list containing the partitions to not
copy. Defaults to empty.
:param ignore_failures: If True, errors encountered for a partition
will not cause the function to exit, but we
instead cause a warning to be logged. Defaults
to true.
:param callaback: If not None, a function with the signature
``callback(int, float)``, where the int represents
partition number and float represents progress. If
an error occurs, the float will be negative. If the
float should pulse, it wil return True."""
self._copy_files(mnt_source, mnt_target, excluded_partitions,
ignore_failures, rsync_args, callback, lvm=False)
if self.lvm_source is not None:
self._copy_files(mnt_source, mnt_target, excluded_partitions,
ignore_failures, rsync_args, callback, lvm=True)
def make_bootable(self,
plugin_name,
source_mnt,
target_mnt,
excluded_partitions=[],
root_partition=None,
boot_partition=None,
efi_partition=None,
callback=None):
"""Calls the appropriate plugin to make the target drive bootable.
:param plugin_name: the name, not pretty name, of the plugin to use.
If None, so bootloading occurs, other than fstab
copying.
:param source_mnt: a string representing the directory where
partitions from the source drive may be mounted.
:param target_mnt: a string representing the directory where
partitions from the target drive may be mounted.
:param copier: an instance of :py:class:`~weresync.device.DeviceCopier`
which represents the source and target drives.
:param excluded_partitions: these partitions should not be searched or
included in the boot installation.
:param boot_partition: this is the partition that should be mounted on
/boot of the root_partition.
:param root_partition: this is the root partition of the drive, where
the bootloader should be installed.
:param efi_partition: this is the partition of the Efi System
Partition. Should be None if not a UEFI system.
:param callback: a function which takes a single argument declaring
whether or not the bootloader was successfully
installed.
"""
LOGGER.info("Using plugin: " + plugin_name)
if callback is not None:
callback(False)
try:
if plugin_name is not None:
import weresync.plugins as plugins
manager = plugins.get_manager()
manager.collectPlugins()
full_name = "weresync_" + plugin_name
pluginInfo = manager.getPluginByName(full_name, "bootloader")
if pluginInfo is None:
raise PluginNotFoundError("No such plugin {0}".format(
full_name))
manager.activatePluginByName(full_name, "bootloader")
plugin = pluginInfo.plugin_object
else:
plugin = None
try:
self._copy_fstab(source_mnt, target_mnt, excluded_partitions)
except DeviceError as ex:
LOGGER.warning("Error copying fstab. Continuing anyway.")
LOGGER.debug("Info: ", exc_info=sys.exc_info())
if self.lvm_source is not None:
try:
self._copy_fstab(source_mnt, target_mnt,
excluded_partitions, lvm=True)
except DeviceError as ex:
LOGGER.warning("Error copying fstab on LVM. Continuing"
" anyway.")
LOGGER.debug("Info: ", exc_info=sys.exc_info())
if plugin is not None:
plugin.install_bootloader(source_mnt, target_mnt, self,
excluded_partitions, boot_partition,
root_partition, efi_partition)
manager.deactivatePluginByName(plugin_name, "bootloader")
else:
LOGGER.warning("No bootloader plugin specified. Not installing"
"bootloader.")
if callback is not None:
callback(True)
except DeviceError as ex:
LOGGER.warning("Error copying bootloader.")
LOGGER.debug("Info: ", exc_info=sys.exc_info())
WereSync-1.1.5/src/weresync/exception.py 0000644 0001750 0001751 00000003021 13501054034 020755 0 ustar daniel daniel 0000000 0000000 # Copyright 2016 Daniel Manila
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Exceptions used by WereSync"""
class DeviceError(Exception):
"""Exception thrown to show errors caused by an issue with a specific
device."""
def __init__(self, device, message, errors=None):
self.device = device
self.message = message
self.errors = errors
class CopyError(Exception):
"""Exception thrown to show errors caused by an issue copying data,
usually both devices face the issue."""
def __init__(self, message, errors=None):
self.message = message
self.errors = errors
class UnsupportedDeviceError(Exception):
"""Exception thrown to show that action is not supported on the partition
table type of the device."""
pass
class InvalidVersionError(Exception):
"""Exception thrown when the version of python being used does not support
the feature."""
pass
class PluginNotFoundError(Exception):
"""Exception thrown when the passed plugin is not found."""
pass
WereSync-1.1.5/src/weresync/interface/ 0000755 0001750 0001751 00000000000 13503555360 020363 5 ustar daniel daniel 0000000 0000000 WereSync-1.1.5/src/weresync/interface/__init__.py 0000644 0001750 0001751 00000000000 13501054034 022450 0 ustar daniel daniel 0000000 0000000 WereSync-1.1.5/src/weresync/interface/cli.py 0000644 0001750 0001751 00000024056 13501054034 021501 0 ustar daniel daniel 0000000 0000000 #! /usr/bin/env python3
# Copyright 2016 Daniel Manila
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""This modules has easy, one function interfaces with the DeviceCopier and
DeviceManager."""
import weresync.daemon.device as device
from weresync.exception import InvalidVersionError
import weresync.interface.dbus_client as dbus_client
import logging
import logging.handlers
import sys
import argparse
import weresync.utils as utils
LOGGER = logging.getLogger(__name__)
DEFAULT_LENGTH = 60
partition_copying_completed = False
def _print_progress_bar(iteration,
total,
prefix='',
suffix='',
decimals=1,
length=DEFAULT_LENGTH,
fill='█'):
"""
Call in a loop to create terminal progress bar
Thanks to Greentick from StackOverflow for this function
https://stackoverflow.com/a/34325723/2719960
@params:
iteration - Required : current iteration (Int)
total - Required : total iterations (Int)
prefix - Optional : prefix string (Str)
suffix - Optional : suffix string (Str)
decimals - Optional : positive number of decimals in percent complete (Int)
length - Optional : character length of bar (Int)
fill - Optional : bar fill character (Str)
"""
# the first part of the above tuple is the terminal width
percent = ("{0:." + str(decimals) + "f}").format(
100 * (iteration / float(total)))
filledLength = int(length * iteration // total)
bar = fill * filledLength + '-' * (length - filledLength)
print('\r%s |%s| %s%% %s' % (prefix, bar, percent, suffix), end='\r')
# Print New Line on Complete
if iteration == total:
print()
def main():
"""The entry point for the command line function. This uses argparse to
parse arguments to call call :py:func:`.copy_drive` with. For help use
"weresync -h" in a commandline after installation."""
if not dbus_client.copy_drive:
LOGGER.error("Failed to connect to dbus service. Is it running?")
LOGGER.log(logging.DEBUG, "DBus Connection error:",
dbus_client.error)
return
def part_callback(status):
global partition_copying_completed
if not partition_copying_completed:
_print_progress_bar(
int(status * 100), 100, prefix=_("Partition Table Copying:"))
if status >= 1:
partition_copying_completed = True
def copy_callback(partition_num, status):
_print_progress_bar(
int(status * 100) if status >= 0 else 0,
100,
prefix=_("Copying Partition {0}:").format(partition_num))
if status < 0:
print()
print(
_("Some error copying partition {0}. "
"Probably fine, but see logs.").format(partition_num))
def boot_callback(status):
if status:
print(_("Bootloader installed"))
# Passes true when completed. CMD doesn't have display for
# incomplete installation so only test if True
utils.enable_localization()
dbus_client.subscribe_to_signals(part_callback, copy_callback,
boot_callback)
try:
utils.check_python_version()
except InvalidVersionError as ex:
print(ex)
sys.exit(1)
try:
import weresync.plugins as plugins
manager = plugins.get_manager()
manager.collectPlugins()
default_part_mask = "{0}{1}"
pluginNames = []
for pluginInfo in manager.getAllPlugins():
pluginNames.append(pluginInfo.plugin_object.name)
epilog_string = (
_("Bootloader plugins found: ") + ", ".join(pluginNames))
parser = argparse.ArgumentParser(epilog=epilog_string)
parser.add_argument(
"source",
help=_("The drive to copy data from. This drive will not be"
" edited."))
parser.add_argument(
"target",
help=_("The drive to copy data to. ALL DATA ON THIS DRIVE WILL BE "
"ERASED."))
parser.add_argument(
"-C",
"--check-and-partition",
action="store_true",
help=_("Check if partitions are valid and re-partition drive to "
"proper partitions if they are not."))
parser.add_argument(
"-s",
"--source-mask",
help=_("A string of format '{0}{1}' where {0} represents drive "
"identifier and {1} represents partition number to point "
"to partition block files for the source drive."))
parser.add_argument(
"-t",
"--target-mask",
help=_("A string of format '{0}{1}' where {0} represents drive "
"identifier and {1} represents partition number to point "
"to partition block files for the target drive."))
parser.add_argument(
"-e",
"--excluded-partitions",
help=_("A comment separated list of partitions of the source "
"drive to apply no actions on.perated list of partitions "
"of the source drive to apply no actions on."))
parser.add_argument(
"-b",
"--break-on-error",
action="store_false",
help=_("Causes program to break whenever a partition cannot be "
"copied, including uncopyable partitions such as swap"
" files. Not recommended."))
parser.add_argument(
"-g",
"--root-partition",
type=int,
help=_("The partition mounted on /."),
default=-1)
parser.add_argument(
"-B",
"--boot-partition",
type=int,
help=_("Partition which should be mounted on /boot"),
default=-1)
parser.add_argument(
"-E",
"--efi-partition",
type=int,
help=_("Partition which should be mounted on /boot/efi"),
default=-1)
parser.add_argument(
"-m",
"--source-mount",
help=_("Folder where partitions from the source drive should be "
"mounted."),
default="")
parser.add_argument(
"-M",
"--target-mount",
help=_("Folder where partitions from source drive should be"
" mounted."),
default="")
parser.add_argument(
"-r",
"--rsync-args",
help=_("List of arguments passed to rsync. Defaults to: ") +
device.DEFAULT_RSYNC_ARGS,
default=device.DEFAULT_RSYNC_ARGS)
parser.add_argument(
"-L",
"--bootloader",
help=_("Passed to decide what boootloader plugin to use. See "
"below for list of plugins. Defaults to simply changing "
"the UUIDs of files in /boot."),
default="uuid_copy")
parser.add_argument(
"-l",
"--lvm",
help=_("The name of the source logical volume."),
nargs="+")
group = parser.add_mutually_exclusive_group()
group.add_argument(
"-v",
"--verbose",
help=_("Prints expanded output."),
action="store_const",
dest="loglevel",
const=logging.INFO)
group.add_argument(
"-d",
"--debug",
help=_("Prints large output. Mainly helpful for developers."),
action="store_const",
dest="loglevel",
const=logging.DEBUG)
args = parser.parse_args()
if (args.loglevel == logging.INFO or args.loglevel == logging.DEBUG):
loglevel = args.loglevel
else:
loglevel = logging.WARNING
utils.start_logging_handler(
utils.DEFAULT_USER_LOG_LOCATION, stream_level=loglevel)
mount_points = (args.source_mount, args.target_mount)
if args.lvm is not None and len(args.lvm) > 2:
LOGGER.warning(
_("More than two lvm options added. Please give "
"either one or two options."))
sys.exit(1)
lvm_source = args.lvm[0] if args.lvm is not None else ""
lvm_target = args.lvm[1] if (args.lvm is not None
and len(args.lvm) == 2) else ""
excluded_partitions = [
int(x) for x in args.excluded_partitions.split(",")
] if args.excluded_partitions is not None else []
source_mask = (args.source_mask
if args.source_mask is not None else default_part_mask)
target_mask = (args.target_mask
if args.target_mask else default_part_mask)
result = dbus_client.copy_drive(
args.source, args.target, args.check_and_partition,
source_mask, target_mask, excluded_partitions,
args.break_on_error, args.root_partition, args.boot_partition,
args.efi_partition, mount_points, args.rsync_args, lvm_source,
lvm_target, args.bootloader)
if result == "True":
print(_("All done, enjoy your drive!"))
else:
print(str(result))
except (KeyboardInterrupt, EOFError):
LOGGER.info("Exiting via user keyboard interrupt.")
LOGGER.debug("Error:\n", exc_info=sys.exc_info())
sys.exit(1)
if __name__ == "__main__":
main()
WereSync-1.1.5/src/weresync/interface/dbus_client.py 0000644 0001750 0001751 00000005251 13501224606 023225 0 ustar daniel daniel 0000000 0000000 # Copyright 2016 Daniel Manila
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Connects the interface applications (cli and gui) with the backend daemon.
See also :mod:`weresync.daemon.daemon`"""
from pydbus import SystemBus
from gi.repository import GLib
import threading
import gi.repository.GLib
try:
bus = SystemBus()
drive_copier = bus.get("net.manilas.weresync.DriveCopier")
copy_drive = drive_copier.CopyDrive
"""A function which connects to :meth:`weresync.daemon.device.copy_drive`:.
For arguments see that function's documentation. If False, WereSync failed
to connect to dbus."""
error = None
except gi.repository.GLib.Error as e:
error = e
"""The error created by connecting to dbus. If no error, then None."""
copy_drive = False
def _unthreaded_subscribe_to_signals(
partition_status_callback, copy_status_callback, boot_status_callback):
drive_copier.PartitionStatus.connect(partition_status_callback)
drive_copier.CopyStatus.connect(copy_status_callback)
drive_copier.BootStatus.connect(boot_status_callback)
loop = GLib.MainLoop()
loop.run()
def subscribe_to_signals(partition_status_callback, copy_status_callback,
boot_status_callback):
"""Subscribes to the weresync callbacks to get information from the daemon.
:param partition_status_callback: A function which takes a float between 0
and 1 which represents the progress on
formatting partitions.
:param copy_status_callback: A function which takes an integer representing
the partition being copied and a float between
0 and 1 representing the progress on the copy.
:param boot_status_callback: A function which takes a boolean. If passed
False the bootloader has not finished
installing. If True it has."""
thread = threading.Thread(
target=_unthreaded_subscribe_to_signals,
args=(partition_status_callback, copy_status_callback,
boot_status_callback))
thread.daemon = True
thread.start()
WereSync-1.1.5/src/weresync/interface/gui.py 0000644 0001750 0001751 00000077541 13501327375 021540 0 ustar daniel daniel 0000000 0000000 # Copyright 2016 Daniel Manila
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""This module runs the GUI for WereSync."""
import weresync.plugins as plugins
import weresync.utils as utils
import weresync.daemon.device as device
from weresync.exception import InvalidVersionError
import subprocess
import gi
import sys
import os
import logging
import logging.handlers
import threading
gi.require_version("Gtk", '3.0')
from gi.repository import Gtk, GLib, GObject # noqa
connected = False
try:
import weresync.interface.dbus_client as dbus_client
connected = True
except GLib.GError as ex:
pass
LOGGER = logging.getLogger(__name__)
DEFAULT_HORIZONTAL_PADDING = 5
DEFAULT_VERTICAL_PADDING = 3
class NumberEntry(Gtk.Entry):
def __init__(self, allowed="", *args, **kargs):
"""An entry that only allows numbers and certain other characters.
:param allowed: The other characters allowed by this entry in an
unseperated string, ex. '., ' to allow periods, commas,
and spaces. Defaults to none."""
Gtk.Entry.__init__(self, *args, **kargs)
self.allowed = allowed
self.connect('changed', self.on_changed)
def on_changed(self, *args):
text = self.get_text()
self.set_text("".join(
[i for i in text if i in "0123456789" + self.allowed]))
def set_margin(widget,
right=DEFAULT_HORIZONTAL_PADDING,
left=DEFAULT_HORIZONTAL_PADDING,
top=DEFAULT_VERTICAL_PADDING,
bottom=DEFAULT_VERTICAL_PADDING):
widget.set_margin_right(right)
widget.set_margin_left(left)
widget.set_margin_top(top)
widget.set_margin_bottom(bottom)
def create_help_box(parent, text, title=""):
help = Gtk.Label(
halign=Gtk.Align.START,
xpad=DEFAULT_HORIZONTAL_PADDING,
ypad=DEFAULT_VERTICAL_PADDING)
help.set_markup(_("What's this?"))
def help_click(*args):
dialog = Gtk.MessageDialog(parent, 0, Gtk.MessageType.INFO,
Gtk.ButtonsType.OK, title)
dialog.format_secondary_text(text)
dialog.set_default_size(parent.get_size()[0], -1)
dialog.run()
dialog.destroy()
return True
help.connect("activate-link", help_click)
return help
def generate_drive_list():
proc = subprocess.Popen(
["lsblk", "-dnoNAME"],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, _ = proc.communicate()
if proc.returncode != 0:
LOGGER.critical("Error reading block list.\n" + output)
device_list = [
"/dev/" + x.strip() for x in str(output, "utf-8").split("\n")
if x.strip() != ""
]
return device_list
def generate_vg_list():
try:
lvm_proc = subprocess.Popen(
["vgs", "-o", "name", "--noheadings"],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
lvm_output, _ = lvm_proc.communicate()
out = str(lvm_output, "utf-8").split("\n")
if lvm_proc.returncode != 0:
LOGGER.critical("Error reading volume group list.\n" +
" ".join(out))
if "No volume groups found" in out:
lvm_list = ["No volume groups found"]
else:
lvm_list = ["/dev/" + x.strip() for x in out if x.strip() != ""]
except FileNotFoundError as ex:
# Probably means LVM is not installed on the system, which is no big
# deal. We'll just log the exception and move on
LOGGER.debug("File not found info: ", exc_info=sys.exc_info())
lvm_list = [] # This variable needs to be defined
return lvm_list
def get_resource(resource):
dir = os.path.dirname(__file__)
rel_resource_path = os.path.join(dir, "../resources", resource)
return os.path.abspath(rel_resource_path)
class WereSyncWindow(Gtk.Window):
def __init__(self, title="WereSync"):
super().__init__(title=title)
# Find all the bootloader plugins available
manager = plugins.get_manager()
manager.collectPlugins()
plugin_store = Gtk.ListStore(int, str, str)
plugins_added = []
uuid_index = 0
for idx, pluginInfo in enumerate(manager.getAllPlugins()):
manager.activatePluginByName(pluginInfo.name)
obj = pluginInfo.plugin_object
if pluginInfo.name not in plugins_added:
plugin_store.append([idx, obj.prettyName, obj.name])
plugins_added.append(pluginInfo.name)
if obj.name == "uuid_copy":
uuid_index = idx
else:
LOGGER.debug("Not adding {name} at {path} because plugin"
"already added".format(
name=pluginInfo.name, path=pluginInfo.path))
self.set_icon_from_file(get_resource("weresync.svg"))
self.grid = Gtk.Grid()
self.add(self.grid)
self.source_label = Gtk.Label(
label=_("Source Drive: "),
halign=Gtk.Align.START,
xpad=DEFAULT_HORIZONTAL_PADDING,
ypad=DEFAULT_VERTICAL_PADDING)
name_store = Gtk.ListStore(int, str)
for idx, val in enumerate(generate_drive_list()):
name_store.append([idx, val])
self.source_combo = Gtk.ComboBox.new_with_model_and_entry(name_store)
self.source_combo.set_hexpand(True)
self.source_combo.set_entry_text_column(1)
self.grid.attach(self.source_label, 1, 1, 1, 1)
self.grid.attach_next_to(self.source_combo, self.source_label,
Gtk.PositionType.RIGHT, 1, 1)
self.target_label = Gtk.Label(
label=_("Target Drive: "),
halign=Gtk.Align.START,
xpad=DEFAULT_HORIZONTAL_PADDING,
ypad=DEFAULT_VERTICAL_PADDING)
self.target_combo = Gtk.ComboBox.new_with_model_and_entry(name_store)
self.target_combo.set_hexpand(True)
self.target_combo.set_entry_text_column(1)
self.grid.attach_next_to(self.target_label, self.source_label,
Gtk.PositionType.BOTTOM, 1, 1)
self.grid.attach_next_to(self.target_combo, self.target_label,
Gtk.PositionType.RIGHT, 1, 1)
box = Gtk.Box()
self.grid.attach_next_to(box, self.source_combo,
Gtk.PositionType.RIGHT, 1, 1)
self.lvm_source_label = Gtk.Label(
label=_("Source VG: "),
halign=Gtk.Align.START,
xpad=DEFAULT_HORIZONTAL_PADDING,
ypad=DEFAULT_VERTICAL_PADDING)
lvm_list = generate_vg_list()
lvm_source_store = Gtk.ListStore(int, str)
for idx, val in enumerate(lvm_list):
lvm_source_store.append([idx, val])
self.lvm_source_combo = Gtk.ComboBox.new_with_model_and_entry(
lvm_source_store)
self.lvm_source_combo.set_hexpand(True)
self.lvm_source_combo.set_entry_text_column(1)
self.lvm_source_combo.set_sensitive(False)
self.grid.attach_next_to(self.lvm_source_label, box,
Gtk.PositionType.RIGHT, 1, 1)
self.grid.attach_next_to(self.lvm_source_combo, self.lvm_source_label,
Gtk.PositionType.RIGHT, 1, 1)
self.lvm_target_label = Gtk.Label(
label=_("Target VG: "),
halign=Gtk.Align.START,
xpad=DEFAULT_HORIZONTAL_PADDING,
ypad=DEFAULT_VERTICAL_PADDING)
lvm_target_store = Gtk.ListStore(int, str)
lvm_target_store.append([1, _("Default")])
for idx, val in enumerate(lvm_list):
lvm_target_store.append([idx, val])
self.lvm_target_combo = Gtk.ComboBox.new_with_model_and_entry(
lvm_target_store)
self.lvm_target_combo.set_hexpand(True)
self.lvm_target_combo.set_entry_text_column(1)
self.lvm_target_combo.set_active(0)
self.lvm_target_combo.set_sensitive(False)
self.grid.attach_next_to(self.lvm_target_label, self.lvm_source_label,
Gtk.PositionType.BOTTOM, 1, 1)
self.grid.attach_next_to(self.lvm_target_combo, self.lvm_target_label,
Gtk.PositionType.RIGHT, 1, 1)
self.copy_partitions_button = Gtk.CheckButton(
label=_("Copy partitions if target partitions are invalid."))
set_margin(self.copy_partitions_button)
self.grid.attach_next_to(self.copy_partitions_button,
self.target_label, Gtk.PositionType.BOTTOM, 2,
1)
self.lvm_button = Gtk.CheckButton(
label=_("Copy Logical Volume Groups."))
self.lvm_button.connect("toggled", self.lvm_button_toggled)
self.grid.attach_next_to(self.lvm_button, self.lvm_target_label,
Gtk.PositionType.BOTTOM, 2, 1)
set_margin(self.lvm_button)
self.bootloader_label = Gtk.Label(
label=_("Bootloader Plugin: "),
halign=Gtk.Align.START,
xpad=DEFAULT_HORIZONTAL_PADDING,
ypad=DEFAULT_VERTICAL_PADDING)
self.bootloader_combo = Gtk.ComboBox.new_with_model_and_entry(
plugin_store)
self.bootloader_combo.set_entry_text_column(1)
self.bootloader_combo.set_active(uuid_index)
self.bootloader_help = create_help_box(
self,
_("This is the plugin which will attempt to make your clone"
" bootable. Select the plugin which corresponds to the "
"bootloader"
" you want to install. If you are unsure what to choose, pick"
" 'UUID Copy'."), _("Bootloader Plugin"))
self.grid.attach_next_to(self.bootloader_label,
self.copy_partitions_button,
Gtk.PositionType.BOTTOM, 1, 1)
self.grid.attach_next_to(self.bootloader_combo, self.bootloader_label,
Gtk.PositionType.RIGHT, 1, 1)
self.grid.attach_next_to(self.bootloader_help, self.bootloader_combo,
Gtk.PositionType.RIGHT, 1, 1)
self.bootloader_partition_label = Gtk.Label(
label=_("Root Partition Number: "),
halign=Gtk.Align.START,
xpad=DEFAULT_HORIZONTAL_PADDING,
ypad=DEFAULT_VERTICAL_PADDING)
self.grid.attach_next_to(self.bootloader_partition_label,
self.bootloader_label,
Gtk.PositionType.BOTTOM, 1, 1)
self.bootloader_partition_entry = NumberEntry()
self.grid.attach_next_to(self.bootloader_partition_entry,
self.bootloader_partition_label,
Gtk.PositionType.RIGHT, 1, 1)
self.bootloader_help = create_help_box(
self,
_("Enter the partition number of the partition"
" to install the bootloader on. This is generally the partition "
"mounted on /\n"
"So if your root directory is /dev/sda2, enter 2."),
_("Bootloader Partition"))
self.grid.attach_next_to(self.bootloader_help,
self.bootloader_partition_entry,
Gtk.PositionType.RIGHT, 1, 1)
# Start adding advanced options
self.boot_part_label = Gtk.Label(
label=_("Boot Partition: "),
halign=Gtk.Align.START,
xpad=DEFAULT_HORIZONTAL_PADDING,
ypad=DEFAULT_VERTICAL_PADDING)
self.grid.attach_next_to(self.boot_part_label, self.lvm_button,
Gtk.PositionType.BOTTOM, 1, 1)
self.boot_part_entry = NumberEntry()
self.grid.attach_next_to(self.boot_part_entry, self.boot_part_label,
Gtk.PositionType.RIGHT, 1, 1)
self.boot_help = create_help_box(
self, _("The number of the partition mounted on /boot."),
_("Boot Partition"))
self.grid.attach_next_to(self.boot_help, self.boot_part_entry,
Gtk.PositionType.RIGHT, 1, 1)
self.expander = Gtk.Expander(label=_("Advanced Options"))
self.efi_partition_label = Gtk.Label(
label=_("EFI Partition Number: "),
halign=Gtk.Align.START,
xpad=DEFAULT_HORIZONTAL_PADDING,
ypad=DEFAULT_VERTICAL_PADDING)
self.grid.attach_next_to(self.efi_partition_label,
self.boot_part_label, Gtk.PositionType.BOTTOM,
1, 1)
self.efi_partition_entry = NumberEntry()
self.efi_partition_entry.set_hexpand(True)
self.grid.attach_next_to(self.efi_partition_entry,
self.efi_partition_label,
Gtk.PositionType.RIGHT, 1, 1)
self.efi_help = create_help_box(
self,
_("Enter the partition number of your EFI partition.\n"
"So if your efi partition is found on /dev/sda1,"
" enter 1.\n"
"If you are not running a UEFI system, leave this blank."),
_("EFI Partition"))
self.grid.attach_next_to(self.efi_help, self.efi_partition_entry,
Gtk.PositionType.RIGHT, 1, 1)
set_margin(self.expander)
self.expander.set_resize_toplevel(True)
self.expand_grid = Gtk.Grid()
self.expander.add(self.expand_grid)
self.expander.set_hexpand(True)
self.ignore_errors = Gtk.CheckButton(
label=_(
"Ignore errors during copying. If off, common errors often "
"stop the clone."))
self.ignore_errors.set_active(True)
set_margin(self.ignore_errors)
self.expand_grid.attach(self.ignore_errors, 1, 1, 3, 1)
self.source_part_mask_label = Gtk.Label(
label=_("Source Partition Mask: "),
halign=Gtk.Align.START,
xpad=DEFAULT_HORIZONTAL_PADDING,
ypad=DEFAULT_VERTICAL_PADDING)
self.expand_grid.attach_next_to(self.source_part_mask_label,
self.ignore_errors,
Gtk.PositionType.BOTTOM, 1, 1)
self.source_part_mask_entry = Gtk.Entry()
self.source_part_mask_entry.set_hexpand(True)
self.source_part_mask_entry.set_text("{0}{1}")
self.expand_grid.attach_next_to(self.source_part_mask_entry,
self.source_part_mask_label,
Gtk.PositionType.RIGHT, 1, 1)
self.part_mask_help = create_help_box(
self,
_("A string that controls the how partitions are found on the "
"file system. It should have two placeholders: "
"{0} for the device name and {1} for the partition number.\n"
"So if you have /dev/loop0 and partition 1 is /dev/loop0p1, the "
"part_mask should be '{0}p{1}'"), _("Partition Mask"))
self.expand_grid.attach_next_to(self.part_mask_help,
self.source_part_mask_entry,
Gtk.PositionType.RIGHT, 1, 1)
self.target_part_mask_label = Gtk.Label(
label=_("Target Partition Mask: "),
halign=Gtk.Align.START,
xpad=DEFAULT_HORIZONTAL_PADDING,
ypad=DEFAULT_VERTICAL_PADDING)
self.expand_grid.attach_next_to(self.target_part_mask_label,
self.source_part_mask_label,
Gtk.PositionType.BOTTOM, 1, 1)
self.target_part_mask_entry = Gtk.Entry()
self.target_part_mask_entry.set_text("{0}{1}")
self.target_part_mask_entry.set_hexpand(True)
self.expand_grid.attach_next_to(self.target_part_mask_entry,
self.target_part_mask_label,
Gtk.PositionType.RIGHT, 1, 1)
self.excluded_label = Gtk.Label(
label=_("Excluded Partitions: "),
halign=Gtk.Align.START,
xpad=DEFAULT_HORIZONTAL_PADDING,
ypad=DEFAULT_VERTICAL_PADDING)
self.expand_grid.attach_next_to(self.excluded_label,
self.target_part_mask_label,
Gtk.PositionType.BOTTOM, 1, 1)
self.excluded_entry = NumberEntry(allowed=", ")
self.excluded_entry.set_hexpand(True)
self.expand_grid.attach_next_to(self.excluded_entry,
self.excluded_label,
Gtk.PositionType.RIGHT, 1, 1)
self.excluded_help = create_help_box(
self,
_("A comma separated list of partition numbers that should not be "
"copied or searched.\n"
"If partitions partitions are copied, they will still be copied."
), _("Excluded Partitions"))
self.expand_grid.attach_next_to(self.excluded_help,
self.excluded_entry,
Gtk.PositionType.RIGHT, 1, 1)
self.rsync_label = Gtk.Label(
label=_("Rsync Arguments: "),
halign=Gtk.Align.START,
xpad=DEFAULT_HORIZONTAL_PADDING,
ypad=DEFAULT_VERTICAL_PADDING)
self.expand_grid.attach_next_to(self.rsync_label, self.part_mask_help,
Gtk.PositionType.RIGHT, 1, 1)
self.rsync_entry = Gtk.Entry(text=device.DEFAULT_RSYNC_ARGS)
self.expand_grid.attach_next_to(self.rsync_entry, self.rsync_label,
Gtk.PositionType.RIGHT, 1, 1)
self.rsync_help = create_help_box(
self,
_("Enter the arguments to pass the rsync program. For more "
"information see the rsync website." # noqa
), # noqa
_("Rsync Arguments"))
self.expand_grid.attach_next_to(self.rsync_help, self.rsync_entry,
Gtk.PositionType.RIGHT, 1, 1)
self.source_mount_label = Gtk.Label(
label=_("Source Drive Mount Point: "),
halign=Gtk.Align.START,
xpad=DEFAULT_HORIZONTAL_PADDING,
ypad=DEFAULT_VERTICAL_PADDING)
self.expand_grid.attach_next_to(self.source_mount_label,
self.rsync_label,
Gtk.PositionType.BOTTOM, 1, 1)
self.source_mount_entry = Gtk.FileChooserButton(
title=_("Source Drive Mount Folder"),
action=Gtk.FileChooserAction.SELECT_FOLDER,
)
self.expand_grid.attach_next_to(self.source_mount_entry,
self.source_mount_label,
Gtk.PositionType.RIGHT, 1, 1)
self.mount_help = create_help_box(
self,
_("These are the folders that the drives to be copied will be "
"mounted in. If unset, WereSync will generate random folders in "
"the /tmp directory. Generally this can be unset."),
_("Drive Mount Point."))
self.expand_grid.attach_next_to(self.mount_help,
self.source_mount_entry,
Gtk.PositionType.RIGHT, 1, 1)
self.target_mount_label = Gtk.Label(
label=_("Target Drive Mount Point: "))
self.expand_grid.attach_next_to(self.target_mount_label,
self.source_mount_label,
Gtk.PositionType.BOTTOM, 1, 1)
self.target_mount_entry = Gtk.FileChooserButton(
title=_("Target Drive Mount Folder"),
action=Gtk.FileChooserAction.SELECT_FOLDER)
self.expand_grid.attach_next_to(self.target_mount_entry,
self.target_mount_label,
Gtk.PositionType.RIGHT, 1, 1)
# End advanced options
self.grid.attach_next_to(self.expander,
self.bootloader_partition_label,
Gtk.PositionType.BOTTOM, 6, 1)
self.start = Gtk.Button(label=_("Start Clone"))
set_margin(self.start)
self.start.set_hexpand(False)
self.grid.attach(self.start, 6, 10, 1, 1)
self.start.connect("clicked", self.start_pressed)
def lvm_button_toggled(self, button):
if self.lvm_button.get_active():
self.lvm_source_combo.set_sensitive(True)
self.lvm_target_combo.set_sensitive(True)
else:
self.lvm_source_combo.set_sensitive(False)
self.lvm_target_combo.set_sensitive(False)
def set_expander(self, val):
self.expander.set_expanded(val)
def get_selected_combo(self, combo):
combo_iter = combo.get_active_iter()
if combo_iter is not None:
model = combo.get_model()
row_id, val = model[combo_iter][:2]
return val
else:
entry = combo.get_child()
return entry.get_text()
def start_pressed(self, *args):
self.source = self.get_selected_combo(self.source_combo)
self.target = self.get_selected_combo(self.target_combo)
is_lvm = self.lvm_button.get_active()
if is_lvm:
self.lvm_source = self.get_selected_combo(self.lvm_source_combo)
lvm_target = self.get_selected_combo(self.lvm_target_combo)
if lvm_target == _("Default"):
lvm_target = ""
else:
self.lvm_source = ""
lvm_target = ""
confirm_dialog = Gtk.MessageDialog(self, 0, Gtk.MessageType.QUESTION,
Gtk.ButtonsType.OK_CANCEL, "")
confirm_dialog.format_secondary_text(
("This action will DELETE "
"everything on {drive} " + (" and {lvm}" if is_lvm else "") +
", and make it the "
"same as the source drives. Is "
"this what you want to do?").format(
drive=self.target, lvm=(lvm_target if is_lvm else "")))
response = confirm_dialog.run()
confirm_dialog.destroy()
if response == Gtk.ResponseType.CANCEL:
return
# The user didn't cancel so we can continue running
copy_if_invalid = self.copy_partitions_button.get_active()
efi_part = int(self.efi_partition_entry.get_text(
)) if self.efi_partition_entry.get_text().strip() != "" else -1
bootloader_part = int(self.bootloader_partition_entry.get_text(
)) if self.bootloader_partition_entry.get_text() != "" else -1
ignore_errors = self.ignore_errors.get_active()
self.source_part_mask = self.source_part_mask_entry.get_text()
self.target_part_mask = self.target_part_mask_entry.get_text()
exclude_text = self.excluded_entry.get_text().strip()
if exclude_text == "":
excluded_parts = []
else:
exclude_text.replace(" ", "")
excluded_parts = [int(x) for x in exclude_text.split(",")]
boot_part = int(self.boot_part_entry.get_text()
) if self.boot_part_entry.get_text() != "" else -1
rsync_args = self.rsync_entry.get_text()
source_mount = self.source_mount_entry.get_filename()
target_mount = self.target_mount_entry.get_filename()
mount_points = (source_mount if source_mount is not None else "",
target_mount if target_mount is not None else "")
boot_iter = self.bootloader_combo.get_active_iter()
model = self.bootloader_combo.get_model()
plugin_name = model[boot_iter][2]
try:
self._generate_progress_grid()
self.remove(self.grid)
self.add(self.progress_grid)
dbus_client.subscribe_to_signals(
lambda x: GLib.idle_add(self.part_callback, x),
lambda num, prog: GLib.idle_add(self.copy_callback, num, prog),
lambda done: GLib.idle_add(self.boot_callback, done))
def copy(callback, error):
try:
result = dbus_client.copy_drive(
self.source, self.target, copy_if_invalid,
self.source_part_mask, self.target_part_mask,
excluded_parts, ignore_errors, bootloader_part,
boot_part, efi_part, mount_points, rsync_args,
self.lvm_source, lvm_target, plugin_name)
callback(result)
except Exception as ex:
LOGGER.debug(
"Full exception info:\n", exc_info=sys.exc_info())
error(ex)
copy_thread = threading.Thread(
target=copy,
args=[
lambda result: GLib.idle_add(self._copy_finished, result),
lambda ex: GLib.idle_add(self._show_error, ex)
])
copy_thread.start()
self.show_all()
except Exception as ex:
LOGGER.debug("Full exception info:\n", exc_info=sys.exc_info())
self._show_error(ex)
return
def _show_error(self, ex):
"""Displays an error in a message dialog."""
dialog = Gtk.MessageDialog(self, 0, Gtk.MessageType.ERROR,
Gtk.ButtonsType.OK,
_("Error starting clone."))
dialog.format_secondary_text(str(ex))
dialog.run()
dialog.destroy()
# Sets back to original screen to allow regenerating any misplace
# parameters.
self.remove(self.progress_grid)
self.add(self.grid)
def _copy_finished(self, result):
"""A callback function to be run when the the drive finishes
copying."""
text = _("Clone finished!")
if result is not True:
text += _("\nNon fatal error occurred: ") + str(result)
dialog = Gtk.MessageDialog(self, 0, Gtk.MessageType.INFO,
Gtk.ButtonsType.OK, text)
dialog.run()
dialog.destroy()
self.remove(self.progress_grid)
self.add(self.grid)
def _generate_progress_grid(self):
"""Generates the grid for the screen showing progress. Sets
`self.progress_grid` as the grid.`"""
self.progress_grid = Gtk.Grid()
part_label = Gtk.Label(
label=_("Checking partitions and copying: "),
halign=Gtk.Align.START,
xpad=DEFAULT_HORIZONTAL_PADDING,
ypad=DEFAULT_VERTICAL_PADDING)
self.progress_grid.attach(part_label, 1, 1, 1, 1)
self.part_progress = Gtk.ProgressBar()
set_margin(self.part_progress)
self.progress_grid.attach_next_to(self.part_progress, part_label,
Gtk.PositionType.RIGHT, 1, 1)
self.copy_progresses = {}
def create_partitions(device, device_part_mask, start_label,
lvm=False):
previous_label = start_label
partitions = dbus_client.drive_copier.GetPartitions(
device, device_part_mask, lvm)
for val in partitions:
copy_label = Gtk.Label(
label=_("Copying partition {0}: ").format(val),
halign=Gtk.Align.START,
xpad=DEFAULT_HORIZONTAL_PADDING,
ypad=DEFAULT_VERTICAL_PADDING)
copy_progress = Gtk.ProgressBar()
set_margin(copy_progress)
self.progress_grid.attach_next_to(
copy_label, previous_label, Gtk.PositionType.BOTTOM, 1, 1)
self.progress_grid.attach_next_to(copy_progress, copy_label,
Gtk.PositionType.RIGHT, 1, 1)
self.copy_progresses[val] = copy_progress
previous_label = copy_label
return previous_label
final_label = create_partitions(self.source, self.source_part_mask,
part_label)
if self.lvm_button.get_active():
final_label = create_partitions(
self.lvm_source, "", final_label, lvm=True)
boot_label = Gtk.Label(
label=_("Making bootable: "),
halign=Gtk.Align.START,
xpad=DEFAULT_HORIZONTAL_PADDING,
ypad=DEFAULT_VERTICAL_PADDING)
self.progress_grid.attach_next_to(boot_label, final_label,
Gtk.PositionType.BOTTOM, 1, 1)
self.boot_progress = Gtk.ProgressBar()
set_margin(self.boot_progress)
self.progress_grid.attach_next_to(self.boot_progress, boot_label,
Gtk.PositionType.RIGHT, 1, 1)
self.cancel_btn = Gtk.Button(label="Cancel")
set_margin(self.cancel_btn)
self.progress_grid.attach_next_to(self.cancel_btn, self.boot_progress,
Gtk.PositionType.BOTTOM, 1, 1)
def part_callback(self, progress):
LOGGER.debug("part callback. Value: {0}".format(progress))
self.part_progress.set_fraction(progress)
def copy_callback(self, part, progress):
part = str(int(part))
if progress < 0:
LOGGER.debug(
"Error occurred copying partition {0}. Marking complete.".
format(part))
self.copy_progresses[part].set_fraction(1.0)
elif progress is True and isinstance(progress, bool):
self.copy_progresses[part].pulse()
elif (progress >= self.copy_progresses[part].get_fraction()):
self.copy_progresses[part].set_fraction(progress)
def boot_callback(self, done):
if not done:
self.boot_progress.pulse()
else:
self.boot_progress.set_fraction(1.0)
def start_gui():
utils.enable_localization()
try:
utils.check_python_version()
except InvalidVersionError as ex:
print(ex)
# This might not work, if the user doesn't have a setup that support
# PyGObject, but it's worth a shot.
dialog = Gtk.MessageDialog(None, 0, Gtk.MessageType.ERROR,
Gtk.ButtonsType.OK,
_("Error starting WereSync."))
dialog.format_secondary_text(str(ex))
dialog.run()
dialog.destroy()
sys.exit(1)
utils.start_logging_handler(utils.DEFAULT_USER_LOG_LOCATION)
if not connected:
dialog = Gtk.MessageDialog(None, 0, Gtk.MessageType.ERROR,
Gtk.ButtonsType.OK,
_("Error starting WereSync."))
dialog.format_secondary_text(_("Weresync service not connected."))
dialog.run()
dialog.destroy()
sys.exit(1)
LOGGER.info(_("Starting gui."))
GObject.threads_init()
win = WereSyncWindow()
win.connect("delete-event", Gtk.main_quit)
# This is set to expanded so it will be centered as if advanced options
# were opened
win.set_expander(True)
win.set_position(Gtk.WindowPosition.CENTER)
win.show_all()
# Then advanced options are closed so as not to be distracting
win.set_expander(False)
win.show_all()
Gtk.main()
WereSync-1.1.5/src/weresync/plugins/ 0000755 0001750 0001751 00000000000 13503555360 020104 5 ustar daniel daniel 0000000 0000000 WereSync-1.1.5/src/weresync/plugins/__init__.py 0000644 0001750 0001751 00000022605 13501054034 022210 0 ustar daniel daniel 0000000 0000000 # Copyright 2016 Daniel Manila
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""This package contains code for bootloader plugins.
Bootloader plugin is any class extending
:py:class:`~weresync.plugins.IBootPlugin` inside a file name following the
regex pattern "^weresync_.*\.py$". These plugins can be installed to the
site-packages directory (for example, using pip) or to
/usr/local/weresync/plugins.
For an example plugin see the `GrubPlugin `_.""" # noqa
from yapsy.PluginManager import PluginManager
from yapsy.PluginFileLocator import (PluginFileAnalyzerMathingRegex,
PluginFileLocator)
from yapsy.IPlugin import IPlugin
from distutils.sysconfig import get_python_lib
import os
import os.path
import weresync.daemon.device as device
from weresync.exception import DeviceError
import sys
import logging
LOGGER = logging.getLogger(__name__)
def translate_uuid(copier, partition, path, target_mnt):
"""Translates all uuids of the files in the given partition at path.
This will not affect files which are not UTF-8 or ASCII, and it will
not affect files which are greater than 200 MB.
:param copier: the object with the DeviceManager instances.
:param partition: the partition number of the partition to translate.
:param path: the path of the file to change relative to the mount of
the partition. Should start with "/".
:param target_mnt: the path to the folder where the partitions should
be mounted."""
mounted_here = False
try:
mount_point = copier.target.mount_point(partition)
if mount_point is None:
copier.target.mount_partition(partition, target_mnt)
mount_point = target_mnt
mounted_here = True
for dname, dirs, files in os.walk(mount_point + path):
for fname in files:
# This if block seeks to avoid opening huge files since
# they are unlikely to be config files like we are looking
# for.
fpath = os.path.join(dname, fname)
if (os.path.getsize(fpath)) / 1000000 > 200:
continue
try:
with open(fpath) as file:
text = file.read()
except UnicodeDecodeError as ex:
continue
uuid_dict = copier.get_uuid_dict()
text = device.multireplace(text, uuid_dict)
with open(fpath, "w") as f:
f.write(text)
finally:
if mounted_here:
copier.target.unmount_partition(partition)
def mount_partition(manager, lvm_manager, part, mount_point):
"""Mounts a partition and figures out whether or not the partition
is in the LVM drive. It assumes a numerical partition is not a
logical volume.
:param manager: a :py:class:`~weresync.device.DeviceManager` object
representing a possible mount.
:param lvm_manager: a :py:class:`~weresync.device.LVMDeviceManager`
object representing a possible host for the mount.
:param part: the name or number of the partition to mount.
:param mount_point: the location to mount the partition."""
try:
part_num = int(part)
manager.mount_partition(part_num, mount_point)
return
except ValueError:
pass
lvm_manager.mount_partition(part, mount_point)
def search_for_boot_part(
target_mnt,
target_manager,
search_folder,
exlcuded_partitions=[],
):
"""Finds the partition that is the boot partition, by searching for
a specific folder name. The first partition that contains this name
or /boot/ will be returned.
:param target_mnt: the folder to mount partitions
:param target_manager: The :py:class:`~weresync.device.DeviceManager`
class representing the drive to search.
:param search_folder: The name of the folder to search for
:param excluded_partitions: A list containing a list of partitions
which should not be searched."""
for i in target_manager.get_partitions():
if i in exlcuded_partitions:
continue
try:
mounted_here = False
mount_point = target_manager.mount_point(i)
if mount_point is None:
target_manager.mount_partition(i, target_mnt)
mount_point = target_mnt
mounted_here = True
mount_point += "/" if not mount_point.endswith("/") else ""
if (os.path.exists(mount_point + "boot/" + search_folder)
or os.path.exists(mount_point + search_folder)):
return i
except DeviceError as ex:
LOGGER.warning("Could not mount partition {0}. "
"Assumed to not be the partition grub "
"is on.".format(i))
LOGGER.debug("Error info:\n", exc_info=sys.exc_info())
finally:
try:
if mounted_here:
target_manager.unmount_partition(i)
except DeviceError as ex:
LOGGER.warning("Error unmounting partition " + i)
LOGGER.debug("Error info:\n", exc_info=sys.exc_info())
else: # No partition found
return None
class IBootPlugin(IPlugin):
"""An interface class for bootloader plugins. Plugins implementing this class
must implement the :py:func:`~.IBootPlugin.install_bootloader` method.
The name of a plugin should simply be its filename, without the
"weresync\_" prefix or a file extension. So "weresync_grub2.py"'s name
would be "grub2".
:param prettyName: a human readable name for display. Can contain any
character.
:param name: A unique identifying name that should be easy to type on
a terminal. Used by users to tell WereSync which plugin
to use. See above for exact definition."""
def __init__(self, name, prettyName=None):
self.name = name
if prettyName is None:
self.prettyName = name
else:
self.prettyName = prettyName
def activate(self):
"""Called at plugin activation,right before bootloader is installed.
This will be called before /etc/fstab has been updated."""
pass
def deactivate(self):
"""Called at plugin deactivation, after bootloader has been
installed."""
pass
def install_bootloader(self,
source_mnt,
target_mnt,
copier,
excluded_partitions=[],
boot_partition=None,
root_partition=None,
efi_partition=None):
"""Called to make the drive bootable.
This will be called after /etc/fstab has been updated.
:param source_mnt: a string representing the directory where
partitions from the source drive may be mounted.
:param target_mnt: a string representing the directory where
partitions from the target drive may be mounted.
:param copier: an instance of :py:class:`~weresync.device.DeviceCopier`
which represents the source and target drives.
:param excluded_partitions: these partitions should not be searched or
included in the boot installation.
:param boot_partition: this is the partition that should be mounted on
/boot of the root_partition.
:param root_partition: this is the root partition of the drive, where
the bootloader should be installed.
:param efi_partition: this is the partition of the Efi System
Partition. Should be None if not a UEFI system.
:raises DeviceError: if a bootloader installation command has an error.
"""
pass
def get_help(self):
"""Returns the help message for this plugin.
It is optional to override this.
:returns: a string representing the help message for this plugin."""
return "Installs the {0} bootloader.".format(self.prettyName)
dirs = [
"/usr/local/weresync/plugins",
os.path.dirname(__file__),
get_python_lib()
]
regex_analyzer = PluginFileAnalyzerMathingRegex("regex", "^weresync_.*\.py$")
locator = PluginFileLocator([regex_analyzer])
__manager = PluginManager(
categories_filter={"bootloader": IBootPlugin},
directories_list=dirs,
plugin_locator=locator)
def get_manager():
"""Returns the PluginManager for this instance of WereSync"""
return __manager
WereSync-1.1.5/src/weresync/plugins/weresync_grub2.py 0000644 0001750 0001751 00000014644 13501054034 023415 0 ustar daniel daniel 0000000 0000000 # Copyright 2016 Daniel Manila
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Installs the Grub2 bootloader. This works on both UEFI and MBR systems."""
from weresync.plugins import IBootPlugin
import weresync.plugins as plugins
import weresync.daemon.device as device
from weresync.exception import CopyError, DeviceError
import subprocess
import os
import sys
import logging
LOGGER = logging.getLogger(__name__)
class GrubPlugin(IBootPlugin):
"""Plugin to install the grub2 bootloader. Does not install grub legacy."""
def __init__(self):
super().__init__("grub2", "Grub2")
def get_help(self):
return __doc__
def install_bootloader(self, source_mnt, target_mnt, copier,
excluded_partitions=[],
boot_partition=None, root_partition=None,
efi_partition=None):
if efi_partition is not None:
import weresync.plugins.weresync_uuid_copy as uuc
# UEFI systems tend to only need a UUID copy. No sense in not
# reusing old code.
uuc.UUIDPlugin().install_bootloader(source_mnt, target_mnt, copier,
excluded_partitions,
boot_partition,
root_partition, efi_partition)
return
if root_partition is None and boot_partition is None:
# This for loop searches for a partition with a /boot/grub folder
# and it assumes it is the root partition
for i in copier.target.get_partitions():
try:
mount_point = copier.target.mount_point(i)
if mount_point is None:
copier.target.mount_partition(i, target_mnt)
mount_point = target_mnt
if os.path.exists(mount_point +
("/" if not mount_point.endswith("/")
else "") + "boot/grub"):
root_partition = i
break
else:
copier.target.unmount_partition(i)
except DeviceError as ex:
LOGGER.warning("Could not mount partition {0}. "
"Assumed to not be the partition grub "
"is on.".format(i))
LOGGER.debug("Error info:\n", exc_info=sys.exc_info())
else: # No partition found
raise CopyError("Could not find partition with "
"'boot/grub' folder on device {0}".format(
copier.target.device))
# These variables are flags that allow the plugin to know if it mounted
# any partitions and then clean up properly if it did
mounted_here = False
boot_mounted_here = False
try:
if root_partition is not None:
mount_loc = copier.target.mount_point(root_partition)
if mount_loc is None:
plugins.mount_partition(copier.target, copier.lvm_target,
root_partition, target_mnt)
mounted_here = True
mount_loc = target_mnt
else:
mount_loc = target_mnt
# This line avoids double slashes in path
mount_loc += "/" if not mount_loc.endswith("/") else ""
if boot_partition is not None:
boot_folder = mount_loc + "boot"
if not os.path.exists(boot_folder):
os.makedirs(boot_folder)
plugins.mount_partition(copier.target, copier.lvm_target,
boot_partition, boot_folder)
boot_mounted_here = True
print(_("Updating Grub"))
grub_cfg = mount_loc + "boot/grub/grub.cfg"
old_perms = os.stat(grub_cfg)[0]
try:
with open(grub_cfg, "r+") as grubcfg:
cfg = grubcfg.read()
LOGGER.debug("UUID Dicts: " + str(copier.get_uuid_dict()))
final = device.multireplace(cfg, copier.get_uuid_dict())
grubcfg.seek(0)
grubcfg.write(final)
grubcfg.truncate()
grubcfg.flush()
finally:
os.chmod(grub_cfg, old_perms)
print(_("Installing Grub"))
grub_command = ["grub-install",
"--boot-directory=" + mount_loc + "boot",
"--recheck",
"--target=i386-pc", copier.target.device]
LOGGER.debug("Grub command: " + " ".join(grub_command))
grub_install = subprocess.Popen(grub_command,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
install_output, install_error = grub_install.communicate()
if grub_install.returncode != 0:
raise DeviceError(copier.target.device,
"Error installing grub.",
str(install_output,
"utf-8"))
print(_("Consider running update-grub on your backup. WereSync"
" copies can sometimes fail to capture all the nuances of a"
" complex system."))
print(_("Cleaning up."))
finally:
# This block cleans up any mounted partitions
if boot_mounted_here:
copier.target.unmount_partition(boot_partition)
if mounted_here:
copier.target.unmount_partition(root_partition)
print(_("Finished!"))
WereSync-1.1.5/src/weresync/plugins/weresync_syslinux.py 0000644 0001750 0001751 00000015106 13501054034 024264 0 ustar daniel daniel 0000000 0000000 # Copyright 2016 Daniel Manila
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Installs the syslinux bootloader. This bootloader plugin requires the
"root partition" option to be defined.
Setups using syslinux's altmbr setup are currently not supported.
This plugin assumes that the boot folder is in /boot/syslinux. If this is
not the case a symbolic link should be created before WereSync is run.
This plugin depends on Extlinux being installed.
On UEFI systems this simply runs the UUID Copy plugin."""
from weresync.plugins import IBootPlugin
import weresync.plugins as plugins
from weresync.exception import CopyError, DeviceError
import subprocess
class SyslinuxPlugin(IBootPlugin):
def __init__(self):
super().__init__("syslinux", "Syslinux")
def get_help(self):
return __doc__
def install_bootloader(self, source_mnt, target_mnt, copier,
excluded_partitions=[],
boot_partition=None, root_partition=None,
efi_partition=None):
if root_partition is None and boot_partition is None:
boot_part = plugins.search_for_boot_part(target_mnt, copier.target,
"syslinux",
excluded_partitions)
if boot_part is None and copier.lvm_source is not None:
boot_part = plugins.search_for_boot_part(target_mnt,
copier.lvm_source,
"syslinux",
excluded_partitions)
if boot_part is None:
raise CopyError("Could not find partition with 'syslinux' "
"folder on device {0}.".format(copier.target.
device))
boot_partition = boot_part
elif boot_partition is None:
boot_partition = root_partition
plugins.translate_uuid(copier, boot_partition, "/boot", target_mnt)
if efi_partition is not None:
plugins.translate_uuid(copier, efi_partition, "/", target_mnt)
else:
if root_partition is None:
raise CopyError("The syslinux bootloader plugin requires that"
" the root partition be defined. The UUIDs of"
" the /boot folder have been updated.")
try:
mounted_here = False
mount_point = copier.target.mount_point(root_partition)
if mount_point is None:
copier.target.mount_partition(root_partition, target_mnt)
mount_point = target_mnt
mounted_here = True
mount_point += "/" if not target_mnt.endswith("/") else ""
extlinux_proc = subprocess.Popen(["extlinux", "--install",
mount_point + "boot/syslinux"
],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
extlinux_output, _ = extlinux_proc.communicate()
if extlinux_proc.returncode != 0:
raise CopyError("Error installing bootloader on target "
"drive.",
extlinux_output)
table_type = copier.target.get_partition_table_type()
if table_type == "msdos":
bios_proc = subprocess.Popen(["dd", "bs=440", "count=1",
"if={0}usr/lib/syslinux"
"/bios/mbr.bin".format(
mount_point),
"of=" + copier.target.device
], stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, error = bios_proc.communicate()
if bios_proc.returncode != 0:
raise DeviceError(copier.target.device,
"Error installing bios to drive.",
output)
elif table_type == "gpt":
attribute_proc = subprocess.Popen(["sgdisk",
copier.target.device,
"--attributes=1:set:2"],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
output, error = attribute_proc.communicate()
if attribute_proc.returncode != 0:
raise DeviceError(copier.target.device,
"Error enabling boot of partition.",
output)
bios_proc = subprocess.Popen(["dd", "conv=notrunc",
"count=1", "if={0}usr/lib"
"/syslinux/bios/gptmbr.bin".
format(mount_point),
"of=" + copier.target.device
], stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
b_output, b_error = bios_proc.communicate()
if bios_proc.returncode != 0:
raise DeviceError(copier.target.device,
"Error install MBR to drive.",
b_output)
finally:
if mounted_here:
copier.target.unmount_partition(root_partition)
WereSync-1.1.5/src/weresync/plugins/weresync_uuid_copy.py 0000644 0001750 0001751 00000004576 13501054034 024377 0 ustar daniel daniel 0000000 0000000 # Copyright 2016 Daniel Manila
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""This modules contains the code to simply translate the UUIDs of all text
files to the new drive. It does not change anything else.
In order to save RAM, uuid_copy will not copy files larger than 200 MB.
This works for many bootloaders."""
from weresync.plugins import IBootPlugin
from weresync.exception import CopyError
import logging
import weresync.plugins as plugins
LOGGER = logging.getLogger(__name__)
class UUIDPlugin(IBootPlugin):
def __init__(self):
super().__init__("uuid_copy", "UUID Copy")
def get_help(self):
return """Changes all UUIDs in every file of /boot to the new drive's UUIDs.
\nDoes not install anything else. This is the default option."""
def install_bootloader(self, source_mnt, target_mnt, copier,
excluded_partitions=[],
boot_partition=None, root_partition=None,
efi_partition=None):
if root_partition is None and boot_partition is None:
part = plugins.search_for_boot_part(target_mnt, copier.target,
"boot",
excluded_partitions)
if part is None:
raise CopyError("Could not find partition with "
"'boot' folder on device {0}".format(
copier.target.device))
plugins.translate_uuid(copier, part, "/boot", target_mnt)
elif boot_partition is not None:
plugins.translate_uuid(copier, boot_partition, "/", target_mnt)
else:
plugins.translate_uuid(copier, root_partition, "/boot", target_mnt)
if efi_partition is not None:
plugins.translate_uuid(copier, efi_partition, "/", target_mnt)
WereSync-1.1.5/src/weresync/resources/ 0000755 0001750 0001751 00000000000 13503555360 020435 5 ustar daniel daniel 0000000 0000000 WereSync-1.1.5/src/weresync/resources/__init__.py 0000644 0001750 0001751 00000000000 13501054034 022522 0 ustar daniel daniel 0000000 0000000 WereSync-1.1.5/src/weresync/resources/locale/ 0000755 0001750 0001751 00000000000 13503555360 021674 5 ustar daniel daniel 0000000 0000000 WereSync-1.1.5/src/weresync/resources/locale/en/ 0000755 0001750 0001751 00000000000 13503555360 022276 5 ustar daniel daniel 0000000 0000000 WereSync-1.1.5/src/weresync/resources/locale/en/LC_MESSAGES/ 0000755 0001750 0001751 00000000000 13503555360 024063 5 ustar daniel daniel 0000000 0000000 WereSync-1.1.5/src/weresync/resources/locale/en/LC_MESSAGES/weresync.mo 0000644 0001750 0001751 00000000733 13503555357 026270 0 ustar daniel daniel 0000000 0000000 $ , 8 9 Project-Id-Version: WereSync v1.0
POT-Creation-Date: 2017-06-13 21:49+EDT
PO-Revision-Date: 2017-06-13 21:56-0500
Last-Translator:
Language-Team: WereSync
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
Generated-By: pygettext.py 1.5
X-Generator: Poedit 1.5.4
Plural-Forms: nplurals=2; plural=(n != 1);
Language: English
X-Poedit-SourceCharset: UTF-8
WereSync-1.1.5/src/weresync/resources/locale/en/LC_MESSAGES/weresync.po 0000644 0001750 0001751 00000020167 13501054034 026256 0 ustar daniel daniel 0000000 0000000 # SOME DESCRIPTIVE TITLE.
# Copyright (C) YEAR ORGANIZATION
# FIRST AUTHOR , YEAR.
#
msgid ""
msgstr ""
"Project-Id-Version: WereSync v1.0\n"
"POT-Creation-Date: 2017-06-13 21:49+EDT\n"
"PO-Revision-Date: 2017-06-13 21:56-0500\n"
"Last-Translator: \n"
"Language-Team: WereSync \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Generated-By: pygettext.py 1.5\n"
"X-Generator: Poedit 1.5.4\n"
"Plural-Forms: nplurals=2; plural=(n != 1);\n"
"Language: English\n"
"X-Poedit-SourceCharset: UTF-8\n"
#: weresync/device.py:1594 weresync/interface.py:322
msgid "Finished copying files."
msgstr ""
#: weresync/gui.py:70
msgid "What's this?"
msgstr ""
#: weresync/gui.py:147
msgid "Source Drive: "
msgstr ""
#: weresync/gui.py:161
msgid "Target Drive: "
msgstr ""
#: weresync/gui.py:173
msgid "Source VG"
msgstr ""
#: weresync/gui.py:190
msgid "Target VG"
msgstr ""
#: weresync/gui.py:205
msgid "Copy partitions if target partitions are invalid."
msgstr ""
#: weresync/gui.py:211
msgid "Source and target are logical volume groups."
msgstr ""
#: weresync/gui.py:216
msgid "Bootloader Plugin: "
msgstr ""
#: weresync/gui.py:226
msgid ""
"This is the plugin which will attempt to make your clone bootable. Select "
"the plugin which corresponds to the bootloader you want to install. If you "
"are unsure what to choose, pick 'UUID Copy'."
msgstr ""
#: weresync/gui.py:230
msgid "Bootloader Plugin"
msgstr ""
#: weresync/gui.py:238
msgid "EFI Partition Number: "
msgstr ""
#: weresync/gui.py:252
msgid ""
"Enter the partition number of your EFI partition.\n"
"So if your efi partition is found on /dev/sda1, enter 1.\n"
"If you are not running a UEFI system, leave this blank."
msgstr ""
#: weresync/gui.py:256
msgid "EFI Partition"
msgstr ""
#: weresync/gui.py:260
msgid "Bootloader Partition Number: "
msgstr ""
#: weresync/gui.py:273
msgid ""
"Enter the partition number of the partition to install the bootloader on. "
"This is generally the partition mounted on /\n"
"So if your root directory is /dev/sda2, enter 2."
msgstr ""
#: weresync/gui.py:277
msgid "Bootloader Partition"
msgstr ""
#: weresync/gui.py:282
msgid "Advanced Options"
msgstr ""
#: weresync/gui.py:288
msgid ""
"Ignore errors during copying. If off, common errors often stop the clone."
msgstr ""
#: weresync/gui.py:296
msgid "Source Partition Mask: "
msgstr ""
#: weresync/gui.py:311
msgid ""
"A string that controls the how partitions are found on the file system. It "
"should have two placeholders: {0} for the device name and {1} for the "
"partition number.\n"
"So if you have /dev/loop0 and partition 1 is /dev/loop0p1, the part_mask "
"should be '{0}p{1}'"
msgstr ""
#: weresync/gui.py:315
msgid "Partition Mask"
msgstr ""
#: weresync/gui.py:320
msgid "Target Partition Mask: "
msgstr ""
#: weresync/gui.py:334
msgid "Excluded Partitions: "
msgstr ""
#: weresync/gui.py:348
msgid ""
"A comma separated list of partition numbers that should not be copied or "
"searched.\n"
"If partitions partitions are copied, they will still be copied."
msgstr ""
#: weresync/gui.py:351
msgid "Excluded Partitions"
msgstr ""
#: weresync/gui.py:357
msgid "Boot Partition: "
msgstr ""
#: weresync/gui.py:370
msgid "The number of the partition mounted on /boot."
msgstr ""
#: weresync/gui.py:371
msgid "Boot Partition"
msgstr ""
#: weresync/gui.py:375
msgid "Rsync Arguments: "
msgstr ""
#: weresync/gui.py:386
msgid ""
"Enter the arguments to pass the rsync program. For more information see the rsync website."
msgstr ""
#: weresync/gui.py:389
msgid "Rsync Arguments"
msgstr ""
#: weresync/gui.py:393
msgid "Source Drive Mount Point: "
msgstr ""
#: weresync/gui.py:401
msgid "Source Drive Mount Folder"
msgstr ""
#: weresync/gui.py:408
msgid ""
"These are the folders that the drives to be copied will be mounted in. If "
"unset, WereSync will generate random folders in the /tmp directory. "
"Generally this can be unset."
msgstr ""
#: weresync/gui.py:411
msgid "Drive Mount Point."
msgstr ""
#: weresync/gui.py:416
msgid "Target Drive Mount Point: "
msgstr ""
#: weresync/gui.py:421
msgid "Target Drive Mount Folder"
msgstr ""
#: weresync/gui.py:431
msgid "Start Clone"
msgstr ""
#: weresync/gui.py:517
msgid "Error starting clone."
msgstr ""
#: weresync/gui.py:530
msgid "Clone finished!"
msgstr ""
#: weresync/gui.py:532
msgid ""
"\n"
"Non fatal error occurred: "
msgstr ""
#: weresync/gui.py:547
msgid "Checking partitions and copying: "
msgstr ""
#: weresync/gui.py:566
msgid "Copying partition {0}: "
msgstr ""
#: weresync/gui.py:579
msgid "Making bootable: "
msgstr ""
#: weresync/gui.py:628
msgid "Error starting WereSync."
msgstr ""
#: weresync/gui.py:638
msgid "Starting gui."
msgstr ""
#: weresync/interface.py:158
msgid "Checking partition validity."
msgstr ""
#: weresync/interface.py:165
msgid ""
"Partitions invalid!\n"
"Copying drive partition table."
msgstr ""
#: weresync/interface.py:314
msgid "Beginning to copy files."
msgstr ""
#: weresync/interface.py:324
msgid "Making bootable"
msgstr ""
#: weresync/interface.py:330
msgid "Error making drive bootable. All files should be fine."
msgstr ""
#: weresync/interface.py:332
msgid "All done, enjoy your drive!"
msgstr ""
#: weresync/interface.py:365
msgid "Bootloader plugins found: "
msgstr ""
#: weresync/interface.py:370
msgid "The drive to copy data from. This drive will not be edited."
msgstr ""
#: weresync/interface.py:374
msgid "The drive to copy data to. ALL DATA ON THIS DRIVE WILL BE ERASED."
msgstr ""
#: weresync/interface.py:381
msgid ""
"Check if partitions are valid and re-partition drive to proper partitions if "
"they are not."
msgstr ""
#: weresync/interface.py:387
msgid ""
"A string of format '{0}{1}' where {0} represents drive identifier and {1} "
"represents partition number to point to partition block files for the source "
"drive."
msgstr ""
#: weresync/interface.py:394
msgid ""
"A string of format '{0}{1}' where {0} represents drive identifier and {1} "
"represents partition number to point to partition block files for the target "
"drive."
msgstr ""
#: weresync/interface.py:400
msgid ""
"A comment separated list of partitions of the source drive to apply no "
"actions on.perated list of partitions of the source drive to apply no "
"actions on."
msgstr ""
#: weresync/interface.py:408
msgid ""
"Causes program to break whenever a partition cannot be copied, including "
"uncopyable partitions such as swap files. Not recommended."
msgstr ""
#: weresync/interface.py:416
msgid "The partition mounted on /."
msgstr ""
#: weresync/interface.py:421
msgid "Partition which should be mounted on /boot"
msgstr ""
#: weresync/interface.py:426
msgid "Partition which should be mounted on /boot/efi"
msgstr ""
#: weresync/interface.py:430
msgid "Folder where partitions from the source drive should be mounted."
msgstr ""
#: weresync/interface.py:436
msgid "Folder where partitions from source drive should be mounted."
msgstr ""
#: weresync/interface.py:442
msgid "List of arguments passed to rsync. Defaults to: "
msgstr ""
#: weresync/interface.py:448
msgid ""
"Passed to decide what boootloader plugin to use. See below for list of "
"plugins. Defaults to simply changing the UUIDs of files in /boot."
msgstr ""
#: weresync/interface.py:455
msgid "The name of the source logical volume."
msgstr ""
#: weresync/interface.py:461
msgid "Prints expanded output."
msgstr ""
#: weresync/interface.py:468
msgid "Prints large output. Mainly helpful for developers."
msgstr ""
#: weresync/interface.py:480
msgid "More than two lvm options added. Please give either one or two options."
msgstr ""
#: weresync/plugins/weresync_grub2.py:105
msgid "Updating Grub"
msgstr ""
#: weresync/plugins/weresync_grub2.py:120
msgid "Installing Grub"
msgstr ""
#: weresync/plugins/weresync_grub2.py:137
msgid ""
"Consider running update-grub on your backup. WereSync copies can sometimes "
"fail to capture all the nuances of a complex system."
msgstr ""
#: weresync/plugins/weresync_grub2.py:140
msgid "Cleaning up."
msgstr ""
#: weresync/plugins/weresync_grub2.py:147
msgid "Finished!"
msgstr ""
WereSync-1.1.5/src/weresync/resources/weresync-dbus.conf 0000644 0001750 0001751 00000000670 13501272661 024077 0 ustar daniel daniel 0000000 0000000
WereSync-1.1.5/src/weresync/resources/weresync-gui.desktop 0000644 0001750 0001751 00000000141 13501327145 024441 0 ustar daniel daniel 0000000 0000000 [Desktop Entry]
Name=WereSync
Exec=weresync-gui
Icon=weresync
Type=Application
Categories=System
WereSync-1.1.5/src/weresync/resources/weresync.service 0000644 0001750 0001751 00000000242 13501272531 023646 0 ustar daniel daniel 0000000 0000000 [Unit]
Description=Weresync Drive Copier
After=dbus.service
[Service]
Type=dbus
BusName=net.manilas.weresync.DriveCopier
ExecStart=/usr/local/bin/weresync-daemon WereSync-1.1.5/src/weresync/resources/weresync.svg 0000644 0001750 0001751 00000067545 13501054034 023024 0 ustar daniel daniel 0000000 0000000
WereSync-1.1.5/src/weresync/utils.py 0000644 0001750 0001751 00000010313 13501054034 020121 0 ustar daniel daniel 0000000 0000000 # Copyright 2016 Daniel Manila
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""This module contains several functions common to all modules."""
from weresync.exception import DeviceError, InvalidVersionError
import subprocess
import logging
import logging.handlers
import os
import gettext
import sys
LOGGER = logging.getLogger(__name__)
LANGUAGES = ["en"]
"""Currently translated languages. See `here `_ for more
information."""
DEFAULT_USER_LOG_LOCATION = os.path.expanduser(
"~/.local/log/weresync/weresync-user.log")
"""The default location for WereSync's user log files."""
def run_proc(args,
target="",
error=None,
valid_returncodes=[0],
throw_error=DeviceError):
"""Creates an runs a subprocess with the passed args. and throws an error
if the valid returncodes do not exist.
This expects either :py:class:`~weresync.exception.DeviceError` or an
exception which takes 2 arguments, the first for a custom error message
and the second for the output of the processs.
:param args: the argument list to run. Passed to the first paramter of
`subprocess.Popen`
:param error: the custom error code to display. Optional
:param valid_returncodes: the list of return codes which should *not* throw
an error.
:param throw_error: the error class to be thrown if there is an error.
Defaults to :py:class:`~weresync.exception.DeviceError`
:returns: the output of the process
"""
proc = subprocess.Popen(
args, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
output, _ = proc.communicate()
output = str(output, "utf-8")
if proc.returncode not in valid_returncodes:
if error is None:
error = ""
if throw_error == DeviceError:
raise DeviceError(target, error, output)
else:
raise throw_error(error, output)
return output
def start_logging_handler(log_loc,
stream_level=logging.WARNING,
file_level=logging.DEBUG):
os.makedirs(os.path.dirname(log_loc), exist_ok=True)
logger = logging.getLogger()
logger.setLevel(file_level if file_level < stream_level else stream_level)
formatter = logging.Formatter(
"%(levelname)s - %(asctime)s - %(name)s - %(message)s")
def enableHandler(hand, level, formatter):
hand.setLevel(level)
hand.setFormatter(formatter)
logger.addHandler(hand)
handler = logging.handlers.TimedRotatingFileHandler(
log_loc, when="D", interval=1, backupCount=15)
enableHandler(handler, file_level, formatter)
streamHandler = logging.StreamHandler()
enableHandler(streamHandler, stream_level, formatter)
logging.getLogger("yapsy").setLevel(logging.INFO)
def enable_localization():
"""Activates the `gettext` module to start internalization and enable
translation."""
LOGGER.debug("Enabling localization")
lodir = os.path.dirname(os.path.realpath(__file__)) + "/resources/locale"
es = gettext.translation("weresync", localedir=lodir, languages=LANGUAGES)
es.install()
def check_python_version():
"""This method tests if the running version of python supports WereSync.
If it does not, it raises a InvalidVersionException"""
try:
assert sys.version_info > (3, 0)
except AssertionError:
info = sys.version_info
raise InvalidVersionError(
"Python version {major}.{minor} not supported. WereSync requires "
"at least Python 3.0\n"
"Considering installing WereSync with the pip3 command to insure "
"it installs with Python3.".format(major=info[0], minor=info[1]))
WereSync-1.1.5/tests/ 0000755 0001750 0001751 00000000000 13503555360 015137 5 ustar daniel daniel 0000000 0000000 WereSync-1.1.5/tests/test_device.py 0000644 0001750 0001751 00000061602 13501235665 020015 0 ustar daniel daniel 0000000 0000000 # Copyright 2016 Daniel Manila
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# flake8: noqa
import sys
import os
myPath = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, myPath + "/../src/")
import pytest
import unittest.mock as mock
import weresync.daemon.device as device
from weresync.exception import DeviceError, UnsupportedDeviceError
def generateStandardMock(monkeypatch,
return_value_output,
return_value_error,
return_code,
type="gpt"):
"""Generates a mock for the Popen class that allows easy testing of device methods that use Popen."""
mock_popen = mock.MagicMock()
if return_value_error != None:
return_value_output += return_value_error # Simulates combining the stdout and stderr
mock_popen.communicate.return_value = (return_value_output, None)
mock_popen.returncode = return_code
def popen_constructor(*args, **kargs):
return mock_popen
def mock_table_type(*args, **kargs):
return type
monkeypatch.setattr("subprocess.Popen", popen_constructor)
if type != None:
monkeypatch.setattr(
"weresync.daemon.device.DeviceManager.get_partition_table_type",
mock_table_type)
def test_get_partitions_valid(monkeypatch):
generateStandardMock(monkeypatch, b"""Model: Unknown (unknown)
Disk /dev/nbd0: 8590MB
Sector size (logical/physical): 512B/512B
Partition Table: gpt
Number Start End Size File system Name Flags
4 1049kB 500MB 499MB bios_grub
1 500MB 6000MB 5500MB ext4
2 6000MB 7400MB 1400MB ext4
3 7400MB 8589MB 1189MB linux-swap(v1)\n """, None,
0) # standard return from sgdisk -p
manager = device.DeviceManager("/dev/sdd")
result = manager.get_partitions()
assert result == [4, 1, 2, 3]
def test_get_partitions_none_zero_returncode(monkeypatch):
generateStandardMock(monkeypatch, b"", b"Error.", 1)
manager = device.DeviceManager("/dev/sda")
with pytest.raises(DeviceError) as execinfo:
manager.get_partitions()
assert "Error." in str(execinfo.value)
def test_get_partitions_no_partitions(monkeypatch):
generateStandardMock(monkeypatch, b"Nope\nvery\nvery\nbad\ndata", None, 0)
manager = device.DeviceManager("/dev/sda")
result = manager.get_partitions()
assert result == []
def test_mount_point_normal(monkeypatch):
generateStandardMock(monkeypatch,
b"""TARGET SOURCE FSTYPE OPTIONS
/mnt /dev/sda11 fuseblk rw,nosuid,nodev,relatime,user_id=0,group_id=0,def
""", None, 0)
manager = device.DeviceManager("/dev/sda")
result = manager.mount_point(3)
assert "/mnt" == result
def test_mount_point_non_zero_return_code(monkeypatch):
generateStandardMock(monkeypatch,
b"""TARGET SOURCE FSTYPE OPTIONS\n
/mnt /dev/sda11 fuseblk rw,nosuid,nodev,relatime,user_id=0,group_id=0,def\n
""", b"Error.", 2)
manager = device.DeviceManager("/dev/sda")
with pytest.raises(DeviceError) as execinfo:
result = manager.mount_point(5)
assert "Error." in str(execinfo.value)
def test_mount_point_no_mount_point(monkeypatch):
generateStandardMock(monkeypatch, b"", None,
1) # findmnt returns 1 when there is no mount point
manager = device.DeviceManager("/dev/sda")
result = manager.mount_point(5)
assert result == None
def test_mount_partition(monkeypatch):
generateStandardMock(monkeypatch, b"", None, 0)
manager = device.DeviceManager("/dev/sda")
manager.mount_partition(3, "/mnt")
def test_mount_partition_non_zero_return_code(monkeypatch):
generateStandardMock(monkeypatch, b"", b"Error.", 1)
manager = device.DeviceManager("/dev/sda")
with pytest.raises(DeviceError) as execinfo:
manager.mount_partition(3, "/mnt")
assert "Error." in str(execinfo.value)
def test_unmount_partition(monkeypatch):
generateStandardMock(monkeypatch, b"", b"", 0)
manager = device.DeviceManager("/dev/sda")
manager.unmount_partition(5)
def test_unmount_partition_non_zero(monkeypatch):
generateStandardMock(monkeypatch, b"", b"Error.", 1)
manager = device.DeviceManager("/dev/sda")
with pytest.raises(DeviceError) as execinfo:
manager.unmount_partition(5)
assert "Error." in str(execinfo.value)
def test_get_partition_table_type_gpt(monkeypatch):
generateStandardMock(monkeypatch, b"""/dev/sda: gpt partitions 1 2 3 4 5 11 8 9 10 6 7""", b"", 0, None)
manager = device.DeviceManager("/dev/sda")
result = manager.get_partition_table_type()
assert "gpt" == result
def test_get_partition_table_type_non_zero_return_code(monkeypatch):
generateStandardMock(monkeypatch, b"", b"Error.", 1, None)
manager = device.DeviceManager("/dev/sda")
with pytest.raises(DeviceError) as execinfo:
manager.get_partition_table_type()
assert "Error." in str(execinfo.value)
def test_get_partition_table_type_mbr(monkeypatch):
generateStandardMock(monkeypatch, b"""/dev/sda: msdos partitions 1 2 3 4 5 11 8 9 10 6 7""", b"", 0, None)
manager = device.DeviceManager("mbr.img")
result = manager.get_partition_table_type()
assert result == "msdos"
def test_get_partition_table_type_unsupported(monkeypatch):
generateStandardMock(monkeypatch, b""" dddd """, b"", 0, None)
manager = device.DeviceManager("/dev/sda")
with pytest.raises(UnsupportedDeviceError) as execinfo:
manager.get_partition_table_type()
assert "Partition table type of /dev/sda not supported" in str(execinfo)
def test_get_drive_size(monkeypatch):
generateStandardMock(monkeypatch, b"192", b"", 0)
manager = device.DeviceManager("/dev/sda")
result = manager.get_drive_size()
assert 192 == result
def test_get_drive_size_non_zero_return_code(monkeypatch):
generateStandardMock(monkeypatch, b"", b"Error.", 1)
manager = device.DeviceManager("/dev/sda")
with pytest.raises(DeviceError) as execinfo:
manager.get_drive_size()
assert "Error." in str(execinfo.value)
def test_get_drive_size_bytes(monkeypatch):
generateStandardMock(monkeypatch, b"190", b"", 0)
manager = device.DeviceManager("/dev/sda")
result = manager.get_drive_size_bytes()
assert 190 == result
def test_get_drive_size_bytes_non_zero_return_code(monkeypatch):
generateStandardMock(monkeypatch, b"", b"Error.", 1)
manager = device.DeviceManager("/dev/sda")
with pytest.raises(DeviceError) as execinfo:
manager.get_drive_size()
assert "Error." in str(execinfo.value)
def test_get_partition_used(monkeypatch):
generateStandardMock(
monkeypatch,
b"/dev/sda11 676276220 179697120 496579100 27% /media/Data", b"",
0)
manager = device.DeviceManager("/dev/sda")
result = manager.get_partition_used(5)
assert 179697120 == result
def test_get_partition_used_non_zero_return(monkeypatch):
generateStandardMock(monkeypatch, b" ", b"Error.", 1)
manager = device.DeviceManager("/dev/sda")
with pytest.raises(DeviceError) as execinfo:
manager.get_partition_used(4)
assert "Error." in str(execinfo.value)
def test_get_drive_empty_space(monkeypatch):
generateStandardMock(monkeypatch,
b"""Disk gpt.img: 1024000 sectors, 500.0 MiB
Logical sector size: 512 bytes
Disk identifier (GUID): 6FCE9962-D7B0-4BF3-B7BC-5E5CE8A5B0B0
Partition table holds up to 128 entries
First usable sector is 34, last usable sector is 1023966
Partitions will be aligned on 2-sector boundaries
Total free space is 647 sectors (323.5 KiB)
Number Start (sector) End (sector) Size Code Name
1 34 97656 47.7 MiB 8300 test
2 98304 145407 23.0 MiB 8300 cool
3 145408 391167 120.0 MiB 8300 nice
4 391168 684031 143.0 MiB 8300 great
5 684032 976895 143.0 MiB 8300 sweet
6 976896 1023966 23.0 MiB 8300
""", b"", 0)
manager = device.DeviceManager("gpt.img")
result = manager.get_empty_space()
assert result == 34
def test_get_empty_space_non_zero_return(monkeypatch):
generateStandardMock(monkeypatch, b"", b"Error.", 2)
manager = device.DeviceManager("gpt.img")
with pytest.raises(DeviceError) as execinfo:
manager.get_empty_space()
assert "Error." in str(execinfo.value)
def test_get_empty_space_mbr(monkeypatch):
generateStandardMock(monkeypatch, b"""Disk mbr.img: 524 MB, 524288000 bytes
63 heads, 37 sectors/track, 439 cylinders, total 1024000 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0xd9e3a78c
Device Boot Start End Blocks Id System
mbr.img1 2050 3942 946+ 83 Linux
""", b"", 0, "msdos")
manager = device.DeviceManager("mbr.img")
result = manager.get_empty_space()
assert result == 1020058
def test_get_empty_space_mbr_boot(monkeypatch):
generateStandardMock(monkeypatch, b"""Disk mbr.img: 524 MB, 524288000 bytes
63 heads, 37 sectors/track, 439 cylinders, total 1024000 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0xd9e3a78c
Device Boot Start End Blocks Id System
mbr.img1 2050 3942 946+ 83 Linux
Disk mbr.img: 524 MB, 524288000 bytes
255 heads, 63 sectors/track, 63 cylinders, total 1024000 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0xd9e3a78c
Device Boot Start End Blocks Id System
mbr.img1 2050 3942 946+ 83 Linux
mbr.img2 2048 2049 1 83 Linux
mbr.img3 3943 255846 125952 5 Extended
mbr.img5 5991 104244 49127 83 Linux
mbr.img6 * 106293 255846 74777 83 Linux
""", b"", 0, "msdos")
manager = device.DeviceManager("mbr.img")
result = manager.get_empty_space()
def test_get_partition_size(monkeypatch):
generateStandardMock(monkeypatch,
b"""Disk /dev/loop0: 1024000 sectors, 500.0 MiB
Logical sector size: 512 bytes
Disk identifier (GUID): 4EB07926-DFE2-4D18-A2F4-75FB23616F71
Partition table holds up to 128 entries
First usable sector is 34, last usable sector is 1023966
Partitions will be aligned on 2048-sector boundaries
Total free space is 2014 sectors (1007.0 KiB)
Number Start (sector) End (sector) Size Code Name
1 2048 309247 150.0 MiB 8300 Linux filesystem
2 309248 821247 250.0 MiB 8300 Linux filesystem
3 821248 972799 74.0 MiB 8300 Linux filesystem
4 972800 1019903 23.0 MiB 8300 Linux filesystem
5 1019904 1023966 2.0 MiB 8300 Linux filesystem
""", None, 0)
monkeypatch.setattr(
"weresync.daemon.device.DeviceManager.get_partition_table_type",
lambda x: "gpt")
manager = device.DeviceManager("gpt.img")
result = manager.get_partition_size(5)
assert 4062 == result
def test_get_partition_size_non_zero_return_code(monkeypatch):
generateStandardMock(monkeypatch, b"", b"Error.", 2)
manager = device.DeviceManager("gpt.img")
with pytest.raises(DeviceError) as execinfo:
manager.get_partition_size(1)
assert "Error." in str(execinfo)
def test_get_partition_size_mbr_non_zero_return_code(monkeypatch):
generateStandardMock(monkeypatch, b"", b"Error.", 2, "msdos")
manager = device.DeviceManager("mbr.img")
with pytest.raises(DeviceError) as execinfo:
manager.get_partition_size(3)
assert "Error." in str(execinfo)
def test_get_partition_size_mbr(monkeypatch):
generateStandardMock(monkeypatch, b"204800", b"", 0, "msdos")
manager = device.DeviceManager("mbr.img")
result = manager.get_partition_size(4)
assert result == 204800
def test_get_partition_size_unknown_table_type(monkeypatch):
generateStandardMock(monkeypatch, b"", b"", 0, "blah")
manager = device.DeviceManager("blah.img")
with pytest.raises(ValueError) as execinfo:
manager.get_partition_size(5)
assert "Unsupported" in str(execinfo)
def test_get_sector_alignment_number(monkeypatch):
generateStandardMock(monkeypatch,
b"""Disk /dev/loop1: 512000 sectors, 250.0 MiB
Logical sector size: 512 bytes
Disk identifier (GUID): 4EB07926-DFE2-4D18-A2F4-75FB23616F71
Partition table holds up to 128 entries
First usable sector is 34, last usable sector is 511966
Partitions will be aligned on 2048-sector boundaries
Total free space is 5558 sectors (2.7 MiB)
Number Start (sector) End (sector) Size Code Name
1 2048 309247 150.0 MiB 8300 Linux filesystem
2 309248 508422 97.3 MiB 8300 Linux filesystem
""", b"", 0)
manager = device.DeviceManager("gpt.img")
result = manager.get_partition_alignment()
assert result == 2048
def test_get_sector_alignment_number_non_zero_return(monkeypatch):
generateStandardMock(monkeypatch, b"", b"Error.", 1)
manager = device.DeviceManager("gpt.img")
with pytest.raises(DeviceError) as execinfo:
result = manager.get_partition_alignment()
assert "Error." in str(execinfo.value)
def test_get_sector_alignment_number_invalid_return(monkeypatch):
generateStandardMock(monkeypatch, b"No alignment", b"", 0)
manager = device.DeviceManager("gpt.img")
with pytest.raises(DeviceError) as execinfo:
result = manager.get_partition_alignment()
def test_get_partition_alignment_msdos(monkeypatch):
generateStandardMock(monkeypatch,
b"""Disk /dev/loop0: 7516 MB, 7516192768 bytes
255 heads, 63 sectors/track, 913 cylinders, total 14680064 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x524f0bf8
Device Boot Start End Blocks Id System
""", b"", 0, "msdos")
manager = device.DeviceManager("msdos.img")
result = manager.get_partition_alignment()
# Basically, this is testing if the physical partition is different then the logical partition. If so, then sectors will need to be aligned properly. That isn't the case here.
assert result == 1
def test_get_partition_alignment_msdos_non_zero_return_code(monkeypatch):
generateStandardMock(monkeypatch, b"", b"Error msdos", 1, "msdos")
manager = device.DeviceManager("msdos.img")
with pytest.raises(DeviceError) as exceinfo:
result = manager.get_partition_alignment()
def test_get_partition_file_system(monkeypatch):
generateStandardMock(monkeypatch, b"ext4", b"", 0)
manager = device.DeviceManager("gpt.img")
result = manager.get_partition_file_system(4)
assert result == "ext4"
def test_get_partition_file_system_empty_return(monkeypatch):
generateStandardMock(monkeypatch, b"", b"", 0)
manager = device.DeviceManager("gpt.img")
result = manager.get_partition_file_system(4)
assert result == None
def test_get_partition_file_system_unsupported_type(monkeypatch):
generateStandardMock(monkeypatch, b"completelyimpossiblefilesystemtype",
b"", 0)
manager = device.DeviceManager("gpt.img")
result = manager.get_partition_file_system(4)
assert result == None
def test_get_partition_file_system_non_zero_return(monkeypatch):
generateStandardMock(monkeypatch, b"", b"Error.", 1)
manager = device.DeviceManager("gpt.img")
with pytest.raises(DeviceError) as execinfo:
manager.get_partition_file_system(3)
assert "Error." in str(execinfo.value)
def test_set_partition_file_system_non_zero_return(monkeypatch):
generateStandardMock(monkeypatch, b"", b"Error.", 1)
manager = device.DeviceManager("gpt.img")
with pytest.raises(DeviceError) as execinfo:
manager.set_partition_file_system(3, "ext4")
assert "new file system" in str(execinfo.value)
assert "Error." in str(execinfo.value)
def test_partition_code(monkeypatch):
generateStandardMock(monkeypatch,
b"""Disk /dev/nbd0: 16777216 sectors, 8.0 GiB
Logical sector size: 512 bytes
Disk identifier (GUID): 13E1C95B-5AC6-412B-930B-8F119760B86E
Partition table holds up to 128 entries
First usable sector is 34, last usable sector is 16777182
Partitions will be aligned on 2048-sector boundaries
Total free space is 4029 sectors (2.0 MiB)
Number Start (sector) End (sector) Size Code Name
1 976896 11718655 5.1 GiB 8300
2 11718656 14452735 1.3 GiB 8300
3 14452736 16775167 1.1 GiB 8200
4 2048 976895 476.0 MiB EF02
""", b"", 0)
manager = device.DeviceManager("gpt.img")
result = manager.get_partition_code(3)
assert "8200" == result
def test_get_partition_code_non_zero_return_code(monkeypatch):
generateStandardMock(monkeypatch, b"", b"Error.", 2, "gpt")
with pytest.raises(DeviceError) as execinfo:
manager = device.DeviceManager("gpt.img")
manager.get_partition_code(3)
assert "Error." in str(execinfo)
def test_get_partition_code_newer_format(monkeypatch):
generateStandardMock(monkeypatch, b"""Disk /dev/sdb: 5 GiB, 5368709120 bytes, 10485760 sectors
Units: sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disklabel type: dos
Disk identifier: 0x0ee18f9a
Device Boot Start End Sectors Size Id Type
/dev/sdb1 * 2048 350300 348253 170M 83 Linux
/dev/sdb2 352347 10485759 10133413 4,9G 5 Extended
/dev/sdb5 352349 10485759 10133411 4,9G 8e Linux LVM""",
b"", 0, "msdos")
manager = device.DeviceManager("/dev/sdb")
result = manager.get_partition_code(5)
assert "8e" == result
def test_get_partition_code_mbr(monkeypatch):
generateStandardMock(monkeypatch,
b"""Disk /dev/loop0: 524 MB, 524288000 bytes
255 heads, 63 sectors/track, 63 cylinders, total 1024000 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x01517e72
Device Boot Start End Blocks Id System
/dev/loop0p1 * 2048 411647 204800 83 Linux
/dev/loop0p2 411648 718847 153600 83 Linux
/dev/loop0p3 * 718848 819199 50176 83 Linux
/dev/loop0p4 819200 1023999 102400 83 Linux
""", b"", 0, "msdos")
manager = device.DeviceManager("/dev/loop0", partition_mask="{0}p{1}")
result = manager.get_partition_code(2)
assert result == "83"
def test_get_partition_code_mbr_bootable(monkeypatch):
generateStandardMock(monkeypatch,
b"""Disk /dev/loop0: 524 MB, 524288000 bytes
255 heads, 63 sectors/track, 63 cylinders, total 1024000 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x01517e72
Device Boot Start End Blocks Id System
/dev/loop0p1 * 2048 411647 204800 83 Linux
/dev/loop0p2 411648 718847 153600 83 Linux
/dev/loop0p3 * 718848 819199 50176 83 Linux
/dev/loop0p4 819200 1023999 102400 83 Linux
""", b"", 0, "msdos")
manager = device.DeviceManager("/dev/loop0", partition_mask="{0}p{1}")
result = manager.get_partition_code(3)
assert result == "83"
def test_get_partition_code_mbr_invalid_value_passed(monkeypatch):
generateStandardMock(monkeypatch,
b"""Disk /dev/loop0: 524 MB, 524288000 bytes
255 heads, 63 sectors/track, 63 cylinders, total 1024000 sectors
Units = sectors of 1 * 512 = 512 bytes
Sector size (logical/physical): 512 bytes / 512 bytes
I/O size (minimum/optimal): 512 bytes / 512 bytes
Disk identifier: 0x01517e72
Device Boot Start End Blocks Id System
/dev/loop0p1 * 2048 411647 204800 83 Linux
/dev/loop0p2 411648 718847 153600 83 Linux
/dev/loop0p3 * 718848 819199 50176 83 Linux
/dev/loop0p4 819200 1023999 102400 83 Linux
""", b"", 0, "msdos")
with pytest.raises(ValueError) as execinfo:
manager = device.DeviceManager("/dev/loop0", "{0}p{1}")
manager.get_partition_code(5)
def test_get_partition_code_mbr_non_zero_return_code(monkeypatch):
generateStandardMock(monkeypatch, b"", b"Test error.", 2, "msdos")
manager = device.DeviceManager("mbr.img")
with pytest.raises(DeviceError) as execinfo:
manager.get_partition_code(4)
assert "Test error." in str(execinfo)
def test_lvm_get_partitions_standard(monkeypatch):
generateStandardMock(
monkeypatch,
b"""LV:VG:Attr:LSize:Pool:Origin:Data%:Meta%:Move:Log:Cpy%Sync:Convert
backup:fileserver:-wi-a-----:5,00g::::::::
media:fileserver:-wi-a-----:1,00g::::::::
share:fileserver:-wi-a-----:50,00g::::::::
root:ubuntu-vg:-wi-ao----:6,52g::::::::
swap_1:ubuntu-vg:-wi-ao----:1,00g::::::::
""", b"", 0, "lvm")
manager = device.LVMDeviceManager("/dev/fileserver")
parts = manager.get_partitions()
assert ["backup", "media", "share"] == parts
def test_lvm_get_partitions_bad_return_code(monkeypatch):
generateStandardMock(monkeypatch, b"Test error.", b"", 1, "lvm")
manager = device.LVMDeviceManager("/dev/fileserver")
with pytest.raises(DeviceError) as execinfo:
manager.get_partitions()
assert "Test error." in str(execinfo)
def test_lvm_get_drive_size_standard(monkeypatch):
generateStandardMock(monkeypatch, b" 12566528S", b"", 0, "lvm")
manager = device.LVMDeviceManager("/dev/fileserver")
result = manager.get_drive_size()
assert 12566528 == result
def test_lvm_get_drive_size_bytes_standard(monkeypatch):
generateStandardMock(monkeypatch, b" 6434062336B", b"", 0, "lvm")
manager = device.LVMDeviceManager("/dev/fileserver")
result = manager.get_drive_size_bytes()
assert 6434062336 == result
def test_lvm_get_drive_size_bytes_bad_return_code(monkeypatch):
generateStandardMock(monkeypatch, b"Test error", b"", 1, "lvm")
manager = device.LVMDeviceManager("/dev/fileserver")
with pytest.raises(DeviceError) as execinfo:
manager.get_drive_size_bytes()
assert "Test error" in str(execinfo)
def test_lvm_get_partition_size(monkeypatch):
generateStandardMock(
monkeypatch,
b"/dev/fileserver/media:fileserver:3:1:-1:0:2097152:256:-1:0:-1:252:3",
b"", 0, "lvm")
manager = device.LVMDeviceManager("/dev/fileserver")
result = manager.get_partition_size("media")
assert result == 2097152
def test_lvm_get_partition_size_bad_return_code(monkeypatch):
generateStandardMock(monkeypatch, b"Didn't work.", b"", 1, "lvm")
manager = device.LVMDeviceManager("/dev/fileserver")
with pytest.raises(DeviceError) as execinfo:
manager.get_partition_size("media")
assert "Didn't work." in str(execinfo)
def test_lvm_get_partition_code_unsupported():
manager = device.LVMDeviceManager("/dev/fileserver")
with pytest.raises(UnsupportedDeviceError) as execinfo:
manager.get_partition_code("media")
def test_lvm_get_partition_alignment_unssported():
manager = device.LVMDeviceManager("/dev/fileserver")
with pytest.raises(UnsupportedDeviceError) as execinfo:
manager.get_partition_alignment()
def test_get_empty_space(monkeypatch):
generateStandardMock(monkeypatch, b" 70921486336B", b"", 0, "lvm")
manager = device.LVMDeviceManager("/dev/fileserver")
result = manager.get_empty_space()
assert result == 70921486336
def test_get_empty_space_non_zero_return_code(monkeypatch):
generateStandardMock(monkeypatch, b"Error.", b"", 1, "lvm")
manager = device.LVMDeviceManager("/dev/fileserver")
with pytest.raises(DeviceError) as execinfo:
manager.get_empty_space()
assert "Error." in str(execinfo)