void OLDdScriptCommand(CommandDetails command)
{
string outp = scriptcommand_base(command);
if (outp == null)
{
return;
}
Chat(command.Channel.Name, command.Pinger + ColorGeneral + "Scanning " + ColorHighlightMajor + (Utilities.CountChar(outp, '\n') + 1) + ColorGeneral + " lines...");
try
{
YamlStream ys = new YamlStream();
ys.Load(new StringReader(outp));
int nodes = 0;
for (int i = 0; i < ys.Documents.Count; i++)
{
nodes += ys.Documents[i].AllNodes.ToArray().Length;
}
}
catch (Exception ex)
{
Chat(command.Channel.Name, ColorGeneral + "Error in your YAML: " + ColorHighlightMajor + ex.Message);
}
List<string> warnings = dsCheck(outp);
Chat(command.Channel.Name, ColorGeneral + "Found " + ColorHighlightMajor + warnings.Count + ColorGeneral + " potential issues.");
for (int i = 0; i < warnings.Count && i < 8; i++)
{
Chat(command.Channel.Name, ColorHighlightMinor + "- " + i + ") " + warnings[i]);
}
}
void YamlDotNetYamlRead()
{
//textAsset
string fileName=AssetDatabase.GetAssetPath(textAsset);
// open
var input = new StreamReader(fileName, Encoding.UTF8);
var yaml = new YamlStream();
yaml.Load(input);
//var mapping = (YamlMappingNode)yaml.Documents[0].RootNode;
Debug.Log("yaml.Documents.Count="+ yaml.Documents.Count);
//foreach (YamlMappingNode item in (YamlMappingNode)yaml.Documents) {
for(int i = 0; i < yaml.Documents.Count; i++){
string str="";
//str="(YamlMappingNode)yaml.Documents["+i+"].RootNode= ";
str=str+(YamlMappingNode)yaml.Documents[i].RootNode+"\n";//Macの場合 optionキーを押しながら¥を押す
Debug.Log(str);
//for(int j = 0; j < yaml.Documents[i].AllNodes.Count(); j++){
//string str1="";
//str="(YamlMappingNode)yaml.Documents["+i+"].RootNode= ";
// str1=str1+(YamlDotNet.RepresentationModel.YamlNode)yaml.Documents[i].AllNodes[j]+"\n";//Macの場合 optionキーを押しながら¥を押す
//}
foreach (YamlDotNet.RepresentationModel.YamlNode yamlNode in yaml.Documents[i].AllNodes) {
Debug.Log(yamlNode.ToString());
}
//foreach (var child in item) {
// Debug.Log(((YamlScalarNode)child.Key).Value + "\t" +
// ((YamlScalarNode)child.Value).Value);
//}
}
TextWriter textWriter = new StreamWriter(Application.dataPath + "/YamlDotNetForUnityYAML/Editor/YamlDotNetYamlReadAndSave_yaml.yaml");
textWriter.WriteLine("%YAML 1.1");//無視される。
textWriter.WriteLine("%TAG !u! tag:unity3d.com,2011:");//無視される。
yaml.Save(textWriter);
textWriter.Close();
AssetDatabase.Refresh();
//var Year = (YamlScalarNode)mapping.Children[new YamlScalarNode("Year")];
//Debug.Log("Year "+ Year.Value);
//var Description = (YamlScalarNode)mapping.Children[new YamlScalarNode("Description")];
//Debug.Log("Desciption "+ Description.Value);
//Debug.Log("Contents:");
//var items = (YamlSequenceNode)mapping.Children[new YamlScalarNode("Contents")];
//foreach (YamlMappingNode item in items) {
// foreach (var child in item) {
// Debug.Log(((YamlScalarNode)child.Key).Value + "\t" +
// ((YamlScalarNode)child.Value).Value);
// }
//}
}
void Start () {
var input = new StringReader(Document);
var yaml = new YamlStream();
yaml.Load(input);
// Examine the stream
var mapping =
(YamlMappingNode)yaml.Documents[0].RootNode;
var output = new StringBuilder();
foreach (var entry in mapping.Children)
{
output.AppendLine(((YamlScalarNode)entry.Key).Value);
}
var items = (YamlSequenceNode)mapping.Children[new YamlScalarNode("items")];
foreach (YamlMappingNode item in items)
{
output.AppendLine(
String.Format("{0}\t{1}",
item.Children[new YamlScalarNode("part_no")],
item.Children[new YamlScalarNode("descrip")]
)
);
}
Debug.Log(output);
}
public IEnumerable<IDocument> Execute(IReadOnlyList<IDocument> inputs, IExecutionContext context)
{
return inputs
.AsParallel()
.SelectMany(input =>
{
List<Dictionary<string, object>> documentMetadata = new List<Dictionary<string, object>>();
using (TextReader contentReader = new StringReader(input.Content))
{
YamlStream yamlStream = new YamlStream();
yamlStream.Load(contentReader);
foreach (YamlDocument document in yamlStream.Documents)
{
// If this is a sequence, get a document for each item
YamlSequenceNode rootSequence = document.RootNode as YamlSequenceNode;
if (rootSequence != null)
{
documentMetadata.AddRange(rootSequence.Children.Select(GetDocumentMetadata));
}
else
{
// Otherwise, just get a single set of metadata
documentMetadata.Add(GetDocumentMetadata(document.RootNode));
}
}
}
return documentMetadata.Select(metadata => context.GetDocument(input, metadata));
})
.Where(x => x != null);
}
public static IDictionary<string, object> YamlHeader(this string text)
{
var results = new Dictionary<string, object>();
var m = r.Matches(text);
if (m.Count == 0)
return results;
var input = new StringReader(m[0].Groups[1].Value);
var yaml = new YamlStream();
yaml.Load(input);
var root = yaml.Documents[0].RootNode;
var collection = root as YamlMappingNode;
if (collection != null)
{
foreach (var entry in collection.Children)
{
var node = entry.Key as YamlScalarNode;
if (node != null)
{
results.Add(node.Value, entry.Value);
}
}
}
return results;
}
public static void load()
{
coal_seams = new List<CoalSeam>();
if (_yaml == null)
_yaml = YamlHelper.ReadFromFile("config.yaml");
server_ip = get_attribute("server_ip");
db_instance = get_attribute("db_instance");
uid = get_attribute("uid");
password = get_attribute("password");
update_url = get_attribute("update_url");
update_file = get_attribute("update_file");
var mapping = (YamlMappingNode)_yaml.Documents[0].RootNode;
var items = (YamlSequenceNode)mapping.Children[new YamlScalarNode("coal_seams")];
foreach (var item in items.Cast<YamlMappingNode>())
{
var coalSeam = new CoalSeam
{
name = item.Children[new YamlScalarNode("name")].ToString(),
db_name = item.Children[new YamlScalarNode("db_name")].ToString(),
gis_name = item.Children[new YamlScalarNode("gis_name")].ToString(),
mxd_name = item.Children[new YamlScalarNode("mxd_name")].ToString(),
port = item.Children[new YamlScalarNode("port")].ToString(),
rest_port = item.Children[new YamlScalarNode("rest_port")].ToString()
};
coal_seams.Add(coalSeam);
}
}
public override string Execute(string input)
{
var yamlDocument = new StringReader(input);
var yaml = new YamlStream();
yaml.Load(yamlDocument);
var mapping = (YamlMappingNode)yaml.Documents[0].RootNode;
foreach (var entry in mapping.Children)
{
var name = entry.Key.ToString();
if (entry.Value is YamlMappingNode)
{
AddRelationsFromLinks(name, entry.Value);
}
else if (entry.Value is YamlSequenceNode)
{
AddAttributesWithExplicitActionFromArray(name, entry.Value);
}
else if (entry.Value is YamlScalarNode)
{
AddAttributeFromScalarProperty(name, entry.Value);
}
}
return Builder.GetAssetXml();
}
public static YamlNode LoadFromTextReader(TextReader reader)
{
var yaml = new YamlStream();
yaml.Load(reader);
return yaml.Documents.First().RootNode;
}
/// <summary>
/// Initializes a new instance of <see cref="DynamicYaml"/> from the specified stream.
/// </summary>
/// <param name="stream">A stream that contains a YAML content. The stream will be disposed</param>
/// <param name="disposeStream">Dispose the stream when reading the YAML content is done. <c>true</c> by default</param>
public DynamicYaml(Stream stream, bool disposeStream = true)
{
if (stream == null) throw new ArgumentNullException(nameof(stream));
// transform the stream into string.
string assetAsString;
try
{
using (var assetStreamReader = new StreamReader(stream, Encoding.UTF8))
{
assetAsString = assetStreamReader.ReadToEnd();
}
}
finally
{
if (disposeStream)
{
stream.Dispose();
}
}
// Load the asset as a YamlNode object
var input = new StringReader(assetAsString);
yamlStream = new YamlStream();
yamlStream.Load(input);
if (yamlStream.Documents.Count != 1 || !(yamlStream.Documents[0].RootNode is YamlMappingNode))
throw new YamlException("Unable to load the given stream");
}
public IConfiguration Read(string path)
{
var entity = new Configuration();
try
{
var yamlStream = new YamlStream();
var fileText = File.ReadAllText(path);
using (var stringReader = new StringReader(fileText))
{
yamlStream.Load(stringReader);
}
var mapping = (YamlMappingNode)yamlStream.Documents[0].RootNode;
if (mapping.Children.ContainsKey(new YamlScalarNode("dateformat")))
{
entity.DateFormat = mapping.Children[new YamlScalarNode("dateformat")].ToString();
}
if (mapping.Children.ContainsKey(new YamlScalarNode("title")))
{
entity.Title = mapping.Children[new YamlScalarNode("title")].ToString();
}
if (mapping.Children.ContainsKey(new YamlScalarNode("author")))
{
entity.Author = mapping.Children[new YamlScalarNode("author")].ToString();
}
}
catch
{
}
return entity;
}
private void Parse(string path)
{
var yamlStream = new YamlStream();
var fileText = File.ReadAllText(path);
using (var stringReader = new StringReader(fileText))
{
yamlStream.Load(stringReader);
}
var mapping = (YamlMappingNode)yamlStream.Documents[0].RootNode;
foreach (var entry in mapping.Children)
{
switch (entry.Key.ToString().ToLower())
{
case "source":
Source = entry.Value.ToString();
break;
case "destination":
Destination = entry.Value.ToString();
break;
case "permalink":
Permalink = entry.Value.ToString();
break;
case "exclude":
Exclude = ((YamlSequenceNode)entry.Value).Children.Select(n => System.IO.Path.Combine(Source, n.ToString()));
break;
default:
break;
}
}
}
private void openRulesetToolStripMenuItem_Click(object sender, EventArgs e)
{
if( ofd.ShowDialog() == System.Windows.Forms.DialogResult.OK )
{
string rulesetContents;
rulesetFilename = ofd.FileName;
this.Text = "M.A.R.S. for OpenXCOM [" + rulesetFilename + "]";
rulesetContents = System.IO.File.ReadAllText( ofd.FileName );
rulesetStream = new YamlStream();
using( System.IO.StringReader docReader = new System.IO.StringReader(rulesetContents) )
{
rulesetStream.Load( docReader );
}
rulesetRoot = (YamlMappingNode)rulesetStream.Documents[0].RootNode;
foreach( System.Collections.Generic.KeyValuePair<YamlNode, YamlNode> child in rulesetRoot.Children )
{
// child are "<name>:" markers in the yaml
TreeNode coreNode = null;
TreeNode objNode = null;
switch( child.Key.ToString() )
{
case "countries":
coreNode = oxcTree.Nodes.Add( "Countries" );
coreNode.Tag = child.Value;
rulesetCountries = new Rulesets.Countries();
rulesetCountries.Load( (YamlSequenceNode)child.Value );
foreach( Rulesets.Country c in rulesetCountries.CountryList )
{
objNode = coreNode.Nodes.Add( c.CountryString );
objNode.Tag = c;
}
break;
case "regions":
coreNode = oxcTree.Nodes.Add( "Regions" );
coreNode.Tag = child.Value;
break;
}
/*
if( coreNode == null )
{
coreNode = oxcTree.Nodes.Add( child.Key.ToString() );
coreNode.Tag = child.Value;
}
*/
}
}
}
public void LoadSimpleDocument() {
var stream = new YamlStream();
stream.Load(YamlFile("test2.yaml"));
Assert.AreEqual(1, stream.Documents.Count);
Assert.IsInstanceOf<YamlScalarNode>(stream.Documents[0].RootNode);
Assert.AreEqual("a scalar", ((YamlScalarNode)stream.Documents[0].RootNode).Value);
}
public void LoadSimpleDocument() {
var stream = new YamlStream();
stream.Load(Yaml.StreamFrom("02-scalar-in-imp-doc.yaml"));
Assert.Equal(1, stream.Documents.Count);
Assert.IsType<YamlScalarNode>(stream.Documents[0].RootNode);
Assert.Equal("a scalar", ((YamlScalarNode)stream.Documents[0].RootNode).Value);
}
public static IEnumerable<Classification> load(StreamReader input)
{
// Load the stream
var yaml = new YamlStream();
yaml.Load(input);
var root = (YamlMappingNode)yaml.Documents[0].RootNode;
return load(root);
}
public static YamlStream ReadFromFile(string path)
{
StreamReader sr = new StreamReader(path);
string content = sr.ReadToEnd();
var input = new StringReader(content);
var yaml = new YamlStream();
yaml.Load(input);
return yaml;
}
public static Version GetPackageVersion(string fullPath)
{
try
{
foreach (var packageFullPath in EnumeratePackageFullPaths(fullPath))
{
// Load the package as a Yaml dynamic node, so that we can check Xenko version from dependencies
var input = new StringReader(File.ReadAllText(packageFullPath));
var yamlStream = new YamlStream();
yamlStream.Load(input);
dynamic yamlRootNode = new DynamicYamlMapping((YamlMappingNode)yamlStream.Documents[0].RootNode);
SemanticVersion dependencyVersion = null;
foreach (var dependency in yamlRootNode.Meta.Dependencies)
{
// Support paradox legacy projects
if ((string)dependency.Name == "Xenko" || (string)dependency.Name == "Paradox")
{
dependencyVersion = new SemanticVersion((string)dependency.Version);
// Paradox 1.1 was having incorrect version set (1.0), read it from .props file
if (dependencyVersion.Version.Major == 1 && dependencyVersion.Version.Minor == 0)
{
var propsFilePath = Path.Combine(Path.GetDirectoryName(packageFullPath) ?? "", Path.GetFileNameWithoutExtension(packageFullPath) + ".props");
if (File.Exists(propsFilePath))
{
using (XmlReader propsReader = XmlReader.Create(propsFilePath))
{
propsReader.MoveToContent();
if (propsReader.ReadToDescendant("SiliconStudioPackageParadoxVersion"))
{
if (propsReader.Read())
{
dependencyVersion = new SemanticVersion(propsReader.Value);
}
}
}
}
}
break;
}
}
// Stop after first version
if (dependencyVersion != null)
{
return new Version(dependencyVersion.Version.Major, dependencyVersion.Version.Minor);
}
}
}
catch (Exception)
{
}
return null;
}
public void AccessingAllNodesOnInfinitelyRecursiveDocumentThrows()
{
var stream = new YamlStream();
stream.Load(Yaml.ParserForText("&a [*a]"));
var accessAllNodes = new Action(() => stream.Documents.Single().AllNodes.ToList());
accessAllNodes.ShouldThrow<MaximumRecursionLevelReachedException>("because the document is infinitely recursive.");
}
public IEnumerable<YamlDocument> Parse(string yaml)
{
using (var stream = new StringReader(yaml))
{
var yamlStream = new YamlStream();
yamlStream.Load (stream);
return yamlStream.Documents;
}
}
/// <summary>
/// Create the template output
/// </summary>
public virtual string TransformText()
{
this.Write("\r\n");
#line 10 "C:\Users\dean\projs\iRacingReplayOverlay.net\iRacingSDK.Net\GenerateDataModels\SessionInfoTemplate.tt"
var data = iRacing.GetDataFeed().First();
var yaml = new YamlStream();
yaml.Load(new StringReader(data.SessionData.Raw));
var mapping = (YamlMappingNode)yaml.Documents[0].RootNode;
#line default
#line hidden
this.Write(@"
// This file is part of iRacingSDK.
//
// Copyright 2014 Dean Netherton
// https://github.com/vipoo/iRacingSDK.Net
//
// iRacingSDK is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// iRacingSDK is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with iRacingSDK. If not, see <http://www.gnu.org/licenses/>.
using System;
using System.Collections.Generic;
using System.Linq;
namespace iRacingSDK
{
public partial class SessionData
{
");
#line 47 "C:\Users\dean\projs\iRacingReplayOverlay.net\iRacingSDK.Net\GenerateDataModels\SessionInfoTemplate.tt"
foreach(var kv in mapping)
Process(kv.Key.ToString(), kv.Value);
#line default
#line hidden
this.Write(" }\r\n}\r\n\r\n");
return this.GenerationEnvironment.ToString();
}
public static IEnumerable<OptionSource> FromFile(string fileName, string sectionName = null)
{
var options = new List<OptionSource>();
if (!File.Exists(fileName))
{
throw new FileNotFoundException(fileName);
}
var yamlStream = new YamlStream();
var reader = new StringReader(File.ReadAllText(fileName));
try
{
yamlStream.Load(reader);
}
catch (Exception ex)
{
throw new OptionException(String.Format("An invalid configuration file has been specified. {0}{1}", Environment.NewLine, ex.Message), "config");
}
var yamlNode = (YamlMappingNode)yamlStream.Documents[0].RootNode;
if (!String.IsNullOrEmpty(sectionName))
{
Func<KeyValuePair<YamlNode, YamlNode>, bool> predicate = x =>
x.Key.ToString() == sectionName && x.Value.GetType() == typeof(YamlMappingNode);
var nodeExists = yamlNode.Children.Any(predicate);
if (nodeExists)
{
yamlNode = (YamlMappingNode)yamlNode.Children.First(predicate).Value;
}
}
foreach (var yamlElement in yamlNode.Children)
{
var yamlScalarNode = yamlElement.Value as YamlScalarNode;
var yamlSequenceNode = yamlElement.Value as YamlSequenceNode;
if (yamlSequenceNode != null)
{
var values = yamlSequenceNode.Children.Select(x => ((YamlScalarNode)x).Value);
try
{
//TODO GFY DO WE PREFER STRINGS OR TYPES HERE?
options.Add(OptionSource.String("Config File", yamlElement.Key.ToString(), values.ToArray()));
}
catch (InvalidCastException)
{
var message = String.Format("Please ensure that {0} is a valid YAML array.{1}", yamlElement.Key, Environment.NewLine);
throw new OptionException(message, yamlElement.Key.ToString());
}
}
else if (yamlScalarNode != null)
{
options.Add(OptionSource.String("Config File", yamlElement.Key.ToString(), yamlElement.Value.ToString()));
}
}
return options;
}
public static IList<Endpoint> FromString(string data)
{
_fileDirectory = CurrentDirectory;
var yaml = new YamlStream();
using(var streamReader = new StringReader(data)) {
yaml.Load(streamReader);
}
return Parse(yaml);
}
public AddonYamlConfig(string configdir, string configfile)
{
var yaml = new YamlStream();
yaml.Load(File.OpenText(Path.Combine(configdir, configfile)));
Log.Notice("RssAddonConfig", sLConsole.GetString("Config file is loading."));
var rssmap = (yaml.Documents.Count > 0 && ((YamlMappingNode)yaml.Documents[0].RootNode).Children.ContainsKey("RssAddon")) ? ((YamlMappingNode)((YamlMappingNode)yaml.Documents[0].RootNode).Children["RssAddon".ToYamlNode()]).Children : YamlExtensions.NullYMap;
RssMap(rssmap.GetYamlChildren("Rss"));
Log.Success("RssAddonConfig", sLConsole.GetString("Config database is loading."));
}
private static NamedModel ParseModel(string input)
{
if (input == null) throw new ArgumentNullException("input");
using (var yamlSource = File.OpenText(input))
{
var stream = new YamlStream();
stream.Load(yamlSource);
var visitor = new ComposeNamedModelVisitor();
stream.Accept(visitor);
return visitor.Model;
}
}
public YamlConfigReader(string path)
{
_yamlStream = new YamlStream();
string fileContext = GetContentYamlFile(path);
try
{
_yamlStream.Load(new StringReader(fileContext));
}
catch (SyntaxErrorException exception)
{
throw new DataSourseException("Incorrect config file.", exception);
}
}
public void YamlNodeGraphsAreBinarySerializeable()
{
var stream = new YamlStream();
stream.Load(Yaml.StreamFrom("fail-backreference.yaml"));
var formatter = new BinaryFormatter();
var memoryStream = new MemoryStream();
formatter.Serialize(memoryStream, stream.Documents[0].RootNode);
memoryStream.Position = 0;
var result = (YamlNode)formatter.Deserialize(memoryStream);
Assert.Equal(stream.Documents[0].RootNode, result);
}
public ShortcutProvider()
{
string folder = Path.GetDirectoryName(Process.GetCurrentProcess().MainModule.FileName) + @"\Keymaps\";
string filter = "*.yml";
if (!Directory.Exists(folder)) return;
string[] files = Directory.GetFiles(folder, filter);
var yaml = new YamlStream();
foreach (string file in files)
{
yaml.Load(File.OpenText(file));
var root = yaml.Documents[0].RootNode;
var collection = root as YamlMappingNode;
if (collection != null)
{
string group = GetValueByKey(collection, "group");
string process = GetValueByKey(collection, "process");
var shortcutCollection = new ShortcutCollection { Process = process, Group = group };
var groupShortcuts = collection.Children.First(n => n.Key.ToString() == "shortcuts").Value as YamlSequenceNode;
foreach (YamlMappingNode entry in groupShortcuts.Children)
{
string name = GetValueByKey(entry, "name");
if (entry.Children.First(n => n.Key.ToString() == "keys").Value as YamlSequenceNode == null)
continue;
var keys = entry.Children.First(n => n.Key.ToString() == "keys").Value as YamlSequenceNode;
foreach (var keyCombo in keys.Children)
{
var definitions = new List<KeyPressDefinition>();
string[] combos = keyCombo.ToString().Split(',');
foreach (string combo in combos)
{
var definition = GetKeyPressDefintion(combo);
if (definition != null)
definitions.Add(definition);
}
if (definitions.Count > 0)
shortcutCollection.Add(new KeyShortcut(name, definitions.ToArray()));
}
}
shortcuts.Add(shortcutCollection);
}
}
}
public IEnumerable<IDocument> Execute(IReadOnlyList<IDocument> inputs, IExecutionContext context)
{
return inputs
.AsParallel()
.Select(x =>
{
try
{
Dictionary<string, object> items = new Dictionary<string, object>();
using (TextReader contentReader = new StringReader(x.Content))
{
YamlStream yamlStream = new YamlStream();
yamlStream.Load(contentReader);
if (yamlStream.Documents.Count > 0)
{
if (!string.IsNullOrEmpty(_key))
{
items[_key] = new DynamicYaml(yamlStream.Documents[0].RootNode);
}
if (_flatten)
{
foreach (YamlDocument document in yamlStream.Documents)
{
// Map scalar-to-scalar children
foreach (KeyValuePair<YamlNode, YamlNode> child in
((YamlMappingNode)document.RootNode).Children.Where(y => y.Key is YamlScalarNode && y.Value is YamlScalarNode))
{
items[((YamlScalarNode)child.Key).Value] = ((YamlScalarNode)child.Value).Value;
}
// Map simple sequences
foreach (KeyValuePair<YamlNode, YamlNode> child in
((YamlMappingNode) document.RootNode).Children.Where(y => y.Key is YamlScalarNode && y.Value is YamlSequenceNode && ((YamlSequenceNode)y.Value).All(z => z is YamlScalarNode)))
{
items[((YamlScalarNode)child.Key).Value] = ((YamlSequenceNode)child.Value).Select(a => ((YamlScalarNode)a).Value).ToArray();
}
}
}
}
}
return x.Clone(items);
}
catch (Exception ex)
{
context.Trace.Error("Error processing YAML for {0}: {1}", x.Source, ex.ToString());
}
return null;
})
.Where(x => x != null);
}
static IEnumerable<YamlMappingNode> GetYamlMappings(IEnumerable<string> filePaths)
{
var yaml = new YamlStream();
foreach (var file in filePaths)
{
yaml.Load(File.OpenText(file));
var root = yaml.Documents[0].RootNode;
var collection = root as YamlMappingNode;
if (collection != null)
yield return collection;
}
}
public IDictionary<string, string> Parse(Stream stream)
{
var data = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
var yamlConfig = new YamlStream();
yamlConfig.Load(new StreamReader(stream));
var mapping =
(YamlMappingNode)yamlConfig.Documents[0].RootNode;
VisitYamlMappingNode(mapping);
return _data;
}
/// <summary>
/// Writes a YAML representation of this callable to a text writer.
/// </summary>
/// <param name="text">The writer to output to</param>
internal override void WriteToFile(TextWriter text)
{
YamlNode BuildInputNode()
{
var inputNode = new YamlMappingNode();
inputNode.AddStringMapping(Utils.ContentsKey, this.inputContent);
var typesNode = new YamlSequenceNode();
inputNode.Add(Utils.TypesListKey, typesNode);
foreach (var declaration in SyntaxGenerator.ExtractItems(this.callable.ArgumentTuple))
{
var argNode = new YamlMappingNode();
var argName = ((QsLocalSymbol.ValidName)declaration.VariableName).Item.Value;
argNode.AddStringMapping(Utils.NameKey, argName);
if (this.comments.Input.TryGetValue(argName, out string summary))
{
argNode.AddStringMapping(Utils.SummaryKey, summary);
}
Utils.ResolvedTypeToYaml(declaration.Type, argNode);
typesNode.Add(argNode);
}
return(inputNode);
}
YamlNode BuildOutputNode()
{
var outputNode = new YamlMappingNode();
outputNode.AddStringMapping(Utils.ContentsKey, this.outputType);
var typesNode = new YamlSequenceNode();
outputNode.Add(Utils.TypesListKey, typesNode);
var outputTypeNode = new YamlMappingNode();
typesNode.Add(outputTypeNode);
if (!string.IsNullOrEmpty(this.comments.Output))
{
outputTypeNode.AddStringMapping(Utils.SummaryKey, this.comments.Output);
}
Utils.ResolvedTypeToYaml(this.callable.Signature.ReturnType, outputTypeNode);
return(outputNode);
}
var rootNode = new YamlMappingNode();
rootNode.AddStringMapping(Utils.UidKey, this.uid);
rootNode.AddStringMapping(Utils.NameKey, this.name);
rootNode.AddStringMapping(Utils.TypeKey, this.itemType);
rootNode.AddStringMapping(Utils.NamespaceKey, this.namespaceName);
if (!string.IsNullOrWhiteSpace(this.comments.Documentation))
{
rootNode.AddStringMapping(Utils.SummaryKey, this.comments.Documentation);
}
if (!string.IsNullOrWhiteSpace(this.comments.Remarks))
{
rootNode.AddStringMapping(Utils.RemarksKey, this.comments.Remarks);
}
if (!string.IsNullOrWhiteSpace(this.comments.Example))
{
rootNode.AddStringMapping(Utils.ExamplesKey, this.comments.Example);
}
rootNode.AddStringMapping(Utils.SyntaxKey, this.syntax);
if (!string.IsNullOrWhiteSpace(this.comments.References))
{
rootNode.AddStringMapping(Utils.ReferencesKey, this.comments.References);
}
rootNode.Add(Utils.InputKey, BuildInputNode());
rootNode.Add(Utils.OutputKey, BuildOutputNode());
if (this.comments.TypeParameters.Count > 0)
{
rootNode.Add(Utils.TypeParamsKey, Utils.BuildSequenceMappingNode(this.comments.TypeParameters));
}
if (this.functors.Count > 0)
{
rootNode.Add(Utils.FunctorsKey, Utils.BuildSequenceNode(this.functors));
}
if (this.comments.SeeAlso.Count > 0)
{
rootNode.Add(Utils.SeeAlsoKey, Utils.BuildSequenceNode(this.comments.SeeAlso));
}
var doc = new YamlDocument(rootNode);
var stream = new YamlStream(doc);
text.WriteLine("### " + Utils.QsYamlMime + Utils.AutogenerationWarning);
stream.Save(text, false);
}
/*
* DoPostprocess() is called when build performed.
* @param [in] reports collection of AssetBundleBuildReport from each BundleBuilders.
*/
public void DoPostprocess(IEnumerable <AssetBundleBuildReport> buildReports, IEnumerable <ExportReport> exportReports)
{
// リスト名とversionから、出力するlistの名称を決め、ファイルを移動させる。
// なんらか対象の設定の把握ができるといいんだけど、exportPathからとるか。
var sampleExportArray = exportReports.ToArray();
if (sampleExportArray == null || sampleExportArray.Length == 0)
{
// no exports found.
return;
}
// pick first exporter only.
if (!sampleExportArray[0].ExportedItems.Any())
{
// empty exports.
return;
}
var exportPlatformStr = BuildTargetUtility.TargetToAssetBundlePlatformName(EditorUserBuildSettings.activeBuildTarget);
var platformDelimiter = exportPlatformStr + "/" + exportPlatformStr + ".manifest";// XPlatform/XPlatform.manifest
var rootManifestEntry = sampleExportArray[0].ExportedItems.Where(p => p.destination.Contains(platformDelimiter)).FirstOrDefault();
if (rootManifestEntry == null)
{
Debug.Log("no exported root manifest with :" + platformDelimiter + " found.");
return;
}
// full path for export base path.
var wholeExportFolderPath = rootManifestEntry.destination.Substring(0, rootManifestEntry.destination.IndexOf(platformDelimiter) - 1 /*remove last / */);
var graphName = new DirectoryInfo(wholeExportFolderPath).Name;
var settingFilePath = EditVersionJson(graphName);
var settingFileData = string.Empty;
using (var sr = new StreamReader(settingFilePath))
{
settingFileData = sr.ReadToEnd();
}
var settingProfile = JsonUtility.FromJson <ListProfile>(settingFileData);
var listIdentity = settingProfile.identity;
var listVersion = settingProfile.version;
var rootManifestPath = rootManifestEntry.destination;
Debug.Log("generating AssetBundleList. rootManifestPath:" + rootManifestPath + " generate list identity:" + listIdentity + " version:" + listVersion);
var targetDirectory = FileController.PathCombine(wholeExportFolderPath, exportPlatformStr, listVersion);
// check if version folder is exists.
if (Directory.Exists(targetDirectory))
{
Debug.Log("same version files are already exists. list identity:" + listIdentity + " version:" + listVersion + " path:" + targetDirectory + " need to delete directory or modify list version. for editing list version, open Window > Autoya > Open AssetBundleListVersionEditor. ");
return;
}
// create version directory under exportPlatformStr.
// then copy necessary files.
{
Directory.CreateDirectory(targetDirectory);
foreach (var exportReport in exportReports)
{
var items = exportReport.ExportedItems;
foreach (var item in items)
{
var currentPath = item.destination;
// skip root manifest and root file.
if (currentPath.Contains(exportPlatformStr + "/" + exportPlatformStr))
{
continue;
}
// skip manifest file.
if (currentPath.EndsWith(".manifest"))
{
continue;
}
var fileName = Path.GetFileName(currentPath);
if (fileName == listIdentity + ".json")
{
throw new Exception("generated AssetBundle name:" + listIdentity + ".json is overlapped with list name. please change assetBundle name, extension or list identity.");
}
var dirPath = Path.GetDirectoryName(currentPath);
var destPath = FileController.PathCombine(dirPath, listVersion, fileName);
File.Copy(currentPath, destPath);
}
}
}
// root manifest から全てのbundleの依存関係を取り出す + 各bundleのManifestから詳細を取得する。
{
var bundleAndDependencies = new List <AssetBundleInfo>();
/*
* load root manifest file and get assetBundle names and dependencies.
*/
using (var sr = new StreamReader(rootManifestPath))
{
// read root manifest file.
{
var rootYaml = new YamlStream();
rootYaml.Load(sr);
var rootMapping = (YamlMappingNode)rootYaml.Documents[0].RootNode;
foreach (var root_item in rootMapping)
{
var rootKey = ((YamlScalarNode)root_item.Key).Value;
switch (rootKey)
{
case "ManifestFileVersion":
{
// Debug.LogError("ManifestFileVersion:" + ((YamlScalarNode)root_item.Value).Value);
break;
}
case "AssetBundleManifest":
{
var assetBundleManifestMapping = (YamlMappingNode)root_item.Value;
foreach (var assetBundleManifestMapping_item in assetBundleManifestMapping)
{
var manifestKey = ((YamlScalarNode)assetBundleManifestMapping_item.Key).Value;
switch (manifestKey)
{
case "AssetBundleInfos":
{
var manifestInfoSeq = (YamlMappingNode)assetBundleManifestMapping_item.Value;
foreach (var manifestInfo_item in manifestInfoSeq)
{
var bundleInfo = new AssetBundleInfo();
var bundleInfoMapping = (YamlMappingNode)manifestInfo_item.Value;
foreach (var info_item in bundleInfoMapping)
{
var infoKey = ((YamlScalarNode)info_item.Key).Value;
switch (infoKey)
{
case "Name":
{
var name = ((YamlScalarNode)info_item.Value).Value;
// Debug.LogError("name:" + name);
bundleInfo.bundleName = name;
break;
}
case "Dependencies":
{
var dependenciesMapping = (YamlMappingNode)info_item.Value;
foreach (var dependency_item in dependenciesMapping)
{
var dependentBundleName = ((YamlScalarNode)dependency_item.Value).Value;
// Debug.LogError("dependentBundleName:" + dependentBundleName);
}
var dependentBundleNames = dependenciesMapping.Select(t => ((YamlScalarNode)t.Value).Value).ToArray();
bundleInfo.dependsBundleNames = dependentBundleNames;
break;
}
}
}
bundleAndDependencies.Add(bundleInfo);
}
break;
}
}
}
break;
}
}
}
}
}
// create assetBundleList.
var assetBundleInfos = new List <AssetBundleInfo>();
var classIdSet = new HashSet <int>();
/*
* load each assetBundle info from bundle manifests.
*/
foreach (var bundleAndDependencie in bundleAndDependencies)
{
var targetBundleName = bundleAndDependencie.bundleName;
var newAssetBundleInfo = new AssetBundleInfo();
newAssetBundleInfo.bundleName = targetBundleName;
newAssetBundleInfo.dependsBundleNames = bundleAndDependencie.dependsBundleNames;
using (var sr = new StreamReader(FileController.PathCombine(wholeExportFolderPath, exportPlatformStr, targetBundleName + ".manifest")))
{
var rootYaml = new YamlStream();
rootYaml.Load(sr);
var rootMapping = (YamlMappingNode)rootYaml.Documents[0].RootNode;
foreach (var root_item in rootMapping)
{
var rootKey = ((YamlScalarNode)root_item.Key).Value;
switch (rootKey)
{
case "CRC":
{
var crc = Convert.ToUInt32(((YamlScalarNode)root_item.Value).Value);
// Debug.LogError("crc:" + crc);
newAssetBundleInfo.crc = crc;
break;
}
case "Assets":
{
var assetNamesSeq = (YamlSequenceNode)root_item.Value;
var assetNames = assetNamesSeq.Select(n => ((YamlScalarNode)n).Value).ToArray();
// foreach (var assetName in assetNames) {
// Debug.LogError("assetName:" + assetName);
// }
newAssetBundleInfo.assetNames = assetNames;
break;
}
case "Hashes":
{
var hashMapping = (YamlMappingNode)root_item.Value;
foreach (var hash_item in hashMapping)
{
var hashKey = ((YamlScalarNode)hash_item.Key).Value;
switch (hashKey)
{
case "AssetFileHash":
{
var assetHashMapping = (YamlMappingNode)hash_item.Value;
foreach (var assetHash_item in assetHashMapping)
{
var assetHashKey = ((YamlScalarNode)assetHash_item.Key).Value;
switch (assetHashKey)
{
case "Hash":
{
var hashStr = ((YamlScalarNode)assetHash_item.Value).Value;
// Debug.LogError("hashStr:" + hashStr);
newAssetBundleInfo.hash = hashStr;
break;
}
}
}
break;
}
}
}
break;
}
case "ClassTypes":
{
var seq = (YamlSequenceNode)root_item.Value;
foreach (var iSeq in seq)
{
var innerMap = (YamlMappingNode)iSeq;
foreach (var map in innerMap)
{
switch ((string)map.Key)
{
case "Class":
{
classIdSet.Add(Convert.ToInt32((string)map.Value));
break;
}
}
}
}
break;
}
default:
{
// ignore.
break;
}
}
}
// set size.
newAssetBundleInfo.size = new FileInfo(FileController.PathCombine(wholeExportFolderPath, exportPlatformStr, targetBundleName)).Length;
// Debug.LogError("newAssetBundleInfo.size:" + newAssetBundleInfo.size);
assetBundleInfos.Add(newAssetBundleInfo);
}
}
var assetBundleList = new AssetBundleList(listIdentity, exportPlatformStr, listVersion, assetBundleInfos.ToArray());
var str = JsonUtility.ToJson(assetBundleList, true);
var listOutputPath = FileController.PathCombine(wholeExportFolderPath, exportPlatformStr, listVersion, listIdentity + ".json");
using (var sw = new StreamWriter(listOutputPath))
{
sw.WriteLine(str);
}
// generate Link.xml
LinkXMLGenerator.ExportLinkXMLWithUsingClassIds(Application.dataPath, classIdSet.ToArray());
}
}
private void CheckModUpdate_Click(object sender, EventArgs e)
{
SaveConfig();
var gamedir = profiles[MinecraftProfileList.SelectedIndex].GameDir;
var moddir = gamedir + @"\mods";
var remoteMods = new Dictionary <string, string>();
string version = null;
DateTime lastModified = DateTime.Now;
Dictionary <string, string> addMods = null, delMods = null;
// check update
var dialog = new TaskDialog()
{
Caption = Application.ProductName,
InstructionText = "Mod の更新を確認しています...",
StandardButtons = TaskDialogStandardButtons.Cancel,
ProgressBar = new TaskDialogProgressBar()
{
State = TaskDialogProgressBarState.Marquee
},
OwnerWindowHandle = Handle,
};
dialog.Opened += async(_sender, _e) => {
dialog.Text = "Mod の一覧を取得しています...";
try {
var req = WebRequest.Create(config.RepositoryUrl + "modlist.yml") as HttpWebRequest;
using (var res = await req.GetResponseAsync() as HttpWebResponse) {
// header
lastModified = DateTime.Parse(res.GetResponseHeader("Last-Modified"));
// body
using (var stream = res.GetResponseStream())
using (var sr = new StreamReader(stream, Encoding.UTF8)) {
var yml = new YamlStream();
yml.Load(sr);
var map = yml.Documents[0].RootNode as YamlMappingNode;
version = (map.Children[new YamlScalarNode("version")] as YamlScalarNode).Value;
var mods = map.Children[new YamlScalarNode("mods")] as YamlSequenceNode;
foreach (YamlMappingNode mod in mods)
{
foreach (var info in mod)
{
remoteMods.Add((info.Key as YamlScalarNode).Value, (info.Value as YamlScalarNode).Value);
}
}
}
}
} catch (Exception ex) {
Debug.WriteLine(ex.Message + Environment.NewLine + ex.StackTrace);
dialog.Close(TaskDialogResult.No);
return;
}
dialog.Text = "Mod の更新を確認しています...";
var excluded = config.ExcludedMods.ToDictionary(i => i, i => GetFileSHA1Hash(moddir + @"\" + i));
addMods = remoteMods.Except(localMods).ToDictionary(i => i.Key, i => i.Value);
delMods = localMods.Except(remoteMods).ToDictionary(i => i.Key, i => i.Value).Except(excluded).ToDictionary(i => i.Key, i => i.Value);
if (addMods.Count == 0 && delMods.Count == 0)
{
dialog.Close(TaskDialogResult.Ok);
return;
}
dialog.Close(TaskDialogResult.Yes);
};
var result = dialog.Show();
if (result == TaskDialogResult.Ok)
{
new TaskDialog()
{
Caption = Application.ProductName,
InstructionText = "Mod の更新はありません",
Icon = TaskDialogStandardIcon.Information,
OwnerWindowHandle = Handle,
}.Show();
return;
}
else if (result == TaskDialogResult.No)
{
new TaskDialog()
{
Caption = Application.ProductName,
InstructionText = "エラーが発生しました",
Text = "更新の確認中にエラーが発生しました。",
Icon = TaskDialogStandardIcon.Error,
OwnerWindowHandle = Handle,
}.Show();
return;
}
else if (result != TaskDialogResult.Yes)
{
return;
}
var br = Environment.NewLine;
var adds = string.Join(br, addMods.Keys.ToArray());
var dels = string.Join(br, delMods.Keys.ToArray());
if (adds == string.Empty)
{
adds = "なし";
}
if (dels == string.Empty)
{
dels = "なし";
}
string detail =
"Forge バージョン: " + version + br
+ "変更日時: " + lastModified.ToLocalTime().ToString() + br
+ br
+ "追加される Mod:" + br
+ adds + br
+ br
+ "削除される Mod:" + br
+ dels;
dialog = new TaskDialog()
{
Caption = Application.ProductName,
InstructionText = "Mod の更新を適用しますか?",
Text = "これにより、" + addMods.Count + " 個の Mod が追加、" + delMods.Count + " 個の Mod が削除されます。",
Icon = TaskDialogStandardIcon.Warning,
StandardButtons = TaskDialogStandardButtons.Yes | TaskDialogStandardButtons.No,
OwnerWindowHandle = Handle,
DetailsCollapsedLabel = "詳細情報",
DetailsExpandedLabel = "詳細情報を非表示",
ExpansionMode = TaskDialogExpandedDetailsLocation.ExpandFooter,
DetailsExpandedText = detail,
};
var confirmResult = dialog.Show();
if (confirmResult != TaskDialogResult.Yes)
{
return;
}
// apply update
dialog = new TaskDialog()
{
Caption = Application.ProductName,
InstructionText = "Mod ファイルの変更を開始しています...",
StandardButtons = TaskDialogStandardButtons.Cancel,
ProgressBar = new TaskDialogProgressBar()
{
State = TaskDialogProgressBarState.Marquee
},
OwnerWindowHandle = Handle,
};
dialog.Opened += async(_sender, _e) => {
bool flag;
do
{
flag = false;
string pid = null;
using (var win32proc = new System.Management.ManagementClass("Win32_Process"))
using (var ps = win32proc.GetInstances()) {
foreach (var p in ps)
{
if (p.GetPropertyValue("Name").ToString().Contains("java") && p.GetPropertyValue("CommandLine").ToString().Contains("minecraft"))
{
flag = true;
pid = p.GetPropertyValue("ProcessId").ToString();
break;
}
}
}
if (flag)
{
var confirm = new TaskDialog()
{
Caption = Application.ProductName,
InstructionText = "Minecraft が起動中です",
Text = "Minecraft が起動しているため Mod の更新ができません。" + br + "アプリケーションを終了後させ [再試行] を押してください。" + br + "中止する場合は [キャンセル] を押してください。",
Icon = TaskDialogStandardIcon.Warning,
StandardButtons = TaskDialogStandardButtons.Retry | TaskDialogStandardButtons.Cancel,
OwnerWindowHandle = Handle,
}.Show();
if (confirm == TaskDialogResult.Cancel)
{
dialog.Close(TaskDialogResult.Cancel);
return;
}
}
} while (flag);
var i = 0;
dialog.InstructionText = "Mod を削除しています...";
foreach (var mod in delMods)
{
dialog.Text = "(" + ++i + "/" + delMods.Count + ") " + mod.Key;
File.Delete(moddir + @"\" + mod.Key);
await Task.Run(() => System.Threading.Thread.Sleep(100));
}
i = 0;
var failed = 0;
dialog.InstructionText = "Mod をダウンロードしています...";
using (var wc = new WebClient()) {
foreach (var mod in addMods)
{
dialog.Text = "(" + ++i + "/" + addMods.Count + ") " + mod.Key;
try {
wc.DownloadFileAsync(new Uri(config.RepositoryUrl + @"/" + version + @"/" + mod.Key), moddir + @"\" + mod.Key);
} catch (Exception ex) {
Debug.WriteLine(ex.Message + Environment.NewLine + ex.StackTrace);
failed++;
}
await Task.Run(() => System.Threading.Thread.Sleep(100));
}
}
dialog.Close();
new TaskDialog()
{
Caption = Application.ProductName,
InstructionText = "変更を適用しました",
Text = addMods.Count + "個の Mod を追加、" + delMods.Count + "個の Mod を削除しました。" + (failed > 0 ? br + failed + " 個の Mod のダウンロードが失敗しました。" : ""),
Icon = TaskDialogStandardIcon.Information,
StandardButtons = TaskDialogStandardButtons.Ok,
OwnerWindowHandle = Handle,
}.Show();
};
result = dialog.Show();
UpdateLocalMods();
}
public void LoadLarge()
{
var yamlStream = new YamlStream();
yamlStream.Load(new StringReader(yamlString));
}
public static bool MigrateAssetIfNeeded(AssetMigrationContext context, PackageLoadingAssetFile loadAsset)
{
var assetFullPath = loadAsset.FilePath.FullPath;
// Determine if asset was Yaml or not
var assetFileExtension = Path.GetExtension(assetFullPath);
if (assetFileExtension == null)
{
return(false);
}
assetFileExtension = assetFileExtension.ToLowerInvariant();
var serializer = AssetSerializer.FindSerializer(assetFileExtension);
if (!(serializer is AssetYamlSerializer))
{
return(false);
}
// We've got a Yaml asset, let's get expected and serialized versions
var serializedVersion = 0;
int expectedVersion;
Type assetType;
// Read from Yaml file the asset version and its type (to get expected version)
// Note: It tries to read as few as possible (SerializedVersion is expected to be right after Id, so it shouldn't try to read further than that)
using (var assetStream = loadAsset.OpenStream())
using (var streamReader = new StreamReader(assetStream))
{
var yamlEventReader = new EventReader(new Parser(streamReader));
// Skip header
yamlEventReader.Expect <StreamStart>();
yamlEventReader.Expect <DocumentStart>();
var mappingStart = yamlEventReader.Expect <MappingStart>();
var yamlSerializerSettings = YamlSerializer.GetSerializerSettings();
var tagTypeRegistry = yamlSerializerSettings.TagTypeRegistry;
bool typeAliased;
assetType = tagTypeRegistry.TypeFromTag(mappingStart.Tag, out typeAliased);
expectedVersion = AssetRegistry.GetCurrentFormatVersion(assetType);
Scalar assetKey;
while ((assetKey = yamlEventReader.Allow <Scalar>()) != null)
{
// Only allow Id before SerializedVersion
if (assetKey.Value == "Id")
{
yamlEventReader.Skip();
continue;
}
if (assetKey.Value == "SerializedVersion")
{
serializedVersion = Convert.ToInt32(yamlEventReader.Expect <Scalar>().Value, CultureInfo.InvariantCulture);
break;
}
}
}
if (serializedVersion > expectedVersion)
{
// Try to open an asset newer than what we support (probably generated by a newer Paradox)
throw new InvalidOperationException(string.Format("Asset of type {0} has been serialized with newer version {1}, but only version {2} is supported. Was this asset created with a newer version of Paradox?", assetType, serializedVersion, expectedVersion));
}
if (serializedVersion < expectedVersion)
{
// Perform asset upgrade
context.Log.Verbose("{0} needs update, from version {1} to version {2}", Path.GetFullPath(assetFullPath), serializedVersion, expectedVersion);
// transform the stream into string.
string assetAsString;
using (var assetStream = loadAsset.OpenStream())
using (var assetStreamReader = new StreamReader(assetStream, Encoding.UTF8))
{
assetAsString = assetStreamReader.ReadToEnd();
}
// Load the asset as a YamlNode object
var input = new StringReader(assetAsString);
var yamlStream = new YamlStream();
yamlStream.Load(input);
var yamlRootNode = (YamlMappingNode)yamlStream.Documents[0].RootNode;
// Check if there is any asset updater
var assetUpgraders = AssetRegistry.GetAssetUpgraders(assetType);
if (assetUpgraders == null)
{
throw new InvalidOperationException(string.Format("Asset of type {0} should be updated from version {1} to {2}, but no asset migration path was found", assetType, serializedVersion, expectedVersion));
}
// Instantiate asset updaters
var currentVersion = serializedVersion;
while (currentVersion != expectedVersion)
{
int targetVersion;
// This will throw an exception if no upgrader is available for the given version, exiting the loop in case of error.
var upgrader = assetUpgraders.GetUpgrader(currentVersion, out targetVersion);
upgrader.Upgrade(context, currentVersion, targetVersion, yamlRootNode, loadAsset);
currentVersion = targetVersion;
}
// Make sure asset is updated to latest version
YamlNode serializedVersionNode;
var newSerializedVersion = 0;
if (yamlRootNode.Children.TryGetValue(new YamlScalarNode("SerializedVersion"), out serializedVersionNode))
{
newSerializedVersion = Convert.ToInt32(((YamlScalarNode)serializedVersionNode).Value);
}
if (newSerializedVersion != expectedVersion)
{
throw new InvalidOperationException(string.Format("Asset of type {0} was migrated, but still its new version {1} doesn't match expected version {2}.", assetType, newSerializedVersion, expectedVersion));
}
context.Log.Info("{0} updated from version {1} to version {2}", Path.GetFullPath(assetFullPath), serializedVersion, expectedVersion);
var preferredIndent = YamlSerializer.GetSerializerSettings().PreferredIndent;
// Save asset back to disk
using (var memoryStream = new MemoryStream())
{
using (var streamWriter = new StreamWriter(memoryStream))
{
yamlStream.Save(streamWriter, true, preferredIndent);
}
loadAsset.AssetContent = memoryStream.ToArray();
}
return(true);
}
return(false);
}
void LoadGames()
{
var yaml = new YamlStream();
yaml.Load(new StringReader(File.ReadAllText("Games.yaml")));
var mapping = (YamlMappingNode)yaml.Documents[0].RootNode;
Games = new Dictionary <string, AGame>();
foreach (var g in mapping)
{
string code, name, creator;
EngineType engineType = EngineType.M4A; ReverbType reverbType = ReverbType.Normal;
byte engineReverb = 0, engineVolume = 0xF, engineTrackLimit = 0x10;
int engineFrequency = 13379; bool engineHasGoldenSunSynths = false;
int[] tables, tableSizes;
List <APlaylist> playlists;
string remap = string.Empty;
int voiceTable = 0, sampleTable = 0, sampleTableSize = 0;
code = g.Key.ToString();
var game = (YamlMappingNode)g.Value;
// Basic info
name = game.Children["Name"].ToString();
// SongTables
var songTables = game.Children["SongTable"].ToString().Split(' ');
tables = new int[songTables.Length]; tableSizes = new int[songTables.Length];
for (int i = 0; i < songTables.Length; i++)
{
tables[i] = (int)Utils.ParseValue(songTables[i]);
}
// MLSS info
if (game.Children.TryGetValue("VoiceTable", out YamlNode vTable))
{
voiceTable = (int)Utils.ParseValue(vTable.ToString());
}
if (game.Children.TryGetValue("SampleTable", out YamlNode sTable))
{
sampleTable = (int)Utils.ParseValue(sTable.ToString());
}
if (game.Children.TryGetValue("SampleTableSize", out YamlNode saTableSize))
{
sampleTableSize = (int)Utils.ParseValue(saTableSize.ToString());
}
// If we are to copy another game's config
if (game.Children.TryGetValue("Copy", out YamlNode copy))
{
game = (YamlMappingNode)mapping.Children[copy];
}
// SongTable Sizes
string[] sizes = { };
if (game.Children.TryGetValue("SongTableSize", out YamlNode soTableSize))
{
sizes = soTableSize.ToString().Split(' ');
}
for (int i = 0; i < songTables.Length; i++)
{
tableSizes[i] = DefaultTableSize;
if (i < sizes.Length)
{
tableSizes[i] = (int)Utils.ParseValue(sizes[i]);
}
}
// Creator name (required)
creator = game.Children["Creator"].ToString();
// Remap
if (game.Children.TryGetValue("Remap", out YamlNode rmap))
{
remap = rmap.ToString();
}
// Engine
if (game.Children.TryGetValue("Engine", out YamlNode yeng))
{
var eng = (YamlMappingNode)yeng;
if (eng.Children.TryGetValue("Type", out YamlNode type))
{
engineType = (EngineType)Enum.Parse(typeof(EngineType), type.ToString());
}
if (eng.Children.TryGetValue("ReverbType", out YamlNode rType))
{
reverbType = (ReverbType)Enum.Parse(typeof(ReverbType), rType.ToString());
}
if (eng.Children.TryGetValue("Reverb", out YamlNode reverb))
{
engineReverb = (byte)Utils.ParseValue(reverb.ToString());
}
if (eng.Children.TryGetValue("Volume", out YamlNode volume))
{
engineVolume = (byte)Utils.ParseValue(volume.ToString());
}
if (eng.Children.TryGetValue("TrackLimit", out YamlNode trackLim))
{
engineTrackLimit = (byte)Utils.ParseValue(trackLim.ToString());
}
if (eng.Children.TryGetValue("Frequency", out YamlNode frequency))
{
engineFrequency = (int)Utils.ParseValue(frequency.ToString());
}
if (eng.Children.TryGetValue("GoldenSunSynths", out YamlNode synths))
{
engineHasGoldenSunSynths = bool.Parse(synths.ToString());
}
}
var engine = new AnEngine(engineType, reverbType, engineReverb, engineVolume, engineTrackLimit, engineFrequency, engineHasGoldenSunSynths);
// Load playlists
playlists = new List <APlaylist>();
if (game.Children.TryGetValue("Music", out YamlNode ymusic))
{
var music = (YamlMappingNode)ymusic;
foreach (var kvp in music)
{
var songs = new List <ASong>();
foreach (var song in (YamlMappingNode)kvp.Value)
{
songs.Add(new ASong(short.Parse(song.Key.ToString()), song.Value.ToString())); // No hex values. It prevents putting in duplicates by having one hex and one dec of the same song index
}
playlists.Add(new APlaylist(kvp.Key.ToString(), songs.ToArray()));
}
}
// Full playlist
if (!playlists.Any(p => p.Name == "Music"))
{
playlists.Insert(0, new APlaylist("Music", playlists.Select(p => p.Songs).UniteAll().OrderBy(s => s.Index).ToArray()));
}
// If playlist is empty, add an empty entry
for (int i = 0; i < playlists.Count; i++)
{
if (playlists[i].Songs.Length == 0)
{
playlists[i] = new APlaylist(playlists[i].Name, new ASong[] { new ASong(0, "La Playlist è vuota.") });
}
}
Games.Add(code, new AGame(code, name, creator, engine, tables, tableSizes, playlists, remap,
voiceTable, sampleTable, sampleTableSize));
}
}
public (World, Camera) LoadYaml(string yaml)
{
var world = new World();
Camera camera = null;
Materials = new Dictionary <string, Material>();
Transforms = new Dictionary <string, Matrix4x4>();
Objects = new Dictionary <string, Matrix4x4>();
using var reader = new StringReader(yaml);
var yamlStream = new YamlStream();
yamlStream.Load(reader);
var mapping = (YamlSequenceNode)yamlStream.Documents[0].RootNode;
foreach (var node in mapping)
{
var nodes = node.AllNodes.ToArray();
string command = ((YamlScalarNode)nodes[1]).Value.ToUpperInvariant();
string type = ((YamlScalarNode)nodes[2]).Value.ToUpperInvariant();
switch (command)
{
case "ADD":
switch (type)
{
case "CAMERA":
camera = ParseCamera(node);
break;
case "LIGHT":
world.Lights.Add(ParseLight(node));
break;
case "PLANE":
case "SPHERE":
case "CUBE":
world.Shapes.Add(ParseShape(node));
break;
default:
throw new Exception($"Add {type} not supported (line {node.Start.Line})");
}
break;
case "DEFINE":
var name = type;
type = type.Substring(type.LastIndexOf('-') + 1);
switch (type)
{
case "MATERIAL":
Materials.Add(name, ParseMaterialDefine(node));
break;
case "TRANSFORM":
Transforms.Add(name, ParseTransform(node.AllNodes.ToArray()[4]));
break;
case "OBJECT":
Objects.Add(name, ParseTransform(node.AllNodes.ToArray()[4]));
break;
default:
throw new Exception($"Define {name} not supported (line {node.Start.Line})");
}
break;
default:
throw new Exception($"Command {command} not supported (line {node.Start.Line})");
}
}
return(world, camera);
}
public void AllAliasesMustBeResolved()
{
var original = new YamlStream();
Assert.Throws <AnchorNotFoundException>(() => original.Load(Yaml.StreamFrom("invalid-reference.yaml")));
}
protected override void Visit(YamlStream stream)
{
WriteIndent();
Console.WriteLine("Visit(YamlStream)");
++indent;
}
public async Task Test()
{
var(client, server) = await StartConnectedServerDummyTickerClientPair();
await server.WaitIdleAsync();
var sResourceManager = server.ResolveDependency <IResourceManager>();
var prototypePath = new ResourcePath("/Prototypes/");
var paths = sResourceManager.ContentFindFiles(prototypePath)
.ToList()
.AsParallel()
.Where(filePath => filePath.Extension == "yml" &&
!filePath.Filename.StartsWith("."))
.ToArray();
var cComponentFactory = client.ResolveDependency <IComponentFactory>();
var sComponentFactory = server.ResolveDependency <IComponentFactory>();
var unknownComponentsClient = new List <(string entityId, string component)>();
var unknownComponentsServer = new List <(string entityId, string component)>();
var entitiesValidated = 0;
var componentsValidated = 0;
foreach (var path in paths)
{
var file = sResourceManager.ContentFileRead(path);
var reader = new StreamReader(file, Encoding.UTF8);
var yamlStream = new YamlStream();
Assert.DoesNotThrow(() => yamlStream.Load(reader), "Error while parsing yaml file {0}", path);
foreach (var document in yamlStream.Documents)
{
var root = (YamlSequenceNode)document.RootNode;
foreach (var node in root.Cast <YamlMappingNode>())
{
var prototypeType = node.GetNode("type").AsString();
if (prototypeType != "entity")
{
continue;
}
if (!node.TryGetNode <YamlSequenceNode>("components", out var components))
{
continue;
}
entitiesValidated++;
foreach (var component in components.Cast <YamlMappingNode>())
{
componentsValidated++;
var componentType = component.GetNode("type").AsString();
var clientAvailability = cComponentFactory.GetComponentAvailability(componentType);
if (clientAvailability == ComponentAvailability.Unknown)
{
var entityId = node.GetNode("id").AsString();
unknownComponentsClient.Add((entityId, componentType));
}
var serverAvailability = sComponentFactory.GetComponentAvailability(componentType);
if (serverAvailability == ComponentAvailability.Unknown)
{
var entityId = node.GetNode("id").AsString();
unknownComponentsServer.Add((entityId, componentType));
}
}
}
}
}
if (unknownComponentsClient.Count + unknownComponentsServer.Count == 0)
{
Assert.Pass($"Validated {entitiesValidated} entities with {componentsValidated} components in {paths.Length} files.");
return;
}
var message = new StringBuilder();
foreach (var unknownComponent in unknownComponentsClient)
{
message.Append(
$"CLIENT: Unknown component {unknownComponent.component} in prototype {unknownComponent.entityId}\n");
}
foreach (var unknownComponent in unknownComponentsServer)
{
message.Append(
$"SERVER: Unknown component {unknownComponent.component} in prototype {unknownComponent.entityId}\n");
}
Assert.Fail(message.ToString());
}
protected override void OnStart()
{
base.OnStart();
// Setup the keys - load YAML asset
var loader = new StringReader(layout.ToString());
var yaml = new YamlStream();
yaml.Load(loader);
var mapping = (YamlMappingNode)yaml.Documents[0].RootNode;
var rows = (YamlSequenceNode)mapping.Children[new YamlScalarNode("rows")];
foreach (YamlMappingNode row in rows)
{
var savedRow = new KeyRow();
var keys = (YamlSequenceNode)row.Children[new YamlScalarNode("keys")];
foreach (YamlMappingNode key in keys)
{
var savedKey = new PhysicsKey();
savedKey.normal = ((YamlScalarNode)key.Children[new YamlScalarNode("std")]).Value;
savedKey.shifted = ((YamlScalarNode)key.Children[new YamlScalarNode("shift")]).Value;
savedKey.width = float.Parse(((YamlScalarNode)key.Children[new YamlScalarNode("width")]).Value);
//Debug.LogFormat("{0} {1} w:{2}", savedKey.normal, savedKey.shifted, savedKey.width);
savedRow.keys.Add(savedKey);
}
this.keyRows.Add(savedRow);
}
// Build the keyboard
keyContainer = new GameObject("KeyContainer");
keyContainer.transform.SetParent(this.transform, false);
keyContainer.transform.localEulerAngles = new Vector3(0.0f, 180.0f, 0.0f);
float size = keySize / 100;
float gap = keyGap / 100;
float xLim = 0.0f;
float yLim = 0.0f;
float y = 0.0f;
foreach (var row in this.keyRows)
{
float x = 0.0f;
foreach (var key in row.keys)
{
// Instantiate key
GameObject newKey = Instantiate(keyPrefab);
newKey.transform.SetParent(keyContainer.transform, false);
var pos = new Vector3();
pos.x = x + size * key.width * 0.5f;
pos.y = y;
newKey.transform.localPosition = pos;
// Scale
newKey.transform.localScale = new Vector3(size, size, size);
// Set the Visible label string and the width
var dim = newKey.GetComponentInChildren <RectTransform>().sizeDelta;
dim.x *= key.width;
newKey.GetComponentInChildren <RectTransform>().sizeDelta = dim;
newKey.GetComponentInChildren <Text>().text = labelKey(false, key);
// Save key properties
key.x = x;
key.y = y;
key.dim = new Vector2(size * key.width, size);
key.obj = newKey;
x += size * key.width + gap;
}
if (x > xLim)
{
xLim = x;
}
yLim = y;
y -= size + gap;
}
// Place key container to center keyboard
keyContainer.transform.localPosition = new Vector3(xLim / 2 + gap, -yLim / 2 - gap);
// Resize background panel
if (panel)
{
var scale = panel.transform.localScale;
panel.transform.localScale = new Vector3(xLim + 2 * gap, -y + 2 * gap, scale.z);
}
}
// private readonly ITestOutputHelper output;
// public LoadingAYamlStream(ITestOutputHelper output)
// {
// this.output = output;
// }
/*[Sample(
* DisplayName = "Loading a YAML Stream",
* Description = "Explains how to load YAML using the representation model."
* )]*/
public void Read()
{
// Setup the input
var input = new StringReader(Document);
// Load the stream
var yaml = new YamlStream();
yaml.Load(input);
// Examine the stream
var mapping =
(YamlMappingNode)yaml.Documents[0].RootNode;
foreach (var entry in mapping.Children)
{
Console.Write(((YamlScalarNode)entry.Key).Value + " : ");
Console.Write((entry.Value));
Console.WriteLine();
//output.WriteLine(((YamlScalarNode)entry.Key).Value);
}
Console.WriteLine("====================");
// List all the items
var items = (YamlSequenceNode)mapping.Children[new YamlScalarNode("Financial")];
foreach (YamlScalarNode item in items)
{
Console.WriteLine(
item.ToString()
);
/* output.WriteLine(
* "{0}\t{1}",
* item.Children[new YamlScalarNode("part_no")],
* item.Children[new YamlScalarNode("descrip")]
* ); */
}
Console.WriteLine("====================");
var dataParameters = (YamlMappingNode)mapping.Children[new YamlScalarNode("Data-Parameters")];
var cards = (YamlSequenceNode)dataParameters.Children[new YamlScalarNode("Cards")];
foreach (YamlMappingNode data in cards)
{
Console.WriteLine(
data.Children[new YamlScalarNode("Card_Type")]
);
/* output.WriteLine(
* "{0}\t{1}",
* item.Children[new YamlScalarNode("part_no")],
* item.Children[new YamlScalarNode("descrip")]
* ); */
}
Console.WriteLine("====================");
var amount = (YamlScalarNode)dataParameters.Children[new YamlScalarNode("Amount")];
Console.WriteLine(amount);
Console.WriteLine("====================");
/*foreach (var entry in amount)
* {
* Console.WriteLine(((YamlScalarNode)entry.Value).Value);
* //output.WriteLine(((YamlScalarNode)entry.Key).Value);
* }*/
}
public NintendoContentFileSystemInfo GetFileSystemInfo()
{
NintendoContentFileSystemInfo fileSystemInfo1 = new NintendoContentFileSystemInfo();
using (StreamReader streamReader = new StreamReader(this.m_adfPath, Encoding.UTF8))
{
YamlStream yamlStream = new YamlStream();
yamlStream.Load((TextReader)streamReader);
YamlMappingNode rootNode;
YamlSequenceNode child1;
try
{
rootNode = (YamlMappingNode)yamlStream.Documents[0].RootNode;
if (((YamlScalarNode)rootNode.Children[(YamlNode) new YamlScalarNode("formatType")]).Value != "NintendoContent")
{
throw new ArgumentException();
}
YamlScalarNode child2 = (YamlScalarNode)rootNode.Children[(YamlNode) new YamlScalarNode("contentType")];
YamlScalarNode child3 = (YamlScalarNode)rootNode.Children[(YamlNode) new YamlScalarNode("keyGeneration")];
YamlScalarNode child4 = (YamlScalarNode)rootNode.Children[(YamlNode) new YamlScalarNode("programId")];
YamlScalarNode child5 = (YamlScalarNode)rootNode.Children[(YamlNode) new YamlScalarNode("contentIndex")];
child1 = (YamlSequenceNode)rootNode.Children[(YamlNode) new YamlScalarNode("entries")];
fileSystemInfo1.contentType = this.ConvertToContentTypeByte(child2.Value);
fileSystemInfo1.keyGeneration = Convert.ToByte(child3.Value);
fileSystemInfo1.programId = Convert.ToUInt64(child4.Value, 16);
fileSystemInfo1.contentIndex = Convert.ToUInt32(child5.Value);
}
catch
{
throw new ArgumentException("invalid format .adf file.");
}
try
{
YamlScalarNode child2 = (YamlScalarNode)rootNode.Children[(YamlNode) new YamlScalarNode("keyAreaEncryptionKeyIndex")];
fileSystemInfo1.keyAreaEncryptionKeyIndex = Convert.ToByte(child2.Value);
}
catch
{
fileSystemInfo1.keyAreaEncryptionKeyIndex = (byte)0;
}
string descFilePath;
if (fileSystemInfo1.contentType == (byte)0)
{
try
{
descFilePath = ((YamlScalarNode)rootNode.Children[(YamlNode) new YamlScalarNode("descFilePath")]).Value;
}
catch
{
throw new ArgumentException(".desc file is not specified for program content.");
}
}
else
{
descFilePath = (string)null;
}
byte[] numArray = (byte[])null;
if (descFilePath != null)
{
numArray = NintendoContentAdfReader.RetrieveInfoFromDesc(ref fileSystemInfo1, descFilePath);
}
foreach (YamlMappingNode yamlMappingNode in child1)
{
NintendoContentFileSystemInfo.EntryInfo entryInfo1 = new NintendoContentFileSystemInfo.EntryInfo();
string adfPath = (string)null;
foreach (KeyValuePair <YamlNode, YamlNode> keyValuePair in yamlMappingNode)
{
switch (((YamlScalarNode)keyValuePair.Key).Value)
{
case "encryptionType":
entryInfo1.encryptionType = Convert.ToByte(((YamlScalarNode)keyValuePair.Value).Value);
continue;
case "formatType":
entryInfo1.formatType = ((YamlScalarNode)keyValuePair.Value).Value;
continue;
case "hashType":
entryInfo1.hashType = Convert.ToByte(((YamlScalarNode)keyValuePair.Value).Value);
continue;
case "partitionType":
entryInfo1.partitionType = ((YamlScalarNode)keyValuePair.Value).Value;
entryInfo1.partitionIndex = this.GetPartitionIndex(entryInfo1.partitionType);
continue;
case "path":
adfPath = ((YamlScalarNode)keyValuePair.Value).Value;
continue;
case "type":
entryInfo1.type = ((YamlScalarNode)keyValuePair.Value).Value;
continue;
case "version":
entryInfo1.version = Convert.ToUInt16(((YamlScalarNode)keyValuePair.Value).Value);
continue;
default:
throw new ArgumentException("invalid format .adf file. invalid key is specified\n" + yamlMappingNode.ToString());
}
}
if (entryInfo1.type == null || entryInfo1.formatType == null || adfPath == null)
{
throw new ArgumentException("invalid format .adf file. \"type\" or \"formatType\" is not specified\n" + yamlMappingNode.ToString());
}
entryInfo1.version = (ushort)2;
entryInfo1.hashType = NintendoContentArchiveSource.VerifyHashType(fileSystemInfo1, entryInfo1);
entryInfo1.encryptionType = NintendoContentArchiveSource.VerifyEncryptionType(fileSystemInfo1, entryInfo1);
string formatType = entryInfo1.formatType;
if (!(formatType == "PartitionFs"))
{
if (!(formatType == "RomFs"))
{
throw new NotImplementedException("invalid format .adf file. invalid formatType." + yamlMappingNode.ToString());
}
RomFsAdfReader romFsAdfReader = new RomFsAdfReader(adfPath);
entryInfo1.fileSystemInfo = (Nintendo.Authoring.FileSystemMetaLibrary.FileSystemInfo)romFsAdfReader.GetFileSystemInfo();
}
else
{
PartitionFileSystemInfo fileSystemInfo2 = new PartitionFsAdfReader(adfPath).GetFileSystemInfo();
if (numArray != null && entryInfo1.partitionType == "code")
{
IEnumerable <PartitionFileSystemInfo.EntryInfo> source = fileSystemInfo2.entries.Where <PartitionFileSystemInfo.EntryInfo>((Func <PartitionFileSystemInfo.EntryInfo, bool>)(p => p.name == "main.npdm"));
if (fileSystemInfo1.contentType == (byte)0 && source.Count <PartitionFileSystemInfo.EntryInfo>() != 1)
{
throw new ArgumentException("\"main.npdm\" must be included in the code region.");
}
foreach (PartitionFileSystemInfo.EntryInfo entryInfo2 in source)
{
if (!((IEnumerable <byte>) this.ReadAcid(entryInfo2.path)).SequenceEqual <byte>((IEnumerable <byte>)numArray))
{
throw new ArgumentException(".desc file specified differ from the one used to build code.");
}
}
}
entryInfo1.fileSystemInfo = (Nintendo.Authoring.FileSystemMetaLibrary.FileSystemInfo)fileSystemInfo2;
}
fileSystemInfo1.fsEntries.Add(entryInfo1);
}
}
fileSystemInfo1.numFsEntries = fileSystemInfo1.fsEntries.Count;
fileSystemInfo1.isProdEncryption = false;
return(fileSystemInfo1);
}
public void ReadYamlStream(YamlStream yaml, FileInfo fileInfo)
{
ReadYamlStream(yaml,
fileInfo.Open(FileMode.Open, FileAccess.Read, FileShare.Read)
);
}
void LoadConfig()
{
var yaml = new YamlStream();
yaml.Load(new StringReader(File.ReadAllText("Config.yaml")));
var mapping = (YamlMappingNode)yaml.Documents[0].RootNode;
DirectCount = (byte)Utils.ParseValue(mapping.Children["DirectCount"].ToString());
InterFrames = (int)Utils.ParseValue(mapping.Children["InterFrames"].ToString());
SampleRate = (int)Utils.ParseValue(mapping.Children["SampleRate"].ToString());
All256Voices = bool.Parse(mapping.Children["All256Voices"].ToString());
MIDIKeyboardFixedVelocity = bool.Parse(mapping.Children["MIDIKeyboardFixedVelocity"].ToString());
TaskbarProgress = bool.Parse(mapping.Children["TaskbarProgress"].ToString());
RefreshRate = (byte)Utils.ParseValue(mapping.Children["RefreshRate"].ToString());
CenterIndicators = bool.Parse(mapping.Children["CenterIndicators"].ToString());
PanpotIndicators = bool.Parse(mapping.Children["PanpotIndicators"].ToString());
Volume = (byte)Utils.ParseValue(mapping.Children["Volume"].ToString());
var cmap = (YamlMappingNode)mapping.Children["Colors"];
Colors = new HSLColor[256];
foreach (var c in cmap)
{
int i = (int)Utils.ParseValue(c.Key.ToString());
var children = ((YamlMappingNode)c.Value).Children;
double h = 0, s = 0, l = 0;
foreach (var v in children)
{
if (v.Key.ToString() == "H")
{
h = byte.Parse(v.Value.ToString());
}
else if (v.Key.ToString() == "S")
{
s = byte.Parse(v.Value.ToString());
}
else if (v.Key.ToString() == "L")
{
l = byte.Parse(v.Value.ToString());
}
}
HSLColor color = new HSLColor(h, s, l);
Colors[i] = Colors[i + 0x80] = color;
}
var rmap = (YamlMappingNode)mapping.Children["InstrumentRemaps"];
InstrumentRemaps = new Dictionary <string, ARemap>();
foreach (var r in rmap)
{
var remaps = new List <Tuple <byte, byte> >();
var children = ((YamlMappingNode)r.Value).Children;
foreach (var v in children)
{
remaps.Add(new Tuple <byte, byte>(byte.Parse(v.Key.ToString()), byte.Parse(v.Value.ToString())));
}
InstrumentRemaps.Add(r.Key.ToString(), new ARemap(remaps.ToArray()));
}
}
public MainWindow()
{
InitializeComponent();
StreamReader sr = new StreamReader("example1.yaml");
string text = sr.ReadToEnd();
var input = new StringReader(text);
// Load the stream
var yaml = new YamlStream();
yaml.Load(input);
// Examine the stream
var mapping =
(YamlMappingNode)yaml.Documents[0].RootNode;
var items = (YamlSequenceNode)mapping.Children[new YamlScalarNode("form-elements")];
foreach (YamlMappingNode item in items)
{
var type = item.Children[new YamlScalarNode("type")];
switch (type.ToString())
{
case "textbox":
{
var textboxItem = new TextBox()
{
Id = item.Children[new YamlScalarNode("id")].ToString(),
Caption = item.Children[new YamlScalarNode("caption")].ToString(),
Size = item.Children[new YamlScalarNode("size")].ToString(),
};
break;
}
case "checkbox":
{
var checkboxItem = new CheckBox()
{
Id = item.Children[new YamlScalarNode("id")].ToString(),
Label = item.Children[new YamlScalarNode("label")].ToString(),
Size = item.Children[new YamlScalarNode("size")].ToString(),
};
break;
}
case "radiobuttons":
{
var optionListItems = (YamlSequenceNode)item.Children[new YamlScalarNode("optionList")];
var list = new List <string>();
foreach (YamlScalarNode x in optionListItems)
{
list.Add(x.ToString());
}
var radiobuttonsItem = new RadioButtonGroup()
{
Id = item.Children[new YamlScalarNode("id")].ToString(),
Label = item.Children[new YamlScalarNode("label")].ToString(),
Orientation = item.Children[new YamlScalarNode("orientation")].ToString(),
OptionList = list,
}
;
break;
}
}
}
}
public static async Task <PackageVersion> GetPackageVersion(string fullPath)
{
try
{
// Solution file: extract projects
var solutionDirectory = Path.GetDirectoryName(fullPath) ?? "";
var solution = Xenko.Core.VisualStudio.Solution.FromFile(fullPath);
foreach (var project in solution.Projects)
{
// Xenko up to 3.0
try
{
string packagePath;
if (IsPackage(project, out packagePath))
{
var packageFullPath = Path.Combine(solutionDirectory, packagePath);
// Load the package as a Yaml dynamic node, so that we can check Xenko version from dependencies
var input = new StringReader(File.ReadAllText(packageFullPath));
var yamlStream = new YamlStream();
yamlStream.Load(input);
dynamic yamlRootNode = new DynamicYamlMapping((YamlMappingNode)yamlStream.Documents[0].RootNode);
if (yamlRootNode.Meta.Dependencies is DynamicYamlArray)
{
foreach (var dependency in yamlRootNode.Meta.Dependencies)
{
if ((string)dependency.Name == "Xenko")
{
return(new PackageVersion((string)dependency.Version));
}
}
}
}
}
catch (Exception e)
{
e.Ignore();
}
// Xenko 3.1+
if (project.TypeGuid == VisualStudio.KnownProjectTypeGuid.CSharp || project.TypeGuid == VisualStudio.KnownProjectTypeGuid.CSharpNewSystem)
{
var projectPath = project.FullPath;
var packagePath = Path.ChangeExtension(projectPath, Package.PackageFileExtension);
if (File.Exists(packagePath))
{
var projectAssetsJsonPath = Path.Combine(Path.GetDirectoryName(projectPath), @"obj", LockFileFormat.AssetsFileName);
#if !XENKO_LAUNCHER
if (!File.Exists(projectAssetsJsonPath))
{
var log = new LoggerResult();
await VSProjectHelper.RestoreNugetPackages(log, projectPath);
}
#endif
if (File.Exists(projectAssetsJsonPath))
{
if (File.Exists(projectAssetsJsonPath))
{
var format = new LockFileFormat();
var projectAssets = format.Read(projectAssetsJsonPath);
foreach (var library in projectAssets.Libraries)
{
if (library.Type == "package" && library.Name == "Xenko.Engine")
{
return(new PackageVersion((string)library.Version.ToString()));
}
}
}
}
}
}
}
}
catch (Exception e)
{
e.Ignore();
}
return(null);
}
static void ProcessData(CommandLineOptions options)
{
if (!string.IsNullOrWhiteSpace(options.ContentPath) && !string.IsNullOrWhiteSpace(options.BaseUrl) &&
!string.IsNullOrWhiteSpace(options.TargetFolder) && !string.IsNullOrWhiteSpace(options.RepoRoot))
{
RedirectionRoot root = new RedirectionRoot();
if (options.MetaType == "ASPNET_LEGACY")
{
var filesNeedingToBeRedirected = Directory.GetFiles(options.ContentPath);
if (filesNeedingToBeRedirected != null)
{
Parallel.ForEach(filesNeedingToBeRedirected, async(file) =>
{
if (!Path.GetFileName(file).StartsWith(".") && !Path.GetFileName(file).StartsWith("toc.yml"))
{
var targetUrl = "https://docs.microsoft.com" + options.BaseUrl + "/" + Path.GetFileNameWithoutExtension(file);
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(targetUrl);
request.Method = "HEAD";
request.Timeout = int.MaxValue;
request.AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip;
try
{
var response = (HttpWebResponse)request.GetResponse();
if (options.DeleteFiles)
{
File.Delete(file);
}
root.RedirectionObjects.Add(new RedirectionObject()
{
SourcePath = file.Replace(options.RepoRoot, "").Replace(@"\", @"/").Remove(0, 1),
RedirectUrl = options.BaseUrl + "/" + Path.GetFileNameWithoutExtension(file),
RedirectDocumentId = true
});
Console.WriteLine("Created redirect for " + targetUrl);
}
catch (Exception ex)
{
Console.WriteLine("Failed redirect for " + targetUrl);
}
}
});
}
}
else if (options.MetaType == "NODEJS")
{
var pathToToc = Path.Combine(options.ContentPath, "toc.yml");
var tocInput = new StringReader(File.ReadAllText(pathToToc));
var tocYaml = new YamlStream();
tocYaml.Load(tocInput);
var mapping = (YamlSequenceNode)tocYaml.Documents[0].RootNode;
foreach (var entry in mapping.Children)
{
// TODO: Here we create package redirections. Thos are currently custom-written,
// so we just need a list.
var serviceName = ((YamlMappingNode)entry).Children["uid"].ToString();
root.RedirectionObjects.Add(new RedirectionObject()
{
SourcePath = "docs-ref-autogen/overview/azure/INSERT_SERVICE_NAME/" + serviceName + ".yml",
RedirectUrl = "/javascript/api/overview/azure/INSER_SERVICE_NAME_HERE/" + serviceName,
RedirectDocumentId = true
});
YamlSequenceNode items = ((YamlMappingNode)entry).Children["items"] as YamlSequenceNode;
foreach (var child in items.Children)
{
var redirectionTarget = ((YamlMappingNode)child).Children["uid"].ToString().Replace('.', '/');
var targetUrl = "https://docs.microsoft.com" + options.BaseUrl + "/" + redirectionTarget;
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(targetUrl);
request.Method = "HEAD";
request.Timeout = int.MaxValue;
request.AutomaticDecompression = DecompressionMethods.Deflate | DecompressionMethods.GZip;
try
{
var response = (HttpWebResponse)request.GetResponse();
Console.WriteLine("Existing cotnent will be redirected: " + redirectionTarget);
root.RedirectionObjects.Add(new RedirectionObject()
{
SourcePath = "docs-ref-autogen/" + redirectionTarget + ".yml",
RedirectUrl = "/javascript/api/" + redirectionTarget,
RedirectDocumentId = true
});
Console.WriteLine("Created redirect for " + targetUrl);
}
catch (Exception ex)
{
Console.WriteLine("Failed redirect for " + targetUrl);
}
}
}
}
var jsonString = JsonConvert.SerializeObject(root);
File.WriteAllText(Path.Combine(options.TargetFolder, ".openpublishing.redirection.json"), jsonString);
Console.WriteLine("Redirection file generation complete.");
}
}
public static string UpdateCodeLocationInYamlTemplate(string templateBody, string s3Bucket, string s3Key)
{
var s3Url = $"s3://{s3Bucket}/{s3Key}";
// Setup the input
var input = new StringReader(templateBody);
// Load the stream
var yaml = new YamlStream();
yaml.Load(input);
// Examine the stream
var root = (YamlMappingNode)yaml.Documents[0].RootNode;
if (root == null)
{
return(templateBody);
}
var resourcesKey = new YamlScalarNode("Resources");
if (!root.Children.ContainsKey(resourcesKey))
{
return(templateBody);
}
var resources = (YamlMappingNode)root.Children[resourcesKey];
foreach (var resource in resources.Children)
{
var resourceBody = (YamlMappingNode)resource.Value;
var type = (YamlScalarNode)resourceBody.Children[new YamlScalarNode("Type")];
var properties = (YamlMappingNode)resourceBody.Children[new YamlScalarNode("Properties")];
if (properties == null)
{
continue;
}
if (type == null)
{
continue;
}
if (string.Equals(type?.Value, "AWS::Serverless::Function", StringComparison.Ordinal))
{
properties.Children.Remove(new YamlScalarNode("CodeUri"));
properties.Add("CodeUri", s3Url);
}
else if (string.Equals(type?.Value, "AWS::Lambda::Function", StringComparison.Ordinal))
{
properties.Children.Remove(new YamlScalarNode("Code"));
var code = new YamlMappingNode();
code.Add("S3Bucket", s3Bucket);
code.Add("S3Key", s3Key);
properties.Add("Code", code);
}
}
var myText = new StringWriter();
yaml.Save(myText);
return(myText.ToString());
}
/// <summary>
/// Executes the framework using the given command line options.
/// </summary>
/// <param name="commandLineOptions">Command line options.</param>
private static async Task RunAsync(CommandLineOptions commandLineOptions)
{
// Configuration file supplied?
if (commandLineOptions.ConfigurationFile == null)
{
Console.WriteLine("Please specify a configuration file, as described in the documentation.");
Console.WriteLine();
// Print module list
Console.WriteLine("Available modules:");
Console.WriteLine(" Testcase generation:");
foreach (var(name, description) in TestcaseStage.Factory.GetSupportedModules())
{
Console.WriteLine(new string(' ', 4) + name + new string(' ', Math.Max(1, 24 - name.Length)) + description);
}
Console.WriteLine();
Console.WriteLine(" Trace generation:");
foreach (var(name, description) in TraceStage.Factory.GetSupportedModules())
{
Console.WriteLine(new string(' ', 4) + name + new string(' ', Math.Max(1, 24 - name.Length)) + description);
}
Console.WriteLine();
Console.WriteLine(" Trace preprocessing:");
foreach (var(name, description) in PreprocessorStage.Factory.GetSupportedModules())
{
Console.WriteLine(new string(' ', 4) + name + new string(' ', Math.Max(1, 24 - name.Length)) + description);
}
Console.WriteLine();
Console.WriteLine(" Analysis:");
foreach (var(name, description) in AnalysisStage.Factory.GetSupportedModules())
{
Console.WriteLine(new string(' ', 4) + name + new string(' ', Math.Max(1, 24 - name.Length)) + description);
}
Console.WriteLine();
// Done
return;
}
// Load configuration file
try
{
// Open file and read YAML
YamlStream yaml = new YamlStream();
using (var configFileStream = new StreamReader(File.Open(commandLineOptions.ConfigurationFile, FileMode.Open, FileAccess.Read, FileShare.Read)))
yaml.Load(configFileStream);
var rootNode = (YamlMappingNode)yaml.Documents[0].RootNode;
// Read general configuration first
var generalConfigurationNode = rootNode.GetChildNodeWithKey("general");
// Initialize logger
if (generalConfigurationNode == null)
{
Logger.Initialize(null);
}
else
{
Logger.Initialize((YamlMappingNode)generalConfigurationNode.GetChildNodeWithKey("logger"));
}
await Logger.LogDebugAsync("Loaded configuration file, initialized logger");
// Read stages
await Logger.LogDebugAsync("Reading pipeline configuration");
foreach (var mainNode in rootNode.Children)
{
// Read key
switch (mainNode.Key.GetNodeString())
{
case "testcase":
{
await Logger.LogDebugAsync("Reading and applying 'testcase' stage configuration");
// There must be a module name node
string moduleName = mainNode.Value.GetChildNodeWithKey("module").GetNodeString();
// Check for options
var optionNode = (YamlMappingNode)mainNode.Value.GetChildNodeWithKey("module-options");
// Create module, if possible
_moduleConfiguration.TestcaseStageModule = await TestcaseStage.Factory.CreateAsync(moduleName, optionNode);
// Remember general stage options
_moduleConfiguration.TestcaseStageOptions = (YamlMappingNode)mainNode.Value.GetChildNodeWithKey("options");
break;
}
case "trace":
{
await Logger.LogDebugAsync("Reading and applying 'trace' stage configuration");
// There must be a module name node
string moduleName = mainNode.Value.GetChildNodeWithKey("module").GetNodeString();
// Check for options
var optionNode = (YamlMappingNode)mainNode.Value.GetChildNodeWithKey("module-options");
// Create module, if possible
_moduleConfiguration.TraceStageModule = await TraceStage.Factory.CreateAsync(moduleName, optionNode);
// Remember general stage options
_moduleConfiguration.TraceStageOptions = (YamlMappingNode)mainNode.Value.GetChildNodeWithKey("options");
break;
}
case "preprocess":
{
await Logger.LogDebugAsync("Reading and applying 'preprocess' stage configuration");
// There must be a module name node
string moduleName = mainNode.Value.GetChildNodeWithKey("module").GetNodeString();
// Check for options
var optionNode = (YamlMappingNode)mainNode.Value.GetChildNodeWithKey("module-options");
// Create module, if possible
_moduleConfiguration.PreprocessorStageModule = await PreprocessorStage.Factory.CreateAsync(moduleName, optionNode);
// Remember general stage options
_moduleConfiguration.PreprocessorStageOptions = (YamlMappingNode)mainNode.Value.GetChildNodeWithKey("options");
break;
}
case "analysis":
{
await Logger.LogDebugAsync("Reading and applying 'analysis' stage configuration");
// There must be a module list node
var moduleListNode = mainNode.Value.GetChildNodeWithKey("modules");
if (!(moduleListNode is YamlSequenceNode moduleListSequenceNode))
{
throw new ConfigurationException("Module list node does not contain a sequence.");
}
_moduleConfiguration.AnalysesStageModules = new List <AnalysisStage>();
foreach (var yamlNode in moduleListSequenceNode)
{
var moduleEntryNode = (YamlMappingNode)yamlNode;
// There must be a module name node
string moduleName = moduleEntryNode.GetChildNodeWithKey("module").GetNodeString();
// Check for options
var optionNode = (YamlMappingNode)moduleEntryNode.GetChildNodeWithKey("module-options");
// Create module, if possible
_moduleConfiguration.AnalysesStageModules.Add(await AnalysisStage.Factory.CreateAsync(moduleName, optionNode));
}
// Remember general stage options
_moduleConfiguration.AnalysisStageOptions = (YamlMappingNode)mainNode.Value.GetChildNodeWithKey("options");
break;
}
}
}
// Check presence of needed pipeline modules
await Logger.LogDebugAsync("Doing some sanity checks");
if (_moduleConfiguration.TestcaseStageModule == null ||
_moduleConfiguration.TraceStageModule == null ||
_moduleConfiguration.PreprocessorStageModule == null ||
!_moduleConfiguration.AnalysesStageModules.Any())
{
throw new ConfigurationException(
"Incomplete module specification. Make sure that there is at least one module for testcase generation, trace generation, preprocessing and analysis, respectively.");
}
// Initialize pipeline stages
// -> [buffer] -> trace -> [buffer]-> preprocess -> [buffer] -> analysis
await Logger.LogDebugAsync("Initializing pipeline stages");
var traceStageBuffer = new BufferBlock <TraceEntity>(new DataflowBlockOptions
{
BoundedCapacity = _moduleConfiguration.TraceStageOptions.GetChildNodeWithKey("input-buffer-size").GetNodeInteger(1),
EnsureOrdered = true
});
var traceStage = new TransformBlock <TraceEntity, TraceEntity>(TraceStageFunc, new ExecutionDataflowBlockOptions
{
BoundedCapacity = 1,
EnsureOrdered = true,
MaxDegreeOfParallelism = _moduleConfiguration.TraceStageModule.SupportsParallelism
? _moduleConfiguration.TraceStageOptions.GetChildNodeWithKey("max-parallel-threads").GetNodeInteger(1)
: 1
});
var preprocessorStageBuffer = new BufferBlock <TraceEntity>(new DataflowBlockOptions
{
BoundedCapacity = _moduleConfiguration.PreprocessorStageOptions.GetChildNodeWithKey("input-buffer-size").GetNodeInteger(1),
EnsureOrdered = true
});
var preprocessorStage = new TransformBlock <TraceEntity, TraceEntity>(PreprocessorStageFunc, new ExecutionDataflowBlockOptions
{
BoundedCapacity = 1,
EnsureOrdered = true,
MaxDegreeOfParallelism = _moduleConfiguration.PreprocessorStageModule.SupportsParallelism
? _moduleConfiguration.PreprocessorStageOptions.GetChildNodeWithKey("max-parallel-threads").GetNodeInteger(1)
: 1
});
var analysisStageBuffer = new BufferBlock <TraceEntity>(new DataflowBlockOptions
{
BoundedCapacity = _moduleConfiguration.AnalysisStageOptions.GetChildNodeWithKey("input-buffer-size").GetNodeInteger(1),
EnsureOrdered = true
});
var analysisStage = new ActionBlock <TraceEntity>(AnalysisStageFunc, new ExecutionDataflowBlockOptions
{
BoundedCapacity = 1,
EnsureOrdered = true,
MaxDegreeOfParallelism = _moduleConfiguration.AnalysesStageModules.All(asm => asm.SupportsParallelism)
? _moduleConfiguration.AnalysisStageOptions.GetChildNodeWithKey("max-parallel-threads").GetNodeInteger(1)
: 1
});
// Link pipeline stages
await Logger.LogDebugAsync("Linking pipeline stages");
var linkOptions = new DataflowLinkOptions
{
PropagateCompletion = true
};
traceStageBuffer.LinkTo(traceStage, linkOptions);
traceStage.LinkTo(preprocessorStageBuffer, linkOptions);
preprocessorStageBuffer.LinkTo(preprocessorStage, linkOptions);
preprocessorStage.LinkTo(analysisStageBuffer, linkOptions);
analysisStageBuffer.LinkTo(analysisStage, linkOptions);
// Start posting test cases
await Logger.LogInfoAsync("Start testcase thread -> pipeline start");
var testcaseTaskCancellationTokenSource = new CancellationTokenSource();
var testcaseTask = PostTestcases(traceStageBuffer, testcaseTaskCancellationTokenSource.Token)
.ContinueWith(async(t) =>
{
if (t.IsFaulted && t.Exception != null && !t.Exception.Flatten().InnerExceptions.Any(e => e is TaskCanceledException))
{
// Log exception
await Logger.LogErrorAsync("Testcase generation has stopped due to an unhandled exception:");
await Logger.LogErrorAsync(FormatException(t.Exception));
await Logger.LogWarningAsync("Pipeline execution will be continued with the existing test cases.");
}
}, testcaseTaskCancellationTokenSource.Token);
// Handle pipeline exceptions
try
{
// Wait for all stages to complete
await analysisStage.Completion;
await Logger.LogInfoAsync("Pipeline completed.");
// Do final analysis steps
foreach (var module in _moduleConfiguration.AnalysesStageModules)
{
await module.FinishAsync();
}
}
catch (Exception ex)
{
// Stop test case generator for clean exit
testcaseTaskCancellationTokenSource.Cancel();
// Log exception
await Logger.LogErrorAsync("An exception occured in the pipeline:");
await Logger.LogErrorAsync(FormatException(ex));
await Logger.LogInfoAsync("Trying to stop gracefully");
}
// Wait for test case generator to stop
try
{
await testcaseTask;
await Logger.LogDebugAsync("Testcase thread completed.");
}
catch (TaskCanceledException)
{
// Ignore
}
finally
{
testcaseTaskCancellationTokenSource.Dispose();
}
// Do some cleanup
await Logger.LogDebugAsync("Performing some clean up");
await _moduleConfiguration.TestcaseStageModule.UninitAsync();
await _moduleConfiguration.TraceStageModule.UninitAsync();
await _moduleConfiguration.PreprocessorStageModule.UninitAsync();
await Task.WhenAll(_moduleConfiguration.AnalysesStageModules.Select(module => module.UninitAsync()));
// Done
await Logger.LogInfoAsync("Program completed.");
}
catch (Exception ex)
{
// Use logger, if already initialized
if (Logger.IsInitialized())
{
await Logger.LogErrorAsync("A general error occurred:");
await Logger.LogErrorAsync(FormatException(ex));
}
else
{
Console.WriteLine("A general error occured:");
Console.WriteLine(FormatException(ex));
}
}
finally
{
// Make sure logger is disposed properly
if (Logger.IsInitialized())
{
Logger.Deinitialize();
}
}
}
public static void 最新版にバージョンアップする()
{
using var _ = new LogBlock(Log.現在のメソッド名);
var path = new VariablePath(@"$(AppData)\Configuration.yaml");
int version = 0;
if (!File.Exists(path.数なしパス))
{
return;
}
#region " YAML階層のルートノード 'Version' を検索し、バージョン値を取得する。"
//----------------
{
var yamlText = File.ReadAllText(path.数なしパス);
var yamlStream = new YamlStream();
yamlStream.Load(new StringReader(yamlText));
var rootMapping = (YamlMappingNode)yamlStream.Documents[0].RootNode;
var versionNode = new YamlScalarNode("Version");
if (rootMapping.Children.ContainsKey(versionNode))
{
var versionValue = rootMapping.Children[versionNode] as YamlScalarNode;
version = int.Parse(versionValue?.Value ?? "1"); // 取得
}
}
//----------------
#endregion
while (version < SystemConfig.VERSION)
{
switch (version)
{
case 1:
{
break; // 存在しない
}
case 2:
{
#region " 2 → 3 "
//----------------
var v2 = old.SystemConfig.v002_システム設定.読み込む(path);
var v3 = new old.SystemConfig.v003_システム設定(v2);
v3.保存する(path);
version = v3.Version;
break;
//----------------
#endregion
}
case 3:
{
#region " 3 → 4 "
//----------------
var v3 = old.SystemConfig.v003_システム設定.読み込む(path);
var v4 = new old.SystemConfig.v004_SystemConfig(v3);
v4.保存する();
version = v4.Version;
break;
//----------------
#endregion
}
case 4:
{
#region " 4 → 5 "
//----------------
var v4 = old.SystemConfig.v004_SystemConfig.読み込む(path);
var v5 = new old.SystemConfig.v005_SystemConfig(v4);
v5.保存する();
version = v5.Version;
break;
//----------------
#endregion
}
case 5:
{
#region " 5 → 6 "
//----------------
var v5 = old.SystemConfig.v005_SystemConfig.読み込む(path);
var v6 = new old.SystemConfig.v006_SystemConfig(v5);
v6.保存する();
version = v6.Version;
break;
//----------------
#endregion
}
case 6:
{
#region " 6 → 最新版 "
//----------------
var v6 = old.SystemConfig.v006_SystemConfig.読み込む(path);
var v7 = new SystemConfig(v6);
v7.保存する();
version = v7.Version;
break;
//----------------
#endregion
}
}
}
}
public void ReadYamlStream(YamlStream yaml, Stream stream)
{
using var reader = new StreamReader(stream, Encoding.UTF8, true, 1024, leaveOpen: true);
yaml.Load(reader);
}
public RomFsFileSystemInfo GetFileSystemInfo()
{
RomFsFileSystemInfo fsFileSystemInfo = new RomFsFileSystemInfo();
using (StreamReader streamReader = new StreamReader(this.m_adfPath, Encoding.UTF8))
{
YamlStream yamlStream = new YamlStream();
yamlStream.Load((TextReader)streamReader);
YamlMappingNode rootNode;
try
{
rootNode = (YamlMappingNode)yamlStream.Documents[0].RootNode;
if (((YamlScalarNode)rootNode.Children[(YamlNode) new YamlScalarNode("formatType")]).Value != "RomFs")
{
throw new ArgumentException();
}
}
catch
{
throw new ArgumentException("invalid format .adf file.");
}
YamlSequenceNode child;
try
{
child = (YamlSequenceNode)rootNode.Children[(YamlNode) new YamlScalarNode("entries")];
}
catch
{
throw new ArgumentException("invalid format .adf file. At least one file must be included in the data region.");
}
DirectoryList directoryList = new DirectoryList();
foreach (YamlMappingNode yamlMappingNode in child)
{
RomFsFileSystemInfo.EntryInfo entryInfo = new RomFsFileSystemInfo.EntryInfo();
foreach (KeyValuePair <YamlNode, YamlNode> keyValuePair in yamlMappingNode)
{
string str = ((YamlScalarNode)keyValuePair.Key).Value;
if (!(str == "type"))
{
if (!(str == "name"))
{
if (!(str == "offset"))
{
if (!(str == "path"))
{
throw new ArgumentException("invalid format .adf file. invalid key is specified\n" + yamlMappingNode.ToString());
}
entryInfo.path = ((YamlScalarNode)keyValuePair.Value).Value;
}
else
{
entryInfo.offset = Convert.ToUInt64(((YamlScalarNode)keyValuePair.Value).Value);
}
}
else
{
entryInfo.name = "/" + ((YamlScalarNode)keyValuePair.Value).Value;
}
}
else
{
entryInfo.type = ((YamlScalarNode)keyValuePair.Value).Value;
}
}
if (entryInfo.type == null)
{
throw new ArgumentException("invalid format .adf file. invalid \"type\"\n" + yamlMappingNode.ToString());
}
if (entryInfo.type == "file" && (entryInfo.name == null || entryInfo.path == null))
{
throw new ArgumentException("invalid format .adf file. \"type == file\" but \"name\" or \"path\" is not specified.\n" + yamlMappingNode.ToString());
}
if (entryInfo.type == "directory" && entryInfo.name == null)
{
throw new ArgumentException("invalid format .adf file. \"type == directory\" but \"name\" is not specified.\n" + yamlMappingNode.ToString());
}
if (entryInfo.type == "file")
{
FileInfo fileInfo = new FileInfo(entryInfo.path);
entryInfo.size = (ulong)fileInfo.Length;
fsFileSystemInfo.entries.Add(entryInfo);
++fsFileSystemInfo.fileEntryCount;
directoryList.AddAncestors(Path.GetDirectoryName(entryInfo.name));
}
else
{
if (!(entryInfo.type == "directory"))
{
throw new ArgumentException("invalid format .adf file. \"type\" should be \"directory\" or \"file\".\n" + yamlMappingNode.ToString());
}
fsFileSystemInfo.entries.Add(entryInfo);
directoryList.AddAncestors(entryInfo.name);
}
}
fsFileSystemInfo.directoryEntryCount = directoryList.Count;
}
return(fsFileSystemInfo);
}
public void WriteYamlStream(YamlStream yaml, string file)
{
using var stream = File.Open(file, FileMode.Create, FileAccess.ReadWrite, FileShare.Read);
WriteYamlStream(yaml, stream);
}
public override async Task ExecuteAsync(OutputContext output, Application application, ServiceEntry service)
{
var bindings = service.Outputs.OfType <ComputedBindings>().FirstOrDefault();
if (bindings is null)
{
return;
}
foreach (var binding in bindings.Bindings)
{
if (binding is SecretInputBinding secretInputBinding)
{
if (!Secrets.Add(secretInputBinding.Name))
{
output.WriteDebugLine($"Already validated secret '{secretInputBinding.Name}'.");
continue;
}
output.WriteDebugLine($"Validating secret '{secretInputBinding.Name}'.");
var config = KubernetesClientConfiguration.BuildDefaultConfig();
// Workaround for https://github.com/kubernetes-client/csharp/issues/372
var store = KubernetesClientConfiguration.LoadKubeConfig();
var context = store.Contexts.Where(c => c.Name == config.CurrentContext).FirstOrDefault();
config.Namespace ??= context?.ContextDetails?.Namespace;
var kubernetes = new Kubernetes(config);
try
{
var result = await kubernetes.ReadNamespacedSecretWithHttpMessagesAsync(secretInputBinding.Name, config.Namespace ?? "default");
output.WriteInfoLine($"Found existing secret '{secretInputBinding.Name}'.");
continue;
}
catch (HttpOperationException ex) when(ex.Response.StatusCode == HttpStatusCode.NotFound)
{
// The kubernetes client uses exceptions for 404s.
}
catch (Exception ex)
{
output.WriteDebugLine("Failed to query secret.");
output.WriteDebugLine(ex.ToString());
throw new CommandException("Unable connect to kubernetes.", ex);
}
if (Force)
{
output.WriteDebugLine("Skipping because force was specified.");
continue;
}
if (!Interactive)
{
throw new CommandException(
$"The secret '{secretInputBinding.Name}' used for service '{secretInputBinding.Service.Service.Name}' is missing from the deployment environment. " +
$"Rerun the command with --interactive to specify the value interactively, or with --force to skip validation. Alternatively " +
$"use the following command to manually create the secret." + System.Environment.NewLine +
$"kubectl create secret generic {secretInputBinding.Name} --from-literal=connectionstring=<value>");
}
// If we get here then we should create the sceret.
var text = output.Prompt($"Enter the connection string to use for service '{secretInputBinding.Service.Service.Name}'", allowEmpty: true);
if (string.IsNullOrWhiteSpace(text))
{
output.WriteAlways($"Skipping creation of secret for '{secretInputBinding.Service.Service.Name}'. This may prevent creation of pods until secrets are created.");
output.WriteAlways($"Manually create a secret with:");
output.WriteAlways($"kubectl create secret generic {secretInputBinding.Name} --from-literal=connectionstring=<value>");
continue;
}
var secret = new V1Secret(type: "Opaque", stringData: new Dictionary <string, string>()
{
{ "connectionstring", text },
});
secret.Metadata = new V1ObjectMeta();
secret.Metadata.Name = secretInputBinding.Name;
output.WriteDebugLine($"Creating secret '{secret.Metadata.Name}'.");
try
{
await kubernetes.CreateNamespacedSecretWithHttpMessagesAsync(secret, config.Namespace ?? "default");
output.WriteInfoLine($"Created secret '{secret.Metadata.Name}'.");
}
catch (Exception ex)
{
output.WriteDebugLine("Failed to create secret.");
output.WriteDebugLine(ex.ToString());
throw new CommandException("Failed to create secret.", ex);
}
}
}
var yaml = service.Outputs.OfType <IYamlManifestOutput>().ToArray();
if (yaml.Length == 0)
{
output.WriteDebugLine($"No yaml manifests found for service '{service.FriendlyName}'. Skipping.");
return;
}
using var tempFile = TempFile.Create();
output.WriteDebugLine($"Writing output to '{tempFile.FilePath}'.");
{
using var stream = File.OpenWrite(tempFile.FilePath);
using var writer = new StreamWriter(stream, Encoding.UTF8, bufferSize: -1, leaveOpen: true);
var yamlStream = new YamlStream(yaml.Select(y => y.Yaml));
yamlStream.Save(writer, assignAnchors: false);
}
// kubectl apply logic is implemented in the client in older versions of k8s. The capability
// to get the same behavior in the server isn't present in every version that's relevant.
//
// https://kubernetes.io/docs/reference/using-api/api-concepts/#server-side-apply
//
output.WriteDebugLine("Running 'kubectl apply'.");
output.WriteCommandLine("kubectl", $"apply -f \"{tempFile.FilePath}\"");
var capture = output.Capture();
var exitCode = await Process.ExecuteAsync(
$"kubectl",
$"apply -f \"{tempFile.FilePath}\"",
System.Environment.CurrentDirectory,
stdOut : capture.StdOut,
stdErr : capture.StdErr);
output.WriteDebugLine($"Done running 'kubectl apply' exit code: {exitCode}");
if (exitCode != 0)
{
throw new CommandException("'kubectl apply' failed.");
}
output.WriteInfoLine($"Deployed service '{service.FriendlyName}'.");
}
public void ParseYmlFileTest()
{
//String filepath = Application + "/StreamingAssets/SolarSystem/";
string path = new DirectoryInfo(Environment.CurrentDirectory).Parent.Parent.FullName;
string path1 = AppDomain.CurrentDomain.BaseDirectory;
string path2 = System.IO.Directory.GetCurrentDirectory();
Console.WriteLine("path: " + path2 + "..\\..\\Data\\Data.txt");
var Document1 = path1 + "..\\..\\Data\\Data.txt";
var yaml1 = @"
Groups:
- Name: ATeam
FirstName, LastName, Age, Height:
- [Joe, Soap, 21, 184]
- [Mary, Ryan, 20, 169]
- [Alex, Dole, 24, 174]
";
var yaml2 = @"
-Label: entry
- Layer: x
- id: B35E246039E1CB70
- Ref: B35E246039E1CB70
Label: Info
- Layer: x
- id: CE0BEFC7022283A6
- Ref: CE0BEFC7022283A6
Label: entry
- Layer: HttpWebRequest
- id: 6DAA24FF5B777506
";
var Document = @"
receipt: Oz-Ware Purchase Invoice
date: 2007-08-06
customer:
given: Dorothy
family: Gale
items:
- part_no: A4786
descrip: Water Bucket (Filled)
price: 1.47
quantity: 4
- part_no: E1628
descrip: High Heeled ""Ruby"" Slippers
price: 100.27
quantity: 1
bill-to: &id001
street: |
123 Tornado Alley
Suite 16
city: East Westville
state: KS
ship-to: *id001
specialDelivery: >
Follow the Yellow Brick
Road to the Emerald City.
Pay no attention to the
man behind the curtain.
";
var Iconyml = @"
icons:
- name: Glass
id: glass
unicode: f000
created: 1.0
filter:
- martini
- drink
- bar
- alcohol
- liquor
categories:
- Web Application Icons
- name: Music
id: music
unicode: f001
created: 1.0
filter:
- note
- sound
categories:
- Web Application Icons
- name: Search
id: search
unicode: f002
created: 1.0
filter:
- magnify
- zoom
- enlarge
- bigger
categories:
- Web Application Icons
";
Console.WriteLine("Read YAML Data File.");
// Setup the input
var input = new StringReader(Document);
// Load the stream
var yaml = new YamlStream();
yaml.Load(input);
// Examine the stream
var mapping =
(YamlMappingNode)yaml.Documents[0].RootNode;
// Loop trough all child entries and print our keys
string key = string.Empty;
foreach (var entry in mapping.Children)
{
var myKey = ((YamlScalarNode)entry.Key).Value;
Console.WriteLine("Print Key: {0}", myKey);
var receiptNode = new YamlScalarNode("receipt");
var customerNode = new YamlScalarNode("customer");
Assert.IsTrue(mapping.Children.ContainsKey(receiptNode), "Document is missing receipt node.");
if (mapping.Children.ContainsKey(receiptNode))
{
Console.WriteLine("Print root node count: {0}", mapping.Children.Count());
}
if (mapping.Children.ContainsKey(customerNode))
{
var customer = mapping.Children[customerNode] as YamlMappingNode;
Console.WriteLine("Print customer node children count: {0}", customer.Count());
}
//The next line works fine
//var node = entry.Key as YamlScalarNode;
//alternative to above line
var node = (YamlScalarNode)entry.Key;
if (node != null)
{
Console.WriteLine("Key: {0} {1}", node.Value, entry.Value);
}
if (myKey != "items")
{
continue;
}
YamlScalarNode myYamlScalarNode = new YamlScalarNode(myKey);
var tmpItem = mapping.Children[myYamlScalarNode];
var items = (YamlSequenceNode)tmpItem;
foreach (YamlMappingNode item in items)
{
Console.WriteLine(
"{0}\t{1}",
item.Children[new YamlScalarNode("part_no")],
item.Children[new YamlScalarNode("descrip")]
);
}
}
}
public static bool TryDeserialize(YamlStream yamlStream, out DeserializedInfo deserializedInfo)
{
if (yamlStream == null)
{
deserializedInfo = null;
return(false);
}
var mapping = (YamlMappingNode)yamlStream.Documents[0].RootNode;
var tool = new Tool();
var publications = new List <Publication>();
foreach (var entry in mapping.Children)
{
switch (entry.Key.ToString())
{
case "package":
foreach (var child in ((YamlMappingNode)entry.Value).Children)
{
if (child.Key.ToString() == "name")
{
tool.Name = child.Value.ToString();
break;
}
}
break;
case "source":
if (entry.Value.GetType() == typeof(YamlMappingNode))
{
foreach (var child in ((YamlMappingNode)entry.Value).Children)
{
if (child.Key.ToString() == "url")
{
tool.CodeRepo = child.Value.ToString();
break;
}
}
}
else if (entry.Value.GetType() == typeof(YamlSequenceNode))
{
foreach (YamlMappingNode child in ((YamlSequenceNode)entry.Value).Children)
{
foreach (var c in child.Children)
{
if (c.Key.ToString() == "url")
{
tool.CodeRepo = c.Value.ToString();
break;
}
}
}
}
break;
case "extra":
foreach (var child in ((YamlMappingNode)entry.Value).Children)
{
if (child.Key.ToString() == "identifiers")
{
foreach (var x in ((YamlSequenceNode)child.Value).Children)
{
if (x.ToString().StartsWith("doi:", StringComparison.OrdinalIgnoreCase))
{
publications.Add(new Publication()
{
DOI = x.ToString().Split(':')[1]
});
break;
}
}
}
}
break;
}
}
deserializedInfo = new DeserializedInfo
{
ToolRepoAssociation = new ToolRepoAssociation()
{
Tool = tool
}
};
deserializedInfo.PopulateToolPublicationAssociations(publications);
return(true);
}
/// <summary>
/// Called when this object is visiting a <see cref="YamlStream"/>.
/// </summary>
/// <param name="stream">
/// The <see cref="YamlStream"/> that is being visited.
/// </param>
public virtual void Visit(YamlStream stream)
{
VisitChildren(stream);
}
private void LoadKeyFile(ResourcePath yamlFile)
{
YamlDocument document;
using (var stream = _resourceMan.ContentFileRead(yamlFile))
using (var reader = new StreamReader(stream, EncodingHelpers.UTF8))
{
var yamlStream = new YamlStream();
yamlStream.Load(reader);
document = yamlStream.Documents[0];
}
var mapping = (YamlMappingNode)document.RootNode;
foreach (var keyMapping in mapping.GetNode <YamlSequenceNode>("binds").Cast <YamlMappingNode>())
{
var function = keyMapping.GetNode("function").AsString();
if (!NetworkBindMap.FunctionExists(function))
{
Logger.ErrorS("input", "Key function in {0} does not exist: '{1}'", yamlFile, function);
continue;
}
var key = keyMapping.GetNode("key").AsEnum <Keyboard.Key>();
var canFocus = false;
if (keyMapping.TryGetNode("canFocus", out var canFocusName))
{
canFocus = canFocusName.AsBool();
}
var canRepeat = false;
if (keyMapping.TryGetNode("canRepeat", out var canRepeatName))
{
canRepeat = canRepeatName.AsBool();
}
var mod1 = Keyboard.Key.Unknown;
if (keyMapping.TryGetNode("mod1", out var mod1Name))
{
mod1 = mod1Name.AsEnum <Keyboard.Key>();
}
var mod2 = Keyboard.Key.Unknown;
if (keyMapping.TryGetNode("mod2", out var mod2Name))
{
mod2 = mod2Name.AsEnum <Keyboard.Key>();
}
var mod3 = Keyboard.Key.Unknown;
if (keyMapping.TryGetNode("mod3", out var mod3Name))
{
mod3 = mod3Name.AsEnum <Keyboard.Key>();
}
var type = keyMapping.GetNode("type").AsEnum <KeyBindingType>();
var binding = new KeyBinding(function, type, key, canFocus, canRepeat, mod1, mod2, mod3);
RegisterBinding(binding);
}
}
/*
* {
* "ManifestFileVersion": "0",
* "CRC": "2462514955",
* "AssetBundleManifest": {
* "AssetBundleInfos": {
* "Info_0": {
* "Name": "bundlename",
* "Dependencies": {}
* },
* "Info_1": {
* "Name": "dependsbundlename",
* "Dependencies": {// うーん複数階層持つことがあり得るのか〜〜きっちーな。このレイヤーは紛れもなく辞書なんだ。
* "Dependency_0": "bundlename"
* }
* },
* "Info_2": {
* "Name": "dependsbundlename2",
* "Dependencies": {
* "Dependency_0": "bundlename"
* }
* },
* "Info_3": {
* "Name": "nestedprefab",
* "Dependencies": {
* "Dependency_0": "dependsbundlename"
* }
* },
* "Info_4": {
* "Name": "updatable",
* "Dependencies": {
* "Dependency_0": "bundlename"
* }
* }
* }
* }
* }
*
*/
public void MakeList()
{
var targetOSStr = targetOS.ToString();
if (!Directory.Exists(PATH_ASSETBUNDLES_EXPORTED))
{
Debug.LogError("no directory found:" + PATH_ASSETBUNDLES_EXPORTED);
return;
}
var platformPath = FileController.PathCombine(PATH_ASSETBUNDLES_EXPORTED, targetOSStr);
if (!Directory.Exists(platformPath))
{
Debug.LogError("no platform folder found:" + platformPath);
return;
}
var assumedListFilePath = FileController.PathCombine(platformPath, "AssetBundles." + targetOSStr + "_" + version.Replace(".", "_") + ".json");
if (File.Exists(assumedListFilePath) && !shouldOverwrite)
{
Debug.LogError("same version file:" + assumedListFilePath + " is already exists.");
return;
}
var bundleAndDependencies = new List <AssetBundleInfo>();
/*
* load root manifest file and get assetBundle names and dependencies.
*/
using (var sr = new StreamReader(FileController.PathCombine(PATH_ASSETBUNDLES_EXPORTED, targetOSStr, targetOSStr + ".manifest"))) {
// read root manifest file.
{
var rootYaml = new YamlStream();
rootYaml.Load(sr);
var rootMapping = (YamlMappingNode)rootYaml.Documents[0].RootNode;
foreach (var root_item in rootMapping)
{
var rootKey = ((YamlScalarNode)root_item.Key).Value;
switch (rootKey)
{
case "ManifestFileVersion": {
// Debug.LogError("ManifestFileVersion:" + ((YamlScalarNode)root_item.Value).Value);
break;
}
case "AssetBundleManifest": {
var assetBundleManifestMapping = (YamlMappingNode)root_item.Value;
foreach (var assetBundleManifestMapping_item in assetBundleManifestMapping)
{
var manifestKey = ((YamlScalarNode)assetBundleManifestMapping_item.Key).Value;
switch (manifestKey)
{
case "AssetBundleInfos": {
var manifestInfoSeq = (YamlMappingNode)assetBundleManifestMapping_item.Value;
foreach (var manifestInfo_item in manifestInfoSeq)
{
var bundleInfo = new AssetBundleInfo();
var bundleInfoMapping = (YamlMappingNode)manifestInfo_item.Value;
foreach (var info_item in bundleInfoMapping)
{
var infoKey = ((YamlScalarNode)info_item.Key).Value;
switch (infoKey)
{
case "Name": {
var name = ((YamlScalarNode)info_item.Value).Value;
// Debug.LogError("name:" + name);
bundleInfo.bundleName = name;
break;
}
case "Dependencies": {
var dependenciesMapping = (YamlMappingNode)info_item.Value;
foreach (var dependency_item in dependenciesMapping)
{
var dependentBundleName = ((YamlScalarNode)dependency_item.Value).Value;
// Debug.LogError("dependentBundleName:" + dependentBundleName);
}
var dependentBundleNames = dependenciesMapping.Select(t => ((YamlScalarNode)t.Value).Value).ToArray();
bundleInfo.dependsBundleNames = dependentBundleNames;
break;
}
}
}
bundleAndDependencies.Add(bundleInfo);
}
break;
}
}
}
break;
}
}
}
}
}
var assetBundleInfos = new List <AssetBundleInfo>();
/*
* load each assetBundle info from bundle manifests.
*/
foreach (var bundleAndDependencie in bundleAndDependencies)
{
var targetBundleName = bundleAndDependencie.bundleName;
var newAssetBundleInfo = new AssetBundleInfo();
newAssetBundleInfo.bundleName = targetBundleName;
newAssetBundleInfo.dependsBundleNames = bundleAndDependencie.dependsBundleNames;
using (var sr = new StreamReader(FileController.PathCombine(PATH_ASSETBUNDLES_EXPORTED, targetOSStr, targetBundleName + ".manifest"))) {
var rootYaml = new YamlStream();
rootYaml.Load(sr);
var rootMapping = (YamlMappingNode)rootYaml.Documents[0].RootNode;
foreach (var root_item in rootMapping)
{
var rootKey = ((YamlScalarNode)root_item.Key).Value;
switch (rootKey)
{
case "CRC": {
var crc = Convert.ToUInt32(((YamlScalarNode)root_item.Value).Value);
// Debug.LogError("crc:" + crc);
newAssetBundleInfo.crc = crc;
break;
}
case "Assets": {
var assetNamesSeq = (YamlSequenceNode)root_item.Value;
var assetNames = assetNamesSeq.Select(n => ((YamlScalarNode)n).Value).ToArray();
// foreach (var assetName in assetNames) {
// Debug.LogError("assetName:" + assetName);
// }
newAssetBundleInfo.assetNames = assetNames;
break;
}
case "Hashes": {
var hashMapping = (YamlMappingNode)root_item.Value;
foreach (var hash_item in hashMapping)
{
var hashKey = ((YamlScalarNode)hash_item.Key).Value;
switch (hashKey)
{
case "AssetFileHash": {
var assetHashMapping = (YamlMappingNode)hash_item.Value;
foreach (var assetHash_item in assetHashMapping)
{
var assetHashKey = ((YamlScalarNode)assetHash_item.Key).Value;
switch (assetHashKey)
{
case "Hash": {
var hashStr = ((YamlScalarNode)assetHash_item.Value).Value;
// Debug.LogError("hashStr:" + hashStr);
newAssetBundleInfo.hash = hashStr;
break;
}
}
}
break;
}
}
}
break;
}
}
}
// set size.
newAssetBundleInfo.size = new FileInfo(FileController.PathCombine(PATH_ASSETBUNDLES_EXPORTED, targetOSStr, targetBundleName)).Length;
// Debug.LogError("newAssetBundleInfo.size:" + newAssetBundleInfo.size);
assetBundleInfos.Add(newAssetBundleInfo);
}
}
var assetBundleList = new AssetBundleList(targetOSStr, version, assetBundleInfos.ToArray());
var str = JsonUtility.ToJson(assetBundleList, true);
var listExportPath = FileController.PathCombine(PATH_ASSETBUNDLES_EXPORTED, targetOSStr, "AssetBundles." + targetOSStr + "_" + version.Replace(".", "_") + ".json");
/*
* write out to file.
* "AssetBundles/OS/AssetBundles.OS_v_e_r.json".
*/
using (var sw = new StreamWriter(listExportPath)) {
sw.WriteLine(str);
}
Debug.Log("list exported at:" + listExportPath);
}
