private void NodeInfoForOneNode(NodeInfoInNet x)
{
LocalNodeInfo nod = null;
lock (LocalNodes)
{
nod = LocalNodes.FirstOrDefault(y => y.NodeId == x.NodeGuid);
if (nod == null)
{
nod = new LocalNodeInfo {
NodeId = x.NodeGuid,
Fetched = false,
PCVersion = x.PCVersion,
StatusTimeStamp = x.TimeStamp,
};
LocalNodes.Add(nod);
}
else
{
if (nod.StatusTimeStamp > x.TimeStamp)
{
return;
}
if (nod.StatusTimeStamp == x.TimeStamp)
{
if (nod.Fetched)
{
return;
}
}
else
{
nod.Fetched = false;
nod.StatusTimeStamp = x.TimeStamp;
}
//do not set LocalNodeInfo.Url in this block
}
}
if (nod.NodeId == ThisNodeID)//self
{
nod.Url = x.Url = $"http://localhost:{WebServerPort}/";
}
var t = new FetchQueueItem {
Node = x,
LocalNode = nod,
FinishTask = new TaskCompletionSource <int>()
};
fetchCloudInfo.Post(t);
t.FinishTask.Task.Wait(10 * 1000);
}
private void FireNodeRemovingEvent(LocalNodeInfo node)
{
try
{
var info = new LocalNodeUpdateEventArgs()
{
nodeInfo = node, PCinfos = new List <SSDPPCInfo>()
};
OnNodeUpdate?.Invoke(this, info);
}
catch (Exception exception)
{
logger.LogError(exception, $"Error getting info for node: {node.Url}");
}
}
private async Task <PersonalCloudInfo> GetPeerPCInfo(PersonalCloud pc, LocalDiscovery.LocalNodeInfo ninfo)
{
try
{
var url = new Uri(new Uri(ninfo.Url), "/api/share/cloud");
var s = await TopFolderClient.GetCloudInfo(httpClient.Value, url, pc.Id, pc.MasterKey).ConfigureAwait(false);
var cfg = JsonConvert.DeserializeObject <PersonalCloudInfo>(s);
var lis = cfg.Apps.Where(x => x.NodeId != ninfo.NodeId).ToList();
foreach (var item in lis)
{
cfg.Apps.Remove(item);
}
return(cfg);
}
catch (Exception e)
{
logger.LogError(e, $"Exception in GetPeerPCInfo {ninfo?.Url}");
return(null);
}
}
private void SyncSharePCs(LocalNodeInfo node, List <SSDPPCInfo> res)
{
//remove
lock (sharedPCs)
{
sharedPCs.RemoveAll(x =>
(x.NodeId == node.NodeId) &&
(
res.FirstOrDefault(y =>
(y.Id == x.PCId) &&
(!string.IsNullOrWhiteSpace(y.CodeHash))) == null
)
);
}
//add
lock (sharedPCs)
{
foreach (var item in res)
{
if (!string.IsNullOrWhiteSpace(item.CodeHash))
{
var prev = sharedPCs.FirstOrDefault(x => ((x.NodeId == node.NodeId) && (x.PCId == item.Id)));
if (prev == null)
{
var hash = ulong.Parse(item.CodeHash, CultureInfo.InvariantCulture);
var snode = new NodeShareInfo {
Hash = hash,
NodeId = node.NodeId,
Url = node.Url,
PCId = item.Id,
PCVersion = node.PCVersion,
};
sharedPCs.Add(snode);
}
logger.LogTrace($"{node.Url}:A PC is sharing");
}
}
}
}
private async Task OnNewNodeDiscovered(LocalNodeInfo node, HttpResponseMessage req)
{
var res = JsonConvert.DeserializeObject <List <SSDPPCInfo> >(await req.Content.ReadAsStringAsync().ConfigureAwait(false));
if (res == null)
{
res = new List <SSDPPCInfo>();
}
try
{
node.PcIds = res.Select(x => x.Id).ToList();
var info = new LocalNodeUpdateEventArgs()
{
nodeInfo = node, PCinfos = res
};
OnNodeUpdate?.Invoke(this, info);
}
catch (Exception exception)
{
logger.LogError(exception, $"Error getting info for node: {node.Url}");
}
SyncSharePCs(node, res);
}
internal async Task OnLocalNodeUpdate(LocalDiscovery.LocalNodeInfo ninfo, List <SSDPPCInfo> ssdpinfo)
{
bool updated = false;
bool deleted = false;
lock (CachedNodes)
{
var ssdpin = ssdpinfo.FirstOrDefault(x => x.Id == Id);
if (ssdpin != null)
{
var name = DecryptName(ssdpin.EN);
if (name == null)
{
logger.LogError($"Invalid node from {ninfo.Url}");
return;
}
NodeInfoForPC info = CachedNodes.FirstOrDefault(x => x.NodeGuid == ninfo.NodeId);
if (info != null)
{
if (info.PCTimeStamp < ssdpin.TimeStamp)
{
logger.LogTrace($"Removing node {info.Name} {info.NodeGuid}");
CachedNodes.Remove(info);
}
else
{
return;
}
}
var newinf = new NodeInfoForPC {
NodeGuid = ninfo.NodeId,
PCVersion = ninfo.PCVersion,
PCTimeStamp = ssdpin.TimeStamp,
Url = ninfo.Url,
Name = name
};
CachedNodes.Add(newinf);
OnCachedNodesChange();
updated = true;
}
else
{
int nremoved = 0;
if (CachedNodes.FirstOrDefault(x => x.NodeGuid == ninfo.NodeId) != null)
{
nremoved = CachedNodes.RemoveAll(x => x.NodeGuid == ninfo.NodeId);
}
if (nremoved > 0)
{
logger.LogTrace($"Removing node {ninfo.NodeId} {ninfo.NodeId} all");
OnCachedNodesChange();
deleted = true;
}
}
}
if (updated || deleted)
{
if (!deleted)
{
var pci = await GetPeerPCInfo(this, ninfo).ConfigureAwait(false);
if ((pci != null) && (pci.StorageProviders != null))
{
bool needResync = false;
foreach (var sp in pci.StorageProviders)
{
if (sp.Visibility != StorageProviderVisibility.Public)
{
continue;
}
if (sp.Type == StorageProviderInstance.TypeAliYun)
{
lock (StorageProviderInstances)
{
if (!StorageProviderInstances.Any(x => sp.Id.Equals(x.RuntimeId)))
{
var instance = new StorageProviderInstance_AliyunOSS(new StorageProviderInfo {
Id = sp.Id,
Type = StorageProviderInstance.TypeAliYun,
Name = sp.Name,
Visibility = sp.Visibility,
Settings = sp.Settings
});
StorageProviderInstances.Add(instance);
needResync = true;
}
}
}
if (sp.Type == StorageProviderInstance.TypeAzure)
{
lock (StorageProviderInstances)
{
if (!StorageProviderInstances.Any(x => sp.Id.Equals(x.RuntimeId)))
{
var instance = new StorageProviderInstance_AzureBlob(new StorageProviderInfo {
Id = sp.Id,
Type = StorageProviderInstance.TypeAzure,
Name = sp.Name,
Visibility = sp.Visibility,
Settings = sp.Settings
});
StorageProviderInstances.Add(instance);
needResync = true;
}
}
}
}
if (needResync)
{
ResyncClientListToStorageProviderInstances();
}
}
if ((pci != null) && (pci.Apps != null))
{
foreach (var ai in pci.Apps)
{
NodeInfoForPC n = GetNodeById(ai.NodeId);
if (n == null)
{
return;
}
var a = Apps.FirstOrDefault(x => (x.NodeId == ai.NodeId) && (x.AppId == ai.AppId) && (x.Name == ai.Name));
if (a == null)
{
lock (Apps)
{
Apps.Add(ai);
}
}
}
}
}
_ = Task.Run(() => {
try
{
OnNodeChangedEvent?.Invoke(this, EventArgs.Empty);
}
catch
{
}
});
}
}
