private async Task <string> ExtendTranslationAsync(string result, string key, string language, IDictionary <string, object> args,
TranslationOptions options)
{
IDictionary <string, object> replaceArgs;
if ((args?.ContainsKey("replace") ?? false) && args["replace"].GetType().IsClass)
{
replaceArgs = args["replace"].ToDictionary();
}
else
{
replaceArgs = args;
}
if (AllowInterpolation && (!(args?.ContainsKey("interpolate") ?? false) || args["interpolate"] is bool interpolate && interpolate))
{
result = await _interpolator.InterpolateAsync(result, key, language, replaceArgs);
}
if (AllowNesting && (!(args?.ContainsKey("nest") ?? false) || args["nest"] is bool nest && nest) && _interpolator.CanNest(result))
{
result = await _interpolator.NestAsync(result, language, replaceArgs,
(lang2, key2, args2) => TranslateAsync(lang2, key2, args2, options));
}
if (AllowPostprocessing && PostProcessors.Count > 0)
{
result = HandlePostProcessing(result, key, args);
}
return(result);
}
public void SetUp()
{
_translator = new DefaultTranslator(_backend, null, _pluralResolver, _interpolator);
_options = new TranslationOptions {
DefaultNamespace = "test"
};
}
/// <summary>
/// Get the translation of an xliff file using the ETS API.
/// </summary>
/// <param name="options"></param>
/// <param name="languageDirection"></param>
/// <param name="xliffFile"></param>
/// <returns></returns>
public static string GetTranslation(TranslationOptions options,
LanguagePair languageDirection,
Xliff xliffFile)
{
Log.Logger.Trace("");
var text = xliffFile.ToString();
var queryString = HttpUtility.ParseQueryString(string.Empty);
var encodedInput = text.Base64Encode();
lock (optionsLock)
{
if (options.ApiVersion == APIVersion.Unknown)
{
SetETSApiVersion(options);
}
}
if (options.ApiVersion == APIVersion.v1)
{
queryString["sourceLanguageId"] = languageDirection.SourceCulture.ToETSCode();
queryString["targetLanguageId"] = languageDirection.TargetCulture.ToETSCode();
queryString["text"] = encodedInput;
}
else
{
// If LPPreferences doesn't contain the target language (source is always the same), figure out the
// preferred LP. Previously set preferred LPs will stay, so this won't get run each time if you have
// multiple LPs.
if (!options.LPPreferences.ContainsKey(languageDirection.TargetCulture))
{
options.SetPreferredLanguages(new LanguagePair[] { languageDirection });
if (!options.LPPreferences.ContainsKey(languageDirection.TargetCulture))
{
throw new Exception("There are no language pairs currently accessible via ETS.");
}
}
queryString["languagePairId"] = options.LPPreferences[languageDirection.TargetCulture].LanguagePairId;
queryString["input"] = encodedInput;
}
queryString["inputFormat"] = "application/x-xliff";
Log.Logger.Debug("Sending translation request for: {0}", encodedInput);
string jsonResult;
try
{
jsonResult = ContactETSServer(ETSPost, options, "translations/quick", queryString);
}
catch (Exception e)
{
Log.Logger.Error($"{Constants.Translation}: {e.Message}\n {e.StackTrace}\n Encoded Input: {encodedInput}");
throw;
}
var encodedTranslation = JsonConvert.DeserializeObject <ETSTranslationOutput>(jsonResult).Translation;
var decodedTranslation = encodedTranslation.Base64Decode();
Log.Logger.Debug("Resultant translation is: {0}", encodedTranslation);
return(decodedTranslation);
}
void DrawToolWindow()
{
GUILayout.Label("Select trasnlation type", EditorStyles.boldLabel);
projectOutFileName = EditorGUILayout.TextField("Output file name: ", projectOutFileName);
scenePrefix = EditorGUILayout.TextField("Name key prefix: ", scenePrefix);
translationOption = (TranslationOptions)EditorGUILayout.EnumPopup("Translate object type of: ", translationOption);
extension = (Extensions)EditorGUILayout.EnumPopup("Select file's extension: ", extension);
fieldTypes = (GDEFiledTypes)EditorGUILayout.EnumPopup("Select GDE fields type: ", fieldTypes);
if (GUILayout.Button("Refresh output file"))
{
UpdateObjectWithTranslationComponent();
}
else if (GUILayout.Button("Confirm"))
{
renameType = RenameType.Selection;
if (string.IsNullOrEmpty(projectOutFileName) || projectOutFileName.Length > 40)
{
projectOutFileName = "results";
EditorUtility.DisplayDialog("Translation plugin message", "Output file name can't be empty or longher than 40 characters. Output file saved as \"results.txt\".\nYou can retype the name of output file via 4Experience/Tools/Setup Translations window.", "OK");
}
InvokeSelectWithUpdate();
AssetDatabase.Refresh();
}
}
public ProviderConfDialog(TranslationOptions options, ITranslationProviderCredentialStore store, LanguagePair[] languagePairs)
{
credentialStore = store;
Options = options;
LanguagePairs = languagePairs;
InitializeComponent();
if (PluginConfiguration.CurrentInstance.DefaultConnection.HasValue &&
Options.Host == null)
{
Options.Host = PluginConfiguration.CurrentInstance.DefaultConnection.Value.Host;
Options.Port = PluginConfiguration.CurrentInstance.DefaultConnection.Value.Port;
}
// Set this outside the if statement in case Options Host & Port were already set to the default connection
setDefaultTM.Checked = PluginConfiguration.CurrentInstance.DefaultConnection.HasValue &&
PluginConfiguration.CurrentInstance.DefaultConnection.Value.Host == Options.Host &&
PluginConfiguration.CurrentInstance.DefaultConnection.Value.Port == Options.Port;
UpdateDialog();
Text = @"SDL Machine Translation Edge";
// .5 seconds after certain events, run the populate command. This prevents us from authenticating each
// keypress (as that was causing massive lag).
lpPopulationTimer.AutoReset = false;
lpPopulationTimer.Elapsed += lpPopulationTimer_Elapsed;
}
/// <summary>
/// Verifies that the API Key passed by the user is a valid API key.
/// </summary>
/// <param name="options"></param>
/// <param name="credentials"></param>
public static void VerifyBasicAPIToken(TranslationOptions options, GenericCredentials credentials)
{
_logger.Trace("");
if (options == null)
{
throw new ArgumentNullException("Options is null");
}
var oldAPIKey = options.ApiToken;
options.ApiToken = credentials["API-Key"];
options.UseBasicAuthentication = credentials["UseApiKey"] != "true";
try
{
// Make a request to the API using whatever path desired.
ContactMtEdgeServer(MtEdgeGet, options, "language-pairs");
}
catch (AggregateException e)
{
_logger.Error($"{Constants.VerifyBasicAPIToken}: {e.Message}\n {e.StackTrace}");
throw TranslateAggregateException(e);
}
catch (SocketException e)
{
_logger.Error($"{Constants.VerifyBasicAPIToken}: {e.Message}\n {e.StackTrace}");
throw TranslateAggregateException(e);
}
finally
{
options.ApiToken = oldAPIKey;
}
}
public void Constructor_Parameterless_NullOrEmptyValues()
{
var options = new TranslationOptions();
Assert.AreEqual(options.Host, null);
Assert.AreEqual(options.ApiToken, null);
Assert.AreEqual(options.Port, 8001);
}
public ETSHelperTests()
{
apiKeyTranslationOptions = new TranslationOptions(new Uri(StringResource.ApiUrl));
apiKeyTranslationOptions.UseBasicAuthentication = false;
apiKeyTranslationOptions.ApiToken = StringResource.ApiKey;
basicAuthTranslationOptions = new TranslationOptions(new Uri(StringResource.ApiUrl));
basicAuthTranslationOptions.UseBasicAuthentication = true;
userCredentials = new GenericCredentials(StringResource.Username, StringResource.Password);
}
public TranslationProviderLanguageDirectionTests()
{
TranslationOptions options = new TranslationOptions(new Uri(StringResource.ApiUrl));
options.UseBasicAuthentication = false;
options.ApiToken = StringResource.ApiKey;
provider = new TranslationProvider(options);
settings = new SearchSettings();
}
private async Task <string> ResolveTranslationAsync(string language, string ns, string key, IDictionary <string, object> args,
TranslationOptions options)
{
var needsPluralHandling = CheckForSpecialArg(args, "count", typeof(int), typeof(long)) && _pluralResolver.NeedsPlural(language);
var needsContextHandling = CheckForSpecialArg(args, "context", typeof(string));
var finalKey = key;
var possibleKeys = new List <string>();
possibleKeys.Add(finalKey);
var pluralSuffix = string.Empty;
if (needsPluralHandling)
{
var count = (int)Convert.ChangeType(args["count"], typeof(int));
pluralSuffix = _pluralResolver.GetPluralSuffix(language, count);
// Fallback for plural if context was not found
if (needsContextHandling)
{
possibleKeys.Add($"{finalKey}{pluralSuffix}");
}
}
// Get key for context if needed
if (needsContextHandling)
{
var context = (string)args["context"];
finalKey = $"{finalKey}{ContextSeparator}{context}";
possibleKeys.Add(finalKey);
}
// Get key for plural if needed
if (needsPluralHandling)
{
finalKey = $"{finalKey}{pluralSuffix}";
possibleKeys.Add(finalKey);
}
// Try to resolve the translation from the backend
var result = await ResolveTranslationFromBackendAsync(language, ns, args, possibleKeys);
if (result == null)
{
OnMissingKey(language, ns, key, possibleKeys);
}
// Try to resolve the translation from the backend for all fallback langauges
if (result == null && options.FallbackLanguages != null && options.FallbackLanguages.Length > 0)
{
result = await ResolveFallbackTranslationAsync(ns, args, options.FallbackLanguages, possibleKeys);
}
return(result);
}
public void Constructor_Parameters_ValidValues()
{
var options = new TranslationOptions(new Uri(UTStringResource.ApiUrl));
string host = UTStringResource.ApiHost;
int port = 8001;
Assert.AreEqual(options.Port, port);
// localhost should be resolved via DNS to wgitbuild#
Assert.AreNotEqual(options.Uri.ToString(), UTStringResource.ApiUrl);
}
public ConversionResult Convert(
ShaderType shaderType, TargetVersion targetVersion, TranslationOptions options,
string hlslCode, string entryPoint,
Dictionary <AttributeSemantic, string> overrideAttributeNames = null)
{
var compilerPtr = NativeMethods.Hlsl2Glsl_ConstructCompiler(shaderType);
if (compilerPtr == IntPtr.Zero)
{
throw new Exception("Failed to construct Hlsl2Glsl compiler");
}
try
{
var callbacks = new NativeMethods.Hlsl2Glsl_ParseCallbacks
{
IncludeOpenCallback = null,
Data = IntPtr.Zero
};
var parseResult = NativeMethods.Hlsl2Glsl_Parse(compilerPtr, hlslCode, targetVersion, ref callbacks, options);
if (parseResult != 1)
{
throw GetInfoLogAndCreateException(compilerPtr, "Failed to parse HLSL code");
}
if (overrideAttributeNames != null)
{
var setUserAttrNamesResult = NativeMethods.Hlsl2Glsl_SetUserAttributeNames(compilerPtr,
overrideAttributeNames.Keys.ToArray(), overrideAttributeNames.Values.ToArray(),
overrideAttributeNames.Count);
if (setUserAttrNamesResult != 1)
{
throw GetInfoLogAndCreateException(compilerPtr, "Failed to user attribute names");
}
}
var translateResult = NativeMethods.Hlsl2Glsl_Translate(compilerPtr, entryPoint, targetVersion, options);
if (translateResult != 1)
{
throw GetInfoLogAndCreateException(compilerPtr, "Failed to translate HLSL code");
}
var glsl = NativeMethods.Hlsl2Glsl_GetShader(compilerPtr);
var uniforms = NativeMethods.Hlsl2Glsl_GetUniformInfo(compilerPtr);
return(new ConversionResult(glsl, uniforms));
}
finally
{
NativeMethods.Hlsl2Glsl_DestructCompiler(compilerPtr);
}
}
/// <summary>
/// Construtor padrão
/// </summary>
/// <param name="nextMiddlewareInPipelineDelegate"></param>
/// <param name="tokenManager"></param>
/// <param name="logger"></param>
/// <param name="errorLogger"></param>
/// <param name="translateOptions"></param>
/// <param name="globalizationOptions"></param>
/// <param name="memoryCache"></param>
/// <param name="httpClientFactory"></param>
public TranslationMiddleware(RequestDelegate nextMiddlewareInPipelineDelegate, IClientTokenManager tokenManager, ILogger <TranslationMiddleware> logger, IErrorLogger errorLogger, IOptions <TranslationOptions> translateOptions, IOptions <GlobalizationOptions> globalizationOptions, IMemoryCache memoryCache, IHttpClientFactory httpClientFactory)
{
this.nextMiddlewareInPipelineDelegate = nextMiddlewareInPipelineDelegate;
this.tokenManager = tokenManager;
this.logger = logger;
this.errorLogger = errorLogger;
this.translateOptions = translateOptions?.Value ?? throw new ArgumentException("Translate options required.");
this.globalizationOptions = globalizationOptions?.Value ?? throw new ArgumentException("Globalization options required.");
this.memoryCache = memoryCache ?? throw new ArgumentException("IMemoryCache options required.");
this.httpClientFactory = httpClientFactory ?? throw new ArgumentException("IHttpClientFactory required.");
recyclableMemoryStreamManager = new RecyclableMemoryStreamManager();
}
public TranslationServiceUnitTests()
{
_translationDataProviderMock = new Mock <ITranslationDataProvider>();
_translationOptionsMock = new Mock <IOptions <TranslationOptions> >();
var translationOptions = new TranslationOptions();
_translationOptionsMock.Setup(x => x.Value).Returns(translationOptions);
_cacheEntryMock = new Mock <ICacheEntry>();
_cacheEntryMock.SetupGet(c => c.ExpirationTokens).Returns(new List <IChangeToken>());
IList <ITranslationDataProvider> listProvider = new List <ITranslationDataProvider> {
_translationDataProviderMock.Object
};
_translationService = new TranslationService(listProvider, GetCache(), _translationOptionsMock.Object);
}
public void Test()
{
IExtensionPoint[] extensionPoints = { new StringExtensionPoint() };
var generator = new JavaGenerator(extensionPoints.OfType <ITypeResolver>().ToArray());
var options = new TranslationOptions
{
IsBeautify = true,
MultiThreading = false
};
var translatorRunner = new TranslationRunner(generator, extensionPoints, options);
var inDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TestFiles");
var outDir = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "TestFilesOut");
translatorRunner.Translate(inDir, outDir, null);
}
public static void SetETSApiVersion(TranslationOptions options)
{
try
{
options.APIVersion = APIVersion.v2;
string systemInfo = ContactETSServer(ETSGet, options, "system/info");
if (systemInfo == null)
{
options.APIVersion = APIVersion.v1;
}
}
catch
{
options.APIVersion = APIVersion.v1;
}
}
void TranslateResxFiles()
{
var srcLng = ((KeyValuePair <string, string>)cmbSourceResxLng.SelectedItem).Key;
var destLanguages = new List <string>();
foreach (ListViewItem item in lstResxLanguages.Items)
{
if (!item.Checked)
{
continue;
}
if (item.Name == srcLng)
{
continue;
}
destLanguages.Add(item.Name);
}
if (destLanguages.Count == 0)
{
MessageBox.Show(
"The source and the destination languages can not be the same.",
"",
MessageBoxButtons.OK,
MessageBoxIcon.Error);
return;
}
var translationOptions = new TranslationOptions
{
ServiceType = GetServiceType(),
MsSubscriptionKey = txtMsTranslationKey.Text,
MsSubscriptionRegion = txtMsTranslationRegion.Text
};
IsBusy(true);
new Action <string, string, TranslationOptions, List <string>, string, ResxProgressCallback>(
TranslateResxFilesAsync).BeginInvoke(
txtSourceResx.Text,
srcLng,
translationOptions,
destLanguages,
txtOutputDir.Text,
ResxWorkingProgress,
(x) => IsBusy(false),
null);
}
public static void SetETSApiVersion(TranslationOptions options)
{
try
{
options.ApiVersion = APIVersion.v2;
var systemInfo = ContactETSServer(ETSGet, options, "system/info");
if (systemInfo == null)
{
options.ApiVersion = APIVersion.v1;
}
}
catch (Exception e)
{
Log.Logger.Error($"{Constants.ETSApiVersion}: {e.Message}\n {e.StackTrace}");
options.ApiVersion = APIVersion.v1;
}
}
public ConversionResult Convert(
ShaderType shaderType, TargetVersion targetVersion, TranslationOptions options,
string hlslCode, string entryPoint,
Dictionary<AttributeSemantic, string> overrideAttributeNames = null)
{
var compilerPtr = NativeMethods.Hlsl2Glsl_ConstructCompiler(shaderType);
if (compilerPtr == IntPtr.Zero)
throw new Exception("Failed to construct Hlsl2Glsl compiler");
try
{
var callbacks = new NativeMethods.Hlsl2Glsl_ParseCallbacks
{
IncludeOpenCallback = null,
Data = IntPtr.Zero
};
var parseResult = NativeMethods.Hlsl2Glsl_Parse(compilerPtr, hlslCode, targetVersion, ref callbacks, options);
if (parseResult != 1)
throw GetInfoLogAndCreateException(compilerPtr, "Failed to parse HLSL code");
if (overrideAttributeNames != null)
{
var setUserAttrNamesResult = NativeMethods.Hlsl2Glsl_SetUserAttributeNames(compilerPtr,
overrideAttributeNames.Keys.ToArray(), overrideAttributeNames.Values.ToArray(),
overrideAttributeNames.Count);
if (setUserAttrNamesResult != 1)
throw GetInfoLogAndCreateException(compilerPtr, "Failed to user attribute names");
}
var translateResult = NativeMethods.Hlsl2Glsl_Translate(compilerPtr, entryPoint, targetVersion, options);
if (translateResult != 1)
throw GetInfoLogAndCreateException(compilerPtr, "Failed to translate HLSL code");
var glsl = NativeMethods.Hlsl2Glsl_GetShader(compilerPtr);
var uniforms = NativeMethods.Hlsl2Glsl_GetUniformInfo(compilerPtr);
return new ConversionResult(glsl, uniforms);
}
finally
{
NativeMethods.Hlsl2Glsl_DestructCompiler(compilerPtr);
}
}
public static void SetMtEdgeApiVersion(TranslationOptions options)
{
try
{
options.ApiVersion = APIVersion.v2;
var systemInfo = ContactMtEdgeServer(MtEdgeGet, options, "system/info");
if (systemInfo == null)
{
options.ApiVersion = APIVersion.v1;
}
}
catch (Exception e)
{
_logger.Error($"{Constants.MTEdgeApiVersion}: {e.Message}\n {e.StackTrace}");
options.ApiVersion = APIVersion.v1;
throw;
}
}
/// <summary>
/// Decode the binary Maxwell shader code to a translator context.
/// </summary>
/// <remarks>
/// This will combine the "Vertex A" and "Vertex B" shader stages, if specified, into one shader.
/// </remarks>
/// <param name="channel">GPU channel</param>
/// <param name="gas">GPU accessor state</param>
/// <param name="counts">Cumulative shader resource counts</param>
/// <param name="flags">Flags that controls shader translation</param>
/// <param name="stage">Shader stage</param>
/// <param name="gpuVa">GPU virtual address of the shader code</param>
/// <returns>The generated translator context</returns>
private TranslatorContext DecodeGraphicsShader(
GpuChannel channel,
GpuAccessorState gas,
TranslationCounts counts,
TranslationFlags flags,
ShaderStage stage,
ulong gpuVa)
{
if (gpuVa == 0)
{
return(null);
}
GpuAccessor gpuAccessor = new GpuAccessor(_context, channel, gas, (int)stage - 1);
var options = new TranslationOptions(TargetLanguage.Glsl, TargetApi.OpenGL, flags);
return(Translator.CreateContext(gpuVa, gpuAccessor, options, counts));
}
void SetTranslationComponent(TranslationOptions options)
{
switch (options)
{
case TranslationOptions.Text:
ChangeTranslatableNames <Text, ChangeLanguageVersion>();
break;
//case TranslationOptions.VRTKTooltip:
// ChangeTranslatableNames<VRTK_ObjectTooltip, VRTKTooltipTranslator>();
// break;
//case TranslationOptions.TMProText:
// ChangeTranslatableNames<Text, ChangeLanguageVersion>();
// break;
default:
Debug.LogError("Unrecognized Option");
break;
}
}
/// <summary>
/// Get an array of Language Pairs accessible by the credentials provided.
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
public static ETSLanguagePair[] GetLanguagePairs(TranslationOptions options)
{
Log.logger.Trace("");
lock (languageLock)
{
if (LanguagePairsOnServer == null || !LanguagePairsOnServer.Any())
{
try
{
// Ideally no exception should be thrown from ContactETSServer, but in rare cases
// it could successfully authenticate using username/password, but then reject the token. If
// that happens, open a message with the related error
string jsonResult = ContactETSServer(ETSGet, options, "language-pairs");
ETSLanguagePair[] languagePairs =
JsonConvert.DeserializeObject <LanguagePairResult>(jsonResult).LanguagePairs;
LanguagePairsOnServer = (languagePairs != null ? languagePairs : new ETSLanguagePair[0]);
// In 60 seconds, wipe the LPs so we query again. That way, if someone makes a change, we'll
// pick it up eventually.
Task.Factory.StartNew(() =>
{
System.Threading.Thread.Sleep(60000);
lock (languageLock)
{
ExpireLanguagePairs();
}
});
}
catch (Exception e)
{
Log.logger.Error(e, "Unable to get the language pairs:");
if (Environment.UserInteractive)
{
MessageBox.Show(e.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
LanguagePairsOnServer = new ETSLanguagePair[0];
}
}
}
return(LanguagePairsOnServer);
}
/// <summary>
/// Decode the binary Maxwell shader code to a translator context.
/// </summary>
/// <param name="channel">GPU channel</param>
/// <param name="gas">GPU accessor state</param>
/// <param name="gpuVa">GPU virtual address of the binary shader code</param>
/// <param name="localSizeX">Local group size X of the computer shader</param>
/// <param name="localSizeY">Local group size Y of the computer shader</param>
/// <param name="localSizeZ">Local group size Z of the computer shader</param>
/// <param name="localMemorySize">Local memory size of the compute shader</param>
/// <param name="sharedMemorySize">Shared memory size of the compute shader</param>
/// <returns>The generated translator context</returns>
private TranslatorContext DecodeComputeShader(
GpuChannel channel,
GpuAccessorState gas,
ulong gpuVa,
int localSizeX,
int localSizeY,
int localSizeZ,
int localMemorySize,
int sharedMemorySize)
{
if (gpuVa == 0)
{
return(null);
}
GpuAccessor gpuAccessor = new GpuAccessor(_context, channel, gas, localSizeX, localSizeY, localSizeZ, localMemorySize, sharedMemorySize);
var options = new TranslationOptions(TargetLanguage.Glsl, TargetApi.OpenGL, DefaultFlags | TranslationFlags.Compute);
return(Translator.CreateContext(gpuVa, gpuAccessor, options));
}
/// <summary>
/// Get dictionaries from the MT Edge server
/// </summary>
/// <param name="tradosToMtEdgeLP"></param>
/// <param name="options"></param>
public static void GetDictionaries(TradosToMTEdgeLP tradosToMtEdgeLP, TranslationOptions options)
{
var queryString = HttpUtility.ParseQueryString(string.Empty);
foreach (var item in tradosToMtEdgeLP.MtEdgeLPs)
{
queryString["sourceLanguageId"] = item.SourceLanguageId;
queryString["targetLanguageId"] = item.TargetLanguageId;
queryString["perPage"] = "1000"; // set to 1000 to avoid the missing dictionaries
var jsonResult = ContactMtEdgeServer(MtEdgeGet, options, "dictionaries", queryString);
var result = JsonConvert.DeserializeObject <DictionaryInfo>(jsonResult);
tradosToMtEdgeLP.Dictionaries = new List <DictionaryModel>(result.Dictionaries);
tradosToMtEdgeLP.Dictionaries.Insert(0, new DictionaryModel
{
DictionaryId = Constants.NoDictionary,
SourceLanguageId = string.Empty,
TargetLanguageId = string.Empty
});
}
}
/// <summary>
/// Get an array of Language Pairs accessible by the credentials provided.
/// </summary>
/// <param name="options"></param>
/// <returns></returns>
public static SDLMTEdgeLanguagePair[] GetLanguagePairs(TranslationOptions options)
{
lock (languageLock)
{
if (_languagePairsOnServer == null || !_languagePairsOnServer.Any())
{
try
{
// Ideally no exception should be thrown from ContactMtEdgeServer, but in rare cases
// it could successfully authenticate using username/password, but then reject the token. If
// that happens, open a message with the related error
var jsonResult = ContactMtEdgeServer(MtEdgeGet, options, "language-pairs");
var languagePairs = JsonConvert.DeserializeObject <LanguagePairResult>(jsonResult).LanguagePairs;
_languagePairsOnServer = (languagePairs != null ? languagePairs : new SDLMTEdgeLanguagePair[0]);
// In 60 seconds, wipe the LPs so we query again. That way, if someone makes a change, we'll
// pick it up eventually.
Task.Factory.StartNew(() =>
{
System.Threading.Thread.Sleep(60000);
lock (languageLock)
{
ExpireLanguagePairs();
}
});
}
catch (Exception e)
{
_logger.Error($"{Constants.LanguagePairs}: {Constants.InaccessibleLangPairs}: {e.Message}\n {e.StackTrace}");
if (Environment.UserInteractive)
{
MessageBox.Show(e.Message, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error);
}
_languagePairsOnServer = new SDLMTEdgeLanguagePair[0];
}
}
}
return(_languagePairsOnServer);
}
static void HandleArguments(Options options)
{
TranslationFlags flags = TranslationFlags.DebugMode;
if (options.Compute)
{
flags |= TranslationFlags.Compute;
}
byte[] data = File.ReadAllBytes(options.InputPath);
TranslationOptions translationOptions = new TranslationOptions(options.TargetLanguage, options.TargetApi, flags);
ShaderProgram program = Translator.CreateContext(0, new GpuAccessor(data), translationOptions).Translate(out _);
if (options.OutputPath == null)
{
if (program.BinaryCode != null)
{
using Stream outputStream = Console.OpenStandardOutput();
outputStream.Write(program.BinaryCode);
}
else
{
Console.WriteLine(program.Code);
}
}
else
{
if (program.BinaryCode != null)
{
File.WriteAllBytes(options.OutputPath, program.BinaryCode);
}
else
{
File.WriteAllText(options.OutputPath, program.Code);
}
}
}
private static string Translate(Dictionary <string, string> parameters, TranslationOptions options, string path)
{
var content = GetStringContentFromParameters(parameters);
ServicePointManager.Expect100Continue = true;
ServicePointManager.DefaultConnectionLimit = 9999;
using (var httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Authorization = options.UseBasicAuthentication
? new AuthenticationHeaderValue("Bearer", options.ApiToken)
: new AuthenticationHeaderValue("Basic", (options.ApiToken + ":").Base64Encode());
var builder = new UriBuilder(options.Uri)
{
Path = $"/api/{options.ApiVersionString}/{path}",
Scheme = options.RequiresSecureProtocol ? Uri.UriSchemeHttps : Uri.UriSchemeHttp
};
var response = httpClient.PostAsync(builder.Uri, content).Result;
var result = response.Content.ReadAsStringAsync().Result;
return(result);
}
}
/// <summary>
/// Decode the binary Maxwell shader code to a translator context.
/// </summary>
/// <remarks>
/// This will combine the "Vertex A" and "Vertex B" shader stages, if specified, into one shader.
/// </remarks>
/// <param name="state">Current GPU state</param>
/// <param name="counts">Cumulative shader resource counts</param>
/// <param name="flags">Flags that controls shader translation</param>
/// <param name="stage">Shader stage</param>
/// <param name="gpuVa">GPU virtual address of the shader code</param>
/// <returns>The generated translator context</returns>
private TranslatorContext DecodeGraphicsShader(
GpuState state,
TranslationCounts counts,
TranslationFlags flags,
ShaderStage stage,
ulong gpuVa)
{
if (gpuVa == 0)
{
return(null);
}
GpuAccessorState gas = new GpuAccessorState(
state.Get <PoolState>(MethodOffset.TexturePoolState).Address.Pack(),
state.Get <PoolState>(MethodOffset.TexturePoolState).MaximumId,
state.Get <int>(MethodOffset.TextureBufferIndex),
state.Get <Boolean32>(MethodOffset.EarlyZForce));
GpuAccessor gpuAccessor = new GpuAccessor(_context, state.Channel, gas, (int)stage - 1);
var options = new TranslationOptions(TargetLanguage.Glsl, TargetApi.OpenGL, flags);
return(Translator.CreateContext(gpuVa, gpuAccessor, options, counts));
}
/// <summary>
/// Using the username and password passed in via credentials, obtain the authentication token that will be
/// later used to validate API calls.
/// </summary>
/// <param name="options"></param>
/// <param name="credentials"></param>
/// <param name="useHTTP"></param>
/// <returns></returns>
public static string GetAuthToken(
TranslationOptions options,
GenericCredentials credentials,
bool useHTTP = false)
{
_logger.Trace("");
lock (optionsLock)
{
if (options.ApiVersion == APIVersion.Unknown)
{
SetMtEdgeApiVersion(options);
}
}
ServicePointManager.Expect100Continue = true;
ServicePointManager.DefaultConnectionLimit = 9999;
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12 | SecurityProtocolType.Ssl3;
using (var httpClient = new HttpClient())
{
// Build the URI for querying the token
var builder = new UriBuilder(options.Uri);
builder.Path = string.Format("/api/{0}/auth", options.ApiVersionString);
// Pass in the username and password as parameters to retrieve the auth token
var queryString = HttpUtility.ParseQueryString(string.Empty);
queryString["username"] = credentials.UserName;
queryString["password"] = credentials.Password;
builder.Query = queryString.ToString();
builder.Scheme = useHTTP ? Uri.UriSchemeHttp : Uri.UriSchemeHttps;
// Users may be hosting the service locally and therefore not sign their certificates. If so,
// we'll want to accept all certificates. Otherwise, this would throw an exception.
ServicePointManager.ServerCertificateValidationCallback += (sender, cert, chain, sslPolicyErrors) => true;
try
{
var httpResponse = httpClient.PostAsync(builder.Uri, null).Result;
if (httpResponse.Content != null && httpResponse.StatusCode == HttpStatusCode.OK)
{
return(httpResponse.Content.ReadAsStringAsync().Result);
}
else if (httpResponse.StatusCode == HttpStatusCode.Unauthorized || httpResponse.StatusCode == HttpStatusCode.BadRequest)
{
throw new UnauthorizedAccessException("The credentials provided are not authorized.");
}
throw new Exception("No response from the URI provided");
}
catch (Exception e)
{
while (e.InnerException != null)
{
e = e.InnerException;
}
if (!useHTTP && e.HResult == (int)ErrorHResult.HandshakeFailure)
{
return(GetAuthToken(options, credentials, true));
}
_logger.Error($"{Constants.AuthToken}: {e.Message}\n {e.StackTrace}");
throw TranslateAggregateException(e);
}
}
}
public static extern int Hlsl2Glsl_Parse(
IntPtr handle,
[MarshalAs(UnmanagedType.LPStr)] string shaderString,
TargetVersion targetVersion,
ref Hlsl2Glsl_ParseCallbacks callbacks,
TranslationOptions options);
public static extern int Hlsl2Glsl_Translate(
IntPtr handle,
[MarshalAs(UnmanagedType.LPStr)] string entry,
TargetVersion targetVersion,
TranslationOptions options);
/// <summary>
/// Queries the MTEdge server specified in options.
/// </summary>
/// <param name="mtEdgeHttpMethod">MtEdgePost or MtEdgeSGet</param>
/// <param name="options">The translation options</param>
/// <param name="path">The path after /api/vX/ for MTEdge api queries</param>
/// <param name="parameters">data to include in the query</param>
/// <param name="useHTTP">Whether to use HTTP over HTTPS</param>
/// <param name="timesToRetry">number of times to retry the query</param>
/// <returns>The string result of the request.</returns>
private static string ContactMtEdgeServer(Func <Uri, HttpClient, HttpResponseMessage> mtEdgeHttpMethod,
TranslationOptions options,
string path,
NameValueCollection parameters = null,
bool useHTTP = false)
{
_logger.Trace("");
lock (optionsLock)
{
if (options.ApiVersion == APIVersion.Unknown)
{
SetMtEdgeApiVersion(options);
}
}
ServicePointManager.Expect100Continue = true;
ServicePointManager.DefaultConnectionLimit = 9999;
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls | SecurityProtocolType.Tls11 | SecurityProtocolType.Tls12 | SecurityProtocolType.Ssl3;
ServicePointManager.ServerCertificateValidationCallback += (sender, cert, chain, sslPolicyErrors) => true;
using (var httpClient = new HttpClient())
{
httpClient.DefaultRequestHeaders.Authorization = options.UseBasicAuthentication
? new AuthenticationHeaderValue("Bearer", options.ApiToken)
: new AuthenticationHeaderValue("Basic", (options.ApiToken + ":").Base64Encode());
var builder = new UriBuilder(options.Uri)
{
Path = $"/api/{options.ApiVersionString}/{path}",
Scheme = useHTTP ? Uri.UriSchemeHttp : Uri.UriSchemeHttps
};
if (parameters != null)
{
builder.Query = parameters.ToString();
}
HttpResponseMessage httpResponse;
try
{
httpResponse = mtEdgeHttpMethod(builder.Uri, httpClient);
}
catch (Exception e)
{
while (e.InnerException != null)
{
e = e.InnerException;
}
_logger.Error($"{Constants.MTEdgeServerContact}:\n {Constants.MtEdgeServerContactExResult} {e.HResult}\n {e.Message}\n {e.StackTrace}");
throw TranslateAggregateException(e);
}
if (httpResponse.Content != null && httpResponse.StatusCode == HttpStatusCode.OK)
{
return(httpResponse.Content.ReadAsStringAsync().Result);
}
switch (httpResponse.StatusCode)
{
case HttpStatusCode.Unauthorized:
_logger.Error($"{Constants.MTEdgeServerContact}: {Constants.InvalidCredentials}");
throw new UnauthorizedAccessException("The credentials provided are not authorized.");
case HttpStatusCode.BadRequest:
_logger.Error($"{Constants.MTEdgeServerContact}: {Constants.BadRequest} {0}", httpResponse.Content.ReadAsStringAsync().Result);
throw new Exception($"There was a problem with the request: { httpResponse.Content.ReadAsStringAsync().Result }");
default:
_logger.Error($"{Constants.MTEdgeServerContact}: {(int)httpResponse.StatusCode} {Constants.StatusCode}");
return(null);
}
}
}
