/// <summary>
/// Serializes the <see cref="Extractors"/> state property to its XML serialization format.
/// </summary>
/// <param name="writer">
/// The <see cref="XmlWriter"/> to serialize the <see cref="Extractors"/> state property to.
/// </param>
public void WriteXml(XmlWriter writer)
{
if (Extractors.Any())
{
WriteXmlProperties(writer);
}
}
static void Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.LiterateConsole()
.CreateLogger();
L = Log.ForContext <Program>();
var result = Parser.Default.ParseArguments <ExtractOptions, TransformOptions>(args)
.WithNotParsed((IEnumerable <Error> errors) =>
{
Exit(ExitResult.INVALID_OPTIONS);
})
.WithParsed((ExtractOptions o) =>
{
if (Extractors.Contains(o.Extractor))
{
ExtractOptions = o;
Extract();
}
else
{
L.Error("The current extractors are: {extractors}.", Extractors);
Exit(ExitResult.INVALID_OPTIONS);
}
});
}
/// <summary>
/// Serializes the <see cref="Extractors"/> state property to its XML serialization format.
/// </summary>
/// <param name="writer">
/// The <see cref="XmlWriter"/> to serialize the <see cref="Extractors"/> state property to.
/// </param>
public void WriteXml(XmlWriter writer)
{
if (Extractors.Any())
{
WriteXmlProperties(writer ?? throw new ArgumentNullException(nameof(writer)));
}
}
internal IEnumerable <KeyValuePair <string, string> > ToKeyValuePairs()
{
var output = new List <KeyValuePair <string, string> >();
if (!string.IsNullOrWhiteSpace(Text))
{
output.Add("text", Text);
}
if (!string.IsNullOrWhiteSpace(Url))
{
output.Add("url", Url);
}
output.Add("extractors", Extractors.ToString().Replace(" ", "").ToLowerInvariant());
if (!string.IsNullOrWhiteSpace(Rules))
{
output.Add("rules", Rules);
}
if (!string.IsNullOrWhiteSpace(LanguageOverride))
{
output.Add("languageOverride", LanguageOverride);
}
if (!string.IsNullOrWhiteSpace(Classifiers))
{
output.Add("classifiers", Classifiers);
}
output.AddRange(Entities.ToKeyValuePairs());
output.AddRange(Cleanup.ToKeyValuePairs());
output.AddRange(Download.ToKeyValuePairs());
return(output);
}
public IPackageExtractor GetExtractor(string packageFile)
{
if (string.IsNullOrEmpty(Path.GetExtension(packageFile)))
{
throw new FileFormatException("Package is missing file extension. This is needed to select the correct extraction algorithm.");
}
var extractor = ExtensionSuffix(packageFile);
if (extractor != null)
{
return(extractor);
}
extractor = ExtensionWithHashSuffix(packageFile);
if (extractor != null)
{
return(extractor);
}
var extensionMatch = Regex.Match(Path.GetExtension(packageFile), ExtensionRegex);
throw new FileFormatException(supportLinkGenerator.GenerateSupportMessage(
string.Format(
"This step supports packages with the following extenions: {0}.\n" +
"The supplied package has the extension \"{1}\" which is not supported.",
Extractors.SelectMany(e => e.Extensions)
.Distinct()
.Aggregate((result, e) => result + ", " + e),
extensionMatch.Success ? extensionMatch.Groups[1].Value : Path.GetExtension(packageFile)),
"JAVA-DEPLOY-ERROR-0001"));
}
public override Header Create(CharSeeker dataSeeker, Configuration config, IdType idType, Groups groups)
{
try
{
Mark mark = new Mark();
Extractors extractors = new Extractors(config.arrayDelimiter(), config.emptyQuotedStringsAsNull(), config.trimStrings(), DefaultTimeZone);
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: org.neo4j.csv.reader.Extractor<?> idExtractor = idType.extractor(extractors);
Extractor <object> idExtractor = idType.extractor(extractors);
int delimiter = config.delimiter();
IList <Header.Entry> columns = new List <Header.Entry>();
for (int i = 0; !mark.EndOfLine && dataSeeker.Seek(mark, delimiter); i++)
{
string entryString = dataSeeker.TryExtract(mark, extractors.String()) ? extractors.String().value() : null;
HeaderEntrySpec spec = new HeaderEntrySpec(entryString);
if ((string.ReferenceEquals(spec.Name, null) && string.ReferenceEquals(spec.Type, null)) || (!string.ReferenceEquals(spec.Type, null) && spec.Type.Equals(Type.Ignore.name())))
{
columns.Add(new Header.Entry(null, Type.Ignore, [email protected]_Fields.Global, null, null));
}
else
{
Group group = CreateGroups ? groups.GetOrCreate(spec.GroupName) : groups.Get(spec.GroupName);
columns.Add(Entry(i, spec.Name, spec.Type, group, extractors, idExtractor));
}
}
Entry[] entries = columns.ToArray();
ValidateHeader(entries);
return(new Header(entries));
}
catch (IOException e)
{
throw new Exception(e);
}
}
private void EditExtractor(object obj)
{
var extractor = Extractors.ElementAt(SelectedIndex);
if (extractor != null)
{
editExtractorService.Edit(extractor);
}
}
public static Header BareboneNodeHeader(string idKey, IdType idType, Extractors extractors, params Header.Entry[] additionalEntries)
{
IList <Header.Entry> entries = new List <Header.Entry>();
entries.Add(new Header.Entry(idKey, Type.ID, null, idType.extractor(extractors)));
entries.Add(new Header.Entry(null, Type.LABEL, null, extractors.StringArray()));
((IList <Header.Entry>)entries).AddRange(asList(additionalEntries));
return(new Header(entries.ToArray()));
}
/// <summary>
/// Initializes a new instance of the <see cref="DefaultFeatureExtractor"/> class.
/// </summary>
/// <param name="summarizers">The summarizers.</param>
public DefaultFeatureExtractor(IEnumerable <IFeatureExtractorLanguage> summarizers)
{
Extractors = summarizers.Where(x => x.GetType().Assembly != typeof(DefaultFeatureExtractor).Assembly).ToDictionary(x => x.Name);
foreach (var Extractor in summarizers.Where(x => x.GetType().Assembly == typeof(DefaultFeatureExtractor).Assembly &&
!Extractors.ContainsKey(x.Name)))
{
Extractors.Add(Extractor.Name, Extractor);
}
}
public override bool TryConvert(ConvertBinder binder, out object result)
{
if (!Extractors.TryGetValue(binder.Type, out var extract) || !extract(Element, out result))
{
throw new FormatException($"Unable to convert json value {Element.GetRawText()} to {binder.Type.Name}");
}
return(true);
}
private void CreateCSharpHeadNode(SyntaxNode root)
{
var nodeType = TypeConversion.FromRoslynKind(root.Kind());
string name = Extractors.ExtractName(root);
Head = new CSharpNode(name, nodeType)
{
Visibility = Configuration.Visibility
};
}
public static Header BareboneRelationshipHeader(IdType idType, Extractors extractors, params Header.Entry[] additionalEntries)
{
IList <Header.Entry> entries = new List <Header.Entry>();
entries.Add(new Header.Entry(null, Type.START_ID, null, idType.extractor(extractors)));
entries.Add(new Header.Entry(null, Type.END_ID, null, idType.extractor(extractors)));
entries.Add(new Header.Entry(null, Type.TYPE, null, extractors.String()));
((IList <Header.Entry>)entries).AddRange(asList(additionalEntries));
return(new Header(entries.ToArray()));
}
public async Task <Uri> ExtractMedia(string originalUrl)
{
var extractor = Extractors.FirstOrDefault(e => e.CanExtract(originalUrl));
if (extractor == null)
{
return(null);
}
return(await extractor.GetMediaUrl(originalUrl));
}
//JAVA TO C# CONVERTER WARNING: Java wildcard generics have no direct equivalent in .NET:
//ORIGINAL LINE: private static org.neo4j.csv.reader.Extractor<?> parsePropertyType(String typeSpec, org.neo4j.csv.reader.Extractors extractors)
private static Extractor <object> ParsePropertyType(string typeSpec, Extractors extractors)
{
try
{
return(extractors.ValueOf(typeSpec));
}
catch (System.ArgumentException e)
{
throw new HeaderException("Unable to parse header", e);
}
}
private static Header ParseRelationshipHeader(Args args, IdType idType, Extractors extractors, Groups groups)
{
string definition = args.Get("relationship-header", null);
if (string.ReferenceEquals(definition, null))
{
return(DataGeneratorInput.bareboneRelationshipHeader(idType, extractors));
}
Configuration config = Configuration.COMMAS;
return(DataFactories.defaultFormatRelationshipFileHeader().create(Seeker(definition, config), config, idType, groups));
}
/// <summary>
/// The constructor takes the Extractor context for recursion.
/// </summary>
/// <param name="context">The Extractor context.</param>
public Extractor(Extractors type)
{
// poor man's type resolving
switch (type)
{
case Extractors.vhdx:
mExtractor = new SharpExtractor.VhxdExtractor();
break;
default:
throw new NotImplementedException($"{type} extractor not implemented");
break;
}
}
IPackageExtractor ReportInvalidExtension(string packageFile)
{
var extensionMatch = Regex.Match(Path.GetExtension(packageFile), ExtensionRegex);
throw new FileFormatException(supportLinkGenerator.GenerateSupportMessage(
string.Format(
"This step supports packages with the following extenions: {0}.\n" +
"The supplied package has the extension \"{1}\" which is not supported.",
Extractors.SelectMany(e => e.Extensions)
.Distinct()
.Aggregate((result, e) => result + ", " + e),
extensionMatch.Success ? extensionMatch.Groups[1].Value : Path.GetExtension(packageFile)),
"JAVA-DEPLOY-ERROR-0001"));
}
private SyntaxNode GetDeclarationNode(SyntaxNode namespaceNode)
{
SyntaxNode classOrInterface = namespaceNode.ChildNodes().FirstOrDefault(node => node.Kind() == SyntaxKind.ClassDeclaration);
if (classOrInterface == null)
{
throw new FileLoadException("Implementation not found");
}
bool isAuthorized = GetConstraintAuthorization(classOrInterface);
if (!isAuthorized)
{
throw new UnauthorizedAccessException(
$"Class {Extractors.ExtractName(classOrInterface)} do not respect the Attribute constraint {Configuration.AttributeNameConstraint}");
}
classOrInterface = classOrInterface ?? namespaceNode.ChildNodes().FirstOrDefault(node => node.Kind() == SyntaxKind.InterfaceDeclaration);
return(classOrInterface);
}
private void InsertNodeInTree(SyntaxNode node)
{
SyntaxKind topLevelKind = node.Kind();
bool isReadonly = false;
string name = "";
TypeWrapper type = new TypeWrapper();
SyntaxNode[] children = node.ChildNodes().ToArray();
if (children.Length < 1)
{
return;
}
switch (topLevelKind)
{
case SyntaxKind.PropertyDeclaration:
type = Extractors.ExtractTypesFromProperty(GetPropertyTypeNode(node));
name = Extractors.ExtractName(node);
isReadonly = Extractors.IsReadOnly(node);
break;
case SyntaxKind.FieldDeclaration:
SyntaxNode firstChild = children.First();
type = Extractors.ExtractTypesFromField(firstChild);
name = Extractors.ExtractName(firstChild);
break;
case SyntaxKind.MethodDeclaration:
/*TODO: Method, can have multiple return/parameters type. Handle that when needed*/
break;
}
var csharpNode = new CSharpNode(name, TypeConversion.FromRoslynKind(topLevelKind))
{
Type = type,
IsReadOnly = isReadonly
};
Head.Children.Add(csharpNode);
}
public void AddExtractor(IMediaExtractor extractor)
{
Extractors.Add(extractor);
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: public static void main(String[] arguments) throws java.io.IOException
public static void Main(string[] arguments)
{
Args args = Args.parse(arguments);
long nodeCount = Settings.parseLongWithUnit(args.Get("nodes", null));
long relationshipCount = Settings.parseLongWithUnit(args.Get("relationships", null));
int labelCount = args.GetNumber("labels", 4).intValue();
int relationshipTypeCount = args.GetNumber("relationship-types", 4).intValue();
File dir = new File(args.Get(ImportTool.Options.StoreDir.key()));
long randomSeed = args.GetNumber("random-seed", currentTimeMillis()).longValue();
Configuration config = Configuration.COMMAS;
Extractors extractors = new Extractors(config.ArrayDelimiter());
IdType idType = IdType.valueOf(args.Get("id-type", IdType.INTEGER.name()));
Groups groups = new Groups();
Header nodeHeader = ParseNodeHeader(args, idType, extractors, groups);
Header relationshipHeader = ParseRelationshipHeader(args, idType, extractors, groups);
Config dbConfig;
string dbConfigFileName = args.Get(ImportTool.Options.DatabaseConfig.key(), null);
if (!string.ReferenceEquals(dbConfigFileName, null))
{
dbConfig = (new Config.Builder()).withFile(new File(dbConfigFileName)).build();
}
else
{
dbConfig = Config.defaults();
}
bool highIo = args.GetBoolean(ImportTool.Options.HighIo.key());
LogProvider logging = NullLogProvider.Instance;
long pageCacheMemory = args.GetNumber("pagecache-memory", [email protected]_Fields.MaxPageCacheMemory).longValue();
[email protected] importConfig = new ConfigurationAnonymousInnerClass(args, highIo, pageCacheMemory);
float factorBadNodeData = args.GetNumber("factor-bad-node-data", 0).floatValue();
float factorBadRelationshipData = args.GetNumber("factor-bad-relationship-data", 0).floatValue();
Input input = new DataGeneratorInput(nodeCount, relationshipCount, idType, Collector.EMPTY, randomSeed, 0, nodeHeader, relationshipHeader, labelCount, relationshipTypeCount, factorBadNodeData, factorBadRelationshipData);
using (FileSystemAbstraction fileSystem = new DefaultFileSystemAbstraction(), Lifespan life = new Lifespan())
{
BatchImporter consumer;
if (args.GetBoolean("to-csv"))
{
consumer = new CsvOutput(dir, nodeHeader, relationshipHeader, config);
}
else
{
Console.WriteLine("Seed " + randomSeed);
//JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final':
//ORIGINAL LINE: final org.neo4j.scheduler.JobScheduler jobScheduler = life.add(createScheduler());
JobScheduler jobScheduler = life.Add(createScheduler());
consumer = BatchImporterFactory.withHighestPriority().instantiate(DatabaseLayout.of(dir), fileSystem, null, importConfig, new SimpleLogService(logging, logging), defaultVisible(jobScheduler), EMPTY, dbConfig, RecordFormatSelector.selectForConfig(dbConfig, logging), NO_MONITOR, jobScheduler);
ImportTool.PrintOverview(dir, Collections.emptyList(), Collections.emptyList(), importConfig, System.out);
}
consumer.DoImport(input);
}
}
private void RemoveExtractor(object obj)
{
var extractor = Extractors.ElementAt(SelectedIndex);
removeExtractorService.Remove(extractor);
}
public Uri ExtractMedia(string originalUrl)
{
var extractor = Extractors.FirstOrDefault(e => e.CanExtract(originalUrl));
return(extractor?.GetMediaUrl(originalUrl));
}
public bool IsFiltered(ILogEntry entry)
{
return(Extractors.Any(filter => filter.Enabled && filter.IsMatch(entry)) ||
SearchExtractors.Any(filter => filter.Enabled && filter.IsMatch(entry)));
}
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in C#:
//ORIGINAL LINE: boolean next(org.neo4j.unsafe.impl.batchimport.input.InputEntityVisitor visitor) throws java.io.IOException
internal virtual bool Next(InputEntityVisitor visitor)
{
_lineNumber++;
int i = 0;
Entry entry = null;
Entry[] entries = _header.entries();
try
{
bool doContinue = true;
for (i = 0; i < entries.Length && doContinue; i++)
{
entry = entries[i];
if (!_seeker.seek(_mark, _delimiter))
{
if (i > 0)
{
throw new UnexpectedEndOfInputException("Near " + _mark);
}
// We're just at the end
return(false);
}
switch (entry.Type())
{
case ID:
if (_seeker.tryExtract(_mark, entry.Extractor()))
{
switch (_idType.innerEnumValue)
{
case Org.Neo4j.@unsafe.Impl.Batchimport.input.csv.IdType.InnerEnum.STRING:
case Org.Neo4j.@unsafe.Impl.Batchimport.input.csv.IdType.InnerEnum.INTEGER:
object idValue = entry.Extractor().value();
doContinue = visitor.Id(idValue, entry.Group());
if (!string.ReferenceEquals(entry.Name(), null))
{
doContinue = visitor.Property(entry.Name(), idValue);
}
break;
case Org.Neo4j.@unsafe.Impl.Batchimport.input.csv.IdType.InnerEnum.ACTUAL:
doContinue = visitor.Id(((Extractors.LongExtractor)entry.Extractor()).longValue());
break;
default:
throw new System.ArgumentException(_idType.name());
}
}
break;
case START_ID:
if (_seeker.tryExtract(_mark, entry.Extractor()))
{
switch (_idType.innerEnumValue)
{
case Org.Neo4j.@unsafe.Impl.Batchimport.input.csv.IdType.InnerEnum.STRING:
doContinue = visitor.StartId(entry.Extractor().value(), entry.Group());
break;
case Org.Neo4j.@unsafe.Impl.Batchimport.input.csv.IdType.InnerEnum.INTEGER:
doContinue = visitor.StartId(entry.Extractor().value(), entry.Group());
break;
case Org.Neo4j.@unsafe.Impl.Batchimport.input.csv.IdType.InnerEnum.ACTUAL:
doContinue = visitor.StartId(((Extractors.LongExtractor)entry.Extractor()).longValue());
break;
default:
throw new System.ArgumentException(_idType.name());
}
}
break;
case END_ID:
if (_seeker.tryExtract(_mark, entry.Extractor()))
{
switch (_idType.innerEnumValue)
{
case Org.Neo4j.@unsafe.Impl.Batchimport.input.csv.IdType.InnerEnum.STRING:
doContinue = visitor.EndId(entry.Extractor().value(), entry.Group());
break;
case Org.Neo4j.@unsafe.Impl.Batchimport.input.csv.IdType.InnerEnum.INTEGER:
doContinue = visitor.EndId(entry.Extractor().value(), entry.Group());
break;
case Org.Neo4j.@unsafe.Impl.Batchimport.input.csv.IdType.InnerEnum.ACTUAL:
doContinue = visitor.EndId(((Extractors.LongExtractor)entry.Extractor()).longValue());
break;
default:
throw new System.ArgumentException(_idType.name());
}
}
break;
case TYPE:
if (_seeker.tryExtract(_mark, entry.Extractor()))
{
doContinue = visitor.Type(( string )entry.Extractor().value());
}
break;
case PROPERTY:
if (_seeker.tryExtract(_mark, entry.Extractor(), entry.OptionalParameter()))
{
// TODO since PropertyStore#encodeValue takes Object there's no point splitting up
// into different primitive types
object value = entry.Extractor().value();
if (!IsEmptyArray(value))
{
doContinue = visitor.Property(entry.Name(), value);
}
}
break;
case LABEL:
if (_seeker.tryExtract(_mark, entry.Extractor()))
{
object labelsValue = entry.Extractor().value();
if (labelsValue.GetType().IsArray)
{
doContinue = visitor.Labels(( string[] )labelsValue);
}
else
{
doContinue = visitor.Labels(new string[] { ( string )labelsValue });
}
}
break;
case IGNORE:
break;
default:
throw new System.ArgumentException(entry.Type().ToString());
}
if (_mark.EndOfLine)
{
// We're at the end of the line, break and return an entity with what we have.
break;
}
}
while (!_mark.EndOfLine)
{
_seeker.seek(_mark, _delimiter);
if (doContinue)
{
_seeker.tryExtract(_mark, _stringExtractor, entry.OptionalParameter());
_badCollector.collectExtraColumns(_seeker.sourceDescription(), _lineNumber, _stringExtractor.value());
}
}
visitor.EndOfEntity();
return(true);
}
//JAVA TO C# CONVERTER WARNING: 'final' catch parameters are not available in C#:
//ORIGINAL LINE: catch (final RuntimeException e)
catch (Exception e)
{
string stringValue = null;
try
{
Extractors extractors = new Extractors('?');
if (_seeker.tryExtract(_mark, extractors.String(), entry.OptionalParameter()))
{
stringValue = extractors.String().value();
}
}
catch (Exception)
{ // OK
}
string message = format("ERROR in input" + "%n data source: %s" + "%n in field: %s" + "%n for header: %s" + "%n raw field value: %s" + "%n original error: %s", _seeker, entry + ":" + (i + 1), _header, !string.ReferenceEquals(stringValue, null) ? stringValue : "??", e.Message);
if (e is InputException)
{
throw Exceptions.withMessage(e, message);
}
throw new InputException(message, e);
}
}
static int Main(string[] args)
{
Log.Logger = new LoggerConfiguration()
.MinimumLevel.Debug()
.WriteTo.LiterateConsole()
.WriteTo.RollingFile(Path.Combine("logs", "CWEBot") + "-{Date}.log")
.CreateLogger();
L = Log.ForContext <Program>();
var result = Parser.Default.ParseArguments <ExtractOptions, TransformOptions>(args)
.WithNotParsed((IEnumerable <Error> errors) =>
{
Exit(ExitResult.INVALID_OPTIONS);
})
.WithParsed((ExtractOptions o) =>
{
if (Extractors.Contains(o.Extractor))
{
ExtractOptions = o;
Extract();
Exit(ExitResult.SUCCESS);
}
else
{
L.Error("The current extractors are: {extractors}.", Extractors);
Exit(ExitResult.INVALID_OPTIONS);
}
})
.WithParsed((TransformOptions o) =>
{
TransformOptions = o;
if (!File.Exists(TransformOptions.InputFile))
{
L.Error("The input file {0} for transform does not exist.", TransformOptions.InputFile);
Exit(ExitResult.INPUT_FILE_ERROR);
}
else
{
InputFile = new FileInfo(TransformOptions.InputFile);
L.Information("Using input file {file} or transform.", TransformOptions.InputFile);
}
TrainingOutputFile = new FileInfo(TransformOptions.OutputFile + ".training.tsv");
if (TrainingOutputFile.Exists)
{
if (!TransformOptions.OverwriteOutputFile)
{
L.Error("The training output file {0} exists. Use the --overwrite flag to overwrite an existing file.", TrainingOutputFile.FullName);
Exit(ExitResult.OUTPUT_FILE_EXISTS);
}
else
{
L.Information("Existing training output file {0} will be overwritten.", TrainingOutputFile.FullName);
}
}
TestOutputFile = new FileInfo(TransformOptions.OutputFile + ".test.tsv");
if (TrainingOutputFile.Exists)
{
if (!TransformOptions.OverwriteOutputFile)
{
L.Error("The test output file {0} exists. Use the --overwrite flag to overwrite an existing file.", TestOutputFile.FullName);
Exit(ExitResult.OUTPUT_FILE_EXISTS);
}
else
{
L.Information("Existing test output file {0} will be overwritten.", TestOutputFile.FullName);
}
}
TargetOutputFile = new FileInfo(TransformOptions.OutputFile + ".target.tsv");
if (TargetOutputFile.Exists)
{
if (!TransformOptions.OverwriteOutputFile)
{
L.Error("The target output file {0} exists. Use the --overwrite flag to overwrite an existing file.", TargetOutputFile.FullName);
Exit(ExitResult.OUTPUT_FILE_EXISTS);
}
else
{
L.Information("Existing target dataset file {0} will be overwritten.", TargetOutputFile.FullName);
}
}
Dictionary <string, object> options = new Dictionary <string, object>();
if (TransformOptions.WithDescription)
{
options.Add("WithDescription", true);
}
if (TransformOptions.VulnerabilitiesLimit > 0)
{
options.Add("VulnerabilitiesLimit", TransformOptions.VulnerabilitiesLimit);
}
if (TransformOptions.Split != 8)
{
options.Add("Split", TransformOptions.Split);
}
TransformStage transform = new TransformStage(InputFile, TrainingOutputFile, TestOutputFile, TargetOutputFile, options.Count == 0 ? null : options);
if (!transform.CreateModelDataset())
{
Exit(ExitResult.ERROR_TRANSFORMING_DATA);
}
else
{
Exit(ExitResult.SUCCESS);
}
});
return(0);
}
public bool CanExtract(string url)
{
return(Extractors.Any(e => e.CanExtract(url)));
}
public IPackageExtractor GetExtractor(string packageFile)
{
var extension = Path.GetExtension(packageFile);
if (string.IsNullOrEmpty(extension))
{
throw new FileFormatException("Package is missing file extension. This is needed to select the correct extraction algorithm.");
}
var file = PackageName.FromFile(packageFile);
if (!Extensions.Contains(file.Extension))
{
throw new FileFormatException($"Unsupported file extension `{extension}`");
}
var extractor = FindByExtension(file);
if (extractor != null)
{
return(extractor);
}
throw new FileFormatException(supportLinkGenerator.GenerateSupportMessage(
$"This step supports packages with the following extensions: {Extractors.SelectMany(e => e.Extensions).Distinct().Aggregate((result, e) => result + ", " + e)}.\n" +
$"The supplied package has the extension \"{file.Extension}\" which is not supported.",
"JAVA-DEPLOY-ERROR-0001"));
}
public static Header BareboneNodeHeader(IdType idType, Extractors extractors)
{
return(BareboneNodeHeader(null, idType, extractors));
}
public static Header SillyNodeHeader(IdType idType, Extractors extractors)
{
return(new Header(new Header.Entry(null, Type.ID, null, idType.extractor(extractors)), new Header.Entry("name", Type.PROPERTY, null, extractors.String()), new Header.Entry("age", Type.PROPERTY, null, extractors.Int_()), new Header.Entry("something", Type.PROPERTY, null, extractors.String()), new Header.Entry(null, Type.LABEL, null, extractors.StringArray())));
}
