private bool AddPackageProvider(string name, IPackageProvider provider, ulong version, IRequest request) { // wrap this in a caller-friendly wrapper lock (_packageProviders) { if (_packageProviders.ContainsKey(name)) { if (version > _packageProviders[name].Version) { // remove the old provider first. // todo: this won't remove the plugin domain and unload the code yet // we'll have to do that later. _packageProviders.Remove(name); } else { return(false); } } request.Debug("Loading provider {0}".format(name, provider.GetPackageProviderName())); provider.InitializeProvider(request); _packageProviders.AddOrSet(name, new PackageProvider(provider) { Version = version }).Initialize(request); } return(true); }
private static ClassifyPackages Default( IPackageProvider packageProvider = null) { packageProvider = packageProvider ?? Substitute.For<IPackageProvider>(); return new ClassifyPackages(packageProvider); }
/// <summary> /// Create a new instance of the handler. /// </summary> /// <param name="packageProvider">The package provider instance.</param> public PackageGroupIdHandler(IPackageProvider packageProvider) { if (packageProvider == null) { throw new ArgumentNullException(nameof(IPackageProvider)); } _packageProvider = packageProvider; }
public ReportEngineProvider() { _clientTypeManager = GetContainer().Resolve <ICustomerTypeProvider>(); _smsProvider = GetContainer().Resolve <ISmsProvider>(); _callProvider = GetContainer().Resolve <ICallProvider>(); _customerProvider = GetContainer().Resolve <ICustomerProvider>(); _packageProvider = GetContainer().Resolve <IPackageProvider>(); _lineProvider = GetContainer().Resolve <ILineProvider>(); }
private void TypeChanged(object sender, SelectionChangedEventArgs e) { ComboBox box = (ComboBox)sender; IPackageProvider provider = (IPackageProvider)box.SelectedItem; Title = $"Install {provider.Name} package"; GetPackages(); }
private static void ProcessPackageProvider(IPackageProvider provider, YieldPackageProvider yieldPackageProvider, FourPartVersion asmVersion, IRequest request) { try { provider.InitializeProvider(DynamicInterface.Instance, request); FourPartVersion ver = provider.GetProviderVersion(); yieldPackageProvider(provider.GetPackageProviderName(), provider, ver == 0 ? asmVersion : ver, request); } catch (Exception e) { e.Dump(); } }
public CRMProvider() { _obj = new Object(); _customerProvider = ModulesRegistrations.RegisterCRMModule().Resolve <ICustomerProvider>(); _packageProvider = ModulesRegistrations.RegisterCRMModule().Resolve <IPackageProvider>(); _customerTypeProvider = ModulesRegistrations.RegisterCRMModule().Resolve <ICustomerTypeProvider>(); _lineProvider = ModulesRegistrations.RegisterCRMModule().Resolve <ILineProvider>(); _packageIncludeProvider = ModulesRegistrations.RegisterCRMModule().Resolve <IPackageIncludeProvider>(); _selectedNumberProvider = ModulesRegistrations.RegisterCRMModule().Resolve <ISelectedNumberProvider>(); _smsProvider = ModulesRegistrations.RegisterCRMModule().Resolve <ISmsProvider>(); _callProvider = ModulesRegistrations.RegisterCRMModule().Resolve <ICallProvider>(); }
private PackageProvider RegisterPackageProvider(IPackageProvider provider, FourPartVersion asmVersion, IHostApi request) { string name = null; try { FourPartVersion ver = provider.GetProviderVersion(); var version = ver == 0 ? asmVersion : ver; name = provider.GetPackageProviderName(); if (string.IsNullOrWhiteSpace(name)) { return(null); } // Initialize the provider before locking the collection // that way we're not blocking others on non-deterministic actions. request.Debug("Initializing provider '{0}'".format(name)); provider.InitializeProvider(request.As <IRequest>()); request.Debug("Provider '{0}' Initialized".format(name)); lock (_packageProviders) { if (_packageProviders.ContainsKey(name)) { if (version > _packageProviders[name].Version) { // remove the old provider first. // todo: this won't remove the plugin domain and unload the code yet // we'll have to do that later. _packageProviders.Remove(name); } else { return(null); } } request.Debug("Using Package Provider {0}".format(name)); var packageProvider = new PackageProvider(provider) { Version = version }; _packageProviders.AddOrSet(name, packageProvider); packageProvider.Initialize(request); return(packageProvider); } } catch (Exception e) { request.Debug("Provider '{0}' Failed".format(name)); e.Dump(); } return(null); }
private void TypeChanged(object sender, SelectionChangedEventArgs e) { ComboBox box = (ComboBox)sender; IPackageProvider provider = (IPackageProvider)box.SelectedItem; cbName.ItemsSource = null; txtArguments.Text = NO_ARGS; SetRandomTip(); GetPackages(); txtArguments.Text = string.IsNullOrWhiteSpace(Provider?.DefaultArguments) ? NO_ARGS : Provider.DefaultArguments; SetInstallArguments(); }
private static bool ProcessPackageProvider(IPackageProvider provider, YieldPackageProvider yieldPackageProvider, FourPartVersion asmVersion, IRequest request) { try { // provider.InitializeProvider(DynamicInterface.Instance, request); FourPartVersion ver = provider.GetProviderVersion(); if (yieldPackageProvider(provider.GetPackageProviderName(), provider, ver == 0 ? asmVersion : ver, request)) { // provider.InitializeProvider(request); return(true); } } catch (Exception e) { e.Dump(); } return(false); }
private static IEnumerable <string> LoadModuleNames(IPackageProvider s) { IList <string> namespaces = new List <string>(); XPathDocument doc = new XPathDocument(s.Reader); XmlNamespaceManager nsmgr = new XmlNamespaceManager(s.Reader.NameTable); nsmgr.AddNamespace("ZetboxBase", "Zetbox.App.Base"); XPathNavigator nav = doc.CreateNavigator(); XPathNodeIterator it = nav.Select("//ZetboxBase:Module/ZetboxBase:Name", nsmgr); while (it.MoveNext()) { namespaces.Add(it.Current.Value); } return(namespaces); }
private static void ExportObject(IPackageProvider s, IPersistenceObject obj, string[] propNamespaces) { XmlWriter writer = s.Writer; Type t = obj.ReadOnlyContext.GetInterfaceType(obj).Type; writer.WriteStartElement(t.Name, t.Namespace); if (((IExportable)obj).ExportGuid == Guid.Empty) { throw new InvalidOperationException(string.Format("At least one object of type {0} has an empty ExportGuid (ID={1})", t.FullName, obj.ID)); } ((IExportableInternal)obj).Export(writer, propNamespaces); if (obj is Blob && s.SupportsBlobs) { var blob = (Blob)obj; s.PutBlob(blob.ExportGuid, blob.OriginalName, blob.GetStream()); } writer.WriteEndElement(); }
public static void PublishFromContext(IZetboxContext ctx, IPackageProvider s, string[] ownerModules) { using (Log.DebugTraceMethodCall("PublishFromContext")) { Log.InfoFormat("Starting Publish for Modules {0}", string.Join(", ", ownerModules)); Log.Debug("Loading modulelist"); var moduleList = GetModules(ctx, ownerModules); WriteStartDocument(s, ctx, new Zetbox.App.Base.Module[] { ctx.GetQuery <Zetbox.App.Base.Module>().First(m => m.Name == "ZetboxBase"), ctx.GetQuery <Zetbox.App.Base.Module>().First(m => m.Name == "GUI"), }); var propNamespaces = new string[] { "Zetbox.App.Base", "Zetbox.App.GUI" }; foreach (var module in moduleList) { Log.DebugFormat("Publishing objects for module {0}", module.Name); var objects = PackagingHelper.GetMetaObjects(ctx, module); Stopwatch watch = new Stopwatch(); watch.Start(); int counter = 0; foreach (var obj in objects) { ExportObject(s, obj, propNamespaces); counter++; if (watch.ElapsedMilliseconds > 1000) { watch.Reset(); watch.Start(); Log.DebugFormat("{0:n0}% finished", (double)counter / (double)objects.Count * 100.0); } } Log.Debug("100% finished"); } Log.Info("Export finished"); } }
private static void WriteStartDocument(IPackageProvider s, IReadOnlyZetboxContext ctx, IEnumerable <Zetbox.App.Base.Module> moduleList) { XmlWriter writer = s.Writer; writer.WriteStartDocument(); if (moduleList.Count() == 1) { // use exported module as default namespace writer.WriteStartElement("ZetboxPackaging", "http://dasz.at/Zetbox"); foreach (var module in moduleList) { writer.WriteAttributeString("xmlns", module.Name, null, module.Namespace); } } else { writer.WriteStartElement("ZetboxPackaging", "http://dasz.at/Zetbox"); foreach (var module in moduleList) { writer.WriteAttributeString("xmlns", module.Name, null, module.Namespace); } } DateTime?lastChanged = new DateTime?[] { ctx.GetQuery <Zetbox.App.Base.Assembly>().Max(d => d.ChangedOn), ctx.GetQuery <Zetbox.App.Base.BaseParameter>().Max(d => d.ChangedOn), ctx.GetQuery <Zetbox.App.Base.Constraint>().Max(d => d.ChangedOn), ctx.GetQuery <Zetbox.App.Base.DataType>().Max(d => d.ChangedOn), ctx.GetQuery <Zetbox.App.Base.DefaultPropertyValue>().Max(d => d.ChangedOn), ctx.GetQuery <Zetbox.App.Base.EnumerationEntry>().Max(d => d.ChangedOn), ctx.GetQuery <Zetbox.App.Base.Method>().Max(d => d.ChangedOn), ctx.GetQuery <Zetbox.App.Base.Module>().Max(d => d.ChangedOn), ctx.GetQuery <Zetbox.App.Base.Property>().Max(d => d.ChangedOn), ctx.GetQuery <Zetbox.App.Base.Relation>().Max(d => d.ChangedOn), ctx.GetQuery <Zetbox.App.Base.RelationEnd>().Max(d => d.ChangedOn), ctx.GetQuery <Zetbox.App.Base.TypeRef>().Max(d => d.ChangedOn) }.Max(); writer.WriteAttributeString("date", XmlConvert.ToString(lastChanged ?? DateTime.Now, XmlDateTimeSerializationMode.Utc)); }
private bool RegisterPackageProvider(IPackageProvider provider, FourPartVersion asmVersion, IHostApi request) { try { FourPartVersion ver = provider.GetProviderVersion(); var version = ver == 0 ? asmVersion : ver; var name = provider.GetPackageProviderName(); lock (_packageProviders) { if (_packageProviders.ContainsKey(name)) { if (version > _packageProviders[name].Version) { // remove the old provider first. // todo: this won't remove the plugin domain and unload the code yet // we'll have to do that later. _packageProviders.Remove(name); } else { return(false); } } request.Debug("Loading provider {0}".format(name, provider.GetPackageProviderName())); provider.InitializeProvider(request.As <IRequest>()); _packageProviders.AddOrSet(name, new PackageProvider(provider) { Version = version }).Initialize(request); } return(true); } catch (Exception e) { e.Dump(); } return(false); }
public ReleaseService(IMilestoneProvider milestoneProvider, IIssueProvider issueProvider, IPackageProvider packageProvider) { _milestoneProvider = milestoneProvider; _issueProvider = issueProvider; _packageProvider = packageProvider; }
private static Dictionary<Type, List<Guid>> LoadGuids(IZetboxContext ctx, IPackageProvider[] providers) { Log.Info("Loading Export Guids"); Dictionary<Type, List<Guid>> guids = new Dictionary<Type, List<Guid>>(); foreach (var reader in providers.Select(p => p.Reader)) { XPathDocument doc = new XPathDocument(reader); XPathNavigator nav = doc.CreateNavigator(); XPathNodeIterator it = nav.Select("//*[@ExportGuid]"); while (it.MoveNext()) { string ns = it.Current.NamespaceURI; string tn = it.Current.LocalName; if (it.Current.MoveToAttribute("ExportGuid", String.Empty)) { Guid exportGuid = it.Current.Value.TryParseGuidValue(); if (exportGuid != Guid.Empty) { string ifTypeName = string.Format("{0}.{1}", ns, tn); ifTypeName = MigrateTypeNameMapping(ifTypeName); Type t = ctx.GetInterfaceType(ifTypeName).Type; if (t != null) { if (!guids.ContainsKey(t)) guids[t] = new List<Guid>(); guids[t].Add(exportGuid); } else { Log.WarnOnce(string.Format("Type {0} not found", ifTypeName)); } } } } } return guids; }
/// <summary> /// Exports data from the specified context into the specified package provider. Data is selected by defining /// schema and owning module. /// </summary> /// <remarks> /// <para>For example, exporting {"ZetboxBase", "GUI"}/{"*"} will export all schema information to recreate the /// current database. Exporting {"Calendar"}/{"MyApplication"} will export all calendar data specific to the /// "MyApplication" module. /// </para> /// </remarks> /// <param name="ctx">The data source</param> /// <param name="s">The export target</param> /// <param name="schemaModules">A list of strings naming the schema-defining modules. This selects which data /// (-classes) should be exported. Specify a single asterisk (<code>"*"</code>) to select all available /// modules.</param> /// <param name="ownerModules">A list of strings naming the data-owning modules. This selects whose data should /// be exported. Specify a single asterisk (<code>"*"</code>) to select all available data, independent of /// module-membership. This also includes data that is not member of any module.</param> public static void ExportFromContext(IReadOnlyZetboxContext ctx, IPackageProvider s, string[] schemaModules, string[] ownerModules) { using (Log.DebugTraceMethodCall("ExportFromContext")) { Log.InfoFormat("Starting Export for Modules [{0}], data owned by [{1}]", string.Join(", ", schemaModules), string.Join(", ", ownerModules)); var allData = ownerModules.Contains("*"); var schemaList = GetModules(ctx, schemaModules); var schemaNamespaces = schemaList.Select(m => m.Namespace).ToArray(); WriteStartDocument(s, ctx, schemaList); var iexpIf = ctx.GetIExportableInterface(); foreach (var module in schemaList) { Log.InfoFormat(" exporting module {0}", module.Name); foreach (var objClass in ctx.GetQuery<ObjectClass>().Where(o => o.Module == module).OrderBy(o => o.Name).ToList()) { if (objClass.SubClasses.Count > 0) { Log.DebugFormat(" skipping {0}: not a leaf class", objClass.Name); } else if (!objClass.AndParents(cls => new[] { cls }, cls => cls.BaseObjectClass).SelectMany(cls => cls.ImplementsInterfaces).Contains(iexpIf)) { Log.DebugFormat(" skipping {0}: not exportable", objClass.Name); } else if (allData) { Log.InfoFormat(" exporting class {0}", objClass.Name); foreach (var obj in ctx.Internals().GetAll(objClass.GetDescribedInterfaceType()).OrderBy(obj => ((IExportable)obj).ExportGuid)) { ExportObject(s, obj, schemaNamespaces); } } else if (objClass.ImplementsIModuleMember()) { Log.InfoFormat(" exporting parts of class {0}", objClass.Name); foreach (var obj in ctx.Internals().GetAll(objClass.GetDescribedInterfaceType()) .Cast<IModuleMember>() .Where(mm => mm.Module != null && ownerModules.Contains(mm.Module.Name)) .Cast<IExportable>() .OrderBy(obj => obj.ExportGuid) .Cast<IPersistenceObject>()) { ExportObject(s, obj, schemaNamespaces); } } else { Log.DebugFormat(" skipping {0}", objClass.Name); } } int moduleID = module.ID; // Dont ask foreach (var rel in ctx.GetQuery<Relation>().Where(r => r.Module.ID == moduleID) .OrderBy(r => r.A.Type.Name).ThenBy(r => r.A.RoleName).ThenBy(r => r.B.Type.Name).ThenBy(r => r.B.RoleName).ThenBy(r => r.ExportGuid)) { if (rel.GetRelationType() != RelationType.n_m) continue; if (!rel.A.Type.ImplementsIExportable()) continue; if (!rel.B.Type.ImplementsIExportable()) continue; try { var ifType = rel.GetEntryInterfaceType(); Log.InfoFormat(" {0} ", ifType.Type.Name); MethodInfo mi = ctx.GetType().FindGenericMethod("FetchRelation", new Type[] { ifType.Type }, new Type[] { typeof(Guid), typeof(RelationEndRole), typeof(IDataObject) }); var relations = MagicCollectionFactory.WrapAsCollection<IPersistenceObject>(mi.Invoke(ctx, new object[] { rel.ExportGuid, RelationEndRole.A, null })); foreach (var obj in relations.OrderBy(obj => ((IExportable)obj).ExportGuid)) { ExportObject(s, obj, schemaNamespaces); } } catch (TypeLoadException ex) { var message = String.Format("Failed to load InterfaceType for entries of {0}", rel); Log.Warn(message, ex); } } } s.Writer.WriteEndElement(); s.Writer.WriteEndDocument(); Log.Info("Export finished"); } }
/// <summary> /// Create package info /// </summary> /// <param name="packageProvider"></param> /// <param name="fileReference"></param> public PackageFileInfo(IPackageProvider packageProvider, PackageFileReference fileReference) { this.packageProvider = packageProvider ?? throw new ArgumentNullException(nameof(packageProvider)); this.fileReference = fileReference ?? throw new ArgumentNullException(nameof(fileReference)); }
private static void WriteStartDocument(IPackageProvider s, IReadOnlyZetboxContext ctx, IEnumerable<Zetbox.App.Base.Module> moduleList) { XmlWriter writer = s.Writer; writer.WriteStartDocument(); if (moduleList.Count() == 1) { // use exported module as default namespace writer.WriteStartElement("ZetboxPackaging", "http://dasz.at/Zetbox"); foreach (var module in moduleList) { writer.WriteAttributeString("xmlns", module.Name, null, module.Namespace); } } else { writer.WriteStartElement("ZetboxPackaging", "http://dasz.at/Zetbox"); foreach (var module in moduleList) { writer.WriteAttributeString("xmlns", module.Name, null, module.Namespace); } } DateTime? lastChanged = new DateTime?[] { ctx.GetQuery<Zetbox.App.Base.Assembly>().Max(d => d.ChangedOn), ctx.GetQuery<Zetbox.App.Base.BaseParameter>().Max(d => d.ChangedOn), ctx.GetQuery<Zetbox.App.Base.Constraint>().Max(d => d.ChangedOn), ctx.GetQuery<Zetbox.App.Base.DataType>().Max(d => d.ChangedOn), ctx.GetQuery<Zetbox.App.Base.DefaultPropertyValue>().Max(d => d.ChangedOn), ctx.GetQuery<Zetbox.App.Base.EnumerationEntry>().Max(d => d.ChangedOn), ctx.GetQuery<Zetbox.App.Base.Method>().Max(d => d.ChangedOn), ctx.GetQuery<Zetbox.App.Base.Module>().Max(d => d.ChangedOn), ctx.GetQuery<Zetbox.App.Base.Property>().Max(d => d.ChangedOn), ctx.GetQuery<Zetbox.App.Base.Relation>().Max(d => d.ChangedOn), ctx.GetQuery<Zetbox.App.Base.RelationEnd>().Max(d => d.ChangedOn), ctx.GetQuery<Zetbox.App.Base.TypeRef>().Max(d => d.ChangedOn) }.Max(); writer.WriteAttributeString("date", XmlConvert.ToString(lastChanged ?? DateTime.Now, XmlDateTimeSerializationMode.Utc)); }
public static void PublishFromContext(IZetboxContext ctx, IPackageProvider s, string[] ownerModules) { using (Log.DebugTraceMethodCall("PublishFromContext")) { Log.InfoFormat("Starting Publish for Modules {0}", string.Join(", ", ownerModules)); Log.Debug("Loading modulelist"); var moduleList = GetModules(ctx, ownerModules); WriteStartDocument(s, ctx, new Zetbox.App.Base.Module[] { ctx.GetQuery<Zetbox.App.Base.Module>().First(m => m.Name == "ZetboxBase"), ctx.GetQuery<Zetbox.App.Base.Module>().First(m => m.Name == "GUI"), }); var propNamespaces = new string[] { "Zetbox.App.Base", "Zetbox.App.GUI" }; foreach (var module in moduleList) { Log.DebugFormat("Publishing objects for module {0}", module.Name); var objects = PackagingHelper.GetMetaObjects(ctx, module); Stopwatch watch = new Stopwatch(); watch.Start(); int counter = 0; foreach (var obj in objects) { ExportObject(s, obj, propNamespaces); counter++; if (watch.ElapsedMilliseconds > 1000) { watch.Reset(); watch.Start(); Log.DebugFormat("{0:n0}% finished", (double)counter / (double)objects.Count * 100.0); } } Log.Debug("100% finished"); } Log.Info("Export finished"); } }
public static IComparer <ISearchItem> For(string searchTerm, IPackageProvider provider) { return(new PackageSorter(searchTerm)); }
public Manager(IPackageProvider provider) { Provider = provider; }
/// <summary> /// Exports data from the specified context into the specified package provider. Data is selected by defining /// schema and owning module. /// </summary> /// <remarks> /// <para>For example, exporting {"ZetboxBase", "GUI"}/{"*"} will export all schema information to recreate the /// current database. Exporting {"Calendar"}/{"MyApplication"} will export all calendar data specific to the /// "MyApplication" module. /// </para> /// </remarks> /// <param name="ctx">The data source</param> /// <param name="s">The export target</param> /// <param name="schemaModules">A list of strings naming the schema-defining modules. This selects which data /// (-classes) should be exported. Specify a single asterisk (<code>"*"</code>) to select all available /// modules.</param> /// <param name="ownerModules">A list of strings naming the data-owning modules. This selects whose data should /// be exported. Specify a single asterisk (<code>"*"</code>) to select all available data, independent of /// module-membership. This also includes data that is not member of any module.</param> public static void ExportFromContext(IReadOnlyZetboxContext ctx, IPackageProvider s, string[] schemaModules, string[] ownerModules) { using (Log.DebugTraceMethodCall("ExportFromContext")) { Log.InfoFormat("Starting Export for Modules [{0}], data owned by [{1}]", string.Join(", ", schemaModules), string.Join(", ", ownerModules)); var allData = ownerModules.Contains("*"); var schemaList = GetModules(ctx, schemaModules); var schemaNamespaces = schemaList.Select(m => m.Namespace).ToArray(); WriteStartDocument(s, ctx, schemaList); var iexpIf = ctx.GetIExportableInterface(); foreach (var module in schemaList) { Log.InfoFormat(" exporting module {0}", module.Name); foreach (var objClass in ctx.GetQuery <ObjectClass>().Where(o => o.Module == module).OrderBy(o => o.Name).ToList()) { if (objClass.SubClasses.Count > 0) { Log.DebugFormat(" skipping {0}: not a leaf class", objClass.Name); } else if (!objClass.AndParents(cls => new[] { cls }, cls => cls.BaseObjectClass).SelectMany(cls => cls.ImplementsInterfaces).Contains(iexpIf)) { Log.DebugFormat(" skipping {0}: not exportable", objClass.Name); } else if (allData) { Log.InfoFormat(" exporting class {0}", objClass.Name); foreach (var obj in ctx.Internals().GetAll(objClass.GetDescribedInterfaceType()).OrderBy(obj => ((IExportable)obj).ExportGuid)) { ExportObject(s, obj, schemaNamespaces); } } else if (objClass.ImplementsIModuleMember()) { Log.InfoFormat(" exporting parts of class {0}", objClass.Name); foreach (var obj in ctx.Internals().GetAll(objClass.GetDescribedInterfaceType()) .Cast <IModuleMember>() .Where(mm => mm.Module != null && ownerModules.Contains(mm.Module.Name)) .Cast <IExportable>() .OrderBy(obj => obj.ExportGuid) .Cast <IPersistenceObject>()) { ExportObject(s, obj, schemaNamespaces); } } else { Log.DebugFormat(" skipping {0}", objClass.Name); } } int moduleID = module.ID; // Dont ask foreach (var rel in ctx.GetQuery <Relation>().Where(r => r.Module.ID == moduleID) .OrderBy(r => r.A.Type.Name).ThenBy(r => r.A.RoleName).ThenBy(r => r.B.Type.Name).ThenBy(r => r.B.RoleName).ThenBy(r => r.ExportGuid)) { if (rel.GetRelationType() != RelationType.n_m) { continue; } if (!rel.A.Type.ImplementsIExportable()) { continue; } if (!rel.B.Type.ImplementsIExportable()) { continue; } try { var ifType = rel.GetEntryInterfaceType(); Log.InfoFormat(" {0} ", ifType.Type.Name); MethodInfo mi = ctx.GetType().FindGenericMethod("FetchRelation", new Type[] { ifType.Type }, new Type[] { typeof(Guid), typeof(RelationEndRole), typeof(IDataObject) }); var relations = MagicCollectionFactory.WrapAsCollection <IPersistenceObject>(mi.Invoke(ctx, new object[] { rel.ExportGuid, RelationEndRole.A, null })); foreach (var obj in relations.OrderBy(obj => ((IExportable)obj).ExportGuid)) { ExportObject(s, obj, schemaNamespaces); } } catch (TypeLoadException ex) { var message = String.Format("Failed to load InterfaceType for entries of {0}", rel); Log.Warn(message, ex); } } } s.Writer.WriteEndElement(); s.Writer.WriteEndDocument(); Log.Info("Export finished"); } }
public async Task Execute(RunningDeployment context) { var variables = context.Variables; var servicePrincipal = ServicePrincipalAccount.CreateFromKnownVariables(variables); string?webAppName = variables.Get(SpecialVariables.Action.Azure.WebAppName); if (webAppName == null) { throw new Exception("Web App Name must be specified"); } string?resourceGroupName = variables.Get(SpecialVariables.Action.Azure.ResourceGroupName); if (resourceGroupName == null) { throw new Exception("resource group name must be specified"); } string?slotName = variables.Get(SpecialVariables.Action.Azure.WebAppSlot); var packageFileInfo = new FileInfo(variables.Get(TentacleVariables.CurrentDeployment.PackageFilePath) !); switch (packageFileInfo.Extension) { case ".zip": Archive = new ZipPackageProvider(); break; case ".nupkg": Archive = new NugetPackageProvider(); break; case ".war": Archive = new WarPackageProvider(Log, variables, context); break; default: throw new Exception("Unsupported archive type"); } var azureClient = servicePrincipal.CreateAzureClient(); var webApp = await azureClient.WebApps.GetByResourceGroupAsync(resourceGroupName, webAppName); var targetSite = AzureWebAppHelper.GetAzureTargetSite(webAppName, slotName, resourceGroupName); // Lets process our archive while the slot is spun up. we will await it later before we try to upload to it. var slotCreateTask = new Task(() => { }); if (targetSite.HasSlot) { slotCreateTask = FindOrCreateSlot(webApp, targetSite); } string[]? substitutionFeatures = { KnownVariables.Features.ConfigurationTransforms, KnownVariables.Features.StructuredConfigurationVariables, KnownVariables.Features.SubstituteInFiles }; /* * Calamari default behaviors * https://github.com/OctopusDeploy/Calamari/tree/master/source/Calamari.Common/Features/Behaviours */ var uploadPath = string.Empty; if (substitutionFeatures.Any(featureName => context.Variables.IsFeatureEnabled(featureName))) { uploadPath = (await Archive.PackageArchive(context.StagingDirectory, context.CurrentDirectory)) .FullName; } else { uploadPath = (await Archive.ConvertToAzureSupportedFile(packageFileInfo)).FullName; } if (uploadPath == null) { throw new Exception("Package File Path must be specified"); } // need to ensure slot is created as slot creds may be used if (targetSite.HasSlot) { await slotCreateTask; } var publishingProfile = await PublishingProfile.GetPublishingProfile(targetSite, servicePrincipal); string?credential = await Auth.GetBasicAuthCreds(servicePrincipal, targetSite); string token = await Auth.GetAuthTokenAsync(servicePrincipal); var webAppClient = new WebSiteManagementClient(new Uri(servicePrincipal.ResourceManagementEndpointBaseUri), new TokenCredentials(token)) { SubscriptionId = servicePrincipal.SubscriptionNumber }; var httpClient = webAppClient.HttpClient; httpClient.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Basic", credential); Log.Info($"Uploading package to {targetSite.SiteAndSlot}"); await UploadZipAsync(publishingProfile, httpClient, uploadPath, targetSite.ScmSiteAndSlot); }
private PackageProvider RegisterPackageProvider(IPackageProvider provider, string name, FourPartVersion asmVersion, IHostApi request) { // string name = null; try { FourPartVersion ver = provider.GetProviderVersion(); var version = ver == 0 ? asmVersion : ver; //TODO: Need to write a blog file name is the provider name. Provider is no longer required to impl ProvierName property //name = provider.GetPackageProviderName(); //if (String.IsNullOrWhiteSpace(name)) { // return null; //} // Initialize the provider before locking the collection // that way we're not blocking others on non-deterministic actions. request.Debug("Initializing provider '{0}'".format(name)); provider.InitializeProvider(request.As<IRequest>()); request.Debug("Provider '{0}' Initialized".format(name)); lock (_packageProviders) { if (_packageProviders.ContainsKey(name)) { if (version > _packageProviders[name].Version) { // remove the old provider first. // todo: this won't remove the plugin domain and unload the code yet // we'll have to do that later. _packageProviders.Remove(name); } else { return null; } } } request.Debug("Using Package Provider {0}".format(name)); var packageProvider = new PackageProvider(provider) { Version = version, IsLoaded = true }; packageProvider.Initialize(request); // addOrSet locks the collection anyway. _packageProviders.AddOrSet(name, packageProvider); return packageProvider; } catch (Exception e) { request.Debug("Provider '{0}' Failed".format(name)); e.Dump(); } return null; }
private static IPersistenceObject ImportElement(IZetboxContext ctx, Dictionary <Guid, IPersistenceObject> objects, IPackageProvider s) { Guid exportGuid = s.Reader.GetAttribute("ExportGuid").TryParseGuidValue(); if (exportGuid != Guid.Empty) { string ifTypeName = string.Format("{0}.{1}", s.Reader.NamespaceURI, s.Reader.LocalName); ifTypeName = MigrateTypeNameMapping(ifTypeName); InterfaceType ifType = ctx.GetInterfaceType(ifTypeName); if (ifType.Type == null) { Log.WarnOnce(string.Format("Type {0} not found", ifTypeName)); return(null); } IPersistenceObject obj = FindObject(ctx, objects, exportGuid, ifType); using (var children = s.Reader.ReadSubtree()) { while (children.Read()) { if (children.NodeType == XmlNodeType.Element) { ((IExportableInternal)obj).MergeImport(s.Reader); } } } if (obj is Blob && s.SupportsBlobs) { var blob = (Blob)obj; using (var stream = s.GetBlob(blob.ExportGuid)) { blob.StoragePath = ctx.Internals().StoreBlobStream(stream, blob.ExportGuid, blob.CreatedOn, blob.OriginalName); } } return(obj); } else { return(null); } }
private static IPersistenceObject ImportElement(IZetboxContext ctx, Dictionary<Guid, IPersistenceObject> objects, IPackageProvider s) { Guid exportGuid = s.Reader.GetAttribute("ExportGuid").TryParseGuidValue(); if (exportGuid != Guid.Empty) { string ifTypeName = string.Format("{0}.{1}", s.Reader.NamespaceURI, s.Reader.LocalName); ifTypeName = MigrateTypeNameMapping(ifTypeName); InterfaceType ifType = ctx.GetInterfaceType(ifTypeName); if (ifType.Type == null) { Log.WarnOnce(string.Format("Type {0} not found", ifTypeName)); return null; } IPersistenceObject obj = FindObject(ctx, objects, exportGuid, ifType); using (var children = s.Reader.ReadSubtree()) { while (children.Read()) { if (children.NodeType == XmlNodeType.Element) { ((IExportableInternal)obj).MergeImport(s.Reader); } } } if (obj is Blob && s.SupportsBlobs) { var blob = (Blob)obj; using (var stream = s.GetBlob(blob.ExportGuid)) { blob.StoragePath = ctx.Internals().StoreBlobStream(stream, blob.ExportGuid, blob.CreatedOn, blob.OriginalName); } } return obj; } else { return null; } }
/// <summary> /// Register the package provider /// </summary> /// <param name="provider">Package provider object</param> /// <param name="asmVersion">assembly version info</param> /// <param name="request"></param> /// <param name="shouldRefreshCache">should refresh the internal provider list</param> /// <returns></returns> private PackageProvider RegisterPackageProvider(IPackageProvider provider, FourPartVersion asmVersion, IHostApi request, bool shouldRefreshCache) { string name = null; try { if (provider == null) { return null; } FourPartVersion ver = provider.GetProviderVersion(); var version = ver == 0 ? asmVersion : ver; name = provider.GetPackageProviderName(); if (string.IsNullOrWhiteSpace(name)) { return null; } // Initialize the provider before locking the collection // that way we're not blocking others on non-deterministic actions. request.Debug("Initializing provider '{0}'".format(name)); provider.InitializeProvider(request.As<IRequest>()); request.Debug("Provider '{0}' Initialized".format(name)); lock (_packageProviders) { //Check if the provider is loaded already. if (_packageProviders.ContainsKey(name)) { //if no -force, do nothing if (!shouldRefreshCache) { request.Verbose(string.Format(CultureInfo.CurrentCulture, Resources.Messages.SkipPreviousProcessedProvider, name)); //add the provider to the list var pkgprovider = new PackageProvider(provider) { Version = version, IsLoaded = true }; AddToProviderCacheTable(name, pkgprovider); return pkgprovider; } else { //looks like -force is used, we need to remove the old provider first. // this won't remove the plugin domain and unload the code yet _packageProviders.Remove(name); } } } request.Debug("Using Package Provider {0}".format(name)); var packageProvider = new PackageProvider(provider) { Version = version }; //initialize the package provider packageProvider.Initialize(request); // addOrSet locks the collection anyway. _packageProviders.AddOrSet(name, packageProvider); packageProvider.IsLoaded = true; request.Debug("The provider '{0}' is imported".format(name)); //add the provider to the list AddToProviderCacheTable(name, packageProvider); return packageProvider; } catch (Exception e) { request.Debug("Provider '{0}' Failed to import".format(name)); e.Dump(); } return null; }
private static IEnumerable<string> LoadModuleNames(IPackageProvider s) { IList<string> namespaces = new List<string>(); XPathDocument doc = new XPathDocument(s.Reader); XmlNamespaceManager nsmgr = new XmlNamespaceManager(s.Reader.NameTable); nsmgr.AddNamespace("ZetboxBase", "Zetbox.App.Base"); XPathNavigator nav = doc.CreateNavigator(); XPathNodeIterator it = nav.Select("//ZetboxBase:Module/ZetboxBase:Name", nsmgr); while (it.MoveNext()) { namespaces.Add(it.Current.Value); } return namespaces; }
public Replicator(IPackageProvider sourceProvider, IPackageProvider destinationProvider) { _sourceProvider = sourceProvider; _destinationProvider = destinationProvider; }
public Replicator(IPackageProvider sourceProvider, IPackageProvider destinationProvider, bool allowDeleteFromDestination) { _sourceProvider = sourceProvider; _destinationProvider = destinationProvider; _allowDeleteFromDestination = allowDeleteFromDestination; }
public ClassifyPackages(IPackageProvider packageProvider) { this.packageProvider = packageProvider; }