When we are developing a client for googleapps using the admin sdk we started using the
google-api-services-admin-directory_v1-rev35-1.18.0-rc.jar and its dependency jars like google-api-client-1.18.0-rc.jar,google-api-services-admin-directory_v1-rev35-1.18.0-rc.jar,httpclient-4.0.1.jar,etc.,
but now we can see that there is a latest admin directory jar one on the googleapps download link https://developers.google.com/admin-sdk/directory/
I also tried getting the jar from https://code.google.com/p/google-api-java-client/ and downloaded google-api-java-client-featured.zip and couldn't find the admin directory jar.
Are the latest ones are backward compatible?
if we are replacing the admin jar to latest in our client everytime then we also need to take use of all its dependency jars as latest??
Is there any location to get the particular versions of admin directory jars?
Thanks
New versions of the client libraries are usually backwards compatible, assuming the API version (v1) is the same. You should also update the dependencies, assuming they have changed. Unless there is a new feature in the Admin SDK or client library you wish to use, it's probably best to stick with your current setup.
Related
Intel-XDK uses third party Cordova plugins only at build time. Is there a way to implement a third party plugin using Cordova CLI in my local Intel-XDK environment? In other words, can I access the internal Intel-XDK Cordova server in some way?
EDIT (7 Aug 2015): With our EA release local plugins no longer need to be placed inside your source directory (typically www inside your project directory). The Intel XDK EA release manages plugins in a way that is consistent with Cordova CLI. This CLI-compatible plugin management scheme will become part of the mainstream release in the very near future.
Original Post:
You cannot directly access the XDK build server's CLI. However, you can reference a plugin locally (that is, you can submit a plugin that is located on your local disk drive). Unfortunately, you have to locate the plugin inside your www "source" directory, I hope to see that changed in a future revision of the product; this is not where a local CLI would place the plugin...
Placing the plugin into your www directory, and then referencing it using the "import local plugin" on the Projects tab (find the "Plugins and Permission" and then the "Third-Party Plugins" section) allows you to customize that plugin before it gets submitted to the build service. For example, assume you need to change the contennts of the plugin.xml file or change a plist or manifest file that is part of the plugin, you could do that in the local copy and those changes would be part of this "local third-party plugin" that is submitted to the build server with your app when the build server runs.
In essence, the build server does a plugin add on a copy of the plugin that got submitted along with your project when you use the "import local plugin" feature. A copy of your local plugin gets sent with your app source to the build server and, before the build happens, the build server's CLI performs a plugin add with that plugin, so the changes you implemented locally will be included in the plugin when it is built by the build server. Make sense? :)
There are also some useful things you can do with the intelxdk.config.additions.xml file regarding plugins. See these doc pages for some details:
https://software.intel.com/en-us/html5/xdkdocs#517453
https://software.intel.com/en-us/html5/articles/using-the-cordova-for-android-ios-etc-build-option
The checkmarked plugins on the Project tab refer only to what are called "core" plugins and "featured" plugins. They are really just a convenience for selecting plugins. The "core" plugins also include some simulation inside the Emulate, Test and Debug tabs (as well as in App Preview). Other than that, they are standard Cordova plugins that are also "plugin added" by the build server if they have been checked. Take a look at the various intelxdk.config.*.xml files that are automatically generated when you perform a build to see how the checkmarks (and third-party plugins) are communicated to the build server.
As you must known, the first time you run SBT, it starts to download his dependencies:
>sbt sbt-version
Getting org.scala-sbt sbt 0.12.4
downloading repo.typesafe.com/typesafe/ivy-releases/org.scala-sbt/main/0.12.4/jars/main.jar ...
The problem is that I'm living in Africa and the ISP is not very good: for some unknown reason, they are some domains from which I can not download any file. For example, if I enter to the site of WAMP and try to download the installer, the download begins but it never ends. Normally I fix this issue by using a proxy (such as HideMyAss or ZendProxy), which servers as an intermediate between the site and the ISP, allowing me of download the file.
typesafe.com seems to be one of the not-work-for-download-in-africa domains, as consequence, SBT can not download his dependencies.
The question is, there is a way of download manually the dependencies? (I have downloaded them using a proxy, but I do not known in which folder put them in order to avoid SBT to try to download them)?
Create a directory in the root of your sbt project called lib and put the jars there.
I recently started learning more about JBoss Application sever. After installation I was looking inside all directories created by JBoss installation. (I'm using JBoss AS version - jboss-5.0.1.GA)
I referred documentation available at this link
It says 'client' directory contains Jar files needed by remote clients.
client: The JARs that are required for clients that run outside of JBoss are located in the client directory.
When I looked inside 'client' directory after installation, it contains 90 jar files overall. Does that mean If I create a remote ejb client I would need to include all the 90 jars in my remote application classpath?
With JBoss AS 5.x things got complicated.
Placing all of the client jar files on classpath will certainly work.
In JBoss 4.x there was an option to use jbossall-client.jar which integrated other numerous client libs into single file. If you'll look into same named jar in JBoss 5.x you'll find out that it's reduced to manifest referencing other jars. Placing this single jar in your classpath will work as long as all of the jars referenced by manifest are present in the same directory.
If accessing remote EJB is all you need then only a subset of jars is required, unfortunatelly it's hard to tell which ones is it.
Following this coderanch link (I've found it here on SO) you'll find such subset prepared for JBoss 5.1.0.GA.
Be warned though, list of jars published on coderanch has abbreviated names, some misquotations and at least two jars are not present in server version 5.0.1. If reducing number of dependencies is your priority, use this list wisely and enhance/extend it by trials and errors.
Somehow I cannot find and answer to this in griffon documentation nor googling...
I have created a griffon plugin. It gets packaged as usual with:
griffon package-plugin
Then I can install it locally in my application specifying path to the zip file resulting from packaging:
griffon install-plugin /path-to-plugin/plugin-name.zip
I can even upload it to a remote url and install it from there:
griffon install-plugin address-of-my-site/plugin-name.zip
How can I make installing of this plugin from my url an automatic step during building/running of a griffon application, which uses it?
I work on the application with another developer and don't want to force him to install the plugin manually every time when something changes. It should be downloaded from my site automatically. But I don't want to release the plugin to the griffon official repository either - it's pretty experimental stuff still.
There is a line in application.properties, which tells griffon, that the plugin is needed:
plugins.plugin-name=0.3
But it cannot be installed from griffon central repository, like all the other plugins, because it's not there, obviously.
I looked into documentation of "griffon.project.dependency.resolution" section in BuildConfig.groovy, but I can't find anything useful for my purposes there.
Do I miss something?
The answer you seek is found in sections 12.1 and 12.2 of the guide. The first section describes an example of a plugin being pushed to a local repository. The second section describes the types of repositories supported by Griffon.
Plugins that are available from a plugin repository that can be queried by the build system (i.e, the repository is configured) are instantly available to be installed using the short notation you want.
There's always a local repository configured by Griffon: griffon-local. Pushing releases to it will make them instantly available to install-plugin, list-plugins, plugin-info, etc.
With P2 Eclipse has the option of using bundle pooling to reuse common bundle between applications, but what possibilities do I have with it?
The example on the page lists two applications that reuse a set of plugins in the users home directory, but can the directory of plugins be set to anything? What limitations are there?
Like:
Application1/
configuration/
config.ini
... other configuration files for Application1...
Application1.exe
Application1.ini
Application2/
configuration/
config.ini
... other configuration files for Application2...
Application2.exe
Application2.ini
...
common_bundle_pool_for_all_users/
.p2/
org/eclipse.equinox.p2.core
org/eclipse.equinox.p2.director
org/eclipse.equinox.p2.engine
org/eclipse.equinox.p2.touchpoint.eclipse
and perhaps even
Documents and Settings
Username
.p2/
plugins/ <-- unique plugins only for this user
Bundle pooling is a good concept, but it's not flexible as expected.
For example, you must install the eclipse based application with bundle pooling option if you want to multiple applications share the bundles. There is no easy way to convert/switch an existing packaged eclipse(like the zips downloaded from eclipse.org) to use bundle pooling.
It means you must use an installer application(equinox p2 team has an example application named p2.installer) to install your eclipse based application with using bundle pooling. It's the first case listed by you.
The possible scenario listed by you handles with the share install case. It always uses that structure when your eclipse instance is read-only. Users don't have permission to change the configuration of eclipse itself, so install the third party plug-ins into a user folder. If you have multiple eclipse packages(such as plug-in development, cdt, wtp and so on) installed in Program files on windows 7 with UAC enable, those eclipse can share the bundles installed in your home folder.