Feature/7 check for code updates

.github/QNetworkReplyErroCodes.txt

@@ -0,0 +1,34 @@
+NoError=0
+ConnectionRefusedError=1
+RemoteHostClosedError
+HostNotFoundError
+TimeoutError
+OperationCanceledError
+SslHandshakeFailedError
+TemporaryNetworkFailureError
+NetworkSessionFailedError
+BackgroundRequestNotAllowedError
+TooManyRedirectsError
+InsecureRedirectError
+UnknownNetworkError=99
+ProxyConnectionRefusedError=101
+ProxyConnectionClosedError
+ProxyNotFoundError
+ProxyTimeoutError
+ProxyAuthenticationRequiredError
+UnknownProxyError=199
+ContentAccessDenied=201
+ContentOperationNotPermittedError
+ContentNotFoundError
+AuthenticationRequiredError
+ContentReSendError
+ContentConflictError
+ContentGoneError
+UnknownContentError=299
+ProtocolUnknownError=301
+ProtocolInvalidOperationError
+ProtocolFailure=399
+InternalServerError=401
+OperationNotImplementedError
+ServiceUnavailableError
+UnknownServerError=499

.github/checkForHttpStatusCodesUpdate.js

@@ -0,0 +1,107 @@
+const fetch = require( 'node-fetch' );
+const diff = require( 'diff' );
+const fs = require( 'fs' ).promises;
+const path = require( 'path' );
+const githubIssues = require( './githubIssues.js' );
+
+let log = console;
+
+const httpStatusCodesUrl = 'https://www.iana.org/assignments/http-status-codes/http-status-codes.txt';
+const issueTitleBase = 'IANA HTTP Status Code Update';
+
+const checkForUpdate = async ( { github, core, context, dryRun } ) => {
+	try
+	{
+		log = core;
+
+		const httpStatusCodes = await fetchHttpStatusCodesList();
+		const lastUpdatedDate = httpStatusCodes.lastUpdated;
+		const diffWithLastUsedVersion = await getDiffWithLastUsedVersion( httpStatusCodes.httpStatusCodesList );
+		if ( !diffWithLastUsedVersion ) {
+			log.info( 'HTTP status codes list is still up to date' );
+			return;
+		}
+		log.warning( 'HTTP status codes list is outdated!' );
+
+		const existingGithubIssues = await githubIssues.searchForExistingGithubIssue( { keywords: [ issueTitleBase, lastUpdatedDate ], github, context } );
+
+		if ( existingGithubIssues.total_count === 0 ) {
+			createNewGithubIssue( { lastUpdatedDate, diffWithLastUsedVersion, github, context, dryRun } );
+		}
+		else if ( existingGithubIssues.total_count === 1 ) {
+			log.info( 'An issue already exists for this update.' );
+		}
+		else {
+			log.warning( `Multiple issues exist for the HTTP status code update from ${lastUpdatedDate}:\n${ JSON.stringify( existingGithubIssues, undefined, 4 ) }` );
+		}
+	}
+	catch ( error ) {
+		core.setFailed( `Could not check for HTTP status codes updates: ${error}` );
+		throw error;
+	}
+};
+
+const fetchHttpStatusCodesList = async () => {
+	const response = await fetch( httpStatusCodesUrl );
+	if ( !response.ok ) {
+		throw Error( `Error fetching HTTP status codes list: ${response.status} ${response.statusText}` );
+	}
+	const httpStatusCodesList = await response.text();
+
+	const match = /Last Updated\s+(\d{4}-\d{2}-\d{2})/.exec( httpStatusCodesList );
+	if ( !match ) {
+		throw Error( 'Could not find "Last Updated" date in HTTP status list' );
+	}
+	const lastUpdated = match[ 1 ];
+	return { lastUpdated, httpStatusCodesList };
+};
+
+const getDiffWithLastUsedVersion = async ( httpStatusCodeList ) => {
+	const pathToLastUsedVersion = path.resolve( './.github/http-status-codes.txt' );
+	const lastUsedVersion = await fs.readFile( pathToLastUsedVersion, { encoding: 'utf-8' } );
+	if ( lastUsedVersion === httpStatusCodeList ) {
+		return null;
+	}
+	const patch = diff.createPatch( 'http-status-codes.txt', lastUsedVersion, httpStatusCodeList );
+	return patch;
+};
+
+const createNewGithubIssue = async ( { lastUpdatedDate, diffWithLastUsedVersion, github, context, dryRun } ) => {
+	const title = `${issueTitleBase} ${lastUpdatedDate}`;
+	const body = `The HTTP status codes list has been updated on ${lastUpdatedDate}.    ` + '\n' +
+				 'See https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml' + '\n\n' +
+				 '## Diff ##'  + '\n' +
+				 '```diff'  + '\n' +
+				 diffWithLastUsedVersion + '\n' +
+				 '```';
+
+	 if ( dryRun ) {
+		log.info( `Would create issue:\n${ JSON.stringify( { title, body }, null, 4 ) }` );
+	}
+	else {
+		const newIssue = await githubIssues.createNewGithubIssue( { title, body, github, context } );
+		log.info( `Created issue #${newIssue.number}: ${newIssue.html_url}`);
+	}
+};
+
+const main = async () => {
+	try
+	{
+		const httpStatusCodes = await fetchHttpStatusCodesList();
+		log.log( httpStatusCodes.lastUpdated );
+		const patch = await getDiffWithLastUsedVersion( httpStatusCodes.httpStatusCodesList );
+		if ( patch ) {
+			log.log( patch );
+		}
+	}
+	catch( reason ) {
+		log.error( reason );
+		process.exitCode = -1;
+	};
+};
+
+module.exports = checkForUpdate;
+
+if ( require.main === module ) {
+	main();
+}

.github/checkQNetworkReplyErrorCodeUpdate.js

@@ -0,0 +1,143 @@
+const fetch = require( 'node-fetch' );
+const diff = require( 'diff' );
+const fs = require( 'fs' ).promises;
+const path = require( 'path' );
+const githubIssues = require( './githubIssues.js' );
+
+let log = console;
+
+const qNetworkReplyHeaderUrl = 'https://code.qt.io/cgit/qt/qtbase.git/plain/src/network/access/qnetworkreply.h';
+const issueTitleBase = 'QNetworkReply Error Code Update';
+
+const checkForUpdate = async ( { github, core, context, dryRun } ) => {
+	try
+	{
+		log = core;
+
+		const { blobId, qNetworkReplyErrorCodes } = await fetchQNetworkReplyErrorCodeListFromGitHub( github );
+		const blobIdShort = shortenId( blobId );
+		const diffWithLastUsedVersion = await getDiffWithLastUsedVersion( qNetworkReplyErrorCodes );
+		if ( !diffWithLastUsedVersion ) {
+			log.info( 'QNetworkReply error codes list is still up to date' );
+			return;
+		}
+		log.warning( 'QNetworkReply error codes list is outdated!' );
+
+		const existingGithubIssues = await githubIssues.searchForExistingGithubIssue( { keywords: [ issueTitleBase, blobIdShort ], github, context } );
+
+		if ( existingGithubIssues.total_count === 0 ) {
+			createNewGithubIssue( { blobId, diffWithLastUsedVersion, github, context, dryRun } );
+		}
+		else if ( existingGithubIssues.total_count === 1 ) {
+			log.info( 'An issue already exists for this update.' );
+		}
+		else {
+			log.warning( `Multiple issues exist for the QNetworkReply error codes update with id ${blobIdShort}:\n${ JSON.stringify( existingGithubIssues, undefined, 4 ) }` );
+		}
+	}
+	catch ( error ) {
+		core.setFailed( `Could not check for HTTP status codes updates: ${error}` );
+		throw error;
+	}
+};
+
+const shortenId = id => {
+	return id.substring( 0, 8 )
+};
+
+const fetchQNetworkReplyErrorCodeListFromGitHub = async ( github ) => {
+	const getContent = github.repos.getContent || github.repos.getContents;
+	const response = await getContent( {
+		owner: 'qt',
+		repo: 'qtbase',
+		path: 'src/network/access/qnetworkreply.h',
+		ref: 'dev'
+	} );
+	const blobId = response.data.sha;
+
+	const qNetworkReplyHeaderSource = decodeRepoContent( response.data );
+	const qNetworkReplyErrorCodes = extractQNetworkReplyErrorCodes( qNetworkReplyHeaderSource );
+
+	return { blobId, qNetworkReplyErrorCodes };
+};
+
+const fetchQNetworkReplyErrorCodeListFromQt = async () => {
+	const response = await fetch( qNetworkReplyHeaderUrl );
+	if ( !response.ok ) {
+		throw Error( `Error fetching QNetworkReply header: ${response.status} ${response.statusText}` );
+	}
+	const qNetworkReplyHeaderSource = await response.text();
+
+	return extractQNetworkReplyErrorCodes( qNetworkReplyHeaderSource );
+}
+
+const decodeRepoContent = ( response ) => {
+	try {
+		return Buffer.from( response.content, response.encoding ).toString( 'utf-8' );
+	}
+	catch( e ) {
+		throw Error( `Unsupported repository content encoding: ${response.encoding}\nOriginal exception: ${e}` );
+	}
+};
+
+const extractQNetworkReplyErrorCodes = ( qnetworkReplyHeaderSource ) => {
+	const enumMatch = /enum NetworkError {(.*?)};/s.exec( qnetworkReplyHeaderSource );
+	if ( !enumMatch ) {
+		throw Error( 'Could not extract NetworkError codes from QNetworkReply header' );
+	}
+	const enums = enumMatch[ 1 ].trim().replace( /\/\/.*$|[ \t]+|\n\n+|,/mg, '' );
+	return enums;
+}
+
+const getDiffWithLastUsedVersion = async ( qNetworkReplyErrorCodes ) => {
+	const pathToLastUsedVersion = path.resolve( './.github/QNetworkReplyErroCodes.txt' );
+	const lastUsedVersion = await fs.readFile( pathToLastUsedVersion, { encoding: 'utf-8' } );
+	if ( lastUsedVersion === qNetworkReplyErrorCodes ) {
+		return null;
+	}
+	const patch = diff.createPatch( 'QNetworkReplyErroCodes.txt', lastUsedVersion, qNetworkReplyErrorCodes );
+	return patch;
+};
+
+const createNewGithubIssue = async ( { blobId, diffWithLastUsedVersion, github, context, dryRun } ) => {
+	const blobIdShort = shortenId( blobId );
+	const title = `${issueTitleBase} ${blobIdShort}`;
+	const body = 'The `QNetworkReply::NetworkError` codes list has been updated.    \n' +
+				 'See https://code.qt.io/cgit/qt/qtbase.git/log/src/network/access/qnetworkreply.h' + '\n\n' +
+				 '## Diff ##'  + '\n' +
+				 '```diff'  + '\n' +
+				 diffWithLastUsedVersion + '\n' +
+				 '```';
+
+	 if ( dryRun ) {
+		log.info( `Would create issue:\n${ JSON.stringify( { title, body }, null, 4 ) }` );
+	}
+	else {
+		const newIssue = await githubIssues.createNewGithubIssue( { title, body, github, context } );
+		log.info( `Created issue #${newIssue.number}: ${newIssue.html_url}`);
+	}
+};
+
+const main = async () => {
+	try
+	{
+		const qnetworkReplyErrorCodes = await fetchQNetworkReplyErrorCodeListFromQt();
+		const patch = await getDiffWithLastUsedVersion( qnetworkReplyErrorCodes );
+		if ( patch ) {
+			log.log( patch );
+		}
+		else {
+			log.log( "Last used version is still up to date!" );
+		}
+	}
+	catch( reason ) {
+		log.error( reason );
+		process.exitCode = -1;
+	};
+};
+
+module.exports = checkForUpdate;
+
+if ( require.main === module ) {
+	main();
+}

.github/githubIssues.js

@@ -0,0 +1,23 @@
+
+const searchForExistingGithubIssue = async ( { keywords, github, context } ) => {
+	const query = keywords.concat( [ 'in:title', `repo:${context.payload.repository.full_name}`, 'type:issue' ] ).join( '+' );
+	const searchResponse = await github.search.issuesAndPullRequests( {
+		q: query,
+	} );
+	return searchResponse.data;
+};
+
+const createNewGithubIssue = async ( { title, body, github, context } ) => {
+
+	const newIssue = {
+		owner: context.repo.owner,
+		repo: context.repo.repo,
+		title,
+		body
+	};
+
+	const issueResponse = await github.issues.create( newIssue );
+	return issueResponse.data;
+};
+
+module.exports = { searchForExistingGithubIssue, createNewGithubIssue };