public static TaskHubWorkerSettings CreateTestWorkerSettings(CompressionStyle style = CompressionStyle.Threshold)
{
var settings = new TaskHubWorkerSettings();
settings.TaskOrchestrationDispatcherSettings.CompressOrchestrationState = true;
settings.MessageCompressionSettings = new CompressionSettings {Style = style, ThresholdInBytes = 1024};
return settings;
}
/// <summary>
/// Reads from a stream.
/// </summary>
public void Read(Stream stream)
{
byte[] buffer = new byte[RevisionSize];
stream.Read(buffer, 0, RevisionSize);
revisionSize = BitConverter.ToInt16(buffer, 0x0);
if (revisionSize != RevisionSize)
{
stream.Position -= RevisionSize;
buffer = new byte[revisionSize];
stream.Read(buffer, 0, revisionSize);
}
compression = (CompressionStyle)BitConverter.ToInt16(buffer, 0x2);
version = BitConverter.ToSingle(buffer, 0x4);
date = BitConverter.ToInt64(buffer, 0x8);
reserved_a = BitConverter.ToInt32(buffer, 0x10);
reserved_b = BitConverter.ToInt32(buffer, 0x14);
reserved_c = BitConverter.ToInt32(buffer, 0x18);
authorLength = BitConverter.ToInt16(buffer, 0x1c);
infoLength = BitConverter.ToInt16(buffer, 0x1e);
authorOffset = BitConverter.ToInt32(buffer, 0x20);
infoOffset = BitConverter.ToInt32(buffer, 0x24);
dataLength = BitConverter.ToInt32(buffer, 0x28);
dataOffset = BitConverter.ToInt32(buffer, 0x2c);
}
/// <summary>
/// Adds a new revision to this attachment.
/// </summary>
public virtual void AddRevision(CompressionStyle compression, byte[] data, float version)
{
int r = revisions.Count;
revisions.Add(new ObjectRevision());
revisions[r].Date = DateTime.Now;
revisions[r].Version = version;
revisions[r].CompressionStyle = compression;
if (compression == CompressionStyle.Store)
{
datas.Add(data);
}
else if (compression == CompressionStyle.GZip)
{
MemoryStream compressionStream = new MemoryStream();
GZipStream gz = new GZipStream(compressionStream, CompressionMode.Compress, true);
gz.Write(data, 0, data.Length);
gz.Close();
datas.Add(compressionStream.ToArray());
compressionStream.Close();
}
else
{
throw new Exception(compression + " is not valid for a tag attachment.");
}
revisions[r].DataLength = data.Length;
headRevision = r;
revisionCount = r + 1;
}
/// <summary>
/// Sets the parser back to the beginning of the file.
/// </summary>
public void Reset()
{
m_compressionAlgorithm = CompressionAlgorithm.None;
m_compressionStyle = CompressionStyle.None;
m_fileReader.BaseStream.Seek(0, SeekOrigin.Begin);
m_hasNextRecord = true;
m_headerAddresses.Clear();
m_exceptionList.Clear();
}
public static TaskHubWorkerSettings CreateTestWorkerSettings(CompressionStyle style = CompressionStyle.Threshold)
{
var settings = new TaskHubWorkerSettings();
settings.TaskOrchestrationDispatcherSettings.CompressOrchestrationState = true;
settings.MessageCompressionSettings = new CompressionSettings {
Style = style, ThresholdInBytes = 1024
};
return(settings);
}
public void InjectFile(Stream generatedFile, string relativePath, CompressionStyle compressionStyle)
{
if (Injector0 != null)
{
Injector0.InjectFile(generatedFile, relativePath, compressionStyle);
}
if (Injector2 != null)
{
Injector2.InjectFile(generatedFile, relativePath, compressionStyle);
}
}
private TaskHubWorkerSettings getDefaultHubWorkerSettings(CompressionStyle style = CompressionStyle.Threshold)
{
var settings = new TaskHubWorkerSettings();
settings.TaskOrchestrationDispatcherSettings.CompressOrchestrationState = true;
settings.MessageCompressionSettings = new CompressionSettings {
Style = style, ThresholdInBytes = 1024
};
// TODO? :
//if (m_Services != null)
// settings.Services = m_Services;
return(settings);
}
public void InjectFile(Stream generatedFile, string relativePath, CompressionStyle compressionStyle)
{
if (DisableInjection)
{
return;
}
// logic for injection into main cpk
int idx = Cpk.GetChildIndexFromName(relativePath).Value;
var fsize = Cpk.QueryChildInfoByIndex(idx, "FileSize");
var esize = Cpk.QueryChildInfoByIndex(idx, "ExtractSize");
var foffs = Cpk.QueryChildInfoByIndex(idx, "FileOffset");
// maybe compress
OutputStream.Position = fsize.data_position;
uint oldfsize = OutputStream.ReadUInt32(EndianUtils.Endianness.BigEndian);
OutputStream.Position = esize.data_position;
uint oldesize = OutputStream.ReadUInt32(EndianUtils.Endianness.BigEndian);
Stream maybeCompressedFile = MaybeCompress(generatedFile, oldfsize, oldesize, compressionStyle, relativePath);
// inject data
maybeCompressedFile.Position = 0;
uint newFilesize = (uint)maybeCompressedFile.Length;
uint newExtractsize = (uint)generatedFile.Length;
long newFileoffs = CurrentInjectionOffset;
OutputStream.Position = newFileoffs;
StreamUtils.CopyStream(maybeCompressedFile, OutputStream, maybeCompressedFile.Length);
// update header
CurrentInjectionOffset = OutputStream.Position;
OutputStream.Position = fsize.data_position;
OutputStream.WriteUInt32(newFilesize.ToEndian(EndianUtils.Endianness.BigEndian));
OutputStream.Position = esize.data_position;
OutputStream.WriteUInt32(newExtractsize.ToEndian(EndianUtils.Endianness.BigEndian));
OutputStream.Position = foffs.data_position;
OutputStream.WriteUInt64(((ulong)(newFileoffs - Math.Min(Cpk.content_offset, Cpk.toc_offset))).ToEndian(EndianUtils.Endianness.BigEndian));
EnsureAligned();
}
public static ServiceBusOrchestrationServiceSettings CreateTestWorkerSettings(CompressionStyle style = CompressionStyle.Threshold)
{
var settings = new ServiceBusOrchestrationServiceSettings
{
TaskOrchestrationDispatcherSettings = { CompressOrchestrationState = true },
MessageCompressionSettings = new CompressionSettings {
Style = style, ThresholdInBytes = 1024
},
JumpStartSettings = { JumpStartEnabled = true, IgnoreWindow = TimeSpan.FromSeconds(10) }
};
return(settings);
}
/// <summary>
/// Sets the parser back to the beginning of the file.
/// </summary>
public void Reset()
{
m_compressionAlgorithm = CompressionAlgorithm.None;
m_compressionStyle = CompressionStyle.None;
m_fileReader.BaseStream.Seek(0, SeekOrigin.Begin);
m_hasNextRecord = true;
m_headerAddresses.Clear();
m_exceptionList.Clear();
}
private static bool ShouldCompress(Stream generatedFile, uint oldfsize, uint oldesize, CompressionStyle compressionStyle, string filename)
{
if (generatedFile.Length <= 0x100)
{
return(false);
}
switch (compressionStyle)
{
case CompressionStyle.NeverCompress:
return(false);
case CompressionStyle.AlwaysCompress:
return(true);
case CompressionStyle.CompressIfOriginallyCompressed:
return(oldfsize != oldesize);
case CompressionStyle.CompressIfOriginallyCompressedPlus:
return(oldfsize != oldesize ||
(filename.StartsWith("movie/str/ja/TOG_") && filename.EndsWith(".bin")) ||
(filename.StartsWith("chat/scs/JA/CHT_") && filename.EndsWith(".scs")));
default:
return(false);
}
}
private static Stream MaybeCompress(Stream generatedFile, uint oldfsize, uint oldesize, CompressionStyle compressionStyle, string filename)
{
if (!ShouldCompress(generatedFile, oldfsize, oldesize, compressionStyle, filename))
{
Console.WriteLine("Injecting {0} uncompressed...", filename);
return(generatedFile);
}
try {
Console.WriteLine("Injecting {0} compressed...", filename);
MemoryStream ms = new MemoryStream();
utf_tab_sharp.CpkCompress.compress(generatedFile, 0, generatedFile.Length, ms);
if (generatedFile.Length <= ms.Length)
{
Console.WriteLine("Compression didn't reduce size, using uncompressed instead...", filename);
return(generatedFile);
}
return(ms);
} catch (Exception ex) {
Console.WriteLine("Error while compressing, injecting uncompressed instead: " + ex.ToString());
return(generatedFile);
}
}
public void InjectFileSubcpk(Stream generatedFile, string subcpkPath, string relativePath, CompressionStyle compressionStyle)
{
if (DisableInjection)
{
return;
}
// logic for injection into subcpk
SubcpkData data = GetOrCreateSubcpkData(subcpkPath);
var filedata = data.Files.Where(x => x.name == relativePath).First();
// maybe compress
OutputStream.Position = filedata.fsizepos;
uint oldfsize = OutputStream.ReadUInt32(EndianUtils.Endianness.BigEndian);
OutputStream.Position = filedata.esizepos;
uint oldesize = OutputStream.ReadUInt32(EndianUtils.Endianness.BigEndian);
Stream maybeCompressedFile = MaybeCompress(generatedFile, oldfsize, oldesize, compressionStyle, subcpkPath + "/" + relativePath);
// copy file into output stream
maybeCompressedFile.Position = 0;
uint newFilesize = (uint)maybeCompressedFile.Length;
uint newExtractsize = (uint)generatedFile.Length;
long newFileoffs = CurrentInjectionOffset;
OutputStream.Position = newFileoffs;
StreamUtils.CopyStream(maybeCompressedFile, OutputStream, maybeCompressedFile.Length);
EnsureAligned();
// fix sizes and offset
OutputStream.Position = filedata.fsizepos;
OutputStream.WriteUInt32(newFilesize.ToEndian(EndianUtils.Endianness.BigEndian));
OutputStream.Position = filedata.esizepos;
OutputStream.WriteUInt32(newExtractsize.ToEndian(EndianUtils.Endianness.BigEndian));
OutputStream.Position = filedata.foffspos;
OutputStream.WriteUInt64(((ulong)(newFileoffs - (data.SubcpkOffset + data.ContentTocOffset))).ToEndian(EndianUtils.Endianness.BigEndian));
OutputStream.Position = CurrentInjectionOffset;
}
public virtual void AddAttachmentRevision(string attachmentName, byte[] data, float version, CompressionStyle compression)
{
foreach (Attachment attachment in attachments)
{
if (attachment.Name == attachmentName)
{
attachment.AddRevision(compression, data, version);
break;
}
}
}
/// <summary>
/// Adds a new revision to the collection of revisions in this tag.
/// </summary>
/// <param name="author">author of the revision</param>
/// <param name="description">information about what is changed or added or removed</param>
/// <param name="binary">the new binary blob</param>
/// <param name="compStyle">compression mode to use</param>
/// <param name="version">a numeric floating-point version to associate with this revision</param>
public virtual void AddRevision(string author, string description, byte[] binary, CompressionStyle compStyle, float version)
{
int r = revisions.Count;
revisions.Add(new ObjectRevision());
revisions[r].Date = DateTime.Now;
revisions[r].Version = version;
revisions[r].CompressionStyle = compStyle;
authors.Add(author);
revisions[r].AuthorLength = (short)author.Length;
informations.Add(description);
revisions[r].InfoLength = (short)description.Length;
binaryBlobs.Add(binary);
revisions[r].DataLength = binary.Length;
headRevision = r;
}
