Web Magician - Information, News, Programming Tips and Tricks about IT Technology

Overriding Controllers and Actions in Magento

pmkansara@gmail.com (Paryank Kansara) — Tue, 16 Aug 2011 01:44:07 PDT

In my previous post, I had explained a way to add extra controllers to existing route. Here I am going to explain another method which is used for overriding controllers and actions. Like my each post on tips & tricks, I am going to first explain where the trick is applicable! I am considering that readers of this post are aware of MVC architecture in Magento.

Let me explain the difference between the both tricks. The trick explained in previous post is used when we need additional URLs in same route i.e. additional controllers and actions. I have already explained an example there. Here we need to change the behavior of existing controller and action. For example, when a customer adds a product to shopping cart, addAction of CartController of Mage_Checkout module is called. If we want to override this by My_Checkout, MycartController, myaddAction as similarly as we can override Models and Blocks in our own modules. So the the trick in previous post is used for overloading while the trick here is used for overriding.

Of course, this too can be done just by simple XML configuration (apart from creating custom controllers and actions) but without using route rewriting approach! Let's take a same example above where we want to override action for checkout/cart/add. First create My_Checkout module with MycartController class and myaddAction method defined within it. The way to do this is better explained in this wiki. Then the configuration required in etc/config.xml of My_Checkout module is like below:

<global>
  <routers>
    <checkout> <!-- Mage_Checkout module -->
      <rewrite>
        <cart> <!-- CartController -->
          <to>mycheckout/mycart</to> <!-- My_Checkout module, MycartController -->
          <override_actions>true</override_actions>
          <actions>
            <add> <!-- addAction -->
              <to>mycheckout/mycart/myadd<to> <!-- My_Checkout/MycartController/myaddAction -->
            </add>
          </actions>
        </cart>
      </rewrite>
    </checkout>
  </routers>
</global>

Here we also need configuration to define module front name for My_Checkout module as below:

<frontend>   <!-- It will be admin for overriding admin controller -->
  <routers>
    <mycheckout>
      <use>admin</use>
      <args>
        <module>My_Checkout</module>
        <frontName>mycheckout</frontName>
      </args>
    </mycheckout>
  </routers>
</frontend>   <!-- It will be admin for overriding admin controller -->

Note: The above configuration examples only display portions of config.xml file. Please do not consider it as a complete configuration.

Simple isn't it? Now let's understand how it works. The work flow of this rewrite process is little bit tricky.

When an checkout/cart/add action is going to be dispatched, first it is passed through rewrite process.
Rewrite process tries to find global/routers/checkout/rewrite/cart node is found in configuration, where checkout is front name of Mage_Checkout module and cart indicates Mage_Checkout_CartController.
If this node is not found, rewrite process is not be continued and returned to dispatch process. So the action is executed normally. Otherwise, rewrite process is continued.
Now, under this node, it tries to find whether override_actions node is true or false. By default value of override_actions is true. So if it is not added in configuration, it is considered as true.
If override_actions is true, it overrides all actions of Mage_Checkout_CartController with same actions of My_Checkout_MycartController as defined by to node value mycheckout/mycart. For example, if we have defined addAction and indexAction methods inside My_Checkout_MycartController, then it automatically overrides both addAction and indexAction of Mage_Checkout_CartController. In short using to node and override_actions node we can override whole controller instead of individual actions.
If actions/add node is defined where, add indicates addAction of Mage_Checkout_CartController, then override_actions node value is not considered and overrides action by value of actions/add/to node which is mycheckout/mycart/myadd i.e. My_Checkout module, My_Checkout_Mycontroller and myaddAction. So we can also override individual actions by this type of configuration.

Sounds good again? Try it too...

Secret feature of Magento 1.3: Sharing same route name for different modules!

pmkansara@gmail.com (Paryank Kansara) — Mon, 01 Feb 2010 20:51:46 PST

I have already talked about flexible architecture of Magento Commerce in my previous posts. As Magento allows to customize its default behavior without touching and modifying the existing code, we can override any of the existing class by defining our own in our out of the box extensions. I have also played with Magento by creating variety of extensions, and believe me, it was a real fun of programming. Magento allowed me to change everything I desired.

But I was still feeling that something is missing! And that missing thing was provision for sharing of route names which is now available since Magento 1.3 released yesterday. Now, the first question may arise here that "what is sharing of route names?". 'Sharing of route names' is not a functional feature. So if you'll try to find it in Magento features list, you may be disappointed. Actually it is a feature for developers. It is not even mentioned in Magento 1.3 Release Notes. I found this secret feature in newer version of Magento when I was roaming inside the code to search the difference between 1.2 and 1.3. Let me explain this feature in more detail.

Sometimes, I was supposed to develop extensions which required extra pages or forms in existing modules. For example, adding extra features to Admin Panel. I needed some extra controllers and actions for Admin Panel. This seems OK. I could easily create a local module for it as explained in this Wiki. But an uncomfortable part in this way is this configuration:

<admin>
 <routers>
   <sintax>
     <use>admin</use>
     <args>
       <module>Mage_Sintax</module>
       <frontName>sintax</frontName>
     </args>
   </sintax>
 </routers>
</admin>

Here, all URLs of my additional pages will be started by /sintax/ while all other admin panel pages will be started by /admin/. I am forced to use other routes for my additional modules. I cannot just add more URLs to 'admin' route! This can be fare for Admin Panel pages as they will never be visible by public. But what if I want to add more pages to frontend? If I add any extra page to 'catalog' module, I can't define URLs for my pages starting with /catalog/. I have to define a route something like /mycatalog/ which I don't like!

One solution for this to use URL rewrite from /catalog/mypage/ to /mycatalog/mypage/. But unfortunately, URL helpers will still generate URLs like /mycatalog/mypage/.

The problem with the older version of Magento was mapping one to one relationthip with module front name to module real name i.e. 'catalog' => 'Mage_Catalog', 'admin' => 'Mage_Adminhtml' etc. So I could not map my additional module to existing front name. But Magento 1.3 allows to map additional modules to existing front names. How? Just by changing router configuration for module shown above to the following:

<admin>
 <routers>
   <adminhtml>
     <args>
       <modules>
         <sintax before="Mage_Adminhtml">Mage_Sintax</sintax>
       </modules>
     </args>
   </adminhtml>
 </routers>
</admin>

This configutation will add Mage_Sintax module to admin frontname. An attribute before can be added to give more priority then existing module in finding controllers. For example in this case, /admin/catalog/ URL will call a controller class Mage_Sintax_CatalogController, if it is defined and if not then it will call Mage_Adminhtml_CatalogController. Similarly, after attribute will assign less priority then the existing module. We can add as many modules as we need to the same front name using this way.

Sounds good? Then try it yourself...!

Zend Framework 1.7 with AMF support released!!!

pmkansara@gmail.com (Paryank Kansara) — Mon, 17 Nov 2008 23:25:57 PST

Zend Framework 1.7.0 is now available from the Zend Framework download site: http://framework.zend.com/download/latest

This release introduces many new components and features, including:

Zend_Amf with support for AMF0 and AMF3 protocols
Dojo Toolkit 1.2.1
Support for dijit editor available in the Dojo Toolkit
Zend_Service_Twitter
ZendX_JQuery in extras library
Metadata API in Zend_Cache
Google book search API in Zend_Gdata
Preliminary support for GData Protocol v2 in Zend_Gdata
Support for skip data processing in Zend_Search_Lucene
Support for Open Office XML documents in Zend_Search_Lucene indexer
Performance enhancements in Zend_Loader, Zend_Controller, and server components
Zend_Mail_Storage_Writable_Maildir enhancements for mail delivery
Zend_Tool in incubator
Zend_Text_Table for formatting table using characters
Zend_ProgressBar
Zend_Config_Writer
ZendX_Console_Unix_Process in the extras library
Zend_Db_Table_Select support for Zend_Paginator
Global parameters for routes
Using Chain-Routes for Hostname-Routes via Zend_Config
I18N improvements
- Application wide locale for all classes
- Data retrieving methods are now static
- Additional cache handling methods in all I18N classes
- Zend_Translate API simplified
File transfer enhancements
- Support for file elements in subforms
- Support for multifile elements
- Support for MAX_FILES_SIZE in form
- Support for breaking validation chain
- Support for translation of failure ,messages
- New IsCompressed, IsImage, ExcludeMimeType, ExcludeExtension validators
- Support for FileInfo extension in MimeType validator
Zend_Db_Table_Select adapater for Zend_Paginator
Support for custom adapters in Zend_Paginator
More flexible handling of complex types in Zend_Soap

In addition, almost three hundred bugs have been fixed:

http://framework.zend.com/issues/secure/IssueNavigator.jspa?requestId=10903

Zend Framework 1.6 Released!!!

pmkansara@gmail.com (Paryank Kansara) — Sat, 06 Sep 2008 18:06:11 PDT

I develop my PHP web applications in Zend Framework since its first stable release. I compared it with many other frameworks and I choose Zend Framework for my development approch because of its outstanding flexibility, huge community support and transperent development roadmap.

Yesterday, Zend has released a brand new version of Zend Framework 1.6. This new version has introduced many new useful features. The new 1.6 version includes built in support of Dojo Toolkit, a powerful AJAX and UI library as well as PHPUnit, the most powerful Unit Testing framework for PHP.

The complete list of new features of Zend Framework is:

Dojo Integration
- JSON-RPC
- Dojo Data packing
- Dojo View Helper
- Dijit integration with Zend_Form & Zend_View
- Dojo Library Distribution
SOAP
- SOAP Server
- SOAP Client
- Autodiscovery
- WSDL access
- WSDL Generation
Preview of Tooling Project in Laboratory (see /laboratory folder)
- Command Line Interface
- Project Asset Management
Unit Testing Harness for Controllers
Lucene 2.3 Index File Format Support
Zend_Session save handler for Database Tables
Paginator Component
Text/Figlet Support
ReCaptcha Service
Zend_Config_Xml Attribute Support
Character Set Option for DB Adapters
Zend File Transfer Component
New Media View Helpers (Flash, Quicktime, Object, and Page)
Support in Zend_Translate for INI File Format
Zend_Tool
Zend_Wildfire Component with FireBug Log Writer
Zend_Db_Profiler with FireBug support

With the lots of new features, Zend Framework has also enhansed the performance compared to older releases. You can download the latest release of Zend Framework from here.

Zend Framework has made its own place in the clouds of more than 40 PHP Frameworks.Technorati Tags: Zend Framework, Web Technology Information, PHP, Frameworks

Introducing Web Magician Toolbar

pmkansara@gmail.com (Paryank Kansara) — Thu, 21 Aug 2008 21:57:19 PDT

New Web Magician Toolbar is now available. You may really like to try our new toolbar because it's free, private and secure. It takes few seconds for installation. It also includes the features which may make your browsing and searching easier and keep you connected with us:

Accelerated search bar - Google powered search bar for faster and accurate search results
E Mail Notifications - Get new email notifications for your Yahoo, Gmail, Hotmail or POP3 Mails
Radio - Stay tuned and listen each Web Magician blog entries as Podcast
RSS feeds - Get updated with latest posts of Web Magician
Pop-up Blocker - Block annoying pop-ups automatically
Privacy - Clean your private data like cookies, history, cache from your browser
Weather forecast - Get world wide weather information
Web Magician Quick launch button - Visit us on a single click

Web Magician Toolbar is available for Mozilla Firefox and Internet Explorer. Try Our Toolbar

Actual Model implementation in MVC Architecture

pmkansara@gmail.com (Paryank Kansara) — Sun, 10 Aug 2008 06:53:10 PDT

Frameworks like Ruby on Rails have made MVC (Model View Controller) architecture more popular and easier. Most of the PHP frameworks like CakePHP, Symfony, PHP on Trax, Zend Framework have followed similar patterns as Ruby on Rails for MVC. By using these frameworks, MVC in design is no longer painful.

But do all people maintain MVC in real manner??? The major misconception the people have is about the role of Model in MVC. I read many tutorials of Ruby on Rails, Zend Framework, CakePHP and Symfony. Many of the tutorials explain the role of Model as to access data from database. That means Model would be responsible for providing and updating of data into the database!!! All the business logic would be handled by the Controller!!!

It is a simple way, but would be fare only for small scale applications which do only CRUD (Create, Read, Update, Delete) operations. Then, what about large applications where business logic is much complex? Is it a good idea to encapsulate all business logic in Controller?

I recently read some blog posts such as:
ActiveRecord sucks by Kore Nordmann,
ActiveRecord sucks, but Kore Nordmann is wrong by Mike Seth,
ActiveRecord does not suck by Bill Karwin and
Fat Models and the Data Access Layer by Dave Marshall

Bill Karwin and Dave Marshall explains actual implimentation of Model. The Model is a business logic of your application not only the database access layer. Active Record (in RoR, Cake, Symfony) or Table/Row Data Gateway (in Zend Framework) should be used as a part of model not as a model. Your all business logic should be encapsulated in Models only.

One of the strongest reasons for following MVC is reusability. Think about the case when you want to port your PHP web application to desktop application using PHP-GTK. If you have followed correct MVC architecture then you can easily reuse the same Models of web based application into GTK based application. If you have encapsulated your business logic in controller, then you have to rewrite all the code again for GTK!!! It would simply kill DRY (Don't Repeat Yourself) principle!!!

I am using Zend Framework since its 1.0 release. At the beginning I read lots of tutorials about it and I was in the same misconceptions about the Models. Then I had taken a look around the code base of Magento Commerce. As I told in my previous post, Magento is built on Zend Framework and follows MVC architecture. (I noticed that Magento uses many ZF components but does not use Zend_Controller and Zend_View for its MVC because of its own custom patterns. But the implementation is quite similar to Zend Framework.) I'd noticed that MVC is followed in really nice way and provides very much flexibility for customization. It is very good example for enterprise application design.

Magento 1.0 has arrived!!!

pmkansara@gmail.com (Paryank Kansara) — Wed, 07 May 2008 23:47:45 PDT

My previous post was published before the launch of Magento - Preview Version and was introducing the features those were going to be implemented (and now have been implemented). The preview version was released on 31st August, 2007. So it has been very long time since my last post but busy schedule of life was'nt giving me a single moment for blogging.

And yesterday, on 31st March, 2008, long awaited Production version of Magento Commerce has been released.

Since the release of first preview version, the updates was being released frequently. With every release, Magento was shining more and more. The progress is incredible in very less time. Magento provides lot of exciting features like Multiple Stores and Websites, Google Checkout support, Single Page Checkout, Shipping to multiple addresses in one order and many more.

Varien - Magento Company has already announced parnership and collaboration with Parallels and Media Temple to deliver Magento 1.0 through a one-click installation wizard.

As a developer, the most impressive thing I found in magento is its flexibility for customization. As I have already mentioned in my previous post, magento is developed on Zend Framework and uses MVC architecture, which makes magento easier to maintain. Apart from that, magento also provides out of the box solution for customization. That means, magento can be customized as you need without modifying a single line of code in existing core modules. Instead, you can develop your own modules with specific configuration which overwrite the behavior of existing core modules. I love this way because it provides flexibility for upgrading magento to newer version.

So, on this occasion it really worths if they say:

Open Source eCommerce has officially evolved.

Magento - Get ready for new Open Source E-Commerce solution

pmkansara@gmail.com (Paryank Kansara) — Thu, 23 Aug 2007 05:06:27 PDT

After investing 5 years in osCommerce based E-Commerce solutions, Varien is going to launch it's own Open Source E-Commerce Solution - Magento.

As osCommerce is not much upgraded since long time, E-Commerce service providers are eagerly waiting for new solutions with more functionalities and features, Magento will have to pass through a difficult examination. At a first look at the website of Magento it seems that it would be better than any older E-Commerce solutions.

It is very hard to make users to switch from other products to your product. Because first question they would ask you is: "What's better in yours than the current?". Varien says something in answer of it on their Why Magento Page.

No Constraints

Magento is much flexible so that you can create your online store exactly as your business model without any extra clutter or constricting design limits.
Completely Scalable

Magento is completely scalable. So with growing of your site, you can easily manage more resources.
Professional and Community Support

Magento offers professional reliable support, as well as the help of its passionate community.
Smooth Integration

You can create your customized store according to your business model in Magento with easier integration by saving your time and resources.
Cutting Edge Features

Magento provides many extra features like Produce Tagging, Multi-address Shipping, Product Comparison System etc. those are not yet provided by any other open source e-commerce solutions.

Magento is built on Zend Framework so it is clear that it will strictly follow MVC structure in it's through out coding. Thus, it would flexible to developers too.

Let's wait for it's first Beta Release and examine it's power trying it our self.

Source: magentocommerce.com

YAML - Just another powerful and easy markup language

pmkansara@gmail.com (Paryank Kansara) — Sun, 05 Aug 2007 22:09:47 PDT

YAML is a human-readable data serialization format that takes concepts from languages such as XML, C, Python, Perl, as well as the format for electronic mail as specified by RFC 2822. YAML was first proposed by Clark Evans in 2001, who designed it together with Ingy döt Net and Oren Ben-Kiki.

YAML is a recursive acronym meaning "YAML Ain't Markup Language". Early in its development, YAML was said to mean "Yet Another Markup Language", retronymed to distinguish its purpose as data-centric, rather than document markup. However since "markup language" is frequently synonymous with data serialization, it is reasonable to consider YAML a lightweight markup language.

YAML syntax is relatively straightforward and was designed to be easily mapped to data types common to most high-level languages (lists, hashes (mappings), and scalar (single value) data.). Its familiar indented outline and lean appearance makes it especially suited for tasks where humans are likely to view or edit data structures, such as configuration files, dumping during debugging, and document headers (e.g. the headers found on most e-mails are very close to YAML in look). Its line and whitespace delimeters make it friendly to ad hoc grep/python/perl/ruby operations. YAML uses a notation based on a set of sigil characters distinct from those used in XML, making the two languages composable. A major part of its accessibility comes from eschewing the use of enclosures like quotation marks, brackets, braces, and open/close-tags which can be hard for the human eye to balance in nested hierarchies.

Data structure hierarchy is maintained by outline indentation. The following YAML document defines a hash with 7 top level keys. One of the keys, "items", contains a 2 element array (or "list"), each element of which is itself a hash with four keys. The "ship-to" hash content is copied from the "bill-to" hash's content as indicated by the anchor(&) and reference(*) labels. An optional "..." can be used at end of a file (useful for signalling an end in streamed communications without closing the pipe). Optional blank lines can be added for readability. The specific number of spaces in the indentation is unimportant as long as the hierarchy order is maintained and parallel elements have the same left justification. Multiple documents can exist in a file and are separated by "---". Notice that strings do not require enclosure in quotations.

Example:

---!myDocument
logEvent:    Purchase Invoice
date:        2007-08-06
customer:
   given:   Dorothy
   family:  Gale

bill-to:  &id001
   street: |
           123 Tornado Alley
           Suite 16
   city:   East Westville
   state:  KS

ship-to:  *id001  
 
items:
   - part_no:   A4786
     descrip:   Water Bucket (Filled)
     price:     1.47
     quantity:  4

   - part_no:   E1628
     descrip:   High Heeled "Ruby" Slippers
     price:     100.27
     quantity:  1

specialDelivery:  >
   Follow the Yellow Brick
   Road to the Emerald City.
   Pay no attention to the
   man behind the curtain.
...

Dynamic Virtual Host with Apache

pmkansara@gmail.com (Paryank Kansara) — Mon, 30 Jul 2007 20:31:50 PDT

Apache, the most popular web server on earth, is distributed with a large number of modules, some of which are included by default when you compile the package, and some which aren't. One of those that you can optionally compile is mod_vhost_alias, which I find particularly useful. It's been available since Apache version 1.3.7.

Mod_vhost_alias adds dynamic virtual hosting. That is, we don't need a VirtualHost declaration for each site. Using mod_vhost_alias directives, we can rewrite requests based on the IP address or the host name of the requested resource and return documents from the correct site. The advantages of this capability are that you can add any number of web sites without resorting to modifying and reloading the Apache configuration time and time again.

The extra directives available to us when mod_vhost_alias is present are: VirtualDocumentRoot, VirtualDocumentRootIP, VirtualScriptAlias, and VirtualScriptAliasIP.

Those ending with 'IP' use the IP address of the site requested, whereas the others use the host name. Since IP addresses are hard to come by these days, that is until IPV6, the 128 bit net addressing protocol becomes the norm, we'll concentrate on using VirtualDocumentRoot and VirtualScriptAlias to maximize the number of sites we host under one IP. If you need to use the IP versions of these instructions, it shouldn't be difficult for you to figure out since they work exactly the same way, but parse the IP of the requested host name instead.

Let's start with an example from an imaginary configuration file...

<VirtualHost 208.231.13.91>
CustomLog /www/logs/208.231.13.91.log vcommon
UseCanonicalName Off
VirtualDocumentRoot /www/webdocs/%-2/
VirtualScriptAlias /www/scripts/%-2/
</VirtualHost>

You'll first notice the "UseCanonicalName Off" core directive. This is mandatory for our purposes as it tells Apache to use the host name as requested by the client rather than a value set in a ServerName directive or devising one if it's absent. You'll also notice that all our sites' web documents must be in a sub-directory of /www/webdocs and all their scripts in a sub-directory of /www/scripts. For each site you added, you'd have to create these sub-directories and add a dns zone with the IP 208.231.13.91, but that's all. Of course, you can use your own paths.

More important are the strange %-2 in the paths. This is a vhost instruction that allows us to extract a part of the host name and use it in the rewriting of the document path. The parts of the host name are determined by the '.' it contains. Thus, www.xyzcgrf.com has 3 parts. '%-2' means "extract the second to last part of the host name". Again using our example, suppose we have a request for "http://www.xyzcgrf.com/hello.htm"...Since xyzcgrf.com resolves to 208.231.13.91, Apache would use our VirtualHost declaration and would replace '%-2' with 'xyzcgrf', as the latter is the before last part of the host name. The document to return would thus be found at: /www/webdocs/xyzcgrf/hello.htm.

Continuing with our example, a request for the script "http://www.xyzcgrf.com/cgi-bin/test.cgi" would execute the script found at /www/scripts/xyzcgrf/test.cgi. Note that even if the requested url omitted the 'www.', it would still be rewritten correctly in my example. While the above example would serve you well for the dot-com and dot-net type domains, it would not fare well for country domains. Thus, a request for http://xfxfvc.co.uk and http://ghtrrd.co.uk would both translate to a path of /www/webdocs/co/, which is obviously not what we intended. There's actually a whole slew of interpolation meta characters that we can use, so we're not stuck. Here are some of them, using http://www.bogus.xyzcgrf.com as an example.

%0 : use the whole name [www.bogus.xyzcgrf.com]
%1 : use the first part [www]
%2 : use the second part [bogus]
%3 : use the third part [xyzcgrf]
%-1 : use the last part [com]
%-3 : use the third to last part [bogus]
%2+ : use the second and all subsequent parts [bogus.xyzcgrf.com]
%3+ : use the third and all subsequent parts [xyzcgrf.com]
...etc...

You can also go nuts by extracting a part from a host name, then extracting a part from that part. In the latter case, the part would be a character or sequence of characters. We do this by using the format '%N.M', where %N is our first extract and 'M' is the second. The '.' is mandatory, but you omit the '%' in the second. For example...

VirtualDocumentRoot /www/webdocs/%-2.2/

...if we put the url http://www.bogus.xyzcgrf.com through this directive, we get /www/webdocs/y/. That's because %-2 extracted xyzcgrf, and the '2' gave us the second letter 'y'. I never needed this capability, but maybe you'll find some use for it. If what truly interests you is extreme url rewriting, there's another module which can allow you to slice and dice urls any which way, called "rewrite_module". We'll explore its possibilities in the near future.

In order to smoothly rewrite paths for our xfxfvc.co.uk type host names that our first example fumbled with, we need to assign them a different IP in a separate VirtualHost declaration. Our vhost directives in that one would look like this...

VirtualDocumentRoot /www/webdocs/%-3/
VirtualScriptAlias /www/scripts/%-3/

Thus, we'd extract the xfxfvc rather than the 'co'. I believe in keeping things simple, so I avoid using anything but the %- interpolations, as the rightmost part of any host name is reliable whereas the leftmost isn't. One drawback to using vhost_mod is that you can't have individual log files for each site sharing the IP. Instead, all will log to the same files. The way we compensate for that is by creating a special logging definition that will include a field that registers the domain of the request. Thus, for example, the instruction...

LogFormat "%V %h %l %u %t "%r" %s %b" vcommon

Appears somewhere in our configuration file. The "%V" tells apache to log the host name requested by the client [See: mod_log_config].

With the LogFormat we've just defined, your log might look something like this...

www.rtzxfgh.com 172.128.55.43 - -
[03/May/2001:10:21:48 -0400]
"GET /bogus.htm HTTP/1.1" 200 0
www.ouwqagxh.com 172.128.55.44 - -
[03/May/2001:10:21:49 -0400]
"GET / HTTP/1.1" 200 0

In order to generate individual traffic reports for each site sharing the log file is a statistical tool that can parse such a log.

Some useful links you can follow to get further knowledge on the subjects discussed today:

mod_vhost_alias
UseCanonicalName
mod_log_config

Source: devnewz.com

PHP 6 Overview

pmkansara@gmail.com (Paryank Kansara) — Thu, 19 Jul 2007 04:14:39 PDT

PHP 6, it seems, will make the leap and become a more clean environment - which is something I really appreciate.

The register_globals, magic_quotes and safe_mode will finally disappear and hopefully slowly fade away into distant memory. It seems PHP 6 will even refuse to start if these settings are found in php.ini. Dropping support for the long versions of super globals, like HTTP_POST_VARS, is also scheduled. This is long overdue.

One thing I at first was a bit hesitant to is moving all the database extensions out of the core into PECL. It looks like this is not set in stone and seems to be an ongoing discussion. After thinking about it myself I think it would be the right thing to do. It would boost the usage of PDO and make it more used and thus more mature. It would also clear up some of the confusion among newcomers in the PHP sphere. "Use PDO or make an active choice" - would probably be the best for the future of PHP.

SOAP is widely used today and good support for SOAP has been around as an extension you have to actively turn on if you needed it. It also has many limitations as has been discussed recently on the PECL-DEV mailing list. There is also a new PHP SOAP extension being developed that is using Apache Axis 2 from the Apache Foundation. I think what is suggested for PHP 6, to fix most of the remaining issues as well as implement support for some of the security extensions of SOAP, is the right way to go. I really think SOAP needs to be natively supported in PHP rather than having to depend on an external library as is the case with the Axis2 extension.

Named parameters to functions and methods has also been discussed. Even though I can remember how I enjoyed writing Smalltalk code with named parameters more than 10 years ago in university I don't think it should be implemented in PHP. Luckily those that decide on the roadmap thought the same as me.

Something that really annoys me today is that you can call methods both statically and dynamically whether they are marked static or not. It just doesn't make sense. This will in the yet distant PHP 6 generate an E_FATAL. Now that makes sense.

This above is all well but it is in the planned additions it gets really interesting. PHP 6 will have the opcode cache APC included in the core distribution. It will not be turned on by default - but I think this is the first small step towards a future with JIT compilation or something along those lines. Good UTF support is another thing that is sorely needed and it seems a lot of work will be directed to clean up the string handling in PHP 6.

Source: dotvoid.com

Web 3.0 Features

pmkansara@gmail.com (Paryank Kansara) — Tue, 17 Jul 2007 02:55:56 PDT

Just in case you missed it, the web now has version numbers. Nearly three years ago, amid continued hand-wringing over the dot-com crash, a man named Dale Dougherty dreamed up something called Web 2.0, and the idea soon took on a life of its own. In the beginning, it was little more than a rallying cry, a belief that the Internet would rise again. But as Dougherty's O'Reilly Media put together the first Web 2.0 Conference in late 2005, the term seemed to trumpet a particular kind of online revolution, a World Wide Web of the people.

Web 2.0 came to describe almost any site, service, or technology that promoted sharing and collaboration right down to the Net's grass roots. That includes blogs and wikis, tags and RSS feeds, del.icio.us and Flickr, MySpace and YouTube. Because the concept blankets so many disparate ideas, some have questioned how meaningful—and how useful—it really is, but there's little doubt it owns a spot in our collective consciousness. Whether or not it makes sense, we now break the history of the Web into two distinct stages: Today we have Web 2.0, and before that there was Web 1.0.

Which raises the question: What will Web 3.0 look like?

Yes, it's too early to say for sure. In many ways, even Web 2.0 is a work in progress. But it goes without saying that new Net technologies are always under development—inside universities, think tanks, and big corporations, as much as Silicon Valley start-ups—and blogs are already abuzz with talk of the Web's next generation.

To many, Web 3.0 is something called the Semantic Web, a term coined by Tim Berners-Lee, the man who invented the (first) World Wide Web. In essence, the Semantic Web is a place where machines can read Web pages much as we humans read them, a place where search engines and software agents can better troll the Net and find what we're looking for. "It's a set of standards that turns the Web into one big database," says Nova Spivack, CEO of Radar Networks, one of the leading voices of this new-age Internet.

But some are skeptical about whether the Semantic Web—or at least, Berners-Lee's view of it—will actually take hold. They point to other technologies capable of reinventing the online world as we know it, from 3D virtual worlds to Web-connected bathroom mirrors. Web 3.0 could mean many things, and for Netheads, every single one is a breathtaking proposition.

Tim, Lucy, and The Semantic Web

The Semantic Web isn't a new idea. This notion of a Web where machines can better read, understand, and process all that data floating through cyberspace—a concept many refer to as Web 3.0—first entered the public consciousness in 2001, when a story appeared in Scientific American. Coauthored by Berners-Lee, the article describes a world in which software "agents" perform Web-based tasks we often struggle to complete on our own.

The article begins with an imaginary girl named Lucy, whose mother has just been told by her doctor that she needs to see a specialist. "At the doctor's office, Lucy instructed her Semantic Web agent through her handheld Web browser," we read. "The agent promptly retrieved information about Mom's prescribed treatment from the doctor's agent, looked up several lists of providers, and checked for the ones in-plan for Mom's insurance within a 20-mile radius of her home and with a rating of excellent on trusted rating services."

That's quite a mouthful, but it only begins to describe Berners-Lee's vision of a future Web. Lucy's Semantic Web agent can also check potential appointment times against her mother's busy schedule, reschedule other appointments if need be, and more—all on its own, without help from Lucy. And Lucy is just one example. A Semantic Web agent could be programmed to do almost anything, from automatically booking your next vacation to researching a term paper.

How will this actually work? In Berners-Lee's view, it involves a reannotation of the Web, adding all sorts of machine-readable metadata to the human-readable Web pages we use today (see "Questions of Semantics," opposite). Six years after the Scientific American article, official standards describing this metadata are in place—including the Recourse Description Framework (RDF) and the Web Ontology Language (OWL)—and they're already trickling into real-world sites, services, and other tools. -Semantic Web metadata underpins Yahoo!'s new food site. Spivack's Radar Networks is building a kind of Semantic Web portal. A development platform, Jena, is in the works at HP. And you'll find Semantic Web structures in Oracle's Spatial database tool.

The problem is that a complete reannotation of the Web is a massive undertaking. "The Semantic Web is a good-news, bad-news thing," says R. David Lankes, an associate professor at Syracuse University's School of Information Studies. "You get the ability to do all these very complex queries, but it takes a tremendous amount of time and metadata to make that happen."

The Other Semantic Web

As a consequence, many researchers take a very different approach to the Semantic Web. Rather than calling for an overhaul of Web formats, which would involve hundreds of thousands of independent sites, they're building agents that can better understand Web pages as they exist today. They're not making the pages easier to read, they're making the software agents smarter.

One early example is the BlueOrganizer from AdaptiveBlue (www.adaptiveblue.com). In certain situations, when you visit a Web page, this browser plug-in can understand what the page is about, automatically retrieving related information from other sites and services. If you visit a movie blog, for instance, and read about a particular film, it immediately links to sites where you can buy or rent that film. "It's what you might call a top-down approach," says Alex Iskold, the company's CEO. "Web pages already contain semantic data. We can understand them, so why shouldn't computers? Why not build a technology that can parse and process existing services and databases?"

Of course, that's easier said than done. Countless companies offer tools similar to BlueOrganizer—including Claria's PersonalWeb—but these aren't that different from the old Amazon.com "recommendation engine," which suggests new products based on your surfing and buying habits. We're a long way from agents that can think on their own. In the near term, the Semantic Web may require the sort of metadata Berners-Lee proposes. "Automated agents are worth striving for," says Pattie Maes, an MIT Media Lab veteran who founded the Lab's Software Agents Group. "But it's hard to say what's better—tags built into Web pages or tags that are, in a sense, inferred by machines."

Semantics and Search

The Semantic Web, like Web 2.0, is a nebulous concept. "Considering that the very word semantic is all about meaning, it's ironic that the term Semantic Web is so ill defined," says Radar Networks' Spivack. Some, like Spivack, fall into the Berners-Lee camp. Others, like AdaptiveBlue's Iskold, believe in the artificial-intelligence method. And then there are the others: the semantic searchers.

Rather than providing automatic information retrieval, semantic search engines seek to improve on the Google-like search model we've grown so accustomed to. The idea is to move beyond mere keyword searches to a better understanding of natural-language queries. "Right now, search engines can't tell the difference between Paris Hilton and the Hilton in Paris," says Jeff Bates, cofounder of Slashdot, one of the driving forces behind Web 2.0. "There's millions of dollars being spent trying to better optimize search, and that's a big part of what the Semantic Web will be."

This kind of natural-language processing has been in development for years, but it, too, has found its way onto the public Web. Several start-ups, including Powerset and TextDigger, are hard at work on semantic search engines based on the open-source academic project WordNet. It should be noted, however, that natural-language search could very well play a role in the Berners-Lee Semantic Web. His is merely a framework to enable all sorts of apps, and semantic search might be one of them.

Source

Go PHP 5 - Major PHP Projects and Web Hosts agrees to go for PHP 5

pmkansara@gmail.com (Paryank Kansara) — Fri, 13 Jul 2007 07:42:58 PDT

PHP 4 has served the web developer community for seven years now, and served it well. However, it also shows its age. Most of PHP 4's shortcomings have been addressed by PHP 5, released three years ago, but the transition from PHP 4 to PHP 5 has been slow for a number of reasons.

PHP developers cannot leverage PHP 5's full potential without dropping support for PHP 4, but PHP 4 is still installed on a majority of shared web hosts and users would then be forced to switch to a different application. Web hosts cannot upgrade their servers to PHP 5 without making it impossible for their users to run PHP 4-targeted web apps, and have no incentive to go to the effort of testing and deploying PHP 5 while most web apps are still compatible with PHP 4 and the PHP development team still provides maintenance support for PHP 4. The PHP development team, of course, can't drop maintenance support for PHP 4 while most web hosts still run PHP 4.

It is a dangerous cycle, and one that needs to be broken. The PHP developer community has decided that it is indeed now time to move forward, together. Therefore, many popular software projects like Drupal, phpMyAdmin, phpPgAdmin, Propel, Symfony, Typo3 etc. have all agreed that effective February 5th, 2008, any new feature releases will have a minimum version requirement of at least PHP 5.2.0. Furthermore, the listed web hosts have agreed that effective February 5th, 2008, they will include PHP 5.2 (or a more recent version) in their service offer.

It is our belief that this will provide web hosts reason to upgrade and the PHP development team the ability to retire PHP 4 and focus efforts on PHP 5 and the forthcoming PHP 6, all without penalizing any existing project for being "first out of the gate".

Source

Object oriented programming (OOP) without classes…!!!

pmkansara@gmail.com (Paryank Kansara) — Thu, 12 Jul 2007 22:21:55 PDT

Nowadays, object oriented programming (OOP) is quickly taking place over the traditional procedure oriented programming (POP). Success of the modern programming languages like C# and Java is obviously because of OOPs Power.

As all the OOP languages use CLASS or similar data structures for Object Oriented Programming, we have considered that without a "CLASS", OOP is not possible.

With the same idea in my mind, I’d briefly gone through the code base of "Drupal" - One of the most popular open source content management system and framework built with PHP language. I often read and heard many praise about the power of Drupal, but after the first look at the code base, I amazed that Drupal doesn’t use a single Class in it’s code base! Whole Drupal code base is based on just functions. As PHP, with which programming language Drupal itself is built, is also implementing many powerful OPP features, I could not understand why Drupal is not using these features!

As I’d not seen the keyword 'class' in Drupal code base, I evaluated Drupal as non-OOP as many programmers do. And that was my mistake! Even though, Drupal doesn’t contain any class like data structure, it is still Object Oriented. I realized this fact after details study of Drupal.

Actually, the OOP concept is not based on uses of data structures like CLASS. It is based on the fundamentals of features like Objects, Abstraction, Encapsulation, Polymorphism, Inheritance etc. If these fundamental features are included in programming then it can be considered in OOP.

Drupal covers all these features without classes. I also realized that the power of Drupal is hardly depends on this programming structure only. The way, how the hook system has been implemented in Drupal would never been possible with the use of Classes.

See more details about how Drupal implements Object Oriented Programming (OOP) without using Classes, visit: http://api.drupal.org/api/HEAD/file/developer/topics/oop.html

Google Gears - lets developers take web applications offline!!!

pmkansara@gmail.com (Paryank Kansara) — Thu, 12 Jul 2007 22:20:09 PDT

One of the biggest knocks against Google Docs & Spreadsheets, Gmail, ThinkFree Office, and other online applications is that you need a fast and reliable Internet connection to use them. No Web access, no data.

Google hopes to eliminate this limitation with Google Gears, a free open-source browser extension that developers can use to create offline versions of their Web applications. The company hopes Gears will lead to the development of a single industry standard for writing offline apps.

The first program created with the Gears API is the Google Reader feed-reading application, which is available today. The company is counting on application developers to extend and enhance the Gears environment, which is why Google decided to release it “in its early stages,” according to the company.

The Gears API will be available for all Web development environments, including Adobe’s Apollo product, which also allows Web apps to run on the desktop. Adobe chief software architect Kevin Lynch says his company is happy to be working with Google to create “a standard cross-platform, cross-browser local storage capability.”

Gears’ Javascript APIs allow you to store data, and cache and multithread online applications to your desktop. It supports the most complex Web services, according to the company. The development environment works with all major browsers written for Windows, Linux, and the Mac OS.

source