File Locking

On Monday, we described how to declare functions in PHP, how to do string manipulation in PHP, and how to read and write from a file in PHP. Today, we start by looking at some more sophisticated file handling in PHP. To start, we consider file locking...

It is completely possible for two scripts to try to access the same file at the same time.

To prevent this you should call the flock function to get a lock before you try to do something with a file:

$fp = fopen("/tmp/my-data.txt", "w");
if (flock($fp, LOCK_EX)) { 
   // do an exclusive/write lock. use LOCK_SH (for  shared/read lock)
   fwrite($fp, "Write something here\n");
   flock($fp, LOCK_UN); // release the lock
} else {
   echo "Couldn't lock the file !";
}
fclose($fp);

Locks are released when fclose() is called.

Permissions and Unix-like File Manipulation

PHP supports several functions for manipulating files and directories:

rename($oldname, $newname); //like Unix mv command, renames/moves a file
copy($source, $dest); //copies a file, like Unix cp
unlink($filename); // delete a file
mkdir($path); // make a directory
rmdir($path); // delete a directory
link($target, $name); // create a link
chmod($filename, $mode); // change file permissions
chown($filename, $user); // change owner of a file or dir or link
chgrp($filename, $group); //change group of a file or dir or link
stat($filename); 
   //returns an array saying size, last access, last modified, etc.  for a file
touch($filename [, int $time = time() [, int $atime ]]); 
   //sets modification/ access times of a file

Directory Handling in PHP

You can read the contents of a directory (aka a folder) with the following PHP code:

if(file_exists('/path/to/folder')) { //file_exists check if a file or dir exists
    $h = opendir('/path/to/folder'); //can use is_dir to check is something is a directory
    while (($item = readdir($h)) !== false) {
        $type = is_dir($item) ? "directory" : 
            (is_link($item) ? "link" : 
            "file");
        //there is also a is_file
        echo "$item is a $type\n";
    }
}

Alternatively, you can get an array of all file names whose path matches a file pattern using the glob command:
```
$text_files = glob("/some_path/*.txt");
foreach($text_files as $file_name) {
   //do something
}
```

Cookies

Sometimes it is useful to remember a client when it comes back, To do this one can use the HTTP-Cookie protocol.

The Server can send as one of its response headers:

Set-Cookie: name=value;Expires=some date;Path=some path;Domain=some_domain;

Expires, Path, Domain, are optional. If don't have Expires, then the cookie lasts until browser is closed (often used for session cookies, which we'll get to in a moment).
The Mozilla Set-Cookie Page has a list of other modifiers besides Expires, Path, and Domain.
In PHP you can write out a header using the header() function.
When the Client comes back, it will send the cookie as part of its request header as:
```
Cookie: name=value
```
The Client can use multiple Cookie headers or
```
Cookie: name1=value1; name2=value2; ...
```
to send back multiple cookies.

Cookies in PHP

Cookies can be set using the setcookie function:
setcookie(name, value, expires);
This should be done before output is produced by your script.
To access the value of a cookie returned from a browser you can use the $_COOKIE array.

Sessions

A session is a collection of information about one user's interaction with a web site.
It is usually transient in nature and has some lifetime associated with it.
For example, interactions with a web-site leading up to a purchase. If a purchase is eventually made, the purchase data is permanently records in the database. The permanent store being different from the session.
Cookies can be used to implement sessions. A single name-value pair: session_id=some-random-string is sent as a cookie together with an expiry time. This pair when sent from the browser is used to look up on the server a file containing a serialized associative array of user data.
PHP supports session management.
To start a session one calls session_start(); . This is what sends the Set-Cookie header so needs to before any html is output. The default name used for the session_id is PHPSESSID. You can change this with the function session_name($some_name);

Then to set/get values of the session one uses the global array variable $_SESSION:

$_SESSION["test"]=37; /* sets the test session variable*/
echo $_SESSION["test"];

Let's Build Something...

Write a short PHP program which starts a session.
Your program should then store the current time into $_SESSION['time'] variable only if $_REQUEST['set_time'] is non-empty. In this case, it should also check if $_REQUEST['name'] is set and store that into $_SESSION['name'].
Finally, your program should print_r the $_SESSION variable.
Locate using phpinfo() where the session file is stored on your machine. What are the contents of this file after your program stores info by the above process?
Next add to your program an include of some_file.php before the session_start. Make sure error reporting is on (error_reporting(-1); ini_set('display_errors', 'On');) For each of the following scenarios say what error messages you get if any when you run your program.
- some_file.php does not exist
- some_file.php consists of a single space.
- some_file.php consists of the five characters: <?php
Post your code and the results of your experiments to the Sep 28 Class Thread.

Website Architecture

At this point, we know how to output html from PHP, how to use the control structures available in PHP, and a little about how to make data permanent (on a hard drive somewhere) in PHP.
Before we continue talking about databases, I thought it would be useful to talk about how to organize your web applications as you are developing them.
A common approach is to use a variant of the Model-View-Controller (MVC) design pattern.
We split the project into different types of files (later we will use classes) which we might put into different project folders: views, models, and controllers.
views folder files are responsible for drawing web pages. They should mainly be HTML with little or no logic. They may have functions like those from last day which take data created elsewhere and draw it in the content of an HTML page.
controllers folder files contain the logic of the application. Code here should not touch permanent storage directly nor should it render HTML.
models folder files contain code to read and write data from the file system. It shouldn't contain logic related to the web app or render things to a browser.

More Website Architecture

In a traditional MVC set-up, a user sees a view, manipulates the GUI, which causes controller functions to be called. These functions in turn make models calls to read and write storage. If storage is written then the model might call view functions to update what the user sees.
In web-development we often use a slightly different MVC set-up known as Model-View-Adapter or mediating-controller MVC .
Here the user points his browser at a web page. Typically, this is set up to always hit the same index.php page.
From the request query string, the index.php determines a controller to use and a function in that controller to call.
This controller function uses the request to determine which model calls to make to read and write storage.
Based on the above, the controller function, determines which view is appropriate to send back to the user and intializes any data it may need.
The controller then calls the appropriate view render function to draw the web page the user will see in his browser.
Notice this is different from MVC in that the controller invokes both model and view methods. In traditional MVC, we have controller function invoking model functions which in turn invoke view updates.

Cookies, Sessions, and Web-site Architecture

Outline