Abstract Extension API and Dependency Interface

• The original application is http://socghop.appspot.com/student_project/show/google/gsoc2009/php/t124023314420
• For those who don't have access - http://www.xvpj.net/gsoc-09-application-php-abstract-extension-api-and-dependency-interface/

• Student: Varuna Jayasiri
• Mentor: shire
• Timezone: GMT +5:30 (Varuna)
• Mailing list: pecl-dev@lists.php.net

The objective of this project is to develop functionality for PHP that will allow extensions to register a set of functions as a versioned API, since PHP does not currently handle interdependencies among PHP extensions well, which leads to various problems. This would also solve the current problem of extension load order.

Versions are in the format major.minor[.build[.revision]] in the string representation. These are stored in unsigned integers for ease of searching. The first 8 bits are used for the major, next 8 for the minor, next 8 for the build and the last 8 bits for the revision. It is possible to convert from the string representation to an unsigned integer using zend_ext_api_toi and from an unsigned integer to the string format using zend_ext_api_toa function.

All functions return SUCCESS on success and FAILURE on failure.

int zend_ext_api_register(char *ext_name, char * version_text, void *api, size_t size)

Registers an API

int zend_ext_api_version_toi(char *version_text, uint *version_int)

Converts a version in text format to an integer.

int zend_ext_api_version_toa(uint version, char * version_text)

Converts a version in integer format to a string

int zend_ext_api_get_latest_version(char *ext_name, uint *version)

Gives the latest version of the extension available

int zend_ext_api_exists(char *ext_name, char *version)

Checks if the API is available

int zend_ext_api_get(char *ext_name, char *version, void **api)

Retrieves the API

20th April to 23rd May – Community bonding period

• Getting more familiarized with PHP core and Zend
• Submitting the proposed API and design for suggestions
• Getting ideas from the developer community on how this should be developed
• Finalizing the design

23rd May to 1st July – Implementing most important features

• The API registration and retrieval component will be developed
• The interface for setting up the callback function will not be implemented at this stage, instead a simpler interface (e.g. php_get_api) would be provided
• Code written will be unit tested
• This would be a standard to be distributed for testing

1st July to 10th July – Testing the implemented section

• The implemented features will be tested with help from the community
• Any bugs encountered will be fixed
• Any suggestions for improvements will be considered and implemented

10th July to 1st August – Completing the implementation of all features

• All the functionality described above will be completed
• Code written will be unit tested
• Behavior of the component in various scenarios with interdependencies among extensions, will be tested thoroughly

1st August to 4th August – Buffer

• Small buffer period so that any additional things that come up in the way could be implemented or if time taken for implementation exceeds time estimated
• The completed extension API and dependency interface will be made available for the developer community
• Any improvements suggested will be considered and implemented

4th August to 17th August – Testing

• Any bug fixes will be implemented
• All documentations will be completed
• It will be ready for distribution at the end of testing

• Setup the development environment
• Working on the GIT repository - git://github.com/vpj/PHP-Extension-API.git
• Made a few changes to the proposed design
  • All the code will be a part of zend and hence all function will be prefixed with zend_ and not php_
  • Prefixed all the functions with zend_ext_api instead of function names like php_register_api

• Discussing how different versions of API's should be maintained
• Coded the basic functionality
  • Memory leaks and exception handling were not considered (TODO's were added to make sure these will be addressed later)

• Two hashtables are used - one to store the API's and the other to store the available versions
• A simple list is used to store the set of versions available
• Versions are represented in major.minor[.build[.revision]] or major.minor[.maintenance[.build]] formats; i.e. “x.x.x.x”
  • These are converted to a 32 bit integer for indexing
  • Bit masks could be used to identify ranges of versions easily

• Included a function to get the latest version of an extension available
• Functions to convert version from major.minor[.build[.revision]] format to an uint and vice versa are provided.
  • when representing the version in uint first 8 bits will be used for major and the next 8 for minor and so on
• A few memory leaks were fixed

• Added some documentation of the interface
• Did some testing

• Coded the callback registration
  • Callbacks are called from php_module_startup (main/main.c)
  • Tested callbacks
  • Update sample usage code