PLUGIN_CONTENT_MANAGER Class Reference

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

#include <pcm.h>

Public Member Functions
	PLUGIN_CONTENT_MANAGER (wxWindow *aParent)
	~PLUGIN_CONTENT_MANAGER ()
bool	FetchRepository (const wxString &aUrl, PCM_REPOSITORY &aRepository, WX_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	DownloadToStream (const wxString &aUrl, std::ostream *aOutput, WX_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...

Private Member Functions
bool	fetchPackages (const wxString &aUrl, const boost::optional< wxString > &aHash, std::vector< PCM_PACKAGE > &aPackages, WX_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...
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

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 >	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 93 of file pcm.h.

Constructor & Destructor Documentation

PLUGIN_CONTENT_MANAGER()

PLUGIN_CONTENT_MANAGER::PLUGIN_CONTENT_MANAGER

(

wxWindow *

aParent

)

Definition at line 63 of file pcm.cpp.

 : m_dialog( aParent )
{
 // Get 3rd party path
 const ENV_VAR_MAP& env = Pgm().GetLocalEnvVariables();
 auto it = env.find( wxT( "KICAD6_3RD_PARTY" ) );

 if( it != env.end() && !it->second.GetValue().IsEmpty() )
 m_3rdparty_path = it->second.GetValue();
 else
 m_3rdparty_path = PATHS::GetDefault3rdPartyPath();

 // Read and store pcm schema
 wxFileName schema_file( PATHS::GetStockDataPath( true ), wxT( "pcm.v1.schema.json" ) );
 schema_file.Normalize();
 schema_file.AppendDir( wxT( "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, "" );
 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 = wxT( "0.0" );
 entry.repository_name = wxT( "<unknown>" );

 if( stat_code == 0 )
 entry.install_timestamp = stat.st_mtime;

 PACKAGE_VERSION version;
 version.version = wxT( "0.0" );
 version.status = PVS_STABLE;
 version.kicad_version = KICAD_MAJOR_MINOR_VERSION;

 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(),
 [&]( auto& entry )
 {
 preparePackage( entry.second.package );
 } );
}

References _, PCM_INSTALLATION_ENTRY::current_version, Format(), PATHS::GetDefault3rdPartyPath(), 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(), Pgm(), preparePackage(), PVS_STABLE, 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 673 of file pcm.cpp.

{
 // Save current installed packages list.

 try
 {
 nlohmann::json js;
 js["packages"] = nlohmann::json::array();

 for( const auto& entry : m_installed )
 {
 js["packages"].emplace_back( entry.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.

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 345 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::unique_ptr<WX_PROGRESS_REPORTER> reporter(
 new WX_PROGRESS_REPORTER( m_dialog, wxEmptyString, 1 ) );

 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( m_3rdparty_path, wxT( "repository.json" ) );
 repo_cache.AppendDir( wxT( "cache" ) );
 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() );
 repo_stream >> js;
 PCM_REPOSITORY saved_repo = js.get<PCM_REPOSITORY>();

 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>>();

 std::for_each( saved_repo.package_list.begin(), saved_repo.package_list.end(),
 &preparePackage );

 m_repository_cache[aRepositoryId] = std::move( saved_repo );

 packages_cache_exists = true;
 }
 catch( ... )
 {
 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;
 }

 std::for_each( current_repo.package_list.begin(), current_repo.package_list.end(),
 &preparePackage );

 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.get();

 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.get() ) )
 {
 read_stream.close();
 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() );
 }
 }
 }

 return true;
}

References _, DownloadToStream(), fetchPackages(), FetchRepository(), getCurrentTimestamp(), m_3rdparty_path, m_dialog, m_repository_cache, m_repository_list, PCM_REPOSITORY::package_list, PCM_REPOSITORY::packages, preparePackage(), PCM_REPOSITORY::resources, PCM_RESOURCE_REFERENCE::sha256, PCM_RESOURCE_REFERENCE::update_timestamp, 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 591 of file pcm.cpp.

{
 if( m_repository_cache.count( aRepositoryId ) > 0 )
 m_repository_cache.erase( aRepositoryId );

 wxFileName repo_cache( m_3rdparty_path, "" );
 repo_cache.AppendDir( wxT( "cache" ) );
 repo_cache.AppendDir( aRepositoryId );

 if( repo_cache.DirExists() )
 repo_cache.Rmdir( wxPATH_RMDIR_RECURSIVE );
}

References m_3rdparty_path, and m_repository_cache.

Referenced by SetRepositoryList().

DownloadToStream()

bool PLUGIN_CONTENT_MANAGER::DownloadToStream	(	const wxString &	aUrl,
		std::ostream *	aOutput,
		WX_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 187 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 > 1024 )
 {
 aReporter->SetCurrentProgress( dlnow / (double) dltotal );
 aReporter->Report( wxString::Format( _( "Downloading %lld/%lld Kb" ), dlnow / 1024,
 dltotal / 1024 ) );
 }
 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( 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_BASE::IsCancelled(), PROGRESS_REPORTER_BASE::KeepRefreshing(), KICAD_CURL_EASY::Perform(), PROGRESS_REPORTER_BASE::Report(), PROGRESS_REPORTER_BASE::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 boost::optional< wxString > &  aHash, std::vector< PCM_PACKAGE > &  aPackages, WX_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 283 of file pcm.cpp.

{
 std::stringstream packages_stream;

 aReporter->SetTitle( _( "Fetching repository packages" ) );

 if( !DownloadToStream( aUrl, &packages_stream, aReporter ) )
 {
 wxLogError( _( "Unable to load repository packages url." ) );
 return false;
 }

 std::istringstream isstream( packages_stream.str() );

 if( aHash && !VerifyHash( isstream, aHash.get() ) )
 {
 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 )
 {
 wxLogError( wxString::Format( _( "Unable to parse packages metadata:\n\n%s" ), e.what() ) );
 return false;
 }

 return true;
}

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

Referenced by CacheRepository().

FetchRepository()

bool PLUGIN_CONTENT_MANAGER::FetchRepository	(	const wxString &	aUrl,
		PCM_REPOSITORY &	aRepository,
		WX_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 242 of file pcm.cpp.

{
 std::stringstream repository_stream;

 aReporter->SetTitle( _( "Fetching repository" ) );

 if( !DownloadToStream( aUrl, &repository_stream, aReporter, 20480 ) )
 {
 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 )
 {
 wxLogError( wxString::Format( _( "Unable to parse repository:\n\n%s" ), e.what() ) );
 return false;
 }

 return true;
}

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

Referenced by CacheRepository().

Get3rdPartyPath()

const wxString& PLUGIN_CONTENT_MANAGER::Get3rdPartyPath ( ) const

inline

Definition at line 216 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 336 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(), and MarkInstalled().

getCurrentTimestamp()

time_t PLUGIN_CONTENT_MANAGER::getCurrentTimestamp ( ) const

private

Definition at line 665 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 824 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 699 of file pcm.cpp.

{
 std::vector<PCM_INSTALLATION_ENTRY> v;

 std::for_each( m_installed.begin(), m_installed.end(),
 [&v]( const auto& entry )
 {
 v.push_back( entry.second );
 } );

 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 installedReturns current 3rd party directory path

Definition at line 714 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 723 of file pcm.cpp.

{
 wxArrayString terms = wxStringTokenize( aSearchTerm.Lower(), wxT( " " ), 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.get().name );

 // Match on resources
 for( const auto& 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 630 of file pcm.cpp.

{
 if( m_installed.find( aPackageId ) != m_installed.end() )
 return PPS_INSTALLED;

 if( aRepositoryId.IsEmpty() || !CacheRepository( aRepositoryId ) )
 return PPS_UNAVAILABLE;

 const PCM_REPOSITORY& repo = getCachedRepository( aRepositoryId );

 auto pkg_it = std::find_if( repo.package_list.begin(), repo.package_list.end(),
 [&aPackageId]( const PCM_PACKAGE& pkg )
 {
 return pkg.identifier == aPackageId;
 } );

 if( pkg_it == repo.package_list.end() )
 return PPS_UNAVAILABLE;

 const PCM_PACKAGE& pkg = *pkg_it;

 auto ver_it = std::find_if( pkg.versions.begin(), pkg.versions.end(),
 []( const PACKAGE_VERSION& ver )
 {
 return ver.compatible;
 } );

 if( ver_it == pkg.versions.end() )
 return PPS_UNAVAILABLE;
 else
 return PPS_AVAILABLE;
}

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

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 170 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 781 of file pcm.cpp.

{
 std::unordered_map<wxString, wxBitmap> bitmaps;

 wxFileName resources_file = wxFileName( m_3rdparty_path, wxT( "resources.zip" ) );
 resources_file.AppendDir( wxT( "cache" ) );
 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 image, m_3rdparty_path, 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 556 of file pcm.cpp.

{
 return getCachedRepository( aRepositoryId ).package_list;
}

References getCachedRepository(), and PCM_REPOSITORY::package_list.

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 605 of file pcm.cpp.

{
 PCM_INSTALLATION_ENTRY entry;
 entry.package = aPackage;
 entry.current_version = aVersion;
 entry.repository_id = aRepositoryId;

 if( !aRepositoryId.IsEmpty() )
 entry.repository_name = getCachedRepository( aRepositoryId ).name;
 else
 entry.repository_name = _( "Local file" );

 entry.install_timestamp = getCurrentTimestamp();

 m_installed.emplace( aPackage.identifier, entry );
}

References _, PCM_INSTALLATION_ENTRY::current_version, getCachedRepository(), getCurrentTimestamp(), PCM_PACKAGE::identifier, PCM_INSTALLATION_ENTRY::install_timestamp, m_installed, PCM_REPOSITORY::name, PCM_INSTALLATION_ENTRY::package, 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 624 of file pcm.cpp.

{
 m_installed.erase( aPackage.identifier );
}

References PCM_PACKAGE::identifier, and m_installed.

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 objectReturns current UTC timestamp

Definition at line 488 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.get();

 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_major_minor = []( const wxString& version )
 {
 wxStringTokenizer tokenizer( version, wxT( "." ) );
 int ver_major = wxAtoi( tokenizer.GetNextToken() );
 int ver_minor = wxAtoi( tokenizer.GetNextToken() );
 return std::tuple<int, int>( ver_major, ver_minor );
 };

 if( parse_major_minor( ver.kicad_version ) > m_kicad_version )
 ver.compatible = false;

 if( ver.kicad_version_max
 && parse_major_minor( ver.kicad_version_max.get() ) < 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(), and PLUGIN_CONTENT_MANAGER().

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 562 of file pcm.cpp.

{
 // Clean up cache folder if repository is not in new list
 for( const auto& 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 auto& 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.

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 275 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 323 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

staticprivate

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

Definition at line 273 of file pcm.h.

m_3rdparty_path

wxString PLUGIN_CONTENT_MANAGER::m_3rdparty_path

private

Definition at line 310 of file pcm.h.

Referenced by CacheRepository(), DiscardRepositoryCache(), Get3rdPartyPath(), GetInstalledPackageBitmaps(), GetRepositoryPackageBitmaps(), and PLUGIN_CONTENT_MANAGER().

m_cache_path

wxString PLUGIN_CONTENT_MANAGER::m_cache_path

private

Definition at line 311 of file pcm.h.

m_dialog

wxWindow* PLUGIN_CONTENT_MANAGER::m_dialog

private

Definition at line 308 of file pcm.h.

Referenced by CacheRepository().

m_installed

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

private

Definition at line 315 of file pcm.h.

Referenced by GetInstalledPackages(), GetInstalledPackageVersion(), GetPackageState(), MarkInstalled(), MarkUninstalled(), PLUGIN_CONTENT_MANAGER(), and ~PLUGIN_CONTENT_MANAGER().

m_kicad_version

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

staticprivate

Initial value:

=
 KICAD_MAJOR_MINOR_VERSION_TUPLE

Definition at line 316 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 312 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 313 of file pcm.h.

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

m_schema_validator

nlohmann::json_schema::json_validator PLUGIN_CONTENT_MANAGER::m_schema_validator

private

Definition at line 309 of file pcm.h.

Referenced by PLUGIN_CONTENT_MANAGER(), and ValidateJson().

---

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

• pcm.h
• pcm.cpp