Virtuel høj kobling

Virtuel høj kobling er et begreb jeg kom til at opfinde i går. I alt sin enkelthed beskriver det den situation, hvor delprojekter begynder at opfinde afhænigheder til andre delprojekter, for at kunne forklare hvorfor de ikke selv har fremdrift.

Silvaplana See

Så er jeg kommet hjem efter en uges ferie ved Silvaplana See i Schweiz. Det var meningen vi skulle snowkite på søen hele ugen, men det blev kun til to dage, på grund af for lidt vind. Resten af dagene brugte vi i stedet på snowboard i skiterrænet ovenfor St. Morritz.

He shoulda surfed

They keep telling me jesus walked on water
He shoulda surfed

Ben Harper - Get It Like You Like It

Den mand kan spille spade og skrive tekster som få :-)

David Lynch iPhone commercial

Den her er da bare for morsom :-)

http://fakesteve.blogspot.com/2008/01/david-lynch-iphone-commercial.html

Hvem sagde 'misundelse er en grim ting'? ;-)

Yaws Del IV

Dette er den 4. post i en række af post's om Yaws. I denne post vil jeg prøve at lade et modul svare på et request.

Først skal der lige pilles lidt ved yaws.conf. ebin_dir sættes til at pege på en ny tom folder, f.eks.

ebin_dir = /Users/dalsgaard/lib/yaws/ebin

Dernæst skal der tilføjes følgende til server-direktivet

  appmods = myapp

(linien placeres mellem <server localhost> og </server>)

I ebin_dir-folderen placeres nu en fil med navnet myapp.erl, og med følgende indhold

-module(myapp).
-export([out/1]).

out(A) ->
  {html, "Hesten er et glubsk rovdyr!"}.

Filen skal nu compiles

$ erlc myapp.erl

Starter man Yaws, og peger en browser på URL'en http://localhost:8000/myapp/, så får man teksten Hesten er et glubsk rovdyr!

Det giver måske ikke så meget mening bare at bruge et module til at returnere almindelig html, men ønsker man f.eks at lave en service der returnere json giver det igen mening. Eksempelvis kan myapp.erl ændres til at returnere json på følgende vis

out(A) ->
  Json = "{firstName: 'Kim', lastName: 'Dalsgaard'}",
  {content, "application/json", Json}.

Denne nye service kan nu efterprøves ved hjælp af eksempelvis curl

$ curl http://localhost:8000/myapp/ -i

Da vi selvfølgelig gerne vil udstille en RESTful service, er det vigtigt at kende den del af url'en der skal bruges til at fremfinde resourcen. Denne er at finde i arg-recorden's pathinfo slot. For at vise dette kan myapp.erl ændres til følgende

-module(myapp).
-export([out/1]).
-include("/Users/dalsgaard/lib/yaws/include/yaws_api.hrl").

out(A) ->
  Req = A#arg.req,
  Method = Req#http_request.method,
  Path = A#arg.pathinfo,
  Json = io_lib:format("{method: '~s', path: '~s'}", [Method, Path]),
  {content, "application/json", Json}.

Hvor /Users/dalsgaard/lib/yaws/include/yaws_api.hrl skiftes ud med den valgte sti.

URL'en http://localhost:8000/myapp/customers/1/orders/2 giver nu svaret {method: 'GET', path: '/customers/1/orders/2'}.

I den kommende post vil jeg kigge på hvorledes pathinfo kan bruges til at vælge den rigtige controller og den rigtige action for der igennem at fremfinde den ønskede resource (ala. Rails routes). På gensyn snarest :-)

Yaws Del III

Dette er den trejde i rækken af post's om Yaws. Denne gang vil jeg kigge lidt på det argument man får med over i out/1.

Argumentet til out/1 er en record der er defineret i yaws_api.hrl. yaws_api.hrl er automatisk inkluderet når en side evalueres, så man kan bruge den normale record-notation uden yderligere tiltag.

Følgende eksempel viser hvordan man kan hente docroot (Yaws-instancens docroot) og fullpath (stien til den ramte .yaws-fil) ud af argumentet

out(A) ->
  {ehtml, [
    {ul, [], [
      {li, [], ["Doc Root: ", A#arg.docroot]},
      {li, [], ["Full Path: ", A#arg.fullpath]}]
    }]
  }.

Argumentet til out/1 indeholder også en record der beskriver det indkomne request.
Følgende eksempel viser hvordan man kan hente method og path ud af argumentet

out(A) ->
  Req = A#arg.req,
  {_, Path} = Req#http_request.path,
  Method = Req#http_request.method,
  {ehtml, [
    {ul, [], [
      {li, [], f("Request Method: ~s", [Method])},
      {li, [], f("Request Path: ~s", [Path])}]
    }]
  }.

Det er også muligt at hente headers fra argumentet. Følgende eksempel viser hvordan man kan hente headerne Accept og User-Agent

out(A) ->
  H = A#arg.headers,
  {ehtml, [
    {ul, [], [
      {li, [], f("Accept: ~s", [H#headers.accept])},
      {li, [], f("User Agent: ~s", [H#headers.user_agent])}]
    }]
  }.

Og så er det naturligvis også muligt at forespørge på parametre fra query-delene af URL'en. Følgende eksempel viser hvordan man kan beregne BMI på baggrund af parametrene height og weigth

out(A) ->
  Q = dict:from_list(yaws_api:parse_query(A)),
  {H, _} = string:to_integer(dict:fetch("height", Q)),
  {W, _} = string:to_integer(dict:fetch("weigth", Q)),
  {ehtml, [
    {h2, [], f("BMI: ~f", [W / math:pow(H / 100, 2)])}]
  }.

Hvis filen (inkl. html) er gemt som query.yaws, så vil URL'en http://localhost:8000/query.yaws?height=183&weigth=99 vise en side med indholdet BMI: 29.561946. Hvem sagde fede! ;-)

I næste post vil jeg se lidt på Yaws applications - Yapps, så på snarligt gensyn :-)

Yaws Del II

Dette er den anden post i en serie af post's om Yaws - en web-server skrevet i Erlang.

Denne post vil omhandle indlejring af Erlang-kode i html-sider.

Først skal Yaws sættes til at pege på en ny tom folder. Dette gøres ved at ændre docroot for server-direktivet i yaws.conf filen.

<server localhost>
  port = 8000
  listen = 0.0.0.0
  docroot = /Users/dalsgaard/var/yaws
</server>

Hvor /Users/dalsgaard/var/yaws erstattes med en tom folder efter eget valg.

Sider med indlejret Erlang skal ende på .yaws. I siden kan der indsættes en eller flere erl-tags, der hver indeholder en out/1-funktion. I det simpleste tilfælde returneres en tuple med atomet 'html' og en tekst, hvor teksten sættes ind i stedet for erl-tagget.

Opret filen index.yaws i den valgte docroot, og giv den følgende indhold

<html>
  <body>
    <erl>
      out(A) ->
        {html, "Hesten er et glubsk rovdyr!"}.
    </erl>
  </body>
</html>

URL'en http://localhost:8000 viser nu en side med teksten Hesten er et glubsk rovdyr! :-)

I stedet for at indsætte ren tekst, kan man også vælge at beskrive det output man ønsker vha. en Erlang struktur. Dette gøres ved at lade out/1 returnere en tuple med atomet 'ehtml' og et array af tupler der beskriver det ønskede output.

Opret filen hesten.yaws i den valgte docroot, og giv den følgende indhold

<html>
  <body>
    <erl>
      out(A) ->
        {ehtml, [
          {h3, [{class, "husdyr"}], "Hesten"},
          {p, [], [
            "Hesten er et ",
            {strong, [], "glubsk"},
            " rovdyr!"]
          }]
        }.
    </erl>
  </body>
</html>

URL'en http://localhost:8000/hesten.yaws viser nu en side med det nye indhold.

I næste post vil jeg se lidt på hvad man får med som argument til out/1 - på snarligt gensyn :-)