private void UploadException(int what, object param)
{
UploadMessage message = param as UploadMessage;
if (message == null)
{
return;
}
LogMessage logMessage = message.RecordMessage;
// DengTaUploadException.UploadException(logMessage.tag.ToString(), logMessage.packedContent);
// Dictionary<string, string> userInfo = new Dictionary<string, string>();
// userInfo.Add(logMessage.tag.ToString(), logMessage.content);
//
// bool result = UserAction.UploadUserAction("ScriptError", false, -1, -1, userInfo, true);
// if (!result)
// {
// Log.D(ELogTag.LogSys, "upload user action failed!!");
// }
// string messageContent = string.Format("{0}:{1}", logMessage.tag, logMessage.content);
// DengTaUploadException.UploadExceptionWithStack(messageContent, message.ContextBefore, message.StackInfo);
}
private void UploadUserActionCallBack(int what, object param)
{
UploadMessage uploadMessage = param as UploadMessage;
if (null == uploadMessage)
{
return;
}
string userActionType = uploadMessage.ContextBefore;
LogMessage logMessage = uploadMessage.RecordMessage;
if (null == logMessage ||
null == logMessage.tag ||
null == logMessage.content)
{
return;
}
Dictionary <string, string> userInfo = new Dictionary <string, string>();
userInfo.Add(logMessage.tag.ToString(), logMessage.content);
//MSDK.Instance.reportEvent(userActionType, userInfo, false);
}
public async Task <UploadMessage> UploadAsync(IFormFile file, string rootFolder)
{
UploadMessage message = new UploadMessage
{
Message = UploadMessage.ERROR
};
try
{
// Create a unique name for the images we are about to upload
string filename = String.Format("{0}{1}",
Guid.NewGuid().ToString().Substring(0, 8),
Path.GetExtension(file.FileName));
string containerDefault = _config.DestinationFolder.Replace("/", "\\");
string path = rootFolder + $@"\{containerDefault}" + $@"\{filename}";
using (FileStream fs = File.Create(path))
{
await file.CopyToAsync(fs);
fs.Flush();
}
message.FileName = file.FileName;
message.GuidFileName = filename;
message.FullPath = String.Format("{0}/{1}", _config.DestinationFolder, filename);
message.Message = UploadMessage.SUCCESS;
}
catch (Exception ex)
{
message.Message = ex.Message;
}
return(message);
}
public UploadMessage Delete(string path)
{
var message = new UploadMessage();
string[] splits = path.Split('/');
string filename = splits[splits.Length - 1];
path = path.Replace(filename, "");
path = path.Replace("/", "\\");
string[] files = Directory.GetFiles(path, filename);
if (files.Length > 0)
{
foreach (var loc in files)
{
File.Delete(loc);
}
message.Message = "Success";
}
else
{
message.Message = "Not Found";
}
return(message);
}
/// <summary>
/// Function to receive upload message
/// </summary>
/// <param name="uploadMessage">The message to be received</param>
private void ReceivedUpload(UploadMessage uploadMessage)
{
if (uploadMessage.type.Equals(TypeCode.REQUEST))
{
int replyPort = uploadMessage.port;
string uuid = uploadMessage.fromUuid;
if (DiskHelper.GetTotalAvailableSpace(@"C:\") > uploadMessage.filesize)
{
uploadMessage.statusCode = StatusCode.ACCEPTED;
Console.WriteLine(@"Request accepted");
}
else
{
Console.WriteLine(@"Not enough space");
uploadMessage.statusCode = StatusCode.INSUFFICIENT_STORAGE;
}
uploadMessage.CreateReply();
uploadMessage.port = _ports.GetAvailablePort();
_fileReceiver =
new FileReceiver(this._path + @".hidden\" + uuid + @"\" + uploadMessage.fullFilename + @"\",
uploadMessage.chunkHash, uploadMessage.port);
_fileReceiver.Start();
uploadMessage.Send(replyPort);
}
_ports.Release(uploadMessage.port);
}
public async Task <UploadMessage> DeleteAsync(string path)
{
var message = new UploadMessage();
var response = await _s3Client.DeleteObjectAsync(_config.Container, path);
message.Message = response.HttpStatusCode == HttpStatusCode.OK ? UploadMessage.SUCCESS : UploadMessage.ERROR;
return(message);
}
public async Task <UploadMessageResponse> UploadSolution(byte[] managedSolution, string solution, string tenantId, Guid corrId, CancellationToken cancellationToken)
{
var req = new UploadMessage(managedSolution, solution, tenantId, corrId);
var response = await this.ExecuteAsync(req, cancellationToken).ConfigureAwait(false);
string respnseMsg = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
var resp = this._jsonSerializer.Deserialize <string[]>(respnseMsg);
return(new UploadMessageResponse(resp, tenantId, corrId));
}
protected override HttpRequestMessage GetHttpMessageRequest(PowerAppRequest request)
{
if (request is UploadMessage)
{
UploadMessage msg = request as UploadMessage;
var req = base.GetHttpMessageRequest(request);
req.Content = msg.MultipartFormDataContent;
return(req);
}
else
{
return(base.GetHttpMessageRequest(request));
}
}
public async Task <UploadMessage> UploadAsync(IFormFile file, string rootFolder)
{
UploadMessage message = new UploadMessage
{
Message = UploadMessage.ERROR
};
try
{
// Create a unique name for the images we are about to upload
string filename = String.Format("{0}{1}",
Guid.NewGuid().ToString().Substring(0, 8),
Path.GetExtension(file.FileName));
HttpStatusCode code;
using (MemoryStream fs = new MemoryStream())
{
file.CopyTo(fs);
var request = new PutObjectRequest
{
BucketName = _config.Container,
Key = String.Format("{0}/{1}", _config.DestinationFolder, filename),
InputStream = fs,
ContentType = file.ContentType,
CannedACL = S3CannedACL.PublicRead
};
var cancellationToken = new CancellationToken();
var response = await _s3Client.PutObjectAsync(request, cancellationToken);
code = response.HttpStatusCode;
fs.Flush();
}
message.FileName = file.FileName;
message.GuidFileName = filename;
message.FullPath = String.Format("{0}/{1}", _config.DestinationFolder, filename);
message.Message = code == HttpStatusCode.OK ? UploadMessage.SUCCESS : UploadMessage.ERROR;
}
catch (Exception ex)
{
Console.Write(ex.Message);
message.Message = ex.Message;
}
return(message);
}
/// <summary>
/// Pushes the inputted chunk to the network, sending it the required amount of peers.
/// </summary>
/// <param name="chunk">The chunk to push to the network</param>
/// <param name="chunkPath">String path to the chunks</param>
/// <param name="numberOfRecevingPeers">The number of peers to send the file to,
/// this will be the amount of receivers, unless the network is smaller than the given input.</param>
/// <param name="receiverOffset">The offset for whom to send the files to, this determines the spacing of the chunks on the peerlist.</param>
/// <returns>Boolean of whether the push was a success.</returns>
public bool Push(P2PChunk chunk, string chunkPath, int numberOfRecevingPeers = 10, int receiverOffset = 0)
{
this._port = _ports.GetAvailablePort();
List <Peer> peers = this.GetPeers();
FileInfo fileInfo = new FileInfo(chunkPath);
Listener listener = new Listener(this._port);
bool sendToAll = true;
int listLength = peers.Count;
int peerCount;
int numberOfReceivers = Math.Min(numberOfRecevingPeers, listLength);
for (peerCount = 0; peerCount < numberOfReceivers; peerCount++)
{
Peer currentPeer = peers[(peerCount + receiverOffset) % listLength];
var upload = new UploadMessage(currentPeer)
{
filesize = fileInfo.Length,
fullFilename = chunk.originalHash,
chunkHash = chunk.hash,
path = chunkPath,
port = this._port
};
if (listener.SendAndAwaitResponse(ref upload, 2000))
{
if (upload.statusCode == StatusCode.ACCEPTED)
{
ChunkSender sender = new ChunkSender(currentPeer.StringIp, upload.port);
if (sender.Send(chunkPath))
{
DiskHelper.ConsoleWrite($"The chunk {chunk.hash} was sent to {currentPeer.GetUuid()}");
chunk.AddPeer(currentPeer.GetUuid());
}
else
{
sendToAll = false;
}
_ports.Release(upload.port);
}
}
}
_ports.Release(this._port);
return(sendToAll);
}
public UploadReturnMessage UploadFile(UploadMessage uploadMessage)
{
throw new NotImplementedException();
}
/// <summary>
/// Lanza un evento con el mensaje
/// </summary>
internal void RaiseMessageEvent(string message, bool error)
{
UploadMessage?.Invoke(this, new EventArguments.UploadEventArgs(message, error));
}
