undersökning, ping, pubsub, pubsubhub, pubsubhubbub

September 6, 2009 av Prashant · Kommentarer
Filed under: teknik

Om du är skeptisk, det finns en metod i galenskapen ovan, i titeln på inlägget. I tech kretsar är det osannolikt att du inte har hört talas om pubsubhubbub. I snabba månaderna har det varit en av de tre pratade om saker. De två andra är homomorphic kryptering och Google wave [ 1. ]. För att återgå till nuvarande post - termer i titeln anger hur du får innehållet från andra människor. Följande uppgifter blir mer tydligt, om du tänka dig saker händer när det gäller bloggar, trots att de begreppsmässigt inte är begränsade till bloggar.

Polling avser scenario där kunderna frågar servern om något nytt har kommit upp. Hur ofta frågar efter uppdateringar kommer alltid att vara ett problem med polling alltför ofta eller för sällan, men som en läsare påpekade här att en stor, sak med polling är att servern inte behöver hålla staten.

Ping hänvisar till fall där då skicka en artikel, du (eller din programvara) också uppdateras några populära (central) uppdatering tjänster. Lite bakgrundsinformation här .

Nästa är pubsub som står för publicera / prenumerera en av de tidigaste pitch för den gjordes här av Evan Henshaw-Plath och Kellan Elliott-McCrea (72 bilder, men värt att gå igenom). Övertygande exempel de gav mot var detta - på ett visst datum, FriendFeed kröp Flickr 2,9 miljoner gånger för att få de senaste bilderna från 45,754 användare, varav 6.721 hade besökt Flickr i dessa 24 timmar och skulle ha "potentiellt" laddat upp en bild. Observera att vad de föreslog var inte en ny teknik, eftersom de pekar ut "revolutionerande nytt 20 år gammal teknik". Om du gör det för bloggar sedan ett av de största problemen med XMPP - Förekomst uppgifter overhead, som kan vara så hög som 60-70% kan minskas en hel del.

pubsubhub står för publicerar Prenumerera nav och pubsubhubbub är ett protokoll, kärna utgörs av idén om pubsubhub. Där förlagen (säg bloggare) uppdatera navet som (kan vara mer än en nav, som talar med varandra) finns "någonstans i molnet", enligt protokollet detta kan skjuta eller dra enligt protokollet, men nästa länk i kedjan, navet klient (säg läsare) att det alltid är tryck-modellen. Denna sida är bra utgångspunkt för pubsubhubbub, översikt bilderna är bra. Ända vältaliga Anil Dash beskriver det här som tryckknapp webben.
Två andra relaterade läsningar är webhooks vilket i grunden http återbesök. Github använder det, så gör paypal för asynkrona meddelanden om betalning IPN . Så gör många andra. Relaterad Konceptet rsscloud vilket återigen är pubsub nav. Följ den här länken för mer information.

Du kanske undrar vad är det för mening att skriva alla dessa här, finns det två 1. Dessa saker är värt att veta, minimalt minst och 2. Denna blogg är pubsubhubbub aktiverat nu via appspot hub med denna wordpress plugin och foder är också pubsubhubbub aktiveras via FeedBurner, länk här
-
[ 1 ]. - Bra inledande läsa för fullt homomorphic kryptering är här artikel av Bruce Schneier, och det tal är mer eller mindre enda källan till Google Wave.

-UPDATE - Det här inlägget förklarar hur kravet på allmän server för återuppringning kan bearbetas runt för stationära klienter genom att använda XMPP gateway (pubsubhubbub).

Taggar: , , ,

Lite av enheten

29 augusti 2009 med Prashant · Kommentarer
Filed under: teknik

Efter att ha läst den här artikeln om Lock gratis buffertar och ser användning av CAS (jämför och swap), kände jag mig som att publicera den assemblerkod att göra detsamma. Använd fall över det var att skriva en alternativ metod och kallar det från Java (tillbaka i 1,5, då samtidiga datastrukturer i Java var mer eller mindre obefintlig). Utan vidare, jag släppa loss koden på dig :) . Första är för CAS och andra är för beräkning GCD använda Euklides algoritm (detta kan hittas på många ställen och handledning samt).

Kompilera och köra instruktionerna gcc file_name.c ; ./a.out

Jämför och Swap 

   # Include 
  # Include 
 / / Exchange - newValue är comperand gamla / förväntat värde
 / *
  * Funktion faktiskt gör följande sak - om värdet på * dest är lika med oldvalue sedan ersätta den med newValue annars lämna den oförändrad: inte alla dessa Atomically
  *
  * Det finns två alternativ för returvärde
  * 1.is initiala värdet av * dest och lämna bördan att kalla fxn att jämföra den med oldval
  * 2.  gör det hit och returnera 0 eller 1, bör detta vara effektivare
  ** /

 / * Senare ändrar det till makro * /
 int cas (int * dest, int oldvalue, int newValue) {
	 printf ("(% d,% d,% d)", * DEST, oldvalue, newValue);
	 / * Int CAS (int dest, int oldvalue, int newValue) {* /
	 / * Int CAS (int dest, int newValue, int oldvalue) {* /
	 int result = 1 ;/ * 1 visar att CAS lyckades och 0 visar att det misslyckades * /
	 / * BTW behöver sätta cc för flagga dunkardags!  * /
	 __asm__ __ volatile__ (
			 "MOVL% 2,%% EAX \ n \ t"
			 "MOVL% 3,%% EBX \ n \ t"
			 "MOVL% 0,%% ECX \ n \ t"
			 "LOCK \ n \ t"
			 "CMPXCHG EBX%% (%% ECX) \ n \ t" / * bör låset på samma linje * /
			 "JZ görs \ n \ t"
			 "MOVL $ 0,% 1 \ n \ t"
			 "KLART: \ n \ t"
			 : "= M" (DEST), "= g" (resultat)
			 : "G" (oldvalue), "g" (newValue), "m" (dest)
			 : "% EAX", "% ebx", "ECX", "CC"
			 );
	 printf ("(% d,% d,% d)", * DEST, oldvalue, newValue);
	 RETURN RESULT;
 }

 / * TODO
  * Skriva en annan asm fxn som sätter ovan fxn i en while-slinga och fortsätta att försöka om det inte lyckas * /

 int main () {
	 int en = 5, b = 6;
	 int * c = (int *) malloc (sizeof (int));
	 * C = 6;
	 / * Int c = 6, * /
	 printf ("% d \ n", CAS (c, b, b));
	 printf ("% d \ n", CAS (c, b, a));
	 printf ("% d \ n", CAS (c, a, a));
	 printf ("% d \ n", CAS (c, b, b));
	 * C = 6;
	 / * C = 5, * /
	 printf ("ändra värdet * c till% d \ n", * c);
	 printf ("% d \ n", CAS (c, b, b));
	 printf ("% d \ n", CAS (c, b, a));
	 printf ("% d \ n", CAS (c, a, a));
	 printf ("% d \ n", CAS (c, a, b));
	 printf ("% d \ n", CAS (c, b, a));
	 returnera 0;
 }

Formatera anteckningar - verkar som att WP syntax highlighter är att lägga till i slutändan, ignorera det.

GCD 

 # Include 
 int gcd (int a, int b) {
     int resultat;
     / * Beräkna största gemensamma nämnaren att använda Euklides algoritm * /
     __asm__ __ volatile__ ("MOVL% 1,%% EAX,"
                           "MOVL% 2,%% EBX;"
                           "Forts: cMpl 0 $,%% EBX;"
                           "Je KLAR;"
                           "Xorl%% EDX,%% EDX,"
                           "Idivl%% EBX;"
                           "MOVL%% EBX,%% EAX,"
                           "MOVL%% EDX,%% EBX;"
                           "JMP forts,"
                           "KLAR: MOVL%% EAX,% 0;" "= g" (Resultat): "g" (en), "g" (b)
     );

     RETURN RESULT;
 }

 int main () {
     int första, andra;
     printf ("Ange två heltal:");
     scanf ("% d% d", & första, och andra);

     printf ("GCD av% d &% d är% d \ n" första, andra, gcd (första, andra));

     returnera 0;
 }

Taggar: , , , ,

ruby ett foder för att skapa hash

20 augusti 2009 med Prashant · Kommentarer
Filed under: teknik

Igår samtidigt gå igenom en av mina gamla program, jag hittade den här skriven av mig någon gång tillbaka:

#begin magic
hash=Hash[*CGI.unescape(raw_text).split('&').map{|x| b=x.split("=");b.push(nil) if b.size==1;b}.flatten]
#end magic

Att döda några av spänning låt mig avslöja att raw_text ser ut

, Höger har skurits från PayPal betalning bekräftelse.

Ovanför linjen om bryts i delar lyder bättre: 

  unescaped_array = CGI.unescape (raw_text). Split ('&')
   unescaped_array = unescaped_array.collect {| x | b = x.split ("="); b.push (noll) vid b.size == 1, b}
   flattened_array = unescaped_array.flatten
   hash = Hash [* flattened_array]

Låt oss göra enskilda stegen i IRK: 

  IRB (huvud):. 009:0> unescaped_array = CGI.unescape (raw_text) Split ('&')    

 => ["Success", "mc_gross = 10,00", "protection_eligibility = Obehörig", "payer_id = U7PPJJ4TSJ47E", "skatt = 0,00", "payment_date = 09:45:30 Jul 10, 2009 PDT", "payment_status = väntan "]                                                                         

 IRB (huvud): 013:0> unescaped_array = unescaped_array.map {| x | b = x.split ("="); b.push (noll) om b.size == 1, b}  

 => [["Success", noll], ["mc_gross", "10,00"], ["protection_eligibility", "Obehörig"], ["payer_id", "U7PPJJ4TSJ47E"], ["skatt", "0,00"] , ["payment_date", "09:45:30 Jul 10, 2009 PDT"], ["payment_status", "I väntan"]]                               

 IRB (huvud): 014:0> flattened_array = unescaped_array.flatten     

 => ["Success", noll, "mc_gross", "10,00", "protection_eligibility", "Obehörig", "payer_id", "U7PPJJ4TSJ47E", "skatt", "0,00", "payment_date", "09:45: 30 Jul 10, 2009 PDT "," payment_status "," I väntan "]
 IRB (huvud): 015:0>
 hash = Hash [* flattened_array]
 => {"Skatt" => "0,00", "payment_status" => "I väntan", "payer_id" => "U7PPJJ4TSJ47E", "mc_gross" => "10,00", "Success" => noll, "payment_date" = > "09:45:30 Jul 10, 2009 PDT", "protection_eligibility" => "Obehörig"}

BTW, är * kallas splat operatören i ruby

Ett annat sätt att skapa hash från "array av par" är att använda injicera: 

  hash = [[1,2], [3,4]] injicera ({}). {| Resultat, element | Resultat [element.first] = resultat [element.last]; resultat}

Det är ytterligare ett sätt :) Skriv en slinga, som jag lämnar som en övning för läsarna!

Här är lite obesläktad användningsfall för att skapa hash från matriser: 

  IRB (huvud): 005:0> [1,2,3,4,7,9] group_by {| x | x <5.?  : Mindre :: större}

 => {: Mindre => [1, 2, 3, 4],: större => [7, 9]}

Du kan göra fler saker, i princip resultatet av blocket används som nyckel för det elementet i den resulterande hash.

Taggar: , ,

gmail, mutt och msmtp fix

17 aug 2009 av Prashant · Kommentarer
Filed under: teknik

Om du använder mutt och SMTP få tillgång till Gmail. Här är en (dålig) nyheter. Coola killar på Google ändras igen certifikat. Åh, har du frågar - hur gör det veta det? Enkel mutt började klaga på dåliga certifikat när du försöker använda msmpt, ökända "msmtp: TLS Kontrollen misslyckades:. Intyget har inte fått en känd emittentens hälsade på mig på skärmen.

Korsa bekräfta -
Bara köras efter

$ msmtp --serverinfo --host=smtp.gmail.com --tls=on --port=587 --tls-certcheck=off

I stället för gamla Thwate Server nu får du följa i emittenten segment
Issuer:
Common Name: Google Internet Authority
Organization: Google Inc
Country: US

Lyckligtvis fix är enkelt, här är vad du behöver göra på Debian

# apt-get install ca-certificates
# dpkg -s ca-certificates|grep Version
Version: 20090814

Efter detta bara ändra följande rad i dig ~ för /. Msmtprc

tls_trust_file /certs/Thawte SSLWeb Server Roots/thawte Premium Server CA/Thawte Premium Server CA.pem

tls_trust_file /certs/Thawte SSLWeb Server Roots/thawte Premium Server CA/Thawte Premium Server CA.pem

till

tls_trust_file /usr/share/ca-certificates/mozilla/Equifax_Secure_CA.crt

Taggar: , , ,

Sammanfoga hashes i yaml conf-filer

31 Juli 2009 med Prashant · Kommentarer
Filed under: teknik

Yaml är ganska praktiskt för att skriva konfigurationsfiler. Primär fördel är att, läser det som textfil. Detta fungerar riktigt bra om din konfigurationsfil är platt (ingen hierarki) och har inga repetitioner.
Om konfigurationer filen har repetitioner då är det logiskt att skilja ut dessa element och återanvända dem. Vad jag menar är - låt oss säga att du din konfigurationsfil ser ut så här: 

  utveckling:
   input_location: common_input
   output_location: dev_location
   mail:
     smtp_server: Your_Server
     login: your_login
     Lösenord: top_secret
 produktion:
   input_location: common_input
   output_location: dev_location
   mail:
     smtp_server: Your_Server
     login: your_login
     Lösenord: top_secret

Förutsatt ovanstående kod i / tmp / test.yml här är hur du kan läsa i Python och Ruby
$cat readyml.py 

 #! / Usr / bin / env python
 från pprint import pprint som pp
 # I debian behöver du installera python-yaml
 från yaml import belastning, load_all, dumpa
 hash = last (open ("/ tmp / test.yml '))
 PP (hash ["utveckling"])


$ cat readyml.rb 

  #! / Usr / bin / env ruby
 kräver "PP"
 hash = yaml :: last (File.open ('/ tmp / test.yml). läsa)
 PP hash ["utveckling"]

här är en praktisk en liner för Ruby version
$ ruby -rpp -e 'pp YAML::load(File.open("/tmp/a.yml"))["development"]' eller så kan du prova samma sak i IRB eller python konsol.

Notera att i ovanstående kodsträngen är allt annat än produktionen placering är densamma i utveckling och produktion del. Det är där yml nodidentifieraren kommer att rädda. Idén är enkel har en uppsättning standardvärden och åsidosätter dem på annan plats.
Du kan dra isär enligt följande: 

  defaults: & standard
   input_location: common_input
   output_location: dev_location
   mail:
     SENDER_NAME: avsändare
     smtp_server: Your_Server
     login: your_login
     Lösenord: top_secret
 utveckling:
   <<: * Standard
 produktion:
   <<: * Standard
   output_location: prod_location


$ ruby -rpp -e 'pp YAML::load(File.open("/tmp/a.yml"))["development"]["mail"]["login"]'
"your_login"
$

Bra, det fungerar (tm)!.
Förmodligen har vi handlas viss klarhet för lite magi. Här är ett litet förklaring: &, * och <<: & som är ankartaggen kan förstås som nod identifierare, är * nod referens och <<: står för hash kopplingen.

För mer information se antingen yaml specifikationer eller wikipedia
Så långt så bra men det finns en hake här, dessa hash smälter samman är inte rekursiva. Vad det betyder är detta: låt oss säga att du vill ha olika namn för avsändare post i två miljöer kan du frestas att göra följande: 

  defaults: & standard
   input_location: common_input
   output_location: dev_location
   mail:
     SENDER_NAME: avsändare
     smtp_server: Your_Server
     login: your_login
     Lösenord: top_secret
 utveckling:
   <<: * Standard
   mail:
     SENDER_NAME: sender_dev
 produktion:
   <<: * Standard
   output_location: prod_location
   mail:
     SENDER_NAME: sender_prod

Lets kontrollera

$ ruby -rpp -e 'pp YAML::load(File.open("/tmp/a.yml"))["development"]["mail"]["login"]'
nil
$

Oj, något gick fel, problem som nämnts ovan är att hash sammanslagning inte är rekursiv och medan slå ihop den utbytt post om standard per post av produktionen som har endast en nyckel. Lösning / arbete runt är att rulla ut en mer jämn: 

  common_settings: & common_settings
 input_location: common_input
 output_location: dev_location
 mail_defaults: & mail_defaults
  SENDER_NAME: avsändare
   smtp_server: Your_Server
   login: your_login
   Lösenord: top_secret

 defaults: & standard
   <<: * Common_settings
   mail:
     <<: * Mail_defaults
 utveckling:
   <<: * Standard
 produktion:
   <<: * Standard
   mail:
     <<: * Mail_defaults
     SENDER_NAME: sender_prod

Lets kontrollera igen

$ ruby -rpp -e 'pp YAML::load(File.open("/tmp/a.yml"))["development"]["mail"]["login"]'
"your_login"
$

Sa du att du har en större grad av häckande, och du kan definitivt rulla ytterligare en nivå, men sedan blir det en enda röra. Så, om du inte försöker skriva lösning torn Hanoi i en conf-fil, är det bättre att restucture conf fil än att gräva i yaml eller något annat. Men det är ditt samtal ändå.

Tags:

Lite skal omdirigering

10 Maj, 2009 av Prashant · Kommentarer
Filed under: teknik

Här är hur vi normalt gör skal omdirigering
$ ./pgm.sh args >out.txt 2>err.txt
Jag ville ändra det lite och kör enligt följande
$ ./pgm.sh args
med kravet att produktionen och fel bör gå till någon filename beräknas inne pgm.sh baserat på args. Man illustrativt fall kan vara när dagen är en del av args. Så du vill stdout gå att säga / din / katalog / pgm_out_YYYYMMDD.txt 1

Problemet med standardiserat sätt att styra N>file.txt dvs associera N filidentifierare till file.txt, är att det fungerar bara för den nyligen kluven processen och inte för den pågående processen.
så
$ echo hi 1>out.txt ; echo hii . skickar hej till out.txt, men kommer att skrivas ut hii till stdout 2

Det är där exec kommer till vår undsättning. Om vi lägger exec 1>somefile.txt sedan ut från resten av skriptet kommer att gå till somefile.txt

$ cat test.sh
#!/usr/bin/env bash
exec 1>out.txt
echo hi
echo hii
$. / Test.sh omdirigerar hi liksom hii att out.txt

Likaså att omdirigera stdout samt stderr vi göra något sånt här
cat test2.sh
exec 1>out.txt
exec 2>err.txt
echo out text
echo 1>&2 err text
somenoneexitent command
ls -ld /tmp

Nu kommer tillbaka till den ursprungliga punkten omdirigera viss fil från innanför skalet, låt oss säga program beräknas filnamnet i någon rörlig UTFIL kunde vi just har gjort exec 1>$OUTFILE

Som löser det aktuella problemet. Men du kanske vill gå igenom följande exempel som uppnår "random access" av filer i skalskript. Exempel är från här
echo 1234567890 > File # Write string to "File".
exec 3<> File # Open "File" and assign fd 3 to it.
read -n 4 <&3 # Read only 4 characters.
echo -n . >&3 # Write a decimal point there.
exec 3>&- # Close fd 3.
cat File # ==> 1234.67890

Med kommentarer, är denna kod självförklarande.
-
1 Det kan också göras genom $ ./pgm.sh args >pgm_out`date +%Y%m%d` men tanken är att skapa den här filen namn baserat på någon logik i själva programmet.
2 1 1> out.txt är överflödigt, men det klargörs här att vi omdirigerar FD 1

Taggar: , ,

Att skala eller inte skala

11 jan 2009 av Prashant · Kommentarer
Filed under: teknik

Medan de talar om horisontell partitionering av databaser, föreslår DHH av ROR berömmelse som skalning grejer kan vänta, definitivt vänta tills den punkt ditt företag behöver kräver det. Hans artikel ger definitivt vettigt för små uppställningar säga startup. Inte att säga att i startup du ska skriva demo program men med tanke på att det bara finns 24 timmar på en dag du bör fokusera på att betjäna säger 1000 användare i mer givande sätt än att förlora din sömn över att behöva oroa dig hur kommer min ansökan hanterar belastning på 13.142 tusen användare. Om du får de många användare som du vet hur man skala. För startup skalbarhet är ett bra problem att lösa, men en mycket bättre problem att ha, jag menar varje start skulle älska att springa på detta problem!

I en annan relaterad artikel Jeremy Zawodny skriver du bör inte vara beroende Mr Moore om du har skalbarhetsproblem.

Eftersom dessa artiklar hänvisar till Moores lag kan jag inte låta bli att skriva att Moores lag måste vara en av de mest generaliserade lag i datavetenskap. Från sin ursprungliga förutsägelse om transistor densitet, är denna lag nu angiven vart du stöter på exponentiell tillväxt.

Taggar: och