TEST(DataTypeStringData, Basic) {
char buf[100];
StringData a("a");
StringData b("bb");
StringData c("ccc");
{
DataRangeCursor drc(buf, buf + sizeof(buf));
ASSERT_OK(drc.writeAndAdvance(Terminated<'\0', StringData>(a)));
ASSERT_OK(drc.writeAndAdvance(Terminated<'\0', StringData>(b)));
ASSERT_OK(drc.writeAndAdvance(Terminated<'\0', StringData>(c)));
ASSERT_EQUALS(1 + 2 + 3 + 3, drc.data() - buf);
}
{
ConstDataRangeCursor cdrc(buf, buf + sizeof(buf));
Terminated<'\0', StringData> tsd;
ASSERT_OK(cdrc.readAndAdvance(&tsd));
ASSERT_EQUALS(a, tsd.value);
ASSERT_OK(cdrc.readAndAdvance(&tsd));
ASSERT_EQUALS(b, tsd.value);
ASSERT_OK(cdrc.readAndAdvance(&tsd));
ASSERT_EQUALS(c, tsd.value);
}
}
void service::recreate(bool updating)
{
if (updating)
utils_docker::pullImage(mParams, mSettings, getImageName());
try
{
// nuke any existing dService files on host (but preserve volume containers!).
if (utils::fileexists(getPath()))
utils::deltree(getPath(), mParams);
// notice for hostVolumes.
if (utils::fileexists(getPathHostVolume()))
logmsg(kLINFO, "A drunner hostVolume already exists for " + getName() + ", reusing it.");
// create the basic directories.
ensureDirectoriesExist();
// copy files to service directory on host.
std::string op;
int r = utils::bashcommand("docker run --rm -i -v " +
getPathdRunner() + ":/tempcopy " + getImageName() + " /bin/bash -c \"cp -r /drunner/* /tempcopy/ && chmod a+rx /tempcopy/*\"", op);
if (r != 0)
logmsg(kLERROR, "Couldn't copy the service files. You will need to reinstall the service.");
// write out variables.sh for the dService.
drunnerCompose drc(*this, mParams);
if (drc.readOkay()==kRError)
fatal("Unexpected error - docker-compose.yml is broken.");
// write out servicevars.sh for ourselves.
sh_servicevars svcvars(getPath());
svcvars.create(getImageName());
if (!svcvars.write())
fatal("Unexpected error - couldn't write out servicevars.sh.");
// make sure we have the latest of all exra containers.
for (const auto & entry : drc.getServicesInfo())
if (entry.mImageName != getImageName()) // don't pull main image again.
utils_docker::pullImage(mParams, mSettings, entry.mImageName);
// create the utils.sh file for the dService.
generate_utils_sh(getPathdRunner(), mParams);
// create launch script
createLaunchScript();
// create volumes
createVolumes(&drc);
}
catch (const eExit & e) {
// tidy up.
if (utils::fileexists(getPath()))
utils::deltree(getPath(), mParams);
throw (e);
}
}
TEST(DataRangeCursor, DataRangeCursorType) {
char buf[] = "foo";
char buf2[] = "barZ";
DataRangeCursor drc(buf, buf + sizeof(buf) + -1);
DataRangeCursor out(nullptr, nullptr);
ASSERT_OK(drc.readIntoNoThrow(&out));
ASSERT_EQUALS(buf, out.data());
drc = DataRangeCursor(buf2, buf2 + sizeof(buf2) + -1);
ASSERT_OK(drc.writeNoThrow(out));
ASSERT_EQUALS(std::string("fooZ"), buf2);
}
eResult service::obliterate()
{
if (!utils::fileexists(getPath()))
logmsg(kLERROR, "Can't obliterate " + getName() + " - it does not exist.");
servicehook hook(this, "obliterate", mParams);
hook.starthook();
logmsg(kLDEBUG, "Obliterating all the docker volumes - data will be gone forever.");
{// [start] deleting docker volumes.
drunnerCompose drc(*this, mParams);
if (drc.readOkay()!=kRError)
{
tVecStr docvolnames;
drc.getDockerVolumeNames(docvolnames);
for (const auto & vol : docvolnames)
{
logmsg(kLINFO, "Obliterating docker volume " + vol);
std::string op;
if (0 != utils::bashcommand("docker volume rm " + vol, op))
logmsg(kLWARN, "Failed to remove " + vol + " -- " + op);
}
}
else
logmsg(kLDEBUG, "Couldn't read configuration to delete the associated docker volumes. :/");
}// [end] deleting docker volumes.
// delete the host volumes
logmsg(kLINFO, "Obliterating the hostVolumes (environment and servicerunner)");
utils::deltree(getPathHostVolume(), mParams);
// delete the service tree.
logmsg(kLINFO, "Obliterating all of the dService files");
utils::deltree(getPath(), mParams);
logmsg(kLINFO, "Obliterated " + getName());
return kRSuccess;
}
bool IrisBitmap::StretchBlt(const IrisRect *destIrisRect, const IrisBitmap *srcIrisBitmap, const IrisRect *srcIrisRect, int opacity){
this->needRefreshTexture = true;
Rect rc(srcIrisRect->x, srcIrisRect->y, srcIrisRect->width, srcIrisRect->height);
Rect drc(destIrisRect->x, destIrisRect->y, destIrisRect->width, destIrisRect->height);
return IrisBitmapStretchBlt(&drc, this->bitmap, &rc, srcIrisBitmap->bitmap, opacity);
}
bool IrisBitmap::StretchBlt(const IIrisRect *destIrisRect, const IIrisBitmap *srcIrisBitmap, const IIrisRect *srcIrisRect, int opacity){
this->needRefreshTexture = true;
Rect rc(((IrisRect*)srcIrisRect)->x, ((IrisRect*)srcIrisRect)->y, ((IrisRect*)srcIrisRect)->width, ((IrisRect*)srcIrisRect)->height);
Rect drc(((IrisRect*)destIrisRect)->x, ((IrisRect*)destIrisRect)->y, ((IrisRect*)destIrisRect)->width, ((IrisRect*)destIrisRect)->height);
return IrisBitmapStretchBlt(&drc, this->bitmap, &rc, ((IrisBitmap*)srcIrisBitmap)->bitmap, opacity);
}
void WinEDA_PcbFrame::Place_Dupl_Route(Track * Track, wxDC * DC)
/******************************************/
/*
Routine de placement d'une piste (succession de segments)
*/
{
D_PAD * pt_pad;
TRACK * pt_track, *Track, * pt_classe, *NextS;
int masquelayer;
EDA_BaseStruct * LockPoint;
int ii, old_net_code, new_net_code, DRC_error = 0;
wxDC * DC = Cmd->DC;
ActiveScreen->ManageCurseur = NULL;
if( NewTrack == NULL ) return ;
old_net_code = NewTrack->net_code;
/* Placement du flag BUSY de la piste originelle, qui ne doit
pas etre vue dans les recherches de raccordement suivantes */
ii = NbPtNewTrack; pt_track = NewTrack;
for ( ; ii > 0; ii --, pt_track = (TRACK*) pt_track->Pnext)
{
pt_track->SetState(BUSY, ON);
}
/* Detection du nouveau net_code */
ii = NbPtNewTrack; pt_track = NewTrack;
for ( ; ii > 0; ii --, pt_track = (TRACK*) pt_track->Pnext)
{
pt_track->net_code = 0;
}
new_net_code = 0;
ii = 0; pt_track = NewTrack;
for( ; ii < NbPtNewTrack ; ii++, pt_track = (TRACK*)pt_track->Pnext)
{
/* Localisation de la pastille ou segment en debut de segment: */
masquelayer = tab_layer[pt_track->Layer];
LockPoint = LocateLockPoint(pt_track->m_Start.x,pt_track->m_Start.y,masquelayer);
if( LockPoint )
{
if ( LockPoint->m_StructType == TYPEPAD )
{
pt_pad = (D_PAD*) LockPoint;
new_net_code = pt_pad->net_code;
if ( new_net_code > 0 ) break;
}
else /* debut de piste sur un segment de piste */
{
Track = (TRACK *) LockPoint;
new_net_code = Track->net_code;
if ( new_net_code > 0 ) break;
}
}
LockPoint = LocateLockPoint(pt_track->m_End.x,pt_track->m_End.y,masquelayer);
if( LockPoint )
{
if ( LockPoint->m_StructType == TYPEPAD )
{
pt_pad = (D_PAD*) LockPoint;
new_net_code = pt_pad->net_code;
if ( new_net_code > 0 ) break;
}
else /* debut de piste sur un segment de piste */
{
Track = (TRACK *) LockPoint;
new_net_code = Track->net_code;
if ( new_net_code > 0 ) break;
}
}
}
/* Mise a jour du nouveau net code de la piste */
ii = 0; pt_track = NewTrack;
for( ; ii < NbPtNewTrack; ii++, pt_track = (TRACK*)pt_track->Pnext)
{
pt_track->net_code = new_net_code;
}
/* Controle DRC de la nouvelle piste */
ii = 0; pt_track = NewTrack;
for( ; ii < NbPtNewTrack; ii++, pt_track = pt_track->Next() )
{
if( Drc_On == RUN )
if( drc(DC, pt_track, pt_pcb->Track, 1) == BAD_DRC )
{
if( confirmation(" Erreur DRC, Place piste:") == YES ) continue;
else { DRC_error = 1; break; }
}
}
if( DRC_error == 0)
{
if(FlagState == MOVE_ROUTE)
{
/* copie nouvelle piste */
pt_track = NewTrack;
NewTrack = pt_track->Copy(NbPtNewTrack);
/* effacement ancienne ( chainage et liens mauvais */
ii = NbPtNewTrack;
for ( ; ii > 0; ii --, pt_track = NextS)
{
NextS = (TRACK*) pt_track->Pnext;
DeleteStructure(pt_track);
}
test_1_net_connexion(DC, old_net_code );
}
pt_classe = NewTrack->GetBestInsertPoint();
NewTrack->Insert(pt_classe);
Trace_Une_Piste(DC, NewTrack,NbPtNewTrack,GR_OR) ;
/* Mise a jour des connexions sur pads et sur pistes */
ii = 0; pt_track = NewTrack;
for( ; ii < NbPtNewTrack; ii++, pt_track = NextS)
{
NextS = (TRACK*)pt_track->Pnext;
pt_track->SetState(BEGIN_ONPAD|END_ONPAD, OFF);
masquelayer = tab_layer[pt_track->Layer];
/* Localisation de la pastille ou segment sur debut segment: */
LockPoint = LocateLockPoint(pt_track->m_Start.x,pt_track->m_Start.y,masquelayer);
if( LockPoint )
{
pt_track->start = LockPoint;
if ( LockPoint->m_StructType == TYPEPAD )
{ /* fin de piste sur un pad */
pt_pad = (D_PAD*) LockPoint;
pt_track->SetState(BEGIN_ONPAD, ON);
}
else /* debut de piste sur un segment de piste */
{
Track = (TRACK *) LockPoint;
CreateLockPoint(&pt_track->m_Start.x,&pt_track->m_Start.y,Track,pt_track);
}
}
/* Localisation de la pastille ou segment sur fin de segment: */
LockPoint = LocateLockPoint(pt_track->m_End.x,pt_track->m_End.y,masquelayer);
if( LockPoint )
{
pt_track->end = LockPoint;
if ( LockPoint->m_StructType == TYPEPAD )
{ /* fin de piste sur un pad */
pt_pad = (D_PAD*) LockPoint;
pt_track->SetState(END_ONPAD, ON);
}
else /* debut de piste sur un segment de piste */
{
Track = (TRACK *) LockPoint;
CreateLockPoint(&pt_track->m_Start.x,&pt_track->m_Start.y,Track,pt_track);
}
}
}
/* Suppression du flag BUSY */
ii = NbPtNewTrack; pt_track = NewTrack;
for ( ; ii > 0; ii --, pt_track = (TRACK*) pt_track->Pnext)
{
pt_track->SetState(BUSY, OFF);
}
test_1_net_connexion(DC, new_net_code );
ActiveScreen->SetModify();
}
else /* Erreur DRC: Annulation commande */
{
DisplayOpt.DisplayPcbTrackFill = SKETCH ;
Trace_Une_Piste(DC, NewTrack,NbPtNewTrack,GR_XOR);
DisplayOpt.DisplayPcbTrackFill = Track_fill_copy ;
if(FlagState == MOVE_ROUTE)
{ /* Remise en position de la piste deplacee */
Track = NewTrack;
PosInitX -= Track->m_Start.x; PosInitY -= Track->m_Start.y;
for( ii = 0; ii < NbPtNewTrack; ii++, Track = (TRACK*) Track->Pnext)
{
if( Track == NULL ) break;
Track->m_Start.x += PosInitX; Track->m_Start.y += PosInitY;
Track->m_End.x += PosInitX; Track->m_End.y += PosInitY;
Track->SetState(BUSY,OFF);
}
Trace_Une_Piste(DC, NewTrack,NbPtNewTrack,GR_OR);
}
if (FlagState == COPY_ROUTE )
{ /* Suppression copie */
for( ii = 0; ii < NbPtNewTrack; NewTrack = NextS)
{
if(NewTrack == NULL) break;
NextS = (TRACK*) NewTrack->Pnext;
delete NewTrack;
}
}
}
NewTrack = NULL;
Affiche_Infos_Status_Pcb(Cmd);
if(Etat_Surbrillance) Hight_Light(DC);
}
