text: package schema
  
  import (
  	gsunit "github.com/coreos/go-systemd/unit"
  
  	"github.com/coreos/fleet/job"
  	"github.com/coreos/fleet/machine"
  	"github.com/coreos/fleet/unit"
  )
  
  func MapUnitFileToSchemaUnitOptions(uf *unit.UnitFile) []*UnitOption {
  	sopts := make([]*UnitOption, len(uf.Options))
  	for i, opt := range uf.Options {
  		sopts[i] = &UnitOption{
  			Section: opt.Section,
  			Name:    opt.Name,
  			Value:   opt.Value,
  		}
  	}
  	return sopts
  }
  
  func MapSchemaUnitOptionsToUnitFile(sopts []*UnitOption) *unit.UnitFile {
  	opts := make([]*gsunit.UnitOption, len(sopts))
  	for i, sopt := range sopts {
  		opts[i] = &gsunit.UnitOption{
  			Section: sopt.Section,
  			Name:    sopt.Name,
  			Value:   sopt.Value,
  		}
  	}
  
  	return unit.NewUnitFromOptions(opts)
  }
  
  func MapSchemaUnitToUnit(entity *Unit) *job.Unit {
  	uf := MapSchemaUnitOptionsToUnitFile(entity.Options)
  	j := job.Unit{
  		Name: entity.Name,
  		Unit: *uf,
  	}
  	return &j
  }
  
  func MapUnitToSchemaUnit(u *job.Unit, su *job.ScheduledUnit) *Unit {
  	s := Unit{
  		Name:         u.Name,
  		Options:      MapUnitFileToSchemaUnitOptions(&(u.Unit)),
  		DesiredState: string(u.TargetState),
  	}
  
  	if su != nil {
  		s.MachineID = su.TargetMachineID
  		if su.State != nil {
  			s.CurrentState = string(*su.State)
  		}
  	}
  
  	return &s
  }
  
  func MapSchemaUnitsToUnits(entities []*Unit) []job.Unit {
  	units := make([]job.Unit, len(entities))
  	for i, _ := range entities {
  		entity := entities[i]
  		units[i] = *(MapSchemaUnitToUnit(entity))
  	}
  
  	return units
  }
  
  func MapMachineStateToSchema(ms *machine.MachineState) *Machine {
  	sm := Machine{
  		Id:        ms.ID,
  		PrimaryIP: ms.PublicIP,
  	}
  
  	sm.Metadata = make(map[string]string, len(ms.Metadata))
  	for k, v := range ms.Metadata {
  		sm.Metadata[k] = v
  	}
  
  	return &sm
  }
  
  func MapSchemaToMachineStates(entities []*Machine) []machine.MachineState {
  	machines := make([]machine.MachineState, len(entities))
  	for i, _ := range entities {
  		me := entities[i]
  
  		ms := machine.MachineState{
  			ID:       me.Id,
  			PublicIP: me.PrimaryIP,
  		}
  
  		ms.Metadata = make(map[string]string, len(me.Metadata))
  		for k, v := range me.Metadata {
  			ms.Metadata[k] = v
  		}
  
  		machines[i] = ms
  	}
  
  	return machines
  }
  
  func MapUnitStatesToSchemaUnitStates(entities []*unit.UnitState) []*UnitState {
  	sus := make([]*UnitState, len(entities))
  	for i, e := range entities {
  		sus[i] = MapUnitStateToSchemaUnitState(e)
  	}
  
  	return sus
  }
  
  func MapUnitStateToSchemaUnitState(entity *unit.UnitState) *UnitState {
  	us := UnitState{
  		Name:               entity.UnitName,
  		Hash:               entity.UnitHash,
  		MachineID:          entity.MachineID,
  		SystemdLoadState:   entity.LoadState,
  		SystemdActiveState: entity.ActiveState,
  		SystemdSubState:    entity.SubState,
  	}
  
  	return &us
  }
  
  func MapSchemaUnitStatesToUnitStates(entities []*UnitState) []*unit.UnitState {
  	us := make([]*unit.UnitState, len(entities))
  	for i, e := range entities {
  		us[i] = &unit.UnitState{
  			UnitName:    e.Name,
  			UnitHash:    e.Hash,
  			MachineID:   e.MachineID,
  			LoadState:   e.SystemdLoadState,
  			ActiveState: e.SystemdActiveState,
  			SubState:    e.SystemdSubState,
  		}
  	}
  
  	return us
  }
  
  func MapSchemaUnitToScheduledUnit(entity *Unit) *job.ScheduledUnit {
  	cs := job.JobState(entity.CurrentState)
  	return &job.ScheduledUnit{
  		Name:            entity.Name,
  		State:           &cs,
  		TargetMachineID: entity.MachineID,
  	}
  }
  
  func MapSchemaUnitsToScheduledUnits(entities []*Unit) []job.ScheduledUnit {
  	su := make([]job.ScheduledUnit, len(entities))
  	for i, e := range entities {
  		su[i] = *MapSchemaUnitToScheduledUnit(e)
  	}
  
  	return su
  }
  