As I am a big fan of Douglas Crockford, the inventor of JSON, several weeks back I’ve found a new series of presentations. The presentations took place in 2010 and can be found on the YUI blog dedicated page: http://yuiblog.com/crockford/.

Why am I a Crockford fan? There were 3 thinks that surprised me on his first presentation I’ve seen:

• he argued fiercely that JavaScript has good parts, but they are not understood,
• said that JavaScript is a functional language, and as such should be taken in order to discover its beauty,
• he was one of the few to write a true programming book for JavaScript and not just a collection of special effects like the majority did at the time.

The series “Crockford on JavaScript” at Yahoo!, is not exactly new but very topical.

What is different about this presentations is that there not completely focused on syntax, language and “good parts”, but rather on the overview picture, all the story of the language, including the storys of the languages that influenced it.

The presentations are quite long, over an hour each, but very interesting in my opinion, especially if you’re a fan of computer history.

Part Three can be a bit more difficult because there are some notions that may seem quite bizarre. But once you get familiar with them, many other things become more clear.

The ssh key based authentication is useful when you don’t want to type the password each time. Also is useful when for instance sshfs is used and mounting takes place without entering a password.

The end result should do login with the following command:

1$ ssh work

Server

In Ubuntu the server installation is done with:

1$ sudo apt-get install ssh

For other distributions the packege is usually called ssh or OpenSSH.

On server-side you must activate the public key authentication in the sshd_config file:

1#/etc/ssh/sshd_config
2
3PubkeyAuthentication yes

Client

On client-side the public/private key pair must be generate:

1$ ssh-keygen -t rsa -b 1024

Where the type of the key is rsa and 1024 is the size. Bigger is safer.

The public key must be copied on the server using the following command:

1$ ssh-copy-id -i ~/.ssh/id_rsa user@192.168.1.1

The -i option and key path are optional, if there was generated a single key on the client in ~/.ssh directory that one will be used as default.

Right now it should work to login using the next command without prompting for password:

1$ ssh user@192.168.1.1

Alias

The last step is creating an alias, in this case it will be called “work”.

You must make a config file in the ~/.ssh directory. The file must have 600 rights, that is reading and writing only for owner.

1$ cd ~/.ssh
2$ touch config
3$ chmod 600 ~/.ssh/config

In this file aliases will be set:

1Host work
2HostName 192.168.1.1
3User user
4IdentityFile ~/.ssh/id_rsa

At this step authentication to the previously defined host can be made with the command:

1$ ssh work

To learn more about ssh aliases checkout the manual:

1$ man ssh_config

Why “ini” files? Because there are more convenient! Most servers in the *nix world have “ini” or “conf” configuration files. In the PHP world there are preferred PHP configuration files, which are usually arrays. Wouldn’t be more elegant to have an ini file without PHP code in it?

Fortunately PHP has a couple of native functions just for that: parse_ini_file and parse_ini_string.

The principle is very simple, you give an configuration ini file as a parameter and it will return an array.

A little example:

 1;config.ini
 2
 3[simple]
 4number = 1
 5another = 2
 6fraction = 0.2
 7
 8[escape]
 9path = /usr/bin/php
10url = https://blog.claudiupersoiu.ro
11error = '<a href="%path%">%error%</a>'
12
13[array]
141 = a
152 = b
163 = c

To parse the previous file:

1$config = parse_ini_file('config.ini', true);
2var_dump($config);

The second parameter specifies if the sections will become keys in the resulting array. Honestly I don’t think of a case when that wouldn’t be useful.

Seems slow? In fact for the file above is faster to parse then to include an array already parsed. The difference on my computer is ~0.00002s.

But the above file is not exactly big, so let’s get to a more serious ini file, like php.ini. Here the difference was bigger in favor of array, which won whit an advantage of ~0.0003, which means about half of parsing time that was ~0.0006s.

Taking into consideration that my computer is pretty fast and concurrent request can add an overhead for big files, sometimes it is useful to use a cache of the ini file.

Fortunately this is easy to do in PHP.

1$cache = var_export($config, true);
2
3file_put_contents('cache/config.php', "<?php\n\$config = " . $cache . ';');

Now you just need to include cache/config.php file and of course regenerate it when something changes in the ini file.

PHP should have write permissions for the cache directory.

Subversionning can be good to you, if you know how to use it!

subversionning

Somewhere in the certification guide there is a chapter dedicated to “streams”.

A small part of it represents the input, output and error streams from PHP.  C/C++ has famous stdio.h library, but few people knows that input from keyboard is possible in PHP too.

In short, this can be achieved with PHP://STDIN, PHP://STDOUT and PHP://STDERR.

As this subject is panicking a lot of developers that are studding for ZCE, let’s get the confusion out. A stream represents a flow of information, just like when your reading and internal or external file using fopen.

But as a programmer best understands from cod, let’s get to more practical stuff.

Input

For input there is PHP://STDIN.

The next script is reading input from the keyboard:

 1#!/usr/bin/php
 2<?php
 3// initializing the input stream
 4$input = fopen('php://stdin', 'r');
 5
 6// welcome message
 7echo 'Type "exit" and then enter to exit' . PHP_EOL;
 8
 9// reading the stream input
10while($line = fgets($input, 1024)) {
11 // exit condition with line terminator
12 if($line == 'exit' . PHP_EOL) {
13    echo 'bye bye' . PHP_EOL;
14    break;
15 }
16 // displaying the input from the keyboard
17 echo 'You say: ' . $line . PHP_EOL;
18}
19
20// close stream
21fclose($input);

The first line of code is specially for Linux/Unix, and Windows users can remove it.

The cod above must be placed in to a file, like for instance testStream.php.

You must have execution rights for that file, witch can be achieved with:

1chmod +x testStream.php

Then the file can be executed in Linux directly with:

1$./testStream.php

In Windows you must give the absolute path to PHP, if the path is not already in the system include path:

1>c:\php\php.exe testStream.php

Notice that the input is with “\n” or “\r\n” at the end of the line, that’s why I’m testing “exit” with the line terminator (PHP_EOL). I’m using PHP_EOL so it can work with both Linux/Unix and Windows.

Output

For output there is PHP://STDOUT.

Unlike input, the output is a lot less relevant. Basically the output is the standard one which can be achieved with echo and print.

But for educational purpose let’s modify the previous file to use PHP://STDOUT:

 1#!/usr/bin/php
 2<?php
 3// initializing the input stream
 4$input = fopen('php://stdin', 'r');
 5
 6// initializing the output stream
 7$output = fopen('php://stdout', 'w');
 8
 9// welcome message
10fwrite($output, 'Type "exit" and then enter to exit' . PHP_EOL);
11// reading the steam input
12while($line = fgets($input, 1024)) {
13 // exit condition with line terminator
14 if($line == 'exit' . PHP_EOL) {
15    fwrite($output, 'bye bye' . PHP_EOL);
16    break;
17 }
18 // displaying the input from the keyboard
19 fwrite($output, 'You say: ' . $line . PHP_EOL);
20}
21
22// close input stream
23fclose($input);
24
25// close output stream
26fclose($output);

Basically there isn’t any change in the script, is just that the output was displayed using PHP://STDOUT explicitly.

Error

A more interesting subject then the output is the error stream.

Basically is more relevant in the Unix/Linux environment, probably is relevant in Windows too but I don’t know how to capture it. If your reading this blog and you know how to do this please leave a comment below.

And again let’s change the script so that error messages will use the proper stream. I’ll output an error each time the user enters more then 5 characters (I’m sorry but I don’t have a lot of ideas right now):

 1#!/usr/bin/php
 2<?php
 3// initializing the input stream
 4$input = fopen('php://stdin', 'r');
 5
 6// initializing the output stream
 7$output = fopen('php://stdout', 'w');
 8
 9// initializing the error stream
10$err = fopen('php://stderr', 'w');
11
12// welcome message
13fwrite($output, 'Type "exit" and then enter to exit' . PHP_EOL);
14
15// reading the steam input
16while($line = fgets($input, 1024)) {
17 // exit condition with line terminator
18 if($line == 'exit' . PHP_EOL) {
19    fwrite($output, 'bye bye' . PHP_EOL);
20    break;
21 }
22
23 if(strlen($line) > 5) {
24    fwrite($err, 'WARNING! Input greater then 5 characters: ' . $line);
25    continue;
26 }
27
28 // displaying the input from the keyboard
29 fwrite($output, 'Ai scris: ' . $line . PHP_EOL);
30}
31
32// close input stream
33fclose($input);
34
35// close output stream
36fclose($output);
37
38// close error stream
39fclose($err);

By default in Linux error messages are displayed to the screen, but there are scenarios when the errors are redirected for instance to a log file .

To redirect the error messages to a log file 2>> is used like in the following example:

1$./testStream 2>>testStream.log

Input from PIPE (|)

Let’s take the fallowing scenario: the output of a previous operation contains a serious of email addresses that are both valid and invalid. There should be two files: valid.txt with valid addresses and invalid.txt with invalid ones. The email addresses will be send to the script using pipe.

The list of email addresses will be simulated using a file called email.txt:

1valid_addres@yahoo.com
2another_valid@yahoo.co.uk
3invalid@y.c
4good@gmail.com
5invalid addres@hotmail.com
6foo

The name of the script will be emailTest.php:

 1#!/usr/bin/php
 2<?php
 3// initializing the input stream
 4$input = fopen('php://stdin', 'r');
 5
 6// initializing error stream
 7$err = fopen('php://stderr', 'w');
 8
 9// unlike the previous cases, here is tested for the end of the file
10// because the input is not coming from keyboard
11while(!feof($input)) {
12 // the value is trimmed to remove line terminators
13 $line = trim(fgets($input, 1024));
14
15 // test email address
16 if(filter_var($line, FILTER_VALIDATE_EMAIL)) {
17    // direct output, equivalent to php://stdout stream
18    echo $line . PHP_EOL;
19 } else {
20    // invalid addresses are redirected to the php://stderr stream
21    // to be intercepted later
22    fputs($err, $line . PHP_EOL);
23 }
24}
25
26// close input stream
27fclose($input);
28
29// close error stream
30fclose($err);

For testing I’ll simulate the output of email addresses with the cat command:

1cat email.txt |./emailTest.php >valid.txt 2>invalid.txt

Now the files valid.txt and invalid.txt from the current directory contain the proper values.

Processing like this is very useful for complex operations. Basically is an alternative to Shell Scripting (linux) or Batch Scripting (windows), which are not as flexible.

Script arguments

Often is useful to send direct arguments to a script to have, for instance, a different functionality.

Let’s change the previous scenario to receive the name of the file that contains the email address, as a script argument.

The script arguments are automatically stored in the $argv variable. Notice the first element of the array ($argv[0]) is the name of the script!

The modified example is as follows:

 1#!/usr/bin/php
 2<?php
 3
 4// the count stars at 1 to eliminate the name of the script
 5for ($i = 1; $i < count($argv); $i++) {
 6  // initializing the input stream
 7  $input = fopen($argv[$i], 'r');
 8
 9  // initializing error stream
10  $err = fopen('php://stderr', 'w');
11
12  if(!$input) {
13   continue;
14  }
15
16  // unlike the previous cases, here is tested for the end of the file
17  // because the input is not coming from keyboard
18  while(!feof($input)) {
19   // the value is trimmed to remove line terminators
20   $line = trim(fgets($input, 1024));
21
22   // test email address
23   if(filter_var($line, FILTER_VALIDATE_EMAIL)) {
24     // direct output, equivalent to php://stdout stream
25     echo $line . PHP_EOL;
26   } else {
27     // invalid addresses are redirected to the php://stderr stream
28     // to be intercepted later
29     fputs($err, $line . PHP_EOL);
30   }
31  }
32
33  // close input stream
34  fclose($input);
35
36  // close error stream
37  fclose($err);
38}

Now just run the script with arguments:

1$./argTest.php email.txt >valid.txt 2>invalid.txt