napcok/calamares
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch '3.1.x-stable' of https://github.com/calamares/calamares into 3.1.x-stable

Browse Source
This commit is contained in:
Philip 2017-11-02 04:12:26 -04:00
commit 6f950e5e38
11 changed files with 36 additions and 682 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
CMakeLists.txt
View File

@ -267,12 +267,9 @@ else()
endif()
# Doesn't list mksquashfs as an optional dep, though, because it
# hasn't been sent through the find_package() scheme.
set_package_properties( mksquashfs PROPERTIES
DESCRIPTION "Create squashed filesystems"
URL "http://tldp.org/HOWTO/SquashFS-HOWTO/creatingandusing.html"
PURPOSE "Create example distro"
TYPE OPTIONAL
)
#
# "http://tldp.org/HOWTO/SquashFS-HOWTO/creatingandusing.html"
add_feature_info( ExampleDistro ${mksquashfs_FOUND} "Create example-distro target.")
# add_subdirectory( thirdparty )
add_subdirectory( src )

2
src/modules/locale/LocaleViewStep.cpp
View File

@ -120,7 +120,7 @@ LocaleViewStep::fetchGeoIpTimezone()
try
{
YAML::Node doc = YAML::Load( reply->readAll() );
YAML::Node doc = YAML::Load( data );
QVariant var = CalamaresUtils::yamlToVariant( doc );
if ( !var.isNull() &&

3
src/modules/netinstall/NetInstallPage.cpp
View File

@ -3,6 +3,7 @@
* Copyright 2016, Lisa Vitolo <shainer@chakraos.org>
* Copyright 2017, Kyle Robbertze <krobbertze@gmail.com>
* Copyright 2017, Adriaan de Groot <groot@kde.org>
* Copyright 2017, Gabriel Craciunescu <crazy@frugalware.org>
*
* Calamares is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@ -77,7 +78,7 @@ NetInstallPage::readGroups( const QByteArray& yamlData )
m_groups = new PackageModel( groups );
CALAMARES_RETRANSLATE(
m_groups->setHeaderData( 0, Qt::Horizontal, tr( "Name" ) );
m_groups->setHeaderData( 0, Qt::Horizontal, tr( "Description" ) ); )
m_groups->setHeaderData( 1, Qt::Horizontal, tr( "Description" ) ); )
return true;
}

18
src/modules/partition/CMakeLists.txt
View File

@ -9,10 +9,22 @@ find_package( KF5 REQUIRED CoreAddons )
find_package( KF5 REQUIRED Config I18n IconThemes KIO Service )
find_package( KPMcore 3.1.50 QUIET )
if ( ${KPMcore_FOUND} )
if ( KPMcore_FOUND )
add_definitions(-DWITH_KPMCORE22)
endif()
find_package( KPMcore 3.0.3 REQUIRED )
find_package( KPMcore 3.0.3 QUIET )
# 3.0.3 and newer has fixes for NVMe support; allow 3.0.2, but warn
# about it .. needs to use a different feature name because it otherwise
# gets reported as KPMcore (the package).
if ( KPMcore_FOUND )
message( STATUS "KPMCore supports NVMe operations" )
add_feature_info( KPMcoreNVMe KPMcore_FOUND "KPMcore with NVMe support" )
else()
find_package( KPMcore 3.0.2 REQUIRED )
message( WARNING "KPMCore 3.0.2 is known to have bugs with NVMe devices" )
add_feature_info( KPMcoreNVMe KPMcore_FOUND "Older KPMcore with no NVMe support" )
endif()
find_library( atasmart_LIB atasmart )
find_library( blkid_LIB blkid )
if( NOT atasmart_LIB )
@ -58,7 +70,6 @@ calamares_add_plugin( partition
gui/PrettyRadioButton.cpp
gui/ScanningDialog.cpp
gui/ReplaceWidget.cpp
jobs/CheckFileSystemJob.cpp
jobs/ClearMountsJob.cpp
jobs/ClearTempMountsJob.cpp
jobs/CreatePartitionJob.cpp
@ -66,7 +77,6 @@ calamares_add_plugin( partition
jobs/DeletePartitionJob.cpp
jobs/FillGlobalStorageJob.cpp
jobs/FormatPartitionJob.cpp
jobs/MoveFileSystemJob.cpp
jobs/PartitionJob.cpp
jobs/ResizePartitionJob.cpp
jobs/SetPartitionFlagsJob.cpp

83
src/modules/partition/jobs/CheckFileSystemJob.cpp
View File

@ -1,83 +0,0 @@
/* === This file is part of Calamares - <http://github.com/calamares> ===
*
* Copyright 2014, Aurélien Gâteau <agateau@kde.org>
* Copyright 2016, Teo Mrnjavac <teo@kde.org>
*
* Calamares is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Calamares is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Calamares. If not, see <http://www.gnu.org/licenses/>.
*/
#include "jobs/CheckFileSystemJob.h"
#include <utils/Logger.h>
// KPMcore
#include <kpmcore/core/partition.h>
#include <kpmcore/fs/filesystem.h>
#include <kpmcore/util/report.h>
#include <QThread>
CheckFileSystemJob::CheckFileSystemJob( Partition* partition )
: PartitionJob( partition )
{}
QString
CheckFileSystemJob::prettyName() const
{
QString path = partition()->partitionPath();
return tr( "Checking file system on partition %1." ).arg( path );
}
QString
CheckFileSystemJob::prettyStatusMessage() const
{
return prettyName();
}
Calamares::JobResult
CheckFileSystemJob::exec()
{
FileSystem& fs = partition()->fileSystem();
// if we cannot check, assume everything is fine
if ( fs.supportCheck() != FileSystem::cmdSupportFileSystem )
return Calamares::JobResult::ok();
Report report( nullptr );
bool ok = fs.check( report, partition()->partitionPath() );
int retries = 0;
const int MAX_RETRIES = 10;
while ( !ok )
{
cDebug() << "Partition" << partition()->partitionPath()
<< "might not be ready yet, retrying (" << ++retries
<< "/" << MAX_RETRIES << ") ...";
QThread::sleep( 2 /*seconds*/ );
ok = fs.check( report, partition()->partitionPath() );
if ( retries == MAX_RETRIES )
break;
}
if ( !ok )
return Calamares::JobResult::error(
tr( "The file system check on partition %1 failed." )
.arg( partition()->partitionPath() ),
report.toText()
);
return Calamares::JobResult::ok();
}

38
src/modules/partition/jobs/CheckFileSystemJob.h
View File

@ -1,38 +0,0 @@
/* === This file is part of Calamares - <http://github.com/calamares> ===
*
* Copyright 2014, Aurélien Gâteau <agateau@kde.org>
*
* Calamares is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Calamares is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Calamares. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef CHECKFILESYSTEMJOB_H
#define CHECKFILESYSTEMJOB_H
#include <jobs/PartitionJob.h>
/**
* Runs a file system check on an existing partition.
*/
class CheckFileSystemJob : public PartitionJob
{
Q_OBJECT
public:
CheckFileSystemJob( Partition* partition );
QString prettyName() const override;
QString prettyStatusMessage() const override;
Calamares::JobResult exec() override;
};
#endif /* CHECKFILESYSTEMJOB_H */

239
src/modules/partition/jobs/MoveFileSystemJob.cpp
View File

@ -1,239 +0,0 @@
/* === This file is part of Calamares - <http://github.com/calamares> ===
*
* Copyright 2014, Aurélien Gâteau <agateau@kde.org>
*
* Calamares is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Calamares is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Calamares. If not, see <http://www.gnu.org/licenses/>.
*/
// This class is heavily based on the MoveFileSystemJob class from KDE Partition
// Manager.
// The copyBlock functions come from Partition Manager Job class.
// Original copyright follow:
/***************************************************************************
* Copyright (C) 2008 by Volker Lanz <vl@fidra.de> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA *
***************************************************************************/
#include <jobs/MoveFileSystemJob.h>
#include <utils/Logger.h>
// KPMcore
#include <kpmcore/core/copysourcedevice.h>
#include <kpmcore/core/copytargetdevice.h>
#include <kpmcore/core/device.h>
#include <kpmcore/core/partition.h>
#include <kpmcore/fs/filesystem.h>
#include <kpmcore/util/report.h>
MoveFileSystemJob::MoveFileSystemJob( Device* device, Partition* partition, qint64 oldFirstSector, qint64 newFirstSector, qint64 length )
: PartitionJob( partition )
, m_device( device )
, m_oldFirstSector( oldFirstSector )
, m_newFirstSector( newFirstSector )
, m_length( length )
{}
QString
MoveFileSystemJob::prettyName() const
{
return tr( "Move file system of partition %1." ).arg( partition()->partitionPath() );
}
Calamares::JobResult
MoveFileSystemJob::exec()
{
Report report( nullptr );
QString partitionPath = partition()->partitionPath();
CopySourceDevice moveSource( *m_device, m_oldFirstSector, m_oldFirstSector + m_length - 1 );
CopyTargetDevice moveTarget( *m_device, m_newFirstSector, m_newFirstSector + m_length - 1 );
if ( !moveSource.open() )
return Calamares::JobResult::error(
QString(),
tr( "Could not open file system on partition %1 for moving." ).arg( partitionPath )
);
if ( !moveTarget.open() )
return Calamares::JobResult::error(
QString(),
tr( "Could not create target for moving file system on partition %1." ).arg( partitionPath )
);
bool ok = copyBlocks( report, moveTarget, moveSource );
if ( !ok )
{
if ( rollbackCopyBlocks( report, moveTarget, moveSource ) )
return Calamares::JobResult::error(
QString(),
tr( "Moving of partition %1 failed, changes have been rolled back." ).arg( partitionPath )
+ '\n' + report.toText()
);
else
return Calamares::JobResult::error(
QString(),
tr( "Moving of partition %1 failed. Roll back of the changes have failed." ).arg( partitionPath )
+ '\n' + report.toText()
);
}
FileSystem& fs = partition()->fileSystem();
fs.setFirstSector( m_newFirstSector );
fs.setLastSector( m_newFirstSector + m_length - 1 );
if ( !fs.updateBootSector( report, partitionPath ) )
return Calamares::JobResult::error(
QString(),
tr( "Updating boot sector after the moving of partition %1 failed." ).arg( partitionPath )
+ '\n' + report.toText()
);
return Calamares::JobResult::ok();
}
bool
MoveFileSystemJob::copyBlocks( Report& report, CopyTargetDevice& target, CopySourceDevice& source )
{
/** @todo copyBlocks() assumes that source.sectorSize() == target.sectorSize(). */
if ( source.sectorSize() != target.sectorSize() )
{
report.line() << tr( "The logical sector sizes in the source and target for copying are not the same. This is currently unsupported." );
return false;
}
bool rval = true;
const qint64 blockSize = 16065 * 8; // number of sectors per block to copy
const qint64 blocksToCopy = source.length() / blockSize;
qint64 readOffset = source.firstSector();
qint64 writeOffset = target.firstSector();
qint32 copyDir = 1;
if ( target.firstSector() > source.firstSector() )
{
readOffset = source.firstSector() + source.length() - blockSize;
writeOffset = target.firstSector() + source.length() - blockSize;
copyDir = -1;
}
qint64 blocksCopied = 0;
Q_ASSERT( blockSize > 0 );
Q_ASSERT( source.sectorSize() > 0 );
Q_ASSERT( blockSize * source.sectorSize() > 0 );
void* buffer = malloc( size_t( blockSize * source.sectorSize() ) );
qint64 percent = 0;
while ( blocksCopied < blocksToCopy )
{
rval = source.readSectors( buffer, readOffset + blockSize * blocksCopied * copyDir, blockSize );
if ( !rval )
break;
rval = target.writeSectors( buffer, writeOffset + blockSize * blocksCopied * copyDir, blockSize );
if ( !rval )
break;
if ( ++blocksCopied * 100 / blocksToCopy != percent )
{
percent = blocksCopied * 100 / blocksToCopy;
progress( percent / 100. );
}
}
const qint64 lastBlock = source.length() % blockSize;
// copy the remainder
if ( rval && lastBlock > 0 )
{
Q_ASSERT( lastBlock < blockSize );
const qint64 lastBlockReadOffset = copyDir > 0 ? readOffset + blockSize * blocksCopied : source.firstSector();
const qint64 lastBlockWriteOffset = copyDir > 0 ? writeOffset + blockSize * blocksCopied : target.firstSector();
rval = source.readSectors( buffer, lastBlockReadOffset, lastBlock );
if ( rval )
rval = target.writeSectors( buffer, lastBlockWriteOffset, lastBlock );
if ( rval )
emit progress( 1.0 );
}
free( buffer );
return rval;
}
bool
MoveFileSystemJob::rollbackCopyBlocks( Report& report, CopyTargetDevice& origTarget, CopySourceDevice& origSource )
{
if ( !origSource.overlaps( origTarget ) )
{
report.line() << tr( "Source and target for copying do not overlap: Rollback is not required." );
return true;
}
// default: use values as if we were copying from front to back.
qint64 undoSourceFirstSector = origTarget.firstSector();
qint64 undoSourceLastSector = origTarget.firstSector() + origTarget.sectorsWritten() - 1;
qint64 undoTargetFirstSector = origSource.firstSector();
qint64 undoTargetLastSector = origSource.firstSector() + origTarget.sectorsWritten() - 1;
if ( origTarget.firstSector() > origSource.firstSector() )
{
// we were copying from back to front
undoSourceFirstSector = origTarget.firstSector() + origSource.length() - origTarget.sectorsWritten();
undoSourceLastSector = origTarget.firstSector() + origSource.length() - 1;
undoTargetFirstSector = origSource.lastSector() - origTarget.sectorsWritten() + 1;
undoTargetLastSector = origSource.lastSector();
}
CopySourceDevice undoSource( origTarget.device(), undoSourceFirstSector, undoSourceLastSector );
if ( !undoSource.open() )
{
report.line() << tr( "Could not open device %1 to rollback copying." )
.arg( origTarget.device().deviceNode() );
return false;
}
CopyTargetDevice undoTarget( origSource.device(), undoTargetFirstSector, undoTargetLastSector );
if ( !undoTarget.open() )
{
report.line() << tr( "Could not open device %1 to rollback copying." )
.arg( origSource.device().deviceNode() );
return false;
}
return copyBlocks( report, undoTarget, undoSource );
}

76
src/modules/partition/jobs/MoveFileSystemJob.h
View File

@ -1,76 +0,0 @@
/* === This file is part of Calamares - <http://github.com/calamares> ===
*
* Copyright 2014, Aurélien Gâteau <agateau@kde.org>
*
* Calamares is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Calamares is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Calamares. If not, see <http://www.gnu.org/licenses/>.
*/
// This class is heavily based on the MoveFileSystemJob class from KDE Partition
// Manager. Original copyright follow:
/***************************************************************************
* Copyright (C) 2008 by Volker Lanz <vl@fidra.de> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA *
***************************************************************************/
#ifndef MOVEFILESYSTEMJOB_H
#define MOVEFILESYSTEMJOB_H
#include <jobs/PartitionJob.h>
class CopySourceDevice;
class CopyTargetDevice;
class Device;
class Partition;
class Report;
/**
* This job moves the data of a filesystem from one position on the disk to
* another.
*
* It is used by the ResizePartitionJob.
*/
class MoveFileSystemJob : public PartitionJob
{
Q_OBJECT
public:
MoveFileSystemJob( Device* device, Partition* partition, qint64 oldFirstSector, qint64 newFirstSector, qint64 length );
QString prettyName() const override;
Calamares::JobResult exec() override;
private:
Device* m_device;
qint64 m_oldFirstSector;
qint64 m_newFirstSector;
qint64 m_length;
bool copyBlocks( Report& report, CopyTargetDevice& target, CopySourceDevice& source );
bool rollbackCopyBlocks( Report& report, CopyTargetDevice& origTarget, CopySourceDevice& origSource );
};
#endif /* MOVEFILESYSTEMJOB_H */

246
src/modules/partition/jobs/ResizePartitionJob.cpp
View File

@ -2,6 +2,7 @@
*
* Copyright 2014, Aurélien Gâteau <agateau@kde.org>
* Copyright 2015, Teo Mrnjavac <teo@kde.org>
* Copyright 2017, Andrius Štikonas <andrius@stikonas.eu>
*
* Calamares is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
@ -17,156 +18,12 @@
* along with Calamares. If not, see <http://www.gnu.org/licenses/>.
*/
// This class is heavily based on the ResizeOperation class from KDE Partition
// Manager. Original copyright follow:
/***************************************************************************
* Copyright (C) 2008,2012 by Volker Lanz <vl@fidra.de> *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA *
***************************************************************************/
#include "jobs/ResizePartitionJob.h"
#include "jobs/CheckFileSystemJob.h"
#include "jobs/MoveFileSystemJob.h"
#include "utils/Logger.h"
// KPMcore
#include <kpmcore/backend/corebackend.h>
#include <kpmcore/backend/corebackendmanager.h>
#include <kpmcore/backend/corebackenddevice.h>
#include <kpmcore/backend/corebackendpartition.h>
#include <kpmcore/backend/corebackendpartitiontable.h>
#include <kpmcore/core/device.h>
#include <kpmcore/core/partition.h>
#include <kpmcore/util/report.h>
// Qt
#include <QScopedPointer>
//- ResizeFileSystemJob --------------------------------------------------------
class ResizeFileSystemJob : public Calamares::Job
{
Q_OBJECT
public:
ResizeFileSystemJob( Device* device, CoreBackendPartitionTable* backendPartitionTable, Partition* partition, qint64 length )
: m_device( device )
, m_backendPartitionTable( backendPartitionTable )
, m_partition( partition )
, m_length( length )
{}
QString prettyName() const override
{
QString path = m_partition->partitionPath();
return tr( "Resize file system on partition %1." ).arg( path );
}
Calamares::JobResult exec() override
{
Report report( nullptr );
FileSystem& fs = m_partition->fileSystem();
FileSystem::CommandSupportType support = m_length < fs.length() ? fs.supportShrink() : fs.supportGrow();
switch ( support )
{
case FileSystem::cmdSupportBackend:
if ( !backendResize( &report ) )
return Calamares::JobResult::error(
QString(),
tr( "Parted failed to resize filesystem." ) + '\n' + report.toText()
);
break;
case FileSystem::cmdSupportFileSystem:
{
qint64 byteLength = m_device->logicalSize() * m_length;
bool ok = fs.resize( report, m_partition->partitionPath(), byteLength );
if ( !ok )
return Calamares::JobResult::error(
QString(),
tr( "Failed to resize filesystem." ) + '\n' + report.toText()
);
break;
}
default:
break;
}
fs.setLastSector( fs.firstSector() + m_length - 1 );
return Calamares::JobResult::ok();
}
private:
Device* m_device;
CoreBackendPartitionTable* m_backendPartitionTable;
Partition* m_partition;
qint64 m_length;
bool backendResize( Report* report )
{
bool ok = m_backendPartitionTable->resizeFileSystem( *report, *m_partition, m_length );
if ( !ok )
return false;
m_backendPartitionTable->commit();
return true;
}
};
//- SetPartGeometryJob ---------------------------------------------------------
class SetPartGeometryJob : public Calamares::Job
{
Q_OBJECT
public:
SetPartGeometryJob( CoreBackendPartitionTable* backendPartitionTable, Partition* partition, qint64 firstSector, qint64 length )
: m_backendPartitionTable( backendPartitionTable )
, m_partition( partition )
, m_firstSector( firstSector )
, m_length( length )
{}
QString prettyName() const override
{
QString path = m_partition->partitionPath();
return tr( "Update geometry of partition %1." ).arg( path );
}
Calamares::JobResult exec() override
{
Report report( nullptr );
qint64 lastSector = m_firstSector + m_length - 1;
bool ok = m_backendPartitionTable->updateGeometry( report, *m_partition, m_firstSector, lastSector );
if ( !ok )
{
return Calamares::JobResult::error(
QString(),
tr( "Failed to change the geometry of the partition." ) + '\n' + report.toText() );
}
m_partition->setFirstSector( m_firstSector );
m_partition->setLastSector( lastSector );
m_backendPartitionTable->commit();
return Calamares::JobResult::ok();
}
private:
CoreBackendPartitionTable* m_backendPartitionTable;
Partition* m_partition;
qint64 m_firstSector;
qint64 m_length;
};
#include <core/device.h>
#include <ops/resizeoperation.h>
#include <util/report.h>
//- ResizePartitionJob ---------------------------------------------------------
ResizePartitionJob::ResizePartitionJob( Device* device, Partition* partition, qint64 firstSector, qint64 lastSector )
@ -205,7 +62,7 @@ ResizePartitionJob::prettyStatusMessage() const
return tr( "Resizing %2MB partition %1 to "
"%3MB." )
.arg( partition()->partitionPath() )
.arg( ( m_oldLastSector - m_oldFirstSector ) * partition()->sectorSize() / 1024 / 1024 )
.arg( ( m_oldLastSector - m_oldFirstSector + 1 ) * partition()->sectorSize() / 1024 / 1024 )
.arg( ( m_newLastSector - m_newFirstSector + 1 ) * partition()->sectorSize() / 1024 / 1024 );
}
@ -213,64 +70,21 @@ ResizePartitionJob::prettyStatusMessage() const
Calamares::JobResult
ResizePartitionJob::exec()
{
qint64 oldLength = m_oldLastSector - m_oldFirstSector + 1;
qint64 newLength = m_newLastSector - m_newFirstSector + 1;
// Assuming updatePreview() has been called, `partition` uses its new
// position and size. Reset it to the old values: part of the libparted
// backend relies on this (for example:
// LibPartedPartitionTable::updateGeometry())
// The jobs are responsible for updating the partition back when they are
// done.
Report report (nullptr);
// Restore partition sectors that were modified for preview
m_partition->setFirstSector( m_oldFirstSector );
m_partition->setLastSector( m_oldLastSector );
ResizeOperation op(*m_device, *m_partition, m_newFirstSector, m_newLastSector);
op.setStatus(Operation::StatusRunning);
connect(&op, &Operation::progress, [&](int percent) { emit progress(percent / 100.0); } );
CoreBackend* backend = CoreBackendManager::self()->backend();
QScopedPointer<CoreBackendDevice> backendDevice( backend->openDevice( m_device->deviceNode() ) );
if ( !backendDevice.data() )
{
QString errorMessage = tr( "The installer failed to resize partition %1 on disk '%2'." )
.arg( m_partition->partitionPath() )
.arg( m_device->name() );
return Calamares::JobResult::error(
errorMessage,
tr( "Could not open device '%1'." ).arg( m_device->deviceNode() )
);
}
QScopedPointer<CoreBackendPartitionTable> backendPartitionTable( backendDevice->openPartitionTable() );
QString errorMessage = tr( "The installer failed to resize partition %1 on disk '%2'." )
.arg( m_partition->partitionPath() )
.arg( m_device->name() );
if (op.execute(report))
return Calamares::JobResult::ok();
// Create jobs
QList< Calamares::job_ptr > jobs;
jobs << Calamares::job_ptr( new CheckFileSystemJob( partition() ) );
if ( m_partition->roles().has( PartitionRole::Extended ) )
jobs << Calamares::job_ptr( new SetPartGeometryJob( backendPartitionTable.data(), m_partition, m_newFirstSector, newLength ) );
else
{
bool shrink = newLength < oldLength;
bool grow = newLength > oldLength;
bool moveRight = m_newFirstSector > m_oldFirstSector;
bool moveLeft = m_newFirstSector < m_oldFirstSector;
if ( shrink )
{
jobs << Calamares::job_ptr( new ResizeFileSystemJob( m_device, backendPartitionTable.data(), m_partition, newLength ) );
jobs << Calamares::job_ptr( new SetPartGeometryJob( backendPartitionTable.data(), m_partition, m_oldFirstSector, newLength ) );
}
if ( moveRight || moveLeft )
{
// At this point, we need to set the partition's length to either the resized length, if it has already been
// shrunk, or to the original length (it may or may not then later be grown, we don't care here)
const qint64 length = shrink ? newLength : oldLength;
jobs << Calamares::job_ptr( new SetPartGeometryJob( backendPartitionTable.data(), m_partition, m_newFirstSector, length ) );
jobs << Calamares::job_ptr( new MoveFileSystemJob( m_device, m_partition, m_oldFirstSector, m_newFirstSector, length ) );
}
if ( grow )
{
jobs << Calamares::job_ptr( new SetPartGeometryJob( backendPartitionTable.data(), m_partition, m_newFirstSector, newLength ) );
jobs << Calamares::job_ptr( new ResizeFileSystemJob( m_device, backendPartitionTable.data(), m_partition, newLength ) );
}
}
jobs << Calamares::job_ptr( new CheckFileSystemJob( partition() ) );
return execJobList( jobs );
return Calamares::JobResult::error(errorMessage, report.toText());
}
void
@ -290,31 +104,3 @@ ResizePartitionJob::device() const
{
return m_device;
}
Calamares::JobResult
ResizePartitionJob::execJobList( const QList< Calamares::job_ptr >& jobs )
{
QString errorMessage = tr( "The installer failed to resize partition %1 on disk '%2'." )
.arg( m_partition->partitionPath() )
.arg( m_device->name() );
int nbJobs = jobs.size();
int count = 0;
for ( Calamares::job_ptr job : jobs )
{
cLog() << "- " + job->prettyName();
Calamares::JobResult result = job->exec();
if ( !result )
{
if ( result.message().isEmpty() )
result.setMessage( errorMessage );
return result;
}
++count;
progress( qreal( count ) / nbJobs );
}
return Calamares::JobResult::ok();
}
#include "ResizePartitionJob.moc"

2
src/modules/partition/jobs/ResizePartitionJob.h
View File

@ -51,8 +51,6 @@ private:
qint64 m_oldLastSector;
qint64 m_newFirstSector;
qint64 m_newLastSector;
Calamares::JobResult execJobList( const QList< Calamares::job_ptr >& jobs );
};
#endif /* RESIZEPARTITIONJOB_H */

2
src/modules/partition/tests/CMakeLists.txt
View File

@ -9,11 +9,9 @@ set( partitionjobtests_SRCS
${PartitionModule_SOURCE_DIR}/core/KPMHelpers.cpp
${PartitionModule_SOURCE_DIR}/core/PartitionInfo.cpp
${PartitionModule_SOURCE_DIR}/core/PartitionIterator.cpp
${PartitionModule_SOURCE_DIR}/jobs/CheckFileSystemJob.cpp
${PartitionModule_SOURCE_DIR}/jobs/CreatePartitionJob.cpp
${PartitionModule_SOURCE_DIR}/jobs/CreatePartitionTableJob.cpp
${PartitionModule_SOURCE_DIR}/jobs/DeletePartitionJob.cpp
${PartitionModule_SOURCE_DIR}/jobs/MoveFileSystemJob.cpp
${PartitionModule_SOURCE_DIR}/jobs/PartitionJob.cpp
${PartitionModule_SOURCE_DIR}/jobs/ResizePartitionJob.cpp
PartitionJobTests.cpp