I just recently updated it to use the Sept 1st, 2010 daily build. You can pull the latest script directly from my website or from my repository on github.

Script Usage

My test environment was a standard web server install from the Fedora 13 download DVD.  After the install, I started the same process I performed with the Ubuntu install, which was something like this:

mkdir mono
cd mono
wget http://www.integratedwebsystems.com/resources/p796/fedora_mono-trunk.sh
chmod 744 fed*.sh
./fedora_mono-trunk.sh

That’s it. It’ll first install all the required dependencies for the build and the web server. It’ll then download the 9/1 build (or latest tested version) from the daily tarball list and pull mod_mono and xsp from subversion trunk. Finally, it will extract, compile, and install everything.

The only thing remaining is to setup a web application and configure apache to use mod_mono. For this, I like to use the Mod Mono Config Tool as a starting point to build my virtual host configuration file.

Setup your web server:

1. Move the mod_mono.conf from /etc/httpd/conf to /etc/httpd/conf.d
2. Create a new directory to hold your virtual host config files at: /etc/httpd/sites-enabled
   
   mkdir /etc/httpd/sites-enabled
3. Copy your new virtual host config file to /etc/httpd/sites-enabled
4. Append a virtual host config line to your httpd.conf
   
   echo ”Include sites-enabled/*.*” >> /etc/httpd/conf/httpd.conf
5. Disable Selinux by editing the /etc/selinux/config file and changing SELINUX=disabled
6. Reboot server
7. Start web server if it isn’t configured to auto-start. (use chkconfig to set auto-start)
   
   service httpd start

That should do it. You can test your new virtual host by browsing to it. The 404 response should show the new mod-mono version.

Good luck!

I’ve always been a big fan of SubSonic since its 2.0 version, which I used for a mid-sized e-commerce site. With a totally rewritten core, 3.0 uses LINQ (language integrated query) for all of its data access providing a great alternative to Dblinq for the Mono platform.

SubSonic3 supports ActiveRecord, Repository, and Custom Linq modes, which give you the flexibility to build code-first or database-first.  SubSonic3 is not an ORM (object relational mapping) like NHibernate, but it can behave like one when you use Repository Mode using POCO (plain old CLR object) representations of your tables. SubSonic handles the mapping and database query generation itself based on the database provider configured. Its intention is to allow you to build code-first and let the persistence of the object be non-critical to your application. It can even migrate your class definition changes (table schema) to the database automatically during runtime; however, it still has the flexibility to let you design your database with keys, indexes, and constraints yourself without using the automatic migration. The SubSonic website has a great demo showing this capability.

Database Independence

To make SubSonc3 truly database agnostic, you have to use Repository mode. Active Record and Custom Linq modes DO support multiple database engines, but they all require custom class generation which is hard-wired to those engines. So when you change database types like from MySql to MSSQL or vice-versa, you have to regenerate your classes.

With Repository mode, you simply change your connection string in the app.config. It will use the 2.0 Data Provider model provided by the database engine client and the definition of your POCO classes to determine the SQL syntax and schema to use.  SubSonic is pre-wired with MSSql, SQLite, MySql, and a generic ANSI Sql syntax support. There’s been lots of talk about implementing Oracle and PostgreSql, which may already work in ActiveRecord or LinqTemplates, but are not yet in the Core assembly for use with Repository.

Decoupled – Mocking for Unit Tests and Framework Independence

Another big advantage of Repository is the ability to decouple your data framework from your application completely. Since the POCO objects are not directly tied to SubSonic, they can be re-used with other frameworks like NHibernate or the latest Entity Framework 4 without touching a single line of application code. It also opens the door to mocking and testability. Dependency Injection frameworks like Unity or StructureMap work perfect for this.

So how about a sample?

This is a silly little test application that is neither pretty nor elegant, but it proves that this code will run on Mono 2.6.3 and 2.7 (trunk) with a SQLite database. It also uses Unity for dependency injection much like you would in Asp.NET MVC. Within the project, you’ll find an AppService interface used to provide the definition for simple ‘business’ functionality. This is meant to be generic for the sample; but in a real application, I would breakdown the services by functional purpose. They all can share the same LinqRepository data interface, which provides basic rules for LINQ-based CRUD. SubSonic3 hooks right into that and is nearly transparent to the application with the exception of a few attributes on the domain objects. There are some placeholder Mock classes there and sample mappings in the code just for show.

Download the sample project

You can also get the latest version from IWS Snippets project subversion.

So about this project…  Well it’s a simple project really: web based, MVC2 with a MySql database. So here’s a few technical issues I ran into while building the beginnings of this application.

Choosing a Data Framework

I know some of you purists would say stick to vanilla ADO.NET; it works every time, and you have no conversion problems. Well, that’s right, but I’m a lazy typist, and I really dig LINQ. So I tested several LINQ data frameworks on mono and found that Dblinq and SubSonic3 were the most functionally supported frameworks. I tested it with Linq to NHibernate, but it didn't work. SubSonic3, after a recent bug fix, now does work in Mono! 

MVC2 Works on Mono?

Yeah it does! Well mostly and only if you pull from the trunk code or the daily tarballs. Unfortunately, it does not work with the latest public release 2.6.4 and definitely not 2.4.4 which is the latest deployed version on Ubuntu 10.04. MVC1 does work out of the box on both of those. But I’ve been spoiling myself on MVC2 while at my fulltime job, so I decided to push for MVC 2.0 for this. So what do you have to do to get it working?  You need to learn a little bit about compiling Mono on your own and installing it, which sounds more painful that it really is. I even wrote a script that works (most of the time) on Ubuntu.  There’s no guarantee that it will work for you of course.

Checkout one of my recent posts about getting Mono trunk installed.

Using MVC2 is the easy part. Just setup a new MVC2 project and ensure your reference options for the System.Web.Mvc and System.Web.Routing assemblies are set to Copy Local. Data annotations will not work, so you’ll need to rip out the model validation in the default MVC2 project; otherwise, the rest of it works like a charm.

xUnit and Dependency injection with Unity works too!

Yup, believe it or not, some of the components in the Enterprise Library do work in Mono including Unity, which works great for swapping out mock classes in test projects. I chose to use xUnit as my testing framework since it seemed to work pretty nicely in the SubSonic project. I also found a real nice breakdown of how they compare to other testing frameworks. The xunit command line runs on vanilla Ubuntu 10.04 (mono 2.4.4). However, my preferred method of running some of these tests is using the TestDriven.net runner on Windows/VS.

System Agnostic Gotchas

I’ve built and tested most of it on Windows. Which sometimes creates problems when deploying to non-Windows servers. Especially when it comes to I/O pathing.  As you go through and design it, you always have to build it in a platform agnostic manner. Duh right?  This includes simple things like case senstive paths, using the correct directory separators, etc. Typically as lazy Windows programmers (not all of us)   we would rather hard code the path separator like this.   string.Format(@“..\files\{0}”, filename);    But unfortunately that breaks Linux pathing. So by using Path.DirectorySeparator, it will automatically decide which is the correct character to use on either platform.
string.Format(“..{0}files{0}{1}”, Path.DirectorySeparator, filename);

The later versions of windows also support both slashes, so you could get away with using forward slashes in windows I/O on Vista and 7.

It can be advantageous (if working with a web application) to use System.Web.HttpContext.Current.Server.MapPath or System.Web.Hosting.HostingEnvironment.MapPath to get your native local path from a virtual one. So store your paths as virtual ones and let the framework convert it to a native/local one.

Image Rendering

Well, I haven’t completely dug into this, but I have briefly tested simple things like resizing images and writing them back out with Jpeg encoding. I have to say that the Mono built-in implementation of the GDI works just fine.  I even tested some other things like rendering speed as far as resizing a jpeg and writing it out. It seems using the System.Drawing as opposed to Mono’s GDK/Cairo actually works faster (only by observation; nothing official). I’ll have more detailed results on this as I get to that piece.

Wrap-Up

So if you’re interested in starting a new Mono project, I hope some of these tips will keep you out of trouble. Good Luck!

Lately, I’ve been really digging the new Ubuntu 10.04 on my desktop and web server. So I’ve been meaning to get a post out here describing how I got Mono trunk installed since it comes packaged with 2.4.4.  After much testing, I finally have finished getting a script to work with a fresh, vanilla install.

I stumbled on this blog post by Boris Schieman where he wrote a bash script to compile and install the Mono trunk.  I made a few tweaks to it for a vanilla linux install for the tagged 2.6.4 release and setup another one for updating a mono trunk build using the daily tarballs. I’ve successfully tested both versions on Ubuntu 10.04 Lucid. I’m just a casual linux/mono user, so use this at your own risk.

Steps to Install

Starting with a fresh install of Ubuntu 10.04 Server, these steps can be run from the console or via SSH. Lately, I’ve been testing the trunk script more thoroughly than the tagged version, but they both should work.  As always, checkout http://www.mono-project.com to get more detailed information about the different versions available and this install process. For the tagged 2.6.4 install, I chose to use the packaged mono to support compiling this one; so when it’s done, you’ll end up with two versions of mono installed. The packaged version is 2.4.4 located at: /usr/bin  and this compiled version will be located at /usr/local/bin and should be the default after it’s installed. These steps are basically the same for both versions. Just switch out the url for the script if you want to install the 2.6.4 tag.

Step by Step

1. Create a new directory in your home directory called mono.
   mkdir mono
   cd mono
2. Copy the script to this folder and make it executable
   wget http://www.integratedwebsystems.com/resources/p796/install_mono-trunk.sh
   chmod 744 install_mono-trunk.sh
3. Execute it. (without sudo; you will be prompted occasionally for your sudo password during install phases)
   ./install_mono-trunk.sh
4. Check the install – sometimes the trunk doesn’t always compile fully or install correctly.  Check your /usr/local/bin folder to see what was installed.  You can also run mono –V to see the current runtime version, which should be the date of the tarball 20100618, etc.  (equivalent of 2.7 trunk) 
   ls /usr/local/bin
5. Setup Mod_Mono by moving the config file and enabling it for apache
   sudo mv /etc/apache2/mod_mono.conf /etc/apache2/mods-available 
   sudo ln -s /etc/apache2/mods-available/mod_mono.conf /etc/apache2/mods-enabled/mono.conf 
6. Check your apache site configurations to ensure they’re using the correct path to mod-mono-server2 located at /usr/local/bin. I use the mod_mono configuration tool and then change the path it generates. Restart Apache when you’re done.
   sudo service apache2 restart

Download Scripts

Install Mono SVN Tag 2.6.4

Install Mono Trunk (updated 2/26/2010)

Update Mono Install (updated 2/26/2010)

Install Script for Trunk

#!/bin/bash

TOPDIR=$(pwd)
BUILDDIR=$TOPDIR/build
DLDDIR=$TOPDIR/downloads

export PATH=/usr/local/bin:$PATH

echo "updating existing system"
sudo apt-get update
sudo apt-get upgrade -y

echo "installing prerequisites"
sudo apt-get install -y build-essential libc6-dev g++ gcc libglib2.0-dev pkg-config subversion apache2 apache2-threaded-dev bison gettext autoconf automake libtool

mkdir -p $BUILDDIR

echo
echo "downloading mono packages"
echo

cd $BUILDDIR

svn co svn://anonsvn.mono-project.com/source/trunk/xsp
svn co svn://anonsvn.mono-project.com/source/trunk/mod_mono

wget http://mono.ximian.com/daily/mono-latest.tar.bz2
wget http://mono.ximian.com/daily/monocharge-latest.tar.gz

cd $BUILDDIR
bunzip2 -df mono-latest.tar.bz2
tar -xvf mono-latest.tar
tar -xzvf monocharge-latest.tar.gz

echo
echo "building and installing mono packages"
echo
cd $BUILDDIR
cd mono-*
./configure --prefix=/usr/local --with-glib=system
make
sudo make install

cd $BUILDDIR
cd monocharge*
sudo env prefix=/usr/local ./recharge.sh

cd $BUILDDIR
cd xsp
./autogen.sh --prefix=/usr/local
make
sudo make install

cd $BUILDDIR
cd mod_mono
./autogen.sh --prefix=/usr/local
make
sudo make install
cd $BUILDDIR

echo
echo "done"

Good luck!

Index

• Getting Started
• Database Migration
• Linq to Sql to Dblinq
• Membership
• Authorization
• Deployment
• VIM (Editing code files on the server)
• Wrap Up
• Get the Source

Getting Started

Since I’ve already ported this application, it is very easy to identify any of the problem points. But for any new project, I would identify the basic items related to common issues with changing platforms like: data access, authentication, and any operating system specific code. Using the MoMA tool is hugely beneficial to see how your code base might fare in the Mono framework. It will point out any specific code you’re using that could cause problems.   You should also browse the Mono site and learn some basics about the framework since they have quite a few useful extended frameworks that are not part of the Windows .Net runtime.  They also have another nice guide out there for porting Asp.Net applications where they use PostgreSql and Blog Starter Kit.

Database Migration

You should know that Microsoft Sql Server works fine with Mono and works well when you are in a Windows environment and want to run Mono applications against existing Sql Servers. Since we’re running this application completely on a Linux server, as you might do in a hosted Linux environment, leaving our database in Sql Server isn’t an option.  I chose to migrate to MySql purely for personal preference since I have a little more experience with this one rather than others like PostgreSql or Sqlite. However with Dblinq, you will have quite a few options.

Create an Empty MySql Database and an Application User

If you recall from my first post in this series, we installed and configured MySql server.   We also discussed creating new users. You will want to create a new database with a new user who has access to it from the local machine. (Note that this can also be performed with the MySql Workbench GUI Tools).

So to begin, using Putty, SSH into your server.  Then run:

root@server: mysql -u admin_username -p
Enter password: ********
create database sitemanager_mono;
grant all privileges on sitemanager_mono.* to 'aspnet'@'localhost' identified by 'pass';
quit

You may want to replace the username and password I used here with something more secure, but for this demo I kept it simple. You can do that by replacing ‘aspnet’ with a username of your choice and ‘pass’ with a password of your choice.

You now have a new empty database with its own power user account that can only access it from the local machine. This will be our application user so keep the credentials handy for later when we edit the config file.

Migrating Sql Server Schema to MySql

I used the MySql Migration Toolkit (part of the GUI Workbench) to perform my migration. It actually worked out pretty well with the exception of a few data type conversions. I like to use varchar(max) fields in Sql server. I also use bit fields for booleans since they parse right over to C# booleans.  The migration tool didnt’ like varchar(max) and converted them to varchar(-1). It also converted my bit fields to tinyint(4). So during the migration, I was able to make edits to a few of my tables that contained those fields. For varchar(max), you have a choice. You can: use a smaller field like varchar(5000), use a Text field, or you can choose to store your text data in a binary blob and encode/decode it to UTF8.  For this, application, I went the route of selecting a smaller varchar field for simplicity; but if my content pages were large, I would probably go the route of text. I found some interesting discussion in this post on the topic.

So in order, here are the steps I took using the migration tool:

	Choose your source database.
	Choose your target database.
	Select the source schema.
	Add exclusions. I chose to exclude my membership tables since I configured those to use a different catalog.
	Utf-8 was fine for my solution
	Mapping error review
	Execution step
	Execution results
	Script errors will appear on the last screen.  Make the necessary changes, click Apply Changes, and Recreate Objects for each error.  When finished, click next to finish. This is where you’ll see varchar(-1) for conversion from varchar(max) fields.  Change this to text or varchar(n). Note that sql bit fields convert to smallint(4) if you wish to change that back to bit.

Linq to Sql Classes to Dblinq

After fixing errors and executing the script, you should now have your full schema migrated to MySql. Now you need to convert your Linq to Sql to Dblinq. Mono uses Dblinq as its Linq to Sql replacement internally. I chose to manually use DBlinq because I wasn’t sure how much of the Dblinq code was available in Mono.  I downloaded the current version of the Dblinq project from their public Subversion repository.

So the basic idea here is that we’re going to swap out L2S with Dblinq in a nearly transparent way.  We’ll drop the existing DBML file from our project, use DBMetal.exe to regenerate new classes, and then update our DBFactory utility function to create a new data context from the DBlinq side.   Essentially, this will allow us to re-use the same operational syntax in the Repository class with minimal changes.

For generating new classes, I used the DBMetal utility that comes with Dblinq. Here’s the batch file I setup to generate my code:

REM: note that the '-sprocs' option is turned on

"DbMetal.exe" --provider=MySql -database:sitemanager_mono -server:carbuncle -user:user -password:pass "-namespace:IWS.SiteManager.Core.Model" -code:Generated.cs -sprocs --pluralize

After generating the classes, I replaced the DBFactory GetProvider function with this:

public static Model.SiteManager GetProvider()
{
    var con_string = GetDefaultConnectionString();
    return new Model.SiteManager(new MySql.Data.MySqlClient.MySqlConnection(con_string));
}

I used a repository class as a helper to access my data model. Each repository class contains its own instance of the data context (in this case, Data.SiteManager). During construction of the repository class, it creates a new instance of the data context so any of the factory functions are able to use it without maintaining their own context. So I replaced all the member variable types for existing data contexts with the new one generated from Dblinq. I also noticed Dblinq had different casing than the original column names.  So where I had columns like, “ModifiedUTC” before, it was “ModifiedUtc” now. This was a pretty painless fix with find/replace.

You’ll notice here that the Linq syntax itself didn’t change at all.

public class ContentRepository
{
    SiteManager _DB;

    public ContentRepository()
    {
        _DB = DBFactory.GetProvider();
    }

    /// <summary>
    /// gets a page by its id
    /// </summary>
    /// <param name="id"></param>
    /// <returns></returns>
    public Content GetContent(int id)
    {
        return _DB.Contents.Where(o => o.ID == id).SingleOrDefault();
    }
    /// <summary>
    /// Load a page by its permalink.
    /// </summary>
    /// <param name="permalink"></param>
    /// <returns></returns>
    public Content GetPage(string section, string permalink)
    {
        return _DB.Contents.Where(o => o.SectionID == section && o.Permalink == permalink.Trim().ToLower()).SingleOrDefault();
    }
    /// <summary>
    /// gets the configured default page.
    /// </summary>
    /// <returns></returns>
    public Content GetIndexPage(string section)
    {
        var data = _DB.Sections.Where(o => o.ID == section).SingleOrDefault();

        Content page = null;

        if (data != null && data.DefaultContentID.HasValue)
            page = _DB.Contents.Where(o => o.ID == data.DefaultContentID.Value).SingleOrDefault;

        return page;
    }
    public string GetSectionIDForPage(int id)
    {
        var section = _DB.Contents.Where(o => o.ID == id).Select(o => o.SectionID).SingleOrDefault();
        return section;
    }
    public void SaveContent(Content content)
    {
        Section section = null;

        if (_DB.Sections.Where(o => o.ID == content.SectionID).Count() == 0)
        {
            section = new Section();
            section.ID = content.SectionID;
            section.Description = "Auto-generated section for new page.";
            _DB.Sections.InsertOnSubmit(section);
            _DB.SubmitChanges();
        }

        //take current version, push it to content history, overwrite current with new.
        Content old = this.GetContent(content.ID);
        if (old != null)
        {
            //archive old version.
            ContentHistory row = new ContentHistory();
            row.ContentID = content.ID;
            row.Body = old.Body;
            row.CreatedUtc = DateTime.UtcNow;
            _DB.ContentHistories.InsertOnSubmit(row);
            _DB.SubmitChanges();

            old.LoadFromExisting(content); //load current values
        }
        else
        {
            old = content;
            _DB.Contents.InsertOnSubmit(old);
        }

        _DB.SubmitChanges();

        if (section != null) //was a new one. set the default content id.
        {
            section.DefaultContentID = content.ID;
            _DB.SubmitChanges();
        }
    }
    public void DeleteContent(int id)
    {
        var data = _DB.Contents.Where(o => o.ID == id).SingleOrDefault();
        if (data != null)
        {
            //remove conflicts first.
            var section = this.GetSectionByID(data.SectionID);
            if (section != null)
            {
                section.DefaultContentID = null;
                _DB.SubmitChanges();
            }

            _DB.Contents.DeleteOnSubmit(data);
            _DB.SubmitChanges();
        }
    }
}

At this point, the project should be compilable. You may need to make a few tweaks to get the loose ends tied up.

Membership Provider

After following the instructions from the last post, you should get your membership provider setup and configured. For Mono, I think the biggest hang up for me was not being able to use hashed passwords. Alternatively, you can investigate using encrypted passwords. For simplicity, I used clear text passwords here.

Membership Authorization

You should now have a runable MVC application. Almost everything should work with exception to how security applies rules from the web.config.  I noticed Mono doesn’t apply the same security authorization rules to paths for MVC like it does for web forms. I removed <location path=””> tags from my config file and placed the authorization restrictions to my controller actions instead.

So for example this config section would be used to restrict access to all actions in the Manage controller on Windows.

<location path="Manage">
    <system.web>
        <authorization>
            <allow roles="Admins,Editors"/>
            <deny users="*"/>
        </authorization>
    </system.web>
</location>

So on Mono, we remove it from web.config and move to the manage controller as an attribute on ALL actions you want to restrict. This can become a maintenance hassle, but they may eventually fix this for MVC in Mono.

[Authorize(Roles="Admins,Editors")]
public ActionResult Index()
{
    return View();
}

Deployment

Don’t forget to make changes to your web.config file. Include the credentials you setup for your database earlier.  Then using Build->Publish, publish the site to a local folder. Don’t include the App_Data folder and have it delete all files before publishing. Then using FileZilla over SFTP, connect to your server and upload the published website to the web folder you configured. With the latest Mono, the website should automatically reload the new assemblies. If you have any doubt about this, you can always SSH into the server and restart apache.

To restart apache, gain root access using su and then:

service apache2 restart

Optionally, if restarting apache doesn’t seem to work, you can also search and kill off the mono processes:

diabolos:/home/nathan # ps -A | grep mono
 2162 ?        00:00:03 mono
 2164 ?        00:00:08 mono
diabolos:/home/nathan # kill 2162
diabolos:/home/nathan # kill 2164

The next request to the server will restart these processes as needed.

Quick Guide to VIM

Every once in awhile, you may need to edit files that live on the server without going through the whole process of publishing, deploying, etc. To do this, I like to use a tool called VIM. So what is VIM?  For those of you haven’t used it, it’s a simple text editor in Linux that comes with most distributions. You can think of VIM like “edit” for DOS on steroids. The OpenSuse version even has code completion and color-coded syntax, which is very neat.

To open a file with VIM, SSH into your server and run this command:

vi filename

When you open the file, there isn’t a menu, but you’ll see ~ on the left and the text of your file.  VIM has modes (much more than I’ll discuss here), but you need to know of at least two:  insert mode and append mode.  This will allow you to insert or append text starting at the cursor position. So move your cursor to any location and press i for insert mode. You will be able to freely type almost anything. To exit insert mode, hit Esc. Append mode uses the same behavior by pressing a. You will append text starting at the cursor position. Entering :d will delete the current line. Be sure not to use arrow keys while in an editing mode.

To save a file, press Esc to exit editing mode, and then press :w to write the file. You can then enter :q to quit.   And to save and quit, use :wq.  You can get more info by entering man vi at the command prompt.

Wrap Up

So that’s it. This is a tiny project, but you may be able to apply these ideas to your own projects.  For me, this gets my imagination fired up about what kinds of solutions I can take advantage of using Mono. I think there’s a lot of potential here.  I’ve recently begun using interfaces and dependency injection with my projects for data frameworks to avoid the mess we covered in the Linq to Sql to Dblinq section. This means I can write a decoupled application that can optionally use Linq to Sql or Dblinq as a pluggable assembly that is injected using settings in my config file. This will make the transition between Windows and Mono much less painful.

Get the Source

To obtain the source, head over to sitemanager.codeplex.com and download the latest source.  You’ll find the mono ported code under the /branches/mono-mysql-fork branch.

Useful Links

• Mono project
• Getting Started with Mono
• Porting Asp.Net Applications
• MySql .NET Connector (I downloaded mono build & source)
• SiteManager CodePlex Mono Branch in Subversion
• Dblinq website
• Dblinq Subversion

This first part will cover installing and configuring an OpenSuse 11.2 server with Apache/Mono and SSH. The second part will talk about how to setup a MySql Membership provider (with mono and Windows), and the third part is a walkthrough showing how to port a simple Asp.Net MVC site to mono and MySql. I’m also targeting those of you who use virtual hosting where you might only have SSH (after install) to configure your server, so I will be using text based tools: SSH, vi, and yast for all my installations and configuration after getting the base system installed.

First off, let me just say that I’m a Windows .NET programmer; not a Linux programmer. I know enough about Linux to dig my way around most of the basic stuff, so if anything seems incorrect in this post, feel free to correct me.   I’m extremely intrigued by Linux and its open source philosophy. I use it for a handful of useful, rock solid services like Subversion, Postfix, Samba file servers and MySql. I also share an interest with many small web shops in finding more affordable hosting solutions for smaller Asp.Net apps. And in light of Mono being able to run MVC apps, it’s very exciting to think of what we can do with it.

Index

• Before You Begin 
• Installing Linux Graphical (part 1)
• Configuring Linux During Install (part 2)
• Configuring Linux After Install
• Updating Software
• Install Mono, Apache, and MySql
• Configure a Virtual Host & Web Directory
• Running the Default Visual Studio MVC Website
• Useful Links

Before you Begin

There are a few things you need to download before you get started.  First of all, you’ll need an SSH client for file transfer and console access. I’m using FileZilla and Putty as my SSH clients. If you’ve never used it before, think of SSH like telnet and FTP wrapped into one.

Here’s a few tips on navigating the text mode installer screens. Use the Tab Key to cycle through fields or change focus between sections on the screen. Use the Spacebar or Enter to select an option. Esc can back out of a dropdown option. You can use the arrow keys to cycle options in a section.

Download one of the installers on OpenSuse’s website. Burn or mount the ISO and boot your machine from it to begin.

Note: while I was doing this on a test virtual machine, I could only get the Network install to work with Virtual PC 2007 on my hardware. All the versions worked fine when installing it to a physical machine. If you choose the network install, you may need to configure your DHCP settings before the GUI installer starts. (with Virtual PC, make sure the correct external network card is exposed to the virtual machine).

Installing Linux Graphical (part 1)

In sequence, here are (most) of the screens you’ll see during the first part of installing OpenSuse 11.2.

	Language selection
	Uncheck Use Automatic Configuration
	Choose your time zone.
	I chose minimal server. Optional: You may choose a desktop if you wish to use remote VNC to remotely admin your server with a GUI.  VNC is kind of like using Remote Desktop. To do that, choose your desktop here, and we’ll configure it to still boot to text mode later at the summary screen.
	Partition selection. I used defaults.
	Enter your username. Uncheck automatic login. Optional: You may choose a different password for the root user.  This is good if you have a public server sitting in the cloud in case someone gets the password to your normal user account.
	Summary screen. Scroll to the bottom. Click “enable and open” for Firewall and SSH. We’ll use SSH to remotely admin the server. Optional: If you chose a desktop earlier, change the Default Runlevel to 3 (Full multiuser with network). This will cause the server to boot to normal text mode by default.
	Click Install to continue.

Configuring Linux During Install (part 2)

After the first phase, your computer will reboot and begin the manual configuration phase. As I mentioned earlier, these screens are pretty easy to navigate. Use tab to cycle through the fields or change focus to different sections. Use space or enter to make a selection. Also, the highlighted letters in words are hotkeys you can use in combination with the Alt key.  Each section will continue when you select the NEXT option in the bottom right corner.

	This is the first configuration screen. Enter your new machine hostname (or leave it default).
	Showing hostname configuration progress.
	This is the main configuration screen. You will set your network configuration here. Tab until you see the bounding box around the gray area light up. Then down arrow to Network Interfaces. Press enter to select it.
	Overview Screen This is the first Network Interfaces screen. There are three focus areas. The first is the top tab area: Overview, Hostname/DNS, and Routing. Tab to the interface list and select your interface card for your main Internet connection. Then press Alt-i to view its details
	Shows Ethernet details. If you choose to use static IP, this is where to set that information. Set the IP address, subnet, etc. You may leave this as DHCP if you wish.  When you’re done tab and select Next.
	From the Overview screen (bolded above), move to the Hostname/DNS section. Set your hostname and your DNS servers (if you chose static IP in the previous step).
	If you chose a static IP, tab from the Overview Screen to Routing. Set your default gateway and associate it with the correct device.
	After clicking Next from the Overview Screen, the configuration changes will be written to disk.
	This step will test your Internet connection. If successful, it will check for updates.
	Successful connection
	Updating packages
	Run updates
	Will reboot after this step. You may need to click Next after it finishes.
	I used defaults here.
	Finally done!
	The installation drops you to a console.

Configuring Linux After Install

Root Access
You’ll need root access to perform most of the tasks we’re doing, so enter: su, then type the root password you configured during install. The command prompt will change color to red.

Updating Software

One of the really cool things about most Linux distributions is their package management. It’s a one-stop-shop for installing, updating, and removing software on your system. Fedora has yum, Debian has apt-get, OpenSuse has zypper. Using these utilities is very straight forward. So if you didn’t update your system during install, you can do it now by entering:

zypper update

You can run this command occasionally to update your system. To see more details about how to use it. Enter: man zypper

Install Mono, Apache, and MySql

Installing Mono and Apache

With zypper, we can cheat a little to install mono, apache, and all dependencies. First we need to add the mono repositories so zypper knows how to find it.

Enter the following lines separately:

zypper addrepo http://ftp.novell.com/pub/mono/download-stable/openSUSE_11.2 mono-stable
zypper refresh --repo mono-stable
zypper dist-upgrade --repo mono-stable

Our cheat is going to be installing Mod_Mono, which is the mono plugin for Apache. This will force it to install apache, mono, xsp and everything we need to get started.

zypper install mod_mono

Autostart Apache

To make apache start when the system reboots, enter this command:

chkconfig --add apache2

Installing MySql Server

To download and install mysql server and client, enter this command:

zypper install mysql

Add MySql to your startup and start it:

chkconfig --add mysql

service mysql start

Then configure the server with:

mysql_secure_installation

Follow the instructions and setup your server. The first question will be to enter your root password; the first time you run this, just press enter with a blank password, then choose Y to enter a new root password. You’ll also want to disable remote root access, the anonymous user, and test database.

Optional:

Now setup your user account so you can remotely access the server. This also requires you to expose your MySql server over the Internet if you’re running a hosted server. Users in MySql are username & host based. Both parts make up a unique user.

To add a user:

Connect to your database server using your new root password. Enter: mysql -p

Here is an example of a user you would typically use for a specific application running on the local machine. This statement grants all privileges on a database called test_database and all its tables to a username ‘my_new_username’ who can only connect from localhost.

grant all privileges on test_database.* to 'my_new_username'@'localhost' identified by 'new_password' with grant option;

An admin user with access to everything from any location would have a statement similar to this:

grant all privileges on *.* to 'super_user'@'%' identified by 'super_secret_pw' with grant option;

Enter quit to exit the MySql client.

Firewall

This is actually much simpler than it looks. I’m showing all these screens just for reference. Basically, just use yast as the tool configure the firewall. It has a nice little interface similar to the post-install configuration. For what we’re doing, add your network device to the External Zone, then add Secure Shell Server and HTTP Web Server to the allowed services. Then just enable and turn on your firewall (if it isn’t already on)

	Enter: yast
	Navigate to Interfaces, set your network device to be in the External Zone.
	Navigate to Allowed Services, select External Zone, then select Secure Shell Server.
	Use the Add link to add the selected service to the list. Repeat this for HTTP server. Optional: Add MySql server if you want to expose it to the Internet and access it remotely with your tools.
	Enable and Start your firewall from the Start Up screen.
	Finish

Configure a Virtual Host & Web Directory

I used the Mod_Mono configuration tool on the Mono website, which built the following configuration file. It looks big, but most of it’s comments. The key notes here are that it runs .Net 2.0, it’s root directory and that it handles all requests through Mono (good for MVC). It also does some nice things like compress the output on certain files as well as the Mono output.

<VirtualHost *:80>
  ServerName odin.integratedwebsystems.int
  ServerAdmin web-admin@odin.integratedwebsystems.int
  DocumentRoot /srv/www/odin.integratedwebsystems.int
  # MonoServerPath can be changed to specify which version of ASP.NET is hosted
  # mod-mono-server1 = ASP.NET 1.1 / mod-mono-server2 = ASP.NET 2.0
  # For SUSE Linux Enterprise Mono Extension, uncomment the line below:
  # MonoServerPath odin.integratedwebsystems.int "/opt/novell/mono/bin/mod-mono-server2"
  # For Mono on openSUSE, uncomment the line below instead:
  MonoServerPath odin.integratedwebsystems.int "/usr/bin/mod-mono-server2"

  # To obtain line numbers in stack traces you need to do two things:
  # 1) Enable Debug code generation in your page by using the Debug="true"
  #    page directive, or by setting <compilation debug="true" /> in the
  #    application's Web.config
  # 2) Uncomment the MonoDebug true directive below to enable mod_mono debugging
  MonoDebug odin.integratedwebsystems.int true

  # The MONO_IOMAP environment variable can be configured to provide platform abstraction
  # for file access in Linux.  Valid values for MONO_IOMAP are:
  #    case
  #    drive
  #    all
  # Uncomment the line below to alter file access behavior for the configured application
  MonoSetEnv odin.integratedwebsystems.int MONO_IOMAP=all
  #
  # Additional environtment variables can be set for this server instance using
  # the MonoSetEnv directive.  MonoSetEnv takes a string of 'name=value' pairs
  # separated by semicolons.  For instance, to enable platform abstraction *and*
  # use Mono's old regular expression interpreter (which is slower, but has a
  # shorter setup time), uncomment the line below instead:
  # MonoSetEnv odin.integratedwebsystems.int MONO_IOMAP=all;MONO_OLD_RX=1

  MonoApplications odin.integratedwebsystems.int "/:/srv/www/odin.integratedwebsystems.int"
  <Location "/">
    Allow from all
    Order allow,deny
    MonoSetServerAlias odin.integratedwebsystems.int
    SetHandler mono
    SetOutputFilter DEFLATE
    SetEnvIfNoCase Request_URI "\.(?:gif|jpe?g|png)$" no-gzip dont-vary
  </Location>
  <IfModule mod_deflate.c>
    AddOutputFilterByType DEFLATE text/html text/plain text/xml text/javascript
  </IfModule>
</VirtualHost>

Edit the information above (or use the configuration tool) and replace my hostname with yours. Then save this file with the extension “.conf” and copy it to your /etc/apache2/conf.d directory using FileZilla SFTP connection as the root user.

Create a new directory at the location you specified in the DocumentRoot command. This is the root folder you’ll use to deploy your website.

cd /srv/www

mkdir my_web_hostname

After setting all this up, you’ll need to restart your Apache server. To do that, just enter:

service apache2 restart

You can restart any of your services this way. You might also reboot your server just to get a fresh run after installing and configuring all our software. Use the shutdown command to restart your system. Again, you can use shutdown –help or man shutdown to learn more about that command.

shutdown -r now

Running the Default Visual Studio MVC Website

This is cool! It’s a great start knowing that routing, controllers and views all work. Feel free to play with it a bit more. Mono has some great tools like MoMa that will tell you if your existing assemblies are compatible with Mono. You can also start toying around with Dblinq and alternative membership providers.

There’s more to come. The next post will show you how to use the MySql Membership provider with both Windows and Mono.

Useful Links

• Mono Website – http://www.mono-project.com 
• Mod_Mono Configuration Tool – http://go-mono.com/config-mod-mono/
• MoMa  Mono Compatibility Checker – http://www.mono-project.com/MoMA
• OpenSuse 11.2 Download Page (scroll down) – http://software.opensuse.org/112/en
• OpenSuse Documentation (loaded with great how to documents) – http://en.opensuse.org/Documentation
• Putty Download Page – http://www.chiark.greenend.org.uk/~sgtatham/putty/download.html
• FileZilla Download Page – http://filezilla-project.org/download.php
• MySql Connector .NET Download – http://dev.mysql.com/downloads/connector/net/#downloads
• MySql Workbench (MySql Administration and Development tools) – http://dev.mysql.com/downloads/workbench/5.2.html