/// <summary>
        /// Function to run setupTomcat.bat which in runnin TomcatConfigManager.exe
        /// </summary>
        /// <param name="batchFile"></param>
        /// <param name="esLocation"></param>
        /// <param name="port"></param>
        /// <param name="appRoot"></param>
        /// <returns></returns>
        private string RunCommand(string batchFile, string esLocation, string port, string appRoot)
        {
            // initiating process
            var newProc = new Process();

            // initiating stream reader to get the output details
            // string variable to store the output details

            try
            {
                // setting the required properties for the process
                newProc.StartInfo.UseShellExecute        = false;
                newProc.StartInfo.RedirectStandardOutput = true;
                newProc.StartInfo.RedirectStandardError  = true;
                newProc.StartInfo.RedirectStandardOutput = true;
#if DEBUG
                newProc.StartInfo.CreateNoWindow = false;
#endif
#if !DEBUG
                newProc.StartInfo.CreateNoWindow = true;
#endif
                newProc.EnableRaisingEvents = false;

                var esHome = esLocation.Substring(0, esLocation.Length - 1);
                // setting the localsource path tomcatlocation to the environment variable catalina_home
                newProc.StartInfo.EnvironmentVariables.Add("ES_HOME", esHome);

                // set the batchFile setupTomcat.bat in approot directory as process filename
                newProc.StartInfo.FileName = batchFile;

                // set the follwing three arguments for the process {0} catalina_home - environment variable which has the localresource path
                // {1} - port in which the tomcat has to be run and which needs to be changed in the server xml
                // {2} - approot path
                newProc.StartInfo.Arguments = String.Format("{0} {1} \"{2}\"", esHome, port, appRoot);

                DiagnosticsHelper.TraceInformation("Arguments: " + newProc.StartInfo.Arguments);

                // starting the process
                newProc.Start();

                newProc.OutputDataReceived += processToExecuteCommand_OutputDataReceived;
                newProc.ErrorDataReceived  += processToExecuteCommand_ErrorDataReceived;
                newProc.BeginOutputReadLine();
                newProc.BeginErrorReadLine();

                newProc.WaitForExit();
                newProc.Close();
            }
            catch (Exception ex)
            {
                Trace.TraceError(ex.Message);
                throw;
            }

            return(String.Empty);
        }
        /// <summary>
        /// Function to start Tomcat Process
        /// </summary>
        /// <param name="esLocation">The es location.</param>
        /// <param name="cacheLocation">The cache location.</param>
        /// <param name="workerIPs">The worker IP's.</param>
        /// <returns></returns>
        private Process StartESProcess(string esLocation, string cacheLocation, string workerIPs)
        {
            DiagnosticsHelper.TraceInformation("ElasticSearch - starting pricess at esLocation:" + esLocation + ",cacheLocation:" + cacheLocation + ",workerIPs:" + workerIPs);

            // initiating process
            var newProc = new Process();

            // stream reader to get the output details of the running command

            try
            {
                //setting the required properties for the process
                newProc.StartInfo.UseShellExecute        = false;
                newProc.StartInfo.RedirectStandardOutput = true;
                newProc.StartInfo.RedirectStandardError  = true;
                newProc.StartInfo.RedirectStandardOutput = true;
#if DEBUG
                newProc.StartInfo.CreateNoWindow = false;
#endif
#if !DEBUG
                newProc.StartInfo.CreateNoWindow = true;
#endif
                newProc.EnableRaisingEvents = false;
                newProc.StartInfo.EnvironmentVariables.Remove("JAVA_HOME");
                newProc.StartInfo.EnvironmentVariables.Add("JAVA_HOME", Path.Combine(esLocation, "jre7"));

                // setting the localsource path tomcatlocation to the environment variable catalina_home
                newProc.StartInfo.EnvironmentVariables.Add("ES_DATA", Path.Combine(Path.Combine(cacheLocation, "ElasticStorage"), "data"));
                newProc.StartInfo.EnvironmentVariables.Add("ES_HOSTS", workerIPs);

                // setting the file name  bin\startup.bat in tomcatlocation of localresourcepath
                newProc.StartInfo.FileName = Path.Combine(esLocation, Settings.ElasticStartApp);

                DiagnosticsHelper.TraceInformation("ElasticSearch start command line: " + newProc.StartInfo.FileName);
                // starting process
                newProc.Start();
                DiagnosticsHelper.TraceInformation("Done - Starting ElasticSearch");

                newProc.OutputDataReceived += processToExecuteCommand_OutputDataReceived;
                newProc.ErrorDataReceived  += processToExecuteCommand_ErrorDataReceived;
                newProc.BeginOutputReadLine();
                newProc.BeginErrorReadLine();
                newProc.Exited += Process_Exited;
            }
            catch (Exception ex)
            {
                // Logging the exceptiom
                DiagnosticsHelper.TraceError(ex.Message);
                throw;
            }

            return(newProc);
        }
        private string GetElasticDataDirectory()
        {
            DiagnosticsHelper.TraceInformation("Getting db path");
            var roleId        = RoleEnvironment.CurrentRoleInstance.Id;
            var containerName = ContainerNameFromRoleId(roleId);

            var dataDrivePath = Utilities.GetMountedPathFromBlob(
                Constants.LocalCacheSetting,
                containerName,
                Constants.ElasticSearchBlobName,
                Settings.DefaultDriveSize,
                out _elasticStorageDrive);

            DiagnosticsHelper.TraceInformation("Obtained data drive as {0}", dataDrivePath);
            return(dataDrivePath);
        }
 public void Dispose()
 {
     try
     {
         if (_elasticStorageDrive != null)
         {
             DiagnosticsHelper.TraceInformation("Unmount called on data drive");
             _elasticStorageDrive.Unmount();
         }
         DiagnosticsHelper.TraceInformation("Unmount completed on data drive");
     }
     catch (Exception e)
     {
         //Ignore any and all exceptions here
         DiagnosticsHelper.TraceWarning(
             "Exception in onstop - unmount failed with {0} {1}",
             e.Message, e.StackTrace);
     }
 }
        private void CreateElasticStoragerDirs(String vhdPath)
        {
            DiagnosticsHelper.TraceInformation("ElasticSearch - creating Cache Directories, path=" + vhdPath);

            var elasticStorageDir = Path.Combine(vhdPath, "ElasticStorage");
            var elasticDataDir    = Path.Combine(elasticStorageDir, "data");

            DiagnosticsHelper.TraceInformation("ElasticSearch - elasticStorageDir=" + elasticStorageDir);
            DiagnosticsHelper.TraceInformation("ElasticSearch - elasticDataDir=" + elasticDataDir);

            if (Directory.Exists(elasticStorageDir) == false)
            {
                Directory.CreateDirectory(elasticStorageDir);
            }
            if (Directory.Exists(elasticDataDir) == false)
            {
                Directory.CreateDirectory(elasticDataDir);
            }
            DiagnosticsHelper.TraceInformation("ElasticSearch - done creating Cache Directories, path=" + vhdPath);
        }
예제 #6
0
        private void ConfigureElasticSearch()
        {
            try
            {
                // Initializing RunES
                _elastic = new RunES();

                var workerIPs = ListWorkerRoles();
                DiagnosticsHelper.TraceInformation("OnStart workerIPs: " + workerIPs);
                DiagnosticsHelper.TraceInformation("OnStart CacheLocation: " + Settings.CacheDir);
                _process = _elastic.StartES(Settings.CacheDir, Settings.DefaultElasticPort, workerIPs);
            }
            catch (Exception ex)
            {
                DiagnosticsHelper.TraceInformation(ex.Message + " " + ex.StackTrace);
                DiagnosticsHelper.TraceError(ex.Message + " " + ex.StackTrace);
                Trace.Flush();
                throw new ApplicationException("Can't configure Elastic Search: " + ex.Message);
            }
        }
예제 #7
0
        public override void OnStop()
        {
            DiagnosticsHelper.TraceInformation("ElasticWorkerRole OnStop() called", "Information");

            if (_process != null)
            {
                try
                {
                    _process.Kill();
                    _process.WaitForExit(2000);
                }
                catch { }
            }

            if (_elastic != null)
            {
                _elastic.Dispose();
            }

            base.OnStop();
        }
 private void processToExecuteCommand_OutputDataReceived(object sender, DataReceivedEventArgs e)
 {
     DiagnosticsHelper.TraceVerbose(e.Data);
 }
 private void processToExecuteCommand_ErrorDataReceived(object sender, DataReceivedEventArgs e)
 {
     DiagnosticsHelper.TraceError(e.Data);
 }
 void Process_Exited(object sender, EventArgs e)
 {
     DiagnosticsHelper.TraceInformation("ElasticSearch Exited");
     RoleEnvironment.RequestRecycle();
 }
예제 #11
0
        internal static string GetMountedPathFromBlob(
            string localCachePath,
            string containerName,
            string blobName,
            int driveSize,
            out CloudDrive elasticDrive)
        {

            DiagnosticsHelper.TraceInformation(
                "In mounting cloud drive for on {0} with {1}",
                containerName,
                blobName);

            var connectionString = RoleEnvironment.GetConfigurationSettingValue("DataConnectionString");
            connectionString = connectionString.Replace("DefaultEndpointsProtocol=https", "DefaultEndpointsProtocol=http");

            var storageAccount = CloudStorageAccount.Parse(connectionString);

            var blobClient = storageAccount.CreateCloudBlobClient();

            DiagnosticsHelper.TraceInformation("Get container");
            // this should be the name of your replset
            var driveContainer = blobClient.GetContainerReference(containerName);

            // create blob container (it has to exist before creating the cloud drive)
            try
            {
                driveContainer.CreateIfNotExist();
            }
            catch (StorageException e)
            {
                DiagnosticsHelper.TraceInformation(
                    "Container creation failed with {0} {1}",
                    e.Message,
                    e.StackTrace);
            }

            var blobUri = blobClient.GetContainerReference(containerName).GetPageBlobReference(blobName).Uri.ToString();
            DiagnosticsHelper.TraceInformation("Blob uri obtained {0}", blobUri);

            // create the cloud drive
            elasticDrive = storageAccount.CreateCloudDrive(blobUri);
            try
            {
                elasticDrive.CreateIfNotExist(driveSize);
            }
            catch (CloudDriveException e)
            {
                DiagnosticsHelper.TraceInformation(
                    "Drive creation failed with {0} {1}",
                    e.Message,
                    e.StackTrace);

            }

            DiagnosticsHelper.TraceInformation("Initialize cache");
            var localStorage = RoleEnvironment.GetLocalResource(localCachePath);

            CloudDrive.InitializeCache(localStorage.RootPath.TrimEnd('\\'),
                localStorage.MaximumSizeInMegabytes);

            // mount the drive and get the root path of the drive it's mounted as
            try
            {
                DiagnosticsHelper.TraceInformation(
                    "Trying to mount blob as azure drive");
                var driveLetter = elasticDrive.Mount(localStorage.MaximumSizeInMegabytes,
                    DriveMountOptions.None);
                DiagnosticsHelper.TraceInformation(
                    "Write lock acquired on azure drive, mounted as {0}",
                    driveLetter);
                return driveLetter;
            }
            catch (CloudDriveException e)
            {
                DiagnosticsHelper.TraceCritical(
                    "Failed to mount cloud drive with {0} {1}",
                    e.Message,
                    e.StackTrace);
                throw;
            }
        }