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

Download the MySql Connector

Fortunately now, the MySql.Web assembly comes with the prebuilt versions of the MySql Connector/Net. If you don’t have it, go get it.  I recommend the Mono build, even for the Windows folks, because it’s a simple zip file with the assemblies. If you would like to see additional samples, download the Source version of their connector. When you have it downloaded, add a reference to MySql.Web in your web project.

Database

As with the Microsoft Sql Server membership provider, you have a choice to place your database tables in an existing application database or in its own database. I prefer to use its own just to keep it separated in case I want to share the Membership component among several applications. If you build upon my last post, you can simply create an empty database for your membership data.  Don’t create any tables yet. Just create an empty shell and create a user account for the application to connect your database and has access to create and alter tables. If you’re new to MySql, the MySql Administration Tools are extremely handy for this.

Configuration

The configuration options are mostly the same as the ones you’ve seen in the Microsoft Sql Server membership provider. This one has one added feature, which is an autogenerateschema flag.  This flag instructs the membership provider to actually push schema updates based on the version you’re running. To enable it, simply set it to true.  As with other membership configuration, once you have it enabled and configured to connect to your database, it should work immediately.

There are a few caveats that I ran into while configuring this. For example, hashed passwords only works on Windows .Net; not Mono. Encrypted passwords takes a little more configuration and also (through practice here) only seemed to work on Windows .Net.  There may be some bugs in my version of Mono 2.6.1 or maybe another configuration oddity I couldn’t identify.

Nonetheless, the MySql providers work 100% on Windows. If you’re running on Mono, your main option is to use Clear Text passwords; or if you want to get a little creative, download the source code to the MySql Connector and rewire how it runs its encryption through the framework and roll your own instead.

Configuration Tool

So moving forward, I built a tiny little configuration tool that you can use to generate the web.config sections you need for this. It takes into account some of my experiences with the things I mentioned like Hashed and Encrypted passwords. It will also auto-generate your MachineKey section if you choose to use encrypted passwords on the Windows side.

Launch Configuration Tool

Here is the default, Windows based configuration that is generated. You may use this and tweak it or generate your own.

<?xml version="1.0"?>
<configuration>
    <connectionStrings>
        <add name="MySqlMembershipConnection"
            connectionString="Data Source=server_name;user id=username;password=password;database=database_name;"
            providerName="MySql.Data.MySqlClient"/>
    </connectionStrings>

    <system.web>

        <authentication mode="Forms">
            <forms
              loginUrl="~/Account/Logon"

              timeout="30"
              name=".ASPXFORM$"
              path="/"
              requireSSL="false"
              slidingExpiration="true"
              defaultUrl="Default.aspx"

              enableCrossAppRedirects="false"/>
        </authentication>

        <membership defaultProvider="MySqlMembershipProvider">
            <providers>
                <clear/>
                <add name="MySqlMembershipProvider"
                      type="MySql.Web.Security.MySQLMembershipProvider, mysql.web"
                        connectionStringName="MySqlMembershipConnection"
                        enablePasswordRetrieval="false"
                        enablePasswordReset="true"
                        requiresQuestionAndAnswer="false"
                        requiresUniqueEmail="true"
                        passwordFormat="Hashed"
                        maxInvalidPasswordAttempts="5"
                        minRequiredPasswordLength="6"
                        minRequiredNonalphanumericCharacters="0"
                        passwordAttemptWindow="10"

                        applicationName="/"
                        autogenerateschema="true"/>
            </providers>
        </membership>

        <roleManager enabled="true" defaultProvider="MySqlRoleProvider">
            <providers>
                <clear />
                <add connectionStringName="MySqlMembershipConnection"
                    applicationName="/"
                    name="MySqlRoleProvider"
                    type="MySql.Web.Security.MySQLRoleProvider, mysql.web"
                    autogenerateschema="true"/>
            </providers>
        </roleManager>

        <profile>
            <providers>
                <clear/>
                <add type="MySql.Web.Security.MySqlProfileProvider, mysql.web"
                      name="MySqlProfileProvider"
                      applicationName="/"
                      connectionStringName="MySqlMembershipConnection"
                      autogenerateschema="true"/>
            </providers>
        </profile>
    </system.web>
</configuration>

Testing Membership

So once you have your membership configured, you’ll need to test it out. First, don’t forget to update your connection string credentials. Then the easiest way to test your membership configuration (if you are using Visual Studio) is to use the ASP.NET Configuration Tool (appears when selecting your web project). When membership configuration is working properly the landing page will show you how many users are configured in the system. If there are none, it will still show you zero. You will also have access to add, remove, and update users from this screen.  If it doesn’t show you anything, then there’s likely something wrong in your configuration.

After the first time testing your membership, you’ll notice all the schema in the database will have been generated and is now filled with data. This was caused by the autogeneratechema flag being set to “true”.  As new versions of MySql.Web assembly are released from MySql, any schema changes new to each version will automatically be applied with this flag enabled. It should also alleviate that “Schema is missing or incorrect” error.

Wrap Up

So with that, you should have your ASP.NET application configured to run membership to a MySql database. If you’re using Mono, this configuration should work with the default ASP.NET MVC web application (after you reference the MySql assemblies and setup the configuration of course).  Look forward to my next post, which will be the final part of this series about porting an ASP.NET MVC application to Mono. We’ll be taking a very simple MVC application called SiteManager on CodePlex and convert it to run on Mono and MySql.

Useful Links

• MySql Community Server  – Installing on OpenSuse Linux? Refer to my last post.
• MySql GUI Tools
• MySql Connector/NET
• My Cool Configuration Tool

The first one is a refraction of moonlight through ice crystals in the atmosphere. It was very cool to see. This image was taken with a 30 second exposure with our Nikon D60.  I found more info describing this phenomenon here.

I also took another one a couple weeks ago after the snow storm hit us pretty hard. I live in the Midwest, and we typically don’t see this kind of snow. This image was taken a few nights later when the snow had time to melt a little and then re-crystallize on the surface.

Lunar-bow by Nathan Bridgewater is licensed under a Creative Commons Attribution-Share Alike 3.0 Unported License.
Permissions beyond the scope of this license may be available at http://www.integratedwebsystems.com.

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

Setup the Dialog and Postback Script

In my application, we may click the button multiple times. So you’ll need to initialize it on load and actually open it later. As you can see below, we’re making our dialog modal and setting its autoOpen to false to prevent it from opening during initialization.  The dialog contains two buttons, and in this initialization, we can define their handler code. The confirmation button “Yes, I Understand and Agree” runs a chunk of code emulates the server control Click event on Button1. Notice I used the inline server-side script to gain access to the Page.ClientScript object, which contains a nice handful of helper functions for javascript.

$().ready(function() {
    $("#ConfirmPanel").dialog(
    { autoOpen: false,
        modal: true,
        bgiframe: true,
        width: 400,
        height: 300,
        buttons: {
            'Youbetcha': function() {
                <%=this.Page.ClientScript.GetPostBackEventReference(new PostBackOptions(this.Button1))%>;
            },
            'No Thanks': function() {
                $(this).dialog('close');
            }
        }
    })
});

Open the Dialog with OnClientClick

Next we’ll open the dialog each time our original server control button is clicked. You use the OnClientClick property to do this.

$("#ConfirmPanel").dialog('open'); return false;

We always return false here. Since the dialog doesn’t suspend the process, it will always finish and immediately postback. So by returning false, we’re preventing the button from posting back and allowing the jquery dialog to appear.

Here’s the full Asp.Net markup:

<asp:Label ID="lblClicked" runat="server" />
<asp:Button ID="Button1" runat="server" OnClick="Button1_Click" Text="Test" OnClientClick="javascript: $('#ConfirmPanel').dialog('open'); return false;"/>
<div id="ConfirmPanel" style="width: 400px; height: 200px;">
    <h2>Terms and Conditions</h2>
    <p>By accepting, you agree to the following:
        <ul>
            <li>Are you really, really sure???? </li>
        </ul>
    </p>
</div>

The Result

Clicking Youbetcha fires the Click event for our Button1.

Updated: 2/16/2010

To answer Matt’s question, I setup a simple web forms page with a data grid and a button within its rows. All the buttons are wired to one event handler and their command argument property is used to provide identifying data to the event handler.  Having said that, here’s the same solution using dynamic confirmation dialog. If you click OK, it will postback using the original button’s information which is displayed on postback.  Noticed I placed a ClientScript.GetPostBackEventReference(uxGrid, string.Empty) within the PageLoad event. Every time the page loads, postback or not, I want it to do this so it will render the __doPostBack client-side function. Without that, it will only work the first time. Subsequent clicks after the first postback will break.

So essentially the solution is to use __doPostBack(clientside_input_name_attribute, ”).  Using the javascript function below we rebuild the buttons for the dialog each time and rewire it to the appropriate location.  So for this, if you didn’t want to use a grid, you could still use it the same way via OnClientClick with “this.name” and pass that to __doPostBack.

Here’s the markup source.  You can also download the full source code here.

Thanks Matt.

<%@ Page Language="C#" AutoEventWireup="true"  %>
<%@ Import Namespace="System.Collections.Generic" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>

    <script type="text/C#" runat="server">
        protected void Page_Load(object sender, EventArgs e)
        {
            ClientScript.GetPostBackEventReference(uxGrid, string.Empty);

            if (!Page.IsPostBack)
            {
                List<int> test = new List<int>();
                test.Add(2);
                test.Add(3);
                test.Add(32);
                test.Add(223);
                test.Add(5);
                test.Add(8);
                uxGrid.DataSource = test;
                uxGrid.DataBind();

            }
        }
        protected void uxRowAction_Click(object sender, EventArgs e)
        {
            Button b = sender as Button;
            if (b != null)
            {
                uxTest.Text = "clicked " + b.CommandArgument;
            }
        }

    </script>

    <link href="smoothness/jquery-ui-1.7.2.custom.css" rel="stylesheet" type="text/css" />
    <script src="jquery-1.3.2.min.js" type="text/javascript"></script>
    <script src="jquery-ui-1.7.2.custom.min.js" type="text/javascript"></script>
    <script type="text/javascript">
        $().ready(function() {
            $('#dialogContent').dialog({
                autoOpen: false,
                modal: true,
                bgiframe: true,
                title: "MySql Membership Config Tool",
                width: 800,
                height: 600
            });
        });

        function rowAction(uniqueID) {

            $('#dialogContent').dialog('option', 'buttons',
                {
                    "OK": function() { __doPostBack(uniqueID, ''); $(this).dialog("close"); },
                    "Cancel": function() { $(this).dialog("close"); }
                });

                $('#dialogContent').dialog('open');

            return false;
        }

    </script>
</head>
<body>
    <form id="form1" runat="server">
    <div id="dialogContent">
        <h3>confirm</h3>
        <p>Click ok to accept</p>
    </div>
    <asp:Literal ID="uxTest" runat="server" />
    <div>
        <asp:DataGrid ID="uxGrid" runat="server" AutoGenerateColumns="false">
            <Columns>
                <asp:TemplateColumn>
                    <ItemTemplate>
                        <asp:Button ID="uxRowAction" runat="server" CommandArgument='<%#Container.DataItem.ToString() %>' Text="Row Action" OnClick="uxRowAction_Click" OnClientClick="javascript:return rowAction(this.name);" />
                    </ItemTemplate>
                </asp:TemplateColumn>
            </Columns>
        </asp:DataGrid>
    </div>
    </form>
</body>
</html>

First of all, if you haven’t seen Conery’s five minute demo video on repository mode, you should. It’s very cool.  Once you watch it, you’ll get the basics of migration and understand the idea of building the object model first while using the database purely as a storage mechanism. In this case, I built my class, and I’m letting Migration handle all the schema generation for me. It will also create a new database file if one doesn’t already exist. That’s the idea right?

Setup Your Configuration File

For starters, don’t forget to download and install the System.Data.SQLite library first. I ran their Windows installer and it worked just fine. Then add a connection string to your config file. Be sure to set the ProviderName to  System.Data.SQLite. SubSonic uses the 2.0 provider model to determine the types required for the data connection.

<connectionStrings>
    <add name="TrackerConnectionString" connectionString="Data Source=Tracker.db3;" providerName="System.Data.SQLite"/>
</connectionStrings>

Create Your Data Classes

Create your storage classes. If you’re new to ORM/data layers, remember that each class definition represents a row in the database. In this case, I want a table called DSTFileTrackers with three columns: ID, Filename, and Imported. These are simple classes (other than the subsonic string length attribute). They don’t inherit from any other base class. A nice attribute not used here would be the [SubSonicIgnore] attribute. It will allow you to define other properties that you don’t want to store to the database like for example, read only properties.

public class DSTFileTracker
{
    public long ID { get; set; }

    [SubSonic.SqlGeneration.Schema.SubSonicStringLength(100)]
    public string Filename { get; set; }

    public bool Imported { get; set; }
}

Write Your Implementation

Lately, I’ve been playing a lot with ASP.NET MVC, I’ve been creating repository classes for my data objects.  They’re simple subject-matter classes that just handle business/data operations for a set of objects. In this case, I created one called TrackerRepository and implemented most of my SubSonic code there. Later on, I could build an interface for the repository and then set it up for unit testing or make it adaptable to switch to another data layer.

So here’s a sample calling code.

var tracker = _Repo.DSTFiles.Where(o => o.Filename == file.name).FirstOrDefault();
if (tracker == null)
{
    tracker = new DSTFileTracker();
    tracker.Filename = file.name;
    _Repo.SaveDSTFileTracker(tracker);
}

This save function below lives in my repository class. You can see how nice and clean these statements are. There’s a ton of potential here. Repository mode can do a lot of really cool stuff like deleting many records at once by expression or doing partial inserts and updates.

public void SaveDSTFileTracker(DSTFileTracker data)
{
    if (_Repo.Exists<DSTFileTracker>(o => o.ID == data.ID))
        _Repo.Update<DSTFileTracker>(data);
    else
        _Repo.Add<DSTFileTracker>(data);
}

So all in all it was pretty easy to do. You’ll notice I ran an existence check. The SimpleRepository doesn’t have this built into a save function like ActiveRecord, but it’s not a big deal to do manually.

Catching SubSonic Gotchas

This library is new and like all new libraries, you’ll run into a bug here and there. Hopefully as more and more people use it, the SubSonic community will become more aware of the bugs out there and can fix them.  I ran into a few myself just while doing this. These are mostly specific to the SQLite portion of SubSonic. They were all very easy to fix, and it’s very easy to submit your own patches. Checkout their GitHub demo video here.  You can access my branch directly for the fixed code. I’ve applied for a code pull, but it takes a few days and code review before they plug it into the main.

Here’s a few of the issues I ran into:

• SQLite’s auto-incrementing integer can only be 64bit [integer] rather than 32bit [int]. SubSonic will go and create the 64bit field during migration though; you just won’t see an error until you try to read it back. So if your ID property is an [int], change it to a [long].
• The default code for [bool] creates a tinyint field in SQLite.  I had to tweak the Subsonic code by changing it to use a bit.  When reading the values, it breaks because tinyint == Byte and SubSonic sets values to data properties by casting them directly to their actual type in the reader.
• When running an Update<T>, I get a NullReferenceException.  This is a bug in SubSonic and already has an issue posted. I submitted a patch for this.  It’s a simple column name mismatch in the update script generator.
• Just like in Linq to Sql when you do custom Lambda expressions with unrelated fields, it could cause problems. I was doing a funky Where(o=>o.Equals(y)) which blew up my stuff because the LINQ predicate expression couldn’t figure out how to parse Equals() and CompareTo() to SQLite syntax.  So keep it simple.

After spending a day drilling into T4 and learning how it works, I have to say that it was definitely time not wasted. I’ve since used it for tons of miscellaneous code generation projects including mostly data layer extensions. And with the help of the data provider specific templates in the SubSonic project, much of the schema extraction code has been provided for us through open source.

I’m a big fan of SubSonic, and I like to push it in all the shops I work with that aren’t already anchored down to another data framework. However, sometimes we still have to fall back to vanilla data layers like Linq to Sql (L2S), Entity Framework (EF), or straight up ADO.Net depending on the shop and its personalities. Having experience using SubSonic opens your eyes to some useful ways you can improve L2S and the others.

Like, for example, updating data… Have you been in a situation (like a web form postback or a web service call) where you’re instantiating a new entity instance whose data already exists in your database and you need to simply update it?  In L2S, this isn’t very straight forward. If you don’t want to mess with detaching and reattaching data entities, you can simple load an instance from the data context and update its fields with the new data; then commit the change back to the data context.

Well that’s great and all, but who’s going to type all the load functions? Not me, I hate typing.   So T4 comes to the rescue.  Here you’ll see a simple script that looks at a database and generates LoadFromExisting() functions for each table into a partial class that extends the original L2S class. Then anytime the schema changes, you simply run the T4 template and it re-executes your generation code.

Using the Generated Code

Here’s an example helper save function using Linq to Sql.  It simply checks for an existing record. If it exists, it updates its fields with the ones you passed in making it dirty to the data context, or it instructs the data context to insert it as a new one.

public void SaveSection(Section section)
{
    var data = this.GetSectionByID(section.ID);

    if (data == null)
    {
        data = section;
        _DB.Sections.InsertOnSubmit(data);
    }
    else
        data.LoadFromExisting(section);

    _DB.SubmitChanges();
}

Here is the corresponding LoadFromExisting() definition. You can see it’s very simple. All I really want to do here is update the values and flag the fields on the instance we pulled from the data context as dirty. The main thing to note here is that the class definition is partial.  It matches the namespace and name of the class generated in our DBML data context file.

public partial class Section
{

    public Section LoadFromExisting(Model.Section data)
    {
        this.ID = data.ID;
        this.DefaultContentID = data.DefaultContentID;
        this.Description = data.Description;
        return this;
    }

}

Now for Actually Generating Code with T4

To briefly explain T4, it’s basically a .net virtual machine hosted by visual studio. The code files appear a lot like classic ASP and MVC where you have rendered sections and functional sections. In T4, the token used to start and end a code section is: <# #>.  Like asp, you can include other files to re-use code files. Those files in this example have the ttinclude extension. Normal T4 scripts must end with the “.tt” extension.

Since we’re using what has already been setup for us by the SubSonic templates, we’re re-using their shared files: Settings.ttinclude and SqlServer.ttinclude. The settings.ttinclude file has all your basic shared settings like the global directives, includes, references, and supporting object model for the database structures. The SqlServer.ttinclude file contains the Sql Server specific schema extraction functions.

Add both these files to your project, and then add a new text file with extension “.tt” to your project.  Copy the content from template.tt into your new tt file. The template content simply includes the shared files for you. Notice every time you save this file, it re-runs itself; so be very aware when you’re saving to avoid running the code accidentally.

Here’s the full script for the partial extension:

<#@ template language="C#v3.5" debug="True" hostspecific="True" #>
<#@ include file="SQLServer.ttinclude" #>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Linq.Expressions;
using System.Collections;
using System.ComponentModel;
using System.Data.Common;

namespace <#=Namespace #>
{
<#

    var tables = LoadTables();

    foreach(Table tbl in tables)
    {
        if(!ExcludeTables.Contains(tbl.Name) && !tbl.Name.StartsWith("aspnet"))
        {
#>

    /// <summary>
    /// A class which represents the <#=tbl.Name #> table in the <#=DatabaseName#> Database.
    /// </summary>
    public partial class <#=tbl.ClassName#>
    {

            public <#=tbl.ClassName #> LoadFromExisting(Model.<#=tbl.ClassName #> data)
            {
<#
            foreach(Column col in tbl.Columns)
            {

                if (tbl.ClassName == col.CleanName)
                {
                    col.CleanName += "X";
                }
#>
                this.<#=col.CleanName #> = data.<#=col.CleanName #>;
<#
            }
#>
                return this;
            }

        }
<#
   }
  }
#>
}

So as  you can see, it’s very straight forward.  Here, we’re loading up all the tables, spinning through each one and then writing a function that spins its columns to generate assignment expressions.  (this.<#=col.CleanName #> = data.<#=col.CleanName #>; )  You’ll notice a few variable names being used like “Namespace” or ExcludeTables, etc.  With T4, you have to pretend that anything defined in a global scope is really just a member of this virtual class we created as our script. Those names were actually defined earlier in the Settings.ttinclude.  That is also where we’re setting our connection string name for the connection info. It uses the app.config in current project so you don’t have to save it statically in the file, which is another perk of these SubSonic templates.

For partial classes to work, you have to match the namespace and class name in your partial file. This is extremely useful, because I can generate code all day long with this file and then create yet another partial extension for the the more functional fine detail extensions.

Enum Generator

Here’s a nice little enum generator I wrote the other day. We typically use lookup tables in a lot of our projects whose names and values match what we have in our tables. This script uses a global list of table names in the Settings.ttinclude file and selects their data to generate enum code with values. The table structure is: (ID int, Name varchar(50), Description varchar(100)). You’ll need to create the table and fill it with your enumeration data first. Then run this script.

<#@ template language="C#v3.5" debug="True" hostspecific="True" #>
<#@ include file="SQLServer.ttinclude" #>
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Data;
using System.Linq.Expressions;
using System.Collections;
using System.ComponentModel;
using System.Data.Common;

namespace <#=EnumNamespace #>
{
<#
            var list = GetEnums();
            foreach (KeyValuePair<string, List<EnumValue>> pair in list)
            {

            #>

        /// <summary>
        /// An enumeration that represents the table <#= pair.Key #> in database: <#= DatabaseName #>
        /// </summary>
        public enum <#=pair.Key#>
        {
<#            int counter = 0;
            foreach(var value in pair.Value)
            {
                counter++;
                if (!string.IsNullOrEmpty(value.Description)) {#>
            /// <summary>
            /// <#= value.Description #>
            /// </summary>
<# } #>            <#= value.Name #> = <#= value.Value #><#if (counter < pair.Value.Count) {#>,<#}#>

<#            }#>
        }

<#            }#>
}

In my case, I dropped these enumerations into a custom namespace since the names were shared with the entities representing the tables.  If you wanted to, you could easily drop these into a class as well.

Download

Here’s the zip file containing the four scripts.

Disclaimer/Licensing: All code provided here was derived using some of the code in SubSonic templates; hence, this code is open source under the same license. New BSD, which I’ve included in the downloadable archive.

Enjoy!

Client-Side

I should make a quick mention that this can be done using either WCF or a simple HTTP request. In my opinion, I think using HTTP request provides better performance and comes with less deployment and maintenance hassle; but likewise it leaves a few other loose ends like security and message integrity (if left unhandled). For this example, I’ll mostly only discuss the HTTP request method. My sample code includes a WCF implementation for reference. (Maybe some of you WCF gurus can tell me how that looks).

So first of all, progress…  How can we measure it?  Due to the max request length constraints in your web application, 4MB by default in Asp.Net, we’ll need to chunk the file by hand to accommodate large files. And in doing so, we can count each time a chunk was successfully sent to the server. So progress is simply counting the number of chunks sent divided by the total number of chunks that need to be sent.  In most cases, on smaller files, you probably won’t have too many chunks. Also, larger chunks seem to perform the better during upload. I tried several different chunk sizes, and it seemed around 100-500k gave me the best of both worlds with having a good progress measurement and not being too chatty where it slows down the upload too much.

All of the file handling and server communication is managed by a FileSender object, which is responsible for a single file upload. ListItem encapsulates the FileSender to make it easier to work with. It’s also initialized using the ListItem control’s Dispatcher property for UI thread callbacks later on during its Completed and ProgressChanged events.

During upload, every chunk that is sent to the server is hashed before sending it and after receiving it to make sure it was a valid transfer. The entire file is also hashed after all chunks are sent to validate the end result matches the original file. If any chunk fails to pass the hash test, it’s kicked back and re-sent. It will attempt to resend the same chunk up to four times (by default) before failing completely and killing the upload.  If the full file hash fails, it will not try to resend the data; it will only notify the UI that the upload has failed.

This diagram shows the basic structure of the client-side program flow.

When the upload has finished, it will invoke the Completed event to let the caller know it’s done uploading. It will pass along the new filename or any errors that occurred during the upload. One of the challenges I mentioned earlier was related to invoking code in the UI after using the HttpRequest object. For this, we used the parent control’s Dispatcher property to invoke Completed and ProgressChanged. With the custom event delegates already defined, this worked out real well.

void OnCompleted(SendStatus status, string newFilename, string message)
{
    if (_Completed != null)
    {
        Delegate d = new FileSenderCompletedEventHandler(_Completed);

        FileSenderCompletedEventArgs e = new FileSenderCompletedEventArgs();
        e.NewFilename = newFilename;
        e.Status = status;
        e.Message = message;

       this._UIDispatcher.BeginInvoke(d, null, e);//use the UI Dispatcher to invoke the event
    }
}

Server-side

So now for the server side.  The destination folder is configured via an AppSettings variable called StorageFolder.  I set the default value to ~/Repo.  I built a generic handler to handle the request and pass data around using serialized XML of the request and response objects.

As requests come in, the handler peeks at the first element of the message, identifies its type, deserializes it, and hands it off to a processor function. The basic idea is to receive all the chunks identified by the same token and append them to a file. When the handler receives a FinishRequest for that token, the file is renamed and moved to a more permanent location, and the new file information is returned in a response.  For new files, an empty Guid is passed along with the first chunk. The handler starts a brand new file and responds with a new Guid token, which the caller will use in subsequent requests.

NOTE: There are many enhancements that can be made to this code. Like for example dead uploads.  If one fails, the guid temp file may live out there forever unless you clean it up. So a good tool to build would be one to go through and wipe files that haven’t been touched for awhile. Another important enhancement is to include security. Since this is just a sample; it’s totally open ended. It would be a good idea to lock out anonymous requests by using authentication/authorization or another security mechanism.

Anyway, the serialization works pretty consistently between Silverlight and full .Net, so I copied my request and response objects to both projects (client and server) and use them to serialize and deserialize the messages. This is where a small chunk size can hurt the upload performance since there is a little bit of overhead data using XML.  A higher performance alternative to XML would be to use query string parameters for all the details and write the file data to the request stream. As I said before, it’s pretty open ended at this point.

Where’s The Code!

(NOTE: Default.aspx = WCF and HTTPUpload.aspx = HTTP method described above)

UploaderSL.zip 1.2MB  (Updated 12/19/09 with minor pathing fix mentioned in comments)

To open this project, you’ll need the free Silverlight3 Tools.

In Summary

My philosophy with samples like this is to leave them completely open ended for you all to modify and play with. I left quite a few things unfinished both on server side and client side; so I encourage you to change whatever you like. And let me know what you think! Just email me at nathan at integrated web systems dot com.

Enjoy!

After googling around a bit, I found this article extremely useful. MIME Types… My server had nothing on it but IIS and Asp.Net. Naturally, Silverlight components were not setup in IIS. So this was a super easy fix by just adding the three new MIME types to the IIS Properties dialog. Check out the link for more details.

http://learn.iis.net/page.aspx/262/silverlight/