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();
        }
Esempio n. 6
0
 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();
     }
 }
Esempio n. 7
0
 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();
        }
Esempio n. 10
0
 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);
 }
Esempio n. 11
0
        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);
        }
Esempio n. 12
0
        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();
        }
Esempio n. 13
0
        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");
            }
        }
Esempio n. 14
0
        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));
        }
Esempio n. 15
0
        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);
        }
Esempio n. 16
0
 public ReleaseService(IMilestoneProvider milestoneProvider, IIssueProvider issueProvider, IPackageProvider packageProvider)
 {
     _milestoneProvider = milestoneProvider;
     _issueProvider     = issueProvider;
     _packageProvider   = packageProvider;
 }
Esempio n. 17
0
        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;
        }
Esempio n. 18
0
        /// <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));
 }
Esempio n. 20
0
        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();
        }
Esempio n. 21
0
        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));
        }
Esempio n. 22
0
 public ReleaseService(IMilestoneProvider milestoneProvider, IIssueProvider issueProvider, IPackageProvider packageProvider)
 {
     _milestoneProvider = milestoneProvider;
     _issueProvider = issueProvider;
     _packageProvider = packageProvider;
 }
Esempio n. 23
0
        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");
            }
        }
Esempio n. 24
0
 public static IComparer <ISearchItem> For(string searchTerm, IPackageProvider provider)
 {
     return(new PackageSorter(searchTerm));
 }
Esempio n. 25
0
 public Manager(IPackageProvider provider)
 {
     Provider = provider;
 }
Esempio n. 26
0
        /// <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");
            }
        }
Esempio n. 27
0
        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;
        }
Esempio n. 29
0
        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);
            }
        }
Esempio n. 30
0
        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;
        }
Esempio n. 32
0
        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;
        }
Esempio n. 33
0
 public Replicator(IPackageProvider sourceProvider, IPackageProvider destinationProvider)
 {
     _sourceProvider      = sourceProvider;
     _destinationProvider = destinationProvider;
 }
Esempio n. 34
0
 public Replicator(IPackageProvider sourceProvider, IPackageProvider destinationProvider, bool allowDeleteFromDestination)
 {
     _sourceProvider             = sourceProvider;
     _destinationProvider        = destinationProvider;
     _allowDeleteFromDestination = allowDeleteFromDestination;
 }
Esempio n. 35
0
 public Manager(IPackageProvider provider)
 {
     Provider = provider;
 }
Esempio n. 36
0
 public ClassifyPackages(IPackageProvider packageProvider)
 {
     this.packageProvider = packageProvider;
 }