//INTERFACE
/// <summary>
/// Load statistics configuration from given file.
/// Creates gatheres writing configuration to files.
/// </summary>
/// <param name="statisticsFileName">Name of file to read configuration from.</param>
public static void Load(string statisticsFileName)
{
string progressText = string.Format("Reading statistics gatherers from {0}.", Configuration.Files.StatisticsFile);
ProgressLogger.Starting(progressText);
gatherers = new List <Gatherer>();
XmlDocument document = new XmlDocument();
document.Load(statisticsFileName);
XmlNode main = document[statisticsTag];
foreach (XmlNode node in main.ChildNodes)
{
switch (node.Name)
{
case Gatherer.GathererTag:
gatherers.Add(Gatherer.Create(node));
break;
default:
throw new ArgumentException("Unknown XML node: " + node.Name);
}
}
ProgressLogger.Finished(progressText);
}
//HELPERS
static void loadElements()
{
string progressText = string.Format("Loading network elements from {0}.", Configuration.Files.NetworkFile);
ProgressLogger.Starting(progressText);
XmlDocument document = new XmlDocument();
document.Load(Configuration.Files.NetworkFile);
XmlNode network = XmlParser.GetChildNode(document, networkTag);
foreach (XmlNode element in network.ChildNodes)
{
switch (element.Name)
{
case Node.NodeTag:
new Node(element);
break;
case Link.LinkTag:
new Link(element);
break;
default:
XmlParser.ThrowUnknownNode(element);
break;
}
}
ProgressLogger.Finished(progressText);
}
// This method is used to login using the credentials captured from UI after assigning the account
public bool LogInUsingCredsAfterAssignAccount(ProgressLogger logger, string userName, string userPassword)
{
bool flag = false;
try
{
UserSetFunctions.EnterText(GenericUtils.WaitForElementPresence(driver, userLoginName, 15), userName);
UserSetFunctions.EnterText(GenericUtils.WaitForElementPresence(driver, userLoginPassword, 15), userPassword);
UserSetFunctions.Click(GenericUtils.WaitForElementPresence(driver, userLoginButton, 15));
if (driver.Title.ToLower().Equals(apexWebTitle.ToLower()))
{
flag = true;
}
if (flag)
{
logger.LogCheckPoint(String.Format(LogMessage.VerifyLoginAfterAssignAccountPassed, userName));
Thread.Sleep(2000);
LogOut();
}
else
{
logger.LogCheckPoint(String.Format(LogMessage.VerifyLoginAfterAssignAccountFailed, userName));
}
}
catch (Exception)
{
throw;
}
return(flag);
}
private string UserLogin(ProgressLogger logger, string userName, string userServerName, bool changeServerOnly = false)
{
try
{
string defaultSelectedServer;
username = data.UserPortal.Users[userName].UserName;
password = data.UserPortal.Users[userName].Password;
IWebElement serverWebElement = driver.FindElement(selectServer);
SelectElement selectObj = new SelectElement(serverWebElement);
defaultSelectedServer = selectObj.SelectedOption.Text;
Thread.Sleep(1000);
if (!(userServerName.Equals(defaultSelectedServer)))
{
UserSetFunctions.SelectDropdown(serverWebElement, userServerName);
}
Thread.Sleep(1000);
if (changeServerOnly)
{
return(null);
}
UserSetFunctions.EnterText(GenericUtils.WaitForElementPresence(driver, userLoginName, 15), username);
UserSetFunctions.EnterText(GenericUtils.WaitForElementPresence(driver, userLoginPassword, 15), password);
UserSetFunctions.Click(GenericUtils.WaitForElementPresence(driver, userLoginButton, 15));
Assert.Equal(driver.Title.ToLower(), apexWebTitle.ToLower());
logger.LogCheckPoint(string.Format(LogMessage.UserLoggedInSuccessfully, username));
Thread.Sleep(2000);
return(username);
}
catch (Exception)
{
throw;
}
}
/// <summary>
/// Runs event loop till either current time is greater than passed endTime or there are no more scheduled events.
/// </summary>
/// <param name="endTime">Simulation time indicating when to stop simulation.</param>
public static void Run()
{
whenStarted = DateTime.Now;
const string progressText = "Simulating.";
ProgressLogger.Starting(progressText);
ProgressLogger.Progress();
lastShown = DateTime.Now;
while(events.Count>0 && currentTime <= simulationTime)
{
//show progress
if (lastShown + showingDelay < DateTime.Now)
{
ProgressLogger.Progress();
lastShown = DateTime.Now;
}
++loopNumber;
//next event;
TimerEntryImplementation entry = events.DeleteMin();
currentTime = entry.Time;
entry.Method(entry);
}
if (events.Count == 0)
{
Console.WriteLine("No more events to handle.");
}
if (currentTime > simulationTime)
{
Console.WriteLine("Simulation came to its end time.");
}
ProgressLogger.Finished(progressText);
}
//This method will login to admin portal
public void AdminLogIn(ProgressLogger logger, string userName = Const.ADMIN1)
{
try
{
username = data.AdminPortal.Users[userName].UserName;
password = data.AdminPortal.Users[userName].Password;
string userUrl = data.AdminPortal.PortalUrl;
string userServerName = data.AdminPortal.PortalServerUrl;
driver.Navigate().GoToUrl(userUrl);
driver.Manage().Timeouts().ImplicitWait = TimeSpan.FromSeconds(20);
driver.Manage().Window.Size = new Size(1366, 768);
UserSetFunctions.EnterText(AdminUserName(), username);
UserSetFunctions.EnterText(AdminUserPassword(), password);
UserSetFunctions.Click(AdminSignIn());
Assert.Equal(driver.Title.ToLower(), Const.AdminLoginTitle.ToLower());
logger.LogCheckPoint(String.Format(LogMessage.AdminLoginSuccessfullMsg, userName));
Thread.Sleep(2000);
}
catch (Exception)
{
throw;
}
}
// This method is used to login using the credentials captured from UI after unassigning the account
public bool LogInUsingCredsAfterUnassignAccount(ProgressLogger logger, string userName, string userPassword)
{
bool flag = false;
try
{
UserSetFunctions.EnterText(GenericUtils.WaitForElementPresence(driver, userLoginName, 15), userName);
UserSetFunctions.EnterText(GenericUtils.WaitForElementPresence(driver, userLoginPassword, 15), userPassword);
UserSetFunctions.Click(GenericUtils.WaitForElementPresence(driver, userLoginButton, 15));
//When trying to login using credential after unassigining the account then page is showing blank
//So in case we have used below condition to check login.
//Once login failed error messges shows then use below comment code in if condition
//LoginErrorMsg().Text.Equals(Const.LoginErrroMsg)
if (driver.Title.ToLower().Equals(apexWebTitle.ToLower()))
{
flag = true;
}
if (flag)
{
logger.LogCheckPoint(String.Format(LogMessage.VerifyLoginAfterUnassignAccountPassed, userName));
}
else
{
logger.LogCheckPoint(String.Format(LogMessage.VerifyLoginAfterUnassignAccountFailed, userName));
}
}
catch (Exception)
{
throw;
}
return(flag);
}
public static void ShutDown()
{
const string progressText = "Shutting down network.";
ProgressLogger.Starting(progressText);
identificables.Clear();
ProgressLogger.Finished(progressText);
}
//INTERFACE
/// <summary>
/// Some parameters can be passed in console command. Analyze them here before moving to reading configuration from XML files.
/// </summary>
/// <param name="arguments">Aguments passed to Main method.</param>
public static void AnalyzeConsoleInput(string[] arguments)
{
const string progressText = "Analyzing console arguments.";
ProgressLogger.Starting(progressText);
Files.AnalyzeConsoleArguments(arguments);
ProgressLogger.Finished(progressText);
}
//HELPERS
static void Main(string[] arguments)
{
try
{
//set some console parameters and write a big "Welcome" :)
Console.ForegroundColor = ConsoleColor.White;
Console.BackgroundColor = ConsoleColor.Black;
Console.WriteLine("Welcome to {0}!", programName);
Console.WriteLine();
//the default color of displayed informations is green
Console.ForegroundColor = ConsoleColor.Green;
string progressText = "Running application.";
ProgressLogger.Starting(progressText);
//load all services
Configuration.AnalyzeConsoleInput(arguments);
Configuration.Load(Configuration.Files.ConfigurationFile);
Timer.SimulationTime = Configuration.Simulation.SimulationTime;
Logger.Initialize(Configuration.Files.LogFile);
Network.Load(Configuration.Files.NetworkFile);
Statistics.Load(Configuration.Files.StatisticsFile);
//run simulation
Timer.Run();
//shut down all services
Statistics.ShutDown();
Network.ShutDown();
Logger.ShutDown();
//log end
ProgressLogger.Finished(progressText);
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.White;
Console.WriteLine("Bye!");
}
#if (!DEBUG)
catch (Exception exception)
{
Console.ForegroundColor = ConsoleColor.Red;
Console.WriteLine();
Console.WriteLine();
Console.WriteLine("An exception occured:");
Console.WriteLine();
Console.WriteLine(exception.Message);
Console.WriteLine();
Console.ForegroundColor = ConsoleColor.Magenta;
Console.WriteLine(exception.StackTrace);
Logger.ShutDown();
}
#endif
finally
{
//reset console to normal state
Console.ResetColor();
}
}
public static void Initialize(string logFileName)
{
const string progressText = "Initializing logging.";
ProgressLogger.Starting(progressText);
logFile = new StreamWriter(logFileName, false);
logFile.AutoFlush = true;
ProgressLogger.Finished(progressText);
}
/// <summary>
/// Writes the limits to the sdf file
/// </summary>
/// <param name="log">logger to write messages to</param>
/// <param name="writer">the writer to write the file with</param>
protected override void WriteLimits(ProgressLogger log, XmlWriter writer)
{
writer.WriteStartElement("limit");
{
SDFExporter.writeSDFElement(writer, "upper", (UpperLimit*ThreadPitch).ToString());
SDFExporter.writeSDFElement(writer, "lower", (LowerLimit*ThreadPitch).ToString());
SDFExporter.writeSDFElement(writer, "effort", EffortLimit.ToString());
}
writer.WriteEndElement();
}
//INTERFACE
public static void Load(string networkFileName)
{
const string progressText = "Loading network.";
ProgressLogger.Starting(progressText);
loadElements();
connectElements();
configureElements();
ProgressLogger.Finished(progressText);
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (disposing)
{
if (_logger != null)
_logger.Dispose();
_logger = null;
}
}
// Login with a user and cancell all placed orders
public static void LoginAndCancelAllOrders(ProgressLogger logger, IWebDriver driver, string instrument, string loginUser)
{
UserFunctions userFunctions = new UserFunctions(logger);
userFunctions.LogIn(logger, loginUser);
Thread.Sleep(2000);
DashBoardMenuButton(driver);
SelectAnExchange(driver);
SelectInstrumentFromExchange(instrument, driver);
CancelAllOrders(driver);
}
public static void PrintUpdateInfo()
{
try
{
// ProgramLog.Log ("Attempting to retreive Build Info...");
var buildInfo = String.Empty;
using (var ctx = new WebClient())
{
using (var prog = new ProgressLogger(100, "Downloading build information..."))
{
var signal = new System.Threading.AutoResetEvent(false);
ctx.DownloadProgressChanged += (sender, args) =>
{
prog.Value = args.ProgressPercentage;
};
ctx.DownloadStringCompleted += (sender, args) =>
{
var arg = args as DownloadStringCompletedEventArgs;
buildInfo = arg.Result;
signal.Set();
};
ctx.DownloadStringAsync(new Uri(UpdateInfo));
signal.WaitOne();
}
}
if (String.IsNullOrEmpty(buildInfo))
{
ProgramLog.Log("Failed to download build information.");
return;
}
var toString = "comments: ";
//if (buildInfo.ToLower().Contains(toString))
var index = buildInfo.ToLower().IndexOf(toString);
if (index != -1)
{
buildInfo = buildInfo.Remove(0, index + toString.Length).Trim();
foreach (var pair in BuildInfoReplacements)
{
buildInfo = buildInfo.Replace(pair.Key, pair.Value);
}
ProgramLog.Log("Build Comments: \n\t " + buildInfo);
}
}
catch (Exception) { }
}
static void connectElements()
{
const string progressText = "Connecting network elements.";
ProgressLogger.Starting(progressText);
foreach (IConnectable connectable in connectables)
{
connectable.Connect();
}
connectables = null;//free memory
ProgressLogger.Finished(progressText);
}
/// <summary>
/// Shuts down all gatheres (saves data in buffers).
/// </summary>
public static void ShutDown()
{
const string progressText = "Shutting down statistics gatherers.";
ProgressLogger.Starting(progressText);
foreach (Gatherer gatherer in gatherers)
{
gatherer.Close();
}
gatherers = null;
ProgressLogger.Finished(progressText);
}
public static void ShutDown()
{
const string progressText = "Shutting down logging.";
ProgressLogger.Starting(progressText);
if (logFile != null)
{
logFile.Close();
logFile = null;
}
ProgressLogger.Finished(progressText);
}
protected override void Dispose(bool disposing)
{
base.Dispose(disposing);
if (disposing)
{
if (_logger != null)
{
_logger.Dispose();
}
_logger = null;
}
}
/*public static BackupResult LoadWorld(string Name)
* {
* WorldIO.LoadWorld(null, null, Statics.WorldPath + Path.DirectorySeparatorChar + Name);
* if (WorldModify.loadFailed && !WorldModify.loadSuccess)
* {
* return BackupResult.LOAD_FAIL;
* }
* return BackupResult.SUCCESS;
* }*/
public static BackupResult Compress(string worldPath)
{
// Stopwatch stopwatch = new Stopwatch();
// stopwatch.Start();
//
// ProgramLog.Log("Compressing backup...");
if (!File.Exists(worldPath))
{
ProgramLog.Error.Log("File not Found: " + worldPath);
return(BackupResult.LOAD_FAIL);
}
using (var pg = new ProgressLogger(1, "Compressing backup"))
{
FileInfo world = new FileInfo(worldPath);
String archivePath = String.Concat(worldPath, ".zip");
using (FileStream inStream = world.OpenRead())
{
using (FileStream outStream = File.Create(archivePath))
{
using (GZipStream alg = new GZipStream(outStream, CompressionMode.Compress))
{
// copy the input file into the compression stream
inStream.CopyTo(alg);
}
}
}
if (File.Exists(archivePath))
{
if (File.Exists(worldPath))
{
File.Delete(worldPath);
}
// stopwatch.Stop();
pg.Value = 1;
// ProgramLog.Log("Compression duration: " + stopwatch.Elapsed.Seconds + " Second(s)");
return(BackupResult.SUCCESS);
}
}
// else
// {
// stopwatch.Stop();
ProgramLog.Error.Log("Compression Failed!");
return(BackupResult.SAVE_FAIL);
// }
}
//This method returns the Success and Failure messages
public static string GetTextOfMessage(IWebDriver driver, ProgressLogger logger)
{
try
{
IWebElement msgWebElement = GenericUtils.WaitForElementVisibility(driver, messageDisplayed, 10);
string messageText = msgWebElement.Text;
return(messageText);
}
catch (Exception e)
{
logger.Error(LogMessage.FailedToRetrieveMessage, e);
logger.Error(e.StackTrace);
throw;
}
}
//This method closes the Advanced Order Section
public static void CloseAdvancedOrderSection(IWebDriver driver, ProgressLogger logger)
{
try
{
IWebElement closeAdvanced = GenericUtils.WaitForElementVisibility(driver, closeIconAdvancedOrder, 30);
UserSetFunctions.Click(closeAdvanced);
Thread.Sleep(2000);
}
catch (Exception e)
{
logger.Error(LogMessage.CloseAdvanceOrderSectFailureMsg, e);
logger.Error(e.StackTrace);
throw;
}
}
//This method returns the text of toast message in Admin
public static string GetTextOfToastMessageInAdmin(IWebDriver driver, ProgressLogger logger)
{
try
{
IWebElement msgWebElement = GenericUtils.WaitForElementPresence(driver, toastMessageAdmin, 20);
string messageText = msgWebElement.Text;
return(messageText);
}
catch (Exception e)
{
logger.Error(LogMessage.FailedToRetrieveMessage, e);
logger.Error(e.StackTrace);
throw;
}
}
static void configureElements()
{
const string progressText = "Configuring network elements.";
ProgressLogger.Starting(progressText);
foreach (Identificable identificable in identificables.Values)
{
IConfigurable configurable = identificable as IConfigurable;
if (configurable != null)
{
Logger.Log(identificable, "Configuring.");
configurable.Configure();
}
}
ProgressLogger.Finished(progressText);
}
//This method is used for User Login
//If the user is already logged in, then this method logs out user and then logs in
public string LogIn(ProgressLogger logger, string userName = Const.USER5, bool changeServerOnly = false)
{
string username = null;
apexWebTitle = TestData.GetData("HomePageTitle");
string userUrl = data.UserPortal.PortalUrl;
string userServerName = data.UserPortal.PortalServerUrl;
driver.Navigate().GoToUrl(userUrl);
driver.Manage().Timeouts().ImplicitWait = TimeSpan.FromSeconds(20);
driver.Manage().Timeouts().PageLoad = TimeSpan.FromSeconds(20);
driver.Manage().Window.Size = new Size(1366, 768);
Thread.Sleep(1000);
if (driver.Url.EndsWith(Const.LoginText))
{
try
{
username = UserLogin(logger, userName, userServerName, changeServerOnly);
}
catch (Exception e)
{
logger.TakeScreenshot();
logger.Error(Const.UserLoginFailed, e);
throw e;
}
}
else
{
try
{
driver.Navigate().Refresh();
Thread.Sleep(2000);
UserSetFunctions.Click(GenericUtils.WaitForElementVisibility(driver, loggedInUserName, 30));
UserSetFunctions.Click(GenericUtils.WaitForElementVisibility(driver, userSignOutButton, 30));
Thread.Sleep(2000);
username = UserLogin(logger, userName, userServerName, changeServerOnly);
}
catch (Exception e)
{
logger.Error(Const.UserLogoutFailed, e);
throw e;
}
}
return(username);
}
public static BackupResult SaveWorld(string path)
{
if (Terraria.WorldGen.saveLock)
{
return(BackupResult.SAVE_LOCK); //Please wait for the current operation to finish.
}
try
{
using (var pg = new ProgressLogger(1, "Backing up world"))
{
if (CopyBackups)
{
var copyFrom = Terraria.Main.ActiveWorldFileData.Path;
if (File.Exists(copyFrom))
{
File.Copy(copyFrom, path);
}
}
else
{
lock (OTA.Callbacks.WorldFileCallback.SavePathLock)
{
OTA.Callbacks.WorldFileCallback.SavePath = path;
Terraria.IO.WorldFile.saveWorld();
OTA.Callbacks.WorldFileCallback.SavePath = null; //Reset
}
}
pg.Value = 1;
}
if (CompressBackups)
{
Compress(path); // it just adds ".zip" to the timestamp+".wld"
}
return(BackupResult.SUCCESS);
}
catch (Exception e)
{
ProgramLog.Log(e, "Error during the save process.");
}
return(BackupResult.SAVE_FAIL);
}
/// <summary>
/// Exports the .stl model for one link
/// The model must already be switched to the correct configuration and all parts must be hidden before this method is called
/// </summary>
/// <param name="link">Link to be exported</param>
/// <param name="configuration">The configuration that this link should be exported from</param>
/// <param name="path">The path to save the .stl file</param>
/// <param name="log">The logger to write messages to</param>
public void ExportLink(Link link ,ModelConfiguration configuration, String path, ProgressLogger log)
{
log.WriteMessage("Exporting link " + link.Name + " as an STL. Configuration: " + ((ModelConfiguration.ModelConfigType)configuration.Type) + "; Path: " + path, false);
int errors = 0;
int warnings = 0;
ModelDoc2 ActiveDoc = (ModelDoc2)asm;
IsolateLink(link, configuration);
int saveOptions = (int)swSaveAsOptions_e.swSaveAsOptions_Silent;
ActiveDoc.Extension.SaveAs(path, (int)swSaveAsVersion_e.swSaveAsCurrentVersion, saveOptions, null, ref errors, ref warnings);
HideLink(link);
log.WriteMessage("Correcting STL header");
CorrectSTLMesh(path);
log.WriteMessage("Finished exporting STL.");
}
/// <summary>
/// Main configuraiton is read from an XML file.
/// All variables have their default values that can be overwritten by values found in configuration.
/// No XML nodes are obligatory(except the main node), all are analyzed when found.
/// </summary>
/// <param name="configurationFileName">Name of file to read configuration from.</param>
public static void Load(string configurationFileName)
{
string progressText = string.Format("Reading configuration from {0}.", configurationFileName);
ProgressLogger.Starting(progressText);
XmlDocument xmlDocument = new XmlDocument();
xmlDocument.Load(configurationFileName);
XmlNode configuration = XmlParser.GetChildNode(xmlDocument, configurationTag);
//find intresting elements and pass XML nodes to them
XmlNode files = configuration[Files.FilesTag];
if (files != null)
{
Files.Configure(files);
}
XmlNode protocols = configuration[Protocols.ProtocolsTag];
if (protocols != null)
{
Protocols.Configure(protocols);
}
XmlNode network = configuration[Network.NetworkTag];
if (network != null)
{
Network.Configure(network);
}
XmlNode simulation = configuration[Simulation.SimulationTag];
if (simulation != null)
{
Simulation.Configre(simulation);
}
ProgressLogger.Finished(progressText);
}
public static void AutoPurge(string worldName)
{
if (!ExpirationsEnabled)
{
return;
}
// ProgramLog.Log("Performing backup purge...");
var backups = GetBackups(worldName);
if (backups != null && backups.Length > 0)
{
using (var pg = new ProgressLogger(backups.Length, "Purging old backups"))
{
var expired = (from x in backups
where (DateTime.Now - File.GetCreationTime(x)).TotalMinutes >= BackupExpiryMinutes
select x).ToArray();
//var deleted = 0;
foreach (var file in expired)
{
try
{
File.Delete(file);
//deleted++;
}
catch
{
}
}
}
}
else
{
ProgramLog.Log("No backups to be purged.");
}
}
internal static void OnUpdate()
{
if ((DateTime.Now - _lastSave).TotalMinutes >= SaveIntervalMinutes)
{
_lastSave = DateTime.Now;
try
{
lock (OTA.Callbacks.WorldFileCallback.SavePathLock)
{
using (var pg = new ProgressLogger(1, "Saving world"))
{
OTA.Callbacks.WorldFileCallback.SavePath = null; //Clear, and use the default
Terraria.IO.WorldFile.saveWorld();
pg.Value = 1;
}
}
}
catch (Exception e)
{
ProgramLog.Log(e, "Error during the world save process");
}
}
}
/// <summary>
/// Verifies that everything is good in the attachment
/// </summary>
/// <param name="log">Logger to output messages to</param>
/// <returns>true if successfully verified</returns>
public override bool Verify(ProgressLogger log)
{
log.WriteMessage("Verifying " + Name);
return true;
}
private static string[] InstallUpdate(string path)
{
//Extract ZIP's into a seperate folder
//Install everything else as a plugin
var info = new FileInfo(path);
var ext = info.Extension.ToLower();
if (ext == ".zip")
{
//Extract into a temporary directory incase of zip exceptions that could potentially corrupt our installation
var tmp = ExtractZip(info);
if (!String.IsNullOrEmpty(tmp))
{
//Read package
var pkgFile = Path.Combine(tmp, "package.json");
if (File.Exists(pkgFile))
{
var pkg = Newtonsoft.Json.JsonConvert.DeserializeObject<UpdatePackage>(File.ReadAllText(pkgFile));
if (pkg != null && pkg.Instructions != null && pkg.Instructions.Length > 0)
{
//Verify first then install
using (var logger = new ProgressLogger(pkg.Instructions.Length, "Verifying package"))
{
foreach (var ins in pkg.Instructions)
{
if (String.IsNullOrEmpty(ins.PackageFileName)) throw new RepositoryError("Invalid source file");
if (String.IsNullOrEmpty(ins.DestinationFileName)) ins.DestinationFileName = ins.PackageFileName; //If not provided then it means it's the same
var relPath = ins.PackageFileName.Split(ins.DirectorySeperator);
relPath = new string[] { tmp }.Concat(relPath).ToArray();
var from = Path.Combine(relPath);
if (!File.Exists(from)) throw new RepositoryError("Source file {0} does not exist", ins.PackageFileName);
var toPath = ins.PackageFileName.Split(ins.DirectorySeperator);
toPath = new string[] { Environment.CurrentDirectory }.Concat(toPath).ToArray();
var to = Path.Combine(toPath);
if (IsChild(to) == null) throw new RepositoryError("Destination file {0} is not within the TDSM install directory", ins.DestinationFileName);
}
}
using (var logger = new ProgressLogger(pkg.Instructions.Length, "Installing package"))
{
foreach (var ins in pkg.Instructions)
{
var relPath = ins.PackageFileName.Split(ins.DirectorySeperator);
relPath = new string[] { tmp }.Concat(relPath).ToArray();
var from = Path.Combine(relPath);
var toPath = ins.PackageFileName.Split(ins.DirectorySeperator);
toPath = new string[] { Environment.CurrentDirectory }.Concat(toPath).ToArray();
var to = IsChild(Path.Combine(toPath));
if (File.Exists(to)) File.Delete(to);
File.Move(from, to);
}
}
ProgramLog.Admin.Log("Cleaning up");
Directory.Delete(tmp, true);
File.Delete(path);
return pkg.PluginsToLoad;
}
else
{
throw new RepositoryError("No install instructions");
}
}
else
{
throw new RepositoryError("package.json is missing");
}
}
else
{
throw new RepositoryError("Failed to extract package");
}
}
else if (ext == ".lua" || ext == ".dll")
{
//Move and replace targets
var dest = Path.Combine(Globals.PluginPath, info.Name);
if (File.Exists(dest)) File.Delete(dest);
File.Move(info.FullName, dest);
return new string[] { dest };
}
else throw new RepositoryError("No package support for {0}", ext ?? "<unknown>");
}
/// <summary>
/// Verifies that the joint is valid to export
/// </summary>
/// <param name="logger">The logger to write messages to</param>
/// <returns>Returns true if succesfully verified</returns>
protected override bool VerifySpecifics(ProgressLogger logger)
{
Axis1.Verify(joint.Name + " Axis1", logger);
RobotInfo.WriteToLogFile("Successfully Verified Single Axis Joint");
return true;
}
public override void WriteSensor(ProgressLogger log, XmlWriter output)
{
}
/// <summary>
/// Writes the Attachment to the URDF file
/// </summary>
/// <param name="log">Logger to write messages to</param>
/// <param name="owner">The XMLWriter to use to write the values</param>
public override void WriteElements(ProgressLogger log, XmlWriter owner)
{
owner.WriteStartElement("gazebo");
owner.WriteStartElement("plugin");
owner.WriteAttributeString("name", Name);
owner.WriteAttributeString("filename", "libpotentiometer.so");
owner.WriteStartElement("joint");
owner.WriteString(Joint.Name);
owner.WriteEndElement();
owner.WriteStartElement("topic");
owner.WriteString("/gazebo/frc/simulator/analog/" + AnalogChannel.ToString());
owner.WriteEndElement();
owner.WriteStartElement("units");
owner.WriteString("degrees");
owner.WriteEndElement();
owner.WriteEndElement();
owner.WriteEndElement();
}
public ProgressWebClient(string message)
{
_logger = new ProgressLogger(1, message);
}
/// <summary>
/// Writes the Attachment to the SDF file
/// </summary>
/// <param name="log"></param>
/// <param name="owner"></param>
public override void WritePlugins(ProgressLogger log, XmlWriter owner)
{
owner.WriteStartElement("plugin");
{
owner.WriteAttributeString("name", Joint.Name + "_encoder");
owner.WriteAttributeString("filename", "libencoder.so");
SDFExporter.writeSDFElement(owner, "joint", Joint.Name.Replace(" ", "_"));
SDFExporter.writeSDFElement(owner, "topic", "/gazebo/frc/simulator/dio/" + DioPinA.ToString() + "/" + DioPinB.ToString());
SDFExporter.writeSDFElement(owner, "units", "degrees");
}
owner.WriteEndElement();
}
/// <summary>
/// Exports the robot
/// </summary>
/// <param name="log"> Logger to be used to write messeges </param>
/// <param name="path"> File path to export robot to </param>
public override void Export(ProgressLogger log, String path)
{
this.log = log;
path += "\\" + robot.Name +"_Exported";
folderPath = path + "\\" + robot.Name;
tempFilePath = folderPath + "\\";
visualSTLPath = folderPath + "\\visualSTL\\";
collisionSTLPath = folderPath + "\\collisionSTL\\";
if (Directory.Exists(path))
Directory.Delete(path, true);
Directory.CreateDirectory(path);
Directory.CreateDirectory(folderPath);
Directory.CreateDirectory(visualSTLPath);
Directory.CreateDirectory(collisionSTLPath);
try
{
log.WriteMessage("Setting up exporter", false);
//Export STLs
log.WriteMessage("Starting STL exports", false);
ModelDoc2 ActiveDoc = (ModelDoc2)asm;
//switchs to the visual configuration and hides all components
Configuration currentConfig = ActiveDoc.ConfigurationManager.ActiveConfiguration;
ActiveDoc.ShowConfiguration2(robot.VisualConfig);
STLExporter meshMaker = new STLExporter(iSwApp, asm);
Component2[] hiddenComps = meshMaker.HideAllComponents();
//exports each Link's visual models
foreach (Link L in robot.GetLinksAsArray())
{
if (!robot.ContinueExport)
{
meshMaker.UnhideComponents(hiddenComps);
meshMaker.close();
ActiveDoc.ShowConfiguration2(currentConfig.Name);
return;
}
meshMaker.ExportLink(L, robot.VisualConfig, visualSTLPath + L.Name + ".stl", log);
}
//unhides all components, switches to collision configuration, then hides all components
meshMaker.UnhideComponents(hiddenComps);
ActiveDoc.ShowConfiguration2(robot.CollisionConfig);
hiddenComps = meshMaker.HideAllComponents();
//exports each Link's collision model
foreach (Link L in robot.GetLinksAsArray())
{
if (!robot.ContinueExport)
{
meshMaker.UnhideComponents(hiddenComps);
meshMaker.close();
ActiveDoc.ShowConfiguration2(currentConfig.Name);
return;
}
meshMaker.ExportLink(L, robot.CollisionConfig, collisionSTLPath + L.Name + ".stl", log);
}
//restores the model to its original configuration
meshMaker.UnhideComponents(hiddenComps);
ActiveDoc.ShowConfiguration(currentConfig.Name);
meshMaker.close();
log.WriteMessage("Finished exporting STL files", false);
//Make URDF
log.WriteMessage("Creating URDF file", false);
XmlWriterSettings settings = new XmlWriterSettings();
settings.Encoding = new UTF8Encoding(false);
settings.Indent = true;
settings.NewLineOnAttributes = false;
XmlWriter URDFwriter = XmlWriter.Create(tempFilePath+robot.Name+".URDF", settings);
URDFwriter.WriteStartDocument();
WriteURDF(URDFwriter);
URDFwriter.WriteEndDocument();
URDFwriter.Close();
log.WriteMessage("URDF file complete");
CreateConfigFile();
log.WriteMessage("Config file complete");
log.WriteMessage("Export Complete");
}
catch (Exception e)
{
log.WriteError("Unhandled Exception thrown when exporting robot: "+e.Message);
}
}
/// <summary>
/// Writes the Attachment to the SDF file
/// </summary>
/// <param name="log"></param>
/// <param name="owner"></param>
public override void WritePlugins(ProgressLogger log, XmlWriter owner)
{
owner.WriteStartElement("plugin");
{
owner.WriteAttributeString("name", Joint.Name + "_motor");
owner.WriteAttributeString("filename", "libdc_motor.so");
SDFExporter.writeSDFElement(owner, "joint", Joint.Name.Replace(" ", "_"));
SDFExporter.writeSDFElement(owner, "topic", "/gazebo/frc/simulator/pwm/" + this.PwmChannel.ToString());
SDFExporter.writeSDFElement(owner, "multiplier", Multiplier.ToString());
}
owner.WriteEndElement();
}
/// <summary>
/// Writes the Attachment to the URDF file
/// </summary>
/// <param name="log">Logger to write messages to</param>
/// <param name="owner">The XMLWriter to use to write the values</param>
public override void WriteElements(ProgressLogger log, XmlWriter owner)
{
owner.WriteStartElement("gazebo");
owner.WriteStartElement("plugin");
owner.WriteAttributeString("name", Name);
owner.WriteAttributeString("filename", "libdc_motor.so");
owner.WriteStartElement("joint");
owner.WriteString(Joint.Name);
owner.WriteEndElement();
owner.WriteStartElement("topic");
owner.WriteString("/gazebo/frc/simulator/pwm/" + PwmChannel.ToString());
owner.WriteEndElement();
owner.WriteStartElement("multiplier");
owner.WriteString(Multiplier.ToString());
owner.WriteEndElement();
owner.WriteEndElement();
owner.WriteEndElement();
}
/// <summary>
/// Writes this joint to the SDF file
/// </summary>
/// <param name="log">The logger to write messages to</param>
/// <param name="writer">The writer to use to write the SDF file</param>
public override void WriteSDF(ProgressLogger log, XmlWriter writer)
{
Axes[0].WriteSDF(log, writer, 1);
Axes[1].WriteSDF(log, writer, 2);
}
/// <summary>
/// Verifies that the joint is valid for export
/// </summary>
/// <param name="log"></param>
/// <returns></returns>
protected override bool VerifySpecifics(ProgressLogger log)
{
Axes[0].Verify(joint.Name + " Axis1", log);
Axes[1].Verify(joint.Name + " Axis2", log);
RobotInfo.WriteToLogFile("Successfully Verified both Double Axis");
return true;
}
/// <summary>
/// Writes the Attachment to the URDF file
/// </summary>
/// <param name="log">Logger to write messages to</param>
/// <param name="owner">The XMLWriter to use to write the values</param>
public override void WriteElements(ProgressLogger log, XmlWriter owner)
{
owner.WriteStartElement("gazebo");
owner.WriteStartElement("plugin");
owner.WriteAttributeString("name", ChildLink.Name + " extlimit");
owner.WriteAttributeString("filename", "liblimit_switch.so");
owner.WriteStartElement("topic");
owner.WriteString("/gazebo/frc/simulator/dio/" + dioChannel.ToString());
owner.WriteEndElement();
owner.WriteStartElement("type");
owner.WriteString("external");
owner.WriteEndElement();
owner.WriteStartElement("sensor");
owner.WriteString(ChildLink.Name);
owner.WriteEndElement();
owner.WriteEndElement();
owner.WriteEndElement();
base.WriteElements(log, owner);
}
/// <summary>
/// Verifies that everything is good in the attachment
/// </summary>
/// <param name="log">Logger to output messages to</param>
/// <returns>true if successfully verified</returns>
public override bool Verify(ProgressLogger log)
{
log.WriteMessage("Verifying " + Name);
if (TicksPerRev == 0)
log.WriteWarning("Tick number not specified in " + Name);
if (Joint == null)
log.WriteError(Name + " must be associated with a joint.");
return true;
}
/// <summary> /// Verifies the attachment /// </summary> /// <param name="log">Logger to print messages to</param> /// <returns>returns true if verified successfully</returns> public abstract bool Verify(ProgressLogger log);
/// <summary>
/// Writes the Attachment to the URDF file
/// </summary>
/// <param name="log">Logger to write messages to</param>
/// <param name="owner">The XMLWriter to use to write the values</param>
public override void WriteElements(ProgressLogger log, XmlWriter owner)
{
owner.WriteStartElement("gazebo");
owner.WriteStartElement("plugin");
owner.WriteAttributeString("name", Name);
owner.WriteAttributeString("filename", "libencoder.so");
owner.WriteStartElement("joint");
owner.WriteString(Joint.Name);
owner.WriteEndElement();
owner.WriteStartElement("topic");
owner.WriteString("/gazebo/frc/simulator/dio/" + DioPinA.ToString() + "/" + DioPinB.ToString());
owner.WriteEndElement();
owner.WriteStartElement("units");
owner.WriteString("degrees");
owner.WriteEndElement();
owner.WriteEndElement();
owner.WriteEndElement();
}
/// <summary> /// Writes the Attachment to the URDF file /// </summary> /// <param name="log">Logger to write messages to</param> /// <param name="output">The XMLWriter to use to write the values</param> public abstract void WriteElements(ProgressLogger log, XmlWriter output);
public ProgressWebClient(string message)
{
_logger = new ProgressLogger(1, message);
}
public abstract void WritePlugins(ProgressLogger log, XmlWriter output);
public override void Verify(string axisName, ProgressLogger log)
{
base.Verify(axisName, log);
if (!IsContinuous && LowerLimit >= 0 && UpperLimit <= 0)
log.WriteWarning("No movement defined in joint " + axisName);
}
public abstract void WriteSensor(ProgressLogger log, XmlWriter output);
/// <summary>
/// Writes the Attachment to the SDF file
/// </summary>
/// <param name="log"></param>
/// <param name="owner"></param>
public override void WritePlugins(ProgressLogger log, XmlWriter owner)
{
owner.WriteStartElement("plugin");
{
owner.WriteAttributeString("name", Joint.Name + "_pot");
owner.WriteAttributeString("filename", "libpotentiometer.so");
SDFExporter.writeSDFElement(owner, "joint", Joint.Name.Replace(" ","_"));
SDFExporter.writeSDFElement(owner, "topic", "/gazebo/frc/simulator/analog/" + AnalogChannel.ToString());
SDFExporter.writeSDFElement(owner, "units", "degrees");
}
owner.WriteEndElement();
}
/// <summary>
/// Verifies that everything is good in the attachment
/// </summary>
/// <param name="log">Logger to output messages to</param>
/// <returns>true if successfully verified</returns>
public override bool Verify(ProgressLogger log)
{
log.WriteMessage("Verifying " + Name);
if (Multiplier == 0)
log.WriteWarning("No multiplier in " + Name);
if (Joint == null)
log.WriteError(Name + " must be associated with a joint.");
return true;
}
public static bool PerformUpdate(string DownloadLink, string savePath, string backupPath, string myFile, int Update, int MaxUpdates, string header = "update ")
{
if (File.Exists(savePath))
{
try
{
File.Delete(savePath);
}
catch (Exception e)
{
ProgramLog.Log(e, "Error deleting old file");
return(false);
}
}
if (File.Exists(myFile) && !MoveFile(myFile, backupPath))
{
ProgramLog.Log("Error moving current file!");
return(false);
}
var download = new System.Net.WebClient();
Exception error = null;
string downloadText = "";
if (MaxUpdates > 1)
{
downloadText = "Downloading " + header + Update.ToString() + "/" + MaxUpdates.ToString() + " from server";
}
else
{
downloadText = "Downloading " + header + "from server";
}
using (var prog = new ProgressLogger(100, downloadText))
{
var signal = new System.Threading.AutoResetEvent(false);
download.DownloadProgressChanged += (sender, args) =>
{
prog.Value = args.ProgressPercentage;
};
download.DownloadFileCompleted += (sender, args) =>
{
error = args.Error;
signal.Set();
};
download.DownloadFileAsync(new Uri(DownloadLink), savePath);
signal.WaitOne();
}
if (error != null)
{
ProgramLog.Log(error, "Error downloading update");
return(false);
}
//Program.tConsole.Write("Finishing Update...");
if (!MoveFile(savePath, myFile))
{
ProgramLog.Log("Error moving updated file!");
return(false);
}
return(true);
}
/// <summary>
/// Verifies that the joint is ready for export
/// </summary>
/// <returns>Returns true if succesfully verified</returns>
public bool Verify(ProgressLogger log)
{
return jointSpecifics.Verify(log);
}
/// <summary>
/// Writes this joint to the SDF file
/// </summary>
/// <param name="log">The logger to write messages to</param>
/// <param name="writer">The writer to use to write the SDF file</param>
public override void WriteSDF(ProgressLogger log, XmlWriter writer)
{
Axis1.WriteSDF(log,writer,1);
}
/// <summary>
/// Writes the SDF file for the joint
/// </summary>
/// <param name="log">The logger to write messages to</param>
/// <param name="writer">The XMLwriter to write the sdf tags to</param>
public void WriteSDF(ProgressLogger log, XmlWriter writer)
{
jointSpecifics.WriteJointSDF(log, writer);
}
public override void WriteSensor(ProgressLogger log, XmlWriter owner)
{
owner.WriteStartElement("sensor");
{
owner.WriteAttributeString("name", ChildLink.Name.Replace(" ", "_") + "_contact");
owner.WriteAttributeString("type", "contact");
SDFExporter.writeSDFElement(owner, "always_on", "1");
//SDFExporter.writeSDFElement(owner, "visualize", "true");
owner.WriteStartElement("contact");
{
SDFExporter.writeSDFElement(owner, "collision", ChildLink.Name.Replace(" ", "_")+"_collision");
}
owner.WriteEndElement();
}
owner.WriteEndElement();
}
/// <summary>
/// Writes the Attachment to the SDF file
/// </summary>
/// <param name="log"></param>
/// <param name="owner"></param>
public override void WritePlugins(ProgressLogger log, XmlWriter owner)
{
owner.WriteStartElement("plugin");
{
owner.WriteAttributeString("name", ChildLink.Name + "_extlimit");
owner.WriteAttributeString("filename", "liblimit_switch.so");
SDFExporter.writeSDFElement(owner, "topic", "/gazebo/frc/simulator/dio/" + dioChannel.ToString());
SDFExporter.writeSDFElement(owner, "type", "external");
SDFExporter.writeSDFElement(owner, "sensor", ChildLink.Name.Replace(" ", "_") + "_contact");
}
owner.WriteEndElement();
}
