/// <summary>
/// Fetches the current status.
/// </summary>
public static ReplicaSetStatus GetStatus()
{
if (!RoleEnvironment.IsAvailable)
{
return(GetDummyStatus());
}
var settings = ConnectionUtilities.GetMongoClientSettings(
ReadPreference.SecondaryPreferred);
var client = new MongoClient(settings);
var server = client.GetServer();
try
{
var result = server.GetDatabase("admin").RunCommand("replSetGetStatus");
return(ParseStatus(result.Response));
}
catch (IOException ie)
{
return(new ReplicaSetStatus {
Status = State.Error, Error = ie
});
}
catch (MongoException e)
{
return(new ReplicaSetStatus {
Status = State.Error, Error = e
});
}
}
internal static int ReconfigReplicaSet(string replicaSetName, int port)
{
var replicaSetRoleCount = RoleEnvironment.Roles[currentRoleName].Instances.Count;
var version = GetReplicaSetConfigVersion(port);
var cfg = CreateReplicaSetConfiguration(replicaSetName, port, replicaSetRoleCount, false);
cfg.Add("version", ++version);
var reconfigCommand = new CommandDocument {
{ "replSetReconfig", cfg }
};
var clientSettings = ConnectionUtilities.GetMongoClientSettings();
var client = new MongoClient(clientSettings);
var server = client.GetServer();
try
{
var result = server.GetDatabase("admin").RunCommand(reconfigCommand);
}
catch (Exception e)
{
// no primary?
DiagnosticsHelper.TraceWarning(e.Message);
}
return(replicaSetRoleCount);
}
internal static void RunInitializeCommandLocally(
string rsName,
int port)
{
var replicaSetRoleCount = RoleEnvironment.Roles[currentRoleName].Instances.Count;
var membersDocument = new BsonArray();
for (int i = 0; i < replicaSetRoleCount; i++)
{
EnsureMongodIsListening(rsName, i, port);
membersDocument.Add(new BsonDocument {
{ "_id", i },
{ "host", RoleEnvironment.IsEmulated
? string.Format(Settings.LocalHostString, (port + i))
: ConnectionUtilities.GetNodeAlias(rsName, i) }
});
}
var cfg = new BsonDocument {
{ "_id", rsName },
{ "members", membersDocument }
};
var initCommand = new CommandDocument {
{ "replSetInitiate", cfg }
};
var server = GetLocalSlaveOkConnection(port);
var result = server["admin"].RunCommand(initCommand);
}
private static BsonDocument CreateReplicaSetConfiguration(
string rsName,
int port,
int replicaSetRoleCount,
bool ensureNodesAreListening)
{
var membersDocument = new BsonArray();
for (int i = 0; i < replicaSetRoleCount; i++)
{
if (ensureNodesAreListening)
{
EnsureMongodIsListening(rsName, i, port);
}
membersDocument.Add(new BsonDocument {
{ "_id", i },
{ "host", RoleEnvironment.IsEmulated
? string.Format(Settings.LocalHostString, (port + i))
: ConnectionUtilities.GetNodeAlias(rsName, i) }
});
}
var cfg = new BsonDocument {
{ "_id", rsName },
{ "members", membersDocument }
};
return(cfg);
}
internal static void EnsureMongodIsListening(string rsName, int instanceId, int mongodPort)
{
var alias = ConnectionUtilities.GetNodeAlias(rsName, instanceId);
var commandSucceeded = false;
while (!commandSucceeded)
{
try
{
MongoServer conn;
if (RoleEnvironment.IsEmulated)
{
conn = DatabaseHelper.GetLocalSlaveOkConnection(mongodPort + instanceId);
}
else
{
conn = DatabaseHelper.GetSlaveOkConnection(alias, mongodPort);
}
conn.Connect(new TimeSpan(0, 0, 5));
commandSucceeded = true;
}
catch (Exception e)
{
DiagnosticsHelper.TraceInformation(e.Message);
commandSucceeded = false;
}
}
}
private static bool Run(string command, string arg)
{
// Ensure they're running a valid command first.
if (!new List <string> {
"snapshot", "snapshotAndBackup", "backup"
}.Contains(command))
{
Console.WriteLine("Error: command \"" + command + "\" not recognized.");
PrintUsage();
return(false);
}
// Determine which actions we need to run.
command = command.ToLower();
bool doSnapshot = command.Contains("snapshot");
bool doBackup = command.Contains("backup");
// Part 1: Snapshot (or read the URI from the arguments).
Uri snapshotUri = null;
if (doSnapshot)
{
var mongoDBRoleCount = ConnectionUtilities.GetDatabaseWorkerRoles().Count;
int instanceId = 0;
bool isInt = int.TryParse(arg, out instanceId);
if (!isInt || instanceId < 0 || instanceId > (mongoDBRoleCount - 1))
{
Console.WriteLine("ERROR: \"{0}\" is not a valid instance number.", arg);
return(false);
}
else
{
snapshotUri = Snapshot(instanceId);
}
}
else
{
try
{
snapshotUri = new Uri(arg);
}
catch (Exception e)
{
Console.WriteLine("Invalid snapshot URL specified. Error {0}", e.Message);
return(false);
}
}
// Part 2: Backup.
if (doBackup)
{
return(Backup(snapshotUri));
}
else
{
return(true); // Already done.
}
}
public override bool OnStart()
{
DiagnosticsHelper.TraceInformation("MongoWorkerRole onstart called");
// For information on handling configuration changes
// see the MSDN topic at http://go.microsoft.com/fwlink/?LinkId=166357.
// Set the maximum number of concurrent connections
ServicePointManager.DefaultConnectionLimit = 12;
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
});
RoleEnvironment.Changing += RoleEnvironmentChanging;
RoleEnvironment.Changed += RoleEnvironmentChanged;
replicaSetName = RoleEnvironment.GetConfigurationSettingValue(Constants.ReplicaSetNameSetting);
instanceId = ConnectionUtilities.ParseNodeInstanceId(RoleEnvironment.CurrentRoleInstance.Id);
DiagnosticsHelper.TraceInformation("ReplicaSetName={0}, InstanceId={1}",
replicaSetName, instanceId);
SetHostAndPort();
DiagnosticsHelper.TraceInformation("Obtained host={0}, port={1}", mongodHost, mongodPort);
StartMongoD();
DiagnosticsHelper.TraceInformation("Mongod process started");
// Need to ensure MongoD is up here
DatabaseHelper.EnsureMongodIsListening(replicaSetName, instanceId, mongodPort);
if ((instanceId == 0) && !DatabaseHelper.IsReplicaSetInitialized(mongodPort))
{
try
{
DatabaseHelper.RunInitializeCommandLocally(replicaSetName, mongodPort);
DiagnosticsHelper.TraceInformation("RSInit issued successfully");
}
catch (MongoCommandException e)
{
//Ignore exceptions caught on rs init for now
DiagnosticsHelper.TraceWarning(
"Exception {0} on RSInit with {1}",
e.Message, e.StackTrace);
}
}
DiagnosticsHelper.TraceInformation("Done with OnStart");
return(true);
}
/// <summary>
/// Snapshots the data drive of the given instance number.
/// </summary>
/// <param name="instanceNum">The number of the instance to snapshot.</param>
/// <param name="credential">The Azure Storage credential string to use</param>
/// <param name="replicaSetName">The name of the MongoDB replica set</param>
public static Uri MakeSnapshot(int instanceNum, string credential, string replicaSetName)
{
var client = CloudStorageAccount.Parse(credential).CreateCloudBlobClient();
// Load the blob...
var container = client.GetContainerReference(ConnectionUtilities.GetDataContainerName(replicaSetName));
var blob = container.GetPageBlobReference(String.Format(Constants.MongoDataBlobName, instanceNum));
// Snapshot it.
var snapshot = blob.CreateSnapshot();
return(GetSnapshotUri(snapshot));
}
/// <summary>
/// Returns all the snapshots available.
/// </summary>
/// <param name="credential">The Azure Storage credential string to use</param>
/// <param name="replicaSetName">The name of the MongoDB replica set</param>
public static List <CloudBlob> GetSnapshots(string credential, string replicaSetName)
{
var client = CloudStorageAccount.Parse(credential).CreateCloudBlobClient();
// Load the container.
var container = client.GetContainerReference(ConnectionUtilities.GetDataContainerName(replicaSetName));
// Collect all the snapshots!
return(container.ListBlobs(new BlobRequestOptions()
{
BlobListingDetails = BlobListingDetails.Snapshots,
UseFlatBlobListing = true
}).Select(item => ((CloudBlob)item)).Where(item => item.SnapshotTime.HasValue).ToList());
}
private static AvailableNodes GetAvailableNodes(string rsName)
{
var nodes = new AvailableNodes();
foreach (var instance in RoleEnvironment.Roles[Constants.MongoDBWorkerRoleName].Instances)
{
nodes.Add(new NodeAlias()
{
Alias = ConnectionUtilities.GetNodeAlias(rsName, ConnectionUtilities.ParseNodeInstanceId(instance.Id)),
IpAddress = instance.InstanceEndpoints[Constants.MongodPortSetting].IPEndpoint.Address.ToString()
});
}
return(nodes);
}
/// <summary>
/// Attempts opening a MongoDBWorkspace from its connection file path
/// </summary>
/// <param name="wksString">the path to a connection file</param>
/// <returns>a mongodbworkspace</returns>
public MongoDBWorkspace OpenMongoDBWorkspace(string wksString)
{
MongoDatabase mDB;
try
{
string connString = ConnectionUtilities.DecodeConnFile(wksString);
MongoDBConnInfo connInfo = ConnectionUtilities.ParseConnectionString(connString);
mDB = ConnectionUtilities.OpenConnection(connInfo);
}
catch (Exception e)
{
throw new COMException(e.Message);
}
return(new MongoDBWorkspace(mDB));
}
private static int defaultTimeIntervalBetweenUpdates = 15; // in seconds
static void Main(string[] args)
{
try
{
Trace.TraceInformation("Starting host file updater");
if ((!RoleEnvironment.IsAvailable) || (RoleEnvironment.IsEmulated))
{
Trace.TraceInformation("Not in a deployed environment. Nothing to do. Exiting");
return;
}
int timeInSeconds = defaultTimeIntervalBetweenUpdates;
if (args.Length > 0)
{
if (!Int32.TryParse(args[0], out timeInSeconds))
{
timeInSeconds = defaultTimeIntervalBetweenUpdates;
}
}
CloudStorageAccount.SetConfigurationSettingPublisher((configName, configSetter) =>
{
configSetter(RoleEnvironment.GetConfigurationSettingValue(configName));
});
var rsName = ConnectionUtilities.GetReplicaSetName();
Trace.TraceInformation("Replica set name is {0}", rsName);
while (true)
{
UpdateWinhostsFile(rsName);
Thread.Sleep(timeInSeconds * 1000);
}
}
catch (Exception e)
{
Trace.TraceError("Exception {0} and stack trace{1} and inner exception {2}", e.Message, e.StackTrace, e.InnerException);
}
finally
{
Trace.Flush();
}
}
private string GetMongoDataDirectory()
{
DiagnosticsHelper.TraceInformation("Getting db path");
var dataBlobName = string.Format(Constants.MongoDataBlobName, instanceId);
var containerName = ConnectionUtilities.GetDataContainerName(replicaSetName);
mongodDataDriveLetter = Utilities.GetMountedPathFromBlob(
Settings.LocalCacheDirSetting,
Constants.MongoDataCredentialSetting,
containerName,
dataBlobName,
Settings.MaxDBDriveSizeInMB,
out mongoDataDrive);
DiagnosticsHelper.TraceInformation("Obtained data drive as {0}", mongodDataDriveLetter);
var dir = Directory.CreateDirectory(Path.Combine(mongodDataDriveLetter, @"data"));
DiagnosticsHelper.TraceInformation("Data directory is {0}", dir.FullName);
return(dir.FullName);
}
/// <summary>
/// Fetches the current status.
/// </summary>
public static ReplicaSetStatus GetStatus()
{
if (!RoleEnvironment.IsAvailable)
{
return(GetDummyStatus());
}
var connection = MongoServer.Create(ConnectionUtilities.GetConnectionSettings(true));
try
{
return(ParseStatus(connection["admin"]["$cmd"].FindOne(Query.EQ("replSetGetStatus", 1))));
}
catch (Exception e)
{
return(new ReplicaSetStatus {
Status = State.Error, Error = e
});
}
}
/// <summary>
/// Determins whether a string represents a workspace
/// Note that workspace strings are file paths to conn files in this plugin
/// </summary>
/// <param name="wksString">the string (i.e. path to conn file)</param>
/// <returns>whether it is or not</returns>
public bool IsWorkspace(string wksString)
{
bool retVal = false;
try
{
if (Directory.Exists(wksString))
{
return(Directory.GetFiles(wksString, "*.mongoconn").Length > 0);
}
string connString = ConnectionUtilities.DecodeConnFile(wksString);
MongoDBConnInfo connInfo = ConnectionUtilities.ParseConnectionString(connString);
ConnectionUtilities.OpenConnection(connInfo);
retVal = true;
}
catch (Exception)
{
// this just means this isn't a proper string
}
return(retVal);
}
public override bool ReadAsync(TransportAsyncCallbackArgs args)
{
this.ThrowIfNotOpen();
Fx.AssertAndThrow(args.Buffer != null, "must have buffer to read");
Fx.AssertAndThrow(args.CompletedCallback != null, "must have a valid callback");
Fx.AssertAndThrow(args.Count <= this.asyncReadBufferSize, Resources.ClientWebSocketTransportReadBufferTooSmall);
ConnectionUtilities.ValidateBufferBounds(args.Buffer, args.Offset, args.Count);
args.Exception = null;
if (this.asyncReadBufferOffset > 0)
{
Fx.AssertAndThrow(this.remainingBytes > 0, "Must have data in buffer to transfer");
this.TransferData(this.remainingBytes, args);
return(false);
}
IAsyncResult asyncResult = this.webSocket.BeginReceive(this.asyncReadBuffer, 0, this.asyncReadBufferSize, TimeSpan.FromMinutes(1), this.onReadComplete, args);
if (!asyncResult.CompletedSynchronously)
{
return(true);
}
this.HandleReadComplete(asyncResult);
return(false);
}
public static ReplicaSetStatus GetReplicaSetStatus()
{
ReplicaSetStatus status;
var settings = ConnectionUtilities.GetMongoClientSettings(ReadPreference.SecondaryPreferred);
var client = new MongoClient(settings);
var server = client.GetServer();
try
{
var result = server.GetDatabase("admin").RunCommand("replSetGetStatus");
var response = result.Response;
BsonValue startupStatus;
if (response.TryGetValue("startupStatus", out startupStatus))
{
status = new ReplicaSetStatus("Replica Set Initializing");
return(status);
}
status = new ReplicaSetStatus((string)response.GetValue("set"));
var value = response.GetElement("members");
var members = value.Value.AsBsonArray;
foreach (BsonDocument member in members)
{
var node = new ServerStatus();
foreach (BsonElement bsonElement in member.Elements)
{
switch (bsonElement.Name)
{
case "_id":
node.id = bsonElement.Value.ToInt32();
break;
case "name":
node.name = bsonElement.Value.ToString();
break;
case "health":
node.health = bsonElement.Value.ToInt32() == 0 ? "DOWN" : "UP";
break;
case "state":
node.state = bsonElement.Value.ToInt32();
if (node.state == 1)
{
node.lastHeartbeat = "Not Applicable";
node.pingMS = "Not Applicable";
}
break;
case "stateStr":
node.stateStr = bsonElement.Value.ToString();
break;
case "uptime":
break;
case "lastHeartbeat":
var hearbeat = bsonElement.Value.ToUniversalTime();
if (hearbeat != null)
{
node.lastHeartbeat = hearbeat.ToString("yyyy-MM-dd HH:mm tt");
}
break;
case "optimeDate":
node.optimeDate = bsonElement.Value.ToUniversalTime();
break;
case "pingMs":
Double pingTime = bsonElement.Value.AsInt32;
node.pingMS = pingTime.ToString(CultureInfo.InvariantCulture);
break;
}
}
status.servers.Add(node);
}
}
catch (MongoException me)
{
status = new ReplicaSetStatus(string.Format(
"Replica Set Unavailable due to {0}", me.Message));
}
return(status);
}
public static ReplicaSetStatus GetReplicaSetStatus()
{
ReplicaSetStatus status;
var settings = ConnectionUtilities.GetConnectionSettings( );
settings.SlaveOk = true;
var server = MongoServer.Create(settings);
try
{
var result = server["admin"].RunCommand("replSetGetStatus");
var response = result.Response;
BsonValue startupStatus;
if (response.TryGetValue("startupStatus", out startupStatus))
{
status = new ReplicaSetStatus("Replica Set Initializing");
return(status);
}
status = new ReplicaSetStatus((string)response.GetValue("set"));
var value = response.GetElement("members");
var members = value.Value.AsBsonArray;
foreach (BsonDocument member in members)
{
var node = new ServerStatus();
foreach (BsonElement bsonElement in member.Elements)
{
switch (bsonElement.Name)
{
case "_id":
node.id = bsonElement.Value.ToInt32();
break;
case "name":
node.name = bsonElement.Value.ToString();
break;
case "health":
node.health = bsonElement.Value.ToInt32() == 0 ? "DOWN" : "UP";
break;
case "state":
node.state = bsonElement.Value.ToInt32();
if (node.state == 1)
{
node.lastHeartbeat = "Not Applicable";
node.pingMS = "Not Applicable";
}
break;
case "stateStr":
node.stateStr = bsonElement.Value.ToString();
break;
case "uptime":
break;
case "lastHeartbeat":
var hearbeat = bsonElement.Value.AsDateTime;
if (hearbeat != null)
{
node.lastHeartbeat = hearbeat.ToString("yyyy-MM-dd HH:mm tt");
}
break;
case "optimeDate":
node.optimeDate = bsonElement.Value.AsDateTime;
break;
case "pingMs":
Double pingTime = bsonElement.Value.AsInt32;
node.pingMS = pingTime.ToString(CultureInfo.InvariantCulture);
break;
}
}
status.servers.Add(node);
}
}
catch
{
status = new ReplicaSetStatus("Replica Set Unavailable");
}
return(status);
}
/// <summary>
/// Occurs when this command is clicked
/// </summary>
public override void OnClick()
{
try
{
IMongoDbDialogVM dbDialog = UIUtils.GetDialogVM();
ButtonInfo okBtn;
okBtn.OnClick = (() =>
{
string connString = dbDialog.File;
if (String.IsNullOrEmpty(connString))
{
return;
}
string selectedFC = dbDialog.GetSelectedFCName();
if (String.IsNullOrEmpty(selectedFC))
{
return;
}
//get the type using the ProgID
Type t = Type.GetTypeFromProgID("esriGeoDatabase.MongoDBPluginWorkspaceFactory");
//Use activator in order to create an instance of the workspace factory
IWorkspaceFactory workspaceFactory = (IWorkspaceFactory)Activator.CreateInstance(t);
IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)workspaceFactory.OpenFromFile(connString, 0);
//get a featureclass from the workspace
IFeatureClass featureClass = featureWorkspace.OpenFeatureClass(selectedFC);
//create a new feature layer and add it to the map
IFeatureLayer featureLayer = new FeatureLayerClass();
featureLayer.Name = featureClass.AliasName;
featureLayer.FeatureClass = featureClass;
m_hookHelper.FocusMap.AddLayer((ILayer)featureLayer);
dbDialog.Close();
});
okBtn.IsEnabled = null;
dbDialog.SetOk(okBtn);
ButtonInfo cancelBtn;
cancelBtn.OnClick = () =>
{
dbDialog.Close();
};
cancelBtn.IsEnabled = null;
dbDialog.SetCancel(cancelBtn);
ButtonInfo browseBtn;
browseBtn.OnClick = () =>
{
string result = UIUtils.BrowseToFile(null, "Connection File to MongoDB (.mongoconn)|*.mongoconn", false);
if (String.IsNullOrEmpty(result))
{
return;
}
string connInfoStr = ConnectionUtilities.DecodeConnFile(result);
MongoDBConnInfo connInfo = ConnectionUtilities.ParseConnectionString(connInfoStr);
dbDialog.DatabaseText = connInfo.DBName;
dbDialog.ServerText = connInfo.Connection.ToString();
dbDialog.File = result;
//get the type using the ProgID
Type t = Type.GetTypeFromProgID("esriGeoDatabase.MongoDBPluginWorkspaceFactory");
//Use activator in order to create an instance of the workspace factory
IWorkspaceFactory workspaceFactory = (IWorkspaceFactory)Activator.CreateInstance(t);
IFeatureWorkspace featureWorkspace = (IFeatureWorkspace)workspaceFactory.OpenFromFile(result, 0);
IEnumDatasetName ipNames = ((IWorkspace)featureWorkspace).get_DatasetNames(esriDatasetType.esriDTFeatureClass);
List <string> dsNames = new List <string>();
IDatasetName ipCurr = ipNames.Next();
while (ipCurr != null)
{
dsNames.Add(ipCurr.Name);
ipCurr = null;
ipCurr = ipNames.Next();
}
dbDialog.ClearFCList();
if (dsNames.Count > 0)
{
dbDialog.SetFCNames(dsNames);
}
};
browseBtn.IsEnabled = null;
dbDialog.SetBrowse(browseBtn);
UIUtils.DisplayMongoBrowseDialog(dbDialog);
}
catch (Exception ex)
{
System.Diagnostics.Trace.WriteLine(ex.Message);
}
}
/// <summary>
/// Occurs when this command is clicked
/// </summary>
public override void OnClick()
{
try
{
IMongoDbLoaderDlgVm dbDialog = UIUtils.GetLoaderVM();
ButtonInfo browseBtn;
browseBtn.OnClick = () =>
{
string result = UIUtils.BrowseToFile(null, "Connection File to MongoDB (.mongoconn)|*.mongoconn", false);
if (String.IsNullOrEmpty(result))
{
return;
}
string connInfoStr = ConnectionUtilities.DecodeConnFile(result);
MongoDBConnInfo connInfo = ConnectionUtilities.ParseConnectionString(connInfoStr);
dbDialog.DatabaseText = connInfo.DBName;
dbDialog.ServerText = connInfo.Connection.ToString();
dbDialog.File = result;
};
browseBtn.IsEnabled = null;
dbDialog.SetBrowse(browseBtn);
IGxObject ipSelectedItem = null;
ButtonInfo browseToFC;
browseToFC.OnClick = () =>
{
IGxDialog ipBrowser = new GxDialog();
ipBrowser.ObjectFilter = (IGxObjectFilter) new GxFilterPointFeatureClasses();
ipBrowser.AllowMultiSelect = false;
IEnumGxObject ipTempSelected;
if (ipBrowser.DoModalOpen(0, out ipTempSelected))
{
if (null != ipTempSelected)
{
ipSelectedItem = ipTempSelected.Next();
dbDialog.FCConn = ipSelectedItem.FullName;
}
}
};
browseToFC.IsEnabled = null;
dbDialog.SetSourceBrowse(browseToFC);
ButtonInfo okBtn;
okBtn.OnClick = (() =>
{
if (ipSelectedItem == null)
{
return;
}
string connString = dbDialog.File;
if (String.IsNullOrEmpty(connString))
{
return;
}
dbDialog.Close();
IName ipSrcName = ipSelectedItem.InternalObjectName;
IFeatureClass ipSrc = (IFeatureClass)ipSrcName.Open();
IEnvelope ipExtent = ((IGeoDataset)ipSrc).Extent;
MongoDBWorkspacePluginFactory factory = new MongoDBWorkspacePluginFactory();
MongoDBWorkspace ws = factory.OpenMongoDBWorkspace(connString);
MongoDBDataset target = ws.CreateDataset(ipSelectedItem.BaseName, DataLoadUtilities.GetCreatableFields(ipSrc.Fields), ipExtent);
DataLoadUtilities.LoadData(ipSrc, target);
});
okBtn.IsEnabled = null;
dbDialog.SetOk(okBtn);
ButtonInfo cancelBtn;
cancelBtn.OnClick = () =>
{
dbDialog.Close();
};
cancelBtn.IsEnabled = null;
dbDialog.SetCancel(cancelBtn);
UIUtils.DisplayLoaderDialog(dbDialog);
}
catch (Exception ex)
{
System.Diagnostics.Trace.WriteLine(ex.Message);
}
}
