So, they’ve got pages and pages on their intranet that has links to these docs.  Templates for new orders, insurance forms, calculators for price lists, etc…  So, I can’t just move them.  They are a mixture of doc, xls, docx, xlsx, etc… just random crap.

Initially, I figured, I’ll just put in a nice handler to catch things first (which is so easy that it took me all damn day – I’ll get into that later!)

Here was the real problem:  The intranet site it is written in classic asp, so the session variables, so my standard “if session(“loggedin”)<>true then goto login page” isn’t going to work.  Classic asp doesn’t have the ease of a handler and if there is a way to do it, well…. I really don’t want to know.  Seriously, I’m not going to learn how to write something complicated in a dead language.  I’d prefer to learn something new that will be useful in the future.

So, sticking with the .Net handler idea.  Here’s the theory I decided upon.  Yes, I know, it is horrible, but here it is:

All I’m going to do is check to see if the referring page was within the intranet site.   Think about it…  If you really really really wanted to, you could write a script that would rip out those files, but seriously….  this is about all it really needs and I’m not going to make a new login page.

Here’s how I started:

Imports Microsoft.VisualBasic
Imports System
Imports System.Web
Imports System.Web.UI
Imports System.IO

Public Class secureDocs : Implements IHttpHandler

    Dim mimes As New contentTypes

    Public Sub ProcessRequest(ByVal context As HttpContext) Implements IHttpHandler.ProcessRequest

        Dim f, strReqPath, filePath, sql As String
        strReqPath = context.Request.Path
        Dim ref As String = context.Request.ServerVariables("HTTP_REFERER")
        Dim fileOK As Boolean = False

        Dim strliveSite As String = ConfigurationManager.AppSettings("public-domain")  'I keep these values in my web.config as appsettings
        Dim strlocalSite As String = ConfigurationManager.AppSettings("local-domain")

        Dim liveSite As Integer = InStr(ref, "http://" & strliveSite)
        Dim localSite As Integer = InStr(ref, "http://" & strlocalSite)
        If liveSite > 0 Or localSite > 0 Then fileOK = True

        If Not fileOK Then
' normally, I'd be checking to see if the user was logged in
' and then send them to a login page, but I just don't have
' the budget for that right now.  so....
            context.Response.Write("THIS IS A SECURE FILE")
            Exit Sub
        End If

        f = context.Request.Path.Substring(context.Request.Path.LastIndexOf("/") + 1)
        filePath = context.Request.PhysicalPath

        Dim strContentType As String
        Dim extension As String = context.Request.Path.Substring(context.Request.Path.LastIndexOf(".") + 1)
        strContentType = mimes.getContentType(extension)

        Try

            Dim file As New FileInfo(filePath)
            Dim len As Integer = file.Length

            context.Response.Clear()
            context.Response.AddHeader("Content-Disposition", "inline; filename=" & file.Name)
            context.Response.AddHeader("Content-Length", file.Length.ToString())
            context.Response.ContentType = strContentType
            context.Response.WriteFile(file.FullName)

            Try
                context.Response.End()
            Catch ex As Exception

            End Try

        Catch ex As Exception

            context.Response.Write("FILE DOES NOT EXIST")
            Exit Sub
        End Try

    End Sub

    Public ReadOnly Property IsReusable() As Boolean Implements IHttpHandler.IsReusable
        Get
            Return False
        End Get
    End Property

End Class
Class contentTypes
    Dim _types As New StringDictionary
    Sub New()
        makeKeys()
    End Sub
    Public ReadOnly Property getContentType(myExtension As String) As String
        Get

            Return _types.Item(myExtension)

        End Get

    End Property
    Sub makeKeys()

        _types.Add("acx", "application/internet-property-stream")
        _types.Add("ai", "application/postscript")
        _types.Add("aif", "audio/x-aiff")

      '---- a whole bunch more mime types here -----'

        _types.Add("z", "application/x-compress")
        _types.Add("zip", "application/zip")

    End Sub

End Class

Now, that file I stick into my app_code directory and I can then reference it by putting it in my web.config file.

it needs to be in two spots:

 <system.web>
     <httpHandlers>
			<add verb="*" path="/client_files/*" type="secureDocs" />
			<add verb="*" path="/someOtherDirectory/*" type="secureDocs" />
      </httpHandlers>
  </system.web>

And you’re also going to need to tell the server that you don’t care what the file is, but you absolutely MUST kick off aspnet when you are in the
directories where these files are. Otherwise, IIS will see .doc or .xls and just give it to them without hitting your handler.

	<system.webServer>
		<handlers>
			<add name="sd" path="client_files/*" verb="*" modules="IsapiModule"
				 scriptProcessor="C:\windows\Microsoft.NET\Framework64\v4.0.30319\aspnet_isapi.dll" resourceType="Unspecified"
				 preCondition="classicMode,runtimeVersionv4.0,bitness64" />
		</handlers>
	</system.webServer>

HOWEVER…. If you run a shitty old server that still has IIS 6.0 on it, this latter module doesn’t work.

You need to open IIS on the server, hit the properties for your website, go to “home direc

Here is a example of a parameterized thread

First, you make a nice class to hold your parameters:

    Class mailParams
        Public mTo As String
        Public mFrom As String
        Public subject As String
        Public body As String
        Public attachmentMemoryStream As MemoryStream
        Public attachmentFileName As String
        Public archiveFile As String
    End Class

Then we have a subroutine attached to a button that does a fire-and-forget email. Basically, it just says, “send that..” and continues to process the page. You get refreshed practically instantly.

protected sub btnSendMail_OnClick(sender as object, e as eventargs) handles btnSendMail.click

    Dim objMailParams As New mailParams
    objMailParams.mTo = strTo
    objMailParams.mFrom = strFrom
    objMailParams.subject = strSubject
    objMailParams.body = strMessage

     Dim asyncMailObj As New System.Threading.ParameterizedThreadStart(AddressOf sendAnEmail)
     Dim t As New System.Threading.Thread(asyncMailObj)
     t.Start(objMailParams)

end sub

That ParameterizedThreadStart simply assigns a CPU thread to kick off the subroutine “sendAnEmail”. I preloaded the class of parameters and used the entire class as a single object parameter.

sub sendAnEmail(obj as object)
       Dim mp As mailParams = obj

        '===  I keep all my settings for mail and connection strings in a class called DataLayer.
        Dim myServer As New DataLayer.mailSettings

        Dim objMM As New MailMessage
        Dim objSMTP As New SmtpClient

        Dim m As New MailMessage()
        Dim mTo As New System.Net.Mail.MailAddress(mp.mTo)
        Dim mFrom As New System.Net.Mail.MailAddress(mp.mFrom)

        objMM.To.Add(mTo)
        objMM.From = mFrom
        objMM.IsBodyHtml = False
        objMM.Priority = MailPriority.Normal
        objMM.Subject = mp.subject
        objMM.Body = mp.body
        objSMTP.Host = myServer.smtpServer
        objSMTP.DeliveryMethod = SmtpDeliveryMethod.Network
        objSMTP.Credentials = New System.Net.NetworkCredential(myServer.smtpUser, myServer.smtpPassword)
        objSMTP.EnableSsl = False
        objSMTP.Send(objMM)

end sub

Now, this is a very simple example. The reason I started doing this is because I was generating PDF invoices by screen captures, then sending an archive of the PDF up to Amazon’s S3 storage, then emailing the pdf to the client. Some of the invoices were 20 pages long. The server can handle the workload, but people couldn’t handle the wait. So, fire-and-forget.

Later on, if it becomes a problem, I’ll see about putting in some kind of confirmation emails that say whether or not the invoice actually got sent.

If it becomes a server memory issue, I’ll update this post with whatever solution I came up with next!

Basically, if you leave the default namespace on the leading line of the XML doc, XPath queries don’t work.  They don’t error, they just don’t return anything.

http://support.microsoft.com/default.aspx?scid=kb;en-us;313372

Dim contents As String = reader.ReadToEnd()
'contents = contents.Replace("<!--?xml version=""1.0""?-->", "")
contents = System.Text.RegularExpressions.Regex.Replace(contents, "(^\s+)|(\s+$)|(\s+(?=\s.))", "")
contents = contents.Replace("> contents = contents.Replace(vbLf, "")
contents = contents.Replace("xmlns=""https://route53.amazonaws.com/doc/2010-10-01/""", "")

So, I got rid of the white spaces. I got rid of the line feeds and I removed their xmlns.

Suddenly, I could do this:

Dim xmlDoc As New Xml.XmlDocument
        xmlDoc.LoadXml(contents)
        Dim nodeList As Xml.XmlNodeList

        ' xmlDoc.SelectNodes("ListResourceRecordSetsResponse/ResourceRecordSets/ResourceRecordSet").Count
        Dim pattern As String = "ListResourceRecordSetsResponse/ResourceRecordSets/ResourceRecordSet"

nodeList = xmlDoc.SelectNodes(pattern)

And get a nice set of records. From there it was just a lot of grunt work to get it moving, but no more spending all day long trying to get past that idiotic empty recordset.

Thanks Microsoft.

Finally, if you have a large video, it is nice to be able to skip to the middle rather than sit around and wait for the entire thing to load.  Streaming servers take care of this problem for you.  Amazon’s CloudFront service is key.

Here’s a quick tutorial for how to do it.

So, nothing like a client emergency to try something brand-spankin’ new. I signed up and got to work. The first thing I discovered was that there is no gui. None. No nice module in the amazon console. Nada. You’ve got to make your own damn XML commands and there is a little perl script that will help you.

ugh…

Luckily, I know there are about a billion amazon api fiends out there who can’t help but put free stuff together and I found a great one: https://www.interstate53.com

So here’s how it works and how Interstate53 plays into it.

Amazon needs a secure connection using it’s access key pairs.  Then, once that is established, you can request records from the Route53 database.  Those requests for data and requests to make updates and get confirmations, all of that is done with little XML commands sent to Route53.  ”Interstate53″ simply provides a GUI so you don’t have to write the commands.

Sure, if you need to automate some things, you can get out your coding gloves and write up something using one of many APIs (which is what I did with S3).  However, I just wanted the benefit of a fast and stable DNS server.  Interstate53 handles it.

The first thing you see when you come to the page is the login.

You add your Access Key and your “Secret Key”.  Those come from your accounts page at Amazon: https://aws-portal.amazon.com/gp/aws/developer/account/index.html?ie=UTF8&action=access-key

On that accounts page, you can actually make an extra security key, just for this instance if you are concerned about security.  (I made one for this instance)  From what they say at Interstate53, it is just to perform the connection with amazon… which is what I do on my own server.  still…

Anyway, once you login, you see the domains you have registered with Amazon Route53:

It is pretty simple, just click “Add Zone”, a little popup appears asking for the new domain name.  You add it and it is then on the list.

Click on the domain name and then you’ll see all the details about it.

Then click to add a record:

You can see, there is every type of record available to you.  I’m just going to do an A record.

Hit save and that’s it…

oh.. no…  you’ve still got to hit “Accept Changes”, and then, that’s it…

Damn… not quite.  So, you might be tempted to hit “reload”, DON’T.  I know, seems like common sense, like you need to wait for the page to refresh…  no.  That means, “reload the data from Amazon right over all the stuff I just did”.

No, hover your mouse over the right hand column and you’ll see a new button appear

THAT will do it.  At this point, Interstate53 takes all your changes, wraps them up in a nice XML command package and sends it to Amazon.  Amazon then updates all the DNS servers, syncing them across the globe, and sends Interstate53 a nice confirmation.

Finally, you’re all set and your files are “Insync”

That’s it.  At least as far as the Amazon part is concerned.

To actually make the change live, just go to your domain registrar and change the name servers to the ones listed on the edit page for the domain.

So, it’s been a single day.  I can’t give you a really good judgment, but that’s what Interstate53 has for you and that’s how it works with Amazon.