func (l *Loader) objectHandler(i *loader.TreeWalkItem) error {
contents, err := i.ReadString()
if err != nil {
return err
}
data, err := l.executeTemplate(i.RelativePath, contents, nil)
if err != nil {
return err
}
objects, err := l.loadYamlObjects(i.RelativePath, data)
if err != nil {
return err
}
for k, v := range objects {
_, found := l.tasks[k]
if found {
return fmt.Errorf("found duplicate object: %q", k)
}
l.tasks[k] = v.(fi.Task)
}
return nil
}
func (l *Loader) resourceHandler(i *loader.TreeWalkItem) error {
contents, err := i.ReadBytes()
if err != nil {
return err
}
var a fi.Resource
key := i.RelativePath
if strings.HasSuffix(key, ".template") {
key = strings.TrimSuffix(key, ".template")
glog.V(2).Infof("loading (templated) resource %q", key)
a = &templateResource{
template: string(contents),
loader: l,
key: key,
}
} else {
glog.V(2).Infof("loading resource %q", key)
a = fi.NewBytesResource(contents)
}
l.Resources[key] = a
return nil
}
func (r *Loader) handleFile(i *loader.TreeWalkItem) error {
var task *nodetasks.File
defaultFileType := nodetasks.FileType_File
var err error
if strings.HasSuffix(i.RelativePath, ".template") {
contents, err := i.ReadString()
if err != nil {
return err
}
// TODO: Use template resource here to defer execution?
destPath := "/" + strings.TrimSuffix(i.RelativePath, ".template")
name := strings.TrimSuffix(i.Name, ".template")
expanded, err := r.executeTemplate(name, contents)
if err != nil {
return fmt.Errorf("error executing template %q: %v", i.RelativePath, err)
}
task, err = nodetasks.NewFileTask(name, fi.NewStringResource(expanded), destPath, i.Meta)
} else if strings.HasSuffix(i.RelativePath, ".asset") {
contents, err := i.ReadBytes()
if err != nil {
return err
}
destPath := "/" + strings.TrimSuffix(i.RelativePath, ".asset")
name := strings.TrimSuffix(i.Name, ".asset")
def := &nodetasks.AssetDefinition{}
err = json.Unmarshal(contents, def)
if err != nil {
return fmt.Errorf("error parsing json for asset %q: %v", name, err)
}
asset, err := r.assets.Find(name, def.AssetPath)
if err != nil {
return fmt.Errorf("error trying to locate asset %q: %v", name, err)
}
if asset == nil {
return fmt.Errorf("unable to locate asset %q", name)
}
task, err = nodetasks.NewFileTask(i.Name, asset, destPath, i.Meta)
} else {
stat, err := os.Stat(i.Path)
if err != nil {
return fmt.Errorf("error doing stat on %q: %v", i.Path, err)
}
var contents fi.Resource
if stat.IsDir() {
defaultFileType = nodetasks.FileType_Directory
} else {
contents = fi.NewFileResource(i.Path)
}
task, err = nodetasks.NewFileTask(i.Name, contents, "/"+i.RelativePath, i.Meta)
}
if task.Type == "" {
task.Type = defaultFileType
}
if err != nil {
return fmt.Errorf("error building task %q: %v", i.RelativePath, err)
}
glog.V(2).Infof("path %q -> task %v", i.Path, task)
if task != nil {
key := "file/" + i.RelativePath
r.tasks[key] = task
}
return nil
}
