static inline int fsam_map_memory(void)
{
const unsigned long max_offset = BIOS_CODE_MAPSIZE - BIOS_SIGN_SIZE - PTR_POSITION;
unsigned long offset;
unsigned int addr;
mem_code = ioremap(BIOS_CODE_ADDR, BIOS_CODE_MAPSIZE);
if (!mem_code)
goto fail;
DEBUG_OUT3("physical memory %x-%x mapped to virtual address %p\n",
BIOS_CODE_ADDR, BIOS_CODE_ADDR+BIOS_CODE_MAPSIZE, mem_code);
for ( offset = 0; offset < max_offset; offset += ALLIGNED_STEP )
if (check_signature((void*)TOUL(mem_code) + offset, bios_sign, BIOS_SIGN_SIZE))
break;
if (offset >= max_offset)
goto fail;
DEBUG_OUT1("bios signature found at offset %lx\n", offset);
addr = readl((void*)TOUL(mem_code) + offset + PTR_POSITION);
if (addr < BIOS_CODE_ADDR) {
DEBUG_OUT0("bios routine out of memory range, "
"doing some new memory mapping...\n");
iounmap(mem_code);
mem_code = NULL;
addr &= BIOS_CODE_ALT_MASK;
mem_code = ioremap(addr, BIOS_CODE_ALT_MAPSIZE);
if (!mem_code)
goto fail;
DEBUG_OUT3("physical memory %x-%x mapped to virtual address %p\n",
addr, addr+BIOS_CODE_ALT_MAPSIZE, mem_code);
addr &= 0x3FFF;
} else
addr &= 0xFFFF;
bios_code = addr + TOUL(mem_code);
DEBUG_OUT1("supposed address of bios routine is %lx\n", bios_code);
return 1;
fail:
fsam_unmap_memory();
return 0;
}
//
// cleaner object for a ValueFactory
//
ValueFactoryCleaner::ValueFactoryCleaner (class CORBA::ValueFactoryBase* factory, char* repid)
: factory_ (factory), is_registered_(false), repid_(repid)
{
int dummy = 0;
CORBA::ORB_var orb = CORBA::ORB_init (dummy, 0);
// check whether there is already a factory
if (orb->lookup_value_factory( repid ))
{
DEBUG_OUT3("..... factory for ", repid, " already registered");
}
else
{
DEBUG_OUT2( "..... register factory for ", repid );
orb->register_value_factory( repid, factory_ );
is_registered_ = true;
}
}
void
AssemblyImpl::build
()
throw( Components::CreateFailure )
{
DEBUG_OUT2( "AssemblyImpl: build assembly for ", package_ );
//
// get data from descriptor file
//
CADReader reader;
try
{
reader.readCAD( package_, &data_, pathname_ );
}
catch( CADReadException )
{
throw Components::CreateFailure();
}
//
// install implementations
//
install();
//
// instantiate components
//
instantiate();
//
// make connections
//
connect();
//
// start components
//
configurationComplete();
DEBUG_OUT3( "AssemblyImpl: assembly for ", package_, " is running" );
}
void
ComponentImplementation::install()
throw(Components::CreateFailure)
{
//
// if already installed increment counter only
//
if (installation_count_)
{
installation_count_++;
DEBUG_OUT3( "..... already installed (", installation_count_, ")" );
return;
}
//
// if without package increment counter only
//
if (package_.empty())
{
installation_count_++;
return;
}
//
// create directories for the component implementation
//
makeDir(data_.installation_dir);
makeDir(build_dir_);
//
// package may be component or composition
//
Package archive = Package( package_ );
std::string xmlfile_name = archive.getFileNameWithSuffix( ".cad" );
if ( xmlfile_name != std::string( "" ) )
{
//
// get info from the assembly package
//
CADReader reader;
try
{
reader.readCAD( package_, &(data_.assembly), build_path_ );
}
catch( CADReadException )
{
std::cerr << "!!!!! Error during reading .cad" << std::endl;
removeFileOrDirectory(data_.installation_dir);
removeFileOrDirectory(build_dir_);
throw Components::CreateFailure();
}
data_.assembly.cad = getFileName( xmlfile_name );
}
else
{
xmlfile_name = archive.getFileNameWithSuffix( ".csd" );
//
// get info from the software package
//
CSDReader reader;
try
{
reader.readCSD( package_, &data_, build_path_ );
}
catch( CSDReadException )
{
std::cerr << "!!!!! Error during reading .csd" << std::endl;
removeFileOrDirectory(data_.installation_dir);
removeFileOrDirectory(build_dir_);
throw Components::CreateFailure();
}
data_.csd = getFileName( xmlfile_name );
}
//
// install any code
//
try
{
installCode();
}
catch( Components::CreateFailure )
{
removeFileOrDirectory(data_.installation_dir);
removeFileOrDirectory(build_dir_);
throw Components::CreateFailure();
}
// increment installation counter ( to 1 )
installation_count_++;
}
char*
RepDCIManagerSessionImpl::install(MDE::Deployment::Assembly_var ass){
char * assUUID = ass->uuid();
MDE::Deployment::Configuration_var cfg = ass->config();
if ( CORBA::is_nil ( cfg ) ) {
NORMAL_ERR("RepDCIManagerSessionImpl::install_with_archive(): assembly reference nil!");
throw CORBA::SystemException();
}
//install on nodes
DEBUG_OUT( "RepDCIManagerSessionImpl::install_with_archive(): install on nodes...");
MDE::Deployment::InstallationSet* inst_set =cfg->install_dest();
for ( unsigned long inst_set_idx = 0; inst_set_idx < inst_set->length(); inst_set_idx++ ) {
MDE::Deployment::DeploymentUnit_var depl = (*inst_set)[inst_set_idx]->impl();
string deplUUID = depl->uuid();
string location("RepRef=");
location += orb_->object_to_string(depl);
DEBUG_OUT( "-----------------------------------------------------------------------------------");
DEBUG_OUT3( deplUUID, " ", location);
// for all destinations:
CorbaIdlTypes::StringSet* dests = (*inst_set)[inst_set_idx]->destinations();
for ( unsigned long dests_idx = 0; dests_idx < dests->length(); dests_idx++ ) {
string destination((*dests)[dests_idx]);
DEBUG_OUT2( " install on node=", destination);
//get NodeManager
DCI::NodeManager_var node_manager_;
try {
node_manager_ = this->get_node_manager(destination.c_str());
}
catch(...) {
throw (Components::Deployment::InstallationFailure());
}
// get ExtComponentInstallation
::DCI::ExtComponentInstallation_var ext_comp_install;
// ::DCI::NodeInformation_var node_information;
CORBA::Object_var obj_nm_;
obj_nm_ = node_manager_->provide_facet("component_installation");
ext_comp_install = ::DCI::ExtComponentInstallation::_narrow ( obj_nm_ );
if (CORBA::is_nil(ext_comp_install))
{
NORMAL_ERR("RepDCIManagerSessionImpl::install_with_archive(): ext_comp_install reference nil!");
throw (Components::Deployment::InstallationFailure());
};
//check non-rep-aware-nodemanager
DCI::RepNodeManager_var rnm = DCI::RepNodeManager::_narrow(node_manager_);
if (CORBA::is_nil(rnm)) {
//non-rep-nodemanager
DEBUG_OUT("RepDCIManagerSessionImpl::install_with_archive(): NON-REP-AWARE-NODEMANAGER");
try {
DEBUG_OUT2("RepDCIManagerSessionImpl::install_with_archive(): try to install without upload uuid=", deplUUID);
ext_comp_install->install(deplUUID.c_str(), "");
}
catch(...) {
//get component archieve
string pathname = mda_etc_var_+"\\repo-files\\"+deplUUID+".ZIP";
DEBUG_OUT2("RepDCIManagerSessionImpl::install_with_archive(): get component package ", pathname);
DCI::AssemblyArchive archive;
::RepUtils::get_file(pathname.c_str(), &archive);
DEBUG_OUT2("RepDCIManagerSessionImpl::install_with_archive(): upload software package with uuid=", deplUUID);
char * nmlocation = ext_comp_install->upload(deplUUID.c_str(), archive);
DEBUG_OUT2("RepDCIManagerSessionImpl::install_with_archive(): install with location=", nmlocation);
ext_comp_install->install(deplUUID.c_str(), nmlocation);
}
}
else
try
{
//install
DEBUG_OUT3("RepDCIManagerSessionImpl::install_with_archive(): try to install uuid/location=", deplUUID, location);
ext_comp_install->install(deplUUID.c_str(), location.c_str());
}
catch (::Components::Deployment::InstallationFailure&)
{
NORMAL_ERR2("RepDCIManagerSessionImpl::install_with_archive(): InstallationFailure on node ", destination);
throw (Components::Deployment::InstallationFailure());
}
catch (::Components::Deployment::InvalidLocation&)
{
NORMAL_ERR2("RepDCIManagerSessionImpl::install_with_archive(): InvalidLocation on node ", destination);
throw (Components::Deployment::InvalidLocation());
}
catch (...)
{
NORMAL_ERR2("RepDCIManagerSessionImpl::install_with_archive(): ERROR on node ", destination);
throw;
}
}
}
//Assembly is installed ("valid")
ass->set_valid(true);
return strdup(assUUID);
}
void
AssemblyImpl::tear_down ()
throw( Components::RemoveFailure )
{
DEBUG_OUT2( "AssemblyImpl: tear down the application for ", package_ );
//
// use reverse start order to remove components
//
std::vector < std::string > ::reverse_iterator iter;
std::map < std::string, Components::CCMObject_var > ::iterator instanceIter;
Components::CCMObject_var comp;
for(iter = data_.start_order_.rbegin();
iter != data_.start_order_.rend();
iter++ )
{
instanceIter = instanceMap_.find( *iter );
if( instanceIter != instanceMap_.end() )
{
try
{
DEBUG_OUT2("..... remove ", instanceIter->first );
comp = Components::CCMObject::_duplicate( instanceIter->second );
comp->remove();
}
catch (CORBA::Exception&)
{
NORMAL_ERR2( "AssemblyImpl: EXCEPTION during removal of ", instanceIter->first );
}
instanceMap_.erase( instanceIter );
}
}
//
// call remove for all remaining components
//
for( instanceIter = instanceMap_.begin();
instanceIter != instanceMap_.end();
instanceIter++ )
{
try
{
DEBUG_OUT2( "..... remove ", instanceIter->first );
instanceIter->second->remove();
}
catch (CORBA::Exception&)
{
NORMAL_ERR2( "AssemblyImpl: EXCEPTION during removal of ", instanceIter->first );
}
}
instanceMap_.clear();
//
// remove homes/containers/servers
//
std::vector < HostData > ::iterator host_iter;
std::vector < ProcessData > ::iterator process_iter;
std::vector < HomeInstanceData > ::iterator home_iter;
// for each host
for(host_iter = data_.hosts_.begin();
host_iter != data_.hosts_.end();
host_iter++)
{
// for each processcollocation
for(process_iter = (*host_iter).processes.begin();
process_iter != (*host_iter).processes.end();
process_iter++)
{
// for each homeplacement
for(home_iter = (*process_iter).homes.begin();
home_iter != (*process_iter).homes.end();
home_iter++)
{
// remove home
try
{
DEBUG_OUT2( "..... remove home ", (*home_iter).id );
(*home_iter).container->remove_home(getHomeInstance((*home_iter).id));
}
catch (Components::RemoveFailure)
{
NORMAL_ERR2( "AssemblyImpl: remove home failure for ", (*home_iter).id );
}
catch (CORBA::Exception& e)
{
NORMAL_ERR2( "AssemblyImpl: EXCEPTION during removal of home ", (*home_iter).id );
#ifdef MICO_ORB
e._print (std::cerr);
std::cerr << std::endl;
#endif
}
// remove container
try
{
DEBUG_OUT( "..... remove container" );
(*home_iter).container->remove();
}
catch (Components::RemoveFailure)
{
NORMAL_ERR( "AssemblyImpl: remove container failure" );
}
catch (CORBA::Exception& e)
{
NORMAL_ERR( "AssemblyImpl: EXCEPTION during removal of container" );
#ifdef MICO_ORB
e._print (std::cerr);
std::cerr << std::endl;
#endif
}
}
// remove component server
try
{
DEBUG_OUT( "..... remove component server" );
(*process_iter).server->remove();
}
catch (Components::RemoveFailure)
{
NORMAL_ERR( "AssemblyImpl: remove component server failure");
}
catch (CORBA::Exception& e)
{
NORMAL_ERR( "AssemblyImpl: EXCEPTION during removal of container" );
#ifdef MICO_ORB
e._print (std::cerr);
std::cerr << std::endl;
#endif
}
}
}
homeMap_.clear();
//
// uninstall
//
uninstall();
DEBUG_OUT3( "application for ", package_, " is teared down and uninstalled" );
}
