void loadFile_Click(object sender, MouseEventArgs mouseEvent)
{
GuiHalWidget.OpenFileDialogParams openParams = new GuiHalWidget.OpenFileDialogParams("MatterScript Files,c-sharp code", "*.part,*.cs");
Stream streamToLoadFrom = GuiHalFactory.PrimaryHalWidget.OpenFileDialog(openParams);
if (streamToLoadFrom != null)
{
loadedFileName = openParams.FileName;
string extension = System.IO.Path.GetExtension(openParams.FileName).ToUpper(CultureInfo.InvariantCulture);
if (extension == ".CS")
{
loadedSourceFileType = SourceFileType.CSharp;
}
else if (extension == ".VB")
{
loadedSourceFileType = SourceFileType.VisualBasic;
}
//string text = System.IO.File.ReadAllText(loadedFileName);
StreamReader streamReader = new StreamReader(streamToLoadFrom);
matterScriptEditor.Text = streamReader.ReadToEnd();
streamToLoadFrom.Close();
verticleSpliter.SplitterDistance = verticleSpliter.SplitterDistance - 1;
verticleSpliter.SplitterDistance = verticleSpliter.SplitterDistance + 1;
}
}
/// <summary>
/// Creates a new source file.
///
/// <param name="filename">source file name</param>
/// <returns>newly created source file</returns>
/// </summary>
public SourceFile(CodeContext context, SourceFileType type, string filename, string content = null, bool cmdline = false)
{
this.context = context;
this.file_type = type;
this.filename = filename;
this.content = content;
this.from_commandline = cmdline;
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="project">Project.</param>
/// <param name="sourceFileType">SourceFileType.</param>
public ApexPageFolderNode(Project project, SourceFileType sourceFileType) :
base(project, sourceFileType)
{
if (sourceFileType.Name != "ApexPage")
{
throw new ArgumentException("sourceFileType", "The sourceFileType must be for ApexPage");
}
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
Dictionary <Enum, object> providerParameters = new Dictionary <Enum, object>();
providerParameters.Add(VaultParams.VaultName, vaultName);
providerParameters.Add(VaultParams.ResourceGroupName, resourceGroupName);
providerParameters.Add(VaultParams.VaultLocation, VaultLocation);
providerParameters.Add(RestoreBackupItemParams.RecoveryPoint, RecoveryPoint);
providerParameters.Add(RestoreVMBackupItemParams.OsaOption, UseOriginalStorageAccount.IsPresent);
providerParameters.Add(RestoreFSBackupItemParams.ResolveConflict, ResolveConflict.ToString());
providerParameters.Add(RestoreFSBackupItemParams.SourceFilePath, SourceFilePath);
providerParameters.Add(RestoreFSBackupItemParams.TargetStorageAccountName, TargetStorageAccountName);
providerParameters.Add(RestoreFSBackupItemParams.TargetFileShareName, TargetFileShareName);
providerParameters.Add(RestoreFSBackupItemParams.TargetFolder, TargetFolder);
if (StorageAccountName != null)
{
providerParameters.Add(RestoreBackupItemParams.StorageAccountName, StorageAccountName);
}
if (StorageAccountResourceGroupName != null)
{
providerParameters.Add(RestoreBackupItemParams.StorageAccountResourceGroupName, StorageAccountResourceGroupName);
}
if (TargetResourceGroupName != null)
{
providerParameters.Add(RestoreVMBackupItemParams.TargetResourceGroupName, TargetResourceGroupName);
}
if (SourceFileType != null)
{
providerParameters.Add(RestoreFSBackupItemParams.SourceFileType, SourceFileType.ToString());
}
PsBackupProviderManager providerManager =
new PsBackupProviderManager(providerParameters, ServiceClientAdapter);
IPsBackupProvider psBackupProvider = providerManager.GetProviderInstance(
RecoveryPoint.WorkloadType, RecoveryPoint.BackupManagementType);
var jobResponse = psBackupProvider.TriggerRestore();
WriteDebug(string.Format("Restore submitted"));
HandleCreatedJob(
jobResponse,
Resources.RestoreOperation,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
}, ShouldProcess(RecoveryPoint.ItemName, VerbsData.Restore));
}
/// <summary>
/// Set the default values for a new LBRaw class instance
/// </summary>
private void SetClassDefaults()
{
this.rawHeightData = null;
this.dataSourceName = "unknown";
this.rawMinHeight = 0;
this.rawMaxHeight = 0;
this.rawSourceWidth = 0;
this.rawSourceLength = 0;
sourceFileType = SourceFileType.RAW;
}
/// <summary>
/// Create an object using the contents of the corresponding MzIdentML object
/// </summary>
/// <param name="sf"></param>
/// <param name="idata"></param>
public SourceFileInfo(SourceFileType sf, IdentDataObj idata)
: base(sf, idata)
{
Id = sf.id;
Name = sf.name;
ExternalFormatDocumentation = sf.ExternalFormatDocumentation;
Location = sf.location;
_fileFormat = null;
if (sf.FileFormat != null)
{
_fileFormat = new FileFormatInfo(sf.FileFormat, IdentData);
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="project">Project.</param>
/// <param name="sourceFileType">SourceFileType.</param>
/// <param name="sourceFile">SourceFile.</param>
public SourceFileFolderNode(Project project, SourceFileType sourceFileType, SourceFile sourceFile)
{
if (project == null)
{
throw new ArgumentNullException("project");
}
if (sourceFileType == null)
{
throw new ArgumentNullException("sourceFileType");
}
Project = project;
SourceFileType = sourceFileType;
SourceFile = sourceFile;
}
public ResolveContext(IMemberContext mc)
{
if (mc == null)
{
throw new ArgumentNullException();
}
MemberContext = mc;
//
// The default setting comes from the command line option
//
if (mc.Module.Compiler.Settings.Checked)
{
flags |= Options.CheckedScope;
}
//
// The constant check state is always set to true
//
flags |= Options.ConstantCheckState;
//
// File type set from member context module sourcefile.
//
var memberCore = mc as MemberCore;
if (memberCore != null && memberCore.Location.SourceFile != null)
{
fileType = memberCore.Location.SourceFile.FileType;
}
else if (mc.Module != null && mc.Module.Location.SourceFile != null)
{
fileType = mc.Module.Location.SourceFile.FileType;
if (mc.Module.Location.SourceFile.PsExtended)
{
flags |= Options.PsExtended;
}
}
else
{
fileType = SourceFileType.CSharp;
}
}
/// <summary>
/// Clone constructor
/// </summary>
/// <param name="lbRaw"></param>
public LBRaw(LBRaw lbRaw)
{
if (lbRaw == null)
{
SetClassDefaults();
}
else
{
if (string.IsNullOrEmpty(this.dataSourceName))
{
this.dataSourceName = "unknown";
}
else
{
this.dataSourceName = lbRaw.dataSourceName;
}
// Heightmap data
if (lbRaw.rawHeightData == null)
{
this.rawHeightData = null;
this.rawMinHeight = 0;
this.rawMaxHeight = 0;
this.rawSourceWidth = 0;
this.rawSourceLength = 0;
this.sourceFileType = SourceFileType.RAW;
}
else
{
// A shallow copy (clone) works here because it is a primative/immutable type
// This should create a true copy rather than a reference to the input array
this.rawHeightData = lbRaw.rawHeightData.Clone() as byte[];
this.rawMinHeight = lbRaw.rawMinHeight;
this.rawMaxHeight = lbRaw.rawMaxHeight;
this.rawSourceWidth = lbRaw.rawSourceWidth;
this.rawSourceLength = lbRaw.rawSourceLength;
this.sourceFileType = lbRaw.sourceFileType;
}
}
}
private static void CreateElementBySourceFileType(XmlWriter Writer, SourceFileType FileType)
{
switch (FileType)
{
case SourceFileType.SourceCode:
Writer.WriteStartElement("ClCompile");
break;
case SourceFileType.HeaderFile:
Writer.WriteStartElement("ClInclude");
break;
case SourceFileType.InlineImpl:
Writer.WriteStartElement("None");
break;
case SourceFileType.ResourceScript:
Writer.WriteStartElement("ResourceCompile");
break;
default:
throw new NotImplementedException();
}
}
public IEnumerable <KeyValuePair <string, string> > Generate(FileStream input,
ComponentDescription description,
ComponentConfiguration configuration,
string inputBaseName,
IDictionary <IOutputGenerator, string> formats,
PreviewGenerationOptions previewOptions,
SourceFileType sourceType)
{
foreach (var f in formats)
{
if (!f.Key.AcceptsSourceFileType(sourceType))
{
continue;
}
string format = f.Key.Format;
if (sourceType == SourceFileType.ComponentDescriptionConfiguration)
{
inputBaseName += $"--{Regex.Replace(configuration.Name.ToLowerInvariant().Replace(" ", "_"), "[^a-z0-9_]", "")}";
}
string autoGeneratedName = $"{inputBaseName}{f.Key.FileExtension}";
string outputPath = f.Value != null && Directory.Exists(f.Value) ? Path.Combine(f.Value, autoGeneratedName) : f.Value ?? autoGeneratedName;
using (var output = File.Open(outputPath, FileMode.Create))
{
logger.LogDebug($"Starting {format} generation.");
input.Seek(0, SeekOrigin.Begin);
f.Key.Generate(description,
configuration,
resourceProvider,
previewOptions,
input,
output,
sourceType);
logger.LogInformation($" {format,-4} -> {outputPath}");
}
yield return(new KeyValuePair <string, string>(format, outputPath));
}
}
public SourceFile(string name, string path, int index)
{
this.Index = index;
this.Name = name;
this.FullPathName = path;
var ext = Path.GetExtension(path);
if (ext.ToLower() == ".as")
{
FileType = SourceFileType.PlayScript;
PsExtended = false;
}
else if (ext.ToLower() == ".play" || ext.ToLower() == ".asx")
{
FileType = SourceFileType.PlayScript;
PsExtended = true;
}
else
{
FileType = SourceFileType.CSharp;
}
}
public bool AcceptsSourceFileType(SourceFileType sourceType) => true;
public ResolveContext (IMemberContext mc)
{
if (mc == null)
throw new ArgumentNullException ();
MemberContext = mc;
//
// The default setting comes from the command line option
//
if (mc.Module.Compiler.Settings.Checked)
flags |= Options.CheckedScope;
//
// The constant check state is always set to true
//
flags |= Options.ConstantCheckState;
//
// File type set from member context module sourcefile.
//
var memberCore = mc as MemberCore;
if (memberCore != null && memberCore.Location.SourceFile != null) {
fileType = memberCore.Location.SourceFile.FileType;
} else if (mc.Module != null && mc.Module.Location.SourceFile != null) {
fileType = mc.Module.Location.SourceFile.FileType;
if (mc.Module.Location.SourceFile.PsExtended)
flags |= Options.PsExtended;
} else {
fileType = SourceFileType.CSharp;
}
}
public void Generate(ComponentDescription description, ComponentConfiguration configuration, IResourceProvider resourceProvider, PreviewGenerationOptions options, Stream input, Stream output, SourceFileType sourceType)
{
var drawingContext = PreviewRenderer.RenderPreview(size => new SvgDrawingContext(Math.Ceiling(size.Width), Math.Ceiling(size.Height), output),
description,
options);
drawingContext.Dispose();
}
void loadFile_Click(object sender, MouseEventArgs mouseEvent)
{
GuiHalWidget.OpenFileDialogParams openParams = new GuiHalWidget.OpenFileDialogParams("MatterScript Files,c-sharp code", "*.part,*.cs");
Stream streamToLoadFrom = GuiHalFactory.PrimaryHalWidget.OpenFileDialog(openParams);
if (streamToLoadFrom != null)
{
loadedFileName = openParams.FileName;
string extension = System.IO.Path.GetExtension(openParams.FileName).ToUpper(CultureInfo.InvariantCulture);
if (extension == ".CS")
{
loadedSourceFileType = SourceFileType.CSharp;
}
else if (extension == ".VB")
{
loadedSourceFileType = SourceFileType.VisualBasic;
}
//string text = System.IO.File.ReadAllText(loadedFileName);
StreamReader streamReader = new StreamReader(streamToLoadFrom);
matterScriptEditor.Text = streamReader.ReadToEnd();
streamToLoadFrom.Close();
verticleSpliter.SplitterDistance = verticleSpliter.SplitterDistance - 1;
verticleSpliter.SplitterDistance = verticleSpliter.SplitterDistance + 1;
}
}
public bool CompileExecutable(String fileContents, String fileName, SourceFileType fileType, out Assembly compiledAssemply)
{
compiledAssemply = null;
// TODO: look into Managed Extensibility Framework
CodeDomProvider provider = null;
bool compileOk = false;
// Select the code provider based on the input file extension.
if (fileType == SourceFileType.CSharp)
{
provider = CodeDomProvider.CreateProvider("CSharp");
}
else if (fileType == SourceFileType.VisualBasic)
{
provider = CodeDomProvider.CreateProvider("VisualBasic");
}
else
{
Debug.WriteLine("Source file must have a .cs or .vb extension");
}
if (provider != null)
{
// Format the executable file name.
// Build the output assembly path using the current directory
// and <source>_cs.exe or <source>_vb.exe.
CompilerParameters cp = new CompilerParameters();
cp.ReferencedAssemblies.Add("MatterHackers.Csg.dll");
cp.ReferencedAssemblies.Add("MatterHackers.VectorMath.dll");
// Generate an executable instead of
// a class library.
cp.GenerateExecutable = false;
// Save the assembly as a physical file.
cp.GenerateInMemory = true;
// Set whether to treat all warnings as errors.
cp.TreatWarningsAsErrors = false;
// Invoke compilation of the source file.
//CompilerResults cr = provider.CompileAssemblyFromFile(cp, fileName);
CompilerResults cr = provider.CompileAssemblyFromSource(cp, fileContents);
if (cr.Errors.Count > 0)
{
// Display compilation errors.
foreach (CompilerError ce in cr.Errors)
{
Debug.WriteLine(" {0}", ce.ToString());
Debug.WriteLine("");
}
}
else
{
// Display a successful compilation message.
Debug.WriteLine("Source built successfully.");
}
// Return the results of the compilation.
if (cr.Errors.Count > 0)
{
compileOk = false;
}
else
{
compileOk = true;
}
compiledAssemply = cr.CompiledAssembly;
}
return compileOk;
}
public void Generate(ComponentDescription description, ComponentConfiguration configuration, IResourceProvider resourceProvider, PreviewGenerationOptions options, Stream input, Stream output, SourceFileType sourceType)
{
ComponentCompileResult result = compiler.Compile(input, output, resourceProvider, new CompileOptions()
{
WriteExtendedMetadata = true
});
if (!result.Success)
{
throw new Exception();
}
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
Dictionary <Enum, object> providerParameters = new Dictionary <Enum, object>();
string secondaryRegion = "";
if (RestoreToSecondaryRegion.IsPresent)
{
ARSVault vault = ServiceClientAdapter.GetVault(resourceGroupName, vaultName);
secondaryRegion = BackupUtils.regionMap[vault.Location];
providerParameters.Add(CRRParams.SecondaryRegion, secondaryRegion);
}
providerParameters.Add(VaultParams.VaultName, vaultName);
providerParameters.Add(VaultParams.ResourceGroupName, resourceGroupName);
providerParameters.Add(VaultParams.VaultLocation, VaultLocation);
providerParameters.Add(RestoreBackupItemParams.RecoveryPoint, RecoveryPoint);
providerParameters.Add(RestoreVMBackupItemParams.OsaOption, UseOriginalStorageAccount.IsPresent);
providerParameters.Add(RestoreFSBackupItemParams.ResolveConflict, ResolveConflict.ToString());
providerParameters.Add(RestoreFSBackupItemParams.SourceFilePath, SourceFilePath);
providerParameters.Add(RestoreFSBackupItemParams.TargetStorageAccountName, TargetStorageAccountName);
providerParameters.Add(RestoreFSBackupItemParams.TargetFileShareName, TargetFileShareName);
providerParameters.Add(RestoreFSBackupItemParams.TargetFolder, TargetFolder);
providerParameters.Add(RestoreWLBackupItemParams.WLRecoveryConfig, WLRecoveryConfig);
providerParameters.Add(RestoreVMBackupItemParams.RestoreDiskList, RestoreDiskList);
providerParameters.Add(RestoreVMBackupItemParams.RestoreOnlyOSDisk, RestoreOnlyOSDisk);
providerParameters.Add(RestoreVMBackupItemParams.RestoreAsUnmanagedDisks, RestoreAsUnmanagedDisks);
providerParameters.Add(CRRParams.UseSecondaryRegion, RestoreToSecondaryRegion.IsPresent);
if (DiskEncryptionSetId != null)
{
AzureVmRecoveryPoint rp = (AzureVmRecoveryPoint)RecoveryPoint;
BackupResourceEncryptionConfigResource vaultEncryptionSettings = ServiceClientAdapter.GetVaultEncryptionConfig(resourceGroupName, vaultName);
if ((vaultEncryptionSettings.Properties.EncryptionAtRestType == "CustomerManaged") && rp.IsManagedVirtualMachine && !(rp.EncryptionEnabled) && !(RestoreToSecondaryRegion.IsPresent))
{
providerParameters.Add(RestoreVMBackupItemParams.DiskEncryptionSetId, DiskEncryptionSetId);
}
}
if (StorageAccountName != null)
{
providerParameters.Add(RestoreBackupItemParams.StorageAccountName, StorageAccountName);
}
if (StorageAccountResourceGroupName != null)
{
providerParameters.Add(RestoreBackupItemParams.StorageAccountResourceGroupName, StorageAccountResourceGroupName);
}
if (TargetResourceGroupName != null)
{
providerParameters.Add(RestoreVMBackupItemParams.TargetResourceGroupName, TargetResourceGroupName);
}
if (SourceFileType != null)
{
providerParameters.Add(RestoreFSBackupItemParams.SourceFileType, SourceFileType.ToString());
}
if (MultipleSourceFilePath != null)
{
providerParameters.Add(RestoreFSBackupItemParams.MultipleSourceFilePath, MultipleSourceFilePath);
}
PsBackupProviderManager providerManager =
new PsBackupProviderManager(providerParameters, ServiceClientAdapter);
IPsBackupProvider psBackupProvider = null;
if (string.Compare(ParameterSetName, AzureWorkloadParameterSet) != 0)
{
psBackupProvider = providerManager.GetProviderInstance(
RecoveryPoint.WorkloadType, RecoveryPoint.BackupManagementType);
}
else
{
psBackupProvider = providerManager.GetProviderInstance(
WorkloadType.MSSQL, BackupManagementType.AzureWorkload);
}
var jobResponse = psBackupProvider.TriggerRestore();
if (RestoreToSecondaryRegion.IsPresent)
{
var operationId = jobResponse.Request.RequestUri.Segments.Last();
var response = ServiceClientAdapter.GetCrrOperationStatus(secondaryRegion, operationId);
string jobIDJson = JsonConvert.SerializeObject(response.Body.Properties);
string[] jobSplits = jobIDJson.Split(new char[] { '\"' });
string jobID = jobSplits[jobSplits.Length - 2];
WriteObject(GetCrrJobObject(secondaryRegion, VaultId, jobID));
}
else
{
HandleCreatedJob(
jobResponse,
Resources.RestoreOperation,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
}
}, ShouldProcess(RecoveryPoint != null ? RecoveryPoint.ItemName : WLRecoveryConfig.ToString(), VerbsData.Restore));
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
Dictionary <Enum, object> providerParameters = new Dictionary <Enum, object>();
providerParameters.Add(VaultParams.VaultName, vaultName);
providerParameters.Add(VaultParams.ResourceGroupName, resourceGroupName);
providerParameters.Add(VaultParams.VaultLocation, VaultLocation);
providerParameters.Add(RestoreBackupItemParams.RecoveryPoint, RecoveryPoint);
providerParameters.Add(RestoreVMBackupItemParams.OsaOption, UseOriginalStorageAccount.IsPresent);
providerParameters.Add(RestoreFSBackupItemParams.ResolveConflict, ResolveConflict.ToString());
providerParameters.Add(RestoreFSBackupItemParams.SourceFilePath, SourceFilePath);
providerParameters.Add(RestoreFSBackupItemParams.TargetStorageAccountName, TargetStorageAccountName);
providerParameters.Add(RestoreFSBackupItemParams.TargetFileShareName, TargetFileShareName);
providerParameters.Add(RestoreFSBackupItemParams.TargetFolder, TargetFolder);
providerParameters.Add(RestoreWLBackupItemParams.WLRecoveryConfig, WLRecoveryConfig);
providerParameters.Add(RestoreVMBackupItemParams.RestoreDiskList, RestoreDiskList);
providerParameters.Add(RestoreVMBackupItemParams.RestoreOnlyOSDisk, RestoreOnlyOSDisk);
providerParameters.Add(RestoreVMBackupItemParams.RestoreAsUnmanagedDisks, RestoreAsUnmanagedDisks);
if (DiskEncryptionSetId != null)
{
AzureVmRecoveryPoint rp = (AzureVmRecoveryPoint)RecoveryPoint;
BackupResourceEncryptionConfigResource vaultEncryptionSettings = ServiceClientAdapter.GetVaultEncryptionConfig(resourceGroupName, vaultName);
// do not allow for CRR - to be added
if ((vaultEncryptionSettings.Properties.EncryptionAtRestType == "CustomerManaged") && rp.IsManagedVirtualMachine && !(rp.EncryptionEnabled))
{
providerParameters.Add(RestoreVMBackupItemParams.DiskEncryptionSetId, DiskEncryptionSetId);
}
}
if (StorageAccountName != null)
{
providerParameters.Add(RestoreBackupItemParams.StorageAccountName, StorageAccountName);
}
if (StorageAccountResourceGroupName != null)
{
providerParameters.Add(RestoreBackupItemParams.StorageAccountResourceGroupName, StorageAccountResourceGroupName);
}
if (TargetResourceGroupName != null)
{
providerParameters.Add(RestoreVMBackupItemParams.TargetResourceGroupName, TargetResourceGroupName);
}
if (SourceFileType != null)
{
providerParameters.Add(RestoreFSBackupItemParams.SourceFileType, SourceFileType.ToString());
}
if (MultipleSourceFilePath != null)
{
providerParameters.Add(RestoreFSBackupItemParams.MultipleSourceFilePath, MultipleSourceFilePath);
}
PsBackupProviderManager providerManager =
new PsBackupProviderManager(providerParameters, ServiceClientAdapter);
IPsBackupProvider psBackupProvider = null;
if (string.Compare(ParameterSetName, AzureWorkloadParameterSet) != 0)
{
psBackupProvider = providerManager.GetProviderInstance(
RecoveryPoint.WorkloadType, RecoveryPoint.BackupManagementType);
}
else
{
psBackupProvider = providerManager.GetProviderInstance(
WorkloadType.MSSQL, BackupManagementType.AzureWorkload);
}
var jobResponse = psBackupProvider.TriggerRestore();
WriteDebug(string.Format("Restore submitted"));
HandleCreatedJob(
jobResponse,
Resources.RestoreOperation,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
}, ShouldProcess(RecoveryPoint != null ? RecoveryPoint.ItemName : WLRecoveryConfig.ToString(), VerbsData.Restore));
}
public void Generate(ComponentDescription description, ComponentConfiguration configuration, IResourceProvider resourceProvider, PreviewGenerationOptions options, Stream input, Stream output, SourceFileType sourceType)
{
var drawingContext = PreviewRenderer.RenderPreview(size => new SkiaDrawingContext((int)Math.Ceiling(size.Width), (int)Math.Ceiling(size.Height), SKColors.White),
description,
options);
drawingContext.WriteAsPng(output);
}
public void Generate(ComponentDescription description, ComponentConfiguration configuration, IResourceProvider resourceProvider, PreviewGenerationOptions options, Stream input, Stream output, SourceFileType sourceType)
{
switch (Renderer)
{
case PngRenderer.Skia:
{
var drawingContext = PreviewRenderer.RenderPreview(size => new SkiaDrawingContext((int)Math.Ceiling(size.Width), (int)Math.Ceiling(size.Height), SKColors.White, (float)options.Scale),
description,
options);
drawingContext.WriteAsPng(output);
break;
}
case PngRenderer.ImageSharp:
{
var drawingContext = PreviewRenderer.RenderPreview(size => new ImageSharpDrawingContext((int)Math.Ceiling(size.Width), (int)Math.Ceiling(size.Height), SixLabors.ImageSharp.Color.White),
description,
options);
drawingContext.WriteAsPng(output);
break;
}
default:
throw new InvalidOperationException($"Unknown renderer: {Renderer}");
}
}
public ResolveContext (IMemberContext mc)
{
if (mc == null)
throw new ArgumentNullException ();
MemberContext = mc;
//
// The default setting comes from the command line option
//
if (mc.Module.Compiler.Settings.Checked)
flags |= Options.CheckedScope;
//
// The constant check state is always set to true
//
flags |= Options.ConstantCheckState;
//
// File type set from member context module sourcefile.
//
var memberCore = mc as MemberCore;
if (memberCore != null && memberCore.Location.SourceFile != null) {
fileType = memberCore.Location.SourceFile.FileType;
} else if (mc.Module != null && mc.Module.Location.SourceFile != null) {
fileType = mc.Module.Location.SourceFile.FileType;
if (mc.Module.Location.SourceFile.PsExtended)
flags |= Options.PsExtended;
} else {
fileType = SourceFileType.CSharp;
}
//
// Set dynamic enabled state
//
if (memberCore is MethodCore) {
if (!(((MethodCore)mc).AllowDynamic ?? true))
flags |= Options.PsDynamicDisabled;
} else if (memberCore is TypeDefinition) {
if (!(((TypeDefinition)mc).AllowDynamic ?? true))
flags |= Options.PsDynamicDisabled;
} else if (memberCore != null && memberCore.Parent != null) {
if (!(memberCore.Parent.AllowDynamic ?? true))
flags |= Options.PsDynamicDisabled;
} else {
if (!Module.Compiler.Settings.AllowDynamic)
flags |= Options.PsDynamicDisabled;
}
}
public bool CompileExecutable(String fileContents, String fileName, SourceFileType fileType, out Assembly compiledAssemply)
{
compiledAssemply = null;
// TODO: look into Managed Extensibility Framework
CodeDomProvider provider = null;
bool compileOk = false;
// Select the code provider based on the input file extension.
if (fileType == SourceFileType.CSharp)
{
provider = CodeDomProvider.CreateProvider("CSharp");
}
else if (fileType == SourceFileType.VisualBasic)
{
provider = CodeDomProvider.CreateProvider("VisualBasic");
}
else
{
Debug.WriteLine("Source file must have a .cs or .vb extension");
}
if (provider != null)
{
// Format the executable file name.
// Build the output assembly path using the current directory
// and <source>_cs.exe or <source>_vb.exe.
CompilerParameters cp = new CompilerParameters();
cp.ReferencedAssemblies.Add("MatterHackers.Csg.dll");
cp.ReferencedAssemblies.Add("MatterHackers.VectorMath.dll");
// Generate an executable instead of
// a class library.
cp.GenerateExecutable = false;
// Save the assembly as a physical file.
cp.GenerateInMemory = true;
// Set whether to treat all warnings as errors.
cp.TreatWarningsAsErrors = false;
// Invoke compilation of the source file.
//CompilerResults cr = provider.CompileAssemblyFromFile(cp, fileName);
CompilerResults cr = provider.CompileAssemblyFromSource(cp, fileContents);
if (cr.Errors.Count > 0)
{
// Display compilation errors.
foreach (CompilerError ce in cr.Errors)
{
Debug.WriteLine(" {0}", ce.ToString());
Debug.WriteLine("");
}
}
else
{
// Display a successful compilation message.
Debug.WriteLine("Source built successfully.");
}
// Return the results of the compilation.
if (cr.Errors.Count > 0)
{
compileOk = false;
}
else
{
compileOk = true;
}
compiledAssemply = cr.CompiledAssembly;
}
return(compileOk);
}
public override void ExecuteCmdlet()
{
ExecutionBlock(() =>
{
base.ExecuteCmdlet();
ResourceIdentifier resourceIdentifier = new ResourceIdentifier(VaultId);
string vaultName = resourceIdentifier.ResourceName;
string resourceGroupName = resourceIdentifier.ResourceGroupName;
Dictionary <Enum, object> providerParameters = new Dictionary <Enum, object>();
string secondaryRegion = "";
if (RestoreToSecondaryRegion.IsPresent)
{
ARSVault vault = ServiceClientAdapter.GetVault(resourceGroupName, vaultName);
secondaryRegion = BackupUtils.regionMap[vault.Location];
providerParameters.Add(CRRParams.SecondaryRegion, secondaryRegion);
}
if (RehydratePriority != null)
{
Logger.Instance.WriteDebug("Rehydrate priority is " + RehydratePriority);
int rehydrateExpiryInDays = Int32.Parse(RehydrateDuration); // Rehydrate duration is taken as days
if (rehydrateExpiryInDays < 10 || rehydrateExpiryInDays > 30)
{
throw new ArgumentException(Resources.InvalidRehydrateDuration);
}
providerParameters.Add(RecoveryPointParams.RehydrateDuration, RehydrateDuration);
providerParameters.Add(RecoveryPointParams.RehydratePriority, RehydratePriority);
}
if (UseSystemAssignedIdentity.IsPresent || UserAssignedIdentityId != null)
{
if (UseSystemAssignedIdentity.IsPresent && UserAssignedIdentityId != null)
{
throw new ArgumentException(Resources.MultipleMSIProvidedForRestore);
}
/*if (UseSystemAssignedIdentity.IsPresent)
* {
* // check to be added on vault.Identity
* }
* else
* {
* // check whether given User MSI is present on vault
* }*/
}
string RestoreType = null;
if (string.Compare(ParameterSetName, AzureManagedVMReplaceExistingParameterSet) == 0)
{
RestoreType = "OriginalLocation";
}
providerParameters.Add(VaultParams.VaultName, vaultName);
providerParameters.Add(VaultParams.ResourceGroupName, resourceGroupName);
providerParameters.Add(VaultParams.VaultLocation, VaultLocation);
providerParameters.Add(RestoreBackupItemParams.RecoveryPoint, RecoveryPoint);
providerParameters.Add(RestoreVMBackupItemParams.OsaOption, UseOriginalStorageAccount.IsPresent);
providerParameters.Add(RestoreFSBackupItemParams.ResolveConflict, ResolveConflict.ToString());
providerParameters.Add(RestoreFSBackupItemParams.SourceFilePath, SourceFilePath);
providerParameters.Add(RestoreFSBackupItemParams.TargetStorageAccountName, TargetStorageAccountName);
providerParameters.Add(RestoreFSBackupItemParams.TargetFileShareName, TargetFileShareName);
providerParameters.Add(RestoreFSBackupItemParams.TargetFolder, TargetFolder);
providerParameters.Add(RestoreWLBackupItemParams.WLRecoveryConfig, WLRecoveryConfig);
providerParameters.Add(RestoreVMBackupItemParams.RestoreDiskList, RestoreDiskList);
providerParameters.Add(RestoreVMBackupItemParams.RestoreOnlyOSDisk, RestoreOnlyOSDisk);
providerParameters.Add(RestoreVMBackupItemParams.RestoreAsUnmanagedDisks, RestoreAsUnmanagedDisks);
providerParameters.Add(CRRParams.UseSecondaryRegion, RestoreToSecondaryRegion.IsPresent);
providerParameters.Add(RestoreVMBackupItemParams.RestoreAsManagedDisk, RestoreAsManagedDisk.IsPresent);
providerParameters.Add(RestoreVMBackupItemParams.UseSystemAssignedIdentity, UseSystemAssignedIdentity.IsPresent);
providerParameters.Add(RestoreVMBackupItemParams.UserAssignedIdentityId, UserAssignedIdentityId);
providerParameters.Add(RestoreVMBackupItemParams.RestoreType, RestoreType);
providerParameters.Add(RestoreVMBackupItemParams.TargetVMName, TargetVMName);
providerParameters.Add(RestoreVMBackupItemParams.TargetVNetName, TargetVNetName);
providerParameters.Add(RestoreVMBackupItemParams.TargetVNetResourceGroup, TargetVNetResourceGroup);
providerParameters.Add(RestoreVMBackupItemParams.TargetSubnetName, TargetSubnetName);
if (DiskEncryptionSetId != null)
{
AzureVmRecoveryPoint rp = (AzureVmRecoveryPoint)RecoveryPoint;
ServiceClientModel.BackupResourceEncryptionConfigExtendedResource vaultEncryptionSettings = ServiceClientAdapter.GetVaultEncryptionConfig(resourceGroupName, vaultName);
if ((vaultEncryptionSettings.Properties.EncryptionAtRestType == "CustomerManaged") && rp.IsManagedVirtualMachine && !(rp.EncryptionEnabled) && !(RestoreToSecondaryRegion.IsPresent))
{
providerParameters.Add(RestoreVMBackupItemParams.DiskEncryptionSetId, DiskEncryptionSetId);
}
}
if (TargetZoneNumber != null)
{
// get storage type
ServiceClientModel.BackupResourceConfigResource getStorageResponse = ServiceClientAdapter.GetVaultStorageType(resourceGroupName, vaultName);
string storageType = getStorageResponse.Properties.StorageType;
bool crrEnabled = (bool)getStorageResponse.Properties.CrossRegionRestoreFlag;
if (storageType == AzureRmRecoveryServicesBackupStorageRedundancyType.ZoneRedundant.ToString() ||
(storageType == AzureRmRecoveryServicesBackupStorageRedundancyType.GeoRedundant.ToString() && crrEnabled))
{
AzureVmRecoveryPoint rp = (AzureVmRecoveryPoint)RecoveryPoint;
if (rp.RecoveryPointTier == RecoveryPointTier.VaultStandard) // RP recovery type should be vault only
{
if (rp.Zones != null)
{
//target region should support Zones
/*if (RestoreToSecondaryRegion.IsPresent)
* {
* FeatureSupportRequest iaasvmFeatureRequest = new FeatureSupportRequest();
* ServiceClientAdapter.BmsAdapter.Client.FeatureSupport.ValidateWithHttpMessagesAsync(secondaryRegion, iaasvmFeatureRequest);
* }*/
providerParameters.Add(RecoveryPointParams.TargetZone, TargetZoneNumber);
}
else
{
throw new ArgumentException(string.Format(Resources.RecoveryPointZonePinnedException));
}
}
else
{
throw new ArgumentException(string.Format(Resources.RecoveryPointVaultRecoveryTypeException));
}
}
else
{
throw new ArgumentException(string.Format(Resources.ZonalRestoreVaultStorageRedundancyException));
}
}
if (StorageAccountName != null)
{
providerParameters.Add(RestoreBackupItemParams.StorageAccountName, StorageAccountName);
}
if (StorageAccountResourceGroupName != null)
{
providerParameters.Add(RestoreBackupItemParams.StorageAccountResourceGroupName, StorageAccountResourceGroupName);
}
if (TargetResourceGroupName != null)
{
providerParameters.Add(RestoreVMBackupItemParams.TargetResourceGroupName, TargetResourceGroupName);
}
if (SourceFileType != null)
{
providerParameters.Add(RestoreFSBackupItemParams.SourceFileType, SourceFileType.ToString());
}
if (MultipleSourceFilePath != null)
{
providerParameters.Add(RestoreFSBackupItemParams.MultipleSourceFilePath, MultipleSourceFilePath);
}
PsBackupProviderManager providerManager =
new PsBackupProviderManager(providerParameters, ServiceClientAdapter);
IPsBackupProvider psBackupProvider = null;
if (string.Compare(ParameterSetName, AzureWorkloadParameterSet) != 0)
{
psBackupProvider = providerManager.GetProviderInstance(
RecoveryPoint.WorkloadType, RecoveryPoint.BackupManagementType);
}
else
{
psBackupProvider = providerManager.GetProviderInstance(
WorkloadType.MSSQL, BackupManagementType.AzureWorkload);
}
var jobResponse = psBackupProvider.TriggerRestore();
if (RestoreToSecondaryRegion.IsPresent)
{
var operationId = jobResponse.Request.RequestUri.Segments.Last();
var response = ServiceClientAdapter.GetCrrOperationStatus(secondaryRegion, operationId);
string jobIdJson = JsonConvert.SerializeObject(response.Body.Properties);
string[] jobSplits = jobIdJson.Split(new char[] { '\"' });
string jobId = jobSplits[jobSplits.Length - 2];
WriteObject(GetCrrJobObject(secondaryRegion, VaultId, jobId));
}
else
{
HandleCreatedJob(
jobResponse,
Resources.RestoreOperation,
vaultName: vaultName,
resourceGroupName: resourceGroupName);
}
}, ShouldProcess(RecoveryPoint != null ? RecoveryPoint.ItemName : WLRecoveryConfig.ToString(), VerbsData.Restore));
}
public ResolveContext(IMemberContext mc)
{
if (mc == null)
{
throw new ArgumentNullException();
}
MemberContext = mc;
//
// The default setting comes from the command line option
//
if (mc.Module.Compiler.Settings.Checked)
{
flags |= Options.CheckedScope;
}
//
// The constant check state is always set to true
//
flags |= Options.ConstantCheckState;
//
// File type set from member context module sourcefile.
//
var memberCore = mc as MemberCore;
if (memberCore != null && memberCore.Location.SourceFile != null)
{
fileType = memberCore.Location.SourceFile.FileType;
}
else if (mc.Module != null && mc.Module.Location.SourceFile != null)
{
fileType = mc.Module.Location.SourceFile.FileType;
if (mc.Module.Location.SourceFile.PsExtended)
{
flags |= Options.PsExtended;
}
}
else
{
fileType = SourceFileType.CSharp;
}
//
// Set dynamic enabled state
//
if (memberCore is MethodCore)
{
if (!(((MethodCore)mc).AllowDynamic ?? true))
{
flags |= Options.PsDynamicDisabled;
}
}
else if (memberCore is TypeDefinition)
{
if (!(((TypeDefinition)mc).AllowDynamic ?? true))
{
flags |= Options.PsDynamicDisabled;
}
}
else if (memberCore != null && memberCore.Parent != null)
{
if (!(memberCore.Parent.AllowDynamic ?? true))
{
flags |= Options.PsDynamicDisabled;
}
}
else
{
if (!Module.Compiler.Settings.AllowDynamic)
{
flags |= Options.PsDynamicDisabled;
}
}
//
// Handle missing return type
//
if (memberCore is Method)
{
if (((Method)memberCore).HasNoReturnType)
{
flags |= Options.HasNoReturnType;
}
}
}
public bool AcceptsSourceFileType(SourceFileType sourceType) => sourceType == SourceFileType.ComponentDescription;
public SourceFile(SourceFileType FileType, string AbsoluteFilePath, string RelativeFilePath)
{
this.FileType = FileType;
this.AbsoluteFilePath = AbsoluteFilePath;
this.RelativeFileFolder = RelativeFilePath;
}
