/// <summary> /// Compiles the specified files and generates the output resource file. /// </summary> /// <param name="fileList">The enumeration of <see cref="FileInfo" /> objects.</param> /// <param name="output">The destination <see cref="DirectoryInfo" /> object.</param> /// <returns></returns> internal int Compile(IEnumerable<FileInfo> fileList, ResourceOutput output) { var database = new TzdbDatabase(); ParseAllFiles(fileList, database); GenerateDateTimeZones(database, output); LogCounts(database); return 0; }
public int Execute(WindowsMapperCompilerOptions options) { log.Info("Starting compilation of {0}", options.SourceFileName); DateTimeZone.SetUtcOnly(true); var inputFile = new FileInfo(options.SourceFileName); if (!inputFile.Exists) { log.Error("Source file {0} does not exist", inputFile.FullName); return 2; } var mappings = ReadInput(inputFile); using (var output = new ResourceOutput(WindowsToPosixResource.WindowToPosixMapBase, options.OutputType)) { log.Info("Compiling to {0}", output.OutputFileName); output.WriteDictionary(WindowsToPosixResource.WindowToPosixMapKey, mappings); } log.Info("Finished compiling.", options.SourceFileName); return 0; }
public static ResourceOutput ProvisionOrUpdateResource(string subscriptionId, string cloudServiceName, string resourceType, string resourceName, ResourceInput resource) { ResourceOutput output; lock (theMassiveLock) { Subscription subscription; if (!allSubscriptions.TryGetValue(subscriptionId, out subscription)) { subscription = new Subscription() { Id = subscriptionId }; allSubscriptions[subscriptionId] = subscription; } CloudService theMatchingCloudService = subscription.CloudServices.SingleOrDefault<CloudService>(cs => String.CompareOrdinal(cs.Name, cloudServiceName) == 0); if (theMatchingCloudService == null) { theMatchingCloudService = new CloudService() { Name = cloudServiceName }; subscription.CloudServices.Add(theMatchingCloudService); } ResourceOutput theMatchingResource = theMatchingCloudService.Resources.FirstOrDefault(r => String.Compare(r.Name, resourceName) == 0); if (theMatchingResource != null) { // We can be called to provision / update a resource several time - Ignore the request if we have a record of the resource with the same incarnation id if (theMatchingResource.ETag != resource.ETag) { theMatchingResource.CloudServiceSettings = resource.CloudServiceSettings; theMatchingResource.ETag = resource.ETag; theMatchingResource.IntrinsicSettings = resource.IntrinsicSettings; theMatchingResource.Name = resourceName; theMatchingResource.OperationStatus = new OperationStatus() { Error = new ErrorData() { HttpCode = 200, Message="OK" }, Result = OperationResult.Succeeded }; theMatchingResource.Plan = resource.Plan; theMatchingResource.SchemaVersion = resource.SchemaVersion; theMatchingResource.State = ResourceState.Started.ToString(); theMatchingResource.SubState = ""; theMatchingResource.Type = resource.Type; } output = theMatchingResource; } else { output = new ResourceOutput() { CloudServiceSettings = resource.CloudServiceSettings, ETag = resource.ETag, IntrinsicSettings = resource.IntrinsicSettings, Name = resourceName, OperationStatus = new OperationStatus() { Error = new ErrorData() { HttpCode = 200, Message="OK" }, Result = OperationResult.Succeeded }, OutputItems = GenerateOutputItems(), Plan = resource.Plan, SchemaVersion = resource.SchemaVersion, State = ResourceState.Started.ToString(), SubState = "", Type = resource.Type }; theMatchingCloudService.Resources.Add(output); } } return output; }
/// <summary> /// Generates the date time zones from the given parsed time zone information object. /// </summary> /// <remarks> /// <para> /// First we go through the list of time zones and generate an <see cref="DateTimeZone" /> /// object for each one. We create a mapping between the time zone name and itself (for /// writing out later). Then we write out the time zone as a resource to the current writer. /// </para> /// <para> /// Second we go through all of the alias mappings and find the actual time zone that they /// map to. we do this by redirecting through aliases until there are no more aliases. This /// allows for on alias to refer to another. We add the alias mapping to the time zone /// mapping created in the first step. When done, we write out the entire mapping as a /// resource. The keys of the mapping can be used as the list of valid time zone ids /// supported by this resource file. /// </para> /// </remarks> /// <param name="database">The database of parsed zone info records.</param> /// <param name="output">The output file <see cref="ResourceOutput" />.</param> private static void GenerateDateTimeZones(TzdbDatabase database, ResourceOutput output) { var timeZoneMap = new Dictionary<string, string>(); foreach (var zoneList in database.Zones) { var timeZone = CreateTimeZone(zoneList, database.Rules); timeZoneMap.Add(timeZone.Id, timeZone.Id); output.WriteTimeZone(timeZone.Id, timeZone); } foreach (var key in database.Aliases.Keys) { var value = database.Aliases[key]; while (database.Aliases.ContainsKey(value)) { value = database.Aliases[value]; } timeZoneMap.Add(key, value); } output.WriteDictionary(DateTimeZoneResourceProvider.IdMapKey, timeZoneMap); }
public int Execute(TzdbCompilerOptions options) { log.Info("Starting compilation of directory {0}", options.SourceDirectoryName); DateTimeZone.SetUtcOnly(true); var sourceDirectory = new DirectoryInfo(options.SourceDirectoryName); var outputFile = new FileInfo(options.OutputFileName); var files = options.InputFiles; var fileList = MakeFileList(sourceDirectory, files); ValidateArguments(sourceDirectory, fileList); using (var output = new ResourceOutput(outputFile.FullName, options.OutputType)) { //// Using this conditional code makes debugging simpler in Visual Studio because exceptions will //// be caught by VS and shown with the exception visualizer. #if DEBUG Compile(fileList, output); #else try { Compile(fileList, output); } catch (Exception e) { log.Error("{0}", e.Message); return 2; } #endif } log.Info("Done compiling time zones."); return 0; }