Symfony Installation, Setup

You can choose between several alternatives to install symfony, from the simplest to the most advanced one.

The PEAR installation is for those who want to run several symfony-based projects, with an easy way to upgrade. It requires PEAR version 1.4.0 or higher, which is bundled in most PHP distributions.

The first thing to do is to add the 'symfony' channel:

Optionally, to see the libraries available in this channel:

Then, to install the latest stable release and all its dependencies with:

or to install the nightly release:

Symfony needs a few other packages to run; some are included in the installation, and some require you to install them if they are not present. Especially, to install Phing:

That's it: symfony is installed. You may now create a new project with the new command line tool symfony and use the classes and methods of the libraries.

To have a glimpse of all the tasks that you can perform directly with the command-line tool, type:

PEAR also provides an easy way to upgrade symfony, for instance to get the latest beta version:

From latest beta upgrade to latest stable:

Check version:

Get more info:

To uninstall:

$ pear channel-update pear.symfony-project.org Retrieving channel.xml from remote server Channel pear.symfony-project.org channel.xml is up to date

documented on: 2007.01.27

http://www.symfony-project.org/book/trunk/project_creation

In symfony, a project is a set of services and operations available under a given domain name, sharing the same object model.

Inside a project, the operations are grouped logically into applications; an application can normally run independently of the other applications of the same project.

In most cases, a project will contain two applications, one for the front-office, and one for the back-office, sharing the same database. But you can also have one project containing lots of mini-sites, each site being a different application. Note that hyperlinks between applications have to be in the absolute form.

Each application is a set of one or more modules, each module bringing a particular feature. A module usually represents a page or a group of pages with a similar purpose. Example modules could be home, articles, help, shoppingCart, account, etc.

Modules contain actions. They represent the various actions that can be done in a module, for instance a shoppingCart module can have add, show and update actions. Dealing with actions is almost like dealing with pages in a classic web application.

If this represents too many levels for a beginning project, it is very easy to group all actions into one module, so that the file structure can be kept simple. When the application gets more complex, it will be time to organize actions into logical modules.

An application can run in various environments to use, for instance, different configurations or databases. By default, every new application can run in three environments (development, test and production). An application can have as many environments as needed. The difference between environments is the configuration.

For instance, a test environment will log alerts and errors, while a production environment will only log errors. The cache acceleration is often deactivated in a development environment but activated in test and production environments. The development and test environments may need test data, stored in a database distinct from the production one. All environments can live together on the same machine, although a production server generally contains only the production environment.

SymFony uses a dedicated tool called Pake to administer projects, applications, and modules. Pake is a php tool similar to the Rake command, a Ruby translation of the make command. It automates some administration tasks according to a specific configuration file called pakefile.php. But since you use the pake tool just by typing symfony in a command line, everything becomes much simpler than it sounds.

To get the full list of the available administration operations, simply type from your project directory:

$ symfony -T

The description of the CLI tasks used during the early stage of a project follows. A full reference of the CLI tasks is available in the CLI chapter.

First of all, you must create the directory that will contain all your project files:

Then, in order to initialize the project and generate the basic files and directories necessary for runtime, simply type:

Here is an overview of the file structure created:

The symfony command must always be called from a project root directory (myproject/ in the example above), because all the tasks performed by this command are project specific. If called from one of the project subdirectories, the command will raise an error.

The project is not yet ready to be seen; it requires at least one application. To initialize it, use the symfony init-app command and pass the name of the application as an argument:

This will create a myapp directory in the apps/ folder of the project root, with a default application configuration and a set of directories ready to host the file of your website:

Some php files corresponding to the front controllers of each default environment are also created in the project root web directory:

index.php is the production front controller of the new application. Because you created the first application of the project, symfony created a file called index.php instead of myapp.php (if you now add a new application called mynewapp, the new production front controller will be named mynewapp.php). To run your application in the development environment, call the front controller myapp_dev.php.

From now on, the /home/steve/myproject/ directory will be considered as the root of your project. The root path is stored in a constant called SF_ROOT_DIR, defined in the file index.php, and we will use this name instead of the real path to avoid confusing the readers who aren't named Steve.