CRM 2011 Online Plugin Uploader to support CI - continuous-integration

I'm involved in developing a sandboxed Microsoft Dynamics CRM 2011 Online plugin and have a set of tests that I can drive from a xUnit front end on my local machine given that I right-click the Package and select the Deploy option (and resort to using the plugin loader sample when that doesn't work).
I'd like to be able to automate the running of my tests on my CI rig, where I'll need it to upload a fresh binary as part of each run.
We've looked at http://pluginregcrm2011.codeplex.com/ but it has bugs that prevent it working for Online and in short looks like it's no longer being maintained and I'm not keen to take ownership of what should be a fundamental tool that a platform/ecosystem should just have.
Is anyone using that tool or another plugin uploader non-interactively? Am I missing something?

I know I'm late with my answer and I`m pretty sure that you already have found a solution which is working for you.
However I felt the same pain and I have hacked a small application which could be used to simply update the plugin assembly, without doing any configuration work.
PluginAssemblyLoader -f "C:\MyPlugin.dll" -c "Url=http://crmserver/org;"
Please see http://msdyncrm-contrib.github.io/PluginAssemblyLoader

There isn't an easy OOB experience with this but the CRM 2011 Developer Toolkit just uses a set of MSBuild targets that you can call yourself. It's just MSBuild, so you could hook it into your CI build if required. If you install or just extract the Developer Toolkit MSI in the SDK you'll find the following two files in there...
Microsoft.CrmdeveloperTools.CrmClient.dll
Microsoft.CrmdeveloperTools.CrmClient.targets
As an aside it would be nice if MS would open source this as the current implementation uses predominantly sealed and internal classes within the custom tasks.

Related

HL7 FHIR .NET Models - include profiles created using Forge (DSTU 2)

I have been working with the HL7 FHIR .NET API reference implementation - utilizing the existing resource models embedded in the library. Now, I am trying to use the Forge tool to modify the resources (contraints/extensions) to suit my requirements.
I noticed that the HL7 publishing mechanism does not generate C# models from DSTU 2 onwards and was wondering - what is the best way of converting profiles created using Forge into C# resource classes such that they may be included into the HL7.Fhir.Model assembly that is part of the reference implementation.
The generation of the models not being part of the official build is correct.
This has now moved to https://github.com/ewoutkramer/fhir-net-api where the rest of the API is maintained more easily.
It is done using T4 templates on the output from the official builds.
There is a simple process for updating the models with the new versions of the spec, and we keep it fresh as people need it, and for each connectathon we publish a new build in NuGet and have a branch of the code in GitHub.
(Its a powershell script that downloads all the latest build outputs and puts them in the appropriate folders, then you need to run the t4 templates in Visual Studio)
Such as this one for the May Connectathon in Montreal
https://github.com/ewoutkramer/fhir-net-api/tree/ft-connectathon-may2016
This is able to be done yourself with a little assistance.
As for generating code for a profile, we haven't done that as yet, but will theoretically be possible.
Don't know that I'd advise this at the moment while the profiles are in so much development and change.

XPage Osgi plug in development

background
I have designed many tools in the past year or so that is designed to help me program for XPages. These tools include primarily helper java classes, extended logging (making use of OpenLogger and my own stuff), and a few other things that I personally feel I cannot work without. It has been discussed with my employer, and we feel that it might be a good idea to start publishing these items to openNTF. Since these tools are made up of about 3 .nsfs, all designed to use the same java code, key javascript classes, css, and even a custom control or two, I would like to consolidate key items into a plug-in that can be installed at the server and client level. I want to do this consolidation before I even think about publishing any of the work I've done so far. It would just be far too much work to maintain, not just for me, but for potential users. I have not really found any information on how to do such a thing in google searches. I also have to make sure that I am able to make use of the ExtLib libraries, openNTF Domino API, and the Notes API.
my questions
How does one best go about designing such plug-ins? Must a designer
use eclipse, or is this it possible to do this directly in the Notes
Designer?
How does a designer best go about keeping a server and client up to date while designing and updating the plug-in code? Is this why GitHub is often used?
Where is the best place to get material to get started in this direction? I sort of feel lost in the woods, knowing I need to head north, but not having a compass for that first step.
Thank you very much for your input.
In my experience, I found that diving into plug-in development is a huge PITA until you get used to it, but it's definitely worth it overall.
As for whether you can use Designer for plugin development: yes, but you will likely eventually want to not do so. I started out by using Designer for this sort of thing for a while, presumably with the same sentiment as you: why bother installing another instance of Eclipse when I'm already sitting in one all day? However, between Designer's age (it's roughly equivalent to, I think, Eclipse 3.4), oddities when it comes to working sets between the "Applications" and "Project Explorer" views, and, in my case, my desire to use a Mac app, I ended up switching.
There are two major starting points: the XSP Starter Kit (http://www.openntf.org/internal/home.nsf/project.xsp?name=XSP%20Starter%20Kit) and Niklas Heidloff's video on setting up Eclipse for XPages development (http://www.openntf.org/main.nsf/blog.xsp?permaLink=NHEF-8RVB5H). The latter mentions the XPages SDK (http://www.openntf.org/internal/home.nsf/project.xsp?name=XPages%20SDK%20for%20Eclipse%20RCP), which is also useful. In my setup, I found the video largely useful, but some aspects either difficult to find (IBM's downloads are shifting sands) or optional (debugging, which will depend on whether or not you're using Eclipse on Windows).
Those resources should generally get you set up. The main thing to worry about when setting up your Eclipse environment will be making sure your Plug-In Execution Environment is properly done. If you're following the SDK setup instructions, that SHOULD get you where you need to be.
The next thing to know about is the way plugins are structured. Each plugin you want to install in Designer or Domino will also be paired with a feature project (a feature can house several plugins), and potentially an update site - the last one is optional if you just want to import the features into an Update Site NSF. That's how I often do my normal plugin development: export the paired feature to a directory and then import the feature into the server's Update Site NSF and then install in Designer from there using Application -> Install. You can also set things up so that you deploy into the server's plugin/feature directories instead of taking the step of installing into an update site if you'd prefer. GitHub doesn't really come into play for this aspect - it's more about sharing/collaborating with your code and also having a remote storage location for your git repositories (which I highly advise).
And as for the "lost in the woods" feeling: yep, you'll have that for a good while. There are lots of moving parts and esoteric concepts to get a hold of all at once. If you mostly follow the above links and then start with some basics from the XSP Starter Kit (which is itself a plugin project that you can pair with a feature) - say, printing text in the Activator class and making an implicit global variable just to make sure it works - that should help get your feet wet.
It's best done in Eclipse. You can debug your code running on the server from there, as well as run it directly from there. The editors are also more up-to-date. You want:
Eclipse for RCP and RAP developers
XPages SDK for Eclipse RCP (from OpenNTF)
XPages Debug Plugin (from OpenNTF - basically allows you to load the plugins to the Domino server dynamically, rather than exporting to an Update Site all the time)
XSP Starter Kit on OpenNTF is a good starting point for a plugin. There are various references to the library id, which has to be unique for your plugin. Basically, references to org.openntf.xsp.starter need changing to whatever you want to call your plugin. You're also best advised to remove what you don't need. I tend to work in a copy of the Starter, remove stuff, build and if there are errors with required classes (Activator.java obviously will be required and some others), then paste them back in from the Starter.
XPages OpenLog Logger is a good cross-reference, that was built from XPages Starter Kit. It's pretty much stripped down and you'll be able to see what had to be changed. A lot of the elements of the XSP Starter Kit correspond to Java classes you'll probably be familiar with from your XPages Java development.
GitHub etc tend to be used as source control, which is useful for working out what's changed from time to time.

Google-like online installer and updater using NSIS

I would like create Google-like online installer and updater using NSIS.
What plugins should I use?
And maybe somebody can recommend any existing solutions or examples?
You can use the Inetc plug-in to download files, it can also perform HEAD requests if you want to perform the version check on the server. Everything else really depends on your specific setup but creating multi-stage online installers/updaters is not easy; see this answer for a list of things you need to think about/figure out...

Is there documentation for Team Build 2010 Activites?

As most of you know TFS Team Build 2010 is Windows Workflow based. It comes with a handful of custom Activities out of the box. Is there any documentation available for these activities?
For example Microsoft.TeamFoundation.Build.Workflow.Activities.GetBuildAgent is one of the activities that has basically only one property called Result which I'm assuming takes a variable name that receives the agent name. But how does it determine which agent to select? which variables/arguments does it use to receive input/output? I'm sure if I ask around I can figure out how this specific Activity works, but what about the other 50 activities? I have been unsuccessful in finding documentation on these Microsoft provided activities to date.
There is currently no documentation on these activities. I have seen some previews on a book on Team Build that will arrive soon (keep an eye on this blog) and the VS ALM rangers who will bring their guidance on codeplex during the beginning of CY11.
See Team Foundation Build Activities on MSDN for documentation on all the included build activities.
The GetBuildAgent activity can only be used within an AgentScope activity. It returns the IBuildAgent object of the build agent that it is running on.
William's book on Inside the Microsoft Build Engine: Using MSBuild and Team Foundation Build will also cover these build activities in more detail.
Beyond the built-in activities, I immediately found a need to implement custom activities. Some Custom Activity examples are:
Checking in/out a file in the build process
Updating Version properties (to support ClickOnce deployment)
Updating deployment folder html file to support Version updates
I found an article by Jakob Ehn very helpful in navigating through this process.
Ewald Hofman has a very thorough guide to help you get more out of customizing Team Build. It acts as a great reference.

Is it possible/advisable to register a MS CRM plugin WITHOUT using the registration tool provided by microsoft

Basically I am looking at doing remote deployment of custom plugin and workflow to an IFD MS CRM deployment. This means that the tool provided by Microsoft cannot be used.
Does anyone do this?
Is it advisable or not?
What resources are available?
I've done a lot of google-ing and reading and it seems like everyone is using the deployment tool.
Absolutely. There are a series of entities that you need to set up to do this. If I'm not mistaken, the SDK includes the source for a plugin registration tool... you can look at that to see how it's done, and you'd just need to update it to work with IFD.

Resources