PLUGIN_CONTENT_MANAGER Class Reference

Main class of Plugin and Content Manager subsystem. More...

#include <pcm.h>

Public Member Functions
	PLUGIN_CONTENT_MANAGER (std::function< void(int)> aAvailableUpdateCallback, std::function< void(const wxString)> aStatusCallback)
	~PLUGIN_CONTENT_MANAGER ()
void	SaveInstalledPackages ()
	Saves metadata of installed packages to disk. More...
bool	FetchRepository (const wxString &aUrl, PCM_REPOSITORY &aRepository, PROGRESS_REPORTER *aReporter)
	Fetches repository metadata from given url. More...
void	ValidateJson (const nlohmann::json &aJson, const nlohmann::json_uri &aUri=nlohmann::json_uri("#")) const
	Validates json against a specific definition in the PCM schema. More...
bool	VerifyHash (std::istream &aStream, const wxString &aHash) const
	Verifies SHA256 hash of a binary stream. More...
void	SetRepositoryList (const STRING_PAIR_LIST &aRepositories)
	Set list of repositories. More...
void	DiscardRepositoryCache (const wxString &aRepositoryId)
	Discard in-memory and on-disk cache of a repository. More...
void	MarkInstalled (const PCM_PACKAGE &aPackage, const wxString &aVersion, const wxString &aRepositoryId)
	Mark package as installed. More...
void	MarkUninstalled (const PCM_PACKAGE &aPackage)
	Mark package as uninstalled. More...
const STRING_TUPLE_LIST &	GetRepositoryList () const
	Get list of repositories. More...
const bool	CacheRepository (const wxString &aRepositoryId)
	Cache specified repository packages and other metadata. More...
const std::vector< PCM_PACKAGE > &	GetRepositoryPackages (const wxString &aRepositoryId) const
	Get the packages metadata from a previously cached repository. More...
const std::vector< PCM_INSTALLATION_ENTRY >	GetInstalledPackages () const
	Get list of installed packages. More...
const wxString &	GetInstalledPackageVersion (const wxString &aPackageId) const
	Get the current version of an installed package. More...
const wxString &	Get3rdPartyPath () const
PCM_PACKAGE_STATE	GetPackageState (const wxString &aRepositoryId, const wxString &aPackageId)
	Get current state of the package. More...
bool	IsPackagePinned (const wxString &aPackageId) const
	Returns pinned status of a package. More...
void	SetPinned (const wxString &aPackageId, const bool aPinned)
	Set the pinned status of a package. More...
const wxString	GetPackageUpdateVersion (const PCM_PACKAGE &aPackage)
	Get the preferred package update version or empty string if there is none. More...
bool	DownloadToStream (const wxString &aUrl, std::ostream *aOutput, PROGRESS_REPORTER *aReporter, const size_t aSizeLimit=DEFAULT_DOWNLOAD_MEM_LIMIT)
	Downloads url to an output stream. More...
int	GetPackageSearchRank (const PCM_PACKAGE &aPackage, const wxString &aSearchTerm)
	Get the approximate measure of how much given package matches the search term. More...
std::unordered_map< wxString, wxBitmap >	GetRepositoryPackageBitmaps (const wxString &aRepositoryId)
	Get the icon bitmaps for repository packages. More...
std::unordered_map< wxString, wxBitmap >	GetInstalledPackageBitmaps ()
	Get the icon bitmaps for installed packages. More...
void	SetDialogWindow (wxWindow *aDialog)
	Set the Dialog Window. More...
void	RunBackgroundUpdate ()
	Runs a background update thread that checks for new package versions. More...
void	StopBackgroundUpdate ()
	Interrupts and joins() the update thread. More...
void	ReadEnvVar ()
	Stores 3rdparty path from environment variables. More...

Private Member Functions
bool	fetchPackages (const wxString &aUrl, const std::optional< wxString > &aHash, std::vector< PCM_PACKAGE > &aPackages, PROGRESS_REPORTER *aReporter)
	Downloads packages metadata to in memory stream, verifies hash and attempts to parse it. More...
const PCM_REPOSITORY &	getCachedRepository (const wxString &aRepositoryId) const
	Get the cached repository metadata. More...
void	updateInstalledPackagesMetadata (const wxString &aRepositoryId)
	Updates metadata of installed packages from freshly fetched repo. More...
time_t	getCurrentTimestamp () const

Static Private Member Functions
static void	preparePackage (PCM_PACKAGE &aPackage)
	Parses version strings and calculates compatibility. More...

Private Attributes
wxWindow *	m_dialog
nlohmann::json_schema::json_validator	m_schema_validator
wxString	m_3rdparty_path
wxString	m_cache_path
std::unordered_map< wxString, PCM_REPOSITORY >	m_repository_cache
STRING_TUPLE_LIST	m_repository_list
std::map< wxString, PCM_INSTALLATION_ENTRY >	m_installed
std::function< void(int)>	m_availableUpdateCallback
std::function< void(const wxString)>	m_statusCallback
std::thread	m_updateThread
std::shared_ptr< STATUS_TEXT_REPORTER >	m_statusReporter

Static Private Attributes
static constexpr size_t	DEFAULT_DOWNLOAD_MEM_LIMIT = 10 * 1024 * 1024
	< Default download limit of 10 Mb to not use too much memory More...
static const std::tuple< int, int, int >	m_kicad_version

Detailed Description

Main class of Plugin and Content Manager subsystem.

This class handles logistics of repository management, caching, json validation, tracking installed packages and provides some utility methods.

Repository caching is done in $KICADX_3RD_PARTY/cache directory with each repository storing it's metadata, packages and optionally resource files under it's id subdirectory.

Repository id is a prefix of sha256 of it's main url.

JSON schema file is expected to be in $KICAD_DATA/schemas directory

Installed packages are stored in <user_settings>/installed_packages.json If that file is missing PCM will try to reconstruct it from existing directory structure inside $KICADX_3RD_PARTY but package descriptions and other metadata will be lost.

Definition at line 101 of file pcm.h.

Constructor & Destructor Documentation

PLUGIN_CONTENT_MANAGER()

PLUGIN_CONTENT_MANAGER::PLUGIN_CONTENT_MANAGER	(	std::function< void(int)>	aAvailableUpdateCallback,
		std::function< void(const wxString)>	aStatusCallback
	)

Definition at line 97 of file pcm.cpp.

 :
 m_dialog( nullptr ),
 m_availableUpdateCallback( aAvailableUpdateCallback ),
 m_statusCallback( aStatusCallback )
{
 ReadEnvVar();
 
 // Read and store pcm schema
 wxFileName schema_file( PATHS::GetStockDataPath( true ), wxS( "pcm.v1.schema.json" ) );
 schema_file.Normalize( FN_NORMALIZE_FLAGS | wxPATH_NORM_ENV_VARS );
 schema_file.AppendDir( wxS( "schemas" ) );
 
 std::ifstream schema_stream( schema_file.GetFullPath().ToUTF8() );
 nlohmann::json schema;
 
 try
 {
 schema_stream >> schema;
 m_schema_validator.set_root_schema( schema );
 }
 catch( std::exception& e )
 {
 if( !schema_file.FileExists() )
 {
 wxLogError( wxString::Format( _( "schema file '%s' not found" ),
 schema_file.GetFullPath() ) );
 }
 else
 {
 wxLogError( wxString::Format( _( "Error loading schema: %s" ), e.what() ) );
 }
 }
 
 // Load currently installed packages
 wxFileName f( SETTINGS_MANAGER::GetUserSettingsPath(), wxT( "installed_packages.json" ) );
 
 if( f.FileExists() )
 {
 std::ifstream installed_stream( f.GetFullPath().ToUTF8() );
 nlohmann::json installed;
 
 try
 {
 installed_stream >> installed;
 
 if( installed.contains( "packages" ) && installed["packages"].is_array() )
 {
 for( const auto& js_entry : installed["packages"] )
 {
 PCM_INSTALLATION_ENTRY entry = js_entry.get<PCM_INSTALLATION_ENTRY>();
 m_installed.emplace( entry.package.identifier, entry );
 }
 }
 }
 catch( std::exception& e )
 {
 wxLogError( wxString::Format( _( "Error loading installed packages list: %s" ),
 e.what() ) );
 }
 }
 
 // As a fall back populate installed from names of directories
 
 for( const wxString& dir : PCM_PACKAGE_DIRECTORIES )
 {
 wxFileName d( m_3rdparty_path, wxEmptyString );
 d.AppendDir( dir );
 
 if( d.DirExists() )
 {
 wxDir package_dir( d.GetPath() );
 
 if( !package_dir.IsOpened() )
 continue;
 
 wxString subdir;
 bool more = package_dir.GetFirst( &subdir, "", wxDIR_DIRS | wxDIR_HIDDEN );
 
 while( more )
 {
 wxString actual_package_id = subdir;
 actual_package_id.Replace( '_', '.' );
 
 if( m_installed.find( actual_package_id ) == m_installed.end() )
 {
 PCM_INSTALLATION_ENTRY entry;
 wxFileName subdir_file( d.GetPath(), subdir );
 
 // wxFileModificationTime bugs out on windows for directories
 wxStructStat stat;
 int stat_code = wxStat( subdir_file.GetFullPath(), &stat );
 
 entry.package.name = subdir;
 entry.package.identifier = actual_package_id;
 entry.current_version = "0.0";
 entry.repository_name = wxT( "<unknown>" );
 
 if( stat_code == 0 )
 entry.install_timestamp = stat.st_mtime;
 
 PACKAGE_VERSION version;
 version.version = "0.0";
 version.status = PVS_STABLE;
 version.kicad_version = GetMajorMinorVersion();
 
 entry.package.versions.emplace_back( version );
 
 m_installed.emplace( actual_package_id, entry );
 }
 
 more = package_dir.GetNext( &subdir );
 }
 }
 }
 
 // Calculate package compatibility
 std::for_each( m_installed.begin(), m_installed.end(),
 [&]( std::pair<const wxString, PCM_INSTALLATION_ENTRY>& entry )
 {
 preparePackage( entry.second.package );
 } );
}

References _, PCM_INSTALLATION_ENTRY::current_version, FN_NORMALIZE_FLAGS, Format(), GetMajorMinorVersion(), PATHS::GetStockDataPath(), SETTINGS_MANAGER::GetUserSettingsPath(), PCM_PACKAGE::identifier, PCM_INSTALLATION_ENTRY::install_timestamp, PACKAGE_VERSION::kicad_version, m_3rdparty_path, m_installed, m_schema_validator, PCM_PACKAGE::name, PCM_INSTALLATION_ENTRY::package, PCM_PACKAGE_DIRECTORIES(), PVS_STABLE, ReadEnvVar(), PCM_INSTALLATION_ENTRY::repository_name, PACKAGE_VERSION::status, PACKAGE_VERSION::version, and PCM_PACKAGE::versions.

~PLUGIN_CONTENT_MANAGER()

PLUGIN_CONTENT_MANAGER::~PLUGIN_CONTENT_MANAGER

(

)

Definition at line 1207 of file pcm.cpp.

{
 // By the time object is being destroyed the thread should be
 // stopped already but just in case do it here too.
 StopBackgroundUpdate();
}

References StopBackgroundUpdate().

Member Function Documentation

CacheRepository()

const bool PLUGIN_CONTENT_MANAGER::CacheRepository

(

const wxString &

aRepositoryId

)

Cache specified repository packages and other metadata.

This method fetches latest repository metadata, checks if there is cache on disk, compares it's last update timestamp to repository metadata and redownloads packages list if necessary. Then it checks sha256 if provided and parses the package list. Parsed packages metadata is stored in memory.

Process is repeated with resources file except it is just stored on disk and any errors at this stage are ignored.

Parameters

aRepositoryId

id of the repository to cache

Returns

true if packages metadata was cached successfully

Definition at line 414 of file pcm.cpp.

{
 if( m_repository_cache.find( aRepositoryId ) != m_repository_cache.end() )
 return true;
 
 const auto repository_tuple =
 std::find_if( m_repository_list.begin(), m_repository_list.end(),
 [&aRepositoryId]( const std::tuple<wxString, wxString, wxString>& t )
 {
 return std::get<0>( t ) == aRepositoryId;
 } );
 
 if( repository_tuple == m_repository_list.end() )
 return false;
 
 wxString url = std::get<2>( *repository_tuple );
 
 nlohmann::json js;
 PCM_REPOSITORY current_repo;
 
 std::shared_ptr<PROGRESS_REPORTER> reporter;
 
 if( m_dialog )
 reporter = std::make_shared<WX_PROGRESS_REPORTER>( m_dialog, wxEmptyString, 1 );
 else
 reporter = m_statusReporter;
 
 if( !FetchRepository( url, current_repo, reporter.get() ) )
 return false;
 
 bool packages_cache_exists = false;
 
 // First load repository data from local filesystem if available.
 wxFileName repo_cache = wxFileName( PATHS::GetUserCachePath(), wxT( "repository.json" ) );
 repo_cache.AppendDir( wxT( "pcm" ) );
 repo_cache.AppendDir( aRepositoryId );
 wxFileName packages_cache( repo_cache.GetPath(), wxT( "packages.json" ) );
 
 if( repo_cache.FileExists() && packages_cache.FileExists() )
 {
 std::ifstream repo_stream( repo_cache.GetFullPath().ToUTF8() );
 PCM_REPOSITORY saved_repo;
 try
 {
 repo_stream >> js;
 saved_repo = js.get<PCM_REPOSITORY>();
 }
 catch( ... )
 {
 if( m_dialog )
 wxLogError( _( "Failed to parse locally stored repository.json." ) );
 }
 
 if( saved_repo.packages.update_timestamp == current_repo.packages.update_timestamp )
 {
 // Cached repo is up to date, use data on disk
 js.clear();
 std::ifstream packages_cache_stream( packages_cache.GetFullPath().ToUTF8() );
 
 try
 {
 packages_cache_stream >> js;
 saved_repo.package_list = js["packages"].get<std::vector<PCM_PACKAGE>>();
 
 for( size_t i = 0; i < saved_repo.package_list.size(); i++ )
 {
 preparePackage( saved_repo.package_list[i] );
 saved_repo.package_map[saved_repo.package_list[i].identifier] = i;
 }
 
 m_repository_cache[aRepositoryId] = std::move( saved_repo );
 
 packages_cache_exists = true;
 }
 catch( ... )
 {
 if( m_dialog )
 {
 wxLogError( _( "Packages cache for current repository is corrupted, it will "
 "be redownloaded." ) );
 }
 }
 }
 }
 
 if( !packages_cache_exists )
 {
 // Cache doesn't exist or is out of date
 if( !fetchPackages( current_repo.packages.url, current_repo.packages.sha256,
 current_repo.package_list, reporter.get() ) )
 {
 return false;
 }
 
 for( size_t i = 0; i < current_repo.package_list.size(); i++ )
 {
 preparePackage( current_repo.package_list[i] );
 current_repo.package_map[current_repo.package_list[i].identifier] = i;
 }
 
 repo_cache.Mkdir( wxS_DIR_DEFAULT, wxPATH_MKDIR_FULL );
 
 std::ofstream repo_cache_stream( repo_cache.GetFullPath().ToUTF8() );
 repo_cache_stream << std::setw( 4 ) << nlohmann::json( current_repo ) << std::endl;
 
 std::ofstream packages_cache_stream( packages_cache.GetFullPath().ToUTF8() );
 js.clear();
 js["packages"] = nlohmann::json( current_repo.package_list );
 packages_cache_stream << std::setw( 4 ) << js << std::endl;
 
 m_repository_cache[aRepositoryId] = std::move( current_repo );
 }
 
 if( current_repo.resources )
 {
 // Check resources file date, redownload if needed
 PCM_RESOURCE_REFERENCE& resources = *current_repo.resources;
 
 wxFileName resource_file( repo_cache.GetPath(), wxT( "resources.zip" ) );
 
 time_t mtime = 0;
 
 if( resource_file.FileExists() )
 mtime = wxFileModificationTime( resource_file.GetFullPath() );
 
 if( mtime + 600 < getCurrentTimestamp() && mtime < (time_t) resources.update_timestamp )
 {
 std::ofstream resources_stream( resource_file.GetFullPath().ToUTF8(),
 std::ios_base::binary );
 
 reporter->SetTitle( _( "Downloading resources" ) );
 
 // 100 Mb resource file limit
 bool success = DownloadToStream( resources.url, &resources_stream, reporter.get(),
 100 * 1024 * 1024 );
 
 resources_stream.close();
 
 if( success )
 {
 std::ifstream read_stream( resource_file.GetFullPath().ToUTF8(),
 std::ios_base::binary );
 
 
 if( resources.sha256 && !VerifyHash( read_stream, *resources.sha256 ) )
 {
 read_stream.close();
 
 if( m_dialog )
 {
 wxLogError( _( "Resources file hash doesn't match and will not be used. "
 "Repository may be corrupted." ) );
 }
 
 wxRemoveFile( resource_file.GetFullPath() );
 }
 }
 else
 {
 // Not critical, just clean up the file
 wxRemoveFile( resource_file.GetFullPath() );
 }
 }
 }
 
 updateInstalledPackagesMetadata( aRepositoryId );
 
 return true;
}

References _, DownloadToStream(), fetchPackages(), FetchRepository(), getCurrentTimestamp(), PATHS::GetUserCachePath(), m_dialog, m_repository_cache, m_repository_list, m_statusReporter, PCM_REPOSITORY::package_list, PCM_REPOSITORY::package_map, PCM_REPOSITORY::packages, preparePackage(), PCM_REPOSITORY::resources, PCM_RESOURCE_REFERENCE::sha256, PCM_RESOURCE_REFERENCE::update_timestamp, updateInstalledPackagesMetadata(), PCM_RESOURCE_REFERENCE::url, and VerifyHash().

Referenced by GetPackageState().

DiscardRepositoryCache()

void PLUGIN_CONTENT_MANAGER::DiscardRepositoryCache

(

const wxString &

aRepositoryId

)

Discard in-memory and on-disk cache of a repository.

Parameters

aRepositoryId

id of the repository

Definition at line 773 of file pcm.cpp.

{
 if( m_repository_cache.count( aRepositoryId ) > 0 )
 m_repository_cache.erase( aRepositoryId );
 
 wxFileName repo_cache = wxFileName( PATHS::GetUserCachePath(), "" );
 repo_cache.AppendDir( wxT( "pcm" ) );
 repo_cache.AppendDir( aRepositoryId );
 
 if( repo_cache.DirExists() )
 repo_cache.Rmdir( wxPATH_RMDIR_RECURSIVE );
}

References PATHS::GetUserCachePath(), and m_repository_cache.

Referenced by SetRepositoryList().

DownloadToStream()

bool PLUGIN_CONTENT_MANAGER::DownloadToStream	(	const wxString &	aUrl,
		std::ostream *	aOutput,
		PROGRESS_REPORTER *	aReporter,
		const size_t	aSizeLimit = DEFAULT_DOWNLOAD_MEM_LIMIT
	)

Downloads url to an output stream.

Parameters

aUrl	URL to download
aOutput	output stream
aReporter	progress dialog to use
aSizeLimit	maximum download size, 0 for unlimited

Returns

true if download was successful

false if download failed or was too large

Definition at line 236 of file pcm.cpp.

{
 bool size_exceeded = false;
 
 TRANSFER_CALLBACK callback = [&]( size_t dltotal, size_t dlnow, size_t ultotal, size_t ulnow )
 {
 if( aSizeLimit > 0 && ( dltotal > aSizeLimit || dlnow > aSizeLimit ) )
 {
 size_exceeded = true;
 
 // Non zero return means abort.
 return true;
 }
 
 if( dltotal > 1000 )
 {
 aReporter->SetCurrentProgress( dlnow / (double) dltotal );
 aReporter->Report( wxString::Format( _( "Downloading %lld/%lld kB" ), dlnow / 1000,
 dltotal / 1000 ) );
 }
 else
 {
 aReporter->SetCurrentProgress( 0.0 );
 }
 
 return !aReporter->KeepRefreshing();
 };
 
 KICAD_CURL_EASY curl;
 curl.SetOutputStream( aOutput );
 curl.SetURL( aUrl.ToUTF8().data() );
 curl.SetFollowRedirects( true );
 curl.SetTransferCallback( callback, 250000L );
 
 int code = curl.Perform();
 
 if( !aReporter->IsCancelled() )
 aReporter->SetCurrentProgress( 1.0 );
 
 if( code != CURLE_OK )
 {
 if( m_dialog )
 {
 if( code == CURLE_ABORTED_BY_CALLBACK && size_exceeded )
 wxMessageBox( _( "Download is too large." ) );
 else if( code != CURLE_ABORTED_BY_CALLBACK )
 wxLogError( wxString( curl.GetErrorText( code ) ) );
 }
 
 return false;
 }
 
 return true;
}

References _, Format(), KICAD_CURL_EASY::GetErrorText(), PROGRESS_REPORTER::IsCancelled(), PROGRESS_REPORTER::KeepRefreshing(), m_dialog, KICAD_CURL_EASY::Perform(), PROGRESS_REPORTER::Report(), PROGRESS_REPORTER::SetCurrentProgress(), KICAD_CURL_EASY::SetFollowRedirects(), KICAD_CURL_EASY::SetOutputStream(), KICAD_CURL_EASY::SetTransferCallback(), and KICAD_CURL_EASY::SetURL().

Referenced by CacheRepository(), fetchPackages(), and FetchRepository().

fetchPackages()

bool PLUGIN_CONTENT_MANAGER::fetchPackages ( const wxString &  aUrl, const std::optional< wxString > &  aHash, std::vector< PCM_PACKAGE > &  aPackages, PROGRESS_REPORTER *  aReporter  )

private

Downloads packages metadata to in memory stream, verifies hash and attempts to parse it.

Parameters

aUrl	URL of the packages metadata
aHash	optional sha256 hash
aPackages	resulting packages metadata list
aReporter	progress dialog to use for download

Returns

true if packages were successfully downloaded, verified and parsed

Definition at line 343 of file pcm.cpp.

{
 std::stringstream packages_stream;
 
 aReporter->SetTitle( _( "Fetching repository packages" ) );
 
 if( !DownloadToStream( aUrl, &packages_stream, aReporter ) )
 {
 if( m_dialog )
 wxLogError( _( "Unable to load repository packages url." ) );
 
 return false;
 }
 
 std::istringstream isstream( packages_stream.str() );
 
 if( aHash && !VerifyHash( isstream, *aHash ) )
 {
 if( m_dialog )
 wxLogError( _( "Packages hash doesn't match. Repository may be corrupted." ) );
 
 return false;
 }
 
 try
 {
 nlohmann::json packages_json = nlohmann::json::parse( packages_stream.str() );
 ValidateJson( packages_json, nlohmann::json_uri( "#/definitions/PackageArray" ) );
 
 aPackages = packages_json["packages"].get<std::vector<PCM_PACKAGE>>();
 }
 catch( std::exception& e )
 {
 if( m_dialog )
 {
 wxLogError( wxString::Format( _( "Unable to parse packages metadata:\n\n%s" ),
 e.what() ) );
 }
 
 return false;
 }
 
 return true;
}

References _, DownloadToStream(), Format(), m_dialog, parse(), PROGRESS_REPORTER::SetTitle(), ValidateJson(), and VerifyHash().

Referenced by CacheRepository().

FetchRepository()

bool PLUGIN_CONTENT_MANAGER::FetchRepository	(	const wxString &	aUrl,
		PCM_REPOSITORY &	aRepository,
		PROGRESS_REPORTER *	aReporter
	)

Fetches repository metadata from given url.

Parameters

aUrl	URL of the repository
aRepository	fetched repository metadata
aReporter	progress reporter dialog to use for download

Returns

true if successful

false if URL could not be downloaded or result could not be parsed

Definition at line 294 of file pcm.cpp.

{
 std::stringstream repository_stream;
 
 aReporter->SetTitle( _( "Fetching repository" ) );
 
 if( !DownloadToStream( aUrl, &repository_stream, aReporter, 20480 ) )
 {
 if( m_dialog )
 wxLogError( _( "Unable to load repository url" ) );
 
 return false;
 }
 
 nlohmann::json repository_json;
 
 try
 {
 repository_stream >> repository_json;
 
 ValidateJson( repository_json, nlohmann::json_uri( "#/definitions/Repository" ) );
 
 aRepository = repository_json.get<PCM_REPOSITORY>();
 }
 catch( const std::exception& e )
 {
 if( m_dialog )
 {
 wxLogError( wxString::Format( _( "Unable to parse repository: %s" ), e.what() ) );
 wxLogError( _( "The given repository URL does not look like a valid KiCad package "
 "repository. Please double check the URL." ) );
 }
 
 return false;
 }
 
 return true;
}

References _, DownloadToStream(), Format(), m_dialog, PROGRESS_REPORTER::SetTitle(), and ValidateJson().

Referenced by CacheRepository().

Get3rdPartyPath()

const wxString & PLUGIN_CONTENT_MANAGER::Get3rdPartyPath ( ) const

inline

Definition at line 232 of file pcm.h.

{ return m_3rdparty_path; };

References m_3rdparty_path.

getCachedRepository()

const PCM_REPOSITORY & PLUGIN_CONTENT_MANAGER::getCachedRepository ( const wxString &  aRepositoryId ) const

private

Get the cached repository metadata.

Parameters

aRepositoryId

id of the repository

Returns

const PCM_REPOSITORY&

Definition at line 405 of file pcm.cpp.

{
 wxASSERT_MSG( m_repository_cache.find( aRepositoryId ) != m_repository_cache.end(),
 wxT( "Repository is not cached." ) );
 
 return m_repository_cache.at( aRepositoryId );
}

References m_repository_cache.

Referenced by GetPackageState(), GetRepositoryPackages(), MarkInstalled(), and updateInstalledPackagesMetadata().

getCurrentTimestamp()

time_t PLUGIN_CONTENT_MANAGER::getCurrentTimestamp ( ) const

private

Definition at line 903 of file pcm.cpp.

{
 return std::chrono::duration_cast<std::chrono::seconds>(
 std::chrono::system_clock::now().time_since_epoch() ).count();
}

Referenced by CacheRepository(), and MarkInstalled().

GetInstalledPackageBitmaps()

std::unordered_map< wxString, wxBitmap > PLUGIN_CONTENT_MANAGER::GetInstalledPackageBitmaps

(

)

Get the icon bitmaps for installed packages.

Icons for installed packages are taken from package extracted files in $KICADX_3RD_PARTY/resources/<packageid> directories

Returns

map of package id -> bitmap

Definition at line 1088 of file pcm.cpp.

{
 std::unordered_map<wxString, wxBitmap> bitmaps;
 
 wxFileName resources_dir_fn( m_3rdparty_path, wxEmptyString );
 resources_dir_fn.AppendDir( wxT( "resources" ) );
 wxDir resources_dir( resources_dir_fn.GetPath() );
 
 if( !resources_dir.IsOpened() )
 return bitmaps;
 
 wxString subdir;
 bool more = resources_dir.GetFirst( &subdir, wxEmptyString, wxDIR_DIRS | wxDIR_HIDDEN );
 
 while( more )
 {
 wxFileName icon( resources_dir_fn.GetPath(), wxT( "icon.png" ) );
 icon.AppendDir( subdir );
 
 if( icon.FileExists() )
 {
 wxString actual_package_id = subdir;
 actual_package_id.Replace( '_', '.' );
 
 try
 {
 wxBitmap bitmap( icon.GetFullPath(), wxBITMAP_TYPE_PNG );
 bitmaps.emplace( actual_package_id, bitmap );
 }
 catch( ... )
 {
 // Log and ignore
 wxLogTrace( wxT( "Error loading png bitmap from %s" ), icon.GetFullPath() );
 }
 }
 
 more = resources_dir.GetNext( &subdir );
 }
 
 return bitmaps;
}

References m_3rdparty_path.

GetInstalledPackages()

const std::vector< PCM_INSTALLATION_ENTRY > PLUGIN_CONTENT_MANAGER::GetInstalledPackages

(

)

const

Get list of installed packages.

Returns

vector of PCM_INSTALLATION_ENTRY objects

Definition at line 934 of file pcm.cpp.

{
 std::vector<PCM_INSTALLATION_ENTRY> v;
 
 std::for_each( m_installed.begin(), m_installed.end(),
 [&v]( const std::pair<const wxString, PCM_INSTALLATION_ENTRY>& entry )
 {
 v.push_back( entry.second );
 } );
 
 std::sort( v.begin(), v.end(),
 []( const PCM_INSTALLATION_ENTRY& a, const PCM_INSTALLATION_ENTRY& b )
 {
 return ( a.install_timestamp < b.install_timestamp )
 || ( a.install_timestamp == b.install_timestamp
 && a.package.identifier < b.package.identifier );
 } );
 
 return v;
}

References m_installed.

GetInstalledPackageVersion()

const wxString & PLUGIN_CONTENT_MANAGER::GetInstalledPackageVersion

(

const wxString &

aPackageId

)

const

Get the current version of an installed package.

Parameters

aPackageId

id of the package

Returns

current version

Exceptions

std::out_of_range

if package with given id is not installed Returns current 3rd party directory path

Definition at line 957 of file pcm.cpp.

{
 wxASSERT_MSG( m_installed.find( aPackageId ) != m_installed.end(),
 wxT( "Installed package not found." ) );
 
 return m_installed.at( aPackageId ).current_version;
}

References m_installed.

GetPackageSearchRank()

int PLUGIN_CONTENT_MANAGER::GetPackageSearchRank	(	const PCM_PACKAGE &	aPackage,
		const wxString &	aSearchTerm
	)

Get the approximate measure of how much given package matches the search term.

Parameters

aPackage	package metadata object
aSearchTerm	search term

Returns

int search rank, higher number means better match, 0 means no match

Definition at line 984 of file pcm.cpp.

{
 wxArrayString terms = wxStringTokenize( aSearchTerm.Lower(), wxS( " " ), wxTOKEN_STRTOK );
 int rank = 0;
 
 const auto find_term_matches =
 [&]( const wxString& str )
 {
 int result = 0;
 wxString lower = str.Lower();
 
 for( const wxString& term : terms )
 {
 if( lower.Find( term ) != wxNOT_FOUND )
 result += 1;
 }
 
 return result;
 };
 
 // Match on package id
 if( terms.size() == 1 && terms[0] == aPackage.identifier )
 rank += 10000;
 
 if( terms.size() == 1 && find_term_matches( aPackage.identifier ) )
 rank += 1000;
 
 // Match on package name
 rank += 500 * find_term_matches( aPackage.name );
 
 // Match on tags
 for( const std::string& tag : aPackage.tags )
 rank += 100 * find_term_matches( wxString( tag ) );
 
 // Match on package description
 rank += 10 * find_term_matches( aPackage.description );
 rank += 10 * find_term_matches( aPackage.description_full );
 
 // Match on author/maintainer
 rank += find_term_matches( aPackage.author.name );
 
 if( aPackage.maintainer )
 rank += 3 * find_term_matches( aPackage.maintainer->name );
 
 // Match on resources
 for( const std::pair<const std::string, wxString>& entry : aPackage.resources )
 {
 rank += find_term_matches( entry.first );
 rank += find_term_matches( entry.second );
 }
 
 // Match on license
 if( terms.size() == 1 && terms[0] == aPackage.license )
 rank += 1;
 
 return rank;
}

References PCM_PACKAGE::author, PCM_PACKAGE::description, PCM_PACKAGE::description_full, PCM_PACKAGE::identifier, PCM_PACKAGE::license, PCM_PACKAGE::maintainer, PCM_CONTACT::name, PCM_PACKAGE::name, PCM_PACKAGE::resources, and PCM_PACKAGE::tags.

GetPackageState()

PCM_PACKAGE_STATE PLUGIN_CONTENT_MANAGER::GetPackageState	(	const wxString &	aRepositoryId,
		const wxString &	aPackageId
	)

Get current state of the package.

Parameters

aRepositoryId	repository id
aPackageId	package id

Returns

PCM_PACKAGE_STATE

Definition at line 829 of file pcm.cpp.

{
 bool installed = m_installed.find( aPackageId ) != m_installed.end();
 
 if( aRepositoryId.IsEmpty() || !CacheRepository( aRepositoryId ) )
 return installed ? PPS_INSTALLED : PPS_UNAVAILABLE;
 
 const PCM_REPOSITORY* repo;
 
 try
 {
 repo = &getCachedRepository( aRepositoryId );
 }
 catch( ... )
 {
 return installed ? PPS_INSTALLED : PPS_UNAVAILABLE;
 }
 
 if( repo->package_map.count( aPackageId ) == 0 )
 return installed ? PPS_INSTALLED : PPS_UNAVAILABLE;
 
 const PCM_PACKAGE& pkg = repo->package_list[repo->package_map.at( aPackageId )];
 
 if( installed )
 {
 // Package is installed, check for available updates at the same or
 // higher (numerically lower) version stability level
 wxString update_version = GetPackageUpdateVersion( pkg );
 
 return update_version.IsEmpty() ? PPS_INSTALLED : PPS_UPDATE_AVAILABLE;
 }
 else
 {
 // Find any compatible version
 auto ver_it = std::find_if( pkg.versions.begin(), pkg.versions.end(),
 []( const PACKAGE_VERSION& ver )
 {
 return ver.compatible;
 } );
 
 return ver_it == pkg.versions.end() ? PPS_UNAVAILABLE : PPS_AVAILABLE;
 }
}

References CacheRepository(), getCachedRepository(), GetPackageUpdateVersion(), m_installed, PCM_REPOSITORY::package_list, PCM_REPOSITORY::package_map, PPS_AVAILABLE, PPS_INSTALLED, PPS_UNAVAILABLE, PPS_UPDATE_AVAILABLE, and PCM_PACKAGE::versions.

GetPackageUpdateVersion()

const wxString PLUGIN_CONTENT_MANAGER::GetPackageUpdateVersion

(

const PCM_PACKAGE &

aPackage

)

Get the preferred package update version or empty string if there is none.

Works only for installed packages and returns highest compatible version greater than currently installed that is at the same or higher (numerically lower) version stability level.

Parameters

aPackage

package

Returns

package version string

Definition at line 875 of file pcm.cpp.

{
 wxASSERT_MSG( m_installed.find( aPackage.identifier ) != m_installed.end(),
 wxT( "GetPackageUpdateVersion called on a not installed package" ) );
 
 const PCM_INSTALLATION_ENTRY& entry = m_installed.at( aPackage.identifier );
 
 auto installed_ver_it = std::find_if(
 entry.package.versions.begin(), entry.package.versions.end(),
 [&]( const PACKAGE_VERSION& ver )
 {
 return ver.version == entry.current_version;
 } );
 
 wxASSERT_MSG( installed_ver_it != entry.package.versions.end(),
 wxT( "Installed package version not found" ) );
 
 auto ver_it = std::find_if( aPackage.versions.begin(), aPackage.versions.end(),
  [&]( const PACKAGE_VERSION& ver )
 {
 return ver.compatible
 && installed_ver_it->status >= ver.status
 && installed_ver_it->parsed_version < ver.parsed_version;
 } );
 
 return ver_it == aPackage.versions.end() ? wxString( wxT( "" ) ) : ver_it->version;
}

References PCM_PACKAGE::identifier, m_installed, PCM_INSTALLATION_ENTRY::package, and PCM_PACKAGE::versions.

Referenced by GetPackageState().

GetRepositoryList()

const STRING_TUPLE_LIST & PLUGIN_CONTENT_MANAGER::GetRepositoryList ( ) const

inline

Get list of repositories.

Returns

const STRING_TUPLE_LIST& list of repositories in <id, URL, name> tuple format

Definition at line 186 of file pcm.h.

{ return m_repository_list; }

References m_repository_list.

GetRepositoryPackageBitmaps()

std::unordered_map< wxString, wxBitmap > PLUGIN_CONTENT_MANAGER::GetRepositoryPackageBitmaps

(

const wxString &

aRepositoryId

)

Get the icon bitmaps for repository packages.

Repository package icons are taken from repository's resources zip file

Parameters

aRepositoryId

id of the repository

Returns

map of package id -> bitmap

Definition at line 1045 of file pcm.cpp.

{
 std::unordered_map<wxString, wxBitmap> bitmaps;
 
 wxFileName resources_file = wxFileName( PATHS::GetUserCachePath(), wxT( "resources.zip" ) );
 resources_file.AppendDir( wxT( "pcm" ) );
 resources_file.AppendDir( aRepositoryId );
 
 if( !resources_file.FileExists() )
 return bitmaps;
 
 wxFFileInputStream stream( resources_file.GetFullPath() );
 wxZipInputStream zip( stream );
 
 if( !zip.IsOk() || zip.GetTotalEntries() == 0 )
 return bitmaps;
 
 for( wxArchiveEntry* entry = zip.GetNextEntry(); entry; entry = zip.GetNextEntry() )
 {
 wxArrayString path_parts = wxSplit( entry->GetName(), wxFileName::GetPathSeparator(),
 (wxChar) 0 );
 
 if( path_parts.size() != 2 || path_parts[1] != wxT( "icon.png" ) )
 continue;
 
 try
 {
 wxMemoryInputStream image_stream( zip, entry->GetSize() );
 wxImage image( image_stream, wxBITMAP_TYPE_PNG );
 bitmaps.emplace( path_parts[0], wxBitmap( image ) );
 }
 catch( ... )
 {
 // Log and ignore
 wxLogTrace( wxT( "Error loading png bitmap for entry %s from %s" ), entry->GetName(),
 resources_file.GetFullPath() );
 }
 }
 
 return bitmaps;
}

References PATHS::GetUserCachePath(), image, and zip.

GetRepositoryPackages()

const std::vector< PCM_PACKAGE > & PLUGIN_CONTENT_MANAGER::GetRepositoryPackages

(

const wxString &

aRepositoryId

)

const

Get the packages metadata from a previously cached repository.

This should only be called after a successful CacheRepository call

Parameters

aRepositoryId

id of the repository

Returns

list of package metadata objects

Definition at line 729 of file pcm.cpp.

{
 static std::vector<PCM_PACKAGE> empty{};
 
 try
 {
 return getCachedRepository( aRepositoryId ).package_list;
 }
 catch( ... )
 {
 return empty;
 }
}

References empty(), getCachedRepository(), and PCM_REPOSITORY::package_list.

IsPackagePinned()

bool PLUGIN_CONTENT_MANAGER::IsPackagePinned

(

const wxString &

aPackageId

)

const

Returns pinned status of a package.

Parameters

aPackageId

package id

Returns

true if package is installed and is pinned

false if package is not installed or not pinned

Definition at line 966 of file pcm.cpp.

{
 if( m_installed.find( aPackageId ) == m_installed.end() )
 return false;
 
 return m_installed.at( aPackageId ).pinned;
}

References m_installed.

MarkInstalled()

void PLUGIN_CONTENT_MANAGER::MarkInstalled	(	const PCM_PACKAGE &	aPackage,
		const wxString &	aVersion,
		const wxString &	aRepositoryId
	)

Mark package as installed.

Parameters

aPackage	package metadata
aVersion	installed package version
aRepositoryId	id of the source repository or empty estring if installed from a local file

Definition at line 787 of file pcm.cpp.

{
 // In case of package update remove old data but keep pinned state
 bool pinned = false;
 
 if( m_installed.count( aPackage.identifier ) )
 {
 pinned = m_installed.at( aPackage.identifier ).pinned;
 MarkUninstalled( aPackage );
 }
 
 PCM_INSTALLATION_ENTRY entry;
 entry.package = aPackage;
 entry.current_version = aVersion;
 entry.repository_id = aRepositoryId;
 
 try
 {
 if( !aRepositoryId.IsEmpty() )
 entry.repository_name = getCachedRepository( aRepositoryId ).name;
 else
 entry.repository_name = _( "Local file" );
 }
 catch( ... )
 {
 entry.repository_name = _( "Unknown" );
 }
 
 entry.install_timestamp = getCurrentTimestamp();
 entry.pinned = pinned;
 
 m_installed.emplace( aPackage.identifier, entry );
}

References _, PCM_INSTALLATION_ENTRY::current_version, getCachedRepository(), getCurrentTimestamp(), PCM_PACKAGE::identifier, PCM_INSTALLATION_ENTRY::install_timestamp, m_installed, MarkUninstalled(), PCM_REPOSITORY::name, PCM_INSTALLATION_ENTRY::package, PCM_INSTALLATION_ENTRY::pinned, PCM_INSTALLATION_ENTRY::repository_id, and PCM_INSTALLATION_ENTRY::repository_name.

MarkUninstalled()

void PLUGIN_CONTENT_MANAGER::MarkUninstalled

(

const PCM_PACKAGE &

aPackage

)

Mark package as uninstalled.

Parameters

aPackage

package metadata

Definition at line 823 of file pcm.cpp.

{
 m_installed.erase( aPackage.identifier );
}

References PCM_PACKAGE::identifier, and m_installed.

Referenced by MarkInstalled().

preparePackage()

void PLUGIN_CONTENT_MANAGER::preparePackage ( PCM_PACKAGE &  aPackage )

staticprivate

Parses version strings and calculates compatibility.

This should be called after loading package metadata from repository or from installation entries

Parameters

aPackage

package metadata object Returns current UTC timestamp

Definition at line 649 of file pcm.cpp.

{
 // Parse package version strings
 for( PACKAGE_VERSION& ver : aPackage.versions )
 {
 int epoch = 0, major = 0, minor = 0, patch = 0;
 
 if( ver.version_epoch )
 epoch = *ver.version_epoch;
 
 wxStringTokenizer version_tokenizer( ver.version, wxT( "." ) );
 
 major = wxAtoi( version_tokenizer.GetNextToken() );
 
 if( version_tokenizer.HasMoreTokens() )
 minor = wxAtoi( version_tokenizer.GetNextToken() );
 
 if( version_tokenizer.HasMoreTokens() )
 patch = wxAtoi( version_tokenizer.GetNextToken() );
 
 ver.parsed_version = std::make_tuple( epoch, major, minor, patch );
 
 // Determine compatibility
 ver.compatible = true;
 
 auto parse_version_tuple =
 []( const wxString& version, int deflt )
 {
 int ver_major = deflt;
 int ver_minor = deflt;
 int ver_patch = deflt;
 
 wxStringTokenizer tokenizer( version, wxT( "." ) );
 
 ver_major = wxAtoi( tokenizer.GetNextToken() );
 
 if( tokenizer.HasMoreTokens() )
 ver_minor = wxAtoi( tokenizer.GetNextToken() );
 
 if( tokenizer.HasMoreTokens() )
 ver_patch = wxAtoi( tokenizer.GetNextToken() );
 
 return std::tuple<int, int, int>( ver_major, ver_minor, ver_patch );
 };
 
 if( parse_version_tuple( ver.kicad_version, 0 ) > m_kicad_version )
 ver.compatible = false;
 
 if( ver.kicad_version_max
 && parse_version_tuple( *ver.kicad_version_max, 999 ) < m_kicad_version )
 ver.compatible = false;
 
#ifdef __WXMSW__
 wxString platform = wxT( "windows" );
#endif
#ifdef __WXOSX__
 wxString platform = wxT( "macos" );
#endif
#ifdef __WXGTK__
 wxString platform = wxT( "linux" );
#endif
 
 if( ver.platforms.size() > 0
 && std::find( ver.platforms.begin(), ver.platforms.end(), platform )
 == ver.platforms.end() )
 {
 ver.compatible = false;
 }
 }
 
 // Sort by descending version
 std::sort( aPackage.versions.begin(), aPackage.versions.end(),
 []( const PACKAGE_VERSION& a, const PACKAGE_VERSION& b )
 {
 return a.parsed_version > b.parsed_version;
 } );
}

References PACKAGE_VERSION::compatible, PACKAGE_VERSION::kicad_version, PACKAGE_VERSION::kicad_version_max, m_kicad_version, PACKAGE_VERSION::parsed_version, PACKAGE_VERSION::platforms, PACKAGE_VERSION::version, PACKAGE_VERSION::version_epoch, and PCM_PACKAGE::versions.

Referenced by CacheRepository().

ReadEnvVar()

void PLUGIN_CONTENT_MANAGER::ReadEnvVar

(

)

Stores 3rdparty path from environment variables.

Definition at line 223 of file pcm.cpp.

{
 // Get 3rd party path
 const ENV_VAR_MAP& env = Pgm().GetLocalEnvVariables();
 auto it = env.find( wxT( "KICAD7_3RD_PARTY" ) );
 
 if( it != env.end() && !it->second.GetValue().IsEmpty() )
 m_3rdparty_path = it->second.GetValue();
 else
 m_3rdparty_path = PATHS::GetDefault3rdPartyPath();
}

References PATHS::GetDefault3rdPartyPath(), m_3rdparty_path, and Pgm().

Referenced by PLUGIN_CONTENT_MANAGER().

RunBackgroundUpdate()

void PLUGIN_CONTENT_MANAGER::RunBackgroundUpdate

(

)

Runs a background update thread that checks for new package versions.

Definition at line 1131 of file pcm.cpp.

{
 // If the thread is already running don't create it again
 if( m_updateThread.joinable() )
 return;
 
 m_statusReporter = std::make_shared<STATUS_TEXT_REPORTER>( m_statusCallback );
 
 m_updateThread = std::thread(
 [this]()
 {
 if( m_installed.size() == 0 )
 return;
 
 // Only fetch repositories that have installed not pinned packages
 std::unordered_set<wxString> repo_ids;
 
 for( std::pair<const wxString, PCM_INSTALLATION_ENTRY>& pair : m_installed )
 {
 if( !pair.second.pinned )
 repo_ids.insert( pair.second.repository_id );
 }
 
 for( const auto& [ repository_id, name, url ] : m_repository_list )
 {
 if( repo_ids.count( repository_id ) == 0 )
 continue;
 
 CacheRepository( repository_id );
 
 if( m_statusReporter->IsCancelled() )
 break;
 }
 
 if( m_statusReporter->IsCancelled() )
 return;
 
 // Count packages with updates
 int availableUpdateCount = 0;
 
 for( std::pair<const wxString, PCM_INSTALLATION_ENTRY>& pair : m_installed )
 {
 PCM_INSTALLATION_ENTRY& entry = pair.second;
 
 if( m_repository_cache.find( entry.repository_id ) != m_repository_cache.end() )
 {
 PCM_PACKAGE_STATE state = GetPackageState( entry.repository_id,
 entry.package.identifier );
 
 if( state == PPS_UPDATE_AVAILABLE && !entry.pinned )
 availableUpdateCount++;
 }
 
 if( m_statusReporter->IsCancelled() )
 return;
 }
 
 // Update the badge on PCM button
 m_availableUpdateCallback( availableUpdateCount );
 
 m_statusCallback( availableUpdateCount > 0 ? _( "Package updates are available" )
 : _( "No package updates available" ) );
 } );
}

References _, m_availableUpdateCallback, m_installed, m_repository_list, m_statusCallback, m_statusReporter, m_updateThread, and name.

SaveInstalledPackages()

void PLUGIN_CONTENT_MANAGER::SaveInstalledPackages

(

)

Saves metadata of installed packages to disk.

Path is <user settings>/installed_packages.json

Definition at line 910 of file pcm.cpp.

{
 try
 {
 nlohmann::json js;
 js["packages"] = nlohmann::json::array();
 
 for( std::pair<const wxString, PCM_INSTALLATION_ENTRY>& pair : m_installed )
 {
 js["packages"].emplace_back( pair.second );
 }
 
 wxFileName f( SETTINGS_MANAGER::GetUserSettingsPath(), wxT( "installed_packages.json" ) );
 std::ofstream stream( f.GetFullPath().ToUTF8() );
 
 stream << std::setw( 4 ) << js << std::endl;
 }
 catch( nlohmann::detail::exception& )
 {
 // Ignore
 }
}

References SETTINGS_MANAGER::GetUserSettingsPath(), and m_installed.

SetDialogWindow()

void PLUGIN_CONTENT_MANAGER::SetDialogWindow ( wxWindow *  aDialog )

inline

Set the Dialog Window.

PCM can effectively run in "silent" mode with a background thread that reports to kicad manager window status bar. Setting valid window pointer here will switch it to GUI mode with WX_PROGRESS_DIALOG popup for downloads.

Parameters

aDialog

parent dialog for progress window

Definition at line 327 of file pcm.h.

{ m_dialog = aDialog; };

References m_dialog.

SetPinned()

void PLUGIN_CONTENT_MANAGER::SetPinned	(	const wxString &	aPackageId,
		const bool	aPinned
	)

Set the pinned status of a package.

no-op for not installed packages

Parameters

aPackageId	package id
aPinned	pinned status

Definition at line 975 of file pcm.cpp.

{
 if( m_installed.find( aPackageId ) == m_installed.end() )
 return;
 
 m_installed.at( aPackageId ).pinned = aPinned;
}

References m_installed.

SetRepositoryList()

void PLUGIN_CONTENT_MANAGER::SetRepositoryList

(

const STRING_PAIR_LIST &

aRepositories

)

Set list of repositories.

Discards cache of repositories that were previously cached but are not on the new list of repositories.

Parameters

aRepositories

list of <URL, name> pairs of repositories

Definition at line 744 of file pcm.cpp.

{
 // Clean up cache folder if repository is not in new list
 for( const std::tuple<wxString, wxString, wxString>& entry : m_repository_list )
 {
 auto it = std::find_if( aRepositories.begin(), aRepositories.end(),
 [&]( const auto& new_entry )
 {
 return new_entry.first == std::get<1>( entry );
 } );
 
 if( it == aRepositories.end() )
 {
 DiscardRepositoryCache( std::get<0>( entry ) );
 }
 }
 
 m_repository_list.clear();
 m_repository_cache.clear();
 
 for( const std::pair<wxString, wxString>& repo : aRepositories )
 {
 std::string url_sha = picosha2::hash256_hex_string( repo.second );
 m_repository_list.push_back( std::make_tuple( url_sha.substr( 0, 16 ), repo.first,
 repo.second ) );
 }
}

References DiscardRepositoryCache(), m_repository_cache, and m_repository_list.

StopBackgroundUpdate()

void PLUGIN_CONTENT_MANAGER::StopBackgroundUpdate

(

)

Interrupts and joins() the update thread.

Definition at line 1197 of file pcm.cpp.

{
 if( m_updateThread.joinable() )
 {
 m_statusReporter->Cancel();
 m_updateThread.join();
 }
}

References m_statusReporter, and m_updateThread.

Referenced by ~PLUGIN_CONTENT_MANAGER().

updateInstalledPackagesMetadata()

void PLUGIN_CONTENT_MANAGER::updateInstalledPackagesMetadata ( const wxString &  aRepositoryId )

private

Updates metadata of installed packages from freshly fetched repo.

This completely replaces all fields including description. Only exception is versions field, if currently installed version is missing from the repo metadata it is manually added back in to correctly display in the installed packages.

Parameters

aRepositoryId

Definition at line 585 of file pcm.cpp.

{
 const PCM_REPOSITORY* repository;
 
 try
 {
 repository = &getCachedRepository( aRepositoryId );
 }
 catch( ... )
 {
 wxLogDebug( "Invalid/Missing repository " + aRepositoryId );
 return;
 }
 
 for( std::pair<const wxString, PCM_INSTALLATION_ENTRY>& pair : m_installed )
 {
 PCM_INSTALLATION_ENTRY& entry = pair.second;
 
 // If current package is not from this repository, skip it
 if( entry.repository_id != aRepositoryId )
 continue;
 
 // If current package is no longer in this repository, keep it as is
 if( repository->package_map.count( entry.package.identifier ) == 0 )
 continue;
 
 std::optional<PACKAGE_VERSION> current_version;
 
 auto current_version_it =
 std::find_if( entry.package.versions.begin(), entry.package.versions.end(),
 [&]( const PACKAGE_VERSION& version )
 {
 return version.version == entry.current_version;
 } );
 
 if( current_version_it != entry.package.versions.end() )
 current_version = *current_version_it; // copy
 
 // Copy repository metadata into installation entry
 entry.package = repository->package_list[repository->package_map.at( entry.package.identifier )];
 
 // Insert current version if it's missing from repository metadata
 current_version_it =
 std::find_if( entry.package.versions.begin(), entry.package.versions.end(),
 [&]( const PACKAGE_VERSION& version )
 {
 return version.version == entry.current_version;
 } );
 
 if( current_version_it == entry.package.versions.end() )
 {
 entry.package.versions.emplace_back( *current_version );
 
 // Re-sort the versions by descending version
 std::sort( entry.package.versions.begin(), entry.package.versions.end(),
 []( const PACKAGE_VERSION& a, const PACKAGE_VERSION& b )
 {
 return a.parsed_version > b.parsed_version;
 } );
 }
 }
}

References getCachedRepository(), PCM_PACKAGE::identifier, m_installed, PCM_INSTALLATION_ENTRY::package, PCM_REPOSITORY::package_list, PCM_REPOSITORY::package_map, PCM_INSTALLATION_ENTRY::repository_id, and PCM_PACKAGE::versions.

Referenced by CacheRepository().

ValidateJson()

void PLUGIN_CONTENT_MANAGER::ValidateJson	(	const nlohmann::json &	aJson,
		const nlohmann::json_uri &	aUri = nlohmann::json_uri( "#" )
	)		const

Validates json against a specific definition in the PCM schema.

Parameters

aJson	JSON object to validate
aUri	JSON URI of a definition to validate against, default is root

Exceptions

std::invalid_argument

on validation failure

Definition at line 335 of file pcm.cpp.

{
 THROWING_ERROR_HANDLER error_handler;
 m_schema_validator.validate( aJson, error_handler, aUri );
}

References m_schema_validator.

Referenced by fetchPackages(), and FetchRepository().

VerifyHash()

bool PLUGIN_CONTENT_MANAGER::VerifyHash	(	std::istream &	aStream,
		const wxString &	aHash
	)		const

Verifies SHA256 hash of a binary stream.

Parameters

aStream	input stream
aHash	sha256 lowercase hex string

Returns

true if hash matches

Definition at line 392 of file pcm.cpp.

{
 std::vector<unsigned char> bytes( picosha2::k_digest_size );
 
 picosha2::hash256( std::istreambuf_iterator<char>( aStream ), std::istreambuf_iterator<char>(),
 bytes.begin(), bytes.end() );
 std::string hex_str = picosha2::bytes_to_hex_string( bytes.begin(), bytes.end() );
 
 return aHash.compare( hex_str ) == 0;
}

Referenced by CacheRepository(), and fetchPackages().

Member Data Documentation

DEFAULT_DOWNLOAD_MEM_LIMIT

constexpr size_t PLUGIN_CONTENT_MANAGER::DEFAULT_DOWNLOAD_MEM_LIMIT = 10 * 1024 * 1024

staticconstexprprivate

< Default download limit of 10 Mb to not use too much memory

Definition at line 346 of file pcm.h.

m_3rdparty_path

wxString PLUGIN_CONTENT_MANAGER::m_3rdparty_path

private

Definition at line 395 of file pcm.h.

Referenced by Get3rdPartyPath(), GetInstalledPackageBitmaps(), PLUGIN_CONTENT_MANAGER(), and ReadEnvVar().

m_availableUpdateCallback

std::function<void( int )> PLUGIN_CONTENT_MANAGER::m_availableUpdateCallback

private

Definition at line 402 of file pcm.h.

Referenced by RunBackgroundUpdate().

m_cache_path

wxString PLUGIN_CONTENT_MANAGER::m_cache_path

private

Definition at line 396 of file pcm.h.

m_dialog

wxWindow* PLUGIN_CONTENT_MANAGER::m_dialog

private

Definition at line 393 of file pcm.h.

Referenced by CacheRepository(), DownloadToStream(), fetchPackages(), FetchRepository(), and SetDialogWindow().

m_installed

std::map<wxString, PCM_INSTALLATION_ENTRY> PLUGIN_CONTENT_MANAGER::m_installed

private

Definition at line 400 of file pcm.h.

Referenced by GetInstalledPackages(), GetInstalledPackageVersion(), GetPackageState(), GetPackageUpdateVersion(), IsPackagePinned(), MarkInstalled(), MarkUninstalled(), PLUGIN_CONTENT_MANAGER(), RunBackgroundUpdate(), SaveInstalledPackages(), SetPinned(), and updateInstalledPackagesMetadata().

m_kicad_version

const std::tuple< int, int, int > PLUGIN_CONTENT_MANAGER::m_kicad_version

staticprivate

Initial value:

=
 GetMajorMinorPatchTuple()

Definition at line 401 of file pcm.h.

Referenced by preparePackage().

m_repository_cache

std::unordered_map<wxString, PCM_REPOSITORY> PLUGIN_CONTENT_MANAGER::m_repository_cache

private

Definition at line 397 of file pcm.h.

Referenced by CacheRepository(), DiscardRepositoryCache(), getCachedRepository(), and SetRepositoryList().

m_repository_list

STRING_TUPLE_LIST PLUGIN_CONTENT_MANAGER::m_repository_list

private

Definition at line 398 of file pcm.h.

Referenced by CacheRepository(), GetRepositoryList(), RunBackgroundUpdate(), and SetRepositoryList().

m_schema_validator

nlohmann::json_schema::json_validator PLUGIN_CONTENT_MANAGER::m_schema_validator

private

Definition at line 394 of file pcm.h.

Referenced by PLUGIN_CONTENT_MANAGER(), and ValidateJson().

m_statusCallback

std::function<void( const wxString )> PLUGIN_CONTENT_MANAGER::m_statusCallback

private

Definition at line 403 of file pcm.h.

Referenced by RunBackgroundUpdate().

m_statusReporter

std::shared_ptr<STATUS_TEXT_REPORTER> PLUGIN_CONTENT_MANAGER::m_statusReporter

private

Definition at line 406 of file pcm.h.

Referenced by CacheRepository(), RunBackgroundUpdate(), and StopBackgroundUpdate().

m_updateThread

std::thread PLUGIN_CONTENT_MANAGER::m_updateThread

private

Definition at line 404 of file pcm.h.

Referenced by RunBackgroundUpdate(), and StopBackgroundUpdate().

---

The documentation for this class was generated from the following files:

• pcm.h
• pcm.cpp