Usefuljaja - Home

The future - a.k.a. What now?

2007-08-31T19:02:00Z

As you may know I have officially joined the ranks of Slicehost as a support/article/helper type bloke (with a dreamy accent to boot!).

So what does that mean for usefuljaja.com?

Well, first of all I'd like to thank everyone for their support during the past few weeks and months. The emails and general encouragement have been great to hear and the advice and suggestions have helped me enormously.

The existing articles are not going anywhere. The site will remain up and freely available to all who want to use them.

One of my main roles at Slicehost will be to create a repository of articles and tutorials (much as I have done here, but specifically aimed at Slicehost users).

As such, I can point you to that url: articles.slicehost.com and say that if an article is not already here then it will, eventually, be there.

So a plain answer as to the questions of a continued expansion of usefuljaja is that I just don't know but I imagine it sitting quietly and helping those of you who want it.

I am very excited about the opportunity at Slicehost so I will be spending a great deal of time there and, as I say, one of my roles will be to continue with much the same type of thing I have done here.

So rather than a goodbye, it's more of a 'see you there'.

Many thanks.

PickledOnion.

MySQL - searching for a record

2007-08-17T12:42:00Z

When the database has more than a handful of records, we need a way of searching for a particular record. The point of a database is to hold the information for us so we don't have to remember it all.

To make this article more practical we need some more entries in our 'pickled1' colleagues table. To save you some writing you can import this pickled1.sql file.

The sql file contain 15 basic records. To import the data:

mysql -u root -p pickled1 < pickled1.sql

Search

Now we have some more data, log into MySQL pickled1 database:

mysql -u root -p pickled1

If we display the contents we can see that with only 15 entries, it's getting difficult to navigate and get the information we want:

select * from colleagues;

So let's do a search for a name that contains 'dave':

select * from colleagues where name like '%dave%';

That will return the 4 entries that have 'dave' in the name column.

Still too many, I want to know how many people named Dave also have Dave in their email address:

select * from colleagues where name like '%dave%' and email like '%dave%';

That returned 3 records. Who's the other one? Let's have a look:

select * from colleagues where name like '%dave%' and email not like '%dave%';

Ah, the record returned good old marshy:

7 | Dave Marshal | marshy@domain.tld

Order

That's OK but we prefer a bit of 'order' to our lists. Lets display the list of Daves in alphabetical order:

select * from colleagues where name like '%dave%' order by name;

That's better.

Counting

Sometimes all you need is to count the records available.

Let's see how many records we have in the colleagues table:

select count(*) from colleagues;

Well, now we know there are 15 entries.

What about how many Daves I know?

select count(*) from colleagues where name like '%dave%';

Hmm, that's 4 Daves. I wonder if that's too many? Maybe I need to know more Sallys.

Anyway, you can get as detailed as you like with the select and count queries but I hope this clears any doubts as to how simple manipulating the data actually is.

PickledOnion.

MySQL - exporting and importing records

2007-08-17T11:39:00Z

Whether it is for a quick database backup or to import existing records to a new database for a server move, importing and exporting records is a basic and essential function.

Luckily, saving the data and moving it to a new MySQL database could not be easier.

Firstly, log into your VPS. The commands shown below are made from the BASH command prompt - in other words, you do not need to log into MySQL.

Export

So, to export a particular database issue one simple command:

mysqldump -u root -p pickled1 > pickled1.sql

It's as simple as that. In this example, I used the MySQL root user and 'pickled1' refers to the database we have been using during these articles.

Once done, we have a file named 'pickled1.sql' which can be copied to the new server ready for importing to the new MySQL install.

Import

Importing the data is just as simple.

Create the new database (it does not have to be named the same as the old database):

mysqladmin -u root -p create pickled1_new

Now import the data from the old database to the newly created one:

mysql -u root -p pickled1_new < pickled1.sql

Again, that's it. Very simple indeed.

Now the newly created 'pickled1_new' database has been populated with the data exported from the original 'pickled1' database.

PickledOnion

Upgrading to Feisty

2007-08-14T14:22:00Z

OK, so you've read Why you shouldn't upgrade to Ubuntu Feisty and decided you still want to use Ubuntu Feisty.

No problem, let's go ahead and upgrade from Ubuntu LTS to Ubuntu Feisty.

This should only be undertaken on a new, or reinstalled, VPS with a starting base of Ubuntu LTS. If you have a working LTS server then I strongly suggest leaving it as an upgrade of this magnitude will almost undoubtedly break things.

First thing is to delete old entries for the VPS IP address in your known_hosts file as a reinstalled Slice/VPS will have an old RSA key:

nano ~/.ssh/known_hosts

If you are not using Linux on your LOCAL computer, the location of the known_hosts file will differ. Please refer to your own OS for details of where this file is kept.

Log in

Log into your minimal Ubuntu LTS server:

ssh root@123.45.67.890

Accept the RSA key and enter the root password supplied on the Slice/VPS reinstall.

Once logged in, change the root password to one of your choosing as we'll need it later on the reboot.

passwd

Let's see what we're using:

cat /etc/issue
#Ubuntu 6.06 LTS \n \l

First upgrade

Although it's possible to upgrade straight from LTS to Feisty it is not recommended. The Ubuntu documentation strongly suggests the slightly longer route I will show here.

So we need to upgrade LTS to Edgy and then Edgy to Feisty. The whole process takes around 5 minutes so it's not an arduous task.

First thing is to update the sources.list:

nano /etc/apt/sources.list

Delete the default entries and add this list:

deb http://archive.ubuntu.com/ubuntu/ edgy main restricted universe
deb-src http://archive.ubuntu.com/ubuntu/ edgy main restricted universe

deb http://archive.ubuntu.com/ubuntu/ edgy-updates main restricted universe
deb-src http://archive.ubuntu.com/ubuntu/ edgy-updates main restricted universe

deb http://security.ubuntu.com/ubuntu edgy-security main restricted universe
deb-src http://security.ubuntu.com/ubuntu edgy-security main restricted universe

Once done, we need to enter a series of update/upgrade commands. All are required so don't think I've repeated myself unnecessarily:

aptitude update
aptitude dist-upgrade <-- follow on-screen instructions
aptitude dist-upgrade <-- Courier = No

Then a few more:

aptitude update
aptitude dist-upgrade
aptitude -f install
dpkg --configure -a

Reboot

Once done, reboot the machine:

shutdown -r now

Log back in and have a look at what the VPS is running:

cat /etc/issue
#Ubuntu 6.10 \n \l

Second upgrade

Thankfully, the upgrade from Edgy to Feisty is much easier as they provide a simple tool that does the hard work for us:

aptitude install update-manager-core

Once installed run:

do-release-upgrade

There are a few question to answer. The first is to accept the SSH connection (it defaults to 'no').

Then follow the on-screen instructions such as removing obsolete packages (Y), to fully ugprade, please restart (Y) and so on.

Final log in

The last reboot was automatic so log into the VPS and have a look at what it's running:

cat /etc/issue
#Ubuntu 7.04 \n \l

And a final update/upgrade:

aptitude update
aptitude upgrade
aptitude dist-upgrade

Done

That's it. As said, this should only be performed on a new, or reinstalled, VPS. Now you have a minimal Ubuntu Feisty install to work with.

PickledOnion.

MySQL - reset a lost root password

2007-08-13T11:51:00Z

There may well be a time where you lose or forget your MySQL root password. This may well, as you can imagine, turn out to be a complete disaster.

OK, so we shouldn't lose root passwords. But what happens if we do?

Resetting the MySQL root password is actually quite easy to do.

However, you do need to have sudo access as we are going to use the sudo command. Not every user will be able to reset the MySQL root password whenever they feel like it!

Stop

Let's go. Log into your VPS and stop mysql:

sudo /etc/init.d/mysql stop

Naturally you will have to enter your user password and, if you have sudo privileges, mysql will be stopped.

Reset password

Next we need to start MySQL in safe mode and ensure it does not read the database tables relating to MySQL user privileges.

sudo mysqld_safe --skip-grant-tables &

Note the ampersand (&) at the end of the command.

As we have started MySQL without referring to the GRANT table, we can log straight in as the MySQL root user:

mysql -u root

Now we are logged in, inform MySQL which database we want to use:

use mysql;

Next, simply change the MySQL root password and flush the privileges:

update user set password=PASSWORD("mynewpassword") where User='root';
flush privileges;

Quit, stop and start

The MySQL root password has been reset so now we need to quit from the safe mode:

quit

Then stop the safe version of MySQL and start the full version which will reference the user privileges we just updated:

sudo /etc/init.d/mysql stop
...
sudo /etc/init.d/mysql start

log in

Now simply log in as the root user and use the newly set password:

mysql -u root -p

Simple as that.

PickledOnion.

MySQL - creating and editing users

2007-08-08T18:41:00Z

Adding MySQL users follows the same principles as adding system users. Each user can be assigned different privileges to different databases.

Privileges can range from read only for a single database to full MySQL wide administrator rights.

You need administrator rights to create a new MySQL user so log into MySQL as the root user:

mysql -u root -p

Create

Let's start off by creating a new MySQL user called 'paul':

CREATE USER 'paul'@'localhost' IDENTIFIED BY 'newpassword';
FLUSH PRIVILEGES;

As before, the syntax is straightforward, we created the user 'paul' who can access MySQL locally and assigned a password.

We 'flushed' the privileges. Cool. This simply reloaded the 'user' table in the mysql database so MySQL can use the new user details. Do this each time you change users and privilege levels.

Grant

We can now assign some privileges to paul. I'd like him to be able to read all the databases but not be able to add or drop data:

GRANT SELECT ON * . * TO 'paul'@'localhost';

So now paul can select data from all the databases but we also want paul to have admin privileges over the pickled1 database:

GRANT ALL PRIVILEGES ON `pickled1` . * TO 'paul'@'localhost';

Paul now has full privileges on the pickled1 database and select only on the others.

Log in

OK. Lets test this new user. Log out of MySQL:

quit

And then log in using the user 'paul':

mysql -u paul -p

Enter the new password and then enter the command:

SHOW databases;

As we gave paul 'select' privileges on all databases, you'll see a list of available ones.

Drop

We know that of the databases listed, the one called 'mysql' holds the users details and is, in fact, the most important database there. Without it things would be very messy indeed.

Let's go ahead and drop it.....

What?

You are now logged in as the user 'paul'. We gave paul all privileges on the pickled1 database but select only privileges on the other databases.

Firstly, make sure you are logged in as paul and have assigned privileges as above.

Secondly this does a couple of things: It puts some trust in the programme and, more importantly, it builds confidence in what you are doing. You know you have assigned select only privileges on the other databases so now is the time to put it to the test:

DROP database mysql;

This is what happened when I did it:

ERROR 1044 (42000): Access denied for user 'paul'@'localhost' to database 'mysql'

Different privileges give different permissions.

Levels

Now we've got that out of the way, we can briefly look at the different levels of privileges available. I'm not going to go through them all but the basics you need are:

For data manipulation:

SELECT........read only
INSERT........insert rows/data
UPDATE.......change inserted rows/data
DELETE.......delete drop rows of data

For table manipulation:

CREATE......create new tables
ALTER........change table/column names
DROP.........drop columns/tables

Examples

Remember that privileges can only be assigned by the root user (well, at this point anyway) so make sure you are logged in as the root user when granting privileges.

1: You have a user (paul) who you want to be able to access all data. He will enter data, correct errors and so on. But you do not want paul to be able to alter the database structure:

GRANT SELECT , INSERT , UPDATE , DELETE ON `pickled1` . * TO 'paul'@'localhost';

2: You have another user (called, err, paul) who you want to be able to alter the structure of the table:

GRANT CREATE , DROP , INDEX , ALTER ON `pickled1` . * TO 'paul'@'localhost';

And so on. Assign privileges as needed.

Remove

Lastly, we want to be able to remove a user when they become redundant (in all senses of the word):

DROP USER 'paul'@'localhost';

Quite a lot going on in this article, but I hope you can see how easy it is to fine tune your MySQL users so they can't cause havoc within your MySQL database.

PickledOnion.

MySQL - creating records and adding columns

2007-08-07T15:23:00Z

Now we have the database and the first table created we can start adding records.

Again, this is very easy via the command line. We'll also add another column to the table, change existing records and delete unwanted records.

As usual, log into MySQL and tell it which database we are going to use:

mysql -u root -p
...
use pickled1;

Insert

Let's insert our first record. It's the email address of Dave, the guy who sits next to me at work:

INSERT INTO `colleagues` (`id` ,`email`)
VALUES
(NULL , 'dave@domain.com');

I find it easier to spread the command (especially as they get longer and more complicated) over several lines. It cleans the code up and makes it easier to review. Remember that MySQL will only execute the code once it reaches the semi-colon at the end.

The syntax order is pretty simple - name the columns and then enter the values you want in the columns. We entered NULL for the id as we set the id column to AUTO_INCREMENT.

Select

Let's see what was actually entered by selecting all entries in the colleagues table:

SELECT * FROM `colleagues`;

The output is exactly as expected - the id has a value of '1' and the email is as we entered.

Alter

Notice anything about the table? Well, I don't think it's too useful yet as I don't know who dave@domain.com is. I might remember now but not after I add the 3 other Dave's that I know.

I think we need to add a column called 'name'. Not only that, I want the column to come straight after the id column. That way, I can read the records like a book: id -> name -> email.

Let's do that:

ALTER TABLE `colleagues` ADD `name` VARCHAR( 45 ) NULL AFTER `id` ;

Now when we do a:

SELECT * FROM `colleagues`;

We see the new column entered but its value is 'NULL'.

Update

Let's insert a name:

UPDATE `colleagues` 
SET 
`name` = 'Dave Farquat' 
WHERE `colleagues`.`id` =1 ;

Again, I don't think the syntax needs too much explaining but do note the 'WHERE' line. Without this, all records would be updated to the name 'Dave Farquat' whereas we only wanted to update the record with the unique id of 1.

Insert

Let's add one more full record:

INSERT INTO `colleagues` 
(`id` , `name` , `email`)
VALUES 
(NULL , 'Paul Tomes', 'paul@domain.com');

Nice.

Delete

Dave spilled coffee on me earlier. Now I want to delete his record from the colleagues table. We do this will a simple:

DELETE FROM `colleagues` WHERE `colleagues`.`id` = 1;

Well, that's him gone.

In the next article, we'll add another user and give them restricted privileges so they can only access the pickled1 database.

PickledOnion

MySQL - creating and deleting tables

2007-08-06T13:51:00Z

Once you have your database created you will want some tables in there.

There are some application frameworks, such as Ruby on Rails, where all you have to do is create the database: the rest is done within the framework itself. However, it is always a good idea to know how to create tables.

So now we have the database 'pickled1' created (see creating/deleting databases), we need to add a couple of tables.

So, log into MySQL:

mysql -u root -p

Use

First of all, we need to tell MySQL which database we are going to be working with. If we just told it to create some tables, it would not know which database to add them to:

use pickled1;

Create

Our first table is very simple and is called 'friends'. All this table will do is hold a unique ID for each friend and their email address (Let's not worry about how to enter the friend's details - at least not yet anyway).

CREATE TABLE `friends` (
   id INT NOT NULL PRIMARY KEY AUTO_INCREMENT,
   email VARCHAR(45)
  );

OK. So what happened there?

The first column (id) was defined as an integer (INT), it must have a value (NOT NULL) and is the PRIMARY KEY (this uniquely identifies the row) and will be incremented automatically.

The second column will contain an email address and we have limited the text input to 45 characters.

Show

Let's take a look and see if the table was created:

SHOW tables;

and to show the columns:

SHOW columns FROM friends;

The output is nicely formatted and shows all the details we just entered.

Rename

Naturally, we want to be able to manipulate the table and we've now decided that the table name is a bit misleading as the list will include people from work.

So let's rename it 'colleagues':

RENAME TABLE friends TO colleagues;

That's better.

Drop

Should you decide you want to delete the table entirely, it's just a case of 'dropping' the table:

DROP TABLE colleagues;

I'm sure you are beginning to see that the syntax is fairly logical - show, rename, drop and so on.

That's it. In the next article we will start to add records (data) to our table, manipulate them, delete them and so on.

PickledOnion.

Litespeed - PDF list of tutorials

2007-08-04T13:56:00Z

I know it's old fashioned, but sometimes it's nice not to have to visit a website or read an RSS feed when you want to find a specific article.

As such, please feel free to download a PDF of the Litespeed articles and tutorials.

The PDF contains a list of all the articles along with a short description and a direct link to the tutorial.

Most browsers will show the PDF in the same window so to save it, you may need to right click on the link and 'save target as' or 'save link as'.

Litespeed Tutorial PDF

Any suggestions always gratefully received.

Pickledonion.

MySQL - creating and deleting a database

2007-08-04T11:16:00Z

Following this MySQL series will see us creating a database called 'pickled1', adding tables, columns, rows (data) and specifying MySQL users for the 'pickled1' database.

We can start by deleting any redundant databases and creating our new 'pickled1' database.

Log into MySQL:

mysql -u root -p

We know what databases are installed by default (see listing databases) and discovered that some OS's have a database called 'test' installed by default.

Drop

Let's delete the 'test' database straight away:

DROP DATABASE test;

That was pretty simple. The entire 'test' database has gone.

Have a look:

SHOW databases;

Create

Let's go ahead and create a new database called 'pickled1'.

CREATE DATABASE pickled1;

Have a look:

SHOW databases;

Shortcuts

You know what? I still find that too much work. You have to log into MySQL and then create the database and then logout. Seems like a long way around.

Luckily there is a shortcut you can use when creating databases (you know, I think the plural should databi, like ocutpi...).

Anyway, to create the same database with just one line would be:

mysqladmin -u root -p create pickled1

Enter your password (if you have one) and that's it. The 'pickled1' database has been created. Now that's more like it.

What about dropping databases with one line?

OK. Let's do this:

mysqladmin -u root -p drop pickled1

Again, it'll ask for a password and is then kind enough to ask if we really want to drop the database. It has a point - it is potentially a very bad thing to do.

Database "pickled1" dropped

Nice.

Naming Conventions

There are some rules you have to follow when creating a MySQL databases but they are pretty simple:

The database name must be no longer than 64 bytes.

Note this is not characters but bytes as some characters can contain more than one byte. Don't be too concerned about this - just don't use ridiculously long names.

Secondly, the name must not contain:

forward slash (/)
back slash ()
periods (.)

That's it. As before, I am sure you can see the advantage of using the command line rather than a MySQL gui for these sorts of queries.

The next article discusses creating, renaming and deleting tables within the new database.

PickledOnion.

MySQL - listing installed databases

2007-08-04T10:41:00Z

Now we have a root password set, let's see what databases are installed by default in MySQL.

Let's get stuck in straight away. SSH into your VPS and then log into MySQl:

mysql -u root -p

Enter your password (if you set one).

This series of MySQL tutorials will be using MySQL version 5.x. If you are using an earlier version some of these commands may not work as suggested. This is because MySQL v5.x introduces new features and new commands. However, I will try to ensure they are as compatible as possible.

There are two ways of listing the databases. Firstly:

SHOW databases;

Fairly simple but do note the semi-colon (;) at the end of the MySQL command. All commands in MySQL require a semi-colon at the end. This lets MySQL know that you have finished typing the command and to execute what you have typed.

That may seem odd but the commands can span several different lines and only when MySQL encounters the semi-colon will it execute the code.

The output on my test machine is as follows:

+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
+--------------------+
2 rows in set (0.00 sec)

This tells me that I have two databases installed by default: information_schema and mysql.

We're not going to worry about those right now. We're only seeing what's there.

The second way of listing the databases in MySQL is very similar except it uses the word 'schemas' instead of 'databases'. This is simply another way of referring to a database.

SHOW schemas;

The output is exactly the same:

+--------------------+
| Database           |
+--------------------+
| information_schema |
| mysql              |
+--------------------+
2 rows in set (0.00 sec)

In general, we will be using the word 'database' instead of 'schema' as although they mean the same thing in MySQL, I have been reliably informed (thanks Ron) that 'schema' can, and does, mean slightly different things on other database software such as postgresql.

Just something to keep in mind if you do use other DB software.

If you are using a different OS than Debian Etch you may well see a third database named 'test'.

It is a very good idea to delete this straight away and the next article concentrates on creating and deleting schemas.

PickledOnion

Setting the MySQL root password

2007-08-03T16:42:00Z

Setting a MySQL root password is considered by some to be a waste of time. But then some also believe having a firewall or wearing a seatbelt are a waste of time.

Setting a MySQL root password is very simple and is the first thing you should do on installing the MySQL database.

When you first install MySQL it won't have a password set for the root user.

Note: Don't confuse the MySQL root user with the system root user.

Although both users have the same philosophy behind them in that they are admin users with full permissions, the MySQL root user is only used when accessing databases and when using MySQL from the command line. It cannot do anything 'outside' of MySQL.

So to start this MySQL series, we will set the MySQL root user password. There are a couple of ways of doing this, but we are going to log into MySQL to set it.

This does a couple of things. Naturally, it will set the password (!) but it will also introduce you to the MySQL command line.

Just as with BASH, you should not be intimidated by using the command line. It is easy to learn and is as powerful as you want it to be. There are plenty of external gui faces to MySQL and indeed, I occasionally use them. But it is useful to learn at least the basics of the command line for there will be a time that entering a couple of commands is far easier than firing up another programme to complete a simple task.

Let's get stuck right in. Log onto your VPS and find out the hostname of your server. You will probably know this already but if not, you can enter the command:

hostname
#shallot

As you can see, my server's hostname is 'shallot'. I'll explain why we need this is a moment.

Now we get to use MySQL via the command line. Simply enter 'mysql:

mysql -u root -p

The -u option specifies the user. In this case the user is root. The -p option means a password will be required. Just hit enter/return when asked as there is no password (yet).

A little tip is to set an alias in your .bash_profile to shorten this command. For example, I have:

alias mysqll="mysql -u root -p"

So when I enter the command 'mysqll' it will execute the full 'mysql -u root -p' code.

You will be greeted with some information regarding version and some tips on getting help:

As this is our first foray into the MySQL command line, let's set the password and leave.

To set the password enter:

SET PASSWORD FOR 'root'@'localhost' = PASSWORD('yourpasswordhere');

Change 'yourpasswordhere' for a password of your choosing and note the semi-colon (;) at the end of the command.

The output is pretty straight forward:

Query OK, 0 rows affected (0.00 sec)

That tells us that the 'Query' (the command we entered) went OK.

That's almost it.

Remember we got the hostname of your VPS? Well, there is more than one way to connect to MySQL. One is from localhost and the other is via the hostname of your machine:

SET PASSWORD FOR 'root'@'shallot' = PASSWORD('yourpasswordhere');

Notice how I have my hostname ('shallot') in the command? As it's the same user, just with different ways of connecting, use the same password as before. We won't have to worry about that again.

Finally, you need to reload the privileges and then leave the MySQL command line:

FLUSH PRIVILEGES;
quit;

MySQL is very polite and will say 'Bye' before putting you back on the BASH command line.

As you can see, using MySQL is very simple and very quick. It would not have been worth starting a gui interface just for this.

The next articles will concentrate on creating databases, tables, columns, users and all the good stuff that databases are used for.

PickledOnion.

Subversion, Rails and Litespeed primer

2007-08-02T19:52:00Z

You are probably using version control for you projects. Even for a lone developer, subversion makes life much easier.

As some point you will test your application in Litespeed. Any commits to subversion after that will include compressed files ending with .lsz and logs full of outdated files. Let's set up the application to ignore certain files when committing changes.

The base for this article came from Ryan Bates' excellent Railscasts series and extends episode 36 for Litespeed use.

I'll assume you have subversion set up on your server. If not, refer to the subversion articles for an introduction and explanation.

let's start by creating a base Ruby on Rails application and moving into the directory:

rails rails_app
cd rails_app

Next move database.yml and remove the log and tmp files:

mv config/database.yml config/database_example.yml
rm -r log/*
rm -r tmp/*

Import

That's the first part done so now import the application to subversion:

svn import /home/paul/rails_app/ file:///home/paul/repository/rails_app/trunk -m "Initial import of rails_app"

Now delete the original rails_app folder as we no longer need it:

cd ..
rm -rf rails_app

Check Out

Now we're free to check out rails_app from the repository and configure it to ignore certain files and directories in any future commit:

svn co file:////home/paul/repository/rails_app/trunk rails_app
cd rails_app

Now copy the database_example.yml file back to database.yml:

cp config/database_example.yml config/database.yml

Now comes the meat of the subversion/rails primer. We're going to set the 'ignore' function on a few files so subversion will literally ignore them on any future commit.

Ignore

These files include log files, files in the rails tmp directory and files ending in .lsz in the public directory:

svn propset svn:ignore database.yml config/
svn propset svn:ignore "schema.rb" config/
svn propset svn:ignore "*.xml" config/
svn propset svn:ignore "*" log/
svn propset svn:ignore "*" tmp/
svn propset svn:ignore "*doc" doc/
svn propset svn:ignore "*.lsz" public/
svn propset svn:ignore "*.lsz" public/javascripts/
svn propset svn:ignore "*.lsz" public/stylesheets/

If you are swapping between Windows and Linux workstations when you develop your application, you will also need to set the subversion 'executable' flag on some files:

svn propset svn:executable "*" `find script -type f | grep -v '.svn'` public/dispatch.*

Commit

Finally you need to commit your changes to the subversion repository:

svn commit -m "ignoring certain files in rails_app"

Tips

There should be no need to 'add' files using 'svn add xxxxx' if you use the -c flag with script/generate.

The -c (or --svn) flag informs subversion of any new files so all you have to do is commit the changes.

An example (with output):

script/generate model user -c

      exists  app/models/
      exists  test/unit/
      exists  test/fixtures/
      create  app/models/user.rb
A    app/models/user.rb
      create  test/unit/user_test.rb
A    test/unit/user_test.rb
      create  test/fixtures/users.yml
A    test/fixtures/users.yml
      create  db/migrate
A    db/migrate
      create  db/migrate/001_create_users.rb
A    db/migrate/001_create_users.rb

Pretty cool. Rails has automatically let subversion know about the new files. Saves us time as all we have to do is commit the changes.

PickledOnion.

Litespeed - Browsing subversion repositories

2007-08-01T17:02:00Z

Litespeed does not support browsing subversion repositories in the way that the Apache webserver does.

This does not leave us high and dry though as there are plenty of third party products that allow us to browse the repository quite happily whilst using svnserve to check-out and commit any changes.

In this article I will show you how to set up a simple Ruby on Rails application using bsSvnBrowser from Bounty Source.

This is a free product and is released under the GPL so feel free to use it for whatever you want - just keep to the rules of the GPL.

Just a quick word of warning: the documentation on the Bounty Source site needs updating and does not work with the latest release.

Let's see if you want to install it first. Have a look at my demo which will allow you to browse two of my projects called user_fu and wibble_fu.

Have a play with the menu and select 'revision info' from the drop down box and click 'Go!'. It'll show you exactly what was changed and when. As you can see, I really went to town with my show method (with a mistake in the syntax!).

Right, I'll assume you have a subversion repository setup with at least one project imported.

BsSvnBrowser will not work unless you have the ruby subversion bindings installed so let's go ahead and do that:

## Debain:
aptitude install libsvn-ruby
## Ubuntu:
apt-get install libsvn-ruby

If you are using another distribution, please refer to the install documentation for that distro.

Using 'irb', have a quick check to see if the ruby bindings have taken:

irb
require 'svn/core'  
## => true
exit

I'm going to create a new Ruby on Rails application for the subversion browser, but you can also install it as a plugin - simply adjust the routes.rb config shown below:

rails svn.domain.com
cd svn.domain.com

Now install the plugin:

./script/plugin install https://svn.bountysource.com/bssvnbrowser/trunk/
mv vendor/plugins/trunk vendor/plugins/bs_svn_browser

Now we need to run a rake task to ensure the assets are linked correctly:

rake bs:svn_browser:link_assets

Once done, we need add a couple of lines to tell BsSvnBrowser where the repository is and to load the correct libraries:

nano config/environment.rb 

## At the bottom add:

BsSvnBrowser.repository_path = '/home/username/repository'

nano  vendor/plugins/bs_svn_browser/init.rb

## At the bottom add:

require 'svn/repos'

In this example, the SvnBrowser is all I want from the Rails application. As such, the routes.rb needs adjusting so all URL requests are routed to the correct controller:

nano config/routes.rb

## Underneath  # map.connect '', :controller => "welcome" add:

map.connect '*path',  :controller => 'bs_svn_browser', :action => 'distributor'

And finally, remove the index.html file as we don't need it:

rm public/index.html

That's it.

The Rails application is good to go. Just add the domain to Litespeed's virtual host configurations (refer to the Ruby on Rails domain article if unsure).

PickledOnion.

Multiple repositories and subversion

2007-07-31T15:48:00Z

Last time we looked at multiple projects which was a nice way of serving multiple projects from the same repository.

But what if we wanted our projects to be completely separated? Well, serving multiple repositories is the answer.

For some reason, this is sometimes seen as a tedious and long route to serve our projects. Nothing could be further from the truth. Multiple repositories are incredibly easy to set up and to serve and do solve issues related to version numbering and so on.

Let's get straight on. If you have been following the previous tutorials, you may well have project1 and project2 in the 'work' and 'repository' folders. You may also have an instance of svnserve running.

Let's stop svnserve and delete the old stuff:

killall svnserve
rm -rf /home/paul/repository
rm -rf /home/paul/work/*

Now we have a clean sheet to work from.

Start by creating a folder to hold our repositories and then, using svnadmin, create two new repositories (we'll keep the naming pretty simple):

mkdir repositories

svnadmin create repositories/project1
svnadmin create repositories/project2

Next, I'm going to create two incredibly simple projects and import them into the separate subversion repositories:

mkdir project1
touch project1/project1.txt

svn import /home/paul/project1 file:///home/paul/repositories/project1/trunk -m "import project1"

mkdir project2
touch project2/project2.txt

svn import /home/paul/project2 file:///home/paul/repositories/project2/trunk -m "import project2"

Notice that this time, for each initial import subversion reported:

Committed revision 1

Now the two projects are seperated. Had we used the technique described in the multiple projects article, project2 would have been committed as revision 2.

Delete the original project folders as we don't need them any more:

rm -rf project*

We could simply check out the projects on the same machine but that's not much fun. Let's setup svnserve to serve both repositories at the same time.

This is exactly the same as when serving one repository:

svnserve -d -r /home/paul/repositories/

That's it. It is incredibly simple to set up. Naturally, if you have a firewall, ensure you allow connections to port 3690 (the default svnserve port).

Checking out the different projects uses the same procedure as before. So from your workstation, issue the command(s):

svn co svn://123.45.67.890/project1/trunk project1

svn co svn://123.45.67.890/project2/trunk project2

The IP address is the address of your VPS.

Add, edit and delete files as you would for any other project under subversion control. Any commits you make will be for that project only.

PickledOnion.