Пример #1
9
inline BOOL ConfDB::UpdateVIPCData(u32 nId, VSCVIPCData &pData)
{
    VSCConfVIPCKey sChKey(nId);
    leveldb::WriteOptions writeOptions;

    leveldb::Slice chKey((char *)&sChKey, sizeof(sChKey));
    leveldb::Slice chValue((char *)&pData, sizeof(VSCDeviceData));
    m_pDb->Put(writeOptions, chKey, chValue);

    return TRUE;
}
Пример #2
0
		void load(unsigned short bamIndex)
			{
			size_t n_reads=0;
			std::string value;
			bam1_t *b= bam_init1();
			
			index2chromNames.resize(bamIndex+1);
			WHERE(in->header);
			for(int32_t i=0;i< in->header->n_targets;++i)
				{
				string target_name(in->header->target_name[i]);
				
				index2chromNames.back().push_back(target_name);
				}
			while(samread(this->in, b) > 0) /* loop over the records */
				{
				std::auto_ptr<vector<Hit> > hits(0);
				Bam1Sequence seq(b);
				leveldb::Slice key1(seq.name());
				value.clear();
				WHERE(n_reads);
				leveldb::Status status = db->Get(this->read_options, key1, &value);
				
				if(!status.ok())
					{
					hits.reset(new vector<Hit>());
					n_reads++;
					if(n_reads%1000000UL==0)
						{
						clog <<  n_reads << endl;
						//break;//TODO
						}
					}
				else
					{
					hits=decode(value);
					}
				
				Hit hit;
				hit.bamIndex=bamIndex;
				hit.tid = seq.tid();
				hit.pos = seq.pos();
				hit.flag = seq.flag();
				hits->push_back(hit);
				
				std::auto_ptr<string> encoded = this->encode(hits.get());
				leveldb::Slice value1(encoded->data(),encoded->size());
				status = db->Put(this->write_options, key1, value1);
				if(!status.ok())
					{
					cerr << "Cannot insert into db" << endl;
					break;
					}
				}
			bam_destroy1(b);
			
			}
Пример #3
0
Try<Option<Entry> > LevelDBStorageProcess::read(const string& name)
{
  CHECK_NONE(error);

  leveldb::ReadOptions options;

  string value;

  leveldb::Status status = db->Get(options, name, &value);

  if (status.IsNotFound()) {
    return None();
  } else if (!status.ok()) {
    return Error(status.ToString());
  }

  google::protobuf::io::ArrayInputStream stream(value.data(), value.size());

  Entry entry;

  if (!entry.ParseFromZeroCopyStream(&stream)) {
    return Error("Failed to deserialize Entry");
  }

  return Some(entry);
}
Пример #4
0
inline BOOL ConfDB::GetVIPCData(u32 nId, VSCVIPCData &pData)
{
    VSCConfVIPCKey sChKey(nId);

    leveldb::Slice key((char *)&sChKey, sizeof(sChKey));


    leveldb::Iterator* it = m_pDb->NewIterator(leveldb::ReadOptions());

    it->Seek(key);
    leveldb::Slice sysValue;

    if (it->Valid())
    {
        sysValue = it->value();
    }

    if (sysValue.size() != sizeof(VSCVIPCData))
    {
        VDC_DEBUG( "Device Can not find !!!\n");

        delete it;
        return FALSE;
    }

    memcpy(&pData, sysValue.data(), sizeof(VSCVIPCData));

    // Check for any errors found during the scan
    assert(it->status().ok());
    delete it;

    return TRUE;
}
Пример #5
0
inline   BOOL ConfDB::GetLicense(astring &strLicense)
{
	VSCConfLicenseKey sLicKey;
	

	leveldb::Slice key((char *)&sLicKey, sizeof(sLicKey));


	leveldb::Iterator* it = m_pDb->NewIterator(leveldb::ReadOptions());

	it->Seek(key);
	leveldb::Slice sysValue;

	if (it->Valid())
	{
		sysValue = it->value();
		strLicense = sysValue.ToString();
	}
	
	// Check for any errors found during the scan
	assert(it->status().ok());
	delete it;

	return TRUE;

}
Пример #6
0
			Status Get(const std::string& key, std::string* value)
			{
				leveldb::Status s = db->Get(leveldb::ReadOptions(), key, value);
				if (s.ok())
				{
					return Status::OK();
				}

				return Status::NotFound();
			}
Пример #7
0
inline   BOOL ConfDB::SetLicense(astring &strLicense)
{
	VSCConfLicenseKey sLic;
	leveldb::WriteOptions writeOptions;

	leveldb::Slice licKey((char *)&sLic, sizeof(sLic));
	leveldb::Slice licValue(strLicense);
	m_pDb->Put(writeOptions, licKey, licValue);
	return true;
    
}
Пример #8
0
			Status Delete(const std::string& key)
			{
				leveldb::Status s = db->Delete(leveldb::WriteOptions(), key);

				if (s.ok())
				{
					return Status::OK();
				}

				return Status::NotFound();
			}
Пример #9
0
			Status Put(const std::string& key, const std::string& value)
			{
				leveldb::Status s = db->Put(leveldb::WriteOptions(), key, value);

				if (s.ok())
				{
					return Status::OK();
				}
                std::cerr << s.ToString() << std::endl;
				return Status::NotFound();

			}
Пример #10
0
/* HDFS record  */
inline s32 ConfDB::UpdateHdfsRecordData(VSCHdfsRecordData &pData)
{
    VSCConfHdfsRecordKey sKey;

    leveldb::WriteOptions writeOptions;

    leveldb::Slice sysKey((char *)&sKey, sizeof(sKey));
    leveldb::Slice sysValue((char *)&pData, sizeof(VSCHdfsRecordData));

    m_pDb->Put(writeOptions, sysKey, sysValue);

    return TRUE;
}
Пример #11
0
/* Camera Group  */
inline s32 ConfDB::UpdateVGroupData(VSCVGroupData &pVGroupData)
{
    VSCConfVGroupKey sVGroupKey;

    leveldb::WriteOptions writeOptions;

    leveldb::Slice sysKey((char *)&sVGroupKey, sizeof(sVGroupKey));
    leveldb::Slice sysValue((char *)&pVGroupData, sizeof(VSCVGroupData));

    m_pDb->Put(writeOptions, sysKey, sysValue);

    return TRUE;
}
Пример #12
0
inline s32 ConfDB::UpdateSysData(VSCConfData &pSysData)
{
    VSCConfSystemKey sSysKey;

    leveldb::WriteOptions writeOptions;

    leveldb::Slice sysKey((char *)&sSysKey, sizeof(sSysKey));
    leveldb::Slice sysValue((char *)&pSysData, sizeof(VSCConfData));

    m_pDb->Put(writeOptions, sysKey, sysValue);

    return TRUE;
}
Пример #13
0
void LevelDBStorageProcess::initialize()
{
  leveldb::Options options;
  options.create_if_missing = true;

  leveldb::Status status = leveldb::DB::Open(options, path, &db);

  if (!status.ok()) {
    // TODO(benh): Consider trying to repair the DB.
    error = status.ToString();
  } else {
    // TODO(benh): Conditionally compact to avoid long recovery times?
    db->CompactRange(NULL, NULL);
  }
}
Пример #14
0
			Status Put(const std::vector<std::pair<std::string, std::string>>& writes)
			{
				leveldb::WriteBatch batch;

				for (auto kv : writes)
				{
					batch.Put(kv.first, kv.second);
				}

				leveldb::Status s = db->Write(leveldb::WriteOptions(), &batch);

				if (s.ok())
				{
					return Status::OK();
				}

				return Status::NotFound();

			}
Пример #15
0
			Status Put(const std::vector<std::pair<unsigned int, std::string>>& writes)
			{
				leveldb::WriteBatch batch;

				for (auto kv : writes)
				{
					std::string keystr;
					ZUtil::PutVarint64(keystr, kv.first);
					batch.Put(keystr, kv.second);
				}

				leveldb::Status s = db->Write(leveldb::WriteOptions(), &batch);

				if (s.ok())
				{
					return Status::OK();
				}

				return Status::NotFound();

			}
Пример #16
0
Future<std::set<string> > LevelDBStorageProcess::names()
{
  if (error.isSome()) {
    return Failure(error.get());
  }

  std::set<string> results;

  leveldb::Iterator* iterator = db->NewIterator(leveldb::ReadOptions());

  iterator->SeekToFirst();

  while (iterator->Valid()) {
    results.insert(iterator->key().ToString());
    iterator->Next();
  }

  delete iterator;

  return results;
}
Пример #17
0
Try<bool> LevelDBStorageProcess::write(const Entry& entry)
{
  CHECK_NONE(error);

  leveldb::WriteOptions options;
  options.sync = true;

  string value;

  if (!entry.SerializeToString(&value)) {
    return Error("Failed to serialize Entry");
  }

  leveldb::Status status = db->Put(options, entry.name(), value);

  if (!status.ok()) {
    return Error(status.ToString());
  }

  return true;
}
Пример #18
0
inline BOOL ConfDB::GetSystemConf(VSCConfData &pSys)
{
    VSCConfSystemKey sSysKey;

    leveldb::Slice key((char *)&sSysKey, sizeof(sSysKey));


    leveldb::Iterator* it = m_pDb->NewIterator(leveldb::ReadOptions());

    it->Seek(key);
    leveldb::Slice sysValue;

    if (it->Valid())
    {
        sysValue = it->value();
    }

    if (sysValue.size() != sizeof(VSCConfData))
    {
        VDC_DEBUG( "System Config is not init\n");
        delete it;
        memset(&pSys, 0, sizeof(VSCConfData));
        SysConfDataDefault(pSys);
        UpdateSysData(pSys);
        astring strLicense = " ";
        SetLicense(strLicense);//set the default license
        /* Call get system again */
        return TRUE;
    }

    memcpy(&pSys, sysValue.data(), sizeof(VSCConfData));

    // Check for any errors found during the scan
    assert(it->status().ok());
    delete it;

    return TRUE;

}
Пример #19
0
Future<bool> LevelDBStorageProcess::expunge(const Entry& entry)
{
  if (error.isSome()) {
    return Failure(error.get());
  }

  // We do a read first to make sure the version has not changed. This
  // could be optimized in the future, for now it will probably hit
  // the cache anyway.
  Try<Option<Entry> > option = read(entry.name());

  if (option.isError()) {
    return Failure(option.error());
  }

  if (option.get().isNone()) {
    return false;
  }

  if (UUID::fromBytes(option.get().get().uuid()) !=
      UUID::fromBytes(entry.uuid())) {
    return false;
  }

  // Note that the read (i.e., DB::Get) and DB::Delete are inherently
  // "atomic" because only one db can be opened at a time, so there
  // can not be any writes that occur concurrently.

  leveldb::WriteOptions options;
  options.sync = true;

  leveldb::Status status = db->Delete(options, entry.name());

  if (!status.ok()) {
    return Failure(status.ToString());
  }

  return true;
}
Пример #20
0
inline BOOL ConfDB::GetHdfsRecordConf(VSCHdfsRecordData &pData)
{
    VSCConfHdfsRecordKey sKey;

    leveldb::Slice key((char *)&sKey, sizeof(sKey));


    leveldb::Iterator* it = m_pDb->NewIterator(leveldb::ReadOptions());

    it->Seek(key);
    leveldb::Slice sysValue;

    if (it->Valid())
    {
        sysValue = it->value();
    }

    if (sysValue.size() != sizeof(VSCHdfsRecordData))
    {
        VDC_DEBUG( "Hdfs Record Config is not init\n");
        delete it;
		memset(&pData, 0, sizeof(VSCHdfsRecordData));
		VSCHdfsRecordDataItemDefault(pData.data.conf);
		UpdateHdfsRecordData(pData);
        /* Call get system again */
        return TRUE;
    }

	memcpy(&pData, sysValue.data(), sizeof(VSCHdfsRecordData));

    // Check for any errors found during the scan
    assert(it->status().ok());
    delete it;

    return TRUE;

}
Пример #21
0
	      	void Compact()
	      	{
		        db->CompactRange(NULL,NULL);
			}
Пример #22
0
		void dump()
			{
			
			leveldb::Iterator* it=db->NewIterator(this->read_options);
			for (it->SeekToFirst(); it->Valid(); it->Next())
				{
				std::auto_ptr<vector<Hit> > hits = decode(it->value().ToString());
				size_t i0=0;
				
				while(i0 < hits->size())
					{
					size_t i1=i0+1;
					while(i1<hits->size())
						{
						if(hits->at(i0).bamIndex==hits->at(i1).bamIndex) {++i1; continue;}
		
						if(IS_FLAG_SET(hits->at(i0).flag,BAM_FREAD1)!=IS_FLAG_SET(hits->at(i1).flag,BAM_FREAD1))
							{
							++i1;
							continue;
							}
						if(IS_FLAG_SET(hits->at(i0).flag,BAM_FREAD2)!=IS_FLAG_SET(hits->at(i1).flag,BAM_FREAD2))
							{
							++i1;
							continue;
							}
						if(!hits->at(i0).mapped() && !hits->at(i1).mapped())
							{
							break;
							}

						if(hits->at(i0).tid==-1 && hits->at(i1).tid==-1)
							{
							break;
							}
						else if(sameChromosome(
							index2chromNames[hits->at(i0).bamIndex][hits->at(i0).tid].c_str(),
							index2chromNames[hits->at(i1).bamIndex][hits->at(i1).tid].c_str()
							))
							{
							if(hits->at(i0).pos==hits->at(i1).pos)
								{
								break;
								}
							}
						
						++i1;
						}
					if(i1!=	hits->size())
						{
						cout 	<< it->key().ToString()
							<< "\t";
						if(IS_FLAG_SET(hits->at(i0).flag,BAM_FREAD1)) { cout << "1\t"; }
						else if(IS_FLAG_SET(hits->at(i0).flag,BAM_FREAD2)) { cout << "2\t";}
						else cout << "?\t";
						print(hits->at(i0));
						cout << "\t";
						print(hits->at(i1));				
						cout << "\t=";
						cout << endl;
						hits->erase(hits->begin()+i1);//that one before
						hits->erase(hits->begin()+i0);
						}
					else
						{
						++i0;
						}
					}
				
				for(i0=0;i0<hits->size();++i0)
					{
					cout 	<< it->key().ToString()
						<< "\t";
					if(IS_FLAG_SET(hits->at(i0).flag,BAM_FREAD1)) cout << "1\t";
					else if(IS_FLAG_SET(hits->at(i0).flag,BAM_FREAD2)) cout << "2\t";
					else cout << "?\t";
					if(hits->at(i0).bamIndex==1) cout << ".\t";	
					print(hits->at(i0));
					if(hits->at(i0).bamIndex==0) cout << "\t.";		
					cout << endl;
					}

				
				}
			delete it;
			}