void PathPlanner::updateSpeed(float v_current) {
  v_current_ = v_current;
}

void PathPlanner::updateStatePointer(const tBehaviour& behaviour_current,
                                     const tPose& pose_global) {
  pose_curr_ = &pose_global;
  behaviour_curr_ = &behaviour_current;
}

void PathPlanner::updateLaneVecPointer(std::vector<Lane>* lane_vert_vec_ptr) {
  lane_vert_vec_ptr_ = lane_vert_vec_ptr;
}
Best Practice: Backup and regular tape retrieval o...
The backup scenario is multiple work disks to dedupe disk, then to tape.
The problem is that there is not enough disk space (work or dedupe) for all the large static (video) files.
Therefore I need a solution to delete files from disk (to make space) while remembering their tape counterparts for future restoring.
The solution requires that restored files (from tape set) do not get re-backed up (duplicated) to same tape set.
Could you perhaps reorg your data so that backups of multimedia files go directly to tape, and all else to the dedupe folder?
Or perhaps it's an archive backup job that you want to have done?
Media files are special?
Thanks and that's fine but let me rephrase my issue slightly.
Irregardless of source directory, is there a backup option to not backup files again that have the same name, date and size?
I currently use Retrospect (a bit flaky) which has the option.
Yes. You can use incremental backups which will backup only those files that were changed since the last full or incremental backup.
Irregardless of source directory?
Irregardless if already on tape (anywhere)?
Normally before doing an incremental backup, one would do a full backup of the source data and then use the SAME selection list to do further incremental backups of the same source data.
The Admin Guide has a section which deals with incremental backups and its implications with respect to restoring the data later. I would strongly suggest that you familiarise yourself with this before doing any incremental backups.package main_test

import (
	"strings"
	"testing"
	"time"

	. "github.com/almighty/almighty-core"
	"github.com/almighty/almighty-core/app"
	"github.com/almighty/almighty-core/app/test"
	"github.com/almighty/almighty-core/application"
	"github.com/almighty/almighty-core/gormapplication"
	"github.com/almighty/almighty-core/gormsupport"
	"github.com/almighty/almighty-core/gormsupport/cleaner"
	"github.com/almighty/almighty-core/iteration"
	"github.com/almighty/almighty-core/resource"
	"github.com/almighty/almighty-core/space"
	testsupport "github.com/almighty/almighty-core/test"
	almtoken "github.com/almighty/almighty-core/token"
	"github.com/goadesign/goa"
	uuid "github.com/satori/go.uuid"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"github.com/stretchr/testify/suite"
	"golang.org/x/net/context"
)

type TestIterationREST struct {
	gormsupport.DBTestSuite

	db    *gormapplication.GormDB
	clean func()
}

func TestRunIterationREST(t *testing.T) {
	suite.Run(t, &TestIterationREST{DBTestSuite: gormsupport.NewDBTestSuite("config.yaml")})
}

func (rest *TestIterationREST) SetupTest() {
	rest.db = gormapplication.NewGormDB(rest.DB)
	rest.clean = cleaner.DeleteCreatedEntities(rest.DB)
}

func (rest *TestIterationREST) TearDownTest() {
	rest.clean()
}

func (rest *TestIterationREST) SecuredController() (*goa.Service, *IterationController) {
	priv, _ := almtoken.ParsePrivateKey([]byte(almtoken.RSAPrivateKey))

	svc := testsupport.ServiceAsUser("Iteration-Service", almtoken.NewManagerWithPrivateKey(priv), testsupport.TestIdentity)
	return svc, NewIterationController(svc, rest.db)
}

func (rest *TestIterationREST) UnSecuredController() (*goa.Service, *IterationController) {
	svc := goa.New("Iteration-Service")
	return svc, NewIterationController(svc, rest.db)
}

func (rest *TestIterationREST) TestSuccessCreateChildIteration() {
	t := rest.T()
	resource.Require(t, resource.Database)

	parentID := createSpaceAndIteration(t, rest.db).ID
	name := "Sprint #21"
	ci := createChildIteration(&name)

	svc, ctrl := rest.SecuredController()
	_, created := test.CreateChildIterationCreated(t, svc.Context, svc, ctrl, parentID.String(), ci)
	assertChildIterationLinking(t, created.Data)
	assert.Equal(t, *ci.Data.Attributes.Name, *created.Data.Attributes.Name)
}

func (rest *TestIterationREST) TestFailCreateChildIterationMissingName() {
	t := rest.T()
	resource.Require(t, resource.Database)

	parentID := createSpaceAndIteration(t, rest.db).ID
	ci := createChildIteration(nil)

	svc, ctrl := rest.SecuredController()
	test.CreateChildIterationBadRequest(t, svc.Context, svc, ctrl, parentID.String(), ci)
}

func (rest *TestIterationREST) TestFailCreateChildIterationMissingParent() {
	t := rest.T()
	resource.Require(t, resource.Database)

	name := "Sprint #21"
	ci := createChildIteration(&name)

	svc, ctrl := rest.SecuredController()
	test.CreateChildIterationNotFound(t, svc.Context, svc, ctrl, uuid.NewV4().String(), ci)
}

func (rest *TestIterationREST) TestFailCreateChildIterationNotAuthorized() {
	t := rest.T()
	resource.Require(t, resource.Database)

	parentID := createSpaceAndIteration(t, rest.db).ID
	name := "Sprint #21"
	ci := createChildIteration(&name)

	svc, ctrl := rest.UnSecuredController()
	test.CreateChildIterationUnauthorized(t, svc.Context, svc, ctrl, parentID.String(), ci)
}

func (rest *TestIterationREST) TestSuccessShowIteration() {
	t := rest.T()
	resource.Require(t, resource.Database)

	itrID := createSpaceAndIteration(t, rest.db)

	svc, ctrl := rest.SecuredController()
	_, created := test.ShowIterationOK(t, svc.Context, svc, ctrl, itrID.ID.String())
	assertIterationLinking(t, created.Data)
}

func (rest *TestIterationREST) TestFailShowIterationMissing() {
	t := rest.T()
	resource.Require(t, resource.Database)

	svc, ctrl := rest.SecuredController()
	test.ShowIterationNotFound(t, svc.Context, svc, ctrl, uuid.NewV4().String())
}

func (rest *TestIterationREST) TestSuccessUpdateIteration() {
	t := rest.T()
	resource.Require(t, resource.Database)

	itr := createSpaceAndIteration(t, rest.db)

	newName := "Sprint 1001"
	newDesc := "New Description"
	payload := app.UpdateIterationPayload{
		Data: &app.Iteration{
			Attributes: &app.IterationAttributes{
				Name:        &newName,
				Description: &newDesc,
			},
			ID:   &itr.ID,
			Type: iteration.APIStringTypeIteration,
		},
	}
	svc, ctrl := rest.SecuredController()
