8503179693

Committed 01 Apr 2024 02:59AM UTC coverage: 68.955% (+0.001%) from 68.954%

Build # 8503179693

Build Type

Pull #9588

github

Committed by

web-flow

Commit Message

Bump actions/setup-python from 5.0.0 to 5.1.0

Bumps [actions/setup-python](https://github.com/actions/setup-python) from 5.0.0 to 5.1.0.
- [Release notes](https://github.com/actions/setup-python/releases)
- [Commits](https://github.com/actions/setup-python/compare/0a5c61591...82c7e631b)

---
updated-dependencies:
- dependency-name: actions/setup-python
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>

Pull Request Pull Request #9588: Bump actions/setup-python from 5.0.0 to 5.1.0

Run Details

527320 of 764735 relevant lines covered (68.95%)

327051.94 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

90.91

/frmts/wms/gdalwmscache.cpp

/******************************************************************************
 *
 * Project:  WMS Client Driver
 * Purpose:  Implementation of Dataset and RasterBand classes for WMS
 *           and other similar services.
 * Author:   Adam Nowacki, nowak@xpam.de
 *
 ******************************************************************************
 * Copyright (c) 2007, Adam Nowacki
 * Copyright (c) 2017, Dmitry Baryshnikov, <polimax@mail.ru>
 * Copyright (c) 2017, NextGIS, <info@nextgis.com>
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the "Software"),
 * to deal in the Software without restriction, including without limitation
 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
 * and/or sell copies of the Software, and to permit persons to whom the
 * Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
 * DEALINGS IN THE SOFTWARE.
 ****************************************************************************/

#include "cpl_md5.h"
#include "wmsdriver.h"

static void CleanCacheThread(void *pData)
{
    GDALWMSCache *pCache = static_cast<GDALWMSCache *>(pData);
    pCache->Clean();
}

//------------------------------------------------------------------------------
// GDALWMSFileCache
//------------------------------------------------------------------------------
class GDALWMSFileCache : public GDALWMSCacheImpl
{
  public:
    GDALWMSFileCache(const CPLString &soPath, CPLXMLNode *pConfig)
        : GDALWMSCacheImpl(soPath, pConfig), m_osPostfix(""), m_nDepth(2),
          m_nExpires(604800),            // 7 days
          m_nMaxSize(67108864),          // 64 Mb
          m_nCleanThreadRunTimeout(120)  // 3 min
    {
        const char *pszCacheDepth = CPLGetXMLValue(pConfig, "Depth", "2");
        if (pszCacheDepth != nullptr)
            m_nDepth = atoi(pszCacheDepth);

        const char *pszCacheExtension =
            CPLGetXMLValue(pConfig, "Extension", nullptr);
        if (pszCacheExtension != nullptr)
            m_osPostfix = pszCacheExtension;

        const char *pszCacheExpires =
            CPLGetXMLValue(pConfig, "Expires", nullptr);
        if (pszCacheExpires != nullptr)
        {
            m_nExpires = atoi(pszCacheExpires);
            CPLDebug("WMS", "Cache expires in %d sec", m_nExpires);
        }

        const char *pszCacheMaxSize =
            CPLGetXMLValue(pConfig, "MaxSize", nullptr);
        if (pszCacheMaxSize != nullptr)
            m_nMaxSize = atol(pszCacheMaxSize);

        const char *pszCleanThreadRunTimeout =
            CPLGetXMLValue(pConfig, "CleanTimeout", nullptr);
        if (pszCleanThreadRunTimeout != nullptr)
        {
            m_nCleanThreadRunTimeout = atoi(pszCleanThreadRunTimeout);
            CPLDebug("WMS", "Clean Thread Run Timeout is %d sec",
                     m_nCleanThreadRunTimeout);
        }
    }

    virtual int GetCleanThreadRunTimeout() override
    {
        return m_nCleanThreadRunTimeout;
    }

    virtual CPLErr Insert(const char *pszKey,
                          const CPLString &osFileName) override
    {
        // Warns if it fails to write, but returns success
        CPLString soFilePath = GetFilePath(pszKey);
        MakeDirs(CPLGetDirname(soFilePath));
        if (CPLCopyFile(soFilePath, osFileName) == CE_None)
            return CE_None;
        // Warn if it fails after folder creation
        CPLError(CE_Warning, CPLE_FileIO, "Error writing to WMS cache %s",
                 m_soPath.c_str());
        return CE_None;
    }

    virtual enum GDALWMSCacheItemStatus
    GetItemStatus(const char *pszKey) const override
    {
        VSIStatBufL sStatBuf;
        if (VSIStatL(GetFilePath(pszKey), &sStatBuf) == 0)
        {
            long seconds = static_cast<long>(time(nullptr) - sStatBuf.st_mtime);
            return seconds < m_nExpires ? CACHE_ITEM_OK : CACHE_ITEM_EXPIRED;
        }
        return CACHE_ITEM_NOT_FOUND;
    }

    virtual GDALDataset *GetDataset(const char *pszKey,
                                    char **papszOpenOptions) const override
    {
        return GDALDataset::FromHandle(GDALOpenEx(
            GetFilePath(pszKey),
            GDAL_OF_RASTER | GDAL_OF_READONLY | GDAL_OF_VERBOSE_ERROR, nullptr,
            papszOpenOptions, nullptr));
    }

    virtual void Clean() override
    {
        char **papszList = VSIReadDirRecursive(m_soPath);
        if (papszList == nullptr)
        {
            return;
        }

        int counter = 0;
        std::vector<int> toDelete;
        long nSize = 0;
        time_t nTime = time(nullptr);
        while (papszList[counter] != nullptr)
        {
            const char *pszPath =
                CPLFormFilename(m_soPath, papszList[counter], nullptr);
            VSIStatBufL sStatBuf;
            if (VSIStatL(pszPath, &sStatBuf) == 0)
            {
                if (!VSI_ISDIR(sStatBuf.st_mode))
                {
                    long seconds = static_cast<long>(nTime - sStatBuf.st_mtime);
                    if (seconds > m_nExpires)
                    {
                        toDelete.push_back(counter);
                    }

                    nSize += static_cast<long>(sStatBuf.st_size);
                }
            }
            counter++;
        }

        if (nSize > m_nMaxSize)
        {
            CPLDebug("WMS", "Delete %u items from cache",
                     static_cast<unsigned int>(toDelete.size()));
            for (size_t i = 0; i < toDelete.size(); ++i)
            {
                const char *pszPath =
                    CPLFormFilename(m_soPath, papszList[toDelete[i]], nullptr);
                VSIUnlink(pszPath);
            }
        }

        CSLDestroy(papszList);
    }

  private:
    CPLString GetFilePath(const char *pszKey) const
    {
        CPLString soHash(CPLMD5String(pszKey));
        CPLString soCacheFile(m_soPath);

        if (!soCacheFile.empty() && soCacheFile.back() != '/')
        {
            soCacheFile.append(1, '/');
        }

        for (int i = 0; i < m_nDepth; ++i)
        {
            soCacheFile.append(1, soHash[i]);
            soCacheFile.append(1, '/');
        }
        soCacheFile.append(soHash);
        soCacheFile.append(m_osPostfix);
        return soCacheFile;
    }

    static void MakeDirs(const char *pszPath)
    {
        if (IsPathExists(pszPath))
        {
            return;
        }
        // Recursive makedirs, ignoring errors
        const char *pszDirPath = CPLGetDirname(pszPath);
        MakeDirs(pszDirPath);

        VSIMkdir(pszPath, 0744);
    }

    static bool IsPathExists(const char *pszPath)
    {
        VSIStatBufL sbuf;
        return VSIStatL(pszPath, &sbuf) == 0;
    }

  private:
    CPLString m_osPostfix;
    int m_nDepth;
    int m_nExpires;
    long m_nMaxSize;
    int m_nCleanThreadRunTimeout;
};

//------------------------------------------------------------------------------
// GDALWMSCache
//------------------------------------------------------------------------------

GDALWMSCache::GDALWMSCache() = default;

GDALWMSCache::~GDALWMSCache()
{
    if (m_hThread)
        CPLJoinThread(m_hThread);
    delete m_poCache;
}

CPLErr GDALWMSCache::Initialize(const char *pszUrl, CPLXMLNode *pConfig)
{
    const auto NullifyIfEmpty = [](const char *pszStr)
    { return pszStr && pszStr[0] != 0 ? pszStr : nullptr; };

    if (const char *pszXmlCachePath =
            NullifyIfEmpty(CPLGetXMLValue(pConfig, "Path", nullptr)))
    {
        m_osCachePath = pszXmlCachePath;
    }
    else if (const char *pszUserCachePath = NullifyIfEmpty(
                 CPLGetConfigOption("GDAL_DEFAULT_WMS_CACHE_PATH", nullptr)))
    {
        m_osCachePath = pszUserCachePath;
    }
    else if (const char *pszXDG_CACHE_HOME =
                 NullifyIfEmpty(CPLGetConfigOption("XDG_CACHE_HOME", nullptr)))
    {
        m_osCachePath =
            CPLFormFilename(pszXDG_CACHE_HOME, "gdalwmscache", nullptr);
    }
    else
    {
#ifdef _WIN32
        const char *pszHome =
            NullifyIfEmpty(CPLGetConfigOption("USERPROFILE", nullptr));
#else
        const char *pszHome =
            NullifyIfEmpty(CPLGetConfigOption("HOME", nullptr));
#endif
        if (pszHome)
        {
            m_osCachePath =
                CPLFormFilename(CPLFormFilename(pszHome, ".cache", nullptr),
                                "gdalwmscache", nullptr);
        }
        else
        {
            const char *pszDir =
                NullifyIfEmpty(CPLGetConfigOption("CPL_TMPDIR", nullptr));

            if (!pszDir)
                pszDir = NullifyIfEmpty(CPLGetConfigOption("TMPDIR", nullptr));

            if (!pszDir)
                pszDir = NullifyIfEmpty(CPLGetConfigOption("TEMP", nullptr));

            if (!pszDir)
                pszDir = ".";

            const char *pszUsername =
                NullifyIfEmpty(CPLGetConfigOption("USERNAME", nullptr));
            if (!pszUsername)
                pszUsername =
                    NullifyIfEmpty(CPLGetConfigOption("USER", nullptr));

            if (pszUsername)
            {
                m_osCachePath = CPLFormFilename(
                    pszDir, CPLSPrintf("gdalwmscache_%s", pszUsername),
                    nullptr);
            }
            else
            {
                m_osCachePath = CPLFormFilename(
                    pszDir,
                    CPLSPrintf("gdalwmscache_%s",
                               CPLMD5String(pszUrl ? pszUrl : "")),
                    nullptr);
            }
        }
    }

    // Separate folder for each unique dataset url
    if (CPLTestBool(CPLGetXMLValue(pConfig, "Unique", "True")))
    {
        m_osCachePath = CPLFormFilename(
            m_osCachePath, CPLMD5String(pszUrl ? pszUrl : ""), nullptr);
    }
    CPLDebug("WMS", "Using %s for cache", m_osCachePath.c_str());

    // TODO: Add sqlite db cache type
    const char *pszType = CPLGetXMLValue(pConfig, "Type", "file");
    if (EQUAL(pszType, "file"))
    {
        m_poCache = new GDALWMSFileCache(m_osCachePath, pConfig);
    }

    return CE_None;
}

CPLErr GDALWMSCache::Insert(const char *pszKey, const CPLString &soFileName)
{
    if (m_poCache != nullptr && pszKey != nullptr)
    {
        // Add file to cache
        CPLErr result = m_poCache->Insert(pszKey, soFileName);
        if (result == CE_None)
        {
            // Start clean thread
            int cleanThreadRunTimeout = m_poCache->GetCleanThreadRunTimeout();
            if (cleanThreadRunTimeout > 0 && !m_bIsCleanThreadRunning &&
                time(nullptr) - m_nCleanThreadLastRunTime >
                    cleanThreadRunTimeout)
            {
                if (m_hThread)
                    CPLJoinThread(m_hThread);
                m_bIsCleanThreadRunning = true;
                m_hThread = CPLCreateJoinableThread(CleanCacheThread, this);
            }
        }
        return result;
    }

    return CE_Failure;
}

enum GDALWMSCacheItemStatus
GDALWMSCache::GetItemStatus(const char *pszKey) const
{
    if (m_poCache != nullptr)
    {
        return m_poCache->GetItemStatus(pszKey);
    }
    return CACHE_ITEM_NOT_FOUND;
}

GDALDataset *GDALWMSCache::GetDataset(const char *pszKey,
                                      char **papszOpenOptions) const
{
    if (m_poCache != nullptr)
    {
        return m_poCache->GetDataset(pszKey, papszOpenOptions);
    }
    return nullptr;
}

void GDALWMSCache::Clean()
{
    if (m_poCache != nullptr)
    {
        CPLDebug("WMS", "Clean cache");
        m_poCache->Clean();
    }

    m_nCleanThreadLastRunTime = time(nullptr);
    m_bIsCleanThreadRunning = false;
}

1	/******************************************************************************
2	*
3	* Project: WMS Client Driver
4	* Purpose: Implementation of Dataset and RasterBand classes for WMS
5	* and other similar services.
6	* Author: Adam Nowacki, nowak@xpam.de
7	*
8	******************************************************************************
9	* Copyright (c) 2007, Adam Nowacki
10	* Copyright (c) 2017, Dmitry Baryshnikov, <polimax@mail.ru>
11	* Copyright (c) 2017, NextGIS, <info@nextgis.com>
12	*
13	* Permission is hereby granted, free of charge, to any person obtaining a
14	* copy of this software and associated documentation files (the "Software"),
15	* to deal in the Software without restriction, including without limitation
16	* the rights to use, copy, modify, merge, publish, distribute, sublicense,
17	* and/or sell copies of the Software, and to permit persons to whom the
18	* Software is furnished to do so, subject to the following conditions:
19	*
20	* The above copyright notice and this permission notice shall be included
21	* in all copies or substantial portions of the Software.
22	*
23	* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
24	* OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
25	* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
26	* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
27	* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
28	* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
29	* DEALINGS IN THE SOFTWARE.
30	****************************************************************************/
31
32	#include "cpl_md5.h"
33	#include "wmsdriver.h"
34
35	static void CleanCacheThread(void *pData)	12✔
36	{
37	GDALWMSCache pCache = static_cast<GDALWMSCache >(pData);	12✔
38	pCache->Clean();	12✔
39	}	12✔
40
41	//------------------------------------------------------------------------------
42	// GDALWMSFileCache
43	//------------------------------------------------------------------------------
44	class GDALWMSFileCache : public GDALWMSCacheImpl
45	{
46	public:
47	GDALWMSFileCache(const CPLString &soPath, CPLXMLNode *pConfig)	197✔
48	: GDALWMSCacheImpl(soPath, pConfig), m_osPostfix(""), m_nDepth(2),	197✔
49	m_nExpires(604800), // 7 days
50	m_nMaxSize(67108864), // 64 Mb
51	m_nCleanThreadRunTimeout(120) // 3 min	197✔
52	{
53	const char *pszCacheDepth = CPLGetXMLValue(pConfig, "Depth", "2");	197✔
54	if (pszCacheDepth != nullptr)	197✔
55	m_nDepth = atoi(pszCacheDepth);	197✔
56
57	const char *pszCacheExtension =
58	CPLGetXMLValue(pConfig, "Extension", nullptr);	197✔
59	if (pszCacheExtension != nullptr)	197✔
60	m_osPostfix = pszCacheExtension;	×
61
62	const char *pszCacheExpires =
63	CPLGetXMLValue(pConfig, "Expires", nullptr);	197✔
64	if (pszCacheExpires != nullptr)	197✔
65	{
66	m_nExpires = atoi(pszCacheExpires);	1✔
67	CPLDebug("WMS", "Cache expires in %d sec", m_nExpires);	1✔
68	}
69
70	const char *pszCacheMaxSize =
71	CPLGetXMLValue(pConfig, "MaxSize", nullptr);	197✔
72	if (pszCacheMaxSize != nullptr)	197✔
73	m_nMaxSize = atol(pszCacheMaxSize);	×
74
75	const char *pszCleanThreadRunTimeout =
76	CPLGetXMLValue(pConfig, "CleanTimeout", nullptr);	197✔
77	if (pszCleanThreadRunTimeout != nullptr)	197✔
78	{
79	m_nCleanThreadRunTimeout = atoi(pszCleanThreadRunTimeout);	×
80	CPLDebug("WMS", "Clean Thread Run Timeout is %d sec",	×
81	m_nCleanThreadRunTimeout);
82	}
83	}	197✔
84
85	virtual int GetCleanThreadRunTimeout() override	18✔
86	{
87	return m_nCleanThreadRunTimeout;	18✔
88	}
89
90	virtual CPLErr Insert(const char *pszKey,	18✔
91	const CPLString &osFileName) override
92	{
93	// Warns if it fails to write, but returns success
94	CPLString soFilePath = GetFilePath(pszKey);	36✔
95	MakeDirs(CPLGetDirname(soFilePath));	18✔
96	if (CPLCopyFile(soFilePath, osFileName) == CE_None)	18✔
97	return CE_None;	17✔
98	// Warn if it fails after folder creation
99	CPLError(CE_Warning, CPLE_FileIO, "Error writing to WMS cache %s",	1✔
100	m_soPath.c_str());
101	return CE_None;	1✔
102	}
103
104	virtual enum GDALWMSCacheItemStatus
105	GetItemStatus(const char *pszKey) const override	32✔
106	{
107	VSIStatBufL sStatBuf;
108	if (VSIStatL(GetFilePath(pszKey), &sStatBuf) == 0)	32✔
109	{
110	long seconds = static_cast<long>(time(nullptr) - sStatBuf.st_mtime);	16✔
111	return seconds < m_nExpires ? CACHE_ITEM_OK : CACHE_ITEM_EXPIRED;	16✔
112	}
113	return CACHE_ITEM_NOT_FOUND;	16✔
114	}
115
116	virtual GDALDataset GetDataset(const char pszKey,	14✔
117	char **papszOpenOptions) const override
118	{
119	return GDALDataset::FromHandle(GDALOpenEx(	14✔
120	GetFilePath(pszKey),	28✔
121	GDAL_OF_RASTER \| GDAL_OF_READONLY \| GDAL_OF_VERBOSE_ERROR, nullptr,
122	papszOpenOptions, nullptr));	28✔
123	}
124
125	virtual void Clean() override	12✔
126	{
127	char **papszList = VSIReadDirRecursive(m_soPath);	12✔
128	if (papszList == nullptr)	12✔
129	{
130	return;	1✔
131	}
132
133	int counter = 0;	11✔
134	std::vector<int> toDelete;	22✔
135	long nSize = 0;	11✔
136	time_t nTime = time(nullptr);	11✔
137	while (papszList[counter] != nullptr)	56✔
138	{
139	const char *pszPath =
140	CPLFormFilename(m_soPath, papszList[counter], nullptr);	45✔
141	VSIStatBufL sStatBuf;
142	if (VSIStatL(pszPath, &sStatBuf) == 0)	45✔
143	{
144	if (!VSI_ISDIR(sStatBuf.st_mode))	45✔
145	{
146	long seconds = static_cast<long>(nTime - sStatBuf.st_mtime);	15✔
147	if (seconds > m_nExpires)	15✔
148	{
149	toDelete.push_back(counter);	×
150	}
151
152	nSize += static_cast<long>(sStatBuf.st_size);	15✔
153	}
154	}
155	counter++;	45✔
156	}
157
158	if (nSize > m_nMaxSize)	11✔
159	{
160	CPLDebug("WMS", "Delete %u items from cache",	×
161	static_cast<unsigned int>(toDelete.size()));	×
162	for (size_t i = 0; i < toDelete.size(); ++i)	×
163	{
164	const char *pszPath =
165	CPLFormFilename(m_soPath, papszList[toDelete[i]], nullptr);	×
166	VSIUnlink(pszPath);	×
167	}
168	}
169
170	CSLDestroy(papszList);	11✔
171	}
172
173	private:
174	CPLString GetFilePath(const char *pszKey) const	64✔
175	{
176	CPLString soHash(CPLMD5String(pszKey));	128✔
177	CPLString soCacheFile(m_soPath);	64✔
178
179	if (!soCacheFile.empty() && soCacheFile.back() != '/')	64✔
180	{
181	soCacheFile.append(1, '/');	64✔
182	}
183
184	for (int i = 0; i < m_nDepth; ++i)	192✔
185	{
186	soCacheFile.append(1, soHash[i]);	128✔
187	soCacheFile.append(1, '/');	128✔
188	}
189	soCacheFile.append(soHash);	64✔
190	soCacheFile.append(m_osPostfix);	64✔
191	return soCacheFile;	128✔
192	}
193
194	static void MakeDirs(const char *pszPath)	60✔
195	{
196	if (IsPathExists(pszPath))	60✔
197	{
198	return;	18✔
199	}
200	// Recursive makedirs, ignoring errors
201	const char *pszDirPath = CPLGetDirname(pszPath);	42✔
202	MakeDirs(pszDirPath);	42✔
203
204	VSIMkdir(pszPath, 0744);	42✔
205	}
206
207	static bool IsPathExists(const char *pszPath)	60✔
208	{
209	VSIStatBufL sbuf;
210	return VSIStatL(pszPath, &sbuf) == 0;	60✔
211	}
212
213	private:
214	CPLString m_osPostfix;
215	int m_nDepth;
216	int m_nExpires;
217	long m_nMaxSize;
218	int m_nCleanThreadRunTimeout;
219	};
220
221	//------------------------------------------------------------------------------
222	// GDALWMSCache
223	//------------------------------------------------------------------------------
224
225	GDALWMSCache::GDALWMSCache() = default;
226
227	GDALWMSCache::~GDALWMSCache()	197✔
228	{
229	if (m_hThread)	197✔
230	CPLJoinThread(m_hThread);	12✔
231	delete m_poCache;	197✔
232	}	197✔
233
234	CPLErr GDALWMSCache::Initialize(const char pszUrl, CPLXMLNode pConfig)	197✔
235	{
236	const auto NullifyIfEmpty = [](const char *pszStr)	322✔
237	{ return pszStr && pszStr[0] != 0 ? pszStr : nullptr; };	322✔
238
239	if (const char *pszXmlCachePath =	197✔
240	NullifyIfEmpty(CPLGetXMLValue(pConfig, "Path", nullptr)))	197✔
241	{
242	m_osCachePath = pszXmlCachePath;	112✔
243	}
244	else if (const char *pszUserCachePath = NullifyIfEmpty(	85✔
245	CPLGetConfigOption("GDAL_DEFAULT_WMS_CACHE_PATH", nullptr)))
246	{
247	m_osCachePath = pszUserCachePath;	74✔
248	}
249	else if (const char *pszXDG_CACHE_HOME =	11✔
250	NullifyIfEmpty(CPLGetConfigOption("XDG_CACHE_HOME", nullptr)))	11✔
251	{
252	m_osCachePath =
253	CPLFormFilename(pszXDG_CACHE_HOME, "gdalwmscache", nullptr);	1✔
254	}
255	else
256	{
257	#ifdef _WIN32
258	const char *pszHome =
259	NullifyIfEmpty(CPLGetConfigOption("USERPROFILE", nullptr));
260	#else
261	const char *pszHome =
262	NullifyIfEmpty(CPLGetConfigOption("HOME", nullptr));	10✔
263	#endif
264	if (pszHome)	10✔
265	{
266	m_osCachePath =
267	CPLFormFilename(CPLFormFilename(pszHome, ".cache", nullptr),
268	"gdalwmscache", nullptr);	5✔
269	}
270	else
271	{
272	const char *pszDir =
273	NullifyIfEmpty(CPLGetConfigOption("CPL_TMPDIR", nullptr));	5✔
274
275	if (!pszDir)	5✔
276	pszDir = NullifyIfEmpty(CPLGetConfigOption("TMPDIR", nullptr));	3✔
277
278	if (!pszDir)	5✔
279	pszDir = NullifyIfEmpty(CPLGetConfigOption("TEMP", nullptr));	2✔
280
281	if (!pszDir)	5✔
282	pszDir = ".";	1✔
283
284	const char *pszUsername =
285	NullifyIfEmpty(CPLGetConfigOption("USERNAME", nullptr));	5✔
286	if (!pszUsername)	5✔
287	pszUsername =
288	NullifyIfEmpty(CPLGetConfigOption("USER", nullptr));	4✔
289
290	if (pszUsername)	5✔
291	{
292	m_osCachePath = CPLFormFilename(
293	pszDir, CPLSPrintf("gdalwmscache_%s", pszUsername),
294	nullptr);	4✔
295	}
296	else
297	{
298	m_osCachePath = CPLFormFilename(
299	pszDir,
300	CPLSPrintf("gdalwmscache_%s",
301	CPLMD5String(pszUrl ? pszUrl : "")),
302	nullptr);	1✔
303	}
304	}
305	}
306
307	// Separate folder for each unique dataset url
308	if (CPLTestBool(CPLGetXMLValue(pConfig, "Unique", "True")))	197✔
309	{
310	m_osCachePath = CPLFormFilename(
311	m_osCachePath, CPLMD5String(pszUrl ? pszUrl : ""), nullptr);	89✔
312	}
313	CPLDebug("WMS", "Using %s for cache", m_osCachePath.c_str());	197✔
314
315	// TODO: Add sqlite db cache type
316	const char *pszType = CPLGetXMLValue(pConfig, "Type", "file");	197✔
317	if (EQUAL(pszType, "file"))	197✔
318	{
319	m_poCache = new GDALWMSFileCache(m_osCachePath, pConfig);	197✔
320	}
321
322	return CE_None;	197✔
323	}
324
325	CPLErr GDALWMSCache::Insert(const char *pszKey, const CPLString &soFileName)	18✔
326	{
327	if (m_poCache != nullptr && pszKey != nullptr)	18✔
328	{
329	// Add file to cache
330	CPLErr result = m_poCache->Insert(pszKey, soFileName);	18✔
331	if (result == CE_None)	18✔
332	{
333	// Start clean thread
334	int cleanThreadRunTimeout = m_poCache->GetCleanThreadRunTimeout();	18✔
335	if (cleanThreadRunTimeout > 0 && !m_bIsCleanThreadRunning &&	36✔
336	time(nullptr) - m_nCleanThreadLastRunTime >	18✔
337	cleanThreadRunTimeout)	18✔
338	{
339	if (m_hThread)	12✔
340	CPLJoinThread(m_hThread);	×
341	m_bIsCleanThreadRunning = true;	12✔
342	m_hThread = CPLCreateJoinableThread(CleanCacheThread, this);	12✔
343	}
344	}
345	return result;	18✔
346	}
347
348	return CE_Failure;	×
349	}
350
351	enum GDALWMSCacheItemStatus
352	GDALWMSCache::GetItemStatus(const char *pszKey) const	32✔
353	{
354	if (m_poCache != nullptr)	32✔
355	{
356	return m_poCache->GetItemStatus(pszKey);	32✔
357	}
358	return CACHE_ITEM_NOT_FOUND;	×
359	}
360
361	GDALDataset GDALWMSCache::GetDataset(const char pszKey,	14✔
362	char **papszOpenOptions) const
363	{
364	if (m_poCache != nullptr)	14✔
365	{
366	return m_poCache->GetDataset(pszKey, papszOpenOptions);	14✔
367	}
368	return nullptr;	×
369	}
370
371	void GDALWMSCache::Clean()	12✔
372	{
373	if (m_poCache != nullptr)	12✔
374	{
375	CPLDebug("WMS", "Clean cache");	12✔
376	m_poCache->Clean();	12✔
377	}
378
379	m_nCleanThreadLastRunTime = time(nullptr);	12✔
380	m_bIsCleanThreadRunning = false;	12✔
381	}	12✔

OSGeo / gdal / 8503179693

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous