File: //lib64/python3.9/site-packages/borg/__pycache__/upgrader.cpython-39.opt-1.pyc
a
HZ�h�4 � @ s� d dl Z d dlZd dlZd dlZddlmZmZ ddlmZ ddl m
Z
ddl m Z m Z m
Z
ddlmZ ddlmZ dd lmZmZ ee�Zd
ZG d d � d e�ZG d
d� de�ZG dd� de�ZG dd� de�ZdS )� N� )�
KeyfileKey�KeyfileNotFoundError)�REPOSITORY_README)�ProgressIndicatorPercent)� get_base_dir� get_keys_dir�
get_cache_dir)�Lock)�
create_logger)�
Repository�MAGICs ATTICSEGc sn e Zd Z� fdd�Zddd�Zdd� Zedd d
��Zedd d ��Zd
d� Z edd� �Z
dd� Z dd� Z � Z
S )�AtticRepositoryUpgraderc s& d|d< d|d< t � j|i |�� d S )NF�lockZcheck_segment_magic)�super�__init__)�self�args�kw�� __class__� �3/usr/lib64/python3.9/site-packages/borg/upgrader.pyr s z AtticRepositoryUpgrader.__init__TFc C sX | �� d}|sJ| j � dtj�� d��}t�d|� |sJtj| j |tjd� t�d� t tj �
| j d�dd d
�� � | _ d d � | j
�� D �}z | �� }W n ty� t�d
� Y n0 | �||� W d � n1 s�0 Y t tj �
| j d�dd�� � | _ zF| �|� | j||d� | j||||d� | �� W | j �� d| _ n| j �� d| _ 0 |S )a� convert an attic repository to a borg repository
those are the files that need to be upgraded here, from most
important to least important: segments, key files, and various
caches, the latter being optional, as they will be rebuilt if
missing.
we nevertheless do the order in reverse, as we prefer to do
the fast stuff first, to improve interactivity.
Nz.before-upgrade-z%Y-%m-%d-%H:%M:%Sz making a hardlink copy in %s)�
copy_functionz1opening attic repository with borg and convertingr Tg �?)� exclusive�timeoutc S s g | ] \}}|�qS r r )�.0�i�filenamer r r �
<listcomp>. � z3AtticRepositoryUpgrader.upgrade.<locals>.<listcomp>� no key file found for repository)r )�dryrun�inplace)r" r# �progress)�path�datetimeZnow�logger�info�shutil�copytree�os�linkr
�join�acquirer �ioZsegment_iterator�find_attic_keyfiler �warning�convert_keyfiles�
convert_cache�convert_repo_index�convert_segments� borg_readme�release)r r" r# r$ Zbackup�segments�keyfiler r r �upgrade s4
*
�
z AtticRepositoryUpgrader.upgradec C sR t j�| jd�}t �|� t|d��}|�t� W d � n1 sD0 Y d S )NZREADME�w)r+ r% r- �remove�open�writer )r Zreadme�fdr r r r6 A s
z#AtticRepositoryUpgrader.borg_readmec C sz t �dt| � � t| �}t|ddd�}t| �D ]8\}}|rF|�|� |rVt�d� q0tj |t
t |d� q0|rv|� � dS )a convert repository segments from attic to borg
replacement pattern is `s/ATTICSEG/BORG_SEG/` in files in
`$ATTIC_REPO/data/**`.
luckily the magic string length didn't change so we can just
replace the 8 first bytes of all regular files in there.zconverting %d segments...zConverting segments %3.0f%%zupgrade.convert_segments)�total�msgZmsgidg����MbP?�r# N)
r' r( �lenr � enumerateZshow�time�sleepr �header_replace� ATTIC_MAGICr
Zfinish)r8 r" r# r$ Z
segment_countZpir r r r r r5 G s
z(AtticRepositoryUpgrader.convert_segmentsc C s� t | d���}|�d� |�t|��|kr�|rB|�d� |�|� n`t�| | d � t | d��(}|�|� |�|�� � W d � n1 s�0 Y t�| d � W d � n1 s�0 Y d S )Nzr+br z.tmp�wb)r= �seek�readrC r> r+ �rename�unlink)r Z old_magicZ new_magicr# ZsegmentZ new_segmentr r r rG ] s
,z&AtticRepositoryUpgrader.header_replacec C s
t �| �S )ae find the attic keyfiles
the keyfiles are loaded by `KeyfileKey.find_key_file()`. that
finds the keys with the right identifier for the repo.
this is expected to look into $HOME/.attic/keys or
$ATTIC_KEYS_DIR for key files matching the given Borg
repository.
it is expected to raise an exception (KeyfileNotFoundError) if
no key is found. whether that exception is from Borg or Attic
is unclear.
this is split in a separate function in case we want to use
the attic code here directly, instead of our local
implementation.)�AtticKeyfileKey�
find_key_file�r r r r r0 r s z*AtticRepositoryUpgrader.find_attic_keyfilec C s� t �d| � t| ��}|�� }W d � n1 s40 Y |�tjtjd�}tj �
t � tj � | ��} t �d| � |s�t| d��}|�
|� W d � n1 s�0 Y dS )a� convert key files from attic to borg
replacement pattern is `s/ATTIC KEY/BORG_KEY/` in
`get_keys_dir()`, that is `$ATTIC_KEYS_DIR` or
`$HOME/.attic/keys`, and moved to `$BORG_KEYS_DIR` or
`$HOME/.config/borg/keys`.
no need to decrypt to convert. we need to rewrite the whole
key file because magic string length changed, but that's not a
problem because the keyfiles are small (compared to, say,
all the segments).zconverting keyfile %sNr zwriting borg keyfile to %sr; )r' r( r= rK �replacerN �FILE_IDr r+ r% r- r �basenamer> )r9 r" �f�datar r r r2 � s
& z(AtticRepositoryUpgrader.convert_keyfilesc C s^ | � � }|du r"t�d| j � n8tj�| jd| �}t�d| � |sZtj|dd|d� dS )a� convert some repo files
those are all hash indexes, so we need to
`s/ATTICIDX/BORG_IDX/` in a few locations:
* the repository index (in `$ATTIC_REPO/index.%d`, where `%d`
is the `Repository.get_index_transaction_id()`), which we
should probably update, with a lock, see
`Repository.open()`, which i'm not sure we should use
because it may write data on `Repository.close()`...
Nz%no index file found for repository %szindex.%dzconverting repo index %s� ATTICIDX� BORG_IDXrB ) Zget_index_transaction_idr' r1 r% r+ r- r( r rG )r r" r# Ztransaction_id�indexr r r r4 � s z*AtticRepositoryUpgrader.convert_repo_indexc s� t j�dt j�t� dd��� t j�� | j�� t j�t� | j��� ��fdd�}t j�� �r�t j���spt � �� dD ] }||� qtdD ],}||�}t
� d| � �s�t �
|d d
� q�d S ) a� convert caches from attic to borg
those are all hash indexes, so we need to
`s/ATTICIDX/BORG_IDX/` in a few locations:
* the `files` and `chunks` cache (in `$ATTIC_CACHE_DIR` or
`$HOME/.cache/attic/<repoid>/`), which we could just drop,
but if we'd want to convert, we could open it with the
`Cache.open()`, edit in place and then `Cache.close()` to
make sure we have locking right
ZATTIC_CACHE_DIRz.cacheZatticc s� t j�� | �}t j�|�rlt j��| �}t j�|�rBt�d|� n&t�d|� d|� �� �sht�||� |S t�d| � d|� �� dS dS )a copy the given attic cache path into the borg directory
does nothing if dryrun is True. also expects
attic_cache_dir and borg_cache_dir to be set in the parent
scope, to the directories path including the repository
identifier.
:params path: the basename of the cache file to copy
(example: "files" or "chunks") as a string
:returns: the borg file that was created or None if no
Attic cache file was found.
z<borg cache file already exists in %s, not copying from Atticz copying attic cache file from z to zno z cache file found in N) r+ r% r- �existsr' r1 r( r) �copyfile)r% Z
attic_fileZ borg_file�Zattic_cache_dirZborg_cache_dirr" r r �copy_cache_file� s z>AtticRepositoryUpgrader.convert_cache.<locals>.copy_cache_file)Zconfig�files)�chunkszconverting cache %srV rW N)r+ �environ�getr% r- r �id_strr rY �makedirsr' r( r rG )r r" r\ �cacher r[ r r3 � s$
��
z%AtticRepositoryUpgrader.convert_cache)TFF)TFF)T)�__name__�
__module__� __qualname__r r: r6 � staticmethodr5 rG r0 r2 r4 r3 �
__classcell__r r r r r s
(
r c @ s, e Zd ZdZdZedd� �Zedd� �ZdS )rN z*backwards compatible Attic key file parserz ATTIC KEYc C s t j�dt j�t� dd��S )z,Determine where to repository keys and cacheZATTIC_KEYS_DIRz.attic�keys�r+ r_ r` r% r- r r r r r r � s �z AtticKeyfileKey.get_keys_dirc C s� | j }|� }tj�|�s$t|j|��t�|�D ]~}tj�||�}t|��T}|�� � � }|r�|�
| j �r�|dd� |j kr�|W d � S W d � q.1 s�0 Y q.t|j|��dS )aw copy of attic's `find_key_file`_
this has two small modifications:
1. it uses the above `get_keys_dir`_ instead of the global one,
assumed to be borg's
2. it uses `repository.path`_ instead of
`repository._location.canonical_path`_ because we can't
assume the repository has been opened by the archiver yet
�
N)
r r+ r% rY r �listdirr- r= �readline�strip�
startswithrR ra ��cls�
repositoryr Zkeys_dir�namer r? �liner r r rO � s
"6z AtticKeyfileKey.find_key_fileN) rd re rf �__doc__rR rg r � classmethodrO r r r r rN � s
rN c @ s& e Zd Zd
dd�Zdd� Zdd� Zd S ) �BorgRepositoryUpgraderTFc C sh t �d� | �F z | �� }W n ty8 t �d� Y n0 | �||� W d � n1 sZ0 Y dS )zDconvert an old borg repository to a current borg repository
z$converting borg 0.xx to borg currentr! N)r' r( �find_borg0xx_keyfiler r1 �
move_keyfiles)r r" r# r$ r9 r r r r: s
z BorgRepositoryUpgrader.upgradec C s
t �| �S �N)�Borg0xxKeyfileKeyrO rP r r r rx % s z+BorgRepositoryUpgrader.find_borg0xx_keyfilec C sD t j�|�}t j�t� |�}zt �||� W n ty> Y n0 d S rz )r+ r% rS r- r rL �FileExistsError)r r9 r" r Z new_keyfiler r r ry ( s z$BorgRepositoryUpgrader.move_keyfilesN)TFF)rd re rf r: rx ry r r r r rw s
rw c @ s( e Zd ZdZedd� �Zedd� �ZdS )r{ z.backwards compatible borg 0.xx key file parserc C s t j�dt j�t� dd��S )NZ
BORG_KEYS_DIRz.borgri rj r r r r r 5 s �z Borg0xxKeyfileKey.get_keys_dirc C s� | j }|� }tj�|�s$t|j|��t�|�D ]�}tj�||�}t|��^}|�� � � }|r�|�
| j �r�|t | j �d d � |j
kr�|W d � S W d � q.1 s�0 Y q.t|j|��d S )Nr )r r+ r% rY r rl r- r= rm rn ro rR rC ra rp r r r rO : s
,6z Borg0xxKeyfileKey.find_key_fileN)rd re rf ru rg r rv rO r r r r r{ 2 s
r{ )r& r+ r) rE Z
crypto.keyr r Z constantsr Zhelpersr r r r Zlockingr
r' r rr r r
rd rH r rN rw r{ r r r r �<module> s" a%