argv.ipfs.object.get(argv.key, { enc: 'base58' }, (err, node) => {
if (err) {
throw err
}
dagPB.util.cid(node, (err, result) => {
if (err) {
throw err
}
let data = node.data
if (Buffer.isBuffer(data)) {
data = node.data.toString(argv.dataEncoding || undefined)
}
const answer = {
Data: data,
Hash: result.toBaseEncodedString(argv.cidBase),
Size: node.size,
Links: node.links.map((l) => {
return {
Name: l.name,
Size: l.size,
Hash: l.cid.toBaseEncodedString(argv.cidBase)
}
})
}
print(JSON.stringify(answer))
})
})
(cb) => {
dagPB.util.serialize(node, (err, _serialized) => {
expect(err).to.not.exist()
serialized = _serialized
cb()
})
},
}, (err, node) => {
expect(err).to.not.exist()
node1b = node
dagPB.util.cid(node, (err, cid) => {
expect(err).to.not.exist()
node1bCid = cid
cb()
})
})
}, (err, result) => {
if (err) {
return callback(err)
}
if (Buffer.isBuffer(obj)) {
if (!options.enc) {
obj = { Data: obj, Links: [] }
} else if (options.enc === 'json') {
obj = JSON.parse(obj.toString())
}
}
let node
if (obj.multihash) {
node = obj
} else if (options.enc === 'protobuf') {
dagPB.util.deserialize(obj, (err, _node) => {
if (err) {
return callback(err)
}
node = _node
next()
})
return
} else {
DAGNode.create(Buffer.from(obj.Data), obj.Links, (err, _node) => {
if (err) {
return callback(err)
}
node = _node
next()
})
return
}
next()
function next () {
const nodeJSON = node.toJSON()
if (nodeJSON.multihash !== result.Hash) {
const err = new Error('multihashes do not match')
return callback(err)
}
cache.set(result.Hash, node)
callback(null, node)
}
})
(cb) => {
dagPB.util.cid(node2, (err, cid) => {
expect(err).to.not.exist()
dagPB.DAGNode.addLink(node3, {
name: '2',
size: node2.size,
cid
}, (err, node) => {
expect(err).to.not.exist()
node3 = node
cb()
})
})
}
map(nodes, (node, cb) => util.cid(util.serialize(node), {
cidVersion: 0
}).then(cid => cb(null, cid), cb), (err, cids) => {
}).unknown()
},
// uses common parseKey method that returns a `key`
parseArgs: exports.parseKey,
// main route handler which is called after the above `parseArgs`, but only if the args were valid
async handler (request, h) {
const { key } = request.pre.args
const enc = request.query.enc || 'base58'
const { ipfs } = request.server.app
let node, cid
try {
node = await ipfs.object.get(key, { enc: enc })
cid = await dagPB.util.cid(dagPB.util.serialize(node))
} catch (err) {
throw Boom.boomify(err, { message: 'Failed to get object' })
}
const nodeJSON = node.toJSON()
if (Buffer.isBuffer(node.data)) {
nodeJSON.data = node.data.toString(request.query['data-encoding'] || undefined)
}
const answer = {
Data: nodeJSON.data,
Hash: cidToString(cid, { base: request.query['cid-base'], upgrade: false }),
Size: nodeJSON.size,
Links: nodeJSON.links.map((l) => {