Exemple #1
0
int	main(int ac, char **av)
{
    bool			debug = false;
    std::string			conf = "config.xml";
    apimeal::Error		err;
    Logger			*log;
    
    for (int i = 1;i < ac;i++)
    {
        std::string	tmp(av[i]);
        
        if (tmp == "-d" || tmp == "--debug")
            debug = true;
        else if (tmp == "-h" || tmp == "--help")
        {
            std::cout << "Usage: ./zia [configuration_file] [OPTS]" << std::endl;
            std::cout << "	-d/--debug : debug mode, print all the log message" << std::endl;
            return (0);
        }
        else
            conf.assign(av[i]);
    }
    
    SSL_load_error_strings();
    SSL_library_init();
    OpenSSL_add_all_algorithms();
    
    ConfParser	*parser = ConfParser::getInstance();
    parser->setFile(conf);

    parser->initialize(err);

    log = Logger::getInstance(parser->getLoggerFormat(), debug,
                              parser->getLoggerFile());
    
    check_error(err, log);
    
    Server	server(log, parser);
    
    check_error(err, log);
    server.listenServer();
    
    log->kill();
    return (0);
}
Exemple #2
0
int main( int argc, char** argv ) {

  if ( argc < 2 ) {
    cerr << "Usage: " << argv[0] << " <config_file> [<config_file> ...]" << endl;
    return -1;
  }

  ConfParser p;

  for ( int i = 1; i < argc; ++i ) {
    try {
      ConfBlock& b = p.parse( argv[i] );
      b.writeConfigFile( string( argv[i] ) + ".out" );
    } catch ( std::exception& e ) {
      cerr << e.what() << endl;
    }
  }

  return 0;
}
Exemple #3
0
void CoronaRenderer::render()
{

	std::string oslShaderPath = (getRendererHome() + "shaders").asChar();
	logger.debug(MString("setting osl shader search path to: ") + oslShaderPath.c_str());
	this->oslRenderer.setShaderSearchPath(oslShaderPath);
	this->oslRenderer.setup();

	//doit();
	//return;
	logger.debug(MString("Starting corona rendering..."));

    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////  INIT SHADING CORE + SCEME
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    //Context context;
    context.core = ICore::createInstance();
    context.scene = context.core->createScene();
    context.logger = new mtco_Logger(context.core);

	logger.debug(MString("core/scene/logger..."));

    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////  SETTINGS
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    context.settings = new MySettings();

    // populate the settings with parameters from a configuration file. If the file does not exist, a new one 
    // is created with default values.
    ConfParser parser;
	
	Corona::String resPath = (getRendererHome() + "ressources/").asChar();
	logger.debug(MString("parser: ") + (resPath + CORONA_DEFAULT_CONF_FILENAME).cStr());
    parser.parseFile(resPath + CORONA_DEFAULT_CONF_FILENAME, context.settings, ConfParser::CREATE_IF_NONEXISTENT);

	logger.debug(MString("defineSettings..."));

	this->clearMaterialLists();
	this->defineSettings();
	logger.debug(MString("definePasses..."));
	this->definePasses();

    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////  INTERNAL FRAME BUFFER
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    // create a new framebuffer, and init it before the rendering
	logger.debug(MString("createFb..."));
    context.fb = context.core->createFb();

	//colorMappingData = context.settings->getColorMapping();
	//this->context.fb->setColorMapping(colorMappingData);

    // the settings and render passes need to contain final parameters of the rendering at the time of the call
	logger.debug(MString("initFb..."));
    context.fb->initFb(context.settings, context.renderPasses);
	//Corona::ColorMappingData cmData;
	//cmData.gamma = 1.0f;
	//context.fb->setColorMapping(cmData);
	logger.debug(MString("createScene..."));

	createScene();

	logger.debug(MString("createScene done..."));

    // test that the now ready scene and settings do not have any errors
	logger.debug(MString("sanityCheck scene..."));
    context.core->sanityCheck(context.scene);
	logger.debug(MString("sanityCheck settings..."));
	//this->sanityCheck(context.settings);
    context.core->sanityCheck(context.settings);

	Corona::String basePath = (this->mtco_renderGlobals->basePath + "/corona/").asChar();
	logger.debug(MString("beginSession..."));
	ICore::AdditionalInfo info;
	info.defaultFilePath = basePath;
    context.core->beginSession(context.scene, context.settings, context.fb, context.logger, info);
    
    // run the rendering. This function blocks until it is done
	logger.debug(MString("renderFrame..."));
    context.core->renderFrame();
	context.isCancelled = true;
    context.core->endSession();
    
	this->saveImage();

    // delete what we have created and call deallocation functions for objects the core has created
    delete context.logger;
    delete context.settings;
    
    for(auto it = context.renderPasses.begin(); it != context.renderPasses.end(); ++it) 
	{
        context.core->destroyRenderPass(*it);
    }

    context.core->destroyScene(context.scene);
    context.core->destroyFb(context.fb);
    ICore::destroyInstance(context.core);	
	context.core = NULL;
	context.fb = NULL;
	context.renderPasses.clear();
	context.isCancelled = false;
	context.scene = NULL;

	// for sequence rendering, at the moment clean up pointers
	// will be removed if I restructure the geo updates

	for( size_t objId = 0; objId < this->mtco_scene->objectList.size(); objId++)
	{
		mtco_MayaObject *obj = (mtco_MayaObject *)this->mtco_scene->objectList[objId];
		obj->geom = NULL;
		obj->instance = NULL;
	}
}
Exemple #4
0
void CoronaRenderer::render()
{
	OSL::OSLShadingNetworkRenderer *r = (OSL::OSLShadingNetworkRenderer *)getObjPtr("oslRenderer");
	if (r == NULL)
	{
		std::cerr << "error CoronaRenderer::render: OSL renderer == NULL\n";
		return;
	}
	this->oslRenderer = r;
	r->setup(); // delete existing shadingsys and reinit all

	//doit();
	//return;
	logger.debug(MString("Starting corona rendering..."));

    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////  INIT SHADING CORE + SCEME
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    
    //Context context;
    context.core = ICore::createInstance();
    context.scene = context.core->createScene();
    context.logger = new mtco_Logger(context.core);

	logger.debug(MString("core/scene/logger..."));

    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////  SETTINGS
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    context.settings = new Settings();
	context.colorMappingData = new Corona::ColorMappingData;

    // populate the settings with parameters from a configuration file. If the file does not exist, a new one 
    // is created with default values.
    ConfParser parser;
	
	Corona::String resPath = (getRendererHome() + "ressources/").asChar();
	logger.debug(MString("parser: ") + (resPath + CORONA_DEFAULT_CONF_FILENAME).cStr());
    parser.parseFile(resPath + CORONA_DEFAULT_CONF_FILENAME, context.settings, ConfParser::CREATE_IF_NONEXISTENT);

	logger.debug(MString("defineSettings..."));

	this->clearMaterialLists();
	this->defineSettings();
	logger.debug(MString("definePasses..."));
	this->definePasses();

    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////
    ////  INTERNAL FRAME BUFFER
    /////////////////////////////////////////////////////////////////////////////////////////////////////////////////

    // create a new framebuffer, and init it before the rendering
	logger.debug(MString("createFb..."));
    context.fb = context.core->createFb();
    context.fb->initFb(context.settings, context.renderPasses);

	this->mtco_renderGlobals->getImageName();
	Corona::String dumpFilename = (this->mtco_renderGlobals->imageOutputFile + ".dmp").asChar();
	if (this->mtco_renderGlobals->dumpAndResume)
	{
		context.settings->set(Corona::PARAM_RANDOM_SEED, 0);
		if (!context.fb->accumulateFromExr(dumpFilename))
		{
			logger.debug(MString("Accumulating from a dumpfile failed: ") + dumpFilename.cStr());
		}
		else{
			// random seed has to be 0 for resuming a render
			context.settings->set(Corona::PARAM_RESUME_RENDERING, true);
			context.settings->set(Corona::PARAM_RANDOM_SEED, 0);
		}
	}
	createScene();
    context.core->sanityCheck(context.scene);
    context.core->sanityCheck(context.settings);

	Corona::String basePath = (this->mtco_renderGlobals->basePath + "/corona/").asChar();
	logger.debug(MString("beginSession..."));
	ICore::AdditionalInfo info;
	info.defaultFilePath = basePath;
    context.core->beginSession(context.scene, context.settings, context.fb, context.logger, info);
    
    // run the rendering. This function blocks until it is done
	logger.debug(MString("renderFrame..."));
    context.core->renderFrame();
	context.isCancelled = true;
    context.core->endSession();
	this->saveImage();

    // delete what we have created and call deallocation functions for objects the core has created
    delete context.logger;
    delete context.settings;
    
    for(auto it = context.renderPasses.begin(); it != context.renderPasses.end(); ++it) 
	{
        context.core->destroyRenderPass(*it);
    }

    context.core->destroyScene(context.scene);
    context.core->destroyFb(context.fb);
    ICore::destroyInstance(context.core);	
	context.core = NULL;
	context.fb = NULL;
	context.renderPasses.clear();
	context.isCancelled = false;
	context.scene = NULL;
	// for sequence rendering, at the moment clean up pointers
	// will be removed if I restructure the geo updates

	for( size_t objId = 0; objId < this->mtco_scene->objectList.size(); objId++)
	{
		mtco_MayaObject *obj = (mtco_MayaObject *)this->mtco_scene->objectList[objId];
		obj->geom = NULL;
		obj->instance = NULL;
	}
}
// Returns:
//   True - configuration file was read
//   False - configuration file was not read, either because an error occurred, or because the config file was previously
//           read and has not changed since then.
bool ReplicaConfig::readConfigFile()
{
   SNode s;
   if( LocalFS::stat(pathToConfigFile, s) < 0 || s.m_llTimeStamp == configFileTimestamp )
      return false;

   configFileTimestamp = s.m_llTimeStamp;

   ConfParser parser;
   Param param;

   if (0 != parser.init(pathToConfigFile))
      return false;

   while (parser.getNextParam(param) >= 0)
   {
      if ("REPLICATION_NUMBER" == param.m_strName)
      {
         for (vector<string>::iterator i = param.m_vstrValue.begin(); i != param.m_vstrValue.end(); ++ i)
         {
            string path;
            int num1, num2;
            if (parseItem(*i, path, num1, num2) >= 0)
            {
               string rp = Metadata::revisePath(path);
               if (rp.length() > 0)
               {                  
                  configData.m_mReplicaNum[rp] = pair<int,int>(num1,num2);
               }
            }
         }
      }
      else if ("REPLICATION_DISTANCE" == param.m_strName)
      {
         for (vector<string>::iterator i = param.m_vstrValue.begin(); i != param.m_vstrValue.end(); ++ i)
         {
            string path;
            int dist;
            if (parseItem(*i, path, dist) >= 0)
            {
               string rp = Metadata::revisePath(path);
               if (rp.length() > 0)
                  configData.m_mReplicaDist[rp] = dist;
            }
         }
      }
      else if ("REPLICATION_LOCATION" == param.m_strName)
      {
         for (vector<string>::iterator i = param.m_vstrValue.begin(); i != param.m_vstrValue.end(); ++ i)
         {
            string path;
            string loc;
            parseItem(*i, path, loc);
            string rp = Metadata::revisePath(path);
            vector<int> topo;
            Topology::parseTopo(loc.c_str(), topo);
            if ((rp.length() > 0) && !topo.empty())
               configData.m_mRestrictedLoc[rp] = topo;
         }
      }
      else if ("REPLICATION_MAX_TRANS" == param.m_strName)
      {
         if( !param.m_vstrValue.empty() )
             configData.m_iReplicationMaxTrans = atoi(param.m_vstrValue[0].c_str());
         else
             cerr << "no value specified for REPLICATION_MAX_TRANS" << endl;
      }
      else if ("CHECK_REPLICA_ON_SAME_IP" == param.m_strName)
      {
         if( !param.m_vstrValue.empty() )
             configData.m_bCheckReplicaOnSameIp = (param.m_vstrValue[0] == "TRUE" );
         else
             cerr << "no value specified for CHECK_REPLICA_ON_SAME_IP" << endl;
      }
      else if ("PCT_SLAVES_TO_CONSIDER" == param.m_strName)
      {
         if( !param.m_vstrValue.empty() )
             configData.m_iPctSlavesToConsider = atoi(param.m_vstrValue[0].c_str());
         else
             cerr << "no value specified for PCT_SLAVES_TO_CONSIDER" << endl;
      }
      else if ("REPLICATION_START_DELAY" == param.m_strName)
      {
         if( !param.m_vstrValue.empty() )
             configData.m_iReplicationStartDelay = atoi(param.m_vstrValue[0].c_str());
         else
             cerr << "no value specified for REPLICATION_START_DELAY" << endl;
      }
      else if ("REPLICATION_FULL_SCAN_DELAY"  == param.m_strName)
      {
         if( !param.m_vstrValue.empty() )
             configData.m_iReplicationFullScanDelay = atoi(param.m_vstrValue[0].c_str());
         else
             cerr << "no value specified for REPLICATION_FULL_SCAN_DELAY" << endl;
         if (configData.m_iReplicationFullScanDelay < 60)
            configData.m_iReplicationFullScanDelay = 60;
      }
      else if ("DISK_BALANCE_AGGRESSIVENESS"  == param.m_strName)
      {
         if( !param.m_vstrValue.empty() )
             configData.m_iDiskBalanceAggressiveness = atoi(param.m_vstrValue[0].c_str());
         else
             cerr << "no value specified for DISK_BALANCE_AGGRESSIVENESS" << endl;
         configData.m_iDiskBalanceAggressiveness = std::max( 0, configData.m_iDiskBalanceAggressiveness );
         configData.m_iDiskBalanceAggressiveness = std::min( 100, configData.m_iDiskBalanceAggressiveness );
      }
      else if ("REPLICATE_ON_TRANSACTION_CLOSE"  == param.m_strName)
      {
         if( !param.m_vstrValue.empty() )
             configData.m_bReplicateOnTransactionClose = (param.m_vstrValue[0] == "TRUE");
         else
             cerr << "no value specified for REPLICATE_ON_TRANSACTION_CLOSE" << endl;
      }
      else if ("CHECK_REPLICA_CLUSTER"  == param.m_strName)
      {
         if( !param.m_vstrValue.empty() )
             configData.m_bCheckReplicaCluster = (param.m_vstrValue[0] == "TRUE");
         else
             cerr << "no value specified for CHECK_REPLCIA_CLUSTER" << endl;
      }
      else
      {
         cerr << "unrecognized replica.conf parameter: " << param.m_strName << endl;
      }
   }

   parser.close();
   return true;
}
int MasterConf::init(const string& path)
{
   ConfParser parser;
   Param param;

   if (0 != parser.init(path))
      return -1;

   while (parser.getNextParam(param) >= 0)
   {
      if (param.m_vstrValue.empty())
         continue;

      if ("SECTOR_PORT" == param.m_strName)
         m_iServerPort = atoi(param.m_vstrValue[0].c_str());
      else if ("SECURITY_SERVER" == param.m_strName)
      {
         char buf[128];
         strncpy(buf, param.m_vstrValue[0].c_str(), 128);

         unsigned int i = 0;
         for (unsigned int n = strlen(buf); i < n; ++ i)
         {
            if (buf[i] == ':')
               break;
         }

         buf[i] = '\0';
         m_strSecServIP = buf;
         m_iSecServPort = atoi(buf + i + 1);
      }
      else if ("MAX_ACTIVE_USER" == param.m_strName)
         m_iMaxActiveUser = atoi(param.m_vstrValue[0].c_str());
      else if ("DATA_DIRECTORY" == param.m_strName)
      {
         m_strHomeDir = param.m_vstrValue[0];
         if (m_strHomeDir.c_str()[m_strHomeDir.length() - 1] != '/')
            m_strHomeDir += "/";
      }
      else if ("REPLICA_NUM" == param.m_strName)
         m_iReplicaNum = atoi(param.m_vstrValue[0].c_str());
      else if ("REPLICA_DIST" == param.m_strName)
         m_iReplicaDist = atoi(param.m_vstrValue[0].c_str());
      else if ("META_LOC" == param.m_strName)
      {
         if ("MEMORY" == param.m_vstrValue[0])
            m_MetaType = MEMORY;
         else if ("DISK" == param.m_vstrValue[0])
            m_MetaType = DISK;
      }
      else if ("SLAVE_TIMEOUT" == param.m_strName)
      {
         m_iSlaveTimeOut = atoi(param.m_vstrValue[0].c_str());

         // slave reports every 30 - 60 seconds
         if (m_iSlaveTimeOut < 120)
            m_iSlaveTimeOut = 120;
      }
      else if ("LOST_SLAVE_RETRY_TIME" == param.m_strName)
      {
         m_iSlaveRetryTime = atoi(param.m_vstrValue[0].c_str());
         if (m_iSlaveRetryTime < 0)
            m_iSlaveRetryTime = 0;
      }
      else if ("SLAVE_MIN_DISK_SPACE" == param.m_strName)
      {
         m_llSlaveMinDiskSpace = atoll(param.m_vstrValue[0].c_str()) * 1000000;
      }
      else if ("CLIENT_TIMEOUT" == param.m_strName)
      {
         m_iClientTimeOut = atoi(param.m_vstrValue[0].c_str());

         // client only sends heartbeat every 60 - 120 seconds, so this value cannot be too small
         if (m_iClientTimeOut < 300)
            m_iClientTimeOut = 300;
      }
      else if ("LOG_LEVEL" == param.m_strName)
      {
         m_iLogLevel = atoi(param.m_vstrValue[0].c_str());
      }
      else if ("PROCESS_THREADS" == param.m_strName)
      {
         m_iProcessThreads = atoi(param.m_vstrValue[0].c_str());
      }
      else if ("WRITE_ONCE_PROTECTION" == param.m_strName)
      {
         for (vector<string>::iterator i = param.m_vstrValue.begin(); i != param.m_vstrValue.end(); ++ i)
         {
            string rp = Metadata::revisePath(*i);
            m_vWriteOncePath.push_back(rp);
         }
      }
      else
      {
         cerr << "unrecongnized system parameter: " << param.m_strName << endl;
      }
   }

   parser.close();

   return 0;
}
Exemple #7
0
int ClientConf::init(const string& path)
{
   ConfParser parser;
   Param param;

   if (0 != parser.init(path))
      return -1;

   while (parser.getNextParam(param) >= 0)
   {
      if (param.m_vstrValue.empty())
         continue;

      if ("MASTER_ADDRESS" == param.m_strName)
      {
         char buf[128];
         strncpy(buf, param.m_vstrValue[0].c_str(), 128);

         unsigned int i = 0;
         for (unsigned int n = strlen(buf); i < n; ++ i)
         {
            if (buf[i] == ':')
               break;
         }

         buf[i] = '\0';
         m_strMasterIP = buf;
         m_iMasterPort = atoi(buf + i + 1);
      }
      else if ("USERNAME" == param.m_strName)
      {
         m_strUserName = param.m_vstrValue[0];
      }
      else if ("PASSWORD" == param.m_strName)
      {
         m_strPassword = param.m_vstrValue[0];
      }
      else if ("CERTIFICATE" == param.m_strName)
      {
         m_strCertificate = param.m_vstrValue[0];
      }
      else if ("MAX_CACHE_SIZE" == param.m_strName)
      {
#ifndef WIN32
         m_llMaxCacheSize = atoll(param.m_vstrValue[0].c_str()) * 1000000;
#else
         m_llMaxCacheSize = _atoi64(param.m_vstrValue[0].c_str()) * 1000000;
#endif
      }
      else if ("FUSE_READ_AHEAD_BLOCK" == param.m_strName)
      {
         m_iFuseReadAheadBlock = atoi(param.m_vstrValue[0].c_str()) * 1000000;
      }
      else if ("MAX_READ_CACHE_SIZE" == param.m_strName)
      {
#ifndef WIN32
         m_llMaxWriteCacheSize = atoll(param.m_vstrValue[0].c_str()) * 1000000;
#else
         m_llMaxWriteCacheSize = _atoi64(param.m_vstrValue[0].c_str()) * 1000000;
#endif
      }
      else
         cerr << "unrecongnized client.conf parameter: " << param.m_strName << endl;
   }

   parser.close();

   return 0;
}
int SlaveConf::init(const string& path)
{
   // initialize these values; a slave must call init()
   // cannot initialize the following values in constructor because they are reserved for global conf
   m_iMasterPort = 6000;
   m_strHomeDir = "./";
   m_llMaxDataSize = -1;
   m_iMaxServiceNum = 64;
   m_MetaType = MEMORY;
   m_iLogLevel = 1;

   ConfParser parser;
   Param param;

   if (0 != parser.init(path))
      return -1;

   while (parser.getNextParam(param) >= 0)
   {
      if (param.m_vstrValue.empty())
         continue;

      if ("MASTER_ADDRESS" == param.m_strName)
      {
         char buf[128];
         strncpy(buf, param.m_vstrValue[0].c_str(), 128);

         unsigned int i = 0;
         for (unsigned int n = strlen(buf); i < n; ++ i)
         {
            if (buf[i] == ':')
               break;
         }

         buf[i] = '\0';
         m_strMasterHost = buf;
         m_iMasterPort = atoi(buf + i + 1);
      }
      else if ("DATA_DIRECTORY" == param.m_strName)
      {
         m_strHomeDir = param.m_vstrValue[0];
         if (m_strHomeDir.c_str()[m_strHomeDir.length() - 1] != '/')
            m_strHomeDir += "/";
      }
      else if ("MAX_DATA_SIZE" == param.m_strName)
      {
         m_llMaxDataSize = atoll(param.m_vstrValue[0].c_str()) * 1024 * 1024;
      }
      else if ("MAX_SERVICE_INSTANCE" == param.m_strName)
         m_iMaxServiceNum = atoi(param.m_vstrValue[0].c_str());
      else if ("LOCAL_ADDRESS" == param.m_strName)
         m_strLocalIP = param.m_vstrValue[0];
      else if ("PUBLIC_ADDRESS" == param.m_strName)
         m_strPublicIP = param.m_vstrValue[0];
      else if ("META_LOC" == param.m_strName)
      {
         if ("MEMORY" == param.m_vstrValue[0])
            m_MetaType = MEMORY;
         else if ("DISK" == param.m_vstrValue[0])
            m_MetaType = DISK;
      }
      else if ("LOG_LEVEL" == param.m_strName)
      {
         m_iLogLevel = atoi(param.m_vstrValue[0].c_str());
      }
      else
      {
         cerr << "unrecongnized system parameter: " << param.m_strName << endl;
      }
   }

   parser.close();

   return 0;
}
Exemple #9
0
int SlaveConf::init(const string& path)
{
   ConfParser parser;
   Param param;

   if (0 != parser.init(path))
      return -1;

   while (parser.getNextParam(param) >= 0)
   {
      if (param.m_vstrValue.empty())
         continue;

      if ("MASTER_ADDRESS" == param.m_strName)
      {
         char buf[128];
         strncpy(buf, param.m_vstrValue[0].c_str(), 128);

         unsigned int i = 0;
         for (unsigned int n = strlen(buf); i < n; ++ i)
         {
            if (buf[i] == ':')
               break;
         }

         buf[i] = '\0';
         m_strMasterHost = buf;
         m_iMasterPort = atoi(buf + i + 1);
      }
      else if ("DATA_DIRECTORY" == param.m_strName)
      {
         m_strHomeDir = param.m_vstrValue[0];
#ifdef WIN32
        win_to_unix_path (m_strHomeDir);

        struct stat t;
        if (stat(m_strHomeDir.c_str(), &t) != 0) 
        {
            char szPath[MAX_PATH]="";
            if (SUCCEEDED(SHGetFolderPath(NULL, 
                                         CSIDL_COMMON_APPDATA | CSIDL_FLAG_CREATE, 
                                         NULL, 
                                         SHGFP_TYPE_DEFAULT, 
                                         szPath)))
            {
                m_strHomeDir.assign (szPath);
                char first = param.m_vstrValue[0][0];
                if (first != '/' && first != '\\')
                    m_strHomeDir += "\\";
                m_strHomeDir.append(param.m_vstrValue[0]);
                win_to_unix_path (m_strHomeDir);
            }
        }

#ifdef _DEBUG
         printf ("DATA_DIRECTORY: %s\n", m_strHomeDir.c_str());
#endif
#endif
         if (m_strHomeDir.c_str()[m_strHomeDir.length() - 1] != '/')
            m_strHomeDir += "/";
      }
      else if ("MAX_DATA_SIZE" == param.m_strName)
      {
#ifndef WIN32
         m_llMaxDataSize = atoll(param.m_vstrValue[0].c_str()) * 1024 * 1024;
#else
         m_llMaxDataSize = _atoi64(param.m_vstrValue[0].c_str()) * 1024 * 1024;
#endif
      }
      else if ("MAX_SERVICE_INSTANCE" == param.m_strName)
         m_iMaxServiceNum = atoi(param.m_vstrValue[0].c_str());
      else if ("LOCAL_ADDRESS" == param.m_strName)
         m_strLocalIP = param.m_vstrValue[0];
      else if ("PUBLIC_ADDRESS" == param.m_strName)
         m_strPublicIP = param.m_vstrValue[0];
      else if ("META_LOC" == param.m_strName)
      {
         if ("MEMORY" == param.m_vstrValue[0])
            m_MetaType = MEMORY;
         else if ("DISK" == param.m_vstrValue[0])
            m_MetaType = DISK;
      }
      else
         cerr << "unrecongnized system parameter: " << param.m_strName << endl;
   }

   parser.close();

   return 0;
}
Exemple #10
0
int MasterConf::init(const string& path)
{
   ConfParser parser;
   Param param;

   if (0 != parser.init(path))
      return -1;

   while (parser.getNextParam(param) >= 0)
   {
      if (param.m_vstrValue.empty())
         continue;

      if ("SECTOR_PORT" == param.m_strName)
         m_iServerPort = atoi(param.m_vstrValue[0].c_str());
      else if ("SECURITY_SERVER" == param.m_strName)
      {
         char buf[128];
         strncpy(buf, param.m_vstrValue[0].c_str(), 128);

         unsigned int i = 0;
         for (unsigned int n = strlen(buf); i < n; ++ i)
         {
            if (buf[i] == ':')
               break;
         }

         buf[i] = '\0';
         m_strSecServIP = buf;
         m_iSecServPort = atoi(buf + i + 1);
      }
      else if ("MAX_ACTIVE_USER" == param.m_strName)
         m_iMaxActiveUser = atoi(param.m_vstrValue[0].c_str());
      else if ("DATA_DIRECTORY" == param.m_strName)
      {
        m_strHomeDir = param.m_vstrValue[0];
#ifdef WIN32
        win_to_unix_path (m_strHomeDir);

        struct stat t;
        if (stat(m_strHomeDir.c_str(), &t) != 0) 
        {
            char szPath[MAX_PATH]="";
            if (SUCCEEDED(SHGetFolderPath(NULL, 
                                         CSIDL_COMMON_APPDATA | CSIDL_FLAG_CREATE, 
                                         NULL, 
                                         SHGFP_TYPE_DEFAULT, 
                                         szPath)))
            {
                m_strHomeDir.assign (szPath);
                char first = param.m_vstrValue[0][0];
                if (first != '/' && first != '\\')
                    m_strHomeDir += "\\";
                m_strHomeDir.append(param.m_vstrValue[0]);
                win_to_unix_path (m_strHomeDir);
            }
        }

#ifdef _DEBUG
         printf ("DATA_DIRECTORY: %s\n", m_strHomeDir.c_str());
#endif
#endif
         char last = m_strHomeDir.c_str()[m_strHomeDir.length() - 1];
         if (last != '/' && last != '\\')
            m_strHomeDir += "/";
      }
      else if ("REPLICA_NUM" == param.m_strName)
         m_iReplicaNum = atoi(param.m_vstrValue[0].c_str());
      else if ("META_LOC" == param.m_strName)
      {
         if ("MEMORY" == param.m_vstrValue[0])
            m_MetaType = MEMORY;
         else if ("DISK" == param.m_vstrValue[0])
            m_MetaType = DISK;
      }
      else if ("SLAVE_TIMEOUT" == param.m_strName)
      {
         m_iSlaveTimeOut = atoi(param.m_vstrValue[0].c_str());
         if (m_iSlaveTimeOut < 120)
            m_iSlaveTimeOut = 120;
      }
      else if ("SLAVE_MIN_DISK_SPACE" == param.m_strName)
      {
#ifndef WIN32
         m_llSlaveMinDiskSpace = atoll(param.m_vstrValue[0].c_str()) * 1000000;
#else
         m_llSlaveMinDiskSpace = _atoi64(param.m_vstrValue[0].c_str()) * 1000000;
#endif
      }
      else if ("CLIENT_TIMEOUT" == param.m_strName)
      {
         m_iClientTimeOut = atoi(param.m_vstrValue[0].c_str());
      }
      else if ("LOG_LEVEL" == param.m_strName)
      {
         m_iLogLevel = atoi(param.m_vstrValue[0].c_str());
      }
      else
      {
         cerr << "unrecongnized system parameter: " << param.m_strName << endl;
      }
   }

   parser.close();

   return 0;
}
Exemple #11
0
// init all data which will be used during a rendering.
// These data will be reused in rendering until the rendering is done.
void CoronaRenderer::initializeRenderer()
{
	Logging::debug("CoronaRenderer::initializeRenderer()");
	MFnDependencyNode gFn(getRenderGlobalsNode());
	clearDataList(); // clear nativeMtlData

	if (MGlobal::mayaState() != MGlobal::kBatch)
		MayaTo::getWorldPtr()->setRenderType(MayaTo::MayaToWorld::WorldRenderType::UIRENDER);
	else
		MayaTo::getWorldPtr()->setRenderType(MayaTo::MayaToWorld::WorldRenderType::BATCHRENDER);

	// first we delete any still existing elements.
	// after a render, the framebuffers, core and passes still exist until a new scene is loaded
	// or a new rendering is started.
	if (context.logger != nullptr)
	{
		delete context.logger;
		context.logger = nullptr;
	}
	if (context.settings != nullptr)
	{
		delete context.settings;
		context.settings = nullptr;
	}
	context.renderPasses.clear();
	if (context.fb != nullptr)
	{
		context.core->destroyFb(context.fb);
		context.fb = nullptr;
	}
	if (context.scene != nullptr)
	{
		context.core->destroyScene(context.scene);
		context.scene = nullptr;
	}
	if (context.core != nullptr)
	{
		ICore::destroyInstance(context.core);
		context.core = nullptr;
	}
	if (context.colorMappingData != nullptr)
	{
		delete context.colorMappingData;
		context.colorMappingData = nullptr;
	}

	context.settings = new Settings();
	context.core = ICore::createInstance();
	context.logger = new mtco_Logger(context.core);
	context.colorMappingData = new Corona::ColorMappingData;
	
	if (gFn.findPlug("useCoronaVFB").asBool())
		if (MGlobal::mayaState() != MGlobal::kBatch)
			vfbCallbacks.core = context.core;

	ConfParser parser;
	Corona::String resPath = (getRendererHome() + "resources/").asChar();
	Logging::debug(MString("parser: ") + (resPath + CORONA_DEFAULT_CONF_FILENAME).cStr());
	parser.parseFile(resPath + CORONA_DEFAULT_CONF_FILENAME, context.settings, ConfParser::CREATE_IF_NONEXISTENT);

	this->defineSettings();
	this->defineColorMapping();
	this->definePasses();
	context.fb = context.core->createFb();
	context.fb->initFb(context.settings, context.renderPasses);
	context.core->sanityCheck(context.settings);

	if (gFn.findPlug("useCoronaVFB").asBool())
		if (MGlobal::mayaState() != MGlobal::kBatch)
			context.core->getWxVfb().renderStarted(context.fb, &vfbCallbacks, IWxVfb::EnviroConfig());

	// this can be extracted and placed in a button function in the render globals
	std::shared_ptr<RenderGlobals> renderGlobals = MayaTo::getWorldPtr()->worldRenderGlobalsPtr;
	MFnDependencyNode renderGlobalsNode(getRenderGlobalsNode());
	Corona::String dumpFilename = (renderGlobals->getImageOutputFile() + ".dmp").asChar();
	if (getBoolAttr("dumpAndResume", renderGlobalsNode, false))
	{
		context.settings->set(Corona::PARAM_RANDOM_SEED, 0);
		if (!context.fb->accumulateFromExr(dumpFilename))
		{
			Logging::debug(MString("Accumulating from a dumpfile failed: ") + dumpFilename.cStr());
		}
		else{
			// random seed has to be 0 for resuming a render
			context.settings->set(Corona::PARAM_RESUME_RENDERING, true);
			context.settings->set(Corona::PARAM_RANDOM_SEED, 0);
		}
	}

	OSL::OSLShadingNetworkRenderer *r = (OSL::OSLShadingNetworkRenderer *)MayaTo::getWorldPtr()->getObjPtr("oslRenderer");
	if (r == nullptr)
	{
		Logging::debug("error CoronaRenderer::render: OSL renderer == nullptr");
		return;
	}
	this->oslRenderer = r;
	r->setup(); // delete existing shadingsys and reinit all

}