Contributing to Wikimedia software projects

Lately, I’ve received numerous emails from new open-source contributors requesting guidance in contributing to Wikimedia software projects. There are a lot of useful resources available, and this post is an effort to gather these resources in one place. Time to get your reading hats on.

Some background: I work as a software engineer in the Product department at the Wikimedia Foundation since 2019. The information / views shared on this blog are my own, and do not necessarily reflect the views of my employer.

Continue reading “Contributing to Wikimedia software projects”

Vagrant development environment for PHP

As a developer, I work on projects that require a variety of software, each tuned to different configurations. The easiest way to achieve this is to set up a virtual machine and configure that as per the need of the project. This allows me to keep my host machine clean, and share the virtual machine with other developers on the project.

In this blog, I’ll describe the configuration of a Vagrant machine that I’ve setup for PHP web development. Here’s a link to the box on vagrant cloud.

Continue reading “Vagrant development environment for PHP”

Setting up MediaWiki, Vagrant and VSCode

The guide describes how to setup MediaWiki for development on Vagrant while adding support for debugging on VSCode using the XDebug PHP extension.

Various documents have been linked to which contain relevant information rather than copying it here again.

Continue reading “Setting up MediaWiki, Vagrant and VSCode”

Ownership and Borrowing in Rust

I’ve been having a lot of fun learning Rust. I’ve been going through the second version of the Rust book and have covered uptil chapter 6 – Enums and Pattern Matching.

One of the unique things about Rust is the Ownership system. I had some doubts understanding this. Searching on Google lead me to this little website – http://intorust.com/ that has some really cool videos explaining – ownership and borrowing.

The author, Nicholas D. Matsakis, has a lot of other interesting work that you can read at http://smallcultfollowing.com/babysteps/

On another note, I’ve been pushing my Rust code to the repository here. I’ll be happy to receive any feedback.

Handling JSON request in PHP

I’ve been working with PHP and jQuery AJAX quite a bit lately. Along with sending form data to PHP page through AJAX, I’ve written restful web services in PHP that receive data in JSON format.

In general when you are sending data through jQuery AJAX to PHP, you don’t have to specify a contentType. Depending on your type ‘GET’ or ‘POST’, PHP will nicely wrap your content into either the $_POST or $_GET global arrays. When you don’t specify a contentType the default contentType is taken as application/x-www-form-urlencoded; charset=UTF-8’.

Following is the request headers from an AJAX call without contentType specified,

GET /ajax-php/api.php?firstname=Abijeet&lastname=Patro HTTP/1.1 
Host: localhost:8081 
Connection: keep-alive 
Cache-Control: no-cache Pragma: no-cache 
Accept: */* 
X-Requested-With: XMLHttpRequest 
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/36.0.1985.143 Safari/537.36
Content-Type: application/x-www-form-urlencoded; charset=UTF-8
Referer:http://localhost:8081/ajax-php/index.php
Accept-Encoding: gzip,deflate,sdch 
Accept-Language: en-US,en;q=0.8,fr;q=0.6

To further test this, I set up the following PHP code on my server,

<?php
$get=$_GET;
$post=$_POST;
$app_json=json_decode(file_get_contents('php://input');
$response=array();
$response['GET']=$get;
$response['POST']=$post;
$response['JSON']=$app_json;
echo json_encode($response);
die();

The response that for the above request case was,

{
  "GET": {
    "firstname": "Abijeet",
    "lastname": "Patro"
  },
  "POST": [],
  "JSON": null
}

If we put the jQuery AJAX type property as ‘POST’ we will have the following request header,

POST /ajax-php/api.php HTTP/1.1 
Host: localhost:8081 
Connection: keep-alive 
Content-Length: 32 
Cache-Control: no-cache 
Pragma: no-cache 
Origin: http://localhost:8081
X-Requested-With: XMLHttpRequest 
Content-Type: application/x-www-form-urlencoded; 
charset=UTF-8 
Accept: */* 
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/36.0.1985.143 Safari/537.36 
Referer: http://localhost:8081/ajax-php/index.php
Accept-Encoding: gzip,deflate,sdch 
Accept-Language: en-US,en;q=0.8,fr;q=0.6

Nothing much changes. The action is specified as POST and the data is no longer a part of the request header. The response from the server is following,

{
  "GET": [],
  "POST": {
    "firstname": "Abijeet",
    "lastname": "Patro"
  },
  "JSON": null
}

Obviously, PHP has no issues parsing content of type – application/x-www-form-urlencoded; charset=UTF-8. As soon as it sees that contentType, it checks the action and packs the data nicely into either $_GET or $_POST.

Let’s now talk about JSON data. In general, restful web services accept data of type JSON. When sending data via JSON the contentType for jQuery AJAX is application/json; charset=UTF-8

This is the request header,

POST /ajax-php/api.php HTTP/1.1 
Host: localhost:8081 
Connection: keep-alive 
Content-Length: 42 
Cache-Control: no-cache 
Pragma: no-cache 
Origin: http://localhost:8081
X-Requested-With: XMLHttpRequest 
Content-Type: application/json; charset=UTF-8
Accept: */* 
User-Agent: Mozilla/5.0 (Windows NT 6.1; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/36.0.1985.143 Safari/537.36 
Referer: http://localhost:8081/ajax-php/index.php
Accept-Encoding: gzip,deflate,sdch 
Accept-Language: en-US,en;q=0.8,fr;q=0.6

When PHP receives this data and looks at the content type, it’s not quite sure how to process it, so it leaves it alone. In this case the action – ‘POST’ or ‘GET’ doesn’t matter. You’ll notice that $_POST or $_GET both, are empty arrays. Now, it’s up to you to read this data and parse it.

<?php
$app_json=json_decode(file_get_contents('php://input'));

The code above, reads the data from PHP’s input stream. Since we have passed a JSON string, we decode it, which converts it to a PHP array and stores it in $app_json. If the data you send is not in a correct JSON format, $app_json will have false.

When we echo our response, we get the following on the client side,

{
  "GET": [],
  "POST": [],
  "JSON": {
    "firstname": "Abijeet",
    "lastname": "Patro"
  }
}

I set up a small project to illustrate what has been written here. You can find it over on my GitHub page

Continue reading “Handling JSON request in PHP”

get_results PHP function not working on CentOS

There are instances where the PHP function – get_results will not work on CentOS (this maybe the case with other Linux based operating systems as well). I faced this issue while deploying a project on CentOS which was originally developed on Windows. All my INSERT, UPDATE and DELETE database statements were working properly, but bulk SELECTstatements had issues. Closer inspection narrowed down the problem to the get_results function.

I came across this on the get_results PHP documentation page –

MySQL Native Driver Only
Available only with mysqlnd.

I was able to determine if mysqlnd driver was installed using this post on StackOverflow as reference. As expected, it wasn’t.

Here’s the relevant php code from the StackOverflow post –

<?php
$mysqlnd=function_exists('mysqli_fetch_all');
if($mysqlnd) {
   echo 'mysqlnd enabled!';
}

Now that I new that we needed to install the mysqlnd driver, here are the steps that I followed to get the mysqlnd driver working on CentOS,

// First remove the existing MySQL driver
yum --enablerepo=remi,remi-test remove php-mysql

// Then go ahead and install mysqlnd
yum --enablerepo=remi,remi-test install php-mysqlnd

// Restart httpd
/sbin/service httpd restart

// If you have phpMyAdmin, re-install it so that it uses the new MySQL driver
yum remove phpMyAdmin
yum install phpMyAdmin

After installing the mysqlnd driver the get_results function worked just fine.