func (id *IndexDeps) UploadFile(fileName string, contents string) (fileRef, wholeRef *blobref.BlobRef) {
cb := &test.Blob{Contents: contents}
id.BlobSource.AddBlob(cb)
wholeRef = cb.BlobRef()
_, err := id.Index.ReceiveBlob(wholeRef, cb.Reader())
if err != nil {
panic(err)
}
m := schema.NewFileMap(fileName)
schema.PopulateParts(m, int64(len(contents)), []schema.BytesPart{
schema.BytesPart{
Size: uint64(len(contents)),
BlobRef: wholeRef,
}})
fjson, err := schema.MapToCamliJSON(m)
if err != nil {
panic(err)
}
fb := &test.Blob{Contents: fjson}
log.Printf("Blob is: %s", fjson)
id.BlobSource.AddBlob(fb)
fileRef = fb.BlobRef()
_, err = id.Index.ReceiveBlob(fileRef, fb.Reader())
if err != nil {
panic(err)
}
return
}
func (c *rawCmd) RunCommand(up *Uploader, args []string) error {
if len(args) > 0 {
return errors.New("Raw Object command doesn't take any additional arguments")
}
m := make(map[string]interface{})
if c.vals == "" {
return errors.New("No values")
}
for _, kv := range strings.Split(c.vals, "|") {
kv := strings.SplitN(kv, "=", 2)
m[kv[0]] = kv[1]
}
if _, ok := m["camliVersion"]; !ok {
m["camliVersion"] = "1"
}
if c.signed {
put, err := up.UploadAndSignMap(m)
handleResult("raw-object-signed", put, err)
return err
}
cj, err := schema.MapToCamliJSON(m)
if err != nil {
return err
}
put, err := up.uploadString(cj)
handleResult("raw-object-unsigned", put, err)
return err
}
func (up *Uploader) UploadMap(m map[string]interface{}) (*client.PutResult, error) {
json, err := schema.MapToCamliJSON(m)
if err != nil {
return nil, err
}
return up.uploadString(json)
}
func (h *JSONSignHandler) SignMap(m map[string]interface{}) (string, error) {
m["camliSigner"] = h.pubKeyBlobRef.String()
unsigned, err := schema.MapToCamliJSON(m)
if err != nil {
return "", err
}
sreq := &jsonsign.SignRequest{
UnsignedJson: unsigned,
Fetcher: h.pubKeyFetcher,
ServerMode: true,
SecretKeyringPath: h.secretRing,
}
return sreq.Sign()
}
func (up *Uploader) SignMap(m map[string]interface{}) (string, error) {
camliSigBlobref := up.Client.SignerPublicKeyBlobref()
if camliSigBlobref == nil {
// TODO: more helpful error message
return "", errors.New("No public key configured.")
}
m["camliSigner"] = camliSigBlobref.String()
unsigned, err := schema.MapToCamliJSON(m)
if err != nil {
return "", err
}
sr := &jsonsign.SignRequest{
UnsignedJson: unsigned,
Fetcher: up.Client.GetBlobFetcher(),
EntityFetcher: up.entityFetcher,
}
return sr.Sign()
}
func (id *IndexDeps) uploadAndSignMap(m map[string]interface{}) *blobref.BlobRef {
m["camliSigner"] = id.SignerBlobRef
unsigned, err := schema.MapToCamliJSON(m)
if err != nil {
panic("uploadAndSignMap: " + err.Error())
}
sr := &jsonsign.SignRequest{
UnsignedJson: unsigned,
Fetcher: id.PublicKeyFetcher,
EntityFetcher: id.EntityFetcher,
}
signed, err := sr.Sign()
if err != nil {
panic("problem signing: " + err.Error())
}
tb := &test.Blob{Contents: signed}
_, err = id.Index.ReceiveBlob(tb.BlobRef(), tb.Reader())
if err != nil {
panic(fmt.Sprintf("problem indexing blob: %v\nblob was:\n%s", err, signed))
}
return tb.BlobRef()
}
func (up *Uploader) uploadNode(n *node) (*client.PutResult, error) {
fi := n.fi
m := schema.NewCommonFileMap(n.fullPath, fi)
mode := fi.Mode()
switch {
case mode&os.ModeSymlink != 0:
// TODO(bradfitz): use VFS here; PopulateSymlinkMap uses os.Readlink directly.
if err := schema.PopulateSymlinkMap(m, n.fullPath); err != nil {
return nil, err
}
case mode&os.ModeDevice != 0:
// including mode & os.ModeCharDevice
fallthrough
case mode&os.ModeSocket != 0:
fallthrough
case mode&os.ModeNamedPipe != 0: // FIFO
fallthrough
default:
return nil, schema.ErrUnimplemented
case mode&os.ModeType == 0: // regular file
m["camliType"] = "file"
file, err := up.open(n.fullPath)
if err != nil {
return nil, err
}
defer file.Close()
statReceiver := up.altStatReceiver
if statReceiver == nil {
// TODO(bradfitz): just make Client be a
// StatReceiver? move remote's ReceiveBlob ->
// Upload wrapper into Client itself?
statReceiver = remote.NewFromClient(up.Client)
}
schemaWriteFileMap := schema.WriteFileMap
if up.rollSplits {
schemaWriteFileMap = schema.WriteFileMapRolling
}
blobref, err := schemaWriteFileMap(statReceiver, m, io.LimitReader(file, fi.Size()))
if err != nil {
return nil, err
}
// TODO(bradfitz): taking a PutResult here is kinda
// gross. should instead make a blobserver.Storage
// wrapper type that can track some of this? or that
// updates the client stats directly or something.
{
json, _ := schema.MapToCamliJSON(m)
pr := &client.PutResult{BlobRef: blobref, Size: int64(len(json)), Skipped: false}
return pr, nil
}
case fi.IsDir():
ss := new(schema.StaticSet)
for _, c := range n.children {
pr, err := c.PutResult()
if err != nil {
return nil, fmt.Errorf("Error populating directory static set for child %q: %v", c.fullPath, err)
}
ss.Add(pr.BlobRef)
}
sspr, err := up.UploadMap(ss.Map())
if err != nil {
return nil, err
}
schema.PopulateDirectoryMap(m, sspr.BlobRef)
}
mappr, err := up.UploadMap(m)
if err == nil {
if !mappr.Skipped {
vlog.Printf("Uploaded %q, %s for %s", m["camliType"], mappr.BlobRef, n.fullPath)
}
} else {
vlog.Printf("Error uploading map %v: %v", m, err)
}
return mappr, err
}
