std::string EnggDiffractionViewQtGUI::guessGSASTemplatePath() const {
// Inside the mantid installation target directory:
// scripts/Engineering/template_ENGINX_241391_236516_North_and_South_banks.par
Poco::Path templ =
Mantid::Kernel::ConfigService::Instance().getInstrumentDirectory();
templ = templ.makeParent();
templ.append("scripts");
templ.append("Engineering");
templ.append("template_ENGINX_241391_236516_North_and_South_banks.par");
return templ.toString();
}
std::string EnggDiffractionViewQtGUI::guessDefaultFullCalibrationPath() const {
// Inside the mantid installation target directory:
// scripts/Engineering/ENGINX_full_pixel_calibration_vana194547_ceria193749.csv
Poco::Path templ =
Mantid::Kernel::ConfigService::Instance().getInstrumentDirectory();
templ = templ.makeParent();
templ.append("scripts");
templ.append("Engineering");
templ.append("calib");
templ.append("ENGINX_full_pixel_calibration_vana194547_ceria193749.csv");
return templ.toString();
}
void ExportFrames( eSUPPORT_IMG_IO imgty, uint32_t proportionofwork )
{
Poco::Path imgdir = Poco::Path(m_outDirPath);
imgdir.append(SPRITE_IMGs_DIR);
Poco::File directory(imgdir);
if( !directory.exists() )
directory.createDirectory();
switch( imgty )
{
case eSUPPORT_IMG_IO::BMP:
{
ExportFramesAsBMPs(imgdir, proportionofwork);
break;
}
#if 0
case eSUPPORT_IMG_IO::RAW:
{
ExportFramesAsRawImgs(imgdir, proportionofwork);
break;
}
#endif
case eSUPPORT_IMG_IO::PNG:
default:
{
ExportFramesAsPNGs(imgdir, proportionofwork);
}
};
}
void Pothos::PluginLoader::loadModules(void)
{
Poco::Path libPath = Pothos::System::getRootPath();
libPath.append("lib@LIB_SUFFIX@");
libPath.append("Pothos");
libPath.append("modules");
const auto paths = getModulePaths(libPath.absolute());
//TODO load user built modules -- when we have a comprehension for them
//spawn futures and wait for completion of load
std::vector<std::future<void>> futures;
for (const auto &path : paths)
{
futures.push_back(std::async(std::launch::async, &loadModuleAtPath, path.toString()));
}
for (auto &future : futures) future.wait();
}
void FileRequestHandler::handleRequest(Poco::Net::HTTPServerRequest& request, Poco::Net::HTTPServerResponse& response)
{
setContentType(request, response);
std::ostream& ostr = response.send();
try {
Poco::Path basedir = Poco::Util::Application::instance().config().getString("application.dir");
basedir.append("web");
basedir.append(request.getURI());
Poco::FileInputStream fis(basedir.toString());
Poco::StreamCopier::copyStream(fis, ostr);
response.setStatus(Poco::Net::HTTPResponse::HTTPStatus::HTTP_OK);
}
catch (Poco::Exception& ex) {
response.setStatus(Poco::Net::HTTPResponse::HTTPStatus::HTTP_NOT_FOUND);
ostr << ex.displayText();
_logger.error("Request failed: %s: %s", request.getURI(), ex.displayText());
}
}
void FileSystemRoute::handleRequest(ServerEventArgs& evt)
{
Poco::Path dataFolder(ofToDataPath("", true));
Poco::Path documentRoot(ofToDataPath(getSettings().getDocumentRoot(), true));
std::string dataFolderString = dataFolder.toString();
std::string documentRootString = documentRoot.toString();
// Document root validity check.
if (_settings.getRequireDocumentRootInDataFolder() &&
(documentRootString.length() < dataFolderString.length() ||
documentRootString.substr(0, dataFolderString.length()) != dataFolderString))
{
ofLogError("FileSystemRoute::handleRequest") << "Document Root is not a sub directory of the data folder.";
evt.getResponse() .setStatusAndReason(Poco::Net::HTTPResponse::HTTP_INTERNAL_SERVER_ERROR);
handleErrorResponse(evt);
return;
}
// check path
Poco::URI uri(evt.getRequest().getURI());
std::string path = uri.getPath(); // just get the path
// make paths absolute
if (path.empty())
{
path = "/";
}
Poco::Path requestPath = documentRoot.append(path).makeAbsolute();
// add the default index if no filename is requested
if (requestPath.getFileName().empty())
{
requestPath.append(getSettings().getDefaultIndex()).makeAbsolute();
}
std::string requestPathString = requestPath.toString();
// double check path safety (not needed?)
if ((requestPathString.length() < documentRootString.length() ||
requestPathString.substr(0, documentRootString.length()) != documentRootString))
{
ofLogError("FileSystemRoute::handleRequest") << "Requested document not inside DocumentFolder.";
evt.getResponse().setStatusAndReason(Poco::Net::HTTPResponse::HTTP_NOT_FOUND);
handleErrorResponse(evt);
return;
}
ofFile file(requestPathString); // use it to parse file name parts
std::string mediaTypeString = MediaTypeMap::getDefault()->getMediaTypeForPath(file.path()).toString();
try
{
// TODO: this is where we would begin to work honoring
/// Accept-Encoding:gzip, deflate, sdch
evt.getResponse().sendFile(file.getAbsolutePath(), mediaTypeString);
return;
}
catch (const Poco::FileNotFoundException& exc)
{
ofLogError("FileSystemRoute::handleRequest") << exc.displayText();
evt.getResponse().setStatusAndReason(Poco::Net::HTTPResponse::HTTP_NOT_FOUND);
handleErrorResponse(evt);
return;
}
catch (const Poco::OpenFileException& exc)
{
ofLogError("FileSystemRoute::handleRequest") << exc.displayText();
evt.getResponse().setStatusAndReason(Poco::Net::HTTPResponse::HTTP_INTERNAL_SERVER_ERROR);
handleErrorResponse(evt);
return;
}
catch (const std::exception& exc)
{
ofLogError("FileSystemRoute::handleRequest") << "Unknown server error: " << exc.what();
evt.getResponse().setStatusAndReason(Poco::Net::HTTPResponse::HTTP_INTERNAL_SERVER_ERROR);
handleErrorResponse(evt);
return;
}
}
void
BundleLoader::InstallLibraries(IBundle::Pointer bundle, bool copy)
{
std::vector<std::string> libraries;
this->ListLibraries(bundle, libraries);
std::vector<std::string>::iterator iter;
for (iter = libraries.begin(); iter != libraries.end(); ++iter)
{
if (iter->empty()) continue;
//BERRY_INFO << "Testing CodeCache for: " << *iter << std::endl;
std::size_t separator = iter->find_last_of("/");
std::string libFileName = *iter;
if (separator != std::string::npos)
libFileName = iter->substr(separator+1);
if (!m_CodeCache->HasLibrary(libFileName))
{
std::string libDir = "";
if (separator != std::string::npos)
libDir += iter->substr(0, separator);
// Check if we should copy the dll (from a ZIP file for example)
if (copy)
{
//TODO This copies all files which start with *iter to the
// plugin cache. This is necessary for Windows, for example,
// where a .dll file is accompanied by a set of other files.
// This should be extended to check for the right dll files, since
// it would be possible (and a good idea anyway) to put multiple
// versions of the same library in the ZIP file, targeting different
// compilers for example.
std::vector<std::string> files;
bundle->GetStorage().List(libDir, files);
for (std::vector<std::string>::iterator fileName = files.begin();
fileName != files.end(); ++fileName)
{
std::size_t size = std::min<std::size_t>(libFileName.size(), fileName->size());
if (fileName->compare(0, size, libFileName) != 0) continue;
std::istream* istr = bundle->GetResource(libDir + *fileName);
m_CodeCache->InstallLibrary(*iter, *istr);
delete istr;
}
}
else
{
Poco::Path bundlePath = bundle->GetStorage().GetPath();
bundlePath.append(Poco::Path::forDirectory(libDir));
// On Windows, we set the path environment variable to include
// the path to the library, so the loader can find it. We do this
// programmatically because otherwise, a user would have to edit
// a batch file every time he adds a new plugin from outside the
// build system.
#ifdef BERRY_OS_FAMILY_WINDOWS
std::string pathEnv = Poco::Environment::get("PATH", "");
if (!pathEnv.empty()) pathEnv += ";";
pathEnv += bundlePath.toString();
Poco::Environment::set("PATH", pathEnv);
#endif
m_CodeCache->InstallLibrary(libFileName, bundlePath);
}
}
}
}
void FileSystemRouteHandler::handleRequest(Poco::Net::HTTPServerRequest& request,
Poco::Net::HTTPServerResponse& response)
{
Poco::Path dataFolder(ofToDataPath("",true));
Poco::Path documentRoot(ofToDataPath(_parent.getSettings().getDocumentRoot(),true));
std::string dataFolderString = dataFolder.toString();
std::string documentRootString = documentRoot.toString();
// doc root validity check
if(_parent.getSettings().getRequireDocumentRootInDataFolder() &&
(documentRootString.length() < dataFolderString.length() ||
documentRootString.substr(0,dataFolderString.length()) != dataFolderString))
{
ofLogError("ServerDefaultRouteHandler::handleRequest") << "Document Root is not a sub directory of the data folder.";
response.setStatusAndReason(Poco::Net::HTTPResponse::HTTP_INTERNAL_SERVER_ERROR);
_parent.handleRequest(request,response);
return;
}
// check path
Poco::URI uri(request.getURI());
std::string path = uri.getPath(); // just get the path
// make paths absolute
if(path.empty())
{
path = "/";
}
Poco::Path requestPath = documentRoot.append(path).makeAbsolute();
// add the default index if no filename is requested
if(requestPath.getFileName().empty())
{
requestPath.append(_parent.getSettings().getDefaultIndex()).makeAbsolute();
}
std::string requestPathString = requestPath.toString();
// double check path safety (not needed?)
if((requestPathString.length() < documentRootString.length() ||
requestPathString.substr(0,documentRootString.length()) != documentRootString))
{
ofLogError("ServerDefaultRouteHandler::handleRequest") << "Requested document not inside DocumentFolder.";
response.setStatusAndReason(Poco::Net::HTTPResponse::HTTP_NOT_FOUND);
_parent.handleRequest(request,response);
return;
}
ofFile file(requestPathString); // use it to parse file name parts
try
{
// ofx::Media::MediaTypeMap mediaMap;
// Poco::Net::MediaType mediaType = mediaMap.getMediaTypeForSuffix(file.getExtension());
std::string mediaTypeString = "application/octet-stream";
std::string ext = file.getExtension();
if(ext == "json")
{
mediaTypeString = "application/json";
}
else if(ext == "html")
{
mediaTypeString = "text/html";
}
else if(ext == "jpg" || ext == "jpeg")
{
mediaTypeString = "image/jpeg";
}
else if(ext == "png")
{
mediaTypeString = "image/png";
}
else if(ext == "js")
{
mediaTypeString = "application/javascript";
}
else if(ext == "css")
{
mediaTypeString = "text/css";
}
else if(ext == "xml")
{
mediaTypeString = "application/xml";
}
else if(ext == "ico")
{
mediaTypeString = "image/x-icon";
}
response.sendFile(file.getAbsolutePath(), mediaTypeString); // will throw exceptions
return;
}
catch (const Poco::FileNotFoundException& ex)
{
ofLogError("ServerDefaultRouteHandler::handleRequest") << ex.displayText();
response.setStatusAndReason(Poco::Net::HTTPResponse::HTTP_NOT_FOUND);
_parent.handleRequest(request,response);
}
catch (const Poco::OpenFileException& ex)
{
ofLogError("ServerDefaultRouteHandler::handleRequest") << ex.displayText();
response.setStatusAndReason(Poco::Net::HTTPResponse::HTTP_INTERNAL_SERVER_ERROR);
_parent.handleRequest(request,response);
}
catch (const exception& ex)
{
ofLogError("ServerDefaultRouteHandler::handleRequest") << "Unknown server error: " << ex.what();
response.setStatusAndReason(Poco::Net::HTTPResponse::HTTP_INTERNAL_SERVER_ERROR);
_parent.handleRequest(request,response);
}
}