public async Task UpgradeAsync(IpfsEngine ipfs, CancellationToken cancel = default(CancellationToken))
{
var path = Path.Combine(ipfs.Options.Repository.Folder, "pins");
var folder = new DirectoryInfo(path);
if (!folder.Exists)
{
return;
}
var store = new FileStore <Cid, Pin1>
{
Folder = path,
NameToKey = (cid) => cid.Hash.ToBase32(),
KeyToName = (key) => new MultiHash(key.FromBase32())
};
var files = folder.EnumerateFiles()
.Where(fi => fi.Length == 0);
foreach (var fi in files)
{
try
{
var cid = Cid.Decode(fi.Name);
await store.PutAsync(cid, new Pin1 { Id = cid }, cancel).ConfigureAwait(false);
File.Delete(fi.FullName);
}
catch
{
}
}
}
public async Task <JToken> GetAsync(
string path,
CancellationToken cancel = default(CancellationToken))
{
if (path.StartsWith("/ipfs/"))
{
path = path.Remove(0, 6);
}
var parts = path.Split('/').Where(p => p.Length > 0).ToArray();
if (parts.Length == 0)
{
throw new ArgumentException($"Cannot resolve '{path}'.");
}
JToken token = await GetAsync(Cid.Decode(parts[0]), cancel).ConfigureAwait(false);
foreach (var child in parts.Skip(1))
{
token = ((JObject)token)[child];
if (token == null)
{
throw new Exception($"Missing component '{child}'.");
}
}
return(token);
}
public async Task <Stream> ReadFileAsync(string path, CancellationToken cancel = default)
{
var r = await _nameApi.ResolveAsync(path, true, false, cancel).ConfigureAwait(false);
var cid = Cid.Decode(r.Remove(0, 6));
return(await UnixFs.UnixFs.CreateReadStreamAsync(cid, _blockApi, _keyApi, cancel).ConfigureAwait(false));
}
public void TestV0Handling()
{
var old = "QmdfTbBqBPQ7VNxZEYEj14VmRuZBkqFbiwReogJgS1zR1n";
var cid = Cid.Decode(old);
Assert.Equal((ulong)0, cid.Prefix.Version);
Assert.Equal(old, cid.Hash.ToString(Multibase.Base58));
Assert.Equal(old, cid.ToString());
}
public async Task <IActionResult> Data(string arg)
{
var r = await IpfsCore.Generic.ResolveAsync(arg, true, Cancel);
var cid = Cid.Decode(r.Remove(0, 6)); // strip '/ipfs/'.
var stream = await IpfsCore.Object.DataAsync(cid, Cancel);
return(File(stream, "text/plain"));
}
private async Task <IActionResult> Data(string arg)
{
var r = await DfsService.NameApi.ResolveAsync(arg, true, false, Cancel);
var cid = Cid.Decode(r.Remove(0, 6)); // strip '/ipfs/'.
var stream = await DfsService.ObjectApi.DataAsync(cid, Cancel);
return(File(stream, "text/plain"));
}
public void Decode_V0()
{
var hash = "QmXg9Pp2ytZ14xgmQjYEiHjVjMFXzCVVEcRTWJBmLgR39V";
var cid = Cid.Decode(hash);
Assert.AreEqual(0, cid.Version);
Assert.AreEqual("dag-pb", cid.ContentType);
Assert.AreEqual("base58btc", cid.Encoding);
Assert.AreEqual(hash, cid.Encode());
}
public void Decode_V1()
{
var id = "zb2rhj7crUKTQYRGCRATFaQ6YFLTde2YzdqbbhAASkL9uRDXn";
var hash = "QmaozNR7DZHQK1ZcU9p7QdrshMvXqWK6gpu5rmrkPdT3L4";
var cid = Cid.Decode(id);
Assert.AreEqual(1, cid.Version);
Assert.AreEqual("base58btc", cid.Encoding);
Assert.AreEqual("raw", cid.ContentType);
Assert.AreEqual(hash, cid.Hash);
}
public void Decode_V1_Unknown_ContentType()
{
var id = "zJAFhtPN28kqMxDkZawWCCL52BzaiymqFgX3LA7XzkNRMNAN1T1J";
var hash = "QmaozNR7DZHQK1ZcU9p7QdrshMvXqWK6gpu5rmrkPdT3L4";
var cid = Cid.Decode(id);
Assert.AreEqual(1, cid.Version);
Assert.AreEqual("base58btc", cid.Encoding);
Assert.AreEqual("codec-32767", cid.ContentType);
Assert.AreEqual(hash, cid.Hash);
}
public void Decode_Invalid_Version()
{
var cid = new Cid
{
Version = 32767,
ContentType = "raw",
Encoding = "base58btc",
Hash = "QmaozNR7DZHQK1ZcU9p7QdrshMvXqWK6gpu5rmrkPdT3L4"
};
var s = cid.Encode();
Assert.ThrowsException <FormatException>(() => Cid.Decode(s));
}
public async Task <IFileSystemNode> ListFileAsync(string path,
CancellationToken cancel = default)
{
var r = await _nameApi.ResolveAsync(path, true, false, cancel).ConfigureAwait(false);
var cid = Cid.Decode(r.Remove(0, 6));
var block = await _blockApi.GetAsync(cid, cancel).ConfigureAwait(false);
switch (cid.ContentType)
{
// TODO: A content-type registry should be used.
case "dag-pb":
// fall thru
break;
case "raw":
return(new UnixFsNode
{
Id = cid,
Size = block.Size
});
case "cms":
return(new UnixFsNode
{
Id = cid,
Size = block.Size
});
default:
throw new NotSupportedException($"Cannot read content type '{cid.ContentType}'.");
}
var dag = new DagNode(block.DataStream);
var dm = Serializer.Deserialize <DataMessage>(dag.DataStream);
var fsn = new UnixFsNode
{
Id = cid,
Links = dag.Links.Select(l => new UnixFsLink
{
Id = l.Id,
Name = l.Name,
Size = l.Size
}).ToArray(),
IsDirectory = dm.Type == DataType.Directory,
Size = (long)(dm.FileSize ?? 0)
};
return(fsn);
}
protected override async Task <int> OnExecute(CommandLineApplication app)
{
var Program = Parent.Parent;
var peers = await Program.CoreApi.Dht.FindProvidersAsync(Cid.Decode(Key), Limit);
return(Program.Output(app, peers, (data, writer) =>
{
foreach (var peer in peers)
{
writer.WriteLine(peer.Id.ToString());
}
}));
}
/// <summary>
/// Creates a new instance of the <see cref="MerkleNode"/> with the specified
/// <see cref="Id">cid</see> and optional <see cref="Name"/>.
/// </summary>
/// <param name="path">
/// The string representation of a <see cref="Cid"/> of the node or "/ipfs/cid".
/// </param>
/// <param name="name">A name for the node.</param>
public MerkleNode(string path, string name = null)
{
if (string.IsNullOrWhiteSpace(path))
{
throw new ArgumentNullException("path");
}
if (path.StartsWith("/ipfs/"))
{
path = path.Substring(6);
}
Id = Cid.Decode(path);
Name = name;
}
public void TestBasicMarshaling()
{
var h = Multihash.Sum <SHA3_512>(Encoding.UTF8.GetBytes("TEST"), 4);
var cid = new Cid(MulticodecCode.MerkleDAGCBOR, h);
var data = cid.ToBytes();
var output = Cid.Cast(data);
Assert.Equal(cid, output);
var s = cid.ToString();
output = Cid.Decode(s);
Assert.Equal(cid, output);
}
/// <inheritdoc />
public byte[] Serialize(CBORObject data)
{
var links = data["links"].Values
.Select(link => new DagLink(
link["Name"].AsString(),
Cid.Decode(link["Cid"]["/"].AsString()),
link["Size"].AsInt64()));
var node = new DagNode(data["data"].GetByteString(), links);
using (var ms = new MemoryStream())
{
node.Write(ms);
return(ms.ToArray());
}
}
/// <summary>
/// </summary>
/// <param name="getFileFromDfsRequest"></param>
/// <param name="channelHandlerContext"></param>
/// <param name="senderPeerId"></param>
/// <param name="correlationId"></param>
/// <returns></returns>
protected override GetFileFromDfsResponse HandleRequest(GetFileFromDfsRequest getFileFromDfsRequest,
IChannelHandlerContext channelHandlerContext,
PeerId senderPeerId,
ICorrelationId correlationId)
{
Guard.Argument(getFileFromDfsRequest, nameof(getFileFromDfsRequest)).NotNull();
Guard.Argument(channelHandlerContext, nameof(channelHandlerContext)).NotNull();
Guard.Argument(senderPeerId, nameof(senderPeerId)).NotNull();
long fileLen = 0;
FileTransferResponseCodeTypes responseCodeType;
var response = Task.Run(async() =>
{
try
{
responseCodeType = await Task.Run(async() =>
{
var stream = await _dfsService.UnixFsApi.ReadFileAsync(Cid.Decode(getFileFromDfsRequest.DfsHash))
.ConfigureAwait(false);
fileLen = stream.Length;
using (var fileTransferInformation = new UploadFileTransferInformation(
stream,
senderPeerId,
PeerSettings.PeerId,
channelHandlerContext.Channel,
correlationId
))
{
return(_fileTransferFactory.RegisterTransfer(fileTransferInformation));
}
}).ConfigureAwait(false);
}
catch (Exception e)
{
Logger.Error(e,
"Failed to handle GetFileFromDfsRequestHandler after receiving message {0}",
getFileFromDfsRequest);
responseCodeType = FileTransferResponseCodeTypes.Error;
}
return(ReturnResponse(responseCodeType, fileLen));
}).ConfigureAwait(false).GetAwaiter().GetResult();
return(response);
}
public async Task <IEnumerable <Cid> > AddAsync(string path,
bool recursive = true,
CancellationToken cancel = default)
{
var r = await _nameApi.ResolveAsync(path, cancel : cancel).ConfigureAwait(false);
var id = Cid.Decode(r.Remove(0, 6));
var todos = new Stack <Cid>();
todos.Push(id);
var dones = new List <Cid>();
// The pin is added before the content is fetched, so that
// garbage collection will not delete the newly pinned
// content.
while (todos.Count > 0)
{
var current = todos.Pop();
// Add CID to PIN database.
await Store.PutAsync(current, new Pin
{
Id = current
}, cancel).ConfigureAwait(false);
// Make sure that the content is stored locally.
await BlockApi.GetAsync(current, cancel).ConfigureAwait(false);
// Recursively pin the links?
if (recursive && current.ContentType == "dag-pb")
{
var links = await _objectApi.LinksAsync(current, cancel);
foreach (var link in links)
{
todos.Push(link.Id);
}
}
dones.Add(current);
}
return(dones);
}
public async Task <IEnumerable <Cid> > WantsAsync(MultiHash peer = null, CancellationToken cancel = default(CancellationToken))
{
var json = await ipfs.DoCommandAsync("bitswap/wantlist", cancel, peer?.ToString());
var keys = (JArray)(JObject.Parse(json)["Keys"]);
// https://github.com/ipfs/go-ipfs/issues/5077
return(keys
.Select(k =>
{
if (k.Type == JTokenType.String)
{
return Cid.Decode(k.ToString());
}
var obj = (JObject)k;
return Cid.Decode(obj["/"].ToString());
}));
}
public async Task <BitswapData> BitswapAsync(CancellationToken cancel = default(CancellationToken))
{
var json = await ipfs.DoCommandAsync("stats/bitswap", cancel);
var stat = JObject.Parse(json);
return(new BitswapData
{
BlocksReceived = (ulong)stat["BlocksReceived"],
DataReceived = (ulong)stat["DataReceived"],
BlocksSent = (ulong)stat["BlocksSent"],
DataSent = (ulong)stat["DataSent"],
DupBlksReceived = (ulong)stat["DupBlksReceived"],
DupDataReceived = (ulong)stat["DupDataReceived"],
ProvideBufLen = (int)stat["ProvideBufLen"],
Peers = ((JArray)stat["Peers"]).Select(s => new MultiHash((string)s)),
Wantlist = ((JArray)stat["Wantlist"]).Select(o => Cid.Decode(o["/"].ToString()))
});
}
public async Task <string> ResolveAsync(string name, bool recursive = false, CancellationToken cancel = default(CancellationToken))
{
var path = name;
if (path.StartsWith("/ipns/"))
{
path = await ipfs.Name.ResolveAsync(path, recursive, false, cancel).ConfigureAwait(false);
if (!recursive)
{
return(path);
}
}
if (path.StartsWith("/ipfs/"))
{
path = path.Remove(0, 6);
}
var parts = path.Split('/').Where(p => p.Length > 0).ToArray();
if (parts.Length == 0)
{
throw new ArgumentException($"Cannot resolve '{name}'.");
}
var id = Cid.Decode(parts[0]);
foreach (var child in parts.Skip(1))
{
var container = await ipfs.Object.GetAsync(id, cancel).ConfigureAwait(false);
var link = container.Links.FirstOrDefault(l => l.Name == child);
if (link == null)
{
throw new ArgumentException($"Cannot resolve '{child}' in '{name}'.");
}
id = link.Id;
}
return("/ipfs/" + id.Encode());
}
public void Value_Equality()
{
var a0 = Cid.Decode("zb2rhj7crUKTQYRGCRATFaQ6YFLTde2YzdqbbhAASkL9uRDXn");
var a1 = Cid.Decode("zb2rhj7crUKTQYRGCRATFaQ6YFLTde2YzdqbbhAASkL9uRDXn");
var b = Cid.Decode("QmaozNR7DZHQK1ZcU9p7QdrshMvXqWK6gpu5rmrkPdT3L5");
Cid c = null;
Cid d = null;
Assert.IsTrue(c == d);
Assert.IsFalse(c == b);
Assert.IsFalse(b == c);
Assert.IsFalse(c != d);
Assert.IsTrue(c != b);
Assert.IsTrue(b != c);
#pragma warning disable 1718
Assert.IsTrue(a0 == a0);
Assert.IsTrue(a0 == a1);
Assert.IsFalse(a0 == b);
Assert.IsFalse(a0 != a0);
Assert.IsFalse(a0 != a1);
Assert.IsTrue(a0 != b);
Assert.IsTrue(a0.Equals(a0));
Assert.IsTrue(a0.Equals(a1));
Assert.IsFalse(a0.Equals(b));
Assert.AreEqual(a0, a0);
Assert.AreEqual(a0, a1);
Assert.AreNotEqual(a0, b);
Assert.AreEqual(a0, a0);
Assert.AreEqual(a0, a1);
Assert.AreNotEqual(a0, b);
Assert.AreEqual(a0.GetHashCode(), a0.GetHashCode());
Assert.AreEqual(a0.GetHashCode(), a1.GetHashCode());
Assert.AreNotEqual(a0.GetHashCode(), b.GetHashCode());
}
public async Task <Stream> GetAsync(string path,
bool compress = false,
CancellationToken cancel = default)
{
var r = await _nameApi.ResolveAsync(path, true, false, cancel).ConfigureAwait(false);
var cid = Cid.Decode(r.Remove(0, 6));
var ms = new MemoryStream();
await using (var tarStream = new TarOutputStream(ms, 1))
{
using (var archive = TarArchive.CreateOutputTarArchive(tarStream))
{
archive.IsStreamOwner = false;
await AddTarNodeAsync(cid, cid.Encode(), tarStream, cancel).ConfigureAwait(false);
}
}
ms.Position = 0;
return(ms);
}
public async Task <IActionResult> Cat(string arg,
long offset = 0,
long length = 0)
{
EntityTagHeaderValue etag = null;
var path = await DfsService.NameApi.ResolveAsync(arg, true, false, Cancel);
var cid = Cid.Decode(path.Substring(6)); // remove leading "/ipfs/"
// Use an etag if the path is IPFS or CID.
if (arg.StartsWith("/ipfs/") || arg[0] != '/')
{
etag = ETag(cid);
Immutable();
}
// Use the last part of the path as the download filename
var filename = arg.Split('/').Last();
var stream = await DfsService.UnixFsApi.ReadFileAsync(cid, offset, length, Cancel);
return(File(stream, "application/octet-stream", filename, null, etag));
}
public void TestEmptyString()
{
Assert.Throws <ArgumentException>(() => Cid.Decode(""));
}
public void Decode_V1_Invalid_MultiBase_String()
{
var id = "zb2rhj7crUKTQYRGCRATFaQ6YFLTde2YzdqbbhAASkL9uRDX?";
Assert.ThrowsException <FormatException>(() => Cid.Decode(id));
}
public void Decode_V1_Invalid_MultiBase_Code()
{
var id = "?";
Assert.ThrowsException <FormatException>(() => Cid.Decode(id));
}
/// <summary>
/// Resolve an "IPFS path" to a content ID.
/// </summary>
/// <param name="path">
/// A IPFS path, such as "Qm...", "Qm.../a/b/c" or "/ipfs/QM..."
/// </param>
/// <param name="cancel">
/// Is used to stop the task. When cancelled, the <see cref="TaskCanceledException"/> is raised.
/// </param>
/// <returns>
/// The content ID of <paramref name="path"/>.
/// </returns>
/// <exception cref="ArgumentException">
/// The <paramref name="path"/> cannot be resolved.
/// </exception>
public async Task <Cid> ResolveIpfsPathToCidAsync(string path, CancellationToken cancel = default(CancellationToken))
{
var r = await Generic.ResolveAsync(path, true, cancel).ConfigureAwait(false);
return(Cid.Decode(r.Remove(0, 6))); // strip '/ipfs/'.
}
public void Decode_V0_Invalid()
{
var hash = "QmXg9Pp2ytZ14xgmQjYEiHjVjMFXzCVVEcRTWJBmLgR39?";
Assert.ThrowsException <FormatException>(() => Cid.Decode(hash));
}
public static Cid ToCid(this string cid)
{
//MultiBase.Encode(cid.ToUtf8Bytes(), Encoding)
return(Cid.Decode(cid));
}
public static Cid ToCid(this byte[] cid)
{
return(Cid.Decode(MultiBase.Encode(cid, Encoding)));
}
