Hi everyone, this is just a quick how-to on handling the Ubuntu Maverick/Gnome Login Keyring issue which occurs when you change your user password.

The issue: You’ve decided to change your password for whatever reason and suddenly you’re presented with the following message whenever you launch an application you have instructed to “remember” your password.

Enter password to unlock your login keyring
The password you use to log in to your computer no longer matches that of your login keyring.

This is how you fix it:

Step 1: Go to System >> Preferences >> Passwords and Encryption Keys.
Step 2: If not already open, click on the “Passwords” tab.
Step 3: Right click on: “Passwords: Login“.
Step 4: From the context menu select: “Change Password“.
Step 5: Enter the Current password in the “Old Password” field.
Step 6: Enter the password you would like to change it to in the “Password” field.
Step 7: Enter the password you would like to change to again in the “Confirm” field.
Step 8: Click “OK“.

After this, relaunch the application which uses Gnome Keyring, you may have to re-enter your password, but after that, Gnome Keyring should remember your password for each subsequent launch.

In previous versions of ubuntu which used grub 1, setting up the resolution for tty was done by simply using the vga=??? boot option. In grub 2 however, this is not so easy.

I remember when it first came out. I was somewhat exasperated by the fact that I had _just_ become comfortable f*cking with grub’s menu.lst and now I had to learn how to use grub 2 – which had some new convention for editing menu items let alone setting up the resolution.

Anyway, there’s really nothing to it. I had to do a lot of digging around and some experimentation, but in the end, as with all things linux it was “easy” when I finally found out how.

Step 1: Open up your the grub header file stored in /etc/grub.d/00_header

$ sudo vim /etc/grub.d/00_header


Step 2: Add a command inside the block of string with script that sets the gfxmode. Acceptable Set the gfxpayload parameter to the resolution you want to use for your virtual terminals / TTY.

SO for me, lines 101 – 113 of the 00_header file in /etc/grub.d looks like this

101 cat << EOF
102 if loadfont `make_system_path_relative_to_its_root ${GRUB_FONT_PATH}` ; then
103 set gfxmode=${GRUB_GFXMODE}
104 insmod gfxterm
105 insmod ${GRUB_VIDEO_BACKEND}
106 if terminal_output gfxterm ; then true ; else
107 # For backward compatibility with versions of terminal.mod that don't
108 # understand terminal_output
109 terminal gfxterm
110 fi
111 #set gfx payload - use your own resolution here. I have a 19 inch monitor which natively supports 1440x900
112 set gfxpayload=1440x900x32
113 EOF


Step 3: After you save the file, go back to the terminal and run update-grub2 as root.


$ sudo update-grub2


Your terminal should look like this:

$ sudo update-grub2
Generating grub.cfg ...
Found linux image: /boot/vmlinuz-2.6.32-23-generic
Found initrd image: /boot/initrd.img-2.6.32-23-generic
Found memtest86+ image: /boot/memtest86+.bin
done


And that’s it. On your next boot, you should see your console displayed in the resolution you used for setting gfxpayload.

To do this though, I had to expand my VMWare virtual disk. So a quick:

vmware-vdiskmanager -x 45GB windevxp.vmdk

… and my virtual disk is now 45GBs! – I then had to resize the windows partition. I’ll post more on this straight after this post.

So with that done, I’m set to install Visual Studio, I thought yeah it should take about 5 – 10 miuntes…

BOY WAS I WRONG!

The installation took like 2 – 3 hours at least, so there’s a large chunk of my day gone. (Great… F*CK!) At this point though, I didn’t care anymore, I was bitter about the amount of work I’ve lost and the disruption caused by stupid Visual Studio Express randomly crashing! I just wanted the whole thing to be installed and start coding again.

After Visual Studio had finished installing, I start coding again, only to experience RAM shortages on the Virtual Machine I use as my windows development environment!

Luckily though, I had 4GB stick of RAM, which my colleague Neil had organised for me yesterday, comin’ in today. I was just itchin to get my hands on that frickin extra RAM, when it finally came, I threw a party! I installed the RAM, started up my notebook. I start making mental comparisons on how much faster it is now, I’ve got 6 GB of RAM now mother f*ckers! (f*cking yes!).

All this excitement was drained out of me when I launch VM Ware and I receive a Kernel panic! Not even it just rebooted back to the start up screen.

When it rebooted, I find that my EXT4 partition has been mounted as read only. Some digging around dmesg reveals that some deleted inodes were being referenced. Pretty scary. I’ve never run into such problems. A quick google search guides me to some information stating that e2fsck will fix this situation - all I need to do is create a start up disk that i can boot into, then run an e2fsck -v /dev/sda2 (/dev/sda2 is where my corrupt files are).

So I burn a start up CD, run it and used e2fsck to fix my hard disk.

Long story short, important VM ware files are missing… I got no answers to this aside from reinstalling. Absolutely terrible! GRRR!

Now, I find myself carving up new designs for ancient projects and looking at the code base, I’m honestly surprised that it has managed to not only run, but make bank for the company it belonged to all these years. Caching really does save your ass, so does having a dedicated server you can pump hardware into.

In the past few weeks, I’ve carved up designs, chased several phantom display bugs (which ended up being typos – you would’ve known if you had been keeping up with my tweets) and went back to coding ASP like it was 1999.

Yes you read right, ASP! I’m currently trapped in legacy code world… negotiating screen real estate and dealing with browser laws and rules that change ever so slightly for each different version of browser software!

Surprisingly, I’m still an epic ASP classic coder. After shaking off some rust, I’ve implemented good old option explicit, eliminated all the “on error resume next” one liners scattered throughout the source code, controlled and centralised the numerous global ADODB Connection and Recordset objects which get shared by different parts of the code… in short I’ve started makin’ the move to make the codebase a little more meaningful.

We opted to go with this option due to time constraints and other plans I’ve got down the track. Needless to say, I’m single handedly taking care of business and by the time I finish, this mission critical website is going to:

• Perform better - I’ve sped up the site by lessening the newbie load cerated by having several Server.CreateObject(“ADODB.Connection”) calls, to use just the one.
• Be easier to navigate - At the present moment, the current version of the website I’m workin’ on has 5 different navigation systems with links that point to the same pages but are named differently. I’ve changed this so that the links are meaningful. Related navigation items are grouped together.
• Consistent content layout – Well, as consistent as possible anyway – there are different heading layouts and a lack of consistency in the current site. The new design has design consistency goodness all over it, but due to the html being deeply mixed up with ASP (we’re talking 3000 – 4000 line scripts here) and the time line I’m working with, I really can’t afford to nit pick html. I’m going for a happy middle here.
  
• Have a complete Member’s Control Panel – The website is going to have a Control Panel that works like a control panel rather than a password protected page with a bunch of links with useless info.

All in all, I’m excited about the end product which comes closer as each productive day is complete! What happens from that point is currently being idly, but meticulously planned for. Very exciting times ahead, this should be great!

One of the first things I do for newly checked out projects is to add a externals.txt and ignore.txt files. Then I just populate these with the property values I require for the project.

I know, it’s a no brainer when you think about it right?

The thing is, I didn’t think of doing it until the past few projects and actually had to rely on ide integrated / gui tools to do it prior to this year. I came across a couple of examples and did it a couple of times in a rush without noting it down, but thought I’d make a post about it on my blog so that I have somehwere easy to find.

Here’s a quick example:

example contents of externals.txt

library/Zend http://framework.zend.com/svn/framework/standard/tags/release-1.10.4/library/Zend
library/ZendX http://framework.zend.com/svn/framework/standard/tags/release-1.10.4/extras/library/ZendX/
library/Doctrine http://svn.doctrine-project.org/tags/1.2.2/lib/Doctrine
externals/dojo http://svn.dojotoolkit.org/src/branches/1.4
nbproject

example contents of ignore.txt

public/webalizer
public/analog

Then I use the -F arguement to specify that I want to use the contents of a file to specify the value or values of the property.
$ svn propset svn:ignore -F ignore.txt . to set my svn:ignore property values.
or
$ svn propset svn:externals -F externals.txt . to set my svn:externals property values.

It’s all about convenience baby!

This makes svn properties management very convenient. It’s one of the things that make it easier for me to set things up. What’s more, when I need to add or remove to/from svn:externals or svn:ignore, I can do so easily – managing my svn properties this way, I also have a good reference as to what my property values are without having to run a number of svn propgets via command line.

Last week, I’ve quietly launched project chronus. A project which provides multi site administration system geared for collaboration. Project Chronus makes it easy for our website content admin people at DevProducts to keep track of numerous website projects placed under their control.

Project Chronus is the first project I’ve built with Zend Framework 1.8 and above (as in utilising bootstrapping with Zend_Application) that felt natural. I’ve built several projects with Zend framework 1.5+, but not as comfortably as I did with my recent project.

While Project Chronus is a project to be used for our own internal purposes, it served as a live project with enough real requirements to be effectively used as a sandbox for future projects we choose to undertake and in addition, set (and put to the test) standards for how we do things.

What I used to build Project Chronus:

• Zend Framework 1.10+
  • I used the Recommended Project Directory Structure.
  • Zend_Auth and a Controller Plugin to check for/redirect authenticated/non-authenticated users.
    • ZendX_Doctrine_Auth_Adapter – although we had to change Doctrine to Doctrine_Core on line 168 since we are using Doctrine 1.2.x which does not have the empty Doctrine class extending Doctrine_Core.
  • Zend_Dojo_Form
  • Dojo View helpers
    • TabContainer
    • ContentContainer
    • We also _slapped_ together an EnhancedDataGrid View helper class (using EnhancedGrid in Dojo 1.4) – which supports menus, delete, export and added a togglable search form.This class is in dire need of refactoring, but it does the job – and doing it well so far. I’m waiting to see if Matthew’s proposal gets active and becomes complete, to see how the ZF/Dojo pros do it and will then fashion our and perhaps release some code I would not be ashamed of.
  • Zend_Navigation
  • Zend_View_Helper_Placeholder
  • Zend_Test_PHPUnit_ControllerTestCase – Yes, we were unit testing everything including Controllers and Views! Although sadly, we found ourselves reverting to “just code it now” conventions as we raced tot the finish line.So we stopped testing Controllers and Views midway – we did however, unit test most of our model_service code and it’s in the cards to write tests for the untested units to achieve 100% code coverage for controllers and models.
• Dojo 1.4x
  • Several form Dijits.
  • The EnhancedGrid component.
    • Menus Plugin
  • Dojo.xhrGet/Post
  • TabContainer
  • ContentPane
• Doctrine 1.2.x ORM
  • Doctrine Query Language – We use DQL extensively within our Service classes to fetch and use models.
  • SFYAML – Doctrine uses this to process fixtures and schema yml files which we use to setup and update the database schema.
• PHPUnit 3..4.11

Approaches we used to build the Project:

• Service Layer – as per my previous entry: “My Zend Framework Model Layer: Part Service, Part ORM” with a few tweaks included. I didn’t get a chance to include ACL into the Service Classes however.  I went with the Controller Plugin option, because we did not have a requirement for multi-role user system.

  I was a little confused at certain times. For instance, I have a Service Layer for authentication and password which started off as authentication, change password and reset password. Still throwing it around, but aside from this, when I have to deal with actual entities, the Service Layer class is pretty much semantic.

• Authentication Module – Another thing that was slightly strange was that I decided to create a separate authentication module where I put in my login, logout, reset password confirmation (sends email) and reset password (after confirmation) features. With this being in a module, I can just drop this module in whenever these generic features are required.

I will be using this as a base for any web applications we will be building using the Zend Framework. The generic features in Authentication and other unmentioned features such as an administrator dashboard module which has features for managing System Users serve as a great starting point for any web application.

I guess it goes without saying, I’m lovin’ web dev at the moment and I’ve finally got some free time, so it’s back to blogging.

Of course, this is not the first time I’ve taken time off, so I thought I’d warm up my blogging again and talk about what I do to get my mind into gear. So here are 5 things that I like to do to get myself back into focus:

1. Classical Music
   This is more a point about setting a quiet mode for the day. When I have my headphones on with a Play list that has Chopin, Liszt and Beethoven, I know that my thoughts are going to be well insulated against the hustle and bustle of phones, idle chatter and other random office noises. Not only that, but over the years, I’ve come to associate classical music with focus – which is my ultimate goal. I want to have a focussed day and this sets it up for me nicely.
   
2. Pen and Paper up a list of things to be done today
   Yes, that’s right I still use pen and paper when creating a “to-do list”.I use evolutions task manager for this in my day to day, but during times when I need to kick start me off, there’s nothing like a good pen and paper to-do list to keep me focussed on what I need to do. I guess it’s because I am more deliberate when I’m writing up a list rather than typing it up.

   It goes without saying, but after each task is completed, I cross it off and continue on to the next one. This keeps me focussed and helps me build momentum.

3. Get the backlog of easy stuff out of the way first – regardless of how tedious it is.
   Once I’ve got Now this goes without saying, today, this is exactly what I did and even though I’d much rather be in the trenches coding away, I know that I’ll be distracted if I didn’t do this first. So that’s what I did. I answered emails, wrote up quotations and even wrote a letter of reference for someone who used to work for us.

   This is linked directly with my to do list and how it works on building my momentum. As each little task is complete, I plough through the next few until there is no more left.
   

4. Do not let myself be swayed by positive stress
   So as I have now completed the easy tasks out of the way, I usually feel the need to lean back and ‘lax out. I feel like I’ve run a marathon… and won! This feeling is known as positive stress. You’ve poured all your energy and focus into a task and successfully completed your mission now it’s time to report to for debriefing. NOPE! Roll forward to the next task – Unit Testing.
   
5. Unit Testing
   Now I’ve mentioned this before on a previous post – I’m a fan of Unit Testing. Unit Testing really does aid in focussing your mind to achieve tasks at hand. With Unit Testing, I map out what I need to do by way of tests. What functionality a certain model object will have. My models methods start off mapping to business requirements, my tests map to each public method in my models. It’s a beautiful cycle of productivity. I love this stuff!

I apply the same to my blogging as well. I’m not game to launch into my theory of how models should be explicitly returning messages just yet, so I’ll be holding off on that post till tomorrow or the day after. I’m currently listening to Classical music and getting this easy post out first to gain some momentum writing my blog posts.

I recommend you try it out yourself. It’s really something that separates the counter-productive, procrastinating me to the productive, action man that I know I am.

There is nothing wrong with Views being able to handle their own models, I’m not suggesting that this shouldn’t be the case. You can also do it this way. That is the “traditional MVC” way of doing things and it works fine which is why I’m questioning why I’ve moved away from it. I’m just typing as I go so hopefully by the end of it, we’ll have something that makes a point.

I used to Really love this sh*t!

I used to trumpet the sh*t out of this because I had it figured out and it made me feel smart . I thought hey, I can adhere to the traditional MVC way of things and make the View select it’s own Model (or models) and gather information on it’s own – all I need is a View Helper. Further along came the question “What about the times when the Model needs to be used by the Controller?” well I got a plan for this too, then there’s the “What about when the Controller and View need access to the same model?” case. I needed to create a strategy to make sure that the Model isn’t instantiated twice in these cases.

This is how I did it: Components you need to code up to make it so that the View can choose it’s own Models

Step 1: I created a Model Service Factory which I stored in Zend_Registry – the Model Service Factory has a Registry of it’s own and checks to see if an instance of the Model being requested already exists – if it does, it returns that instead of creating a new instance.
Step 2: I created a View Helper called “GetModel” which accesses the Zend_Registry to access the Model Service Factory and returns the model
Step 3: I then created an Action Helper called “GetModel” which worked exactly like the View Helper.

But then, I found myself questioning if the view selecting it’s own models / data applies to PHP, or if all this complexity is worth anything useful aside from saying “I can do it”. Here are some of the things I’m thinking about:

• One of the cases that I’ve found cumbersome is when I need to access  request parameters in the View whether it be for creating a URL. This should be regarded as a data source as well. Does this mean that we have to code up View Helper to access this also? (This isn’t a smart ass rhetorical question either – I really want to know what do you do?)To handle cases where I need to display parameters in the view, I assign the view parameters in the controller something along the lines of:

$this->view->username = $this->_getParam(‘username’);

• Say you need to display session data in the view, how would you go about doing that? Personally, as with the request parameters, I assign the session data to the view in the controller:

$this->view->somesessiondata = $session->somedata;

• Now say we need to get some data from the model… no problem!  I can use the getModel view helper that makes me feel so smart. To do this though, we need to set up the view so that it has the ID parameter.

$data = $this->getModel(‘SomeModel’)->findById($this->id);
// or if we us a view helper for parameters (I said IF – not entirely sure about this yet)
$data = $this->getModel(‘SomeModel’)->findById($this->getParam(‘id’));

Now compare this with providing the data that the view needs via the Controller.

// in the controller
$this->view->data = $this->_service->findById($this->_getParam(‘id’));
$this->view->username = $this->_getParam(‘username’);
$session = new Zend_Session_NameSpace
$this->view->sessionData = $session->sessionData;

// in the view
<h2>User Details</h2>
<?php foreach ($data as $key=>$val) : ?>
<?=$key?>: <?=$val;?>
<?php endforeach; ?>

<p>You have requested the username: <?=$this->username; ?> which is not available. </p>

Also at one point I was thinking why we are fighting so hard to decouple the view from the controller anyway? They are coupled from the file system and have default conventions like indexAction is coupled with index.phtml view script in an index script directory (which matches controller name).

Having said that though, I don’t see a strong case for or against pushing or pulling models to or from the View. Maybe I’m just missing the point somewhere. In any case, I’d be grateful to know (and learn from) what your take is on this subject matter.

So to sum it up, these are the questions that are floating through my head at the moment.

• What are the _specific_ advantages of having the View pull data from the model directly?
• What are the _specific_ disadvantages of having the Controller push data from the model into view member variables?
• Is the example I specified above (creating view helpers, registry, action helpers) overkill just to achieve something that may or may not be a design problem?

After some more thought and lots of research on the subject, I’ve come to a solid point where I actually have something to try out which seems semantic aside from the naming of the class (Service Class) – but this is derived from what some people are talking about in ZF circles starting from Matthew Weier O’Phinney who was coining it as the “Gateway to the Domain” from early on, then later changing it to “Service Class”.

The Service Class

So this is what I chose to go with:  For each model class, I’ve got a Database Agnostic Service class - in fact, it uses the Entities Produced by Doctrine ORM to talk to the database, but isn’t entirely reliant upon Doctrine to Provide the Model Layer on it’s own. Using Doctrine as your Model Layer alone I suppose is better than extending Zend_Db which is highly discouraged by everyone, but you still have the database dependency.

I thought well, I’ve done a lot of feeling around the subject, maybe I’ll just ask around. So over to twitter I go. I sent Matthew Weier O’Phinney a tweet asking if it is right that Doctrine models are relatively empty whilst Model services are filled with business logic and he answered: “Absolutely. Plain old PHP is perfect for entities.” but I had no idea WTF that meant.

The Service Layer uses the Model which is the Entity. My further attempt to clarify the situation and continue discussion didn’t get a response – maybe because I had to condense words and use accronymns to fit the message in or he had just become too busy. So on my own I go again.

After mulling over it a few, I thought I’d just run with what I’ve got. It seems to be semantic, but it has a lot of responsibilities:

• The Model Service Class is a Resource.
• The Model Service uses the ACL layer to check if a Role Identified has the Privileges to make it’s request prior to usage.
• The Model Service creates Entities by using its Model Factory/Finder methods such as FindById it then returns either an array or an Entity based on what Hydration mode was specified (default is array).
• The Model Service creates Forms and uses it for Validation
• The Model Service provides the CRUD methods so that the Controller does not have to worry about instantiating and configuring models to Create Update or Delete data.
• The Model Service uses Zend_Cache and can use caching on non-changing data such as lookup lists status or types and large collections of data used in drop downs, lists or datagrids.
• Although there is no factory for it, the Model Service can create and use other Model Service classes.
• The Service Layer is not passed to the View either. The View is configured by the Controller and has data shoved into properties/member variables.
• The Service Object can be passed to the View if required, so that the View can use the Sevice object to interrogate models on it’s own. We trust that those writing the View Markup will only be using the service object _strictly for reading only_.

I’ve been working with this setup for a few weeks now. This method is very testable and makes for an extremely thin Controller Layer.

What do you guys think?

Have we over engineered this thing? Should it be called the Service Layer as more and more people are coining it as? What suggestions can you make to make this better?

I came accross laserlight back in the day when I was still trying to find a forum to hang out after work or over the weekend.  I ended up at PHP Builder and had posted a few comments and tried to be part of their community. I think what turned me off PHP Builder was that the members that they had were slightly cliquey and were not as friendly as the ones at SitePoint. At the time, they also had some very big trolls. But that I Imagine would have been in the past.

It would have been great to keep in touch with her, she had some brains about her. Hopefully she’s doing well.

So the way Top Commentators works is that it keeps count of those who comment on my blog posts by using email addresses, does a calculation and then displays the top ten people who have been commenting on the home page and each of the pages on my blog, with a back link to their website.

Hopefully, this will encourage my followers on twitter and the rvdavid my blog log community members to get involved and participate in leaving comments on some of the blog posts that I write.

This is my way of providing a window of appreciation for everyone who contributes to my blog posts. So thank you in advance, and thank you to the regular visitors who keep an eye out for my blog. You guys are great!