private async Task ValidateRunnerHash(string archiveFile, string packageHashValue) { var stopWatch = Stopwatch.StartNew(); // Validate Hash Matches if it is provided using (FileStream stream = File.OpenRead(archiveFile)) { if (!string.IsNullOrEmpty(packageHashValue)) { using (SHA256 sha256 = SHA256.Create()) { byte[] srcHashBytes = await sha256.ComputeHashAsync(stream); var hash = PrimitiveExtensions.ConvertToHexString(srcHashBytes); if (hash != packageHashValue) { // Hash did not match, we can't recover from this, just throw throw new Exception($"Computed runner hash {hash} did not match expected Runner Hash {packageHashValue} for {_targetPackage.Filename}"); } stopWatch.Stop(); Trace.Info($"Validated Runner Hash matches {_targetPackage.Filename} : {packageHashValue}"); _updateTrace.Add($"ValidateHashTime: {stopWatch.ElapsedMilliseconds}ms"); } } } }
public static IQueryable <TEntity> Sort <TEntity>(this IQueryable <TEntity> result, string fields) { if (string.IsNullOrEmpty(fields)) { return(result); } var useThenBy = false; foreach (var sortTerm in fields.Fields()) { var property = PrimitiveExtensions.GetProperty <TEntity>(sortTerm.FieldName()); if (property != null) { var command = useThenBy ? "ThenBy" : "OrderBy"; command += sortTerm.IsDescending() ? "Descending" : string.Empty; result = result.OrderBy(property, command); } useThenBy = true; } return(result); }
public bool IsMatch(ResolutionContext context) { var isMatch = PrimitiveExtensions.IsEnumerableType(context.SourceType) && PrimitiveExtensions.IsCollectionType(context.DestinationType); return(isMatch); }
public static IQueryable <TEntity> Paginate <TEntity, TModel>(this IQueryable <TEntity> result, TModel options) where TModel : IQueryPaging { var attr = Attribute.GetCustomAttributes(PrimitiveExtensions.GetProperty <TModel>("Limit")).FirstOrDefault(); // Check for the AnimalType attribute. if (attr?.GetType() == typeof(QueryOperatorAttribute)) { var data = (QueryOperatorAttribute)attr; if (data.Max > 0) { options.Limit = data.Max; } } if (options.Offset.HasValue) { result = result.Skip(options.Offset.Value); } if (options.Limit.HasValue) { result = result.Take(options.Limit.Value); } return(result); }
public override bool IsMatch(ResolutionContext context) { // destination type must be IEnumerable interface or a class implementing at least IList return(PrimitiveExtensions.IsEnumerableType(context.SourceType) && (PrimitiveExtensions.IsListType(context.DestinationType) || DestinationIListTypedAsIEnumerable(context))); }
public static IQueryable <TEntity> Paginate <TEntity, TModel>(this IQueryable <TEntity> result, TModel options) where TModel : class, IQueryPaging { var attr = Attribute.GetCustomAttribute(PrimitiveExtensions.GetProperty(options.GetType(), "Limit"), typeof(QueryOperatorAttribute)); if (attr?.GetType() == typeof(QueryOperatorAttribute)) { var data = (QueryOperatorAttribute)attr; if (data.Max > 0) { options.Limit = data.Max; } } if (options.Offset.HasValue) { result = result.Skip(options.Offset.Value); } if (options.Limit.HasValue) { result = result.Take(options.Limit.Value); } return(result); }
public TypeMap ResolveTypeMap(TypePair typePair) { var typeMap = _typeMapPlanCache.GetOrAdd(typePair, _ => GetRelatedTypePairs(_) .Select(tp => PrimitiveExtensions.GetOrDefault(_typeMapPlanCache, tp) ?? FindTypeMapFor(tp)) .FirstOrDefault(tm => tm != null)); return(typeMap); }
/// <summary> /// Adds a node to this database. /// </summary> /// <param name="node"></param> public override void AddNode(Node node) { // save the node in the current redis key. string nodeKey = node.GetRedisKey(); _nodeTypeClient.SetEntry(nodeKey, PrimitiveExtensions.ConvertTo(node)); // save the node in the correct osmhash location. var idBytes = BitConverter.GetBytes(node.Id.Value); _redisClient.SAdd(node.GetOsmHash(), idBytes); }
public bool IsMatch(ResolutionContext context) { if ( !(PrimitiveExtensions.IsEnumerableType(context.SourceType) && TypeExtensions.IsGenericType(context.DestinationType))) { return(false); } var genericType = context.DestinationType.GetGenericTypeDefinition(); return(genericType == typeof(ReadOnlyCollection <>)); }
private static MethodInfo GetImplicitConversionOperator(ResolutionContext context) { var destinationType = context.DestinationType; if (PrimitiveExtensions.IsNullableType(destinationType)) { destinationType = PrimitiveExtensions.GetTypeOfNullable(destinationType); } var sourceTypeMethod = TypeExtensions.GetDeclaredMethods(context.SourceType) .FirstOrDefault( mi => mi.IsPublic && mi.IsStatic && mi.Name == "op_Implicit" && mi.ReturnType == destinationType); return(sourceTypeMethod ?? destinationType.GetMethod("op_Implicit", new[] { context.SourceType })); }
public static Type GetEnumerationType(Type enumType) { if (PrimitiveExtensions.IsNullableType(enumType)) { enumType = enumType.GetGenericArguments()[0]; } if (!TypeExtensions.IsEnum(enumType)) { return(null); } return(enumType); }
/// <summary> /// Adds a relation to this database. /// </summary> /// <param name="relation"></param> public override void AddRelation(Relation relation) { // save the relation in the current redis key. string relationKey = relation.GetRedisKey(); _relationTypeClient.SetEntry(relationKey, PrimitiveExtensions.ConvertTo(relation)); // save the relation-member relation. if (relation.Members != null) { foreach (var member in relation.Members) { _redisClient.AddItemToSet(PrimitiveExtensions.BuildMemberRelationListRedisKey(member), relation.Id.Value.ToString()); } } }
private static MemberInfo[] BuildPublicAccessors(IEnumerable <MemberInfo> allMembers) { // Multiple types may define the same property (e.g. the class and multiple interfaces) - filter this to one of those properties var filteredMembers = allMembers .OfType <PropertyInfo>() .GroupBy(x => x.Name) // group properties of the same name together .Select(x => x.Any(y => y.CanWrite && y.CanRead) ? // favor the first property that can both read & write - otherwise pick the first one x.First(y => y.CanWrite && y.CanRead) : x.First()) .Where(pi => pi.CanWrite || PrimitiveExtensions.IsListOrDictionaryType(pi.PropertyType)) .OfType <MemberInfo>() // cast back to MemberInfo so we can add back FieldInfo objects .Concat(allMembers.Where(x => x is FieldInfo)); // add FieldInfo objects back return(filteredMembers.ToArray()); }
bool IMappingEngineRunner.ShouldMapSourceValueAsNull(ResolutionContext context) { if (TypeExtensions.IsValueType(context.DestinationType) && !PrimitiveExtensions.IsNullableType(context.DestinationType)) { return(false); } var typeMap = context.GetContextTypeMap(); if (typeMap != null) { return(ConfigurationProvider.GetProfileConfiguration(typeMap.Profile).AllowNullDestinationValues); } return(ConfigurationProvider.AllowNullDestinationValues); }
/// <summary> /// Adds a way to this database. /// </summary> /// <param name="way"></param> public override void AddWay(Way way) { // save the way in the current redis key. string wayKey = way.GetRedisKey(); _wayTypeClient.SetEntry(wayKey, PrimitiveExtensions.ConvertTo(way)); // save the way-node relation. if (way.Nodes != null) { foreach (long nodeId in way.Nodes) { _redisClient.AddItemToSet(PrimitiveExtensions.BuildNodeWayListRedisKey(nodeId), way.Id.Value.ToString()); } } }
/// <summary> /// Returns true if the given object exists. /// </summary> /// <param name="id"></param> /// <param name="type"></param> /// <returns></returns> private bool Exist(long id, OsmGeoType type) { switch (type) { case OsmGeoType.Node: string nodeKey = PrimitiveExtensions.BuildNodeRedisKey(id); return(_clientNode.ContainsKey(nodeKey)); case OsmGeoType.Way: string wayKey = PrimitiveExtensions.BuildWayRedisKey(id); return(_clientWay.ContainsKey(wayKey)); case OsmGeoType.Relation: string relationKey = PrimitiveExtensions.BuildRelationRedisKey(id); return(_clientRelation.ContainsKey(relationKey)); } throw new ArgumentOutOfRangeException("type"); }
public object Map(ResolutionContext context, IMappingEngineRunner mapper) { if (context.IsSourceValueNull && mapper.ShouldMapSourceCollectionAsNull(context)) { return(null); } var genericSourceDictType = PrimitiveExtensions.GetDictionaryType(context.SourceType); var sourceKeyType = genericSourceDictType.GetGenericArguments()[0]; var sourceValueType = genericSourceDictType.GetGenericArguments()[1]; var sourceKvpType = KvpType.MakeGenericType(sourceKeyType, sourceValueType); var genericDestDictType = PrimitiveExtensions.GetDictionaryType(context.DestinationType); var destKeyType = genericDestDictType.GetGenericArguments()[0]; var destValueType = genericDestDictType.GetGenericArguments()[1]; var kvpEnumerator = GetKeyValuePairEnumerator(context, sourceKvpType); var destDictionary = ObjectCreator.CreateDictionary(context.DestinationType, destKeyType, destValueType); var count = 0; while (kvpEnumerator.MoveNext()) { var keyValuePair = kvpEnumerator.Current; var sourceKey = sourceKvpType.GetProperty("Key").GetValue(keyValuePair, new object[0]); var sourceValue = sourceKvpType.GetProperty("Value").GetValue(keyValuePair, new object[0]); var keyTypeMap = mapper.ConfigurationProvider.ResolveTypeMap(sourceKey, null, sourceKeyType, destKeyType); var valueTypeMap = mapper.ConfigurationProvider.ResolveTypeMap(sourceValue, null, sourceValueType, destValueType); var keyContext = context.CreateElementContext(keyTypeMap, sourceKey, sourceKeyType, destKeyType, count); var valueContext = context.CreateElementContext(valueTypeMap, sourceValue, sourceValueType, destValueType, count); var destKey = mapper.Map(keyContext); var destValue = mapper.Map(valueContext); genericDestDictType.GetMethod("Add").Invoke(destDictionary, new[] { destKey, destValue }); count++; } return(destDictionary); }
public object Map(ResolutionContext context, IMappingEngineRunner mapper) { var sourceEnumerableValue = (IEnumerable)context.SourceValue ?? new object[0]; var enumerableValue = sourceEnumerableValue.Cast <object>(); var sourceElementType = TypeHelper.GetElementType(context.SourceType, sourceEnumerableValue); var genericDestDictType = PrimitiveExtensions.GetDictionaryType(context.DestinationType); var destKeyType = genericDestDictType.GetGenericArguments()[0]; var destValueType = genericDestDictType.GetGenericArguments()[1]; var destKvpType = KvpType.MakeGenericType(destKeyType, destValueType); var destDictionary = ObjectCreator.CreateDictionary(context.DestinationType, destKeyType, destValueType); var count = 0; foreach (var item in enumerableValue) { var typeMap = mapper.ConfigurationProvider.ResolveTypeMap(item, null, sourceElementType, destKvpType); var targetSourceType = typeMap != null ? typeMap.SourceType : sourceElementType; var targetDestinationType = typeMap != null ? typeMap.DestinationType : destKvpType; var newContext = context.CreateElementContext(typeMap, item, targetSourceType, targetDestinationType, count); var mappedValue = mapper.Map(newContext); var keyProperty = mappedValue.GetType().GetProperty("Key"); var destKey = keyProperty.GetValue(mappedValue, null); var valueProperty = mappedValue.GetType().GetProperty("Value"); var destValue = valueProperty.GetValue(mappedValue, null); genericDestDictType.GetMethod("Add").Invoke(destDictionary, new[] { destKey, destValue }); count++; } return(destDictionary); }
/// <summary> /// Stores an osmGeo object to disk. /// </summary> /// <param name="osmGeo"></param> private void Store(OsmGeo osmGeo) { switch (osmGeo.Type) { case OsmGeoType.Node: Node node = osmGeo as Node; string nodeKey = node.GetRedisKey(); _clientNode.SetEntry(nodeKey, PrimitiveExtensions.ConvertTo(node)); break; case OsmGeoType.Way: Way way = osmGeo as Way; string wayKey = way.GetRedisKey(); _clientWay.SetEntry(wayKey, PrimitiveExtensions.ConvertTo(way)); break; case OsmGeoType.Relation: Relation relation = osmGeo as Relation; string relationKey = relation.GetRedisKey(); _clientRelation.SetEntry(relationKey, PrimitiveExtensions.ConvertTo(relation)); break; } }
/// <summary> /// Deletes an osmGeo object from disk. /// </summary> /// <param name="id"></param> /// <param name="type"></param> private void Delete(long id, OsmGeoType type) { switch (type) { case OsmGeoType.Node: string nodeKey = PrimitiveExtensions.BuildNodeRedisKey(id); _client.Del(nodeKey); //_clientNode.DeleteById(nodeKey); break; case OsmGeoType.Way: string wayKey = PrimitiveExtensions.BuildWayRedisKey(id); //_clientWay.DeleteById(wayKey); _client.Del(wayKey); break; case OsmGeoType.Relation: string relationKey = PrimitiveExtensions.BuildRelationRedisKey(id); //_clientRelation.DeleteById(relationKey); _client.Del(relationKey); break; } }
/// <summary> /// Reads an osmGeo object from disk. /// </summary> /// <param name="id"></param> /// <param name="type"></param> private OsmGeo Read(long id, OsmGeoType type) { switch (type) { case OsmGeoType.Node: string nodeKey = PrimitiveExtensions.BuildNodeRedisKey(id); RedisNode redisNode = _clientNode.GetValue(nodeKey); Node node = null; if (redisNode != null) { node = PrimitiveExtensions.ConvertFrom(redisNode); } return(node); case OsmGeoType.Way: string wayKey = PrimitiveExtensions.BuildWayRedisKey(id); RedisWay redisWay = _clientWay.GetValue(wayKey); Way way = null; if (redisWay != null) { way = PrimitiveExtensions.ConvertFrom(redisWay); } return(way); case OsmGeoType.Relation: string relationKey = PrimitiveExtensions.BuildRelationRedisKey(id); RedisRelation redisRelation = _clientRelation.GetValue(relationKey); Relation relation = null; if (redisRelation != null) { relation = PrimitiveExtensions.ConvertFrom(redisRelation); } return(relation); } throw new ArgumentOutOfRangeException("type"); }
public object Map(ResolutionContext context, IMappingEngineRunner mapper) { var toEnum = false; var enumSourceType = TypeHelper.GetEnumerationType(context.SourceType); var enumDestinationType = TypeHelper.GetEnumerationType(context.DestinationType); if (EnumToStringMapping(context, ref toEnum)) { if (context.SourceValue == null) { return(mapper.CreateObject(context)); } if (toEnum) { var stringValue = context.SourceValue.ToString(); if (string.IsNullOrEmpty(stringValue)) { return(mapper.CreateObject(context)); } return(Enum.Parse(enumDestinationType, stringValue, true)); } return(Enum.GetName(enumSourceType, context.SourceValue)); } if (EnumToEnumMapping(context)) { if (context.SourceValue == null) { if (mapper.ShouldMapSourceValueAsNull(context) && PrimitiveExtensions.IsNullableType(context.DestinationType)) { return(null); } return(mapper.CreateObject(context)); } if (!Enum.IsDefined(enumSourceType, context.SourceValue)) { return(Enum.ToObject(enumDestinationType, context.SourceValue)); } if (FeatureDetector.IsEnumGetNamesSupported) { var enumValueMapper = EnumNameValueMapperFactory.Create(); if (enumValueMapper.IsMatch(enumDestinationType, context.SourceValue.ToString())) { return(enumValueMapper.Convert(enumSourceType, enumDestinationType, context)); } } return(Enum.Parse(enumDestinationType, Enum.GetName(enumSourceType, context.SourceValue), true)); } if (EnumToUnderlyingTypeMapping(context, ref toEnum)) { if (toEnum && context.SourceValue != null) { return(Enum.Parse(enumDestinationType, context.SourceValue.ToString(), true)); } if (EnumToNullableTypeMapping(context)) { return(ConvertEnumToNullableType(context)); } return(Convert.ChangeType(context.SourceValue, context.DestinationType, null)); } return(null); }
public override bool IsMatch(ResolutionContext context) { return((context.DestinationType.IsArray) && (PrimitiveExtensions.IsEnumerableType(context.SourceType))); }
private static bool DestinationIListTypedAsIEnumerable(ResolutionContext context) { return(TypeExtensions.IsInterface(context.DestinationType) && PrimitiveExtensions.IsEnumerableType(context.DestinationType) && (context.DestinationValue == null || context.DestinationValue is IList)); }
private void DryRunTypeMap(ICollection <TypeMap> typeMapsChecked, ResolutionContext context) { if (context.TypeMap != null) { typeMapsChecked.Add(context.TypeMap); } var mapperToUse = GetMappers().FirstOrDefault(mapper => mapper.IsMatch(context)); if (mapperToUse == null && PrimitiveExtensions.IsNullableType(context.SourceType)) { var nullableContext = context.CreateValueContext(null, Nullable.GetUnderlyingType(context.SourceType)); mapperToUse = GetMappers().FirstOrDefault(mapper => mapper.IsMatch(nullableContext)); } if (mapperToUse == null) { throw new AutoMapperConfigurationException(context); } if (mapperToUse is TypeMapMapper) { foreach (var propertyMap in context.TypeMap.GetPropertyMaps()) { if (!propertyMap.IsIgnored()) { var lastResolver = propertyMap.GetSourceValueResolvers().OfType <IMemberResolver>().LastOrDefault(); if (lastResolver != null) { var sourceType = lastResolver.MemberType; var destinationType = propertyMap.DestinationProperty.MemberType; var memberTypeMap = ((IConfigurationProvider)this).ResolveTypeMap(sourceType, destinationType); if (typeMapsChecked.Any(typeMap => Equals(typeMap, memberTypeMap))) { continue; } var memberContext = context.CreateMemberContext(memberTypeMap, null, null, sourceType, propertyMap); DryRunTypeMap(typeMapsChecked, memberContext); } } } } else if (mapperToUse is ArrayMapper || mapperToUse is EnumerableMapper || mapperToUse is CollectionMapper) { var sourceElementType = TypeHelper.GetElementType(context.SourceType); var destElementType = TypeHelper.GetElementType(context.DestinationType); var itemTypeMap = ((IConfigurationProvider)this).ResolveTypeMap(sourceElementType, destElementType); if (typeMapsChecked.Any(typeMap => Equals(typeMap, itemTypeMap))) { return; } var memberContext = context.CreateElementContext(itemTypeMap, null, sourceElementType, destElementType, 0); DryRunTypeMap(typeMapsChecked, memberContext); } }
private static bool BothAreNonNullable(Expression node, Expression newLeft) { return(!PrimitiveExtensions.IsNullableType(node.Type) && !PrimitiveExtensions.IsNullableType(newLeft.Type)); }
public bool IsMatch(PropertyMap propertyMap, TypeMap propertyTypeMap, ExpressionResolutionResult result) { return(PrimitiveExtensions.IsNullableType(propertyMap.DestinationPropertyType) && !PrimitiveExtensions.IsNullableType(result.Type)); }
public bool IsMatch(ResolutionContext context) { return(PrimitiveExtensions.IsDictionaryType(context.SourceType) && PrimitiveExtensions.IsDictionaryType(context.DestinationType)); }
/// <summary> /// _work /// \_update /// \bin /// \externals /// \run.sh /// \run.cmd /// \package.zip //temp download .zip/.tar.gz /// </summary> /// <param name="token"></param> /// <returns></returns> private async Task DownloadLatestRunner(CancellationToken token) { string latestRunnerDirectory = Path.Combine(HostContext.GetDirectory(WellKnownDirectory.Work), Constants.Path.UpdateDirectory); IOUtil.DeleteDirectory(latestRunnerDirectory, token); Directory.CreateDirectory(latestRunnerDirectory); int runnerSuffix = 1; string archiveFile = null; bool downloadSucceeded = false; try { // Download the runner, using multiple attempts in order to be resilient against any networking/CDN issues for (int attempt = 1; attempt <= Constants.RunnerDownloadRetryMaxAttempts; attempt++) { // Generate an available package name, and do our best effort to clean up stale local zip files while (true) { if (_targetPackage.Platform.StartsWith("win")) { archiveFile = Path.Combine(latestRunnerDirectory, $"runner{runnerSuffix}.zip"); } else { archiveFile = Path.Combine(latestRunnerDirectory, $"runner{runnerSuffix}.tar.gz"); } try { // delete .zip file if (!string.IsNullOrEmpty(archiveFile) && File.Exists(archiveFile)) { Trace.Verbose("Deleting latest runner package zip '{0}'", archiveFile); IOUtil.DeleteFile(archiveFile); } break; } catch (Exception ex) { // couldn't delete the file for whatever reason, so generate another name Trace.Warning("Failed to delete runner package zip '{0}'. Exception: {1}", archiveFile, ex); runnerSuffix++; } } // Allow a 15-minute package download timeout, which is good enough to update the runner from a 1 Mbit/s ADSL connection. if (!int.TryParse(Environment.GetEnvironmentVariable("GITHUB_ACTIONS_RUNNER_DOWNLOAD_TIMEOUT") ?? string.Empty, out int timeoutSeconds)) { timeoutSeconds = 15 * 60; } Trace.Info($"Attempt {attempt}: save latest runner into {archiveFile}."); using (var downloadTimeout = new CancellationTokenSource(TimeSpan.FromSeconds(timeoutSeconds))) using (var downloadCts = CancellationTokenSource.CreateLinkedTokenSource(downloadTimeout.Token, token)) { try { Trace.Info($"Download runner: begin download"); //open zip stream in async mode using (HttpClient httpClient = new HttpClient(HostContext.CreateHttpClientHandler())) { if (!string.IsNullOrEmpty(_targetPackage.Token)) { Trace.Info($"Adding authorization token ({_targetPackage.Token.Length} chars)"); httpClient.DefaultRequestHeaders.Authorization = new System.Net.Http.Headers.AuthenticationHeaderValue("Bearer", _targetPackage.Token); } Trace.Info($"Downloading {_targetPackage.DownloadUrl}"); using (FileStream fs = new FileStream(archiveFile, FileMode.Create, FileAccess.Write, FileShare.None, bufferSize: 4096, useAsync: true)) using (Stream result = await httpClient.GetStreamAsync(_targetPackage.DownloadUrl)) { //81920 is the default used by System.IO.Stream.CopyTo and is under the large object heap threshold (85k). await result.CopyToAsync(fs, 81920, downloadCts.Token); await fs.FlushAsync(downloadCts.Token); } } Trace.Info($"Download runner: finished download"); downloadSucceeded = true; break; } catch (OperationCanceledException) when(token.IsCancellationRequested) { Trace.Info($"Runner download has been canceled."); throw; } catch (Exception ex) { if (downloadCts.Token.IsCancellationRequested) { Trace.Warning($"Runner download has timed out after {timeoutSeconds} seconds"); } Trace.Warning($"Failed to get package '{archiveFile}' from '{_targetPackage.DownloadUrl}'. Exception {ex}"); } } } if (!downloadSucceeded) { throw new TaskCanceledException($"Runner package '{archiveFile}' failed after {Constants.RunnerDownloadRetryMaxAttempts} download attempts"); } // If we got this far, we know that we've successfully downloaded the runner package // Validate Hash Matches if it is provided using (FileStream stream = File.OpenRead(archiveFile)) { if (!String.IsNullOrEmpty(_targetPackage.HashValue)) { using (SHA256 sha256 = SHA256.Create()) { byte[] srcHashBytes = await sha256.ComputeHashAsync(stream); var hash = PrimitiveExtensions.ConvertToHexString(srcHashBytes); if (hash != _targetPackage.HashValue) { // Hash did not match, we can't recover from this, just throw throw new Exception($"Computed runner hash {hash} did not match expected Runner Hash {_targetPackage.HashValue} for {_targetPackage.Filename}"); } Trace.Info($"Validated Runner Hash matches {_targetPackage.Filename} : {_targetPackage.HashValue}"); } } } if (archiveFile.EndsWith(".zip", StringComparison.OrdinalIgnoreCase)) { ZipFile.ExtractToDirectory(archiveFile, latestRunnerDirectory); } else if (archiveFile.EndsWith(".tar.gz", StringComparison.OrdinalIgnoreCase)) { string tar = WhichUtil.Which("tar", trace: Trace); if (string.IsNullOrEmpty(tar)) { throw new NotSupportedException($"tar -xzf"); } // tar -xzf using (var processInvoker = HostContext.CreateService <IProcessInvoker>()) { processInvoker.OutputDataReceived += new EventHandler <ProcessDataReceivedEventArgs>((sender, args) => { if (!string.IsNullOrEmpty(args.Data)) { Trace.Info(args.Data); } }); processInvoker.ErrorDataReceived += new EventHandler <ProcessDataReceivedEventArgs>((sender, args) => { if (!string.IsNullOrEmpty(args.Data)) { Trace.Error(args.Data); } }); int exitCode = await processInvoker.ExecuteAsync(latestRunnerDirectory, tar, $"-xzf \"{archiveFile}\"", null, token); if (exitCode != 0) { throw new NotSupportedException($"Can't use 'tar -xzf' extract archive file: {archiveFile}. return code: {exitCode}."); } } } else { throw new NotSupportedException($"{archiveFile}"); } Trace.Info($"Finished getting latest runner package at: {latestRunnerDirectory}."); } finally { try { // delete .zip file if (!string.IsNullOrEmpty(archiveFile) && File.Exists(archiveFile)) { Trace.Verbose("Deleting latest runner package zip: {0}", archiveFile); IOUtil.DeleteFile(archiveFile); } } catch (Exception ex) { //it is not critical if we fail to delete the .zip file Trace.Warning("Failed to delete runner package zip '{0}'. Exception: {1}", archiveFile, ex); } } // copy latest runner into runner root folder // copy bin from _work/_update -> bin.version under root string binVersionDir = Path.Combine(HostContext.GetDirectory(WellKnownDirectory.Root), $"{Constants.Path.BinDirectory}.{_targetPackage.Version}"); Directory.CreateDirectory(binVersionDir); Trace.Info($"Copy {Path.Combine(latestRunnerDirectory, Constants.Path.BinDirectory)} to {binVersionDir}."); IOUtil.CopyDirectory(Path.Combine(latestRunnerDirectory, Constants.Path.BinDirectory), binVersionDir, token); // copy externals from _work/_update -> externals.version under root string externalsVersionDir = Path.Combine(HostContext.GetDirectory(WellKnownDirectory.Root), $"{Constants.Path.ExternalsDirectory}.{_targetPackage.Version}"); Directory.CreateDirectory(externalsVersionDir); Trace.Info($"Copy {Path.Combine(latestRunnerDirectory, Constants.Path.ExternalsDirectory)} to {externalsVersionDir}."); IOUtil.CopyDirectory(Path.Combine(latestRunnerDirectory, Constants.Path.ExternalsDirectory), externalsVersionDir, token); // copy and replace all .sh/.cmd files Trace.Info($"Copy any remaining .sh/.cmd files into runner root."); foreach (FileInfo file in new DirectoryInfo(latestRunnerDirectory).GetFiles() ?? new FileInfo[0]) { string destination = Path.Combine(HostContext.GetDirectory(WellKnownDirectory.Root), file.Name); // Removing the file instead of just trying to overwrite it works around permissions issues on linux. // https://github.com/actions/runner/issues/981 Trace.Info($"Copy {file.FullName} to {destination}"); IOUtil.DeleteFile(destination); file.CopyTo(destination, true); } }
public bool IsMatch(ResolutionContext context) { return(PrimitiveExtensions.IsNullableType(context.DestinationType)); }