bool Package::PackDepend(const Package& p) const
{
bool depends(false);
Depend(p);
for(std::set<Package>::const_iterator it = m_Package->second.package.begin();
it != m_Package->second.package.end(); ++it)
{
p.PackDepend(*it);
}
for(std::set<Object>::const_iterator it = m_Package->second.object.begin();
it != m_Package->second.object.end(); ++it)
{
if(it->Depend(p))
{
//direct dependency
depends = true;
}
}
if(depends && Name() != p.Name())
{
std::clog << '"' << fs::basename(fs::path(Name()).leaf()) << "\" -> \""
<< fs::basename(fs::path(p.Name()).leaf()) << "\";" << std::endl;
}
return depends;
}
int TcpProtocol::mysend(char *data, int len, int peer)
{
Package *message = new Package(2, peer, data);
int m = send(msocket, message->getbuf(), PACKAGE_SIZE, 0);
delete message;
return m;
}
void PackageService::onFinish()
{
FinishSqliteVFS();
// Turn off all sticky flags - NO MERCY!
for (PackageNameMap::iterator itr = _linkedPackages.begin(), end = _linkedPackages.end(); itr != end; ++itr)
{
itr->second->_stayResident = false;
itr->second->_stayForCurrent = false;
itr->second->_stayForNext = false;
}
// And compact so that all packages get disposed
compact();
// If Something's remaining, we're in danger!
for (PackageNameMap::iterator itr = _linkedPackages.begin(), end = _linkedPackages.end(); itr != end; ++itr)
{
Package* pack = itr->second;
LOG(0, "*** Package '%s': still alive: %d usage, requires:\n", pack->getName().c_str(), pack->getUseCount());
if (pack->getRequiredList().empty())
LOG(0, " <none>\n");
else
pack->printDependancy(1);
}
// Terminate AsyncLoader
if (_asyncLoader)
{
_asyncLoader->Terminate();
}
safeDelete(_asyncLoader);
}
int general_replica(Package package, struct HostEntity &destination) {
package.set_replicano(3);
string str = package.SerializeAsString();
// cout << "socket_replica--------1" << endl;
// cout << "socket_replica--------before makeConnForReplica sock = "<< destination.sock << endl;
int sock = makeConnForReplica(destination); //reusable sockets creation
// cout << "socket_replica--------after makeConnForReplica sock = "<< destination.sock << endl;
// int sock = makeClientSocket("localhost", 50009, true);
// cout << "socket_replica--------2, sock = " << sock << endl;
// generalSend(destination.host, destination.port, sock, str.c_str(), 1);
// cout << "socket_replica--------2, sock = " << sock << endl;
// generalSendTCP(sock, str.c_str());
generalSendTo(destination.host.c_str(), destination.port, sock, str.c_str(),
str.size(), TCP);
// cout << "socket_replica--------3" << endl;
void *buff_return = (void*) malloc(sizeof(int32_t));
// int r = d3_svr_recv(sock, buff_return, sizeof(int32_t), 0, &recv_addr);
// int r = generalReveiveTCP(sock, buff_return, sizeof buff_return, 0);
struct sockaddr_in recvAddr;
// int r =generalReceive(sock, buff_return, sizeof(int32_t), recvAddr, 0, TCP);
int r = 0;
// cout << "socket_replica--------4" << endl;
//connect (int socket, struct sockaddr *addr, size_t length)
if (r < 0) {
cerr << "general_replica: got bad news from relica: " << r << endl;
}
}
void SharedMemory::create(const char* name, Package& pkg)
{
shared_mem_name_ = name;
// Create a shared memory object
shm = ipc::shared_memory_object(ipc::open_or_create, shared_mem_name_.c_str(), ipc::read_write);
// Serialize the package specification (first to a buffer, because we do not know how big it is)
io::GrowingBuffer spec;
pkg.SerializeSpecification(spec);
// Set size: specification size + package size
shm.truncate(spec.size() + pkg.size());
// Map the specification region
mem_spec_ = ipc::mapped_region(shm, ipc::read_write, 0, spec.size());
// Map the data (pkg) region
mem_pkg_ = ipc::mapped_region(shm, ipc::read_write, spec.size(), pkg.size());
// Copy the package specification to the shared memory
spec.copyTo(mem_spec_.get_address());
// Map the package to the data address
pkg.mapTo(mem_pkg_.get_address());
}
Controller::Controller(int serverSocket, bool displayStati) : AbstractHost(serverSocket), stdinWatcher(NULL), commands(NULL), lastSendPackageID(0), waitingForAck(false), maxCommandNameLength(0)
{
this->displayStati = displayStati;
std::cout<<std::endl;
std::cout<<" _ ._ _| _ ._ |_ _ "<<std::endl;
std::cout<<" \\/(_)| |(_|(/_| |_)(_)\\/"<<std::endl;
std::cout<<" / / "<<std::endl;
std::cout<<std::endl;
commands = new std::map<std::string, CommandParser*>();
parseSpecFile(configuration->retrieveAsPath("general","net-spec"));
if(maxCommandNameLength<4) { maxCommandNameLength = 4; } // for the case where the "help" command is the longest
commands->insert(std::make_pair("help", new HelpCommandParser(commands, maxCommandNameLength)));
// setup stdin read watcher and readline library
rl_attempted_completion_function = &Controller::completionCallback;
using_history();
stdinWatcher = new ev::io();
stdinWatcher->set<Controller, &Controller::stdinCallback>(this);
Package *initPackage;
if(displayStati)
{
initPackage = constructPackage("connection-management", "id", getNextPackageID().c_str(), "command", "initialize", "client-name", PROJECT_NAME, "client-version", PROJECT_VERSION, "can-display-stati", "", "interactive", "", "can-handle-requests", "", NULL);
}
else
{
initPackage = constructPackage("connection-management", "id", getNextPackageID().c_str(), "command", "initialize", "client-name", PROJECT_NAME, "client-version", PROJECT_VERSION, "interactive", "", "can-handle-requests", "", NULL);
}
lastSendPackageID = initPackage->getID();
waitingForAck = true;
sendPackageAndDelete(initPackage);
}
int32_t HB_insert(NoVoHT *map, Package &package) {
//int opt = package.operation();//opt not be used?
string value = package.SerializeAsString();
//int ret = db.set(package.virtualpath(), package_str); //virtualpath as key
// cout << "Insert to pmap...value = " << value << endl;
string key = package.virtualpath();
// cout<<"key:"<<key<<endl;
// cout<<"value:"<<value<<endl;
// cout<<"Insert: k-v ready. put..."<<endl;
int ret = map->put(key, value);
// cout << "end inserting, ret = " << ret << endl;
if (ret != 0) {
cerr << "insert error: ret = " << ret << endl;
return -3;
}
/*
cout << "String insted: " << package_str << endl;
*/
else
return 0;
}
void Server::in_ping_ACK(Packet* p)
{
sf::Uint8 sortingId;
*p >> sortingId;
Package* pack = connection.getPacketNR(sortingId);
if (pack == 0)
{
cout << "Recieved ACK on a non-used package slot?" << endl;
return;
}
//ping doesnt use event ID so it should be empty
if (pack->getEventID() != NET_EVENT_ID::EMPTY)
{
cout << "Recieved ACK on WRONG package slot?" << endl;
return;
}
unsigned int oldStamp = pack->getTimeStamp();
unsigned int temp = clock();
oldStamp = temp - oldStamp;
cout << "Ping Confirmed. RTT: " << oldStamp << endl;
connection.successfulPing = true;
connection.clearPacketNR(sortingId);
}
void RepositoryProfile::addPackage ( const Package &package )
{
packages.insert ( package.packageName(), package );
// set the architecture for this package
packages[package.packageName() ].setArchitectures ( PackageMetaData::archStringList ( architecures() ) );
updatePackageStatus ( package.packageName() );
}
void MeshGame::initialize()
{
// Display the gameplay splash screen for at least 2.4 seconds.
displaySplash(this, &MeshGame::drawSplash, NULL, 2400L);
// Load font
_font = Font::create("res/arial40.gpb");
// Load mesh/scene from file
Package* pkg = Package::create("res/duck.gpb");
_scene = pkg->loadScene();
SAFE_RELEASE(pkg);
// Get the duck node
_modelNode = _scene->findNode("duck");
// Bind the material to the model
_modelNode->getModel()->setMaterial("res/duck.material");
// Find the light node
Node* lightNode = _scene->findNode("directionalLight1");
// Bind the light node's direction into duck's material.
_modelNode->getModel()->getMaterial()->getParameter("u_lightDirection")->bindValue(lightNode, &Node::getForwardVectorView);
}
const FilePath *Helium::Asset::GetAssetFileSystemPath()
{
HELIUM_ASSERT( !m_path.IsEmpty() );
FilePath filePath;
Asset *pSourceAsset = GetSourceAsset();
if (pSourceAsset)
{
Package *pPackage = Reflect::SafeCast<Package>( pSourceAsset->GetOwner() );
if ( pPackage )
{
PackageLoader *pLoader = pPackage->GetLoader();
HELIUM_ASSERT( pLoader->HasAssetFileState() );
if ( pLoader )
{
return &pLoader->GetAssetFileSystemPath( pSourceAsset->GetPath() );
}
}
}
return NULL;
}
void* notQueue(void* args) {
Worker *worker = (Worker*) args;
string *st;
Package package;
while (ON) {
while (notifyq.size() > 0) {
pthread_mutex_lock(¬q_lock);
if (notifyq.size() > 0) {
try {
st = notifyq.front();
notifyq.pop();
} catch (exception& e) {
cout << "void* notifyq: " << e.what() << endl;
exit(1);
}
} else {
pthread_mutex_unlock(¬q_lock);
continue;
}
pthread_mutex_unlock(¬q_lock);
package.ParseFromString(*st);
delete st;
worker->update(package);
}
}
}
int Worker::zht_remove(string key) {
/*Package package;
package.set_virtualpath(key);
package.set_operation(2);
string str = package.SerializeAsString();
int index;
svrclient.str2Host(str, index);*/
int index = myhash(key.c_str(), svrclient.memberList.size());
if (index != selfIndex) {
Package package;
package.set_virtualpath(key);
package.set_operation(2);
string str = package.SerializeAsString();
pthread_mutex_lock(&msg_lock);
int ret = svrclient.remove(str);
pthread_mutex_unlock(&msg_lock);
return ret;
} else {
int ret = pmap->remove(key);
if (ret != 0) {
cerr << "DB Error: fail to remove :ret= " << ret << endl;
return -2;
} else
return 0; //succeed.
}
}
int Worker::zht_insert(string str) {
Package package;
package.ParseFromString(str);
package.set_operation(3);
str = package.SerializeAsString();
int index;
svrclient.str2Host(str, index);
if (index != selfIndex) { //cout << "NOOOOO..index = " << index << endl;
pthread_mutex_lock(&msg_lock);
int ret = svrclient.insert(str);
pthread_mutex_unlock(&msg_lock);
return ret;
} else {
string key = package.virtualpath(); //cout << "key = " << key << endl;
//pthread_mutex_lock(&zht_lock);
int ret = pmap->put(key, str);
//pthread_mutex_unlock(&zht_lock);
if (ret != 0) {
cerr << "insert error: key = " << key << " ret = " << ret << endl;
return -3;
} else
return 0;
}
}
OutcomePackage::OutcomePackage(const Package &xPackage) : OutcomPackage()
{
mHeaderSended = false;
mBodySended = false;
mFileSended = false;
mBody.open(QIODevice::WriteOnly);
QDataStream xBodyStream(&mBody);
xBodyStream.setVersion(QDataStream::Qt_4_7);
xBodyStream<<xPackage.getBodyFields();
mBody.close();
mFile.setFileName(xPackage.getAttachedFile());
QFileInfo xAttachedFileInfo(mFile);
mHeader.open(QIODevice::WriteOnly);
QDataStream xHeaderStream(&mHeader);
xHeaderStream.setVersion(QDataStream::Qt_4_7);
xHeaderStream<<qint64(0);//оставляем место для размера заголовка
xHeaderStream<<mBody.size();
xHeaderStream<<xAttachedFileInfo.fileName();
xHeaderStream<<mFile.size();
xHeaderStream.device()->seek(0);
xHeaderStream<<mHeader.size();
mHeader.close();
mBytesTottal = mHeader.size() + mBody.size() + mFile.size();
mBytesCurrent = 0;
}
Package * ReflectorPass::getOrCreateSubPackage(const StringRef & pkgName, Module * module) {
PackageMap::iterator it = packages_.find(pkgName);
if (it != packages_.end()) {
return it->second;
}
// Try to find a parent package
std::string parentPkgName(pkgName);
std::string::size_type dot = parentPkgName.rfind('.');
if (dot != parentPkgName.npos) {
parentPkgName.erase(dot, parentPkgName.npos);
Package * parent = getOrCreateSubPackage(parentPkgName, module);
if (parent != NULL) {
assert(parent->global() != NULL);
GlobalVariable * global = new GlobalVariable(*module,
parent->global()->getType()->getContainedType(0), true,
GlobalValue::ExternalLinkage, NULL, ".package." + pkgName);
Package * p = createPackage(pkgName, global);
parent->subpackages().push_back(p);
return p;
}
}
return NULL;
}
int CSysInfo::GetKernelBitness(void)
{
static int kernelBitness = -1;
if (kernelBitness == -1)
{
#ifdef TARGET_WINDOWS_STORE
Package package = Package::Current();
auto arch = package.Id().Architecture();
switch (arch)
{
case ProcessorArchitecture::X86:
kernelBitness = 32;
break;
case ProcessorArchitecture::X64:
kernelBitness = 64;
break;
case ProcessorArchitecture::Arm:
kernelBitness = 32;
break;
case ProcessorArchitecture::Unknown: // not sure what to do here. guess 32 for now
case ProcessorArchitecture::Neutral:
kernelBitness = 32;
break;
}
#elif defined(TARGET_WINDOWS_DESKTOP)
SYSTEM_INFO si;
GetNativeSystemInfo(&si);
if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL || si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_ARM)
kernelBitness = 32;
else if (si.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64)
kernelBitness = 64;
else
{
BOOL isWow64 = FALSE;
if (IsWow64Process(GetCurrentProcess(), &isWow64) && isWow64) // fallback
kernelBitness = 64;
}
#elif defined(TARGET_DARWIN_IOS)
// Note: OS X return x86 CPU type without CPU_ARCH_ABI64 flag
const NXArchInfo* archInfo = NXGetLocalArchInfo();
if (archInfo)
kernelBitness = ((archInfo->cputype & CPU_ARCH_ABI64) != 0) ? 64 : 32;
#elif defined(TARGET_POSIX)
struct utsname un;
if (uname(&un) == 0)
{
std::string machine(un.machine);
if (machine == "x86_64" || machine == "amd64" || machine == "arm64" || machine == "aarch64" || machine == "ppc64" ||
machine == "ia64" || machine == "mips64" || machine == "s390x")
kernelBitness = 64;
else
kernelBitness = 32;
}
#endif
if (kernelBitness == -1)
kernelBitness = 0; // can't detect
}
return kernelBitness;
}
void LoadPackageV1(TiXmlElement *packNode, Category *cat)
{
const char *type = packNode->Attribute("type");
if(!type) type = "";
const char *name = packNode->Attribute("name");
if(!name) name = "";
const char *desc = packNode->Attribute("desc");
if(!desc) desc = "";
Package *pack = new Package(Package::getType(type), name, cat);
unique_ptr<Package> ptr(pack);
pack->setDescription(desc);
TiXmlElement *node = packNode->FirstChildElement("version");
while(node) {
LoadVersionV1(node, pack);
node = node->NextSiblingElement("version");
}
node = packNode->FirstChildElement("metadata");
if(node)
LoadMetadataV1(node, pack->metadata());
if(cat->addPackage(pack))
ptr.release();
}
void NPCPackage::leavePackage ()
{
const b2Vec2& pos = getPos();
Package* package = new Package(_map, pos.x, pos.y);
package->createBody();
returnToInitialPosition();
}
void CharacterGame::initialize()
{
// Load the font.
_font = Font::create("res/arial40.gpb");
// Load mesh from file.
Package* pkg = Package::create("res/seymour.gpb");
_scene = pkg->loadScene();
SAFE_RELEASE(pkg);
_modelNode = _scene->findNode("boyShape");
// Get directional light node.
Node* lightNode = _scene->findNode("directionalLight1");
// Load character's material from a .material file.
Material* meshMaterial = _modelNode->getModel()->setMaterial("res/seymour.material");
meshMaterial->getParameter("u_lightDirection")->bindValue(lightNode, &Node::getForwardVectorView);
// Load character animations clips.
loadAnimationClips();
// Get plane.
Node* planeNode = _scene->findNode("floor");
// Load planes material from a .material file.
Material* planeMaterial = planeNode->getModel()->setMaterial("res/floor.material");
planeMaterial->getParameter("u_lightDirection")->bindValue(lightNode, &Node::getForwardVectorView);
}
int32_t HB_insert_cstr_(map<char*, char*> &chmap, Package &package) {
string package_str = package.SerializeAsString();
char* value = (char*) malloc(package_str.length() * sizeof(char));
strcpy(value, package_str.c_str());
char* key = (char*) malloc(package.virtualpath().length() * sizeof(char));
// cout << "package.virtualpath().c_str()="<<package.virtualpath().c_str()<<endl;
strcpy(key, package.virtualpath().c_str());
// cout <<"after scrcpy, key = "<<key<<", key length = "<< strlen(key) <<endl;
// pair<map<char*, char*>::iterator, bool> ret;
// ret = chmap.insert(pair<char*, char*>(key, value));
// free(key);
// free(value);
if (chmap.insert(pair<char*, char*>(key, value)).second == false) {
cout
<< "HB_insert_cstr: insert failed, return -3, element exists, key = "
<< key << ", value = " << value << endl;
free(key);
free(value);
return -3;
} else {
cout << " HB_insert_cstr: insert succeeded. key = " << key
<< ", value = " << chmap.find(key)->second << endl;
free(key);
free(value);
return 0;
}
}
void Block_manager_parent::init(Ssd* new_ssd, FtlParent* new_ftl, IOScheduler* new_sched, Garbage_Collector* new_gc, Wear_Leveling_Strategy* new_wl, Migrator* new_migrator) {
ssd = new_ssd;
ftl = new_ftl;
scheduler = new_sched;
for (uint i = 0; i < SSD_SIZE; i++) {
Package* package = ssd->get_package(i);
for (uint j = 0; j < PACKAGE_SIZE; j++) {
Die* die = package->get_die(j);
for (uint t = 0; t < DIE_SIZE; t++) {
Plane* plane = die->get_plane(t);
for (uint b = 0; b < PLANE_SIZE; b++) {
Block* block = plane->get_block(b);
free_blocks[i][j][0].push_back(Address(block->get_physical_address(), PAGE));
all_blocks.push_back(block);
}
}
Address pointer = free_blocks[i][j][0].back();
free_block_pointers[i][j] = pointer;
Free_Space_Per_LUN_Meter::mark_new_space(pointer, 0);
free_blocks[i][j][0].pop_back();
}
}
wl = new_wl;
gc = new_gc;
migrator = new_migrator;
}
void AbstractHost::processPackage()
{
Package *constructedPackage = new Package(parseBuffer);
if(!constructedPackage->isValid())
{
sendPackage(constructAcknowledgementPackage(constructedPackage, "invalid"));
delete constructedPackage;
}
else if(!server->packageRouterInstance()->isAllowed(type, constructedPackage))
{
sendPackageAndDelete(constructAcknowledgementPackage(constructedPackage, "forbidden"));
delete constructedPackage;
}
else if(constructedPackage->getType() == ConnectionManagement)
{
updateNextPackageID(constructedPackage->getID());
handlePackage(constructedPackage);
}
else if(state == Established)
{
updateNextPackageID(constructedPackage->getID());
server->packageRouterInstance()->processPackage(this, constructedPackage);
}
else
{
sendPackage(constructAcknowledgementPackage(constructedPackage, "invalid"));
delete constructedPackage;
}
parseBuffer.clear();
}
int benchmarkInsert() {
double start = 0;
double end = 0;
start = TimeUtil::getTime_msec();
int errCount = 0;
int c = 0;
vector<string>::iterator it;
for (it = pkgList.begin(); it != pkgList.end(); it++) {
c++;
string pkg_str = *it;
Package pkg;
pkg.ParseFromString(pkg_str);
int ret = zc.insert(pkg.virtualpath(), pkg_str);
if (ret < 0) {
errCount++;
}
}
end = TimeUtil::getTime_msec();
char buf[200];
sprintf(buf, "Inserted packages, %d, %d, cost(ms), %f", numOfOps - errCount,
numOfOps, end - start);
cout << buf << endl;
return 0;
}
/// Initialize the static type information for the "GameObject" class.
///
/// @return Static "GameObject" type.
const GameObjectType* GameObject::InitStaticType()
{
HELIUM_ASSERT( s_Class );
if ( !s_Class->m_Tag )
{
// To resolve interdependencies between the GameObject type information and other objects (i.e. the owner
// package, its type, etc.), we will create and register all the dependencies here manually as well.
Name nameObject( TXT( "GameObject" ) );
Name namePackage( TXT( "Package" ) );
RenameParameters nameParamsObject, nameParamsPackage, nameParamsEngine, nameParamsTypes;
nameParamsEngine.name.Set( TXT( "Engine" ) );
nameParamsTypes.name.Set( TXT( "Types" ) );
Package* pTypesPackage = new Package();
HELIUM_ASSERT( pTypesPackage );
HELIUM_VERIFY( RegisterObject( pTypesPackage ) );
HELIUM_VERIFY( pTypesPackage->Rename( nameParamsTypes ) );
GameObjectType::SetTypePackage( pTypesPackage );
nameParamsEngine.spOwner = pTypesPackage;
Package* pEnginePackage = new Package();
HELIUM_ASSERT( pEnginePackage );
HELIUM_VERIFY( RegisterObject( pEnginePackage ) );
HELIUM_VERIFY( pEnginePackage->Rename( nameParamsEngine ) );
// Don't set up templates here; they're initialized during type registration.
GameObjectPtr spObjectTemplate = Helium::Reflect::AssertCast< GameObject >( s_Class->m_Default );
HELIUM_ASSERT( spObjectTemplate );
PackagePtr spPackageTemplate = new Package();
HELIUM_ASSERT( spPackageTemplate );
// Package flag is set automatically by the Package constructor, but it shouldn't be set for the Package
// type template.
spPackageTemplate->ClearFlags( FLAG_PACKAGE );
// Initialize and register all types.
GameObjectType::Create(
Reflect::GetClass< GameObject >(),
pEnginePackage,
NULL,
spObjectTemplate,
GameObjectType::FLAG_ABSTRACT );
HELIUM_VERIFY( GameObjectType::Create(
Reflect::GetClass< Package >(),
pEnginePackage,
static_cast< const GameObjectType* >( s_Class->m_Tag ),
spPackageTemplate,
0 ) );
// Force initialization of Package so it can report its static type information.
HELIUM_VERIFY( Package::InitStaticType() );
}
return static_cast< const GameObjectType* >( s_Class->m_Tag );
}
unsigned char* PackageManager::getFileData(const char* fileName, unsigned long* dataSize)
{
if (m_currentPackage && m_currentPackage->fileExist(fileName)) {
unsigned char* buffer = m_currentPackage->getFileData(fileName, dataSize);
if (buffer) {
return buffer;
}
}
for (std::vector<Package*>::iterator itr = m_allPackages.begin(); itr != m_allPackages.end(); ++itr) {
Package* package = *itr;
if (!package) {
continue;
}
if (!package->fileExist(fileName)) {
continue;
}
unsigned char* buffer = package->getFileData(fileName, dataSize);
if (buffer) {
return buffer;
}
}
return NULL;
}
void get_map_1(vector<string> &mqueue, uint32_t num_nodes) {
//map<uint32_t, NodeList> update_map;
//uint32_t num_nodes = svrclient.memberList.size();
for(vector<string>::iterator it = mqueue.begin(); it != mqueue.end(); ++it) {
Package package;
package.ParseFromString(*it); //cout << "key = " << package.virtualpath() << endl;
uint32_t serverid = myhash(package.virtualpath().c_str(), num_nodes);
string str(*it); str.append("#");
if(update_map_zht.find(serverid) == update_map_zht.end()) {
str.append("$");
NodeList new_list;
new_list.push_back(str);
update_map_zht.insert(make_pair(serverid, new_list));
}
else {
NodeList &exist_list = update_map_zht[serverid];
string last_str(exist_list.back());
if((last_str.size() + str.size()) > STRING_THRESHOLD) {
str.append("$");
exist_list.push_back(str);
}
else {
exist_list.pop_back();
str.append(last_str);
exist_list.push_back(str);
}
}
}
//return update_map;
}
int ZHTClient::removeMeta(string path) {
Package package;
package.set_operation(2); // 3 for insert, 1 for look up, 2 for remove
package.set_replicano(3); //5: original, 3 not original
package.set_virtualpath(path);
string str = package.SerializeAsString();
int sock = this->str2SockLRU(str, TCP);
reuseSock(sock);
// cout<<"sock = "<<sock<<endl;
struct HostEntity dest = this->str2Host(str);
sockaddr_in recvAddr;
int sentSize = generalSendTo(dest.host.data() ,dest.port, sock, str.c_str(), TCP);
// cout<<"remove sentSize "<< sentSize <<endl;
int32_t* ret_buf = (int32_t*) malloc(sizeof(int32_t));
// generalReveiveTCP(sock, (void*) ret_buf, sizeof(int32_t), 0);
generalReceive(sock, (void*)ret_buf, sizeof(int32_t),recvAddr,0, TCP);
// generalSendTCP(sock, str.c_str());
// int32_t* ret = (int32_t*) malloc(sizeof(int32_t));
// generalReveiveTCP(sock, (void*) ret, sizeof(int32_t), 0);
int ret_1 = *(int32_t*) ret_buf;
// cout<<"remove got: "<< ret_1 <<endl;
// cout <<"Returned status: "<< *(int32_t*) ret<<endl;
// d3_closeConnection(sock);
free(ret_buf);
return ret_1;
}
void UmlDeploymentView::scan_it(int & n)
{
// compute artifact list
const Q3PtrVector<UmlItem> & ch = UmlItem::children();
UmlItem ** v = ch.data();
UmlItem ** const vsup = v + ch.size();
n = 0;
for (; v != vsup; v += 1) {
if (((*v)->kind() == anArtifact) &&
((UmlArtifact *) *v)->is_roundtrip_expected()) {
Artifacts.append((UmlArtifact *) *v);
n += 1;
}
}
if (n != 0) {
Package::set_step(1, n);
Package * pk =
((UmlPackage *) Artifacts.first()->parent()->parent())->get_package();
foreach (UmlArtifact *artifact, Artifacts) {
pk->reverse(artifact);
Progress::tic_it();
}
void WorkerThread::run() {
// If you wish to add post-extraction code, do it here.
connect( this, SIGNAL( requestDiskspaceError() ),
this, SLOT( showDiskspaceError() ) );
// FIXME: Remove Test code for dialog over splash screen.
//QThread::currentThread()->sleep( 1 );
//emit requestDiskspaceError();
//return;
QDir d( _hiddenDir );
if ( ! QFile::exists( QDir::cleanPath( _hiddenDir + "/version.nfo" ) ) ) {
Package* pkg = Package::openEdit( _archFile );
if ( ! checkAvailoableDiskSpace( pkg->requiredDiskSpace() ) ) {
delete pkg;
return;
}
connect( pkg, SIGNAL( checkingFile( QString ) ),
this, SLOT( checkingFile( QString ) ) );
connect( pkg, SIGNAL( extractingFile( QString ) ),
this, SLOT( extractingFile( QString ) ) );
connect( pkg, SIGNAL( skippingFile( QString ) ),
this, SLOT( skippingFile( QString ) ) );
connect( pkg, SIGNAL( finishExtracting() ),
this, SLOT( finishExtracting() ) );
connect( pkg, SIGNAL( startExtracting( int ) ),
this, SLOT( startExtracting( int ) ) );
connect( pkg, SIGNAL( destroyed( QObject* ) ),
this, SLOT( packageDeleted() ) );
pkg->extractAll( _hiddenDir );
delete pkg;
} else {
