Search results matching tag '.NET'

Migration from Windows Server/IIS/SQL/ASP.NET to LMono (not LAMP and not LAMMono)

david — Thu, 27 Dec 2007 07:40:00 GMT

For those loyal readers of my blog, I'd like to announce a personal change of direction back to lighter, more open tools in the form of Linux, Mac OS, and Windows and Mono.

Background

It wasn't many years ago that I was enjoying burning my time by presenting .NET tech talks at Michigan State University. While I was on this .NET journey, I grew far away from my roots in linux and open source. And now, as we get closer to 2008, I'm taking a slightly different direction from the relative ease of Microsoft software to supporting Linux and Mac OS.

I'm building on Mono now, and look forward to writing software that will run cross-platform (so now my friends will all be able to play with my stuff on their macs). I've been playing with lighttpd on CentOS since I'm already very familiar with Apache. I've installed CentOS 5.1, Ubuntu 7.10, and have an UltraVNC connection to a local G4 so I'm pretty set with regards to testing.

The migration path from Windows Server /IIS/SQL/ASP.NET to Linux/Mono and will be slow, but satisfying. I'll be describing my experiences with the migration here.

Step 1: Install alternate OS's

Download Virtual PC
Install Ubuntu 7.10 w/ GUI - Virtual PC has a problem with the default Ubuntu mouse and video resolution settings, but 1 hour of tinkering will solve it.
Install CentOS 5.1 - I decided to install CentOS because I wanted to be able to support lighttpd with FastCGI Mono plugin installed.
Get a Mac - Install VineServer for VNC connectivity.

Install UltraVNC on your Windows machine

Depending on what you want and need, install Apache or Lighttpd. Since I'll be developing desktop software first, I'm not interested in the web server setup until I'm ready to migrate from IIS. I've played with the FastCGI mod, but will not be going over that yet.

Step 2: Install Visual Studio Express Versions on your Windows machine

They're simpler, lighter, faster, free-er, and easier than Visual Studio Standard or Pro. While you'll be forced to seperate your Web and C# projects into Web Express and C# Express, this was a welcome forced seperation for me.

Step 3: Install Mono on alternate OS's (official site: http://www.mono-project.com/Downloads)

Ubuntu 7.10

sudo apt-get update
sudo apt-get install mono
sudo apt-get install mono-gmcs

CentOS 5.1

The built-in installer for CentOS 5.1 is called yum. If you run into any dependency issues, you can issue a command such as yum install XXX to install the XXX libraries and executables.

wget http://go-mono.com/sources/mono/mono-1.2.6.tar.bz2
tar -xjf mono-1.2.6.tar.bz2
cd mono-1.2.6
./configure
make
make install

Mac OS

Download and run the installer from http://www.mono-project.com/Downloads

Step 4: Share projects between computers and create build scripts

You can mount a windows share from Mac OS by exploring your 'Servers' tab in the Finder.
On Ubuntu, create a directory under /mnt and type: sudo mount -t cifs //192.168.1.102/SharedDirectory /mnt/SharedDirectory -o username=John,password=mySecretPassword
On CentOS, create a directory under /mnt and type: mount -t cifs //192.168.1.102/SharedDirectory /mnt/SharedDirectory -o username=John,password=mySecretPassword

The compiler for Mono (.NET 2.0) is called gmcs. I like to build a project on Windows, then copy the project over to a shared folder that's mounted between all the computers and execute the build command on each of the separate computers to do unit testing.

Since I'm starting very simple, my build script is a simple gmcs command that compiles 2 projects, 1 library and 1 executable.

/mnt/SharedDirectory/build.sh

rm -r -f ./bin
mkdir ./bin

gmcs ./Directory1/SourceFile1.cs ./Directory1/Directory2/SourceFile2.cs ./Directory1/Directory2/SourceFile3.cs /d:TRACE /t:library -out:./bin/MyLibrary.dll
gmcs ./Directory1.UnitTest/Program.cs /d:TRACE /t:exe -out:./bin/MyProgram.UnitTest.exe -r:./bin/MyLibrary.dll

To run the compiled program, I then type:

mono ./bin/MyProgram.UnitTest.exe

This is the start. I'll be adding things as I go deeper down the rabbit hole. Nice to be back in the more open arena everyone.

RE: IFPI on BitTorrent

david — Thu, 27 Dec 2007 07:22:00 GMT

The IFPI and ISPs like Comcast make me angry. http://torrentfreak.com/isps-should-block-bittorrent-and-tpb-071226/

"There’s noway this can happen…Everybody knows there is so much people in p2p that someone will find a way to go around all this. " - most_uniQue

most_uniQue is right. They can't stop anything. Developers will always be 2 steps ahead.

TLS is just the start.

Using Argotic to create an RSS feed from an ASPX page

david — Thu, 09 Aug 2007 20:43:00 GMT

It's simple. Thanks Brian, for making such an easy-to-use syndication library in .NET.
You can find Argotic at: http://www.codeplex.com/Argotic

Interesting points about this sample include:

There's no easy way to get the MIME-type from a certain file extension. (that I know of). I've used a static MIME library to get the MIME type for file extensions. This is included with the example as a referenced library (Okaypublish.Mime.Static)
The example I've included uses a pre-defined DataTable as its datasource, which you would then wire up to your SQL database.
I'm using a constant file size for the enclosure file sizes since I'm not packaging any example content files with this source. I've commented out how to get the filesize from the local file. (If you're hosted on a shared/dedicated server, you should probably append Environment.CurrentDirectory to the begining of the file name)

You can download the example from: http://piqd.com/get/q/bor

Source

While I don't know how to post really pretty code samples on the blog, I'll do my best with copy and paste.

// Demo application written by David Smith of OkayPublish LLC

// http://okaypublish.com

// http://btsharp.com

// http://ceedien.com

// http://piqd.com

using System;

using Argotic.Core.Rss;

using System.Data;

public partial class feed : System.Web.UI.Page

{

/// <summary>

/// This code will be executed every time somebody visits the RSS feed page

/// </summary>

protected void Page_Load(object sender, EventArgs e)

{

// This will be used to query the correct information from the SQL database

long userId;

// Don't respond if the request is not in the form of:

// "http://example.com/feed.aspx?q=1"

// "http://example.com/feed.aspx?q=2"

if (Request.Params["q"] == null)

{

Response.Output.Write("This URL must be in the form of http://example.com/feed.aspx?q=2. Be sure you're not missing the \"q\" parameter.");

return;

}

// Check to see if the GET parameter in "q" is garbage

try

{

userId = Convert.ToInt64(Request.Params["q"]);

}

catch (ArgumentException)

{

return;

}

catch (OverflowException)

{

return;

}

catch (FormatException)

{

return;

}

if (userId == 0)

{

return;

}

// Create the RSS feed to be published on this query

RssFeed myFeed = new RssFeed();

// Create the new RSS Channel. This has an array of RssItems.

myFeed.Channel =

new RssChannel("Argotic Demo Feed from User #" + userId.ToString(),

"Published feed from Argotic Demo User #" + userId,

new Uri(Request.Url.AbsoluteUri.ToString()));

// Create the data access layer

// NOTIC: this would be your SQL code

ExampleDataLayer exampleDataLayer = new ExampleDataLayer();

// Get all of the items the user has published

using (DataTable dataTable = exampleDataLayer.CreateDataTable(userId))

{

// Loop through the results of the SQL query to the

// database and insert them into the RSS channel items

foreach (DataRow row in dataTable.Rows)

{

// Title of the post

string title = (string)row["Title"];

// Description of the post

string description = (string)row["Description"];

// Time posted

DateTime dateTime = (DateTime)row["Time"];

// Attached file. This will be an RSS enclosure.

string filename = (string)row["File"];

// Get the right MIME-type for the attached file

string fileExtension = Utils.GetExtension(filename);

string mimeType = "";

if (fileExtension.Length > 0)

{

OkayPublish.Mime.Static.MimeType currentMimeType =

OkayPublish.Mime.Static.MimeType.FromExtension(fileExtension);

if (currentMimeType != null)

{

mimeType = currentMimeType.MimeName;

}

else

{

mimeType = "application/octet-stream";

}

else

{

mimeType = "application/octet-stream";

}

// Create the new RSSItem to be inserted into myFeed.Channel

RssItem newItem = new RssItem();

// Bind each of the returned results to a new RSS item

newItem.PublicationDate = dateTime;

newItem.Title = title;

newItem.Description = description;

newItem.Link = new Uri("http://example.com/readmore.aspx?q=" + filename);

//FileInfo fi = new FileInfo(Environment.CurrentDirectory + @"\" + filename);

newItem.Enclosure = new RssEnclosure(

new Uri("http://example.com/download.aspx?q=" + filename),

1024 * 30, //fi.Length, 30 KB, since these aren't real files right now

mimeType

);

// Add the new RSS item to the RSS feed channel (there is only one channel per RSS feed)

myFeed.Channel.Items.Add(newItem);

} // End Databinding loop

}

// Set the ContentType for the response

Response.ContentType = "application/xml";

// Write the feed to the output stream

myFeed.Save(Response.OutputStream);

return;

}

As always, comments are appreciated. Cheers.

Argotic on the Web: Part 2 (Setup)

david — Sun, 17 Jun 2007 04:19:00 GMT

Continued from Argotic on the Web: Part 1 (Solution Design)...

Prerequisites:

1. Microsoft Visual Web Developer 2005 Express Edition (direct link)

We'll use this to design the website that we'll be building for the creation of RSS feeds. The project will reference the Argotic library and will be end up being hosted on a GoDaddy shared server.

2. Microsoft Visual C# 2005 Express Edition (direct link)

We'll use this to create the RSS reader. The Windows Forms application will be used to read data from the website's RSS feeds (view.aspx).

3. Microsoft SQL Server 2005 Express Edition (direct link)

We'll use this to create a Database and Table for the Users table. We can test the SQL server statements on our own machines before we post the website to GoDaddy.

4. SQL Server Management Studio Express Edition (direct link)

This will be our administrative interface for the local SQL server. We'll code up the website against the local SQL server before we upload it to the server through FTP.

5. Argotic (direct link)

This is the library we'll be using to create (feed) and consume (read) the feeds published by our ArgoticWebSample.

Optional Setup Items

5. A GoDaddy shared hosting account (direct link)

We can set up a GoDaddy shared hosting account that will be used for hosting our web application. After we set up our hosting, we can upload from our computer to the website.

6. CoreFTP (direct link)

We'll use this to upload to the GoDaddy server.

This wraps up part 2 to the ArgoticWebSample. Next we'll be diving into the implementation of the Feeder and Reader.

Argotic on the Web: Part 1 (Solution Design)

david — Tue, 12 Jun 2007 22:06:00 GMT

Recently I got excited about a the video about Argotic (blog) on dnrTV.

Argotic is a .NET library for RSS/ATOM/OPML creation and consumption. The library is very easy to use, and can be used in a shared hosting environment (creation) and desktop environment(consumption).

So I decided to make amends for all the tutorials I've read and never contributed to - by coding up an example application for Brian's Argotic .NET Library for .NET.

This is a complete tutorial, beginning to end, feeder to aggregator. Get a glass of water and get comfortable. I'll be posting this in multiple parts and updating things as necessary.

Introduction

This solution will be divided into 3 Parts.

Part 1: Solution Design
Part 2: Setup
Part 3: Implementation

Architecture

Goal: This will be a RESTful (whatever that means) website that allows users to publish text.

Platform: The site will be hosted on an ASP.NET GoDaddy shared server, and will use the shared server instance of SQL to store data (up to 200MB, more than enough).

Features and Interface: The site will be as simple as possible. It will have 5 pages: CreateAccount, DeleteAccount, Post, Delete, and View pages.

Data storage: User-posted data will be stored on local site files. Critical site information that needs to be accessed quickly (passwords) will be stored in the SQL server. (GoDaddy SQL servers can only store 200 MB, so we don't want to store too much user-posted data in the SQL database)

Solution Plan

We'll be creating 2 Visual Studio projects for this solution. (They'll actually be in 2 different solutions, since we're using Visual Studio Express for the development)

1. The RSS/ATOM/OPML Feeder

This will be the website.

2. Reader

We'll be creating a Windows Forms application that will contact the website (http://piqd.com/ArgoticWebSample/View.aspx?user=david&format=rss) and get the content for the given user.

The Web Pages

CreateAccount - Creates an account with a username and a password.

DeleteAccount - Deletes an existing account given a username and password.

Post - A logged-in user can publish a new post from this page.

Delete - A logged-in user can see all of his/her posts and choose to delete one of them at a time.

View - This page will return a feed (RSS, OPML, or ATOM) with the given user's posted data.

The Windows Form Reader

There will only be one Form if I can help it. We'll jump that when we get to it!

This is it for my first post. I'll be coming back to revise it I'm sure.

Continued at Argotic on the Web: Part 2 (Setup).

Argotic: RSS in .NET

david — Sat, 09 Jun 2007 00:00:00 GMT

On dnrTV this week, Brian Kuhn shows off Argotic, his .NET RSS library. Argotic supports parsing of RSS feeds as well as creation of RSS feeds.

I'm very impressed by how easy the library is to use and look forward to digging in.

I'll be posting my tinkerings online here.

A Windows Forms demo application is available here: http://piqd.com/get.aspx?q=bf383d84-144b-416f-a37a-c61fb644ff4f

In an upcoming dnrTV episode, David Smith teaches how to use BTSharp to enable scalable serverless content distribution in your applications.

david — Sat, 17 Mar 2007 07:27:00 GMT

Do you like Dot Net Rocks? You might like dnrTV too - that's Dot Net Rocks TV.

Carl Franklin and Richard Campell produce an educational and entertaining talk show about .NET and Microsoft technologies.

Description: Interested in creating highly scalable data-driven applications with no servers? David wrote his .NET implementation of the BitTorrent protocol in C# and gives a great introduction to BitTorrent and an in-depth look into how to use BTSharp in your applications.

Speaker Bio: David is Computer Science graduate from Michigan State University. He served as Microsoft Student Ambassador at MSU for two years and has been as a C# MVP. David is interested in distributed systems and distributed communication algorithms and frameworks. David also likes frisbee and swimming.

You can find dnrTV at: http://dnrTV.com

You can find Dot Net Rocks at: http://dotnetrocks.com

Webcast on API design.

david — Tue, 06 Feb 2007 11:51:00 GMT

Great talk recommended by Brad Abrams.

http://www.infoq.com/presentations/effective-api-design

Long, but really great.

Best advice: "Code to the API before you're even done."
This prevents: Getting to the end and saying "Hm, that doesn't feel right."

Through experience, I've been learning that flexibility and valuable feedback are really priceless.

Authenticode and Strong naming ("signing")

david — Sun, 21 Jan 2007 05:24:00 GMT

It kills me that the names for these processes are "Code signing" and "Strong Name signing".

So this is the scenario. I'd like for my assembly to be strong named (able to be loaded into the GAC, and used in strong-named apps) and I'd like it to be code signed (verifiably from me, and verifiably changed or not).

Instead of writing you a walk-through, I'm going to post some links to important articles, then post the build script that allows me to go from a raw Assembly to an obfuscated, strong-named, code-signed assembly.

A tip to all the college hobbiest out there: Obtaining a code-signing certificate that allows you to publish code publicly costs ~ $500 from Verisign, $200 from Thawte, and ~179 from Comodo. Comodo has horrible customer service, so I went to Thawte (owned by Verisign) and never looked back. Thawte's been great.

In the meantime, or just for fun, you can create your own code-signing certificate and install the cert on your local machine for testing of code-signing (Authenticode) success.

Links

1. Best article, defining the two processes and what each does
http://www.robrich.org/archive/2006/11/29/Code-Signing-two-worlds-defined.aspx

2. .NET Security blog from Shawn, explaining the order or processes and why
http://blogs.msdn.com/shawnfa/archive/2007/01/10/combining-strong-names-with-authenticode.aspx

3. Explaining Strong Naming
http://msdn.microsoft.com/msdnmag/issues/06/07/CLRInsideOut/default.aspx

4. And on Strong Name integration with VS 2005
http://blogs.msdn.com/shawnfa/archive/2006/02/14/531921.aspx

Code (I renamed some of my files, and blanked my private key password, hope you don't mind)

:: Begin SignAssembly.bat

:: Obfuscate the library

:: In : Raw
:: Out: Obfuscated

"C:\Program Files\Wise Owl, Inc\Demeanor for .NET, Enterprise Edition\v4.0\Demeanor.exe" /application /encryptstrings /names:alpha /noenums /out:".\Obfuscated" ".\Raw\MyAssembly.dll"

:: Create the strong-named assembly

:: In : Obfuscated
:: Out: ObfuscatedAndStrongnamed

copy ".\Obfuscated\MyAssembly.dll" ".\ObfuscatedAndStrongnamed\MyAssembly.dll"
sn -Ra ".\ObfuscatedAndStrongnamed\MyAssembly.dll" BusinessCodeSigningKey.Single.PublicPrivate.pfx

:: Codesign the library

:: In : ObfuscatedAndStrongnamed
:: Out: ObfuscatedAndStrongnamedAndCodesigned

copy ".\ObfuscatedAndStrongnamed\MyAssembly.dll" ".\ObfuscatedAndStrongnamedAndCodesigned\MyAssembly.dll"
signtool sign /f BusinessCodeSigningKey.Single.PublicPrivate.pfx /p *********** /t http://timestamp.verisign.com/scripts/timstamp.dll /d "Description of the dll file" /du http://mywebsite.com ".\ObfuscatedAndStrongnamedAndCodesigned\MyAssembly.dll"

As always, comments or questions are welcome.