הסקר, פינג, pubsub, pubsubhub, pubsubhubbub

6 ספטמבר 2009 על ידי Prashant · תגובות
מתויק תחת: טכנולוגיה

במקרה שאתה סקפטי, יש שיטה בטירוף לעיל, בכותרת של ההודעה. בחוגים טק אין זה סביר כי לא שמעו על pubsubhubbub. בחודשים ספורים מהר, זה היה אחד מהשלושה למעלה דיבר על דברים. שתי האחרות היו הצפנה homomorphic וגוגל גל [ 1. ]. חוזר להודעה הנוכחית - תנאי בכותרת לציין כיצד אתה מקבל את התוכן מאנשים אחרים. הפרטים הבאים יתברר יותר, אם אתה מדמיין דברים קורה לגבי בלוגים, למרות שהם לא מושגית מוגבלת בלוגים.

הסקרים מתייחס לתרחיש שבו הלקוחות להמשיך לשאול שרת אם משהו חדש צץ. כמה פעמים לשאול אם יש עדכונים תמיד תהיה בעיה עם הסקרים תכופות מדי או תכוף מדי, אבל בתור אחד הקורא הצביע פה אחד דבר נהדר, עם הקלפי היא שהשרת לא צריך לשמור על המדינה.

פינג מתייחס למקרה בו כאשר לכתוב מאמר, אתה (או התוכנה) מעדכן גם כמה פופולרי (מרכז) Update Services. קצת רקע כאן .

הבא הוא pubsub אשר מייצג לפרסם / להירשם, אחד המגרש המוקדם נעשה כאן על ידי אוון Henshaw-פלאת Kellan אליוט-McCrea (72 שקופיות אבל שווה עוברים). דוגמא משכנעת שהם נתנו היה נגד זה - בתאריך מסוים, FriendFeed זחל פליקר 2.9 מיליון פעמים כדי לקבל את התמונות העדכניות של 45,754 משתמשים, מתוכם 6,721 ביקר Flickr באותם 24 שעות ויכול היה "פוטנציאל" להעלות תמונה. שים לב מה שהם הציעו לא טכנולוגיה חדשה, כפי שהם מציינים "טכנולוגיה מהפכנית חדשה 20 שנה". אם אתה עושה את זה על הבלוגים ואז אחת הבעיות הגדולות עם XMPP - נתוני הנוכחות תקורה, אשר עשוי להיות גבוה כמו 60-70%, ניתן להפחית הרבה.

pubsubhub מייצג לפרסם רכזת כמנוי pubsubhubbub הוא פרוטוקול, הליבה שבהם הוא הרעיון של pubsubhub. המו"לים שבה (נניח בלוגרים) לעדכן את הרכזת שבו (אולי יותר מאחד רכזות, אשר לדבר אחד עם השני) שוכן "אי שם בענן", על פי פרוטוקול זה ניתן לדחוף או למשוך על פי הפרוטוקול, אבל את הקישור הבא , שרשרת רכזת ללקוח (נניח הקוראים) הוא תמיד לדחוף את המודל. זה הדף טוב נקודת המוצא עבור pubsubhubbub, שקופיות סקירה טובים. רהוט פעם אניל דאש מתאר את זה כאן כמו לחיץ האינטרנט.
שתי כניסות קשורים אחרים הם webhooks שהוא בעצם callbacks HTTP. Github משתמשת בו, כך גם PayPal עבור הודעות אסינכרוני של תשלום IPN . כך גם רבים אחרים. הרעיון הוא קשורים rsscloud שהוא שוב לרכזת pubsub. בצע את הקישור לקבלת פרטים.

ייתכן שאתה תוהה מה הטעם לכתוב כל אלה כאן, יש 2 1. דברים אלה כדאי לדעת, מינימלית לפחות ו 2. בלוג זה נמצא pubsubhubbub מופעלת כיום באמצעות רכזת appspot באמצעות וורדפרס תוסף להאכיל גם הוא pubsubhubbub מופעל באמצעות קישור, FeedBurner כאן
-
[ 1 ]. - היכרות טובה לקרוא להצפנה homomorphic מלא הוא זה מאמר של ברוס שנייר ואת זה לדבר פחות או יותר המקור היחיד של Google Wave.

עדכון - זה מסביר כיצד לכתוב את הדרישה של שרת ציבורי התקשרות יכול להיות עבד עבור לקוחות ברחבי שולחן העבודה באמצעות שער XMPP (עבור pubsubhubbub).

תגיות: , , ,

קצת הרכבה

29 אוגוסט 2009 על ידי Prashant · תגובות
מתויק תחת: טכנולוגיה

אחרי שקראתי את הכתבה על מאגרים נעילת בחינם ולראות את השימוש CAS (להשוואה, להחליף), הרגשתי כמו פרסום קוד הרכבה לעשות את אותו הדבר. השתמש במקרה שם היה לכתוב שיטה מקורית ולקרוא אותו Java (בחזרה 1.5, כאשר במקביל מבני נתונים ב-Java היו פחות או יותר לא קיימת). בלי שהיות, אני לשחרר את הקוד אל לך :) . הראשון הוא על CAS ואת השני הוא מחשוב GCD באמצעות האלגוריתם של אוקלידס (את זה אפשר למצוא במקומות ומדריכים רבים גם כן).

לקמפל ולהריץ הוראות gcc file_name.c ; ./a.out

השווה והחלף 

   # Include 
  # Include 
 / / Exchange - newvalue, comperand ישן / הערך הצפוי
 / *
  פונקציה * באמת עושה את הדבר הבא - אם הערך ב * dest שווה oldvalue מכן להחליף אותו על ידי newvalue אחר להשאיר אותו ללא שינוי: האם כל אלה אטומית
  *
  * יש שתי אפשרויות עבור ערך ההחזרה
  * הערך הראשוני של 1.is * dest ולהשאיר את נטל fxn קורא להשוות את זה עם oldval
  * 2.  לעשות את זה כאן ולחזור 0 או 1, זה אמור להיות יעיל יותר
  ** /

 / * לאחר מכן לשנות את זה לתוך מאקרו * /
 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 התוצאה = 1 ;/ * 1 מראה כי הצליחו CAS ו 0 מראה שהוא נכשל * /
	 / * אגב צריך להגדיר סמ"ק עבור הדגל מחץ!  * /
	 __ __asm__ volatile__ (
			 "Movl% 2,%% EAX \ n \ t"
			 "Movl% 3,%% EBX \ n \ t"
			 "0% movl,%% ECX \ n \ t"
			 "LOCK \ n \ t"
			 "CMPXCHG%% EBX, (%% ECX) \ n \ t" / * לנעול להיות באותה שורה * /
			 "סיימנו JZ \ n \ t"
			 "Movl 0 $,% 1 \ n \ t"
			 "מה נעשה: \ n \ t"
			 : "= M" (dest), "= g" (תוצאה)
			 : "ז" (oldvalue), "G" (newvalue), "M" (dest)
			 : "% EAX", "% EBX", "ECX", "cc"
			 );
	 printf ("(% d,% d,% d)", * dest, oldvalue, newvalue);
	 להחזיר את התוצאה;
 }

 / * TODO
  * לכתוב עוד fxn ASM אשר מעמידה מעל fxn בלולאה תוך ולשמור מנסה אלא אם כן הוא מצליח * /

 int main () {
	 int = 5, b = 6;
	 int * c = (int *) malloc (sizeof (int));
	 * C = 6;
	 / * Int c = 6; * /
	 printf ("% d \ n", CAS (ג, ב, ב));
	 printf ("% d \ n", CAS (ג, ב, א));
	 printf ("% d \ n", CAS (ג,,));
	 printf ("% d \ n", CAS (ג, ב, ב));
	 * C = 6;
	 / * C = 5, * /
	 printf ("ערך המשתנה של * ג ל% d \ n", * ג);
	 printf ("% d \ n", CAS (ג, ב, ב));
	 printf ("% d \ n", CAS (ג, ב, א));
	 printf ("% d \ n", CAS (ג,,));
	 printf ("% d \ n", CAS (ג, א, ב));
	 printf ("% d \ n", CAS (ג, ב, א));
	 התשואה 0;
 }

הערות עיצוב - נראה כמו סימון תחביר wp מוסיפה בסופו של דבר, להתעלם מזה.

GCD 

 # Include 
 GCD int (int, int b) {
     int התוצאה;
     / * Compute מחלק משותף גדול ביותר באמצעות אלגוריתם של אוקלידס * /
     __ volatile__ __asm__ ("movl% 1,%% EAX;"
                           "Movl% 2,%% EBX;"
                           "CONTD: cmpl 0 $,%% EBX;"
                           "Je נעשה;"
                           "Xorl%% edx, edx%%;"
                           "Idivl%% EBX;"
                           "% Movl EBX%%% EAX;"
                           "Movl%% edx, EBX%%;"
                           "JMP CONTD;"
                           "מה נעשה: movl%% EAX, 0%;": "= g" (תוצאה): "G" (א), "G" (ב)
     );

     להחזיר את התוצאה;
 }

 int main () {
     int 1, 2;
     printf ("הכנס שני מספרים שלמים:");
     scanf ("% d% d", & 1, & 2);

     printf ("GCD של D & D%% הוא% d \ n", 1, 2, GCD (1, 2));

     התשואה 0;
 }

תגיות: , , , ,

רובי 1 ספינות ליצור חשיש

20 אוגוסט 2009 על ידי Prashant · תגובות
מתויק תחת: טכנולוגיה

אתמול בשעה עובר אחת מתוכניות הישנים שלי, מצאתי את זה נכתב על ידי לי מתישהו בחזרה:

#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

להרוג כמה מתח הרשה לי לחשוף כי raw_text נראה

, נכון זה נחתך מן ההכרה התשלום PayPal.

מעל קו אם נשבר בחלקים קורא טוב יותר: 

  unescaped_array = CGI.unescape (raw_text). מפוצל ("&")
   unescaped_array unescaped_array.collect = {| x | = b x.split ("="); b.push (אפס) אם b.size == 1, B}
   flattened_array = unescaped_array.flatten
   hash = Hash [* flattened_array]

בוא לעשות צעדים בודדים IRB: 

  IRB (ראשי):. 009:0> unescaped_array = CGI.unescape (raw_text) מפוצל ("&")    

 => ["הצלחה", "mc_gross = 10.00", "protection_eligibility = כשיר", "payer_id = U7PPJJ4TSJ47E", "מס = 0.00", "payment_date = 09:45:30 10 יולי 2009 PDT", "payment_status = בהמתנה "]                                                                         

 IRB (ראשי): 013:0> unescaped_array unescaped_array.map = {| x | = b x.split ("="); b.push (אפס) אם b.size == 1, B}  

 => [["הצלחה", אפסי], ["mc_gross", "10.00"] ["protection_eligibility", "כשיר"], ["payer_id", "U7PPJJ4TSJ47E"], ["מס", "0.00"] , ["payment_date", "09:45:30 10 יולי 2009 PDT"], ["payment_status", "בהמתנה"]]                               

 IRB (ראשי): 014:0> flattened_array = unescaped_array.flatten     

 => ["הצלחה" אפסית ", mc_gross", "10.00", "protection_eligibility", "כשיר", "payer_id", "U7PPJJ4TSJ47E", "מס", "0.00", "payment_date", "09:45: 30 יולי 10, 2009 PDT "," payment_status "," בהמתנה "]
 IRB (ראשי): 015:0>
 hash = Hash [* flattened_array]
 => {"מס" => "0.00", "payment_status" => "בהמתנה", "payer_id" => "U7PPJJ4TSJ47E", "mc_gross" => "10.00", "הצלחה" => אפסי ", payment_date" = > "09:45:30 10 יולי 2009 PDT", "protection_eligibility" => "כשיר"}

אגב, * נקרא מפעיל מעיכה של רובי

דרך נוספת ליצור חשיש מ 'מערך של זוגות "הוא להשתמש להזריק: 

  hash = [[1,2], [3,4]] להזריק ({}). {| מכך, האלמנט | תוצאה [element.first] = התוצאה [element.last]; התוצאה}

יש דרך אחת יותר :) כתוב לולאה, כי אני אשאיר כתרגיל לקוראים!

הנה מקרה קצת שימוש של יצירת קשר בין חשיש מערכים: 

  IRB (ראשי): 005:0> [1,2,3,4,7,9] group_by {| x | x <5.?  : פחותה יותר ::}

 => {: פחות => [1, 2, 3, 4],: יותר => [7, 9]}

אתה יכול לעשות עוד דברים, בעצם תוצאה של בלוק משמש כמפתח עבור אלמנט כי hash שהתקבל.

תגיות: , ,

Gmail, מאט ו msmtp תיקון

17 אוגוסט 2009 על ידי Prashant · תגובות
מתויק תחת: טכנולוגיה

אם אתה משתמש הכלבלב ו-SMTP גישה ל-Gmail. הנה החדשות (רע). חבר 'ה מגניבים בגוגל שוב שינה את האישור. אה, שאלת - איך הוא יודע את זה? הכלב פשוט התחיל להתלונן על תעודת רע כאשר מנסים להשתמש msmpt, הידוע לשמצה "msmtp: אימות TLS תעודת נכשל. תעודת אין לו המנפיק ידוע" בירך אותי על המסך.

לחצות לאשר -
רק לרוץ אחרי

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

במקום שרת Thwate זקן עכשיו אתה מקבל בעקבות במגזר מנפיק
Issuer:
Common Name: Google Internet Authority
Organization: Google Inc
Country: US

למרבה המזל התיקון הוא פשוט, הנה מה שאתה צריך לעשות על דביאן

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

אחרי זה פשוט לשנות את השורה הבאה שאתה ~~~V /. 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

אל

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

תגיות: , , ,

Hashes המתמזגות בקבצי conf yaml

31 יולי 2009 על ידי Prashant · תגובות
מתויק תחת: טכנולוגיה

YAML הוא די נוח לכתיבת קבצי תצורה. היתרון העיקרי הוא, זה נשמע כמו קובץ טקסט. זה עובד ממש טוב אם הקובץ config שלך הוא שטוח (ללא היררכיה) ואין לו חזרות.
אם הקובץ תצורות שלך יש חזרות אז זה הגיוני להפריד את אותם אלמנטים ושימוש חוזר בהם. כוונתי היא זו - נניח הקובץ config שלך נראה כך: 

  פיתוח:
   input_location: common_input
   output_location: dev_location
   דואר אלקטרוני:
     smtp_server: Your_Server
     כניסה: your_login
     סיסמה: top_secret
 הפקה:
   input_location: common_input
   output_location: dev_location
   דואר אלקטרוני:
     smtp_server: Your_Server
     כניסה: your_login
     סיסמה: top_secret

בהנחה מעל הקוד tmp / / test.yml כאן היא איך אתה יכול לקרוא פייתון ורובי
$cat readyml.py 

 #! / Usr / bin / env python
 מ pprint יבוא pprint כמו PP
 # של דביאן צריך להתקין python-yaml
 מ יבוא yaml עומס dump, load_all
 hash = עומס (פתוח ('/ tmp / test.yml "))
 PP (חשיש ["פיתוח"])


$ cat readyml.rb 

  #! / Usr / bin / env רובי
 דורשים "עמ '
 hash = YAML :: עומס (File.open ('/ tmp / test.yml "). לקרוא)
 PP חשיש ["פיתוח"]

כאן הוא תוחם שימושי 1 לגרסה רובי
$ ruby -rpp -e 'pp YAML::load(File.open("/tmp/a.yml"))["development"]' או שאתה יכול לנסות אותו IRB או קונסולת פייתון.

יש לציין כי קטע הקוד הנ"ל, הכל מלבד המיקום הפלט הוא אותו חלק בפיתוח ייצור. זה המקום שבו מזהה הצומת yml בא להציל. הרעיון הוא פשוט להיות קבוצה של ערכי ברירת המחדל ואת לעקוף אותם במקום אחר.
אתה יכול למשוך את זה לבד באופן הבא: 

  המחדל: & המחדל
   input_location: common_input
   output_location: dev_location
   דואר אלקטרוני:
     SENDER_NAME השולח: *
     smtp_server: Your_Server
     כניסה: your_login
     סיסמה: top_secret
 פיתוח:
   <<: * ברירת המחדל
 הפקה:
   <<: * ברירת המחדל
   output_location: prod_location


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

יופי, זה עובד (tm)!.
ניתן לטעון שאנחנו נסחר קצת בהירות קצת קסם. הנה הסבר קטן: & * ו <<: & שהוא תג העוגן יכול להיות מובן מזהה הצומת, * הוא התייחסות צמתים <<: מייצג מיזוג חשיש.

לפרטים נוספים ראו באפשרות מפרט yaml או ויקיפדיה
עד כאן טוב ויפה אבל יש מלכוד כאן, אלה מתמזג חשיש לא רקורסיבית. המשמעות היא זו: נניח אתה רוצה להיות שם השולח שונה עבור דואר בשתי סביבות, אתה עלול להתפתות לבצע את הפעולות הבאות: 

  המחדל: & המחדל
   input_location: common_input
   output_location: dev_location
   דואר אלקטרוני:
     SENDER_NAME השולח: *
     smtp_server: Your_Server
     כניסה: your_login
     סיסמה: top_secret
 פיתוח:
   <<: * ברירת המחדל
   דואר אלקטרוני:
     SENDER_NAME: sender_dev
 הפקה:
   <<: * ברירת המחדל
   output_location: prod_location
   דואר אלקטרוני:
     SENDER_NAME: sender_prod

בואו לבדוק

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

אופס, משהו השתבש, הבעיה כאמור היא כי המיזוג חשיש לא רקורסיבית ובעוד מיזוג זה החליף האלקטרוני של ברירת המחדל בדואר הייצור שבה יש רק מפתח אחד. הפתרון / לעקוף היא לפרוש רמה אחת יותר: 

  common_settings: & common_settings
 input_location: common_input
 output_location: dev_location
 mail_defaults: & mail_defaults
  SENDER_NAME השולח: *
   smtp_server: Your_Server
   כניסה: your_login
   סיסמה: top_secret

 המחדל: & המחדל
   <<: * Common_settings
   דואר אלקטרוני:
     <<: * Mail_defaults
 פיתוח:
   <<: * ברירת המחדל
 הפקה:
   <<: * ברירת המחדל
   דואר אלקטרוני:
     <<: * Mail_defaults
     SENDER_NAME: sender_prod

בואו לבדוק שוב

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

אמרת שיש לך רמה אחת יותר קינון, גם אתה בהחלט יכול לפרוש רמה אחת יותר, אבל אז הוא הופך להיות בלגן. לכן, אם אתה לא מנסה לכתוב פתרון מגדלי האנוי בקובץ conf, עדיף restucture הקובץ conf מאשר לחפור לתוך yaml או משהו אחר. אבל זו השיחה בכל מקרה.

תגיות:

קצת ניתוב מחדש של פגז

10 מאי 2009 על ידי Prashant · תגובות
מתויק תחת: טכנולוגיה

כאן הוא איך אנחנו עושים בדרך כלל פגז ניתוב מחדש
$ ./pgm.sh args >out.txt 2>err.txt
רציתי לשנות את זה קצת ולהפעיל כדלקמן
$ ./pgm.sh args
עם דרישה כי פלט השגיאה צריך ללכת קובץ כלשהו מחושב בתוך pgm.sh מבוסס על ארגומנטים. מקרה אחד יכול להיות המחשה, כאשר התאריך הוא חלק ארגומנטים. אז אתה רוצה ללכת stdout להגיד / מדריך / שלך / pgm_out_YYYYMMDD.txt 1

הבעיה עם הדרך הסטנדרטית של הפניית N>file.txt כלומר, שיוך מתאר קובץ N כדי file.txt, היא שזה עובד רק עבור התהליך החדש מפוצל ולא עבור התהליך הנוכחי.
כך
$ echo hi 1>out.txt ; echo hii . ישלח שלום out.txt אבל ידפיס hii ל stdout 2

זה המקום שבו exec בא להציל שלנו. אם נוסיף exec 1>somefile.txt ואז פלט שאר התסריט יהיה ללכת somefile.txt

$ cat test.sh
#!/usr/bin/env bash
exec 1>out.txt
echo hi
echo hii
$. / Test.sh יפנה היי וכן hii כדי out.txt

באופן דומה כדי להפנות stdout וכן נציג stderr לעשות משהו כזה
cat test2.sh
exec 1>out.txt
exec 2>err.txt
echo out text
echo 1>&2 err text
somenoneexitent command
ls -ld /tmp

עכשיו חוזר לנקודה המקורית של מעביר קובץ כלשהו מתוך מעטפת, נניח תוכנית לחשב את שם הקובץ ב OUTFILE קצת משתנה, היינו יכולים לעשות רק exec 1>$OUTFILE

זה פותר את הבעיה הנוכחית. אבל ייתכן רוצה לעבור את הדוגמה הבאה, אשר משיגה 'גישה אקראית "של הקובץ סקריפט מעטפת. דוגמה לכך היא מפני כאן
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

עם הערות, קוד זה הוא מסביר את עצמי.
-
1 זה גם יכול להיעשות על ידי $ ./pgm.sh args >pgm_out`date +%Y%m%d` אבל הרעיון הוא ליצור את שם הקובץ מבוסס על היגיון כלשהו בתוכנית עצמה.
2 1 על 1> out.txt הוא מיותר אך מבהיר כאן כי אנו הפניית FD 1

תגיות: , ,

להרחיב או לא להרחיב

11 ינואר 2009 על ידי Prashant · תגובות
מתויק תחת: טכנולוגיה

בעוד מדברים על חלוקה אופקית של מסדי נתונים, DHH של רע"ש תהילה עולה כי הדברים קנה המידה יכול לחכות, בהחלט לחכות עד לנקודה לצרכים העסקיים שלך דורשים את זה. במאמרו בהחלט הגיוני setups קטנים אומרים סטארט אפ. לא אומר כי חברות סטארט אתה צריך לכתוב תוכניות הדגמה אבל בהתחשב בעובדה שיש רק 24 שעות ביום אתה צריך להתמקד המשרתים אומרים 1000 משתמשים בדרך להגשמת יותר לאבד את השינה על לדאוג איך הבקשה שלי יטפל עומס של 13142000 המשתמשים. אם אתה מקבל אותם משתמשים רבים אתה יודע איך לשנות את קנה המידה. עבור חברות סטארט הרחבה היא בעיה טובה לפתור אבל הבעיה הרבה יותר טוב להיות, זאת אומרת כל ההפעלה אשמח נתקל בבעיה הזאת!

במקרה אחר הקשור במאמר ג'רמי Zawodny כותב אתה לא צריך לסמוך על מר מור אם יש לך בעיות הרחבה.

מאז מאמרים אלה מתייחסים חוק מור אני לא יכולה שלא לכתוב כי חוק מור חייב להיות חוק אחד כללי ביותר במדעי המחשב. מן התחזית המקורית שלו על צפיפות הטרנזיסטורים, המשפט הזה מביא עכשיו בכל מקום שאתה נתקל גידול מעריכי.

תגיות: ,