FastCGI Haskell script to make use of Pandoc text conversion

Question

1. Motivation

I'm writing my own mini-wiki. I want to be able to easily convert from markdown to LATEX/HTML and vice versa. After some searching I discovered Pandoc, which is written in Haskell and that I could use the FastCGI module to run a Haskell program on my Apache server.

2. Problem/ Question

I'm not sure how to what protocol I should use to send my FastCGI script the input/output variables (POST/GET?) and how this is done exactly. Any ideas, suggestions, solutions?

3. Steps taken

3.1 Attempt

Here is what I've done so far (based on example code). Note, I have no experience in Haskell and at the moment I don't have too much time to learn the language. I'd just love to be able to use the pandoc text format conversion tool.

module Main ( main ) where

import Control.Concurrent
import Network.FastCGI
import Text.Pandoc

--initialize Variables/ functions
fastcgiResult :: CGI CGIResult
markdownToHTML:: String -> String

--implement conversion function
markdownToHTML s = writeLaTeX defaultWriterOptions {writerReferenceLinks = True} (readMarkdown defaultParserState s)    

--main action
fastcgiResult = do
    setHeader "Content-type" "text/plain"
    n <- queryString
    output $ (markdownToHTML n)

main :: IO ()
main = runFastCGIConcurrent' forkIO 10 fastcgiResult

This code reads the string after the question mark in the request url. But this is not a good solution as certain characters are omitted (e.g. '#' ) and spaces are replaced by "/20%".

Thanks in advance.

3.2 Network.CGI

Documentation found here. Under the heading "Input" there are a number of methods to get input. Which one is right for me?

Is it :

Get the value of an input variable, for example from a form. If the variable has multiple values, the first one is returned. Example:

query <- getInput "query"

So lets say I have a HTML POST form with name='Joe' can I grab this using getInput? And if so how do I handle the Maybe String type?

Answer 1

The fastCGI package is actually a extension of the cgi package, which includes the protocol types for receiving request data and returning result pages. I'd suggest using CGI to start with, and then move to fastCGI once you know what you are doing.

You might also want to look at this tutorial.

Edit to answer questions about the tutorial:

"Maybe a" is a type that can either contain "Just a" or "Nothing". Most languages use a null pointer to indicate that there is no data, but Haskell doesn't have null pointers. So we have an explicit "Maybe" type instead for cases when the data might be null. The two constructors ("Just" and "Nothing") along with the type force you to explicitly allow for the null case when it might happen, but also let you ignore it when it can't happen.

The "maybe" function is the universal extractor for Maybe types. The signature is:

maybe :: b -> (a -> b) -> Maybe a -> b

Taking the arguments from front to back, the "Maybe a" third argument is the value you are trying to work with. The second argument is a function called if the third argument is "Just v", in which case the result is "f v". The first argument is the default, returned if the third is "Nothing".

In this case, the trick is that the "cgiMain" function is called twice. If it finds an input field "name" then the "mn" variable will be set to (Just "Joe Bloggs"), otherwise it will be set to (Nothing). (I'm using brackets to delimit values now because quotes are being used for strings).

So the "maybe" call returns the page to render. The first time through no name is provided, so "mn" is (Nothing) and the default "inputForm" page is returned for rendering. When the user clicks Submit the same URL is requested, but this time with the "name" field set, so now you get the "greet" function called with the name as an argument, so it says "Hello Joe Bloggs".