יום חמישי, 21 באפריל 2011

Hard Drive Starting Guide

טרגדיה!! נמחק לי ה Hard Disk! מה אני יעשה איך אני אשחזר את הנתונים שלי?! עם מי לדבר? זה חלק מהשאלות שאתה שואל את עצמך כאשר עוברת עליך "טרגדיה" כזאת... אז דבר ראשון תנו לשבור לכם מיתוס, המידע בדיסק לא נעלם, אלא נשאר אלא אם כן נדרש המקום ע"י מערכת ההפעלה שלנו, כוננים קשיחים זה החלק הנע היחידי שנשאר עוד במחשבים (חוץ מהמאוררים) ועם הזמן המערכות שבו נשחקות כמו שהרכב שלנו נשחק, אבל אני לא רוצה להאשים את הכוננים על כך שהם לא אמינים, הם שירתו אותנו שנים רבות ואני מאמין שהם ישרתו אותנו עוד למרות שתכנולוגיות חדשות ושיפורים מראים עולם טוב יותר ובקרוב החלק הפרימטיבי הזה יוחלף בזיכרון Flash מהיר ועצבני, רק חשוב לי להדגיש כל הקשור לקבצים שנמחקו או כוננים שנדפקו לא קרו בגלל עייפות החומרים אלא בגלל טעויות משתמשים.

במאמר זה נכיר את המנגנון הזה וכיצד הוא עובד, בנוסף נשחזר כונן שנמחק ,לצורך העניין אני יקריב HD של 10 GB ישן.

המקומות הנסתרים של הכוננים הקשיחים:

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

אז איך בדיוק זה עובד?

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

אז אחרי התיאוריה נעבור לתכלס:


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

המנגנון המכני:


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


  1. דיסק מתכת (אלומניום) שמכיל את המידע לפעמים יש יותר מדיסק אחת.
  2. מנוע שמסתובב בין 5,400 עד 15,000 סיבובים בדקה.




   3.  ראשי מחט שממגנטים נקודות ע"ג הדיסק.
   4.  נקודת החיבור עם המנגנון האלקטרוני.
   5.  חתיכת פלסטיק ששומרת על הציר של המחט ומונעת ממנה לחרוג מחוץ לדיסק.
   6.  מגנט עליון
   7.  מגנט תחתון.

כל מערכת הפעלה מכילה מיפוי עבור הכונן לפי השיטות שלה ב Windows למשל זה נקרא FAT - File Allocation Table שנכתב ע"י ביל גייטס בשלבים הראשונים של האימפריה ועבר שיפורים במהלך השנים, FAT מכיל מפה של נקודות המידע על הדיסק שנקראות Sectors וברגע שהכונן רוצה לכתוב או לקרוא הוא מעביר למחט את המיפוי של ה Sector.

שחזור מידע מדיסק שנמחק:

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

יצירת Case חדש.


הכנסת הפרטים של ה"תיק שלנו" ובחירת הכונן שאותו אנחנו רוצים לשחזר



ביצוע Recover Folder יחשוף לנו את הקבצים והספריות שנמחקו.

בחירת הקובץ או הספרייה שאנחנו רוצים לשחזר


 
שחזור המידע.


סרט הדגמה:
 
בהצלחה...

יום שישי, 15 באפריל 2011

Pixel Bender Starting Guide



למי שלא מכיר Pixel Bender זה Framework שעוצב ע"י Adobe במטרה לכתוב Filters ו Effects עבור המוצרים שלה, הסביבה הזאת תומכת בהרבה מוצרים של Adobe כמו: Photoshop, After Effects ,Flex. זאת שפה עצמאית המתלבשת על שפת C, ומאפשרת לנו להריץ את הקוד שלנו ע"ג ה Gpu ולקבל ביצועים טובים יותר, קיימים עשרות דוגמאות כיצד לממש בעזרתו אפקטים ופילטרים רבים על תמונות ואפילו סרטים בעזרת After Effect, השפה יחסית נוחה לכתיבה והביצועים שלה באמת מרשימים.

שלב ראשון: נעים להכיר Pixel Bender

ניתן להוריד את ה Toolkit של Pixel Bender , באופן חופשי והוא מאוד מזכיר את ה Extended Script של Indesign , אותו ממשק משעמם וממש לא מובן אבל כנראה זה מה יש..., השפה עצמה לא כל כך מסובכת מה שבאמת מסובך הוא להבין כיצד לעבד את התמונה והחישובים שצריכים לעשות על הפיקסל בשביל לקבל את התוצאה שאנחנו מחפשים.

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

קצת על הקוד:

כל קוד נפתח עם הכותרת הבאה:

< languageversion 1.0; >
  kernel NewFilter
   <
      namespace : "Your Namespace";
       vendor : "Your Vendor";
       version : 1;
       description : "your description";
    >

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

{


   input image4 src;
   output pixel4 dst;

   void evaluatePixel()
  {
       dst = sampleNearest(src,outCoord());
   }
}

כל פילטר חייב לעבוד עם 2 פרמטרים גלובלים מסוג Input ו Output , ה Input מייצג את התמונה המקורית , Image4 חייב להיות מוגדר על מנת שהפונקציה Evaluate pixel תעבוד,4 Pixel מייצג אובייקט של פיקסל החוזר לתמונה, המורכב מ 4 הערוצים של RGBA- Red,Green,Blue,Alpha.
אז כמו שאמרתי בהתחלה הפונקציה evaluatePixel היא פונקצית ה Main שלנו, היא חייבת להחזיר פיקסל בודד בחזרה, במקרה שלנו קיימת הפונקציה sampleNearest דוגמת לנו את הפיקסל שהגיע מהתמונה המקורית , הפונקציה הפנימית outCoord מחזירה את הקורדינטות של הפיקסל המקורי ומשווים אותו ל dst שהוא הפיקסל החוזר ובעצם לא השתנה כלום בתמונה.
שימוש בפרמטרים חיצוניים:

Pixel Bender מאפשר לנו להעביר אליו פרמטרים מבחוץ לדוגמה מ Photoshop,Flash ו After Effects.
 parameter int size
<
   minValue:1;
   maxValue:50;
   defaultValue:1;
>

פונקציות:
  • Mathematical functions - פונקציות מתמטיקאיות על פיקסלים ובין פיקסלים.
  • Geometric functions - פונקציות גיאומטריות לחישוב מרחקים ורדיוסים בין פיקסלים.
  • Region functions - פונקציות על איזורים בתמונה.
  • Sampling functions - פונקציות דגימה של פיקסלים.
  • Intrinsic functions - פונקציות כלליות.
משתנים:
  • Scalar - משתני בסיס כמו Bool,Int,Float,Pixel
  • Vector - משתנים ויקטורים שמכילים בתוכם בין 2 ל 4 משתני Scalar לדוגמה Pixel 2 מכיל בתוכו 2 משתנים מסוג Pixel.
  • Matrix - משתנים למטריצות מכילים משתנים מסוג Vector \ Scalar לדוגמה Float4x4 מכיל בתוכו מטריצה מסוג של Float בגודל 4 שורות ועמודות.
ניתן לממש ביטויים רבים כמו If,For,While,Do אבל חייבים לשים לב אם זה נתמך באפליקציה שהולכת להריץ את הסקריפט לדוגמה לולאות לא נתמכות ב Flash לכן חשוב מאוד לדעת את התמיכה באפליקציות כי זה חלק חשוב בתכנון הפילטר.

דוגמה 1:
משחק בסיסי


חישובי צבעים , ושליטה על ערוץ צבע ספציפי.
דוגמה 2:
משחקי בהירות


שינוי בהירות התמונה ע"י פרמטר חיצוני.

דוגמה 3:
שליטה על ערוצי צבע


שליטה על ערוצי הצבע בעזרת פרמטרים חיצוניים.

דוגמה 4
משחק בין ערוצי הצבע


שינוי ערוצי הצבע במימוש פרמטר חיצוני בעזרת ביטוי IF, אפשרות השוואה ליותר מ 2 פרמטרים.

דוגמה 5:
טשטוש תמונה


נאספו 4 פיקסלים שמסביב הפיקסל המקורי , נבחרו ע"פ המרחק שעבר לנו בפרמטר החיצוני ואח"כ חולקו ב 5 על מנת לקבל פיקסל ממוצע של כל הפיקסלים כולל המקורי.

Graph Language

Pixel Bender מאפשר לנו אפשרות יחודית , אנחנו יכולים לשרשר פילטרים ביחד, כלומר פיקסל אחד יכול לרוץ על כמה Kernel שכל אחד מהם מייצג פילטר, ריבוי של הפונקציה evalutePixel מאפשר לנו שילוב של כמה פילטרים על פיקסל בודד.


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


  <graph name="IdentityGraph" xmlns:pbg="http://ns.adobe.com/PixelBenderGraph/1.0">
  <metadata name="namespace" value="Your Namespace">
  <metadata name="vendor" value="Your Vendor">
  <metadata name="version" type="int" value="1">

  <!-- Image inputs and outputs of the graph -->
  <inputimage name="global_src" type="image4">
  <outputimage name="global_dst" type="image4">
 
   <kernel>
                          Kernel Code Here!
   </kernel>
   <!-- Instances of the nodes -->
  <node id = "identity1" name ="Identity1" namespace = "Your Namespace" vendor = "Your Vendor" version ="1" >
</node>
   <kernel>
                          Kernel Code Here!
   </kernel>
   <!-- Instances of the nodes -->
   <node id = "identity2" name ="Identity2" namespace = "Your Namespace" vendor = "Your Vendor" version ="1" >
   </node>
 <kernel>
                         Kernel Code Here!
   </kernel>
    <!-- Instances of the nodes -->
    <node id = "identity3" name ="Identity3" namespace = "Your Namespace" vendor = "Your Vendor" version ="1" >
    </node>
   

לאחר שהגדרנו 3 בלוקים של Kernel והגדרנו להם Node על מנת שה Graph יכיר בהם נשאר להגדיר את הסדר שלהם, איזה פילטר יהיה ראשון ומה יבוא אחריו.
<!-- Connections -->
<connect fromImage="global_src" toNode="identity1" toInput="src"/>
<connect fromNode="identity1" fromOutput="dst" toNode="identity2" toInput="src"/>
<connect fromNode="identity2" fromOutput="dst" toNode="identity3" toInput="src" toImage="global_dst"/>
</graph>

גם בעבודה עם Graph Language צריך לשים לב לתמיכה, היא לא נתמכת ע"י Flash.

להורדה חינם מאתר Adobe , ניתן למצוא עשרות דוגמאות חינמיות באתר ה Exchange של Adobe.
בהצלחה...

יום שבת, 2 באפריל 2011

Mssql BackUp Application From Sketch

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

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

אפשרויות גיבוי בעזרת Microsoft Sql Server 2005 :
בחנתי את צורת הגיבוי ב Mssql , זה נראה פשוט מאוד, לחצן ימני על ה Database שאנחנו רוצים לגבות:


השלב הבא הוא להגדיר לאן לשמור את קובץ ה Bak שזה פורמט הגיבוי עבור Mssql.

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


אבל מה בעצם לא ראיתי?
לא ראיתי את האפשרות לשמור לי גרסאות שונות ואם יש לי הרבה Databases העסק יכול להיות מסורבל, מה קורה אם אני רוצה לעשות זאת אוטומטי משרת מרוחק, ואולי גם לקבץ לי אותו ב Zip על הדרך ולשלוח לי אימייל כאשר הגיבוי התבצע, המון מחשבות רצו לי בראש ונראה לי שאני מתחיל להבין מה אני רוצה מהתוכנית הגיבויים שלי.
דרך נוספת שבדקתי היא אפשרות לגבות את הנתונים בעזרת משפט Sql , זה נראה אפשרי בעזרת הדוגמה הזאת:
BACK UP DATABASE db_name TO DISK = N'C:\backup\db_name.BAK'
אבל חסר לי פה מעקב על התהליך אני אף פעם לא יודע מתי הוא סיים ואם הוא סיים לגבות לכן הרעיון להשתמש במשפט Sql ירד משולחן הסירטוטים וההיתי צריך לחפש כיוון אחר...
הישועה הגיעה מה Mssql עצמו מסתבר של Mssql יש SDK רחב מאוד שתומך ב NET. מגרסה 2, יש מספר ספריות שנתנות לנו את האפשרות לשלוט ב Sql Agent שזה הוא ה Service שמנהל לנו את מסדי הנתונים.
Microsoft.SqlServer.ConnectionInfo
ספריה זאת אחראית על ההתחברות והאימות מול השרת.
 
Microsoft.SqlServer.Smo
מכיל מופע למנוע של ה Mssql , ובעצם זאת המחלקה העיקרית שנעבוד מולה.
 
מיקום הקבצים:
 
C:\Windows\assembly\GAC_MSIL\Microsoft.SqlServer.Smo\9.0.242.0__89845dcd8080cc91
 
בנקודה זאת הבנתי שמצאתי את מה שאני מחפש, את השליטה , חזרתי לשולחן הסירטוטים והתחלתי לעצב את הרעיון של התוכנית.
 
 
שרת אחד מפעיל בתוכו תוכנית שמתחברת מרחוק למספר שרתים שמריצים Sql Server , בעזרת פקודה מרחוק השרתים מגבים את מסדי הנתונים ישירות ליחידת גיבוי, בשלב הזה הכל כבר נראה ברור , הרעיון שלי מגובש ואפשר להתחיל לכתוב את הקוד, במאמר זה אני יתאר את הקוד שמגבה בלבד למרות שהעלתי עוד רעיונות שיכולים להתלבש על המנגנון הזה אבל אותם אני אשמור לפעם אחרת.

using System;
using System.Collections.Generic;
using System.Text;
using Microsoft.SqlServer.Management.Smo;
using Microsoft.SqlServer.Management.Common;
namespace backup_mssql
{
   class Program
  {
    static void Main(string[] args)
    {
      BackupDeviceItem bdi = new BackupDeviceItem(@"\\storageunit\backup.bak",DeviceType.File);
      Backup bu = new Backup();
      bu.Database = "mydatabase";
      bu.Devices.Add(bdi);
      bu.Initialize = true;
      
      bu.PercentComplete += new PercentCompleteEventHandler(Backup_PercentComplete);
      bu.Complete +=new ServerMessageEventHandler(Backup_Complete);
     
      ServerConnection myconnection = new ServerConnection("192.1.1.1","username","password");
      Server server = new Server(myconnection);
      bu.SqlBackup(server);
      Console.WriteLine("Press any key to continue.");
      Console.ReadKey();
     }

     protected static void Backup_PercentComplete(object sender, PercentCompleteEventArgs e)
    {
      Console.WriteLine(e.Percent + "%.");
    }
   
    protected static void Backup_Complete(object sender, ServerMessageEventArgs e)
    {
      Console.WriteLine(e.ToString());
    }
  }
}

מעבר זריז על קוד מאפשר לנו לראות שתחילה אנחנו מגדירים Device , שבעצם מצביע לנתיב גיבוי חדש ע"ג יחידה חיצונית ברשת, קיימים 2 אירועים - קבלת האחוזים עד להשלמת התהליך , וסיום התהליך, קיימת נקודה חשובה בנוגע ל Device חשוב לזכור שה Sql Server Agent רץ עם הרשאות משלו ולפעמים לא ניתן לרשום את הגיבוי ליעד בגלל הרשאות כתיבה, לכן חשוב מאוד שכל ה Services של ה Mssql ירוצו עם הרשאות שמאפשרות כתיבה ליחידת גיבוי.

כפתור ימני על ה Service של Sql Server Agent אח"כ Log On יאפשר לנו להחליף את ההרשאות של ה Service למשתמש אחר.

בהצלחה...