/// <summary>
        /// Create a new worker from its information in the database
        /// </summary>
        /// <param name="workerID"></param>
        public void CreateWorker(int workerID)
        {
            Cloud cloud = cloudLookupFromWorkerId(workerID);

            try
            {
                CloudWebPortal.Areas.Aneka.Models.Machine masterMachine = machineLookupFromMasterId(cloud.Master.MasterId);
                CloudWebPortal.Areas.Aneka.Models.Machine workerMachine = machineLookupFromWorkerId(workerID);
                Master master = cloud.Master;
                Worker worker = db.Workers.Find(workerID);

                DaemonProbeResult result = new DaemonProbeResult(DaemonProbeStatus.Unknown, null);
                if (masterMachine.StatusEnum == DaemonProbeStatus.ServiceStarted && workerMachine.StatusEnum == DaemonProbeStatus.ServiceStarted)
                    result = new DaemonProbeResult(DaemonProbeStatus.ServiceStarted, null);
                else
                    return;

                global::Aneka.PAL.Management.Model.Machine AnekaWorkerMachine = machineManagment.ToAnekaPALMachine(workerMachine);

                String containerId = CreateContainer(workerMachine.Daemon.Directory,
                    workerMachine.IP,
                    workerMachine.Daemon.Port,
                    worker.Port,
                    false,
                    cloud.CloudName,
                    worker.Cost,
                    cloud.SecuritySharedKey,
                    workerMachine.SoftwareAppliances,
                    worker.Services,
                    AnekaWorkerMachine.DaemonUri,
                    master.Port,
                    masterMachine.IP,
                    null,//for master only
                    null);//for master only

                Worker workerFromDB = db.Workers.Find(workerID);
                workerFromDB.AnekaContainerID = containerId;
                db.SaveChanges();

                FinishedWorkerActivity(workerID);
            }
            catch (Exception ex)
            {
                Worker workerFromDB = db.Workers.Find(workerID);
                workerFromDB.StatusEnum = global::Aneka.UI.Configuration.ProbeStatus.Error;
                workerFromDB.ProgressMesage = "Error while creating worker container: " + ex;
                workerFromDB.isInProgress = false;
                db.SaveChanges();
            }
        }
        /// <summary>
        /// Probe a  machine
        /// </summary>
        /// <param name="daemonMachine">Daemon Machine entity</param>
        /// <returns></returns>
        public DaemonProbeResult ProbeMachine(global::Aneka.PAL.Management.Model.Machine daemonMachine)
        {
            DaemonProbeResult result = new DaemonProbeResult(DaemonProbeStatus.Unknown, null);

            if (daemonMachine != null)
            {
                // set the probe status to unknown
                daemonMachine.ProbeResult = result;

                // check service status
                if (daemonMachine.UserAccount != null)
                {
                    // Probe the target machine..
                    DaemonManager daemonManager = new DaemonManager();
                    result = daemonManager.Probe(daemonMachine);

                    //The machine been pinged and it is reachable of course,
                    //so the statues can't be "NetworkNotReachable"!!!
                    //If DaemonManager.Probe returns "NetworkNotReachable"
                    //it is most likely that it is a credential problem, but maybe not.
                    //So the DaemonManager.Probe must be re-implemented to be more accurate.
                    if(result.Status == DaemonProbeStatus.NetworkNotReachable)
                        result =  new DaemonProbeResult(DaemonProbeStatus.BadCredentials, null);
                }
                else
                    result = new DaemonProbeResult(DaemonProbeStatus.BadCredentials, null);

            }

            //set the probe status of the machine
            return result;
        }
        /// <summary>
        /// Get the latest Machine Status, and update it in the database
        /// </summary>
        /// <param name="machineID">Machine ID</param>
        /// <param name="login">Machine Login Credential</param>
        /// <returns>Machine Status</returns>
        public DaemonProbeResult UpdateMachineStatus(int machineID, MachineLoginCredential login)
        {
            DaemonProbeResult probeResult = new DaemonProbeResult(DaemonProbeStatus.Unknown,null);
            CloudWebPortal.Areas.Aneka.Models.Machine machine = db.Machines.Find(machineID);
            if (pingMachine(machine.IP))
            {
                global::Aneka.PAL.Management.Model.Machine daemonMachine = ToAnekaPALMachineWithLogin(machine, login);
                probeResult = ProbeMachine(daemonMachine);

                machine.IP = daemonMachine.Address;
                machine.StatusEnum = probeResult.Status;

                db.SaveChanges();
            }
            else
            {
                machine.StatusEnum = DaemonProbeStatus.NetworkNotReachable;
                db.SaveChanges();
            }
            return probeResult;
        }
        /// <summary>
        /// Build Cloud from its information in the database
        /// </summary>
        /// <param name="cloudID">CloudID</param>
        public void CreateCloud(int cloudID)
        {
            Cloud cloud = db.Clouds.Find(cloudID);

            try
            {
                CloudWebPortal.Areas.Aneka.Models.Machine machine = machineLookupFromMasterId(cloud.Master.MasterId);
                Master master = cloud.Master;

                DaemonProbeResult result = new DaemonProbeResult(DaemonProbeStatus.Unknown, null);
                if (machine.StatusEnum == DaemonProbeStatus.ServiceStarted)
                    result = new DaemonProbeResult(DaemonProbeStatus.ServiceStarted, null);
                else
                    return;

                global::Aneka.PAL.Management.Model.Machine AnekaMachine = machineManagment.ToAnekaPALMachine(machine);

                byte[] key = global::Aneka.Security.Cryptography.AESCryptoUtil.GenerateKey();
                String NewSecuritySharedKey = Convert.ToBase64String(key);
               // String NewSecuritySharedKey = "whM2IcwXiQzmVbDyvOnOmPxgUS6WRp+VKVYuThtVuiM=";

                String containerId = CreateContainer(machine.Daemon.Directory,
                    machine.IP,
                    machine.Daemon.Port,
                    master.Port,
                    true,
                    cloud.CloudName,
                    master.Cost,
                    NewSecuritySharedKey,
                    machine.SoftwareAppliances,
                    master.Services,
                    AnekaMachine.DaemonUri,
                    null, //Only for worker
                    null, //Only for worker
                    cloud.DBConnectionString,//Only for master
                    cloud.Master.MasterFailoverBackupURI);//Only for master

                Master masterFromDB = db.Masters.Find(cloud.Master.MasterId);
                masterFromDB.AnekaContainerID = containerId;
                db.SaveChanges();

                Cloud cloudFromDB = db.Clouds.Find(cloudID);
                cloudFromDB.SecuritySharedKey = NewSecuritySharedKey;
                db.SaveChanges();

                //Get already exist users
                Uri masterUri = new Uri(ContainersManagement.GetContainerUri(machine.IP, master.Port));
                global::Aneka.Security.UserCredentials adminLogin = new global::Aneka.Security.UserCredentials("Administrator", String.Empty);
                AnekaUsersManagement anekaUsersManagement = new AnekaUsersManagement(masterUri, adminLogin);
                List<CloudUserAccount> cloudUserAccounts = anekaUsersManagement.getAllUsersFromTheCloud();
                foreach (CloudUserAccount account in cloudUserAccounts)
                {
                    if (account.Password == "")
                        account.Password = "******";
                    account.Clouds = new List<Cloud>();
                    account.Clouds.Add(cloud);
                    db.CloudUserAccounts.Add(account);
                    db.SaveChanges();
                }

                FinishedMasterActivity(cloud.CloudId);
            }
            catch (Exception ex)
            {
                Master masterFromDB = db.Masters.Find(cloud.Master.MasterId);
                masterFromDB.StatusEnum = global::Aneka.UI.Configuration.ProbeStatus.Error;
                masterFromDB.ProgressMesage = "Error while creating master container: " + ex;
                masterFromDB.isInProgress = false;
                db.SaveChanges();
            }
        }