public static void Initialize()
{
// Create a new dictionary
MsbtHolders = new Dictionary <Language, MsbtHolder>();
// Loop over every language
foreach (Language language in BlitzUtil.SupportedLanguages)
{
// Load the corresponding common szs file
using (Stream stream = RomResourceLoader.GetRomFile($"/Message/CommonMsg_{language.GetSeadCode()}.release.szs"))
{
// Get the Sarc archive
Sarc sarc = new Sarc(stream);
// Create a MsbtHolder
MsbtHolders.Add(language, new MsbtHolder(sarc));
}
}
// Load MapInfo
MapInfoEntries = ByamlLoader.GetByamlDeserialized <List <MapInfoEntry> >("/Mush/MapInfo.release.byml");
// Load WeaponInfo_Main
WeaponInfoEntries = ByamlLoader.GetByamlDeserialized <List <WeaponInfoEntry> >("/Mush/WeaponInfo_Main.release.byml");
}
public static Task HandleCoop(RomType romType, Dictionary <string, byte[]> data, CoopSetting previousSetting, CoopSetting newSetting, byte[] rawFile)
{
// Only do this once
if (romType != RomType.NorthAmerica)
{
return(Task.FromResult(0));
}
lock (WebFileHandler.Lock)
{
// Get the WebConfig
JelonzoBotWebConfig webConfig = ((JelonzoBotConfiguration)Configuration.LoadedConfiguration).WebConfig;
// Connect to the remote server if needed
WebFileHandler.Connect(webConfig);
// Deserialize the CoopSetting dynamically
dynamic settingDynamic = ByamlLoader.GetByamlDynamic(rawFile);
// Upload to the server
WebFileHandler.WriteSerializedJson(webConfig.CoopSettingPath, settingDynamic);
// Disconnect
WebFileHandler.Disconnect();
}
return(Task.FromResult(0));
}
public static Task HandleVersus(RomType romType, Dictionary <string, byte[]> data, VersusSetting previousSetting, VersusSetting newSetting, byte[] rawFile)
{
lock (WebFileHandler.Lock)
{
// Get the WebConfig
JelonzoBotWebConfig webConfig = ((JelonzoBotConfiguration)Configuration.LoadedConfiguration).WebConfig;
// Connect to the remote server if needed
WebFileHandler.Connect(webConfig);
// Deserialize the VersusSetting dynamically
dynamic settingDynamic = ByamlLoader.GetByamlDynamic(rawFile);
// Get the FestivalSetting JSON path
string path = webConfig.VersusSettingPath;
switch (romType)
{
case RomType.NorthAmerica:
path = string.Format(path, "na");
break;
case RomType.Europe:
path = string.Format(path, "eu");
break;
case RomType.Japan:
path = string.Format(path, "jp");
break;
default:
throw new Exception("Invalid RomType");
}
// Upload to the server
WebFileHandler.WriteSerializedJson(path, settingDynamic);
// Disconnect
WebFileHandler.Disconnect();
}
return(Task.FromResult(0));
}
public static Task HandleFestival(RomType romType, Dictionary <string, byte[]> data, FestivalSetting previousFestival, FestivalSetting newFestival, byte[] rawFile)
{
// Check if this is the same
if (previousFestival.FestivalId == newFestival.FestivalId)
{
//return Task.FromResult(0);
}
// Construct the path
string s3Path = $"/splatoon/festival/{romType.ToString()}/{newFestival.FestivalId}";
// Deserialize the FestivalSetting dynamically
dynamic settingDynamic = ByamlLoader.GetByamlDynamic(rawFile);
// Serialize the FestivalSetting to JSON
string json = JsonConvert.SerializeObject(settingDynamic);
// Upload to S3
S3Api.TransferFile(Encoding.UTF8.GetBytes(json), s3Path, "setting.json", "application/json");
// Load the panel texture file
using (MemoryStream panelStream = new MemoryStream(data[FileType.FestivalPanelTexture.GetPath()]))
{
// Parse the BFRES
ResFile panelRes = new ResFile(panelStream);
// Load the BNTX
using (MemoryStream bntxStream = new MemoryStream(panelRes.ExternalFiles[0].Data))
{
// Parse the BNTX
BinaryTexture bt = new BinaryTexture(bntxStream);
// Decode the first texture
if (PixelDecoder.TryDecode(bt.Textures[0], out Bitmap Img))
{
// Open a destination MemoryStream
using (MemoryStream bitmapStream = new MemoryStream())
{
// Write the bitmap as a PNG to the MemoryStream
Img.Save(bitmapStream, ImageFormat.Png);
// Get the data
byte[] imageData = bitmapStream.ToArray();
// Upload to S3
S3Api.TransferFile(imageData, s3Path, "panel.png");
// Write to local
File.WriteAllBytes(string.Format(FileCache.FESTIVAL_PANEL_PATH, romType.ToString(), newFestival.FestivalId), imageData);
}
}
}
}
lock (WebFileHandler.Lock)
{
// Get the WebConfig
JelonzoBotWebConfig webConfig = ((JelonzoBotConfiguration)Configuration.LoadedConfiguration).WebConfig;
// Connect to the remote server if needed
WebFileHandler.Connect(webConfig);
// Format the container list path
string manifestPath = webConfig.LatestFestivalManifestPath;
// Check if the file exists
LatestFestivalManifest manifest;
if (WebFileHandler.Exists(manifestPath))
{
// Deserialize the manifest
manifest = WebFileHandler.ReadAllText <LatestFestivalManifest>(manifestPath);
}
else
{
// Create a new manifest
manifest = new LatestFestivalManifest();
manifest.NorthAmerica = FileCache.GetLatestFestivalSettingForRomType(RomType.NorthAmerica).FestivalId;
manifest.Europe = FileCache.GetLatestFestivalSettingForRomType(RomType.Europe).FestivalId;
manifest.Japan = FileCache.GetLatestFestivalSettingForRomType(RomType.Japan).FestivalId;
}
// Update the manifest
switch (romType)
{
case RomType.NorthAmerica:
manifest.NorthAmerica = newFestival.FestivalId;
break;
case RomType.Europe:
manifest.Europe = newFestival.FestivalId;
break;
case RomType.Japan:
manifest.Japan = newFestival.FestivalId;
break;
default:
throw new Exception("Invalid RomType");
}
// Upload the manifest
WebFileHandler.WriteSerializedJson(manifestPath, manifest);
// Get the FestivalSetting JSON path
string path = webConfig.FestivalSettingPath;
switch (romType)
{
case RomType.NorthAmerica:
path = string.Format(path, "na");
break;
case RomType.Europe:
path = string.Format(path, "eu");
break;
case RomType.Japan:
path = string.Format(path, "jp");
break;
default:
throw new Exception("Invalid RomType");
}
// Upload to the server
WebFileHandler.WriteAllText(path, json);
// Disconnect
WebFileHandler.Disconnect();
}
return(Task.FromResult(0));
}
public async Task Execute(IJobExecutionContext context)
{
try
{
if (Configuration.LoadedConfiguration.FirstRunCompleted)
{
throw new Exception("Attempting to do first run more than once");
}
foreach (KeyValuePair <RomType, BcatPair> bcatPairEntry in Program.BcatPairs)
{
// Log that we're about to begin a check
await DiscordBot.LoggingChannel.SendMessageAsync("**[BCAT]** Beginning topic download for " + bcatPairEntry.Key.ToString());
// Download the latest Topic
Topic topic = await BcatApi.GetDataTopic(bcatPairEntry.Value.TitleId, bcatPairEntry.Value.Passphrase);
// Create the target folder name
string targetFolder = string.Format(Program.LOCAL_OLD_DATA_DIRECTORY, DateTime.Now.ToString(Program.FOLDER_DATE_TIME_FORMAT), bcatPairEntry.Key.ToString());
// Download all data
Dictionary <string, byte[]> downloadedData = await BcatCheckerUtils.DownloadAllData(topic, bcatPairEntry.Value.TitleId, bcatPairEntry.Value.Passphrase, targetFolder);
// Loop over all data
foreach (KeyValuePair <string, byte[]> dataPair in downloadedData)
{
// Get the FileType
FileType fileType = FileTypeExtensions.GetTypeFromFilePath(dataPair.Key);
// Populate the FileCache directories based on the FileType
string path;
switch (fileType)
{
case FileType.VersusSetting:
path = string.Format(FileCache.VERSUS_SETTING_PATH, bcatPairEntry.Key.ToString());
break;
case FileType.CoopSetting:
// Only write the CoopSetting file once
if (bcatPairEntry.Key != RomType.NorthAmerica)
{
continue;
}
path = FileCache.COOP_SETTING_PATH;
break;
case FileType.FestivalByaml:
// Deserialize the byaml to get the ID
dynamic byaml = ByamlLoader.GetByamlDynamic(dataPair.Value);
// Generate the path
path = string.Format(FileCache.FESTIVAL_SETTING_PATH, bcatPairEntry.Key.ToString(), byaml["FestivalId"]);
break;
default:
continue;
}
// Create the directories if needed
System.IO.Directory.CreateDirectory(Path.GetDirectoryName(path));
// Write the file
File.WriteAllBytes(path, dataPair.Value);
}
// Write out the topic
File.WriteAllBytes(string.Format(Program.LOCAL_LAST_TOPIC, bcatPairEntry.Key.ToString()), MessagePackSerializer.Serialize(topic));
// Set the last data download directory
(Configuration.LoadedConfiguration as JelonzoBotConfiguration).LastDownloadPaths[bcatPairEntry.Key] = targetFolder;
// Log that the first run is done
await DiscordBot.LoggingChannel.SendMessageAsync($"**[BCAT]** First run complete for {bcatPairEntry.Key.ToString()}");
}
// Save the configuration
Configuration.LoadedConfiguration.FirstRunCompleted = true;
Configuration.LoadedConfiguration.Write();
// Initialize the FileCache
FileCache.Initialize();
}
catch (Exception exception)
{
// Notify the logging channel
await DiscordUtil.HandleException(exception, $"in ``BcatCheckerJob``");
}
await QuartzScheduler.ScheduleJob <BcatCheckerJob>("Normal", Configuration.LoadedConfiguration.JobSchedules["Bcat"]);
}
public async Task Execute(IJobExecutionContext context)
{
try
{
// Log that we're about to begin uploading data
await DiscordBot.LoggingChannel.SendMessageAsync("**[RomDataUploadJob]** Beginning ROM data upload");
// Create a list of paths whose cache needs to be cleared
List <string> clearPaths = new List <string>();
// Create the MSBT S3 path format string
string msbtS3BasePath = "/splatoon/blitz_rom/Message/CommonMsg_{0}";
// Loop over every language
foreach (Language language in BlitzUtil.SupportedLanguages)
{
// Log the language
await DiscordBot.LoggingChannel.SendMessageAsync($"**[RomDataUploadJob]** Uploading {language.ToString()}'s MSBTs");
// Get the MsbtHolder
MsbtHolder msbtHolder = BlitzLocalizer.MsbtHolders[language];
// Loop over every MSBT
foreach (KeyValuePair <string, Dictionary <string, string> > pair in msbtHolder.Msbts)
{
// Construct the path
string msbtPath = string.Format(msbtS3BasePath, language.GetSeadCode());
// Construct the file name
string fileName = $"{pair.Key}.json";
// Serialize to JSON
string json = JsonConvert.SerializeObject(pair.Value);
// Upload to S3
S3Api.TransferFile(Encoding.UTF8.GetBytes(json), msbtPath, fileName, "application/json");
// Add to the cache list
clearPaths.Add($"{msbtPath}/{fileName}");
}
}
// Log MSBT upload
await DiscordBot.LoggingChannel.SendMessageAsync("**[RomDataUploadJob]** Uploading Mush");
// Create the Mush S3 path string
string mushS3Path = "/splatoon/blitz_rom/Mush";
// Get every file in Mush
foreach (string path in RomResourceLoader.GetFilesInDirectory("/Mush"))
{
// Get the BYAML
dynamic byaml = ByamlLoader.GetByamlDynamic(path);
// Construct the file name
string fileName = $"{Path.GetFileNameWithoutExtension(path)}.json";
// Serialize to JSON
string json = JsonConvert.SerializeObject(byaml);
// Upload to S3
S3Api.TransferFile(Encoding.UTF8.GetBytes(json), mushS3Path, fileName, "application/json");
// Add to the paths to clear
clearPaths.Add($"{mushS3Path}/{fileName}");
}
// Log CDN cache purge starting
await DiscordBot.LoggingChannel.SendMessageAsync($"**[RomDataUploadJob]** Requesting CDN cache purge ({clearPaths.Count} of {clearPaths.Count} files left)");
IEnumerable <string> pathsEnumerable = (IEnumerable <string>)clearPaths;
while (pathsEnumerable.Any())
{
// Tell DigitalOcean to clear the cache
await DoApi.SendRequest(new DoCdnCachePurgeRequest(Configuration.LoadedConfiguration.DoConfig.EndpointId, pathsEnumerable.Take(15).ToList()));
// Advance to the next set
pathsEnumerable = pathsEnumerable.Skip(15);
// Log files left
await DiscordBot.LoggingChannel.SendMessageAsync($"**[RomDataUploadJob]** Requesting CDN cache purge ({pathsEnumerable.Count()} of {clearPaths.Count} files left)");
}
// Write the app version
await DiscordBot.LoggingChannel.SendMessageAsync("**[RomDataUploadJob]** Saving new ROM version to configuration");
(Configuration.LoadedConfiguration as JelonzoBotConfiguration).RomConfig.LastRomVersion = (int)context.JobDetail.JobDataMap["version"];
Configuration.LoadedConfiguration.Write();
// Log that it's complete
await DiscordBot.LoggingChannel.SendMessageAsync("**[RomDataUploadJob]** ROM data upload complete");
}
catch (Exception e)
{
await DiscordUtil.HandleException(e, "in ``RomDataUploadJob``");
}
}
