public static async Task <ClientVersionInfo> GetTargetVersionInfo(string branch, string targetVersion, string fastGuid = "")
{
var logData = await StudioDeployLogs.Get(branch);
HashSet <DeployLog> targets;
if (Environment.Is64BitOperatingSystem)
{
targets = logData.CurrentLogs_x64;
}
else
{
targets = logData.CurrentLogs_x86;
}
DeployLog target = targets
.Where(log => log.VersionId == targetVersion)
.FirstOrDefault();
if (target == null)
{
Program.SetValue("TargetVersion", "");
return(await GetCurrentVersionInfo(branch, fastGuid));
}
return(new ClientVersionInfo()
{
Guid = target.VersionGuid,
Version = target.VersionId
});
}
private async void branchSelect_SelectedIndexChanged(object sender, EventArgs e)
{
// Save the user's branch preference.
string branch = getSelectedBranch();
Program.SetValue("BuildBranch", branch);
// Grab the version currently being targetted.
string targetId = Program.GetString("TargetVersion");
// Clear the current list of target items.
targetVersion.Items.Clear();
targetVersion.Items.Add("(Use Latest)");
// Populate the items list using the deploy history.
Enabled = false;
UseWaitCursor = true;
var getDeployLogs = StudioDeployLogs.Get(branch);
var deployLogs = await getDeployLogs.ConfigureAwait(true);
Enabled = true;
UseWaitCursor = false;
HashSet <DeployLog> targets;
if (Environment.Is64BitOperatingSystem)
{
targets = deployLogs.CurrentLogs_x64;
}
else
{
targets = deployLogs.CurrentLogs_x86;
}
var items = targets
.OrderByDescending(log => log.Changelist)
.Cast <object>()
.Skip(1)
.ToArray();
targetVersion.Items.AddRange(items);
// Select the deploy log being targetted.
DeployLog target = targets
.Where(log => log.VersionId == targetId)
.FirstOrDefault();
if (target != null)
{
targetVersion.SelectedItem = target;
return;
}
// If the target isn't valid, fallback to the latest version.
targetVersion.SelectedIndex = 0;
}
public static async Task <StudioDeployLogs> Get(string branch)
{
StudioDeployLogs logs = null;
if (LogCache.ContainsKey(branch))
{
logs = LogCache[branch];
}
else
{
logs = new StudioDeployLogs(branch);
}
var getDeployHistory = HistoryCache.GetDeployHistory(branch);
string deployHistory = await getDeployHistory.ConfigureAwait(false);
if (logs.LastDeployHistory != deployHistory)
{
int maxVersion = int.MaxValue;
if (branch == "roblox")
{
string binaryType = StudioBootstrapper.GetStudioBinaryType();
var getInfo = ClientVersionInfo.Get(binaryType);
var info = await getInfo.ConfigureAwait(false);
int version = info.Version
.Split('.')
.Select(int.Parse)
.Skip(1)
.First();
maxVersion = version;
}
logs.LastDeployHistory = deployHistory;
logs.UpdateLogs(deployHistory, maxVersion);
}
return(logs);
}
public static async Task <StudioDeployLogs> Get(string branch)
{
StudioDeployLogs logs = null;
if (LogCache.ContainsKey(branch))
{
logs = LogCache[branch];
}
else
{
logs = new StudioDeployLogs(branch);
}
string deployHistory = await HistoryCache.GetDeployHistory(branch);
if (logs.LastDeployHistory != deployHistory)
{
logs.LastDeployHistory = deployHistory;
logs.UpdateLogs(deployHistory);
}
return(logs);
}
public static async Task <ClientVersionInfo> GetCurrentVersionInfo(string branch, string fastVersionGuid = "")
{
string binaryType = GetStudioBinaryType();
if (branch == "roblox")
{
return(await ClientVersionInfo.Get(binaryType));
}
if (fastVersionGuid != "")
{
string latestGuid;
if (binaryType == "WindowsStudio64")
{
latestGuid = versionRegistry.GetString("LatestGuid_x86");
}
else
{
latestGuid = versionRegistry.GetString("LatestGuid_x64");
}
// If we already determined the fast version guid is pointing
// to the other version of Roblox Studio, fallback to the
// version data that has been cached already.
if (fastVersionGuid == latestGuid)
{
string versionId = versionRegistry.GetString("Version");
string versionGuid = versionRegistry.GetString("VersionGuid");
ClientVersionInfo proxy = new ClientVersionInfo()
{
Version = versionId,
Guid = versionGuid
};
return(proxy);
}
}
// Unfortunately as of right now, the ClientVersionInfo end-point on
// gametest isn't available to the public, so I have to use some hacks
// with the DeployHistory.txt file to figure out what version guid to use.
var logData = await StudioDeployLogs.Get(branch);
var currentLogs = logData.CurrentLogs;
int numLogs = currentLogs.Count;
DeployLog latest = currentLogs[numLogs - 1];
DeployLog prev = currentLogs[numLogs - 2];
DeployLog build_x86, build_x64;
// If these builds aren't using the same perforce changelist,
// then the 64-bit version hasn't been deployed yet. There is
// usually a ~5 minute gap between the new 32-bit version being
// deployed, and the 64-bit version proceeding it.
if (prev.Changelist != latest.Changelist)
{
build_x86 = latest;
build_x64 = prev;
}
else
{
build_x86 = prev;
build_x64 = latest;
}
var info = new ClientVersionInfo();
if (binaryType == "WindowsStudio64")
{
info.Version = build_x64.ToString();
info.Guid = build_x64.VersionGuid;
}
else
{
info.Version = build_x86.ToString();
info.Guid = build_x86.VersionGuid;
}
versionRegistry.SetValue("LatestGuid_x86", build_x86.VersionGuid);
versionRegistry.SetValue("LatestGuid_x64", build_x64.VersionGuid);
return(info);
}
public static async Task <ClientVersionInfo> GetCurrentVersionInfo(string branch, string fastGuid = "")
{
string targetVersion = Program.GetString("TargetVersion");
if (targetVersion != "")
{
return(await GetTargetVersionInfo(branch, targetVersion));
}
string binaryType = GetStudioBinaryType();
bool is64Bit = Environment.Is64BitOperatingSystem;
if (branch == "roblox")
{
return(await ClientVersionInfo.Get(binaryType));
}
if (fastGuid == "")
{
fastGuid = await GetFastVersionGuid(branch);
}
string latestFastGuid = versionRegistry.GetString("LatestFastGuid");
var info = new ClientVersionInfo();
if (latestFastGuid == fastGuid)
{
string version = versionRegistry.GetString("Version");
info.Version = version;
string latest_x86 = versionRegistry.GetString("LatestGuid_x86");
string latest_x64 = versionRegistry.GetString("LatestGuid_x64");
if (latestFastGuid == latest_x64 && is64Bit)
{
info.Guid = latest_x64;
return(info);
}
if (latestFastGuid == latest_x86 && !is64Bit)
{
info.Guid = latest_x86;
return(info);
}
}
// Unfortunately the ClientVersionInfo end-point on sitetest
// isn't available to the public, so I have to parse the
// DeployHistory.txt file on their setup s3 bucket.
var logData = await StudioDeployLogs.Get(branch);
DeployLog build_x86 = logData.CurrentLogs_x86.Last();
DeployLog build_x64 = logData.CurrentLogs_x64.Last();
if (is64Bit)
{
info.Version = build_x64.VersionId;
info.Guid = build_x64.VersionGuid;
}
else
{
info.Version = build_x86.VersionId;
info.Guid = build_x86.VersionGuid;
}
versionRegistry.SetValue("LatestFastGuid", fastGuid);
versionRegistry.SetValue("LatestGuid_x86", build_x86.VersionGuid);
versionRegistry.SetValue("LatestGuid_x64", build_x64.VersionGuid);
return(info);
}
