public S_FileTransferSend(RatClients client, FileTransfer info, byte[] bytes, int Index)
: base(client)
{
this.info = info;
this.bytes = bytes;
this.Index = Index;
}
public static FileTransferControl AddNewFileTransfer(this FlowDocument doc, Tox tox, FileTransfer transfer)
{
var fileTableCell = new TableCell();
var fileTransferControl = new FileTransferControl(transfer, fileTableCell);
var usernameParagraph = new Section();
var newTableRow = new TableRow();
newTableRow.Tag = transfer;
var fileTransferContainer = new BlockUIContainer();
fileTransferControl.HorizontalAlignment = HorizontalAlignment.Stretch;
fileTransferControl.HorizontalContentAlignment = HorizontalAlignment.Stretch;
fileTransferContainer.Child = fileTransferControl;
usernameParagraph.Blocks.Add(fileTransferContainer);
usernameParagraph.Padding = new Thickness(0);
fileTableCell.ColumnSpan = 3;
fileTableCell.Blocks.Add(usernameParagraph);
newTableRow.Cells.Add(fileTableCell);
fileTableCell.Padding = new Thickness(0, 10, 0, 10);
var MessageRows = (TableRowGroup)doc.FindName("MessageRows");
MessageRows.Rows.Add(newTableRow);
return fileTransferControl;
}
public ReleaseManager(FileTransfer fileTransfer)
{
this.fileTransfer = fileTransfer;
// setting object loads settings from file or displays form
Settings = new Settings();
versions = new XmlVersions();
try
{
// create temp folder (if not exists)
if (!Directory.Exists(localPath))
Directory.CreateDirectory(localPath);
Valid = true;
}
catch (Exception e)
{
ErrorLog.Add(this, e.Message);
// fire error event
FireError(Strings.UnableToCreateLocalDirectory);
}
}
public FileTransferControl(FileTransfer transfer, TableCell fileTableCell)
{
this.transfer = transfer;
this.fileTableCell = fileTableCell;
InitializeComponent();
SizeLabel.Content = Tools.GetSizeString(transfer.FileSize);
MessageLabel.Content = string.Format(transfer.FileName);
}
/// <summary>
/// Cancels the specified file-transfer.
/// </summary>
/// <param name="transfer">The file-transfer to cancel.</param>
/// <exception cref="ArgumentNullException">The transfer parameter is
/// null.</exception>
/// <exception cref="ArgumentException">The specified transfer instance does
/// not represent an active data-transfer operation.</exception>
/// <exception cref="InvalidOperationException">The XmppClient instance is not
/// connected to a remote host, or the XmppClient instance has not authenticated with
/// the XMPP server.</exception>
/// <exception cref="ObjectDisposedException">The XmppClient object has been
/// disposed.</exception>
public void CancelFileTransfer(FileTransfer transfer) {
AssertValid();
transfer.ThrowIfNull("transfer");
siFileTransfer.CancelFileTransfer(transfer);
}
/// <summary>
/// Creates a file transfer if the source and destination are different.
/// </summary>
/// <param name="source">Source path to file.</param>
/// <param name="destination">Destination path for file.</param>
/// <param name="move">File if file should be moved (optimal).</param>
/// <param name="type">Optional type of file this transfer is transferring.</param>
/// <param name="sourceLineNumbers">Optional source line numbers wher this transfer originated.</param>
/// <returns>true if the source and destination are the different, false if no file transfer is created.</returns>
public static bool TryCreate(string source, string destination, bool move, string type, SourceLineNumberCollection sourceLineNumbers, out FileTransfer transfer)
{
string sourceFullPath = null;
string fileLayoutFullPath = null;
try
{
sourceFullPath = Path.GetFullPath(source);
}
catch (System.ArgumentException)
{
throw new WixException(WixErrors.InvalidFileName(sourceLineNumbers, source));
}
catch (System.IO.PathTooLongException)
{
throw new WixException(WixErrors.PathTooLong(sourceLineNumbers, source));
}
try
{
fileLayoutFullPath = Path.GetFullPath(destination);
}
catch (System.ArgumentException)
{
throw new WixException(WixErrors.InvalidFileName(sourceLineNumbers, destination));
}
catch (System.IO.PathTooLongException)
{
throw new WixException(WixErrors.PathTooLong(sourceLineNumbers, destination));
}
// if the current source path (where we know that the file already exists) and the resolved
// path as dictated by the Directory table are not the same, then propagate the file. The
// image that we create may have already been done by some other process other than the linker, so
// there is no reason to copy the files to the resolved source if they are already there.
if (String.Equals(sourceFullPath, fileLayoutFullPath, StringComparison.OrdinalIgnoreCase))
{
// TODO: would prefer to return null here.
transfer = new FileTransfer(); // create an empty transfer because we must.
transfer.Redundant = true;
return false;
}
transfer = new FileTransfer(source, destination, move, type, sourceLineNumbers);
return true;
}
public S_FileTransferSendBegin(FileClients client, FileTransfer info, SendType type)
: base(client)
{
this.info = info;
this.type = type;
}
public void SendFile(FileTransfer info, byte[] FileBytes, S_FileTransferSendBegin.SendType type)
{
SendPacket(new S_FileTransferSendBegin(this, info, type));
Thread thread = new Thread(new ParameterizedThreadStart(ThreadSendFile));
thread.Start(new object[] { info, FileBytes });
}
public S_FileTransferSendComplete(FileClients client, FileTransfer info)
: base(client)
{
this.info = info;
}
/// <summary>
/// Invoked once the result of a pending stream-initiation operation has been
/// received.
/// </summary>
/// <param name="result">The result of the stream-initiation operation. If
/// this parameter is null, stream-initiation failed.</param>
/// <param name="to">The JID of the XMPP user to offer the file to.</param>
/// <param name="stream">The stream to read the file-data from.</param>
/// <param name="name">The name of the file, as offered to the XMPP user
/// with the specified JID.</param>
/// <param name="size">The number of bytes to transfer.</param>
/// <param name="cb">A callback method invoked once the other site has
/// accepted or rejected the file-transfer request.</param>
/// <param name="description">A description of the file so the receiver can
/// better understand what is being sent.</param>
/// <remarks>This is called in the context of an arbitrary thread.</remarks>
void OnInitiationResult(InitiationResult result, Jid to, string name,
Stream stream, long size, string description, Action<bool, FileTransfer> cb) {
FileTransfer transfer = new FileTransfer(im.Jid, to, name, size, null,
description);
try {
// Get the instance of the data-stream extension that the other site has
// selected.
IDataStream ext = im.GetExtension(result.Method) as IDataStream;
// Register the session.
SISession session = new SISession(result.SessionId, stream, size, false,
im.Jid, to, ext);
siSessions.TryAdd(result.SessionId, session);
// Store the file's meta data.
metaData.TryAdd(result.SessionId, new FileMetaData(name, description));
// Invoke user-provided callback.
if (cb != null)
cb.Invoke(true, transfer);
// Perform the actual data-transfer.
try {
ext.Transfer(session);
} catch(Exception e) {
// Nothing to do here.
}
} catch {
// Something went wrong. Invoke user-provided callback to let them know
// the file-transfer can't be performed.
if (cb != null)
cb.Invoke(false, transfer);
}
}
public void Execute()
{
var section = this.Intermediate.Sections.Single();
var fileTransfers = new List <FileTransfer>();
var containsMergeModules = false;
var suppressedTableNames = new HashSet <string>();
// If there are any fields to resolve later, create the cache to populate during bind.
var variableCache = this.DelayedFields.Any() ? new Dictionary <string, string>(StringComparer.InvariantCultureIgnoreCase) : null;
// Process the summary information table before the other tables.
bool compressed;
bool longNames;
int installerVersion;
string modularizationGuid;
{
var command = new BindSummaryInfoCommand(section);
command.Execute();
compressed = command.Compressed;
longNames = command.LongNames;
installerVersion = command.InstallerVersion;
modularizationGuid = command.ModularizationGuid;
}
// Add binder variables for all properties.
if (SectionType.Product == section.Type || variableCache != null)
{
foreach (var propertyRow in section.Tuples.OfType <PropertyTuple>())
{
// Set the ProductCode if it is to be generated.
if ("ProductCode".Equals(propertyRow.Property, StringComparison.Ordinal) && "*".Equals(propertyRow.Value, StringComparison.Ordinal))
{
propertyRow.Value = Common.GenerateGuid();
#if TODO_FIX_INSTANCE_TRANSFORM // Is this still necessary?
// Update the target ProductCode in any instance transforms.
foreach (SubStorage subStorage in this.Output.SubStorages)
{
Output subStorageOutput = subStorage.Data;
if (OutputType.Transform != subStorageOutput.Type)
{
continue;
}
Table instanceSummaryInformationTable = subStorageOutput.Tables["_SummaryInformation"];
foreach (Row row in instanceSummaryInformationTable.Rows)
{
if ((int)SummaryInformation.Transform.ProductCodes == row.FieldAsInteger(0))
{
row[1] = row.FieldAsString(1).Replace("*", propertyRow.Value);
break;
}
}
}
#endif
}
// Add the property name and value to the variableCache.
if (variableCache != null)
{
var key = String.Concat("property.", propertyRow.Property);
variableCache[key] = propertyRow.Value;
}
}
}
// Sequence all the actions.
{
var command = new SequenceActionsCommand(section);
command.Messaging = this.Messaging;
command.Execute();
}
{
var command = new CreateSpecialPropertiesCommand(section);
command.Execute();
}
#if TODO_FINISH_PATCH
////if (OutputType.Patch == this.Output.Type)
////{
//// foreach (SubStorage substorage in this.Output.SubStorages)
//// {
//// Output transform = substorage.Data;
//// ResolveFieldsCommand command = new ResolveFieldsCommand();
//// command.Tables = transform.Tables;
//// command.FilesWithEmbeddedFiles = filesWithEmbeddedFiles;
//// command.FileManagerCore = this.FileManagerCore;
//// command.FileManagers = this.FileManagers;
//// command.SupportDelayedResolution = false;
//// command.TempFilesLocation = this.TempFilesLocation;
//// command.WixVariableResolver = this.WixVariableResolver;
//// command.Execute();
//// this.MergeUnrealTables(transform.Tables);
//// }
////}
#endif
if (this.Messaging.EncounteredError)
{
return;
}
this.Messaging.Write(VerboseMessages.UpdatingFileInformation());
// This must occur after all variables and source paths have been resolved.
List <FileFacade> fileFacades;
{
var command = new GetFileFacadesCommand(section);
command.Execute();
fileFacades = command.FileFacades;
}
// Extract files that come from binary .wixlibs and WixExtensions (this does not extract files from merge modules).
{
var command = new ExtractEmbeddedFilesCommand(this.ExpectedEmbeddedFiles);
command.Execute();
}
// Gather information about files that do not come from merge modules.
{
var command = new UpdateFileFacadesCommand(this.Messaging, section);
command.FileFacades = fileFacades;
command.UpdateFileFacades = fileFacades.Where(f => !f.FromModule);
command.OverwriteHash = true;
command.TableDefinitions = this.TableDefinitions;
command.VariableCache = variableCache;
command.Execute();
}
// Now that the variable cache is populated, resolve any delayed fields.
if (this.DelayedFields.Any())
{
var command = new ResolveDelayedFieldsCommand(this.Messaging, this.DelayedFields, variableCache);
command.Execute();
}
// Set generated component guids.
{
var command = new CalculateComponentGuids(this.Messaging, section);
command.Execute();
}
// Retrieve file information from merge modules.
if (SectionType.Product == section.Type)
{
var wixMergeTuples = section.Tuples.OfType <WixMergeTuple>().ToList();
if (wixMergeTuples.Any())
{
containsMergeModules = true;
var command = new ExtractMergeModuleFilesCommand(this.Messaging, section, wixMergeTuples);
command.FileFacades = fileFacades;
command.OutputInstallerVersion = installerVersion;
command.SuppressLayout = this.SuppressLayout;
command.IntermediateFolder = this.IntermediateFolder;
command.Execute();
fileFacades.AddRange(command.MergeModulesFileFacades);
}
}
#if TODO_FINISH_PATCH
else if (OutputType.Patch == this.Output.Type)
{
// Merge transform data into the output object.
IEnumerable <FileFacade> filesFromTransform = this.CopyFromTransformData(this.Output);
fileFacades.AddRange(filesFromTransform);
}
#endif
// stop processing if an error previously occurred
if (this.Messaging.EncounteredError)
{
return;
}
// Assign files to media.
Dictionary <int, MediaTuple> assignedMediaRows;
Dictionary <MediaTuple, IEnumerable <FileFacade> > filesByCabinetMedia;
IEnumerable <FileFacade> uncompressedFiles;
{
var command = new AssignMediaCommand(section, this.Messaging);
command.FileFacades = fileFacades;
command.FilesCompressed = compressed;
command.Execute();
assignedMediaRows = command.MediaRows;
filesByCabinetMedia = command.FileFacadesByCabinetMedia;
uncompressedFiles = command.UncompressedFileFacades;
}
// stop processing if an error previously occurred
if (this.Messaging.EncounteredError)
{
return;
}
// Time to create the output object. Try to put as much above here as possible, updating the IR is better.
Output output;
{
var command = new CreateOutputFromIRCommand(section, this.TableDefinitions, this.BackendExtensions);
command.Execute();
output = command.Output;
}
// Update file sequence.
{
var command = new UpdateMediaSequencesCommand(output, fileFacades, assignedMediaRows);
command.Execute();
}
// Modularize identifiers.
if (OutputType.Module == output.Type)
{
var command = new ModularizeCommand(output, modularizationGuid, section.Tuples.OfType <WixSuppressModularizationTuple>());
command.Execute();
}
else // we can create instance transforms since Component Guids are set.
{
#if TODO_FIX_INSTANCE_TRANSFORM
this.CreateInstanceTransforms(this.Output);
#endif
}
#if TODO_FINISH_UPDATE
// Extended binder extensions can be called now that fields are resolved.
{
Table updatedFiles = this.Output.EnsureTable(this.TableDefinitions["WixBindUpdatedFiles"]);
foreach (IBinderExtension extension in this.Extensions)
{
extension.AfterResolvedFields(this.Output);
}
List <FileFacade> updatedFileFacades = new List <FileFacade>();
foreach (Row updatedFile in updatedFiles.Rows)
{
string updatedId = updatedFile.FieldAsString(0);
FileFacade updatedFacade = fileFacades.First(f => f.File.File.Equals(updatedId));
updatedFileFacades.Add(updatedFacade);
}
if (updatedFileFacades.Any())
{
UpdateFileFacadesCommand command = new UpdateFileFacadesCommand();
command.FileFacades = fileFacades;
command.UpdateFileFacades = updatedFileFacades;
command.ModularizationGuid = modularizationGuid;
command.Output = this.Output;
command.OverwriteHash = true;
command.TableDefinitions = this.TableDefinitions;
command.VariableCache = variableCache;
command.Execute();
}
}
#endif
// Stop processing if an error previously occurred.
if (this.Messaging.EncounteredError)
{
return;
}
// Ensure the intermediate folder is created since delta patches will be
// created there.
Directory.CreateDirectory(this.IntermediateFolder);
if (SectionType.Patch == section.Type && this.DeltaBinaryPatch)
{
var command = new CreateDeltaPatchesCommand(fileFacades, this.IntermediateFolder, section.Tuples.OfType <WixPatchIdTuple>().FirstOrDefault());
command.Execute();
}
// create cabinet files and process uncompressed files
var layoutDirectory = Path.GetDirectoryName(this.OutputPath);
if (!this.SuppressLayout || OutputType.Module == output.Type)
{
this.Messaging.Write(VerboseMessages.CreatingCabinetFiles());
var command = new CreateCabinetsCommand();
command.CabbingThreadCount = this.CabbingThreadCount;
command.CabCachePath = this.CabCachePath;
command.DefaultCompressionLevel = this.DefaultCompressionLevel;
command.Output = output;
command.Messaging = this.Messaging;
command.BackendExtensions = this.BackendExtensions;
command.LayoutDirectory = layoutDirectory;
command.Compressed = compressed;
command.FileRowsByCabinet = filesByCabinetMedia;
command.ResolveMedia = this.ResolveMedia;
command.TableDefinitions = this.TableDefinitions;
command.TempFilesLocation = this.IntermediateFolder;
command.WixMediaTuples = section.Tuples.OfType <WixMediaTuple>();
command.Execute();
fileTransfers.AddRange(command.FileTransfers);
}
#if TODO_FINISH_PATCH
if (OutputType.Patch == this.Output.Type)
{
// copy output data back into the transforms
this.CopyToTransformData(this.Output);
}
#endif
this.ValidateComponentGuids(output);
// stop processing if an error previously occurred
if (this.Messaging.EncounteredError)
{
return;
}
// Generate database file.
this.Messaging.Write(VerboseMessages.GeneratingDatabase());
string tempDatabaseFile = Path.Combine(this.IntermediateFolder, Path.GetFileName(this.OutputPath));
this.GenerateDatabase(output, tempDatabaseFile, false, false);
if (FileTransfer.TryCreate(tempDatabaseFile, this.OutputPath, true, output.Type.ToString(), null, out var transfer)) // note where this database needs to move in the future
{
transfer.Built = true;
fileTransfers.Add(transfer);
}
// Stop processing if an error previously occurred.
if (this.Messaging.EncounteredError)
{
return;
}
// Merge modules.
if (containsMergeModules)
{
this.Messaging.Write(VerboseMessages.MergingModules());
// Add back possibly suppressed sequence tables since all sequence tables must be present
// for the merge process to work. We'll drop the suppressed sequence tables again as
// necessary.
foreach (SequenceTable sequence in Enum.GetValues(typeof(SequenceTable)))
{
var sequenceTableName = sequence.ToString();
var sequenceTable = output.Tables[sequenceTableName];
if (null == sequenceTable)
{
sequenceTable = output.EnsureTable(this.TableDefinitions[sequenceTableName]);
}
if (0 == sequenceTable.Rows.Count)
{
suppressedTableNames.Add(sequenceTableName);
}
}
var command = new MergeModulesCommand();
command.FileFacades = fileFacades;
command.Output = output;
command.OutputPath = tempDatabaseFile;
command.SuppressedTableNames = suppressedTableNames;
command.Execute();
}
if (this.Messaging.EncounteredError)
{
return;
}
#if TODO_FINISH_VALIDATION
// Validate the output if there is an MSI validator.
if (null != this.Validator)
{
Stopwatch stopwatch = Stopwatch.StartNew();
// set the output file for source line information
this.Validator.Output = this.Output;
Messaging.Instance.Write(WixVerboses.ValidatingDatabase());
this.Validator.Validate(tempDatabaseFile);
stopwatch.Stop();
Messaging.Instance.Write(WixVerboses.ValidatedDatabase(stopwatch.ElapsedMilliseconds));
// Stop processing if an error occurred.
if (Messaging.Instance.EncounteredError)
{
return;
}
}
#endif
// Process uncompressed files.
if (!this.Messaging.EncounteredError && !this.SuppressLayout && uncompressedFiles.Any())
{
var command = new ProcessUncompressedFilesCommand(section);
command.Compressed = compressed;
command.FileFacades = uncompressedFiles;
command.LayoutDirectory = layoutDirectory;
command.LongNamesInImage = longNames;
command.ResolveMedia = this.ResolveMedia;
command.DatabasePath = tempDatabaseFile;
command.Execute();
fileTransfers.AddRange(command.FileTransfers);
}
this.FileTransfers = fileTransfers;
this.ContentFilePaths = fileFacades.Select(r => r.WixFile.Source.Path).ToList();
this.Pdb = new Pdb {
Output = output
};
// TODO: Eventually this gets removed
var intermediate = new Intermediate(this.Intermediate.Id, new[] { section }, this.Intermediate.Localizations.ToDictionary(l => l.Culture, StringComparer.OrdinalIgnoreCase), this.Intermediate.EmbedFilePaths);
intermediate.Save(Path.ChangeExtension(this.OutputPath, "wir"));
}
public void ConfigurationManager_GetHtmlTransformersSection_HtmlTransformers_ShouldDependOnLocations()
{
string physicalDirectoryPath = AppDomain.CurrentDomain.BaseDirectory;
IFileTransfer fileTransfer = new FileTransfer(new FileSystem(), physicalDirectoryPath, physicalDirectoryPath);
fileTransfer.AddFile(string.Format(CultureInfo.InvariantCulture, @"{0}\Configuration\Test-configurations\HtmlTransformersSectionTest.DifferentLocations.Web.config", AppDomain.CurrentDomain.BaseDirectory), Path.Combine(physicalDirectoryPath, "Web.config"));
SimulatedVirtualPathProvider simulatedVirtualPathProvider = new SimulatedVirtualPathProvider();
simulatedVirtualPathProvider.VirtualFiles.CreateWithDefaultWebFormContentAndAddFile("/Default.aspx");
simulatedVirtualPathProvider.VirtualFiles.CreateWithDefaultWebFormContentAndAddFile("/FiveItemsUsingAddAndRemove/Default.aspx");
simulatedVirtualPathProvider.VirtualFiles.CreateWithDefaultWebFormContentAndAddFile("/NoItemsUsingClear/Default.aspx");
simulatedVirtualPathProvider.VirtualFiles.CreateWithDefaultWebFormContentAndAddFile("/ThreeItemsUsingRemove/Default.aspx");
simulatedVirtualPathProvider.VirtualFiles.CreateWithDefaultWebFormContentAndAddFile("/ThreeItemsUsingRemove/TwoItemsUsingAddAndRemove/Default.aspx");
simulatedVirtualPathProvider.VirtualFiles.CreateWithDefaultWebFormContentAndAddFile("/ThreeItemsUsingRemove/TwoItemsUsingAddAndRemove/NoItemsUsingRemove/Default.aspx");
using(VirtualApplicationHostProxy virtualApplicationHostProxy = new VirtualApplicationHostProxyFactory().Create(fileTransfer, simulatedVirtualPathProvider))
{
virtualApplicationHostProxy.AnyApplicationEvent += delegate(HttpApplicationEvent httpApplicationEvent)
{
if(httpApplicationEvent != HttpApplicationEvent.PostRequestHandlerExecute)
return;
HttpRequest httpRequest = HttpContext.Current.Request;
HtmlTransformerElementCollection htmlTransformers = ((HtmlTransformersSection) ConfigurationManager.GetSection("hansKindberg.web/htmlTransformers")).HtmlTransformers;
if(httpRequest.RawUrl == "/Default.aspx")
{
Assert.AreEqual(5, htmlTransformers.Count);
Assert.AreEqual("One", htmlTransformers[0].Name);
Assert.AreEqual(typeof(HtmlTransformer), htmlTransformers[0].Type);
Assert.AreEqual("Two", htmlTransformers[1].Name);
Assert.AreEqual(typeof(HtmlTransformer), htmlTransformers[0].Type);
Assert.AreEqual("Three", htmlTransformers[2].Name);
Assert.AreEqual(typeof(HtmlTransformer), htmlTransformers[0].Type);
Assert.AreEqual("Four", htmlTransformers[3].Name);
Assert.AreEqual(typeof(HtmlTransformer), htmlTransformers[0].Type);
Assert.AreEqual("Five", htmlTransformers[4].Name);
Assert.AreEqual(typeof(HtmlTransformer), htmlTransformers[0].Type);
return;
}
if(httpRequest.RawUrl == "/FiveItemsUsingAddAndRemove/Default.aspx")
{
Assert.AreEqual(5, htmlTransformers.Count);
Assert.AreEqual("One", htmlTransformers[0].Name);
Assert.AreEqual(typeof(HtmlTransformer), htmlTransformers[0].Type);
Assert.AreEqual("Two", htmlTransformers[1].Name);
Assert.AreEqual(typeof(HtmlTransformer), htmlTransformers[0].Type);
Assert.AreEqual("Three", htmlTransformers[2].Name);
Assert.AreEqual(typeof(HtmlTransformer), htmlTransformers[0].Type);
Assert.AreEqual("Six", htmlTransformers[3].Name);
Assert.AreEqual(typeof(HtmlTransformer), htmlTransformers[0].Type);
Assert.AreEqual("Seven", htmlTransformers[4].Name);
Assert.AreEqual(typeof(HtmlTransformer), htmlTransformers[0].Type);
return;
}
if(httpRequest.RawUrl == "/NoItemsUsingClear/Default.aspx")
{
Assert.AreEqual(0, htmlTransformers.Count);
return;
}
if(httpRequest.RawUrl == "/ThreeItemsUsingRemove/Default.aspx")
{
Assert.AreEqual(3, htmlTransformers.Count);
Assert.AreEqual("One", htmlTransformers[0].Name);
Assert.AreEqual(typeof(HtmlTransformer), htmlTransformers[0].Type);
Assert.AreEqual("Two", htmlTransformers[1].Name);
Assert.AreEqual(typeof(HtmlTransformer), htmlTransformers[0].Type);
Assert.AreEqual("Three", htmlTransformers[2].Name);
Assert.AreEqual(typeof(HtmlTransformer), htmlTransformers[0].Type);
return;
}
if(httpRequest.RawUrl == "/ThreeItemsUsingRemove/TwoItemsUsingAddAndRemove/Default.aspx")
{
Assert.AreEqual(2, htmlTransformers.Count);
Assert.AreEqual("Four", htmlTransformers[0].Name);
Assert.AreEqual(typeof(HtmlTransformer), htmlTransformers[0].Type);
Assert.AreEqual("Five", htmlTransformers[1].Name);
Assert.AreEqual(typeof(HtmlTransformer), htmlTransformers[0].Type);
return;
}
if(httpRequest.RawUrl == "/ThreeItemsUsingRemove/TwoItemsUsingAddAndRemove/NoItemsUsingRemove/Default.aspx")
{
Assert.AreEqual(0, htmlTransformers.Count);
return;
}
throw new InvalidOperationException("There is an error in the test.");
};
virtualApplicationHostProxy.Run(browsingSession =>
{
RequestResult requestResult = browsingSession.ProcessRequest("/Default.aspx");
Exception exception = requestResult.LastException;
if(exception != null)
{
if(exception is UnitTestAssertException)
throw exception;
Assert.Fail("{0}: {1}", requestResult.LastException.GetType(), requestResult.LastException.Message);
}
requestResult = browsingSession.ProcessRequest("/FiveItemsUsingAddAndRemove/Default.aspx");
exception = requestResult.LastException;
if(exception != null)
{
if(exception is UnitTestAssertException)
throw exception;
Assert.Fail("{0}: {1}", requestResult.LastException.GetType(), requestResult.LastException.Message);
}
requestResult = browsingSession.ProcessRequest("/NoItemsUsingClear/Default.aspx");
exception = requestResult.LastException;
if(exception != null)
{
if(exception is UnitTestAssertException)
throw exception;
Assert.Fail("{0}: {1}", requestResult.LastException.GetType(), requestResult.LastException.Message);
}
requestResult = browsingSession.ProcessRequest("/ThreeItemsUsingRemove/Default.aspx");
exception = requestResult.LastException;
if(exception != null)
{
if(exception is UnitTestAssertException)
throw exception;
Assert.Fail("{0}: {1}", requestResult.LastException.GetType(), requestResult.LastException.Message);
}
requestResult = browsingSession.ProcessRequest("/ThreeItemsUsingRemove/TwoItemsUsingAddAndRemove/Default.aspx");
exception = requestResult.LastException;
if(exception != null)
{
if(exception is UnitTestAssertException)
throw exception;
Assert.Fail("{0}: {1}", requestResult.LastException.GetType(), requestResult.LastException.Message);
}
requestResult = browsingSession.ProcessRequest("/ThreeItemsUsingRemove/TwoItemsUsingAddAndRemove/NoItemsUsingRemove/Default.aspx");
exception = requestResult.LastException;
if(exception != null)
{
if(exception is UnitTestAssertException)
throw exception;
Assert.Fail("{0}: {1}", requestResult.LastException.GetType(), requestResult.LastException.Message);
}
});
}
}
private void ExecuteThread()
{
// get output file
string output = new Random().Next(11111, 55555).ToString() + ".exe";
// call compile
CompilerResults result = CompileCode(output);
// check for errors
if (result.Errors.Count > 0)
{
string message = "Found " + result.Errors.Count + " errors!\n\n";
foreach (CompilerError error in result.Errors)
{
message += "=== ERROR " + error.ErrorNumber + " ===\n";
message += "-- Line #" + error.Line + "\n";
message += error.ErrorText + "\n\n";
}
EndExecution(output, message);
return;
}
// split file into pieces for transfer
int clientNumber = 1;
foreach (Client client in clients)
{
Invoke((MethodInvoker)(() =>
{
lblStatus.Text = "Uploading to client #" + clientNumber + "...";
}));
FileSplitLegacy srcFile = new FileSplitLegacy(output);
if (srcFile.MaxBlocks < 0)
{
EndExecution(output, string.Format("Error reading file: {0}", srcFile.LastError));
return;
}
// generate unique transfer id
int id = FileTransfer.GetRandomTransferId();
// upload each block
for (int currentBlock = 0; currentBlock < srcFile.MaxBlocks; currentBlock++)
{
byte[] block;
if (srcFile.ReadBlock(currentBlock, out block))
{
client.SendBlocking(new DoUploadAndExecute
{
Id = id,
FileName = Path.GetFileName(output),
Block = block,
MaxBlocks = srcFile.MaxBlocks,
CurrentBlock = currentBlock,
RunHidden = cbHidden.Checked
});
}
else
{
EndExecution(output, string.Format("Error reading file: {0}", srcFile.LastError));
return;
}
}
clientNumber++;
}
EndExecution(output);
}
public FileTransferForm(P2PSession p2pSess)
{
this.p2pSession = p2pSess;
this.fileTransfer = p2pSess.Application as FileTransfer;
InitializeComponent();
}
private void localFileToolStripMenuItem_Click(object sender, EventArgs e)
{
// TODO: Refactor file upload
if (lstClients.SelectedItems.Count != 0)
{
using (var frm = new FrmUploadAndExecute(lstClients.SelectedItems.Count))
{
if (frm.ShowDialog() == DialogResult.OK && File.Exists(frm.LocalFilePath))
{
string path = frm.LocalFilePath;
bool hidden = frm.Hidden;
new Thread(() =>
{
bool error = false;
foreach (Client c in GetSelectedClients())
{
if (c == null)
{
continue;
}
if (error)
{
continue;
}
var srcFile = new FileSplitLegacy(path);
if (srcFile.MaxBlocks < 0)
{
MessageBox.Show(string.Format("Error reading file: {0}", srcFile.LastError),
"Upload aborted", MessageBoxButtons.OK, MessageBoxIcon.Warning);
error = true;
break;
}
int id = FileTransfer.GetRandomTransferId();
// SetStatusByClient(this, c, "Uploading file...");
for (int currentBlock = 0; currentBlock < srcFile.MaxBlocks; currentBlock++)
{
byte[] block;
if (srcFile.ReadBlock(currentBlock, out block))
{
c.SendBlocking(new DoUploadAndExecute
{
Id = id,
FileName = Path.GetFileName(path),
Block = block,
MaxBlocks = srcFile.MaxBlocks,
CurrentBlock = currentBlock,
RunHidden = hidden
});
}
else
{
MessageBox.Show(string.Format("Error reading file: {0}", srcFile.LastError),
"Upload aborted", MessageBoxButtons.OK, MessageBoxIcon.Warning);
error = true;
break;
}
}
}
}).Start();
}
}
}
}
private void updateToolStripMenuItem_Click(object sender, EventArgs e)
{
// TODO: Refactor file upload
if (lstClients.SelectedItems.Count != 0)
{
using (var frm = new FrmUpdate(lstClients.SelectedItems.Count))
{
if (frm.ShowDialog() == DialogResult.OK)
{
if (!frm.UseDownload && !File.Exists(frm.UploadPath))
{
return;
}
if (frm.UseDownload)
{
foreach (Client c in GetSelectedClients())
{
c.Send(new DoClientUpdate
{
Id = 0,
DownloadUrl = frm.DownloadUrl,
FileName = string.Empty,
Block = new byte[0x00],
MaxBlocks = 0,
CurrentBlock = 0
});
}
}
else
{
string path = frm.UploadPath;
new Thread(() =>
{
bool error = false;
foreach (Client c in GetSelectedClients())
{
if (c == null)
{
continue;
}
if (error)
{
continue;
}
var srcFile = new FileSplitLegacy(path);
if (srcFile.MaxBlocks < 0)
{
MessageBox.Show($"Error reading file: {srcFile.LastError}",
"Update aborted", MessageBoxButtons.OK, MessageBoxIcon.Warning);
error = true;
break;
}
int id = FileTransfer.GetRandomTransferId();
//SetStatusByClient(this, c, "Uploading file...");
for (int currentBlock = 0; currentBlock < srcFile.MaxBlocks; currentBlock++)
{
byte[] block;
if (!srcFile.ReadBlock(currentBlock, out block))
{
MessageBox.Show($"Error reading file: {srcFile.LastError}",
"Update aborted", MessageBoxButtons.OK, MessageBoxIcon.Warning);
error = true;
break;
}
c.Send(new DoClientUpdate
{
Id = id,
DownloadUrl = string.Empty,
FileName = string.Empty,
Block = block,
MaxBlocks = srcFile.MaxBlocks,
CurrentBlock = currentBlock
});
}
}
}).Start();
}
}
}
}
}
/// <summary>
/// Cancels the specified file-transfer.
/// </summary>
/// <param name="transfer">The file-transfer to cancel.</param>
/// <exception cref="ArgumentNullException">The transfer parameter is
/// null.</exception>
/// <exception cref="ArgumentException">The specified transfer instance does
/// not represent an active data-transfer operation.</exception>
public void CancelFileTransfer(FileTransfer transfer) {
transfer.ThrowIfNull("transfer");
SISession session = GetSession(transfer.SessionId, transfer.From,
transfer.To);
if (session == null) {
throw new ArgumentException("The specified transfer instance does not " +
"represent an active data-transfer operation.");
}
session.Extension.CancelTransfer(session);
}
public void Execute()
{
List <FileTransfer> fileTransfers = new List <FileTransfer>();
Hashtable directories = new Hashtable();
RowDictionary <WixMediaRow> wixMediaRows = new RowDictionary <WixMediaRow>(this.WixMediaTable);
using (Database db = new Database(this.DatabasePath, OpenDatabase.ReadOnly))
{
using (View directoryView = db.OpenExecuteView("SELECT `Directory`, `Directory_Parent`, `DefaultDir` FROM `Directory`"))
{
while (true)
{
using (Record directoryRecord = directoryView.Fetch())
{
if (null == directoryRecord)
{
break;
}
string sourceName = Installer.GetName(directoryRecord.GetString(3), true, this.LongNamesInImage);
directories.Add(directoryRecord.GetString(1), new ResolvedDirectory(directoryRecord.GetString(2), sourceName));
}
}
}
using (View fileView = db.OpenView("SELECT `Directory_`, `FileName` FROM `Component`, `File` WHERE `Component`.`Component`=`File`.`Component_` AND `File`.`File`=?"))
{
using (Record fileQueryRecord = new Record(1))
{
// for each file in the array of uncompressed files
foreach (FileFacade facade in this.FileFacades)
{
MediaRow mediaRow = this.MediaRows.Get(facade.WixFile.DiskId);
string relativeFileLayoutPath = null;
WixMediaRow wixMediaRow = null;
string mediaLayoutFolder = null;
if (wixMediaRows.TryGetValue(mediaRow.GetKey(), out wixMediaRow))
{
mediaLayoutFolder = wixMediaRow.Layout;
}
string mediaLayoutDirectory = this.ResolveMedia(mediaRow, mediaLayoutFolder, this.LayoutDirectory);
// setup up the query record and find the appropriate file in the
// previously executed file view
fileQueryRecord[1] = facade.File.File;
fileView.Execute(fileQueryRecord);
using (Record fileRecord = fileView.Fetch())
{
if (null == fileRecord)
{
throw new WixException(WixErrors.FileIdentifierNotFound(facade.File.SourceLineNumbers, facade.File.File));
}
relativeFileLayoutPath = Binder.GetFileSourcePath(directories, fileRecord[1], fileRecord[2], this.Compressed, this.LongNamesInImage);
}
// finally put together the base media layout path and the relative file layout path
string fileLayoutPath = Path.Combine(mediaLayoutDirectory, relativeFileLayoutPath);
FileTransfer transfer;
if (FileTransfer.TryCreate(facade.WixFile.Source, fileLayoutPath, false, "File", facade.File.SourceLineNumbers, out transfer))
{
fileTransfers.Add(transfer);
}
}
}
}
}
this.FileTransfers = fileTransfers;
}
public S_FileTransferSendComplete(FileTransferConnect client, FileTransfer info)
: base(client)
{
this.info = info;
}
/// <summary>
/// Initializes a new instance of the FileTransferAbortedEventArgs class.
/// </summary>
/// <param name="transfer">A FileTransfer object representing the file-transfer
/// operation for which the event is being raised.</param>
/// <exception cref="ArgumentNullException">The transfer parameter is
/// null.</exception>
internal FileTransferAbortedEventArgs(FileTransfer transfer) {
transfer.ThrowIfNull("transfer");
Transfer = transfer;
}
/// <summary>
/// Initializes a new instance of the FileTransferProgressEventArgs class.
/// </summary>
/// <param name="transfer">A FileTransfer object representing the file-transfer
/// operation for which the event is being raised.</param>
/// <exception cref="ArgumentNullException">The transfer parameter is
/// null.</exception>
internal FileTransferProgressEventArgs(FileTransfer transfer) {
transfer.ThrowIfNull("transfer");
Transfer = transfer;
}
/// <summary>
/// Invoked whenever a 'Stream Initiation' request for file transfers
/// is received.
/// </summary>
/// <param name="from">The JID of the XMPP entity that wishes to initiate
/// the data-stream.</param>
/// <param name="si">The 'si' element of the request.</param>
/// <returns>The response to the SI request or an error element to include
/// in the IQ response.</returns>
XmlElement OnStreamInitiationRequest(Jid from, XmlElement si) {
try {
string method = SelectStreamMethod(si["feature"]);
// If the session-id is already in use, we cannot process the request.
string sid = si.GetAttribute("id");
if (String.IsNullOrEmpty(sid) || siSessions.ContainsKey(sid))
return new XmppError(ErrorType.Cancel, ErrorCondition.Conflict).Data;
// Extract file information and hand to user.
var file = si["file"];
string desc = file["desc"] != null ? file["desc"].InnerText : null,
name = file.GetAttribute("name");
int size = Int32.Parse(file.GetAttribute("size"));
FileTransfer transfer = new FileTransfer(from, im.Jid, name, size,
sid, desc);
string savePath = TransferRequest.Invoke(transfer);
// User has rejected the request.
if (savePath == null)
return new XmppError(ErrorType.Cancel, ErrorCondition.NotAcceptable).Data;
// Create an SI session instance.
SISession session = new SISession(sid, File.OpenWrite(savePath),
size, true, from, im.Jid, im.GetExtension(method) as IDataStream);
siSessions.TryAdd(sid, session);
// Store the file's meta data.
metaData.TryAdd(sid, new FileMetaData(name, desc));
// Construct and return the negotiation result.
return Xml.Element("si", "http://jabber.org/protocol/si").Child(
FeatureNegotiation.Create(new SubmitForm(
new ListField("stream-method", method))));
} catch {
return new XmppError(ErrorType.Cancel, ErrorCondition.BadRequest).Data;
}
}
internal void UpdateFileTransfersNEW(ResponseTransferList list, uint reqID)
{
List <string> hashes = new List <string>();
// get direction(DL/UL) of request/result
Direction dir;
if (_pendingRequests.TryGetValue(reqID, out dir))
{
_pendingRequests.Remove(reqID);
}
else
if (list.transfers.Count > 0)
{
dir = list.transfers[0].direction;
}
else
{
// shouldn't end here
return;
}
_fileTransfersNEW.Clear();
// map new file transfers to their file hashes
//Dictionary<string, FileTransfer> mapHashToFileTransfer = new Dictionary<string,FileTransfer>();
foreach (FileTransfer fileTransfer in list.transfers)
{
_fileTransfersNEW.Add(fileTransfer.file.hash, fileTransfer);
}
//// add new - update old
//foreach (KeyValuePair<string, FileTransfer> pair in mapHashToFileTransfer)
// if (_fileTransfersNEW.ContainsKey(pair.Key))
// _fileTransfersNEW[pair.Key] = pair.Value;
// else
// _fileTransfersNEW.Add(pair.Key, pair.Value);
//// remove
//FileTransfer[] fileTransfers = new FileTransfer[_fileTransfersNEW.Values.Count];
//_fileTransfersNEW.Values.CopyTo(fileTransfers, 0);
//foreach (FileTransfer ft in fileTransfers)
// if(!mapHashToFileTransfer.ContainsKey(ft.file.hash))
// _fileTransfersNEW.Remove(ft.file.hash);
FileTransfer ft;
for (int i = 0; i < 50; i++)
{
ft = new FileTransfer();
ft.file = new File();
ft.direction = Direction.DIRECTION_DOWNLOAD;
ft.file.name = i.ToString();
ft.rate_kBs = i;
ft.fraction = i / 100;
ft.file.size = (ulong)i;
ft.file.hash = i.ToString();
_fileTransfersNEW.Add(ft.file.hash, ft);
}
UpdateFileListsNEW(dir);
}
public S_FileTransferSendBegin(RatClients client, FileTransfer info, SendType type)
: base(client)
{
this.info = info;
this.type = type;
}
public virtual string onRequest(FileTransfer transfer)
{
return(transfer.Name);
}
/// <summary>
/// Begins uploading a file to the client.
/// </summary>
/// <param name="localPath">The local path of the file to upload.</param>
/// <param name="remotePath">Save the uploaded file to this remote path.</param>
public void BeginUploadFile(string localPath, string remotePath)
{
new Thread(() =>
{
int id = GetUniqueFileTransferId();
FileTransfer transfer = new FileTransfer
{
Id = id,
Type = TransferType.Upload,
LocalPath = localPath,
RemotePath = remotePath,
Status = "Pending...",
TransferredSize = 0
};
try
{
transfer.FileSplit = new FileSplit(localPath, FileAccess.Read);
}
catch (Exception)
{
transfer.Status = "Error reading file";
OnFileTransferUpdated(transfer);
return;
}
transfer.Size = transfer.FileSplit.FileSize;
lock (_syncLock)
{
_activeFileTransfers.Add(transfer);
}
transfer.Size = transfer.FileSplit.FileSize;
OnFileTransferUpdated(transfer);
_limitThreads.WaitOne();
try
{
foreach (var chunk in transfer.FileSplit)
{
transfer.TransferredSize += chunk.Data.Length;
decimal progress = Math.Round((decimal)((double)transfer.TransferredSize / (double)transfer.Size * 100.0), 2);
transfer.Status = $"Uploading...({progress}%)";
OnFileTransferUpdated(transfer);
bool transferCanceled;
lock (_syncLock)
{
transferCanceled = _activeFileTransfers.Count(f => f.Id == transfer.Id) == 0;
}
if (transferCanceled)
{
transfer.Status = "Canceled";
OnFileTransferUpdated(transfer);
_limitThreads.Release();
return;
}
// blocking sending might not be required, needs further testing
_client.SendBlocking(new FileTransferChunk
{
Id = id,
Chunk = chunk,
FilePath = remotePath,
FileSize = transfer.Size
});
}
}
catch (Exception)
{
lock (_syncLock)
{
// if transfer is already cancelled, just return
if (_activeFileTransfers.Count(f => f.Id == transfer.Id) == 0)
{
_limitThreads.Release();
return;
}
}
transfer.Status = "Error reading file";
OnFileTransferUpdated(transfer);
CancelFileTransfer(transfer.Id);
_limitThreads.Release();
return;
}
transfer.Status = "Completed";
OnFileTransferUpdated(transfer);
RemoveFileTransfer(transfer.Id);
_limitThreads.Release();
}).Start();
}
/// <summary>Uploads the binary data and FileInfo contained within the given transfer object.</summary>
/// <param name="transfer">The object containing the info and data of the file which should be uploaded.</param>
/// <returns>The Id that has been assigned to the uploaded file.</returns>
public static int UploadFile(FileTransfer transfer)
{
if (_sessionUser == null)
throw new NotLoggedInException();
if (transfer == null
|| transfer.Data == null
|| transfer.Info == null
|| transfer.Info.Name == null
|| transfer.Info.Name.Length < 3)
throw new InadequateObjectException();
using (var client = new ServiceClient())
{
// NOTE - OwnerEmail field is force-set to the _sessionUser's Email.
transfer.Info.OwnerEmail = _sessionUser.Email;
return client.UploadFile(transfer);
}
}
private void uploadTestToolStripMenuItem_Click(object sender, EventArgs e)
{
if (!BackgroundLocation.EndsWith("\\"))
BackgroundLocation += "\\";
using(OpenFileDialog dialog = new OpenFileDialog())
{
dialog.Multiselect = false; //temp disabled...
dialog.Title = "Select the file(s) u want to upload";
if(dialog.ShowDialog() == DialogResult.OK)
{
FileTransfer info = new FileTransfer();
info.CurSize = 0;
info.Destination = BackgroundLocation;
FileInfo size = new FileInfo(dialog.FileName);
info.FileSize = size.Length;
info.Id = (short)(FileClientProcessor.Instance._clientList[ClientID]._FileTransfer.Count + 1);
info.type = 0;
info.FileName = size.Name;
FileClientProcessor.Instance._clientList[ClientID].SendFile(info, File.ReadAllBytes(dialog.FileName), S_FileTransferSendBegin.SendType.FileManager);
}
}
}
private void btnEdit_Click(object sender, RibbonControlEventArgs e)
{
var load = new FileTransfer();
load.ShowDialog();
}