← Back to branch summary

~oif-team/ubuntu/natty/qt4-x11/xi2.1

« back to all changes in this revision

Viewing changes to tools/qtestlib/wince/cetest/deployment.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Alessandro Ghersi
  • Date: 2009-11-02 18:30:08 UTC
  • mfrom: (1.2.2 upstream)
  • mto: (15.2.5 experimental)
  • mto: This revision was merged to the branch mainline in revision 88.
  • Revision ID: james.westby@ubuntu.com-20091102183008-b6a4gcs128mvfb3m
Tags: upstream-4.6.0~beta1
Import upstream version 4.6.0~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
tools/qtestlib/wince/cetest/deployment.cpp
 
1
/****************************************************************************
 
2
**
 
3
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
 
4
** All rights reserved.
 
5
** Contact: Nokia Corporation (qt-info@nokia.com)
 
6
**
 
7
** This file is part of the tools applications of the Qt Toolkit.
 
8
**
 
9
** $QT_BEGIN_LICENSE:LGPL$
 
10
** No Commercial Usage
 
11
** This file contains pre-release code and may not be distributed.
 
12
** You may use this file in accordance with the terms and conditions
 
13
** contained in the Technology Preview License Agreement accompanying
 
14
** this package.
 
15
**
 
16
** GNU Lesser General Public License Usage
 
17
** Alternatively, this file may be used under the terms of the GNU Lesser
 
18
** General Public License version 2.1 as published by the Free Software
 
19
** Foundation and appearing in the file LICENSE.LGPL included in the
 
20
** packaging of this file.  Please review the following information to
 
21
** ensure the GNU Lesser General Public License version 2.1 requirements
 
22
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 
23
**
 
24
** In addition, as a special exception, Nokia gives you certain additional
 
25
** rights.  These rights are described in the Nokia Qt LGPL Exception
 
26
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 
27
**
 
28
** If you have questions regarding the use of this file, please contact
 
29
** Nokia at qt-info@nokia.com.
 
30
**
 
31
**
 
32
**
 
33
**
 
34
**
 
35
**
 
36
**
 
37
**
 
38
** $QT_END_LICENSE$
 
39
**
 
40
****************************************************************************/
 
41
 
 
42
#include "deployment.h"
 
43
#include "remoteconnection.h"
 
44
#include <option.h>
 
45
#include <qdir.h>
 
46
#include <qfile.h>
 
47
#include <qstring.h>
 
48
 
 
49
extern void debugOutput(const QString& text, int level);
 
50
 
 
51
bool DeploymentHandler::deviceCopy(const DeploymentList &deploymentList)
 
52
{
 
53
    for (int i=0; i<deploymentList.size(); ++i) {
 
54
        CopyItem item = deploymentList.at(i);
 
55
        m_connection->createDirectory(item.to.left(item.to.lastIndexOf(QLatin1Char('\\'))));
 
56
        if (!m_connection->copyFileToDevice(item.from , item.to)) {
 
57
            debugOutput(QString::fromLatin1("Error while copy: %1 -> %2").arg(item.from).arg(item.to),0);
 
58
            return false;
 
59
        }
 
60
    }
 
61
    return true;
 
62
}
 
63
 
 
64
bool DeploymentHandler::deviceDeploy(const DeploymentList &deploymentList)
 
65
{
 
66
    DeploymentList copyList;
 
67
    for (int i=0; i<deploymentList.size(); ++i) {
 
68
#if defined(Q_OS_WIN)
 
69
        HANDLE localHandle = CreateFile(deploymentList.at(i).from.utf16(), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
 
70
        if (localHandle == INVALID_HANDLE_VALUE) {
 
71
            copyList.append(deploymentList.at(i));
 
72
            continue;
 
73
        }
 
74
        FILETIME localCreationTime;
 
75
        if (!GetFileTime(localHandle, NULL, NULL, &localCreationTime) || !m_connection->timeStampForLocalFileTime(&localCreationTime)) {
 
76
            copyList.append(deploymentList.at(i));
 
77
            CloseHandle(localHandle);
 
78
            continue;
 
79
        }
 
80
        CloseHandle(localHandle);
 
81
 
 
82
        FILETIME deviceCreationTime;
 
83
        if (!m_connection->fileCreationTime(deploymentList.at(i).to , &deviceCreationTime)) {
 
84
            copyList.append(deploymentList.at(i));
 
85
            continue;
 
86
        }
 
87
        
 
88
        int res = CompareFileTime(&localCreationTime, &deviceCreationTime);
 
89
        if (res != 0)
 
90
            copyList.append(deploymentList.at(i));
 
91
        else
 
92
            debugOutput(QString::fromLatin1("Skipping File %1, already latest version").arg(deploymentList.at(i).from),0);
 
93
#else
 
94
        copyList.append(deploymentList.at(i));
 
95
#endif
 
96
    }
 
97
    return deviceCopy(copyList);
 
98
}
 
99
 
 
100
void DeploymentHandler::cleanup(const DeploymentList &deploymentList)
 
101
{
 
102
    for (int i=0; i<deploymentList.size(); ++i) {
 
103
        m_connection->deleteFile(deploymentList.at(i).to);
 
104
#ifdef Q_OS_WIN
 
105
        QString path = deploymentList.at(i).to;
 
106
        int pos;
 
107
        while ( (pos = path.lastIndexOf(QLatin1Char('\\'))) > 0) {
 
108
            path = path.left(pos);
 
109
            if (!m_connection->deleteDirectory(path, false, true))
 
110
                break;
 
111
        }
 
112
#endif
 
113
    }
 
114
}
 
115
 
 
116
void DeploymentHandler::initQtDeploy(QMakeProject *project, DeploymentList &deploymentList, const QString &testPath)
 
117
{
 
118
    QString targetPath = project->values("deploy.path").join(" ");
 
119
    if (targetPath.isEmpty())
 
120
        targetPath = testPath;
 
121
    if (targetPath.endsWith("/") || targetPath.endsWith("\\"))
 
122
        targetPath = targetPath.mid(0,targetPath.size()-1);
 
123
 
 
124
    // Only deploy Qt libs for shared build
 
125
    if (!project->values("QMAKE_QT_DLL").isEmpty() && !project->values("QMAKE_LIBDIR").isEmpty()) {
 
126
        QStringList libs = project->values("LIBS");
 
127
        QStringList qtLibs;
 
128
        QStringList libPaths;
 
129
        foreach (QString item, libs) {
 
130
 
 
131
            if (item.startsWith("-L")) {
 
132
                // -L -> a directory containing DLLs
 
133
                libPaths << item.mid(2);
 
134
                continue;
 
135
            }
 
136
 
 
137
            QStringList libCandidates;
 
138
 
 
139
            if (item.startsWith("-l")) {
 
140
                // -l -> a library located within one of the standard library paths
 
141
                QString lib = item.mid(2);
 
142
 
 
143
                // Check if it's a Qt library first, then check in all paths given with -L.
 
144
                // Note Qt libraries get a `4' appended to them, others don't.
 
145
                libCandidates << project->values("QMAKE_LIBDIR").at(0) + QDir::separator() + lib + QLatin1String("4.dll");
 
146
                foreach (QString const& libPath, libPaths) {
 
147
                    libCandidates << libPath + QDir::separator() + lib + QLatin1String(".dll");
 
148
                }
 
149
            } else {
 
150
                libCandidates << item.replace(".lib",".dll");
 
151
            }
 
152
 
 
153
            foreach (QString const& file, libCandidates) {
 
154
                QFileInfo info(file);
 
155
                if (info.exists()) {
 
156
                    qtLibs += info.dir().absoluteFilePath(info.fileName());
 
157
                    break;
 
158
                }
 
159
            }
 
160
        }
 
161
        for (QStringList::ConstIterator it = qtLibs.constBegin(); it != qtLibs.constEnd(); ++it) {
 
162
                QString dllName = *it;
 
163
                QFileInfo info(dllName);
 
164
                if (!info.exists())
 
165
                    continue;
 
166
                deploymentList.append(CopyItem(Option::fixPathToLocalOS(info.absoluteFilePath()) ,
 
167
                    Option::fixPathToLocalOS(targetPath + "/" + info.fileName())));
 
168
        }
 
169
    }
 
170
 
 
171
#ifndef QT_CETEST_NO_ACTIVESYNC
 
172
    // QtRemote deployment. We always deploy to \Windows
 
173
    if (!project->values("QMAKE_LIBDIR").isEmpty()) {
 
174
        QString remoteLibName = QLatin1String("QtRemote.dll");
 
175
        QString remoteLib = Option::fixPathToLocalOS(project->values("QMAKE_LIBDIR").at(0) + QDir::separator() + remoteLibName);
 
176
        if (QFile::exists(remoteLib))
 
177
            deploymentList.append(CopyItem(remoteLib, QString::fromLatin1("\\Windows\\") + remoteLibName));
 
178
        else
 
179
            debugOutput(QString::fromLatin1("Could not find QtRemote. Might not be able to launch target executable"),0);
 
180
    }
 
181
#endif
 
182
 
 
183
    // C-runtime deployment
 
184
    QString runtime = project->values("QT_CE_C_RUNTIME").join(QLatin1String(" "));
 
185
    debugOutput(QString::fromLatin1("Runtime:%1").arg(runtime), 2);
 
186
    if (!runtime.isEmpty() && (runtime != QLatin1String("no"))) {
 
187
        QString runtimeVersion = QLatin1String("msvcr");
 
188
        const QString mkspec = project->values("QMAKESPEC").first();
 
189
        if (mkspec.endsWith("2008"))
 
190
            runtimeVersion.append("90");
 
191
        else
 
192
            runtimeVersion.append("80");
 
193
        if (project->isActiveConfig("debug"))
 
194
            runtimeVersion.append("d");
 
195
        runtimeVersion.append(".dll");
 
196
 
 
197
        if (runtime == "yes") {
 
198
            // Auto-find C-runtime
 
199
            QString vcInstallDir = qgetenv("VCINSTALLDIR");
 
200
            if (!vcInstallDir.isEmpty()) {
 
201
                vcInstallDir += "\\ce\\dll\\";
 
202
                vcInstallDir += project->values("CE_ARCH").join(QLatin1String(" "));
 
203
                if (!QFileInfo(vcInstallDir + QDir::separator() + runtimeVersion).exists())
 
204
                    runtime.clear();
 
205
                else
 
206
                    runtime = vcInstallDir;
 
207
            }
 
208
        }
 
209
 
 
210
        if (!runtime.isEmpty()) {
 
211
            deploymentList.append(CopyItem(Option::fixPathToLocalOS(runtime + "/" + runtimeVersion ) ,
 
212
                Option::fixPathToLocalOS(targetPath + "/" + runtimeVersion)));
 
213
        }
 
214
    }
 
215
}
 
216
 
 
217
void DeploymentHandler::initProjectDeploy(QMakeProject* project, DeploymentList &deploymentList, const QString &testPath)
 
218
{
 
219
    QString targetPath = project->values("deploy.path").join(" ");
 
220
    if (targetPath.isEmpty())
 
221
        targetPath = testPath;
 
222
    if (targetPath.endsWith("/") || targetPath.endsWith("\\"))
 
223
        targetPath = targetPath.mid(0,targetPath.size()-1);
 
224
 
 
225
    QStringList& list = project->values("DEPLOYMENT");
 
226
    if (list.isEmpty())
 
227
        return;
 
228
 
 
229
    for (int it = 0; it < list.size(); ++it) {
 
230
        QString argSource = list.at(it) + QString(".sources");
 
231
        QString argPath = list.at(it) + QString(".path");
 
232
        if ((project->values(argSource).isEmpty() || project->values(argPath).isEmpty()) && list.at(it) != "deploy") {
 
233
            debugOutput(QString::fromLatin1("cannot deploy \"%1\" because of missing data.").arg(list.at(it)), 0);
 
234
            continue;
 
235
        }
 
236
 
 
237
        QString addPath = project->values(argPath).join(QLatin1String(" "));
 
238
        if (addPath == QLatin1String("."))
 
239
            addPath.clear();
 
240
        if (!addPath.startsWith("/") && !addPath.startsWith(QLatin1String("\\")))
 
241
            addPath = targetPath + "/" + addPath;
 
242
 
 
243
        QStringList addSources = project->values(argSource);
 
244
        addSources.replaceInStrings(QLatin1String("/"), QLatin1String("\\"));
 
245
        for(int index=0; index < addSources.size(); ++index) {
 
246
            QString dirstr = qmake_getpwd();
 
247
            QString filestr = Option::fixPathToLocalOS(addSources.at(index), false, false);
 
248
            int slsh = filestr.lastIndexOf(Option::dir_sep);
 
249
            if(slsh != -1) {
 
250
                dirstr = filestr.left(slsh+1);
 
251
                filestr = filestr.right(filestr.length() - slsh - 1);
 
252
            }
 
253
            if(dirstr.right(Option::dir_sep.length()) != Option::dir_sep)
 
254
                dirstr += Option::dir_sep;
 
255
            QFileInfo info(dirstr + filestr);
 
256
            
 
257
            static int addQMakeDeployCounter = 0;
 
258
            QStringList entryList = info.absoluteDir().entryList(QStringList() << info.fileName());
 
259
            if (entryList.size() > 1) {
 
260
                foreach(QString s, entryList) {
 
261
                    // We do not include directories when using wildcards
 
262
                    QFileInfo wildInfo(info.absolutePath() + "/" + s);
 
263
                    if (wildInfo.isDir()) {
 
264
                        continue;
 
265
                    }
 
266
                    QString appendedQmakeDeploy = QString::fromLatin1("_q_make_additional_deploy_%1").arg(addQMakeDeployCounter++);
 
267
                    project->parse(appendedQmakeDeploy + QLatin1String(".sources = \"") + wildInfo.absoluteFilePath());
 
268
                    project->parse(appendedQmakeDeploy + QLatin1String(".path    = \"") + addPath);
 
269
                    list.append(appendedQmakeDeploy);
 
270
                }
 
271
                continue;
 
272
            }
 
273
                                                                            
 
274
            if (info.isDir()) {
 
275
                QDir additionalDir(dirstr + filestr);
 
276
                QStringList additionalEntries = additionalDir.entryList(QDir::NoDotAndDotDot | QDir::AllEntries | QDir::NoSymLinks);
 
277
                foreach(QString item, additionalEntries) {
 
278
                QString appendedDeploy = QString::fromLatin1("_q_make_additional_deploy_%1").arg(addQMakeDeployCounter++);
 
279
                    project->parse(appendedDeploy + QLatin1String(".sources = \"") + Option::fixPathToLocalOS(additionalDir.absoluteFilePath(item)) + QLatin1String("\""));
 
280
                    QString appendTargetPath = project->values(argPath).join(QLatin1String(" "));
 
281
                    if (appendTargetPath == QLatin1String("."))
 
282
                        appendTargetPath = filestr;
 
283
                    else
 
284
                        appendTargetPath.append(QLatin1String("\\") + filestr);
 
285
                    project->parse(appendedDeploy + QLatin1String(".path = ") + appendTargetPath);
 
286
                    list.append(appendedDeploy);
 
287
                }
 
288
            } else if (entryList.size() == 1)
 
289
                deploymentList.append(CopyItem(Option::fixPathToLocalOS(info.absolutePath() + "/" + entryList.at(0)) ,
 
290
                    Option::fixPathToLocalOS(addPath + "/" + entryList.at(0))));
 
291
        }
 
292
    }
 
293
}