poll, ping, PubSub, pubsubhub, pubsubhubbub

06 september 2009 door Prashant · Reacties
Geplaatst onder: technologie

In het geval dat je sceptisch bent, is er een methode in de waanzin boven, in de titel van de post. In tech kringen is het niet waarschijnlijk dat je niet hebben gehoord van pubsubhubbub. In snelle paar maanden, is het een van de top drie gesproken over dingen. Andere twee zijn homomorfe encryptie en Google wave [ 1. ]. Terugkomend op de huidige post - termen in de titel aangeven hoe u de inhoud te krijgen van andere mensen. Naar aanleiding van informatie steeds meer duidelijk zijn, als je je voorstellen dat dingen gebeuren met betrekking tot blogs, ook al zijn ze conceptueel zijn niet beperkt tot blogs.

Polling verwijst naar het scenario waarin klanten blijven vragen van de server als er iets nieuw is gekomen. Hoe vaak om te vragen of er updates zijn zal altijd een probleem met polling te vaak of te onregelmatig, maar als een lezer wees hier dat een groot, ding met polling is dat de server niet hoeft te toestand te houden.

Ping heeft betrekking op het geval dat bij het plaatsen van een artikel, u (of uw software) werkt ook een aantal populaire (CV) Update Services. Wat achtergrond hier .

Vervolgens is PubSub wat staat voor publish / subscribe, een van de eerste plaats voor het werd gemaakt hier door Evan Henshaw-Plath en Kellan Elliott-McCrea (72 dia's, maar de moeite waard door). Dwingende voorbeeld gaven ze tegen was deze - op een bepaalde datum, FriendFeed kroop Flickr 2,9 miljoen keer om de nieuwste foto's van 45.754 gebruikers krijgen, waarvan er 6.721 waren Flickr bezocht in die 24 uur en kan 'potentieel' heeft een foto toegevoegd. Merk op dat wat ze voorgesteld, was niet een nieuwe technologie, omdat ze wijzen op 'revolutionaire nieuwe 20 jaar oude technologie'. Als je het voor blogs dan een van de grote problemen met xmpp - aanwezigheid van gegevens overhead, die kan oplopen tot 60-70% kan worden verminderd veel.

pubsubhub staat voor publiceren subscribe hub en pubsubhubbub is een protocol, Essentieel is dat idee van pubsubhub. Waarin uitgevers (zeg bloggers) bij te werken, die de naaf (kan meer dan een hubs, die met elkaar praten) woont 'ergens in de cloud', volgens het protocol dit kan duwen of trekken volgens het protocol, maar de volgende schakel in de keten, hub van de klant (laten we zeggen lezers) het altijd model te duwen. Deze pagina is goed uitgangspunt voor pubsubhubbub, overzicht dia's zijn goed. Ooit welsprekende Anil Dash beschrijft het hier als drukknop web.
Twee andere maal gelezen zijn webhooks die in feite http callbacks. GitHub gebruikt , dus doet paypal voor asynchrone kennisgevingen van betaling in IPN . Dat geldt ook voor vele anderen. Verwant begrip is rsscloud die weer is PubSub hub. Volg deze link voor meer informatie.

U vraagt ​​zich misschien af ​​wat is het punt van het schrijven van al deze hier, zijn er twee: 1. Deze dingen zijn de moeite waard te weten, minimaal op zijn minst en 2. Deze blog is pubsubhubbub nu ingeschakeld via appspot hub het gebruik van dit wordpress plugin en diervoeders te pubsubhubbub is ingeschakeld via FeedBurner, link hier
-
[ 1 ]. - Goede inleidende lezen voor volledig homomorfe encryptie is dit artikel van Bruce Schneier en dit gesprek is min of meer enige bron voor Google wave.

-UPDATE - Dit bericht wordt uitgelegd hoe de eis van de openbare server voor terugbellen kan worden gewerkt rond voor desktop clients via XMPP-gateway (voor pubsubhubbub).

Tags: , , ,

Een beetje van vergadering

29 augustus 2009 door Prashant · Reacties
Geplaatst onder: technologie

Na het lezen van dit artikel over lock vrij buffers en het zien van het gebruik van CAS (te vergelijken en te wisselen), voelde ik me net als het plaatsen van de assemblage-code om hetzelfde te doen. Gebruik geval daar was om een ​​eigen methode te schrijven en het noemen van Java (terug in 1.5, wanneer gelijktijdige datastructuren in Java waren min of meer ontbreekt). Zonder verdere omhaal, ik zal de code los te laten op je :) . De eerste is voor de CAS en de tweede is voor het berekenen van GCD met behulp van het algoritme van Euclides (deze is te vinden op vele plaatsen en tutorials ook).

Compileer en uitvoeren instructies gcc file_name.c ; ./a.out

Vergelijk en Swap 

   # Include 
  # Include 
 / / Uitwisseling - newValue, comperand is oud / verwachte waarde
 / *
  * Functie doet eigenlijk het volgende ding - als de waarde op * dest is gelijk aan dan oldvalue te vervangen door newValue anders laat het onveranderd: niet al deze atomair
  *
  * Er zijn twee opties voor de return waarde
  * 1.is initiële waarde van * dest en laat de last van de oproep FXN te vergelijken met oldval
  * 2.  doen het hier over en weer 0 of 1, moet dit efficiënter
  ** /

 / * Later veranderen in macro * /
 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 resultaat = 1 ;/ * 1 laat zien dat cas geslaagd en 0 geeft aan dat het * niet /
	 / * Btw moeten cc voor vlag verpesten!  * /
	 __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" / * moet LOCK op dezelfde lijn * /
			 "JZ GEDAAN \ n \ t"
			 "Movl $ 0,% 1 \ n \ t"
			 "DONE: \ n \ t"
			 : "= M" (DEST), "= g" (resultaat)
			 : "G" (oldvalue), "G" (newValue), "m" (DEST)
			 "% Eax", "% ebx", "ecx", "cc"
			 );
	 printf ("(% d,% d,% d)", * DEST, oldvalue, newValue);
	 terug te keren resultaat;
 }

 / * TODO
  * Schrijf een andere asm FXN die hierboven FXN zet in de zoveel tijd loop en blijf proberen, tenzij het lukt * /

 int main () {
	 int a = 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 ("veranderende waarde van * c om% 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));
	 return 0;
 }

Opmaak van nota's - lijkt wp syntax highlighter is het toevoegen van op het einde, negeren dat.

GCD 

 # Include 
 int ggd (int a, int b) {
     int resultaat;
     / * Compute Grootste gemene deler met behulp van het algoritme van Euclides * /
     __asm__ __ volatile__ ("movl% 1,%% eax;"
                           "Movl% 2,%% ebx;"
                           "Vervolg: cmpl $ 0,%% ebx;"
                           "Je gedaan;"
                           "Xorl%% edx,%% edx;"
                           "Idivl%% ebx;"
                           "Movl%% ebx,%% eax;"
                           "Movl%% edx,%% ebx;"
                           "Jmp Vervolg;"
                           "DONE: movl%% eax,% 0;": "= g" (resultaat): "g" (a), "G" (b)
     );

     terug te keren resultaat;
 }

 int main () {
     int eerste, tweede;
     printf ("Geef twee gehele getallen:");
     scanf ("% d% d", & eerste en tweede);

     printf ("GCD van% d &% d is% d \ n", eerste, tweede, ggd (eerste, tweede));

     return 0;
 }

Tags: , , , ,

robijn One Liners te creëren hash

20 augustus 2009 door Prashant · Reacties
Geplaatst onder: technologie

Gisteren terwijl er door een van mijn oude programma's, vond ik deze door mij geschreven eens weer:

#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

Om enkele van spanning te doden laat me onthullen dat raw_text lijkt

, Rechts het is gesneden uit PayPal-betaling bevestiging.

Boven regel als gebroken in delen leest beter: 

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

Laten we de afzonderlijke stappen in irb: 

  IRB (hoofd):. 009:0> unescaped_array = CGI.unescape (raw_text) split ('&')    

 => ["SUCCES", "mc_gross = 10,00", "protection_eligibility = niet in aanmerking", "payer_id = U7PPJJ4TSJ47E", "belasting = 0.00", "payment_date = 09:45:30 10 juli 2009 PDT", "payment_status = In afwachting van "]                                                                         

 IRB (hoofd): 013:0> unescaped_array = unescaped_array.map {| x | b = x.split ("="); b.push (nihil) als b.size == 1, b}  

 => [["Succes", nihil], ["mc_gross", "10,00"], ["protection_eligibility", "niet in aanmerking"], ["payer_id", "U7PPJJ4TSJ47E"], ["belasting", "0.00"] , ["payment_date", "09:45:30 10 juli 2009 PDT"], ["payment_status", "In afwachting van"]]                               

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

 => ["Succes", nihil, "mc_gross", "10,00", "protection_eligibility", "niet in aanmerking", "payer_id", "U7PPJJ4TSJ47E", "belasting", "0.00", "payment_date", "09:45: 30 juli 10 2009 PDT "," payment_status "," In afwachting van "]
 IRB (hoofd): 015:0>
 hash = Hash [* flattened_array]
 => {"Belasting" => "0.00", "payment_status" => "In afwachting van", "payer_id" => "U7PPJJ4TSJ47E", "mc_gross" => "10,00", "SUCCES" => nihil, "payment_date" = > "09:45:30 10 juli 2009 PDT", "protection_eligibility" => "niet in aanmerking"}

BTW, wordt genoemd * splat operator in robijn

Een andere manier om te creëren hash van 'array van paren' is om te injecteren gebruiken: 

  hash = [[1,2], [3,4]] injecteren ({}). {| resultaat, element | resultaat [element.first] = resultaat [element.last]; resultaat}

Er is nog een manier :) Schrijf een lus, die ik laat als oefening voor de lezers!

Hier is een beetje los use case van het creëren van hash van arrays: 

  IRB (hoofd): 005:0> [1,2,3,4,7,9] group_by {| x | x <5.?  : Mindere :: groter}

 => {: Minder => [1, 2, 3, 4]: groter => [7, 9]}

Je kan meer dingen, voornamelijk door het blok wordt gebruikt als sleutel voor dat element in de resulterende hash.

Tags: , ,

gmail, mutt en msmtp fix

17 augustus 2009 door Prashant · Reacties
Geplaatst onder: technologie

Als u mutt en smtp om Gmail te openen. Hier is een (slechte) nieuws. Cool jongens op Google opnieuw gewijzigd certificaat. Oh, heb je vragen - hoe kan het kennen? Eenvoudige mutt begonnen te klagen over de slechte certificaat wanneer het proberen om msmpt, beruchte gebruik van 'msmtp: TLS-certificaat verificatie mislukt:. Het certificaat heeft nog een bekende uitgever' begroette me op het scherm.

Om te bevestigen over te steken -
Start gewoon na

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

In plaats van oude Thawte Server Nu krijg je volgen in emittent segment
Issuer:
Common Name: Google Internet Authority
Organization: Google Inc
Country: US

Gelukkig fix is ​​simpel, hier is wat je moet doen op debian

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

Na dit gewoon volgende regel te veranderen in je op ~ /. 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

naar

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

Tags: , , ,

Samenvoegen hashes in YAML conf bestanden

31 juli 2009 door Prashant · Reacties
Geplaatst onder: technologie

YAML is heel handig voor het schrijven van configuratiebestanden. Primair voordeel is dat, het leest als tekstbestand. Dit werkt echt goed als je config bestand is plat (geen hiërarchie) en heeft geen herhalingen.
Als uw configuratie bestand herhalingen dan is het zinvol deze te scheiden van die elementen en ze opnieuw te gebruiken. Wat ik bedoel is dit - laten we zeggen dat je je config bestand ziet er als volgt uit: 

  ontwikkeling:
   input_location: common_input
   output_location: dev_location
   mail:
     smtp_server: uw_server
     login: your_login
     wachtwoord: top_secret
 productie:
   input_location: common_input
   output_location: dev_location
   mail:
     smtp_server: uw_server
     login: your_login
     wachtwoord: top_secret

Ervan uitgaande dat bovenstaande code in / tmp / test.yml hier is hoe je kunt lezen in Python en Ruby
$cat readyml.py 

 #! / Usr / bin / env python
 van pprint import pprint als pp
 # In debian moet python-yaml te installeren
 van yaml import belasting, load_all, dump
 hash = belasting (open ("/ tmp / test.yml '))
 pp (hash ['ontwikkeling'])


$ cat readyml.rb 

  #! / Usr / bin / env ruby
 require 'pp'
 hash = YAML :: load (File.open ('/ tmp / test.yml'). lezen)
 pp hash ['ontwikkeling']

Hier is een handige one-liner voor Ruby versie
$ ruby -rpp -e 'pp YAML::load(File.open("/tmp/a.yml"))["development"]' of u kunt hetzelfde proberen in irb of python console.

Merk op dat in het bovenstaande stukje code, alles is anders dan uitvoerlocatie hetzelfde is in ontwikkeling en productie deel. Dit is waar yml node identifier komt te redden is. Idee is simpel beschikken over een set van standaard waarden en ze op andere plaats te overschrijven.
Je zou kunnen trek het uit elkaar als volgt: 

  standaard: & defaults
   input_location: common_input
   output_location: dev_location
   mail:
     SENDER_NAME: afzender
     smtp_server: uw_server
     login: your_login
     wachtwoord: top_secret
 ontwikkeling:
   <<: * Standaard
 productie:
   <<: * Standaard
   output_location: prod_location


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

Geweldig, het werkt (tm)!.
Ongetwijfeld hebben we geruild enige duidelijkheid voor een beetje magie. Hier is een kleine uitleg: &, * en <<: & dat is ankertag kan worden opgevat als node identifier, * is knooppunt referentie-en <<: staat voor hash samenvoegen.

Voor meer details zie ofwel yaml specs of wikipedia
Tot nu toe zo goed, maar er is hier een vangst, deze hash fuseert zijn niet recursief. Wat het betekent is dit: stel dat u verschillende afzender naam hebben voor de post in twee omgevingen, kunt u in de verleiding komen het volgende doen: 

  standaard: & defaults
   input_location: common_input
   output_location: dev_location
   mail:
     SENDER_NAME: afzender
     smtp_server: uw_server
     login: your_login
     wachtwoord: top_secret
 ontwikkeling:
   <<: * Standaard
   mail:
     SENDER_NAME: sender_dev
 productie:
   <<: * Standaard
   output_location: prod_location
   mail:
     SENDER_NAME: sender_prod

Laten we bekijken

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

Oeps, er ging iets mis, probleem zoals hierboven vermeld is dat de hash samenvoegen niet recursief is en bij het samenvoegen van deze vervangen mail in gebreke per post van de productie die op een sleutel heeft. Oplossing / werk in de buurt is om uitgerold nog een niveau: 

  common_settings: & common_settings
 input_location: common_input
 output_location: dev_location
 mail_defaults: & mail_defaults
  SENDER_NAME: afzender
   smtp_server: uw_server
   login: your_login
   wachtwoord: top_secret

 standaard: & defaults
   << * Common_settings
   mail:
     << * Mail_defaults
 ontwikkeling:
   <<: * Standaard
 productie:
   <<: * Standaard
   mail:
     << * Mail_defaults
     SENDER_NAME: sender_prod

Laten we controleer opnieuw

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

Heb je zeggen dat je nog een niveau van nesting, goed je kan zeker uitrollen nog een niveau, maar dan wordt het een puinhoop. Dus, als je niet probeert om oplossing voor Torens van Hanoi in een conf bestand te schrijven, is het beter om conf bestand restucture dan graven in yaml of iets anders. Maar dat is uw oproep toch.

Tags:

Een beetje shell redirection

10 mei 2009 door Prashant · Reacties
Geplaatst onder: technologie

Hier is hoe we normaal gesproken shell redirection te doen
$ ./pgm.sh args >out.txt 2>err.txt
Ik wilde het een beetje te wijzigen en uit te voeren als volgt
$ ./pgm.sh args
met de eis dat de output en error moet gaan om een ​​aantal bestandsnaam berekend binnen pgm.sh op basis van args. Een illustratief geval zou zijn wanneer de datum is een onderdeel van args. Dus u wilt stdout te gaan om te zeggen / uw / directory / pgm_out_YYYYMMDD.txt 1

Het probleem met standaard manier van omleiden van N>file.txt dat wil zeggen, associëren file descriptor N tot bestand.txt, is dat het werkt alleen voor de nieuw gevorkte proces en niet voor het huidige proces.
zo
$ echo hi 1>out.txt ; echo hii . zal hi te sturen naar out.txt maar zal HII afdrukken naar stdout 2

Dit is waar exec komt ons te hulp. Als we exec 1>somefile.txt dan uitgang van de rest van het script gaat naar somefile.txt

$ cat test.sh
#!/usr/bin/env bash
exec 1>out.txt
echo hi
echo hii
$. / Test.sh zal hi omleiden en HII out.txt

Net als stdout en stderr omleiden we iets doen als dit
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 weer terug naar oorspronkelijke punt van om te leiden naar een bestand vanuit de shell, laten we zeggen-programma berekend de bestandsnaam in sommige variabele OUTFILE, kunnen we zojuist hebben gedaan exec 1>$OUTFILE

Dat lost het huidige probleem. Maar je kunt houden om te gaan door volgende voorbeeld waarin 'random access' van het bestand in de schaal script bereikt. Voorbeeld is van hier
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

Met opmerkingen, deze code is voor zichzelf.
-
1 Het kan ook worden gedaan door $ ./pgm.sh args >pgm_out`date +%Y%m%d` , maar idee is het bestand deze naam te genereren op basis van enkele logica in het programma zelf.
2 1 op 1> out.txt is overbodig, maar het verduidelijkt hier dat we fd 1 omgeleid

Tags: , ,

Op schaal of niet op schaal

11 januari 2009 door Prashant · Reacties
Geplaatst onder: technologie

Terwijl het over horizontale verdeling van databases, tuigpaard van ROR roem suggereert dat schaalvergroting spul kan zeker wacht, wacht tot het punt uw zakelijke behoeften nodig hebben. Zijn artikel is zeker zinvol voor kleine opstellingen zeggen startups. Niet om te zeggen dat in startups moet je demo programma's te schrijven, maar gezien het feit dat er maar 24 uren in een dag moet je richten op het bedienen zeggen 1000 gebruikers in meer voldoening manier dan het verliezen van je slaap dan zorgen te maken over hoe wordt mijn aanvraag in behandeling belasting van 13,142 miljoen gebruikers. Als je die vele gebruikers zult u weten hoe op te schalen. Voor startups schaalbaarheid is een goed probleem om te lossen, maar een veel betere probleem om te hebben, ik bedoel elke opstart zou graag in de dit probleem!

In een ander gerelateerde artikel Jeremy Zawodny schrijft moet je niet afhankelijk van de heer Moore als u schaalbaarheid problemen.

Aangezien deze artikelen verwijzen naar de wet van Moore Ik kan het niet helpen, maar schrijven dat de wet van Moore moet een van de meest algemene wet in Computer Science. Van zijn oorspronkelijke voorspelling over transistor dichtheid, wordt deze wet nu aangehaald overal kom je exponentiële groei.

Tags: ,