void SettingsTest::testUpgrade_data(){
// Read recipe
QFile recipe(":/testdata/upgrade/recipe");
QVERIFY(recipe.open(QIODevice::ReadOnly));
QList<UpgradeTestHelper::TestCase> testCases = UpgradeTestHelper::readRecipe(&recipe);
// Generate settings file according to recipe
QTemporaryFile settingsFile;
QVERIFY(settingsFile.open() == true);
QSettings settings(settingsFile.fileName(), QSettings::IniFormat);
UpgradeTestHelper::fillSettings(&settings, testCases);
// Generate defaults file according to recipe
QTemporaryFile defaultSettingsFile;
QVERIFY(defaultSettingsFile.open() == true);
QSettings defaultSettings(defaultSettingsFile.fileName(), QSettings::IniFormat);
UpgradeTestHelper::fillDefaultSettings(&defaultSettings, testCases);
// Parse settings -- do upgrade
#if 0
settingsFile.seek(0);
defaultSettingsFile.seek(0);
qDebug() << "SETTINGS {{{\n" << settingsFile.readAll() << "\n}}}";
qDebug() << "DEFAULT SETTINGS {{{\n" << defaultSettingsFile.readAll() << "\n}}}";
#endif
SsuSettings ssuSettings(settingsFile.fileName(), QSettings::IniFormat,
defaultSettingsFile.fileName());
#if 0
settingsFile.seek(0);
qDebug() << "SETTINGS UPGRADED {{{\n" << settingsFile.readAll() << "\n}}}";
#endif
// Record data for verification phase
QTest::addColumn<bool>("keyIsSet");
QTest::addColumn<bool>("keyShouldBeSet");
QTest::addColumn<QString>("actualValue");
QTest::addColumn<QString>("expectedValue");
foreach (const UpgradeTestHelper::TestCase &testCase, testCases){
foreach (const QString &group, UpgradeTestHelper::groups()){
const QString key = group.isEmpty() ? testCase.key() : group + '/' + testCase.key();
QTest::newRow(qPrintable(QString("%1%2:%3:%4")
.arg(group.isEmpty() ? "" : group + "/")
.arg(testCase.history())
.arg(testCase.current())
.arg(testCase.expected())))
<< ssuSettings.contains(key)
<< testCase.keyShouldBeSet()
<< ssuSettings.value(key).toString()
<< testCase.expected();
}
}
void ClippingConverter::convert(const QByteArray &clippingData, const QString &directory)
{
QDataStream stream(clippingData);
stream.setFloatingPointPrecision(QDataStream::SinglePrecision);
stream.setByteOrder(QDataStream::LittleEndian);
QString newDirectory = directory;
newDirectory.replace('\\', '/');
if (!newDirectory.endsWith('/'))
newDirectory.append('/');
int objectCount, instanceCount;
stream >> objectCount >> instanceCount;
for (int i = 0; i < objectCount; ++i) {
MeshPtr mesh = importObject(stream);
// Serialize to a temporary file, then read it in again
QTemporaryFile tempFile;
if (!tempFile.open()) {
qWarning("Unable to open the temporary %s file.", qPrintable(tempFile.fileName()));
continue;
}
d->ogre->meshSerializer->exportMesh(mesh.getPointer(), tempFile.fileName().toStdString());
QByteArray meshData = tempFile.readAll();
QString meshFilename = QString("%1clipping/mesh-%2.mesh").arg(newDirectory).arg(i+1);
d->output->writeFile(meshFilename, meshData);
}
QByteArray instances;
instances.append("[");
for (int i = 0; i < instanceCount; ++i) {
QVector4D position;
int index;
stream >> position >> index;
QString line = QString("{\"position\":[%1,%2,%3],\"file\":\"%5mesh-%4.mesh\"}")
.arg(position.x())
.arg(position.y())
.arg(position.z())
.arg(index+1)
.arg(newDirectory);
if (i > 0)
instances.append(",");
instances.append(line.toAscii());
}
instances.append("]");
d->output->writeFile(newDirectory + "clipping.json", instances);
}
QString WebPuppeteerTab::printBase64() {
QTemporaryFile t;
if (!t.open()) return QString();
if (!print(t.fileName())) return QString();
QByteArray data = t.readAll();
t.remove();
return QString::fromLatin1(data.toBase64());
}
bool STTY::findExternalTTY(const QString& termApp)
{
QString appName(termApp.isEmpty() ? QString("xterm") : termApp);
if (QStandardPaths::findExecutable(appName).isEmpty()) {
m_lastError = i18n("%1 is incorrect terminal name", termApp);
return false;
}
QTemporaryFile file;
if (!file.open()) {
m_lastError = i18n("Can't create a temporary file");
return false;
}
m_externalTerminal.reset(new QProcess(this));
if (appName == "konsole") {
m_externalTerminal->start(appName, QStringList() << "-e" << "sh" << "-c" << "tty>" + file.fileName() + ";exec<&-;exec>&-;while :;do sleep 3600;done");
} else if (appName == "xfce4-terminal") {
m_externalTerminal->start(appName, QStringList() << "-e" << " sh -c \"tty>" + file.fileName() + ";\"\"<&\\-\"\">&\\-;\"\"while :;\"\"do sleep 3600;\"\"done\"");
} else {
m_externalTerminal->start(appName, QStringList() << "-e" << "sh -c \"tty>" + file.fileName() + ";exec<&-;exec>&-;while :;do sleep 3600;done\"");
}
if (!m_externalTerminal->waitForStarted(500)) {
m_lastError = "Can't run terminal: " + appName;
m_externalTerminal->terminate();
return false;
}
for (int i = 0; i < 800; i++) {
if (!file.bytesAvailable()) {
if (m_externalTerminal->state() == QProcess::NotRunning && m_externalTerminal->exitCode()) {
break;
}
QCoreApplication::processEvents(QEventLoop::AllEvents, 100);
usleep(8000);
} else {
qCDebug(DEBUGGERCOMMON) << "Received terminal output(tty)";
break;
}
}
usleep(1000);
ttySlave = file.readAll().trimmed();
file.close();
if (ttySlave.isEmpty()) {
m_lastError = i18n("Can't receive %1 tty/pty. Check that %1 is actually a terminal and that it accepts these arguments: -e sh -c \"tty> %2 ;exec<&-;exec>&-;while :;do sleep 3600;done\"", appName, file.fileName());
}
return true;
}
void ExternalWriterTest::test()
{
QTemporaryFile file;
QScopedPointer<WriterPlugin> plugin(
new ExternalWriter(testFilePath("testexternalwriter")
));
file.open();
WriteData data(file.fileName(), "application/text");
plugin->write(data);
QCOMPARE(QString(file.readAll()), QStringLiteral("{}"));
}
void ZynAddSubFxInstrument::saveSettings( QDomDocument & _doc,
QDomElement & _this )
{
m_portamentoModel.saveSettings( _doc, _this, "portamento" );
m_filterFreqModel.saveSettings( _doc, _this, "filterfreq" );
m_filterQModel.saveSettings( _doc, _this, "filterq" );
m_bandwidthModel.saveSettings( _doc, _this, "bandwidth" );
m_fmGainModel.saveSettings( _doc, _this, "fmgain" );
m_resCenterFreqModel.saveSettings( _doc, _this, "rescenterfreq" );
m_resBandwidthModel.saveSettings( _doc, _this, "resbandwidth" );
QString modifiedControllers;
for( QMap<int, bool>::ConstIterator it = m_modifiedControllers.begin();
it != m_modifiedControllers.end(); ++it )
{
if( it.value() )
{
modifiedControllers += QString( "%1," ).arg( it.key() );
}
}
_this.setAttribute( "modifiedcontrollers", modifiedControllers );
m_forwardMidiCcModel.saveSettings( _doc, _this, "forwardmidicc" );
QTemporaryFile tf;
if( tf.open() )
{
const std::string fn = QSTR_TO_STDSTR(
QDir::toNativeSeparators( tf.fileName() ) );
m_pluginMutex.lock();
if( m_remotePlugin )
{
m_remotePlugin->lock();
m_remotePlugin->sendMessage( RemotePlugin::message( IdSaveSettingsToFile ).addString( fn ) );
m_remotePlugin->waitForMessage( IdSaveSettingsToFile );
m_remotePlugin->unlock();
}
else
{
m_plugin->saveXML( fn );
}
m_pluginMutex.unlock();
QByteArray a = tf.readAll();
QDomDocument doc( "mydoc" );
if( doc.setContent( a ) )
{
QDomNode n = _doc.importNode( doc.documentElement(), true );
_this.appendChild( n );
}
}
}
void RPCServer::sendOptions(quint64 client){
QTemporaryFile file;
if (file.open()) {
file.close();
write_options_file(file.fileName().toAscii().constData());
file.open();
QByteArray optionsString = file.readAll();
qDebug("Read %d bytes in the configuration file",optionsString.size());
call(client,QString("sendOptions(QByteArray)"),optionsString);
sendInputImages(client);
}else{
qDebug("RPCServer: Failed to create temporary file!");
return;
}
}
bool SxVersionedFile::checkInHead( QFile *file, QDir *history)
{
QMap<QString,QVariant> props;
QByteArray data;
QFile revFile( makeVersionName( history, 0) );
if( revFile.exists () )
{
// Build patch
if( !revFile.open(QIODevice::ReadWrite) )
return false;
// Diff current file and revFile. save patch as rev + 1;
qDebug() << "Diff" << revFile.fileName();
QTemporaryFile patch;
patch.open();
m_versionUtils.diffQFiles( file, &revFile, &patch );
QMap<QString,QVariant> props = getHeadProps( history);
QString revName = makeNextVersionName( history );
qDebug() << "Write to" << revName;
QFile rev( revName );
if( !rev.open(QIODevice::WriteOnly) )
return false;
QDataStream outputStream( &rev );
patch.seek(0);
outputStream << props << patch.readAll();
rev.close();
patch.close();
revFile.close();
}
if( !revFile.open(QIODevice::ReadWrite) )
return false;
QDataStream outputStream( &revFile );
quint64 origPos = file->pos();
file->seek(0);
outputStream << metaInfo() << file->readAll();
file->seek(origPos);
revFile.close();
return true;
}
QByteArray VstPlugin::saveChunk()
{
QByteArray a;
QTemporaryFile tf;
if( tf.open() )
{
lock();
sendMessage( message( IdSaveSettingsToFile ).
addString(
QSTR_TO_STDSTR(
QDir::toNativeSeparators( tf.fileName() ) ) ) );
waitForMessage( IdSaveSettingsToFile, true );
unlock();
a = tf.readAll();
}
return a;
}
//checks if load/saving preserves encoding and line endings
void QEditorTest::loadSave(){
QFETCH(QString, outCodecName);
QFETCH(QString, outLineEnding);
QFETCH(bool, autodetect);
QTextCodec* outCodec=QTextCodec::codecForName(qPrintable(outCodecName));
if (outCodecName=="latin1") outCodec = defaultCodec;
if (!allTests) {
qDebug("skipped load save test");
return;
}
const QString testText = QString::fromLatin1("hallo\n\xE4\xF6\xFC\n");
QString testTextWithLineEndings=testText;
testTextWithLineEndings.replace("\n",outLineEnding);
QTemporaryFile tf;//uncomment if you need to look at the files &tf=*(new QTemporaryFile);
tf.open();
QString tfn=tf.fileName();
tf.write(outCodec->fromUnicode(testTextWithLineEndings));
tf.close();
//Load
editor->setFileCodec(QTextCodec::codecForName("iso-8859-5"));
editor->load(tfn,autodetect?0:outCodec);
editor->document()->setLineEnding(editor->document()->originalLineEnding()); //TODO: find out why this line is only needed iff the editor passed by the testmanager is used and not if a new QEditor(0) is created
QEQUAL2(editor->document()->text(),testTextWithLineEndings,QString("File: %1 Got file codec: %2 ").arg(tfn).arg(editor->getFileCodec()?QString::fromAscii(editor->getFileCodec()->name()):"<null>"));
QVERIFY2(editor->getFileCodec()==outCodec,qPrintable(QString("wrong encoding: got %1 wanted %2 by the sheriff %3").arg(QString::fromAscii(editor->getFileCodec()->name())).arg(QString::fromAscii(outCodec->name())).arg(autodetect)));
QEQUAL(editor->document()->lineEndingString(),outLineEnding);
//Save
editor->setText(editor->document()->text()+"Save test", false);
editor->save();
tf.open();
QString writtenText=outCodec->toUnicode( tf.readAll());
tf.close();
QEQUAL2(writtenText, testTextWithLineEndings+"Save test", "file text check, file:"+tfn);
QVERIFY2(writtenText.contains(outLineEnding), qPrintable("file don't contain right line ending, file"+tfn));
editor->setFileName(""); //reset filename so it won't get panically if the file is deleted
editor->document()->setLineEnding(QDocument::Conservative); //reset line ending so we won't screw up the other tests
}
void BootloaderInstallHex::installStage2(void)
{
emit logItem(tr("Adding bootloader to firmware file"), LOGINFO);
QCoreApplication::processEvents();
// local temp file
QTemporaryFile tempbin;
tempbin.open();
QString tempbinName = tempbin.fileName();
tempbin.close();
// get temporary files filenames -- external tools need this.
m_descrambled.open();
QString descrambledName = m_descrambled.fileName();
m_descrambled.close();
m_tempfile.open();
QString tempfileName = m_tempfile.fileName();
m_tempfile.close();
int origin = 0;
switch(m_model) {
case 3:
origin = 0x3f0000;
break;
case 2:
case 1:
origin = 0x1f0000;
break;
default:
origin = 0;
break;
}
// iriver decode already done in stage 1
int result;
if((result = mkboot_iriver(descrambledName.toLocal8Bit().constData(),
tempfileName.toLocal8Bit().constData(),
tempbinName.toLocal8Bit().constData(), origin)) < 0)
{
QString error;
switch(result) {
case -1: error = tr("could not open input file"); break;
case -2: error = tr("reading header failed"); break;
case -3: error = tr("reading firmware failed"); break;
case -4: error = tr("can't open bootloader file"); break;
case -5: error = tr("reading bootloader file failed"); break;
case -6: error = tr("can't open output file"); break;
case -7: error = tr("writing output file failed"); break;
}
emit logItem(tr("Error in patching: %1").arg(error), LOGERROR);
emit done(true);
return;
}
QTemporaryFile targethex;
targethex.open();
QString targethexName = targethex.fileName();
if((result = iriver_encode(tempbinName.toLocal8Bit().constData(),
targethexName.toLocal8Bit().constData(), FALSE)) < 0)
{
emit logItem(tr("Error in scramble: %1").arg(scrambleError(result)), LOGERROR);
targethex.close();
emit done(true);
return;
}
// finally check the md5sum of the created file
QByteArray filedata;
filedata = targethex.readAll();
targethex.close();
QString hash = QCryptographicHash::hash(filedata,
QCryptographicHash::Md5).toHex();
qDebug() << "[BootloaderInstallHex] created hexfile hash:" << hash;
emit logItem(tr("Checking modified firmware file"), LOGINFO);
if(hash != QString(md5sums[m_hashindex].patched)) {
emit logItem(tr("Error: modified file checksum wrong"), LOGERROR);
targethex.remove();
emit done(true);
return;
}
// finally copy file to player
targethex.copy(m_blfile);
emit logItem(tr("Success: modified firmware file created"), LOGINFO);
logInstall(LogAdd);
emit done(false);
return;
}
QString ExportHelper::XSLTConvertString(QString input, int xsltmapid, QString &errmsg)
{
if (DEBUG)
qDebug("ExportHelper::XSLTConvertString(%s..., %d, errmsg) entered",
qPrintable(input.left(200)), xsltmapid);
QString returnVal;
XSqlQuery xsltq;
xsltq.prepare("SELECT xsltmap_name, xsltmap_export"
" FROM xsltmap"
" WHERE xsltmap_id=:id;");
xsltq.bindValue(":id", xsltmapid);
xsltq.exec();
if (xsltq.first())
{
/* tempfile handling is messy because windows doesn't handle them as you
might expect.
TODO: find a simpler way
*/
QString xsltmap = xsltq.value("xsltmap_name").toString();
QTemporaryFile *inputfile = new QTemporaryFile(QDir::tempPath()
+ QDir::separator()
+ xsltmap
+ "Input.XXXXXX.xml");
inputfile->setAutoRemove(false);
if (! inputfile->open())
errmsg = tr("Could not open temporary input file (%1).")
.arg(inputfile->error());
else
{
QString inputfileName = inputfile->fileName();
inputfile->write(input.toUtf8());
inputfile->close();
delete inputfile;
inputfile = 0;
QTemporaryFile *outputfile = new QTemporaryFile(QDir::tempPath()
+ QDir::separator()
+ xsltmap
+ "Output.XXXXXX.xml");
outputfile->setAutoRemove(false);
if (! outputfile->open())
errmsg = tr("Could not open temporary output file (%1).")
.arg(outputfile->error());
else
{
QString outputfileName = outputfile->fileName();
if (DEBUG)
qDebug("ExportHelper::XSLTConvertString writing from %s to %s",
qPrintable(inputfileName), qPrintable(outputfileName));
if (XSLTConvertFile(inputfileName, outputfileName,
xsltq.value("xsltmap_export").toString(), errmsg))
returnVal = outputfile->readAll();
outputfile->close();
delete outputfile;
outputfile = 0;
if (errmsg.isEmpty())
{
QFile::remove(outputfileName);
QFile::remove(inputfileName);
}
}
}
}
else if (xsltq.lastError().type() != QSqlError::NoError)
errmsg = xsltq.lastError().text();
else
errmsg = tr("Could not find XSLT mapping with internal id %1.")
.arg(xsltmapid);
if (! errmsg.isEmpty())
qWarning("%s", qPrintable(errmsg));
return returnVal;
}
void OscapScannerLocal::evaluate()
{
if (mDryRun)
{
signalCompletion(mCancelRequested);
return;
}
emit infoMessage(QObject::tr("Querying capabilities..."));
try
{
fillInCapabilities();
}
catch (std::exception& e)
{
emit errorMessage(e.what());
return;
}
if (!checkPrerequisites())
{
mCancelRequested = true;
signalCompletion(mCancelRequested);
return;
}
// TODO: Error handling!
// This is mainly for check-engine-results and oval-results, to ensure
// we get a full report, including info from these files. openscap's XSLT
// uses info in the check engine results if it can find them.
QProcess process(this);
emit infoMessage(QObject::tr("Creating temporary files..."));
// This is mainly for check-engine-results and oval-results, to ensure
// we get a full report, including info from these files. openscap's XSLT
// uses info in the check engine results if it can find them.
TemporaryDir workingDir;
process.setWorkingDirectory(workingDir.getPath());
QStringList args;
QTemporaryFile inputARFFile;
QTemporaryFile arfFile;
arfFile.setAutoRemove(true);
setFilenameToTempFile(arfFile);
QTemporaryFile reportFile;
reportFile.setAutoRemove(true);
setFilenameToTempFile(reportFile);
QTemporaryFile resultFile;
resultFile.setAutoRemove(true);
setFilenameToTempFile(resultFile);
if (mScannerMode == SM_OFFLINE_REMEDIATION)
{
inputARFFile.open();
inputARFFile.write(getARFForRemediation());
inputARFFile.close();
args = buildOfflineRemediationArgs(inputARFFile.fileName(),
resultFile.fileName(),
reportFile.fileName(),
arfFile.fileName());
}
else
{
args = buildEvaluationArgs(mSession->getOpenedFilePath(),
mSession->hasTailoring() ? mSession->getTailoringFilePath() : QString(),
resultFile.fileName(),
reportFile.fileName(),
arfFile.fileName(),
mScannerMode == SM_SCAN_ONLINE_REMEDIATION);
}
QString program = getOscapProgramAndAdaptArgs(args);
emit infoMessage(QObject::tr("Starting the oscap process..."));
process.start(program, args);
process.waitForStarted();
if (process.state() != QProcess::Running)
{
emit errorMessage(QObject::tr("Failed to start local scanning process '%1'. Perhaps the executable was not found?").arg(program));
mCancelRequested = true;
}
unsigned int pollInterval = 100;
emit infoMessage(QObject::tr("Processing..."));
while (!process.waitForFinished(pollInterval))
{
// read everything new
readStdOut(process);
watchStdErr(process);
// pump the event queue, mainly because the user might want to cancel
QAbstractEventDispatcher::instance(mScanThread)->processEvents(QEventLoop::AllEvents);
if (mCancelRequested)
{
pollInterval = 1000;
emit infoMessage(QObject::tr("Cancellation was requested! Terminating scanning..."));
process.kill();
}
}
if (!mCancelRequested)
{
if (process.exitCode() == 1) // error happened
{
watchStdErr(process);
// TODO: pass the diagnostics over
emit errorMessage(QObject::tr("There was an error during evaluation! Exit code of the 'oscap' process was 1."));
// mark this run as canceled
mCancelRequested = true;
}
else
{
// read everything left over
readStdOut(process);
watchStdErr(process);
emit infoMessage(QObject::tr("The oscap tool has finished. Reading results..."));
resultFile.open();
mResults = resultFile.readAll();
resultFile.close();
reportFile.open();
mReport = reportFile.readAll();
reportFile.close();
arfFile.open();
mARF = arfFile.readAll();
arfFile.close();
emit infoMessage(QObject::tr("Processing has been finished!"));
}
}
else
{
emit infoMessage(QObject::tr("Scanning cancelled!"));
}
signalCompletion(mCancelRequested);
}
QByteArray* QgsWCSServer::getCoverage()
{
QStringList wcsLayersId = mConfigParser->wcsLayers();
QList<QgsMapLayer*> layerList;
QStringList mErrors = QStringList();
//defining coverage name
QString coveName = "";
//read COVERAGE
QMap<QString, QString>::const_iterator cove_name_it = mParameters.find( "COVERAGE" );
if ( cove_name_it != mParameters.end() )
{
coveName = cove_name_it.value();
}
if ( coveName == "" )
{
QMap<QString, QString>::const_iterator cove_name_it = mParameters.find( "IDENTIFIER" );
if ( cove_name_it != mParameters.end() )
{
coveName = cove_name_it.value();
}
}
if ( coveName == "" )
{
mErrors << QString( "COVERAGE is mandatory" );
}
layerList = mConfigParser->mapLayerFromCoverage( coveName );
if ( layerList.size() < 1 )
{
mErrors << QString( "The layer for the COVERAGE '%1' is not found" ).arg( coveName );
}
bool conversionSuccess;
// BBOX
bool bboxOk = false;
double minx = 0.0, miny = 0.0, maxx = 0.0, maxy = 0.0;
// WIDTh and HEIGHT
int width = 0, height = 0;
// CRS
QString crs = "";
// read BBOX
QMap<QString, QString>::const_iterator bbIt = mParameters.find( "BBOX" );
if ( bbIt == mParameters.end() )
{
minx = 0; miny = 0; maxx = 0; maxy = 0;
}
else
{
bboxOk = true;
QString bbString = bbIt.value();
minx = bbString.section( ",", 0, 0 ).toDouble( &conversionSuccess );
if ( !conversionSuccess ) {bboxOk = false;}
miny = bbString.section( ",", 1, 1 ).toDouble( &conversionSuccess );
if ( !conversionSuccess ) {bboxOk = false;}
maxx = bbString.section( ",", 2, 2 ).toDouble( &conversionSuccess );
if ( !conversionSuccess ) {bboxOk = false;}
maxy = bbString.section( ",", 3, 3 ).toDouble( &conversionSuccess );
if ( !conversionSuccess ) {bboxOk = false;}
}
if ( !bboxOk )
{
mErrors << QString( "The BBOX is mandatory and has to be xx.xxx,yy.yyy,xx.xxx,yy.yyy" );
}
// read WIDTH
width = mParameters.value( "WIDTH", "0" ).toInt( &conversionSuccess );
if ( !conversionSuccess )
width = 0;
// read HEIGHT
height = mParameters.value( "HEIGHT", "0" ).toInt( &conversionSuccess );
if ( !conversionSuccess )
{
height = 0;
}
if ( width < 0 || height < 0 )
{
mErrors << QString( "The WIDTH and HEIGHT are mandatory and have to be integer" );
}
crs = mParameters.value( "CRS", "" );
if ( crs == "" )
{
mErrors << QString( "The CRS is mandatory" );
}
if ( mErrors.count() != 0 )
{
throw QgsMapServiceException( "RequestNotWellFormed", mErrors.join( ". " ) );
}
QgsCoordinateReferenceSystem requestCRS = QgsCRSCache::instance()->crsByAuthId( crs );
if ( !requestCRS.isValid() )
{
mErrors << QString( "Could not create request CRS" );
throw QgsMapServiceException( "RequestNotWellFormed", mErrors.join( ". " ) );
}
QgsRectangle rect( minx, miny, maxx, maxy );
QgsMapLayer* layer = layerList.at( 0 );
QgsRasterLayer* rLayer = dynamic_cast<QgsRasterLayer*>( layer );
if ( rLayer && wcsLayersId.contains( rLayer->id() ) )
{
// RESPONSE_CRS
QgsCoordinateReferenceSystem responseCRS = rLayer->crs();
crs = mParameters.value( "RESPONSE_CRS", "" );
if ( crs != "" )
{
responseCRS = QgsCRSCache::instance()->crsByAuthId( crs );
if ( !responseCRS.isValid() )
{
responseCRS = rLayer->crs();
}
}
// transform rect
if ( requestCRS != rLayer->crs() )
{
QgsCoordinateTransform t( requestCRS, rLayer->crs() );
rect = t.transformBoundingBox( rect );
}
QTemporaryFile tempFile;
tempFile.open();
QgsRasterFileWriter fileWriter( tempFile.fileName() );
// clone pipe/provider
QgsRasterPipe* pipe = new QgsRasterPipe();
if ( !pipe->set( rLayer->dataProvider()->clone() ) )
{
mErrors << QString( "Cannot set pipe provider" );
throw QgsMapServiceException( "RequestNotWellFormed", mErrors.join( ". " ) );
}
// add projector if necessary
if ( responseCRS != rLayer->crs() )
{
QgsRasterProjector * projector = new QgsRasterProjector;
projector->setCRS( rLayer->crs(), responseCRS );
if ( !pipe->insert( 2, projector ) )
{
mErrors << QString( "Cannot set pipe projector" );
throw QgsMapServiceException( "RequestNotWellFormed", mErrors.join( ". " ) );
}
}
QgsRasterFileWriter::WriterError err = fileWriter.writeRaster( pipe, width, height, rect, responseCRS );
if ( err != QgsRasterFileWriter::NoError )
{
mErrors << QString( "Cannot write raster error code: %1" ).arg( err );
throw QgsMapServiceException( "RequestNotWellFormed", mErrors.join( ". " ) );
}
delete pipe;
QByteArray* ba = 0;
ba = new QByteArray();
*ba = tempFile.readAll();
return ba;
}
return 0;
}
bool MapnikRenderer::Preprocess( IImporter* importer, QString dir )
{
QString filename = fileInDirectory( dir, "Mapnik Renderer" );
try {
IImporter::BoundingBox box;
if ( !importer->GetBoundingBox( &box ) )
return false;
std::vector< IImporter::RoutingEdge > inputEdges;
std::vector< IImporter::RoutingNode > inputNodes;
std::vector< IImporter::RoutingNode > inputPaths;
if ( m_settings.deleteTiles ) {
if ( !importer->GetRoutingEdges( &inputEdges ) ) {
qCritical() << "Mapnik Renderer: failed to read routing edges";
return false;
}
if ( !importer->GetRoutingNodes( &inputNodes ) ) {
qCritical() << "Mapnik Renderer: failed to read routing nodes";
return false;
}
if ( !importer->GetRoutingEdgePaths( &inputPaths ) ) {
qCritical() << "Mapnik Renderer: failed to read routing paths";
}
}
Timer time;
mapnik::datasource_cache::instance().register_datasources( m_settings.plugins.toLatin1().constData() );
QDir fonts( m_settings.fonts );
mapnik::projection projection( "+proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs +over" );
mapnik::freetype_engine::register_font( fonts.filePath( "DejaVuSans.ttf" ).toLatin1().constData() );
mapnik::freetype_engine::register_font( fonts.filePath( "DejaVuSans-Bold.ttf" ).toLatin1().constData() );
mapnik::freetype_engine::register_font( fonts.filePath( "DejaVuSans-Oblique.ttf" ).toLatin1().constData() );
mapnik::freetype_engine::register_font( fonts.filePath( "DejaVuSans-BoldOblique.ttf" ).toLatin1().constData() );
qDebug() << "Mapnik Renderer: initialized mapnik connection:" << time.restart() << "ms";
int numThreads = omp_get_max_threads();
qDebug() << "Mapnik Renderer: using" << numThreads << "threads";
qDebug() << "Mapnik Renderer: x: " << box.min.x << "-" << box.max.x;
qDebug() << "Mapnik Renderer: y: " << box.min.y << "-" << box.max.y;
FileStream configData( filename );
if ( !configData.open( QIODevice::WriteOnly ) )
return false;
configData << quint32( m_settings.tileSize ) << quint32( m_settings.zoomLevels.size() );
long long tilesSkipped = 0;
long long tiles = 0;
long long metaTilesRendered = 0;
long long pngcrushSaved = 0;
std::vector< ZoomInfo > zoomInfo( m_settings.zoomLevels.size() );
std::vector< MetaTile > tasks;
for ( int zoomLevel = 0; zoomLevel < ( int ) m_settings.zoomLevels.size(); zoomLevel++ ) {
ZoomInfo& info = zoomInfo[zoomLevel];
int zoom = m_settings.zoomLevels[zoomLevel];
info.minX = box.min.GetTileX( zoom );
info.maxX = box.max.GetTileX( zoom ) + 1;
info.minY = box.min.GetTileY( zoom );
info.maxY = box.max.GetTileY( zoom ) + 1;
if ( zoom <= m_settings.fullZoom ) {
info.minX = info.minY = 0;
info.maxX = info.maxY = 1 << zoom;
} else {
info.minX = std::max( 0 , info.minX - m_settings.tileMargin );
info.maxX = std::min ( 1 << zoom, info.maxX + m_settings.tileMargin );
info.minY = std::max( 0, info.minY - m_settings.tileMargin );
info.maxY = std::min ( 1 << zoom, info.maxY + m_settings.tileMargin );
}
tiles += ( info.maxX - info.minX ) * ( info.maxY - info.minY );
qDebug() << "Mapnik Renderer: [" << zoom << "] x:" << info.minX << "-" << info.maxX << "; y:" << info.minY << "-" << info.maxY;
configData << quint32( zoom ) << quint32( info.minX ) << quint32( info.maxX ) << quint32( info.minY ) << quint32( info.maxY );
int numberOfTiles = ( info.maxX - info.minX ) * ( info.maxY - info.minY );
IndexElement dummyIndex;
dummyIndex.start = dummyIndex.size = 0;
info.index.resize( numberOfTiles, dummyIndex );
std::vector< UnsignedCoordinate > path;
for ( std::vector< IImporter::RoutingEdge >::const_iterator i = inputEdges.begin(), e = inputEdges.end(); i != e; ++i ) {
path.push_back( inputNodes[i->source].coordinate );
for ( int pathID = 0; pathID < i->pathLength; pathID++ )
path.push_back( inputPaths[pathID + i->pathID].coordinate );
path.push_back( inputNodes[i->target].coordinate );
for ( unsigned edge = 0; edge < path.size(); edge++ ) {
int sourceX = path[edge].GetTileX( zoom );
int sourceY = path[edge].GetTileY( zoom );
int targetX = path[edge].GetTileX( zoom );
int targetY = path[edge].GetTileY( zoom );
if ( sourceX > targetX )
std::swap( sourceX, targetX );
if ( sourceY > targetY )
std::swap( sourceY, targetY );
sourceX = std::max( sourceX, info.minX );
sourceX = std::min( sourceX, info.maxX - 1 );
sourceY = std::max( sourceY, info.minY );
sourceY = std::min( sourceY, info.maxY - 1 );
targetX = std::max( targetX, info.minX );
targetX = std::min( targetX, info.maxX - 1 );
targetY = std::max( targetY, info.minY );
targetY = std::min( targetY, info.maxY - 1 );
for ( int x = sourceX; x <= targetX; ++x )
for ( int y = sourceY; y <= targetY; ++y )
info.index[( x - info.minX ) + ( y - info.minY ) * ( info.maxX - info.minX )].size = 1;
}
path.clear();
}
info.tilesFile = new QFile( filename + QString( "_%1_tiles" ).arg( zoom ) );
if ( !openQFile( info.tilesFile, QIODevice::WriteOnly ) )
return false;
for ( int x = info.minX; x < info.maxX; x+= m_settings.metaTileSize ) {
int metaTileSizeX = std::min( m_settings.metaTileSize, info.maxX - x );
for ( int y = info.minY; y < info.maxY; y+= m_settings.metaTileSize ) {
int metaTileSizeY = std::min( m_settings.metaTileSize, info.maxY - y );
MetaTile tile;
tile.zoom = zoomLevel;
tile.x = x;
tile.y = y;
tile.metaTileSizeX = metaTileSizeX;
tile.metaTileSizeY = metaTileSizeY;
tasks.push_back( tile );
}
}
}
#pragma omp parallel
{
int threadID = omp_get_thread_num();
const int metaTileSize = m_settings.metaTileSize * m_settings.tileSize + 2 * m_settings.margin;
mapnik::Map map;
mapnik::image_32 image( metaTileSize, metaTileSize );
QTemporaryFile tempOut;
QTemporaryFile tempIn;
mapnik::load_map( map, m_settings.theme.toLocal8Bit().constData() );
#pragma omp for schedule( dynamic )
for ( int i = 0; i < ( int ) tasks.size(); i++ ) {
int metaTileSizeX = tasks[i].metaTileSizeX;
int metaTileSizeY = tasks[i].metaTileSizeY;
int x = tasks[i].x;
int y = tasks[i].y;
int zoomLevel = tasks[i].zoom;
int zoom = m_settings.zoomLevels[zoomLevel];
ZoomInfo& info = zoomInfo[zoomLevel];
map.resize( metaTileSizeX * m_settings.tileSize + 2 * m_settings.margin, metaTileSizeY * m_settings.tileSize + 2 * m_settings.margin );
ProjectedCoordinate drawTopLeft( x - 1.0 * m_settings.margin / m_settings.tileSize, y - 1.0 * m_settings.margin / m_settings.tileSize, zoom );
ProjectedCoordinate drawBottomRight( x + metaTileSizeX + 1.0 * m_settings.margin / m_settings.tileSize, y + metaTileSizeY + 1.0 * m_settings.margin / m_settings.tileSize, zoom );
GPSCoordinate drawTopLeftGPS = drawTopLeft.ToGPSCoordinate();
GPSCoordinate drawBottomRightGPS = drawBottomRight.ToGPSCoordinate();
projection.forward( drawTopLeftGPS.longitude, drawBottomRightGPS.latitude );
projection.forward( drawBottomRightGPS.longitude, drawTopLeftGPS.latitude );
mapnik::box2d<double> boundingBox( drawTopLeftGPS.longitude, drawTopLeftGPS.latitude, drawBottomRightGPS.longitude, drawBottomRightGPS.latitude );
map.zoom_to_box( boundingBox );
mapnik::agg_renderer<mapnik::image_32> renderer( map, image );
renderer.apply();
std::string data;
int skipped = 0;
int saved = 0;
for ( int subX = 0; subX < metaTileSizeX; ++subX ) {
for ( int subY = 0; subY < metaTileSizeY; ++subY ) {
int indexNumber = ( y + subY - info.minY ) * ( info.maxX - info.minX ) + x + subX - info.minX;
mapnik::image_view<mapnik::image_data_32> view = image.get_view( subX * m_settings.tileSize + m_settings.margin, subY * m_settings.tileSize + m_settings.margin, m_settings.tileSize, m_settings.tileSize );
std::string result;
if ( !m_settings.deleteTiles || info.index[( x + subX - info.minX ) + ( y + subY - info.minY ) * ( info.maxX - info.minX )].size == 1 ) {
if ( m_settings.reduceColors )
result = mapnik::save_to_string( view, "png256" );
else
result = mapnik::save_to_string( view, "png" );
if ( m_settings.pngcrush ) {
tempOut.open();
tempOut.write( result.data(), result.size() );
tempOut.flush();
tempIn.open();
pclose( popen( ( "pngcrush " + tempOut.fileName() + " " + tempIn.fileName() ).toUtf8().constData(), "r" ) );
QByteArray buffer = tempIn.readAll();
tempIn.close();
tempOut.close();
if ( buffer.size() != 0 && buffer.size() < ( int ) result.size() ) {
saved += result.size() - buffer.size();
result.assign( buffer.constData(), buffer.size() );
}
}
}
info.index[indexNumber].start = data.size();
info.index[indexNumber].size = result.size();
data += result;
}
}
qint64 position;
#pragma omp critical
{
position = info.tilesFile->pos();
info.tilesFile->write( data.data(), data.size() );
metaTilesRendered++;
tilesSkipped += skipped;
pngcrushSaved += saved;
qDebug() << "Mapnik Renderer: [" << zoom << "], thread" << threadID << ", metatiles:" << metaTilesRendered << "/" << tasks.size();
}
for ( int subX = 0; subX < metaTileSizeX; ++subX ) {
for ( int subY = 0; subY < metaTileSizeY; ++subY ) {
int indexNumber = ( y + subY - info.minY ) * ( info.maxX - info.minX ) + x + subX - info.minX;
info.index[indexNumber].start += position;
}
}
}
}
for ( int zoomLevel = 0; zoomLevel < ( int ) m_settings.zoomLevels.size(); zoomLevel++ ) {
const ZoomInfo& info = zoomInfo[zoomLevel];
int zoom = m_settings.zoomLevels[zoomLevel];
QFile indexFile( filename + QString( "_%1_index" ).arg( zoom ) );
if ( !openQFile( &indexFile, QIODevice::WriteOnly ) )
return false;
for ( int i = 0; i < ( int ) info.index.size(); i++ ) {
indexFile.write( ( const char* ) &info.index[i].start, sizeof( info.index[i].start ) );
indexFile.write( ( const char* ) &info.index[i].size, sizeof( info.index[i].size ) );
}
delete info.tilesFile;
}
if ( m_settings.deleteTiles )
qDebug() << "Mapnik Renderer: removed" << tilesSkipped << "tiles";
if ( m_settings.pngcrush )
qDebug() << "Mapnik Renderer: PNGcrush saved" << pngcrushSaved / 1024 / 1024 << "MB";
qDebug() << "Mapnik Renderer: finished:" << time.restart() << "ms";
} catch ( const mapnik::config_error & ex ) {
qCritical( "Mapnik Renderer: ### Configuration error: %s", ex.what() );
return false;
} catch ( const std::exception & ex ) {
qCritical( "Mapnik Renderer: ### STD error: %s", ex.what() );
return false;
} catch ( ... ) {
qCritical( "Mapnik Renderer: ### Unknown error" );
return false;
}
return true;
}
void OscapScannerLocal::evaluate()
{
if (mDryRun)
{
signalCompletion(mCancelRequested);
return;
}
emit infoMessage(QObject::tr("Querying capabilities..."));
{
SyncProcess proc(this);
proc.setCommand(SCAP_WORKBENCH_LOCAL_OSCAP_PATH);
proc.setArguments(QStringList("--v"));
proc.run();
if (proc.getExitCode() != 0)
{
emit errorMessage(
QObject::tr("Failed to query capabilities of oscap on local machine.\n"
"Diagnostic info:\n%1").arg(proc.getDiagnosticInfo())
);
mCancelRequested = true;
signalCompletion(mCancelRequested);
return;
}
mCapabilities.parse(proc.getStdOutContents());
}
if (!checkPrerequisites())
{
mCancelRequested = true;
signalCompletion(mCancelRequested);
return;
}
// TODO: Error handling!
emit infoMessage(QObject::tr("Creating temporary files..."));
QTemporaryFile resultFile;
resultFile.setAutoRemove(true);
// the following forces Qt to give us the filename
resultFile.open(); resultFile.close();
QTemporaryFile reportFile;
reportFile.setAutoRemove(true);
reportFile.open(); reportFile.close();
QTemporaryFile arfFile;
arfFile.setAutoRemove(true);
arfFile.open(); arfFile.close();
// This is mainly for check-engine-results and oval-results, to ensure
// we get a full report, including info from these files. openscap's XSLT
// uses info in the check engine results if it can find them.
TemporaryDir workingDir;
emit infoMessage(QObject::tr("Starting the oscap process..."));
QProcess process(this);
process.setWorkingDirectory(workingDir.getPath());
QStringList args;
QTemporaryFile inputARFFile;
inputARFFile.setAutoRemove(true);
if (mScannerMode == SM_OFFLINE_REMEDIATION)
{
inputARFFile.open();
inputARFFile.write(getARFForRemediation());
inputARFFile.close();
args = buildOfflineRemediationArgs(inputARFFile.fileName(),
resultFile.fileName(),
reportFile.fileName(),
arfFile.fileName());
}
else
{
args = buildEvaluationArgs(mSession->getOpenedFilePath(),
mSession->hasTailoring() ? mSession->getTailoringFilePath() : QString(),
resultFile.fileName(),
reportFile.fileName(),
arfFile.fileName(),
mScannerMode == SM_SCAN_ONLINE_REMEDIATION);
}
QString program = "";
#ifdef SCAP_WORKBENCH_LOCAL_NICE_FOUND
args.prepend(getPkexecOscapPath());
args.prepend(QString::number(SCAP_WORKBENCH_LOCAL_OSCAP_NICENESS));
args.prepend("-n");
program = SCAP_WORKBENCH_LOCAL_NICE_PATH;
#else
program = getPkexecOscapPath();
#endif
process.start(program, args);
process.waitForStarted();
if (process.state() != QProcess::Running)
{
emit errorMessage(QObject::tr("Failed to start local scanning process '%1'. Perhaps the executable was not found?").arg(program));
mCancelRequested = true;
}
const unsigned int pollInterval = 100;
emit infoMessage(QObject::tr("Processing..."));
while (!process.waitForFinished(pollInterval))
{
// read everything new
readStdOut(process);
watchStdErr(process);
// pump the event queue, mainly because the user might want to cancel
QAbstractEventDispatcher::instance(mScanThread)->processEvents(QEventLoop::AllEvents);
if (mCancelRequested)
{
emit infoMessage(QObject::tr("Cancellation was requested! Terminating scanning..."));
process.kill();
process.waitForFinished(1000);
break;
}
}
if (!mCancelRequested)
{
if (process.exitCode() == 1) // error happened
{
watchStdErr(process);
// TODO: pass the diagnostics over
emit errorMessage(QObject::tr("There was an error during evaluation! Exit code of the 'oscap' process was 1."));
// mark this run as canceled
mCancelRequested = true;
}
else
{
// read everything left over
readStdOut(process);
watchStdErr(process);
emit infoMessage(QObject::tr("The oscap tool has finished. Reading results..."));
resultFile.open();
mResults = resultFile.readAll();
resultFile.close();
reportFile.open();
mReport = reportFile.readAll();
reportFile.close();
arfFile.open();
mARF = arfFile.readAll();
arfFile.close();
emit infoMessage(QObject::tr("Processing has been finished!"));
}
}
signalCompletion(mCancelRequested);
}
Transformation SVMTrain::analyze(const DataSet* dataset) const {
G_INFO("Doing SVMTrain analysis...");
QStringList sdescs = selectDescriptors(dataset->layout(), StringType, _descriptorNames, _exclude, false);
if (!sdescs.isEmpty()) {
throw GaiaException("SVMTrain: if you want to use string descriptors for training your SVM, "
"you first need to enumerate them using the 'enumerate' transform on them. "
"String descriptors: ", sdescs.join(", "));
}
QStringList descs = selectDescriptors(dataset->layout(), UndefinedType, _descriptorNames, _exclude);
// sort descriptors in the order in which they are taken inside the libsvm dataset
sort(descs.begin(), descs.end(), DescCompare(dataset->layout()));
Region region = dataset->layout().descriptorLocation(descs);
QStringList classMapping = svm::createClassMapping(dataset, _className);
// first, convert the training data into an SVM problem structure
// NB: all checks about fixed-length and type of descriptors are done in this function
struct svm_problem prob = svm::dataSetToLibsvmProblem(dataset, _className, region, classMapping);
// also get dimension (this trick works because a vector in there is the number
// of dimensions + 1 for the sentinel, and we're not in a sparse representation)
int dimension = prob.x[1] - prob.x[0] - 1;
// default values
struct svm_parameter param;
//param.svm_type = C_SVC;
//param.kernel_type = RBF;
//param.degree = 3;
//param.gamma = 0; // 1/k
param.coef0 = 0;
param.nu = 0.5;
param.cache_size = 100;
//param.C = 1;
param.eps = 1e-3;
param.p = 0.1;
param.shrinking = 1;
//param.probability = 0;
param.nr_weight = 0;
param.weight_label = NULL;
param.weight = NULL;
// get parameters
QString svmType = _params.value("type", "C-SVC").toString().toLower();
param.svm_type = _svmTypeMap.value(svmType);
QString kernelType = _params.value("kernel", "RBF").toString().toLower();
param.kernel_type = _kernelTypeMap.value(kernelType);
param.degree = _params.value("degree", 3).toInt();
param.C = _params.value("c", 1).toDouble();
param.gamma = _params.value("gamma", 1.0/dimension).toDouble();
param.probability = _params.value("probability", false).toBool() ? 1 : 0;
const char* error_msg = svm_check_parameter(&prob, ¶m);
if (error_msg) {
throw GaiaException(error_msg);
}
// do it!
struct svm_model* model;
const bool crossValidation = false;
if (crossValidation) {
int nr_fold = 10;
int total_correct = 0;
double total_error = 0;
double sumv = 0, sumy = 0, sumvv = 0, sumyy = 0, sumvy = 0;
double* target = new double[prob.l];
svm_cross_validation(&prob, ¶m, nr_fold, target);
if (param.svm_type == EPSILON_SVR ||
param.svm_type == NU_SVR) {
for (int i=0; i<prob.l; i++) {
double y = prob.y[i];
double v = target[i];
total_error += (v-y)*(v-y);
sumv += v;
sumy += y;
sumvv += v*v;
sumyy += y*y;
sumvy += v*y;
}
G_INFO("Cross Validation Mean squared error =" << total_error/prob.l);
G_INFO("Cross Validation Squared correlation coefficient =" <<
((prob.l*sumvy - sumv*sumy) * (prob.l*sumvy - sumv*sumy)) /
((prob.l*sumvv - sumv*sumv) * (prob.l*sumyy - sumy*sumy))
);
}
else {
for (int i=0; i<prob.l; i++)
if (target[i] == prob.y[i])
++total_correct;
G_INFO("Cross Validation Accuracy =" << 100.0*total_correct/prob.l << "%");
}
}
else { // !crossValidation
model = svm_train(&prob, ¶m);
}
// save model to a temporary file (only method available from libsvm...),
// reload it and put it into a gaia2::Parameter
QTemporaryFile modelFile;
modelFile.open();
QString modelFilename = modelFile.fileName();
modelFile.close();
if (svm_save_model(modelFilename.toAscii().constData(), model) == -1) {
throw GaiaException("SVMTrain: error while saving SVM model to temp file");
}
modelFile.open();
QByteArray modelData = modelFile.readAll();
modelFile.close();
// if we asked for the model to be output specifically, also do it
if (_params.value("modelFilename", "").toString() != "") {
QString filename = _params.value("modelFilename").toString();
svm_save_model(filename.toAscii().constData(), model);
}
// destroy the model allocated by libsvm
svm_destroy_model(model);
Transformation result(dataset->layout());
result.analyzerName = "svmtrain";
result.analyzerParams = _params;
result.applierName = "svmpredict";
result.params.insert("modelData", modelData);
result.params.insert("className", _params.value("className"));
result.params.insert("descriptorNames", descs);
result.params.insert("classMapping", classMapping);
result.params.insert("probability", (param.probability == 1 && (param.svm_type == C_SVC ||
param.svm_type == NU_SVC)));
return result;
}
