private IStorageContext GetContext()
{
StorageEmulatorUpdatableConfiguration storageEmulatorUpdatableConfiguration;
if (this.autoDetect)
{
this.LogMessage(Resource.AutoDetectRequested, new object[0]);
storageEmulatorUpdatableConfiguration = this.AutoDetectAndUpdate();
}
else if (!string.IsNullOrEmpty(this.server))
{
this.LogMessage(Resource.ServerSpecified, new object[0]);
storageEmulatorUpdatableConfiguration = this.ProbeInstanceAndUpdate(this.server);
}
else if (!StorageEmulatorUpdatableConfiguration.TryGetFromUserProfile(out storageEmulatorUpdatableConfiguration))
{
this.LogMessage(Resource.NoConfigurationAutoDetecting, new object[0]);
storageEmulatorUpdatableConfiguration = this.AutoDetectAndUpdate();
}
else if (string.IsNullOrEmpty(storageEmulatorUpdatableConfiguration.SqlInstance))
{
this.LogMessage(Resource.EmptyInstanceAutoDetecting, new object[0]);
storageEmulatorUpdatableConfiguration = this.AutoDetectAndUpdate();
}
if (string.IsNullOrEmpty(storageEmulatorUpdatableConfiguration.SqlInstance))
{
this.LogErrorAndThrowException(EmulatorErrorCode.NoSqlInstanceFound, null);
}
this.LogMessage(Resource.FoundSqlInstance, new object[] { storageEmulatorUpdatableConfiguration.SqlInstance });
return(new StorageContext()
{
InstanceName = storageEmulatorUpdatableConfiguration.SqlInstance
});
}
private StorageEmulatorUpdatableConfiguration ProbeInstanceAndUpdate(string instanceName)
{
StorageEmulatorUpdatableConfiguration storageEmulatorUpdatableConfiguration;
if (!StorageEmulatorUpdatableConfiguration.TryGetFromUserProfile(true, out storageEmulatorUpdatableConfiguration))
{
storageEmulatorUpdatableConfiguration = new StorageEmulatorUpdatableConfiguration();
}
if (!string.IsNullOrEmpty(instanceName))
{
this.LogMessage(Resource.UserSpecifiedInstance, new object[0]);
DBProbe dBProbe = new DBProbe((string message) => this.LogMessage(message, new object[0]), (string message) => this.LogMessage(message, new object[0]));
try
{
if (!dBProbe.ProbeInstanceWithRetry(instanceName, 20, 10))
{
this.LogErrorAndThrowException(EmulatorErrorCode.UserSpecifiedSqlInstanceNotFound, null);
}
else
{
storageEmulatorUpdatableConfiguration.SqlInstance = instanceName;
this.server = storageEmulatorUpdatableConfiguration.SqlInstance;
storageEmulatorUpdatableConfiguration.WriteToUserProfile();
}
}
catch (ArgumentException argumentException)
{
this.LogError("SQL instance name is rejected as malformed: {0}", new object[] { instanceName });
this.LogErrorAndThrowException(EmulatorErrorCode.UserSpecifiedSqlInstanceNotFound, null);
}
}
return(storageEmulatorUpdatableConfiguration);
}
internal static PrerequisiteCheckResult CheckDbAccess(string sqlInstance)
{
PrerequisiteCheckResult prerequisiteCheckResult;
PrerequisiteCheckResult prerequisiteCheckResult1 = PrerequisiteCheckResult.None;
string masterConnectionString = StorageEmulatorUpdatableConfiguration.GetMasterConnectionString();
string storageEmulatorDBName = StorageEmulatorUpdatableConfiguration.GetStorageEmulatorDBName();
List <string> strs = new List <string>();
string name = WindowsIdentity.GetCurrent().Name;
char[] chrArray = new char[] { '\\' };
string[] strArrays = name.Split(chrArray, 2);
if ((int)strArrays.Length == 2)
{
string str = strArrays[1];
}
else
{
string str1 = strArrays[0];
}
using (SqlConnection sqlConnection = new SqlConnection(masterConnectionString))
{
sqlConnection.Open();
string str2 = string.Concat("SELECT HAS_DBACCESS('", storageEmulatorDBName, "')");
using (SqlCommand sqlCommand = new SqlCommand(str2, sqlConnection))
{
object obj = sqlCommand.ExecuteScalar();
if (!(obj is int))
{
prerequisiteCheckResult = PrerequisiteCheckResult.NoDatabaseAccess;
return(prerequisiteCheckResult);
}
else if ((int)obj != 1)
{
prerequisiteCheckResult = PrerequisiteCheckResult.NoDatabaseAccess;
return(prerequisiteCheckResult);
}
}
string str3 = string.Concat("USE ", storageEmulatorDBName, " SELECT IS_MEMBER ('db_datareader'),IS_MEMBER ('db_datawriter')");
int item = 0;
int num = 0;
using (SqlCommand sqlCommand1 = new SqlCommand(str3, sqlConnection))
{
using (SqlDataReader sqlDataReader = sqlCommand1.ExecuteReader())
{
if (sqlDataReader.HasRows)
{
while (sqlDataReader.Read())
{
item = (int)sqlDataReader[0];
num = (int)sqlDataReader[1];
}
}
prerequisiteCheckResult1 = (item != 1 || num != 1 ? PrerequisiteCheckResult.NoDatabaseAccess : PrerequisiteCheckResult.HasDatabaseAccess);
}
}
return(prerequisiteCheckResult1);
}
return(prerequisiteCheckResult);
}
internal static PrerequisiteCheckResult CheckSqlInstanceAndDatabase(out string sqlInstance)
{
PrerequisiteCheckResult prerequisiteCheckResult = PrerequisiteCheckResult.None;
string storageEmulatorDBName = StorageEmulatorUpdatableConfiguration.GetStorageEmulatorDBName();
sqlInstance = StorageEmulatorUpdatableConfiguration.GetSqlInstance();
string masterConnectionString = StorageEmulatorUpdatableConfiguration.GetMasterConnectionString();
int num = 10;
bool flag = true;
while (flag && num > 0)
{
flag = false;
num--;
using (SqlConnection sqlConnection = new SqlConnection(masterConnectionString))
{
try
{
try
{
Trace.WriteLine("Attempting to connect to db");
sqlConnection.Open();
using (SqlCommand sqlCommand = new SqlCommand("SELECT name FROM sys.databases WHERE name = @name", sqlConnection))
{
sqlCommand.Parameters.Add(new SqlParameter("@name", storageEmulatorDBName));
using (SqlDataReader sqlDataReader = sqlCommand.ExecuteReader())
{
prerequisiteCheckResult = (!sqlDataReader.HasRows ? PrerequisiteCheckResult.DatabaseNotInstalledOrLoginFailed : PrerequisiteCheckResult.DatabaseInstalled);
}
}
}
catch (SqlException sqlException)
{
if (sqlException.Number != 4060)
{
prerequisiteCheckResult = PrerequisiteCheckResult.SqlExpressInstanceNotInstalledOrRunning;
if (sqlInstance.Contains("(localdb)"))
{
flag = true;
}
}
else
{
prerequisiteCheckResult = PrerequisiteCheckResult.DatabaseNotInstalledOrLoginFailed;
}
}
}
finally
{
if (sqlConnection != null)
{
Trace.WriteLine(string.Format("Connection state is: {0}", sqlConnection.State));
SqlConnection.ClearPool(sqlConnection);
}
}
}
}
return(prerequisiteCheckResult);
}
private StorageEmulatorUpdatableConfiguration AutoDetectAndUpdate()
{
StorageEmulatorUpdatableConfiguration storageEmulatorUpdatableConfiguration;
if (!StorageEmulatorUpdatableConfiguration.TryGetFromUserProfile(true, out storageEmulatorUpdatableConfiguration))
{
storageEmulatorUpdatableConfiguration = new StorageEmulatorUpdatableConfiguration();
}
this.LogMessage(Resource.LocalDBCheckForInstall, new object[0]);
DBProbe dBProbe = new DBProbe((string message) => this.LogMessage(message, new object[0]), (string message) => this.LogMessage(message, new object[0]));
string str = this.CheckForLocalDB();
if (str == null)
{
this.LogMessage(Resource.LocalDBInstallNotFound, new object[0]);
try
{
if (!dBProbe.ProbeInstance("localhost\\SQLExpress", 2))
{
storageEmulatorUpdatableConfiguration.SqlInstance = string.Empty;
}
else
{
storageEmulatorUpdatableConfiguration.SqlInstance = "localhost\\SQLExpress";
}
}
catch (ArgumentException argumentException)
{
this.LogError("SQL default instance name was rejected: {0}", new object[] { "localhost\\SQLExpress" });
storageEmulatorUpdatableConfiguration.SqlInstance = string.Empty;
}
}
else
{
try
{
this.LogMessage(Resource.LocalDBInstallFound, new object[0]);
if (!dBProbe.ProbeInstanceWithRetry(str, 20, 10))
{
storageEmulatorUpdatableConfiguration.SqlInstance = string.Empty;
this.LogError(Resource.LocalDBInstalledButNotRunning, new object[0]);
}
else
{
storageEmulatorUpdatableConfiguration.SqlInstance = str;
}
}
catch (ArgumentException argumentException1)
{
this.LogError("LocalDB default instance name was rejected: {0}", new object[] { str });
storageEmulatorUpdatableConfiguration.SqlInstance = string.Empty;
this.LogError(Resource.LocalDBInstalledButNotRunning, new object[0]);
}
}
this.server = storageEmulatorUpdatableConfiguration.SqlInstance;
storageEmulatorUpdatableConfiguration.WriteToUserProfile();
return(storageEmulatorUpdatableConfiguration);
}
public string GetPageBlobRoot()
{
StorageEmulatorUpdatableConfiguration storageEmulatorUpdatableConfiguration;
StorageEmulatorUpdatableConfiguration.TryGetFromUserProfile(out storageEmulatorUpdatableConfiguration);
if (storageEmulatorUpdatableConfiguration == null)
{
throw new EmulatorException(EmulatorErrorCode.InitializationRequired);
}
string pageBlobRoot = storageEmulatorUpdatableConfiguration.PageBlobRoot;
if (!Directory.Exists(pageBlobRoot))
{
Directory.CreateDirectory(pageBlobRoot);
}
return(pageBlobRoot);
}
public void InitializeLogger()
{
string storageEmulatorDBName = StorageEmulatorUpdatableConfiguration.GetStorageEmulatorDBName();
string sqlInstance = StorageEmulatorUpdatableConfiguration.GetSqlInstance();
DevelopmentStorageDbDataContext.LogDirectory = StorageEmulatorUpdatableConfiguration.GetLogPath();
DevelopmentStorageDbDataContext.SqlInstance = sqlInstance;
DevelopmentStorageDbDataContext.DatabaseName = storageEmulatorDBName;
DevelopmentStorageDbDataContext.PageBlobRoot = this.GetPageBlobRoot();
DevelopmentStorageDbDataContext.BlockBlobRoot = this.GetBlockBlobRoot();
DevelopmentStorageDbDataContext.LinqToSqlLogStream = new LoggerProviderTextWriter();
if (StorageEmulatorUpdatableConfiguration.GetLoggingEnabled())
{
LoggerProvider.Instance = new FileLoggerProvider();
return;
}
LoggerProvider.Instance = new DummyLoggerProvider();
}
internal void PerformEmulatorInitialization()
{
StorageEmulatorUpdatableConfiguration storageEmulatorUpdatableConfiguration;
IStorageContext context = null;
try
{
using (EventWaitHandle eventWaitHandle = EventWaitHandle.OpenExisting("DevelopmentStorage-7580AFBB-2BEC-4269-B083-46C1361A69B0"))
{
this.LogErrorAndThrowException(EmulatorErrorCode.StopRequired, null);
}
}
catch (WaitHandleCannotBeOpenedException waitHandleCannotBeOpenedException)
{
}
if (this.reservePorts || this.unreservePorts)
{
try
{
foreach (string value in this.endpoints.Values)
{
if (!this.unreservePorts)
{
HttpReservation.ModifyReservation(value, this.username, true);
string addedReservation = Resource.AddedReservation;
object[] objArray = new object[] { value, this.username };
this.LogMessage(addedReservation, objArray);
}
else
{
if (!HttpReservation.TryDeleteReservation(value, this.username))
{
continue;
}
string removedReservation = Resource.RemovedReservation;
object[] objArray1 = new object[] { value, this.username };
this.LogMessage(removedReservation, objArray1);
}
}
}
catch (HttpReservationException httpReservationException)
{
string str = string.Format(Resource.ReservationFailed, httpReservationException.Message);
this.LogErrorAndThrowException(EmulatorErrorCode.ReservationFailed, str);
}
catch (IdentityNotMappedException identityNotMappedException1)
{
IdentityNotMappedException identityNotMappedException = identityNotMappedException1;
string str1 = string.Format(Resource.ReservationFailedIncorrectUser, this.username, identityNotMappedException.Message);
this.LogErrorAndThrowException(EmulatorErrorCode.ReservationFailedIncorrectUser, str1);
}
this.LogNewline();
}
if (!this.skipCreate)
{
context = this.GetContext();
try
{
this.CreateDatabaseAndGrantAccess(context);
if (!StorageEmulatorUpdatableConfiguration.TryGetFromUserProfile(out storageEmulatorUpdatableConfiguration))
{
storageEmulatorUpdatableConfiguration = new StorageEmulatorUpdatableConfiguration();
}
storageEmulatorUpdatableConfiguration.SqlInstance = this.server;
}
catch (SqlException sqlException1)
{
SqlException sqlException = sqlException1;
string str2 = string.Format(Resource.DatabaseCreationFailed, context.DatabaseName, sqlException.Message);
this.LogErrorAndThrowException(EmulatorErrorCode.DatabaseCreationFailed, str2);
}
catch (InvalidOperationException invalidOperationException1)
{
InvalidOperationException invalidOperationException = invalidOperationException1;
string str3 = string.Format(Resource.DatabaseCreationFailed, context.DatabaseName, invalidOperationException.Message);
this.LogErrorAndThrowException(EmulatorErrorCode.DatabaseCreationFailed, str3);
}
catch (IOException oException1)
{
IOException oException = oException1;
string str4 = string.Format(Resource.DatabaseCreationFailed, context.DatabaseName, oException.Message);
this.LogErrorAndThrowException(EmulatorErrorCode.DatabaseCreationFailed, str4);
}
catch (Exception exception1)
{
Exception exception = exception1;
string str5 = string.Format(Resource.DatabaseCreationFailed, context.DatabaseName, exception.Message);
this.LogErrorAndThrowException(EmulatorErrorCode.DatabaseCreationFailed, str5);
}
this.LogNewline();
}
this.LogMessage(Resource.ActionsSucceeded, new object[0]);
}