Skip navigation
All Places > Blackboard Developer Community > Blackboard Learn Developers > Blog

For self-hosted Unix installations see How much longer will Red Hat 5 be supported?

mkauffman

Blackboard Learn Mobile

Posted by mkauffman Mar 7, 2017

We've had several developers ask about registering Mobile Web Services. The first step is to read this article on how to Configure and Register Blackboard Mobile Web Services. After reading, the common roadblock is filling out the registration form, hitting submit, and then the page reloads with the default values, like nothing happened. What's wrong? The answer is that the server must be on the public internet and have a valid SSL certificate installed. This has to be because the Mobile service is a cloud service that talks back to your Learn instance.

This just in. bb-manifest.xml files will not upload to SaaS when the XML does not meet the standard: Extensible Markup Language (XML) 1.0 (Second Edition) .As we don't check this in Self and Managed-hosted systems, you may have had URLs in your bb-manifest.xml file using the following format:

<url value="itemanalysis/showItemAnalysis?action=display&;course_id=@X@course.pk_string@X@" />

 

These should be written as follows because the & character in XML must be encoded:

<url value="itemanalysis/showItemAnalysis?action=display&amp;course_id=@X@course.pk_string@X@" />

I’m writing this to let you know that we’ve run into a new issue with the SAML B2 on a few Learn systems that then causes problems for other B2s that make outbound connections from Learn. We're still working to determine the Learn & SAML B2 versions affected. To date we've seen this on a Q2 2016 system with the 3000.1.0 version of SAML, and a SaaS 3100.9 system running version 3100.9 of SAML.

 

If the lines shown below are found in the stdout-stderr logs, please open a ticket using your Behind the Blackboard account, include the logs, the Learn version, and the version of the SAML authorization B2. Reference LRN-121348 early in the case description so that support is aware that this is a known issue. While you're on Behind the Blackboard, be sure to subscribe to the Learn support bulletins (Top menu, My Account, MY SUBSCRIPTiONS).

 

Here are the lines your will see in the stdout-stderr files on an affected system

org.springframework.security.saml.metadata.MetadataManager.setKeyManager(org.springframework.security.saml.key.KeyManager); nested exception is org.springframework.beans.factory.BeanCreationException: Error creating bean with name 'keyManager' defined in ServletContext resource [/WEB-INF/config/saml/securityContext.xml]: Invocation of init method failed; nested exception is java.lang.RuntimeException: Unable to load aliases from keyStore

 

There may be other exceptions that the SAML B2 throws that will cause the issue. The above is one example. The main point is that for this issue to occur the SAML B2 must throw an exception and stop running.

 

... then later in the log file ...

INFO   | jvm 2    | < information about your B2 wil be here>  threw exception [Handler dispatch failed; nested exception is java.lang.NoClassDefFoundError: org/apache/commons/httpclient/params/HttpConnectionParams] with root cause

INFO   | jvm 2    | 2017/02/15 18:55:54 | java.lang.NoClassDefFoundError: org/apache/commons/httpclient/params/HttpConnectionParams

INFO   | jvm 2    | 2017/02/15 18:55:54 |     at org.opensaml.ws.soap.client.http.TLSProtocolSocketFactory.createSocket(TLSProtocolSocketFactory.java:182)

INFO   | jvm 2    | 2017/02/15 18:55:54 |     at org.apache.commons.httpclient.HttpConnection.open(HttpConnection.java:707)

 

The main point of the above is that we can see that your B2 threw an error because the system was incorrectly handing it the SAML socket factory.

This came up in a recent case with a Partner. Their B2 is exposing a new endpoint in Learn for their external server make calls to. (Example: webapps/abc-myb2-VeryLogSaaSDBschemaName/MyEndpoint) Everything worked fine on their test system. But when they deployed to a recent 3100 build, the calls the external server made were not getting through to Learn. Why? Because newer builds of Learn have the 'Security Management: Cookie Disclosure' B2 installed and active. This B2 forces you to accept Blackboard's Cookie Disclosure Agreement before logging in. It also blocks incoming calls to endpoints like that described. There is no impact on our REST APIs. I've not checked our Web Service SOAP APIs yet... In any case, how do you work around it? Put a cookie in your cookie jar. Just set a cookie with name="COOKIE_CONSENT_ACCEPTED" and path="/" in your cookie jar, so it's sent with every request. Hope this helps the next developer who runs into this one!

The upcoming release of Blackboard Learn 9.1 Q2 2016 will be upgraded to run on the latest version of Java from Oracle, Java 8.  The primary impact of this change will be to Building Blocks.  Nearly all Building Blocks are expected to continue to work without any changes as, generally, most Java 7 code is compatible with Java 8 code.  There may be instances, however, where a Building Block will need to be updated.  You may need to update a Building Block if:

  • During compilation, the values for compatibility, source, and target were not specified in a way compatible with Java 8.
  • A Building Block uses complex Java 7 libraries.
  • A Building Block that relies on the Spring Framework must be updated to use Spring 4.2.0+.

 

The following resources are available to assist you in the evaluation and updating of your Building Blocks for Java 8:

 

We strongly encourage anyone who has a Building Block to test it against Java 8 before installing the Learn 9.1 Q2 2016 release onto a production environment. 

 

Preparing Building Blocks for Release 3000.1.0 in SaaS and the Java 8 Update

 

The information above is also applicable to SaaS Plus/Advantage deployments where clients can add their own Building Blocks. In addition to the above resources, developers should be aware of additional possible updates that may be required in these deployments:

Greetings Developer Community,

 

It’s been a few months since the Developer Community moved to community.blackboard.com. We hope you’re enjoying the collaborative features that this site offers. Between discussions, blogs, ideas, and questions, there are a lot of content types to help you learn from other developers and post your own successes for fellow community members.

 

Now that we’re properly established on the Community site, we are entering the next phase of migration from edugarage.com: moving all developer documentation to this site. Soon you will be able to find all Blackboard Learn developer resources here. This is exciting news, but we also want to give you advance warning: we’re retiring EduGarage.com on Dec 31, 2015, after the migration is complete.

 

We’ll have a few redirects in place from the most common links that people visit, so those links will take you directly to the corresponding section on this site. Jive will continue to serve the community well when it comes to finding, using, and discussing developer information. For a long time, the EduGarage forums were the most active part of the site and we hope that trend continues here. We are still identifying if and how to archive the data in the edugarage forums in how to make them searchable if we do, but all further communication will take place here in the discussions section. We will redirect forums.edugarage.com to the new site, as well.

 

As we move the content in the next few weeks, we’re also updating it for accuracy and usefulness. Please bear with us while some of the content is under construction or if some information is initially moved and then removed (i.e. Powerlinks documentation). We will be tagging everything that is migrated as 'migrated from edugarage' so you know where it came from. If you notice a broken hyperlink or something looks a bit off, let an admin know by leaving a comment or sending a message and we’ll take care of it as soon as possible.

 

If you have any questions, please let us know! We don’t want this to be a surprise, so we’re putting a banner on EduGarage to announce the migration there as well. Please share the news with your networks as appropriate.

 

Thank you for your patience and understanding. I look forward to continuing to build the Developer Community in collaboration with all of you here in Jive!

This is my cheatsheet for the Bb DEV Virtual Machine (managed by Vagrant).

 

Vagrant command line

Where to run the commands on Windows: Run > cmd > C:\Users\[my user]\[the_folder_with_the_april_release_box + vagrant_file]> <run your command here>

-> vagrant up

-> vagrant halt

-> vagrant reload (after applying changes to the Vagrantfile)

-> vagrant box list
-> vagrant plugin install vagrant-hostupdater
-> vagrant ssh

-> vagrant destroy

-> vagrant box remove

 

SSH connection to the back-end

Note that on a Windows host machine you may experience issues, hence for the SSH connection use instead putty or MobaXterm or RemoteNG:

-> Host: 127.0.0.1

-> Username: vagrant
->  Port: 2222 (do not use 22) (Blackboard box OR e.g: lucid32 Ubuntu box)

Port: 2200 (in case you assigned the 2222 to other box, use the port 2200 for the Blackboard box)

-> vagrant@127.0.0.1's password: vagrant

 

SSL certs

SSL cert (it has a Private key, but it is not a CA cert): C:/Users/[my user]/.vagrant.d/insecure_private_key

 

Manage the Learn Bb VM: edit bb-config, use the command line admin tools

-> sudo /usr/local/blackboard/tools/admin/ServiceController.sh services.start

-> sudo vi /usr/local/blackboard/config/bb-config.properties (save & exit: ESC ZZ)

-> sudo /usr/local/blackboard/tools/admin/ServiceController.sh services.start

 

GUI access to the Learn Bb VM

-> April 2014 and above: https://localhost:9877/ (web browser) u: administrator - p: password

 

Example of a "Vagrantfile"

 

Vagrant.configure("2") do |config|

 

  config.vm.provider :virtualbox do |vb|
    vb.customize ["modifyvm", :id, "--memory", "4096"]
  end

 

  config.vm.box = 'bb-learn-9.1.201404.160205'
  config.vm.box_url = './bb-learn-9.1.201404.160205.box'
  config.vm.network :forwarded_port, guest: 8080, host: 9876
  config.vm.network :forwarded_port, guest: 8443, host: 9877
  config.vm.network :forwarded_port, guest: 2222, host: 9878

end

There are a few template variables you can use to render platform, user or course information dynamically in contents, LTI custom params and other places. This is quite powerful, but it can be better...

 

With a custom template variable Building Block you can define new template variables to render virtually anything in your contents, from your Blackboard Learn instance using the API or taking data from the data base, or from an external system using web services, external data bases, etc... You can even render not only strings, but even html snippets to add dynamically, for instance, search forms from your Library service.

 

This is made by creating an extension Building Block, for what you have to include :

 

 <webapp-type value="javaext" />

 

in your bb-manifest.xml file.

 

You also have to declare in the same file your custom context handler, defining your extension with:

 

 <extension-defs>
   <definition namespace="blackboard.platform">
    <extension id="customContextHandler"
      point="blackboard.platform.contextHandler"
      class="es.elearningmedia.services.CustomContextHandler"
      singleton="false" />
  </definition>
 </extension-defs>

 

Then, in your source code, you create your custom context handler:

 

package es.elearningmedia.services;

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

import javax.servlet.http.HttpServletRequest;

import blackboard.persist.BbPersistenceManager;
import blackboard.platform.context.Context;
import blackboard.platform.context.ContextEntry;
import blackboard.platform.context.ContextHandler;
import blackboard.platform.security.EntitlementList;
import blackboard.platform.security.Entitlements;
import blackboard.platform.security.SecurityContext;
import blackboard.util.resolver.Resolver;

//Extends ContextHandler class to include our variable resolver
public class CustomContextHandler implements ContextHandler {

  public CustomContextHandler() {
  }

  public Entitlements getEffectiveEntitlements(Context ctx) {
       return new EntitlementList();
  }

  public Entitlements getRestrictedEntitlements(Context ctx) {
       return null;
  }

  public List<SecurityContext> getSecurityContexts(Context unused) {
       return new ArrayList<SecurityContext>();
  }

  // Here is were we inyect our custom resolver
  public List<ContextEntry> resolveKeys(HttpServletRequest request,
  BbPersistenceManager unused) {
       CustomResolver resolver = new CustomResolver(request);
       Resolver.attachResolverToContext(resolver);
       return new LinkedList<ContextEntry>();
  }

}

 

And now implement the custom resolver who contains the logic to show what you want where you insert your template variable:

 

package es.elearningmedia.integracionbiblioteca.services;

import javax.servlet.http.HttpServletRequest;

import blackboard.platform.context.ContextManagerFactory;
import blackboard.util.resolver.ResolverComponent;

public class CustomResolver implements ResolverComponent {

  private static HttpServletRequest _request = null;

  public CustomResolver(HttpServletRequest request) {
       _request = request;
  }

  public String[] getKeys() {

       return (new String[] { "variable_key" }); // the first part of the
                                                    // template variable (@X@
                                                    // tag) - variable_key in
                                                    // @X@variable_key.show@X@
  }

  public String resolve(String method, String attributes[]) {
       String varout = null;

       if ("show".equalsIgnoreCase(method)) { // the second part of the @X@
                                                 // tag - show in
                                                 // @X@variable_key.show@X@
  
       try {

          ContextManagerFactory.getInstance().setContext(_request);
          String uriPrefix = Utils.getUriPrefix();
          // the code for inserting
          // the Unika search box
          varout = "Whatever you whant to show in your template variable <div></div><script></script>...";
  
          return varout;

       } catch (Exception e) {

       } finally {

          ContextManagerFactory.getInstance().releaseContext();

       }
  }

       return null;

}


}

 

Now typing @X@variable_key.show@X@ in your contents you will get the rendered html code you put in varout.

 

This technique has been very useful to me in different projects, so I hope this helps to somebody else.

Blackboard Developer Community Newsletter - Updates on Blackboard’s Developer Platform and Developer Program

 

 

For those who may not have been able to attend one of the recent DevCons or otherwise heard through the grapevine - there are substantial and positive changes happening with the Blackboard Developer Platform and Developer Program!

 

 

This is in part why it has been an exciting 6 months for Scott and me. We have traveled to hold DevCons in Liverpool, DC, and Adelaide. In doing so we have been able to meet developers and administrators directly to discuss what we and the company are envisioning as the new developer platform and program, and what we are personally doing to help achieve that vision. Simply we want to deliver to you the best possible developer experience and are working diligently with other Blackboard Staff to make this a reality.

 

 

As an example, Scott and I are traveling 18 days during the month of October through Singapore, Seoul, and Beijing. We will be taking this opportunity to evangelize the Developer Platform, conduct DevCons, and meet with Blackboard Staff and most importantly meet with our Customers.

 

 

On our return watch for an update on how our fellow developers on the Pacific Rim are using or interested in using the Blackboard dev platform to meet their integration requirements.

 

 

Also, over the coming months watch this space for quarterly newsletters and monthly blogs that will inform you of where we are in delivering exciting developer platform and program changes!

 

 

Until next time - Happy Coding!

 

Mark and Scott

 

-------------------

 

Mark O’Neil

Senior Product Manager, Developer Platform

 

and

 

Scott Hurrey

Senior Technical Writer, Developer Experience

scott.hurrey

And The Winner Is...

Posted by scott.hurrey Sep 29, 2015

Szymon Machajewski!

 

Of what, you ask? The name the new Blackboard API contest, as documented in this discussion.

 

Szymon suggested that we keep the naming convention simple and in keeping with marketplace trends, so hence forth, the impending Blackboard Rest APIs will be known as the Blackboard API, and the integrations you will build will be Blackboard Apps.

 

I will be contacting Szymon to work out his prize, but in the meantime, keep on your thinking caps, folks. Soon it will be time to name the overall integration platform, and we hope to hear from you with your ideas.

 

Check back here for more information.

 

Thanks!

-scott

kelley.macewen

Calling all bloggers!

Posted by kelley.macewen Sep 24, 2015

Hi everyone,

 

My name is Kelley and I’m a Content Designer at Blackboard. I’m on the team working to promote the community site, especially the developer community group. We think one way to promote collaboration and discussion on the site is to post thoughtful content regularly. And to make it feel like a true community site, we want to hear what administrators and technologists are working on at their institutions. These posts can help start discussions and develop new ideas among group members. This is where you come in!

 

Would any of you be interested in writing blog posts to publish in this group? We don’t have any requirements except that your post is relevant to the group’s shared interests. You can post as often as you want, and write a little or a lot.

 

This is completely voluntary, of course. But if you are interested, feel free to message me or Scott Hurrey with any questions.

 

Thanks for your time!

 

Best,

Kelley MacEwen

scott.hurrey

DevCon 2015: The Keynotes

Posted by scott.hurrey Jun 18, 2015

One of the highlights of DevCon is always the key note sessions. These sessions are always a great place to learn about the direction of the Blackboard Learn platform from Blackboard leaders, as well as external speakers that bring new insight and vision into topics of emerging or evolving importance to Developers and System Administrators.

 

DevCon 2015 continues this tradition in glorious fashion!

Opening Session

 

The opening session at this year's DevCon will feature Peter George, Senior Vice President, Product Development, Support And Cloud Services at Blackboard. Peter is the new head of Blackboard's Product Development group, and as such, is responsible for driving the innovation for the entirety of the Blackboard portfolio. This will be a chance for DevCon attendees to hear about the direction of Blackboard directly from the proverbial horse's mouth.

 

Peter's Keynote, entitled, "Working Together to Shape the Future of Learning," will introduce the foundation of Blackboard's New Learning Environment and focus on learner-centric design. The session will cover key concepts in this approach, such as the integration of the Blackboard suite of products from a disparate group of related products into a cohesive, unified experience. George will also discuss the new Blackboard Learn SaaS deployment model, and why it enables Blackboard to provide a greater innovation is a more scalable and stable way. He will also discuss the new Ultra experience, and why and how an institution should prepare for the transition, Blackboard's focus on the mobile, always-on experience, and leveraging analytics to make insightful decisions. Lastly -- but certainly not least -- Peter will emphasize the continued investment in the Learn Platform.

 

Attendees should leave this opening session with the high-level knowledge needed to understand where Blackboard is headed and to be prepared for the rest of the conference, and specifically, which break out sessions are must-see for them.

 

External Keynote

 

The DevCon team is excited to announce that Ryan Baker, Associate Professor of Cognitive Studies in Education from Columbia University has agreed to be the external keynote for DevCon 2015. Ryan is a leader in the use of data analysis to predict student outcomes. While this is a seemingly new trend to the marketplace, Baker and his research laboratory have been studying this for more than a decade.

 

In "Predicting Learner Outcomes with Learning Analytics," Ryan will talk about the work his team has done to predict a large range of outcomes, including course success, a Learner's preparedness for future learning opportunities, long-term educational attainment, and even participation in scientific communities of practice. Baker will discuss what to keep in mind when developing a product to capture the best data for analysis, as well as providing insight into best practices for developing data analytics.

 

Attendees will leave this session cognizant of the data their applications should be tracking and why, as well as how to approach the use of this data to make informed decisions around student outcomes.

 

Closing Session

 

Jon Kolko will close out this year's DevCon with his talk, "Well Designed: How to Use Empathy to Design Products People Love." Jon is Blackboard's Vice President of Design, and he brings to Blackboard his innovative approach to design; that design is a feeling that is evoked by human-application interaction that is above and beyond just a flashy screen or smooth workflow. Jon will use this keynote session to share that vision with DevCon.

 

This session will be less about the specificities of Blackboard Learn, and more about the philosophy behind good design. It is not only the visual appeal of a product, but also the process by which a product is conceived, utilizing empathy for the end users using a product and the goals they hope to achieve to anticipate problems and challenges and to identify solutions that will have a strong emotional appeal to the user, while still fitting in with product and market requirements. This is the philosophy of Blackboard's Design team, and the impetus for the usability and user experience improvements across the spectrum of the Blackboard suite of products that have been shown over the past year.

 

Attendees will leave this session with a new way to think about the overall design process, as well as new insight into the internal thought process behind Blackboard's product innovations.

 

Learn More about DevCon or Register now. Then stay tuned over the next few weeks for more information about the sessions, events, and networking opportunities you can look forward to at DevCon. We’ll see you in DC!

After a year off, Blackboard’s Developers Conference is back. Back in 2013, DevCon was very much focused on extending Blackboard Learn Release 9.1. We introduced a number of new tools, like the external Maven repository and the Developer Virtual Machine. Since that time, Blackboard announced a new release model, a new, cohesive user interface, and even began delivering on that new strategy.

 

 

Without a Developers Conference during this time, a lot of questions have arisen. DevCon 2015 in Washington, DC is the chance to get answers to those questions. The Architects and Product Managers that have been driving this innovation will be on-hand and on stage providing deep technical insight into the future direction of the Blackboard suite of product with a specific focus on Blackboard Learn SaaS and what it means for both Administrators and Developers.

 

 

While the agenda has not been posted yet, a number of sessions have been identified that will highlight these new and upcoming features and functionality. Administrators will find out what it means to move to SaaS, the future of Learning Analytics, and all about the Cloud Stack behind the SaaS delivery model of Blackboard Learn. Developers will get a sneak peek at the future of the integration framework, Angular and extension points, preparing custom Building Blocks for Learn Custom SaaS, and even a Round Table Q&A session with Blackboard Architects.

 

 

If information about the future of Blackboard Learn is of interest, DevCon 2015 should be required. There has been much in the way of opinion and conjecture about what is on the horizon, but DevCon will provide the facts Administrators and Developers need to move forward in the Blackboard ecosystem. Stay tuned for more information in the coming weeks about what to expect in Washington, DC July 20-21!