Etikettarkiv: perl

Loopia lanserar domän-API

Från och med idag finns ett öppet programmeringssgränssnitt mot vår domänplattform, smidigt kallat LoopiaAPI. Snart sagt allt du kan göra i LoopiaDNS går nu att sköta via API-anrop. LoopiaAPI är ett XML-RPC-gränssnitt som idag öppnats för ett fåtal utvalda utvecklare. Under våren kommer API:t även att öppnas för allmänheten att använda till egna applikationer samt till de som vill erbjuda egna domäntjänster.

Fullständig dokumentation och kodexempel finns redan nu tillgängliga på loopia.se/api/. Är du intresserad av API:t och vill sätta dig in i hur det fungerar, tveka då inte att kika in på ovanstående adress. Där hittar du även information om hur du automatiskt blir informerad när tjänsten öppnar för alla.

Frågor och svar om LoopiaAPI 

Kan jag via API-anrop skapa ett LoopiaDNS-konto, registrera två domännamn, betala dessa och lägga upp 27 olika subdomäner?

– Ja. Betalning av domännamnen kan ske antingen med krediter från ens Loopia PrePAID-pott vilket innebär att allt sker helt automatiskt och att domännamnen skickas för omedelbar registrering. Det går dock även att begära ut en faktura för sedvanlig förskottsbetalning.

Kan jag skapa egna domänapplikationer som Loopia inte tänkt på?

– Självklart.

Om jag hittar på en tokbra domänfunktion och utvecklar denna med LoopiaAPI, kan denna då implementeras i Loopias kontrollpaneler?

– Med bra och värdefulla funktioner är vi givetvis inte främmande för detta. Däremot står det dig givetvis fritt att även på fri fot erbjuda din idé till allmänheten.

Kan jag skapa en white label-lösning så jag själv kan erbjuda registrering och hantering av domännamn.

– Visst kan du det, kan även vara ett tips för de nuvarande .SE-ombud som inte vill gå igenom den certifieringsprocess som det innebär att bli ackrediterad registrar.

Vilka domäntyper kan man registrera och administrera?

– Alla de domäntyper som Loopia säljer idag.

Har ni något litet kodexempel man kan få se?

– Visst har vi det, all dokumentation hittar du på loopia.se/api/, men nedan har vi klistrat in ett litet kodexempel som i Perl ansluter till vår XML-RPC-server, skapar ett LoopiaDNS-konto, registrerar en domän och lägger upp domänkonfiguration så all besökstrafik till domänen samt eventuella subdomäner går till IP-adressen 127.0.0.1.


#!/usr/bin/perl

use RPC::XML;
use RPC::XML::Client;
use Data::Dumper;

my $global_check_domain_server_url =
   'https://api.loopia.se/RPCSERV';

my $global_username = "YOUR_USERNAME";
my $global_password = "YOUR_PASSWORD";

my $client =
   RPC::XML::Client->new($global_check_domain_server_url);

$client->credentials("Loopia-API", $global_username,
   $global_password);

my $contact = {	"firstname" => "anders",
   "lastname" => "andersson",
   "company" => "loopia ab",
   "street" => "kopparlundsvägen 7b",
   "street2" => "",
   "zip" => 72130,
   "city" => "västerås",
   "country_iso2" => "se",
   "orgno" => "556633-9304",
   "phone" => "021-128222",
   "cell" => "",
   "fax" => "",
   "email" => "info@loopia.se" };

my $domain = "anderstestarapi" . `date +%s | tr -d "\n"` . ".se";
my $password = "generated_password_for_customer";

my $response =
   $client->simple_request('addDNSAccount', $domain, $password,
   $contact, $contact, $contact, RPC::XML::boolean->new(1),
   RPC::XML::boolean->new(1));

print "Account created: " . Dumper($response) . "\n\n";

$response = $client->simple_request('addSubdomain', $domain,
   $password, $domain, "\@");

print "Subdomain added: " . Dumper($response) . "\n\n";

$response = $client->simple_request('addZoneRecord', $domain,
   $password, $domain, "\@", { type => "A", "priority" => undef,
   "ttl" => "300", "rdata" => "127.0.0.1" });

print "Record added: " . Dumper($response) . "\n\n";

$response = $client->simple_request('addSubdomain', $domain,
   $password, $domain, "*");

print "Subdomain added: " . Dumper($response) . "\n\n";

$response = $client->simple_request('addZoneRecord', $domain,
   $password, $domain, "*", { type => "A", "priority" => undef,
   "ttl" =>"300", "rdata" => "127.0.0.1" });

print "Record added: " . Dumper($response) . "\n\n";
 

Har du något spännande förslag på funktion som kan skapas med ett sånt här API? Tveka inte att skriva en rad. 😉

Dela detta inlägg:

Snakes on a server

Ett av de kanske lite mer ovanliga språken vi har stöd för på Loopia är Python. Python är ett skriptspråk i likhet med exempelvis Perl eller PHP och är ett så kallat general purpose-språk. Detta innebär att Python kan användas till allt mellan himmel och jord. Python används bland annat av NASA, ILM och Astra Zeneca. Ett annat exempel är Eve Online, ett onlinespel, som använder en specialversion av Python (Stackless Python) till stor utsträckning.

Det som gör att jag gillar Python är flera saker. En prominent anledning är att det är så lätt att läsa Pythonkod. En annan anledning är att jag gillar funktionell programmering (tänk exempelvis LISP (SBCL), Haskell och Erlang) och Python har inslag av just det.

Nåväl, talk is cheap så nu är det hög tid för några exempel.

Databashantering

En kort exempel på databashantering (utan felhantering).

import MySQLdb

db = MySQLdb.connect("host", "user", "password", "database")
db_cursor = db.cursor()
db_cursor.execute("SELECT title FROM books")

row = db_cursor.fetchone()
count = 1
while row is not None:
     print count, row[0]
     count += 1
     row = db_cursor.fetchone()

db_cursor.close()
db.close()

Detta ger följande utmatning från min testdatabas:

1 Security Engineering: A Guide to Building Dependable ...
2 Secrets and Lies: Digital Security in a Networked World
3 Hackers and Painters: Essays on the Art of Programming

Sortering av en hash

Sortering av en hash (som heter dictionary i Python) på värdet istället för nyckeln:

data = {'a' : 2, 'b' : 1}
for key in sorted(data.keys(), lambda x, y: cmp(data[x], data[y])):
        print key, data[key]

Detta ger följande utmatning:

b 1
a 2

Annat spännande …

Andra attraktiva funktioner är filter(), map() och reduce(). Dessa används för att filtrera och sammanställa data. Ett något krystat exempel på detta är följande kodsnutt som filtrerar ut alla tal som är större än noll ur en lista, dela dessa med två och sedan summerar:

data = [6, 4, 8, -3, 5, -7]
bigger_than_zero = filter(lambda x: x > 0, data)
half = map(lambda x: x / 2.0, bigger_than_zero)
the_sum = reduce(lambda x, y: x + y, half)
print the_sum

Ger följande utmatning:

11.5

Det härliga med Python är förstås att allt detta kan skapas med endast en (1) rad kod. Denna är förvisso ganska lång och behöver därför radbrytas i detta exempel (med ett \-tecken).

print reduce(lambda x, y: x + y, map(lambda x: x / 2.0, \
filter(lambda x: x > 0, [6, 4, 8, -3, 5, -7])))

Utmärkta introduktioner för dig som programmerat tidigare och som tycker Python verkar intressant hittar du här och här. Lycka till!

Dela detta inlägg: